sid/manager/repo/note.php

<?php require_once __ROOT__.'/manager/security.php';

/*************************************************************/
/*    _   _  ___ _____ _____       ____  _____ ____   ___    */
/*   | \ | |/ _ \_   _| ____|     |  _ \| ____|  _ \ / _ \   */
/*   |  \| | | | || | |  _|       | |_) |  _| | |_) | | | |  */
/*   | |\  | |_| || | | |___      |  _ <| |___|  __/| |_| |  */
/*   |_| \_|\___/ |_| |_____|     |_| \_\_____|_|    \___/   */
/*                                                           */
/*************************************************************/

class noteRepo{
	/* VERIFIE L'EXISTENCE D'UNE NOTE POUR UN ÉTUDIANT A UN CONTROLE
	*
	* @etudiant<String>			l'identifiant de l'étudiant recherché
	* @controle<int>			l'UID du contrôle
	* 
	* @return  UID<String>		l'UID de la note si elle existe pour ces critères (la dernière assignée)
	* @return  FALSE<Boolean>	FAUX si aucune note répondant à ces critères n'est pas présente dans la BDD
	* 
	*/
	public static function UID($etudiant, $controle){
		$getNoteUID = DataBase::getPDO()->prepare("SELECT note.id_note as id
			FROM appartenance as app, note, controle as ctrl
			WHERE app.id_appartenance = note.id_appartenance
			AND   ctrl.id_controle = note.id_controle
			
			AND   app.id_etudiant = :etudiant
			AND   ctrl.id_controle = :controle
			AND   note.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)");
		$getNoteUID->execute(array( ':etudiant' => $etudiant, ':controle' => $controle ));

		// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID de l'utilisateur
		return $getNoteUID->fetch()['id'];
	}




	/* RENVOIE LES INFORMATIONS D'UN UTILISATEUR D'UID DONNÉ
	*
	* @utilisateurUID<int>				l'UID de l'utilisateur duquel on veut les infos
	*
	* @return utilisateur<Array>		tableau associatif contenant tout les champs de la BDD pour cet utilisateur
	*
	*/
	public static function info($utilisateurUID){
		// on considère que le semestre existe
		$getUtilisateurInfo = DataBase::getPDO()->prepare("SELECT identifiant, prenom, nom, mail, droits FROM utilisateur WHERE identifiant = :utilisateurUID");
		$getUtilisateurInfo->execute(array(
			':utilisateurUID' => $utilisateurUID
		));

		// on retourne le résultat en supprimant les doublons à indices numériques
		return $getUtilisateurInfo->fetch();
	}





		
	/* RENVOIE LES NOTES D'UN  ETUDIANT POUR UN CONTROLE PARTICULIER
	*
	* @etudiant<String>					l'UID de l'étudiant concerné
	* @controle<int>					l'UID du controle concerné
	*
	* @return notes<Array>				retourne les notes d'un étudiant pour un controle particulier
	*
	*/
	public static function forStudent($etudiant, $controle){
		$getNoteList = DataBase::getPDO()->prepare("SELECT DISTINCT n.id_note as id, n.id_appartenance, n.id_controle, n.valeur
			FROM note as n, appartenance as app, semestre as s, controle as ctrl, mcc_ue, mcc_module as mcc_m
			WHERE n.id_appartenance = app.id_appartenance
			AND   app.id_semestre = s.id_semestre
			AND   s.id_semestre = mcc_ue.id_semestre
			AND   mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
			AND   mcc_m.id_mcc_module = ctrl.id_mcc_module
			AND   n.id_controle = ctrl.id_controle
			AND   n.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)

			AND   app.id_etudiant = :etudiant
			AND   ctrl.id_controle = :controle
			ORDER BY n.valeur ASC");
		$getNoteList->execute(array( ':etudiant' => $etudiant, ':controle' => $controle ));

		return DataBase::delNumeric( $getNoteList->fetchAll() );
	}





