555 lines
20 KiB
PHP
Executable File
555 lines
20 KiB
PHP
Executable File
<?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'];
|
|
}
|
|
|
|
|
|
|
|
/* Recherche des étudiants avec un mot clé
|
|
*
|
|
* @keyword<String> Mot clé en question
|
|
*
|
|
*
|
|
* @return results<Array> Tableau contenant les étudiants matchant le mot clé
|
|
* FALSE si une erreur occure
|
|
*
|
|
*/
|
|
public static function search($keyword){
|
|
|
|
// Vérification du paramètre
|
|
if( !checkParam($keyword, '<string>') ) return false;
|
|
|
|
// On recherche dans la table utilisateur dans les noms et prénoms qui contiendraient une occurence de "keyword"
|
|
$statement = DataBase::getPDO()->prepare("SELECT *
|
|
FROM utilisateur
|
|
WHERE nom LIKE :a
|
|
OR prenom LIKE :b
|
|
OR prenom = :mot
|
|
OR nom = :mot
|
|
ORDER BY identifiant, prenom, nom ASC");
|
|
$statement->execute(array(
|
|
':a' => '%'.$keyword.'%',
|
|
':b' => '%'.$keyword.'%',
|
|
':mot' => $keyword
|
|
));
|
|
|
|
return DataBase::delNumeric( $statement->fetchAll() );
|
|
|
|
}
|
|
|
|
|
|
} |