sid/manager/database.php

<?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/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){
		// si l'utilisateur n'existe pas on retourne 'unknown_user'
		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::studentCurrent($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){
		// si on trouve pas, on retourne "unknown_user"
		if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';

		// si on trouve pas, on retourne 'unknown_group' sinon on définit la variable
		if( !($groupeUID=groupRepo::UID($groupe)) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID;

		// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
		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){

		// si on trouve pas, on retourne 'unknown_group' sinon on définit la variable
		if( !($groupeUID=groupRepo::UID($groupe)) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID;

		// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
		if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;



		// si le groupe existe => on récupère ses utilisateurs
		$appartenance = DataBase::getPDO()->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
		));


		// on fetch tous les utilisateurs & on supprime les doublons des entrées (indice numérique)
		return DataBase::delNumeric( $appartenance->fetchAll() ); // on retourne le tout

	}

	/********************************************************************/
	/*** 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=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 = 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 = groupRepo::membres($groupeUID['id'], $semestreUID); // 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, $semestre_pair, $pSemestre, $pGroupe){
		$semestre_pair = ($semestre_pair) ? '0' : '1';

		// 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 = DataBase::getPDO()->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 = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe as id, g.nom, s.rang, s.id_semestre, 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.rang % 2 = :semestre_pair ".
			"AND   s.annee = :annee ".
			"ORDER BY g.nom");
		$getGroupesUID->execute(array(
			':semestreDeb' => $semestreDeb,
			':semestreFin' => $semestreFin,
			':semestre_pair' => $semestre_pair,
			':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 = groupRepo::membres($groupeUID['id'], $groupeUID['id_semestre']); // 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, $semestre_pair, $enseignant, $pSemestre, $pGroupe){
		$semestre_pair = ($semestre_pair) ? '0' : '1';

		// 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 = DataBase::getPDO()->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=userRepo::UID($enseignant)) ) return 'unknown_user';


		// 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, s.id_semestre, 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.rang % 2 = :semestre_pair ".
			"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,
			':semestre_pair' => $semestre_pair,
			':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 = groupRepo::membres($groupeUID['id'], $groupeUID['id_semestre']); // 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=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;

		// si on trouve pas, on retourne "unknown_user"
		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){

		// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
		if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;

		// si on trouve pas, on retourne "unknown_user"
		if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';




		/*** 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;
		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 = DataBase::getPDO()->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']
			));

			// on ajoute la liste des modules en supprimant les valeurs à indinces numériques
			$UEList[$iter]['modules'] = DataBase::delNumeric( $getModuleList->fetchAll() );
		}

		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=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;

		// si on trouve pas, on retourne "unknown_user"
		if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';




		/*** 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 = :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 = DataBase::getPDO()->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
		));

		// on retourne les modules en supprimant les valeurs à indices numériques
		return DataBase::delNumeric( $getModuleList->fetchAll() );
	}


	/**************************************/
	/*** 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=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;

		// si on trouve pas, on retourne "unknown_user"
		if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';




		/*** 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;
		else
			return 'unknown_group';

		// si on a l'UID utilisateur & l'UID groupe => on récupère les modules
		$getUEList = DataBase::getPDO()->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
		));

		// on retourne la liste d'UEs en supprimant les doublons à clés numériques
		return DataBase::delNumeric( $getUEList->fetchAll() );
	}












	/**************************************************/
	/*** 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 = DataBase::getPDO()->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 = DataBase::getPDO()->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 = 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 ".
				"ORDER BY m.nom, m.libelle ASC");
			$getModuleList->execute(array(
				':enseignantUID' => $enseignantUID,
				':UEUID'         => $UE['id'],
				':annee'         => $annee
			));

			// 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, $annee){
		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = DataBase::getPDO()->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 = DataBase::getPDO()->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 = DataBase::getPDO()->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
		));

		// on retourne la liste d'UEs en supprimant les doublons à clés numériques
		return DataBase::delNumeric( $getUEList->fetchAll() );
	}













/*******************************************/
/*    _   _  ____ _______ ______  _____    */
/*   | \ | |/ __ \__   __|  ____|/ ____|   */
/*   |  \| | |  | | | |  | |__  | (___     */
/*   | . ` | |  | | | |  |  __|  \___ \    */
/*   | |\  | |__| | | |  | |____ ____) |   */
/*   |_| \_|\____/  |_|  |______|_____/    */
/*                                         */
/*******************************************/



	/**************************************/
	/*** 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=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = DataBase::getPDO()->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=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre';
		else                                                        $semestreUID = (int) $semestreUID;


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = DataBase::getPDO()->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=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = DataBase::getPDO()->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 = DataBase::getPDO()->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
		$getNoteList = DataBase::getPDO()->prepare("SELECT m.nom as module, m.libelle as modulelib, ctrl.intitule, note.valeur, ctrl.base, ctrl.coefficient ".
			"FROM note, appartenance as app, semestre as s, module as m, mcc_ue, mcc_module as mcc_m, controle as ctrl ".
			"WHERE note.id_appartenance = app.id_appartenance ".
			"AND   ctrl.id_controle = note.id_controle ".
			"AND   ctrl.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 ctrl.date_publication ASC");
		$getNoteList->execute(array(
			':moduleUID'   => $moduleUID,
			':etudiantUID' => $etudiantUID,
			':semestreUID' => $semestreUID
		));

		// on retourne la liste des notes et supprime les doublons à indices numériques
		return DataBase::delNumeric( $getNoteList->fetchAll() );
	}





	/**********************************/
	/*** 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=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = DataBase::getPDO()->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 = DataBase::getPDO()->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
		$getNoteList = DataBase::getPDO()->prepare("SELECT m.nom as module, m.libelle as modulelib, ctrl.intitule, note.valeur, ctrl.base, ctrl.coefficient ".
			"FROM note, appartenance as app, semestre as s, module as m, ue, mcc_ue, mcc_module as mcc_m, controle as ctrl ".
			"WHERE note.id_appartenance = app.id_appartenance ".
			"AND   ctrl.id_mcc_module = mcc_m.id_mcc_module ".
			"AND   ctrl.id_controle = note.id_controle ".

			"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, ctrl.date_publication ASC");
		$getNoteList->execute(array(
			':UEUID'       => $UEUID,
			':etudiantUID' => $etudiantUID,
			':semestreUID' => $semestreUID
		));

		// on retourne la liste de notes et supprime les doublons à indices numériques
		return DataBase::delNumeric( $getNoteList->fetchAll() );
	}









}

?>