résolution des conflis

app/api/sco_api.py

@@ -50,38 +50,17 @@ from app.api.errors import error_response
 from app import models
 from app.models import FormSemestre, FormSemestreInscription, Identite
 from app.models import ApcReferentielCompetences
+from app.scodoc.sco_abs import annule_absence, annule_justif
+from app.scodoc.sco_bulletins import formsemestre_bulletinetud_dict
+from app.scodoc.sco_bulletins_json import make_json_formsemestre_bulletinetud
+from app.scodoc.sco_formations import formation_export
+from app.scodoc.sco_formsemestre_inscriptions import do_formsemestre_inscription_listinscrits
+from app.scodoc.sco_groups import setGroups, get_etud_groups
+from app.scodoc.sco_moduleimpl import moduleimpl_list
 from app.scodoc.sco_permissions import Permission
 
 
-@bp.route("/list_depts", methods=["GET"])
+############################################### Departements ##########################################################
-@token_auth.login_required
-def list_depts():
-    depts = models.Departement.query.filter_by(visible=True).all()
-    data = [d.to_dict() for d in depts]
-    return jsonify(data)
-
-
-@bp.route("/etudiants/courant", methods=["GET"])
-@token_auth.login_required
-def etudiants():
-    """Liste de tous les étudiants actuellement inscrits à un semestre
-    en cours.
-    """
-    # Vérification de l'accès: permission Observateur sur tous les départements
-    # (c'est un exemple à compléter)
-    if not g.current_user.has_permission(Permission.ScoObservateur, None):
-        return error_response(401, message="accès interdit")
-
-    query = db.session.query(Identite).filter(
-        FormSemestreInscription.formsemestre_id == FormSemestre.id,
-        FormSemestreInscription.etudid == Identite.id,
-        FormSemestre.date_debut <= func.now(),
-        FormSemestre.date_fin >= func.now(),
-    )
-    return jsonify([e.to_dict_bul(include_urls=False) for e in query])
-
-
-######################## Departements ##################################
 
 
 @bp.route("/departements", methods=["GET"])
@@ -97,7 +76,7 @@ def departements():
 
 @bp.route("/departements/<string:dept>/etudiants/liste/<int:sem_id>", methods=["GET"])
 @token_auth.login_required
-def liste_etudiants(dept, *args, sem_id):  # XXX TODO A REVOIR
+def liste_etudiants(dept: str, *args, sem_id):  # XXX TODO A REVOIR
     """
     Liste des étudiants d'un département
     """
@@ -133,145 +112,273 @@ def liste_etudiants(dept, *args, sem_id):  # XXX TODO A REVOIR
 
 @bp.route("/departements/<string:dept>/semestres_actifs", methods=["GET"])
 @token_auth.login_required
-def liste_semestres_actifs(dept):  # TODO : changer nom
+def liste_semestres_courant(dept: str):
     """
     Liste des semestres actifs d'un départements donné
     """
-    # Récupération de l'id du dept
+    depts = models.Departement.query.filter_by(acronym=dept).all()
-    dept_id = models.Departement.query.filter(models.Departement.acronym == dept)
-    # Puis ici récupération du FormSemestre correspondant
-    depts_actifs = models.FormSemestre.query.filter_by(
-        etat=True,
-        dept_id=dept_id,
-    )
-    data = [da.to_dict() for da in depts_actifs]
 
-    # return jsonify(data)
+    id_dept = depts[0].id
-    return error_response(501, message="Not implemented")
 
+    semestres = models.FormSemestre.query.filter_by(dept_id=id_dept, etat=True).all()
 
-@bp.route("/referentiel_competences/<int:referentiel_competence_id>")
+    data = semestres[0].to_dict()
-@token_auth.login_required
+
-def referentiel_competences(referentiel_competence_id):
+    return jsonify(data)
+
+@bp.route(
+    "/departements/<string:dept>/formations/<int:formation_id>/referentiel_competences",
+    methods=["GET"],
+)
+def referenciel_competences(dept: str, formation_id: int):
     """
     Le référentiel de compétences
     """
