Version 22.50: Oct 19, 2022 Code refactoring related to dates.

swad_RSS.c

@@ -63,6 +63,7 @@ void RSS_UpdateRSSFileForACrs (struct Crs_Course *Crs)
    FILE *FileRSS;
    char RSSLink[Cns_MAX_BYTES_WWW + 1];
    struct tm *tm;
+   time_t t = Dat_GetStartExecutionTimeUTC ();
 
    /***** Create RSS directory if not exists *****/
    snprintf (PathRelPublRSSDir,sizeof (PathRelPublRSSDir),"%s/%ld/%s",
@@ -111,12 +112,12 @@ void RSS_UpdateRSSFileForACrs (struct Crs_Course *Crs)
 
    // All date-times in RSS conform to the Date and Time Specification of RFC 822, with the exception that the year may be expressed with two characters or four characters (four preferred)
    fprintf (FileRSS,"<pubDate>");	
-   tm = gmtime (&Gbl.StartExecutionTimeUTC);
+   tm = gmtime (&t);
    Dat_WriteRFC822DateFromTM (FileRSS,tm);
    fprintf (FileRSS,"</pubDate>\n");
 
    fprintf (FileRSS,"<lastBuildDate>");	
-   tm = gmtime (&Gbl.StartExecutionTimeUTC);
+   tm = gmtime (&t);
    Dat_WriteRFC822DateFromTM (FileRSS,tm);
    fprintf (FileRSS,"</lastBuildDate>\n");
 

swad_agenda.c

@@ -1407,8 +1407,8 @@ void Agd_RequestCreatOrEditEvent (void)
      {
       /* Initialize to empty event */
       AgdEvent.AgdCod = -1L;
-      AgdEvent.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      AgdEvent.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
-      AgdEvent.TimeUTC[Dat_END_TIME] = Gbl.StartExecutionTimeUTC + (2 * 60 * 60);	// +2 hours
+      AgdEvent.TimeUTC[Dat_END_TIME] = AgdEvent.TimeUTC[Dat_STR_TIME] + (2 * 60 * 60);	// +2 hours
       AgdEvent.TimeStatus = Dat_FUTURE;
       AgdEvent.Event[0]    = '\0';
       AgdEvent.Location[0] = '\0';
@@ -1562,7 +1562,7 @@ void Agd_ReceiveFormEvent (void)
 
    /***** Adjust dates *****/
    if (AgdEvent.TimeUTC[Dat_STR_TIME] == 0)
-      AgdEvent.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      AgdEvent.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
    if (AgdEvent.TimeUTC[Dat_END_TIME] == 0)
       AgdEvent.TimeUTC[Dat_END_TIME] = AgdEvent.TimeUTC[Dat_STR_TIME] + 2 * 60 * 60;	// +2 hours
 

swad_assignment.c

@@ -1210,8 +1210,8 @@ void Asg_RequestCreatOrEditAsg (void)
      {
       /* Initialize to empty assignment */
       Assignments.Asg.AsgCod = -1L;
-      Assignments.Asg.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      Assignments.Asg.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
-      Assignments.Asg.TimeUTC[Dat_END_TIME] = Gbl.StartExecutionTimeUTC + (2 * 60 * 60);	// +2 hours
+      Assignments.Asg.TimeUTC[Dat_END_TIME] = Assignments.Asg.TimeUTC[Dat_STR_TIME] + (2 * 60 * 60);	// +2 hours
       Assignments.Asg.Open = true;
       Assignments.Asg.Title[0] = '\0';
       Assignments.Asg.SendWork = Asg_DO_NOT_SEND_WORK;
@@ -1454,7 +1454,7 @@ void Asg_ReceiveFormAssignment (void)
 
    /***** Adjust dates *****/
    if (Assignments.Asg.TimeUTC[Dat_STR_TIME] == 0)
-      Assignments.Asg.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      Assignments.Asg.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
    if (Assignments.Asg.TimeUTC[Dat_END_TIME] == 0)
       Assignments.Asg.TimeUTC[Dat_END_TIME] = Assignments.Asg.TimeUTC[Dat_STR_TIME] + 2 * 60 * 60;	// +2 hours
 

swad_attendance.c

@@ -1010,8 +1010,8 @@ void Att_RequestCreatOrEditAttEvent (void)
       /* Initialize some fields */
       Events.Event.CrsCod = Gbl.Hierarchy.Crs.CrsCod;
       Events.Event.UsrCod = Gbl.Usrs.Me.UsrDat.UsrCod;
-      Events.Event.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      Events.Event.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
-      Events.Event.TimeUTC[Dat_END_TIME] = Gbl.StartExecutionTimeUTC + (2 * 60 * 60);	// +2 hours
+      Events.Event.TimeUTC[Dat_END_TIME] = Events.Event.TimeUTC[Dat_STR_TIME] + (2 * 60 * 60);	// +2 hours
       Events.Event.Open = true;
      }
    else
@@ -1230,7 +1230,7 @@ void Att_ReceiveFormAttEvent (void)
 
    /***** Adjust dates *****/
    if (ReceivedAtt.TimeUTC[Dat_STR_TIME] == 0)
-      ReceivedAtt.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      ReceivedAtt.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
    if (ReceivedAtt.TimeUTC[Dat_END_TIME] == 0)
       ReceivedAtt.TimeUTC[Dat_END_TIME] = ReceivedAtt.TimeUTC[Dat_STR_TIME] + 2 * 60 * 60;	// +2 hours // TODO: 2 * 60 * 60 should be in a #define in swad_config.h
 

swad_banner_database.c

@@ -93,7 +93,7 @@ unsigned Ban_DB_GetRandomBanners (MYSQL_RES **mysql_res)
 		   " WHERE Hidden='N'"
 		   " ORDER BY RAND(%lu)"
 		   " LIMIT %u",
-		   (unsigned long) (Gbl.StartExecutionTimeUTC /
+		   (unsigned long) (Dat_GetStartExecutionTimeUTC () /
 				    Cfg_TIME_TO_CHANGE_BANNER),
 		   Cfg_NUMBER_OF_BANNERS);
   }

swad_browser.c

@@ -4482,7 +4482,7 @@ static bool Brw_WriteRowFileBrowser (unsigned Level,const char *RowId,
 
    /***** Check if is a recent file or folder *****/
    // If less than a week since last modify ==> indicate the file is recent by writting its name in green
-   if (Gbl.StartExecutionTimeUTC < FileMetadata.Time + (7L * 24L * 60L * 60L))
+   if (Dat_GetStartExecutionTimeUTC () < FileMetadata.Time + (7L * 24L * 60L * 60L))
       IsRecent = true;
 
    /* Style of the text in this row */
@@ -10318,7 +10318,7 @@ static void Brw_RemoveOldFilesInBrowser (unsigned Months,struct Brw_NumObjects *
 
    /***** Compute time in seconds
           (files older than this time will be removed) *****/
-   TimeRemoveFilesOlder = Gbl.StartExecutionTimeUTC -
+   TimeRemoveFilesOlder = Dat_GetStartExecutionTimeUTC () -
 	                  (time_t) Months * Dat_SECONDS_IN_ONE_MONTH;
 
    /***** Remove old files recursively *****/

swad_calendar.c

@@ -215,7 +215,7 @@ void Cal_DrawCurrentMonth (void)
       HTM_Txt ("\tGbl_HTMLContent = '';");
       HTM_TxtF ("\tDrawCurrentMonth ('CurrentMonth',%u,%ld,%ld,'%s','%s/%s',",
 		Gbl.Prefs.FirstDayOfWeek,
-		(long) Gbl.StartExecutionTimeUTC,
+		(long) Dat_GetStartExecutionTimeUTC (),
 		Gbl.Hierarchy.Ctr.PlcCod,
 		The_GetSuffix (),
 		Cfg_URL_SWAD_CGI,Lan_STR_LANG_ID[Gbl.Prefs.Language]);
@@ -284,7 +284,7 @@ static void Cal_DrawCalendar (Act_Action_t ActionSeeCalendar,
 	 HTM_Txt ("\tGbl_HTMLContent = '';");
 	 HTM_TxtF ("\tCal_DrawCalendar('calendar',%u,%ld,%ld,%s,'%s','%s/%s',",
 		   Gbl.Prefs.FirstDayOfWeek,
-		   (long) Gbl.StartExecutionTimeUTC,
+		   (long) Dat_GetStartExecutionTimeUTC (),
 		   Gbl.Hierarchy.Ctr.PlcCod,
 		   PrintView ? "true" :
 			       "false",

swad_call_for_exam.c

@@ -195,9 +195,9 @@ static long Cfe_GetParamsCallsForExams (struct Cfe_CallsForExams *CallsForExams)
        CallsForExams->CallForExam.ExamDate.Month == 0 ||
        CallsForExams->CallForExam.ExamDate.Year  == 0)
      {
-      CallsForExams->CallForExam.ExamDate.Day   = Gbl.Now.Date.Day;
+      CallsForExams->CallForExam.ExamDate.Day   = Dat_GetCurrentDay ();
-      CallsForExams->CallForExam.ExamDate.Month = Gbl.Now.Date.Month;
+      CallsForExams->CallForExam.ExamDate.Month = Dat_GetCurrentMonth ();
-      CallsForExams->CallForExam.ExamDate.Year  = Gbl.Now.Date.Year;
+      CallsForExams->CallForExam.ExamDate.Year  = Dat_GetCurrentYear ();
      }
 
    /***** Get the hour of the exam *****/
@@ -898,6 +898,7 @@ static void Cfe_ShowCallForExam (struct Cfe_CallsForExams *CallsForExams,
    extern const char *Txt_Publish_call_FOR_EXAM;
    struct Ins_Instit Ins;
    char StrExamDate[Cns_MAX_BYTES_DATE + 1];
+   unsigned CurrentYear = Dat_GetCurrentYear ();
    unsigned Year;
    unsigned Hour;
    unsigned Minute;
@@ -1103,9 +1104,9 @@ static void Cfe_ShowCallForExam (struct Cfe_CallsForExams *CallsForExams,
 	    if (TypeViewCallForExam == Cfe_FORM_VIEW)
 	      {
 	       HTM_TD_Begin ("class=\"LB\"");
-		  Dat_WriteFormDate (CallsForExams->CallForExam.ExamDate.Year < Gbl.Now.Date.Year ? CallsForExams->CallForExam.ExamDate.Year :
+		  Dat_WriteFormDate (CallsForExams->CallForExam.ExamDate.Year < CurrentYear ? CallsForExams->CallForExam.ExamDate.Year :
-												    Gbl.Now.Date.Year,
+											      CurrentYear,
-				     Gbl.Now.Date.Year + 1,"Exam",
+				     CurrentYear + 1,"Exam",
 				     &(CallsForExams->CallForExam.ExamDate),
 				     false,false);
 	       HTM_TD_End ();

swad_changelog.h

@@ -606,10 +606,11 @@ TODO: Fix bug: error al enviar un mensaje a dos recipientes, error on duplicate
 
 TODO: Attach pdf files in multimedia.
 */
-#define Log_PLATFORM_VERSION	"SWAD 22.49.9 (2022-10-18)"
+#define Log_PLATFORM_VERSION	"SWAD 22.50 (2022-10-19)"
 #define CSS_FILE		"swad22.49.4.css"
 #define JS_FILE			"swad22.49.js"
 /*
+	Version 22.50:    Oct 19, 2022  Code refactoring related to dates. (333318 lines)
 	Version 22.49.9:  Oct 18, 2022  Code refactoring related to XML. (333257 lines)
 	Version 22.49.8:  Oct 18, 2022  Code refactoring related to parameters. (333253 lines)
 	Version 22.49.7:  Oct 18, 2022  Code refactoring related to database. (333218 lines)

swad_connected.c

@@ -113,7 +113,7 @@ void Con_ShowConnectedUsrs (void)
    free (Title);
 
       /***** Current time *****/
-      Dat_WriteLocalDateHMSFromUTC ("connected_current_time",Gbl.StartExecutionTimeUTC,
+      Dat_WriteLocalDateHMSFromUTC ("connected_current_time",Dat_GetStartExecutionTimeUTC (),
 				    Gbl.Prefs.DateFormat,Dat_SEPARATOR_COMMA,
 				    false,false,true,0x7);
 

swad_cryptography.c

@@ -133,6 +133,6 @@ void Cry_CreateUniqueNameEncrypted (char UniqueNameEncrypted[Cry_BYTES_ENCRYPTED
 
    NumCall++;
    snprintf (UniqueNamePlain,sizeof (UniqueNamePlain),"%s-%lx-%x-%x",
-             Gbl.IP,Gbl.StartExecutionTimeUTC,Gbl.PID,NumCall);
+             Gbl.IP,Dat_GetStartExecutionTimeUTC (),Gbl.PID,NumCall);
    Cry_EncryptSHA256Base64 (UniqueNamePlain,UniqueNameEncrypted);	// Make difficult to guess a unique name
   }

swad_date.c

@@ -90,6 +90,20 @@ static const unsigned Dat_NumDaysMonth[1 + 12] =
    [12] = 31,	// December
   };
 
+static struct
+  {
+   struct timeval tvStart;
+   struct timeval tvPageCreated;
+   time_t StartExecutionTimeUTC;
+   struct Dat_DateTime Now;
+   long TimeGenerationInMicroseconds;
+   long TimeSendInMicroseconds;
+  } Dat_Time =
+  {
+   .TimeGenerationInMicroseconds = 0L,
+   .TimeSendInMicroseconds       = 0L,
+  };
+
 /*****************************************************************************/
 /**************************** Private prototypes *****************************/
 /*****************************************************************************/
@@ -97,6 +111,138 @@ static const unsigned Dat_NumDaysMonth[1 + 12] =
 static void Dat_PutIconsDateFormat (__attribute__((unused)) void *Args);
 static unsigned Dat_GetParamDateFormat (void);
 
+/*****************************************************************************/
+/*********************** Set/get start execution time ************************/
+/*****************************************************************************/
+
+void Dat_SetStartExecutionTimeval (void)
+  {
+   struct timezone tz;
+
+   gettimeofday (&Dat_Time.tvStart, &tz);
+  }
+
+void Dat_SetStartExecutionTimeUTC (void)
+  {
+   Dat_Time.StartExecutionTimeUTC = time (NULL);
+  }
+
+time_t Dat_GetStartExecutionTimeUTC (void)
+  {
+   return Dat_Time.StartExecutionTimeUTC;
+  }
+
+struct Dat_Date *Dat_GetCurrentDate (void)
+  {
+   return &Dat_Time.Now.Date;
+  }
+
+unsigned Dat_GetCurrentDay (void)
+  {
+   return Dat_Time.Now.Date.Day;
+  }
+
+unsigned Dat_GetCurrentMonth (void)
+  {
+   return Dat_Time.Now.Date.Month;
+  }
+
+unsigned Dat_GetCurrentYear (void)
+  {
+   return Dat_Time.Now.Date.Year;
+  }
+
+/*****************************************************************************/
+/************** Get time to generate/send page in microseconds ***************/
+/*****************************************************************************/
+
+long Dat_GetTimeGenerationInMicroseconds (void)
+  {
+   return Dat_Time.TimeGenerationInMicroseconds;
+  }
+
+long Dat_GetTimeSendInMicroseconds (void)
+  {
+   return Dat_Time.TimeSendInMicroseconds;
+  }
+
+/*****************************************************************************/
+/**************** Compute the time used to generate the page *****************/
+/*****************************************************************************/
+
+void Dat_ComputeTimeToGeneratePage (void)
+  {
+   struct timezone tz;
+
+   if (gettimeofday (&Dat_Time.tvPageCreated, &tz))
+      // Error in gettimeofday
+      Dat_Time.TimeGenerationInMicroseconds = 0L;
+   else
+      Dat_Time.TimeGenerationInMicroseconds = (long) ((Dat_Time.tvPageCreated.tv_sec  - Dat_Time.tvStart.tv_sec) * 1000000L +
+						       Dat_Time.tvPageCreated.tv_usec - Dat_Time.tvStart.tv_usec);
+  }
+
+/*****************************************************************************/
+/****************** Compute the time used to send the page *******************/
+/*****************************************************************************/
+
+void Dat_ComputeTimeToSendPage (void)
+  {
+   struct timeval tvPageSent;
+   struct timezone tz;
+
+   if (gettimeofday (&tvPageSent, &tz))
+      // Error in gettimeofday
+      Dat_Time.TimeSendInMicroseconds = 0;
+   else
+     {
+      if (tvPageSent.tv_usec < Dat_Time.tvPageCreated.tv_usec)
+	{
+	 tvPageSent.tv_sec--;
+	 tvPageSent.tv_usec += 1000000;
+	}
+      Dat_Time.TimeSendInMicroseconds = (tvPageSent.tv_sec  - Dat_Time.tvPageCreated.tv_sec) * 1000000L +
+                                         tvPageSent.tv_usec - Dat_Time.tvPageCreated.tv_usec;
+     }
+  }
+
+/*****************************************************************************/
+/************** Write the time to generate and send the page *****************/
+/*****************************************************************************/
+
+void Dat_WriteTimeToGenerateAndSendPage (void)
+  {
+   extern const char *Txt_PAGE1_Page_generated_in;
+   extern const char *Txt_PAGE2_and_sent_in;
+   char StrTimeGenerationInMicroseconds[Dat_MAX_BYTES_TIME + 1];
+   char StrTimeSendInMicroseconds[Dat_MAX_BYTES_TIME + 1];
+
+   Dat_WriteTime (StrTimeGenerationInMicroseconds,Dat_GetTimeGenerationInMicroseconds ());
+   Dat_WriteTime (StrTimeSendInMicroseconds      ,Dat_GetTimeSendInMicroseconds ());
+   HTM_TxtF ("%s %s %s %s",
+             Txt_PAGE1_Page_generated_in,StrTimeGenerationInMicroseconds,
+             Txt_PAGE2_and_sent_in,StrTimeSendInMicroseconds);
+  }
+
+/*****************************************************************************/
+/********* Write time (given in microseconds) depending on amount ************/
+/*****************************************************************************/
+
+void Dat_WriteTime (char Str[Dat_MAX_BYTES_TIME],long TimeInMicroseconds)
+  {
+   if (TimeInMicroseconds < 1000L)
+      snprintf (Str,Dat_MAX_BYTES_TIME + 1,"%ld &micro;s",TimeInMicroseconds);
+   else if (TimeInMicroseconds < 1000000L)
+      snprintf (Str,Dat_MAX_BYTES_TIME + 1,"%ld ms",TimeInMicroseconds / 1000);
+   else if (TimeInMicroseconds < (60 * 1000000L))
+      snprintf (Str,Dat_MAX_BYTES_TIME + 1,"%.1f s",
+                (double) TimeInMicroseconds / 1E6);
+   else
+      snprintf (Str,Dat_MAX_BYTES_TIME + 1,"%ld min, %ld s",
+                TimeInMicroseconds / (60 * 1000000L),
+                (TimeInMicroseconds / 1000000L) % 60);
+  }
+
 /*****************************************************************************/
 /******************************** Reset date *********************************/
 /*****************************************************************************/
@@ -195,7 +341,7 @@ void Dat_PutScriptDateFormat (Dat_Format_t Format)
 
    if (asprintf (&Id,"date_format_%u",(unsigned) Format) < 0)
       Err_NotEnoughMemoryExit ();
-   Dat_WriteLocalDateHMSFromUTC (Id,Gbl.StartExecutionTimeUTC,
+   Dat_WriteLocalDateHMSFromUTC (Id,Dat_GetStartExecutionTimeUTC (),
 				 Format,Dat_SEPARATOR_NONE,
 				 false,true,false,0x0);
    free (Id);
@@ -245,15 +391,6 @@ Dat_Format_t Dat_GetDateFormatFromStr (const char *Str)
    return Dat_FORMAT_DEFAULT;
   }
 
-/*****************************************************************************/
-/************************** Get current time UTC *****************************/
-/*****************************************************************************/
-
-void Dat_GetStartExecutionTimeUTC (void)
-  {
-   Gbl.StartExecutionTimeUTC = time (NULL);
-  }
-
 /*****************************************************************************/
 /********************** Get and convert current time *************************/
 /*****************************************************************************/
@@ -261,30 +398,28 @@ void Dat_GetStartExecutionTimeUTC (void)
 void Dat_GetAndConvertCurrentDateTime (void)
   {
    struct tm *tm_ptr;
+   time_t t = Dat_GetStartExecutionTimeUTC ();
 
    /***** Convert current local time to a struct tblock *****/
-   tm_ptr = Dat_GetLocalTimeFromClock (&Gbl.StartExecutionTimeUTC);
+   tm_ptr = Dat_GetLocalTimeFromClock (&t);
 
-   Gbl.Now.Date.Year   = tm_ptr->tm_year + 1900;
+   Dat_Time.Now.Date.Year   = tm_ptr->tm_year + 1900;
-   Gbl.Now.Date.Month  = tm_ptr->tm_mon  + 1;
+   Dat_Time.Now.Date.Month  = tm_ptr->tm_mon  + 1;
-   Gbl.Now.Date.Day    = tm_ptr->tm_mday;
+   Dat_Time.Now.Date.Day    = tm_ptr->tm_mday;
-   Gbl.Now.Time.Hour   = tm_ptr->tm_hour;
+   Dat_Time.Now.Time.Hour   = tm_ptr->tm_hour;
-   Gbl.Now.Time.Minute = tm_ptr->tm_min;
+   Dat_Time.Now.Time.Minute = tm_ptr->tm_min;
-   Gbl.Now.Time.Second = tm_ptr->tm_sec;
+   Dat_Time.Now.Time.Second = tm_ptr->tm_sec;
 
    /***** Initialize current date in format YYYYMMDD *****/
-   snprintf (Gbl.Now.Date.YYYYMMDD,sizeof (Gbl.Now.Date.YYYYMMDD),
+   snprintf (Dat_Time.Now.Date.YYYYMMDD,sizeof (Dat_Time.Now.Date.YYYYMMDD),
 	     "%04u%02u%02u",
-             Gbl.Now.Date.Year,Gbl.Now.Date.Month,Gbl.Now.Date.Day);
+             Dat_Time.Now.Date.Year,Dat_Time.Now.Date.Month,Dat_Time.Now.Date.Day);
 
    /***** Initialize current time in format YYYYMMDDHHMMSS *****/
-   snprintf (Gbl.Now.YYYYMMDDHHMMSS,sizeof (Gbl.Now.YYYYMMDDHHMMSS),
+   snprintf (Dat_Time.Now.YYYYMMDDHHMMSS,sizeof (Dat_Time.Now.YYYYMMDDHHMMSS),
 	     "%04u%02u%02u%02u%02u%02u",
-             Gbl.Now.Date.Year,Gbl.Now.Date.Month,Gbl.Now.Date.Day,
+             Dat_Time.Now.Date.Year,Dat_Time.Now.Date.Month ,Dat_Time.Now.Date.Day,
-             Gbl.Now.Time.Hour,Gbl.Now.Time.Minute,Gbl.Now.Time.Second);
+             Dat_Time.Now.Time.Hour,Dat_Time.Now.Time.Minute,Dat_Time.Now.Time.Second);
-
-   /***** Compute what day was yesterday *****/
-   Dat_GetDateBefore (&Gbl.Now.Date,&Gbl.Yesterday);
   }
 
 /*****************************************************************************/
@@ -376,7 +511,7 @@ void Dat_ShowClientLocalTime (void)
    HTM_SCRIPT_Begin (NULL,NULL);
       HTM_TxtF ("secondsSince1970UTC = %ld;\n"
 		"writeLocalClock();\n",
-		(long) Gbl.StartExecutionTimeUTC);
+		(long) Dat_GetStartExecutionTimeUTC ());
    HTM_SCRIPT_End ();
   }
 
@@ -449,6 +584,7 @@ void Dat_PutFormStartEndClientLocalDateTimesWithYesterdayToday (const Dat_SetHMS
    extern const char *Txt_START_END_TIME[Dat_NUM_START_END_TIME];
    extern const char *Txt_Yesterday;
    extern const char *Txt_Today;
+   unsigned CurrentYear = Dat_GetCurrentYear ();
 
    /***** Start date-time *****/
    HTM_TR_Begin (NULL);
@@ -462,7 +598,7 @@ void Dat_PutFormStartEndClientLocalDateTimesWithYesterdayToday (const Dat_SetHMS
 						      "Start",
 						      Gbl.DateRange.TimeUTC[Dat_STR_TIME],
 						      Cfg_LOG_START_YEAR,
-						      Gbl.Now.Date.Year,
+						      CurrentYear,
 						      Dat_FORM_SECONDS_ON,
 						      SetHMS[Dat_STR_TIME],
 						      false);	// Don't submit on change
@@ -489,7 +625,7 @@ void Dat_PutFormStartEndClientLocalDateTimesWithYesterdayToday (const Dat_SetHMS
 						      "End",
 						      Gbl.DateRange.TimeUTC[Dat_END_TIME],
 						      Cfg_LOG_START_YEAR,
-						      Gbl.Now.Date.Year,
+						      CurrentYear,
 						      Dat_FORM_SECONDS_ON,
 						      SetHMS[Dat_END_TIME],
 						      false);	// Don't submit on change
@@ -530,7 +666,7 @@ void Dat_PutFormStartEndClientLocalDateTimes (const time_t TimeUTC[Dat_NUM_START
 							 Id[StartEndTime],
 							 TimeUTC[StartEndTime],
 							 Cfg_LOG_START_YEAR,
-							 Gbl.Now.Date.Year + 1,
+							 Dat_GetCurrentYear () + 1,
 							 FormSeconds,
 							 SetHMS[StartEndTime],	// Set hour, minute and second?
 							 false);			// Don't submit on change
@@ -1017,7 +1153,7 @@ void Dat_GetDateFromForm (const char *ParamNameDay,const char *ParamNameMonth,co
 void Dat_SetIniEndDates (void)
   {
    Gbl.DateRange.TimeUTC[Dat_STR_TIME] = (time_t) 0;
-   Gbl.DateRange.TimeUTC[Dat_END_TIME] = Gbl.StartExecutionTimeUTC;
+   Gbl.DateRange.TimeUTC[Dat_END_TIME] = Dat_GetStartExecutionTimeUTC ();
   }
 
 /*****************************************************************************/
@@ -1071,7 +1207,7 @@ void Dat_GetIniEndDatesFromForm (void)
    /***** Get end date *****/
    Gbl.DateRange.TimeUTC[Dat_END_TIME] = Dat_GetTimeUTCFromForm ("EndTimeUTC");
    if (Gbl.DateRange.TimeUTC[Dat_END_TIME] == 0)	// Gbl.DateRange.TimeUTC[Dat_END_TIME] == 0 ==> end date not specified
-      Gbl.DateRange.TimeUTC[Dat_END_TIME] = Gbl.StartExecutionTimeUTC;
+      Gbl.DateRange.TimeUTC[Dat_END_TIME] = Dat_GetStartExecutionTimeUTC ();
 
    /* Convert current time UTC to a local date */
    tm_ptr = Dat_GetLocalTimeFromClock (&Gbl.DateRange.TimeUTC[Dat_END_TIME]);

swad_date.h

@@ -126,6 +126,20 @@ typedef enum
 /***************************** Public prototypes *****************************/
 /*****************************************************************************/
 
+void Dat_SetStartExecutionTimeval (void);
+void Dat_SetStartExecutionTimeUTC (void);
+time_t Dat_GetStartExecutionTimeUTC (void);
+struct Dat_Date *Dat_GetCurrentDate (void);
+unsigned Dat_GetCurrentDay (void);
+unsigned Dat_GetCurrentMonth (void);
+unsigned Dat_GetCurrentYear (void);
+long Dat_GetTimeGenerationInMicroseconds (void);
+long Dat_GetTimeSendInMicroseconds (void);
+void Dat_ComputeTimeToGeneratePage (void);
+void Dat_ComputeTimeToSendPage (void);
+void Dat_WriteTimeToGenerateAndSendPage (void);
+void Dat_WriteTime (char Str[Dat_MAX_BYTES_TIME],long TimeInMicroseconds);
+
 void Dat_ResetDate (struct Dat_Date *Date);
 void Dat_ResetHour (struct Dat_Hour *Hour);
 
@@ -137,7 +151,6 @@ void Dat_PutScriptDateFormat (Dat_Format_t Format);
 void Dat_ChangeDateFormat (void);
 Dat_Format_t Dat_GetDateFormatFromStr (const char *Str);
 
-void Dat_GetStartExecutionTimeUTC (void);
 void Dat_GetAndConvertCurrentDateTime (void);
 
 time_t Dat_GetUNIXTimeFromStr (const char *Str);

swad_error.c

@@ -575,12 +575,12 @@ void Err_ShowErrorAndExit (const char *Txt)
    /***** Page is generated (except </body> and </html>).
           Compute time to generate page *****/
    if (!Gbl.Action.IsAJAXAutoRefresh)
-      Gbl.TimeGenerationInMicroseconds = (long) Sta_ComputeTimeToGeneratePage ();
+      Dat_ComputeTimeToGeneratePage ();
 
    if (Gbl.WebService.IsWebService)		// Serving a plugin request
      {
       /***** Log access *****/
-      Gbl.TimeSendInMicroseconds = 0L;
+      // Gbl.TimeSendInMicroseconds = 0L;
       Log_LogAccess (Txt);
      }
    else
@@ -595,7 +595,7 @@ void Err_ShowErrorAndExit (const char *Txt)
       if (!Gbl.Action.IsAJAXAutoRefresh)
 	{
 	 /***** Compute time to send page *****/
-	 Sta_ComputeTimeToSendPage ();
+	 Dat_ComputeTimeToSendPage ();
 
 	 /***** Log access *****/
 	 Log_LogAccess (Txt);

swad_exam_session.c

@@ -180,8 +180,8 @@ void ExaSes_ListSessions (struct Exa_Exams *Exams,
 	    /* Reset session */
 	    ExaSes_ResetSession (Session);
 	    Session->ExaCod = Exams->Exam.ExaCod;
-	    Session->TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;			// Now
+	    Session->TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();			// Now
-	    Session->TimeUTC[Dat_END_TIME] = Gbl.StartExecutionTimeUTC + (1 * 60 * 60);	// Now + 1 hour
+	    Session->TimeUTC[Dat_END_TIME] = Session->TimeUTC[Dat_STR_TIME] + (1 * 60 * 60);	// Now + 1 hour
             Str_Copy (Session->Title,Exams->Exam.Title,sizeof (Session->Title) - 1);
 
 	    /* Put form to create new session */
@@ -406,8 +406,8 @@ static bool ExaSes_CheckIfICanEditThisSession (long UsrCod)
 
 static bool ExaSes_CheckIfVisibilityOfResultsCanBeChanged (const struct ExaSes_Session *Session)
   {
-   if (Session->ShowUsrResults ||					// Results are currently visible
+   if (Session->ShowUsrResults ||						// Results are currently visible
-       Session->TimeUTC[Dat_END_TIME] < Gbl.StartExecutionTimeUTC)	// End of time is in the past
+       Session->TimeUTC[Dat_END_TIME] < Dat_GetStartExecutionTimeUTC ())	// End of time is in the past
       if (ExaSes_CheckIfICanEditThisSession (Session->UsrCod))
 	 return true;
 
@@ -1228,7 +1228,7 @@ void ExaSes_ReceiveFormSession (void)
       ExaSes_CreateSession (&Session);
    else
      {
-      if (Session.TimeUTC[Dat_END_TIME] >= Gbl.StartExecutionTimeUTC)	// End of time is in the future
+      if (Session.TimeUTC[Dat_END_TIME] >= Dat_GetStartExecutionTimeUTC ())	// End of time is in the future
          Session.ShowUsrResults = false;	// Force results to be hidden
       ExaSes_UpdateSession (&Session);
      }

swad_file.c

@@ -57,6 +57,11 @@ extern struct Globals Gbl;
 
 #define NUM_BYTES_PER_CHUNK 4096
 
+static struct
+  {
+   char FileName[PATH_MAX + 1];
+  } Fil_HTMLOutput;
+
 /*****************************************************************************/
 /******** Create HTML output file for the web page sent by this CGI **********/
 /*****************************************************************************/
@@ -67,11 +72,11 @@ void Fil_CreateFileForHTMLOutput (void)
    Fil_CreateDirIfNotExists (Cfg_PATH_OUT_PRIVATE);
 
    /***** Create a unique name for the file *****/
-   snprintf (Gbl.HTMLOutput.FileName,sizeof (Gbl.HTMLOutput.FileName),
+   snprintf (Fil_HTMLOutput.FileName,sizeof (Fil_HTMLOutput.FileName),
              "%s/%s.html",Cfg_PATH_OUT_PRIVATE,Gbl.UniqueNameEncrypted);
 
    /***** Open file for writing and reading *****/
-   if ((Gbl.F.Out = fopen (Gbl.HTMLOutput.FileName,"w+t")) == NULL)
+   if ((Gbl.F.Out = fopen (Fil_HTMLOutput.FileName,"w+t")) == NULL)
      {
       Gbl.F.Out = stdout;
       Err_ShowErrorAndExit ("Can not create output file.");
@@ -87,7 +92,7 @@ void Fil_CloseAndRemoveFileForHTMLOutput (void)
    if (Gbl.F.Out)
      {
       fclose (Gbl.F.Out);
-      unlink (Gbl.HTMLOutput.FileName);
+      unlink (Fil_HTMLOutput.FileName);
      }
    Gbl.F.Out = stdout;
   }
@@ -116,7 +121,7 @@ bool Fil_ReadStdinIntoTmpFile (void)
       if (TmpFileSize < Fil_MAX_FILE_SIZE)
         {
          if (!(TmpFileSize % (64ULL * 1024ULL)))	// Check timeout from time to time
-            if (time (NULL) - Gbl.StartExecutionTimeUTC >= Cfg_TIME_TO_ABORT_FILE_UPLOAD)
+            if (time (NULL) - Dat_GetStartExecutionTimeUTC () >= Cfg_TIME_TO_ABORT_FILE_UPLOAD)
                TimeExceeded = true;
          fputc (fgetc (stdin),Gbl.F.Tmp);
         }
@@ -502,14 +507,14 @@ void Fil_RemoveOldTmpFiles (const char *Path,time_t TimeToRemove,
 
 	    if (RemoveDirectory)
 	       /* Remove the directory itself */
-	       if (FileStatus.st_mtime < Gbl.StartExecutionTimeUTC - TimeToRemove)
+	       if (FileStatus.st_mtime < Dat_GetStartExecutionTimeUTC () - TimeToRemove)
 		  rmdir (Path);
 	   }
 	 else
 	    Err_ShowErrorAndExit ("Error while scanning directory.");
 	}
       else					// Not a directory
-	 if (FileStatus.st_mtime < Gbl.StartExecutionTimeUTC - TimeToRemove)
+	 if (FileStatus.st_mtime < Dat_GetStartExecutionTimeUTC () - TimeToRemove)
 	    unlink (Path);
      }
   }

swad_global.c

@@ -79,20 +79,19 @@ void Gbl_InitializeGlobals (void)
    if (!setlocale (LC_ALL,"es_ES.utf8"))   // TODO: this should be internationalized!!!!!!!
       exit (1);
 
-   gettimeofday (&Gbl.tvStart, &Gbl.tz);
+   Dat_SetStartExecutionTimeval ();
-   Dat_GetStartExecutionTimeUTC ();
+   Dat_SetStartExecutionTimeUTC ();
    Dat_GetAndConvertCurrentDateTime ();
 
    Gbl.Config.DatabasePassword[0] = '\0';
    Gbl.Config.SMTPPassword[0] = '\0';
 
-   Gbl.TimeGenerationInMicroseconds = Gbl.TimeSendInMicroseconds = 0L;
    Gbl.PID = getpid ();
    Sta_GetRemoteAddr ();
 
    Cry_CreateUniqueNameEncrypted (Gbl.UniqueNameEncrypted);
 
-   srand ((unsigned int) Gbl.StartExecutionTimeUTC);	// Initialize seed for rand()
+   srand ((unsigned int) Dat_GetStartExecutionTimeUTC ());	// Initialize seed for rand()
 
    Gbl.WebService.IsWebService = false;
 

swad_global.h

@@ -72,6 +72,7 @@ struct Globals
       char DatabasePassword[Cfg_MAX_BYTES_DATABASE_PASSWORD + 1];
       char SMTPPassword[Cfg_MAX_BYTES_SMTP_PASSWORD + 1];
      } Config;
+
    struct Files F;
    pid_t PID;	// PID of current process
 
@@ -83,13 +84,12 @@ struct Globals
       bool HTMLEndWritten;	// Used to avoid writing more than once the HTML end
      } Layout;
 
-   /* To compute execution time of the program */
+   struct
-   struct timeval tvStart;
+     {
-   struct timeval tvPageCreated;
+      struct Dat_DateTime DateIni;	// TODO: Remove in future versions
-   struct timeval tvPageSent;
+      struct Dat_DateTime DateEnd;	// TODO: Remove in future versions
-   struct timezone tz;
+      time_t TimeUTC[Dat_NUM_START_END_TIME];
-   long TimeGenerationInMicroseconds;
+     } DateRange;	// TODO: Move to swad_date.c
-   long TimeSendInMicroseconds;
 
    char IP[Cns_MAX_BYTES_IP + 1];
    char UniqueNameEncrypted[Cry_BYTES_ENCRYPTED_STR_SHA256_BASE64 + 1];	// Used for session id, temporary directory names, etc.
@@ -125,14 +125,6 @@ struct Globals
       bool IsAJAXAutoRefresh;	// It's an automatic refresh drom time to time
      } Action;
 
-   time_t StartExecutionTimeUTC;
-   struct Dat_DateTime Now;
-   struct Dat_Date Yesterday;
-
-   struct
-     {
-      char FileName[PATH_MAX + 1];
-     } HTMLOutput;
    struct
      {
       HieLvl_Level_t Level;	// Current level in the hierarchy: system, country, institution, center, degree or course
@@ -382,12 +374,6 @@ struct Globals
          char TmpDir[NAME_MAX + 1];
         } ZIP;
      } FileBrowser;	// Struct used for a file browser
-   struct
-     {
-      struct Dat_DateTime DateIni;	// TODO: Remove in future versions
-      struct Dat_DateTime DateEnd;	// TODO: Remove in future versions
-      time_t TimeUTC[Dat_NUM_START_END_TIME];
-     } DateRange;
 
    /* Cache */
    struct

swad_group.c

@@ -1227,6 +1227,7 @@ static void Grp_ListGroupTypesForEdition (void)
    extern const char *Txt_The_groups_will_automatically_open;
    extern const char *Txt_The_groups_will_not_automatically_open;
    unsigned NumGrpTyp;
+   unsigned CurrentYear = Dat_GetCurrentYear ();
    unsigned UniqueId;
    char Id[32];
 
@@ -1320,8 +1321,8 @@ static void Grp_ListGroupTypesForEdition (void)
 			   Dat_WriteFormClientLocalDateTimeFromTimeUTC (Id,
 									"Open",
 									Gbl.Crs.Grps.GrpTypes.LstGrpTypes[NumGrpTyp].OpenTimeUTC,
-									Gbl.Now.Date.Year,
+									CurrentYear,
-									Gbl.Now.Date.Year + 1,
+									CurrentYear + 1,
 									Dat_FORM_SECONDS_ON,
 									Dat_HMS_DO_NOT_SET,	// Don't set hour, minute and second
 									true);			// Submit on change
@@ -2405,6 +2406,7 @@ static void Grp_PutFormToCreateGroupType (void)
    extern const char *Txt_The_groups_will_automatically_open;
    extern const char *Txt_The_groups_will_not_automatically_open;
    extern const char *Txt_Create_type_of_group;
+   unsigned CurrentYear = Dat_GetCurrentYear ();
 
    /***** Begin section *****/
    HTM_SECTION_Begin (Grp_NEW_GROUP_TYPE_SECTION_ID);
@@ -2483,8 +2485,8 @@ static void Grp_PutFormToCreateGroupType (void)
 			   Dat_WriteFormClientLocalDateTimeFromTimeUTC ("open_time",
 									"Open",
 									Gbl.Crs.Grps.GrpTyp.OpenTimeUTC,
-									Gbl.Now.Date.Year,
+									CurrentYear,
-									Gbl.Now.Date.Year + 1,
+									CurrentYear + 1,
 									Dat_FORM_SECONDS_ON,
 									Dat_HMS_DO_NOT_SET,	// Don't set hour, minute and second
 									false);			// Don't submit on change
@@ -3277,7 +3279,7 @@ static bool Grp_CheckIfOpenTimeInTheFuture (time_t OpenTimeUTC)
       return false;
 
    /***** Is open time in the future? *****/
-   return (OpenTimeUTC > Gbl.StartExecutionTimeUTC);
+   return (OpenTimeUTC > Dat_GetStartExecutionTimeUTC ());
   }
 
 /*****************************************************************************/

swad_holiday.c

@@ -511,6 +511,7 @@ static void Hld_ListHolidaysForEdition (const struct Hld_Holidays *Holidays,
    struct Hld_Holiday *Hld;
    Hld_HolidayType_t HolidayType;
    unsigned HolidayTypeUnsigned;
+   unsigned CurrentYear = Dat_GetCurrentYear ();
 
    /***** Begin box and table *****/
    Box_BoxTableBegin (NULL,Txt_Holidays,
@@ -584,8 +585,8 @@ static void Hld_ListHolidaysForEdition (const struct Hld_Holidays *Holidays,
 	    HTM_TD_Begin ("class=\"CM\"");
 	       Frm_BeginForm (ActChgHldStrDat);
 		  Hld_PutParamHldCod (&Hld->HldCod);
-		  Dat_WriteFormDate (Gbl.Now.Date.Year - 1,
+		  Dat_WriteFormDate (CurrentYear - 1,
-				     Gbl.Now.Date.Year + 1,
+				     CurrentYear + 1,
 				     "Start",
 				     &(Holidays->Lst[NumHld].StartDate),
 				     true,false);
@@ -596,8 +597,8 @@ static void Hld_ListHolidaysForEdition (const struct Hld_Holidays *Holidays,
 	    HTM_TD_Begin ("class=\"CM\"");
 	       Frm_BeginForm (ActChgHldEndDat);
 		  Hld_PutParamHldCod (&Hld->HldCod);
-		  Dat_WriteFormDate (Gbl.Now.Date.Year - 1,
+		  Dat_WriteFormDate (CurrentYear - 1,
-				     Gbl.Now.Date.Year + 1,
+				     CurrentYear + 1,
 				     "End",
 				     &(Holidays->Lst[NumHld].EndDate),
 				     true,(Hld->HldTyp == Hld_HOLIDAY));
@@ -788,7 +789,7 @@ static void Hld_ChangeDate (Hld_StartOrEndDate_t StartOrEndDate)
          if (NewDate.Day   == 0 ||
              NewDate.Month == 0 ||
              NewDate.Year  == 0)
-            Dat_AssignDate (&NewDate,&Gbl.Now.Date);
+            Dat_AssignDate (&NewDate,Dat_GetCurrentDate ());
          break;
       case Hld_END_DATE:
          StrStartOrEndDate = "EndDate";
@@ -804,7 +805,7 @@ static void Hld_ChangeDate (Hld_StartOrEndDate_t StartOrEndDate)
                if (NewDate.Day   == 0 ||
         	   NewDate.Month == 0 ||
         	   NewDate.Year  == 0)
-        	  Dat_AssignDate (&NewDate,&Gbl.Now.Date);
+        	  Dat_AssignDate (&NewDate,Dat_GetCurrentDate ());
                break;
            }
          break;
@@ -905,6 +906,7 @@ static void Hld_PutFormToCreateHoliday (const struct Plc_Places *Places)
    unsigned NumPlc;
    Hld_HolidayType_t HolidayType;
    unsigned HolidayTypeUnsigned;
+   unsigned CurrentYear = Dat_GetCurrentYear ();
 
    /***** Begin form *****/
    Frm_BeginForm (ActNewHld);
@@ -961,8 +963,8 @@ static void Hld_PutFormToCreateHoliday (const struct Plc_Places *Places)
 
 	    /***** Holiday date / Non school period start date *****/
 	    HTM_TD_Begin ("class=\"CM\"");
-	       Dat_WriteFormDate (Gbl.Now.Date.Year - 1,
+	       Dat_WriteFormDate (CurrentYear - 1,
-				  Gbl.Now.Date.Year + 1,
+				  CurrentYear + 1,
 				  "Start",
 				  &Hld_EditingHld->StartDate,
 				  false,false);
@@ -970,8 +972,8 @@ static void Hld_PutFormToCreateHoliday (const struct Plc_Places *Places)
 
 	    /***** Non school period end date *****/
 	    HTM_TD_Begin ("class=\"CM\"");
-	       Dat_WriteFormDate (Gbl.Now.Date.Year - 1,
+	       Dat_WriteFormDate (CurrentYear - 1,
-				  Gbl.Now.Date.Year + 1,
+				  CurrentYear + 1,
 				  "End",
 				  &Hld_EditingHld->EndDate,
 				  false,false);
@@ -1046,7 +1048,7 @@ void Hld_ReceiveFormNewHoliday (void)
    if (Hld_EditingHld->StartDate.Day   == 0 ||
        Hld_EditingHld->StartDate.Month == 0 ||
        Hld_EditingHld->StartDate.Year  == 0)
-      Dat_AssignDate (&Hld_EditingHld->StartDate,&Gbl.Now.Date);
+      Dat_AssignDate (&Hld_EditingHld->StartDate,Dat_GetCurrentDate ());
 
    /***** Set end date *****/
    switch (Hld_EditingHld->HldTyp)
@@ -1064,7 +1066,7 @@ void Hld_ReceiveFormNewHoliday (void)
 	 if (Hld_EditingHld->EndDate.Day   == 0 ||
              Hld_EditingHld->EndDate.Month == 0 ||
              Hld_EditingHld->EndDate.Year  == 0)
-            Dat_AssignDate (&Hld_EditingHld->EndDate,&Gbl.Now.Date);
+            Dat_AssignDate (&Hld_EditingHld->EndDate,Dat_GetCurrentDate ());
          break;
      }
 
@@ -1107,9 +1109,9 @@ static void Hld_EditingHolidayConstructor (void)
    Hld_EditingHld->PlcCod = -1L;
    Hld_EditingHld->PlaceFullName[0] = '\0';
    Hld_EditingHld->HldTyp = Hld_HOLIDAY;
-   Hld_EditingHld->StartDate.Year  = Hld_EditingHld->EndDate.Year  = Gbl.Now.Date.Year;
+   Hld_EditingHld->StartDate.Year  = Hld_EditingHld->EndDate.Year  = Dat_GetCurrentYear ();
-   Hld_EditingHld->StartDate.Month = Hld_EditingHld->EndDate.Month = Gbl.Now.Date.Month;
+   Hld_EditingHld->StartDate.Month = Hld_EditingHld->EndDate.Month = Dat_GetCurrentMonth ();
-   Hld_EditingHld->StartDate.Day   = Hld_EditingHld->EndDate.Day   = Gbl.Now.Date.Day;
+   Hld_EditingHld->StartDate.Day   = Hld_EditingHld->EndDate.Day   = Dat_GetCurrentDay ();
    Hld_EditingHld->Name[0] = '\0';
   }
 

swad_layout.c

@@ -1346,7 +1346,7 @@ void Lay_WriteAboutZone (void)
 	    HTM_NBSP ();
 
 	 /* Time to generate and send page */
-	 Sta_WriteTimeToGenerateAndSendPage ();
+	 Dat_WriteTimeToGenerateAndSendPage ();
 
       HTM_DIV_End ();
 

swad_log_database.c

@@ -60,8 +60,8 @@ long Log_DB_LogAccessInHistoricalLog (long ActCod,Rol_Role_t RoleToStore)
 				Gbl.Hierarchy.Crs.CrsCod,
 				Gbl.Usrs.Me.UsrDat.UsrCod,
 				(unsigned) RoleToStore,
-				Gbl.TimeGenerationInMicroseconds,
+				Dat_GetTimeGenerationInMicroseconds (),
-				Gbl.TimeSendInMicroseconds,
+				Dat_GetTimeSendInMicroseconds (),
 				Gbl.IP);
   }
 
@@ -89,8 +89,8 @@ void Log_DB_LogAccessInRecentLog (long LogCod,long ActCod,Rol_Role_t RoleToStore
 		   Gbl.Hierarchy.Crs.CrsCod,
 		   Gbl.Usrs.Me.UsrDat.UsrCod,
 		   (unsigned) RoleToStore,
-		   Gbl.TimeGenerationInMicroseconds,
+		   Dat_GetTimeGenerationInMicroseconds (),
-		   Gbl.TimeSendInMicroseconds,
+		   Dat_GetTimeSendInMicroseconds (),
 		   Gbl.IP);
    }
 

swad_photo.c

@@ -1415,7 +1415,7 @@ void Pho_CalcPhotoDegree (void)
      {
       /***** Prevent the computing of an average photo too recently updated *****/
       if (Pho_GetTimeAvgPhotoWasComputed (DegCod) >=
-	  Gbl.StartExecutionTimeUTC - Cfg_MIN_TIME_TO_RECOMPUTE_AVG_PHOTO)
+	  Dat_GetStartExecutionTimeUTC () - Cfg_MIN_TIME_TO_RECOMPUTE_AVG_PHOTO)
 	 Err_ShowErrorAndExit ("Average photo has been computed recently.");
 
       /***** Get list of students in this degree *****/
@@ -1513,7 +1513,7 @@ static long Pho_GetTimeToComputeAvgPhoto (long DegCod)
    /***** Get time to compute average photo from database *****/
    if (Pho_DB_GetTimeToComputeAvgPhoto (&mysql_res,DegCod) == Usr_NUM_SEXS)
      {
-      TotalTimeToComputeAvgPhoto = 0;
+      TotalTimeToComputeAvgPhoto = 0L;
       for (Sex  = (Usr_Sex_t) 0;
 	   Sex <= (Usr_Sex_t) (Usr_NUM_SEXS - 1);
 	   Sex++)
@@ -2014,7 +2014,7 @@ static void Pho_PutLinkToCalculateDegreeStats (const struct Pho_DegPhotos *DegPh
 		     Str_Copy (StrEstimatedTimeToComputeAvgPhoto,Txt_unknown_TIME,
 			       sizeof (StrEstimatedTimeToComputeAvgPhoto) - 1);
 		  else
-		     Sta_WriteTime (StrEstimatedTimeToComputeAvgPhoto,
+		     Dat_WriteTime (StrEstimatedTimeToComputeAvgPhoto,
 				    EstimatedTimeToComputeAvgPhotoInMicroseconds);
 
 		  Selected = (Degs.Lst[NumDeg].DegCod == Deg.DegCod);
@@ -2023,7 +2023,7 @@ static void Pho_PutLinkToCalculateDegreeStats (const struct Pho_DegPhotos *DegPh
 		  else
 		     // Too recently computed ?
 		     Disabled = Pho_GetTimeAvgPhotoWasComputed (Degs.Lst[NumDeg].DegCod) >=
-				Gbl.StartExecutionTimeUTC - Cfg_MIN_TIME_TO_RECOMPUTE_AVG_PHOTO;
+				Dat_GetStartExecutionTimeUTC () - Cfg_MIN_TIME_TO_RECOMPUTE_AVG_PHOTO;
 		  HTM_OPTION (HTM_Type_LONG,&Degs.Lst[NumDeg].DegCod,Selected,Disabled,
 			      "%s (%s: %s)",
 			      Degs.Lst[NumDeg].ShrtName,

swad_program.c

@@ -1967,8 +1967,8 @@ static void Prg_ShowFormToCreateItem (long ParentItmCod)
 
    /***** Initialize to empty program item *****/
    Prg_ResetItem (&Item);
-   Item.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+   Item.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
-   Item.TimeUTC[Dat_END_TIME] = Gbl.StartExecutionTimeUTC + (2 * 60 * 60);	// +2 hours
+   Item.TimeUTC[Dat_END_TIME] = Item.TimeUTC[Dat_STR_TIME] + (2 * 60 * 60);	// +2 hours
    Item.Open = true;
 
    /***** Show pending alerts */
@@ -2122,7 +2122,7 @@ void Prg_ReceiveFormChgItem (void)
 
    /***** Adjust dates *****/
    if (Item.TimeUTC[Dat_STR_TIME] == 0)
-      Item.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      Item.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
    if (Item.TimeUTC[Dat_END_TIME] == 0)
       Item.TimeUTC[Dat_END_TIME] = Item.TimeUTC[Dat_STR_TIME] + 2 * 60 * 60;	// +2 hours
 
@@ -2169,7 +2169,7 @@ void Prg_ReceiveFormNewItem (void)
 
    /***** Adjust dates *****/
    if (NewItem.TimeUTC[Dat_STR_TIME] == 0)
-      NewItem.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      NewItem.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
    if (NewItem.TimeUTC[Dat_END_TIME] == 0)
       NewItem.TimeUTC[Dat_END_TIME] = NewItem.TimeUTC[Dat_STR_TIME] + 2 * 60 * 60;	// +2 hours
 

swad_project.c

@@ -3654,8 +3654,8 @@ static void Prj_RequestCreatOrEditPrj (struct Prj_Projects *Projects)
      {
       /* Initialize to empty project */
       Prj_ResetProject (&Projects->Prj);
-      Projects->Prj.CreatTime = Gbl.StartExecutionTimeUTC;
+      Projects->Prj.CreatTime =
-      Projects->Prj.ModifTime = Gbl.StartExecutionTimeUTC;
+      Projects->Prj.ModifTime = Dat_GetStartExecutionTimeUTC ();
       Projects->Prj.DptCod = Gbl.Usrs.Me.UsrDat.Tch.DptCod;	// Default: my department
      }
    else
@@ -4083,7 +4083,7 @@ static void Prj_CreateProject (struct Prj_Project *Prj)
   {
    /***** Set dates to now *****/
    Prj->CreatTime =
-   Prj->ModifTime = Gbl.StartExecutionTimeUTC;
+   Prj->ModifTime = Dat_GetStartExecutionTimeUTC ();
 
    /***** Create a new project *****/
    Prj->PrjCod = Prj_DB_CreateProject (Prj);
@@ -4102,7 +4102,7 @@ static void Prj_CreateProject (struct Prj_Project *Prj)
 static void Prj_UpdateProject (struct Prj_Project *Prj)
   {
    /***** Adjust date of last edition to now *****/
-   Prj->ModifTime = Gbl.StartExecutionTimeUTC;
+   Prj->ModifTime = Dat_GetStartExecutionTimeUTC ();
 
    /***** Update the data of the project *****/
    Prj_DB_UpdateProject (Prj);

swad_record.c

@@ -3195,6 +3195,7 @@ static void Rec_ShowCountry (struct Usr_Data *UsrDat,bool PutForm)
 static void Rec_ShowDateOfBirth (struct Usr_Data *UsrDat,bool ShowData,bool PutForm)
   {
    extern const char *Txt_Date_of_birth;
+   unsigned CurrentYear = Dat_GetCurrentYear ();
 
    /***** Date of birth *****/
    HTM_TR_Begin (NULL);
@@ -3210,8 +3211,8 @@ static void Rec_ShowDateOfBirth (struct Usr_Data *UsrDat,bool ShowData,bool PutF
 	 if (ShowData)
 	   {
 	    if (PutForm)
-	       Dat_WriteFormDate (Gbl.Now.Date.Year - Rec_USR_MAX_AGE,
+	       Dat_WriteFormDate (CurrentYear - Rec_USR_MAX_AGE,
-				  Gbl.Now.Date.Year - Rec_USR_MIN_AGE,
+				  CurrentYear - Rec_USR_MIN_AGE,
 				  "Birth",
 				  &(UsrDat->Birthday),
 				  false,false);

swad_report.c

@@ -1105,7 +1105,7 @@ static void Rep_ShowMyHitsPerYear (bool AnyCourse,long CrsCod,Rol_Role_t Role,
    FirstYear = 1900 + Report->tm_FirstClickTime.tm_year;
 
    /***** Initialize LastYear *****/
-   LastYear = Gbl.Now.Date.Year;
+   LastYear = Dat_GetCurrentYear ();
 
    /***** Set maximum number of hits per year *****/
    if (Report->MaxHitsPerYear)

swad_statistic.c

@@ -725,8 +725,8 @@ static void Sta_WriteSelectorAction (const struct Sta_Stats *Stats)
 
 void Sta_SetIniEndDates (void)
   {
-   Gbl.DateRange.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC - ((Cfg_DAYS_IN_RECENT_LOG - 1) * 24 * 60 * 60);
+   Gbl.DateRange.TimeUTC[Dat_END_TIME] = Dat_GetStartExecutionTimeUTC ();
-   Gbl.DateRange.TimeUTC[Dat_END_TIME] = Gbl.StartExecutionTimeUTC;
+   Gbl.DateRange.TimeUTC[Dat_STR_TIME] = Gbl.DateRange.TimeUTC[Dat_END_TIME] - ((Cfg_DAYS_IN_RECENT_LOG - 1) * 24 * 60 * 60);
   }
 
 /*****************************************************************************/
@@ -783,7 +783,7 @@ static void Sta_ShowHits (Sta_GlobalOrCourseAccesses_t GlobalOrCourse)
    /* If initial day is older than current day minus Cfg_DAYS_IN_RECENT_LOG,
       then use recent log table, else use historic log table */
    LogTable = (Dat_GetNumDaysBetweenDates (&Gbl.DateRange.DateIni.Date,
-                                           &Gbl.Now.Date)
+                                           Dat_GetCurrentDate ())
 	       <= Cfg_DAYS_IN_RECENT_LOG) ? "log_recent" :
 	                                    "log";
 
@@ -3434,75 +3434,3 @@ static void Sta_DrawBarNumHits (char Color,
 
    HTM_TD_End ();
   }
-
-/*****************************************************************************/
-/**************** Compute the time used to generate the page *****************/
-/*****************************************************************************/
-
-time_t Sta_ComputeTimeToGeneratePage (void)
-  {
-   if (gettimeofday (&Gbl.tvPageCreated, &Gbl.tz))
-      // Error in gettimeofday
-      return (time_t) 0;
-
-   return (time_t) ((Gbl.tvPageCreated.tv_sec  - Gbl.tvStart.tv_sec) * 1000000L +
-                     Gbl.tvPageCreated.tv_usec - Gbl.tvStart.tv_usec);
-  }
-
-/*****************************************************************************/
-/****************** Compute the time used to send the page *******************/
-/*****************************************************************************/
-
-void Sta_ComputeTimeToSendPage (void)
-  {
-   if (gettimeofday (&Gbl.tvPageSent, &Gbl.tz))
-      // Error in gettimeofday
-      Gbl.TimeSendInMicroseconds = 0;
-   else
-     {
-      if (Gbl.tvPageSent.tv_usec < Gbl.tvPageCreated.tv_usec)
-	{
-	 Gbl.tvPageSent.tv_sec--;
-	 Gbl.tvPageSent.tv_usec += 1000000;
-	}
-      Gbl.TimeSendInMicroseconds = (Gbl.tvPageSent.tv_sec  - Gbl.tvPageCreated.tv_sec) * 1000000L +
-                                    Gbl.tvPageSent.tv_usec - Gbl.tvPageCreated.tv_usec;
-     }
-  }
-
-/*****************************************************************************/
-/************** Write the time to generate and send the page *****************/
-/*****************************************************************************/
-
-void Sta_WriteTimeToGenerateAndSendPage (void)
-  {
-   extern const char *Txt_PAGE1_Page_generated_in;
-   extern const char *Txt_PAGE2_and_sent_in;
-   char StrTimeGenerationInMicroseconds[Dat_MAX_BYTES_TIME + 1];
-   char StrTimeSendInMicroseconds[Dat_MAX_BYTES_TIME + 1];
-
-   Sta_WriteTime (StrTimeGenerationInMicroseconds,Gbl.TimeGenerationInMicroseconds);
-   Sta_WriteTime (StrTimeSendInMicroseconds,Gbl.TimeSendInMicroseconds);
-   HTM_TxtF ("%s %s %s %s",
-             Txt_PAGE1_Page_generated_in,StrTimeGenerationInMicroseconds,
-             Txt_PAGE2_and_sent_in,StrTimeSendInMicroseconds);
-  }
-
-/*****************************************************************************/
-/********* Write time (given in microseconds) depending on amount ************/
-/*****************************************************************************/
-
-void Sta_WriteTime (char Str[Dat_MAX_BYTES_TIME],long TimeInMicroseconds)
-  {
-   if (TimeInMicroseconds < 1000L)
-      snprintf (Str,Dat_MAX_BYTES_TIME + 1,"%ld &micro;s",TimeInMicroseconds);
-   else if (TimeInMicroseconds < 1000000L)
-      snprintf (Str,Dat_MAX_BYTES_TIME + 1,"%ld ms",TimeInMicroseconds / 1000);
-   else if (TimeInMicroseconds < (60 * 1000000L))
-      snprintf (Str,Dat_MAX_BYTES_TIME + 1,"%.1f s",
-                (double) TimeInMicroseconds / 1E6);
-   else
-      snprintf (Str,Dat_MAX_BYTES_TIME + 1,"%ld min, %ld s",
-                TimeInMicroseconds / (60 * 1000000L),
-                (TimeInMicroseconds / 1000000L) % 60);
-  }

swad_statistic.h

@@ -167,9 +167,4 @@ void Sta_ComputeMaxAndTotalHits (struct Sta_Hits *Hits,
                                  MYSQL_RES *mysql_res,unsigned Field,
                                  unsigned Divisor);
 
-time_t Sta_ComputeTimeToGeneratePage (void);
-void Sta_ComputeTimeToSendPage (void);
-void Sta_WriteTimeToGenerateAndSendPage (void);
-void Sta_WriteTime (char Str[Dat_MAX_BYTES_TIME],long TimeInMicroseconds);
-
 #endif

swad_survey.c

@@ -1707,8 +1707,8 @@ void Svy_RequestCreatOrEditSvy (void)
       Surveys.Svy.Scope  = HieLvl_UNK;
       Surveys.Svy.Roles  = (1 << Rol_STD);
       Surveys.Svy.UsrCod = Gbl.Usrs.Me.UsrDat.UsrCod;
-      Surveys.Svy.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      Surveys.Svy.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
-      Surveys.Svy.TimeUTC[Dat_END_TIME] = Gbl.StartExecutionTimeUTC + (24 * 60 * 60);	// +24 hours
+      Surveys.Svy.TimeUTC[Dat_END_TIME] = Surveys.Svy.TimeUTC[Dat_STR_TIME] + (24 * 60 * 60);	// +24 hours
       Surveys.Svy.Title[0] = '\0';
       Surveys.Svy.NumQsts = 0;
       Surveys.Svy.NumUsrs = 0;
@@ -2081,7 +2081,7 @@ void Svy_ReceiveFormSurvey (void)
 
    /***** Adjust dates *****/
    if (NewSvy.TimeUTC[Dat_STR_TIME] == 0)
-      NewSvy.TimeUTC[Dat_STR_TIME] = Gbl.StartExecutionTimeUTC;
+      NewSvy.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
    if (NewSvy.TimeUTC[Dat_END_TIME] == 0)
       NewSvy.TimeUTC[Dat_END_TIME] = NewSvy.TimeUTC[Dat_STR_TIME] + 24 * 60 * 60;	// +24 hours
 

swad_user.c

@@ -1207,6 +1207,9 @@ void Usr_WelcomeUsr (void)
    extern const char *Txt_Check;
    extern const char *Txt_Switching_to_LANGUAGE[1 + Lan_NUM_LANGUAGES];
    char URLIconSet[PATH_MAX + 1];
+   unsigned CurrentDay   = Dat_GetCurrentDay ();
+   unsigned CurrentMonth = Dat_GetCurrentMonth ();
+   unsigned CurrentYear  = Dat_GetCurrentYear ();
 
    if (Gbl.Usrs.Me.Logged)
      {
@@ -1215,14 +1218,13 @@ void Usr_WelcomeUsr (void)
          if (Gbl.Usrs.Me.UsrDat.FrstName[0])
            {
 	    /***** New year greeting *****/
-	    if (Gbl.Now.Date.Day   == 1 &&
+	    if (CurrentDay == 1 && CurrentMonth == 1)
-		Gbl.Now.Date.Month == 1)
 	       Ale_ShowAlert (Ale_INFO,Txt_NEW_YEAR_GREETING,
-			      Gbl.Now.Date.Year);
+			      CurrentYear);
 
             /***** Birthday congratulation *****/
-            if (Gbl.Usrs.Me.UsrDat.Birthday.Day   == Gbl.Now.Date.Day &&
+            if (Gbl.Usrs.Me.UsrDat.Birthday.Day   == CurrentDay &&
-                Gbl.Usrs.Me.UsrDat.Birthday.Month == Gbl.Now.Date.Month)
+                Gbl.Usrs.Me.UsrDat.Birthday.Month == CurrentMonth)
                if (Usr_DB_CheckIfMyBirthdayHasNotBeenCongratulated ())
                  {
                   /* Mark my birthday as already congratulated */
@@ -1322,9 +1324,11 @@ void Usr_CreateBirthdayStrDB (const struct Usr_Data *UsrDat,
 
 void Usr_FilterUsrBirthday (struct Dat_Date *Birthday)
   {
+   unsigned CurrentYear = Dat_GetCurrentYear ();
+
    /***** Fix birthday *****/
-   if (Birthday->Year < Gbl.Now.Date.Year-99 ||
+   if (Birthday->Year < CurrentYear - 99 ||
-       Birthday->Year > Gbl.Now.Date.Year-16)
+       Birthday->Year > CurrentYear - 16)
       Birthday->Year  =
       Birthday->Month =
       Birthday->Day   = 0;
@@ -2006,7 +2010,7 @@ static void Usr_SetMyPrefsAndRoles (void)
 	 Gbl.Usrs.Me.Role.Logged = Gbl.Usrs.Me.UsrLast.LastRole;
 
 	 /* Last action is really got only if last access is recent */
-	 if (Gbl.Usrs.Me.UsrLast.LastTime >= Gbl.StartExecutionTimeUTC -
+	 if (Gbl.Usrs.Me.UsrLast.LastTime >= Dat_GetStartExecutionTimeUTC () -
 	                                     Cfg_MAX_TIME_TO_REMEMBER_LAST_ACTION_ON_LOGIN)
 	   {
 	    /* Get action from last data */