sid/manager/repo/group.php

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

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

class groupRepo extends DBAccess{
	/* 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, libelle 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( groupRepo::UID($nom) ) // si le groupe existe déjà
			return false;      // 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
	*
	* @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
		===========================================================================*/
		$dejaMembre = DataBase::getPDO()->prepare("SELECT id_appartenance as id ".
			"FROM appartenance ".
			"WHERE id_etudiant = :etudiant ".
			"AND   id_semestre = :semestre ");
		$dejaMembre->execute(array(
			':etudiant' => $etudiant,
			':semestre' => $semestre
		));

		if( $appartenanceUID = $dejaMembre->fetch()['id'] ){ // 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");
			$ajouterMembre->execute(array(
				':groupe'   => $groupeUID,
				':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( ".
					"(SELECT identifiant FROM utilisateur WHERE identifiant = :etudiant), ".
					"(SELECT id_groupe FROM groupe WHERE id_groupe = :groupe), ".
					"(SELECT id_semestre FROM semestre WHERE id_semestre = :semestre) ".
				" )");
			$ajouterMembre->execute(array(
				':etudiant' => $etudiantUID,
				':groupe'   => $groupeUID,
				':semestre' => $semestre
			));

		}

		/* [3] On vérifie que l'appartenance est bien définie
		======================================================*/
		return groupRepo::appartenanceUID($etudiant, $groupe, $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
		$getMembres = DataBase::getPDO()->prepare("SELECT u.identifiant, u.prenom, u.nom, u.mail, u.droits, s.nom as semestre, g.id_groupe, g.nom as groupe ".
			"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   app.id_semestre = app.id_semestre ". // à virer (peut-être)
			
			"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 g.id_groupe as id, g.nom, g.libelle ".
			"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");
		$getGroupe->execute(array( ':etudiantUID' => $etudiantUID, ':semestreUID' => $semestreUID ));

		return DataBase::delNumeric( $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
	* @annee<int>							l'année recherchée
	*
	* @pSemestre<int>						***OPTIONNEL*** le nom du semestre
	* @pGroupe<String>						***OPTIONNEL*** le nom du groupe
	*
	* 
	* @return groupes<Array>				retourne la liste des groupes correspondant aux critères
	* 
	*/
	public static function forTeacher($enseignant, $semestre_pair, $annee, $pSemestre=null, $pGroupe=null){
		// si le semestre est donné, on cherche uniquement celui-ci, sinon on les affiche tous
		$semestreOpt = '%';
		if( $pSemestre != null ){ $semestreOpt = $pSemestre; }

		// si le groupe est donné, on cherche uniquement celui-ci, sinon on les affiche tous
		$groupeOpt = '%';
		if( $pGroupe != null   ){ $groupeOpt = $pGroupe; }
	

		$getGroupeList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe as id, g.nom, s.rang, s.id_semestre, s.nom as semestre ".
			"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   ens.correcteur = 1 ". // uniquement les groupes pour lesquels il est correcteur

			"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.nom LIKE '".$semestreOpt."' ".
			"AND   u.identifiant = :enseignant ".
			"AND   s.rang % 2 = :semestre_pair ".
			"AND   s.annee = :annee ".
			"ORDER BY s.rang, g.nom");
		$getGroupeList->execute(array( ':enseignant' => $enseignant, ':semestre_pair' => ($semestre_pair) ? '0' : '1', ':annee' => $annee ));

		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
	* @annee<int>							L'année en cours
	*
	* @pSemestre<int>						***OPTIONNEL*** le nom du semestre
	* @pGroupe<String>						***OPTIONNEL*** le nom du groupe
	*
	* 
	* @return groupes<Array>				retourne la liste des groupes correspondant aux critères
	* 
	*/
	public static function forYear($semestre_pair, $annee, $pSemestre=null, $pGroupe=null){
		// si le semestre est donné, on cherche uniquement celui-ci, sinon on les affiche tous
		$semestreOpt = '%';
		if( $pSemestre != null ){ $semestreOpt = $pSemestre; }

		// si le groupe est donné, on cherche uniquement celui-ci, sinon on les affiche tous
		$groupeOpt = '%';
		if( $pGroupe != null   ){ $groupeOpt = $pGroupe; }

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

			"AND   g.nom LIKE '".$groupeOpt."' ".
			"AND   s.nom LIKE '".$semestreOpt."' ".
			"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() );
	}


}