-    ref = ApcReferentielCompetences.query.get_or_404(referentiel_competence_id)
+    # depts = models.Departement.query.filter_by(acronym=dept).all()
+    #
+    # id_dept = depts[0].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(204, message="Pas de référenciel de compétences pour cette formation")
+    # else:
+    #     return jsonify(ref_comp)
+
+    ref = ApcReferentielCompetences.query.get_or_404(formation_id)
+
     return jsonify(ref.to_dict())
 
 
-####################### Etudiants ##################################
+@bp.route("/departements/<string:dept>/formations/programme/<string:sem_idx>", methods=["GET"])
-
+def semestre_index(dept: str, sem_idx: str):
-
-@bp.route("/etudiant/<int:etudid>", methods=["GET"])
-@token_auth.login_required
-def etudiant(etudid):
     """
-    Un dictionnaire avec les informations de l'étudiant correspondant à l'id passé en paramètres.
+
     """
-    etud: Identite = Identite.query.get_or_404(etudid)
+    return error_response(501, message="not implemented")
-    return jsonify(etud.to_dict_bul())
 
 
-@bp.route("/etudiant/<int:etudid>/semestre/<int:sem_id>/bulletin", methods=["GET"])
+#################################################### Etudiants ########################################################
-@token_auth.login_required
+
-def etudiant_bulletin_semestre(etudid, sem_id):
+
+@bp.route("/etudiants", methods=["GET"])
+def etudiants():
+    """
+    La liste des étudiants
+    """
+    etu = models.Identite.query.all()
+
+    data = [d.to_dict_bul(include_urls=False) for d in etu]
+
+    return jsonify(data)
+    # return error_response(501, message="Not implemented")
+
+
+@bp.route("/etudiants/courant", methods=["GET"])
+def etudiants_courant():
+    """
+    La liste des étudiants courant
+    """
+    etus = models.Identite.query.all()
+
+    data = []
+    for etu in etus:
+        if etu.inscription_courante() is not None:
+            data.append(etu.to_dict_bul(include_urls=False))
+
+    return jsonify(data)
+    # return error_response(501, message="Not implemented")
+
+@bp.route("/etudiant/etudid/<int:etudid>", methods=["GET"])
+@bp.route("/etudiant/nip/<int:nip>", methods=["GET"])
+@bp.route("/etudiant/ine/<int:ine>", methods=["GET"])
+def etudiant(etudid=None, nip=None, ine=None):
+    """
+    Les informations de l'étudiant correspondant à l'id passé en paramètres.
+    """
+    etu = []
+    if etudid is not None:
+        etu = models.Identite.query.filter_by(id=etudid).first()
+    if nip is not None:
+        etu = models.Identite.query.filter_by(code_nip=etudid).first()
+    if ine is not None:
+        etu = models.Identite.query.filter_by(code_ine=etudid).first()
+
+    data = etu.to_dict_bul(include_urls=False)
+
+    return jsonify(data)
+
+@bp.route("/etudiant/etudid/<int:etudid>/formsemestres")
+@bp.route("/etudiant/nip/<int:nip>/formsemestres")
+@bp.route("/etudiant/ine/<int:ine>/formsemestres")
+def etudiant_formsemestres(etudid=None, nip=None, ine=None):
+    """
+    Retourne les semestres qu'un étudiant a suivi
+    """
+
+    inscriptions = models.FormSemestreInscription.query.all()
+
+    sems = []
+    for sem in inscriptions:
+        if etudid is not None:
+            if sem.etudid == etudid:
+                sems.append(sem)
+        if nip is not None:
+            etu = models.Identite.query.filter_by(code_nip=nip).first()
+            if sem.etudid == etu.etudid:
+                sems.append(sem)
+        if ine is not None:
+            etu = models.Identite.query.filter_by(code_ine=ine).firt()
+            if sem.etudid == etu.etudid:
+                sems.append(sem)
+
+    data_inscriptions = [d.to_dict() for d in sems]
+
+    formsemestres = []
+
+    for sem in data_inscriptions:
+        res = models.FormSemestre.query.filter_by(id=sem['formsemestre_id']).first()
+        formsemestres.append(res)
+
+    data = []
+    for formsem in formsemestres:
+        data.append(formsem.to_dict())
+
+    return jsonify(data)
+
+
+@bp.route("/etudiant/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"])
+@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"])
+def etudiant_bulletin_semestre(formsemestre_id, etudid=None, nip=None, ine=None):
     """
     Le bulletin d'un étudiant en fonction de son id et d'un semestre donné
     """
