swad-core/swad_info.c

// swad_info.c: info about course

/*
    SWAD (Shared Workspace At a Distance),
    is a web platform developed at the University of Granada (Spain),
    and used to support university teaching.

    This file is part of SWAD core.
    Copyright (C) 1999-2023 Antonio Ca<EFBFBD>as Vargas

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as
    published by the Free Software Foundation, either version 3 of the
    License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*****************************************************************************/
/********************************* Headers ***********************************/
/*****************************************************************************/

#include <limits.h>		// For maximum values
#include <linux/limits.h>	// For PATH_MAX, NAME_MAX
#include <stddef.h>		// For NULL
#include <stdlib.h>		// For getenv, etc
#include <stdsoap2.h>		// For SOAP_OK and soap functions
#include <string.h>		// For string functions
#include <unistd.h>		// For unlink

#include "swad_action.h"
#include "swad_action_list.h"
#include "swad_alert.h"
#include "swad_autolink.h"
#include "swad_box.h"
#include "swad_database.h"
#include "swad_error.h"
#include "swad_form.h"
#include "swad_global.h"
#include "swad_HTML.h"
#include "swad_info.h"
#include "swad_info_database.h"
#include "swad_parameter.h"
#include "swad_string.h"

/*****************************************************************************/
/************** External global variables from others modules ****************/
/*****************************************************************************/

extern struct Globals Gbl;

/*****************************************************************************/
/****************************** Public constants *****************************/
/*****************************************************************************/

const Act_Action_t Inf_ActionsSeeInfo[Inf_NUM_TYPES] =
  {
   [Inf_INTRODUCTION  ] = ActSeeCrsInf,
   [Inf_TEACHING_GUIDE] = ActSeeTchGui,
   [Inf_LECTURES      ] = ActSeeSylLec,
   [Inf_PRACTICALS    ] = ActSeeSylPra,
   [Inf_BIBLIOGRAPHY  ] = ActSeeBib,
   [Inf_FAQ           ] = ActSeeFAQ,
   [Inf_LINKS         ] = ActSeeCrsLnk,
   [Inf_ASSESSMENT    ] = ActSeeAss,
  };

/*****************************************************************************/
/***************************** Private constants *****************************/
/*****************************************************************************/

static const char *Inf_FileNamesForInfoType[Inf_NUM_TYPES] =
  {
   [Inf_INTRODUCTION  ] = Cfg_CRS_INFO_INTRODUCTION,
   [Inf_TEACHING_GUIDE] = Cfg_CRS_INFO_TEACHING_GUIDE,
   [Inf_LECTURES      ] = Cfg_CRS_INFO_LECTURES,
   [Inf_PRACTICALS    ] = Cfg_CRS_INFO_PRACTICALS,
   [Inf_BIBLIOGRAPHY  ] = Cfg_CRS_INFO_BIBLIOGRAPHY,
   [Inf_FAQ           ] = Cfg_CRS_INFO_FAQ,
   [Inf_LINKS         ] = Cfg_CRS_INFO_LINKS,
   [Inf_ASSESSMENT    ] = Cfg_CRS_INFO_ASSESSMENT,
  };

