465 lines
19 KiB
PHP
Executable File
465 lines
19 KiB
PHP
Executable File
<?php require_once __ROOT__.'/manager/security.php';
|
|
|
|
/**************************************************************/
|
|
/* _ _ ____ _____ ____ ____ _____ ____ ___ */
|
|
/* | | | / ___|| ____| _ \ | _ \| ____| _ \ / _ \ */
|
|
/* | | | \___ \| _| | |_) | | |_) | _| | |_) | | | | */
|
|
/* | |_| |___) | |___| _ < | _ <| |___| __/| |_| | */
|
|
/* \___/|____/|_____|_| \_\ |_| \_\_____|_| \___/ */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
class userRepo extends DBAccess{
|
|
/* VERIFIE L'EXISTENCE D'UN UTILISATEUR DANS LA BDD
|
|
*
|
|
* @identifiant<String> l'identifiant de l'utilisateur recherché
|
|
*
|
|
* @semestre<int> ***OPTIONNEL*** l'UID du semestre auquel on veut vérifier que l'étudiant est inscrit
|
|
*
|
|
* @semestre_pair<Boolean> ***OPTIONNEL*** détermine si le semestre est pair ou non
|
|
* @annee<int> ***OPTIONNEL*** l'année auquelle on veut vérifier si l'enseignant enseigne
|
|
*
|
|
* @return UID<String> si l'utilisateur est dans la BDD, retourne son UID
|
|
* @return FALSE<Boolean> FAUX si l'utilisateur n'est pas présent dans la BDD
|
|
*
|
|
*/
|
|
public static function UID($identifiant, $semestre=null, $semestre_pair=null, $annee=null){
|
|
|
|
if( $semestre == null && $semestre_pair == null && $annee == null ){ // on cherche un utilisateur avec cet identifiant
|
|
|
|
/* [1] Cas où on cherche juste si l'utilisateur existe
|
|
=============================================================*/
|
|
$getUtilisateurUID = DataBase::getPDO()->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :identifiant");
|
|
$getUtilisateurUID->execute(array( ':identifiant' => $identifiant ));
|
|
|
|
}elseif( $semestre != null ){
|
|
|
|
/* [2] Cas où on cherche si un étudiant est inscrit à un semestre
|
|
==============================================================*/
|
|
$getUtilisateurUID = DataBase::getPDO()->prepare("SELECT u.identifiant as id
|
|
FROM utilisateur as u, appartenance as app
|
|
WHERE u.identifiant = app.id_etudiant
|
|
AND u.identifiant = :identifiant
|
|
AND app.id_semestre = :semestre");
|
|
$getUtilisateurUID->execute(array( ':identifiant' => $identifiant, ':semestre' => $semestre ));
|
|
|
|
}elseif( $annee != null ){
|
|
|
|
$semestrePair0 = '0'; $semestrePair1 = '1';
|
|
if( is_bool($semestre_pair) ){ $semestrePair0 = ($semestre_pair)?'0':'1'; $semestrePair1 = ($semestre_pair)?'0':'1'; }
|
|
|
|
|
|
/* [2] Cas où on cherche si un enseignant enseigne l'année donnée
|
|
==============================================================*/
|
|
$getUtilisateurUID = DataBase::getPDO()->prepare("SELECT DISTINCT u.identifiant as id
|
|
FROM utilisateur as u, enseignement as ens, semestre as s, mcc_module as mcc_m, mcc_ue
|
|
WHERE u.identifiant = ens.id_enseignant
|
|
AND ens.id_mcc_module = mcc_m.id_mcc_module
|
|
AND mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue
|
|
AND mcc_ue.id_semestre = s.id_semestre
|
|
|
|
AND u.identifiant = :identifiant
|
|
AND (s.rang % 2 = :semestre_pair0 OR s.rang % 2 = :semestre_pair1)
|
|
AND s.annee = :annee");
|
|
$getUtilisateurUID->execute(array( ':identifiant' => $identifiant, ':semestre_pair0' => $semestrePair0, ':semestre_pair1' => $semestrePair1, ':annee' => $annee ));
|
|
|
|
}else // si les paramètres sont pas bons
|
|
return false;
|
|
|
|
// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID de l'utilisateur
|
|
return $getUtilisateurUID->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, sexe, 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();
|
|
}
|
|
|
|
|
|
|
|
|
|
/* retourne la liste des enseignants de la BDD
|
|
*
|
|
* @return enseignants<Array> retourne la liste des enseignants
|
|
* @return FALSE<Boolean> retourne FAUX si aucun résultat
|
|
*
|
|
*/
|
|
public static function getRoleUsers(){
|
|
$getListeUtilisateurs = DataBase::getPDO()->query("SELECT DISTINCT identifiant as id, nom, prenom, droits as role
|
|
FROM utilisateur
|
|
WHERE droits <> 'student'
|
|
ORDER BY identifiant ASC");
|
|
|
|
// si aucun résultat, on retourne false
|
|
if( !($userlist=$getListeUtilisateurs->fetchAll()) )
|
|
return false;
|
|
|
|
$userlist = DataBase::delNumeric( $userlist );
|
|
|
|
// sinon on met les rôles sous forme de tableau
|
|
foreach($userlist as $iter=>$user)
|
|
$userlist[$iter]['role'] = explode(',', $user['role']);
|
|
|
|
return $userlist;
|
|
}
|
|
|
|
|
|
|
|
/* modifie le caractère "admin" d'un utilisateur
|
|
*
|
|
* @utilisateur<String> l'UID de l'utilisateur en question
|
|
* @admin<Boolean> VRAI si admin, FAUX sinon
|
|
*
|
|
*
|
|
* @return updated<Boolean> VRAI si la modification a été faite
|
|
*
|
|
*/
|
|
public static function setAdmin($utilisateur, $admin){
|
|
/* [1] On récupère les droits actuels de l'utilisateur
|
|
=========================================================*/
|
|
if( !($utilisateurInfo=userRepo::info($utilisateur)) ) return false;
|
|
|
|
$droitsArray = explode(',', $utilisateurInfo['droits'] );
|
|
// on supprime les entrées vides
|
|
foreach($droitsArray as $i=>$droit)
|
|
if( strlen($droit) == 0 )
|
|
unset($droitsArray[$i]);
|
|
|
|
/* [2] On modifie les droits en fonction des paramètres
|
|
=========================================================*/
|
|
if( $admin && !in_array('admin', $droitsArray) ) // si on doit ajouter le droit et qu'il n'y est pas encore
|
|
array_push($droitsArray, 'admin'); // => on ajoute 'admin'
|
|
|
|
if( !$admin && in_array('admin', $droitsArray) ) // si on doit enlever le droit et qu'il y est
|
|
array_splice($droitsArray, array_search('admin', $droitsArray), 1 ); // => on enleve 'admin'
|
|
|
|
$droitsString = implode(',', $droitsArray);
|
|
|
|
|
|
/* [3] On modifie les droits dans la BDD
|
|
=========================================================*/
|
|
$modifierAdmin = DataBase::getPDO()->prepare("UPDATE utilisateur SET droits = :droits WHERE identifiant = :identifiant");
|
|
$modifierAdmin->execute(array( ':droits' => $droitsString, ':identifiant' => $utilisateur ));
|
|
|
|
|
|
/* [4] On vérifie que les changements on bien pris effet
|
|
=========================================================*/
|
|
if( !($utilisateurInfoVerif=userRepo::info($utilisateur)) ) return false;
|
|
|
|
return $utilisateurInfoVerif['droits'] == $droitsString; // si les droits de la BDD sont les mêmes que ceux calculés, c'est que c'est ok
|
|
}
|
|
|
|
|
|
|
|
/* modifie le caractère "référent" d'un utilisateur
|
|
*
|
|
* @utilisateur<String> l'UID de l'utilisateur en question
|
|
* @master<Boolean> VRAI si master, FAUX sinon
|
|
*
|
|
*
|
|
* @return updated<Boolean> VRAI si la modification a été faite
|
|
*
|
|
*/
|
|
public static function setMaster($utilisateur, $master){
|
|
/* [1] On récupère les droits actuels de l'utilisateur
|
|
=========================================================*/
|
|
if( !($utilisateurInfo=userRepo::info($utilisateur)) ) return false;
|
|
|
|
$droitsArray = explode(',', $utilisateurInfo['droits'] );
|
|
// on supprime les entrées vides
|
|
foreach($droitsArray as $i=>$droit)
|
|
if( strlen($droit) == 0 )
|
|
unset($droitsArray[$i]);
|
|
|
|
/* [2] On modifie les droits en fonction des paramètres
|
|
=========================================================*/
|
|
if( $master && !in_array('master', $droitsArray) ) // si on doit ajouter le droit et qu'il n'y est pas encore
|
|
array_push($droitsArray, 'master'); // => on ajoute 'master'
|
|
|
|
if( !$master && in_array('master', $droitsArray) ) // si on doit enlever le droit et qu'il y est
|
|
array_splice($droitsArray, array_search('master', $droitsArray), 1 ); // => on enleve 'master'
|
|
|
|
$droitsString = implode(',', $droitsArray);
|
|
|
|
|
|
/* [3] On modifie les droits dans la BDD
|
|
=========================================================*/
|
|
$modifierAdmin = DataBase::getPDO()->prepare("UPDATE utilisateur SET droits = :droits WHERE identifiant = :identifiant");
|
|
$modifierAdmin->execute(array( ':droits' => $droitsString, ':identifiant' => $utilisateur ));
|
|
|
|
|
|
/* [4] On vérifie que les changements on bien pris effet
|
|
=========================================================*/
|
|
if( !($utilisateurInfoVerif=userRepo::info($utilisateur)) ) return false;
|
|
|
|
return $utilisateurInfoVerif['droits'] == $droitsString; // si les droits de la BDD sont les mêmes que ceux calculés, c'est que c'est ok
|
|
}
|
|
|
|
|
|
/* modifie le caractère "teacher" d'un utilisateur
|
|
*
|
|
* @utilisateur<String> l'UID de l'utilisateur en question
|
|
* @teacher<Boolean> VRAI si teacher, FAUX sinon
|
|
*
|
|
*
|
|
* @return updated<Boolean> VRAI si la modification a été faite
|
|
*
|
|
*/
|
|
public static function setTeacher($utilisateur, $teacher){
|
|
/* [1] On récupère les droits actuels de l'utilisateur
|
|
=========================================================*/
|
|
if( !($utilisateurInfo=userRepo::info($utilisateur)) ) return false;
|
|
|
|
$droitsArray = explode(',', $utilisateurInfo['droits'] );
|
|
// on supprime les entrées vides
|
|
foreach($droitsArray as $i=>$droit)
|
|
if( strlen($droit) == 0 )
|
|
unset($droitsArray[$i]);
|
|
|
|
/* [2] On modifie les droits en fonction des paramètres
|
|
=========================================================*/
|
|
if( $teacher && !in_array('teacher', $droitsArray) ) // si on doit ajouter le droit et qu'il n'y est pas encore
|
|
array_push($droitsArray, 'teacher'); // => on ajoute 'teacher'
|
|
|
|
if( !$teacher && in_array('teacher', $droitsArray) ) // si on doit enlever le droit et qu'il y est
|
|
array_splice($droitsArray, array_search('teacher', $droitsArray), 1 ); // => on enleve 'teacher'
|
|
|
|
$droitsString = implode(',', $droitsArray);
|
|
|
|
|
|
/* [3] On modifie les droits dans la BDD
|
|
=========================================================*/
|
|
$modifierTeacger = DataBase::getPDO()->prepare("UPDATE utilisateur SET droits = :droits WHERE identifiant = :identifiant");
|
|
$modifierTeacger->execute(array( ':droits' => $droitsString, ':identifiant' => $utilisateur ));
|
|
|
|
|
|
/* [4] On vérifie que les changements on bien pris effet
|
|
=========================================================*/
|
|
if( !($utilisateurInfoVerif=userRepo::info($utilisateur)) ) return false;
|
|
|
|
return $utilisateurInfoVerif['droits'] == $droitsString; // si les droits de la BDD sont les mêmes que ceux calculés, c'est que c'est ok
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* ajoute un module qu'un utilisateur peut corriger
|
|
*
|
|
* @utilisateur<String> l'UID de l'utilisateur en question
|
|
* @mccmodule<int> l'UID du mcc_module à ajouter
|
|
*
|
|
*
|
|
* @return added<Boolean> VRAI si module ajouté, sinon FALSE
|
|
*
|
|
*/
|
|
public static function addModule($utilisateur, $mccmodule){
|
|
/* [1] On vérifie s'il n'enseigne pas déjà pour ce module
|
|
==============================================================*/
|
|
$enseignementExiste = DataBase::getPDO()->prepare("SELECT id_enseignement as id
|
|
FROM enseignement
|
|
WHERE id_enseignant = :utilisateur
|
|
AND id_mcc_module = :mccmodule");
|
|
$enseignementExiste->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule ));
|
|
|
|
|
|
/* [2] Si l'enseignement existe, on retourne "TRUE"
|
|
==============================================================*/
|
|
if( $enseignementExiste->fetch() ) return true;
|
|
|
|
|
|
|
|
/* [3] Si l'enseignement n'existe, on le créé
|
|
==============================================================*/
|
|
$creerEnseignement = DataBase::getPDO()->prepare("INSERT INTO enseignement(id_enseignement, id_enseignant, id_mcc_module, correcteur)
|
|
VALUES(DEFAULT, :utilisateur, :mccmodule, 1)");
|
|
$creerEnseignement->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule ));
|
|
|
|
|
|
|
|
/* [4] On vérifie que l'enseignement a été créé
|
|
==============================================================*/
|
|
$enseignementExiste = DataBase::getPDO()->prepare("SELECT id_enseignement as id
|
|
FROM enseignement
|
|
WHERE id_enseignant = :utilisateur
|
|
AND id_mcc_module = :mccmodule");
|
|
$enseignementExiste->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule ));
|
|
|
|
|
|
return is_array($enseignementExiste->fetch());
|
|
}
|
|
|
|
|
|
|
|
/* supprime un module qu'un utilisateur peut corriger
|
|
*
|
|
* @utilisateur<String> l'UID de l'utilisateur en question
|
|
* @mccmodule<int> l'UID du mcc_module à supprimer
|
|
*
|
|
*
|
|
* @return removed<Boolean> VRAI si module supprimé, sinon FALSE
|
|
*
|
|
*/
|
|
public static function delModule($utilisateur, $mccmodule){
|
|
/* [1] On vérifie s'il n'enseigne pas déjà pour ce module
|
|
==============================================================*/
|
|
$enseignementExiste = DataBase::getPDO()->prepare("SELECT id_enseignement as id
|
|
FROM enseignement
|
|
WHERE id_enseignant = :utilisateur
|
|
AND id_mcc_module = :mccmodule");
|
|
$enseignementExiste->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule ));
|
|
|
|
|
|
/* [2] Si l'enseignement n'existe pas, on returne "TRUE
|
|
==============================================================*/
|
|
if( !($enseignementUID=$enseignementExiste->fetch()['id']) ) return true;
|
|
|
|
|
|
/* [3] Si l'enseignement existe, on le supprime
|
|
==============================================================*/
|
|
$supprimerEnseignement = DataBase::getPDO()->prepare("DELETE FROM enseignement WHERE id_enseignement = :enseignementUID");
|
|
$supprimerEnseignement->execute(array( ':enseignementUID' => $enseignementUID ));
|
|
|
|
/* [4] On vérifie que l'enseignement a été supprimé
|
|
==============================================================*/
|
|
$enseignementExiste = DataBase::getPDO()->prepare("SELECT id_enseignement as id
|
|
FROM enseignement
|
|
WHERE id_enseignant = :utilisateur
|
|
AND id_mcc_module = :mccmodule");
|
|
$enseignementExiste->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule ));
|
|
|
|
|
|
return !is_array($enseignementExiste->fetch());
|
|
}
|
|
|
|
|
|
|
|
|
|
/* CREE UN NOUVEL UTILISATEUR DANS LA BASE DE DONNES
|
|
*
|
|
* @identifiant<String> l'identifiant (unique) de l'utilisateur à créer
|
|
* @prenom<String> le prénom du nouvel utilisateur
|
|
* @nom<String> le nom du nouvel utilisateur
|
|
* @mail<String> le mail du nouvel utilisateur
|
|
* @mdp<String> le mot de passe du nouvel utilisateur
|
|
* @droits<Array> les droits à donner au nouvel utilisateur
|
|
*
|
|
* @return UID<String> l'UID du nouvel utilisateur s'il a bien été créé
|
|
* @return created<Boolean> VRAI si l'utilisateur n'existait pas déjà* et qu'il a bien été créé
|
|
* (*) Si aucun autre n'avait le même @identifiant
|
|
*
|
|
*/
|
|
public static function creer($identifiant, $prenom, $nom, $sexe, $mail, $mdp, $droits){
|
|
/* [1] On normalise les données
|
|
=================================================================================================*/
|
|
foreach($droits as $droit)
|
|
if( !is_int( array_search($droit, getPermissions()) ) ) // si le droit n'est pas dans la liste des droits existants
|
|
return false; // on retourne une erreur comme quoi le droit est inexistant
|
|
|
|
|
|
$identifiant = strtolower($identifiant); // on met l'identifiant en minuscule
|
|
$prenom = ucwords( strtolower($prenom) ); // majuscule à chaque mot sinon minuscule
|
|
$nom = strtoupper($nom); // nom en majuscules
|
|
$sexe = boolval($sexe); // VRAI pour homme / FAUX pour femme
|
|
$mail = strtolower($mail); // email en minuscules
|
|
$mdp = secure_sha1($mdp); // on hash le password (SHA1)
|
|
$droits = implode(',', $droits); // on met le droit sous forme de chaine
|
|
|
|
/* [2] On vérifie que l'utilisateur n'est pas déjà créé
|
|
=================================================================================================*/
|
|
if( userRepo::UID($identifiant) ) // si on a un résultat, c'est qu'un utilisateur a déjà cet identifiant (UID)
|
|
return false;
|
|
|
|
/* [3] On créé le nouvel utilisateur
|
|
=================================================================================================*/
|
|
$creationUtilisateur = DataBase::getPDO()->prepare("INSERT INTO utilisateur(identifiant, prenom, nom, sexe, mail, mdp, droits)
|
|
VALUES(:identifiant, :prenom, :nom, :sexe, :mail, :mdp, :droits)");
|
|
$creationUtilisateur->execute(array(
|
|
':identifiant' => $identifiant,
|
|
':prenom' => $prenom,
|
|
':nom' => $nom,
|
|
':sexe' => $sexe,
|
|
':mail' => $mail,
|
|
':mdp' => $mdp,
|
|
':droits' => $droits
|
|
));
|
|
|
|
|
|
/* [4] On vérifie que l'utilisateur a bien été créé
|
|
=================================================================================================*/
|
|
return userRepo::UID($identifiant);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* retourne l'UID d'un étudiant et le créé en amont s'il n'existe pas
|
|
*
|
|
* @identifiant<String> l'UID de l'étudiant en question
|
|
* @prenom<String> le prénom de l'étudiant en question
|
|
* @nom<String> le nom de l'étudiant en question
|
|
* @sexe<Boolean> le sexe de l'étudiant en question
|
|
* @mail<String> le mail de l'étudiant en question
|
|
*
|
|
*
|
|
* @return UID<String> retourne l'UID de l'étudiant
|
|
* @return FALSE<Boolean> retourne FALSE si une erreur occure
|
|
*
|
|
*/
|
|
public static function includeEtudiant($identifiant, $prenom, $nom, $sexe, $mail){
|
|
/* [1] On vérifie l'existence de l'étudiant (par identifiant uniquement)
|
|
======================================================*/
|
|
$getEtudiantUID = DataBase::getPDO()->prepare("SELECT identifiant as id
|
|
FROM utilisateur
|
|
WHERE identifiant = :identifiant");
|
|
$getEtudiantUID->execute(array( ':identifiant' => $identifiant ));
|
|
|
|
/* [2] Cas où l'étudiant existe déjà, alors on retourne l'UID
|
|
======================================================*/
|
|
if( $etudiantUID = $getEtudiantUID->fetch()['id'] ) return $etudiantUID;
|
|
|
|
/* [3] Cas où l'étudiant n'existe pas, alors on le créé
|
|
======================================================*/
|
|
$creerSemestre = DataBase::getPDO()->prepare("INSERT INTO utilisateur(identifiant, prenom, nom, sexe, mail, mdp, droits)
|
|
VALUES(:identifiant, :prenom, :nom, :sexe, :mail, DEFAULT, :droits)"); // par défaut le nom du semestre = "Sn" où n est le rang
|
|
$creerSemestre->execute(array(
|
|
':identifiant' => $identifiant,
|
|
':prenom' => $prenom,
|
|
':nom' => $nom,
|
|
':sexe' => $sexe,
|
|
':mail' => $mail,
|
|
':droits' => 'student'
|
|
));
|
|
|
|
/* [4] On vérifie que la formation a été créé et retourne son UID
|
|
======================================================*/
|
|
$getEtudiantUID = DataBase::getPDO()->prepare("SELECT identifiant as id
|
|
FROM utilisateur
|
|
WHERE identifiant = :identifiant");
|
|
$getEtudiantUID->execute(array( ':identifiant' => $identifiant ));
|
|
|
|
return $etudiantUID = $getEtudiantUID->fetch()['id'];
|
|
}
|
|
|
|
|
|
} |