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
swad-core/swad_program.c

1702 lines
59 KiB
C
Raw Blame History

// swad_program.c: course program
/*
SWAD (Shared Workspace At a Distance),
is a web platform developed at the University of Granada (Spain),
and used to support university teaching.
This file is part of SWAD core.
Copyright (C) 1999-2020 Antonio Cañas Vargas
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*****************************************************************************/
/********************************* Headers ***********************************/
/*****************************************************************************/
#define _GNU_SOURCE // For asprintf
#include <linux/limits.h> // For PATH_MAX
#include <stddef.h> // For NULL
#include <stdio.h> // For asprintf
#include <stdlib.h> // For calloc
#include <string.h> // For string functions
#include "swad_box.h"
#include "swad_database.h"
#include "swad_figure.h"
#include "swad_form.h"
#include "swad_global.h"
#include "swad_group.h"
#include "swad_HTML.h"
#include "swad_notification.h"
#include "swad_pagination.h"
#include "swad_parameter.h"
#include "swad_photo.h"
#include "swad_program.h"
#include "swad_role.h"
#include "swad_setting.h"
#include "swad_string.h"
/*****************************************************************************/
/************** External global variables from others modules ****************/
/*****************************************************************************/
extern struct Globals Gbl;
/*****************************************************************************/
/***************************** Private constants *****************************/
/*****************************************************************************/
/*****************************************************************************/
/******************************* Private types *******************************/
/*****************************************************************************/
/*****************************************************************************/
/***************************** Private variables *****************************/
/*****************************************************************************/
/*****************************************************************************/
/***************************** Private prototypes ****************************/
/*****************************************************************************/
static void Prg_ShowAllPrgItems (void);
static void Prg_PutHeadForSeeing (bool PrintView);
static bool Prg_CheckIfICanCreatePrgItems (void);
static void Prg_PutIconsListPrgItems (void);
static void Prg_PutIconToCreateNewPrgItem (void);
static void Prg_PutButtonToCreateNewPrgItem (void);
static void Prg_ParamsWhichGroupsToShow (void);
static void Prg_ShowOnePrgItem (long PrgIteCod,bool PrintView);
static void Prg_WritePrgItemAuthor (struct ProgramItem *PrgItem);
static void Prg_GetParamPrgOrder (void);
static void Prg_PutFormsToRemEditOnePrgItem (const struct ProgramItem *PrgItem,
const char *Anchor);
static void Prg_PutParams (void);
static void Prg_GetDataOfPrgItem (struct ProgramItem *PrgItem,
MYSQL_RES **mysql_res,
unsigned long NumRows);
static void Prg_ResetPrgItem (struct ProgramItem *PrgItem);
static void Prg_GetPrgItemTxtFromDB (long PrgIteCod,char Txt[Cns_MAX_BYTES_TEXT + 1]);
static void Prg_PutParamPrgItemCod (long PrgIteCod);
static bool Prg_CheckIfSimilarPrgItemExists (const char *Field,const char *Value,long PrgIteCod);
static void Prg_ShowLstGrpsToEditPrgItem (long PrgIteCod);
static void Prg_CreatePrgItem (struct ProgramItem *PrgItem,const char *Txt);
static void Prg_UpdatePrgItem (struct ProgramItem *PrgItem,const char *Txt);
static bool Prg_CheckIfPrgItemIsAssociatedToGrps (long PrgIteCod);
static void Prg_RemoveAllTheGrpsAssociatedToAPrgItem (long PrgIteCod);
static void Prg_CreateGrps (long PrgIteCod);
static void Prg_GetAndWriteNamesOfGrpsAssociatedToPrgItem (struct ProgramItem *PrgItem);
static bool Prg_CheckIfIBelongToCrsOrGrpsThisPrgItem (long PrgIteCod);
/*****************************************************************************/
/************************ List all the program items *************************/
/*****************************************************************************/
void Prg_SeeCourseProgram (void)
{
/***** Get parameters *****/
Prg_GetParamPrgOrder ();
Grp_GetParamWhichGrps ();
Gbl.Prg.CurrentPage = Pag_GetParamPagNum (Pag_COURSE_PROGRAM);
/***** Show all the program items *****/
Prg_ShowAllPrgItems ();
}
/*****************************************************************************/
/*********************** Show all the program items **************************/
/*****************************************************************************/
static void Prg_ShowAllPrgItems (void)
{
extern const char *Hlp_COURSE_Program;
extern const char *Txt_Course_program;
extern const char *Txt_No_items;
struct Pagination Pagination;
unsigned NumAsg;
/***** Get list of program items *****/
Prg_GetListPrgItems ();
/***** Compute variables related to pagination *****/
Pagination.NumItems = Gbl.Prg.Num;
Pagination.CurrentPage = (int) Gbl.Prg.CurrentPage;
Pag_CalculatePagination (&Pagination);
Gbl.Prg.CurrentPage = (unsigned) Pagination.CurrentPage;
/***** Begin box *****/
Box_BoxBegin ("100%",Txt_Course_program,Prg_PutIconsListPrgItems,
Hlp_COURSE_Program,Box_NOT_CLOSABLE);
/***** Select whether show only my groups or all groups *****/
if (Gbl.Crs.Grps.NumGrps)
{
Set_StartSettingsHead ();
Grp_ShowFormToSelWhichGrps (ActSeePrg,Prg_ParamsWhichGroupsToShow);
Set_EndSettingsHead ();
}
/***** Write links to pages *****/
Pag_WriteLinksToPagesCentered (Pag_COURSE_PROGRAM,
&Pagination,
0);
if (Gbl.Prg.Num)
{
/***** Table head *****/
HTM_TABLE_BeginWideMarginPadding (2);
Prg_PutHeadForSeeing (false); // Not print view
/***** Write all the program items *****/
for (NumAsg = Pagination.FirstItemVisible;
NumAsg <= Pagination.LastItemVisible;
NumAsg++)
Prg_ShowOnePrgItem (Gbl.Prg.LstPrgIteCods[NumAsg - 1],
false); // Not print view
/***** End table *****/
HTM_TABLE_End ();
}
else // No program items created
Ale_ShowAlert (Ale_INFO,Txt_No_items);
/***** Write again links to pages *****/
Pag_WriteLinksToPagesCentered (Pag_COURSE_PROGRAM,
&Pagination,
0);
/***** Button to create a new program item *****/
if (Prg_CheckIfICanCreatePrgItems ())
Prg_PutButtonToCreateNewPrgItem ();
/***** End box *****/
Box_BoxEnd ();
/***** Free list of program items *****/
Prg_FreeListPrgItems ();
}
/*****************************************************************************/
/***************** Write header with fields of a program item ****************/
/*****************************************************************************/
static void Prg_PutHeadForSeeing (bool PrintView)
{
extern const char *Txt_START_END_TIME_HELP[Dat_NUM_START_END_TIME];
extern const char *Txt_START_END_TIME[Dat_NUM_START_END_TIME];
extern const char *Txt_Item;
Dat_StartEndTime_t Order;
HTM_TR_Begin (NULL);
HTM_TH (1,1,"CONTEXT_COL",NULL); // Column for contextual icons
for (Order = Dat_START_TIME;
Order <= Dat_END_TIME;
Order++)
{
HTM_TH_Begin (1,1,"LM");
if (!PrintView)
{
Frm_StartForm (ActSeePrg);
Grp_PutParamWhichGrps ();
Pag_PutHiddenParamPagNum (Pag_COURSE_PROGRAM,Gbl.Prg.CurrentPage);
Par_PutHiddenParamUnsigned (NULL,"Order",(unsigned) Order);
HTM_BUTTON_SUBMIT_Begin (Txt_START_END_TIME_HELP[Order],"BT_LINK TIT_TBL",NULL);
if (Order == Gbl.Prg.SelectedOrder)
HTM_U_Begin ();
}
HTM_Txt (Txt_START_END_TIME[Order]);
if (!PrintView)
{
if (Order == Gbl.Prg.SelectedOrder)
HTM_U_End ();
HTM_BUTTON_End ();
Frm_EndForm ();
}
HTM_TH_End ();
}
HTM_TH (1,1,"LM",Txt_Item);
HTM_TR_End ();
}
/*****************************************************************************/
/******************* Check if I can create program items *********************/
/*****************************************************************************/
static bool Prg_CheckIfICanCreatePrgItems (void)
{
return (bool) (Gbl.Usrs.Me.Role.Logged == Rol_TCH ||
Gbl.Usrs.Me.Role.Logged == Rol_SYS_ADM);
}
/*****************************************************************************/
/************** Put contextual icons in list of program items ****************/
/*****************************************************************************/
static void Prg_PutIconsListPrgItems (void)
{
/***** Put icon to create a new program item *****/
if (Prg_CheckIfICanCreatePrgItems ())
Prg_PutIconToCreateNewPrgItem ();
/***** Put icon to show a figure *****/
Gbl.Figures.FigureType = Fig_COURSE_PROGRAM;
Fig_PutIconToShowFigure ();
}
/*****************************************************************************/
/****************** Put icon to create a new program item ********************/
/*****************************************************************************/
static void Prg_PutIconToCreateNewPrgItem (void)
{
extern const char *Txt_New_item;
/***** Put form to create a new program item *****/
Gbl.Prg.PrgIteCodToEdit = -1L;
Ico_PutContextualIconToAdd (ActFrmNewPrgIte,NULL,Prg_PutParams,
Txt_New_item);
}
/*****************************************************************************/
/***************** Put button to create a new program item *******************/
/*****************************************************************************/
static void Prg_PutButtonToCreateNewPrgItem (void)
{
extern const char *Txt_New_item;
Gbl.Prg.PrgIteCodToEdit = -1L;
Frm_StartForm (ActFrmNewPrgIte);
Prg_PutParams ();
Btn_PutConfirmButton (Txt_New_item);
Frm_EndForm ();
}
/*****************************************************************************/
/**************** Put params to select which groups to show ******************/
/*****************************************************************************/
static void Prg_ParamsWhichGroupsToShow (void)
{
Prg_PutHiddenParamPrgOrder ();
Pag_PutHiddenParamPagNum (Pag_COURSE_PROGRAM,Gbl.Prg.CurrentPage);
}
/*****************************************************************************/
/******************* Show print view of one program item *********************/
/*****************************************************************************/
void Prg_PrintOnePrgItem (void)
{
long PrgIteCod;
/***** Get the code of the program item *****/
PrgIteCod = Prg_GetParamPrgItemCod ();
/***** Write header *****/
Lay_WriteHeaderClassPhoto (true,false,
Gbl.Hierarchy.Ins.InsCod,
Gbl.Hierarchy.Deg.DegCod,
Gbl.Hierarchy.Crs.CrsCod);
/***** Table head *****/
HTM_TABLE_BeginWideMarginPadding (2);
Prg_PutHeadForSeeing (true); // Print view
/***** Write program item *****/
Prg_ShowOnePrgItem (PrgIteCod,
true); // Print view
/***** End table *****/
HTM_TABLE_End ();
}
/*****************************************************************************/
/************************** Show one program item ****************************/
/*****************************************************************************/
static void Prg_ShowOnePrgItem (long PrgIteCod,bool PrintView)
{
char *Anchor = NULL;
static unsigned UniqueId = 0;
char *Id;
struct ProgramItem PrgItem;
Dat_StartEndTime_t StartEndTime;
char Txt[Cns_MAX_BYTES_TEXT + 1];
/***** Get data of this program item *****/
PrgItem.PrgIteCod = PrgIteCod;
Prg_GetDataOfPrgItemByCod (&PrgItem);
/***** Set anchor string *****/
Frm_SetAnchorStr (PrgItem.PrgIteCod,&Anchor);
/***** Write first row of data of this program item *****/
HTM_TR_Begin (NULL);
/* Forms to remove/edit this program item */
if (PrintView)
HTM_TD_Begin ("rowspan=\"2\" class=\"CONTEXT_COL\"");
else
{
HTM_TD_Begin ("rowspan=\"2\" class=\"CONTEXT_COL COLOR%u\"",Gbl.RowEvenOdd);
Prg_PutFormsToRemEditOnePrgItem (&PrgItem,Anchor);
}
HTM_TD_End ();
/* Start/end date/time */
UniqueId++;
for (StartEndTime = (Dat_StartEndTime_t) 0;
StartEndTime <= (Dat_StartEndTime_t) (Dat_NUM_START_END_TIME - 1);
StartEndTime++)
{
if (asprintf (&Id,"scd_date_%u_%u",(unsigned) StartEndTime,UniqueId) < 0)
Lay_NotEnoughMemoryExit ();
if (PrintView)
HTM_TD_Begin ("id=\"%s\" class=\"%s LB\"",
Id,
PrgItem.Hidden ? (PrgItem.Open ? "DATE_GREEN_LIGHT" :
"DATE_RED_LIGHT") :
(PrgItem.Open ? "DATE_GREEN" :
"DATE_RED"));
else
HTM_TD_Begin ("id=\"%s\" class=\"%s LB COLOR%u\"",
Id,
PrgItem.Hidden ? (PrgItem.Open ? "DATE_GREEN_LIGHT" :
"DATE_RED_LIGHT") :
(PrgItem.Open ? "DATE_GREEN" :
"DATE_RED"),
Gbl.RowEvenOdd);
Dat_WriteLocalDateHMSFromUTC (Id,PrgItem.TimeUTC[StartEndTime],
Gbl.Prefs.DateFormat,Dat_SEPARATOR_BREAK,
true,true,true,0x7);
HTM_TD_End ();
free (Id);
}
/* Schedule item title */
if (PrintView)
HTM_TD_Begin ("class=\"%s LT\"",
PrgItem.Hidden ? "ASG_TITLE_LIGHT" :
"ASG_TITLE");
else
HTM_TD_Begin ("class=\"%s LT COLOR%u\"",
PrgItem.Hidden ? "ASG_TITLE_LIGHT" :
"ASG_TITLE",
Gbl.RowEvenOdd);
HTM_ARTICLE_Begin (Anchor);
HTM_Txt (PrgItem.Title);
HTM_ARTICLE_End ();
HTM_TD_End ();
HTM_TR_End ();
/***** Write second row of data of this program item *****/
HTM_TR_Begin (NULL);
/* Author of the program item */
if (PrintView)
HTM_TD_Begin ("colspan=\"2\" class=\"LT\"");
else
HTM_TD_Begin ("colspan=\"2\" class=\"LT COLOR%u\"",Gbl.RowEvenOdd);
Prg_WritePrgItemAuthor (&PrgItem);
HTM_TD_End ();
/* Text of the program item */
Prg_GetPrgItemTxtFromDB (PrgItem.PrgIteCod,Txt);
Str_ChangeFormat (Str_FROM_HTML,Str_TO_RIGOROUS_HTML,
Txt,Cns_MAX_BYTES_TEXT,false); // Convert from HTML to recpectful HTML
Str_InsertLinks (Txt,Cns_MAX_BYTES_TEXT,60); // Insert links
if (PrintView)
HTM_TD_Begin ("colspan=\"2\" class=\"LT\"");
else
HTM_TD_Begin ("colspan=\"2\" class=\"LT COLOR%u\"",Gbl.RowEvenOdd);
if (Gbl.Crs.Grps.NumGrps)
Prg_GetAndWriteNamesOfGrpsAssociatedToPrgItem (&PrgItem);
HTM_DIV_Begin ("class=\"PAR %s\"",PrgItem.Hidden ? "DAT_LIGHT" :
"DAT");
HTM_Txt (Txt);
HTM_DIV_End ();
HTM_TD_End ();
HTM_TR_End ();
/***** Free anchor string *****/
Frm_FreeAnchorStr (Anchor);
Gbl.RowEvenOdd = 1 - Gbl.RowEvenOdd;
/***** Mark possible notification as seen *****/
Ntf_MarkNotifAsSeen (Ntf_EVENT_ASSIGNMENT,
PrgIteCod,Gbl.Hierarchy.Crs.CrsCod,
Gbl.Usrs.Me.UsrDat.UsrCod);
}
/*****************************************************************************/
/********************* Write the author of a program item ********************/
/*****************************************************************************/
static void Prg_WritePrgItemAuthor (struct ProgramItem *PrgItem)
{
Usr_WriteAuthor1Line (PrgItem->UsrCod,PrgItem->Hidden);
}
/*****************************************************************************/
/******* Get parameter with the type or order in list of program items *******/
/*****************************************************************************/
static void Prg_GetParamPrgOrder (void)
{
Gbl.Prg.SelectedOrder = (Dat_StartEndTime_t)
Par_GetParToUnsignedLong ("Order",
0,
Dat_NUM_START_END_TIME - 1,
(unsigned long) Prg_ORDER_DEFAULT);
}
/*****************************************************************************/
/** Put a hidden parameter with the type of order in list of program items ***/
/*****************************************************************************/
void Prg_PutHiddenParamPrgOrder (void)
{
Par_PutHiddenParamUnsigned (NULL,"Order",(unsigned) Gbl.Prg.SelectedOrder);
}
/*****************************************************************************/
/**************** Put a link (form) to edit one program item *****************/
/*****************************************************************************/
static void Prg_PutFormsToRemEditOnePrgItem (const struct ProgramItem *PrgItem,
const char *Anchor)
{
Gbl.Prg.PrgIteCodToEdit = PrgItem->PrgIteCod; // Used as parameter in contextual links
switch (Gbl.Usrs.Me.Role.Logged)
{
case Rol_TCH:
case Rol_SYS_ADM:
/***** Put form to remove program item *****/
Ico_PutContextualIconToRemove (ActReqRemAsg,Prg_PutParams);
/***** Put form to hide/show program item *****/
if (PrgItem->Hidden)
Ico_PutContextualIconToUnhide (ActShoAsg,Anchor,Prg_PutParams);
else
Ico_PutContextualIconToHide (ActHidAsg,Anchor,Prg_PutParams);
/***** Put form to edit program item *****/
Ico_PutContextualIconToEdit (ActEdiOneAsg,Prg_PutParams);
/* falls through */
/* no break */
case Rol_STD:
case Rol_NET:
/***** Put form to print program item *****/
Ico_PutContextualIconToPrint (ActPrnOneAsg,Prg_PutParams);
break;
default:
break;
}
}
/*****************************************************************************/
/******************** Params used to edit a program item *********************/
/*****************************************************************************/
static void Prg_PutParams (void)
{
if (Gbl.Prg.PrgIteCodToEdit > 0)
Prg_PutParamPrgItemCod (Gbl.Prg.PrgIteCodToEdit);
Prg_PutHiddenParamPrgOrder ();
Grp_PutParamWhichGrps ();
Pag_PutHiddenParamPagNum (Pag_COURSE_PROGRAM,Gbl.Prg.CurrentPage);
}
/*****************************************************************************/
/*********************** List all the program items **************************/
/*****************************************************************************/
void Prg_GetListPrgItems (void)
{
static const char *HiddenSubQuery[Rol_NUM_ROLES] =
{
[Rol_UNK ] = " AND Hidden='N'",
[Rol_GST ] = " AND Hidden='N'",
[Rol_USR ] = " AND Hidden='N'",
[Rol_STD ] = " AND Hidden='N'",
[Rol_NET ] = " AND Hidden='N'",
[Rol_TCH ] = "",
[Rol_DEG_ADM] = " AND Hidden='N'",
[Rol_CTR_ADM] = " AND Hidden='N'",
[Rol_INS_ADM] = " AND Hidden='N'",
[Rol_SYS_ADM] = "",
};
static const char *OrderBySubQuery[Dat_NUM_START_END_TIME] =
{
[Dat_START_TIME] = "StartTime DESC,EndTime DESC,Title DESC",
[Dat_END_TIME ] = "EndTime DESC,StartTime DESC,Title DESC",
};
MYSQL_RES *mysql_res;
MYSQL_ROW row;
unsigned long NumRows;
unsigned NumAsg;
if (Gbl.Prg.LstIsRead)
Prg_FreeListPrgItems ();
/***** Get list of program items from database *****/
if (Gbl.Crs.Grps.WhichGrps == Grp_MY_GROUPS)
NumRows = DB_QuerySELECT (&mysql_res,"can not get program items",
"SELECT PrgIteCod"
" FROM prg_items"
" WHERE CrsCod=%ld%s"
" AND (PrgIteCod NOT IN (SELECT PrgIteCod FROM prg_grp) OR"
" PrgIteCod IN (SELECT prg_grp.PrgIteCod FROM prg_grp,crs_grp_usr"
" WHERE crs_grp_usr.UsrCod=%ld AND prg_grp.GrpCod=crs_grp_usr.GrpCod))"
" ORDER BY %s",
Gbl.Hierarchy.Crs.CrsCod,
HiddenSubQuery[Gbl.Usrs.Me.Role.Logged],
Gbl.Usrs.Me.UsrDat.UsrCod,
OrderBySubQuery[Gbl.Prg.SelectedOrder]);
else // Gbl.Crs.Grps.WhichGrps == Grp_ALL_GROUPS
NumRows = DB_QuerySELECT (&mysql_res,"can not get program items",
"SELECT PrgIteCod"
" FROM prg_items"
" WHERE CrsCod=%ld%s"
" ORDER BY %s",
Gbl.Hierarchy.Crs.CrsCod,
HiddenSubQuery[Gbl.Usrs.Me.Role.Logged],
OrderBySubQuery[Gbl.Prg.SelectedOrder]);
if (NumRows) // Assignments found...
{
Gbl.Prg.Num = (unsigned) NumRows;
/***** Create list of program items *****/
if ((Gbl.Prg.LstPrgIteCods = (long *) calloc (NumRows,sizeof (long))) == NULL)
Lay_NotEnoughMemoryExit ();
/***** Get the program items codes *****/
for (NumAsg = 0;
NumAsg < Gbl.Prg.Num;
NumAsg++)
{
/* Get next program item code */
row = mysql_fetch_row (mysql_res);
if ((Gbl.Prg.LstPrgIteCods[NumAsg] = Str_ConvertStrCodToLongCod (row[0])) < 0)
Lay_ShowErrorAndExit ("Error: wrong program item code.");
}
}
else
Gbl.Prg.Num = 0;
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
Gbl.Prg.LstIsRead = true;
}
/*****************************************************************************/
/****************** Get program item data using its code *********************/
/*****************************************************************************/
void Prg_GetDataOfPrgItemByCod (struct ProgramItem *PrgItem)
{
MYSQL_RES *mysql_res;
unsigned long NumRows;
if (PrgItem->PrgIteCod > 0)
{
/***** Build query *****/
NumRows = DB_QuerySELECT (&mysql_res,"can not get program item data",
"SELECT PrgIteCod,Hidden,UsrCod,"
"UNIX_TIMESTAMP(StartTime),"
"UNIX_TIMESTAMP(EndTime),"
"NOW() BETWEEN StartTime AND EndTime,"
"Title"
" FROM prg_items"
" WHERE PrgIteCod=%ld AND CrsCod=%ld",
PrgItem->PrgIteCod,Gbl.Hierarchy.Crs.CrsCod);
/***** Get data of program item *****/
Prg_GetDataOfPrgItem (PrgItem,&mysql_res,NumRows);
}
else
{
/***** Clear all program item data *****/
PrgItem->PrgIteCod = -1L;
Prg_ResetPrgItem (PrgItem);
}
}
/*****************************************************************************/
/************************* Get program item data *****************************/
/*****************************************************************************/
static void Prg_GetDataOfPrgItem (struct ProgramItem *PrgItem,
MYSQL_RES **mysql_res,
unsigned long NumRows)
{
MYSQL_ROW row;
/***** Clear all program item data *****/
Prg_ResetPrgItem (PrgItem);
/***** Get data of program item from database *****/
if (NumRows) // Schedule item found...
{
/* Get row */
row = mysql_fetch_row (*mysql_res);
/* Get code of the program item (row[0]) */
PrgItem->PrgIteCod = Str_ConvertStrCodToLongCod (row[0]);
/* Get whether the program item is hidden or not (row[1]) */
PrgItem->Hidden = (row[1][0] == 'Y');
/* Get author of the program item (row[2]) */
PrgItem->UsrCod = Str_ConvertStrCodToLongCod (row[2]);
/* Get start date (row[3] holds the start UTC time) */
PrgItem->TimeUTC[Dat_START_TIME] = Dat_GetUNIXTimeFromStr (row[3]);
/* Get end date (row[4] holds the end UTC time) */
PrgItem->TimeUTC[Dat_END_TIME ] = Dat_GetUNIXTimeFromStr (row[4]);
/* Get whether the program item is open or closed (row(5)) */
PrgItem->Open = (row[5][0] == '1');
/* Get the title of the program item (row[6]) */
Str_Copy (PrgItem->Title,row[6],
Prg_MAX_BYTES_PROGRAM_ITEM_TITLE);
/* Can I do this program item? */
PrgItem->IBelongToCrsOrGrps = Prg_CheckIfIBelongToCrsOrGrpsThisPrgItem (PrgItem->PrgIteCod);
}
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (mysql_res);
}
/*****************************************************************************/
/************************ Clear all program item data ************************/
/*****************************************************************************/
static void Prg_ResetPrgItem (struct ProgramItem *PrgItem)
{
if (PrgItem->PrgIteCod <= 0) // If > 0 ==> keep value
PrgItem->PrgIteCod = -1L;
PrgItem->PrgIteCod = -1L;
PrgItem->Hidden = false;
PrgItem->UsrCod = -1L;
PrgItem->TimeUTC[Dat_START_TIME] =
PrgItem->TimeUTC[Dat_END_TIME ] = (time_t) 0;
PrgItem->Open = false;
PrgItem->Title[0] = '\0';
PrgItem->IBelongToCrsOrGrps = false;
}
/*****************************************************************************/
/************************ Free list of program items *************************/
/*****************************************************************************/
void Prg_FreeListPrgItems (void)
{
if (Gbl.Prg.LstIsRead && Gbl.Prg.LstPrgIteCods)
{
/***** Free memory used by the list of program items *****/
free (Gbl.Prg.LstPrgIteCods);
Gbl.Prg.LstPrgIteCods = NULL;
Gbl.Prg.Num = 0;
Gbl.Prg.LstIsRead = false;
}
}
/*****************************************************************************/
/******************* Get program item text from database *********************/
/*****************************************************************************/
static void Prg_GetPrgItemTxtFromDB (long PrgIteCod,char Txt[Cns_MAX_BYTES_TEXT + 1])
{
MYSQL_RES *mysql_res;
MYSQL_ROW row;
unsigned long NumRows;
/***** Get text of program item from database *****/
NumRows = DB_QuerySELECT (&mysql_res,"can not get program item text",
"SELECT Txt FROM prg_items"
" WHERE PrgIteCod=%ld AND CrsCod=%ld",
PrgIteCod,Gbl.Hierarchy.Crs.CrsCod);
/***** The result of the query must have one row or none *****/
if (NumRows == 1)
{
/* Get info text */
row = mysql_fetch_row (mysql_res);
Str_Copy (Txt,row[0],
Cns_MAX_BYTES_TEXT);
}
else
Txt[0] = '\0';
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
if (NumRows > 1)
Lay_ShowErrorAndExit ("Error when getting program item text.");
}
/*****************************************************************************/
/***************** Get summary and content of a program item ****************/
/*****************************************************************************/
// This function may be called inside a web service
void Prg_GetNotifPrgItem (char SummaryStr[Ntf_MAX_BYTES_SUMMARY + 1],
char **ContentStr,
long PrgIteCod,bool GetContent)
{
MYSQL_RES *mysql_res;
MYSQL_ROW row;
unsigned long NumRows;
size_t Length;
SummaryStr[0] = '\0'; // Return nothing on error
/***** Build query *****/
NumRows = DB_QuerySELECT (&mysql_res,"can not get program item title and text",
"SELECT Title,Txt FROM prg_items"
" WHERE PrgIteCod=%ld",
PrgIteCod);
/***** Result should have a unique row *****/
if (NumRows == 1)
{
/***** Get row *****/
row = mysql_fetch_row (mysql_res);
/***** Get summary *****/
Str_Copy (SummaryStr,row[0],
Ntf_MAX_BYTES_SUMMARY);
/***** Get content *****/
if (GetContent)
{
Length = strlen (row[1]);
if ((*ContentStr = (char *) malloc (Length + 1)) == NULL)
Lay_ShowErrorAndExit ("Error allocating memory for notification content.");
Str_Copy (*ContentStr,row[1],
Length);
}
}
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
}
/*****************************************************************************/
/**************** Write parameter with code of program item ******************/
/*****************************************************************************/
static void Prg_PutParamPrgItemCod (long PrgIteCod)
{
Par_PutHiddenParamLong (NULL,"PrgIteCod",PrgIteCod);
}
/*****************************************************************************/
/***************** Get parameter with code of program item *******************/
/*****************************************************************************/
long Prg_GetParamPrgItemCod (void)
{
/***** Get code of program item *****/
return Par_GetParToLong ("PrgIteCod");
}
/*****************************************************************************/
/************* Ask for confirmation of removing a program item ***************/
/*****************************************************************************/
void Prg_ReqRemPrgItem (void)
{
extern const char *Txt_Do_you_really_want_to_remove_the_item_X;
extern const char *Txt_Remove_item;
struct ProgramItem PrgItem;
/***** Get parameters *****/
Prg_GetParamPrgOrder ();
Grp_GetParamWhichGrps ();
Gbl.Prg.CurrentPage = Pag_GetParamPagNum (Pag_COURSE_PROGRAM);
/***** Get program item code *****/
if ((PrgItem.PrgIteCod = Prg_GetParamPrgItemCod ()) == -1L)
Lay_ShowErrorAndExit ("Code of program item is missing.");
/***** Get data of the program item from database *****/
Prg_GetDataOfPrgItemByCod (&PrgItem);
/***** Show question and button to remove the program item *****/
Gbl.Prg.PrgIteCodToEdit = PrgItem.PrgIteCod;
Ale_ShowAlertAndButton (ActRemAsg,NULL,NULL,Prg_PutParams,
Btn_REMOVE_BUTTON,Txt_Remove_item,
Ale_QUESTION,Txt_Do_you_really_want_to_remove_the_item_X,
PrgItem.Title);
/***** Show program items again *****/
Prg_SeeCourseProgram ();
}
/*****************************************************************************/
/*************************** Remove a program item ***************************/
/*****************************************************************************/
void Prg_RemovePrgItem (void)
{
extern const char *Txt_Assignment_X_removed;
struct ProgramItem PrgItem;
/***** Get program item code *****/
if ((PrgItem.PrgIteCod = Prg_GetParamPrgItemCod ()) == -1L)
Lay_ShowErrorAndExit ("Code of program item is missing.");
/***** Get data of the program item from database *****/
Prg_GetDataOfPrgItemByCod (&PrgItem); // Inside this function, the course is checked to be the current one
/***** Remove all the groups of this program item *****/
Prg_RemoveAllTheGrpsAssociatedToAPrgItem (PrgItem.PrgIteCod);
/***** Remove program item *****/
DB_QueryDELETE ("can not remove program item",
"DELETE FROM prg_items WHERE PrgIteCod=%ld AND CrsCod=%ld",
PrgItem.PrgIteCod,Gbl.Hierarchy.Crs.CrsCod);
/***** Mark possible notifications as removed *****/
Ntf_MarkNotifAsRemoved (Ntf_EVENT_ASSIGNMENT,PrgItem.PrgIteCod);
/***** Write message to show the change made *****/
Ale_ShowAlert (Ale_SUCCESS,Txt_Assignment_X_removed,
PrgItem.Title);
/***** Show program items again *****/
Prg_SeeCourseProgram ();
}
/*****************************************************************************/
/***************************** Hide a program item ***************************/
/*****************************************************************************/
void Prg_HidePrgItem (void)
{
struct ProgramItem PrgItem;
/***** Get program item code *****/
if ((PrgItem.PrgIteCod = Prg_GetParamPrgItemCod ()) == -1L)
Lay_ShowErrorAndExit ("Code of program item is missing.");
/***** Get data of the program item from database *****/
Prg_GetDataOfPrgItemByCod (&PrgItem);
/***** Hide program item *****/
DB_QueryUPDATE ("can not hide program item",
"UPDATE prg_items SET Hidden='Y'"
" WHERE PrgIteCod=%ld AND CrsCod=%ld",
PrgItem.PrgIteCod,Gbl.Hierarchy.Crs.CrsCod);
/***** Show program items again *****/
Prg_SeeCourseProgram ();
}
/*****************************************************************************/
/***************************** Show a program item ***************************/
/*****************************************************************************/
void Prg_ShowPrgItem (void)
{
struct ProgramItem PrgItem;
/***** Get program item code *****/
if ((PrgItem.PrgIteCod = Prg_GetParamPrgItemCod ()) == -1L)
Lay_ShowErrorAndExit ("Code of program item is missing.");
/***** Get data of the program item from database *****/
Prg_GetDataOfPrgItemByCod (&PrgItem);
/***** Hide program item *****/
DB_QueryUPDATE ("can not show program item",
"UPDATE prg_items SET Hidden='N'"
" WHERE PrgIteCod=%ld AND CrsCod=%ld",
PrgItem.PrgIteCod,Gbl.Hierarchy.Crs.CrsCod);
/***** Show program items again *****/
Prg_SeeCourseProgram ();
}
/*****************************************************************************/
/*************** Check if the title of a program item exists *****************/
/*****************************************************************************/
static bool Prg_CheckIfSimilarPrgItemExists (const char *Field,const char *Value,long PrgIteCod)
{
/***** Get number of program items with a field value from database *****/
return (DB_QueryCOUNT ("can not get similar program items",
"SELECT COUNT(*) FROM prg_items"
" WHERE CrsCod=%ld"
" AND %s='%s' AND PrgIteCod<>%ld",
Gbl.Hierarchy.Crs.CrsCod,
Field,Value,PrgIteCod) != 0);
}
/*****************************************************************************/
/***************** Put a form to create a new program item *******************/
/*****************************************************************************/
void Prg_RequestCreatOrEditPrgItem (void)
{
extern const char *Hlp_COURSE_Program_new_item;
extern const char *Hlp_COURSE_Program_edit_item;
extern const char *Txt_New_item;
extern const char *Txt_Edit_item;
extern const char *Txt_Title;
extern const char *Txt_Description;
extern const char *Txt_Create_item;
extern const char *Txt_Save_changes;
struct ProgramItem PrgItem;
bool ItsANewPrgItem;
char Txt[Cns_MAX_BYTES_TEXT + 1];
/***** Get parameters *****/
Prg_GetParamPrgOrder ();
Grp_GetParamWhichGrps ();
Gbl.Prg.CurrentPage = Pag_GetParamPagNum (Pag_COURSE_PROGRAM);
/***** Get the code of the program item *****/
ItsANewPrgItem = ((PrgItem.PrgIteCod = Prg_GetParamPrgItemCod ()) == -1L);
/***** Get from the database the data of the program item *****/
if (ItsANewPrgItem)
{
/* Initialize to empty program item */
PrgItem.PrgIteCod = -1L;
PrgItem.TimeUTC[Dat_START_TIME] = Gbl.StartExecutionTimeUTC;
PrgItem.TimeUTC[Dat_END_TIME ] = Gbl.StartExecutionTimeUTC + (2 * 60 * 60); // +2 hours
PrgItem.Open = true;
PrgItem.Title[0] = '\0';
PrgItem.IBelongToCrsOrGrps = false;
}
else
{
/* Get data of the program item from database */
Prg_GetDataOfPrgItemByCod (&PrgItem);
/* Get text of the program item from database */
Prg_GetPrgItemTxtFromDB (PrgItem.PrgIteCod,Txt);
}
/***** Begin form *****/
if (ItsANewPrgItem)
{
Frm_StartForm (ActNewPrgIte);
Gbl.Prg.PrgIteCodToEdit = -1L;
}
else
{
Frm_StartForm (ActChgPrgIte);
Gbl.Prg.PrgIteCodToEdit = PrgItem.PrgIteCod;
}
Prg_PutParams ();
/***** Begin box and table *****/
if (ItsANewPrgItem)
Box_BoxTableBegin (NULL,Txt_New_item,NULL,
Hlp_COURSE_Program_new_item,Box_NOT_CLOSABLE,2);
else
Box_BoxTableBegin (NULL,
PrgItem.Title[0] ? PrgItem.Title :
Txt_Edit_item,
NULL,
Hlp_COURSE_Program_edit_item,Box_NOT_CLOSABLE,2);
/***** Schedule item title *****/
HTM_TR_Begin (NULL);
/* Label */
Frm_LabelColumn ("RM","Title",Txt_Title);
/* Data */
HTM_TD_Begin ("class=\"LM\"");
HTM_INPUT_TEXT ("Title",Prg_MAX_CHARS_PROGRAM_ITEM_TITLE,PrgItem.Title,false,
"id=\"Title\" required=\"required\""
" class=\"TITLE_DESCRIPTION_WIDTH\"");
HTM_TD_End ();
HTM_TR_End ();
/***** Schedule item start and end dates *****/
Dat_PutFormStartEndClientLocalDateTimes (PrgItem.TimeUTC,Dat_FORM_SECONDS_ON);
/***** Schedule item text *****/
HTM_TR_Begin (NULL);
/* Label */
Frm_LabelColumn ("RT","Txt",Txt_Description);
/* Data */
HTM_TD_Begin ("class=\"LT\"");
HTM_TEXTAREA_Begin ("id=\"Txt\" name=\"Txt\" rows=\"10\""
" class=\"TITLE_DESCRIPTION_WIDTH\"");
if (!ItsANewPrgItem)
HTM_Txt (Txt);
HTM_TEXTAREA_End ();
HTM_TD_End ();
HTM_TR_End ();
/***** Groups *****/
Prg_ShowLstGrpsToEditPrgItem (PrgItem.PrgIteCod);
/***** End table, send button and end box *****/
if (ItsANewPrgItem)
Box_BoxTableWithButtonEnd (Btn_CREATE_BUTTON,Txt_Create_item);
else
Box_BoxTableWithButtonEnd (Btn_CONFIRM_BUTTON,Txt_Save_changes);
/***** End form *****/
Frm_EndForm ();
/***** Show current program items, if any *****/
Prg_ShowAllPrgItems ();
}
/*****************************************************************************/
/*************** Show list of groups to edit and program item ****************/
/*****************************************************************************/
static void Prg_ShowLstGrpsToEditPrgItem (long PrgIteCod)
{
extern const char *Hlp_USERS_Groups;
extern const char *The_ClassFormInBox[The_NUM_THEMES];
extern const char *Txt_Groups;
extern const char *Txt_The_whole_course;
unsigned NumGrpTyp;
/***** Get list of groups types and groups in this course *****/
Grp_GetListGrpTypesAndGrpsInThisCrs (Grp_ONLY_GROUP_TYPES_WITH_GROUPS);
if (Gbl.Crs.Grps.GrpTypes.Num)
{
/***** Begin box and table *****/
HTM_TR_Begin (NULL);
HTM_TD_Begin ("class=\"%s RT\"",The_ClassFormInBox[Gbl.Prefs.Theme]);
HTM_TxtF ("%s:",Txt_Groups);
HTM_TD_End ();
HTM_TD_Begin ("class=\"LT\"");
Box_BoxTableBegin ("100%",NULL,NULL,
Hlp_USERS_Groups,Box_NOT_CLOSABLE,0);
/***** First row: checkbox to select the whole course *****/
HTM_TR_Begin (NULL);
HTM_TD_Begin ("colspan=\"7\" class=\"DAT LM\"");
HTM_LABEL_Begin (NULL);
HTM_INPUT_CHECKBOX ("WholeCrs",false,
"id=\"WholeCrs\" value=\"Y\"%s"
" onclick=\"uncheckChildren(this,'GrpCods')\"",
Prg_CheckIfPrgItemIsAssociatedToGrps (PrgIteCod) ? "" :
" checked=\"checked\"");
HTM_TxtF ("%s&nbsp;%s",Txt_The_whole_course,Gbl.Hierarchy.Crs.ShrtName);
HTM_LABEL_End ();
HTM_TD_End ();
HTM_TR_End ();
/***** List the groups for each group type *****/
for (NumGrpTyp = 0;
NumGrpTyp < Gbl.Crs.Grps.GrpTypes.Num;
NumGrpTyp++)
if (Gbl.Crs.Grps.GrpTypes.LstGrpTypes[NumGrpTyp].NumGrps)
Grp_ListGrpsToEditAsgAttSvyMch (&Gbl.Crs.Grps.GrpTypes.LstGrpTypes[NumGrpTyp],
PrgIteCod,Grp_ASSIGNMENT);
/***** End table and box *****/
Box_BoxTableEnd ();
HTM_TD_End ();
HTM_TR_End ();
}
/***** Free list of groups types and groups in this course *****/
Grp_FreeListGrpTypesAndGrps ();
}
/*****************************************************************************/
/***************** Receive form to create a new program item *****************/
/*****************************************************************************/
void Prg_RecFormPrgItem (void)
{
extern const char *Txt_Already_existed_an_item_with_the_title_X;
extern const char *Txt_You_must_specify_the_title_of_the_item;
extern const char *Txt_Created_new_item_X;
extern const char *Txt_The_item_has_been_modified;
struct ProgramItem OldPrgItem; // Current program item data in database
struct ProgramItem NewPrgItem; // Schedule item data received from form
bool ItsANewPrgItem;
bool NewPrgItemIsCorrect = true;
char Description[Cns_MAX_BYTES_TEXT + 1];
/***** Get the code of the program item *****/
NewPrgItem.PrgIteCod = Prg_GetParamPrgItemCod ();
ItsANewPrgItem = (NewPrgItem.PrgIteCod < 0);
if (ItsANewPrgItem)
{
/***** Reset old (current, not existing) program item data *****/
OldPrgItem.PrgIteCod = -1L;
Prg_ResetPrgItem (&OldPrgItem);
}
else
{
/***** Get data of the old (current) program item from database *****/
OldPrgItem.PrgIteCod = NewPrgItem.PrgIteCod;
Prg_GetDataOfPrgItemByCod (&OldPrgItem);
}
/***** Get start/end date-times *****/
NewPrgItem.TimeUTC[Dat_START_TIME] = Dat_GetTimeUTCFromForm ("StartTimeUTC");
NewPrgItem.TimeUTC[Dat_END_TIME ] = Dat_GetTimeUTCFromForm ("EndTimeUTC" );
/***** Get program item title *****/
Par_GetParToText ("Title",NewPrgItem.Title,Prg_MAX_BYTES_PROGRAM_ITEM_TITLE);
/***** Get program item text *****/
Par_GetParToHTML ("Txt",Description,Cns_MAX_BYTES_TEXT); // Store in HTML format (not rigorous)
/***** Adjust dates *****/
if (NewPrgItem.TimeUTC[Dat_START_TIME] == 0)
NewPrgItem.TimeUTC[Dat_START_TIME] = Gbl.StartExecutionTimeUTC;
if (NewPrgItem.TimeUTC[Dat_END_TIME] == 0)
NewPrgItem.TimeUTC[Dat_END_TIME] = NewPrgItem.TimeUTC[Dat_START_TIME] + 2 * 60 * 60; // +2 hours
/***** Check if title is correct *****/
if (NewPrgItem.Title[0]) // If there's a program item title
{
/* If title of program item was in database... */
if (Prg_CheckIfSimilarPrgItemExists ("Title",NewPrgItem.Title,NewPrgItem.PrgIteCod))
{
NewPrgItemIsCorrect = false;
Ale_ShowAlert (Ale_WARNING,Txt_Already_existed_an_item_with_the_title_X,
NewPrgItem.Title);
}
}
else // If there is not a program item title
{
NewPrgItemIsCorrect = false;
Ale_ShowAlert (Ale_WARNING,Txt_You_must_specify_the_title_of_the_item);
}
/***** Create a new program item or update an existing one *****/
if (NewPrgItemIsCorrect)
{
/* Get groups for this program items */
Grp_GetParCodsSeveralGrps ();
if (ItsANewPrgItem)
{
Prg_CreatePrgItem (&NewPrgItem,Description); // Add new program item to database
/***** Write success message *****/
Ale_ShowAlert (Ale_SUCCESS,Txt_Created_new_item_X,
NewPrgItem.Title);
}
else
{
Prg_UpdatePrgItem (&NewPrgItem,Description);
/***** Write success message *****/
Ale_ShowAlert (Ale_SUCCESS,Txt_The_item_has_been_modified);
}
/* Free memory for list of selected groups */
Grp_FreeListCodSelectedGrps ();
/***** Show program items again *****/
Prg_SeeCourseProgram ();
}
else
// TODO: The form should be filled with partial data, now is always empty
Prg_RequestCreatOrEditPrgItem ();
}
/*****************************************************************************/
/************************ Create a new program item **************************/
/*****************************************************************************/
static void Prg_CreatePrgItem (struct ProgramItem *PrgItem,const char *Txt)
{
/***** Create a new program item *****/
PrgItem->PrgIteCod =
DB_QueryINSERTandReturnCode ("can not create new program item",
"INSERT INTO prg_items"
" (CrsCod,UsrCod,StartTime,EndTime,Title,Txt)"
" VALUES"
" (%ld,%ld,FROM_UNIXTIME(%ld),FROM_UNIXTIME(%ld),"
"'%s','%s')",
Gbl.Hierarchy.Crs.CrsCod,
Gbl.Usrs.Me.UsrDat.UsrCod,
PrgItem->TimeUTC[Dat_START_TIME],
PrgItem->TimeUTC[Dat_END_TIME ],
PrgItem->Title,
Txt);
/***** Create groups *****/
if (Gbl.Crs.Grps.LstGrpsSel.NumGrps)
Prg_CreateGrps (PrgItem->PrgIteCod);
}
/*****************************************************************************/
/******************** Update an existing program item ************************/
/*****************************************************************************/
static void Prg_UpdatePrgItem (struct ProgramItem *PrgItem,const char *Txt)
{
/***** Update the data of the program item *****/
DB_QueryUPDATE ("can not update program item",
"UPDATE prg_items SET "
"StartTime=FROM_UNIXTIME(%ld),"
"EndTime=FROM_UNIXTIME(%ld),"
"Title='%s',Txt='%s'"
" WHERE PrgIteCod=%ld AND CrsCod=%ld",
PrgItem->TimeUTC[Dat_START_TIME],
PrgItem->TimeUTC[Dat_END_TIME ],
PrgItem->Title,
Txt,
PrgItem->PrgIteCod,Gbl.Hierarchy.Crs.CrsCod);
/***** Update groups *****/
/* Remove old groups */
Prg_RemoveAllTheGrpsAssociatedToAPrgItem (PrgItem->PrgIteCod);
/* Create new groups */
if (Gbl.Crs.Grps.LstGrpsSel.NumGrps)
Prg_CreateGrps (PrgItem->PrgIteCod);
}
/*****************************************************************************/
/*********** Check if a program item is associated to any group **************/
/*****************************************************************************/
static bool Prg_CheckIfPrgItemIsAssociatedToGrps (long PrgIteCod)
{
/***** Get if a program item is associated to a group from database *****/
return (DB_QueryCOUNT ("can not check if a program item"
" is associated to groups",
"SELECT COUNT(*) FROM prg_grp WHERE PrgIteCod=%ld",
PrgIteCod) != 0);
}
/*****************************************************************************/
/************ Check if a program item is associated to a group ***************/
/*****************************************************************************/
bool Prg_CheckIfPrgItemIsAssociatedToGrp (long PrgIteCod,long GrpCod)
{
/***** Get if a program item is associated to a group from database *****/
return (DB_QueryCOUNT ("can not check if a program item"
" is associated to a group",
"SELECT COUNT(*) FROM prg_grp"
" WHERE PrgIteCod=%ld AND GrpCod=%ld",
PrgIteCod,GrpCod) != 0);
}
/*****************************************************************************/
/********************* Remove groups of a program item ***********************/
/*****************************************************************************/
static void Prg_RemoveAllTheGrpsAssociatedToAPrgItem (long PrgIteCod)
{
/***** Remove groups of the program item *****/
DB_QueryDELETE ("can not remove the groups associated to a program item",
"DELETE FROM prg_grp WHERE PrgIteCod=%ld",
PrgIteCod);
}
/*****************************************************************************/
/*************** Remove one group from all the program items *****************/
/*****************************************************************************/
void Prg_RemoveGroup (long GrpCod)
{
/***** Remove group from all the program items *****/
DB_QueryDELETE ("can not remove group from the associations"
" between program items and groups",
"DELETE FROM prg_grp WHERE GrpCod=%ld",
GrpCod);
}
/*****************************************************************************/
/********** Remove groups of one type from all the program items *************/
/*****************************************************************************/
void Prg_RemoveGroupsOfType (long GrpTypCod)
{
/***** Remove group from all the program items *****/
DB_QueryDELETE ("can not remove groups of a type from the associations"
" between program items and groups",
"DELETE FROM prg_grp USING crs_grp,prg_grp"
" WHERE crs_grp.GrpTypCod=%ld"
" AND crs_grp.GrpCod=prg_grp.GrpCod",
GrpTypCod);
}
/*****************************************************************************/
/********************* Create groups of a program item ***********************/
/*****************************************************************************/
static void Prg_CreateGrps (long PrgIteCod)
{
unsigned NumGrpSel;
/***** Create groups of the program item *****/
for (NumGrpSel = 0;
NumGrpSel < Gbl.Crs.Grps.LstGrpsSel.NumGrps;
NumGrpSel++)
/* Create group */
DB_QueryINSERT ("can not associate a group to a program item",
"INSERT INTO prg_grp"
" (PrgIteCod,GrpCod)"
" VALUES"
" (%ld,%ld)",
PrgIteCod,
Gbl.Crs.Grps.LstGrpsSel.GrpCods[NumGrpSel]);
}
/*****************************************************************************/
/********* Get and write the names of the groups of a program item ***********/
/*****************************************************************************/
static void Prg_GetAndWriteNamesOfGrpsAssociatedToPrgItem (struct ProgramItem *PrgItem)
{
extern const char *Txt_Group;
extern const char *Txt_Groups;
extern const char *Txt_and;
extern const char *Txt_The_whole_course;
MYSQL_RES *mysql_res;
MYSQL_ROW row;
unsigned long NumRow;
unsigned long NumRows;
/***** Get groups associated to a program item from database *****/
NumRows = DB_QuerySELECT (&mysql_res,"can not get groups of a program item",
"SELECT crs_grp_types.GrpTypName,crs_grp.GrpName"
" FROM prg_grp,crs_grp,crs_grp_types"
" WHERE prg_grp.PrgIteCod=%ld"
" AND prg_grp.GrpCod=crs_grp.GrpCod"
" AND crs_grp.GrpTypCod=crs_grp_types.GrpTypCod"
" ORDER BY crs_grp_types.GrpTypName,crs_grp.GrpName",
PrgItem->PrgIteCod);
/***** Write heading *****/
HTM_DIV_Begin ("class=\"%s\"",PrgItem->Hidden ? "ASG_GRP_LIGHT" :
"ASG_GRP");
HTM_TxtColonNBSP (NumRows == 1 ? Txt_Group :
Txt_Groups);
/***** Write groups *****/
if (NumRows) // Groups found...
{
/* Get and write the group types and names */
for (NumRow = 0;
NumRow < NumRows;
NumRow++)
{
/* Get next group */
row = mysql_fetch_row (mysql_res);
/* Write group type name and group name */
HTM_TxtF ("%s&nbsp;%s",row[0],row[1]);
if (NumRows >= 2)
{
if (NumRow == NumRows-2)
HTM_TxtF (" %s ",Txt_and);
if (NumRows >= 3)
if (NumRow < NumRows-2)
HTM_Txt (", ");
}
}
}
else
HTM_TxtF ("%s&nbsp;%s",Txt_The_whole_course,Gbl.Hierarchy.Crs.ShrtName);
HTM_DIV_End ();
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
}
/*****************************************************************************/
/***************** Remove all the program items of a course ******************/
/*****************************************************************************/
void Prg_RemoveCrsPrgItems (long CrsCod)
{
/***** Remove groups *****/
DB_QueryDELETE ("can not remove all the groups associated"
" to program items of a course",
"DELETE FROM prg_grp USING prg_items,prg_grp"
" WHERE prg_items.CrsCod=%ld"
" AND prg_items.PrgIteCod=prg_grp.PrgIteCod",
CrsCod);
/***** Remove program items *****/
DB_QueryDELETE ("can not remove all the program items of a course",
"DELETE FROM prg_items WHERE CrsCod=%ld",
CrsCod);
}
/*****************************************************************************/
/******** Check if I belong to any of the groups of a program item ***********/
/*****************************************************************************/
static bool Prg_CheckIfIBelongToCrsOrGrpsThisPrgItem (long PrgIteCod)
{
switch (Gbl.Usrs.Me.Role.Logged)
{
case Rol_STD:
case Rol_NET:
case Rol_TCH:
// Students and teachers can do program items depending on groups
/***** Get if I can do a program item from database *****/
return (DB_QueryCOUNT ("can not check if I can do a program item",
"SELECT COUNT(*) FROM prg_items"
" WHERE PrgIteCod=%ld"
" AND "
"("
// Schedule item is for the whole course
"PrgIteCod NOT IN (SELECT PrgIteCod FROM prg_grp)"
" OR "
// Schedule item is for specific groups
"PrgIteCod IN"
" (SELECT prg_grp.PrgIteCod FROM prg_grp,crs_grp_usr"
" WHERE crs_grp_usr.UsrCod=%ld"
" AND prg_grp.GrpCod=crs_grp_usr.GrpCod)"
")",
PrgIteCod,Gbl.Usrs.Me.UsrDat.UsrCod) != 0);
case Rol_SYS_ADM:
return true;
default:
return false;
}
}
/*****************************************************************************/
/***************** Get number of program items in a course *******************/
/*****************************************************************************/
unsigned Prg_GetNumPrgItemsInCrs (long CrsCod)
{
/***** Get number of program items in a course from database *****/
return
(unsigned) DB_QueryCOUNT ("can not get number of program items in course",
"SELECT COUNT(*) FROM prg_items"
" WHERE CrsCod=%ld",
CrsCod);
}
/*****************************************************************************/
/****************** Get number of courses with program items *****************/
/*****************************************************************************/
// Returns the number of courses with program items
// in this location (all the platform, current degree or current course)
unsigned Prg_GetNumCoursesWithPrgItems (Hie_Level_t Scope)
{
MYSQL_RES *mysql_res;
MYSQL_ROW row;
unsigned NumCourses;
/***** Get number of courses with program items from database *****/
switch (Scope)
{
case Hie_SYS:
DB_QuerySELECT (&mysql_res,"can not get number of courses with program items",
"SELECT COUNT(DISTINCT CrsCod)"
" FROM prg_items"
" WHERE CrsCod>0");
break;
case Hie_CTY:
DB_QuerySELECT (&mysql_res,"can not get number of courses with program items",
"SELECT COUNT(DISTINCT prg_items.CrsCod)"
" FROM institutions,centres,degrees,courses,prg_items"
" WHERE institutions.CtyCod=%ld"
" AND institutions.InsCod=centres.InsCod"
" AND centres.CtrCod=degrees.CtrCod"
" AND degrees.DegCod=courses.DegCod"
" AND courses.Status=0"
" AND courses.CrsCod=prg_items.CrsCod",
Gbl.Hierarchy.Cty.CtyCod);
break;
case Hie_INS:
DB_QuerySELECT (&mysql_res,"can not get number of courses with program items",
"SELECT COUNT(DISTINCT prg_items.CrsCod)"
" FROM centres,degrees,courses,prg_items"
" WHERE centres.InsCod=%ld"
" AND centres.CtrCod=degrees.CtrCod"
" AND degrees.DegCod=courses.DegCod"
" AND courses.Status=0"
" AND courses.CrsCod=prg_items.CrsCod",
Gbl.Hierarchy.Ins.InsCod);
break;
case Hie_CTR:
DB_QuerySELECT (&mysql_res,"can not get number of courses with program items",
"SELECT COUNT(DISTINCT prg_items.CrsCod)"
" FROM degrees,courses,prg_items"
" WHERE degrees.CtrCod=%ld"
" AND degrees.DegCod=courses.DegCod"
" AND courses.Status=0"
" AND courses.CrsCod=prg_items.CrsCod",
Gbl.Hierarchy.Ctr.CtrCod);
break;
case Hie_DEG:
DB_QuerySELECT (&mysql_res,"can not get number of courses with program items",
"SELECT COUNT(DISTINCT prg_items.CrsCod)"
" FROM courses,prg_items"
" WHERE courses.DegCod=%ld"
" AND courses.Status=0"
" AND courses.CrsCod=prg_items.CrsCod",
Gbl.Hierarchy.Deg.DegCod);
break;
case Hie_CRS:
DB_QuerySELECT (&mysql_res,"can not get number of courses with program items",
"SELECT COUNT(DISTINCT CrsCod)"
" FROM prg_items"
" WHERE CrsCod=%ld",
Gbl.Hierarchy.Crs.CrsCod);
break;
default:
Lay_WrongScopeExit ();
break;
}
/***** Get number of courses *****/
row = mysql_fetch_row (mysql_res);
if (sscanf (row[0],"%u",&NumCourses) != 1)
Lay_ShowErrorAndExit ("Error when getting number of courses with program items.");
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
return NumCourses;
}
/*****************************************************************************/
/************************ Get number of program items ************************/
/*****************************************************************************/
// Returns the number of program items
// in this location (all the platform, current degree or current course)
unsigned Prg_GetNumPrgItems (Hie_Level_t Scope,unsigned *NumNotif)
{
MYSQL_RES *mysql_res;
MYSQL_ROW row;
unsigned NumPrgItems;
/***** Get number of program items from database *****/
switch (Scope)
{
case Hie_SYS:
DB_QuerySELECT (&mysql_res,"can not get number of program items",
"SELECT COUNT(*),SUM(NumNotif)"
" FROM prg_items"
" WHERE CrsCod>0");
break;
case Hie_CTY:
DB_QuerySELECT (&mysql_res,"can not get number of program items",
"SELECT COUNT(*),SUM(prg_items.NumNotif)"
" FROM institutions,centres,degrees,courses,prg_items"
" WHERE institutions.CtyCod=%ld"
" AND institutions.InsCod=centres.InsCod"
" AND centres.CtrCod=degrees.CtrCod"
" AND degrees.DegCod=courses.DegCod"
" AND courses.CrsCod=prg_items.CrsCod",
Gbl.Hierarchy.Cty.CtyCod);
break;
case Hie_INS:
DB_QuerySELECT (&mysql_res,"can not get number of program items",
"SELECT COUNT(*),SUM(prg_items.NumNotif)"
" FROM centres,degrees,courses,prg_items"
" WHERE centres.InsCod=%ld"
" AND centres.CtrCod=degrees.CtrCod"
" AND degrees.DegCod=courses.DegCod"
" AND courses.CrsCod=prg_items.CrsCod",
Gbl.Hierarchy.Ins.InsCod);
break;
case Hie_CTR:
DB_QuerySELECT (&mysql_res,"can not get number of program items",
"SELECT COUNT(*),SUM(prg_items.NumNotif)"
" FROM degrees,courses,prg_items"
" WHERE degrees.CtrCod=%ld"
" AND degrees.DegCod=courses.DegCod"
" AND courses.CrsCod=prg_items.CrsCod",
Gbl.Hierarchy.Ctr.CtrCod);
break;
case Hie_DEG:
DB_QuerySELECT (&mysql_res,"can not get number of program items",
"SELECT COUNT(*),SUM(prg_items.NumNotif)"
" FROM courses,prg_items"
" WHERE courses.DegCod=%ld"
" AND courses.CrsCod=prg_items.CrsCod",
Gbl.Hierarchy.Deg.DegCod);
break;
case Hie_CRS:
DB_QuerySELECT (&mysql_res,"can not get number of program items",
"SELECT COUNT(*),SUM(NumNotif)"
" FROM prg_items"
" WHERE CrsCod=%ld",
Gbl.Hierarchy.Crs.CrsCod);
break;
default:
Lay_WrongScopeExit ();
break;
}
/***** Get number of program items *****/
row = mysql_fetch_row (mysql_res);
if (sscanf (row[0],"%u",&NumPrgItems) != 1)
Lay_ShowErrorAndExit ("Error when getting number of program items.");
/***** Get number of notifications by email *****/
if (row[1])
{
if (sscanf (row[1],"%u",NumNotif) != 1)
Lay_ShowErrorAndExit ("Error when getting number of notifications of program items.");
}
else
*NumNotif = 0;
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
return NumPrgItems;
}
Reference in New Issue View Git Blame Copy Permalink