static const Act_Action_t Inf_ActionsInfo[Inf_NUM_SOURCES][Inf_NUM_TYPES] =
  {
   [Inf_NONE      ][Inf_INTRODUCTION  ] = ActUnk,
   [Inf_NONE      ][Inf_TEACHING_GUIDE] = ActUnk,
   [Inf_NONE      ][Inf_LECTURES      ] = ActUnk,
   [Inf_NONE      ][Inf_PRACTICALS    ] = ActUnk,
   [Inf_NONE      ][Inf_BIBLIOGRAPHY  ] = ActUnk,
   [Inf_NONE      ][Inf_FAQ           ] = ActUnk,
   [Inf_NONE      ][Inf_LINKS         ] = ActUnk,
   [Inf_NONE      ][Inf_ASSESSMENT    ] = ActUnk,

   [Inf_EDITOR    ][Inf_INTRODUCTION  ] = ActEditorCrsInf,
   [Inf_EDITOR    ][Inf_TEACHING_GUIDE] = ActEditorTchGui,
   [Inf_EDITOR    ][Inf_LECTURES      ] = ActEditorSylLec,
   [Inf_EDITOR    ][Inf_PRACTICALS    ] = ActEditorSylPra,
   [Inf_EDITOR    ][Inf_BIBLIOGRAPHY  ] = ActEditorBib,
   [Inf_EDITOR    ][Inf_FAQ           ] = ActEditorFAQ,
   [Inf_EDITOR    ][Inf_LINKS         ] = ActEditorCrsLnk,
   [Inf_EDITOR    ][Inf_ASSESSMENT    ] = ActEditorAss,

   [Inf_PLAIN_TEXT][Inf_INTRODUCTION  ] = ActPlaTxtEdiCrsInf,
   [Inf_PLAIN_TEXT][Inf_TEACHING_GUIDE] = ActPlaTxtEdiTchGui,
   [Inf_PLAIN_TEXT][Inf_LECTURES      ] = ActPlaTxtEdiSylLec,
   [Inf_PLAIN_TEXT][Inf_PRACTICALS    ] = ActPlaTxtEdiSylPra,
   [Inf_PLAIN_TEXT][Inf_BIBLIOGRAPHY  ] = ActPlaTxtEdiBib,
   [Inf_PLAIN_TEXT][Inf_FAQ           ] = ActPlaTxtEdiFAQ,
   [Inf_PLAIN_TEXT][Inf_LINKS         ] = ActPlaTxtEdiCrsLnk,
   [Inf_PLAIN_TEXT][Inf_ASSESSMENT    ] = ActPlaTxtEdiAss,

   [Inf_RICH_TEXT ][Inf_INTRODUCTION  ] = ActRchTxtEdiCrsInf,
   [Inf_RICH_TEXT ][Inf_TEACHING_GUIDE] = ActRchTxtEdiTchGui,
   [Inf_RICH_TEXT ][Inf_LECTURES      ] = ActRchTxtEdiSylLec,
   [Inf_RICH_TEXT ][Inf_PRACTICALS    ] = ActRchTxtEdiSylPra,
   [Inf_RICH_TEXT ][Inf_BIBLIOGRAPHY  ] = ActRchTxtEdiBib,
   [Inf_RICH_TEXT ][Inf_FAQ           ] = ActRchTxtEdiFAQ,
   [Inf_RICH_TEXT ][Inf_LINKS         ] = ActRchTxtEdiCrsLnk,
   [Inf_RICH_TEXT ][Inf_ASSESSMENT    ] = ActRchTxtEdiAss,

   [Inf_PAGE      ][Inf_INTRODUCTION  ] = ActRcvPagCrsInf,
   [Inf_PAGE      ][Inf_TEACHING_GUIDE] = ActRcvPagTchGui,
   [Inf_PAGE      ][Inf_LECTURES      ] = ActRcvPagSylLec,
   [Inf_PAGE      ][Inf_PRACTICALS    ] = ActRcvPagSylPra,
   [Inf_PAGE      ][Inf_BIBLIOGRAPHY  ] = ActRcvPagBib,
   [Inf_PAGE      ][Inf_FAQ           ] = ActRcvPagFAQ,
   [Inf_PAGE      ][Inf_LINKS         ] = ActRcvPagCrsLnk,
   [Inf_PAGE      ][Inf_ASSESSMENT    ] = ActRcvPagAss,

   [Inf_URL       ][Inf_INTRODUCTION  ] = ActRcvURLCrsInf,
   [Inf_URL       ][Inf_TEACHING_GUIDE] = ActRcvURLTchGui,
   [Inf_URL       ][Inf_LECTURES      ] = ActRcvURLSylLec,
   [Inf_URL       ][Inf_PRACTICALS    ] = ActRcvURLSylPra,
   [Inf_URL       ][Inf_BIBLIOGRAPHY  ] = ActRcvURLBib,
   [Inf_URL       ][Inf_FAQ           ] = ActRcvURLFAQ,
   [Inf_URL       ][Inf_LINKS         ] = ActRcvURLCrsLnk,
   [Inf_URL       ][Inf_ASSESSMENT    ] = ActRcvURLAss,
  };

