Marown/swad-core
Marown
/
swad-core
mirror of https://github.com/acanas/swad-core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

This commit is contained in:
acanas 2022-10-19 01:04:19 +02:00
parent c574a04071
commit bb3ba72121
31 changed files with 301 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
swad_RSS.c
View File

@ -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");

6
swad_agenda.c
View File

@ -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_END_TIME] = Gbl.StartExecutionTimeUTC + (2 * 60 * 60); // +2 hours
AgdEvent.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
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

6
swad_assignment.c
View File

@ -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_END_TIME] = Gbl.StartExecutionTimeUTC + (2 * 60 * 60); // +2 hours
Assignments.Asg.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
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

6
swad_attendance.c
View File

@ -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_END_TIME] = Gbl.StartExecutionTimeUTC + (2 * 60 * 60); // +2 hours
Events.Event.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
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

2
swad_banner_database.c
View File

@ -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);
}

4
swad_browser.c
View File

@ -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 *****/

4
swad_calendar.c
View File

@ -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",

13
swad_call_for_exam.c
View File

@ -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.Month = Gbl.Now.Date.Month;
CallsForExams->CallForExam.ExamDate.Year = Gbl.Now.Date.Year;
CallsForExams->CallForExam.ExamDate.Day = Dat_GetCurrentDay ();
CallsForExams->CallForExam.ExamDate.Month = Dat_GetCurrentMonth ();
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 :
Gbl.Now.Date.Year,
Gbl.Now.Date.Year + 1,"Exam",
Dat_WriteFormDate (CallsForExams->CallForExam.ExamDate.Year < CurrentYear ? CallsForExams->CallForExam.ExamDate.Year :
CurrentYear,
CurrentYear + 1,"Exam",
&(CallsForExams->CallForExam.ExamDate),
false,false);
HTM_TD_End ();

3
swad_changelog.h
View File

@ -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)

2
swad_connected.c
View File

@ -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);

2
swad_cryptography.c
View File

@ -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
}

198
swad_date.c
View File

@ -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;
Gbl.Now.Date.Month = tm_ptr->tm_mon + 1;
Gbl.Now.Date.Day = tm_ptr->tm_mday;
Gbl.Now.Time.Hour = tm_ptr->tm_hour;
Gbl.Now.Time.Minute = tm_ptr->tm_min;
Gbl.Now.Time.Second = tm_ptr->tm_sec;
Dat_Time.Now.Date.Year = tm_ptr->tm_year + 1900;
Dat_Time.Now.Date.Month = tm_ptr->tm_mon + 1;
Dat_Time.Now.Date.Day = tm_ptr->tm_mday;
Dat_Time.Now.Time.Hour = tm_ptr->tm_hour;
Dat_Time.Now.Time.Minute = tm_ptr->tm_min;
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,
Gbl.Now.Time.Hour,Gbl.Now.Time.Minute,Gbl.Now.Time.Second);
/***** Compute what day was yesterday *****/
Dat_GetDateBefore (&Gbl.Now.Date,&Gbl.Yesterday);
Dat_Time.Now.Date.Year,Dat_Time.Now.Date.Month ,Dat_Time.Now.Date.Day,
Dat_Time.Now.Time.Hour,Dat_Time.Now.Time.Minute,Dat_Time.Now.Time.Second);
}
/*****************************************************************************/
@ -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]);

15
swad_date.h
View File

@ -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);

6
swad_error.c
View File

@ -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);

10
swad_exam_session.c
View File

@ -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_END_TIME] = Gbl.StartExecutionTimeUTC + (1 * 60 * 60); // Now + 1 hour
Session->TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC (); // Now
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
Session->TimeUTC[Dat_END_TIME] < Gbl.StartExecutionTimeUTC) // End of time is in the past
if (Session->ShowUsrResults || // Results are currently visible
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);
}

17
swad_file.c
View File

@ -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);
}
}

7
swad_global.c
View File

