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_permission_required
+from app.api.auth import token_auth, 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)
+    depts = models.Departement.query.filter_by(visible=True).all()
 
     # 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_or_404()
+        formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
         # 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_or_404()
+        departement = models.Departement.query.filter_by(acronym=dept).first()
 
     # Récupération des étudiants
     etudiants = departement.etudiants.all()
@@ -129,12 +129,16 @@ def liste_semestres_courant(dept: str):
                 ]
     """
     # Récupération des départements comportant l'acronym mit en paramètre
-    dept = models.Departement.query.filter_by(acronym=dept).first_or_404()
+    depts = models.Departement.query.filter_by(acronym=dept).all()
+
+    # Récupération de l'id
+    id_dept = depts[0].id
 
     # Récupération des semestres suivant id_dept
-    semestres = models.FormSemestre.query.filter_by(dept_id=dept.id, etat=True)
+    semestres = models.FormSemestre.query.filter_by(dept_id=id_dept, etat=True).all()
 
     # Mise en forme des données
+
     data = [d.to_dict() for d in semestres]
 
     return jsonify(data)
@@ -152,13 +156,15 @@ def referenciel_competences(dept: str, formation_id: int):
     dept : l'acronym d'un département
     formation_id : l'id d'une formation
     """
-    dept = models.Departement.query.filter_by(acronym=dept).first_or_404()
+    depts = models.Departement.query.filter_by(acronym=dept).all()
 
-    formation = models.Formation.query.filter_by(
+    id_dept = depts[0].id
-        id=formation_id, dept_id=dept.id
-    ).first_or_404()
 
-    ref_comp = formation.referentiel_competence_id
+    formations = models.Formation.query.filter_by(
+        id=formation_id, dept_id=id_dept
+    ).all()
+
+    ref_comp = formations[0].referentiel_competence_id
 
     if ref_comp is None:
         return error_response(
@@ -167,6 +173,10 @@ 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",
@@ -180,7 +190,7 @@ def semestre_index(dept: str, formsemestre_id: int):
 
     app.set_sco_dept(dept)
 
-    formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
+    formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
 
     ues = formsemestre.query_ues()
 
@@ -208,3 +218,4 @@ 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_permission_required
+from app.api.auth import token_auth, token_permission_required
 from app.api.tools import get_etu_from_request
 from app.models import FormSemestreInscription, FormSemestre, Identite
-from app.scodoc import sco_bulletins
+from app.scodoc.sco_bulletins import get_formsemestre_bulletin_etud_json
-from app.scodoc import sco_groups
+from app.scodoc.sco_groups import get_etud_groups
 from app.scodoc.sco_permissions import Permission
 
 
@@ -46,14 +46,13 @@ def etudiants_courant():
               ...
     """
     # Récupération de tous les étudiants
-    etuds = Identite.query.filter(
+    etus = 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 etuds]
+    data = [etu.to_dict_bul(include_urls=False) for etu in etus]
 
     return jsonify(data)
 
@@ -98,7 +97,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 suivi, triés par ordre chronologique.
+    Retourne la liste des semestres qu'un étudiant a suivis
 
     etudid : l'etudid d'un étudiant
     nip : le code nip d'un étudiant
@@ -109,6 +108,7 @@ 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,14 +139,27 @@ def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None)
                 ]
     """
     # Récupération de l'étudiant
-    etud = get_etu_from_request(etudid, nip, ine)
+    etu = get_etu_from_request(etudid, nip, ine)
 
-    formsemestres = models.FormSemestre.query.filter(
+    # Récupération de toutes les inscriptions de l'étudiant
-        models.FormSemestreInscription.etudid == etud.id,
+    formsemestres_inscriptions = models.FormSemestreInscription.query.filter_by(
-        models.FormSemestreInscription.formsemestre_id == models.FormSemestre.id,
+        etud=etu
-    ).order_by(models.FormSemestre.date_debut)
+    ).all()
 
-    return jsonify([formsemestre.to_dict() for formsemestre in formsemestres])
+    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)
 
 
 @bp.route(
@@ -175,9 +188,7 @@ def etudiant_bulletin_semestre(
     """
     # Fonction utilisée : app.scodoc.sco_bulletins_json.make_json_formsemestre_bulletinetud()
 
-    formsemestre = models.FormSemestre.query.filter_by(
+    formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
-        id=formsemestre_id
-    ).first_or_404()
 
     dept = models.Departement.query.filter_by(id=formsemestre.dept_id).first_or_404()
 
@@ -190,10 +201,10 @@ def etudiant_bulletin_semestre(
         return error_response(
             409,
             message="La requête ne peut être traitée en l’état actuel.\n "
-            "Veuillez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
+            "Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
         )
 
-    return sco_bulletins.get_formsemestre_bulletin_etud_json(formsemestre, etu)
+    return get_formsemestre_bulletin_etud_json(formsemestre, etu)
 
 
 @bp.route(
@@ -244,6 +255,8 @@ def etudiant_groups(
                   }
                 ]
     """
+    # Fonction utilisée : app.scodoc.sco_groups.get_etud_groups()
+
     if etudid is None:
         # Récupération de l'étudiant
         try:
@@ -253,18 +266,19 @@ def etudiant_groups(
             return error_response(
                 409,
                 message="La requête ne peut être traitée en l’état actuel.\n "
-                "Veuillez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
+                "Veilliez 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:
-        data = sco_groups.get_etud_groups(etudid, sem.id)
+        # Utilisation de la fonction get_etud_groups
+        data = 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 "
-            "Veuillez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide"
+            "Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide"
             " et le formsemestre_id sont valides",
         )
 

app/api/evaluations.py

@@ -1,8 +1,6 @@
 ############################################### Evaluations ###########################################################
 from flask import jsonify
 
-import app
-
 from app import models
 from app.api import bp
 from app.api.auth import token_permission_required
@@ -18,39 +16,15 @@ 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)
+    evals = models.Evaluation.query.filter_by(id=moduleimpl_id).all()
 
     # 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"])
@@ -60,44 +34,9 @@ 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)
@@ -109,3 +48,35 @@ 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,8 +4,9 @@ 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_permission_required
+from app.api.auth import token_auth, 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
 
 
@@ -33,7 +34,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_or_404()
+    forma = models.Formation.query.filter_by(id=formation_id).first()
 
     # Mise en forme des données
     data = [d.to_dict() for d in forma]
@@ -71,14 +72,12 @@ 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)
+    apos = models.FormSemestreEtape.query.filter_by(etape_apo=etape_apo).all()
 
     data = []
     # Filtre les formsemestres correspondant + mise en forme des données
     for apo in apos:
-        formsem = models.FormSemestre.query.filter_by(
+        formsem = models.FormSemestre.query.filter_by(id=apo["formsemestre_id"]).first()
-            id=apo["formsemestre_id"]
-        ).first_or_404()
         data.append(formsem.to_dict())
 
     return jsonify(data)
@@ -94,32 +93,37 @@ 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)
+    list_moduleimpls = models.ModuleImpl.query.filter_by(id=moduleimpl_id).all()
 
     # Mise en forme des données
-    data = [moduleimpl.to_dict() for moduleimpl in list_moduleimpls]
+    data = list_moduleimpls[0].to_dict()
 
     return jsonify(data)
 
 
 @bp.route(
-    "/formations/moduleimpl/formsemestre/<int:formsemestre_id>/liste",
+    "/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>",
     methods=["GET"],
-)  # XXX TODO penser à changer la route sur la doc
+)
 @token_permission_required(Permission.APIView)
-def moduleimpls_sem(formsemestre_id: int):
+def moduleimpls_sem(moduleimpl_id: int, 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
     """
-    formsemestre = models.FormSemestre.query.filter_by(
+    # Fonction utilisée : app.scodoc.sco_moduleimpl.moduleimpl_list()
-        id=formsemestre_id
-    ).first_or_404()
 
-    moduleimpls = formsemestre.modimpls_sorted
+    # Utilisation de la fonction moduleimpl_list
+    data = moduleimpl_list(moduleimpl_id, formsemestre_id)
 
-    data = [moduleimpl.to_dict() for moduleimpl in moduleimpls]
+    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é",
+        )
 
     return jsonify(data)

app/api/remiser.py

@@ -1,72 +0,0 @@
-# @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
-            etud = models.Identite.query.filter_by(code_ine=str(ine)).first()
+            etu = models.Identite.query.filter_by(code_ine=str(ine)).first()
         else:  # si nip
-            etud = models.Identite.query.filter_by(code_nip=str(nip)).first()
+            etu = models.Identite.query.filter_by(code_nip=str(nip)).first()
     else:  # si etudid
-        etud = models.Identite.query.filter_by(id=etudid).first()
+        etu = models.Identite.query.filter_by(id=etudid).first()
 
-    return etud
+    return etu