/***** Help *****/
extern const char *Hlp_COURSE_Information_textual_information;
extern const char *Hlp_COURSE_Guide;
extern const char *Hlp_COURSE_Syllabus;
extern const char *Hlp_COURSE_Bibliography;
extern const char *Hlp_COURSE_FAQ;
extern const char *Hlp_COURSE_Links;
extern const char *Hlp_COURSE_Assessment;

extern const char *Hlp_COURSE_Information_edit;
extern const char *Hlp_COURSE_Guide_edit;
extern const char *Hlp_COURSE_Syllabus_edit;
extern const char *Hlp_COURSE_Bibliography_edit;
extern const char *Hlp_COURSE_FAQ_edit;
extern const char *Hlp_COURSE_Links_edit;
extern const char *Hlp_COURSE_Assessment_edit;

/*****************************************************************************/
/**************************** Private prototypes *****************************/
/*****************************************************************************/

static void Inf_PutIconToViewInfo (void *Type);
static void Inf_PutCheckboxForceStdsToReadInfo (bool MustBeRead,bool Disabled);
static void Inf_PutCheckboxConfirmIHaveReadInfo (void);
static bool Inf_GetMustBeReadFromForm (void);
static bool Inf_GetIfIHaveReadFromForm (void);

static bool Inf_CheckPage (long CrsCod,Inf_Type_t InfoType);
static bool Inf_CheckAndShowPage (void);

static bool Inf_CheckURL (long CrsCod,Inf_Type_t InfoType);
static bool Inf_CheckAndShowURL (void);
static void Inf_BuildPathURL (long CrsCod,Inf_Type_t InfoType,
                              char PathFile[PATH_MAX + 1]);

static void Inf_ShowPage (const char *URL);

static bool Inf_CheckIfInfoAvailable (struct Syl_Syllabus *Syllabus,
                                      Inf_Src_t InfoSrc);
static void Inf_AsignInfoType (struct Inf_Info *Info,
                               struct Syl_Syllabus *Syllabus);

static bool Inf_CheckPlainTxt (long CrsCod,Inf_Type_t InfoType);
static bool Inf_CheckAndShowPlainTxt (void);

static bool Inf_CheckRichTxt (long CrsCod,Inf_Type_t InfoType);
static bool Inf_CheckAndShowRichTxt (void);

/*****************************************************************************/
/******** Show course info (theory, practices, bibliography, etc.) ***********/
/*****************************************************************************/

