882 lines
30 KiB
PHP
Executable File
882 lines
30 KiB
PHP
Executable File
<?php require_once __ROOT__.'/manager/security.php';
|
|
|
|
|
|
class DataBase{
|
|
|
|
/* ATTRIBUTS */
|
|
private $host;
|
|
private $dbname;
|
|
private $username;
|
|
private $password;
|
|
|
|
private $pdo;
|
|
|
|
public function __construct($host, $dbname, $username, $password){
|
|
$this->host = $host;
|
|
$this->dbname = $dbname;
|
|
$this->username = $username;
|
|
$this->password = $password;
|
|
|
|
// password: Qt358nUdyeTxLDM8
|
|
$this->pdo = new PDO('mysql:host='.$host.';dbname='.$dbname, $username, $password);
|
|
}
|
|
|
|
|
|
/* retourne une instance de la classe */
|
|
public static function getInstance(){
|
|
return new DataBase("localhost", "sid2", "php", "Qt358nUdyeTxLDM8");
|
|
}
|
|
|
|
/*********************************************/
|
|
/*** création d'un utilisateur dans la bdd ***/
|
|
/*********************************************/
|
|
public function creerUtilisateur($identifiant, $prenom, $nom, $mail, $mdp, $droits){
|
|
$getLastCount = $this->pdo->query('SELECT count(identifiant) as count FROM utilisateur');
|
|
$lastCount = (int) $getLastCount->fetch()['count'];
|
|
|
|
// on applique une normalisation
|
|
$prenom = ucwords( strtolower($prenom) ); // majuscule à chaque mot sinon minuscule
|
|
$nom = strtoupper($nom); // nom en majuscules
|
|
$mail = strtolower($mail); // email en minuscules
|
|
$mdp = sha1($mdp); // on hash le password
|
|
|
|
$req = $this->pdo->prepare("INSERT INTO utilisateur(identifiant, prenom, nom, mail, mdp, droits) VALUES(:identifiant, :prenom, :nom, :mail, :mdp, :droits)");
|
|
|
|
$req->execute(array(
|
|
':identifiant' => $identifiant,
|
|
':prenom' => $prenom,
|
|
':nom' => $nom,
|
|
':mail' => $mail,
|
|
':mdp' => $mdp,
|
|
':droits' => $droits
|
|
));
|
|
|
|
$getNewCount = $this->pdo->query('SELECT count(identifiant) as count FROM utilisateur');
|
|
$newCount = (int) $getNewCount->fetch()['count'];
|
|
|
|
if( $newCount > $lastCount ) // si on a bien ajouté un entrée
|
|
return 'success';
|
|
else
|
|
return 'error';
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************/
|
|
/*** création d'un groupe dans la bdd ***/
|
|
/****************************************/
|
|
public function creerGroupe($nom){
|
|
$getLastCount = $this->pdo->query('SELECT count(id_groupe) as count FROM groupe');
|
|
$lastCount = (int) $getLastCount->fetch()['count'];
|
|
|
|
// on applique une normalisation
|
|
$nom = strtoupper($nom); // nom en majuscules
|
|
|
|
$req = $this->pdo->prepare("INSERT INTO groupe(id_groupe, nom) VALUES(default, :nom)");
|
|
|
|
$req->execute(array(
|
|
':nom' => $nom
|
|
));
|
|
|
|
|
|
$getNewCount = $this->pdo->query('SELECT count(id_groupe) as count FROM groupe');
|
|
$newCount = (int) $getNewCount->fetch()['count'];
|
|
|
|
if( $newCount > $lastCount ) // si on a bien ajouté un entrée
|
|
return 'success';
|
|
else
|
|
return 'error';
|
|
|
|
}
|
|
|
|
/******************************************************/
|
|
/*** ajout d'un utilisateur à un groupe dans la bdd ***/
|
|
/******************************************************/
|
|
public function ajouterEtudiantGroupe($etudiant, $groupe, $semestre, $annee){
|
|
$getLastCount = $this->pdo->query('SELECT count(id_etudiant) as count FROM appartenance');
|
|
$lastCount = (int) $getLastCount->fetch()['count'];
|
|
|
|
|
|
/*** on cherche un utilisateur avec cet identifiant ***/
|
|
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
|
|
$getEtudiantUID->execute(array(
|
|
':etudiant' => $etudiant
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
|
|
$etudiantUID = $etudiantUID;
|
|
else
|
|
return 'unknown_user';
|
|
|
|
|
|
/*** on cherche un groupe avec ce nom ***/
|
|
$getGroupeUID = $this->pdo->prepare("SELECT id_groupe as id FROM groupe WHERE nom = :nom");
|
|
$getGroupeUID->execute(array(
|
|
':nom' => $groupe
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $groupeUID = $getGroupeUID->fetch()['id'] )
|
|
$groupeUID = (int) $groupeUID;
|
|
else
|
|
return 'unknown_group';
|
|
|
|
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
|
|
|
|
|
|
// si on a l'UID utilisateur & l'UID groupe => on créé l'association
|
|
$asso = $this->pdo->prepare("INSERT INTO appartenance(id_etudiant, id_groupe, id_semestre) ".
|
|
"VALUES( ".
|
|
"(SELECT identifiant FROM utilisateur WHERE identifiant = :etudiantUID), ".
|
|
"(SELECT id_groupe FROM groupe WHERE id_groupe = :groupeUID), ".
|
|
"(SELECT id_semestre FROM semestre WHERE id_semestre = :semestreUID) ".
|
|
" )");
|
|
$asso->execute(array(
|
|
':etudiantUID' => $etudiantUID,
|
|
':groupeUID' => $groupeUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
|
|
|
|
$getNewCount = $this->pdo->query('SELECT count(id_etudiant) as count FROM appartenance');
|
|
$newCount = (int) $getNewCount->fetch()['count'];
|
|
|
|
if( $newCount > $lastCount ) // 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 cherche un groupe avec ce nom ***/
|
|
$getGroupeUID = $this->pdo->prepare("SELECT id_groupe as id FROM groupe WHERE nom = :nom");
|
|
$getGroupeUID->execute(array(
|
|
':nom' => $groupe
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $groupeUID = $getGroupeUID->fetch()['id'] )
|
|
$groupeUID = (int) $groupeUID;
|
|
else
|
|
return 'unknown_group';
|
|
|
|
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
|
|
|
|
// si le groupe existe => on récupère ses utilisateurs
|
|
$appartenance = $this->pdo->prepare("SELECT u.identifiant, u.prenom, u.nom, u.mail, u.droits ".
|
|
"FROM utilisateur as u, groupe as g, semestre as s, appartenance as app ".
|
|
"WHERE u.identifiant = app.id_etudiant ".
|
|
"AND g.id_groupe = app.id_groupe ".
|
|
"AND s.id_semestre = app.id_semestre ". // à virer (peut-être)
|
|
|
|
"AND g.id_groupe = :groupeUID ".
|
|
"AND s.id_semestre = :semestreUID ".
|
|
"ORDER BY u.prenom, u.nom");
|
|
$appartenance->execute(array(
|
|
':groupeUID' => $groupeUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
|
|
$userlist = $appartenance->fetchAll();
|
|
|
|
// on supprime les doublons des entrées (indice numérique)
|
|
for( $i = 0 ; $i < count($userlist) ; $i++ ) // pour tout les utilisateurs
|
|
foreach($userlist[$i] as $col => $val) // pour toutes les entrées
|
|
if( is_int($col) ) // si l'indice est un entier
|
|
unset( $userlist[$i][$col] ); // on le supprime
|
|
|
|
|
|
return $userlist; // on retourne le liste d'utilisateurs
|
|
|
|
}
|
|
|
|
/******************************************************/
|
|
/*** retourne la liste des utilisateurs des groupes ***/
|
|
/******************************************************/
|
|
public function listeEtudiantsTousGroupes($semestre, $annee){
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
// on cherche tout les groupes du même semestre de la même année
|
|
$getGroupesUID = $this->pdo->prepare("SELECT DISTINCT g.nom ".
|
|
"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 = array(); // contiendra tout les groupes
|
|
|
|
// on parcourt tous les groupes
|
|
while( $groupeUID = $getGroupesUID->fetch() ){
|
|
|
|
$groupe = new stdClass();
|
|
$groupe->nom = $groupeUID['nom']; // attribut "nom" ajouté au groupe
|
|
|
|
$groupe->userlist = $this->listeEtudiantsGroupe($groupe->nom, $semestre, $annee); // on charge la liste des utilisateurs de ce groupe
|
|
|
|
array_push($grouplist, $groupe); // on l'ajoute au résultat
|
|
}
|
|
|
|
return $grouplist; // sinon on retourne le tableau
|
|
|
|
}
|
|
|
|
|
|
/***********************************************/
|
|
/*** retourne le nom du groupe d'un étudiant ***/
|
|
/***********************************************/
|
|
public function getGroupeEtudiant($etudiant, $semestre, $annee){
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
// on cherche le groupe associé
|
|
$getNomGroupe = $this->pdo->prepare("SELECT g.nom ".
|
|
"FROM utilisateur as u, groupe as g, appartenance as app ".
|
|
"WHERE u.identifiant = app.id_etudiant ".
|
|
"AND g.id_groupe = app.id_groupe ".
|
|
|
|
"AND u.identifiant = :etudiant ".
|
|
"ORDER BY g.nom");
|
|
$getNomGroupe->execute(array(
|
|
':etudiant' => $etudiant
|
|
));
|
|
|
|
// si on a un résultat
|
|
if( $nomGroupe = $getNomGroupe->fetch()['nom'] )
|
|
return $nomGroupe;
|
|
else
|
|
return 'error';
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
/*** retourne les modules d'un étudiant ***/
|
|
/******************************************/
|
|
public function getModulesEtudiant($etudiant, $semestre, $annee){
|
|
/*** on cherche un utilisateur avec cet identifiant ***/
|
|
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
|
|
$getEtudiantUID->execute(array(
|
|
':etudiant' => $etudiant
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
|
|
$etudiantUID = $etudiantUID;
|
|
else
|
|
return 'unknown_user';
|
|
|
|
/*** on cherche le groupe de cet utilisateur ***/
|
|
$getGroupeUID = $this->pdo->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 = :etudiant ".
|
|
"AND s.rang = :semestre ".
|
|
"AND s.annee = :annee");
|
|
$getGroupeUID->execute(array(
|
|
':etudiant' => $etudiant,
|
|
':semestre' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $groupeUID = $getGroupeUID->fetch()['id'] )
|
|
$groupeUID = $groupeUID;
|
|
else
|
|
return 'unknown_group';
|
|
|
|
// si on a l'UID utilisateur & l'UID groupe => on récupère les modules
|
|
$getModuleList = $this->pdo->prepare("SELECT DISTINCT m.id_module as id, m.nom as nom, m.libelle as libelle ".
|
|
"FROM module as m, groupe as g, semestre as s, programme as prog, ue, appartenance as app ".
|
|
"WHERE app.id_semestre = prog.id_semestre ".
|
|
"AND app.id_semestre = s.id_semestre ".
|
|
"AND app.id_groupe = g.id_groupe ".
|
|
"AND prog.id_ue = ue.id_ue ".
|
|
"AND prog.id_module = m.id_module ".
|
|
|
|
"AND g.id_groupe = :groupeUID ".
|
|
"AND s.rang = :semestre ".
|
|
"AND s.annee = :annee ".
|
|
"ORDER BY m.nom, m.libelle ASC");
|
|
$getModuleList->execute(array(
|
|
':groupeUID' => $groupeUID,
|
|
':semestre' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
$modulelist = $getModuleList->fetchAll(); // on récupère la liste des modules
|
|
|
|
// on supprime les doublons des entrées (indice numérique)
|
|
for( $i = 0 ; $i < count($modulelist) ; $i++ ) // pour tout les modules
|
|
foreach($modulelist[$i] as $col => $val) // pour toutes les entrées
|
|
if( is_int($col) ) // si l'indice est un entier
|
|
unset( $modulelist[$i][$col] ); // on le supprime
|
|
|
|
return $modulelist;
|
|
}
|
|
|
|
|
|
|
|
/**************************************/
|
|
/*** retourne les UEs d'un étudiant ***/
|
|
/**************************************/
|
|
public function getUEsEtudiant($etudiant, $semestre, $annee){
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
|
|
|
|
/*** on cherche un utilisateur avec cet identifiant ***/
|
|
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
|
|
$getEtudiantUID->execute(array(
|
|
':etudiant' => $etudiant
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
|
|
$etudiantUID = $etudiantUID;
|
|
else
|
|
return 'unknown_user';
|
|
|
|
/*** on cherche le groupe de cet utilisateur ***/
|
|
$getGroupeUID = $this->pdo->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;
|
|
else
|
|
return 'unknown_group';
|
|
|
|
// si on a l'UID utilisateur & l'UID groupe => on récupère les modules
|
|
$getUEList = $this->pdo->prepare("SELECT DISTINCT ue.id_ue as id, s.annee as annee, ue.nom as nom, ue.libelle as libelle ".
|
|
"FROM module as m, groupe as g, semestre as s, programme as prog, ue, appartenance as app ".
|
|
"WHERE app.id_semestre = prog.id_semestre ".
|
|
"AND app.id_semestre = s.id_semestre ".
|
|
"AND app.id_groupe = g.id_groupe ".
|
|
"AND prog.id_ue = ue.id_ue ".
|
|
"AND prog.id_module = m.id_module ".
|
|
|
|
"AND g.id_groupe = :groupeUID ".
|
|
"AND app.id_semestre = :semestreUID ".
|
|
"ORDER BY m.nom, m.libelle ASC");
|
|
$getUEList->execute(array(
|
|
':groupeUID' => $groupeUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
$UElist = $getUEList->fetchAll(); // on récupère la liste des modules
|
|
|
|
// on supprime les doublons des entrées (indice numérique)
|
|
for( $i = 0 ; $i < count($UElist) ; $i++ ) // pour tout les modules
|
|
foreach($UElist[$i] as $col => $val) // pour toutes les entrées
|
|
if( is_int($col) ) // si l'indice est un entier
|
|
unset( $UElist[$i][$col] ); // on le supprime
|
|
|
|
return $UElist;
|
|
}
|
|
|
|
|
|
/**************************************/
|
|
/*** retourne les notes par modules ***/
|
|
/**************************************/
|
|
public function getNotesByModules($etudiant, $semestre, $annee){
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
|
|
/*** on cherche un utilisateur avec cet identifiant ***/
|
|
$getEtudiantUID = $this->pdo->prepare("SELECT u.identifiant as id FROM utilisateur as u, appartenance as app ".
|
|
"WHERE u.identifiant = app.id_etudiant ".
|
|
"AND u.identifiant = :etudiant ".
|
|
"AND app.id_semestre = :semestreUID");
|
|
$getEtudiantUID->execute(array(
|
|
':etudiant' => $etudiant,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
|
|
$etudiantUID = $etudiantUID;
|
|
else
|
|
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 par UE ***/
|
|
/*********************************/
|
|
public function getNotesByUEs($etudiant, $semestre, $annee){
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
|
|
/*** on cherche un utilisateur avec cet identifiant ***/
|
|
$getEtudiantUID = $this->pdo->prepare("SELECT u.identifiant as id FROM utilisateur as u, appartenance as app ".
|
|
"WHERE u.identifiant = app.id_etudiant ".
|
|
"AND u.identifiant = :etudiant ".
|
|
"AND app.id_semestre = :semestreUID");
|
|
$getEtudiantUID->execute(array(
|
|
':etudiant' => $etudiant,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
|
|
$etudiantUID = $etudiantUID;
|
|
else
|
|
return 'unknown_user';
|
|
|
|
|
|
$notelist = array(); // tableau qui contiendra tout les modules
|
|
|
|
$UElist = $this->getUEsEtudiant($etudiant, $semestre, $annee); // on récupère la liste des modules
|
|
|
|
foreach($UElist as $UE){ // pour chaque module
|
|
|
|
$notes = $this->getUENotes($etudiant, $UE['nom'], $semestre, $annee); // on récupère les notes
|
|
|
|
$current = array(); // on créé l'entrée qui sera dans le tableau de retour
|
|
$current['UE'] = array();
|
|
$current['UE']['annee'] = $UE['annee']; // contenant l'annee du UE
|
|
$current['UE']['nom'] = $UE['nom']; // contenant le nom du UE
|
|
$current['UE']['libelle'] = $UE['libelle']; // contenant le libelle du UE
|
|
$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 module ***/
|
|
/**************************************/
|
|
public function getModuleNotes($etudiant, $module, $semestre, $annee){
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
|
|
/*** on cherche un utilisateur avec cet identifiant ***/
|
|
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur as u, appartenance as app ".
|
|
"WHERE u.identifiant = app.id_etudiant ".
|
|
"AND u.identifiant = :etudiant ".
|
|
"AND app.id_semestre = :semestreUID");
|
|
$getEtudiantUID->execute(array(
|
|
':etudiant' => $etudiant,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
|
|
$etudiantUID = $etudiantUID;
|
|
else
|
|
return 'unknown_user';
|
|
|
|
|
|
|
|
/*** on cherche un module avec ce nom, en accord avec le semestre et l'étudiant ***/
|
|
$getModuleUID = $this->pdo->prepare("SELECT m.id_module as id FROM module as m, appartenance as app, programme as prog ".
|
|
"WHERE prog.id_module = m.id_module ".
|
|
"AND prog.id_semestre = app.id_semestre ".
|
|
"AND m.nom = :module ".
|
|
"AND app.id_etudiant = :etudiantUID ".
|
|
"AND app.id_semestre = :semestreUID");
|
|
$getModuleUID->execute(array(
|
|
':module' => $module,
|
|
':etudiantUID' => $etudiantUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $moduleUID = $getModuleUID->fetch()['id'] )
|
|
$moduleUID = (int) $moduleUID;
|
|
else
|
|
return 'unknown_module';
|
|
|
|
// si on a l'UID utilisateur & l'UID groupe => on récupère les modules
|
|
$getModuleList = $this->pdo->prepare("SELECT note.intitule, note.valeur, note.base ".
|
|
"FROM note, appartenance as app, programme as prog, semestre as s, module as m ".
|
|
"WHERE note.id_appartenance = app.id_appartenance ".
|
|
"AND note.id_programme = prog.id_programme ".
|
|
"AND prog.id_module = m.id_module ".
|
|
"AND prog.id_semestre = s.id_semestre ".
|
|
|
|
"AND prog.id_module = :moduleUID ".
|
|
"AND app.id_etudiant = :etudiantUID ".
|
|
"AND s.id_semestre = :semestreUID ".
|
|
"ORDER BY note.valeur, note.base ASC");
|
|
$getModuleList->execute(array(
|
|
':moduleUID' => $moduleUID,
|
|
':etudiantUID' => $etudiantUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
$notes = $getModuleList->fetchAll(); // on récupère la liste des notes
|
|
|
|
// on supprime les doublons des entrées (indice numérique)
|
|
for( $i = 0 ; $i < count($notes) ; $i++ ) // pour toutes les notes
|
|
foreach($notes[$i] as $col => $val) // pour toutes les entrées
|
|
if( is_int($col) ) // si l'indice est un entier
|
|
unset( $notes[$i][$col] ); // on le supprime
|
|
|
|
return $notes;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**********************************/
|
|
/*** retourne les notes d'un UE ***/
|
|
/**********************************/
|
|
public function getUENotes($etudiant, $UE, $semestre, $annee){
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
|
|
/*** on cherche un utilisateur avec cet identifiant ***/
|
|
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur as u, appartenance as app ".
|
|
"WHERE u.identifiant = app.id_etudiant ".
|
|
"AND u.identifiant = :etudiant ".
|
|
"AND app.id_semestre = :semestreUID");
|
|
$getEtudiantUID->execute(array(
|
|
':etudiant' => $etudiant,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
|
|
$etudiantUID = $etudiantUID;
|
|
else
|
|
return 'unknown_user';
|
|
|
|
|
|
/*** on cherche un module avec ce nom, en accord avec le semestre et l'étudiant ***/
|
|
$getUEUID = $this->pdo->prepare("SELECT ue.id_ue as id ".
|
|
"FROM module as m, appartenance as app, programme as prog, ue ".
|
|
"WHERE prog.id_module = m.id_module ".
|
|
"AND prog.id_semestre = app.id_semestre ".
|
|
"AND prog.id_ue = ue.id_ue ".
|
|
|
|
"AND ue.nom = :UE ".
|
|
"AND app.id_etudiant = :etudiantUID ".
|
|
"AND app.id_semestre = :semestreUID");
|
|
$getUEUID->execute(array(
|
|
':UE' => $UE,
|
|
':etudiantUID' => $etudiantUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $UEUID = $getUEUID->fetch()['id'] )
|
|
$UEUID = (int) $UEUID;
|
|
else
|
|
return 'unknown_UE';
|
|
|
|
|
|
// si on a l'UID utilisateur & l'UID UE => on récupère les notes
|
|
$getUEList = $this->pdo->prepare("SELECT m.nom as module, note.intitule, note.valeur, note.base ".
|
|
"FROM note, appartenance as app, programme as prog, semestre as s, module as m ".
|
|
"WHERE note.id_appartenance = app.id_appartenance ".
|
|
"AND note.id_programme = prog.id_programme ".
|
|
"AND prog.id_module = m.id_module ".
|
|
"AND prog.id_semestre = s.id_semestre ".
|
|
|
|
"AND prog.id_ue = :UEUID ".
|
|
"AND app.id_etudiant = :etudiantUID ".
|
|
"AND s.id_semestre = :semestreUID ".
|
|
"ORDER BY m.nom, note.valeur, note.base ASC");
|
|
$getUEList->execute(array(
|
|
':UEUID' => $UEUID,
|
|
':etudiantUID' => $etudiantUID,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
$notes = $getUEList->fetchAll(); // on récupère la liste des notes
|
|
|
|
// on supprime les doublons des entrées (indice numérique)
|
|
for( $i = 0 ; $i < count($notes) ; $i++ ) // pour toutes les notes
|
|
foreach($notes[$i] as $col => $val) // pour toutes les entrées
|
|
if( is_int($col) ) // si l'indice est un entier
|
|
unset( $notes[$i][$col] ); // on le supprime
|
|
|
|
return $notes;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/******************************************************/
|
|
/***** déplace un étudiant d'un groupe à un autre *****/
|
|
/******************************************************/
|
|
public function deplacerEtudiant($etudiant, $groupe, $semestre, $annee){
|
|
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
|
|
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
|
|
$getSemestreUID->execute(array(
|
|
':rang' => $semestre,
|
|
':annee' => $annee
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
|
if( $semestreUID = $getSemestreUID->fetch()['id'] )
|
|
$semestreUID = (int) $semestreUID;
|
|
else
|
|
return 'unknown_semestre';
|
|
|
|
|
|
/*** on cherche un utilisateur avec cet identifiant ***/
|
|
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur as u, appartenance as app ".
|
|
"WHERE u.identifiant = app.id_etudiant ".
|
|
"AND u.identifiant = :etudiant ".
|
|
"AND app.id_semestre = :semestreUID");
|
|
$getEtudiantUID->execute(array(
|
|
':etudiant' => $etudiant,
|
|
':semestreUID' => $semestreUID
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
|
|
$etudiantUID = $etudiantUID;
|
|
else
|
|
return 'unknown_user';
|
|
|
|
|
|
/*** on cherche le nouveau groupe pour cet utilisateur ***/
|
|
$getNouveauGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
|
|
"FROM groupe as g ".
|
|
"WHERE g.nom = :groupe");
|
|
$getNouveauGroupeUID->execute(array(
|
|
':groupe' => $groupe
|
|
));
|
|
|
|
// si on trouve, on le définit, sinon on retourne "unknown_user"
|
|
if( $nouveauGroupeUID = $getNouveauGroupeUID->fetch()['id'] )
|
|
$nouveauGroupeUID = $nouveauGroupeUID;
|
|
else
|
|
return 'unknown_newgroup';
|
|
|
|
|
|
/*** on cherche le groupe de cet utilisateur ***/
|
|
$getGroupeUID = $this->pdo->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 = $this->pdo->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 = $this->pdo->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 = $this->pdo->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';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
?>
|