sid/manager/database.php

<?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", "sid", "php", "Qt358nUdyeTxLDM8");
	}

	/*********************************************/
	/*** création d'un utilisateur dans la bdd ***/
	/*********************************************/
	public function creerUtilisateur($identifiant, $prenom, $nom, $mail, $mdp, $droits){
		$getLastCount = $this->pdo->query('SELECT count(identifiant) as count FROM utilisateur');
		$lastCount    = (int) $getLastCount->fetch()['count'];

		// on applique une normalisation
		$prenom = ucwords( strtolower($prenom) ); // majuscule à chaque mot sinon minuscule
		$nom    = strtoupper($nom);               // nom en majuscules
		$mail   = strtolower($mail);              // email en minuscules
		$mdp    = sha1($mdp);                     // on hash le password

		$req = $this->pdo->prepare("INSERT INTO utilisateur(identifiant, prenom, nom, mail, mdp, droits) VALUES(:identifiant, :prenom, :nom, :mail, :mdp, :droits)");

		$req->execute(array(
			':identifiant' => $identifiant,
			':prenom'      => $prenom,
			':nom'         => $nom,
			':mail'        => $mail,
			':mdp'         => $mdp,
			':droits'      => $droits  
		));

		$getNewCount = $this->pdo->query('SELECT count(identifiant) as count FROM utilisateur');
		$newCount = (int) $getNewCount->fetch()['count'];

		if( $newCount > $lastCount ) // si on a bien ajouté un entrée
			return 'success';
		else
			return 'error';

	}




	/****************************************/
	/*** création d'un groupe dans la bdd ***/
	/****************************************/
	public function creerGroupe($nom){
		$getLastCount = $this->pdo->query('SELECT count(id_groupe) as count FROM groupe');
		$lastCount    = (int) $getLastCount->fetch()['count'];

		// on applique une normalisation
		$nom = strtoupper($nom);               // nom en majuscules

		$req = $this->pdo->prepare("INSERT INTO groupe(id_groupe, nom) VALUES(default, :nom)");

		$req->execute(array(
			':nom' => $nom
		));


		$getNewCount = $this->pdo->query('SELECT count(id_groupe) as count FROM groupe');
		$newCount = (int) $getNewCount->fetch()['count'];

		if( $newCount > $lastCount ) // si on a bien ajouté un entrée
			return 'success';
		else
			return 'error';

	}

	/******************************************************/
	/*** ajout d'un utilisateur à un groupe dans la bdd ***/
	/******************************************************/
	public function ajouterEtudiantGroupe($etudiant, $groupe, $semestre, $annee){
		$getLastCount = $this->pdo->query('SELECT count(id_etudiant) as count FROM appartenance');
		$lastCount    = (int) $getLastCount->fetch()['count'];


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
		$getEtudiantUID->execute(array(
			':etudiant' => $etudiant
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
			$etudiantUID = $etudiantUID;
		else
			return 'unknown_user';


		/*** on cherche un groupe avec ce nom ***/
		$getGroupeUID = $this->pdo->prepare("SELECT id_groupe as id FROM groupe WHERE nom = :nom");
		$getGroupeUID->execute(array(
			':nom' => $groupe
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $groupeUID = $getGroupeUID->fetch()['id'] )
			$groupeUID = (int) $groupeUID;
		else
			return 'unknown_group';


		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';




		// si on a l'UID utilisateur & l'UID groupe => on créé l'association
		$asso = $this->pdo->prepare("INSERT INTO appartenance(id_etudiant, id_groupe, id_semestre) ".
			"VALUES( ".
				"(SELECT identifiant FROM utilisateur WHERE identifiant = :etudiantUID), ".
				"(SELECT id_groupe FROM groupe WHERE id_groupe = :groupeUID), ".
				"(SELECT id_semestre FROM semestre WHERE id_semestre = :semestreUID) ".
			" )");
		$asso->execute(array(
			':etudiantUID' => $etudiantUID,
			':groupeUID'   => $groupeUID,
			':semestreUID' => $semestreUID
		));



		$getNewCount = $this->pdo->query('SELECT count(id_etudiant) as count FROM appartenance');
		$newCount = (int) $getNewCount->fetch()['count'];

		if( $newCount > $lastCount ) // si on a bien ajouté un entrée
			return 'success';
		else
			return 'error';
	}

	/******************************************************/
	/*** retourne la liste des utilisateurs d'un groupe ***/
	/******************************************************/
	public function listeEtudiantsGroupe($groupe, $semestre, $annee){

		/*** on cherche un groupe avec ce nom ***/
		$getGroupeUID = $this->pdo->prepare("SELECT id_groupe as id FROM groupe WHERE nom = :nom");
		$getGroupeUID->execute(array(
			':nom' => $groupe
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $groupeUID = $getGroupeUID->fetch()['id'] )
			$groupeUID = (int) $groupeUID;
		else
			return 'unknown_group';


		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';



		// si le groupe existe => on récupère ses utilisateurs
		$appartenance = $this->pdo->prepare("SELECT u.identifiant, u.prenom, u.nom, u.mail, u.droits ".
			"FROM utilisateur as u, groupe as g, semestre as s, appartenance as app ".
			"WHERE u.identifiant = app.id_etudiant ".
			"AND   g.id_groupe   = app.id_groupe ".
			"AND   s.id_semestre = app.id_semestre ". // à virer (peut-être)
			
			"AND   g.id_groupe   = :groupeUID ".
			"AND   s.id_semestre = :semestreUID ".
			"ORDER BY u.prenom, u.nom");
		$appartenance->execute(array(
			':groupeUID' => $groupeUID,
			':semestreUID' => $semestreUID
		));


		$userlist = $appartenance->fetchAll();

		// on supprime les doublons des entrées (indice numérique)
		for( $i = 0 ; $i < count($userlist) ; $i++ ) // pour tout les utilisateurs
			foreach($userlist[$i] as $col => $val)   // pour toutes les entrées
				if( is_int($col) )                   // si l'indice est un entier
					unset( $userlist[$i][$col] );    // on le supprime
			

		return $userlist; // on retourne le liste d'utilisateurs

	}

	/******************************************************/
	/*** retourne la liste des utilisateurs des groupes ***/
	/******************************************************/
	public function listeEtudiantsTousGroupes($semestre, $annee){
		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';

		// on cherche tout les groupes du même semestre de la même année
		$getGroupesUID = $this->pdo->prepare("SELECT DISTINCT g.nom ".
			"FROM groupe as g, semestre as s, appartenance as app ".
			"WHERE g.id_groupe   = app.id_groupe ".
			"AND   s.id_semestre = app.id_semestre ".
			
			"AND   s.id_semestre = :semestreUID ".
			"ORDER BY g.nom");
		$getGroupesUID->execute(array(
			':semestreUID'  => $semestreUID
		));

		$grouplist = array(); // contiendra tout les groupes

		// on parcourt tous les groupes
		while( $groupeUID = $getGroupesUID->fetch() ){
			
			$groupe = new stdClass();
			$groupe->nom = $groupeUID['nom']; // attribut "nom" ajouté au groupe

			$groupe->userlist = $this->listeEtudiantsGroupe($groupe->nom, $semestre, $annee); // on charge la liste des utilisateurs de ce groupe

			array_push($grouplist, $groupe); // on l'ajoute au résultat
		}

		return $grouplist; // sinon on retourne le tableau

	}


	/***********************************************/
	/*** retourne le nom du groupe d'un étudiant ***/
	/***********************************************/
	public function getGroupeEtudiant($etudiant, $semestre, $annee){
		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';

		// on cherche le groupe associé
		$getNomGroupe = $this->pdo->prepare("SELECT g.nom ".
			"FROM utilisateur as u, groupe as g, appartenance as app ".
			"WHERE u.identifiant = app.id_etudiant ".
			"AND   g.id_groupe   = app.id_groupe ".

			"AND   u.identifiant = :etudiant ".
			"ORDER BY g.nom");
		$getNomGroupe->execute(array(
			':etudiant' => $etudiant
		));

		// si on a un résultat
		if( $nomGroupe = $getNomGroupe->fetch()['nom'] )
			return $nomGroupe;
		else
			return 'error';
	}


	/******************************************/
	/*** retourne les modules d'un étudiant ***/
	/******************************************/
	public function getModulesEtudiant($etudiant, $semestre, $annee){
		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
		$getEtudiantUID->execute(array(
			':etudiant' => $etudiant
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
			$etudiantUID = $etudiantUID;
		else
			return 'unknown_user';

		/*** on cherche le groupe de cet utilisateur ***/
		$getGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
			"FROM utilisateur as u, groupe as g, appartenance as app, semestre as s ".
			"WHERE app.id_etudiant = u.identifiant ".
			"AND   app.id_groupe = g.id_groupe ".
			"AND   app.id_semestre = s.id_semestre ".

			"AND   u.identifiant = :etudiant ".
			"AND   s.rang = :semestre ".
			"AND   s.annee = :annee");
		$getGroupeUID->execute(array(
			':etudiant' => $etudiant,
			':semestre' => $semestre,
			':annee'    => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $groupeUID = $getGroupeUID->fetch()['id'] )
			$groupeUID = $groupeUID;
		else
			return 'unknown_group';

		// si on a l'UID utilisateur & l'UID groupe => on récupère les modules
		$getModuleList = $this->pdo->prepare("SELECT DISTINCT m.id_module as id, m.nom as nom, m.libelle as libelle ".
			"FROM module as m, groupe as g, semestre as s, programme as prog, ue, appartenance as app ".
			"WHERE app.id_semestre = prog.id_semestre ".
			"AND   app.id_semestre = s.id_semestre ".
			"AND   app.id_groupe = g.id_groupe ".
			"AND   prog.id_ue = ue.id_ue ".
			"AND   prog.id_module = m.id_module ".

			"AND   g.id_groupe = :groupeUID ".
			"AND   s.rang = :semestre ".
			"AND   s.annee = :annee ".
			"ORDER BY m.nom, m.libelle ASC");
		$getModuleList->execute(array(
			':groupeUID' => $groupeUID,
			':semestre'  => $semestre,
			':annee'     => $annee
		));

		$modulelist = $getModuleList->fetchAll(); // on récupère la liste des modules

		// on supprime les doublons des entrées (indice numérique)
		for( $i = 0 ; $i < count($modulelist) ; $i++ ) // pour tout les modules
			foreach($modulelist[$i] as $col => $val)   // pour toutes les entrées
				if( is_int($col) )                   // si l'indice est un entier
					unset( $modulelist[$i][$col] );    // on le supprime

		return $modulelist;
	}



	/**************************************/
	/*** retourne les UEs d'un étudiant ***/
	/**************************************/
	public function getUEsEtudiant($etudiant, $semestre, $annee){
		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';



		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
		$getEtudiantUID->execute(array(
			':etudiant' => $etudiant
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
			$etudiantUID = $etudiantUID;
		else
			return 'unknown_user';

		/*** on cherche le groupe de cet utilisateur ***/
		$getGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
			"FROM utilisateur as u, groupe as g, appartenance as app, semestre as s ".
			"WHERE app.id_etudiant = u.identifiant ".
			"AND   app.id_groupe = g.id_groupe ".
			"AND   app.id_semestre = s.id_semestre ".

			"AND   u.identifiant = :etudiantUID ".
			"AND   app.id_semestre = :semestreUID");
		$getGroupeUID->execute(array(
			':etudiantUID' => $etudiantUID,
			':semestreUID' => $semestreUID,
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $groupeUID = $getGroupeUID->fetch()['id'] )
			$groupeUID = $groupeUID;
		else
			return 'unknown_group';

		// si on a l'UID utilisateur & l'UID groupe => on récupère les modules
		$getUEList = $this->pdo->prepare("SELECT DISTINCT ue.id_ue as id, s.annee as annee, ue.nom as nom, ue.libelle as libelle ".
			"FROM module as m, groupe as g, semestre as s, programme as prog, ue, appartenance as app ".
			"WHERE app.id_semestre = prog.id_semestre ".
			"AND   app.id_semestre = s.id_semestre ".
			"AND   app.id_groupe = g.id_groupe ".
			"AND   prog.id_ue = ue.id_ue ".
			"AND   prog.id_module = m.id_module ".

			"AND   g.id_groupe = :groupeUID ".
			"AND   app.id_semestre = :semestreUID ".
			"ORDER BY m.nom, m.libelle ASC");
		$getUEList->execute(array(
			':groupeUID' => $groupeUID,
			':semestreUID'  => $semestreUID
		));

		$UElist = $getUEList->fetchAll(); // on récupère la liste des modules

		// on supprime les doublons des entrées (indice numérique)
		for( $i = 0 ; $i < count($UElist) ; $i++ ) // pour tout les modules
			foreach($UElist[$i] as $col => $val)   // pour toutes les entrées
				if( is_int($col) )                   // si l'indice est un entier
					unset( $UElist[$i][$col] );    // on le supprime

		return $UElist;
	}


	/**************************************/
	/*** retourne les notes par modules ***/
	/**************************************/
	public function getNotesByModules($etudiant, $semestre, $annee){
		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = $this->pdo->prepare("SELECT u.identifiant as id FROM utilisateur as u, appartenance as app ".
			"WHERE u.identifiant = app.id_etudiant ".
			"AND   u.identifiant = :etudiant ".
			"AND   app.id_semestre = :semestreUID");
		$getEtudiantUID->execute(array(
			':etudiant'    => $etudiant,
			':semestreUID' => $semestreUID
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
			$etudiantUID = $etudiantUID;
		else
			return 'unknown_user';


		$notelist = array(); // tableau qui contiendra tout les modules

		$modulelist = $this->getModulesEtudiant($etudiant, $semestre, $annee); // on récupère la liste des modules

		foreach($modulelist as $module){ // pour chaque module

			$notes = $this->getModuleNotes($etudiant, $module['nom'], $semestre, $annee); // on récupère les notes

			$current = array(); // on créé l'entrée qui sera dans le tableau de retour
			$current['module'] = array();
			$current['module']['nom'] = $module['nom']; // contenant le nom du module
			$current['module']['libelle'] = $module['libelle']; // contenant le nom du module
			$current['notes'] = $notes;          // et la liste de notes

			array_push($notelist, $current); // on l'ajoute au résultat
		}

		return $notelist;
	}


	/*********************************/
	/*** retourne les notes par UE ***/
	/*********************************/
	public function getNotesByUEs($etudiant, $semestre, $annee){
		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = $this->pdo->prepare("SELECT u.identifiant as id FROM utilisateur as u, appartenance as app ".
			"WHERE u.identifiant = app.id_etudiant ".
			"AND   u.identifiant = :etudiant ".
			"AND   app.id_semestre = :semestreUID");
		$getEtudiantUID->execute(array(
			':etudiant'    => $etudiant,
			':semestreUID' => $semestreUID
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
			$etudiantUID = $etudiantUID;
		else
			return 'unknown_user';


		$notelist = array(); // tableau qui contiendra tout les modules

		$UElist = $this->getUEsEtudiant($etudiant, $semestre, $annee); // on récupère la liste des modules

		foreach($UElist as $UE){ // pour chaque module

			$notes = $this->getUENotes($etudiant, $UE['nom'], $semestre, $annee); // on récupère les notes

			$current = array(); // on créé l'entrée qui sera dans le tableau de retour
			$current['UE'] = array();
			$current['UE']['annee'] = $UE['annee']; // contenant l'annee du UE
			$current['UE']['nom'] = $UE['nom']; // contenant le nom du UE
			$current['UE']['libelle'] = $UE['libelle']; // contenant le libelle du UE
			$current['notes'] = $notes;          // et la liste de notes

			array_push($notelist, $current); // on l'ajoute au résultat
		}

		return $notelist;
	}



	/**************************************/
	/*** retourne les notes d'un module ***/
	/**************************************/
	public function getModuleNotes($etudiant, $module, $semestre, $annee){
		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur as u, appartenance as app ".
			"WHERE u.identifiant = app.id_etudiant ".
			"AND   u.identifiant = :etudiant ".
			"AND   app.id_semestre = :semestreUID");
		$getEtudiantUID->execute(array(
			':etudiant'    => $etudiant,
			':semestreUID' => $semestreUID
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
			$etudiantUID = $etudiantUID;
		else
			return 'unknown_user';

		

		/*** on cherche un module avec ce nom, en accord avec le semestre et l'étudiant ***/
		$getModuleUID = $this->pdo->prepare("SELECT m.id_module as id FROM module as m, appartenance as app, programme as prog ".
			"WHERE prog.id_module = m.id_module ".
			"AND   prog.id_semestre = app.id_semestre ".
			"AND   m.nom = :module ".
			"AND   app.id_etudiant = :etudiantUID ".
			"AND   app.id_semestre = :semestreUID");
		$getModuleUID->execute(array(
			':module'      => $module,
			':etudiantUID' => $etudiantUID,
			':semestreUID' => $semestreUID
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $moduleUID = $getModuleUID->fetch()['id'] )
			$moduleUID = (int) $moduleUID;
		else
			return 'unknown_module';

		// si on a l'UID utilisateur & l'UID groupe => on récupère les modules
		$getModuleList = $this->pdo->prepare("SELECT note.intitule, note.valeur, note.base ".
			"FROM note, appartenance as app, programme as prog, semestre as s, module as m  ".
			"WHERE note.id_appartenance = app.id_appartenance ".
			"AND   note.id_programme = prog.id_programme ".
			"AND   prog.id_module = m.id_module ".
			"AND   prog.id_semestre = s.id_semestre ".

			"AND   prog.id_module = :moduleUID ".
			"AND   app.id_etudiant = :etudiantUID ".
			"AND   s.id_semestre = :semestreUID ".
			"ORDER BY note.valeur, note.base ASC");
		$getModuleList->execute(array(
			':moduleUID'   => $moduleUID,
			':etudiantUID' => $etudiantUID,
			':semestreUID' => $semestreUID
		));

		$notes = $getModuleList->fetchAll(); // on récupère la liste des notes

		// on supprime les doublons des entrées (indice numérique)
		for( $i = 0 ; $i < count($notes) ; $i++ ) // pour toutes les notes
			foreach($notes[$i] as $col => $val)   // pour toutes les entrées
				if( is_int($col) )                   // si l'indice est un entier
					unset( $notes[$i][$col] );    // on le supprime

		return $notes;
	}





	/**********************************/
	/*** retourne les notes d'un UE ***/
	/**********************************/
	public function getUENotes($etudiant, $UE, $semestre, $annee){
		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur as u, appartenance as app ".
			"WHERE u.identifiant = app.id_etudiant ".
			"AND   u.identifiant = :etudiant ".
			"AND   app.id_semestre = :semestreUID");
		$getEtudiantUID->execute(array(
			':etudiant'    => $etudiant,
			':semestreUID' => $semestreUID
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
			$etudiantUID = $etudiantUID;
		else
			return 'unknown_user';


		/*** on cherche un module avec ce nom, en accord avec le semestre et l'étudiant ***/
		$getUEUID = $this->pdo->prepare("SELECT ue.id_ue as id ".
			"FROM module as m, appartenance as app, programme as prog, ue ".
			"WHERE prog.id_module = m.id_module ".
			"AND   prog.id_semestre = app.id_semestre ".
			"AND   prog.id_ue = ue.id_ue ".

			"AND   ue.nom = :UE ".
			"AND   app.id_etudiant = :etudiantUID ".
			"AND   app.id_semestre = :semestreUID");
		$getUEUID->execute(array(
			':UE'      => $UE,
			':etudiantUID' => $etudiantUID,
			':semestreUID' => $semestreUID
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $UEUID = $getUEUID->fetch()['id'] )
			$UEUID = (int) $UEUID;
		else
			return 'unknown_UE';


		// si on a l'UID utilisateur & l'UID UE => on récupère les notes
		$getUEList = $this->pdo->prepare("SELECT m.nom as module, note.intitule, note.valeur, note.base ".
			"FROM note, appartenance as app, programme as prog, semestre as s, module as m  ".
			"WHERE note.id_appartenance = app.id_appartenance ".
			"AND   note.id_programme = prog.id_programme ".
			"AND   prog.id_module = m.id_module ".
			"AND   prog.id_semestre = s.id_semestre ".

			"AND   prog.id_ue = :UEUID ".
			"AND   app.id_etudiant = :etudiantUID ".
			"AND   s.id_semestre = :semestreUID ".
			"ORDER BY m.nom, note.valeur, note.base ASC");
		$getUEList->execute(array(
			':UEUID'       => $UEUID,
			':etudiantUID' => $etudiantUID,
			':semestreUID' => $semestreUID
		));

		$notes = $getUEList->fetchAll(); // on récupère la liste des notes

		// on supprime les doublons des entrées (indice numérique)
		for( $i = 0 ; $i < count($notes) ; $i++ ) // pour toutes les notes
			foreach($notes[$i] as $col => $val)   // pour toutes les entrées
				if( is_int($col) )                   // si l'indice est un entier
					unset( $notes[$i][$col] );    // on le supprime

		return $notes;
	}









	/******************************************************/
	/***** déplace un étudiant d'un groupe à un autre *****/
	/******************************************************/
	public function deplacerEtudiant($etudiant, $groupe, $semestre, $annee){
		/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
		$getSemestreUID->execute(array(
			':rang' => $semestre,
			':annee' => $annee
		));

		// si on trouve, on le définit, sinon on retourne "unknown_group"
		if( $semestreUID = $getSemestreUID->fetch()['id'] )
			$semestreUID = (int) $semestreUID;
		else
			return 'unknown_semestre';


		/*** on cherche un utilisateur avec cet identifiant ***/
		$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur as u, appartenance as app ".
			"WHERE u.identifiant = app.id_etudiant ".
			"AND   u.identifiant = :etudiant ".
			"AND   app.id_semestre = :semestreUID");
		$getEtudiantUID->execute(array(
			':etudiant'    => $etudiant,
			':semestreUID' => $semestreUID
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
			$etudiantUID = $etudiantUID;
		else
			return 'unknown_user';


		/*** on cherche le nouveau groupe pour cet utilisateur ***/
		$getNouveauGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
			"FROM groupe as g ".
			"WHERE g.nom = :groupe");
		$getNouveauGroupeUID->execute(array(
			':groupe' => $groupe
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $nouveauGroupeUID = $getNouveauGroupeUID->fetch()['id'] )
			$nouveauGroupeUID = $nouveauGroupeUID;
		else
			return 'unknown_newgroup';


		/*** on cherche le groupe de cet utilisateur ***/
		$getGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
			"FROM utilisateur as u, groupe as g, appartenance as app, semestre as s ".
			"WHERE app.id_etudiant = u.identifiant ".
			"AND   app.id_groupe   = g.id_groupe ".
			"AND   app.id_semestre = s.id_semestre ".
			
			"AND   u.identifiant   = :etudiantUID ".
			"AND   app.id_semestre = :semestreUID");
		$getGroupeUID->execute(array(
			':etudiantUID' => $etudiantUID,
			':semestreUID' => $semestreUID,
		));

		// si on trouve, on le définit, sinon on retourne "unknown_user"
		if( $groupeUID = $getGroupeUID->fetch()['id'] ){
			$groupeUID = $groupeUID;

			/***************************************************************/
			/*** CAS 1 : l'utilisateur a déjà un groupe pour ce semestre ***/
			/***************************************************************/

			// il suffit donc maintenant de modifier l' "appartenance"
			$updateGroupe = $this->pdo->prepare("UPDATE appartenance SET id_groupe = :nouveauGroupeUID ".
				"WHERE id_etudiant = :etudiantUID ".
				"AND   id_groupe   = :groupeUID ".
				"AND   id_semestre = :semestreUID");
			$updateGroupe->execute(array(
				':nouveauGroupeUID' => $nouveauGroupeUID,
				':etudiantUID'      => $etudiantUID,
				':groupeUID'        => $groupeUID,
				':semestreUID'      => $semestreUID
			));

		}
		else{
			/****************************************************/
			/*** CAS 2 : l'utilisateur n'a pas encore de groupe */
			/****************************************************/
			$insertGroupe = $this->pdo->prepare("INSERT INTO appartenance(id_appartenance, id_etudiant, id_groupe, id_semestre) ".
				"VALUES(NULL, :etudiantUID, :nouveauGroupeUID, :semestreUID)");
			$insertGroupe->execute(array(
				':etudiantUID'      => $etudiantUID,
				':nouveauGroupeUID' => $nouveauGroupeUID,
				':semestreUID'      => $semestreUID
			));
		}

		/* Vérification de l'entrée dans la table */
		$verif = $this->pdo->prepare("SELECT count(id_appartenance) as count ".
			"FROM appartenance ".
			"WHERE id_etudiant = :etudiantUID ".
			"AND   id_groupe   = :nouveauGroupeUID ".
			"AND   id_semestre = :semestreUID");
		$verif->execute(array(
			':etudiantUID'      => $etudiantUID,
			':nouveauGroupeUID' => $nouveauGroupeUID,
			':semestreUID'      => $semestreUID
		));

		$verifFetch = $verif->fetch();

		if( $verifFetch && $verifFetch['count'] == '1' )
			return 'success';
		else
			return 'error';

	}

}

?>