void Inf_ShowInfo (void)
  {
   extern const char *Txt_INFO_TITLE[Inf_NUM_TYPES];
   extern const char *Txt_No_information;
   struct Syl_Syllabus Syllabus;
   struct Inf_FromDB FromDB;
   bool Disabled;
   bool ICanEdit = (Gbl.Usrs.Me.Role.Logged == Rol_TCH ||
                    Gbl.Usrs.Me.Role.Logged == Rol_SYS_ADM);
   bool ShowWarningNoInfo = false;
   const char *Help[Inf_NUM_TYPES] =
     {
      [Inf_INTRODUCTION  ] = Hlp_COURSE_Information_textual_information,
      [Inf_TEACHING_GUIDE] = Hlp_COURSE_Guide,
      [Inf_LECTURES      ] = Hlp_COURSE_Syllabus,
      [Inf_PRACTICALS    ] = Hlp_COURSE_Syllabus,
      [Inf_BIBLIOGRAPHY  ] = Hlp_COURSE_Bibliography,
      [Inf_FAQ           ] = Hlp_COURSE_FAQ,
      [Inf_LINKS         ] = Hlp_COURSE_Links,
      [Inf_ASSESSMENT    ] = Hlp_COURSE_Assessment,
     };

   /***** Reset syllabus context *****/
   Syl_ResetSyllabus (&Syllabus);

   /***** Set info type *****/
   Inf_AsignInfoType (&Gbl.Crs.Info,&Syllabus);

   /***** Get info source from database *****/
   Inf_GetAndCheckInfoSrcFromDB (&Syllabus,
                                 Gbl.Hierarchy.Crs.CrsCod,
                                 Gbl.Crs.Info.Type,
                                 &FromDB);

   switch (Gbl.Usrs.Me.Role.Logged)
     {
      case Rol_STD:
         if (FromDB.MustBeRead)
           {
            /***** Contextual menu *****/
            Mnu_ContextMenuBegin ();
	       Inf_PutCheckboxConfirmIHaveReadInfo ();	// Checkbox to confirm that...
							   // ...I have read this couse info
            Mnu_ContextMenuEnd ();
           }
         break;
      case Rol_NET:
      case Rol_TCH:
      case Rol_SYS_ADM:
         /* Put  */
         if (FromDB.Src != Inf_NONE)
           {
            /***** Contextual menu *****/
            Mnu_ContextMenuBegin ();
	       Disabled = (Gbl.Usrs.Me.Role.Logged == Rol_NET);	// Non-editing teachers can not change the status of checkbox
	       Inf_PutCheckboxForceStdsToReadInfo (FromDB.MustBeRead,Disabled);	// Checkbox to force students...
										// ...to read this couse info
            Mnu_ContextMenuEnd ();
           }
         break;
      default:
         break;
     }

   switch (FromDB.Src)
     {
      case Inf_NONE:
	 ShowWarningNoInfo = true;
         break;
      case Inf_EDITOR:
         switch (Gbl.Crs.Info.Type)
           {
            case Inf_LECTURES:
            case Inf_PRACTICALS:
               ShowWarningNoInfo = !Syl_CheckAndEditSyllabus (&Syllabus);
               break;
            case Inf_INTRODUCTION:
            case Inf_TEACHING_GUIDE:
            case Inf_BIBLIOGRAPHY:
            case Inf_FAQ:
            case Inf_LINKS:
            case Inf_ASSESSMENT:
               ShowWarningNoInfo = true;
	       break;
           }
         break;
      case Inf_PLAIN_TEXT:
         ShowWarningNoInfo = !Inf_CheckAndShowPlainTxt ();
         break;
      case Inf_RICH_TEXT:
         ShowWarningNoInfo = !Inf_CheckAndShowRichTxt ();
         break;
      case Inf_PAGE:
         /***** Open file with web page *****/
	 ShowWarningNoInfo = !Inf_CheckAndShowPage ();
         break;
      case Inf_URL:
         /***** Check if file with URL exists *****/
	 ShowWarningNoInfo = !Inf_CheckAndShowURL ();
         break;
     }

   if (ShowWarningNoInfo)
     {
      if (ICanEdit)
	 Box_BoxBegin ("100%",Txt_INFO_TITLE[Gbl.Crs.Info.Type],
		       Inf_PutIconToEditInfo,&Gbl.Crs.Info.Type,
		       Help[Gbl.Crs.Info.Type],Box_NOT_CLOSABLE);
      else
	 Box_BoxBegin ("100%",Txt_INFO_TITLE[Gbl.Crs.Info.Type],
		       NULL,NULL,
		       Help[Gbl.Crs.Info.Type],Box_NOT_CLOSABLE);
      Ale_ShowAlert (Ale_INFO,Txt_No_information);
      Box_BoxEnd ();
     }
  }

/*****************************************************************************/
/************************ Put icon to edit course info ***********************/
/*****************************************************************************/

static void Inf_PutIconToViewInfo (void *Type)
  {
   if (Type)
      Ico_PutContextualIconToView (Inf_ActionsSeeInfo[*((Inf_Type_t *) Type)],NULL,
				   NULL,NULL);
  }

