sid/manager/database.php

1278 lines
46 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", "root", "");
}
/*************************************************************/
/* _____ ______ _ _ ______ _____ _ */
/* / ____| ____| \ | | ____| __ \ /\ | | */
/* | | __| |__ | \| | |__ | |__) | / \ | | */
/* | | |_ | __| | . ` | __| | _ / / /\ \ | | */
/* | |__| | |____| |\ | |____| | \ \ / ____ \| |____ */
/* \_____|______|_| \_|______|_| \_\/_/ \_\______| */
/* */
/*************************************************************/
/********************************************************/
/*** Vérifie l'existence d'un utilisateur dans le BDD ***/
/********************************************************/
private function utilisateurUID($identifiant){
/*** on cherche un utilisateur avec cet identifiant ***/
$getUtilisateurUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :identifiant");
$getUtilisateurUID->execute(array(
':identifiant' => $identifiant
));
// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID de l'utilisateur
return $getUtilisateurUID->fetch()['id'];
}
/***************************************************/
/*** Vérifie l'existence d'un groupe dans le BDD ***/
/***************************************************/
private function groupeUID($nom){
/*** 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' => $nom
));
// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID du groupe
return $getGroupeUID->fetch()['id'];
}
/*****************************************************/
/*** Vérifie l'existence d'un semestre dans le BDD ***/
/*****************************************************/
private function semestreUID($rang, $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' => $rang,
':annee' => $annee
));
// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID du semestre
return $getSemestreUID->fetch()['id'];
}
/*************************************************************************************/
/* _ _ _______ _____ _ _____ _____ _______ ______ _ _ _____ */
/* | | | |__ __|_ _| | |_ _|/ ____| /\|__ __| ____| | | | __ \ */
/* | | | | | | | | | | | | | (___ / \ | | | |__ | | | | |__) | */
/* | | | | | | | | | | | | \___ \ / /\ \ | | | __| | | | | _ / */
/* | |__| | | | _| |_| |____ _| |_ ____) / ____ \| | | |____| |__| | | \ \ */
/* \____/ |_| |_____|______|_____|_____/_/ \_\_| |______|\____/|_| \_\ */
/* */
/*************************************************************************************/
/*********************************************/
/*** 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';
}
/*********************************************************************************/
/*** on récupère les informations utiles à l'utilisateur lors de la connection ***/
/*********************************************************************************/
public function utilisateurInfo($identifiant){
// si l'utilisateur n'existe pas on retourne 'unknown_user'
if( !($utilisateurUID=$this->utilisateurUID($identifiant)) ) return 'unknown_user';
$getUtilisateurInfo = $this->pdo->prepare("SELECT identifiant, prenom, nom, mail, droits FROM utilisateur WHERE identifiant = :identifiant");
$getUtilisateurInfo->execute(array( ':identifiant' => $utilisateurUID ));
return $getUtilisateurInfo->fetch(); // retourne les info, si pas de résultat, retourne [FAUX]
}
/**********************************************************/
/* _____ _____ ____ _ _ _____ ______ _____ */
/* / ____| __ \ / __ \| | | | __ \| ____|/ ____| */
/* | | __| |__) | | | | | | | |__) | |__ | (___ */
/* | | |_ | _ /| | | | | | | ___/| __| \___ \ */
/* | |__| | | \ \| |__| | |__| | | | |____ ____) | */
/* \_____|_| \_\\____/ \____/|_| |______|_____/ */
/* */
/**********************************************************/
/****************************************/
/*** 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'];
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) return 'unknown_user';
// si on trouve pas, on retourne 'unknown_group' sinon on définit la variable
if( !($groupeUID=$this->groupeUID($groupe)) ) return 'unknown_group';
else $groupeUID = (int) $groupeUID;
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// 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){
// si on trouve pas, on retourne 'unknown_group' sinon on définit la variable
if( !($groupeUID=$this->groupeUID($groupe)) ) return 'unknown_group';
else $groupeUID = (int) $groupeUID;
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// 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, s.nom as semestre ".
"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 d'un semestre ***/
/********************************************************************/
public function listeEtudiantsTousGroupesSemestre($semestre, $annee){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($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 = $this->pdo->prepare("SELECT DISTINCT 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 = 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->semestre = $groupeUID['semestre'];
$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 la liste des utilisateurs des groupes d'une année ***/
/******************************************************************/
public function listeEtudiantsTousGroupesAnnee($annee, $pSemestre, $pGroupe){
// définition des paramètres optionnels
$semestreDeb = 1; $semestreFin = 4;
if( $pSemestre != null ){ $semestreDeb = $pSemestre; $semestreFin = $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 = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE annee = :annee");
$checkAnnee->execute(array(
':annee' => $annee
));
// si on trouve pas, on retourne "unknown_year"
if( !( $checkAnnee->fetch()['id'] ) )
return 'unknown_year';
// on cherche tout les groupes du même semestre de la même année
$getGroupesUID = $this->pdo->prepare("SELECT DISTINCT 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 g.nom LIKE '".$groupeOpt."' ".
"AND s.rang BETWEEN :semestreDeb AND :semestreFin ".
"AND s.annee = :annee ".
"ORDER BY g.nom");
$getGroupesUID->execute(array(
':semestreDeb' => $semestreDeb,
':semestreFin' => $semestreFin,
':annee' => $annee
));
$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->semestre = $groupeUID['semestre'];
$groupe->userlist = $this->listeEtudiantsGroupe($groupe->nom, $groupeUID['rang'], $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 la liste des utilisateurs des groupes d'une année ***/
/******************************************************************/
public function listeEtudiantsTousGroupesEnseignant($annee, $enseignant, $pSemestre, $pGroupe){
// définition des paramètres optionnels
$semestreDeb = 1; $semestreFin = 4;
if( $pSemestre != null ){ $semestreDeb = $pSemestre; $semestreFin = $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 = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE annee = :annee");
$checkAnnee->execute(array(
':annee' => $annee
));
// si on trouve pas, on retourne "unknown_year"
if( !( $checkAnnee->fetch()['id'] ) )
return 'unknown_year';
// si on trouve pas, on retourne "unknown_user"
if( !($enseignantUID=$this->utilisateurUID($enseignant)) ) return 'unknown_user';
// on cherche tout les groupes du même semestre de la même année
$getGroupesUID = $this->pdo->prepare("SELECT DISTINCT s.nom as semestre, s.rang, g.nom as nom ".
"FROM module as m, utilisateur as u, utilisateur as eleve, groupe as g, enseignement as ens, mcc_ue, mcc_module as mcc_m, semestre as s, appartenance as app ".
"WHERE mcc_ue.id_semestre = s.id_semestre ".
"AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue ".
"AND mcc_m.id_module = m.id_module ".
"AND mcc_m.id_mcc_module = ens.id_mcc_module ".
"AND ens.id_enseignant = u.identifiant ".
"AND app.id_etudiant = eleve.identifiant ".
"AND app.id_semestre = s.id_semestre ".
"AND app.id_groupe = g.id_groupe ".
"AND g.nom LIKE '".$groupeOpt."' ".
"AND s.rang BETWEEN :semestreDeb AND :semestreFin ".
"AND s.annee = :annee ".
"AND u.identifiant = :enseignantUID ".
"ORDER BY s.rang, g.nom");
$getGroupesUID->execute(array(
// ':groupeOpt' => $groupeOpt,
':semestreDeb' => $semestreDeb,
':semestreFin' => $semestreFin,
':annee' => $annee,
':enseignantUID' => $enseignantUID
));
$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->semestre = $groupeUID['semestre'];
$groupe->userlist = $this->listeEtudiantsGroupe($groupe->nom, $groupeUID['rang'], $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){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) return 'unknown_user';
// on cherche le groupe associé
$getNomGroupe = $this->pdo->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 = $this->pdo->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 = $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';
}
/**********************************************************/
/* */
/* __ __ ____ _____ _ _ _ ______ _____ */
/* | \/ |/ __ \| __ \| | | | | | ____|/ ____| */
/* | \ / | | | | | | | | | | | | |__ | (___ */
/* | |\/| | | | | | | | | | | | | __| \___ \ */
/* | | | | |__| | |__| | |__| | |____| |____ ____) | */
/* |_| |_|\____/|_____/ \____/|______|______|_____/ */
/* */
/**********************************************************/
/**************************************************/
/*** retourne les modules d'un étudiant par UEs ***/
/**************************************************/
public function getModulesByUEByEtudiant($etudiant, $semestre, $annee){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) 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';
$UEList = $this->getUEsEtudiant($etudiant, $semestre, $annee); // on récupère la liste des UEs
foreach($UEList as $iter=>$UE){
// 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, ue, appartenance as app, mcc_ue, mcc_module as mcc_m ".
"WHERE app.id_semestre = s.id_semestre ".
"AND app.id_groupe = g.id_groupe ".
"AND app.id_semestre = mcc_ue.id_semestre ".
"AND mcc_ue.id_ue = ue.id_ue ".
"AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue ".
"AND mcc_m.id_module = m.id_module ".
"AND g.id_groupe = :groupeUID ".
"AND s.id_semestre = :semestreUID ".
"AND ue.id_ue = :UEUID ".
"ORDER BY m.nom, m.libelle ASC");
$getModuleList->execute(array(
':groupeUID' => $groupeUID,
':semestreUID' => $semestreUID,
':UEUID' => $UE['id']
));
$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
$UEList[$iter]['modules'] = $modulelist; // on ajoute la liste des mdules
}
return $UEList;
}
/******************************************/
/*** retourne les modules d'un étudiant ***/
/******************************************/
public function getModulesEtudiant($etudiant, $semestre, $annee){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) 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 = :semestreUID ".
"AND u.identifiant = :etudiantUID");
$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
$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, ue, appartenance as app, mcc_ue, mcc_module as mcc_m ".
"WHERE app.id_semestre = s.id_semestre ".
"AND app.id_groupe = g.id_groupe ".
"AND app.id_semestre = mcc_ue.id_semestre ".
"AND mcc_ue.id_ue = ue.id_ue ".
"AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue ".
"AND mcc_m.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){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) 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, ue, appartenance as app, mcc_ue, mcc_module as mcc_m ".
"WHERE app.id_semestre = s.id_semestre ".
"AND app.id_groupe = g.id_groupe ".
"AND app.id_semestre = mcc_ue.id_semestre ".
"AND mcc_ue.id_ue = ue.id_ue ".
"AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue ".
"AND mcc_m.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 modules d'un étudiant par UEs ***/
/**************************************************/
public function getModulesByUEByEnseignant($enseignant, $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 annee = :annee");
$getSemestreUID->execute(array(
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( ! $getSemestreUID->fetch() )
return 'unknown_year';
/*** on cherche un utilisateur avec cet identifiant ***/
$getEnseignantUID = $this->pdo->prepare("SELECT DISTINCT u.identifiant as id ".
"FROM utilisateur as u, enseignement as ens, semestre as s, mcc_module as mcc_m, mcc_ue ".
"WHERE u.identifiant = ens.id_enseignant ".
"AND ens.id_mcc_module = mcc_m.id_mcc_module ".
"AND mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue ".
"AND mcc_ue.id_semestre = s.id_semestre ".
"AND s.annee = :annee ".
"AND u.identifiant = :enseignant");
$getEnseignantUID->execute(array(
':annee' => $annee,
':enseignant' => $enseignant
));
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $enseignantUID = $getEnseignantUID->fetch()['id'] )
$enseignantUID = $enseignantUID;
else
return 'unknown_teacher';
$UEList = $this->getUEsEnseignant($enseignant, $annee); // on récupère la liste des UEs
foreach($UEList as $iter=>$UE){
// 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 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 ".
"ORDER BY m.nom, m.libelle ASC");
$getModuleList->execute(array(
':enseignantUID' => $enseignantUID,
':UEUID' => $UE['id'],
':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
$UEList[$iter]['modules'] = $modulelist; // on ajoute la liste des mdules
}
return $UEList;
}
/****************************************/
/*** retourne les UEs d'un enseignant ***/
/****************************************/
public function getUEsEnseignant($enseignant, $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 annee = :annee");
$getSemestreUID->execute(array(
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( ! $getSemestreUID->fetch() )
return 'unknown_year';
/*** on cherche un utilisateur avec cet identifiant ***/
$getEnseignantUID = $this->pdo->prepare("SELECT DISTINCT u.identifiant as id ".
"FROM utilisateur as u, enseignement as ens, semestre as s, mcc_module as mcc_m, mcc_ue ".
"WHERE u.identifiant = ens.id_enseignant ".
"AND ens.id_mcc_module = mcc_m.id_mcc_module ".
"AND mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue ".
"AND mcc_ue.id_semestre = s.id_semestre ".
"AND s.annee = :annee ".
"AND u.identifiant = :enseignant");
$getEnseignantUID->execute(array(
':annee' => $annee,
':enseignant' => $enseignant
));
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $enseignantUID = $getEnseignantUID->fetch()['id'] )
$enseignantUID = $enseignantUID;
else
return 'unknown_teacher';
// si on a l'UID enseignant => on récupère les UEs
$getUEList = $this->pdo->prepare("SELECT DISTINCT ue.id_ue as id, s.annee as annee, ue.nom as nom, ue.libelle as libelle ".
"FROM enseignement as ens, semestre as s, ue, mcc_ue, mcc_module as mcc_m ".
"WHERE ens.id_mcc_module = mcc_m.id_mcc_module ".
"AND mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue ".
"AND mcc_ue.id_ue = ue.id_ue ".
"AND ens.id_enseignant = :enseignantUID ".
"AND s.annee = :annee ".
"ORDER BY ue.nom, ue.libelle ASC");
$getUEList->execute(array(
':enseignantUID' => $enseignantUID,
':annee' => $annee
));
$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){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
/*** 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){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
/*** 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){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
/*** 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, ue, mcc_ue, mcc_module as mcc_m ".
"WHERE app.id_etudiant = :etudiantUID ".
"AND mcc_ue.id_ue = ue.id_ue ".
"AND mcc_ue.id_semestre = app.id_semestre ".
"AND mcc_ue.id_semestre = :semestreUID ".
"AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue ".
"AND mcc_m.id_module = m.id_module ".
"AND m.nom = :module ");
$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 m.nom as module, m.libelle as modulelib, note.intitule, note.valeur, note.base, note.coefficient ".
"FROM note, appartenance as app, semestre as s, module as m, mcc_ue, mcc_module as mcc_m ".
"WHERE note.id_appartenance = app.id_appartenance ".
"AND note.id_mcc_module = mcc_m.id_mcc_module ".
"AND mcc_ue.id_semestre = app.id_semestre ".
"AND mcc_ue.id_semestre = s.id_semestre ".
"AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue ".
"AND mcc_m.id_module = m.id_module ".
"AND m.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){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
/*** 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, ue, mcc_ue, mcc_module as mcc_m ".
"WHERE mcc_ue.id_ue = ue.id_ue ".
"AND mcc_ue.id_semestre = app.id_semestre ".
"AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue ".
"AND mcc_m.id_module = m.id_module ".
"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, m.libelle as modulelib, note.intitule, note.valeur, note.base, note.coefficient ".
"FROM note, appartenance as app, semestre as s, module as m, ue, mcc_ue, mcc_module as mcc_m ".
"WHERE note.id_appartenance = app.id_appartenance ".
"AND note.id_mcc_module = mcc_m.id_mcc_module ".
"AND mcc_ue.id_ue = ue.id_ue ".
"AND mcc_ue.id_semestre = app.id_semestre ".
"AND mcc_ue.id_semestre = s.id_semestre ".
"AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue ".
"AND mcc_m.id_module = m.id_module ".
"AND ue.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;
}
}
?>