	/* RENVOIE LES NOTES POUR UN CONTROLE PARTICULIER
	*
	*  [1] Par groupe si aucun groupe spécifié (statistiques: moyenne, min, max, nb notes, ...)
	*  [2] Liste des élèves d'un groupe si aucun groupe spécifié
	*
	* 
	* @controle<int>					l'UID du controle concerné
	*
	* @groupe<int>						***OPTIONNEL*** l'UID du groupe spécifique 
	* 
	*
	* @return notes<Array>				[1] retourne les stats des notes pour les groupes à ce contrôle
	*                             		[2] retourne les notes des étudiants du groupe spécifié pour ce contrôle
	*
	*/
	public static function forControle($controle, $groupe=null){	
		/* [1] Statistiques des groupes
		============================================================*/
		if( !is_int($groupe) ){

			$getNoteList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe, g.nom as groupe, n.id_note as id, n.id_controle, AVG(n.valeur) as moyenne, min(n.valeur) as min, max(n.valeur) as max, COUNT(n.valeur) as nb_notes
				FROM note as n, appartenance as app, semestre as s, controle as ctrl, mcc_ue, mcc_module as mcc_m, groupe as g
				WHERE n.id_appartenance = app.id_appartenance
				AND   app.id_semestre = s.id_semestre
				AND   app.id_groupe = g.id_groupe
				AND   s.id_semestre = mcc_ue.id_semestre
				AND   mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
				AND   mcc_m.id_mcc_module = ctrl.id_mcc_module
				AND   n.id_controle = ctrl.id_controle

				AND   n.id_note in (SELECT max(id_note) FROM note GROUP BY id_appartenance, id_controle)

				AND   ctrl.id_controle = :controle

				GROUP BY g.id_groupe

				ORDER BY g.nom ASC");
			$getNoteList->execute(array( ':controle' => $controle ));


		/* [2] Notes des étudiants d'un groupe
		============================================================*/
		}else{

			$getNoteList = DataBase::getPDO()->prepare("SELECT DISTINCT n.id_note as id, g.nom as groupe, app.id_etudiant as etudiant, n.id_appartenance, n.id_controle, n.valeur
				FROM note as n, appartenance as app, semestre as s, controle as ctrl, mcc_ue, mcc_module as mcc_m, groupe as g
				WHERE n.id_appartenance = app.id_appartenance
				AND   app.id_semestre = s.id_semestre
				AND   app.id_groupe = g.id_groupe
				AND   s.id_semestre = mcc_ue.id_semestre
				AND   mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
				AND   mcc_m.id_mcc_module = ctrl.id_mcc_module
				AND   n.id_controle = ctrl.id_controle
				
				AND   n.id_note in (SELECT max(id_note) FROM note GROUP BY id_appartenance, id_controle)

				AND   ctrl.id_controle = :controle
				AND   app.id_groupe = :groupe

				ORDER BY g.nom ASC");
			$getNoteList->execute(array( ':controle' => $controle, ':groupe' => $groupe ));

		}

		return DataBase::delNumeric( $getNoteList->fetchAll() );
	}




	/* RENVOIE LES STATISTIQUES ASSOCIÉES À UN CONTRÔLE POUR UN GROUPE SPÉCIFIQUE
	* 
	* @controle<int>					l'UID du controle concerné
	* @groupe<int>						l'UID du groupe spécifique 
	* 
	*
	* @return notes<Array>				retourne les stats des notes pour les groupes à ce contrôle
	* @return FALSE<Boolean>			retourne FALSE si aucun résultat n'est trouvé
	* 
	*/
	public static function forGroupe($controle, $groupe){
		$getNoteList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe, g.nom as groupe, n.id_note as id, n.id_appartenance, n.id_controle, AVG(n.valeur) as moyenne, min(n.valeur) as min, max(n.valeur) as max, COUNT(n.valeur) as nb_notes
			FROM note as n, appartenance as app, semestre as s, controle as ctrl, mcc_ue, mcc_module as mcc_m, groupe as g
			WHERE n.id_appartenance = app.id_appartenance
			AND   app.id_semestre = s.id_semestre
			AND   app.id_groupe = g.id_groupe
			AND   s.id_semestre = mcc_ue.id_semestre
			AND   mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
			AND   mcc_m.id_mcc_module = ctrl.id_mcc_module
			AND   n.id_controle = ctrl.id_controle
			
			AND   n.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)

			AND   ctrl.id_controle = :controle
			AND   app.id_groupe = :groupe

			GROUP BY g.id_groupe

			ORDER BY g.nom ASC");
		$getNoteList->execute(array( ':controle' => $controle, ':groupe' => $groupe ));

		return $getNoteList->fetch();
	}