void Inf_PutIconToEditInfo (void *Type)
  {
   static const Act_Action_t Inf_ActionsEditInfo[Inf_NUM_TYPES] =
     {
      [Inf_INTRODUCTION  ] = ActEdiCrsInf,
      [Inf_TEACHING_GUIDE] = ActEdiTchGui,
      [Inf_LECTURES      ] = ActEdiSylLec,
      [Inf_PRACTICALS    ] = ActEdiSylPra,
      [Inf_BIBLIOGRAPHY  ] = ActEdiBib,
      [Inf_FAQ           ] = ActEdiFAQ,
      [Inf_LINKS         ] = ActEdiCrsLnk,
      [Inf_ASSESSMENT    ] = ActEdiAss,
     };

   if (Type)
      Ico_PutContextualIconToEdit (Inf_ActionsEditInfo[*((Inf_Type_t *) Type)],NULL,
				   NULL,NULL);
  }

/*****************************************************************************/
/********** Put a form (checkbox) to force students to read info *************/
/*****************************************************************************/

static void Inf_PutCheckboxForceStdsToReadInfo (bool MustBeRead,bool Disabled)
  {
   extern const char *Txt_Force_students_to_read_this_information;
   static const Act_Action_t Inf_ActionsChangeForceReadInfo[Inf_NUM_TYPES] =
     {
      [Inf_INTRODUCTION  ] = ActChgFrcReaCrsInf,
      [Inf_TEACHING_GUIDE] = ActChgFrcReaTchGui,
      [Inf_LECTURES      ] = ActChgFrcReaSylLec,
      [Inf_PRACTICALS    ] = ActChgFrcReaSylPra,
      [Inf_BIBLIOGRAPHY  ] = ActChgFrcReaBib,
      [Inf_FAQ           ] = ActChgFrcReaFAQ,
      [Inf_LINKS         ] = ActChgFrcReaCrsLnk,
      [Inf_ASSESSMENT    ] = ActChgFrcReaAss,
     };

   Lay_PutContextualCheckbox (Inf_ActionsChangeForceReadInfo[Gbl.Crs.Info.Type],
                              NULL,
                              "MustBeRead",
                              MustBeRead,Disabled,
                              Txt_Force_students_to_read_this_information,
                              Txt_Force_students_to_read_this_information);
  }

/*****************************************************************************/
/********** Put a form (checkbox) to force students to read info *************/
/*****************************************************************************/

static void Inf_PutCheckboxConfirmIHaveReadInfo (void)
  {
   extern const char *Txt_I_have_read_this_information;
   static const Act_Action_t Inf_ActionsIHaveReadInfo[Inf_NUM_TYPES] =
     {
      [Inf_INTRODUCTION  ] = ActChgHavReaCrsInf,
      [Inf_TEACHING_GUIDE] = ActChgHavReaTchGui,
      [Inf_LECTURES      ] = ActChgHavReaSylLec,
      [Inf_PRACTICALS    ] = ActChgHavReaSylPra,
      [Inf_BIBLIOGRAPHY  ] = ActChgHavReaBib,
      [Inf_FAQ           ] = ActChgHavReaFAQ,
      [Inf_LINKS         ] = ActChgHavReaCrsLnk,
      [Inf_ASSESSMENT    ] = ActChgHavReaAss,
     };
   bool IHaveRead = Inf_DB_CheckIfIHaveReadInfo ();

   Lay_PutContextualCheckbox (Inf_ActionsIHaveReadInfo[Gbl.Crs.Info.Type],
                              NULL,
                              "IHaveRead",
                              IHaveRead,false,
                              Txt_I_have_read_this_information,
                              Txt_I_have_read_this_information);
  }

/*****************************************************************************/
/********* Get if students must read any info about current course ***********/
/*****************************************************************************/

