dut
/
sid
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Informations utilisateur récupérées, gestion des droits dans la BDD, refactor de database.php

This commit is contained in:
xdrm-brackets 2015-11-08 22:30:23 +01:00
parent 94c36a0c48
commit 8257019c8f
10 changed files with 711 additions and 525 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
manager/career.php
View File

@ -36,7 +36,8 @@ require_once __ROOT__.'/manager/database.php';
/*******************************/
/* liste des notes par modules */
/*******************************/
case 'getNotesByModules':
case 'getNotesByModules': if( connected() ){
$areSetParam = isset($request->etudiant) && isset($request->semestre) && isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->etudiant) && is_string($request->semestre) && is_string($request->annee); // si c'est des strings
$nEmptyParam = $typeOkParam && strlen($request->etudiant) > 0 && is_numeric($request->semestre) && is_numeric($request->annee); // des bon types
@ -54,12 +55,15 @@ require_once __ROOT__.'/manager/database.php';
$answer->request = $notes; // on retourne l'erreur
}else
$answer->request = 'param_error';
}
break;
/***************************/
/* liste des notes par UEs */
/***************************/
case 'getNotesByUEs':
case 'getNotesByUEs': if( connected() ){
$areSetParam = isset($request->etudiant) && isset($request->semestre) && isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->etudiant) && is_string($request->semestre) && is_string($request->annee); // si c'est des strings
$nEmptyParam = $typeOkParam && strlen($request->etudiant) > 0 && is_numeric($request->semestre) && is_numeric($request->annee); // des bon types
@ -77,6 +81,9 @@ require_once __ROOT__.'/manager/database.php';
$answer->request = $notes; // on retourne l'erreur
}else
$answer->request = 'param_error';
}else
$answer->request = 'permission_error';
break;

607
manager/database.php
View File

