1
0
forked from ScoDoc/ScoDoc
ScoDoc-Front/app/api/assiduites.py

310 lines
8.8 KiB
Python
Raw Normal View History

##############################################################################
# ScoDoc
# Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved.
# See LICENSE
##############################################################################
"""ScoDoc 9 API : Assiduités
"""
from datetime import datetime
from pytz import UTC
from typing import List
from flask import g, jsonify, request
from app import db
from app.api import api_bp as bp
from app.scodoc.sco_utils import json_error
from app.decorators import scodoc, permission_required
from app.scodoc.sco_permissions import Permission
from flask_login import login_required
from app.models import Identite, Assiduite
import app.scodoc.sco_utils as scu
@bp.route("/assiduite/<int:assiduiteid>")
@scodoc
@permission_required(Permission.ScoView)
def assiduite(assiduiteid: int = None):
"""Retourne un objet assiduité à partir de son id
Exemple de résultat:
{
"assiduiteid": 1,
"etuid": 2,
"moduleimpl_id": 3,
"date_debut": "2022-10-31T08:00",
"date_fin": "2022-10-31T10:00",
"etat": "retard"
}
"""
assiduite = Assiduite.query.get(assiduiteid)
if assiduite is None:
return json_error(404, message="assiduité inexistante")
data = assiduite.to_dict()
return jsonify(change_etat(data))
@bp.route("/assiduites/<int:etuid>", defaults={"with_query": False})
@bp.route("/assiduites/<int:etuid>/query", defaults={"with_query": True})
@login_required
@scodoc
@permission_required(Permission.ScoView)
def assiduites(etuid: int = None, with_query: bool = False):
"""Retourne toutes les assiduités d'un étudiant"""
query = Identite.query.filter_by(id=etuid)
if g.scodoc_dept:
query = query.filter_by(dept_id=g.scodoc_dept_id)
etud: Identite = query.first_or_404(etuid)
assiduites: List[Assiduite] = etud.assiduites.all()
if with_query:
# cas 1 : etat assiduite
etat = request.args.get("etat")
if etat is not None:
etat = list(etat.split(","))
etat = [scu.ETATS_ASSIDUITE.get(e, "absent") for e in etat]
assiduites = [ass for ass in assiduites if ass.etat in etat]
# cas 2 : date de début
deb = request.args.get("date_debut")
deb: datetime = is_iso_formated(deb, True)
if deb is not None:
filtered_assiduites = []
for ass in assiduites:
if deb.tzinfo is None:
deb: datetime = deb.replace(tzinfo=ass.date_debut.tzinfo)
if ass.date_debut >= deb:
filtered_assiduites.append(ass)
assiduites.clear()
assiduites.extend(filtered_assiduites)
# cas 3 : date de fin
fin = request.args.get("date_fin")
fin = is_iso_formated(fin, True)
if fin is not None:
filtered_assiduites = []
for ass in assiduites:
if fin.tzinfo is None:
fin: datetime = fin.replace(tzinfo=ass.date_fin.tzinfo)
if ass.date_fin <= fin:
filtered_assiduites.append(ass)
assiduites.clear()
assiduites.extend(filtered_assiduites)
# cas 4 : moduleimpl_id
module = request.args.get("moduleimpl_id")
try:
module = int(module)
except Exception:
module = None
if module is not None:
assiduites = [ass for ass in assiduites if ass.moduleimpl_id == module]
data_set: List[dict] = []
for ass in assiduites:
data = ass.to_dict()
data_set.append(change_etat(data))
return jsonify(data_set)
@bp.route("/assiduite/<int:etuid>/create", methods=["POST"])
@scodoc
@permission_required(Permission.ScoView)
def create(etuid: int = None):
"""
Création d'une assiduité pour l'étudiant (etuid)
La requête doit avoir un content type "application/json":
{
"date_debut": str,
"date_fin": str,
"etat": str,
}
ou
{
"date_debut": str,
"date_fin": str,
"etat": str,
"moduleimpl_id": int,
}
"""
etud: Identite = Identite.query.filter_by(id=etuid).first_or_404()
data = request.get_json(force=True)
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_ASSIDUITE.keys():
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 = is_iso_formated(date_debut, 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 = is_iso_formated(date_fin, True)
if fin is None:
errors.append(f"param 'date_fin': format invalide")
# cas 4 : moduleimpl_id
moduleimpl_id = data.get("moduleimpl_id", None)
if moduleimpl_id is not None:
try:
moduleimpl_id: int = int(moduleimpl_id)
if moduleimpl_id < 0:
raise Exception
except:
errors.append("param 'moduleimpl_id': invalide")
if errors != []:
err: str = ", ".join(errors)
return json_error(404, err)
# TOUT EST OK
nouv_assiduite: Assiduite or str = Assiduite.create_assiduite(
date_debut=deb,
date_fin=fin,
etat=etat,
etud=etud,
module=moduleimpl_id,
)
if type(nouv_assiduite) is Assiduite:
return jsonify({"assiduiteid": nouv_assiduite.assiduiteid})
return json_error(
404,
{
1: "La période sélectionnée est déjà couverte par une autre assiduite",
2: "L'étudiant ne participe pas au moduleimpl sélectionné",
}.get(nouv_assiduite),
)
@bp.route("/assiduite/<int:assiduiteid>/delete", methods=["POST"])
@login_required
@scodoc
@permission_required(Permission.ScoAssiduiteChange)
def delete(assiduiteid: int):
"""
Suppression d'une assiduité à partir de son id
"""
assiduite: Assiduite = Assiduite.query.filter_by(id=assiduiteid).first_or_404()
db.session.delete(assiduite)
db.session.commit()
return jsonify({"OK": True})
@bp.route("/assiduite/<int:assiduiteid>/edit", methods=["POST"])
@login_required
@scodoc
@permission_required(Permission.ScoAssiduiteChange)
def edit(assiduiteid: int):
"""
Edition d'une assiduité à partir de son id
La requête doit avoir un content type "application/json":
{
"etat": str,
"moduleimpl_id": int
}
"""
assiduite: Assiduite = Assiduite.query.filter_by(id=assiduiteid).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:
assiduite.etat = data.get("etat")
# Cas 2 : Moduleimpl_id
moduleimpl_id = data.get("moduleimpl_id", False)
if moduleimpl_id is not False:
try:
if moduleimpl_id is not None:
moduleimpl_id: int = int(moduleimpl_id)
if moduleimpl_id < 0 or not Assiduite.verif_moduleimpl(
moduleimpl_id, assiduite.etudid
):
raise Exception
assiduite.moduleimpl_id = moduleimpl_id
except:
errors.append("param 'moduleimpl_id': invalide")
if errors != []:
err: str = ", ".join(errors)
return json_error(404, err)
db.session.add(assiduite)
db.session.commit()
return jsonify({"OK": True})
# -- 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_ASSIDUITE_NAME.get(data["etat"])
else:
data["etat"] = scu.ETATS_ASSIDUITE.get(data["etat"])
return data
def is_iso_formated(date: str, convert=False) -> bool or datetime or None:
"""
Vérifie si une date est au format iso
Retourne un booléen Vrai (ou un objet Datetime si convert = True)
si l'objet est au format iso
Retourne Faux si l'objet n'est pas au format et convert = False
Retourne None sinon
"""
import dateutil.parser as dtparser
try:
date: datetime = dtparser.isoparse(date)
if date.tzinfo is None:
date = UTC.localize(date)
return date if convert else True
except Exception:
return None if convert else False