bool Inf_GetIfIMustReadAnyCrsInfoInThisCrs (void)
  {
   MYSQL_RES *mysql_res;
   MYSQL_ROW row;
   unsigned NumInfos;
   unsigned NumInfo;
   Inf_Type_t InfoType;

   /***** Reset must-be-read to false for all info types *****/
   for (InfoType  = (Inf_Type_t) 0;
	InfoType <= (Inf_Type_t) (Inf_NUM_TYPES - 1);
	InfoType++)
      Gbl.Crs.Info.MustBeRead[InfoType] = false;

   /***** Get info types where students must read info *****/
   NumInfos = Inf_DB_GetInfoTypesfIMustReadInfo (&mysql_res);

   /***** Set must-be-read to true for each rown in result *****/
   for (NumInfo = 0;
	NumInfo < NumInfos;
	NumInfo++)
     {
      row = mysql_fetch_row (mysql_res);

      /* Get info type (row[0]) */
      InfoType = Inf_DB_ConvertFromStrDBToInfoType (row[0]);

      Gbl.Crs.Info.MustBeRead[InfoType] = true;
     }

   /***** Free structure that stores the query result *****/
   DB_FreeMySQLResult (&mysql_res);

   return (NumInfos != 0);
  }

/*****************************************************************************/
/***** Write message if students must read any info about current course *****/
/*****************************************************************************/

void Inf_WriteMsgYouMustReadInfo (void)
  {
   extern const char *Txt_Required_reading;
   extern const char *Txt_You_should_read_the_following_information;
   Inf_Type_t InfoType;

   /***** Begin box *****/
   Box_BoxBegin (NULL,Txt_Required_reading,
                 NULL,NULL,
                 NULL,Box_CLOSABLE);

      /***** Write message *****/
      Ale_ShowAlert (Ale_WARNING,Txt_You_should_read_the_following_information);

      /***** Write every information I must read *****/
      HTM_DIV_Begin ("class=\"CM\"");
	 HTM_UL_Begin ("class=\"LIST_I_MUST_READ\"");
	    for (InfoType  = (Inf_Type_t) 0;
		 InfoType <= (Inf_Type_t) (Inf_NUM_TYPES - 1);
		 InfoType++)
	       if (Gbl.Crs.Info.MustBeRead[InfoType])
		 {
		  HTM_LI_Begin (NULL);
		     Frm_BeginForm (Inf_ActionsSeeInfo[InfoType]);
			HTM_BUTTON_Submit_Begin (Act_GetTitleAction (Inf_ActionsSeeInfo[InfoType]),
						 "class=\"BT_LINK FORM_IN_%s\"",
						 The_GetSuffix ());
			   HTM_Txt (Act_GetTitleAction (Inf_ActionsSeeInfo[InfoType]));
			HTM_BUTTON_End ();
		     Frm_EndForm ();
		  HTM_LI_End ();
		 }
	 HTM_UL_End ();
      HTM_DIV_End ();

   /***** End box *****/
   Box_BoxEnd ();
  }

/*****************************************************************************/
/****** Change teacher's preference about force students to read info ********/
/*****************************************************************************/

void Inf_ChangeForceReadInfo (void)
  {
   extern const char *Txt_Students_now_are_required_to_read_this_information;
   extern const char *Txt_Students_are_no_longer_obliged_to_read_this_information;
   struct Syl_Syllabus Syllabus;
   bool MustBeRead = Inf_GetMustBeReadFromForm ();

   /***** Reset syllabus context *****/
   Syl_ResetSyllabus (&Syllabus);

   /***** Set info type *****/
   Inf_AsignInfoType (&Gbl.Crs.Info,&Syllabus);

   /***** Set status (if info must be read or not) into database *****/
   Inf_DB_SetForceRead (MustBeRead);

   /***** Write message of success *****/
   Ale_ShowAlert (Ale_SUCCESS,
                  MustBeRead ? Txt_Students_now_are_required_to_read_this_information :
                               Txt_Students_are_no_longer_obliged_to_read_this_information);

   /***** Show the selected info *****/
   Inf_ShowInfo ();
  }

