1500 lines
54 KiB
PHP
Executable File
1500 lines
54 KiB
PHP
Executable File
<?php require_once __ROOT__.'/manager/security.php';
|
|
|
|
class DBAccess{};
|
|
|
|
class DataBase{
|
|
|
|
/* ATTRIBUTS */
|
|
private $host;
|
|
private $dbname;
|
|
private $username;
|
|
private $password;
|
|
|
|
private static $pdo;
|
|
|
|
private static $instance;
|
|
|
|
public function __construct($host, $dbname, $username, $password){
|
|
$this->host = $host;
|
|
$this->dbname = $dbname;
|
|
$this->username = $username;
|
|
$this->password = $password;
|
|
|
|
// password: Qt358nUdyeTxLDM8
|
|
DataBase::$pdo = new PDO('mysql:host='.$host.';dbname='.$dbname, $username, $password);
|
|
}
|
|
|
|
|
|
/* retourne une instance de la classe */
|
|
public static function getInstance(){
|
|
if( DataBase::$instance == null ){
|
|
|
|
// chargement de la configuration du server SQL
|
|
$conf = json_decode(file_get_contents(__ROOT__.'/manager/conf.json'), true);
|
|
DataBase::$instance = new DataBase($conf['host'], $conf['dbname'], $conf['user'], $conf['password']);
|
|
|
|
}
|
|
|
|
return DataBase::$instance;
|
|
}
|
|
|
|
/* retourne la connection statique */
|
|
public static function getPDO(){
|
|
$instance = DataBase::getInstance();
|
|
return DataBase::$pdo;
|
|
}
|
|
|
|
|
|
/*************************************************************/
|
|
/* _____ ______ _ _ ______ _____ _ */
|
|
/* / ____| ____| \ | | ____| __ \ /\ | | */
|
|
/* | | __| |__ | \| | |__ | |__) | / \ | | */
|
|
/* | | |_ | __| | . ` | __| | _ / / /\ \ | | */
|
|
/* | |__| | |____| |\ | |____| | \ \ / ____ \| |____ */
|
|
/* \_____|______|_| \_|______|_| \_\/_/ \_\______| */
|
|
/* */
|
|
/*************************************************************/
|
|
|
|
/* SUPPRIME LES VALEURS À CLÉS NUMÉRIQUES DANS UN FETCH D'UNE TABLE DE LA BDD
|
|
*
|
|
* @fetchData<Array> le résultat d'une $requeteSQL->fetchAll()
|
|
*
|
|
* @return newFetchData<Array> retourne le tableau donné en paramètre mais sans les valeurs à clés numériques
|
|
*
|
|
*/
|
|
public static function delNumeric($fetchData, $oneDimension=false){
|
|
|
|
/* [1] 2 dimensions
|
|
===============================================*/
|
|
if( !$oneDimension ){
|
|
|
|
// on supprime les doublons des entrées (indice numérique)
|
|
for( $i = 0 ; $i < count($fetchData) ; $i++ ) // pour tout les utilisateurs
|
|
foreach($fetchData[$i] as $col => $val){ // pour toutes les entrées
|
|
|
|
if( !mb_detect_encoding($val, 'UTF-8') )
|
|
$fetchData[$i][$col] = utf8_encode($val);
|
|
|
|
if( is_int($col) ) // si l'indice est un entier
|
|
unset( $fetchData[$i][$col] ); // on le supprime
|
|
}
|
|
|
|
/* [2] 1 dimensions
|
|
===============================================*/
|
|
}else{
|
|
|
|
// on supprime les doublons des entrées (indice numérique)
|
|
foreach($fetchData as $i=>$val){ // pour toutes les entrées
|
|
|
|
if( !mb_detect_encoding($val, 'UTF-8') )
|
|
$fetchData[$i] = utf8_encode($val);
|
|
|
|
if( is_int($i) ) // si l'indice est un entier
|
|
unset( $fetchData[$i] ); // on le supprime
|
|
}
|
|
|
|
}
|
|
|
|
return $fetchData;
|
|
}
|
|
|
|
|
|
|
|
|
|
public function getSemestreInfoFromTime($time){
|
|
$now = date('Y-m-d', $time);
|
|
|
|
/* On cherche si l'année en cours est définie et on y est */
|
|
$req = DataBase::getPDO()->prepare("SELECT *
|
|
FROM semestrepair
|
|
WHERE :now BETWEEN debut AND FIN");
|
|
$req->execute(array( ':now' => $now ));
|
|
$res = $req->fetch();
|
|
|
|
/* Résultat bon, on le retourne */
|
|
if( is_array($res) )
|
|
return array('annee' => $res['annee'], 'semestre_pair' => $time >= strtotime($res['milieu']) );
|
|
|
|
/* Sinon, on recherche la dernière année entrée dans la BDD */
|
|
else{
|
|
$req2 = DataBase::getPDO()->query("SELECT *
|
|
FROM semestrepair
|
|
WHERE annee in (select max(annee) from semestrepair);");
|
|
$res2 = $req2->fetch();
|
|
|
|
/* Résultat bon, on le retourne */
|
|
if( is_array($res2) )
|
|
return array('annee' => $res2['annee'], 'semestre_pair' => $time >= strtotime($res2['milieu']) );
|
|
|
|
/* Sinon on retourne la valeur par défaut */
|
|
else{
|
|
$semestre_pair = Date('m', $time) < 8;
|
|
$annee = ($semestre_pair) ? Date('Y', $time)-1 : Date('Y', $time);
|
|
return array('annee' => "".$annee, 'semestre_pair' => $semestre_pair );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*********************************************************************************/
|
|
/* __ __ ____ ____ */
|
|
/* | \/ |/ ___/ ___| */
|
|
/* | |\/| | | | | */
|
|
/* | | | | |__| |___ */
|
|
/* |_| |_|\____\____| */
|
|
/* */
|
|
/*********************************************************************************/
|
|
|
|
/* intègre un MCC à la BDD
|
|
*
|
|
* @semestre<int> l'UID du semestre concerné
|
|
* @mcc<Array> contient toutes les données du MCC
|
|
*
|
|
*/
|
|
public function setMCC($semestre, $mcc){
|
|
|
|
foreach($mcc as $ue){
|
|
$mcc_ue = ueRepo::forMCC($semestre, $ue->nom, $ue->libelle, $ue->coefficient);
|
|
|
|
|
|
foreach($ue->modules as $module){
|
|
$mcc_module = moduleRepo::forMCC($mcc_ue, $module->nom, $module->libelle, $module->coefficient);
|
|
|
|
|
|
foreach($module->controles as $controle)
|
|
$controle_uid = controleRepo::forMCC($mcc_module, $controle->nom, $controle->libelle, $controle->coefficient);
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* clone les MCC de la dernière année à l'année donnée
|
|
*
|
|
* @annee<int> L'année de destination
|
|
*
|
|
* @return status<String> "success" si tout s'est bien passé, sinon code erreur
|
|
*
|
|
*/
|
|
public function cloneMCC($annee){
|
|
// on récupère la dernière année à être référencée, si aucun résultat, on retourne une erreur
|
|
if( !($srcYear=semestreRepo::getLastMCCYear()['annee']) ) return 'no_mcc_found';
|
|
|
|
// année de destination
|
|
$dstYear = $annee;
|
|
|
|
|
|
/* [1] Pour chaque SEMESTRE de l'année
|
|
============================================*/
|
|
$listSemestre = semestreRepo::forYear($srcYear);
|
|
foreach($listSemestre as $SEMESTRE){
|
|
// on clone le semestre pour la nouvelle année
|
|
$newSemestreUID = semestreRepo::creer($SEMESTRE['formation'], $SEMESTRE['nom_formation'], $SEMESTRE['nom'], $SEMESTRE['rang'], $dstYear);
|
|
|
|
/* [2] Pour chaque UE de ce semestre
|
|
============================================*/
|
|
$listUE = ueRepo::forYear($SEMESTRE['id']);
|
|
foreach($listUE as $UE){
|
|
// on clone le mcc_ue mais pour le nouveau semestre
|
|
$newUEUID = ueRepo::forMCC($newSemestreUID, $UE['nom'], $UE['libelle'], $UE['coefficient']);
|
|
|
|
/* [3] Pour chaque MODULE de cet UE
|
|
============================================*/
|
|
$listModule = moduleRepo::forYear($UE['id'], $SEMESTRE['id']);
|
|
foreach($listModule as $MODULE){
|
|
// on clone le mcc_module mais pour le nouvel mcc_ue
|
|
$newModuleUID = moduleRepo::forMCC($newUEUID, $MODULE['nom'], $MODULE['libelle'], $MODULE['coefficient']);
|
|
|
|
/* [4] Pour chaque CONTRÔLE de ce module
|
|
============================================*/
|
|
$listControle = controleRepo::forYear($MODULE['id'], $SEMESTRE['id']);
|
|
foreach($listControle as $CONTROLE){
|
|
// on duplique le contrôle mais pour le nouveau mcc_module
|
|
$newControleUID = controleRepo::forMCC($newModuleUID, $CONTROLE['nom'], $CONTROLE['libelle'], $CONTROLE['coefficient']);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// tout s'est bien déroulé si on est arrivé jusque là
|
|
return 'success';
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* intègre une liste d'utilisateurs (pour un rang d'une année) à la BDD
|
|
*
|
|
* @rang<int> le rang du semestre en question
|
|
* @annee<int> l'année du semestre en question
|
|
* @formationList<Array> contient tous les étudiants par formations
|
|
*
|
|
*/
|
|
public function addUserlist($rang, $annee, $formationList){
|
|
|
|
foreach($formationList as $form){
|
|
|
|
$formationUID = semestreRepo::includeFormation($form->nom, $form->libelle); // on récupère l'UID de la formation en la créant si nécessaire
|
|
|
|
if( is_numeric($formationUID) ){ // si la formation est ok, alors on cherche le semestre
|
|
|
|
$semestreUID = semestreRepo::includeSemestre($rang, $annee, $formationUID); // on récupère l'UID du semestre en le créant si nécessaire
|
|
|
|
if( is_numeric($semestreUID) ){ // si le semestre est ok, alors on ajoute les utilisateurs
|
|
|
|
foreach($form->userlist as $user){
|
|
// on récupère l'UID utilisateur en le créant si nécessaire
|
|
$utilisateurUID = userRepo::includeEtudiant($user->identifiant, $user->prenom, $user->nom, $user->sexe, $user->mail);
|
|
|
|
if( is_string($utilisateurUID) ) // si l'utilisateur est ok, alors on créé l'appartenance
|
|
groupRepo::includeAppartenance($utilisateurUID, $semestreUID); // on ajoute l'utilisateur au groupeVide de chaque semestre (s'il n'a pas déjà un groupe)
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* créé un semestre/formation dans la BDD
|
|
*
|
|
* @codeFormation<String> le code/nom de la formation
|
|
* @nomFormation<String> le libellé de la formation
|
|
* @nomSemestre<String> le nom/libellé du semestre
|
|
* @rangSemestre<int> le rang du semestre dans la formation
|
|
* @annee<int> l'année du semestre
|
|
*
|
|
*
|
|
* @return cree<Boolean> retourne VRAI si les éléments existaient ou ont bien été créés
|
|
*
|
|
*/
|
|
public function creerSemestre($codeFormation, $nomFormation, $nomSemestre, $rangSemestre, $annee){
|
|
// si on a tout créé ou que tout existe "creer" retourne l'UID du semestre,
|
|
// si on a un boolean c'est FALSE => erreur
|
|
|
|
if( !is_bool(semestreRepo::creer($codeFormation, $nomFormation, $nomSemestre, $rangSemestre, $annee)) )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* effectue la capitalisation de l'ue
|
|
* @ue pour le semestre @semestre
|
|
* pour l'étudiant @etudiant
|
|
*/
|
|
public function capitaliserUE($ue, $semestre, $etudiant){
|
|
// on vérifie l'existence des paramètres (etudiant, semestre, ue)
|
|
if( !semestreRepo::exists($semestre) ) return 'unknown_semestre';
|
|
if( !groupRepo::forStudent($etudiant, $semestre) ) return 'unknown_user';
|
|
if( !($ueInfo=ueRepo::info($ue)) ) return 'unknown_ue';
|
|
|
|
// on vérifie que ce semestre a bien l'ue donnée
|
|
$UEs = ueRepo::forStudent($etudiant, $semestre);
|
|
$UEUIDList = array();
|
|
|
|
foreach($UEs as $UE)
|
|
if( !in_array($UE['id'], $UEUIDList) )
|
|
array_push($UEUIDList, $UE['id']);
|
|
|
|
// si l'UE n'est pas dans ce semestre, on retourne une erreur
|
|
if( !in_array($ue, $UEUIDList) ) return 'unknown_ue';
|
|
|
|
|
|
/* [1] On récupère les redoublements de ce semestre
|
|
======================================================*/
|
|
$redoublements = semestreRepo::getRedoublements($semestre, $etudiant);
|
|
|
|
/* [2] On retire ceux qui n'ont pas l'UE
|
|
======================================================*/
|
|
foreach($redoublements as $iter_s=>$SEM){
|
|
$listeUEs = ueRepo::forStudent($etudiant, $SEM['id_semestre']);
|
|
$hasUE = false;
|
|
// on vérifie que le semestre a bien l'UE
|
|
foreach($listeUEs as $UE)
|
|
if( $UE['id'] == $ue ) $hasUE = true;
|
|
|
|
// s'il n'a pas l'UE, on le supprime
|
|
if( !$hasUE ) unset($redoublements[$iter_s]);
|
|
}
|
|
|
|
/* [3] On applique les modifications
|
|
======================================================*/
|
|
$checker = true;
|
|
// on définit l'UE comme actif
|
|
$checker = $checker && ueRepo::capitalisation($semestre, $etudiant, $ue, true);
|
|
|
|
// on définit l'UE dans les autres semestres comme inactif
|
|
foreach($redoublements as $red)
|
|
$checker = $checker && ueRepo::capitalisation($red['id_semestre'], $etudiant, $ue, false);
|
|
|
|
|
|
return ($checker) ? 'success' : 'error';
|
|
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************************/
|
|
/* _ _ _______ _____ _ _____ _____ _______ ______ _ _ _____ */
|
|
/* | | | |__ __|_ _| | |_ _|/ ____| /\|__ __| ____| | | | __ \ */
|
|
/* | | | | | | | | | | | | | (___ / \ | | | |__ | | | | |__) | */
|
|
/* | | | | | | | | | | | | \___ \ / /\ \ | | | __| | | | | _ / */
|
|
/* | |__| | | | _| |_| |____ _| |_ ____) / ____ \| | | |____| |__| | | \ \ */
|
|
/* \____/ |_| |_____|______|_____|_____/_/ \_\_| |______|\____/|_| \_\ */
|
|
/* */
|
|
/*************************************************************************************/
|
|
|
|
|
|
/*********************************************/
|
|
/*** création d'un utilisateur dans la bdd ***/
|
|
/*********************************************/
|
|
public function creerUtilisateur($identifiant, $prenom, $nom, $mail, $mdp, $droits){
|
|
if( userRepo::creer($identifiant, $prenom, $nom, $mail, $mdp, $droits) ) // si l'utilisateur a bien été créé
|
|
return 'success';
|
|
else
|
|
return 'error';
|
|
}
|
|
|
|
|
|
|
|
/*********************************************************************************/
|
|
/*** on récupère les informations utiles à l'utilisateur lors de la connection ***/
|
|
/*********************************************************************************/
|
|
public function utilisateurInfo($identifiant){
|
|
// on vérifie que l'utilisateur existe
|
|
if( !($utilisateurUID=userRepo::UID($identifiant)) ) return 'unknown_user';
|
|
|
|
return userRepo::info($utilisateurUID);
|
|
}
|
|
|
|
|
|
|
|
/* retourne le semestre en cours d'un étudiant
|
|
*
|
|
* @etudiant<String> L'identifiant (UID) de l'étudiant en question
|
|
* @semestre_pair<Boolean> VRAI si le rang semestre est pair, sinon FAUX
|
|
* @annee<int> L'année scolaire en cours
|
|
*
|
|
* @return semestreUID<int> l'UID du semestre courant
|
|
*
|
|
*/
|
|
public static function studentSemestre($etudiant, $semestre_pair, $annee){
|
|
if( !($semestre=semestreRepo::forStudent($etudiant, $semestre_pair, $annee)) ) // si on a un résultat
|
|
return 'error';
|
|
else
|
|
return $semestre;
|
|
}
|
|
|
|
|
|
/* retourne la liste des enseignants de la BDD
|
|
*
|
|
* @admin<String> l'UID de l'admin qui demande ça
|
|
*
|
|
*
|
|
* @return enseignants<Array> retourne la liste des enseignants de la bdd
|
|
*
|
|
*/
|
|
public function listeUtilisateursRole($annee){
|
|
$roleUsers = userRepo::getRoleUsers();
|
|
|
|
foreach($roleUsers as $iter=>$user){
|
|
$semestreList = $this->getModulesByUEByEnseignant($user['id'], null, $annee);
|
|
if( is_array($semestreList) ) $roleUsers[$iter]['semestreList'] = $semestreList;
|
|
else $roleUsers[$iter]['semestreList'] = null;
|
|
}
|
|
|
|
return $roleUsers;
|
|
}
|
|
|
|
|
|
|
|
/* retourne la liste des semestres de la BDD par annnées
|
|
*
|
|
* @return annees<Array> retourne la liste des années contenant chacunes leurs semestres
|
|
*
|
|
*/
|
|
public function getListeSemestres(){
|
|
$listeAnnees = semestreRepo::getAnnees();
|
|
|
|
foreach($listeAnnees as $iter_a=>$annee){
|
|
|
|
$listeAnnees[$iter_a]['semestres'] = semestreRepo::forYear($annee['annee']);
|
|
|
|
foreach($listeAnnees[$iter_a]['semestres'] as $iter_s=>$semestre)
|
|
$listeAnnees[$iter_a]['semestres'][$iter_s]['nb_etudiants'] = semestreRepo::nbEtuForSemestre($semestre['id']);
|
|
|
|
}
|
|
|
|
return $listeAnnees;
|
|
}
|
|
|
|
|
|
/* modifie le caractère "admin" d'un utilisateur
|
|
*
|
|
* @utilisateur<String> l'UID de l'utilisateur en question
|
|
* @admin<Boolean> VRAI si admin, FAUX sinon
|
|
*
|
|
*
|
|
* @return updated<Boolean> VRAI si la modification a été faite
|
|
*
|
|
*/
|
|
public function setAdmin($utilisateur, $admin){
|
|
// on vérifie l'existence de l'utilisateur
|
|
if( !($utilisateurUID=userRepo::UID($utilisateur)) ) return 'unknown_user';
|
|
|
|
return userRepo::setAdmin($utilisateurUID, $admin);
|
|
}
|
|
|
|
|
|
/* modifie le caractère "référent" d'un utilisateur
|
|
*
|
|
* @utilisateur<String> l'UID de l'utilisateur en question
|
|
* @master<Boolean> VRAI si master, FAUX sinon
|
|
*
|
|
*
|
|
* @return updated<Boolean> VRAI si la modification a été faite
|
|
*
|
|
*/
|
|
public function setMaster($utilisateur, $master){
|
|
// on vérifie l'existence de l'utilisateur
|
|
if( !($utilisateurUID=userRepo::UID($utilisateur)) ) return 'unknown_user';
|
|
|
|
return userRepo::setMaster($utilisateurUID, $master);
|
|
}
|
|
|
|
|
|
/* ajoute un module qu'un utilisateur peut corriger
|
|
*
|
|
* @utilisateur<String> l'UID de l'utilisateur en question
|
|
* @mccmodule<int> l'UID du mcc_module à ajouter
|
|
*
|
|
* @groupe<int> ***OPTIONNEL*** l'UID du groupe à ajouter
|
|
*
|
|
*
|
|
* @return added<Boolean> VRAI si module ajouté, sinon FALSE
|
|
*
|
|
*/
|
|
public function correcteurAjouterModule($utilisateur, $mccmodule, $groupe=null){
|
|
// on vérifie l'existence de l'utilisateur et du groupe
|
|
if( !($utilisateurUID=userRepo::UID($utilisateur)) ) return 'unknown_user';
|
|
|
|
if( $groupe != null ) // si un groupe est donné, on le cherche
|
|
if( !($groupeUID=groupRepo::info($groupe)['id']) ) return 'unknown_group';
|
|
|
|
|
|
|
|
|
|
// si on ajoute pour un groupe donné, on le fait
|
|
if( $groupe != null ){
|
|
$success = userRepo::addModule($utilisateurUID, $mccmodule, $groupeUID);
|
|
|
|
// si aucun groupe n'est donné
|
|
}else{
|
|
|
|
$inscrits = groupRepo::inscritsMccModule($mccmodule);
|
|
$success = true;
|
|
foreach($inscrits as $groupe)
|
|
$success = $success && userRepo::addModule($utilisateurUID, $mccmodule, $groupe['id']);
|
|
|
|
}
|
|
|
|
|
|
// définit l'utilisateur comme enseignant et retourne le statut
|
|
return $success && userRepo::setTeacher($utilisateurUID);
|
|
|
|
}
|
|
|
|
|
|
/* supprime un module qu'un utilisateur peut corriger
|
|
*
|
|
* @utilisateur<String> l'UID de l'utilisateur en question
|
|
* @mccmodule<int> l'UID du mcc_module à supprimer
|
|
*
|
|
* @groupe<int> ***OPTIONNEL*** l'UID du groupe à supprimer
|
|
*
|
|
*
|
|
* @return removed<Boolean> VRAI si module supprimé, sinon FALSE
|
|
*
|
|
*/
|
|
public function correcteurSupprimerModule($utilisateur, $mccmodule, $groupe=null){
|
|
// on vérifie l'existence de l'utilisateur
|
|
if( !($utilisateurUID=userRepo::UID($utilisateur)) ) return 'unknown_user';
|
|
|
|
if( $groupe != null ) // si un groupe est donné, on le cherche
|
|
if( !($groupeUID=groupRepo::info($groupe)['id']) ) return 'unknown_group';
|
|
|
|
|
|
|
|
|
|
// si on ajoute pour un groupe donné, on le fait
|
|
if( $groupe != null )
|
|
$success = userRepo::delModule($utilisateurUID, $mccmodule, $groupeUID);
|
|
|
|
|
|
|
|
// si aucun groupe n'est donné
|
|
else{
|
|
|
|
$inscrits = groupRepo::inscritsMccModule($mccmodule);
|
|
$success = true;
|
|
foreach($inscrits as $groupe)
|
|
$success = $success && userRepo::delModule($utilisateurUID, $mccmodule, $groupe['id']);
|
|
|
|
}
|
|
|
|
// définit l'utilisateur comme enseignant et retourne le statut
|
|
return $success && userRepo::setTeacher($utilisateurUID);
|
|
|
|
}
|
|
|
|
/**********************************************************/
|
|
/* _____ _____ ____ _ _ _____ ______ _____ */
|
|
/* / ____| __ \ / __ \| | | | __ \| ____|/ ____| */
|
|
/* | | __| |__) | | | | | | | |__) | |__ | (___ */
|
|
/* | | |_ | _ /| | | | | | | ___/| __| \___ \ */
|
|
/* | |__| | | \ \| |__| | |__| | | | |____ ____) | */
|
|
/* \_____|_| \_\\____/ \____/|_| |______|_____/ */
|
|
/* */
|
|
/**********************************************************/
|
|
|
|
|
|
/****************************************/
|
|
/*** création d'un groupe dans la bdd ***/
|
|
/****************************************/
|
|
public function creerGroupe($nom){
|
|
if( groupRepo::creer($nom) ) // si on a bien ajouté un entrée ou qu'elle n'existait pas déjà
|
|
return 'success';
|
|
else
|
|
return 'error';
|
|
}
|
|
|
|
/******************************************************/
|
|
/*** ajout d'un utilisateur à un groupe dans la bdd ***/
|
|
/******************************************************/
|
|
public function ajouterEtudiantGroupe($etudiant, $groupe, $semestre, $annee){
|
|
// on vérifie que l'utilisateur, le groupe, le semestre existent
|
|
if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';
|
|
if( !($groupeUID=groupRepo::UID($groupe)) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID;
|
|
if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
|
|
|
|
|
|
if( groupRepo::ajouterMembre($etudiantUID, $groupeUID, $semestreUID) ) // si on a bien ajouté un entrée
|
|
return 'success';
|
|
else
|
|
return 'error';
|
|
}
|
|
|
|
/******************************************************************/
|
|
/*** retourne la liste des utilisateurs du groupe d'un étudiant ***/
|
|
/******************************************************************/
|
|
public function listeEtudiantsGroupe($etudiant, $semestre){
|
|
// on vérifie que le groupe et le semestre existent
|
|
if( !semestreRepo::exists($semestre) ) return 'unknown_semestre';
|
|
else $semestreUID = $semestre;
|
|
|
|
if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';
|
|
if( !($groupeObj=groupRepo::forStudent($etudiantUID, $semestreUID)) ) return 'unknown_group';
|
|
|
|
$userlist = DataBase::delNumeric( groupRepo::membres($groupeObj['id'], $semestreUID) );
|
|
$userlist['groupe'] = $groupeObj['nom'];
|
|
// foreach($userlist as $iter=>$user)
|
|
// $userlist[$iter]['groupe'] = $groupeObj['nom'];
|
|
|
|
// on retourne la liste des utilisateurs et on supprime les doublons à indices numériques
|
|
return $userlist;
|
|
|
|
}
|
|
|
|
/********************************************************************/
|
|
/*** retourne la liste des utilisateurs des groupes d'un semestre ***/
|
|
/********************************************************************/
|
|
public function listeEtudiantsTousGroupesSemestre($semestre){
|
|
// on vérifie que le semestre existe
|
|
if( !semestreRepo::exists($semestre) ) return 'unknown_semestre';
|
|
else $semestreUID = $semestre;
|
|
|
|
$grouplist = groupRepo::forSemestre($semestreUID); // contiendra tout les groupes
|
|
|
|
// on parcourt tous les groupes
|
|
foreach($grouplist as $iter=>$val)
|
|
$grouplist[$iter]['userlist'] = groupRepo::membres($grouplist[$iter]['id'], $semestreUID); // on charge la liste des utilisateurs de ce groupe
|
|
|
|
return $grouplist; // sinon on retourne le tableau
|
|
|
|
}
|
|
|
|
/******************************************************************/
|
|
/*** retourne la liste des utilisateurs des groupes d'une année ***/
|
|
/******************************************************************/
|
|
public function listeEtudiantsTousGroupesAnnee($annee, $semestre_pair){
|
|
// on récupère la liste des groupes
|
|
$grouplist = groupRepo::forYear($semestre_pair, $annee);
|
|
|
|
foreach($grouplist as $iter=>$val) // pour chaque groupe un récupère la liste des utilisateurs
|
|
$grouplist[$iter]['userlist'] = groupRepo::membres($grouplist[$iter]['id'], $grouplist[$iter]['id_semestre']);
|
|
|
|
return $grouplist; // sinon on retourne le tableau
|
|
|
|
}
|
|
|
|
/******************************************************************/
|
|
/*** retourne la liste des utilisateurs des groupes d'une année ***/
|
|
/******************************************************************/
|
|
public function listeEtudiantsTousGroupesEnseignant($annee, $semestre_pair, $enseignant){
|
|
/*** on cherche un semestre avec cette année ***/
|
|
$checkAnnee = DataBase::getPDO()->prepare("SELECT id_semestre as id FROM semestre WHERE annee = :annee");
|
|
$checkAnnee->execute(array( ':annee' => $annee ));
|
|
if( !( $checkAnnee->fetch()['id'] ) ) return 'unknown_year';
|
|
|
|
// on cherche si cet enseignant enseigne un semestre courant de cette année
|
|
if( !($enseignantUID=userRepo::UID($enseignant, null, $semestre_pair, $annee)) ) return 'unknown_teacher';
|
|
|
|
|
|
// on récupère la liste des groupes
|
|
$grouplist = DataBase::delNumeric( groupRepo::forTeacher($enseignantUID, $semestre_pair, $annee) );
|
|
|
|
foreach($grouplist as $iter=>$val) // pour chaque groupe un récupère la liste des utilisateurs
|
|
$grouplist[$iter]['userlist'] = groupRepo::membres($grouplist[$iter]['id'], $grouplist[$iter]['id_semestre']);
|
|
|
|
return $grouplist; // sinon on retourne le tableau
|
|
}
|
|
|
|
|
|
/****************************************************************/
|
|
/***** déplace une liste d'étudiants d'un groupe à un autre *****/
|
|
/****************************************************************/
|
|
public function deplacerEtudiantMultiple($etudiants, $groupe, $semestre){
|
|
|
|
// on vérifie que le semestre et que le groupe de destination existent
|
|
if( !($semestreInfo=semestreRepo::info($semestre)) ) return 'unknown_semestre';
|
|
if( !($destGroupeInfo=groupRepo::info($groupe)) ) return 'unknown_newgroup';
|
|
|
|
foreach($etudiants as $etu)
|
|
if( !(groupRepo::ajouterMembre($etu, $destGroupeInfo['id'], $semestreInfo['id'])) )
|
|
return 'error';
|
|
|
|
return 'success';
|
|
}
|
|
|
|
|
|
|
|
/* retourne la liste exhaustive des groupes de la BDD
|
|
*
|
|
* @return grouplist<Array> la liste de tous les groupes de la BDD
|
|
*
|
|
*/
|
|
public function getExhaustiveGroupList(){
|
|
$grouplist = groupRepo::getAllGroups();
|
|
|
|
// on essaie de supposer le semestre en fonction du nom
|
|
foreach($grouplist as $i=>$group)
|
|
if( preg_match('/^(?:.+)?S(\d)(?:.+)?$/', $group['nom'], $m) ) // si le semestre est dans le nom
|
|
$grouplist[$i]['rang'] = intval($m[1]); // on récupère le rang
|
|
else
|
|
$grouplist[$i]['rang'] = null; // sinon rang = null
|
|
|
|
|
|
return $grouplist;
|
|
}
|
|
|
|
|
|
|
|
/* Applique les mentions du jury aux étudiants d'un semestre
|
|
*
|
|
* @semestre<int> UID du semestre en question
|
|
* @jury<Array> Tableau contenant les étudiants et leurs mention
|
|
*
|
|
*
|
|
* @return success<Boolean> Retourne VRAI si aucune erreur n'occure, sinon retourne FAUX
|
|
*
|
|
*/
|
|
public function applyJurySemestre($semestre, $jury){
|
|
$state = true;
|
|
foreach($jury as $ETU){
|
|
$state = $state && DataBase::getInstance()->applyJuryTo($ETU->etudiant, $semestre, $ETU->mention) == 'success';
|
|
}
|
|
|
|
return $state;
|
|
}
|
|
|
|
|
|
|
|
/* Applique la mention du jury à un étudiant d'un semestre
|
|
*
|
|
* @etudiant<String> UID de l'étudiant en question
|
|
* @semestre<int> UID du semestre courant de l'étudiant
|
|
*
|
|
*
|
|
* @return state<String> SUCCESS => changement effectué
|
|
* OU fin de formation
|
|
* * => ERREUR
|
|
*
|
|
* ADM => Passage de semestre (admis)
|
|
* ADJ => Passage de semestre (admis pas jury)
|
|
* ATT => Passage de semestre (si rang impair) SINON redoublement
|
|
* NAR/DEM/AJ => Pas pris
|
|
*/
|
|
public function applyJuryTo($etudiant, $semestre, $mention){
|
|
|
|
// on vérifie que le semestre existe et que l'étudiant est inscrit à ce semestre
|
|
if( !($semestreInfo=semestreRepo::info($semestre)) ) return 'unknown_semestre';
|
|
if( !($etudiantUID=userRepo::UID($etudiant, $semestre)) ) return 'unknown_user';
|
|
|
|
// on vérifie que la mention est correcte
|
|
if( !in_array($mention, array('ADM', 'ADJ', 'ATT', 'NAR', 'DEM', 'AJ')) ) return 'unknown_mention';
|
|
|
|
/* [1] On définit la mention pour l'utilisateur à ce semestre
|
|
======================================================*/
|
|
groupRepo::setMention($etudiantUID, $semestre, $mention);
|
|
|
|
/* [2] Gestion du passage de l'étudiant
|
|
======================================================*/
|
|
// si ADM/ADJ ou RDB (redoublement) et semestre impair, passage
|
|
if( in_array($mention, array('ADM', 'ADJ')) || $mention == 'ATT' && $semestreInfo['rang']%2==1 ){
|
|
/* (1) On récupère le semestre suivant s'il existe */
|
|
$nextSemestre = semestreRepo::next($semestre);
|
|
|
|
/* (2) Si le semestre n'existe pas, on le créé */
|
|
if( is_array($nextSemestre) )
|
|
$nextSemestre = semestreRepo::creer($semestreInfo['formation'], $semestreInfo['nom_formation'], null, $nextSemestre['rang'], $nextSemestre['annee']);
|
|
|
|
// si le semestre n'est toujours pas créé, on retourne une erreur
|
|
if( is_bool($nextSemestre) ) return 'error';
|
|
|
|
/* (3) On créé l'appartenance */
|
|
$appartenanceUID = groupRepo::includeAppartenance($etudiant, $nextSemestre);
|
|
|
|
/* [3] Gestion du redoublement (début année), rang-2
|
|
======================================================*/
|
|
}elseif( $mention == 'ATT' ){
|
|
/* (1) On récupère le semestre précédent */
|
|
$rdbSemestre = semestreRepo::prev($semestre);
|
|
|
|
/* (2) Si le semestre n'existe pas, on le créé */
|
|
if( is_array($rdbSemestre) )
|
|
$rdbSemestre = semestreRepo::creer($semestreInfo['formation'], $semestreInfo['nom_formation'], null, $rdbSemestre['rang'], $rdbSemestre['annee']);
|
|
|
|
// si le semestre n'est toujours pas créé, on retourne une erreur
|
|
if( is_bool($rdbSemestre) ) return 'error';
|
|
|
|
/* (3) On créé l'appartenance */
|
|
$appartenanceUID = groupRepo::includeAppartenance($etudiant, $rdbSemestre);
|
|
}
|
|
|
|
// if( isset($nextSemestre) ) var_dump('nxt: '.$nextSemestre);
|
|
// if( isset($rdbSemestre) ) var_dump('rdb: '.$rdbSemestre);
|
|
// if( isset($appartenanceUID) ) var_dump('app: '.$appartenanceUID);
|
|
return 'success';
|
|
}
|
|
|
|
|
|
|
|
|
|
/**********************************************************/
|
|
/* */
|
|
/* __ __ ____ _____ _ _ _ ______ _____ */
|
|
/* | \/ |/ __ \| __ \| | | | | | ____|/ ____| */
|
|
/* | \ / | | | | | | | | | | | | |__ | (___ */
|
|
/* | |\/| | | | | | | | | | | | | __| \___ \ */
|
|
/* | | | | |__| | |__| | |__| | |____| |____ ____) | */
|
|
/* |_| |_|\____/|_____/ \____/|______|______|_____/ */
|
|
/* */
|
|
/**********************************************************/
|
|
|
|
|
|
|
|
/**************************************************/
|
|
/*** retourne les modules d'un étudiant par UEs ***/
|
|
/**************************************************/
|
|
public function getModulesByUEByEtudiant($etudiant, $semestre){
|
|
// on vérifie que le semestre et l'utilisateur existent
|
|
if( !semestreRepo::exists($semestre) ) return 'unknown_semestre';
|
|
else $semestreUID = $semestre;
|
|
|
|
if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';
|
|
|
|
// on récupère la liste des UE
|
|
$UEList = ueRepo::forStudent($etudiantUID, $semestreUID);
|
|
|
|
foreach($UEList as $iter=>$UE) // pour chaque UE, on récupère la liste des modules
|
|
$UEList[$iter]['modules'] = moduleRepo::forStudent($UE['id'], $semestreUID);
|
|
|
|
return $UEList;
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
/*** retourne les modules d'un étudiant ***/
|
|
/******************************************/
|
|
public function getModulesEtudiant($etudiant, $semestre, $annee){
|
|
// on vérifie que le semestre et l'étudiant existent
|
|
if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
|
|
if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';
|
|
|
|
// on retourne les modules en supprimant les valeurs à indices numériques
|
|
return moduleRepo::forStudent($etudiantUID, $semestreUID);
|
|
}
|
|
|
|
|
|
/**************************************/
|
|
/*** retourne les UEs d'un étudiant ***/
|
|
/**************************************/
|
|
public function getUEsEtudiant($etudiant, $semestre, $annee){
|
|
// on vérifie que le semestre et l'étudiant existent
|
|
if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
|
|
if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';
|
|
|
|
|
|
// on retourne la liste d'UEs en supprimant les doublons à clés numériques
|
|
return ueRepo::forStudent($etudiantUID, $semestreUID);
|
|
}
|
|
|
|
|
|
|
|
|
|
/**********************************************************/
|
|
/*** retourne la liste exhaustive des MODULES de la BDD ***/
|
|
/**********************************************************/
|
|
public function getExhaustiveModuleList(){
|
|
return moduleRepo::exhaustiveList();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************/
|
|
/*** retourne les modules d'un enseignant par UEs ***/
|
|
/****************************************************/
|
|
public function getModulesByUEByEnseignant($enseignant, $semestre_pair, $annee){
|
|
// on vérifie que l'enseignant enseigne bien cette année
|
|
if( !($enseignantUID=userRepo::UID($enseignant, null, $semestre_pair, $annee)) ) return 'unknown_teacher';
|
|
|
|
// on récupère les semestres de cette année
|
|
$semestreList = semestreRepo::forTeacher($enseignantUID, $semestre_pair, $annee);
|
|
|
|
foreach($semestreList as $iter_s=>$a){
|
|
$semestreList[$iter_s]['UElist'] = ueRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['id']);
|
|
|
|
foreach($semestreList[$iter_s]['UElist'] as $iter_u=>$b){
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'] = moduleRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['UElist'][$iter_u]['id'], $semestreList[$iter_s]['id']);
|
|
|
|
|
|
foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'] as $iter_m=>$MOD){
|
|
// on enregistre la liste des groupes inscrits
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['groupes'] = groupRepo::inscritsMccModule($MOD['id_mcc_module']);
|
|
|
|
foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['groupes'] as $iter_g=>$GROUPE){
|
|
// on enregistre "true" si l'enseignant les enseigne, sinon "false"
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['groupes'][$iter_g]['enseigne'] = userRepo::enseigne($enseignantUID, $MOD['id_mcc_module'], $GROUPE['id']);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $semestreList;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***************************************************/
|
|
/*** retourne les modules des semestres en cours ***/
|
|
/***************************************************/
|
|
public function getModulesByUEByYear($semestre_pair, $annee){ // ***OPTIONNEL*** semestre_pair
|
|
|
|
// on récupère les semestres de cette année
|
|
$semestreList = semestreRepo::forYear($annee);
|
|
|
|
foreach($semestreList as $iter_s=>$SEMESTRE){
|
|
$semestreList[$iter_s]['UElist'] = ueRepo::forYear($SEMESTRE['id']);
|
|
|
|
foreach($semestreList[$iter_s]['UElist'] as $iter_u=>$UE)
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'] = moduleRepo::forYear($UE['id'], $SEMESTRE['id']);
|
|
|
|
}
|
|
|
|
return $semestreList;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*******************************************/
|
|
/* _ _ ____ _______ ______ _____ */
|
|
/* | \ | |/ __ \__ __| ____|/ ____| */
|
|
/* | \| | | | | | | | |__ | (___ */
|
|
/* | . ` | | | | | | | __| \___ \ */
|
|
/* | |\ | |__| | | | | |____ ____) | */
|
|
/* |_| \_|\____/ |_| |______|_____/ */
|
|
/* */
|
|
/*******************************************/
|
|
|
|
|
|
/*********************************************************/
|
|
/* définie le caractère "publié" des notes d'un contrôle */
|
|
/*********************************************************/
|
|
public function publicationControle($controle, $publication){
|
|
// on vérifie l'existence du contrôle en question
|
|
if( !($controleObj=controleRepo::info($controle)) ) return 'unknown_controle';
|
|
|
|
// on met à jour le caractère "publié" du contrôle
|
|
return controleRepo::publication($controleObj['id'], $publication);
|
|
}
|
|
|
|
|
|
|
|
|
|
/**************************************/
|
|
/*** retourne les notes par modules ***/
|
|
/**************************************/
|
|
public function getNotesByModules($etudiant, $semestre, $annee){
|
|
// on vérifie que le semestre exist et que l'étudiant est inscrit à ce semestre
|
|
if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
|
|
if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';
|
|
|
|
|
|
$notelist = array(); // tableau qui contiendra tout les modules
|
|
|
|
$modulelist = $this->getModulesEtudiant($etudiant, $semestre, $annee); // on récupère la liste des modules
|
|
|
|
foreach($modulelist as $module){ // pour chaque module
|
|
|
|
$notes = $this->getModuleNotes($etudiant, $module['nom'], $semestre, $annee); // on récupère les notes
|
|
|
|
$current = array(); // on créé l'entrée qui sera dans le tableau de retour
|
|
$current['module'] = array();
|
|
$current['module']['nom'] = $module['nom']; // contenant le nom du module
|
|
$current['module']['libelle'] = $module['libelle']; // contenant le nom du module
|
|
$current['notes'] = $notes; // et la liste de notes
|
|
|
|
array_push($notelist, $current); // on l'ajoute au résultat
|
|
}
|
|
|
|
return $notelist;
|
|
}
|
|
|
|
|
|
/****************************************/
|
|
/*** retourne les notes d'un étudiant ***/
|
|
/****************************************/
|
|
public function getNotesEtudiant($etudiant, $semestre){
|
|
// on vérifie que le semestre exist et que l'étudiant est inscrit à ce semestre
|
|
if( !semestreRepo::exists($semestre) ) return 'unknown_semestre';
|
|
else $semestreUID = $semestre;
|
|
|
|
if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';
|
|
|
|
|
|
$UEList = ueRepo::forStudent($etudiantUID, $semestreUID);
|
|
|
|
foreach($UEList as $iter_ue=>$a){
|
|
$UEList[$iter_ue]['modules'] = moduleRepo::forStudent($UEList[$iter_ue]['id'], $semestreUID);
|
|
|
|
foreach($UEList[$iter_ue]['modules'] as $iter_mod=>$b){
|
|
$UEList[$iter_ue]['modules'][$iter_mod]['controles'] = controleRepo::forStudent($UEList[$iter_ue]['modules'][$iter_mod]['id'], $semestreUID);
|
|
|
|
foreach($UEList[$iter_ue]['modules'][$iter_mod]['controles'] as $iter_ct=>$c)
|
|
$UEList[$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['notes'] = noteRepo::forStudent($etudiantUID, $UEList[$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['id']);
|
|
}
|
|
|
|
}
|
|
|
|
return $UEList;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************/
|
|
/* retourne les informations du dossier étudiant */
|
|
/*************************************************/
|
|
public function getParcoursEtudiant($etudiant){
|
|
// on vérifie l'existence de l'étudiant
|
|
if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';
|
|
|
|
|
|
$parcours = semestreRepo::getParcours($etudiantUID);
|
|
|
|
// contiendra les couples [id_formation, rang] pour les semestres capitalisables
|
|
$listeSemestresFR = array();
|
|
|
|
/* [1] Chaque semestre
|
|
==========================*/
|
|
foreach($parcours as $iter_s=>$semestre){
|
|
// on récupère les id des UEs non pris en compte
|
|
$inactiveUE = explode(',', $semestre['inactive']);
|
|
// on supprime les entrées vides
|
|
foreach($inactiveUE as $i=>$UE)
|
|
if( strlen($UE) == 0 )
|
|
unset($inactiveUE[$i]);
|
|
|
|
// si pas déjà ajouté, on ajoute le rang+formation à la liste
|
|
if( !in_array( array($semestre['id_formation'], $semestre['rang']), $listeSemestresFR) )
|
|
array_push($listeSemestresFR, array($semestre['id_formation'], $semestre['rang']));
|
|
|
|
$parcours[$iter_s]['UEs'] = ueRepo::forStudent($etudiantUID, $semestre['id']);
|
|
|
|
/* CALCUL DE MOYENNE DU SEMESTRE */
|
|
$moyenneSemestre = 0; // contiendra la somme des valeurs*coefficients
|
|
$totalSemestre = 0; // contiendra la somme des coefficients
|
|
|
|
// par défaut le semestre est compensable
|
|
$semestreCompensable = true;
|
|
// vrai si le semestre est obtenu par compensation des UE
|
|
$semestreCompensation = false;
|
|
|
|
|
|
/* [2] Chaque UE
|
|
==========================*/
|
|
foreach($parcours[$iter_s]['UEs'] as $iter_ue=>$UE){
|
|
$parcours[$iter_s]['UEs'][$iter_ue]['modules'] = moduleRepo::forStudent($UE['id'], $semestre['id']);
|
|
|
|
/* CALCUL DE MOYENNE DE L'UE */
|
|
$moyenneUE = 0; // contiendra la somme des valeurs*coefficients
|
|
$totalUE = 0; // contiendra la somme des coefficients
|
|
|
|
/* [3] Chaque module
|
|
==========================*/
|
|
foreach($parcours[$iter_s]['UEs'][$iter_ue]['modules'] as $iter_mod=>$MOD){
|
|
$parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod]['controles'] = controleRepo::forStudent($MOD['id'], $semestre['id']);
|
|
|
|
$parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod]['moyenne'] = noteRepo::moyenneModule($etudiantUID, $MOD['id'], $semestre['id']);
|
|
|
|
|
|
|
|
// on complète la moyenne de l'UE si le module a une moyenne
|
|
$tmpModule = $parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod];
|
|
|
|
if( !is_bool($tmpModule['moyenne']) ){
|
|
$moyenneUE += $tmpModule['moyenne']['moyenne']/$tmpModule['moyenne']['base'] * $tmpModule['coefficient'];
|
|
$totalUE += $tmpModule['coefficient'];
|
|
}
|
|
|
|
/* [4] Chaque contrôle
|
|
==========================*/
|
|
foreach($parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod]['controles'] as $iter_ct=>$CONTROLE)
|
|
$parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['notes'] = noteRepo::forStudent($etudiantUID, $CONTROLE['id']);
|
|
|
|
|
|
}
|
|
|
|
/* ENREGISTREMENT DE LA MOYENNE DE L'UE */
|
|
if( $totalUE == 0 ) // si la somme vaut 0, on retourne FALSE
|
|
$parcours[$iter_s]['UEs'][$iter_ue]['moyenne'] = false;
|
|
else
|
|
$parcours[$iter_s]['UEs'][$iter_ue]['moyenne'] = array('moyenne' => 20*$moyenneUE/$totalUE, 'base' => 20 );
|
|
|
|
|
|
// on complète la moyenne du semestre
|
|
// SI l'UE a une moyenne
|
|
$tmpUE = $parcours[$iter_s]['UEs'][$iter_ue];
|
|
|
|
if( !is_bool($tmpUE['moyenne']) ){
|
|
$moyenneSemestre += $tmpUE['moyenne']['moyenne']/$tmpUE['moyenne']['base'] * $tmpUE['coefficient'];
|
|
$totalSemestre += $tmpUE['coefficient'];
|
|
|
|
// le semestre est non compensable si la moyenne d'au moins un UE < 8
|
|
// if( 20*$tmpUE['moyenne']['moyenne']/$tmpUE['moyenne']['base'] < 8 )
|
|
// $semestreCompensable = false;
|
|
|
|
// // semestreCompensé est VRAI si au moins un semestre est entre 8 et 10
|
|
// if( 20*$tmpUE['moyenne']['moyenne']/$tmpUE['moyenne']['base'] >= 8 && 20*$tmpUE['moyenne']['moyenne']/$tmpUE['moyenne']['base'] < 10 )
|
|
// $semestreCompensation = true;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* ENREGISTREMENT DE LA MOYENNE DU SEMESTRE */
|
|
// on enregistre les valeurs du calcul pour pouvoir calculer avec compensation
|
|
$parcours[$iter_s]['calculMoyenne'] = array( 'sum' => $moyenneSemestre, 'count' => $totalSemestre );
|
|
|
|
if( $totalSemestre == 0 ) // si la somme vaut 0, on retourne FALSE
|
|
$parcours[$iter_s]['moyenne'] = false;
|
|
else{
|
|
// on enregistre la moyenne
|
|
$parcours[$iter_s]['moyenne'] = array('moyenne' => 20*$moyenneSemestre/$totalSemestre, 'base' => 20 );
|
|
}
|
|
|
|
$parcours[$iter_s]['compensable'] = $semestreCompensable;
|
|
|
|
// si le semestre est obtenu et utilise la compensation => on le définit
|
|
if( $semestreCompensable && $semestreCompensation && $parcours[$iter_s]['moyenne']['moyenne'] >= 10 )
|
|
$parcours[$iter_s]['compensation'] = true;
|
|
else
|
|
$parcours[$iter_s]['compensation'] = false;
|
|
|
|
// on met la liste des id d'ue inactifs sous forme de tableau
|
|
$parcours[$iter_s]['inactive'] = $inactiveUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* LISTE DES UES CAPITALISÉES PAR SEMESTRES REGROUPÉS (FORMATION+RANG) */
|
|
// On ajoute toutes les UE capitalisées
|
|
foreach($listeSemestresFR as $i=>$formationRang){
|
|
|
|
// pour cette formation+rang, on récupère toutes les UEs
|
|
$listeUEs = array();
|
|
$UEUIDS = array();
|
|
$listeSemestresIndexes = array();
|
|
|
|
//var_dump('f:'.$formationRang[0].'/'.$formationRang[1]);
|
|
foreach(array_reverse($parcours, true) as $iter_s=>$semestre){
|
|
|
|
// si fait partie de la formation+rang courante
|
|
if( $formationRang == array( $semestre['id_formation'], $semestre['rang'] ) ){
|
|
|
|
// on ajoute l'index du semestre à la liste
|
|
array_push($listeSemestresIndexes, $iter_s);
|
|
|
|
// on ajoute chaque UE de ce semestre s'il est actif
|
|
foreach($semestre['UEs'] as $UE)
|
|
if( !in_array($UE['id'], $semestre['inactive']) ){
|
|
if( array_search($UE['id'], $UEUIDS) === false ){
|
|
// pour le premier UE (capitalisé) on s'assure de lui attribuer la capitalisation
|
|
//var_dump(' u:'.$UE['id']);
|
|
DataBase::getInstance()->capitaliserUE($UE['id'], $semestre['id'], $etudiantUID);
|
|
array_push( $listeUEs, $UE );
|
|
array_push( $UEUIDS, $UE['id'] );
|
|
}
|
|
}//else
|
|
//var_dump(' x:'.$UE['id']);
|
|
}
|
|
|
|
}
|
|
|
|
// variables utiles pour la moyenne
|
|
$moyenneSemestre = 0; $totalSemestre = 0;
|
|
$semestreCompensable = true; $semestreCompensation = false;
|
|
|
|
// pour chaque UE capitalisée
|
|
foreach($listeUEs as $iter_ue=>$UE){
|
|
// si l'UE a une moyenne
|
|
if( !is_bool($UE['moyenne']) ){
|
|
$moyenneSemestre += $UE['moyenne']['moyenne']/$UE['moyenne']['base'] * $UE['coefficient'];
|
|
$totalSemestre += $UE['coefficient'];
|
|
|
|
// le semestre est non compensable si la moyenne d'au moins un UE < 8
|
|
if( 20*$UE['moyenne']['moyenne']/$UE['moyenne']['base'] < 8 )
|
|
$semestreCompensable = false;
|
|
|
|
// semestreCompensé est VRAI si au moins un semestre est entre 8 et 10
|
|
elseif( 20*$UE['moyenne']['moyenne']/$UE['moyenne']['base'] < 10 ){
|
|
$semestreCompensation = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// attribution des moyennes aux semestres concernés
|
|
foreach($listeSemestresIndexes as $index){
|
|
if( $totalSemestre > 0 )
|
|
$parcours[$index]['moyenne'] = array( 'moyenne' => 20*$moyenneSemestre/$totalSemestre, 'base' => 20 );
|
|
else
|
|
$parcours[$index]['moyenne'] = array( 'moyenne' => 0, 'base' => 20 );
|
|
|
|
// on met à jour le semestre compensable, et compensation
|
|
$parcours[$index]['compensable'] = $semestreCompensable;
|
|
$parcours[$index]['compensation'] = $semestreCompensation && $parcours[$index]['moyenne']['moyenne'] >= 10;
|
|
}
|
|
|
|
}
|
|
|
|
return $parcours;
|
|
}
|
|
|
|
|
|
/*******************************************/
|
|
/*** retourne les notes d'un enseignant ***/
|
|
/*******************************************/
|
|
public function getControlesEnseignant($enseignant, $semestre_pair, $annee){
|
|
// on vérifie que le semestre existe et que l'enseignant y enseigne
|
|
if( !($enseignantUID=userRepo::UID($enseignant, null, $semestre_pair, $annee)) ) return 'unknown_teacher';
|
|
|
|
// on récupère les semestres de cette année
|
|
$semestreList = semestreRepo::forTeacher($enseignantUID, $semestre_pair, $annee);
|
|
|
|
foreach($semestreList as $iter_s=>$a){
|
|
|
|
$semestreList[$iter_s]['UElist'] = ueRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['id']);
|
|
|
|
foreach($semestreList[$iter_s]['UElist'] as $iter_u=>$b){
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'] = moduleRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['UElist'][$iter_u]['id'], $semestreList[$iter_s]['id']);
|
|
|
|
foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'] as $iter_m=>$c){
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'] = controleRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['id'], $semestreList[$iter_s]['id']);
|
|
|
|
foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'] as $iter_ct=>$c){
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['grouplist'] = noteRepo::forControle($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['id']);
|
|
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['moyenne'] = noteRepo::moyenneForControle($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['id']);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $semestreList;
|
|
}
|
|
|
|
|
|
|
|
/***************************************/
|
|
/*** retourne les notes d'une année ***/
|
|
/***************************************/
|
|
public function getControlesForYear($annee){
|
|
// on récupère les semestres de cette année
|
|
$semestreList = semestreRepo::forYear($annee);
|
|
|
|
foreach($semestreList as $iter_s=>$a){
|
|
$semestreList[$iter_s]['UElist'] = ueRepo::forYear($semestreList[$iter_s]['id']);
|
|
|
|
foreach($semestreList[$iter_s]['UElist'] as $iter_u=>$b){
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'] = moduleRepo::forYear($semestreList[$iter_s]['UElist'][$iter_u]['id'], $semestreList[$iter_s]['id']);
|
|
|
|
foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'] as $iter_m=>$c){
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'] = controleRepo::forYear($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['id'], $semestreList[$iter_s]['id']);
|
|
|
|
foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'] as $iter_ct=>$c){
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['grouplist'] = noteRepo::forControle($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['id']);
|
|
|
|
$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['moyenne'] = noteRepo::moyenneForControle($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['id']);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $semestreList;
|
|
}
|
|
|
|
|
|
|
|
|
|
/***********************************************************/
|
|
/*** retourne les notes pour un contrôle d'un enseignant ***/
|
|
/***********************************************************/
|
|
public function getNotesForControleEnseignant($enseignant, $annee, $controle, $groupe=null){ // [OPTIONNEL] $groupe
|
|
|
|
// on vérifie que le semestre existe et que l'enseignant y enseigne
|
|
if( !($enseignantUID=userRepo::UID($enseignant)) ) return 'unknown_teacher';
|
|
|
|
// on récupère les informations du contrôle
|
|
if( !($controlObj=controleRepo::info($controle, $enseignant, $groupe)) ) return 'unknown_controle';
|
|
|
|
// on ajoute la moyenne au contrôle
|
|
$controlObj['moyenne'] = noteRepo::moyenneForControle($controlObj['id']);
|
|
|
|
/* [1] si le groupe est donné
|
|
=======================================*/
|
|
if( $groupe != null ){
|
|
if( !($groupeUID=groupRepo::info($groupe)['id']) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID; // on récupère l'UID du groupe
|
|
|
|
$controlObj['moyenneGroupe'] = noteRepo::forGroupe($controle, $groupeUID)['moyenne'];
|
|
|
|
$controlObj['userlist'] = groupRepo::membres($groupeUID, $controlObj['id_semestre']); // on récupère la liste des étudiants de ce groupe
|
|
|
|
foreach($controlObj['userlist'] as $iter=>$note)
|
|
if( $resultNote = noteRepo::forStudent($controlObj['userlist'][$iter]['identifiant'], $controle) ) // si l'étudiant a une note pour ce controle
|
|
$controlObj['userlist'][$iter]['note'] = $resultNote[0]['valeur'];
|
|
else
|
|
$controlObj['userlist'][$iter]['note'] = null;
|
|
|
|
/* [2] si on veut par groupe
|
|
=======================================*/
|
|
}else{
|
|
$controlObj['grouplist'] = groupRepo::forControle($controle, $enseignant);
|
|
|
|
foreach($controlObj['grouplist'] as $iter=>$grpe)
|
|
if( $controleNotes = noteRepo::forGroupe($controle, $grpe['id_groupe']) ) // si le groupe a des notes, on les ajoutes
|
|
$controlObj['grouplist'][$iter] = array_merge($controlObj['grouplist'][$iter], $controleNotes);
|
|
|
|
}
|
|
|
|
return $controlObj;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*******************************************/
|
|
/*** retourne les notes pour un contrôle ***/
|
|
/*******************************************/
|
|
public function getNotesForControle($annee, $controle, $groupe=null){ // [OPTIONNEL] $groupe
|
|
|
|
// on récupère les informations du contrôle
|
|
if( !($controlObj=controleRepo::info($controle)) ) return 'unknown_controle';
|
|
|
|
// on ajoute la moyenne au contrôle
|
|
$controlObj['moyenne'] = noteRepo::moyenneForControle($controlObj['id']);
|
|
|
|
/* [1] si le groupe est donné
|
|
=======================================*/
|
|
if( $groupe != null ){
|
|
if( !($groupeUID=groupRepo::info($groupe)['id']) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID; // on récupère l'UID du groupe
|
|
|
|
$controlObj['moyenneGroupe'] = noteRepo::forGroupe($controle, $groupeUID)['moyenne'];
|
|
|
|
$controlObj['userlist'] = groupRepo::membres($groupeUID, $controlObj['id_semestre']); // on récupère la liste des étudiants de ce groupe
|
|
|
|
foreach($controlObj['userlist'] as $iter=>$note)
|
|
if( $resultNote = noteRepo::forStudent($controlObj['userlist'][$iter]['identifiant'], $controle) ) // si l'étudiant a une note pour ce controle
|
|
$controlObj['userlist'][$iter]['note'] = $resultNote[0]['valeur'];
|
|
else
|
|
$controlObj['userlist'][$iter]['note'] = null;
|
|
|
|
/* [2] si on veut par groupe
|
|
=======================================*/
|
|
}else{
|
|
$controlObj['grouplist'] = groupRepo::forControle($controle);
|
|
|
|
foreach($controlObj['grouplist'] as $iter=>$grpe)
|
|
if( $controleNotes = noteRepo::forGroupe($controle, $grpe['id_groupe']) ) // si le groupe a des notes, on les ajoutes
|
|
$controlObj['grouplist'][$iter] = array_merge($controlObj['grouplist'][$iter], $controleNotes);
|
|
|
|
// var_dump( $controlObj );
|
|
debug();
|
|
}
|
|
|
|
return $controlObj;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/******************************************/
|
|
/*** saisie note étudiant à un contrôle ***/
|
|
/******************************************/
|
|
public function saisieNote($etudiant, $controle, $note){
|
|
// on vérifie l'existence de l'étudiant et du contrôle, ainsi que la cohérence de la note (pas supérieure à la base)
|
|
if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';
|
|
if( !($controleInfo=controleRepo::info($controle)) ) return 'unknown_controle';
|
|
if( $note > $controleInfo['base'] ) return 'unknown_note';
|
|
|
|
// saisie de la note
|
|
$rep = noteRepo::creer($etudiantUID, $controleInfo['id'], $controleInfo['id_semestre'], $note);
|
|
|
|
// var_dump( $rep );
|
|
|
|
if( $rep )
|
|
return 'success';
|
|
else
|
|
return 'error';
|
|
|
|
}
|
|
|
|
|
|
/******************************/
|
|
/*** saisie notes multiples ***/
|
|
/******************************/
|
|
public function saisieNoteMultiple($controle, $notes){
|
|
if( !($controleInfo=controleRepo::info($controle)) ) return 'unknown_controle';
|
|
|
|
foreach($notes as $iter=>$NOTE){
|
|
|
|
$NOTE->valeur = floatval($NOTE->valeur);
|
|
|
|
// on vérifie l'existence de l'étudiant et du contrôle, ainsi que la cohérence de la note (pas supérieure à la base)
|
|
if( !(userRepo::UID($NOTE->etudiant)) ) return 'unknown_user';
|
|
|
|
// si la note > base du contrôle, on supprime la note
|
|
if( $NOTE->valeur > $controleInfo['base'] )
|
|
unset( $notes[$iter] );
|
|
}
|
|
|
|
// saisie multiple des notes
|
|
$rep = noteRepo::creerMultiple($controleInfo['id'], $controleInfo['id_semestre'], $notes);
|
|
|
|
if( $rep )
|
|
return 'success';
|
|
else
|
|
return 'error';
|
|
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
|
|
** ad88888ba 88888888888 db 88888888ba ,ad8888ba, 88 88 **
|
|
** d8" "8b 88 d88b 88 "8b d8"' `"8b 88 88 **
|
|
** Y8, 88 d8'`8b 88 ,8P d8' 88 88 **
|
|
** `Y8aaaaa, 88aaaaa d8' `8b 88aaaaaa8P' 88 88aaaaaaaa88 **
|
|
** `"""""8b, 88""""" d8YaaaaY8b 88""""88' 88 88""""""""88 **
|
|
** `8b 88 d8""""""""8b 88 `8b Y8, 88 88 **
|
|
** Y8a a8P 88 d8' `8b 88 `8b Y8a. .a8P 88 88 **
|
|
** "Y88888P" 88888888888 d8' `8b 88 `8b `"Y8888Y"' 88 88 **
|
|
|
|
*****************************************************************************************************/
|
|
|
|
public function searchForUsers($keyword){
|
|
|
|
$results = groupRepo::search($keyword);
|
|
|
|
// si aucun erreur, on retourne FAUX
|
|
if ( !$results ) return false;
|
|
|
|
//On classe les résultats en fonction de si c'est un étudiant ou bien un professeur
|
|
foreach ($results as $num=>$user) {
|
|
// On supprime tous les non-étudiants
|
|
if( $user['droits'] != 'student')
|
|
unset($results[$num]);
|
|
}
|
|
|
|
return $results;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
?>
|