api justificatif : modèle + api (❌ archivage)

app/api/__init__.py

@@ -42,6 +42,7 @@ from app.api import (
     formations,
     formsemestres,
     jury,
+    justificatif,
     logos,
     partitions,
     users,

app/api/assiduites.py

@@ -6,7 +6,6 @@
 """ScoDoc 9 API : Assiduités
 """
 from datetime import datetime
-from typing import List
 from flask import g, jsonify, request
 from flask_login import login_required
 
@@ -48,7 +47,7 @@ def assiduite(assiduite_id: int = None):
 
     data = assiduite_query.to_dict()
 
-    return jsonify(change_etat(data))
+    return jsonify(_change_etat(data))
 
 
 @bp.route("/assiduites/<int:etudid>/count", defaults={"with_query": False})
@@ -104,7 +103,7 @@ def count_assiduites(etudid: int = None, with_query: bool = False):
     metric: str = "all"
 
     if with_query:
-        metric, filtered = count_manager(request)
+        metric, filtered = _count_manager(request)
 
     return jsonify(
         scass.get_assiduites_stats(
@@ -161,12 +160,12 @@ def assiduites(etudid: int = None, with_query: bool = False):
     assiduites_query = etud.assiduites
 
     if with_query:
-        assiduites_query = filter_manager(request, assiduites_query)
+        assiduites_query = _filter_manager(request, assiduites_query)
 
-    data_set: List[dict] = []
+    data_set: list[dict] = []
     for ass in assiduites_query.all():
         data = ass.to_dict()
-        data_set.append(change_etat(data))
+        data_set.append(_change_etat(data))
 
     return jsonify(data_set)
 
@@ -199,12 +198,12 @@ def assiduites_formsemestre(formsemestre_id: int, with_query: bool = False):
     assiduites_query = scass.filter_by_formsemestre(Assiduite.query, formsemestre)
 
     if with_query:
-        assiduites_query = filter_manager(request, assiduites_query)
+        assiduites_query = _filter_manager(request, assiduites_query)
 
-    data_set: List[dict] = []
+    data_set: list[dict] = []
     for ass in assiduites_query.all():
         data = ass.to_dict()
-        data_set.append(change_etat(data))
+        data_set.append(_change_etat(data))
 
     return jsonify(data_set)
 
@@ -246,7 +245,7 @@ def count_assiduites_formsemestre(
     metric: str = "all"
     filtered: dict = {}
     if with_query:
-        metric, filtered = count_manager(request)
+        metric, filtered = _count_manager(request)
 
     return jsonify(scass.get_assiduites_stats(assiduites_query, metric, filtered))
 
@@ -257,7 +256,7 @@ def count_assiduites_formsemestre(
 @login_required
 @permission_required(Permission.ScoView)
 # @permission_required(Permission.ScoAssiduiteChange)
-def create(etudid: int = None):
+def assiduite_create(etudid: int = None):
     """
     Création d'une assiduité pour l'étudiant (etudid)
     La requête doit avoir un content type "application/json":
@@ -277,9 +276,6 @@ def create(etudid: int = None):
         ...
     ]
 
-    TODO:
-        - vérifier si l'entrée est bien une liste
-
     """
     etud: Identite = Identite.query.filter_by(id=etudid).first_or_404()
 
@@ -304,7 +300,7 @@ def _create_singular(
     data: dict,
     etud: Identite,
 ) -> tuple[int, object]:
-    errors: List[str] = []
+    errors: list[str] = []
 
     # -- vérifications de l'objet json --
     # cas 1 : ETAT
@@ -314,7 +310,7 @@ def _create_singular(
     elif etat not in scu.ETATS_ASSIDUITE:
         errors.append("param 'etat': invalide")
 
-    data = change_etat(data, False)
+    data = _change_etat(data, False)
     etat = data.get("etat", None)
 
     # cas 2 : date_debut
@@ -379,7 +375,7 @@ def _create_singular(
 @scodoc
 @permission_required(Permission.ScoView)
 # @permission_required(Permission.ScoAssiduiteChange)
-def delete():
+def assiduite_cdelete():
     """
     Suppression d'une assiduité à partir de son id
 
@@ -422,7 +418,7 @@ def _delete_singular(assiduite_id: int, database):
 @scodoc
 @permission_required(Permission.ScoView)
 # @permission_required(Permission.ScoAssiduiteChange)
-def edit(assiduite_id: int):
+def assiduite_cedit(assiduite_id: int):
     """
     Edition d'une assiduité à partir de son id
     La requête doit avoir un content type "application/json":
@@ -435,14 +431,14 @@ def edit(assiduite_id: int):
     assiduite_unique: Assiduite = Assiduite.query.filter_by(
         id=assiduite_id
     ).first_or_404()
-    errors: List[str] = []
+    errors: list[str] = []
     data = request.get_json(force=True)
 
     # Vérifications de data
 
     # Cas 1 : Etat
     if data.get("etat") is not None:
-        data = change_etat(data, False)
+        data = _change_etat(data, False)
         if data.get("etat") is None:
             errors.append("param 'etat': invalide")
         else:
@@ -482,7 +478,7 @@ def edit(assiduite_id: int):
 
 
 # -- Utils --
-def change_etat(data: dict, from_int: bool = True):
+def _change_etat(data: dict, from_int: bool = True):
     """change dans un json la valeur du champs état"""
     if from_int:
         data["etat"] = scu.ETAT_ASSIDUITE_NAME.get(data["etat"])
@@ -491,7 +487,7 @@ def change_etat(data: dict, from_int: bool = True):
     return data
 
 
-def count_manager(requested) -> tuple[str, dict]:
+def _count_manager(requested) -> tuple[str, dict]:
     """
     Retourne la/les métriques à utiliser ainsi que le filtre donnés en query de la requête
     """
@@ -544,28 +540,32 @@ def count_manager(requested) -> tuple[str, dict]:
     return (metric, filtered)
 
 
-def filter_manager(requested, assiduites_query):
+def _filter_manager(requested, assiduites_query):
     """
     Retourne les assiduites entrées filtrées en fonction de la request
     """
     # cas 1 : etat assiduite
     etat = requested.args.get("etat")
     if etat is not None:
-        assiduites_query = scass.filter_by_etat(assiduites_query, etat)
+        assiduites_query = scass.filter_assiduites_by_etat(assiduites_query, etat)
 
     # cas 2 : date de début
     deb = requested.args.get("date_debut")
     deb: datetime = scu.is_iso_formated(deb, True)
     if deb is not None:
 
-        assiduites_query = scass.filter_by_date(assiduites_query, deb, sup=True)
+        assiduites_query = scass.filter_assiduites_by_date(
+            assiduites_query, deb, sup=True
+        )
 
     # cas 3 : date de fin
     fin = requested.args.get("date_fin")
     fin = scu.is_iso_formated(fin, True)
 
     if fin is not None:
-        assiduites_query = scass.filter_by_date(assiduites_query, fin, sup=False)
+        assiduites_query = scass.filter_assiduites_by_date(
+            assiduites_query, fin, sup=False
+        )
 
     # cas 4 : moduleimpl_id
     module = requested.args.get("moduleimpl_id", False)

app/api/justificatif.py

@@ -0,0 +1,386 @@
+##############################################################################
+# ScoDoc
+# Copyright (c) 1999 - 2022 Emmanuel Viennet.  All rights reserved.
+# See LICENSE
+##############################################################################
+"""ScoDoc 9 API : Assiduités
+"""
+import os
+from datetime import datetime
+
+import app.scodoc.sco_assiduites as scass
+import app.scodoc.sco_utils as scu
+from app import db
+
+from app.api import api_bp as bp
+from app.api import api_web_bp
+from app.scodoc.sco_exceptions import ScoValueError
+from app.decorators import permission_required, scodoc
+from app.models import Identite, Justificatif
+from app.scodoc.sco_archives_justificatifs import JustificatifArchiver
+from app.scodoc.sco_permissions import Permission
+from flask import g, jsonify, request
+from flask_login import login_required
+from app.scodoc.sco_utils import json_error
+
+
+# @bp.route("/justificatif/import")
+# @api_web_bp.route("/justificatif/import")
+# @scodoc
+# def justificatif():
+#     """ """
+#     archiver: JustificatifArchiver = JustificatifArchiver()
+
+#     filename: str = "lol.txt"
+#     data: bytes = "test".encode("utf-8")
+
+#     archiver.save_justificatif(
+#         etudid=1, filename=filename, data=data, archive_id="2023-02-01-10-29-20"
+#     )
+#     return jsonify([filename, "done"])
+
+
+# @bp.route("/justificatif/remove")
+# @api_web_bp.route("/justificatif/remove")
+# @scodoc
+# def justremove():
+#     """ """
+#     archiver: JustificatifArchiver = JustificatifArchiver()
+
+#     archiver.delete_justificatif(etudid=1, archive_id="2023-02-01-10-29-20")
+#     return jsonify("done")
+
+# Partie Modèle
+# TODO: justificatif
+@bp.route("/justificatif/<int:justif_id>")
+@api_web_bp.route("/assiduite/<int:justif_id>")
+@scodoc
+@permission_required(Permission.ScoView)
+def justificatif(justif_id: int = None):
+    """Retourne un objet justificatif à partir de son id
+
+    Exemple de résultat:
+    {
+        "justif_id": 1,
+        "etudid": 2,
+        "date_debut": "2022-10-31T08:00+01:00",
+        "date_fin": "2022-10-31T10:00+01:00",
+        "etat": "valide",
+        "fichier": "archive_id",
+        "raison": "une raison",
+        "entry_date": "2022-10-31T08:00+01:00",
+    }
+    """
+
+    query = Justificatif.query.filter_by(id=justif_id)
+    if g.scodoc_dept:
+        query = query.join(Identite).filter_by(dept_id=g.scodoc_dept_id)
+    justificatif_unique = query.first_or_404()
+
+    data = justificatif_unique.to_dict()
+
+    return jsonify(_change_etat(data))
+
+
+# TODO: justificatifs[-query]
+@bp.route("/justificatifs/<int:etudid>", defaults={"with_query": False})
+@bp.route("/justificatifs/<int:etudid>/query", defaults={"with_query": True})
+@api_web_bp.route("/justificatifs/<int:etudid>", defaults={"with_query": False})
+@api_web_bp.route("/justificatifs/<int:etudid>/query", defaults={"with_query": True})
+@login_required
+@scodoc
+@permission_required(Permission.ScoView)
+def justificatifs(etudid: int = None, with_query: bool = False):
+    """
+    Retourne toutes les assiduités d'un étudiant
+    chemin : /justificatifs/<int:etudid>
+
+    Un filtrage peut être donné avec une query
+    chemin : /justificatifs/<int:etudid>/query?
+
+    Les différents filtres :
+        Etat (etat du justificatif -> validé, non validé, modifé, en attente):
+            query?etat=[- liste des états séparé par une virgule -]
+            ex: .../query?etat=validé,modifié
+        Date debut
+        (date de début du justificatif, sont affichés les justificatifs
+        dont la date de début est supérieur ou égale à la valeur donnée):
+            query?date_debut=[- date au format iso -]
+            ex: query?date_debut=2022-11-03T08:00+01:00
+        Date fin
+        (date de fin du justificatif, sont affichés les justificatifs
+        dont la date de fin est inférieure ou égale à la valeur donnée):
+            query?date_fin=[- date au format iso -]
+            ex: query?date_fin=2022-11-03T10:00+01:00
+    """
+
+    query = Identite.query.filter_by(id=etudid)
+    if g.scodoc_dept:
+        query = query.filter_by(dept_id=g.scodoc_dept_id)
+
+    etud: Identite = query.first_or_404(etudid)
+    justificatifs_query = etud.justificatifs
+
+    if with_query:
+        justificatifs_query = _filter_manager(request, justificatifs_query)
+
+    data_set: list[dict] = []
+    for just in justificatifs_query.all():
+        data = just.to_dict()
+        data_set.append(_change_etat(data))
+
+    return jsonify(data_set)
+
+
+# TODO: justificatif-create
+
+
+@bp.route("/justificatif/<int:etudid>/create", methods=["POST"])
+@api_web_bp.route("/justificatif/<int:etudid>/create", methods=["POST"])
+@scodoc
+@login_required
+@permission_required(Permission.ScoView)
+# @permission_required(Permission.ScoAssiduiteChange)
+def justif_create(etudid: int = None):
+    """
+    Création d'un justificatif pour l'étudiant (etudid)
+    La requête doit avoir un content type "application/json":
+    [
+        {
+            "date_debut": str,
+            "date_fin": str,
+            "etat": str,
+        },
+        {
+            "date_debut": str,
+            "date_fin": str,
+            "etat": str,
+            "raison":str,
+        }
+        ...
+    ]
+
+    """
+    etud: Identite = Identite.query.filter_by(id=etudid).first_or_404()
+
+    create_list: list[object] = request.get_json(force=True)
+
+    if not isinstance(create_list, list):
+        return json_error(404, "Le contenu envoyé n'est pas une liste")
+
+    errors: dict[int, str] = {}
+    success: dict[int, object] = {}
+    for i, data in enumerate(create_list):
+        code, obj = _create_singular(data, etud)
+        if code == 404:
+            errors[i] = obj
+        else:
+            success[i] = obj
+
+    return jsonify({"errors": errors, "success": success})
+
+
+def _create_singular(
+    data: dict,
+    etud: Identite,
+) -> tuple[int, object]:
+    errors: list[str] = []
+
+    # -- vérifications de l'objet json --
+    # cas 1 : ETAT
+    etat = data.get("etat", None)
+    if etat is None:
+        errors.append("param 'etat': manquant")
+    elif etat not in scu.ETATS_JUSTIFICATIF:
+        errors.append("param 'etat': invalide")
+
+    data = _change_etat(data, False)
+    etat = data.get("etat", None)
+
+    # cas 2 : date_debut
+    date_debut = data.get("date_debut", None)
+    if date_debut is None:
+        errors.append("param 'date_debut': manquant")
+    deb = scu.is_iso_formated(date_debut, convert=True)
+    if deb is None:
+        errors.append("param 'date_debut': format invalide")
+
+    # cas 3 : date_fin
+    date_fin = data.get("date_fin", None)
+    if date_fin is None:
+        errors.append("param 'date_fin': manquant")
+    fin = scu.is_iso_formated(date_fin, convert=True)
+    if fin is None:
+        errors.append("param 'date_fin': format invalide")
+
+    # cas 4 : raison
+
+    raison: str = data.get("raison", None)
+
+    if errors:
+        err: str = ", ".join(errors)
+        return (404, err)
+
+    # TOUT EST OK
+
+    try:
+        nouv_justificatif: Justificatif = Justificatif.create_justificatif(
+            date_debut=deb,
+            date_fin=fin,
+            etat=etat,
+            etud=etud,
+            raison=raison,
+        )
+
+        db.session.add(nouv_justificatif)
+        db.session.commit()
+        return (200, {"justif_id": nouv_justificatif.id})
+    except ScoValueError as excp:
+        return (
+            404,
+            excp.args[0],
+        )
+
+
+# TODO: justificatif-edit
+@bp.route("/justificatif/<int:justif_id>/edit", methods=["POST"])
+@api_web_bp.route("/justificatif/<int:justif_id>/edit", methods=["POST"])
+@login_required
+@scodoc
+@permission_required(Permission.ScoView)
+# @permission_required(Permission.ScoAssiduiteChange)
+def justif_edit(justif_id: int):
+    """
+    Edition d'un justificatif à partir de son id
+    La requête doit avoir un content type "application/json":
+    {
+        "etat"?: str,
+        "raison"?: str
+    }
+    """
+    justificatif_unique: Justificatif = Justificatif.query.filter_by(
+        id=justif_id
+    ).first_or_404()
+    errors: list[str] = []
+    data = request.get_json(force=True)
+
+    # Vérifications de data
+
+    # Cas 1 : Etat
+    if data.get("etat") is not None:
+        data = _change_etat(data, False)
+        if data.get("etat") is None:
+            errors.append("param 'etat': invalide")
+        else:
+            justificatif_unique.etat = data.get("etat")
+
+    # Cas 2 : raison
+    raison = data.get("raison", False)
+    if raison is not False:
+        justificatif_unique.raison = raison
+
+    if errors:
+        err: str = ", ".join(errors)
+        return json_error(404, err)
+
+    db.session.add(justificatif_unique)
+    db.session.commit()
+    return jsonify({"OK": True})
+
+
+# TODO: justificatif-delete
+@bp.route("/justificatif/delete", methods=["POST"])
+@api_web_bp.route("/justificatif/delete", methods=["POST"])
+@login_required
+@scodoc
+@permission_required(Permission.ScoView)
+# @permission_required(Permission.ScoAssiduiteChange)
+def justif_delete():
+    """
+    Suppression d'un justificatif à partir de son id
+
+    Forme des données envoyées :
+
+    [
+        <justif_id:int>,
+        ...
+    ]
+
+
+    """
+    justificatifs_list: list[int] = request.get_json(force=True)
+    if not isinstance(justificatifs_list, list):
+        return json_error(404, "Le contenu envoyé n'est pas une liste")
+
+    output = {"errors": {}, "success": {}}
+
+    for i, ass in enumerate(justificatifs_list):
+        code, msg = _delete_singular(ass, db)
+        if code == 404:
+            output["errors"][f"{i}"] = msg
+        else:
+            output["success"][f"{i}"] = {"OK": True}
+    db.session.commit()
+    return jsonify(output)
+
+
+def _delete_singular(justif_id: int, database):
+    justificatif_unique: Justificatif = Justificatif.query.filter_by(
+        id=justif_id
+    ).first()
+    if justificatif_unique is None:
+        return (404, "Justificatif non existant")
+    database.session.delete(justificatif_unique)
+    return (200, "OK")
+
+
+# Partie archivage
+# TODO: justificatif-import
+# TODO: justificatif-export
+# TODO: justificatif-remove
+# TODO: justificatif-list
+
+# Partie justification
+# TODO: justificatif-justified
+
+
+# -- Utils --
+def _change_etat(data: dict, from_int: bool = True):
+    """change dans un json la valeur du champs état"""
+    if from_int:
+        data["etat"] = scu.ETAT_JUSTIFICATIF_NAME.get(data["etat"])
+    else:
+        data["etat"] = scu.ETATS_JUSTIFICATIF.get(data["etat"])
+    return data
+
+
+def _filter_manager(requested, justificatifs_query):
+    """
+    Retourne les justificatifs entrés filtrés en fonction de la request
+    """
+    # cas 1 : etat justificatif
+    etat = requested.args.get("etat")
+    if etat is not None:
+        justificatifs_query = scass.filter_justificatifs_by_etat(
+            justificatifs_query, etat
+        )
+
+    # cas 2 : date de début
+    deb = requested.args.get("date_debut")
+    deb: datetime = scu.is_iso_formated(deb, True)
+    if deb is not None:
+
+        justificatifs_query = scass.filter_justificatifs_by_date(
+            justificatifs_query, deb, sup=True
+        )
+
+    # cas 3 : date de fin
+    fin = requested.args.get("date_fin")
+    fin = scu.is_iso_formated(fin, True)
+
+    if fin is not None:
+        justificatifs_query = scass.filter_justificatifs_by_date(
+            justificatifs_query, fin, sup=False
+        )
+
+    return justificatifs_query

app/models/assiduites.py

@@ -7,7 +7,12 @@ from app import db
 from app.models import ModuleImpl
 from app.models.etudiants import Identite
 from app.scodoc.sco_exceptions import ScoValueError
-from app.scodoc.sco_utils import EtatAssiduite, is_period_overlapping, localize_datetime
+from app.scodoc.sco_utils import (
+    EtatAssiduite,
+    EtatJustificatif,
+    is_period_overlapping,
+    localize_datetime,
+)
 
 
 class Assiduite(db.Model):
@@ -123,7 +128,8 @@ class Justificatif(db.Model):
 
     __tablename__ = "justificatifs"
 
-    justif_id = db.Column(db.Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
+    justif_id = db.synonym("id")
 
     date_debut = db.Column(
         db.DateTime(timezone=True), server_default=db.func.now(), nullable=False
@@ -152,7 +158,7 @@ class Justificatif(db.Model):
 
     def to_dict(self) -> dict:
         data = {
-            "justif_id": self.assiduite_id,
+            "justif_id": self.justif_id,
             "etudid": self.etudid,
             "date_debut": self.date_debut,
             "date_fin": self.date_fin,
@@ -162,3 +168,41 @@ class Justificatif(db.Model):
             "entry_date": self.entry_date,
         }
         return data
+
+    @classmethod
+    def create_justificatif(
+        cls,
+        etud: Identite,
+        date_debut: datetime,
+        date_fin: datetime,
+        etat: EtatJustificatif,
+        raison: str = None,
+    ) -> object or int:
+        """Créer un nouveau justificatif pour l'étudiant"""
+        # Vérification de non duplication des périodes
+        justificatifs: list[Justificatif] = etud.justificatifs.all()
+
+        date_debut = localize_datetime(date_debut)
+        date_fin = localize_datetime(date_fin)
+        justificatifs = [
+            just
+            for just in justificatifs
+            if is_period_overlapping(
+                (date_debut, date_fin),
+                (just.date_debut, just.date_fin),
+            )
+        ]
+        if len(justificatifs) != 0:
+            raise ScoValueError(
+                "Duplication des justificatifs (la période rentrée rentre en conflit avec un justificatif enregistré)"
+            )
+
+        nouv_assiduite = Justificatif(
+            date_debut=date_debut,
+            date_fin=date_fin,
+            etat=etat,
+            etudiant=etud,
+            raison=raison,
+        )
+
+        return nouv_assiduite

app/scodoc/sco_archives_justificatifs.py

@@ -0,0 +1,90 @@
+from app.scodoc.sco_archives import BaseArchiver
+import os
+
+
+class JustificatifArchiver(BaseArchiver):
+    """
+
+    TOTALK:
+        - oid -> etudid
+        - archive_id -> date de création de l'archive (une archive par dépot de document)
+
+    justificatif
+        └── <dept_id>
+            └── <etudid/oid>
+                └── <archive_id>
+                    ├── [_description.txt]
+                    └── [<filename.ext>]
+
+
+    TODO:
+        - Faire fonction suppression fichier unique dans archive
+    """
+
+    def __init__(self):
+        BaseArchiver.__init__(self, archive_type="justificatifs")
+
+    def save_justificatif(
+        self,
+        etudid: int,
+        filename: str,
+        data: bytes or str,
+        archive_id: str = None,
+        description: str = "",
+    ):
+        """
+        Ajoute un fichier dans une archive "justificatif" pour l'etudid donné
+        """
+        if archive_id is None:
+            archive_id: str = self.create_obj_archive(
+                oid=etudid, description=description
+            )
+        else:
+            archive_id = self._true_archive_id(archive_id, etudid)
+
+        self.store(archive_id, filename, data)
+
+    def delete_justificatif(self, etudid: int, archive_id: str, filename: str = None):
+        """
+        Supprime une archive ou un fichier particulier de l'archivage de l'étudiant donné
+        """
+        if str(etudid) not in self.list_oids():
+            raise ValueError(f"Aucune archive pour etudid[{etudid}]")
+
+        archive_id = self._true_archive_id(archive_id, etudid)
+
+        if filename is not None:
+            if filename not in self.list_archive(archive_id):
+                raise ValueError(
+                    f"filename inconnu dans l'archive archive_id[{archive_id}] -> etudid[{etudid}]"
+                )
+
+            path: str = os.path.join(self.get_obj_dir(etudid), archive_id, filename)
+
+            if os.path.isfile(path):
+                os.remove(path)
+
+        else:
+            self.delete_archive(
+                os.path.join(
+                    self.get_obj_dir(etudid),
+                    archive_id,
+                )
+            )
+
+    def _true_archive_id(self, archive_id: str, etudid: int):
+        """
+        Test si l'archive_id est bien dans le dossier d'archive
+        Retourne le chemin complet de l'id
+        """
+        archives: list[str] = [
+            arc for arc in self.list_obj_archives(etudid) if archive_id in arc
+        ]
+
+        if len(archives) == 0:
+            raise ValueError(
+                f"archive_id[{archive_id}] inconnu pour etudid[{etudid}]",
+                self.list_obj_archives(etudid),
+            )
+
+        return archives[0]

app/scodoc/sco_assiduites.py

@@ -1,7 +1,7 @@
 from datetime import date, datetime, time, timedelta
 
 import app.scodoc.sco_utils as scu
-from app.models.assiduites import Assiduite
+from app.models.assiduites import Assiduite, Justificatif
 from app.models.etudiants import Identite
 from app.models.formsemestre import FormSemestre, FormSemestreInscription
 
@@ -15,11 +15,15 @@ def get_assiduites_stats(
     if filtered is not None:
         for key in filtered:
             if key == "etat":
-                assiduites = filter_by_etat(assiduites, filtered[key])
+                assiduites = filter_assiduites_by_etat(assiduites, filtered[key])
             elif key == "date_fin":
-                assiduites = filter_by_date(assiduites, filtered[key], sup=False)
+                assiduites = filter_assiduites_by_date(
+                    assiduites, filtered[key], sup=False
+                )
             elif key == "date_debut":
-                assiduites = filter_by_date(assiduites, filtered[key], sup=True)
+                assiduites = filter_assiduites_by_date(
+                    assiduites, filtered[key], sup=True
+                )
             elif key == "moduleimpl_id":
                 assiduites = filter_by_module_impl(assiduites, filtered[key])
             elif key == "formsemestre":
@@ -76,7 +80,7 @@ def get_count(assiduites: Assiduite) -> dict[str, int or float]:
     return output
 
 
-def filter_by_etat(assiduites: Assiduite, etat: str) -> Assiduite:
+def filter_assiduites_by_etat(assiduites: Assiduite, etat: str) -> Assiduite:
     """
     Filtrage d'une collection d'assiduites en fonction de leur état
     """
@@ -85,7 +89,7 @@ def filter_by_etat(assiduites: Assiduite, etat: str) -> Assiduite:
     return assiduites.filter(Assiduite.etat.in_(etats))
 
 
-def filter_by_date(
+def filter_assiduites_by_date(
     assiduites: Assiduite, date_: datetime, sup: bool = True
 ) -> Assiduite:
     """
@@ -106,6 +110,38 @@ def filter_by_date(
     return assiduites.filter(Assiduite.date_fin <= date_)
 
 
+def filter_justificatifs_by_etat(
+    justificatifs: Justificatif, etat: str
+) -> Justificatif:
+    """
+    Filtrage d'une collection de justificatifs en fonction de leur état
+    """
+    etats: list[str] = list(etat.split(","))
+    etats = [scu.ETATS_JUSTIFICATIF.get(e, -1) for e in etats]
+    return justificatifs.filter(Justificatif.etat.in_(etats))
+
+
+def filter_justificatifs_by_date(
+    justificatifs: Justificatif, date_: datetime, sup: bool = True
+) -> Assiduite:
+    """
+    Filtrage d'une collection d'assiduites en fonction d'une date
+
+    Sup == True -> les assiduites doivent débuter après 'date'\n
+    Sup == False -> les assiduites doivent finir avant 'date'
+    """
+
+    if date_.tzinfo is None:
+        first_justificatif: Justificatif = justificatifs.first()
+        if first_justificatif is not None:
+            date_: datetime = date_.replace(tzinfo=first_justificatif.date_debut.tzinfo)
+
+    if sup:
+        return justificatifs.filter(Justificatif.date_debut >= date_)
+
+    return justificatifs.filter(Justificatif.date_fin <= date_)
+
+
 def filter_by_module_impl(
     assiduites: Assiduite, module_impl_id: int or None
 ) -> Assiduite:

app/scodoc/sco_utils.py

@@ -128,6 +128,13 @@ ETAT_JUSTIFICATIF_NAME = {
     EtatJustificatif.MODIFIE: "modifié",
 }
 
+ETATS_JUSTIFICATIF = {
+    "validé": EtatJustificatif.VALIDE,
+    "non vaidé": EtatJustificatif.NON_VALIDE,
+    "en attente": EtatJustificatif.ATTENTE,
+    "modifié": EtatJustificatif.MODIFIE,
+}
+
 
 def is_iso_formated(date: str, convert=False) -> bool or datetime.datetime or None:
     """

migrations/versions/dbcf2175e87f_modèles_assiduites_justificatifs.py

@@ -1,8 +1,8 @@
-"""Modeles assiduites et justificatifs
+"""modèles assiduites justificatifs
 
-Revision ID: 961b2f2c595d
+Revision ID: dbcf2175e87f
 Revises: 5c7b208355df
-Create Date: 2023-01-31 15:37:02.961533
+Create Date: 2023-02-01 14:21:06.989190
 
 """
 from alembic import op
@@ -10,7 +10,7 @@ import sqlalchemy as sa
 
 
 # revision identifiers, used by Alembic.
-revision = '961b2f2c595d'
+revision = 'dbcf2175e87f'
 down_revision = '5c7b208355df'
 branch_labels = None
 depends_on = None
@@ -19,7 +19,7 @@ depends_on = None
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
     op.create_table('justificatifs',
-    sa.Column('justif_id', sa.Integer(), nullable=False),
+    sa.Column('id', sa.Integer(), nullable=False),
     sa.Column('date_debut', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
     sa.Column('date_fin', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
     sa.Column('etudid', sa.Integer(), nullable=False),
@@ -28,7 +28,7 @@ def upgrade():
     sa.Column('raison', sa.Text(), nullable=True),
     sa.Column('fichier', sa.Text(), nullable=True),
     sa.ForeignKeyConstraint(['etudid'], ['identite.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('justif_id')
+    sa.PrimaryKeyConstraint('id')
     )
     op.create_index(op.f('ix_justificatifs_etudid'), 'justificatifs', ['etudid'], unique=False)
     op.create_table('assiduites',

tests/api/test_api_justificatifs.py

@@ -0,0 +1,255 @@
+"""
+Test de l'api Assiduité
+
+Ecrit par HARTMANN Matthias
+
+"""
+
+from random import randint
+
+from tests.api.setup_test_api import GET, POST_JSON, APIError, api_headers
+
+ETUDID = 1
+FAUX = 42069
+
+
+JUSTIFICATIFS_FIELDS = {
+    "justif_id": int,
+    "etudid": int,
+    "date_debut": str,
+    "date_fin": str,
+    "etat": str,
+    "raison": str,
+    "entry_date": str,
+    "fichier": str,
+}
+
+CREATE_FIELD = {"justif_id": int}
+BATCH_FIELD = {"errors": dict, "success": dict}
+
+TO_REMOVE = []
+
+
+def check_fields(data, fields: dict = None):
+    if fields is None:
+        fields = JUSTIFICATIFS_FIELDS
+    assert set(data.keys()) == set(fields.keys())
+    for key in data:
+        if key in ("raison", "fichier"):
+            assert isinstance(data[key], fields[key]) or data[key] is None
+        else:
+            assert isinstance(data[key], fields[key])
+
+
+def check_failure_get(path, headers, err=None):
+    try:
+        GET(path=path, headers=headers)
+        # ^ Renvoi un 404
+    except APIError as api_err:
+        if err is not None:
+            assert api_err.payload["message"] == err
+    else:
+        raise APIError("Le GET n'aurait pas du fonctionner")
+
+
+def check_failure_post(path, headers, data, err=None):
+    try:
+        data = POST_JSON(path=path, headers=headers, data=data)
+        # ^ Renvoi un 404
+    except APIError as api_err:
+        if err is not None:
+            assert api_err.payload["message"] == err
+    else:
+        raise APIError("Le GET n'aurait pas du fonctionner")
+
+
+def create_data(etat: str, day: str, raison: str = None):
+    data = {
+        "date_debut": f"2022-01-{day}T08:00",
+        "date_fin": f"2022-01-{day}T10:00",
+        "etat": etat,
+    }
+    if raison is not None:
+        data["desc"] = raison
+
+    return data
+
+
+def test_route_justificatif(api_headers):
+
+    # Bon fonctionnement == id connu
+    data = GET(path="/justificatif/1", headers=api_headers)
+    check_fields(data)
+
+    # Mauvais Fonctionnement == id inconnu
+
+    check_failure_get(
+        f"/justificatif/{FAUX}",
+        api_headers,
+    )
+
+
+def test_route_justificatifs(api_headers):
+
+    # Bon fonctionnement
+
+    data = GET(path=f"/justificatifs/{ETUDID}", headers=api_headers)
+    assert isinstance(data, list)
+    for just in data:
+        check_fields(just, JUSTIFICATIFS_FIELDS)
+
+    data = GET(path=f"/justificatifs/{ETUDID}/query?", headers=api_headers)
+    assert isinstance(data, list)
+    for just in data:
+        check_fields(just, JUSTIFICATIFS_FIELDS)
+
+    # Mauvais fonctionnement
+    check_failure_get(f"/justificatifs/{FAUX}", api_headers)
+    check_failure_get(f"/justificatifs/{FAUX}/query?", api_headers)
+
+
+def test_route_create(api_headers):
+
+    # -== Unique ==-
+
+    # Bon fonctionnement
+    data = create_data("validé", "01")
+
+    res = POST_JSON(f"/justificatif/{ETUDID}/create", [data], api_headers)
+    check_fields(res, BATCH_FIELD)
+    assert len(res["success"]) == 1
+
+    TO_REMOVE.append(res["success"]["0"]["justif_id"])
+
+    data2 = create_data("modifié", "02", "raison")
+    res = POST_JSON(f"/justificatif/{ETUDID}/create", [data2], api_headers)
+    check_fields(res, BATCH_FIELD)
+    assert len(res["success"]) == 1
+
+    TO_REMOVE.append(res["success"]["0"]["justif_id"])
+
+    # Mauvais fonctionnement
+    check_failure_post(f"/justificatif/{FAUX}/create", api_headers, [data])
+
+    res = POST_JSON(f"/justificatif/{ETUDID}/create", [data], api_headers)
+    check_fields(res, BATCH_FIELD)
+    assert len(res["errors"]) == 1
+    assert (
+        res["errors"]["0"]
+        == "Duplication des justificatifs (la période rentrée rentre en conflit avec un justificatif enregistré)"
+    )
+
+    res = POST_JSON(
+        f"/justificatif/{ETUDID}/create",
+        [create_data("absent", "03")],
+        api_headers,
+    )
+    check_fields(res, BATCH_FIELD)
+    assert len(res["errors"]) == 1
+    assert res["errors"]["0"] == "param 'etat': invalide"
+
+    # -== Multiple ==-
+
+    # Bon Fonctionnement
+
+    etats = ["validé", "modifé", "non validé", "en attente"]
+    data = [
+        create_data(etats[d % 4], 10 + d, "raison" if d % 2 else None)
+        for d in range(randint(3, 5))
+    ]
+
+    res = POST_JSON(f"/justificatif/{ETUDID}/create", data, api_headers)
+    check_fields(res, BATCH_FIELD)
+    for dat in res["success"]:
+        check_fields(res["success"][dat], CREATE_FIELD)
+        TO_REMOVE.append(res["success"][dat]["justif_id"])
+
+    # Mauvais Fonctionnement
+
+    data2 = [
+        create_data("modifié", "01"),
+        create_data(None, "25"),
+        create_data("blabla", 26),
+        create_data("validé", 32),
+    ]
+
+    res = POST_JSON(f"/justificatif/{ETUDID}/create", data2, api_headers)
+    check_fields(res, BATCH_FIELD)
+    assert len(res["errors"]) == 4
+
+    assert (
+        res["errors"]["0"]
+        == "Duplication des justificatifs (la période rentrée rentre en conflit avec un justificatif enregistré)"
+    )
+    assert res["errors"]["1"] == "param 'etat': manquant"
+    assert res["errors"]["2"] == "param 'etat': invalide"
+    assert (
+        res["errors"]["3"]
+        == "param 'date_debut': format invalide, param 'date_fin': format invalide"
+    )
+
+
+def test_route_edit(api_headers):
+
+    # Bon fonctionnement
+
+    data = {"etat": "modifié", "raison": "test"}
+    res = POST_JSON(f"/justificatif/{TO_REMOVE[0]}/edit", data, api_headers)
+    assert res == {"OK": True}
+
+    data["raison"] = None
+    res = POST_JSON(f"/justificatif/{TO_REMOVE[1]}/edit", data, api_headers)
+    assert res == {"OK": True}
+
+    # Mauvais fonctionnement
+
+    check_failure_post(f"/justificatif/{FAUX}/edit", api_headers, data)
+    data["etat"] = "blabla"
+    check_failure_post(
+        f"/justificatif/{TO_REMOVE[2]}/edit",
+        api_headers,
+        data,
+        err="param 'etat': invalide",
+    )
+
+
+def test_route_delete(api_headers):
+    # -== Unique ==-
+
+    # Bon fonctionnement
+    data = TO_REMOVE[0]
+
+    res = POST_JSON("/justificatif/delete", [data], api_headers)
+    check_fields(res, BATCH_FIELD)
+    for dat in res["success"]:
+        assert res["success"][dat] == {"OK": True}
+
+    # Mauvais fonctionnement
+    res = POST_JSON("/justificatif/delete", [data], api_headers)
+    check_fields(res, BATCH_FIELD)
+    assert len(res["errors"]) == 1
+
+    # -== Multiple ==-
+
+    # Bon Fonctionnement
+
+    data = TO_REMOVE[1:]
+
+    res = POST_JSON("/justificatif/delete", data, api_headers)
+    check_fields(res, BATCH_FIELD)
+    for dat in res["success"]:
+        assert res["success"][dat] == {"OK": True}
+
+    # Mauvais Fonctionnement
+
+    data2 = [
+        FAUX,
+        FAUX + 1,
+        FAUX + 2,
+    ]
+
+    res = POST_JSON("/justificatif/delete", data2, api_headers)
+    check_fields(res, BATCH_FIELD)
+    assert len(res["errors"]) == 3
+
+    assert all([res["errors"][i] == "Justificatif non existant" for i in res["errors"]])

tests/api/test_api_permissions.py

@@ -60,6 +60,7 @@ def test_permissions(api_headers):
         "uid": 1,
         "version": "long",
         "assiduite_id": 1,
+        "justif_id": 1,
     }
     for rule in api_rules:
         path = rule.build(args)[1]

tests/unit/test_assiduites.py

@@ -142,7 +142,7 @@ def editer_supprimer_assiduiter(etuds: list[Identite], moduleimpls: list[int]):
 
     # Vérification du changement
     assert (
-        scass.filter_by_etat(etuds[0].assiduites, "retard").count() == 3
+        scass.filter_assiduites_by_etat(etuds[0].assiduites, "retard").count() == 3
     ), "Edition d'assiduité mauvais"
     assert (
         scass.filter_by_module_impl(etuds[1].assiduites, moduleimpls[0].id).count() == 2
@@ -294,22 +294,25 @@ def verifier_comptage_et_filtrage(
 
     # Etat
     assert (
-        scass.filter_by_etat(etu2.assiduites, "present").count() == 2
+        scass.filter_assiduites_by_etat(etu2.assiduites, "present").count() == 2
     ), "Filtrage de l'état 'présent' mauvais"
     assert (
-        scass.filter_by_etat(etu2.assiduites, "retard").count() == 2
+        scass.filter_assiduites_by_etat(etu2.assiduites, "retard").count() == 2
     ), "Filtrage de l'état 'retard' mauvais"
     assert (
-        scass.filter_by_etat(etu2.assiduites, "absent").count() == 2
+        scass.filter_assiduites_by_etat(etu2.assiduites, "absent").count() == 2
     ), "Filtrage de l'état 'absent' mauvais"
     assert (
-        scass.filter_by_etat(etu2.assiduites, "absent,retard").count() == 4
+        scass.filter_assiduites_by_etat(etu2.assiduites, "absent,retard").count() == 4
     ), "Filtrage de l'état 'absent,retard' mauvais"
     assert (
-        scass.filter_by_etat(etu2.assiduites, "absent,retard,present").count() == 6
+        scass.filter_assiduites_by_etat(
+            etu2.assiduites, "absent,retard,present"
+        ).count()
+        == 6
     ), "Filtrage de l'état 'absent,retard,present' mauvais"
     assert (
-        scass.filter_by_etat(etu2.assiduites, "autre").count() == 0
+        scass.filter_assiduites_by_etat(etu2.assiduites, "autre").count() == 0
     ), "Filtrage de l'état 'autre' mauvais"
 
     # Module
@@ -349,39 +352,39 @@ def verifier_comptage_et_filtrage(
     # Date début
     date = scu.localize_datetime("2022-09-01T10:00+01:00")
     assert (
-        scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 6
+        scass.filter_assiduites_by_date(etu2.assiduites, date, sup=True).count() == 6
     ), "Filtrage 'Date début' mauvais"
     date = scu.localize_datetime("2022-09-03T10:00:00+01:00")
     assert (
-        scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 5
+        scass.filter_assiduites_by_date(etu2.assiduites, date, sup=True).count() == 5
     ), "Filtrage 'Date début' mauvais"
     date = scu.localize_datetime("2022-09-03T10:00:01+01:00")
     assert (
-        scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 5
+        scass.filter_assiduites_by_date(etu2.assiduites, date, sup=True).count() == 5
     ), "Filtrage 'Date début' mauvais"
     date = scu.localize_datetime("2022-09-03T10:00:02+01:00")
     assert (
-        scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 4
+        scass.filter_assiduites_by_date(etu2.assiduites, date, sup=True).count() == 4
     ), "Filtrage 'Date début' mauvais"
 
     # Date fin
     date = scu.localize_datetime("2022-09-01T10:00+01:00")
     assert (
-        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 0
+        scass.filter_assiduites_by_date(etu2.assiduites, date, sup=False).count() == 0
     ), "Filtrage 'Date fin' mauvais"
     date = scu.localize_datetime("2022-09-03T10:00:00+01:00")
     assert (
-        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 1
+        scass.filter_assiduites_by_date(etu2.assiduites, date, sup=False).count() == 1
     ), "Filtrage 'Date fin' mauvais"
     date = scu.localize_datetime("2022-09-03T10:00:01+01:00")
     assert (
-        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 1
+        scass.filter_assiduites_by_date(etu2.assiduites, date, sup=False).count() == 1
     ), "Filtrage 'Date fin' mauvais"
     date = scu.localize_datetime("2023-01-04T13:00:01+01:00")
     assert (
-        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 6
+        scass.filter_assiduites_by_date(etu2.assiduites, date, sup=False).count() == 6
     ), "Filtrage 'Date fin' mauvais"
     date = scu.localize_datetime("2023-01-03T11:00:01+01:00")
     assert (
-        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 4
+        scass.filter_assiduites_by_date(etu2.assiduites, date, sup=False).count() == 4
     ), "Filtrage 'Date fin' mauvais"

tools/fakedatabase/create_test_api_database.py

@@ -11,14 +11,12 @@ import datetime
 import os
 import random
 import shutil
-import time
 import sys
+import time
 
-from app import db
+from app import db, models
 from app.auth.models import Role, User
 from app.but.import_refcomp import orebut_import_refcomp
-from app import models
-from app.models import departements
 from app.models import (
     Absence,
     Assiduite,
@@ -27,8 +25,10 @@ from app.models import (
     FormSemestre,
     FormSemestreEtape,
     Identite,
+    Justificatif,
     ModuleImpl,
     NotesNotes,
+    departements,
 )
 from app.scodoc import (
     sco_cache,
@@ -38,6 +38,7 @@ from app.scodoc import (
     sco_groups,
 )
 from app.scodoc.sco_permissions import Permission
+from app.scodoc.sco_utils import localize_datetime
 from tools.fakeportal.gen_nomprenoms import nomprenom
 
 random.seed(12345678)  # tests reproductibles
@@ -379,13 +380,12 @@ def create_logos():
     )
 
 
-def ajouter_assiduites(formsemestre: FormSemestre):
+def ajouter_assiduites_justificatifs(formsemestre: FormSemestre):
     """
     Ajoute des assiduités semi-aléatoires à chaque étudiant du semestre
     """
     MODS = [moduleimpl for moduleimpl in formsemestre.modimpls]
     MODS.append(None)
-    from app.scodoc.sco_utils import localize_datetime
 
     for etud in formsemestre.etuds:
 
@@ -408,6 +408,26 @@ def ajouter_assiduites(formsemestre: FormSemestre):
 
             db.session.add(code)
 
+        for i in range(random.randint(0, 2)):
+            etat = random.randint(0, 3)
+            deb_date = base_date + datetime.timedelta(days=i)
+            fin_date = deb_date + datetime.timedelta(hours=8)
+            raison = random.choice(["raison", None])
+
+            code = Justificatif.create_justificatif(
+                etud=etud,
+                date_debut=deb_date,
+                date_fin=fin_date,
+                etat=etat,
+                raison=raison,
+            )
+
+            assert isinstance(
+                code, Justificatif
+            ), "Erreur dans la génération des justificatifs"
+
+            db.session.add(code)
+
     db.session.commit()
 
 
@@ -431,7 +451,7 @@ def init_test_database():
         saisie_notes_evaluations(formsemestre, user_lecteur)
         add_absences(formsemestre)
         create_etape_apo(formsemestre)
-        ajouter_assiduites(formsemestre)
+        ajouter_assiduites_justificatifs(formsemestre)
     create_logos()
     # à compléter
     # - groupes