prise en compte des remarques du 21/04/2022

app/api/absences.py

@@ -5,11 +5,16 @@ from flask import jsonify
 
 from app import models
 from app.api import bp
-from app.api.auth import token_auth
 from app.api.errors import error_response
-from app.decorators import permission_required
+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.scodoc.sco_abs import add_absence, add_justif, annule_absence, annule_justif, list_abs_date
+from app.scodoc.sco_abs import (
+    add_absence,
+    add_justif,
+    annule_absence,
+    annule_justif,
+    list_abs_date,
+)
 from app.scodoc.sco_groups import get_group_members
 from app.scodoc.sco_permissions import Permission
 
@@ -17,7 +22,6 @@ from app.scodoc.sco_permissions import Permission
 @bp.route("/absences/etudid/<int:etudid>", methods=["GET"])
 @bp.route("/absences/nip/<int:nip>", methods=["GET"])
 @bp.route("/absences/ine/<int:ine>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def absences(etudid: int = None, nip: int = None, ine: int = None):
     """
@@ -27,35 +31,34 @@ def absences(etudid: int = None, nip: int = None, ine: int = None):
     nip: le code nip d'un étudiant
     ine : le code ine d'un étudiant
     """
-    abs = None
+    if etudid is None:
-    if etudid is not None: # Si route etudid
+        # Récupération de l'étudiant
+        try:
+            etu = get_etu_from_request(etudid, nip, ine)
+            etudid = etu.etudid
+        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",
+            )
+
     # Récupération des absences de l'étudiant
     abs = models.Absence.query.filter_by(etudid=etudid).all()
-    else:
-        if nip is not None: # Si route nip
-            # Récupération de l'étudiant
-            etu = models.Identite.query.filter_by(code_nip=nip).first()
-            # Récupération des absences de l'étudiant
-            abs = models.Absence.query.filter_by(etudid=etu.etudid).all()
 
-        if ine is not None: # Si route ine
+    # Si l'étudiant a au minimum une absence
-            # Récupération de l'étudiant
+    if len(abs) > 0:
-            etu = models.Identite.query.filter_by(code_ine=ine).first()
-            # Récupération des absences de l'étudiant
-            abs = models.Absence.query.filter_by(etudid=etu.etudid).all()
-
-    if abs is not None: # Si des absences ont bien été trouvé
         # Mise en forme des données
         data = [d.to_dict() for d in abs]
 
         return jsonify(data)
-    return error_response(501, message="Not implemented")
+
+    return error_response(200, message="Aucune absence trouvé pour cet étudiant")
 
 
 @bp.route("/absences/etudid/<int:etudid>/abs_just_only", methods=["GET"])
 @bp.route("/absences/nip/<int:nip>/abs_just_only", methods=["GET"])
 @bp.route("/absences/ine/<int:ine>/abs_just_only", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def absences_justify(etudid: int = None, nip: int = None, ine: int = None):
     """
@@ -65,43 +68,65 @@ def absences_justify(etudid: int = None, nip: int = None, ine: int = None):
     nip: le code nip d'un étudiant
     ine : le code ine d'un étudiant
     """
-    abs = None
+    if etudid is None:
-    if etudid is not None: # Si route etudid
+        # Récupération de l'étudiant
+        try:
+            etu = get_etu_from_request(etudid, nip, ine)
+            etudid = etu.etudid
+        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",
+            )
+
     # Récupération des absences justifiées de l'étudiant
     abs = models.Absence.query.filter_by(etudid=etudid, estjust=True).all()
-    else:
-        if nip is not None: # Si route nip
-            # Récupération de l'étudiant
-            etu = models.Identite.query.filter_by(code_nip=nip).first()
-            # Récupération des absences justifiées de l'étudiant
-            abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all()
 
-        if ine is not None: # Si route ine
+    # Si l'étudiant a au minimum une absence justifiées
-            # Récupération de l'étudiant
+    if len(abs) > 0:
-            etu = models.Identite.query.filter_by(code_ine=ine).first()
-            # Récupération des absences justifiées de l'étudiant
-            abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all()
-
-    if abs is not None: # Si des absences ont bien été trouvé
         # Mise en forme des données
         data = [d.to_dict() for d in abs]
 
         return jsonify(data)
-    return error_response(501, message="Not implemented")
+
+    return error_response(
+        200, message="Aucune absence justifié trouvé pour cet étudiant"
+    )
 
 
-@bp.route("/absences/abs_signale?etudid=<int:etudid>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
+### Inutil en définitif ###
-          "&description=<string:description>", methods=["POST"])
+@bp.route(
-@bp.route("/absences/abs_signale?nip=<int:nip>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
+    "/absences/abs_signale?etudid=<int:etudid>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
-          "&description=<string:description>", methods=["POST"])
+    "&description=<string:description>",
-@bp.route("/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
+    methods=["POST"],
-          "&description=<string:description>", methods=["POST"])
+)
-@bp.route("/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
+@bp.route(
-          "&description=<string:description>&moduleimpl_id=<int:moduleimpl_id>", methods=["POST"])
+    "/absences/abs_signale?nip=<int:nip>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
-@token_auth.login_required
+    "&description=<string:description>",
+    methods=["POST"],
+)
+@bp.route(
+    "/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
+    "&description=<string:description>",
+    methods=["POST"],
+)
+@bp.route(
+    "/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
+    "&description=<string:description>&moduleimpl_id=<int:moduleimpl_id>",
+    methods=["POST"],
+)
 @token_permission_required(Permission.APIAbsChange)