-    # return jsonify(models.BulAppreciations.query.filter_by(etudid=etudid, formsemestre_id=sem_id))
+    # fonction to use:  make_json_formsemestre_bulletinetud()
-    return error_response(501, message="Not implemented")
+    if etudid is not None:
-
+        return make_json_formsemestre_bulletinetud(formsemestre_id, etudid)
-
-@bp.route(
-    "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/nip/<int:NIP>/releve",
-    methods=["GET"],
-)
-@bp.route(
-    "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/id/<int:etudid>/releve",
-    methods=["GET"],
-)
-@bp.route(
-    "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/ine/<int:numScodoc>/releve",
-    methods=["GET"],
-)
-@token_auth.login_required
-def etudiant_bulletin(formsemestre_id, dept, etudid, format="json", *args, size):
-    """
-    Un bulletin de note
-    """
-    formsemestres = models.FormSemestre.query.filter_by(id=formsemestre_id)
-    depts = models.Departement.query.filter_by(acronym=dept)
-    etud = ""
-
-    data = []
-    if args[0] == "short":
-        pass
-    elif args[0] == "selectevals":
-        pass
-    elif args[0] == "long":
-        pass
     else:
-        return "erreur"
+        etu = None
+        if nip is not None:
+            etu = models.Identite.query.filter_by(code_nip=nip).first()
 
-    # return jsonify(data)
+        if ine is not None:
-    return error_response(501, message="Not implemented")
+            etu = models.Identite.query.filter_by(code_nip=ine).first()
+
+        if etu is not None:
+            return make_json_formsemestre_bulletinetud(formsemestre_id, etu.etudid)
+
+    # return error_response(501, message="Not implemented")
 
 
 @bp.route(
-    "/etudiant/<int:etudid>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
+    "/etudiant/etudid/<int:etudid>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
 )
-@token_auth.login_required
+@bp.route(
-def etudiant_groups(etudid: int, formsemestre_id: int):
+    "/etudiant/nip/<int:nip>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
+)
+@bp.route(
+    "/etudiant/ine/<int:ine>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
+)
+def etudiant_groups(formsemestre_id: int, etudid=None, nip=None, ine=None):
     """
     Liste des groupes auxquels appartient l'étudiant dans le semestre indiqué
     """
-    semestre = models.FormSemestre.query.filter_by(id=formsemestre_id)
+    # fonction to use : get_etud_groups
-    etudiant = models.Identite.query.filter_by(id=etudid)
 
-    groups = models.Partition.query.filter(
+    if etudid is None:
-        models.Partition.formsemestre_id == semestre,
+        if nip is not None:
-        models.GroupDescr.etudiants == etudiant,
+            etu = models.Identite.query.filter_by(code_nip=nip).first()
-    )
+            etudid = etu.etudid
-    data = [d.to_dict() for d in groups]
+        if ine is not None:
-    # return jsonify(data)
+            etu = models.Identite.query.filter_by(code_ine=ine).first()
+            etudid = etu.etudid
+    sem = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
+    try:
+        data = get_etud_groups(etudid, sem.to_dict())
+    except ValueError:
+        return error_response(409, message="La requête ne peut être traitée en l’état actuel")
 
-    return error_response(501, message="Not implemented")
+    return jsonify(data)
 
-
+##############################################" Formations ############################################################
-#######################" Programmes de formations #########################
 
 
 @bp.route("/formations", methods=["GET"])
-@bp.route("/formations/<int:formation_id>", methods=["GET"])
+def formations():
-@token_auth.login_required
-def formations(formation_id: int):
     """
     Liste des formations
     """
-    formations = models.Formation.query.filter_by(id=formation_id)
+    list_formations = models.Formation.query.all()
-    data = [d.to_dict() for d in formations]
-    # return jsonify(data)
 
-    return error_response(501, message="Not implemented")
+    data = [d.to_dict() for d in list_formations]
+
+    return jsonify(data)
+
+
+@bp.route("/formations/<int:formation_id>", methods=["GET"])
+def formations_by_id(formation_id: int):
+    """
+    Formation en fonction d'un id donné
+    """
+    forma = models.Formation.query.filter_by(id=formation_id).all()
+
+    data = [d.to_dict() for d in forma]
+
+    return jsonify(data)
 
 
 @bp.route("/formations/formation_export/<int:formation_id>", methods=["GET"])
