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 / 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){
		debug();
		/* [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(
					(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)
				)");
			$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);

	}



	/* 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, 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 = 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 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.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   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
	*
	*
	* @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){
		$getGroupeList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe, g.nom
			FROM groupe as g, appartenance as app, mcc_ue, mcc_module as mcc_m, controle as ctrl
			WHERE app.id_groupe = g.id_groupe
			AND   ctrl.id_mcc_module = mcc_m.id_mcc_module
			AND   mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue
			AND   app.id_semestre = mcc_ue.id_semestre

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


		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() );
	}


}