/*****************************************************************************/
/************** Change confirmation of I have read course info ***************/
/*****************************************************************************/

void Inf_ChangeIHaveReadInfo (void)
  {
   extern const char *Txt_You_have_confirmed_that_you_have_read_this_information;
   extern const char *Txt_You_have_eliminated_the_confirmation_that_you_have_read_this_information;
   struct Syl_Syllabus Syllabus;
   bool IHaveRead = Inf_GetIfIHaveReadFromForm ();

   /***** Reset syllabus context *****/
   Syl_ResetSyllabus (&Syllabus);

   /***** Set info type *****/
   Inf_AsignInfoType (&Gbl.Crs.Info,&Syllabus);

   /***** Set status (if I have read or not a information) into database *****/
   Inf_DB_SetIHaveRead (IHaveRead);

   /***** Write message of success *****/
   Ale_ShowAlert (Ale_SUCCESS,
                  IHaveRead ? Txt_You_have_confirmed_that_you_have_read_this_information :
                              Txt_You_have_eliminated_the_confirmation_that_you_have_read_this_information);

   /***** Show the selected info *****/
   Inf_ShowInfo ();
  }

/*****************************************************************************/
/************* Get if info must be read by students from form ****************/
/*****************************************************************************/

static bool Inf_GetMustBeReadFromForm (void)
  {
   return Par_GetParBool ("MustBeRead");
  }

/*****************************************************************************/
/************* Get if info must be read by students from form ****************/
/*****************************************************************************/

static bool Inf_GetIfIHaveReadFromForm (void)
  {
   return Par_GetParBool ("IHaveRead");
  }

/*****************************************************************************/
/************************** Check if exists a page ***************************/
/*****************************************************************************/
// Return true if info available

static bool Inf_CheckPage (long CrsCod,Inf_Type_t InfoType)
  {
   char PathRelDirHTML[PATH_MAX + 1];
   char PathRelFileHTML[PATH_MAX + 1 + 10 + 1];

   // TODO !!!!!!!!!!!! If the page is hosted in server ==> it should be created a temporary public directory
   //                                                       and host the page in a private directory !!!!!!!!!!!!!!!!!

   /***** Build path of directory containing web page *****/
   Inf_BuildPathPage (CrsCod,InfoType,PathRelDirHTML);

   /***** Open file with web page *****/
   /* 1. Check if index.html exists */
   snprintf (PathRelFileHTML,sizeof (PathRelFileHTML),"%s/index.html",
	     PathRelDirHTML);
   if (Fil_CheckIfPathExists (PathRelFileHTML))	// TODO: Check if not empty?
      return true;

   /* 2. If index.html does not exist, try index.htm */
   snprintf (PathRelFileHTML,sizeof (PathRelFileHTML),"%s/index.htm",
	     PathRelDirHTML);
   if (Fil_CheckIfPathExists (PathRelFileHTML))	// TODO: Check if not empty?
      return true;

   return false;
  }

/*****************************************************************************/
/**************** Check if exists and show link to a page ********************/
/*****************************************************************************/
// Return true if info available