-@token_auth.login_required
+def formation_export_by_formation_id(formation_id: int, export_ids=False):
-def formation_export(formation_id: int, export_ids=False):
     """
     La formation, avec UE, matières, modules
     """
+    data = formation_export(formation_id)
+
+    return jsonify(data)
+
+
+@bp.route("/formations/apo/<int:etape_apo>", methods=["GET"])
+def formsemestre_apo(etape_apo: int):
+    """
+    Information sur les formsemestres
+    """
     return error_response(501, message="Not implemented")
 
 
-###################### UE #######################################
+@bp.route("/formations/moduleimpl/<int:moduleimpl_id>", methods=["GET"])
+def moduleimpls(moduleimpl_id: int):
+    """
+    Liste des moduleimpl
+    """
+    list_moduleimpls = models.ModuleImpl.query.filter_by(id=moduleimpl_id)
+
+    data = list_moduleimpls[0].to_dict()
+
+    return jsonify(data)
+
+
+@bp.route(
+    "/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>",
+    methods=["GET"],
+)
+def moduleimpls_sem(moduleimpl_id: int, formsemestre_id: int):
+    """
+    Liste de moduleimpl d'un semestre
+    """
+    data = moduleimpl_list(moduleimpl_id, formsemestre_id)
+    return jsonify(data)
+    # return error_response(501, message="Not implemented")
+
+
+#################################################### UE ###############################################################
 
 
 @bp.route(
     "/departements/<string:dept>/formations/programme/<string:sem_id>", methods=["GET"]
 )
-@token_auth.login_required
 def eus(dept: str, sem_id: int):
     """
     Liste des UES, ressources et SAE d'un semestre
@@ -279,42 +386,70 @@ def eus(dept: str, sem_id: int):
     return error_response(501, message="Not implemented")
 
 
-######## Semestres de formation ###############
+########################################## Formsemestres ##############################################################
 
 
 @bp.route("/formations/formsemestre/<int:formsemestre_id>", methods=["GET"])
-@bp.route("/formations/apo/<int:etape_apo>", methods=["GET"])
+def formsemestre(formsemestre_id: int):
-@token_auth.login_required
-def formsemestre(
-    id: int,
-):
     """
-    Information sur les formsemestres
+    Information sur le formsemestre correspondant au formsemestre_id
     """
-    return error_response(501, message="Not implemented")
+    list_formsemetre = models.FormSemestre.query.filter_by(id=formsemestre_id)
+
+    data = list_formsemetre[0].to_dict()
+
+    return jsonify(data)
 
 
-############ Modules de formation ##############
-
-
-@bp.route("/formations/moduleimpl/<int:moduleimpl_id>", methods=["GET"])
 @bp.route(
-    "/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>",
+    "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/etudid/<int:etudid>/bulletin",
     methods=["GET"],
 )
-@token_auth.login_required
+@bp.route(
-def moduleimpl(id: int):
+    "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/nip/<int:nip>/bulletin",
+    methods=["GET"],
+)
+@bp.route(
+    "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/ine/<int:ine>/bulletin",
+    methods=["GET"],
+)
+def etudiant_bulletin(formsemestre_id, dept, etudid, format="json", *args, size):
     """
-    Liste de moduleimpl
+    Un bulletin de note
+    """
+    data = []
+    if args[0] == "short":
+        data = formsemestre_bulletinetud_dict(formsemestre_id, etudid, version=args[0])
+    elif args[0] == "selectevals":
+        data = formsemestre_bulletinetud_dict(formsemestre_id, etudid, version=args[0])
+    elif args[0] == "long":
+        data = formsemestre_bulletinetud_dict(formsemestre_id, etudid)
+    else:
+        return error_response(501, message="Not implemented")
+
+    return jsonify(data)
+
+
+@bp.route("/formsemestre/<int:formsemestre_id>/bulletins", methods=["GET"])
+def bulletins(formsemestre_id: int):
+    """
+    Les bulletins d'un formsemestre donné
     """
     return error_response(501, message="Not implemented")
 
 
-########### Groupes et partitions ###############
+@bp.route("/formsemestre/<int:formsemestre_id>/jury", methods=["GET"])
+def jury(formsemestre_id: int):
+    """
+
+    """
+    return error_response(501, message="Not implemented")
+
+
+############################################### Partitions ############################################################
 
 
 @bp.route("/partitions/<int:formsemestre_id>", methods=["GET"])
-@token_auth.login_required
 def partition(formsemestre_id: int):
     """
     La liste de toutes les partitions d'un formsemestre
