366 lines
14 KiB
PHP
Executable File
366 lines
14 KiB
PHP
Executable File
<?php require_once __ROOT__.'/manager/security.php';
|
|
|
|
/*************************************************************/
|
|
/* _ _ ___ _____ _____ ____ _____ ____ ___ */
|
|
/* | \ | |/ _ \_ _| ____| | _ \| ____| _ \ / _ \ */
|
|
/* | \| | | | || | | _| | |_) | _| | |_) | | | | */
|
|
/* | |\ | |_| || | | |___ | _ <| |___| __/| |_| | */
|
|
/* |_| \_|\___/ |_| |_____| |_| \_\_____|_| \___/ */
|
|
/* */
|
|
/*************************************************************/
|
|
|
|
class noteRepo{
|
|
/* 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> l'UID de la note si elle existe pour ces critères (la dernière assignée)
|
|
* @return FALSE<Boolean> FAUX si aucune note répondant à ces critères n'est pas présente dans la BDD
|
|
*
|
|
*/
|
|
public static function UID($etudiant, $controle){
|
|
$getNoteUID = DataBase::getPDO()->prepare("SELECT note.id_note as id
|
|
FROM appartenance as app, note, controle as ctrl
|
|
WHERE app.id_appartenance = note.id_appartenance
|
|
AND ctrl.id_controle = note.id_controle
|
|
|
|
AND app.id_etudiant = :etudiant
|
|
AND ctrl.id_controle = :controle
|
|
AND note.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)");
|
|
$getNoteUID->execute(array( ':etudiant' => $etudiant, ':controle' => $controle ));
|
|
|
|
// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID de l'utilisateur
|
|
return $getNoteUID->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();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LES NOTES D'UN ETUDIANT POUR UN CONTROLE PARTICULIER
|
|
*
|
|
* @etudiant<String> l'UID de l'étudiant concerné
|
|
* @controle<int> l'UID du controle concerné
|
|
*
|
|
* @return notes<Array> retourne les notes d'un étudiant pour un controle particulier
|
|
*
|
|
*/
|
|
public static function forStudent($etudiant, $controle){
|
|
$getNoteList = DataBase::getPDO()->prepare("SELECT DISTINCT n.id_note as id, n.id_appartenance, n.id_controle, n.valeur
|
|
FROM note as n, appartenance as app, semestre as s, controle as ctrl, mcc_ue, mcc_module as mcc_m
|
|
WHERE n.id_appartenance = app.id_appartenance
|
|
AND app.id_semestre = s.id_semestre
|
|
AND s.id_semestre = mcc_ue.id_semestre
|
|
AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
|
|
AND mcc_m.id_mcc_module = ctrl.id_mcc_module
|
|
AND n.id_controle = ctrl.id_controle
|
|
AND n.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)
|
|
|
|
AND app.id_etudiant = :etudiant
|
|
AND ctrl.id_controle = :controle
|
|
ORDER BY n.valeur ASC");
|
|
$getNoteList->execute(array( ':etudiant' => $etudiant, ':controle' => $controle ));
|
|
|
|
return DataBase::delNumeric( $getNoteList->fetchAll() );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LES NOTES POUR UN CONTROLE PARTICULIER
|
|
*
|
|
* [1] Par groupe si aucun groupe spécifié (statistiques: moyenne, min, max, nb notes, ...)
|
|
* [2] Liste des élèves d'un groupe si aucun groupe spécifié
|
|
*
|
|
*
|
|
* @controle<int> l'UID du controle concerné
|
|
*
|
|
* @groupe<int> ***OPTIONNEL*** l'UID du groupe spécifique
|
|
*
|
|
*
|
|
* @return notes<Array> [1] retourne les stats des notes pour les groupes à ce contrôle
|
|
* [2] retourne les notes des étudiants du groupe spécifié pour ce contrôle
|
|
*
|
|
*/
|
|
public static function forControle($controle, $groupe=null){
|
|
/* [1] Statistiques des groupes
|
|
============================================================*/
|
|
if( !is_int($groupe) ){
|
|
|
|
$getNoteList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe, g.nom as groupe, n.id_note as id, n.id_controle, AVG(n.valeur) as moyenne, min(n.valeur) as min, max(n.valeur) as max, COUNT(n.valeur) as nb_notes
|
|
FROM note as n, appartenance as app, semestre as s, controle as ctrl, mcc_ue, mcc_module as mcc_m, groupe as g
|
|
WHERE n.id_appartenance = app.id_appartenance
|
|
AND app.id_semestre = s.id_semestre
|
|
AND app.id_groupe = g.id_groupe
|
|
AND s.id_semestre = mcc_ue.id_semestre
|
|
AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
|
|
AND mcc_m.id_mcc_module = ctrl.id_mcc_module
|
|
AND n.id_controle = ctrl.id_controle
|
|
|
|
AND n.id_note in (SELECT max(id_note) FROM note GROUP BY id_appartenance, id_controle)
|
|
|
|
AND ctrl.id_controle = :controle
|
|
|
|
GROUP BY g.id_groupe
|
|
|
|
ORDER BY g.nom ASC");
|
|
$getNoteList->execute(array( ':controle' => $controle ));
|
|
|
|
|
|
/* [2] Notes des étudiants d'un groupe
|
|
============================================================*/
|
|
}else{
|
|
|
|
$getNoteList = DataBase::getPDO()->prepare("SELECT DISTINCT n.id_note as id, g.nom as groupe, app.id_etudiant as etudiant, n.id_appartenance, n.id_controle, n.valeur
|
|
FROM note as n, appartenance as app, semestre as s, controle as ctrl, mcc_ue, mcc_module as mcc_m, groupe as g
|
|
WHERE n.id_appartenance = app.id_appartenance
|
|
AND app.id_semestre = s.id_semestre
|
|
AND app.id_groupe = g.id_groupe
|
|
AND s.id_semestre = mcc_ue.id_semestre
|
|
AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
|
|
AND mcc_m.id_mcc_module = ctrl.id_mcc_module
|
|
AND n.id_controle = ctrl.id_controle
|
|
|
|
AND n.id_note in (SELECT max(id_note) FROM note GROUP BY id_appartenance, id_controle)
|
|
|
|
AND ctrl.id_controle = :controle
|
|
AND app.id_groupe = :groupe
|
|
|
|
ORDER BY g.nom ASC");
|
|
$getNoteList->execute(array( ':controle' => $controle, ':groupe' => $groupe ));
|
|
|
|
}
|
|
|
|
return DataBase::delNumeric( $getNoteList->fetchAll() );
|
|
}
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LES STATISTIQUES ASSOCIÉES À UN CONTRÔLE POUR UN GROUPE SPÉCIFIQUE
|
|
*
|
|
* @controle<int> l'UID du controle concerné
|
|
* @groupe<int> l'UID du groupe spécifique
|
|
*
|
|
*
|
|
* @return notes<Array> retourne les stats des notes pour les groupes à ce contrôle
|
|
* @return FALSE<Boolean> retourne FALSE si aucun résultat n'est trouvé
|
|
*
|
|
*/
|
|
public static function forGroupe($controle, $groupe){
|
|
$getNoteList = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe, g.nom as groupe, n.id_note as id, n.id_appartenance, n.id_controle, AVG(n.valeur) as moyenne, min(n.valeur) as min, max(n.valeur) as max, COUNT(n.valeur) as nb_notes
|
|
FROM note as n, appartenance as app, semestre as s, controle as ctrl, mcc_ue, mcc_module as mcc_m, groupe as g
|
|
WHERE n.id_appartenance = app.id_appartenance
|
|
AND app.id_semestre = s.id_semestre
|
|
AND app.id_groupe = g.id_groupe
|
|
AND s.id_semestre = mcc_ue.id_semestre
|
|
AND mcc_ue.id_mcc_ue = mcc_m.id_mcc_ue
|
|
AND mcc_m.id_mcc_module = ctrl.id_mcc_module
|
|
AND n.id_controle = ctrl.id_controle
|
|
|
|
AND n.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)
|
|
|
|
AND ctrl.id_controle = :controle
|
|
AND app.id_groupe = :groupe
|
|
|
|
GROUP BY g.id_groupe
|
|
|
|
ORDER BY g.nom ASC");
|
|
$getNoteList->execute(array( ':controle' => $controle, ':groupe' => $groupe ));
|
|
|
|
return $getNoteList->fetch();
|
|
}
|
|
|
|
|
|
/* RETOURNE LA MOYENNE D'UN CONTRÔLE PARTICULIER
|
|
*
|
|
* @controle<int> l'UID du contrôle en question
|
|
*
|
|
*
|
|
* @return moyenne<Float> retourne la moyenne d'un contrôle
|
|
* @return NULL retourne NULL s'il y a aucune note à ce contrôle
|
|
*
|
|
*/
|
|
public static function moyenneForControle($controle){
|
|
$getMoyenne = DataBase::getPDO()->prepare("SELECT ctrl.id_controle, AVG(n.valeur) as moyenne
|
|
FROM controle as ctrl, note as n
|
|
WHERE ctrl.id_controle = n.id_controle
|
|
AND ctrl.id_controle = :controle
|
|
AND n.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)
|
|
|
|
GROUP BY ctrl.id_controle");
|
|
$getMoyenne->execute(array( ':controle' => $controle ));
|
|
|
|
if( $fetchObj = $getMoyenne->fetch() )
|
|
return $fetchObj['moyenne'];
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
|
|
/* RETOURNE LA MOYENNE D'UN MODULE POUR UN ETUDIANT
|
|
*
|
|
* @etudiant<String> l'UID de l'étudiant en question
|
|
* @module<int> l'UID du module en quesion
|
|
* @semestre<int> l'UID du semestre en question
|
|
*
|
|
*
|
|
* @return moyenne<Float> retourne la valeur de la moyenne en question
|
|
* @return FALSE<Boolean> retourne FALSE si rien n'est trouvé
|
|
*
|
|
*/
|
|
public static function moyenneModule($etudiant, $module, $semestre){
|
|
$getMoyenneModule = DataBase::getPDO()->prepare("SELECT SUM(note.valeur*ctrl.coefficient)/SUM(ctrl.coefficient) as moyenne, ctrl.base
|
|
FROM note, appartenance as app, controle as ctrl, mcc_module as mcc_m, mcc_ue, semestre as s
|
|
WHERE note.id_controle = ctrl.id_controle
|
|
AND 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_etudiant = :etudiant
|
|
AND mcc_m.id_module = :module
|
|
AND app.id_semestre = :semestre
|
|
AND note.id_note in (SELECT max(id_note) FROM note WHERE id_controle=ctrl.id_controle AND id_appartenance=app.id_appartenance GROUP BY id_controle, id_appartenance)
|
|
GROUP BY mcc_m.id_mcc_module");
|
|
$getMoyenneModule->execute(array( ':etudiant' => $etudiant, ':module' => $module, ':semestre' => $semestre ));
|
|
|
|
return $getMoyenneModule->fetch();
|
|
}
|
|
|
|
|
|
|
|
/* CRÉATION/MODIFICATION D'UNE NOTE POUR UN ETUDIANT À UN CONTRÔLE
|
|
*
|
|
* @etudiant<String> l'UID de l'étudiant en question
|
|
* @controle<int> l'UID du contrôle en question
|
|
* @semestre<int> l'UID du semestre en question
|
|
* @valeur<number> valeur de la note à saisir
|
|
*
|
|
*
|
|
* @return noteUID<int> l'UID de la note si elle a bien été créé
|
|
* @return cree<Boolean> FALSE si la note n'a pas été créé
|
|
*
|
|
*/
|
|
public static function creer($etudiant, $controle, $semestre, $valeur){
|
|
/* [1] Premier cas : il faut créer la note de cet étudiant pour ce contrôle
|
|
============================================================================*/
|
|
/* [MAJ] On créé toujours une note, même si une existe déjà afin de garder toutes les modifications */
|
|
if( true ){ // !($noteUID=noteRepo::UID($etudiant, $controle))
|
|
|
|
$creationNote = DataBase::getPDO()->prepare("INSERT INTO note(id_note, id_appartenance, id_controle, valeur)
|
|
VALUES(
|
|
DEFAULT,
|
|
(SELECT id_appartenance FROM appartenance WHERE id_etudiant = :etudiant AND id_semestre = :semestre),
|
|
:controle,
|
|
:valeur
|
|
)");
|
|
$creationNote->execute(array( ':etudiant' => $etudiant, ':semestre' => $semestre, ':controle' => $controle, ':valeur' => $valeur ));
|
|
|
|
|
|
/* [2] Second cas : il faut modifier la note de cet étudiant
|
|
============================================================================*/
|
|
}else{
|
|
|
|
$modificationNote = DataBase::getPDO()->prepare("UPDATE note SET valeur = :valeur WHERE id_note = :noteUID");
|
|
$modificationNote->execute(array( ':valeur' => $valeur, ':noteUID' => $noteUID ));
|
|
|
|
}
|
|
|
|
/* [3] On vérifie que la note a bien été créé pour cet étudiant et ce contrôle
|
|
=================================================================================*/
|
|
$verifNote = DataBase::getPDO()->prepare("SELECT n.id_note as id, n.valeur
|
|
FROM note as n, appartenance as app
|
|
WHERE n.id_appartenance = app.id_appartenance
|
|
AND app.id_etudiant = :etudiant
|
|
AND n.id_controle = :controle
|
|
AND n.id_note in (SELECT max(id_note) FROM note GROUP BY id_controle, id_appartenance)
|
|
GROUP BY app.id_appartenance, n.id_controle");
|
|
$verifNote->execute(array( ':etudiant' => $etudiant, ':controle' => $controle ));
|
|
|
|
$verifResult = $verifNote->fetch();
|
|
|
|
// si aucun résultat, on retourne FALSE
|
|
if( !is_array($verifResult) ) return false;
|
|
|
|
// sinon on retourne la vérification de la valeur
|
|
return $verifResult['valeur'] == $valeur;
|
|
}
|
|
|
|
|
|
|
|
/* CRÉATION/MODIFICATION DE NOTES MULTIPLE
|
|
*
|
|
* @notes<Array>
|
|
* @etudiant<String> l'UID de l'étudiant en question
|
|
* @controle<int> l'UID du contrôle en question
|
|
* @semestre<int> l'UID du semestre en question
|
|
* @valeur<number> valeur de la note à saisir
|
|
*
|
|
*
|
|
* @return noteUID<int> l'UID de la note si elle a bien été créé
|
|
* @return cree<Boolean> FALSE si la note n'a pas été créé
|
|
*
|
|
*/
|
|
public static function creerMultiple($controle, $semestre, $notes){
|
|
$saisieFinie = true;
|
|
|
|
foreach($notes as $iter=>$note){
|
|
|
|
|
|
$cEtudiant = $note->etudiant;
|
|
$cValeur = $note->valeur;
|
|
|
|
/* [1] Il faut créer la note de cet étudiant pour ce contrôle
|
|
============================================================================*/
|
|
$creationNote = DataBase::getPDO()->prepare("INSERT INTO note(id_note, id_appartenance, id_controle, valeur)
|
|
VALUES(
|
|
DEFAULT,
|
|
(SELECT id_appartenance FROM appartenance WHERE id_etudiant = :etudiant AND id_semestre = :semestre),
|
|
:controle,
|
|
:valeur
|
|
)");
|
|
$creationNote->execute(array( ':etudiant' => $cEtudiant, ':semestre' => $semestre, ':controle' => $controle, ':valeur' => $cValeur ));
|
|
|
|
|
|
/* [2] On vérifie que la note a bien été créé pour cet étudiant et ce contrôle
|
|
=================================================================================*/
|
|
if( !($noteUID=noteRepo::UID($cEtudiant, $controle)) ) return false;
|
|
|
|
/* [3] On vérifie que la note créée a bien la valeur qu'on a attribuée
|
|
=================================================================================*/
|
|
$verificationValeur = DataBase::getPDO()->prepare("SELECT valeur FROM note WHERE id_note = :noteUID");
|
|
$verificationValeur->execute(array( ':noteUID' => $noteUID ));
|
|
|
|
|
|
$saisieFinie = $saisieFinie && ( $verificationValeur->fetch()['valeur'] == $cValeur );
|
|
}
|
|
|
|
return $saisieFinie;
|
|
}
|
|
|
|
|
|
} |