265 lines
10 KiB
PHP
Executable File
265 lines
10 KiB
PHP
Executable File
<?php require_once __ROOT__.'/manager/security.php';
|
|
|
|
/**************************************************************************/
|
|
/* __ __ ___ ____ _ _ _ _____ ____ _____ ____ ___ */
|
|
/* | \/ |/ _ \| _ \| | | | | | ____| | _ \| ____| _ \ / _ \ */
|
|
/* | |\/| | | | | | | | | | | | | _| | |_) | _| | |_) | | | | */
|
|
/* | | | | |_| | |_| | |_| | |___| |___ | _ <| |___| __/| |_| | */
|
|
/* |_| |_|\___/|____/ \___/|_____|_____| |_| \_\_____|_| \___/ */
|
|
/* */
|
|
/**************************************************************************/
|
|
|
|
class moduleRepo extends DBAccess{
|
|
/* VERIFIE L'EXISTENCE D'UN MODULE DANS LA BDD
|
|
*
|
|
* @nom<String> le nom du module recherché
|
|
*
|
|
* @return UID<int> si le module est dans la BDD, retourne son UID
|
|
* @return FALSE<Boolean> FAUX si le module n'est pas présent dans la BDD
|
|
*
|
|
*/
|
|
public static function UID($nom){
|
|
$getModuleUID = DataBase::getPDO()->prepare("SELECT DISTINCT id_module as id FROM module WHERE nom = :nom");
|
|
$getModuleUID->execute(array( ':nom' => $nom ));
|
|
|
|
// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID du module
|
|
return $getModuleUID->fetch()['id'];
|
|
}
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LES INFORMATIONS D'UN MODULE D'UID DONNÉ
|
|
*
|
|
* @moduleUID<int> l'UID du module duquel on veut les infos
|
|
*
|
|
* @return module<Array> tableau associatif contenant tout les champs de la BDD pour ce module
|
|
*
|
|
*/
|
|
public static function info($moduleUID){
|
|
$getModuleInfo = DataBase::getPDO()->prepare("SELECT DISTINCT id_module as id, nom, libelle FROM module WHERE id_module = :moduleUID");
|
|
$getModuleInfo->execute(array( ':moduleUID' => $moduleUID ));
|
|
|
|
// on retourne le résultat en supprimant les doublons à indices numériques
|
|
return $getModuleInfo->fetch();
|
|
}
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LA LISTE DES MODULES POUR UN UE D'UN SEMESTRE PARTICULER
|
|
*
|
|
* @UEUID<int> l'UID d'un UE
|
|
* @semestre<int> l'UID du semestre
|
|
*
|
|
* @return modules<Array> retourne un tableau contenant les modules de l'utilisateur pour ce semestre
|
|
* @return existent<Boolean> FAUX si aucun module n'a été trouvé
|
|
*
|
|
*/
|
|
public static function forStudent($UEUID, $semestre){
|
|
// on récupère les modules
|
|
$getModulesForStudent = DataBase::getPDO()->prepare("SELECT DISTINCT m.id_module as id, m.nom, m.libelle, mcc_m.id_mcc_module
|
|
FROM module as m, semestre as s, mcc_ue, mcc_module as mcc_m
|
|
WHERE mcc_ue.id_semestre = s.id_semestre
|
|
AND mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue
|
|
AND mcc_m.id_module = m.id_module
|
|
|
|
AND mcc_ue.id_ue = :UEUID
|
|
AND s.id_semestre = :semestre
|
|
ORDER BY m.nom, m.libelle");
|
|
$getModulesForStudent->execute(array( ':UEUID' => $UEUID, ':semestre' => $semestre ));
|
|
|
|
return DataBase::delNumeric( $getModulesForStudent->fetchAll() );
|
|
}
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LA LISTE DES MODULES QU'ENSEIGNE UN ENSEIGNANT POUR UN UE D'UNE ANNEE
|
|
*
|
|
* @enseignant<String> Identifiant de l'enseignant
|
|
* @UEUID<int> L'UID de l'UE en question
|
|
* @semestre<int> L'UID du semestre en question
|
|
*
|
|
* @return Modules<Array> retourne un tableau contenant les modules de l'enseignant pour ce semestre et cet UE
|
|
*
|
|
*/
|
|
public static function forTeacher($enseignant, $UEUID, $semestre){
|
|
|
|
// on récupère les modules
|
|
$getModulesForTeacher = DataBase::getPDO()->prepare("SELECT DISTINCT m.id_module as id, m.nom, m.libelle, mcc_m.id_mcc_module
|
|
FROM module as m, mcc_module as mcc_m, mcc_ue, enseignement as ens
|
|
WHERE ens.id_mcc_module = mcc_m.id_mcc_module
|
|
AND mcc_m.id_module = m.id_module
|
|
AND mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue
|
|
|
|
AND ens.id_enseignant = :enseignant
|
|
AND mcc_ue.id_ue = :UEUID
|
|
AND mcc_ue.id_semestre = :semestre
|
|
ORDER BY m.nom, m.libelle");
|
|
$getModulesForTeacher->execute(array( ':enseignant' => $enseignant, ':UEUID' => $UEUID, ':semestre' => $semestre ));
|
|
|
|
return DataBase::delNumeric( $getModulesForTeacher->fetchAll() );
|
|
}
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LA LISTE DES MODULES D'UN UE D'UN SEMESTRE PARTICULIER
|
|
*
|
|
* @UEUID<int> l'UID d'un UE
|
|
* @semestre<int> l'UID du semestre en question
|
|
*
|
|
* @return modules<Array> retourne un tableau contenant les modules de l'utilisateur pour ce semestre
|
|
* @return existent<Boolean> FAUX si aucun module n'a été trouvé
|
|
*
|
|
*/
|
|
public static function forYear($UEUID, $semestre){
|
|
// on récupère les modules
|
|
$getModulesForYear = DataBase::getPDO()->prepare("SELECT DISTINCT m.id_module as id, m.nom, m.libelle, mcc_m.id_mcc_module
|
|
FROM module as m, mcc_module as mcc_m, mcc_ue, semestre as s
|
|
WHERE m.id_module = mcc_m.id_module
|
|
AND mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue
|
|
AND mcc_ue.id_semestre = s.id_semestre
|
|
|
|
AND mcc_ue.id_ue = :UEUID
|
|
AND s.id_semestre = :semestre
|
|
ORDER BY s.rang, m.nom, m.libelle");
|
|
$getModulesForYear->execute(array( ':UEUID' => $UEUID, ':semestre' => $semestre ));
|
|
|
|
return DataBase::delNumeric( $getModulesForYear->fetchAll() );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* CREE UN NOUVEAU MODULE DANS LA BASE DE DONNES
|
|
*
|
|
* @nom<String> le nom du nouveau module
|
|
* @libelle<String> le libellé du nouveau module
|
|
*
|
|
* @return UID<String> l'UID du nouveau module s'il a bien été créé
|
|
* @return created<Boolean> VRAI si le module n'existait pas déjà* et qu'il a bien été créé
|
|
* (*) Si aucun autre n'avait le même @nom
|
|
*/
|
|
public static function creer($nom, $libelle){
|
|
/* [1] On normalise les données
|
|
=================================================================================================*/
|
|
$nom = strtoupper($nom); // nom en majuscules
|
|
|
|
/* [2] On vérifie que le module n'est pas déjà créé
|
|
=================================================================================================*/
|
|
if( moduleRepo::UID($nom) ) // si on a un résultat, c'est qu'un module a déjà cee nom
|
|
return false;
|
|
|
|
/* [3] On créé le nouveu module
|
|
=================================================================================================*/
|
|
$creationModule = DataBase::getPDO()->prepare("INSERT INTO module(id_module, nom, libelle) VALUES(DEFAULT, :nom, :libelle)");
|
|
$creationModule->execute(array(
|
|
':nom' => $nom,
|
|
':libelle' => $libelle
|
|
));
|
|
|
|
|
|
/* [4] On vérifie que le module a bien été créé
|
|
=================================================================================================*/
|
|
return moduleRepo::UID($nom);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* retourne la liste de tous les modules existants
|
|
*
|
|
* @return modules<Array> retourne la liste de tous les modules existant
|
|
*
|
|
*/
|
|
public static function exhaustiveList(){
|
|
$getModuleList = DataBase::getPDO()->query("SELECT id_module as id, nom, libelle FROM module ORDER BY nom, libelle");
|
|
|
|
return DataBase::delNumeric( $getModuleList->fetchAll() );
|
|
}
|
|
|
|
|
|
|
|
|
|
/* retourne l'UID d'un mcc_module s'il existe sinon créé tout ce qui a besoin et on retourne l'UID
|
|
*
|
|
* @mcc_ue<int> l'UID du mcc_ue en question
|
|
* @nom<String> le code du module en question
|
|
* @libelle<String> le libellé du module en question
|
|
* @coefficient<Float> le coefficient du module en question dans le mcc_ue en question
|
|
*
|
|
*
|
|
* @return UID<int> retourne l'UID du MCC_MODULE si tout s'est bien passé
|
|
* @return FALSE<Boolean> retourne FALSE s'il y a eu une erreur
|
|
*
|
|
*/
|
|
public static function forMCC($mcc_ue, $nom, $libelle, $coefficient){
|
|
$count = 0; $maxLoop = 2;
|
|
|
|
/* ON VÉRIFIE QUE L'UE EN LUI-MÊME (NOM/LIBELLÉ) EXISTE DANS LA BDD */
|
|
$getModuleUID = DataBase::getPDO()->prepare("SELECT id_module as id FROM module WHERE nom = :nom AND libelle = :libelle");
|
|
$getModuleUID->execute(array( ':nom' => $nom, ':libelle' => $libelle ));
|
|
|
|
while( !$moduleUID = $getModuleUID->fetch()['id'] ){ // on vérifie l'existence de ce module
|
|
|
|
/* [1] SI LE MODULE N'EXISTE PAS => ON LE CRÉÉ
|
|
=====================================================*/
|
|
$creerModule = DataBase::getPDO()->prepare("INSERT INTO module(id_module, nom, libelle) VALUES(DEFAULT, :nom, :libelle)");
|
|
$creerModule->execute(array( ':nom' => $nom, ':libelle' => $libelle ));
|
|
|
|
$getModuleUID = DataBase::getPDO()->prepare("SELECT id_module as id FROM module WHERE nom = :nom AND libelle = :libelle");
|
|
$getModuleUID->execute(array( ':nom' => $nom, ':libelle' => $libelle ));
|
|
|
|
if( $count >= $maxLoop ) return false;
|
|
$count++;
|
|
|
|
}
|
|
|
|
|
|
/* ON VÉRIFIE QUE LE MODULE APPARTIENT AU MCC DE CE MCC_UE */
|
|
$getMccModuleUID = DataBase::getPDO()->prepare("SELECT mcc_m.id_mcc_module as id
|
|
FROM mcc_ue, module as m, mcc_module as mcc_m
|
|
WHERE mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
|
|
AND mcc_m.id_module = m.id_module
|
|
AND mcc_ue.id_mcc_ue = :mcc_ue
|
|
AND mcc_m.id_module = :moduleUID");
|
|
$getMccModuleUID->execute(array( ':mcc_ue' => $mcc_ue, ':moduleUID' => $moduleUID ));
|
|
|
|
while( !($mccModuleUID=$getMccModuleUID->fetch()['id']) ){ // si on a pas de résultat ou qu'on a un résultat différent de l'moduleUID déjà récupéré
|
|
|
|
/* [2] SI LE MCC_UE N'EXISTE PAS => ON LE CRÉÉ
|
|
==========================================================*/
|
|
$creerMccModule = DataBase::getPDO()->prepare("INSERT INTO mcc_module(id_mcc_module, id_mcc_ue, id_module, coefficient) VALUES(DEFAULT, :mcc_ue, :moduleUID, :coefficient)");
|
|
$creerMccModule->execute(array( ':mcc_ue' => $mcc_ue, ':moduleUID' => $moduleUID, ':coefficient' => $coefficient ));
|
|
|
|
|
|
$getMccModuleUID = DataBase::getPDO()->prepare("SELECT mcc_m.id_mcc_module as id
|
|
FROM mcc_ue, module as m, mcc_module as mcc_m
|
|
WHERE mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
|
|
AND mcc_m.id_module = m.id_module
|
|
AND mcc_ue.id_mcc_ue = :mcc_ue
|
|
AND mcc_m.id_module = :moduleUID");
|
|
$getMccModuleUID->execute(array( ':mcc_ue' => $mcc_ue, ':moduleUID' => $moduleUID ));
|
|
|
|
if( $count >= $maxLoop ) return false;
|
|
$count++;
|
|
}
|
|
|
|
|
|
|
|
/* [3] ON MET À JOUR LE COEFFICIENT AU CAS OÙ LE MCC_UE EXISTAIT
|
|
==================================================================*/
|
|
$updateCoeff = DataBase::getPDO()->prepare("UPDATE mcc_module SET coefficient = :coefficient WHERE id_mcc_module = :mccModuleUID");
|
|
$updateCoeff->execute(array( ':coefficient' => $coefficient, ':mccModuleUID' => $mccModuleUID ));
|
|
|
|
// on retourne enfin l'UID du mcc_ue en question
|
|
return $mccModuleUID;
|
|
|
|
}
|
|
|
|
} |