@@ -330,7 +465,6 @@ def partition(formsemestre_id: int):
     "/partitions/formsemestre/<int:formsemestre_id>/groups/group_ids?with_codes=&all_groups=&etat=",
     methods=["GET"],
 )
-@token_auth.login_required
 def groups(formsemestre_id: int, group_ids: int):
     """
     Liste des étudiants dans un groupe
@@ -339,24 +473,27 @@ def groups(formsemestre_id: int, group_ids: int):
 
 
 @bp.route(
-    "/partitions/set_groups?partition_id=<int:partition_id>&groups=<int:groups>&groups_to_delete=<int:groups_to_delete>&groups_to_create=<int:groups_to_create>",
+    "/partitions/set_groups?partition_id=<int:partition_id>&groups_lists=<int:groups_lists>&groups_to_create=<int"
-    methods=["POST"],
+    ":groups_to_create>&groups_to_delete=<int:groups_to_delete>", methods=["POST"],
 )
 @token_auth.login_required
 def set_groups(
-    partition_id: int, groups: int, groups_to_delete: int, groups_to_create: int
+        partition_id: int, groups_lists: int, groups_to_delete: int, groups_to_create: int
 ):
     """
     Set les groups
     """
-    return error_response(501, message="Not implemented")
+    try:
+        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")
 
 
-####### Bulletins de notes ###########
+################################################### Evaluations #######################################################
 
 
 @bp.route("/evaluations/<int:moduleimpl_id>", methods=["GET"])
-@token_auth.login_required
 def evaluations(moduleimpl_id: int):
     """
     Liste des évaluations à partir de l'id d'un moduleimpl
@@ -364,22 +501,21 @@ def evaluations(moduleimpl_id: int):
     evals = models.Evaluation.query.filter_by(id=moduleimpl_id)
     data = [d.to_dict() for d in evals]
 
-    # return jsonify(data)
+    return jsonify(data)
-    return error_response(501, message="Not implemented")
+    # return error_response(501, message="Not implemented")
 
 
 @bp.route("/evaluations/eval_notes/<int:evaluation_id>", methods=["GET"])
-@token_auth.login_required
 def evaluation_notes(evaluation_id: int):
     """
     Liste des notes à partir de l'id d'une évaluation donnée
     """
-    evals = models.Evaluation.query.filter_by(id=evaluation_id)
+    notes = models.NotesNotes.query.filter_by(evaluation_id=evaluation_id).all()
-    notes = evals.get_notes()
 
     data = [d.to_dict() for d in notes]
