723 lines
28 KiB
PHP
Executable File
723 lines
28 KiB
PHP
Executable File
<?php require_once __ROOT__.'/manager/security.php';
|
|
|
|
/* INCLUSION DES REPOs */
|
|
require_once __ROOT__.'/manager/repo/user.php'; // gestion des utilisateurs (UID, infos, création, modification)
|
|
require_once __ROOT__.'/manager/repo/group.php'; // gestion des groupes & appartenances (UID, ajouter membres, visu membres, création, modification)
|
|
require_once __ROOT__.'/manager/repo/semestre.php';
|
|
require_once __ROOT__.'/manager/repo/module.php';
|
|
require_once __ROOT__.'/manager/repo/ue.php';
|
|
require_once __ROOT__.'/manager/repo/controle.php';
|
|
require_once __ROOT__.'/manager/repo/note.php';
|
|
// debug();
|
|
|
|
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 )
|
|
DataBase::$instance = new DataBase("localhost", "sid2", "php", "Qt358nUdyeTxLDM8");
|
|
|
|
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){
|
|
// 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( is_int($col) ) // si l'indice est un entier
|
|
unset( $fetchData[$i][$col] ); // on le supprime
|
|
|
|
return $fetchData;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*************************************************************************************/
|
|
/* _ _ _______ _____ _ _____ _____ _______ ______ _ _ _____ */
|
|
/* | | | |__ __|_ _| | |_ _|/ ____| /\|__ __| ____| | | | __ \ */
|
|
/* | | | | | | | | | | | | | (___ / \ | | | |__ | | | | |__) | */
|
|
/* | | | | | | | | | | | | \___ \ / /\ \ | | | __| | | | | _ / */
|
|
/* | |__| | | | _| |_| |____ _| |_ ____) / ____ \| | | |____| |__| | | \ \ */
|
|
/* \____/ |_| |_____|______|_____|_____/_/ \_\_| |______|\____/|_| \_\ */
|
|
/* */
|
|
/*************************************************************************************/
|
|
|
|
|
|
/*********************************************/
|
|
/*** 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 à ajouter au groupe
|
|
*
|
|
* @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 $semestre;
|
|
else
|
|
return 'error';
|
|
}
|
|
|
|
/**********************************************************/
|
|
/* _____ _____ ____ _ _ _____ ______ _____ */
|
|
/* / ____| __ \ / __ \| | | | __ \| ____|/ ____| */
|
|
/* | | __| |__) | | | | | | | |__) | |__ | (___ */
|
|
/* | | |_ | _ /| | | | | | | ___/| __| \___ \ */
|
|
/* | |__| | | \ \| |__| | |__| | | | |____ ____) | */
|
|
/* \_____|_| \_\\____/ \____/|_| |______|_____/ */
|
|
/* */
|
|
/**********************************************************/
|
|
|
|
|
|
/****************************************/
|
|
/*** 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 d'un groupe ***/
|
|
/******************************************************/
|
|
public function listeEtudiantsGroupe($groupe, $semestre, $annee){
|
|
// on vérifie que le groupe et le semestre existent
|
|
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;
|
|
|
|
// on retourne la liste des utilisateurs et on supprime les doublons à indices numériques
|
|
return DataBase::delNumeric( groupRepo::membres($groupeUID, $semestreUID) );
|
|
|
|
}
|
|
|
|
/********************************************************************/
|
|
/*** retourne la liste des utilisateurs des groupes d'un semestre ***/
|
|
/********************************************************************/
|
|
public function listeEtudiantsTousGroupesSemestre($semestre, $annee){
|
|
// on vérifie que le semestre existe
|
|
if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
|
|
|
|
|
|
// on cherche tout les groupes du même semestre de la même année
|
|
$getGroupesUID = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe as id, g.nom, s.rang, s.nom as semestre ".
|
|
"FROM groupe as g, semestre as s, appartenance as app ".
|
|
"WHERE g.id_groupe = app.id_groupe ".
|
|
"AND s.id_semestre = app.id_semestre ".
|
|
|
|
"AND s.id_semestre = :semestreUID ".
|
|
"ORDER BY g.nom");
|
|
$getGroupesUID->execute(array(
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
$grouplist = $getGroupesUID->fetchAll(); // 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, $pSemestre=null, $pGroupe=null){ // pSemestre/pGroupe optionnels
|
|
// définition des paramètres optionnels
|
|
$semestreOpt = '%';
|
|
if( $pSemestre != null ) $semestreOpt = $pSemestre; // semestre donné uniquement (si param non null)
|
|
|
|
$groupeOpt = '%';
|
|
if( $pGroupe != null ) $groupeOpt = $pGroupe; // si le groupe est donné, on le définit
|
|
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$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 récupère la liste des groupes
|
|
$grouplist = DataBase::delNumeric( groupRepo::forYear($semestre_pair, $annee, $pSemestre, $pGroupe) );
|
|
|
|
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, $pSemestre, $pGroupe){
|
|
// définition des paramètres optionnels
|
|
$semestreOpt = '%';
|
|
if( $pSemestre != null ) $semestreOpt = $pSemestre; // semestre donné uniquement (si param non null)
|
|
|
|
$groupeOpt = '%';
|
|
if( $pGroupe != null ) $groupeOpt = $pGroupe; // si le groupe est donné, on le définit
|
|
|
|
|
|
/*** 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, $pSemestre, $pGroupe) );
|
|
|
|
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 le nom du groupe d'un étudiant ***/
|
|
/***********************************************/
|
|
public function getGroupeEtudiant($etudiant, $semestre, $annee){
|
|
// on vérifie que le semestre et l'utilisateur existent
|
|
if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
|
|
if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';
|
|
|
|
|
|
// on cherche le groupe associé
|
|
$getNomGroupe = DataBase::getPDO()->prepare("SELECT g.nom ".
|
|
"FROM utilisateur as u, groupe as g, appartenance as app ".
|
|
"WHERE app.id_etudiant = u.identifiant ".
|
|
"AND app.id_groupe = g.id_groupe ".
|
|
"AND u.identifiant = :etudiantUID ".
|
|
|
|
"AND app.id_semestre = :semestreUID ".
|
|
"ORDER BY g.nom");
|
|
$getNomGroupe->execute(array( ':etudiantUID' => $etudiantUID, ':semestreUID' => $semestreUID ));
|
|
|
|
// si on a un résultat
|
|
if( $nomGroupe = $getNomGroupe->fetch()['nom'] )
|
|
return $nomGroupe;
|
|
else
|
|
return 'error';
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/******************************************************/
|
|
/***** déplace un étudiant d'un groupe à un autre *****/
|
|
/******************************************************/
|
|
public function deplacerEtudiant($etudiant, $groupe, $annee){
|
|
|
|
|
|
/*** on cherche le nouveau groupe pour cet utilisateur ***/
|
|
$getNouveauGroupeUID = DataBase::getPDO()->prepare("SELECT DISTINCT s.id_semestre as semestre, g.id_groupe as id, u.identifiant as etuUID ".
|
|
"FROM groupe as g, appartenance as app, appartenance as myapp, utilisateur as u, semestre as s ".
|
|
"WHERE g.nom = :groupe ".
|
|
"AND u.identifiant = :etudiant ".
|
|
|
|
"AND myapp.id_etudiant = u.identifiant ".
|
|
"AND myapp.id_semestre = s.id_semestre ".
|
|
|
|
"AND app.id_groupe = g.id_groupe ".
|
|
"AND app.id_semestre = s.id_semestre");
|
|
$getNouveauGroupeUID->execute(array(
|
|
':groupe' => $groupe,
|
|
':etudiant' => $etudiant
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $data = $getNouveauGroupeUID->fetch() ){
|
|
$nouveauGroupeUID = (int) $data['id'];
|
|
$semestreUID = $data['semestre'];
|
|
$etudiantUID = $data['etuUID'];
|
|
}
|
|
else
|
|
return 'unknown_newgroup';
|
|
|
|
|
|
/*** on cherche le groupe de cet utilisateur ***/
|
|
$getGroupeUID = DataBase::getPDO()->prepare("SELECT g.id_groupe as id ".
|
|
"FROM utilisateur as u, groupe as g, appartenance as app, semestre as s ".
|
|
"WHERE app.id_etudiant = u.identifiant ".
|
|
"AND app.id_groupe = g.id_groupe ".
|
|
"AND app.id_semestre = s.id_semestre ".
|
|
|
|
"AND u.identifiant = :etudiantUID ".
|
|
"AND app.id_semestre = :semestreUID");
|
|
$getGroupeUID->execute(array(
|
|
':etudiantUID' => $etudiantUID,
|
|
':semestreUID' => $semestreUID,
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $groupeUID = $getGroupeUID->fetch()['id'] ){
|
|
$groupeUID = $groupeUID;
|
|
|
|
/***************************************************************/
|
|
/*** CAS 1 : l'utilisateur a déjà un groupe pour ce semestre ***/
|
|
/***************************************************************/
|
|
|
|
// il suffit donc maintenant de modifier l' "appartenance"
|
|
$updateGroupe = DataBase::getPDO()->prepare("UPDATE appartenance SET id_groupe = :nouveauGroupeUID ".
|
|
"WHERE id_etudiant = :etudiantUID ".
|
|
"AND id_groupe = :groupeUID ".
|
|
"AND id_semestre = :semestreUID");
|
|
$updateGroupe->execute(array(
|
|
':nouveauGroupeUID' => $nouveauGroupeUID,
|
|
':etudiantUID' => $etudiantUID,
|
|
':groupeUID' => $groupeUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
}
|
|
else{
|
|
/****************************************************/
|
|
/*** CAS 2 : l'utilisateur n'a pas encore de groupe */
|
|
/****************************************************/
|
|
$insertGroupe = DataBase::getPDO()->prepare("INSERT INTO appartenance(id_appartenance, id_etudiant, id_groupe, id_semestre) ".
|
|
"VALUES(NULL, :etudiantUID, :nouveauGroupeUID, :semestreUID)");
|
|
$insertGroupe->execute(array(
|
|
':etudiantUID' => $etudiantUID,
|
|
':nouveauGroupeUID' => $nouveauGroupeUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
}
|
|
|
|
/* Vérification de l'entrée dans la table */
|
|
$verif = DataBase::getPDO()->prepare("SELECT count(id_appartenance) as count ".
|
|
"FROM appartenance ".
|
|
"WHERE id_etudiant = :etudiantUID ".
|
|
"AND id_groupe = :nouveauGroupeUID ".
|
|
"AND id_semestre = :semestreUID");
|
|
$verif->execute(array(
|
|
':etudiantUID' => $etudiantUID,
|
|
':nouveauGroupeUID' => $nouveauGroupeUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
$verifFetch = $verif->fetch();
|
|
|
|
if( $verifFetch && $verifFetch['count'] == '1' )
|
|
return 'success';
|
|
else
|
|
return 'error';
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**********************************************************/
|
|
/* */
|
|
/* __ __ ____ _____ _ _ _ ______ _____ */
|
|
/* | \/ |/ __ \| __ \| | | | | | ____|/ ____| */
|
|
/* | \ / | | | | | | | | | | | | |__ | (___ */
|
|
/* | |\/| | | | | | | | | | | | | __| \___ \ */
|
|
/* | | | | |__| | |__| | |__| | |____| |____ ____) | */
|
|
/* |_| |_|\____/|_____/ \____/|______|______|_____/ */
|
|
/* */
|
|
/**********************************************************/
|
|
|
|
|
|
|
|
/**************************************************/
|
|
/*** retourne les modules d'un étudiant par UEs ***/
|
|
/**************************************************/
|
|
public function getModulesByUEByEtudiant($etudiant, $semestre, $annee){
|
|
// on vérifie que le semestre et l'utilisateur existent
|
|
if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
|
|
if( !($etudiantUID=userRepo::UID($etudiant)) ) 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 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';
|
|
|
|
$UEList = $this->getUEsEnseignant($enseignant, $semestre_pair, $annee); // on récupère la liste des UEs
|
|
|
|
foreach($UEList as $iter=>$UE){
|
|
|
|
// si on a l'UID enseignant & l'UE => on récupère les modules
|
|
$getModuleList = DataBase::getPDO()->prepare("SELECT DISTINCT m.id_module as id, m.nom as nom, m.libelle as libelle ".
|
|
"FROM enseignement as ens, semestre as s, ue, module as m, mcc_ue, mcc_module as mcc_m ".
|
|
"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 mcc_ue.id_ue = ue.id_ue ".
|
|
|
|
"AND ens.id_enseignant = :enseignantUID ".
|
|
"AND ue.id_ue = :UEUID ".
|
|
"AND s.annee = :annee ".
|
|
"AND s.rang % 2 = :semestre_pair ".
|
|
"ORDER BY m.nom, m.libelle ASC");
|
|
$getModuleList->execute(array(
|
|
':enseignantUID' => $enseignantUID,
|
|
':UEUID' => $UE['id'],
|
|
':annee' => $annee,
|
|
':semestre_pair' => ($semestre_pair) ? '0' : '1'
|
|
));
|
|
|
|
// on ajoute la liste des modules en supprimant les valeurs à indinces numériques
|
|
$UEList[$iter]['modules'] = DataBase::delNumeric( $getModuleList->fetchAll() );
|
|
}
|
|
|
|
return $UEList;
|
|
}
|
|
|
|
|
|
/****************************************/
|
|
/*** retourne les UEs d'un enseignant ***/
|
|
/****************************************/
|
|
public function getUEsEnseignant($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 retourne la liste des UEs en supprimant les doublons à indices numériques
|
|
return ueRepo::forTeacher($enseignantUID, $semestre_pair, $annee);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***************************************************/
|
|
/*** retourne les modules des semestres en cours ***/
|
|
/***************************************************/
|
|
public function getModulesByUEByYear($semestre_pair, $annee){ // ***OPTIONNEL*** semestre_pair
|
|
// on récupère la liste des UEs
|
|
$UEList = ueRepo::forYear($semestre_pair, $annee);
|
|
|
|
foreach($UEList as $iter=>$UE) // pour chaque UE, on récupère la liste des UEs
|
|
$UEList[$iter]['modules'] = moduleRepo::forYear($UE['id'], $semestre_pair, $annee);
|
|
|
|
return $UEList;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*******************************************/
|
|
/* _ _ ____ _______ ______ _____ */
|
|
/* | \ | |/ __ \__ __| ____|/ ____| */
|
|
/* | \| | | | | | | | |__ | (___ */
|
|
/* | . ` | | | | | | | __| \___ \ */
|
|
/* | |\ | |__| | | | | |____ ____) | */
|
|
/* |_| \_|\____/ |_| |______|_____/ */
|
|
/* */
|
|
/*******************************************/
|
|
|
|
|
|
|
|
/**************************************/
|
|
/*** 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, $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';
|
|
|
|
|
|
$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 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';
|
|
|
|
|
|
$UEList = ueRepo::forTeacher($enseignantUID, $semestre_pair, $annee);
|
|
|
|
foreach($UEList as $iter_ue=>$a){
|
|
$UEList[$iter_ue]['modules'] = moduleRepo::forTeacher($enseignantUID, $UEList[$iter_ue]['id'], $UEList[$iter_ue]['id_semestre']);
|
|
|
|
foreach($UEList[$iter_ue]['modules'] as $iter_mod=>$b){
|
|
$UEList[$iter_ue]['modules'][$iter_mod]['controles'] = controleRepo::forTeacher($enseignantUID, $UEList[$iter_ue]['modules'][$iter_mod]['id'], $UEList[$iter_ue]['id_semestre']);
|
|
|
|
foreach($UEList[$iter_ue]['modules'][$iter_mod]['controles'] as $iter_ct=>$c){
|
|
$UEList[$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['grouplist'] = noteRepo::forTeacher($UEList[$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['id']);
|
|
|
|
$UEList[$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['moyenne'] = noteRepo::moyenneForControle($UEList[$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['id']);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $UEList;
|
|
}
|
|
|
|
|
|
|
|
|
|
/********************************************/
|
|
/*** retourne les notes pour un contrôle ***/
|
|
/********************************************/
|
|
public function getNotesEnseignant($enseignant, $semestre_pair, $annee, $controle, $groupe=null){ // [OPTIONNEL] $groupe
|
|
|
|
|
|
// on récupère les informations du contrôle
|
|
if( ! ($controlObj=controleRepo::info($controle)) ) return 'unknown_controle';
|
|
|
|
/* [1] si le groupe est donné
|
|
=======================================*/
|
|
if( $groupe != null ){
|
|
if( !($groupeUID=groupRepo::UID($groupe)) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID; // on récupère l'UID du groupe
|
|
|
|
$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{
|
|
// on ajoute au controle['notes'] la liste des notes des groupes
|
|
// $controlObj['grouplist'] = noteRepo::forTeacher($controle, null);
|
|
|
|
$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);
|
|
|
|
if( $rep )
|
|
return 'success';
|
|
else
|
|
return 'error';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
?>
|