sid/manager/repo/note.php

366 lines
14 KiB
PHP
Raw Permalink Normal View History

<?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)
2015-11-15 14:12:26 +00:00
* @return FALSE<Boolean> FAUX si aucune note répondant à ces critères n'est pas présente dans la BDD
*
*/
2015-11-15 14:12:26 +00:00
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)");
2015-11-15 14:12:26 +00:00
$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
2015-11-15 14:12:26 +00:00
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() );
}
2015-11-15 14:12:26 +00:00
/* 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 ));
2016-01-03 10:58:11 +00:00
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() )
2016-01-03 00:04:28 +00:00
return $fetchObj['moyenne'];
else
return null;
}
2015-11-30 09:23:34 +00:00
/* 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
2015-11-30 09:23:34 +00:00
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)
2015-11-30 09:23:34 +00:00
GROUP BY mcc_m.id_mcc_module");
$getMoyenneModule->execute(array( ':etudiant' => $etudiant, ':module' => $module, ':semestre' => $semestre ));
2016-01-03 10:58:11 +00:00
return $getMoyenneModule->fetch();
2015-11-30 09:23:34 +00:00
}
2015-11-15 14:12:26 +00:00
/* 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))
2015-11-15 14:12:26 +00:00
$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
)");
2015-11-15 14:12:26 +00:00
$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éé
*
*/
2015-11-22 16:23:01 +00:00
public static function creerMultiple($controle, $semestre, $notes){
$saisieFinie = true;
2015-11-15 14:12:26 +00:00
2015-11-22 16:23:01 +00:00
foreach($notes as $iter=>$note){
2015-11-15 14:12:26 +00:00
2015-11-22 16:23:01 +00:00
$cEtudiant = $note->etudiant;
$cValeur = $note->valeur;
2015-11-15 14:12:26 +00:00
/* [1] Il faut créer la note de cet étudiant pour ce contrôle
2015-11-22 16:23:01 +00:00
============================================================================*/
$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 ));
2015-11-22 16:23:01 +00:00
/* [2] On vérifie que la note a bien été créé pour cet étudiant et ce contrôle
2015-11-22 16:23:01 +00:00
=================================================================================*/
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
2015-11-22 16:23:01 +00:00
=================================================================================*/
$verificationValeur = DataBase::getPDO()->prepare("SELECT valeur FROM note WHERE id_note = :noteUID");
$verificationValeur->execute(array( ':noteUID' => $noteUID ));
$saisieFinie = $saisieFinie && ( $verificationValeur->fetch()['valeur'] == $cValeur );
2015-11-22 16:23:01 +00:00
}
return $saisieFinie;
2015-11-15 14:12:26 +00:00
}
}