-    # return jsonify(data)
+
-    return error_response(501, message="Not implemented")
+    return jsonify(data)
+    # return error_response(501, message="Not implemented")
 
 
 @bp.route(
@@ -394,20 +530,52 @@ def evaluation_set_notes(eval_id: int, etudid: int, note: float):
     return error_response(501, message="Not implemented")
 
 
-############## Absences #############
+#################################################### Absences #########################################################
 
 
 @bp.route("/absences/<int:etudid>", methods=["GET"])
+def absences(etudid=None, nip=None, ine=None):
+    """
+    Liste des absences d'un étudiant donné
+    """
+    abs = ""
+    if etudid is not None:
+        abs = models.Absence.query.filter_by(etudid=etudid).all()
+    else:
+        if nip is not None:
+            etu = models.Identite.query.filter_by(code_nip=nip).first()
+            abs = models.Absence.query.filter_by(etudid=etu.etudid).all()
+        if ine is not None:
+            etu = models.Identite.query.filter_by(code_ine=ine).first()
+            abs = models.Absence.query.filter_by(etudid=etu.etudid).all()
+
+    if abs != "":
+        data = [d.to_dict() for d in abs]
+
+        return jsonify(data)
+    return error_response(501, message="Not implemented")
+
+
 @bp.route("/absences/<int:etudid>/abs_just_only", methods=["GET"])
-def absences(etudid: int):
+def absences_justify(etudid=None, nip=None, ine=None):
     """
-    Liste des absences d'un étudiant donnée
+    Liste des absences justifiés d'un étudiant donné
     """
-    abs = models.Absence.query.filter_by(id=etudid)
+    abs = ""
+    if etudid is not None:
+        abs = models.Absence.query.filter_by(etudid=etudid, estjust=True).all()
+    else:
+        if nip is not None:
+            etu = models.Identite.query.filter_by(code_nip=nip).first()
+            abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all()
+        if ine is not None:
+            etu = models.Identite.query.filter_by(code_ine=ine).first()
+            abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all()
 
-    data = [d.to_dict() for d in abs]
+    if abs != "":
+        data = [d.to_dict() for d in abs]
 
-    # return jsonify(data)
+        return jsonify(data)
     return error_response(501, message="Not implemented")
 
 
@@ -420,43 +588,73 @@ def abs_signale():
     return error_response(501, message="Not implemented")
 
 
-@bp.route("/absences/abs_annule", methods=["POST"])
+@bp.route("/absences/abs_annule?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
+@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_auth.login_required
-def abs_annule():
+def abs_annule(jour: datetime, matin: str, etudid=None, nip=None, ine=None):
     """
     Retourne un html
     """
-    return error_response(501, message="Not implemented")
+    # fonction to use : annule_absence
+    if etudid is None:
+        if nip is not None:
+            etu = models.Identite.query.filter_by(code_nip=nip).first()
+            etudid = etu.etudid
+        if ine is not None:
+            etu = models.Identite.query.filter_by(code_ine=ine).first()
+            etudid = etu.etudid
+    try:
+        annule_absence(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(200, message="OK")
 
 
-@bp.route("/absences/abs_annule_justif", methods=["POST"])
+@bp.route("/absences/abs_annule_justif?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
+@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_auth.login_required
-def abs_annule_justif():
+def abs_annule_justif(jour: datetime, matin: str, etudid=None, nip=None, ine=None):
     """
     Retourne un html
     """
-    return error_response(501, message="Not implemented")
+    # fonction to use : annule_justif
+    if etudid is None:
+        if nip is not None:
+            etu = models.Identite.query.filter_by(code_nip=nip).first()
+            etudid = etu.etudid
+        if ine is not None:
+            etu = models.Identite.query.filter_by(code_ine=ine).first()
+            etudid = etu.etudid
+    try:
+        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(200, message="OK")
 
 
 @bp.route(
     "/absences/abs_group_etat/?group_ids=<int:group_ids>&date_debut=date_debut&date_fin=date_fin",
     methods=["GET"],
 )
-@token_auth.login_required
 def abs_groupe_etat(
-    group_ids: int, date_debut, date_fin, with_boursier=True, format="html"
+        group_ids: int, date_debut, date_fin, with_boursier=True, format="html"
 ):
     """
     Liste des absences d'un ou plusieurs groupes entre deux dates
     """
+
+    # list_abs_date
     return error_response(501, message="Not implemented")
 
 
-################ Logos ################
+###################################################### Logos ##########################################################
 
 
 @bp.route("/logos", methods=["GET"])
-@token_auth.login_required
 def liste_logos(format="json"):
     """
     Liste des logos définis pour le site scodoc.
@@ -465,7 +663,6 @@ def liste_logos(format="json"):
 
 
 @bp.route("/logos/<string:nom>", methods=["GET"])
-@token_auth.login_required
 def recup_logo_global(nom: str):
     """
     Retourne l'image au format png ou jpg
@@ -474,7 +671,6 @@ def recup_logo_global(nom: str):
 
 
 @bp.route("/departements/<string:dept>/logos", methods=["GET"])
-@token_auth.login_required
 def logo_dept(dept: str):
     """
     Liste des logos définis pour le département visé.
@@ -483,7 +679,6 @@ def logo_dept(dept: str):
 
 
 @bp.route("/departement/<string:dept>/logos/<string:nom>", methods=["GET"])
-@token_auth.login_required
 def recup_logo_dept_global(dept: str, nom: str):
     """
     L'image format png ou jpg