sid/manager/repo/group.php

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

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

class groupRepo{
	/* VERIFIE L'EXISTENCE D'UN GROUPE DANS LA BDD
	*
	* @nom<String>				le nom du groupe recherché
	*
	* @return  UID<int>			si le groupe est dans la BDD, retourne son UID (auto_incr)
	* @return  FALSE<Boolean>	FAUX si aucun groupe avec ce nom n'est pas présent dans la BDD
	* 
	*/
	public static function UID($nom){
		/*** on cherche un groupe avec ce nom ***/
		$getGroupeUID = DataBase::getPDO()->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'];
	}



	/* RETOURNE LES INFORMATIONS RELATIVES A UN GROUPE
	*
	* @groupeUID<int>			l'UID du groupe
	*
	* @return existe<Boolean>	FAUX si le groupe n'existe pas
	* @return infos<Array>		les informations relatives au groupe
	*
	*/
	public static function info($groupeUID){
		// on considère que le groupe existe
		$getGroupeInfo = DataBase::getPDO()->prepare("SELECT id_groupe as id, nom FROM groupe WHERE id_groupe = :groupeUID");
		$getGroupeInfo->execute(array( ':groupeUID' => $groupeUID ));

		return $getGroupeInfo->fetch();
	}


	/* VERIFIE L'EXISTENCE D'UNE APPARTENANCE DANS LA BDD
	*
	* @etudiant<String>		l'identifiant (UID) de l'étudiant à ajouter au groupe
	* @groupe<String>       le nom du groupe auquel on veut le ratacher
	* @semestre<int>        l'UID du semestre pour lequel il sera membre
	*
	* @return  UID<int>			si l'appartenance est dans la BDD, retourne son UID (auto_incr)
	* @return  FALSE<Boolean>	FAUX si aucune appartenance pour cet étudiant à ce groupe pour ce semestre n'est pas présent dans la BDD
	* 
	*/
	public static function appartenanceUID($etudiant, $groupe, $semestre){
		/*** on cherche un groupe avec ce nom ***/
		$getAppartenanceUID = DataBase::getPDO()->prepare("SELECT id_appartenance as id
			FROM appartenance
			WHERE id_etudiant = :etudiant
			AND   id_groupe   = :groupe
			AND   id_semestre = :semestre");
		$getAppartenanceUID->execute(array(
			':etudiant' => $etudiant,
			':groupe' => $groupe,
			':semestre' => $semestre
		));

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






	/* CREER UN GROUPE AVEC CE NOM
	*
	* @nom<String>					le nom du groupe à créer
	*
	* @return UID<int>				l'UID du groupe maintenant créé
	* @return created<Boolean>		FAUX si le groupe existait déjà ou qu'il n' pasa bien été créé
	* 
	*/
	public static function creer($nom){
		/* [1] On vérifie l'existence d'un groupe avec ce nom
		======================================================*/
		if( $groupeUID=groupRepo::UID($nom) ) // si le groupe existe déjà
			return $groupeUID;      // on retourne FAUX

		/* [2] On créé le groupe 
		=========================*/
		$nom = strtoupper($nom); // on met le nom en majuscules

		// on créé et envoie la requête de création du groupe
		$creerGroupe = DataBase::getPDO()->prepare("INSERT INTO groupe(id_groupe, nom) VALUES(default, :nom)");
		$creerGroupe->execute(array(
			':nom' => $nom
		));

		/* [3] On vérifie si le groupe a bien été créé
		===============================================*/
		return groupRepo::UID($nom);
	}


	/* AJOUTER UN MEMBRE A UN GROUPE / DEPLACER UN MEMBRE VERS UN GROUPE DONNE (si déjà dans un groupe)
	*
	* @etudiant<String>		l'identifiant (UID) de l'étudiant à ajouter au groupe
	* @groupe<int>          l'UID du groupe auquel on veut le ratacher
	* @semestre<int>        l'UID du semestre pour lequel il sera membre
	*
	* @UID<Boolean>			l'UID de l'appartenance si l'utilisateur a été ajouté au groupe pour ce semestre
	* @member<Boolean>		FAUX si l'utilisateur n'a pas été créé pour une quelconque erreur
	* 
	*/
	public static function ajouterMembre($etudiant, $groupe, $semestre){

		/* [1] On vérifie si l'utilisateur appartient à un groupe pour ce semestre
		===========================================================================*/
		if( $appartenanceUID = groupRepo::forStudent($etudiant, $semestre)['id_appartenance'] ){ // si c'est le cas

			/* [2] On modifie l'appartenance
			==============================*/
			// création et exécution de la requête de modification de l'appartenance
			$ajouterMembres = DataBase::getPDO()->prepare("UPDATE appartenance
				SET id_groupe = :groupe
				WHERE id_appartenance = :appartenanceUID");
			$ajouterMembres->execute(array(
				':groupe'   => $groupe,
				':appartenanceUID' => $appartenanceUID
			));

		}else{ // si l'utilisateur n'a pas de groupe pour ce semestre

			/* [2] On créé l'appartenance
			==============================*/
			// création et exécution de la requête de création d'appartenance
			$ajouterMembres = DataBase::getPDO()->prepare("INSERT INTO appartenance(id_etudiant, id_groupe, id_semestre)
				VALUES(:etudiant, :groupe, :semestre)");
			$ajouterMembres->execute(array(
				':etudiant' => $etudiant,
				':groupe'   => $groupe,
				':semestre' => $semestre
			));

		}

		/* [3] On vérifie que l'appartenance est bien définie
		======================================================*/
		return groupRepo::appartenanceUID($etudiant, $groupe, $semestre);

	}




	/* DEFINIT LA MENTION DU JURY POUR UNE APPARTENANCE
	*
	* @etudiant<String>					UID de l'étudiant en question
	* @semestre<int>					UID du semestre en question
	* @mention<String>					Mention à affecter à l'appartenance
	*
	*/
	public static function setMention($etudiant, $semestre, $mention){
		$setMention = DataBase::getPDO()->prepare("UPDATE appartenance
			SET mention = :mention
			WHERE id_etudiant = :etudiant
			AND   id_semestre = :semestre");
		$setMention->execute(array( ':mention' => $mention, ':etudiant' => $etudiant, ':semestre' => $semestre ));

	}


	/* RETOURNE LA LISTE DES UTILISATEURS MEMBRES D'UN GROUPE
	*
	* @groupeUID<int>				l'UID du groupe en question
	* @semestreUID<int>				l'UID du semestre en question
	*
	* @return membres<Array>		la liste des utilisateurs du groupe
	*
	*/
	public static function membres($groupeUID, $semestreUID){
		// si le groupe existe => on récupère ses utilisateurs
		// var_dump($groupeUID.' - '.$semestreUID);
		$getMembres = DataBase::getPDO()->prepare("SELECT u.identifiant, u.prenom, u.nom, u.sexe, u.mail, u.droits, s.nom as semestre, g.id_groupe, g.nom as groupe, app.mention
			FROM utilisateur as u, groupe as g, semestre as s, appartenance as app, formation as f
			WHERE s.id_formation = f.id_formation
			AND   u.identifiant = app.id_etudiant
			AND   g.id_groupe   = app.id_groupe
			AND   app.id_semestre = s.id_semestre
			
			AND   g.id_groupe   = :groupeUID
			AND   s.id_semestre = :semestreUID
			ORDER BY u.prenom, u.nom");
		$getMembres->execute(array(
			':groupeUID' => $groupeUID,
			':semestreUID' => $semestreUID
		));

		// on retourne la liste des membres en supprimant les doublons à indices numériques
		return DataBase::delNumeric( $getMembres->fetchAll() );
	}




	/* RETOURNE LE GROUPE AUQUEL EST INSCRIT UN ETUDIANT POUR UN SEMESTRE DONNÉ
	*
	* @etudiant<String>					l'UID de l'étudiant en question
	* @semestre<int>					l'UID du semestre en question
	*
	* @return trouve<Boolean>			FAUX si aucun groupe ne correspond aux critères
	* @return groupe<int>				retourne l'UID du groupe correspondant
	*
	*/
	public static function forStudent($etudiant, $semestre){
		$getGroupe = DataBase::getPDO()->prepare("SELECT DISTINCT app.id_appartenance, g.id_groupe as id, g.nom, s.id_semestre, s.nom as semestre, f.id_formation, f.code as formation, f.nom as nom_formation
			FROM groupe as g, appartenance as app, formation as f, semestre as s
			WHERE s.id_formation = f.id_formation
			AND   app.id_groupe   = g.id_groupe
			AND   app.id_semestre = s.id_semestre

			AND   app.id_etudiant = :etudiant
			AND   s.id_semestre = :semestre
			ORDER BY g.nom");
		$getGroupe->execute(array( ':etudiant' => $etudiant, ':semestre' => $semestre ));

		return $getGroupe->fetch();
	}





	/* RETOURNE TOUS LES GROUPES QUI ONT UN ENSEIGNANT PARTICULIER POUR UNE ANNEE DONNEE
	*
	* @enseignant<String>					l'UID de l'enseignant recherché
	* @semestre_pair<Boolean>				VRAI si le semestre courant est pair (***OPTIONNEL***)
	* @annee<int>							l'année recherchée
	*
	* 
	* @return groupes<Array>				retourne la liste des groupes correspondant aux critères
	* 
	*/
	public static function forTeacher($enseignant, $semestre_pair, $annee){

		$semestrePair0 = '0'; $semestrePair1 = '1';
		if( is_bool($semestre_pair) ){ $semestrePair0 = ($semestre_pair)?'0':'1'; $semestrePair1 = ($semestre_pair)?'0':'1'; }

		$getGroupeList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe as id, g.nom, s.rang, s.id_semestre, s.nom as semestre, f.id_formation, f.code as formation, f.nom as nom_formation
			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, formation as f
			WHERE s.id_formation      = f.id_formation
			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   mcc_m.id_mcc_module = ens.id_mcc_module
			
			AND   ens.id_enseignant   = u.identifiant
			AND   ens.id_groupe       = g.id_groupe
			AND   ens.correcteur      = 1
			
			AND   app.id_etudiant     = eleve.identifiant
			AND   app.id_semestre     = s.id_semestre
			AND   app.id_groupe       = g.id_groupe
			
			AND   u.identifiant       = :enseignant
			AND   (s.rang % 2 = :semestre_pair0 OR s.rang % 2 = :semestre_pair1)
			AND   s.annee             = :annee
			ORDER BY s.rang, g.nom");
		$getGroupeList->execute(array( ':enseignant' => $enseignant, ':semestre_pair0' => $semestrePair0, ':semestre_pair1' => $semestrePair1, ':annee' => $annee ));

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





	/* RETOURNE LES GROUPES INSCRITS A UN CONTROLE
	*
	* @controle<int>				l'UID du contrôle en question
	*
	* @enseignant<int>				***OPTIONNEL*** l'UID de l'enseignant en question
	*
	* 
	* @return groupes<Array>		retourne un tableau contenant les groupes inscrits à ce contrôle
	* @return FALSE<Boolean>		retourne FALSE si aucun groupe n'y est inscrit
	*
	*/
	public static function forControle($controle, $enseignant=null){

		/* [1] Tous les groupes pour un contrôle
		===============================================*/
		if( !is_string($enseignant) ){ // admin et master

			$getGroupList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe, g.nom
				FROM controle as ctrl, mcc_module as mcc_m, mcc_ue, appartenance as app, groupe as g
				WHERE 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_groupe = g.id_groupe

				AND   ctrl.id_controle = :controle
				ORDER BY g.nom ASC");
			$getGroupList->execute(array( ':controle' => $controle ));


		/* [2] Les groupes d'un enseignant uniquement
		===============================================*/
		}else{ // teacher
			$getGroupList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe, g.nom
				FROM controle as ctrl, mcc_module as mcc_m, enseignement as ens, groupe as g 
				WHERE ctrl.id_mcc_module = mcc_m.id_mcc_module
				AND   ens.id_mcc_module = mcc_m.id_mcc_module
				AND   ens.id_groupe = g.id_groupe

				AND   ens.id_enseignant LIKE '$enseignant'

				AND   ctrl.id_controle = :controle
				ORDER BY g.nom ASC");
			$getGroupList->execute(array( ':controle' => $controle ));

		}


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



	/* RETOURNE TOUS LES GROUPES DU SEMESTRE SPÉCIFIÉ
	*
	* @semestreUID<int>						L'UID du semestre en question
	*
	* 
	* @return groupes<Array>				retourne la liste des groupes correspondant aux critères
	* 
	*/
	public static function forSemestre($semestreUID){

		$getGroupeList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe as id, g.nom, s.rang, s.id_semestre, s.nom as semestre, f.id_formation, f.code as formation, f.nom as nom_formation
			FROM groupe as g, semestre as s, appartenance as app, formation as f
			WHERE s.id_formation = f.id_formation
			AND   g.id_groupe   = app.id_groupe
			AND   s.id_semestre = app.id_semestre

			AND   s.id_semestre = :semestreUID
			ORDER BY g.nom");
		$getGroupeList->execute(array( ':semestreUID' => $semestreUID ));
	
		return DataBase::delNumeric( $getGroupeList->fetchAll() );
	}


	/* RETOURNE TOUS LES GROUPES DES SEMESTRES COURANT D'UNE ANNÉE
	*
	* @semestre_pair<Boolean>				VRAI si le semestre courant est pair (***OPTIONNEL***)
	* @annee<int>							L'année en cours
	*
	* 
	* @return groupes<Array>				retourne la liste des groupes correspondant aux critères
	* 
	*/
	public static function forYear($semestre_pair, $annee){

		$semestrePair0 = '0'; $semestrePair1 = '1';
		if( is_bool($semestre_pair) ){ $semestrePair0 = ($semestre_pair)?'0':'1'; $semestrePair1 = ($semestre_pair)?'0':'1'; }
		
		$getGroupeList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe as id, g.nom, s.rang, s.id_semestre, s.nom as semestre, f.id_formation, f.code as formation, f.nom as nom_formation
			FROM groupe as g, semestre as s, appartenance as app, formation as f
			WHERE s.id_formation = f.id_formation
			AND   g.id_groupe   = app.id_groupe
			AND   s.id_semestre = app.id_semestre

			AND   (s.rang % 2 = :semestre_pair0 OR s.rang % 2 = :semestre_pair1)
			AND   s.annee = :annee
			ORDER BY g.nom");
		$getGroupeList->execute(array( ':semestre_pair0' => $semestrePair0, ':semestre_pair1' => $semestrePair1, ':annee'  => $annee ));
	
		return DataBase::delNumeric( $getGroupeList->fetchAll() );
	}



	/* retourne la liste exhaustive des groupes
	*
	* @return groupes<Array>			retourne la liste des groupes de la BDD
	*
	*/
	public static function getAllGroups(){
		$getGroupList = DataBase::getPDO()->query("SELECT DISTINCT id_groupe as id, nom FROM groupe ORDER BY LENGTH(nom), nom ASC");
		// $getGroupList = DataBase::getPDO()->query("SELECT id_groupe as id, nom FROM groupe WHERE length(nom) <= 6 ORDER BY nom ASC");

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



	/* retourne les groupes inscrits à un mcc_module
	*
	* @mcc_module<int>				l'UID du mcc_module en question
	*
	*
	* @return groupes<Array>		retourne la liste des groupes inscrits à ce mcc_module
	*
	*/
	public static function inscritsMccModule($mcc_module){
		$getGroupeList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe as id, g.nom
			FROM groupe as g, appartenance as app, mcc_ue, mcc_module as mcc_m
			WHERE mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue
			AND   mcc_ue.id_semestre = app.id_semestre
			AND   app.id_groupe = g.id_groupe

			AND   mcc_m.id_mcc_module = :mcc_module
			ORDER BY nom ASC");
		$getGroupeList->execute(array( ':mcc_module' => $mcc_module ));

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





	/* retourne l'UID d'une appartenance et la créé en amont si elle n'existe pas
	*
	* @identifiant<String>				l'UID de l'étudiant en question
	* @semestre<int>					l'UID du semestre en question
	*
	*
	* @return UID<String>				retourne l'UID de l'appartenance
	* @return FALSE<Boolean>			retourne FALSE si une erreur occure
	* 
	*/
	public static function includeAppartenance($identifiant, $semestre){
		/* [1] On vérifie l'existence de l'appartenance
		======================================================*/
		$getAppartenanceUID = DataBase::getPDO()->prepare("SELECT id_appartenance as id
			FROM appartenance
			WHERE id_etudiant = :identifiant
			AND   id_semestre = :semestre");
		$getAppartenanceUID->execute(array( ':identifiant' => $identifiant, ':semestre' => $semestre ));

		/* [2] Cas où l'appartenance existe déjà, alors on retourne l'UID
		======================================================*/
		if( $appartenanceUID = $getAppartenanceUID->fetch()['id'] ) return $appartenanceUID;

		/* [3] Cas où l'appartenance n'existe pas, 
		/*     alors on met l'étudiant dans le groupe de même
		/*     nom que la formation+semestre
		======================================================*/


			/* [3-1] On vérifie l'existence du groupe de même nom que la formation+semestre
			======================================================*/
			$getGroupeUID = DataBase::getPDO()->prepare("SELECT DISTINCT id_groupe as id
				FROM groupe
				WHERE nom = (SELECT concat(f.code, ' ', s.nom) as nom
					FROM semestre as s, formation as f
					WHERE s.id_formation = f.id_formation
					AND   s.id_semestre = :semestre)");
			$getGroupeUID->execute(array( ':semestre' => $semestre ));


			/* [3-2] Le groupe n'existe pas, alors on le créé
			======================================================*/
			if( !($groupeUID=$getGroupeUID->fetch()['id']) ){

				$creerGroupe = DataBase::getPDO()->prepare("INSERT INTO groupe(id_groupe, nom)
					VALUES(DEFAULT, (SELECT concat(f.code, ' ', s.nom) as nom
						FROM semestre as s, formation as f
						WHERE s.id_formation = f.id_formation
						AND   s.id_semestre = :semestre)
					)");
				$creerGroupe->execute(array( ':semestre' => $semestre ));

				
				// si le groupe n'a pas été créé (erreur) on retourne false
				$getGroupeUID = DataBase::getPDO()->prepare("SELECT DISTINCT id_groupe as id
					FROM groupe
					WHERE nom = (SELECT concat(f.code, ' ', s.nom) as nom
						FROM semestre as s, formation as f
						WHERE s.id_formation = f.id_formation
						AND   s.id_semestre = :semestre)");
				$getGroupeUID->execute(array( ':semestre' => $semestre ));

				if( !($groupeUID=$getGroupeUID->fetch()['id']) ) return false;

			}



		$creerAppartenance = DataBase::getPDO()->prepare("INSERT INTO appartenance(id_appartenance, id_etudiant, id_groupe, id_semestre, mention)
			VALUES(DEFAULT, :identifiant, :groupeUID, :semestre, DEFAULT)");
		$creerAppartenance->execute(array(
			':identifiant' => $identifiant,
			':groupeUID'   => $groupeUID,
			':semestre'    => $semestre
		));

		/* [4] On vérifie que l'appartenance a été créé et retourne son UID
		======================================================*/
		$getAppartenanceUID = DataBase::getPDO()->prepare("SELECT id_appartenance as id
			FROM appartenance
			WHERE id_etudiant = :identifiant
			AND   id_semestre = :semestre");
		$getAppartenanceUID->execute(array( ':identifiant' => $identifiant, ':semestre' => $semestre ));

		return $getAppartenanceUID->fetch()['id'];
	}



	/**
	* Fonction search : recherche dans la bae de données un utilisateur
	* Pour se faire on recherche un mot clé contenu dans le nom ou le prénom de l'utilisateur
	*
	* @param $mot: le mot clé de la recherche associée
	* @return le tableau des résultats, ou false en cas d'erreur
	*==================================================================================================>
	*/
	public static function search($mot){
		//Vérification du paramètre:
		if (! checkParam($mot, '<string>')) {
			return false;
		}
		//On recherche dans la table utilisateur dans les noms et prénoms qui contiendraient une ccurence de "mot"
		$statement  = DataBase::getPDO()->prepare("SELECT * FROM utilisateur".
			" WHERE nom LIKE :nom OR :prenom OR nom = :mot OR prenom = :mot ;");
		$ret = $statement->execute(array(':nom'    => '%'.$mot.'%',
			                             ':prenom' => '%'.$mot.'%',
			                             ':mot'    => $mot));
		if($ret)
			return $statement->fetchAll();
		return false;
	}


}