308 lines
11 KiB
PHP
Executable File
308 lines
11 KiB
PHP
Executable File
<?php require_once __ROOT__.'/manager/security.php';
|
|
|
|
/**************************************************/
|
|
/* _ _ _____ ____ _____ ____ ___ */
|
|
/* | | | | ____| | _ \| ____| _ \ / _ \ */
|
|
/* | | | | _| | |_) | _| | |_) | | | | */
|
|
/* | |_| | |___ | _ <| |___| __/| |_| | */
|
|
/* \___/|_____| |_| \_\_____|_| \___/ */
|
|
/* */
|
|
/**************************************************/
|
|
|
|
class ueRepo extends DBAccess{
|
|
/* VERIFIE L'EXISTENCE D'UN UE DANS LA BDD
|
|
*
|
|
* @nom<String> le nom de l'UE recherchée
|
|
*
|
|
* @return UID<int> si l'UE est dans la BDD, retourne son UID
|
|
* @return FALSE<Boolean> FAUX si l'UE' n'est pas présent dans la BDD
|
|
*
|
|
*/
|
|
public static function UID($nom){
|
|
$getUEUID = DataBase::getPDO()->prepare("SELECT DISTINCT id_ue as id FROM ue WHERE nom = :nom");
|
|
$getUEUID->execute(array( ':nom' => $nom ));
|
|
|
|
// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID du module
|
|
return $getUEUID->fetch()['id'];
|
|
}
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LES INFORMATIONS D'UN UE D'UID DONNÉ
|
|
*
|
|
* @UEUID<int> l'UID de l'UE duquel on veut les infos
|
|
*
|
|
* @return UE<Array> tableau associatif contenant tout les champs de la BDD pour cet UE
|
|
*
|
|
*/
|
|
public static function info($UEUID){
|
|
$getUEInfo = DataBase::getPDO()->prepare("SELECT DISTINCT id_ue as id, nom, libelle FROM ue WHERE id_ue = :UEUID");
|
|
$getUEInfo->execute(array( ':UEUID' => $UEUID ));
|
|
|
|
// on retourne le résultat en supprimant les doublons à indices numériques
|
|
return $getUEInfo->fetch();
|
|
}
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LA LISTE DES UEs QU'A UN ETUDIANT POUR UN SEMESTRE
|
|
*
|
|
* @etudiant<String> Identifiant de l'étudiant
|
|
* @semestre<int> l'UID du semestre
|
|
*
|
|
* @return UEs<Array> retourne un tableau contenant les UEs de l'utilisateur pour ce semestre
|
|
*
|
|
*/
|
|
public static function forStudent($etudiant, $semestre){
|
|
// on récupère les UEs
|
|
$getUesForStudent = DataBase::getPDO()->prepare("SELECT DISTINCT ue.id_ue as id, s.id_semestre, s.nom as semestre, s.annee, ue.nom, ue.libelle, mcc_ue.coefficient
|
|
FROM appartenance as app, semestre as s, mcc_ue, ue
|
|
WHERE app.id_semestre = s.id_semestre
|
|
AND mcc_ue.id_semestre = s.id_semestre
|
|
AND mcc_ue.id_ue = ue.id_ue
|
|
|
|
AND app.id_etudiant = :etudiant
|
|
AND s.id_semestre = :semestre
|
|
ORDER BY ue.nom, ue.libelle");
|
|
$getUesForStudent->execute(array( ':etudiant' => $etudiant, ':semestre' => $semestre ));
|
|
|
|
return DataBase::delNumeric( $getUesForStudent->fetchAll() );
|
|
}
|
|
|
|
|
|
|
|
/* RENVOIE LA LISTE DES UEs QU'ENSEIGNE UN ENSEIGNANT POUR UN SEMESTRE
|
|
*
|
|
* @enseignant<String> Identifiant de l'enseignant
|
|
* @semestre<int> l'UID du semestre en question
|
|
*
|
|
* @return UEs<Array> retourne un tableau contenant les UEs de l'enseignant pour ce semestre
|
|
*
|
|
*/
|
|
public static function forTeacher($enseignant, $semestre){
|
|
// on récupère les modules
|
|
$getUesForTeacher = DataBase::getPDO()->prepare("SELECT DISTINCT ue.id_ue as id, s.id_semestre, s.nom as semestre, s.annee, ue.nom, ue.libelle, mcc_ue.coefficient
|
|
FROM enseignement as ens, semestre as s, ue, mcc_ue, mcc_module as mcc_m
|
|
WHERE ens.id_mcc_module = mcc_m.id_mcc_module
|
|
AND ens.correcteur = 1
|
|
AND mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue
|
|
AND mcc_ue.id_semestre = s.id_semestre
|
|
AND mcc_ue.id_ue = ue.id_ue
|
|
|
|
AND ens.id_enseignant = :enseignant
|
|
AND s.id_semestre = :semestre
|
|
|
|
ORDER BY ue.nom, ue.libelle ASC");
|
|
$getUesForTeacher->execute(array( ':enseignant' => $enseignant, ':semestre' => $semestre ));
|
|
|
|
return DataBase::delNumeric( $getUesForTeacher->fetchAll() );
|
|
}
|
|
|
|
|
|
|
|
/* RENVOIE LA LISTE DES UEs D'UN SEMESTRE (D'UNE ANNEE PARTICULIÈRE)
|
|
*
|
|
* @semestre<int> l'UID du semestre en question
|
|
*
|
|
* @return UEs<Array> retourne un tableau contenant les UEs du semestre en question
|
|
* @return existent<Boolean> FAUX si aucun UE n'a été trouvé
|
|
*
|
|
*/
|
|
public static function forYear($semestre){
|
|
// on récupère les modules
|
|
$getUEList = DataBase::getPDO()->prepare("SELECT DISTINCT ue.id_ue as id, s.id_semestre, s.nom as semestre, s.annee, ue.nom, ue.libelle, mcc_ue.coefficient
|
|
FROM ue, mcc_ue, semestre as s
|
|
WHERE ue.id_ue = mcc_ue.id_ue
|
|
AND mcc_ue.id_semestre = s.id_semestre
|
|
|
|
AND s.id_semestre = :semestre
|
|
ORDER BY s.rang, ue.nom, ue.libelle ASC");
|
|
$getUEList->execute(array( ':semestre' => $semestre ));
|
|
|
|
return DataBase::delNumeric( $getUEList->fetchAll() );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* CREE UN NOUVEL UE DANS LA BASE DE DONNES
|
|
*
|
|
* @nom<String> le nom du nouvel UE
|
|
* @libelle<String> le libellé du nouvel UE
|
|
*
|
|
* @return UID<String> l'UID du nouveal UE s'il a bien été créé
|
|
* @return created<Boolean> VRAI si l'UE 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( ueRepo::UID($nom) ) // si on a un résultat, c'est qu'un module a déjà cee nom
|
|
return false;
|
|
|
|
/* [3] On créé le nouvel UE
|
|
=================================================================================================*/
|
|
$creationUE = DataBase::getPDO()->prepare("INSERT INTO ue(id_ue, nom, libelle) VALUES(DEFAULT, :nom, :libelle)");
|
|
$creationUE->execute(array(
|
|
':nom' => $nom,
|
|
':libelle' => $libelle
|
|
));
|
|
|
|
|
|
/* [4] On vérifie que l'UE a bien été créé
|
|
=================================================================================================*/
|
|
return ueRepo::UID($nom);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* retourne l'UID d'un mcc_ue s'il existe sinon créé tout ce qui a besoin et on retourne l'UID
|
|
*
|
|
* @semestre<int> l'UID du semestre en question
|
|
* @nom<String> le code de l'UE en question
|
|
* @libelle<String> le libellé de l'UE en question
|
|
* @coefficient<Float> le coefficient de l'UE en question dans le semestre en question
|
|
*
|
|
*
|
|
* @return UID<int> retourne l'UID du MCC_UE si tout s'est bien passé
|
|
* @return FALSE<Boolean> retourne FALSE s'il y a eu une erreur
|
|
*
|
|
*/
|
|
public static function forMCC($semestre, $nom, $libelle, $coefficient){
|
|
$count = 0;
|
|
|
|
/* ON VÉRIFIE QUE L'UE EN LUI-MÊME (NOM/LIBELLÉ) EXISTE DANS LA BDD */
|
|
$getUEUID = DataBase::getPDO()->prepare("SELECT id_ue as id FROM ue WHERE nom = :nom AND libelle = :libelle");
|
|
$getUEUID->execute(array( ':nom' => $nom, ':libelle' => $libelle ));
|
|
|
|
while( !$ueUID = $getUEUID->fetch()['id'] ){ // on vérifie l'existence de cet UE
|
|
|
|
/* [1] SI UE N'EXISTE PAS => ON LE CRÉÉ
|
|
=====================================================*/
|
|
$creerUE = DataBase::getPDO()->prepare("INSERT INTO ue(id_ue, nom, libelle) VALUES(DEFAULT, :nom, :libelle)");
|
|
$creerUE->execute(array( ':nom' => $nom, ':libelle' => $libelle ));
|
|
|
|
$getUEUID = DataBase::getPDO()->prepare("SELECT id_ue as id FROM ue WHERE nom = :nom AND libelle = :libelle");
|
|
$getUEUID->execute(array( ':nom' => $nom, ':libelle' => $libelle ));
|
|
|
|
if( $count > 10 ) return false;
|
|
$count++;
|
|
|
|
}
|
|
|
|
|
|
/* ON VÉRIFIE QUE L'UE APPARTIENT AU MCC DE CE SEMESTRE */
|
|
$getMccUEUID = DataBase::getPDO()->prepare("SELECT mcc_ue.id_mcc_ue as id
|
|
FROM ue, mcc_ue
|
|
WHERE mcc_ue.id_ue = ue.id_ue
|
|
AND mcc_ue.id_semestre = :semestre
|
|
AND ue.id_ue = :ueUID");
|
|
$getMccUEUID->execute(array( ':semestre' => $semestre, ':ueUID' => $ueUID ));
|
|
|
|
while( !($mccUeUID=$getMccUEUID->fetch()['id']) ){ // si on a pas de résultat ou qu'on a un résultat différent de l'ueUID déjà récupéré
|
|
|
|
/* [2] SI LE MCC_UE N'EXISTE PAS => ON LE CRÉÉ
|
|
==========================================================*/
|
|
$creeMccUE = DataBase::getPDO()->prepare("INSERT INTO mcc_ue(id_mcc_ue, id_semestre, id_ue, coefficient) VALUES(DEFAULT, :semestre, :ueUID, :coefficient)");
|
|
$creeMccUE->execute(array( ':semestre' => $semestre, ':ueUID' => $ueUID, ':coefficient' => $coefficient ));
|
|
|
|
$getMccUEUID = DataBase::getPDO()->prepare("SELECT mcc_ue.id_mcc_ue as id
|
|
FROM ue, mcc_ue
|
|
WHERE mcc_ue.id_ue = ue.id_ue
|
|
AND mcc_ue.id_semestre = :semestre
|
|
AND ue.id_ue = :ueUID");
|
|
$getMccUEUID->execute(array( ':semestre' => $semestre, ':ueUID' => $ueUID ));
|
|
|
|
|
|
if( $count > 10 ) return false;
|
|
$count++;
|
|
}
|
|
|
|
|
|
|
|
/* [3] ON MET À JOUR LE COEFFICIENT AU CAS OÙ LE MCC_UE EXISTAIT
|
|
==================================================================*/
|
|
$updateCoeff = DataBase::getPDO()->prepare("UPDATE mcc_ue SET coefficient = :coefficient WHERE id_mcc_ue = :mccUeUID");
|
|
$updateCoeff->execute(array( ':coefficient' => $coefficient, ':mccUeUID' => $mccUeUID ));
|
|
|
|
// on retourne enfin l'UID du mcc_ue en question
|
|
return $mccUeUID;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* DEFINIT SI UN UE EST PRIS EN COMPTE OU NON (CAPITALISATION)
|
|
*
|
|
* @semestre<int> UID du semestre en question
|
|
* @etudiant<String> UID de l'étudiant en question
|
|
* @ue<int> UID de l'UE en question
|
|
* @active<Boolean> VRAI si on veut qu'il soit pris en compte, NON sinon
|
|
*
|
|
*
|
|
* @return state<Boolean> VRAI si les changements sont pris en compte, sinon FAUX
|
|
*
|
|
*/
|
|
public static function capitalisation($semestre, $etudiant, $ue, $active){
|
|
/* [1] On récupère l'appartenance
|
|
==========================================================================*/
|
|
$getUEState = DataBase::getPDO()->prepare("SELECT *
|
|
FROM appartenance
|
|
WHERE id_semestre = :semestre
|
|
AND id_etudiant = :etudiant");
|
|
$getUEState->execute(array( ':semestre' => $semestre, ':etudiant' => $etudiant ));
|
|
|
|
// si on trouve aucune appartenance, on retourne FAUX
|
|
if( !($ueState=$getUEState->fetch()) ) return false;
|
|
|
|
$stateArray = explode(',', $ueState['inactive'] );
|
|
// on supprime les entrées vides
|
|
foreach($stateArray as $i=>$state)
|
|
if( strlen($state) == 0 )
|
|
unset($stateArray[$i]);
|
|
|
|
/* [2] On met à jour "inactive" pour enlever ou mettre l'UE
|
|
==========================================================================*/
|
|
if( $active && in_array($ue, $stateArray) ) // si on doit enlever l'ue et qu'il y est
|
|
array_splice($stateArray, array_search($ue, $stateArray), 1 ); // => on enleve l'ue
|
|
|
|
if( !$active && !in_array($ue, $stateArray) ) // si on doit ajouter l'ue et qu'il n'y est pas encore
|
|
array_push($stateArray, $ue); // => on ajoute l'ue
|
|
|
|
$stateString = implode(',', $stateArray);
|
|
|
|
/* [3] On met à jour dans la base de données
|
|
==========================================================================*/
|
|
$setUEState = DataBase::getPDO()->prepare("UPDATE appartenance
|
|
SET inactive = :uestate
|
|
WHERE id_appartenance = :appartenance");
|
|
$setUEState->execute(array( ':uestate' => $stateString, ':appartenance' => $ueState['id_appartenance'] ));
|
|
|
|
/* [4] On vérifie que la modification a bien été faite
|
|
==========================================================================*/
|
|
$getVerifState = DataBase::getPDO()->prepare("SELECT inactive FROM appartenance WHERE id_appartenance = :appartenance");
|
|
$getVerifState->execute(array( ':appartenance' => $ueState['id_appartenance'] ));
|
|
|
|
if( !($verifState=$getVerifState->fetch()) ) return false;
|
|
|
|
return $verifState['inactive'] == $stateString;
|
|
|
|
}
|
|
|
|
} |