ScoDoc/ScoDoc
ScoDoc
/
ScoDoc
9
2
Fork 15
Code Issues 150 Pull Requests Projects 3 Releases 108 Wiki Activity

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

This commit is contained in:
iziram 2023-02-01 15:08:06 +01:00
parent 86f5751e79
commit 8bc780f2cf
12 changed files with 907 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
app/api/__init__.py
View File

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

52
app/api/assiduites.py
View File

@ -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)

386
app/api/justificatif.py Normal file
View File

@ -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

50
app/models/assiduites.py
View File

@ -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

90
app/scodoc/sco_archives_justificatifs.py Normal file
View File

@ -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]

48
app/scodoc/sco_assiduites.py
View File

@ -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:

7
app/scodoc/sco_utils.py
View File

@ -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:
"""

12
migrations/versions/961b2f2c595d_modeles_assiduites_et_justificatifs.py → migrations/versions/dbcf2175e87f_modèles_assiduites_justificatifs.py
View File

@ -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',

255
tests/api/test_api_justificatifs.py Normal file
View File

@ -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"]])

1
tests/api/test_api_permissions.py
View File

@ -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]

35
tests/unit/test_assiduites.py
View File

@ -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"

34
tools/fakedatabase/create_test_api_database.py
View File

@ -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