	/* RETOURNE LA MOYENNE D'UN CONTRÔLE PARTICULIER
	*
	* @controle<int>				l'UID du contrôle en question
	*
	*
	* @return moyenne<Float>		retourne la moyenne d'un contrôle
	* @return NULL					retourne NULL s'il y a aucune note à ce contrôle
	*
	*/
	public static function moyenneForControle($controle){
		$getMoyenne = DataBase::getPDO()->prepare("SELECT ctrl.id_controle, AVG(n.valeur) as moyenne
			FROM controle as ctrl, note as n
			WHERE ctrl.id_controle = n.id_controle
			AND   ctrl.id_controle = :controle
			AND   n.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)

			GROUP BY ctrl.id_controle");
		$getMoyenne->execute(array( ':controle' => $controle ));

		if( $fetchObj = $getMoyenne->fetch() )
			return $fetchObj['moyenne'];
		else
			return null;
	}



	/* RETOURNE LA MOYENNE D'UN MODULE POUR UN ETUDIANT
	*
	* @etudiant<String>					l'UID de l'étudiant en question
	* @module<int>						l'UID du module en quesion
	* @semestre<int>					l'UID du semestre en question
	*
	*
	* @return moyenne<Float>			retourne la valeur de la moyenne en question
	* @return FALSE<Boolean>			retourne FALSE si rien n'est trouvé
	*
	*/
	public static function moyenneModule($etudiant, $module, $semestre){
		$getMoyenneModule = DataBase::getPDO()->prepare("SELECT SUM(note.valeur*ctrl.coefficient)/SUM(ctrl.coefficient) as moyenne, ctrl.base
			FROM note, appartenance as app, controle as ctrl, mcc_module as mcc_m, mcc_ue, semestre as s
			WHERE note.id_controle = ctrl.id_controle
			AND   ctrl.id_mcc_module = mcc_m.id_mcc_module
			AND   mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue
			AND   mcc_ue.id_semestre = app.id_semestre
			AND   app.id_etudiant = :etudiant
			AND   mcc_m.id_module = :module
			AND   app.id_semestre = :semestre
			AND   note.id_note in (SELECT max(id_note) FROM note WHERE id_controle=ctrl.id_controle AND id_appartenance=app.id_appartenance GROUP BY id_controle, id_appartenance)
			GROUP BY mcc_m.id_mcc_module");
		$getMoyenneModule->execute(array( ':etudiant' => $etudiant, ':module' => $module, ':semestre' => $semestre ));
	
		return $getMoyenneModule->fetch();
	}



	/* CRÉATION/MODIFICATION D'UNE NOTE POUR UN ETUDIANT À UN CONTRÔLE
	*
	* @etudiant<String>				l'UID de l'étudiant en question
	* @controle<int>				l'UID du contrôle en question
	* @semestre<int>				l'UID du semestre en question
	* @valeur<number>				valeur de la note à saisir
	*
	* 
	* @return noteUID<int>			l'UID de la note si elle a bien été créé
	* @return cree<Boolean>			FALSE si la note n'a pas été créé
	*
	*/
	public static function creer($etudiant, $controle, $semestre, $valeur){
		/* [1] Premier cas : il faut créer la note de cet étudiant pour ce contrôle
		============================================================================*/
		/* [MAJ] On créé toujours une note, même si une existe déjà afin de garder toutes les modifications */
		if( true ){ // !($noteUID=noteRepo::UID($etudiant, $controle))

			$creationNote = DataBase::getPDO()->prepare("INSERT INTO note(id_note, id_appartenance, id_controle, valeur) 
				VALUES(
					DEFAULT,
					(SELECT id_appartenance FROM appartenance WHERE id_etudiant = :etudiant AND id_semestre = :semestre),
					:controle,
					:valeur
				)");
			$creationNote->execute(array( ':etudiant' => $etudiant, ':semestre' => $semestre, ':controle' => $controle, ':valeur' => $valeur ));


		/* [2] Second cas : il faut modifier la note de cet étudiant
		============================================================================*/
		}else{

			$modificationNote = DataBase::getPDO()->prepare("UPDATE note SET valeur = :valeur WHERE id_note = :noteUID");
			$modificationNote->execute(array( ':valeur' => $valeur, ':noteUID' => $noteUID ));

		}

		/* [3] On vérifie que la note a bien été créé pour cet étudiant et ce contrôle
		=================================================================================*/
		$verifNote = DataBase::getPDO()->prepare("SELECT n.id_note as id, n.valeur
			FROM note as n, appartenance as app
			WHERE n.id_appartenance = app.id_appartenance
			AND   app.id_etudiant = :etudiant
			AND   n.id_controle = :controle
			AND   n.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)
			GROUP BY app.id_appartenance, n.id_controle");
		$verifNote->execute(array( ':etudiant' => $etudiant, ':controle' => $controle ));

		$verifResult = $verifNote->fetch(); 

		// si aucun résultat, on retourne FALSE
		if( !is_array($verifResult) ) return false;
	
		// sinon on retourne la vérification de la valeur	
		return $verifResult['valeur'] == $valeur;
	}



	/* CRÉATION/MODIFICATION DE NOTES MULTIPLE
	*
	* @notes<Array>
		* @etudiant<String>				l'UID de l'étudiant en question
		* @controle<int>				l'UID du contrôle en question
		* @semestre<int>				l'UID du semestre en question
		* @valeur<number>				valeur de la note à saisir
	*
	* 
	* @return noteUID<int>			l'UID de la note si elle a bien été créé
	* @return cree<Boolean>			FALSE si la note n'a pas été créé
	*
	*/
	public static function creerMultiple($controle, $semestre, $notes){
		$saisieFinie = true;

		foreach($notes as $iter=>$note){


			$cEtudiant = $note->etudiant;
			$cValeur   = $note->valeur;

			/* [1] Il faut créer la note de cet étudiant pour ce contrôle
			============================================================================*/
			$creationNote = DataBase::getPDO()->prepare("INSERT INTO note(id_note, id_appartenance, id_controle, valeur) 
				VALUES(
					DEFAULT,
					(SELECT id_appartenance FROM appartenance WHERE id_etudiant = :etudiant AND id_semestre = :semestre),
					:controle,
					:valeur
				)");
			$creationNote->execute(array( ':etudiant' => $cEtudiant, ':semestre' => $semestre, ':controle' => $controle, ':valeur' => $cValeur ));


			/* [2] On vérifie que la note a bien été créé pour cet étudiant et ce contrôle
			=================================================================================*/
			if( !($noteUID=noteRepo::UID($cEtudiant, $controle)) ) return false;

			/* [3] On vérifie que la note créée a bien la valeur qu'on a attribuée
			=================================================================================*/
			$verificationValeur = DataBase::getPDO()->prepare("SELECT valeur FROM note WHERE id_note = :noteUID");
			$verificationValeur->execute(array( ':noteUID' => $noteUID ));


			$saisieFinie = $saisieFinie && ( $verificationValeur->fetch()['valeur'] == $cValeur );
		}

		return $saisieFinie;
	}


}