<?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, 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");
		$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, 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");
		$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;
	}


}

?>