-def abs_signale(date: datetime, matin: bool, justif: bool, etudid: int = None, nip: int = None, ine: int = None,
+def abs_signale(
-                description: str = None, moduleimpl_id: int = None):
+    date: datetime,
+    matin: bool,
+    justif: bool,
+    etudid: int = None,
+    nip: int = None,
+    ine: int = None,  ### Inutil en définitif
+    description: str = None,
+    moduleimpl_id: int = None,
+):
     """
     Permet d'ajouter une absence en base
 
@@ -116,114 +141,45 @@ def abs_signale(date: datetime, matin: bool, justif: bool, etudid: int = None, n
     """
     # Fonctions utilisées : app.scodoc.sco_abs.add_absence() et app.scodoc.sco_abs.add_justif()
 
-    if description is not None: # Si la description a été renseignée
+    if etudid is None:
-        if moduleimpl_id is not None: # Si le moduleimpl a été renseigné
+        # Récupération de l'étudiant
-            if etudid is not None: # Si route etudid
+        try:
+            etu = get_etu_from_request(etudid, nip, ine)
+            etudid = etu.etudid
+        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",
+            )
     try:
         # Utilisation de la fonction add_absence
         add_absence(etudid, date, matin, justif, description, moduleimpl_id)
+        if justif == True:
             # Utilisation de la fonction add_justif
             add_justif(etudid, date, matin, description)
     except ValueError:
-                    return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+        return error_response(
-
+            409, message="La requête ne peut être traitée en l’état actuel"
-            if nip is not None: # Si route nip
+        )
-                # Récupération de l'étudiant
-                etu = models.Identite.query.filter_by(code_nip=nip).first()
-                try:
-                    # Utilisation de la fonction add_absence
-                    add_absence(etu.etudid, date, matin, justif, description, moduleimpl_id)
-                    # Utilisation de la fonction add_justif
-                    add_justif(etu.etudid, date, matin, description)
-                except ValueError:
-                    return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-
-            if ine is not None: # Si route ine
-                # Récupération de l'étudiant
-                etu = models.Identite.query.filter_by(code_ine=ine).first()
-                try:
-                    # Utilisation de la fonction add_absence
-                    add_absence(etu.etudid, date, matin, justif, description, moduleimpl_id)
-                    # Utilisation de la fonction add_justif
-                    add_justif(etu.etudid, date, matin, description)
-                except ValueError:
-                    return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-
-            return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-
-        else: # Si le moduleimpl n'a pas été renseigné
-            if etudid is not None: # Si route etudid
-                try:
-                    # Utilisation de la fonction add_absence
-                    add_absence(etudid, date, matin, justif, description)
-                    # Utilisation de la fonction add_justif
-                    add_justif(etudid, date, matin, description)
-                except ValueError:
-                    return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-
-            if nip is not None: # Si route nip
-                # Récupération de l'étudiant
-                etu = models.Identite.query.filter_by(code_nip=nip).first()
-                try:
-                    # Utilisation de la fonction add_absence
-                    add_absence(etu.etudid, date, matin, justif, description)
-                    # Utilisation de la fonction add_justif
-                    add_justif(etu.etudid, date, matin, description)
-                except ValueError:
-                    return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-
-            if ine is not None: # Si route ine
-                # Récupération de l'étudiant
-                etu = models.Identite.query.filter_by(code_ine=ine).first()
-                try:
-                    # Utilisation de la fonction add_absence
-                    add_absence(etu.etudid, date, matin, justif, description)
-                    # Utilisation de la fonction add_justif
-                    add_justif(etu.etudid, date, matin, description)
-                except ValueError:
-                    return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-            return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-    else:
-        if etudid is not None: # Si route etudid
-            try:
-                # Utilisation de la fonction add_absence
-                add_absence(etudid, date, matin, justif)
-                # Utilisation de la fonction add_justif
-                add_justif(etudid, date, matin)
-            except ValueError:
-                return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-
-        if nip is not None: # Si route nip
-            # Récupération de l'étudiant
-            etu = models.Identite.query.filter_by(code_nip=nip).first()
-            try:
-                # Utilisation de la fonction add_absence
-                add_absence(etu.etudid, date, matin, justif)
-                # Utilisation de la fonction add_justif
-                add_justif(etu.etudid, date, matin)
-            except ValueError:
-                return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-
-        if ine is not None: # Si route ine
-            # Récupération de l'étudiant
-            etu = models.Identite.query.filter_by(code_ine=ine).first()
-            try:
-                # Utilisation de la fonction add_absence
-                add_absence(etu.etudid, date, matin, justif)
-                # Utilisation de la fonction add_justif
-                add_justif(etu.etudid, date, matin)
-            except ValueError:
-                return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-
-    return error_response(200, message="OK")
 
 
-@bp.route("/absences/abs_annule?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
+@bp.route(
-@bp.route("/absences/abs_annule?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
+    "/absences/abs_annule?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>",
-@bp.route("/absences/abs_annule?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
+    methods=["POST"],
-@token_auth.login_required
+)
+@bp.route(
+    "/absences/abs_annule?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>",
+    methods=["POST"],
+)
+@bp.route(
+    "/absences/abs_annule?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>",
+    methods=["POST"],
+)
 @token_permission_required(Permission.APIAbsChange)
-def abs_annule(jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None):
+def abs_annule(
+    jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None
+):
     """
     Retourne un html
 
@@ -236,32 +192,46 @@ def abs_annule(jour: datetime, matin: str, etudid: int = None, nip: int = None,
     # Fonction utilisée : app.scodoc.sco_abs.annule_absence()
 
     if etudid is None:
-        if nip is not None: # Si route nip
         # Récupération de l'étudiant
-            etu = models.Identite.query.filter_by(code_nip=nip).first()
+        try:
-            # Récupération de l'etudid de l'étudiant
+            etu = get_etu_from_request(etudid, nip, ine)
             etudid = etu.etudid
+        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",
+            )
 
-        if ine is not None: # Si route ine
-            # Récupération de l'étudiant
-            etu = models.Identite.query.filter_by(code_ine=ine).first()
-            # Récupération de l'etudid de l'étudiant
-            etudid = etu.etudid
     try:
         # Utilisation de la fonction annule_absence
         annule_absence(etudid, jour, matin)
-    except ValueError:
+    except AttributeError:
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+        return error_response(
+            409,
+            message="La requête ne peut être traitée en l’état actuel.\n "
+            "Veilliez vérifier que le 'jour' et le 'matin' sont valides",
+        )
 
     return error_response(200, message="OK")
 
 
-@bp.route("/absences/abs_annule_justif?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
+@bp.route(
-@bp.route("/absences/abs_annule_justif?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
+    "/absences/abs_annule_justif?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>",
-@bp.route("/absences/abs_annule_justif?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
+    methods=["POST"],
-@token_auth.login_required
+)
+@bp.route(
+    "/absences/abs_annule_justif?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>",
+    methods=["POST"],
+)
+@bp.route(
+    "/absences/abs_annule_justif?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>",
+    methods=["POST"],
+)
 @token_permission_required(Permission.APIAbsChange)
-def abs_annule_justif(jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None):
+def abs_annule_justif(
+    jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None
+):
     """
     Retourne un html
 
@@ -274,30 +244,37 @@ def abs_annule_justif(jour: datetime, matin: str, etudid: int = None, nip: int =
     # Fonction utilisée : app.scodoc.sco_abs.annule_justif()
 
     if etudid is None:
-        if nip is not None: # Si route nip
         # Récupération de l'étudiant
-            etu = models.Identite.query.filter_by(code_nip=nip).first()
+        try:
-            # Récupération de l'etudid de l'étudiant
+            etu = get_etu_from_request(etudid, nip, ine)
-            etudid = etu.etudid
-
-        if ine is not None: # Si route ine
-            # Récupération de l'étudiant
-            etu = models.Identite.query.filter_by(code_ine=ine).first()
-            # Récupération de l'etudid de l'étudiant
             etudid = etu.etudid
+        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",
+            )
     try:
         # Utilisation de la fonction annule_justif
         annule_justif(etudid, jour, matin)
     except ValueError:
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+        return error_response(
+            409,
+            message="La requête ne peut être traitée en l’état actuel.\n "
+            "Veilliez vérifier que le 'jour' et le 'matin' sont valides",
+        )
 
     return error_response(200, message="OK")
 
 
-@bp.route("/absences/abs_group_etat/?group_id=<int:group_id>&date_debut=date_debut&date_fin=date_fin", methods=["GET"])
+@bp.route(
-@token_auth.login_required
+    "/absences/abs_group_etat/?group_id=<int:group_id>&date_debut=date_debut&date_fin=date_fin",
+    methods=["GET"],
+)
 @token_permission_required(Permission.APIView)
-def abs_groupe_etat(group_id: int, date_debut, date_fin, with_boursier=True, format="html"):
+def abs_groupe_etat(
+    group_id: int, date_debut, date_fin, with_boursier=True, format="html"
+):
     """
     Retoune la liste des absences d'un ou plusieurs groupes entre deux dates
     """
@@ -307,7 +284,9 @@ def abs_groupe_etat(group_id: int, date_debut, date_fin, with_boursier=True, for
         # Utilisation de la fonction get_group_members
         members = get_group_members(group_id)
     except ValueError:
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+        return error_response(
+            409, message="La requête ne peut être traitée en l’état actuel"
+        )
 
     data = []
     # Filtre entre les deux dates renseignées

app/api/departements.py

@@ -1,6 +1,5 @@
 ############################################### Departements ##########################################################
 import app
-from flask import jsonify
 
 from app import models
 from app.api import bp
@@ -8,9 +7,10 @@ from app.api.auth import token_auth, token_permission_required
 from app.api.errors import error_response
 from app.scodoc.sco_permissions import Permission
 
+from flask import jsonify
+
 
 @bp.route("/departements", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def departements():
     """
@@ -31,7 +31,6 @@ def departements():
 @bp.route(
     "/departements/<string:dept>/etudiants/liste/<int:formsemestre_id>", methods=["GET"]
 )
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def liste_etudiants(dept: str, formsemestre_id=None):
     """
@@ -87,7 +86,6 @@ def liste_etudiants(dept: str, formsemestre_id=None):
 
 
 @bp.route("/departements/<string:dept>/semestres_courants", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def liste_semestres_courant(dept: str):
     """
@@ -150,7 +148,6 @@ def liste_semestres_courant(dept: str):
     "/departements/<string:dept>/formations/<int:formation_id>/referentiel_competences",
     methods=["GET"],
 )
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def referenciel_competences(dept: str, formation_id: int):
     """
@@ -185,7 +182,6 @@ def referenciel_competences(dept: str, formation_id: int):
     "/departements/<string:dept>/formsemestre/<string:formsemestre_id>/programme",
     methods=["GET"],
 )
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def semestre_index(dept: str, formsemestre_id: int):
     """
@@ -222,4 +218,4 @@ def semestre_index(dept: str, formsemestre_id: int):
     }
 
     return data
-    #return error_response(501, message="not implemented")
+    # return error_response(501, message="not implemented")

app/api/etudiants.py

@@ -13,9 +13,7 @@ from app.scodoc.sco_groups import get_etud_groups
 from app.scodoc.sco_permissions import Permission
 
 
-
 @bp.route("/etudiants", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def etudiants():
     """
@@ -56,7 +54,6 @@ def etudiants():
 
 
 @bp.route("/etudiants/courant", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def etudiants_courant():
     """
@@ -102,7 +99,6 @@ def etudiants_courant():
 @bp.route("/etudiant/etudid/<int:etudid>", methods=["GET"])
 @bp.route("/etudiant/nip/<int:nip>", methods=["GET"])
 @bp.route("/etudiant/ine/<int:ine>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def etudiant(etudid: int = None, nip: int = None, ine: int = None):
     """
@@ -137,7 +133,6 @@ def etudiant(etudid: int = None, nip: int = None, ine: int = None):
 @bp.route("/etudiant/etudid/<int:etudid>/formsemestres")
 @bp.route("/etudiant/nip/<int:nip>/formsemestres")
 @bp.route("/etudiant/ine/<int:ine>/formsemestres")
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None):
     """
@@ -182,39 +177,46 @@ def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None)
                   ...
                 ]
     """
-    # Récupération de toutes les inscriptions
-    inscriptions = models.FormSemestreInscription.query.all()
-
     # Récupération de l'étudiant
     etu = get_etu_from_request(etudid, nip, ine)
 
-    sems = []
+    # Récupération de toutes les inscriptions de l'étudiant
-    # Filtre les inscriptions contenant l'étudiant
+    formsemestres_inscriptions = models.FormSemestreInscription.query.filter_by(
-    for sem in inscriptions:
+        etud=etu
-        if sem.etudid == etu.etudid:
+    ).all()
-            sems.append(sem)
 
     formsemestres = []
-
+    # Récupération des formsemestres contenant les inscriptions de l'étudiant
-    # Filtre les formsemestre contenant les inscriptions de l'étudiant
+    for formsemestre_inscription in formsemestres_inscriptions:
-    for sem in sems: #data_inscriptions:
+        res = models.FormSemestre.query.filter_by(
-        res = models.FormSemestre.query.filter_by(id=sem.formsemestre_id).first()
+            id=formsemestre_inscription.formsemestre_id
+        ).first()
         formsemestres.append(res)
 
     data = []
     # Mise en forme des données
-    for formsem in formsemestres:
+    for formsemestre in formsemestres:
-        data.append(formsem.to_dict())
+        data.append(formsemestre.to_dict())
 
     return jsonify(data)
 
 
-@bp.route("/etudiant/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"])
+@bp.route(
-@bp.route("/etudiant/nip/<int:nip>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"])
+    "/etudiant/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/bulletin",
-@bp.route("/etudiant/ine/<int:ine>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"])
+    methods=["GET"],
-@token_auth.login_required
+)
+@bp.route(
+    "/etudiant/nip/<int:nip>/formsemestre/<int:formsemestre_id>/bulletin",
+    methods=["GET"],
+)
+@bp.route(
+    "/etudiant/ine/<int:ine>/formsemestre/<int:formsemestre_id>/bulletin",
+    methods=["GET"],
+)
 @token_permission_required(Permission.APIView)
-def etudiant_bulletin_semestre(formsemestre_id, etudid: int = None, nip: int = None, ine: int = None):
+def etudiant_bulletin_semestre(
+    formsemestre_id, etudid: int = None, nip: int = None, ine: int = None
+):
     """
     Retourne le bulletin d'un étudiant en fonction de son id et d'un semestre donné
 
@@ -233,18 +235,33 @@ def etudiant_bulletin_semestre(formsemestre_id, etudid: int = None, nip: int = N
 
     if etudid is None:
         # Récupération de l'étudiant
+        try:
             etu = get_etu_from_request(etudid, nip, ine)
             etudid = etu.etudid
+        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",
+            )
 
     return make_json_formsemestre_bulletinetud(formsemestre_id, etudid)
 
 
-@bp.route("/etudiant/etudid/<int:etudid>/semestre/<int:formsemestre_id>/groups", methods=["GET"])
+@bp.route(
-@bp.route("/etudiant/nip/<int:nip>/semestre/<int:formsemestre_id>/groups", methods=["GET"])
+    "/etudiant/etudid/<int:etudid>/semestre/<int:formsemestre_id>/groups",
-@bp.route("/etudiant/ine/<int:ine>/semestre/<int:formsemestre_id>/groups", methods=["GET"])
+    methods=["GET"],
-@token_auth.login_required
+)
+@bp.route(
+    "/etudiant/nip/<int:nip>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
+)
+@bp.route(
+    "/etudiant/ine/<int:ine>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
+)
 @token_permission_required(Permission.APIView)
-def etudiant_groups(formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None):
+def etudiant_groups(
+    formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None
+):
     """
     Retourne la liste des groupes auxquels appartient l'étudiant dans le semestre indiqué
 
@@ -283,16 +300,27 @@ def etudiant_groups(formsemestre_id: int, etudid: int = None, nip: int = None, i
 
     if etudid is None:
         # Récupération de l'étudiant
+        try:
             etu = get_etu_from_request(etudid, nip, ine)
             etudid = etu.etudid
+        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",
+            )
 
     # Récupération du formsemestre
     sem = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
-    #breakpoint()
     try:
         # Utilisation de la fonction get_etud_groups
         data = get_etud_groups(etudid, sem.id)
-    except ValueError:
+    except AttributeError:
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+        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"
+            " et le formsemestre_id sont valides",
+        )
 
     return jsonify(data)

app/api/evaluations.py

@@ -3,14 +3,13 @@ from flask import jsonify
 
 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_evaluation_db import do_evaluation_get_all_notes
 from app.scodoc.sco_permissions import Permission
 
 
 @bp.route("/evaluations/<int:moduleimpl_id>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def evaluations(moduleimpl_id: int):
     """
@@ -29,7 +28,6 @@ def evaluations(moduleimpl_id: int):
 
 
 @bp.route("/evaluations/eval_notes/<int:evaluation_id>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def evaluation_notes(evaluation_id: int):
     """
@@ -42,18 +40,32 @@ def evaluation_notes(evaluation_id: int):
     try:
         # Utilisation de la fonction do_evaluation_get_all_notes
         data = do_evaluation_get_all_notes(evaluation_id)
-    except ValueError:
+    except AttributeError:
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+        return error_response(
+            409,
+            message="La requête ne peut être traitée en l’état actuel. \n"
+            "Veillez vérifier la conformité du 'evaluation_id'",
+        )
 
     return jsonify(data)
 
 
-@bp.route("/evaluations/eval_set_notes?eval_id=<int:eval_id>&etudid=<int:etudid>&note=<float:note>", methods=["POST"])
+@bp.route(
-@bp.route("/evaluations/eval_set_notes?eval_id=<int:eval_id>&nip=<int:nip>&note=<float:note>", methods=["POST"])
+    "/evaluations/eval_set_notes?eval_id=<int:eval_id>&etudid=<int:etudid>&note=<float:note>",
-@bp.route("/evaluations/eval_set_notes?eval_id=<int:eval_id>&ine=<int:ine>&note=<float:note>", methods=["POST"])
+    methods=["POST"],
-@token_auth.login_required
+)
+@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):
+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
 

app/api/formations.py

@@ -5,14 +5,12 @@ 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.decorators import 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
 
 
 @bp.route("/formations", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def formations():
     """
@@ -28,7 +26,6 @@ def formations():
 
 
 @bp.route("/formations/<int:formation_id>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def formations_by_id(formation_id: int):
     """
@@ -46,7 +43,6 @@ def formations_by_id(formation_id: int):
 
 
 @bp.route("/formations/formation_export/<int:formation_id>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def formation_export_by_formation_id(formation_id: int, export_ids=False):
     """
@@ -58,13 +54,16 @@ def formation_export_by_formation_id(formation_id: int, export_ids=False):
         # Utilisation de la fonction formation_export
         data = formation_export(formation_id)
     except ValueError:
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+        return error_response(
+            409,
+            message="La requête ne peut être traitée en l’état actuel. \n"
+            "Veillez vérifier la conformité du 'formation_id'",
+        )
 
     return jsonify(data)
 
 
 @bp.route("/formations/apo/<string:etape_apo>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def formsemestre_apo(etape_apo: int):
     """
@@ -86,7 +85,6 @@ def formsemestre_apo(etape_apo: int):
 
 
 @bp.route("/formations/moduleimpl/<int:moduleimpl_id>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def moduleimpls(moduleimpl_id: int):
     """
@@ -103,8 +101,10 @@ def moduleimpls(moduleimpl_id: int):
     return jsonify(data)
 
 
-@bp.route("/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>", methods=["GET"])
+@bp.route(
-@token_auth.login_required
+    "/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>",
+    methods=["GET"],
+)
 @token_permission_required(Permission.APIView)
 def moduleimpls_sem(moduleimpl_id: int, formsemestre_id: int):
     """
@@ -115,10 +115,15 @@ def moduleimpls_sem(moduleimpl_id: int, formsemestre_id: int):
     """
     # Fonction utilisée : app.scodoc.sco_moduleimpl.moduleimpl_list()
 
-    try:
     # Utilisation de la fonction moduleimpl_list
     data = moduleimpl_list(moduleimpl_id, formsemestre_id)
-    except ValueError:
+
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+    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/formsemestres.py

@@ -10,11 +10,13 @@ from app.api.tools import get_etu_from_request
 from app.scodoc.sco_bulletins_json import make_json_formsemestre_bulletinetud
 from app.scodoc.sco_permissions import Permission
 from app.scodoc.sco_pvjury import formsemestre_pvjury
-from app.scodoc.sco_recapcomplet import formsemestre_recapcomplet
+from app.scodoc.sco_recapcomplet import (
+    formsemestre_recapcomplet,
+    gen_formsemestre_recapcomplet_json,
+)
 
 
 @bp.route("/formations/formsemestre/<int:formsemestre_id>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def formsemestre(formsemestre_id: int):
     """
@@ -44,9 +46,15 @@ def formsemestre(formsemestre_id: int):
     "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/ine/<int:ine>/bulletin",
     methods=["GET"],
 )
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
-def etudiant_bulletin(formsemestre_id, dept, format="json", etudid: int = None, nip: int = None, ine: int = None, ):#*args, size
+def etudiant_bulletin(
+    formsemestre_id,
+    dept,
+    format="json",
+    etudid: int = None,
+    nip: int = None,
+    ine: int = None,
+):  # *args, size
     """
     Retourne le bulletin de note d'un étudiant
 
@@ -59,18 +67,30 @@ def etudiant_bulletin(formsemestre_id, dept, format="json", etudid: int = None,
 
     # make_json_formsemestre_bulletinetud
 
+    try:
         app.set_sco_dept(dept)
-
+    except:
+        return error_response(
+            409,
+            message="La requête ne peut être traitée en l’état actuel.\n "
+            "Veilliez vérifier que le nom de département est valide",
+        )
     if etudid is None:
         # Récupération de l'étudiant
+        try:
             etu = get_etu_from_request(etudid, nip, ine)
             etudid = etu.etudid
+        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",
+            )
 
     data = make_json_formsemestre_bulletinetud(formsemestre_id, etudid)
 
     return data
 
-
     # if args[0] == "short":
     #     data = formsemestre_bulletinetud_dict(formsemestre_id, etudid, version=args[0])
     # elif args[0] == "selectevals":
@@ -83,8 +103,9 @@ def etudiant_bulletin(formsemestre_id, dept, format="json", etudid: int = None,
     # return jsonify(data)
 
 
-@bp.route("/formsemestre/<int:formsemestre_id>/bulletins", methods=["GET"])
+@bp.route(
-@token_auth.login_required
+    "/formsemestre/<int:formsemestre_id>/bulletins", methods=["GET"]
+)  # XXX TODO à revoir
 @token_permission_required(Permission.APIView)
 def bulletins(formsemestre_id: int):
     """
@@ -93,18 +114,23 @@ def bulletins(formsemestre_id: int):
     formsemestre_id : l'id d'un formesemestre
     """
     # Fonction utilisée : app.scodoc.sco_recapcomplet.formsemestre_recapcomplet()
+    # gen_formsemestre_recapcomplet_json ??
 
     try:
         # Utilisation de la fonction formsemestre_recapcomplet
-        data = formsemestre_recapcomplet(formsemestre_id)
+        # data = formsemestre_recapcomplet(formsemestre_id)
-    except ValueError:
+        data = gen_formsemestre_recapcomplet_json(formsemestre_id)
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+    except AttributeError:
+        return error_response(
+            409,
+            message="La requête ne peut être traitée en l’état actuel. \n"
+            "Veillez vérifier la conformité du 'formation_id'",
+        )
 
     return jsonify(data)
 
 
 @bp.route("/formsemestre/<int:formsemestre_id>/jury", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def jury(formsemestre_id: int):
     """
@@ -117,7 +143,11 @@ def jury(formsemestre_id: int):
     try:
         # Utilisation de la fonction formsemestre_pvjury
         data = formsemestre_pvjury(formsemestre_id)
-    except ValueError:
+    except AttributeError:
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+        return error_response(
+            409,
+            message="La requête ne peut être traitée en l’état actuel. \n"
+            "Veillez vérifier la conformité du 'formation_id'",
+        )
 
     return jsonify(data)

app/api/jury.py

@@ -4,13 +4,14 @@ 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_prepajury import feuille_preparation_jury
 from app.scodoc.sco_pvjury import formsemestre_pvjury
 
 
 @bp.route("/jury/formsemestre/<int:formsemestre_id>/preparation_jury", methods=["GET"])
-def jury_preparation(formsemestre_id: int): # XXX TODO check à quoi resemble le retour de la fonction
+# @token_permission_required(Permission.)
+def jury_preparation(formsemestre_id: int):
     """
     Retourne la feuille de préparation du jury
 
@@ -25,7 +26,8 @@ def jury_preparation(formsemestre_id: int): # XXX TODO check à quoi resemble le
 
 
 @bp.route("/jury/formsemestre/<int:formsemestre_id>/decisions_jury", methods=["GET"])
-def jury_decisions(formsemestre_id: int): # XXX TODO check à quoi resemble le retour de la fonction
+# @token_permission_required(Permission.)
+def jury_decisions(formsemestre_id: int):
     """
     Retourne les décisions du jury suivant un formsemestre donné
 
@@ -39,14 +41,31 @@ def jury_decisions(formsemestre_id: int): # XXX TODO check à quoi resemble le r
     return error_response(501, message="Not implemented")
 
 
-@bp.route("/jury/set_decision/etudid?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
+@bp.route(
-          "&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>", methods=["POST"])
+    "/jury/set_decision/etudid?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
-@bp.route("/jury/set_decision/nip?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
+    "&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>",
-          "&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>", methods=["POST"])
+    methods=["POST"],
-@bp.route("/jury/set_decision/ine?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
+)
-          "&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>", methods=["POST"])
+@bp.route(
-def set_decision_jury(formsemestre_id: int, decision_jury: str, devenir_jury: str, assiduite: bool,
+    "/jury/set_decision/nip?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
-                      etudid: int = None, nip: int = None, ine: int = None):
+    "&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>",
+    methods=["POST"],
+)
+@bp.route(
+    "/jury/set_decision/ine?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
+    "&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>",
+    methods=["POST"],
+)
+# @token_permission_required(Permission.)
+def set_decision_jury(
+    formsemestre_id: int,
+    decision_jury: str,
+    devenir_jury: str,
+    assiduite: bool,
+    etudid: int = None,
+    nip: int = None,
+    ine: int = None,
+):
     """
     Attribuer la décision du jury et le devenir à un etudiant
 
@@ -61,10 +80,22 @@ def set_decision_jury(formsemestre_id: int, decision_jury: str, devenir_jury: st
     return error_response(501, message="Not implemented")
 
 
-@bp.route("/jury/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/annule_decision", methods=["DELETE"])
+@bp.route(
-@bp.route("/jury/nip/<int:nip>/formsemestre/<int:formsemestre_id>/annule_decision", methods=["DELETE"])
+    "/jury/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/annule_decision",
-@bp.route("/jury/ine/<int:ine>/formsemestre/<int:formsemestre_id>/annule_decision", methods=["DELETE"])
+    methods=["DELETE"],
-def annule_decision_jury(formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None):
+)
+@bp.route(
+    "/jury/nip/<int:nip>/formsemestre/<int:formsemestre_id>/annule_decision",
+    methods=["DELETE"],
+)
+@bp.route(
+    "/jury/ine/<int:ine>/formsemestre/<int:formsemestre_id>/annule_decision",
+    methods=["DELETE"],
+)
+# @token_permission_required(Permission.)
+def annule_decision_jury(
+    formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None
+):
     """
     Supprime la déciosion du jury pour un étudiant donné
 

app/api/logos.py

@@ -44,7 +44,6 @@ from app.scodoc.sco_permissions import Permission
 
 
 @bp.route("/logos", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def api_get_glob_logos():
     if not g.current_user.has_permission(Permission.ScoSuperAdmin, None):
@@ -57,7 +56,6 @@ def api_get_glob_logos():
 
 
 @bp.route("/logos/<string:logoname>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def api_get_glob_logo(logoname):
     if not g.current_user.has_permission(Permission.ScoSuperAdmin, None):
@@ -74,7 +72,6 @@ def api_get_glob_logo(logoname):
 
 
 @bp.route("/departements/<string:departement>/logos", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def api_get_local_logos(departement):
     dept_id = Departement.from_acronym(departement).id
@@ -85,7 +82,6 @@ def api_get_local_logos(departement):
 
 
 @bp.route("/departements/<string:departement>/logos/<string:logoname>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def api_get_local_logo(departement, logoname):
     # format = requested_format("jpg", ['png', 'jpg']) XXX ?

app/api/partitions.py

@@ -3,16 +3,14 @@ from flask import jsonify
 
 from app import models
 from app.api import bp
-from app.api.auth import token_auth
+
 from app.api.errors import error_response
-from app.decorators import permission_required
+from app.api.auth import token_permission_required
-from app.api.auth import token_auth, token_permission_required
 from app.scodoc.sco_groups import get_group_members, setGroups
 from app.scodoc.sco_permissions import Permission
 
 
 @bp.route("/partitions/<int:formsemestre_id>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def partition(formsemestre_id: int):
     """
@@ -30,13 +28,8 @@ def partition(formsemestre_id: int):
     # return error_response(501, message="Not implemented")
 
 
-# @bp.route(
-#     "/partitions/formsemestre/<int:formsemestre_id>/groups/group_ids?with_codes=&all_groups=&etat=",
-#     methods=["GET"],
-# )
 @bp.route("/partitions/groups/<int:group_id>", methods=["GET"])
 @bp.route("/partitions/groups/<int:group_id>/etat/<string:etat>", methods=["GET"])
-@token_auth.login_required
 @token_permission_required(Permission.APIView)
 def etud_in_group(group_id: int, etat=None):
     """
@@ -47,29 +40,30 @@ def etud_in_group(group_id: int, etat=None):
     """
     # Fonction utilisée : app.scodoc.sco_groups.get_group_members()
 
-    if etat is None: # Si l'état n'est pas renseigné
+    if etat is None:
-        try:
-            # Utilisation de la fonction get_group_members
         data = get_group_members(group_id)
-        except ValueError:
+    else:
-            return error_response(409, message="La requête ne peut être traitée en l’état actuel")
-    else: # Si l'état est renseigné
-        try:
-            # Utilisation de la fonction get_group_members
         data = get_group_members(group_id, etat)
-        except ValueError:
+
-            return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+    if len(data) == 0:
+        return error_response(
+            409,
+            message="La requête ne peut être traitée en l’état actuel. \n"
+            "Aucun groupe ne correspond au 'group_id' renseigné",
+        )
 
     return jsonify(data)
 
 
 @bp.route(
     "/partitions/set_groups?partition_id=<int:partition_id>&groups_lists=<int:groups_lists>&"
-    "groups_to_create=<int:groups_to_create>&groups_to_delete=<int:groups_to_delete>", methods=["POST"],
+    "groups_to_create=<int:groups_to_create>&groups_to_delete=<int:groups_to_delete>",
+    methods=["POST"],
 )
-@token_auth.login_required
 @token_permission_required(Permission.APIEtudChangeGroups)
-def set_groups(partition_id: int, groups_lists: int, groups_to_delete: int, groups_to_create: int):
+def set_groups(
+    partition_id: int, groups_lists: int, groups_to_delete: int, groups_to_create: int
+):
     """
     Set les groups
 
@@ -84,4 +78,8 @@ def set_groups(partition_id: int, groups_lists: int, groups_to_delete: int, grou
         setGroups(partition_id, groups_lists, groups_to_create, groups_to_delete)
         return error_response(200, message="Groups set")
     except ValueError:
-        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
+        return error_response(
+            409,
+            message="La requête ne peut être traitée en l’état actuel. \n"
+            "Veillez vérifier la conformité des éléments passé en paramètres",
+        )

app/api/tools.py

@@ -1,5 +1,6 @@
 from app import models
 
+
 def get_etu_from_request(etudid, nip, ine):
     """
     Fonction qui retourne un etudiant en fonction de l'etudid, code nip et code ine rentré en paramètres
@@ -10,7 +11,6 @@ def get_etu_from_request(etudid, nip, ine):
 
     Exemple de résultat: <Itendite>
     """
-
     if etudid is None:
         if nip is None:  # si ine
             etu = models.Identite.query.filter_by(code_ine=str(ine)).first()

app/models/absences.py

@@ -27,6 +27,20 @@ class Absence(db.Model):
     # XXX TODO: contrainte ajoutée: vérifier suppression du module
     # (mettre à NULL sans supprimer)
 
+    def to_dict(self):
+        data = {
+            "id": self.id,
+            "etudid": self.etudid,
+            "jour": self.jour,
+            "estabs": self.estabs,
+            "estjust": self.estjust,
+            "matin": self.matin,
+            "description": self.description,
+            "entry_date": self.entry_date,
+            "moduleimpl_id": self.moduleimpl_id,
+        }
+        return data
+
 
 class AbsenceNotification(db.Model):
     """Notification d'absence émise"""