@ -27,6 +27,82 @@ class DataBase{
return new DataBase("localhost", "sid2", "php", "Qt358nUdyeTxLDM8");
}
/*************************************************************/
/* _____ ______ _ _ ______ _____ _ */
/* / ____| ____| \ | | ____| __ \ /\ | | */
/* | | __| |__ | \| | |__ | |__) | / \ | | */
/* | | |_ | __| | . ` | __| | _ / / /\ \ | | */
/* | |__| | |____| |\ | |____| | \ \ / ____ \| |____ */
/* \_____|______|_| \_|______|_| \_\/_/ \_\______| */
/* */
/*************************************************************/
/********************************************************/
/*** Vérifie l'existence d'un utilisateur dans le BDD ***/
/********************************************************/
private function utilisateurUID($identifiant){
/*** on cherche un utilisateur avec cet identifiant ***/
$getUtilisateurUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :identifiant");
$getUtilisateurUID->execute(array(
':identifiant' => $identifiant
));
// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID de l'utilisateur
return $getUtilisateurUID->fetch()['id'];
}
/***************************************************/
/*** Vérifie l'existence d'un groupe dans le BDD ***/
/***************************************************/
private function groupeUID($nom){
/*** on cherche un groupe avec ce nom ***/
$getGroupeUID = $this->pdo->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'];
}
/*****************************************************/
/*** Vérifie l'existence d'un semestre dans le BDD ***/
/*****************************************************/
private function semestreUID($rang, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $rang,
':annee' => $annee
));
// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID du semestre
return $getSemestreUID->fetch()['id'];
}
/*************************************************************************************/
/* _ _ _______ _____ _ _____ _____ _______ ______ _ _ _____ */
/* | | | |__ __|_ _| | |_ _|/ ____| /\|__ __| ____| | | | __ \ */
/* | | | | | | | | | | | | | (___ / \ | | | |__ | | | | |__) | */
/* | | | | | | | | | | | | \___ \ / /\ \ | | | __| | | | | _ / */
/* | |__| | | | _| |_| |____ _| |_ ____) / ____ \| | | |____| |__| | | \ \ */
/* \____/ |_| |_____|______|_____|_____/_/ \_\_| |______|\____/|_| \_\ */
/* */
/*************************************************************************************/
/*********************************************/
/*** création d'un utilisateur dans la bdd ***/
/*********************************************/
@ -58,11 +134,36 @@ class DataBase{
return 'success';
else
return 'error';
}
/*********************************************************************************/
/*** on récupère les informations utiles à l'utilisateur lors de la connection ***/
/*********************************************************************************/
public function utilisateurInfo($identifiant){
// si l'utilisateur n'existe pas on retourne 'unknown_user'
if( !($utilisateurUID=$this->utilisateurUID($identifiant)) ) return 'unknown_user';
$getUtilisateurInfo = $this->pdo->prepare("SELECT identifiant, prenom, nom, mail, droits FROM utilisateur WHERE identifiant = :identifiant");
$getUtilisateurInfo->execute(array( ':identifiant' => $utilisateurUID ));
return $getUtilisateurInfo->fetch(); // retourne les info, si pas de résultat, retourne [FAUX]
}
/**********************************************************/
/* _____ _____ ____ _ _ _____ ______ _____ */
/* / ____| __ \ / __ \| | | | __ \| ____|/ ____| */
/* | | __| |__) | | | | | | | |__) | |__ | (___ */
/* | | |_ | _ /| | | | | | | ___/| __| \___ \ */
/* | |__| | | \ \| |__| | |__| | | | |____ ____) | */
/* \_____|_| \_\\____/ \____/|_| |______|_____/ */
/* */
/**********************************************************/
/****************************************/
/*** création d'un groupe dans la bdd ***/
@ -98,45 +199,16 @@ class DataBase{
$getLastCount = $this->pdo->query('SELECT count(id_etudiant) as count FROM appartenance');
$lastCount = (int) $getLastCount->fetch()['count'];
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) return 'unknown_user';
/*** on cherche un utilisateur avec cet identifiant ***/
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
$getEtudiantUID->execute(array(
':etudiant' => $etudiant
));
// si on trouve pas, on retourne 'unknown_group' sinon on définit la variable
if( !($groupeUID=$this->groupeUID($groupe)) ) return 'unknown_group';
else $groupeUID = (int) $groupeUID;
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
$etudiantUID = $etudiantUID;
else
return 'unknown_user';
/*** on cherche un groupe avec ce nom ***/
$getGroupeUID = $this->pdo->prepare("SELECT id_groupe as id FROM groupe WHERE nom = :nom");
$getGroupeUID->execute(array(
':nom' => $groupe
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $groupeUID = $getGroupeUID->fetch()['id'] )
$groupeUID = (int) $groupeUID;
else
return 'unknown_group';
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
@ -170,31 +242,13 @@ class DataBase{
/******************************************************/
public function listeEtudiantsGroupe($groupe, $semestre, $annee){
/*** on cherche un groupe avec ce nom ***/
$getGroupeUID = $this->pdo->prepare("SELECT id_groupe as id FROM groupe WHERE nom = :nom");
$getGroupeUID->execute(array(
':nom' => $groupe
));
// si on trouve pas, on retourne 'unknown_group' sinon on définit la variable
if( !($groupeUID=$this->groupeUID($groupe)) ) return 'unknown_group';
else $groupeUID = (int) $groupeUID;
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $groupeUID = $getGroupeUID->fetch()['id'] )
$groupeUID = (int) $groupeUID;
else
return 'unknown_group';
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
@ -231,18 +285,10 @@ class DataBase{
/*** retourne la liste des utilisateurs des groupes d'un semestre ***/
/********************************************************************/
public function listeEtudiantsTousGroupesSemestre($semestre, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// on cherche tout les groupes du même semestre de la même année
$getGroupesUID = $this->pdo->prepare("SELECT DISTINCT g.nom, s.rang, s.nom as semestre ".
@ -352,17 +398,9 @@ class DataBase{
return 'unknown_year';
/*** on cherche un utilisateur avec cet identifiant ***/
$getEnseignantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :enseignant");
$getEnseignantUID->execute(array(
':enseignant' => $enseignant
));
// si on trouve pas, on retourne "unknown_user"
if( !($enseignantUID=$this->utilisateurUID($enseignant)) ) return 'unknown_user';
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $enseignantUID = $getEnseignantUID->fetch()['id'] )
$enseignantUID = $enseignantUID;
else
return 'unknown_user';
// on cherche tout les groupes du même semestre de la même année
$getGroupesUID = $this->pdo->prepare("SELECT DISTINCT s.nom as semestre, s.rang, g.nom as nom ".
@ -414,30 +452,14 @@ class DataBase{
/*** retourne le nom du groupe d'un étudiant ***/
/***********************************************/
public function getGroupeEtudiant($etudiant, $semestre, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
/*** on cherche un utilisateur avec cet identifiant ***/
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
$getEtudiantUID->execute(array(
':etudiant' => $etudiant
));
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) return 'unknown_user';
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
$etudiantUID = $etudiantUID;
else
return 'unknown_user';
// on cherche le groupe associé
$getNomGroupe = $this->pdo->prepare("SELECT g.nom ".
@ -460,36 +482,143 @@ class DataBase{
return 'error';
}
/**************************************************/
/*** retourne les modules d'un étudiant par UEs ***/
/**************************************************/
public function getModulesByUEByEtudiant($etudiant, $semestre, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
/*** on cherche un utilisateur avec cet identifiant ***/
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
$getEtudiantUID->execute(array(
/******************************************************/
/***** déplace un étudiant d'un groupe à un autre *****/
/******************************************************/
public function deplacerEtudiant($etudiant, $groupe, $annee){
/*** on cherche le nouveau groupe pour cet utilisateur ***/
$getNouveauGroupeUID = $this->pdo->prepare("SELECT DISTINCT s.id_semestre as semestre, g.id_groupe as id, u.identifiant as etuUID ".
"FROM groupe as g, appartenance as app, appartenance as myapp, utilisateur as u, semestre as s ".
"WHERE g.nom = :groupe ".
"AND u.identifiant = :etudiant ".
"AND myapp.id_etudiant = u.identifiant ".
"AND myapp.id_semestre = s.id_semestre ".
"AND app.id_groupe = g.id_groupe ".
"AND app.id_semestre = s.id_semestre");
$getNouveauGroupeUID->execute(array(
':groupe' => $groupe,
':etudiant' => $etudiant
));
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
$etudiantUID = $etudiantUID;
if( $data = $getNouveauGroupeUID->fetch() ){
$nouveauGroupeUID = (int) $data['id'];
$semestreUID = $data['semestre'];
$etudiantUID = $data['etuUID'];
}
else
return 'unknown_user';
return 'unknown_newgroup';
/*** on cherche le groupe de cet utilisateur ***/
$getGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
"FROM utilisateur as u, groupe as g, appartenance as app, semestre as s ".
"WHERE app.id_etudiant = u.identifiant ".
"AND app.id_groupe = g.id_groupe ".
"AND app.id_semestre = s.id_semestre ".
"AND u.identifiant = :etudiantUID ".
"AND app.id_semestre = :semestreUID");
$getGroupeUID->execute(array(
':etudiantUID' => $etudiantUID,
':semestreUID' => $semestreUID,
));
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $groupeUID = $getGroupeUID->fetch()['id'] ){
$groupeUID = $groupeUID;
/***************************************************************/
/*** CAS 1 : l'utilisateur a déjà un groupe pour ce semestre ***/
/***************************************************************/
// il suffit donc maintenant de modifier l' "appartenance"
$updateGroupe = $this->pdo->prepare("UPDATE appartenance SET id_groupe = :nouveauGroupeUID ".
"WHERE id_etudiant = :etudiantUID ".
"AND id_groupe = :groupeUID ".
"AND id_semestre = :semestreUID");
$updateGroupe->execute(array(
':nouveauGroupeUID' => $nouveauGroupeUID,
':etudiantUID' => $etudiantUID,
':groupeUID' => $groupeUID,
':semestreUID' => $semestreUID
));
}
else{
/****************************************************/
/*** CAS 2 : l'utilisateur n'a pas encore de groupe */
/****************************************************/
$insertGroupe = $this->pdo->prepare("INSERT INTO appartenance(id_appartenance, id_etudiant, id_groupe, id_semestre) ".
"VALUES(NULL, :etudiantUID, :nouveauGroupeUID, :semestreUID)");
$insertGroupe->execute(array(
':etudiantUID' => $etudiantUID,
':nouveauGroupeUID' => $nouveauGroupeUID,
':semestreUID' => $semestreUID
));
}
/* Vérification de l'entrée dans la table */
$verif = $this->pdo->prepare("SELECT count(id_appartenance) as count ".
"FROM appartenance ".
"WHERE id_etudiant = :etudiantUID ".
"AND id_groupe = :nouveauGroupeUID ".
"AND id_semestre = :semestreUID");
$verif->execute(array(
':etudiantUID' => $etudiantUID,
':nouveauGroupeUID' => $nouveauGroupeUID,
':semestreUID' => $semestreUID
));
$verifFetch = $verif->fetch();
if( $verifFetch && $verifFetch['count'] == '1' )
return 'success';
else
return 'error';
}
/**********************************************************/
/* */
/* __ __ ____ _____ _ _ _ ______ _____ */
/* | \/ |/ __ \| __ \| | | | | | ____|/ ____| */
/* | \ / | | | | | | | | | | | | |__ | (___ */
/* | |\/| | | | | | | | | | | | | __| \___ \ */
/* | | | | |__| | |__| | |__| | |____| |____ ____) | */
/* |_| |_|\____/|_____/ \____/|______|______|_____/ */
/* */
/**********************************************************/
/**************************************************/
/*** retourne les modules d'un étudiant par UEs ***/
/**************************************************/
public function getModulesByUEByEtudiant($etudiant, $semestre, $annee){
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) return 'unknown_user';
/*** on cherche le groupe de cet utilisateur ***/
$getGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
@ -555,31 +684,17 @@ class DataBase{
/*** retourne les modules d'un étudiant ***/
/******************************************/
public function getModulesEtudiant($etudiant, $semestre, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) return 'unknown_user';
/*** on cherche un utilisateur avec cet identifiant ***/
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
$getEtudiantUID->execute(array(
':etudiant' => $etudiant
));
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
$etudiantUID = $etudiantUID;
else
return 'unknown_user';
/*** on cherche le groupe de cet utilisateur ***/
$getGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
@ -637,32 +752,16 @@ class DataBase{
/*** retourne les UEs d'un étudiant ***/
/**************************************/
public function getUEsEtudiant($etudiant, $semestre, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
// si on trouve pas, on retourne "unknown_user"
if( !($etudiantUID=$this->utilisateurUID($etudiant)) ) return 'unknown_user';
/*** on cherche un utilisateur avec cet identifiant ***/
$getEtudiantUID = $this->pdo->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :etudiant");
$getEtudiantUID->execute(array(
':etudiant' => $etudiant
));
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $etudiantUID = $getEtudiantUID->fetch()['id'] )
$etudiantUID = $etudiantUID;
else
return 'unknown_user';
/*** on cherche le groupe de cet utilisateur ***/
$getGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
@ -877,10 +976,15 @@ class DataBase{
/*******************************************/
/* _ _ ____ _______ ______ _____ */
/* | \ | |/ __ \__ __| ____|/ ____| */
/* | \| | | | | | | | |__ | (___ */
/* | . ` | | | | | | | __| \___ \ */
/* | |\ | |__| | | | | |____ ____) | */
/* |_| \_|\____/ |_| |______|_____/ */
/* */
/*******************************************/
@ -888,18 +992,10 @@ class DataBase{
/*** retourne les notes par modules ***/
/**************************************/
public function getNotesByModules($etudiant, $semestre, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
/*** on cherche un utilisateur avec cet identifiant ***/
@ -944,18 +1040,10 @@ class DataBase{
/*** retourne les notes par UE ***/
/*********************************/
public function getNotesByUEs($etudiant, $semestre, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
/*** on cherche un utilisateur avec cet identifiant ***/
@ -1002,18 +1090,10 @@ class DataBase{
/*** retourne les notes d'un module ***/
/**************************************/
public function getModuleNotes($etudiant, $module, $semestre, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
/*** on cherche un utilisateur avec cet identifiant ***/
@ -1102,18 +1182,10 @@ class DataBase{
/*** retourne les notes d'un UE ***/
/**********************************/
public function getUENotes($etudiant, $UE, $semestre, $annee){
/*** on cherche un semestre avec ce rang et cette année (qui est unique) ***/
$getSemestreUID = $this->pdo->prepare("SELECT id_semestre as id FROM semestre WHERE rang = :rang AND annee = :annee");
$getSemestreUID->execute(array(
':rang' => $semestre,
':annee' => $annee
));
// si on trouve, on le définit, sinon on retourne "unknown_group"
if( $semestreUID = $getSemestreUID->fetch()['id'] )
$semestreUID = (int) $semestreUID;
else
return 'unknown_semestre';
// si on trouve pas, on retourne 'unknown_semestre', sinon on définit la variable
if( !($semestreUID=$this->semestreUID($semestre, $annee)) ) return 'unknown_semestre';
else $semestreUID = (int) $semestreUID;
/*** on cherche un utilisateur avec cet identifiant ***/
@ -1200,107 +1272,6 @@ class DataBase{
/******************************************************/
/***** déplace un étudiant d'un groupe à un autre *****/
/******************************************************/
public function deplacerEtudiant($etudiant, $groupe, $annee){
/*** on cherche le nouveau groupe pour cet utilisateur ***/
$getNouveauGroupeUID = $this->pdo->prepare("SELECT DISTINCT s.id_semestre as semestre, g.id_groupe as id, u.identifiant as etuUID ".
"FROM groupe as g, appartenance as app, appartenance as myapp, utilisateur as u, semestre as s ".
"WHERE g.nom = :groupe ".
"AND u.identifiant = :etudiant ".
"AND myapp.id_etudiant = u.identifiant ".
"AND myapp.id_semestre = s.id_semestre ".
"AND app.id_groupe = g.id_groupe ".
"AND app.id_semestre = s.id_semestre");
$getNouveauGroupeUID->execute(array(
':groupe' => $groupe,
':etudiant' => $etudiant
));
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $data = $getNouveauGroupeUID->fetch() ){
$nouveauGroupeUID = (int) $data['id'];
$semestreUID = $data['semestre'];
$etudiantUID = $data['etuUID'];
}
else
return 'unknown_newgroup';
/*** on cherche le groupe de cet utilisateur ***/
$getGroupeUID = $this->pdo->prepare("SELECT g.id_groupe as id ".
"FROM utilisateur as u, groupe as g, appartenance as app, semestre as s ".
"WHERE app.id_etudiant = u.identifiant ".
"AND app.id_groupe = g.id_groupe ".
"AND app.id_semestre = s.id_semestre ".
"AND u.identifiant = :etudiantUID ".
"AND app.id_semestre = :semestreUID");
$getGroupeUID->execute(array(
':etudiantUID' => $etudiantUID,
':semestreUID' => $semestreUID,
));
// si on trouve, on le définit, sinon on retourne "unknown_user"
if( $groupeUID = $getGroupeUID->fetch()['id'] ){
$groupeUID = $groupeUID;
/***************************************************************/
/*** CAS 1 : l'utilisateur a déjà un groupe pour ce semestre ***/
/***************************************************************/
// il suffit donc maintenant de modifier l' "appartenance"
$updateGroupe = $this->pdo->prepare("UPDATE appartenance SET id_groupe = :nouveauGroupeUID ".
"WHERE id_etudiant = :etudiantUID ".
"AND id_groupe = :groupeUID ".
"AND id_semestre = :semestreUID");
$updateGroupe->execute(array(
':nouveauGroupeUID' => $nouveauGroupeUID,
':etudiantUID' => $etudiantUID,
':groupeUID' => $groupeUID,
':semestreUID' => $semestreUID
));
}
else{
/****************************************************/
/*** CAS 2 : l'utilisateur n'a pas encore de groupe */
/****************************************************/
$insertGroupe = $this->pdo->prepare("INSERT INTO appartenance(id_appartenance, id_etudiant, id_groupe, id_semestre) ".
"VALUES(NULL, :etudiantUID, :nouveauGroupeUID, :semestreUID)");
$insertGroupe->execute(array(
':etudiantUID' => $etudiantUID,
':nouveauGroupeUID' => $nouveauGroupeUID,
':semestreUID' => $semestreUID
));
}
/* Vérification de l'entrée dans la table */
$verif = $this->pdo->prepare("SELECT count(id_appartenance) as count ".
"FROM appartenance ".
"WHERE id_etudiant = :etudiantUID ".
"AND id_groupe = :nouveauGroupeUID ".
"AND id_semestre = :semestreUID");
$verif->execute(array(
':etudiantUID' => $etudiantUID,
':nouveauGroupeUID' => $nouveauGroupeUID,
':semestreUID' => $semestreUID
));
$verifFetch = $verif->fetch();
if( $verifFetch && $verifFetch['count'] == '1' )
return 'success';
else
return 'error';
}
}
?>

52
manager/groups.php
View File

@ -37,7 +37,8 @@ require_once __ROOT__.'/manager/database.php';
/************************/
/* création d'un groupe */
/************************/
case 'create':
case 'create': if( permission('admin') ){
$areSetParam = isset($request->nom) ; // l'argument existe
$typeOkParam = $areSetParam && is_string($request->nom); // si c'est une string
$nEmptyParam = $typeOkParam && strlen($request->nom) > 0; // d'au moins 1 caractère
@ -47,12 +48,16 @@ require_once __ROOT__.'/manager/database.php';
$answer->request = DataBase::getInstance()->creerGroupe($request->nom);
}else
$answer->request = 'param_error';
}else
$answer->request = 'permission_error';
break;
/***********************************/
/* ajout d'un étudiant à un groupe */
/***********************************/
case 'add':
case 'add': if( permission('admin') ){
$areSetParam = isset($request->etudiant) && isset($request->groupe) && isset($request->semestre) && isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->etudiant) && is_string($request->groupe) && is_numeric($request->semestre) && is_numeric($request->annee); // si c'est des strings
$nEmptyParam = $typeOkParam && strlen($request->etudiant) > 0 && strlen($request->groupe) > 0; // d'au moins 1 caractère
@ -65,12 +70,16 @@ require_once __ROOT__.'/manager/database.php';
$answer->request = DataBase::getInstance()->ajouterEtudiantGroupe($request->etudiant, $request->groupe, $request->semestre, $request->annee);
}else
$answer->request = 'param_error';
}else
$answer->request = 'permission_error';
break;
/*****************************************/
/* retourne les utilisateurs d'un groupe */
/*****************************************/
case 'userlist':
case 'userlist': if( connected() ){
$areSetParam = isset($request->groupe) && isset($request->semestre) && isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->groupe) && is_numeric($request->semestre) && is_numeric($request->annee); // si c'est des strings
$nEmptyParam = $typeOkParam && strlen($request->groupe) > 0; // d'au moins 1 caractère
@ -89,13 +98,17 @@ require_once __ROOT__.'/manager/database.php';
}else
$answer->request = 'param_error';
}else
$answer->request = 'permission_error';
break;
/*******************************************************************/
/* retourne les utilisateurs de tous les groupes du semestre donné */
/*******************************************************************/
case 'grouplist':
case 'grouplist': if( connected() ){
$areSetParam = isset($request->semestre) && isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_numeric($request->semestre) && is_numeric($request->annee); // si c'est des strings
$semestreCheck = $typeOkParam && preg_match('/^[1-4]{1}$/i', $request->semestre); // semestre (semestre) bon format
@ -113,12 +126,16 @@ require_once __ROOT__.'/manager/database.php';
}else
return 'param_error';
}else
$answer->request = 'permission_error';
break;
/*****************************************************************************/
/* retourne les utilisateurs de tous les groupes des modules d'un enseignant */
/*****************************************************************************/
case 'grouplistForTeacher':
case 'grouplistForTeacher': if( permission('teacher') || permission('admin') ){
$areSetParam = isset($request->annee) && isset($request->enseignant); // les arguments existent
$typeOkParam = $areSetParam && is_numeric($request->annee) && is_string($request->enseignant); // si c'est des strings
$anneeCheck = $areSetParam && preg_match('/^[0-9]{4}$/i', $request->annee); // semestre (annee) bon format
@ -147,12 +164,16 @@ require_once __ROOT__.'/manager/database.php';
}else
return 'param_error';
}else
$answer->request = 'permission_error';
break;
/*******************************************************************/
/********************************************************************/
/* retourne les utilisateurs de tous les groupes d'une année donnée */
/*******************************************************************/
case 'grouplistForYear':
/********************************************************************/
case 'grouplistForYear': if( permission('teacher') || permission('admin') ){
$areSetParam = isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_numeric($request->annee); // si c'est des strings
$anneeCheck = $areSetParam && preg_match('/^[0-9]{4}$/i', $request->annee); // semestre (annee) bon format
@ -183,12 +204,16 @@ require_once __ROOT__.'/manager/database.php';
}else
return 'param_error';
}else
$answer->request = 'permission_error';
break;
/**********************************************/
/* retourne le nom du groupe d'un utilisateur */
/**********************************************/
case 'get':
case 'get': if( connected() ){
$areSetParam = isset($request->etudiant) && isset($request->semestre) && isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->etudiant) && is_numeric($request->semestre) && is_numeric($request->annee); // si c'est des strings
$nEmptyParam = $typeOkParam && strlen($request->etudiant) > 0; // d'au moins 1 caractère
@ -204,12 +229,16 @@ require_once __ROOT__.'/manager/database.php';
$answer->request = 'success';
}else // si on a pas "success", alors c'est que $groupe est un message d'erreur
$answer->answer = 'error';
}else
$answer->request = 'permission_error';
break;
/************************************************/
/* déplace un étudiant de son groupe à un autre */
/************************************************/
case 'move':
case 'move': if( permission('admin') ){
$areSetParam = isset($request->etudiant) && isset($request->groupe); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->etudiant) && is_string($request->groupe); // si c'est des strings
$nEmptyParam = $typeOkParam && strlen($request->etudiant) > 0 && strlen($request->groupe) > 0; // d'au moins 1 caractère
@ -220,6 +249,9 @@ require_once __ROOT__.'/manager/database.php';
$answer->request = DataBase::getInstance()->deplacerEtudiant($request->etudiant, $request->groupe, $_SESSION['annee']);
}else
$answer->answer = 'param_error';
}else
$answer->request = 'permission_error';
break;
/***********/

42
manager/modules.php
View File

@ -36,7 +36,8 @@ require_once __ROOT__.'/manager/database.php';
/********************************************/
/* liste des modules d'un ETUDIANT (par UE) */
/********************************************/
case 'getByEtudiant':
case 'getByEtudiant': if( connected() ){
$areSetParam = isset($request->etudiant) && isset($request->semestre) && isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->etudiant) && is_string($request->semestre) && is_string($request->annee); // si c'est des strings
$nEmptyParam = $typeOkParam && strlen($request->etudiant) > 0 && is_numeric($request->semestre) && is_numeric($request->annee); // des bon types
@ -57,12 +58,16 @@ require_once __ROOT__.'/manager/database.php';
$answer->request = $UEList; // on retourne l'erreur
}else
$answer->request = 'param_error';
}else
$answer->request = 'permission_error';
break;
/**********************************************/
/* liste des modules d'un ENSEIGNANT (par UE) */
/**********************************************/
case 'getByEnseignant':
case 'getByEnseignant': if( permission('teacher') || permission('admin') ){
$areSetParam = isset($request->enseignant)&& isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->enseignant) && is_string($request->annee); // si c'est des strings
$nEmptyParam = $typeOkParam && strlen($request->enseignant) > 0 && is_numeric($request->annee); // des bon types
@ -82,6 +87,39 @@ require_once __ROOT__.'/manager/database.php';
$answer->request = $UEList; // on retourne l'erreur
}else
$answer->request = 'param_error';
}else
$answer->request = 'permission_error';
break;
/******************************************/
/* liste des modules d'une ANNEE (par UE) */
/******************************************/
case 'getByYear': if( permission('admin') ){
$areSetParam = isset($request->annee); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->annee); // si c'est des strings
$nEmptyParam = $typeOkParam && is_numeric($request->annee); // des bon types
$anneeCheck = $nEmptyParam && preg_match('/^[0-9]{4}$/i', $request->annee); // semestre (annee) bon format
if( $anneeCheck ){ // si tout les paramètres sont bons
$UEList = DataBase::getInstance()->getModulesByUEByYear($request->annee);
// STRUCTURE
// tableau d'UES contenant un tableau de MODULES
if( is_array($UEList) ){ // si on a bien un tableau
$answer->UEs = $UEList; // on renvoie dans answer->ues
$answer->request = 'success'; // et on renvoie success
}else // sinon si c'est pas un tableau
$answer->request = $UEList; // on retourne l'erreur
}else
$answer->request = 'param_error';
}else
$answer->request = 'permission_error';
break;

24
manager/user.php
View File

@ -74,7 +74,8 @@ require_once __ROOT__.'/manager/database.php';
/**************************/
/* création d'utilisateur */
/**************************/
case 'create':
case 'create': if( permission('admin') ){
$areSetParam = isset($request->identifiant) && isset($request->prenom) && isset($request->nom) && isset($request->mail) && isset($request->mdp) && isset($request->droits); // les arguments existent
$typeOkParam = $areSetParam && is_string($request->identifiant) && is_string($request->prenom) && is_string($request->nom) && is_string($request->mail) && is_string($request->mdp) && is_string($request->droits); // ils sont tous 2 des string
$nEmptyParam = $typeOkParam && strlen($request->identifiant) > 0 && strlen($request->prenom) > 0 && is_string($request->nom) && is_string($request->mail) && is_string($request->mdp) && is_string($request->droits); // d'au moins 1 caractère
@ -89,6 +90,9 @@ require_once __ROOT__.'/manager/database.php';
$answer->request = DataBase::getInstance()->creerUtilisateur($request->identifiant, $request->prenom, $request->nom, $request->mail, $request->mdp, $request->droits);
}else
$answer->request = 'param_error';
}else
$answer->request = 'permission_error';
break;
@ -158,13 +162,23 @@ require_once __ROOT__.'/manager/database.php';
// [3] On check le mot de passe
if( $userList->{$username}->password == $password ){
// on définit les variables session
$_SESSION['identifiant'] = $username;
$_SESSION['droits'] = $userList->{$username}->permissions; // est un TABLEAU
// [4] On récupère les informations dans la base de données
if( $utilInfo = Database::getInstance()->utilisateurInfo($username) ){ // si l'utilisateur est dans le BDD
$_SESSION['identifiant'] = $utilInfo['identifiant'];
$_SESSION['droits'] = explode(',', $utilInfo['droits']);
// on récupère l'année courante (1er sept à 1er sept)
// SI (mois < 8) ALORS (annee - 1) SINON (annee)
$_SESSION['annee'] = (Date('m', time())<8) ? Date('Y', time()) - 1 : Date('Y', time());
}else
return 'not_in_db';
/******************************* TEMPO *********************************/
/*** ON VA CHERCHER LES INFOS DANS LA BDD ***/
$_SESSION['semestre'] = '2';
$_SESSION['annee'] = '2015';
/***********************************************************************/
return 'success';
}else

50
page/modules.php
View File

@ -70,7 +70,7 @@ if( permission('student') ){ // si l'utilisateur est connecté et que c'est un
/****************************************/
/*** MES MODULES (version enseignant) ***/
/****************************************/
if( permission('teacher') ){ // si l'utilisateur est connecté et que c'est un élève
if( permission('teacher') ){ // si l'utilisateur est un prof
$request = new stdClass(); $answer = new stdClass();
@ -110,3 +110,51 @@ if( permission('teacher') ){ // si l'utilisateur est connecté et que c'est un
} ?>
<!-- tous les modules -->
<?php
/****************************************/
/*** TOUT LES MODULES (version admin) ***/
/****************************************/
if( permission('admin') ){ // si l'utilisateur est un admin
$request = new stdClass(); $answer = new stdClass();
$request->level_1 = 'getByYear';
$request->annee = $_SESSION['annee'];
modules_switch_level_1($request, $answer);
if( $answer->request == 'success' ){ // si on a bien récupéré les membres du groupe
////////////////////////////////////////////////////////////////////////////////
echo "<section name='allmodules' title='Mes modules' class='basic'>";
foreach($answer->UEs as $UE){
echo "<table class='basic'>";
echo "<thead class='active'>";
echo '<tr>';
echo '<th colspan=5>'.$UE['nom'].' - '.$UE['libelle'].'</th>';
echo '</tr>';
echo '</thead>';
echo '<tbody>';
foreach($UE['modules'] as $MODULE){
echo '<tr>';
echo '<td>'.$MODULE['nom'].'</td>';
echo '<td>'.$MODULE['libelle'].'</td>';
echo '</tr>';
}
echo '</tbody>';
echo '</table>';
}
////////////////////////////////////////////////////////////////////////////////
echo '</section>';
}else
echo "Erreur interne.";
} ?>

2
src/userlist.json
View File

@ -24,7 +24,7 @@
"password" : "password"
},
"admin1": {
"admin": {
"permissions": ["admin"],
"password" : "password"
},

9
test.php
View File

@ -1,7 +1,14 @@
<?php define('__ROOT__', dirname(__FILE__) );
require_once __ROOT__.'/manager/security.php';
var_dump( $_SESSION['droits'] );
$annee = Date('Y', time());
$mois = (int) Date('m', time());
$annee = 2015; $mois = 8;
if( $mois < 8 ) $annee--;
echo ($mois<8) ? Date('Y', time()) - 1 : Date('Y', time());
/***************/
/*** A FAIRE ***/

59
xdoc/iteration1.mail Normal file
View File

@ -0,0 +1,59 @@
Bonjour,
En accord avec le cycle de développement sélectionné, nous vous soumettons un compte rendu de la première itération du projet,
afin d'avoir votre approbation ou vos corrections afin de définir les premiers objectifs de la seconde itération.
Voici les principales fonctionnalités implémentées:
[1] Authentification par fichier JSON (synchronisé avec la BDD)
[2] pour les étudiants
(1) affichage des groupes du même semestre
(2) affichage du groupe auquel il appartient actuellement
(3) affichage des modules de son semestre (affichage par ue)
(4) affichage de ses notes par modules (affichage par ue)
[3] pour les enseignants
(1) affichage des groupes des semestres en cours (possibilité de filtrage par semestre ou par groupe)
(2) affichage des groupes qui sont ses élèves (possibilité de filtrage par semestre ou par groupe)
(3) affichage des modules qu'il enseigne sur ce semestre (affichage par ue)
[4] pour l'administrateur
(1) affichage des groupes des semestres en cours (possibilité de filtrage par semestre ou par groupe)
Les fonctionnalités prévues pour la seconde itération sont
[1] pour les étudiants
(1) affichage des groupes du même semestre
(2) affichage du groupe auquel il appartient actuellement
(3) affichage des modules de son semestre (affichage par ue)
(4) affichage de ses notes par modules (affichage par ue)
[2] pour les enseignants
(4) affichage des contrôles de ses modules uniquement
+ visualisation par groupe avec une moyenne et un graphique de répartition
(4bis) si correcteur pour un module, alors peut créér/modifier un contrôle et/ou ajouter des notes
+ import Excel
[3] pour l'administrateur
(2) affichage des modules par UE (semestres en cours)
(3) créer/modifier/supprimer des modules
créer/modifier/supprimer des UEs
ajouter/supprimer des modules d'un UE
+ import Excel

10
xdoc/linecount Normal file
View File

@ -0,0 +1,10 @@
| css | 954 |
| js | 822 |
| manager | 2014 |
| page | 863 |
| _JS | 98 |
| API.js | 77 |
| API.php | 104 |
| index.php | 142 |
+-----------+-------+
| TOTAL | 5074 |