Refactor + avancée repos + corrections repos utilisation statique au lieu de $this (car ne marchais pas) + creation module/Ue vérifiée
This commit is contained in:
xdrm-brackets
parent
4b78463224
commit
989cae3b32
|
|
@ -786,11 +786,11 @@ class DataBase{
|
|||
/*** retourne les notes d'un module ***/
|
||||
/**************************************/
|
||||
public function getModuleNotes($etudiant, $module, $semestre, $annee){
|
||||
// on vérifie que le semestre exist et que l'étudiant est inscrit à ce semestre
|
||||
// on vérifie que le module, le semestre existent et que l'étudiant est inscrit à ce semestre
|
||||
if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
|
||||
if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';
|
||||
|
||||
|
||||
if( !($moduleUID=moduleRepo::UID($module)) ) return 'unknown_module';
|
||||
|
||||
|
||||
/*** on cherche un module avec ce nom, en accord avec le semestre et l'étudiant ***/
|
||||
$getModuleUID = DataBase::getPDO()->prepare("SELECT m.id_module as id FROM module as m, appartenance as app, ue, mcc_ue, mcc_module as mcc_m ".
|
||||
|
|
@ -818,6 +818,18 @@ class DataBase{
|
|||
return 'unknown_module';
|
||||
|
||||
|
||||
|
||||
$EtudiantInscritAuModule = false; // par défaut on dit que l'étudiant n'est pas inscrit à ce module
|
||||
foreach(moduleRepo::forStudent($etudiant, $semestreUID) as $module ) // on récupère parmi les modules auquel est inscrit l'utilisateur
|
||||
if( $module['id'] == $moduleUID ){ // s'il est inscrit au module donné
|
||||
$EtudiantInscritAuModule = true;
|
||||
break;
|
||||
}
|
||||
|
||||
// si l'étudiant n'a pas ce module dans ceux auxquels il est inscrit
|
||||
if( !$EtudiantInscritAuModule ) return 'unknown_module';
|
||||
|
||||
|
||||
// si on a l'UID utilisateur & l'UID groupe => on récupère les modules
|
||||
$getNoteList = DataBase::getPDO()->prepare("SELECT m.nom as module, m.libelle as modulelib, ctrl.intitule, note.valeur, ctrl.base, ctrl.coefficient ".
|
||||
"FROM note, appartenance as app, semestre as s, module as m, mcc_ue, mcc_module as mcc_m, controle as ctrl ".
|
||||
|
|
@ -854,34 +866,21 @@ class DataBase{
|
|||
/*** retourne les notes d'un UE ***/
|
||||
/**********************************/
|
||||
public function getUENotes($etudiant, $UE, $semestre, $annee){
|
||||
// on vérifie que le semestre exist et que l'étudiant est inscrit à ce semestre
|
||||
// on vérifie que l'UE, le semestre existent et que l'étudiant est inscrit à ce semestre
|
||||
if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
|
||||
if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';
|
||||
if( !($UEUID=ueRepo::UID($UE)) ) return 'unknown_ue';
|
||||
|
||||
|
||||
/*** on cherche un module avec ce nom, en accord avec le semestre et l'étudiant ***/
|
||||
$getUEUID = DataBase::getPDO()->prepare("SELECT ue.id_ue as id ".
|
||||
"FROM module as m, appartenance as app, ue, mcc_ue, mcc_module as mcc_m ".
|
||||
"WHERE mcc_ue.id_ue = ue.id_ue ".
|
||||
"AND mcc_ue.id_semestre = app.id_semestre ".
|
||||
"AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue ".
|
||||
$EtudiantInscritAlUE = false; // par défaut on dit que l'étudiant n'est pas inscrit à cet UE
|
||||
foreach(ueRepo::forStudent($etudiant, $semestreUID) as $UE ) // on récupère parmi les UEs auquel est inscrit l'utilisateur
|
||||
if( $UE['id'] == $UEUID ){ // s'il est inscrit à l'UE donnée
|
||||
$EtudiantInscritAlUE = true;
|
||||
break;
|
||||
}
|
||||
|
||||
"AND mcc_m.id_module = m.id_module ".
|
||||
|
||||
"AND ue.nom = :UE ".
|
||||
"AND app.id_etudiant = :etudiantUID ".
|
||||
"AND app.id_semestre = :semestreUID");
|
||||
$getUEUID->execute(array(
|
||||
':UE' => $UE,
|
||||
':etudiantUID' => $etudiantUID,
|
||||
':semestreUID' => $semestreUID
|
||||
));
|
||||
|
||||
// si on trouve, on le définit, sinon on retourne "unknown_group"
|
||||
if( $UEUID = $getUEUID->fetch()['id'] )
|
||||
$UEUID = (int) $UEUID;
|
||||
else
|
||||
return 'unknown_UE';
|
||||
// si l'étudiant n'a pas ce module dans ceux auxquels il est inscrit
|
||||
if( !$EtudiantInscritAlUE ) return 'unknown_module';
|
||||
|
||||
// si on a l'UID utilisateur & l'UID UE => on récupère les notes
|
||||
$getNoteList = DataBase::getPDO()->prepare("SELECT m.nom as module, m.libelle as modulelib, ctrl.intitule, note.valeur, ctrl.base, ctrl.coefficient ".
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ class groupRepo extends DBAccess{
|
|||
public static function creer($nom){
|
||||
/* [1] On vérifie l'existence d'un groupe avec ce nom
|
||||
======================================================*/
|
||||
if( $this->UID($nom) ) // si le groupe existe déjà
|
||||
if( groupRepo::UID($nom) ) // si le groupe existe déjà
|
||||
return false; // on retourne FAUX
|
||||
|
||||
/* [2] On créé le groupe
|
||||
|
|
@ -88,7 +88,7 @@ class groupRepo extends DBAccess{
|
|||
|
||||
/* [3] On vérifie si le groupe a bien été créé
|
||||
===============================================*/
|
||||
return $this->UID($nom);
|
||||
return groupRepo::UID($nom);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -148,7 +148,7 @@ class groupRepo extends DBAccess{
|
|||
|
||||
/* [3] On vérifie que l'appartenance est bien définie
|
||||
======================================================*/
|
||||
return $this->appartenanceUID($etudiant, $groupe, $semestre);
|
||||
return groupRepo::appartenanceUID($etudiant, $groupe, $semestre);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -94,26 +94,26 @@ class moduleRepo extends DBAccess{
|
|||
public static function creer($nom, $libelle){
|
||||
/* [1] On normalise les données
|
||||
=================================================================================================*/
|
||||
$nom = strtoupper($nom); // nom en majuscules
|
||||
$nom = strtoupper($nom); // nom en majuscules
|
||||
|
||||
/* [2] On vérifie que le module n'est pas déjà créé
|
||||
=================================================================================================*/
|
||||
if( $this->UID($nom) ) // si on a un résultat, c'est qu'un module a déjà cee nom
|
||||
if( moduleRepo::UID($nom) ) // si on a un résultat, c'est qu'un module a déjà cee nom
|
||||
return false;
|
||||
|
||||
/* [3] On créé le nouvel utilisateur
|
||||
/* [3] On créé le nouveu module
|
||||
=================================================================================================*/
|
||||
$creationModule = DataBase::getPDO()->prepare("INSERT INTO module(id_module, nom, libelle) ".
|
||||
"VALUES(DEFAULT, :nom, :libelle)");
|
||||
$creationModule->execute(array(
|
||||
':nom' => $nom,
|
||||
':libelle' => $libelle
|
||||
':nom' => $nom,
|
||||
':libelle' => $libelle
|
||||
));
|
||||
|
||||
|
||||
/* [4] On vérifie que l'utilisateur a bien été créé
|
||||
/* [4] On vérifie que le module a bien été créé
|
||||
=================================================================================================*/
|
||||
return $this->UID($nom);
|
||||
return moduleRepo::UID($nom);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,148 @@
|
|||
<?php require_once __ROOT__.'/manager/security.php';
|
||||
|
||||
/*************************************************************/
|
||||
/* _ _ ___ _____ _____ ____ _____ ____ ___ */
|
||||
/* | \ | |/ _ \_ _| ____| | _ \| ____| _ \ / _ \ */
|
||||
/* | \| | | | || | | _| | |_) | _| | |_) | | | | */
|
||||
/* | |\ | |_| || | | |___ | _ <| |___| __/| |_| | */
|
||||
/* |_| \_|\___/ |_| |_____| |_| \_\_____|_| \___/ */
|
||||
/* */
|
||||
/*************************************************************/
|
||||
|
||||
class noteRepo extends DBAccess{
|
||||
/* VERIFIE L'EXISTENCE D'UNE NOTE POUR UN ÉTUDIANT A UN CONTROLE
|
||||
*
|
||||
* @etudiant<String> l'identifiant de l'étudiant recherché
|
||||
* @controle<int> l'UID du contrôle
|
||||
*
|
||||
* @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, $annee=null){
|
||||
if( $semestre == 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 ));
|
||||
|
||||
}else{
|
||||
|
||||
/* [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 s.annee = :annee ".
|
||||
"AND u.identifiant = :identifiant");
|
||||
$getUtilisateurUID->execute(array( ':identifiant' => $identifiant, ':annee' => $annee ));
|
||||
|
||||
}
|
||||
|
||||
// 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, 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();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/* 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, $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
|
||||
$mail = strtolower($mail); // email en minuscules
|
||||
$mdp = 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( noteRepo::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, mail, mdp, droits) ".
|
||||
"VALUES(:identifiant, :prenom, :nom, :mail, :mdp, :droits)");
|
||||
$creationUtilisateur->execute(array(
|
||||
':identifiant' => $identifiant,
|
||||
':prenom' => $prenom,
|
||||
':nom' => $nom,
|
||||
':mail' => $mail,
|
||||
':mdp' => $mdp,
|
||||
':droits' => $droits
|
||||
));
|
||||
|
||||
|
||||
/* [4] On vérifie que l'utilisateur a bien été créé
|
||||
=================================================================================================*/
|
||||
return noteRepo::UID($identifiant);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -51,7 +51,7 @@ class ueRepo extends DBAccess{
|
|||
*
|
||||
* @etudiant<String> Identifiant de l'étudiant
|
||||
* @semestre<int> l'UID du semestre
|
||||
*
|
||||
*
|
||||
* @return UEs<Array> retourne un tableau contenant les UEs de l'utilisateur pour ce semestre
|
||||
*
|
||||
*/
|
||||
|
|
@ -81,38 +81,38 @@ class ueRepo extends DBAccess{
|
|||
|
||||
|
||||
|
||||
/* CREE UN NOUVEAU MODULE DANS LA BASE DE DONNES
|
||||
/* CREE UN NOUVEL UE DANS LA BASE DE DONNES
|
||||
*
|
||||
* @nom<String> le nom du nouveau module
|
||||
* @libelle<String> le libellé du nouveau module
|
||||
* @nom<String> le nom du nouvel UE
|
||||
* @libelle<String> le libellé du nouvel UE
|
||||
*
|
||||
* @return UID<String> l'UID du nouveau module s'il a bien été créé
|
||||
* @return created<Boolean> VRAI si le module n'existait pas déjà* et qu'il a bien été créé
|
||||
* @return UID<String> l'UID du nouveal UE s'il a bien été créé
|
||||
* @return created<Boolean> VRAI si l'UE n'existait pas déjà* et qu'il a bien été créé
|
||||
* (*) Si aucun autre n'avait le même @nom
|
||||
*/
|
||||
public static function creer($nom, $libelle){
|
||||
/* [1] On normalise les données
|
||||
=================================================================================================*/
|
||||
$nom = strtoupper($nom); // nom en majuscules
|
||||
$nom = strtoupper($nom); // nom en majuscules
|
||||
|
||||
/* [2] On vérifie que le module n'est pas déjà créé
|
||||
=================================================================================================*/
|
||||
if( $this->UID($nom) ) // si on a un résultat, c'est qu'un module a déjà cee nom
|
||||
if( ueRepo::UID($nom) ) // si on a un résultat, c'est qu'un module a déjà cee nom
|
||||
return false;
|
||||
|
||||
/* [3] On créé le nouvel utilisateur
|
||||
/* [3] On créé le nouvel UE
|
||||
=================================================================================================*/
|
||||
$creationModule = DataBase::getPDO()->prepare("INSERT INTO module(id_module, nom, libelle) ".
|
||||
$creationUE = DataBase::getPDO()->prepare("INSERT INTO ue(id_ue, nom, libelle) ".
|
||||
"VALUES(DEFAULT, :nom, :libelle)");
|
||||
$creationModule->execute(array(
|
||||
':nom' => $nom,
|
||||
':libelle' => $libelle
|
||||
$creationUE->execute(array(
|
||||
':nom' => $nom,
|
||||
':libelle' => $libelle
|
||||
));
|
||||
|
||||
|
||||
/* [4] On vérifie que l'utilisateur a bien été créé
|
||||
/* [4] On vérifie que l'UE a bien été créé
|
||||
=================================================================================================*/
|
||||
return $this->UID($nom);
|
||||
return ueRepo::UID($nom);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -122,7 +122,7 @@ class userRepo extends DBAccess{
|
|||
|
||||
/* [2] On vérifie que l'utilisateur n'est pas déjà créé
|
||||
=================================================================================================*/
|
||||
if( $this->UID($identifiant) ) // si on a un résultat, c'est qu'un utilisateur a déjà cet identifiant (UID)
|
||||
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
|
||||
|
|
@ -141,7 +141,7 @@ class userRepo extends DBAccess{
|
|||
|
||||
/* [4] On vérifie que l'utilisateur a bien été créé
|
||||
=================================================================================================*/
|
||||
return $this->UID($identifiant);
|
||||
return userRepo::UID($identifiant);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
8
test.php
8
test.php
|
|
@ -1,9 +1,6 @@
|
|||
<?php define('__ROOT__', dirname(__FILE__) );
|
||||
require_once __ROOT__.'/manager/security.php';
|
||||
|
||||
|
||||
var_dump( $_SESSION['semestre'] );
|
||||
|
||||
/***************/
|
||||
/*** A FAIRE ***/
|
||||
/***************
|
||||
|
|
@ -48,9 +45,10 @@ require_once __ROOT__.'/manager/security.php';
|
|||
|
||||
|
||||
|
||||
require_once __ROOT__.'/manager/database.php';
|
||||
|
||||
|
||||
|
||||
debug();
|
||||
var_dump( $_SESSION['droits'] );
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue