prise en compte des remarques de formations.py

app/api/departements.py

@@ -3,7 +3,7 @@ import app
 
 from app import models
 from app.api import bp
-from app.api.auth import token_auth, token_permission_required
+from app.api.auth import token_permission_required
 from app.api.errors import error_response
 from app.scodoc.sco_permissions import Permission
 
@@ -19,7 +19,7 @@ def departements():
     Exemple de résultat : [2, 5, 8, 1, 4, 18]
     """
     # Récupération de tous les départements
-    depts = models.Departement.query.filter_by(visible=True).all()
+    depts = models.Departement.query.filter_by(visible=True)
 
     # Mise en place de la liste avec tous les ids de départements
     depts_ids = [d.id for d in depts]
@@ -67,14 +67,14 @@ def liste_etudiants(dept: str, formsemestre_id=None):
     # Si le formsemestre_id a été renseigné
     if formsemestre_id is not None:
         # Récupération du formsemestre
-        formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
+        formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
         # Récupération du département
         departement = formsemestre.departement
 
     # Si le formsemestre_id n'a pas été renseigné
     else:
         # Récupération du formsemestre
-        departement = models.Departement.query.filter_by(acronym=dept).first()
+        departement = models.Departement.query.filter_by(acronym=dept).first_or_404()
 
     # Récupération des étudiants
     etudiants = departement.etudiants.all()
@@ -129,16 +129,12 @@ def liste_semestres_courant(dept: str):
                 ]
     """
     # Récupération des départements comportant l'acronym mit en paramètre
-    depts = models.Departement.query.filter_by(acronym=dept).all()
-
-    # Récupération de l'id
-    id_dept = depts[0].id
+    dept = models.Departement.query.filter_by(acronym=dept).first_or_404()
 
     # Récupération des semestres suivant id_dept
-    semestres = models.FormSemestre.query.filter_by(dept_id=id_dept, etat=True).all()
+    semestres = models.FormSemestre.query.filter_by(dept_id=dept.id, etat=True)
 
     # Mise en forme des données
-
     data = [d.to_dict() for d in semestres]
 
     return jsonify(data)
@@ -156,15 +152,13 @@ def referenciel_competences(dept: str, formation_id: int):
     dept : l'acronym d'un département
     formation_id : l'id d'une formation
     """
-    depts = models.Departement.query.filter_by(acronym=dept).all()
+    dept = models.Departement.query.filter_by(acronym=dept).first_or_404()
 
-    id_dept = depts[0].id
+    formation = models.Formation.query.filter_by(
+        id=formation_id, dept_id=dept.id
+    ).first_or_404()
 
-    formations = models.Formation.query.filter_by(
-        id=formation_id, dept_id=id_dept
-    ).all()
-
-    ref_comp = formations[0].referentiel_competence_id
+    ref_comp = formation.referentiel_competence_id
 
     if ref_comp is None:
         return error_response(
@@ -173,10 +167,6 @@ def referenciel_competences(dept: str, formation_id: int):
     else:
         return jsonify(ref_comp)
 
-    # ref = ApcReferentielCompetences.query.get_or_404(formation_id)
-    #
-    # return jsonify(ref.to_dict())
-
 
 @bp.route(
     "/departements/<string:dept>/formsemestre/<string:formsemestre_id>/programme",
@@ -190,7 +180,7 @@ def semestre_index(dept: str, formsemestre_id: int):
 
     app.set_sco_dept(dept)
 
-    formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
+    formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
 
     ues = formsemestre.query_ues()
 
@@ -218,4 +208,3 @@ def semestre_index(dept: str, formsemestre_id: int):
     }
 
     return data
-    # return error_response(501, message="not implemented")

app/api/etudiants.py

@@ -1,16 +1,16 @@
 #################################################### Etudiants ########################################################
-import app
 
 from flask import jsonify
 
+import app
 from app import models
 from app.api import bp
 from app.api.errors import error_response
-from app.api.auth import token_auth, token_permission_required
+from app.api.auth import token_permission_required
 from app.api.tools import get_etu_from_request
 from app.models import FormSemestreInscription, FormSemestre, Identite
-from app.scodoc.sco_bulletins import get_formsemestre_bulletin_etud_json
-from app.scodoc.sco_groups import get_etud_groups
+from app.scodoc import sco_bulletins
+from app.scodoc import sco_groups
 from app.scodoc.sco_permissions import Permission
 
 
@@ -46,13 +46,14 @@ def etudiants_courant():
               ...
     """
     # Récupération de tous les étudiants
-    etus = Identite.query.filter(
+    etuds = Identite.query.filter(
         Identite.id == FormSemestreInscription.etudid,
         FormSemestreInscription.formsemestre_id == FormSemestre.id,
         FormSemestre.date_debut <= app.db.func.now(),
-        FormSemestre.date_fin >= app.db.func.now())
+        FormSemestre.date_fin >= app.db.func.now(),
+    )
 
-    data = [etu.to_dict_bul(include_urls=False) for etu in etus]
+    data = [etu.to_dict_bul(include_urls=False) for etu in etuds]
 
     return jsonify(data)
 
@@ -97,7 +98,7 @@ def etudiant(etudid: int = None, nip: int = None, ine: int = None):
 @token_permission_required(Permission.APIView)
 def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None):
     """
-    Retourne la liste des semestres qu'un étudiant a suivis
+    Retourne la liste des semestres qu'un étudiant a suivi, triés par ordre chronologique.
 
     etudid : l'etudid d'un étudiant
     nip : le code nip d'un étudiant
@@ -108,7 +109,6 @@ def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None)
                   {
                     "titre": "master machine info",
                     "gestion_semestrielle": false,
-                    "scodoc7_id": null,
                     "date_debut": "01/09/2021",
                     "bul_bgcolor": null,
                     "date_fin": "15/12/2022",
@@ -139,27 +139,14 @@ def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None)
                 ]
     """
     # Récupération de l'étudiant
-    etu = get_etu_from_request(etudid, nip, ine)
+    etud = get_etu_from_request(etudid, nip, ine)
 
-    # Récupération de toutes les inscriptions de l'étudiant
-    formsemestres_inscriptions = models.FormSemestreInscription.query.filter_by(
-        etud=etu
-    ).all()
+    formsemestres = models.FormSemestre.query.filter(
+        models.FormSemestreInscription.etudid == etud.id,
+        models.FormSemestreInscription.formsemestre_id == models.FormSemestre.id,
+    ).order_by(models.FormSemestre.date_debut)
 
-    formsemestres = []
-    # Récupération des formsemestres contenant les inscriptions de l'étudiant
-    for formsemestre_inscription in formsemestres_inscriptions:
-        res = models.FormSemestre.query.filter_by(
-            id=formsemestre_inscription.formsemestre_id
-        ).first_or_404()
-        formsemestres.append(res)
-
-    data = []
-    # Mise en forme des données
-    for formsemestre in formsemestres:
-        data.append(formsemestre.to_dict())
-
-    return jsonify(data)
+    return jsonify([formsemestre.to_dict() for formsemestre in formsemestres])
 
 
 @bp.route(
@@ -188,7 +175,9 @@ def etudiant_bulletin_semestre(
     """
     # Fonction utilisée : app.scodoc.sco_bulletins_json.make_json_formsemestre_bulletinetud()
 
-    formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
+    formsemestre = models.FormSemestre.query.filter_by(
+        id=formsemestre_id
+    ).first_or_404()
 
     dept = models.Departement.query.filter_by(id=formsemestre.dept_id).first_or_404()
 
@@ -201,10 +190,10 @@ def etudiant_bulletin_semestre(
         return error_response(
             409,
             message="La requête ne peut être traitée en l’état actuel.\n "
-            "Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
+            "Veuillez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
         )
 
-    return get_formsemestre_bulletin_etud_json(formsemestre, etu)
+    return sco_bulletins.get_formsemestre_bulletin_etud_json(formsemestre, etu)
 
 
 @bp.route(
@@ -255,8 +244,6 @@ def etudiant_groups(
                   }
                 ]
     """
-    # Fonction utilisée : app.scodoc.sco_groups.get_etud_groups()
-
     if etudid is None:
         # Récupération de l'étudiant
         try:
@@ -266,19 +253,18 @@ def etudiant_groups(
             return error_response(
                 409,
                 message="La requête ne peut être traitée en l’état actuel.\n "
-                "Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
+                "Veuillez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
             )
 
     # Récupération du formsemestre
     sem = models.FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
     try:
-        # Utilisation de la fonction get_etud_groups
-        data = get_etud_groups(etudid, sem.id)
+        data = sco_groups.get_etud_groups(etudid, sem.id)
     except AttributeError:
         return error_response(
             409,
             message="La requête ne peut être traitée en l’état actuel.\n "
-            "Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide"
+            "Veuillez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide"
             " et le formsemestre_id sont valides",
         )
 

app/api/evaluations.py

@@ -1,6 +1,8 @@
 ############################################### Evaluations ###########################################################
 from flask import jsonify
 
+import app
+
 from app import models
 from app.api import bp
 from app.api.auth import token_permission_required
@@ -16,15 +18,39 @@ def evaluations(moduleimpl_id: int):
     Retourne la liste des évaluations à partir de l'id d'un moduleimpl
 
     moduleimpl_id : l'id d'un moduleimpl
+
+    Exemple de résultat :
+                    [
+                  {
+                    "jour": "20/04/2022",
+                    "id": 1,
+                    "heure_fin": "09h00",
+                    "note_max": 20.0,
+                    "visibulletin": true,
+                    "evaluation_type": 0,
+                    "moduleimpl_id": 1,
+                    "heure_debut": "08h00",
+                    "description": "eval1",
+                    "coefficient": 1.0,
+                    "publish_incomplete": false,
+                    "numero": 0,
+                    "evaluation_id": 1,
+                    "jouriso": "2022-04-20",
+                    "duree": "1h",
+                    "descrheure": " de 08h00 \u00e0 09h00",
+                    "matin": 1,
+                    "apresmidi": 0
+                  },
+                  ...
+                ]
     """
     # Récupération de toutes les évaluations
-    evals = models.Evaluation.query.filter_by(id=moduleimpl_id).all()
+    evals = models.Evaluation.query.filter_by(id=moduleimpl_id)
 
     # Mise en forme des données
     data = [d.to_dict() for d in evals]
 
     return jsonify(data)
-    # return error_response(501, message="Not implemented")
 
 
 @bp.route("/evaluations/eval_notes/<int:evaluation_id>", methods=["GET"])
@@ -34,9 +60,44 @@ def evaluation_notes(evaluation_id: int):
     Retourne la liste des notes à partir de l'id d'une évaluation donnée
 
     evaluation_id : l'id d'une évaluation
+
+    Exemple de résultat :
+                {
+                  "1": {
+                    "id": 1,
+                    "etudid": 10,
+                    "evaluation_id": 1,
+                    "value": 15.0,
+                    "comment": "",
+                    "date": "Wed, 20 Apr 2022 06:49:05 GMT",
+                    "uid": 2
+                  },
+                  "2": {
+                    "id": 2,
+                    "etudid": 1,
+                    "evaluation_id": 1,
+                    "value": 12.0,
+                    "comment": "",
+                    "date": "Wed, 20 Apr 2022 06:49:06 GMT",
+                    "uid": 2
+                  },
+                  ...
+                }
     """
     # Fonction utilisée : app.scodoc.sco_evaluation_db.do_evaluation_get_all_notes()
 
+    eval = models.Evaluation.query.filter_by(id=evaluation_id).first_or_404()
+
+    moduleimpl = models.ModuleImpl.query.filter_by(id=eval.moduleimpl_id).first_or_404()
+
+    formsemestre = models.FormSemestre.query.filter_by(
+        id=moduleimpl.formsemestre_id
+    ).first_or_404()
+
+    dept = models.Departement.query.filter_by(id=formsemestre.dept_id).first_or_404()
+
+    app.set_sco_dept(dept.acronym)
+
     try:
         # Utilisation de la fonction do_evaluation_get_all_notes
         data = do_evaluation_get_all_notes(evaluation_id)
@@ -48,35 +109,3 @@ def evaluation_notes(evaluation_id: int):
         )
 
     return jsonify(data)
-
-
-@bp.route(
-    "/evaluations/eval_set_notes?eval_id=<int:eval_id>&etudid=<int:etudid>&note=<float:note>",
-    methods=["POST"],
-)
-@bp.route(
-    "/evaluations/eval_set_notes?eval_id=<int:eval_id>&nip=<int:nip>&note=<float:note>",
-    methods=["POST"],
-)
-@bp.route(
-    "/evaluations/eval_set_notes?eval_id=<int:eval_id>&ine=<int:ine>&note=<float:note>",
-    methods=["POST"],
-)
-@token_permission_required(Permission.APIEditAllNotes)
-def evaluation_set_notes(
-    eval_id: int, note: float, etudid: int = None, nip: int = None, ine: int = None
-):
-    """
-    Set les notes d'une évaluation pour un étudiant donnée
-
-    eval_id : l'id d'une évaluation
-    note : la note à attribuer
-    etudid : l'etudid d'un étudiant
-    nip : le code nip d'un étudiant
-    ine : le code ine d'un étudiant
-    """
-    # Fonction utilisée : app.scodoc.sco_saisie_notes.notes_add()
-
-    # Qu'est ce qu'un user ???
-    # notes_add()
-    return error_response(501, message="Not implemented")

app/api/formations.py

@@ -4,9 +4,8 @@ from flask import jsonify
 from app import models
 from app.api import bp
 from app.api.errors import error_response
-from app.api.auth import token_auth, token_permission_required
+from app.api.auth import token_permission_required
 from app.scodoc.sco_formations import formation_export
-from app.scodoc.sco_moduleimpl import moduleimpl_list
 from app.scodoc.sco_permissions import Permission
 
 
@@ -34,7 +33,7 @@ def formations_by_id(formation_id: int):
     formation_id : l'id d'une formation
     """
     # Récupération de la formation
-    forma = models.Formation.query.filter_by(id=formation_id).first()
+    forma = models.Formation.query.filter_by(id=formation_id).first_or_404()
 
     # Mise en forme des données
     data = [d.to_dict() for d in forma]
@@ -72,12 +71,14 @@ def formsemestre_apo(etape_apo: int):
     etape_apo : l'id d'une étape apogée
     """
     # Récupération des formsemestres
-    apos = models.FormSemestreEtape.query.filter_by(etape_apo=etape_apo).all()
+    apos = models.FormSemestreEtape.query.filter_by(etape_apo=etape_apo)
 
     data = []
     # Filtre les formsemestres correspondant + mise en forme des données
     for apo in apos:
-        formsem = models.FormSemestre.query.filter_by(id=apo["formsemestre_id"]).first()
+        formsem = models.FormSemestre.query.filter_by(
+            id=apo["formsemestre_id"]
+        ).first_or_404()
         data.append(formsem.to_dict())
 
     return jsonify(data)
@@ -93,37 +94,32 @@ def moduleimpls(moduleimpl_id: int):
     moduleimpl_id : l'id d'un moduleimpl
     """
     # Récupération des tous les moduleimpl
-    list_moduleimpls = models.ModuleImpl.query.filter_by(id=moduleimpl_id).all()
+    list_moduleimpls = models.ModuleImpl.query.filter_by(id=moduleimpl_id)
 
     # Mise en forme des données
-    data = list_moduleimpls[0].to_dict()
+    data = [moduleimpl.to_dict() for moduleimpl in list_moduleimpls]
 
     return jsonify(data)
 
 
 @bp.route(
-    "/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>",
+    "/formations/moduleimpl/formsemestre/<int:formsemestre_id>/liste",
     methods=["GET"],
-)
+)  # XXX TODO penser à changer la route sur la doc
 @token_permission_required(Permission.APIView)
-def moduleimpls_sem(moduleimpl_id: int, formsemestre_id: int):
+def moduleimpls_sem(formsemestre_id: int):
     """
     Retourne la liste des moduleimpl d'un semestre
 
     moduleimpl_id : l'id d'un moduleimpl
     formsemestre_id : l'id d'un formsemestre
     """
-    # Fonction utilisée : app.scodoc.sco_moduleimpl.moduleimpl_list()
+    formsemestre = models.FormSemestre.query.filter_by(
+        id=formsemestre_id
+    ).first_or_404()
 
-    # Utilisation de la fonction moduleimpl_list
-    data = moduleimpl_list(moduleimpl_id, formsemestre_id)
+    moduleimpls = formsemestre.modimpls_sorted
 
-    if len(data) == 0:
-        return error_response(
-            409,
-            message="La requête ne peut être traitée en l’état actuel. \n"
-            "Aucun moduleimpl ne correspond au 'moduleimpl_id' ou "
-            "'formsemestre_id' renseigné",
-        )
+    data = [moduleimpl.to_dict() for moduleimpl in moduleimpls]
 
     return jsonify(data)

app/api/remiser.py

@@ -0,0 +1,72 @@
+# @bp.route("/etudiants", methods=["GET"])
+# @token_permission_required(Permission.APIView)
+# def etudiants():
+#     """
+#     Retourne la liste de tous les étudiants
+#
+#     Exemple de résultat :
+#                 {
+#                 "civilite": "X",
+#                 "code_ine": null,
+#                 "code_nip": null,
+#                 "date_naissance": null,
+#                 "email": null,
+#                 "emailperso": null,
+#                 "etudid": 18,
+#                 "nom": "MOREL",
+#                 "prenom": "JACQUES"
+#               },
+#               {
+#                 "civilite": "X",
+#                 "code_ine": null,
+#                 "code_nip": null,
+#                 "date_naissance": null,
+#                 "email": null,
+#                 "emailperso": null,
+#                 "etudid": 19,
+#                 "nom": "FOURNIER",
+#                 "prenom": "ANNE"
+#               },
+#               ...
+#     """
+#     # Récupération de tous les étudiants
+#     etu = models.Identite.query.all()
+#
+#     # Mise en forme des données
+#     data = [d.to_dict_bul(include_urls=False) for d in etu]
+#
+#     return jsonify(data)
+
+
+
+
+# @bp.route(
+#     "/evaluations/eval_set_notes?eval_id=<int:eval_id>&etudid=<int:etudid>&note=<float:note>",
+#     methods=["POST"],
+# )
+# @bp.route(
+#     "/evaluations/eval_set_notes?eval_id=<int:eval_id>&nip=<int:nip>&note=<float:note>",
+#     methods=["POST"],
+# )
+# @bp.route(
+#     "/evaluations/eval_set_notes?eval_id=<int:eval_id>&ine=<int:ine>&note=<float:note>",
+#     methods=["POST"],
+# )
+# @token_permission_required(Permission.APIEditAllNotes)
+# def evaluation_set_notes(
+#     eval_id: int, note: float, etudid: int = None, nip: int = None, ine: int = None
+# ):
+#     """
+#     Set les notes d'une évaluation pour un étudiant donnée
+#
+#     eval_id : l'id d'une évaluation
+#     note : la note à attribuer
+#     etudid : l'etudid d'un étudiant
+#     nip : le code nip d'un étudiant
+#     ine : le code ine d'un étudiant
+#     """
+#     # Fonction utilisée : app.scodoc.sco_saisie_notes.notes_add()
+#
+#     # Qu'est ce qu'un user ???
+#     # notes_add()
+#     return error_response(501, message="Not implemented")

app/api/tools.py

@@ -13,10 +13,10 @@ def get_etu_from_request(etudid, nip, ine):
     """
     if etudid is None:
         if nip is None:  # si ine
-            etu = models.Identite.query.filter_by(code_ine=str(ine)).first()
+            etud = models.Identite.query.filter_by(code_ine=str(ine)).first()
         else:  # si nip
-            etu = models.Identite.query.filter_by(code_nip=str(nip)).first()
+            etud = models.Identite.query.filter_by(code_nip=str(nip)).first()
     else:  # si etudid
-        etu = models.Identite.query.filter_by(id=etudid).first()
+        etud = models.Identite.query.filter_by(id=etudid).first()
 
-    return etu
+    return etud