@ -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_GetStartExecutionTimeUTC ();
Dat_SetStartExecutionTimeval ();
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;

28
swad_global.h
View File

@ -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 timeval tvStart;
struct timeval tvPageCreated;
struct timeval tvPageSent;
struct timezone tz;
long TimeGenerationInMicroseconds;
long TimeSendInMicroseconds;
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; // TODO: Move to swad_date.c
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

12
swad_group.c
View File

@ -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,
Gbl.Now.Date.Year + 1,
CurrentYear,
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,
Gbl.Now.Date.Year + 1,
CurrentYear,
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 ());
}
/*****************************************************************************/

32
swad_holiday.c
View File

@ -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,
Gbl.Now.Date.Year + 1,
Dat_WriteFormDate (CurrentYear - 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,
Gbl.Now.Date.Year + 1,
Dat_WriteFormDate (CurrentYear - 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,
Gbl.Now.Date.Year + 1,
Dat_WriteFormDate (CurrentYear - 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,
Gbl.Now.Date.Year + 1,
Dat_WriteFormDate (CurrentYear - 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.Month = Hld_EditingHld->EndDate.Month = Gbl.Now.Date.Month;
Hld_EditingHld->StartDate.Day = Hld_EditingHld->EndDate.Day = Gbl.Now.Date.Day;
Hld_EditingHld->StartDate.Year = Hld_EditingHld->EndDate.Year = Dat_GetCurrentYear ();
Hld_EditingHld->StartDate.Month = Hld_EditingHld->EndDate.Month = Dat_GetCurrentMonth ();
Hld_EditingHld->StartDate.Day = Hld_EditingHld->EndDate.Day = Dat_GetCurrentDay ();
Hld_EditingHld->Name[0] = '\0';
}

2
swad_layout.c
View File

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

8
swad_log_database.c
View File

@ -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,
Gbl.TimeSendInMicroseconds,
Dat_GetTimeGenerationInMicroseconds (),
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,
Gbl.TimeSendInMicroseconds,
Dat_GetTimeGenerationInMicroseconds (),
Dat_GetTimeSendInMicroseconds (),
Gbl.IP);
}

8
swad_photo.c
View File

@ -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,

8
swad_program.c
View File

@ -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_END_TIME] = Gbl.StartExecutionTimeUTC + (2 * 60 * 60); // +2 hours
Item.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
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

8
swad_project.c
View File

@ -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.ModifTime = Gbl.StartExecutionTimeUTC;
Projects->Prj.CreatTime =
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);

5
swad_record.c
View File

@ -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,
Gbl.Now.Date.Year - Rec_USR_MIN_AGE,
Dat_WriteFormDate (CurrentYear - Rec_USR_MAX_AGE,
CurrentYear - Rec_USR_MIN_AGE,
"Birth",
&(UsrDat->Birthday),
false,false);

2
swad_report.c
View File

@ -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)

78
swad_statistic.c
View File

@ -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] = Gbl.StartExecutionTimeUTC;
Gbl.DateRange.TimeUTC[Dat_END_TIME] = Dat_GetStartExecutionTimeUTC ();
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);
}

5
swad_statistic.h
View File

@ -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

6
swad_survey.c
View File

@ -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_END_TIME] = Gbl.StartExecutionTimeUTC + (24 * 60 * 60); // +24 hours
Surveys.Svy.TimeUTC[Dat_STR_TIME] = Dat_GetStartExecutionTimeUTC ();
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

20
swad_user.c
View File

@ -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 &&
Gbl.Now.Date.Month == 1)
if (CurrentDay == 1 && CurrentMonth == 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 &&
Gbl.Usrs.Me.UsrDat.Birthday.Month == Gbl.Now.Date.Month)
if (Gbl.Usrs.Me.UsrDat.Birthday.Day == CurrentDay &&
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 ||
Birthday->Year > Gbl.Now.Date.Year-16)
if (Birthday->Year < CurrentYear - 99 ||
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 */