static bool Inf_CheckAndShowPage (void)
  {
   char PathRelDirHTML[PATH_MAX + 1];
   char PathRelFileHTML[PATH_MAX + 1 + 10 + 1];
   char URL[PATH_MAX + 1];

   // TODO !!!!!!!!!!!! If the page is hosted in server ==> it should be created a temporary public directory
   //                                                       and host the page in a private directory !!!!!!!!!!!!!!!!!

   /***** Build path of directory containing web page *****/
   Inf_BuildPathPage (Gbl.Hierarchy.Crs.CrsCod,Gbl.Crs.Info.Type,PathRelDirHTML);

   /***** Open file with web page *****/
   /* 1. Check if index.html exists */
   snprintf (PathRelFileHTML,sizeof (PathRelFileHTML),"%s/index.html",
	     PathRelDirHTML);
   if (Fil_CheckIfPathExists (PathRelFileHTML))	// TODO: Check if not empty?
     {
      snprintf (URL,sizeof (URL),"%s/%ld/%s/index.html",
	        Cfg_URL_CRS_PUBLIC,Gbl.Hierarchy.Crs.CrsCod,
	        Inf_FileNamesForInfoType[Gbl.Crs.Info.Type]);
      Inf_ShowPage (URL);

      return true;
     }

   /* 2. If index.html does not exist, try index.htm */
   snprintf (PathRelFileHTML,sizeof (PathRelFileHTML),"%s/index.htm",
	     PathRelDirHTML);
   if (Fil_CheckIfPathExists (PathRelFileHTML))	// TODO: Check if not empty?
     {
      snprintf (URL,sizeof (URL),"%s/%ld/%s/index.htm",
	        Cfg_URL_CRS_PUBLIC,Gbl.Hierarchy.Crs.CrsCod,
	        Inf_FileNamesForInfoType[Gbl.Crs.Info.Type]);
      Inf_ShowPage (URL);

      return true;
     }

   return false;
  }

/*****************************************************************************/
/* Build path inside a course for a given a info type to store web page file */
/*****************************************************************************/

void Inf_BuildPathPage (long CrsCod,Inf_Type_t InfoType,char PathDir[PATH_MAX + 1])
  {
   snprintf (PathDir,PATH_MAX + 1,"%s/%ld/%s",
             Cfg_PATH_CRS_PUBLIC,CrsCod,Inf_FileNamesForInfoType[InfoType]);
  }

/*****************************************************************************/
/********************* Check if exists link to a page ************************/
/*****************************************************************************/
// Return true if info available

static bool Inf_CheckURL (long CrsCod,Inf_Type_t InfoType)
  {
   char PathFile[PATH_MAX + 1];
   FILE *FileURL;

   /***** Build path to file containing URL *****/
   Inf_BuildPathURL (CrsCod,InfoType,PathFile);

   /***** Check if file with URL exists *****/
   if ((FileURL = fopen (PathFile,"rb")))
     {
      if (fgets (Gbl.Crs.Info.URL,Cns_MAX_BYTES_WWW,FileURL) == NULL)
	 Gbl.Crs.Info.URL[0] = '\0';
      /* File is not longer needed  ==> close it */
      fclose (FileURL);

      if (Gbl.Crs.Info.URL[0])
         return true;
     }

   return false;
  }

/*****************************************************************************/
/**************** Check if exists and show link to a page ********************/
/*****************************************************************************/
// Return true if info available

static bool Inf_CheckAndShowURL (void)
  {
   char PathFile[PATH_MAX + 1];
   FILE *FileURL;

   /***** Build path to file containing URL *****/
   Inf_BuildPathURL (Gbl.Hierarchy.Crs.CrsCod,Gbl.Crs.Info.Type,PathFile);

   /***** Check if file with URL exists *****/
   if ((FileURL = fopen (PathFile,"rb")))
     {
      if (fgets (Gbl.Crs.Info.URL,Cns_MAX_BYTES_WWW,FileURL) == NULL)
	 Gbl.Crs.Info.URL[0] = '\0';
      /* File is not longer needed  ==> close it */
      fclose (FileURL);

      if (Gbl.Crs.Info.URL[0])
	{
	 Inf_ShowPage (Gbl.Crs.Info.URL);
         return true;
	}
     }

   return false;
  }

/*****************************************************************************/
/*** Build path inside a course for a given a info type to store URL file ****/
/*****************************************************************************/

static void Inf_BuildPathURL (long CrsCod,Inf_Type_t InfoType,
                              char PathFile[PATH_MAX + 1])
  {
   snprintf (PathFile,PATH_MAX + 1,"%s/%ld/%s.url",
	     Cfg_PATH_CRS_PRIVATE,CrsCod,Inf_FileNamesForInfoType[InfoType]);
  }

/*****************************************************************************/
/************* Check if exists and write URL into text buffer ****************/
/*****************************************************************************/
// This function is called only from web service