1
0
forked from ScoDoc/ScoDoc
ScoDoc-Front/app/api/absences.py
2022-04-25 15:25:45 +02:00

299 lines
9.8 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#################################################### Absences #########################################################
from datetime import datetime
from flask import jsonify
from app import models
from app.api import bp
from app.api.errors import error_response
from app.api.auth import token_permission_required
from app.api.tools import get_etu_from_request
from app.scodoc.sco_abs import (
add_absence,
add_justif,
annule_absence,
annule_justif,
list_abs_date,
)
from app.scodoc.sco_groups import get_group_members
from app.scodoc.sco_permissions import Permission
@bp.route("/absences/etudid/<int:etudid>", methods=["GET"])
@bp.route("/absences/nip/<int:nip>", methods=["GET"])
@bp.route("/absences/ine/<int:ine>", methods=["GET"])
@token_permission_required(Permission.APIView)
def absences(etudid: int = None, nip: int = None, ine: int = None):
"""
Retourne la liste des absences d'un étudiant donné
etudid : l'etudid d'un étudiant
nip: le code nip d'un étudiant
ine : le code ine d'un étudiant
"""
if etudid is None:
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
# Récupération des absences de l'étudiant
abs = models.Absence.query.filter_by(etudid=etudid).all()
# Si l'étudiant a au minimum une absence
if len(abs) > 0:
# Mise en forme des données
data = [d.to_dict() for d in abs]
return jsonify(data)
return error_response(200, message="Aucune absence trouvé pour cet étudiant")
@bp.route("/absences/etudid/<int:etudid>/abs_just_only", methods=["GET"])
@bp.route("/absences/nip/<int:nip>/abs_just_only", methods=["GET"])
@bp.route("/absences/ine/<int:ine>/abs_just_only", methods=["GET"])
@token_permission_required(Permission.APIView)
def absences_justify(etudid: int = None, nip: int = None, ine: int = None):
"""
Retourne la liste des absences justifiées d'un étudiant donné
etudid : l'etudid d'un étudiant
nip: le code nip d'un étudiant
ine : le code ine d'un étudiant
"""
if etudid is None:
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
# Récupération des absences justifiées de l'étudiant
abs = models.Absence.query.filter_by(etudid=etudid, estjust=True).all()
# Si l'étudiant a au minimum une absence justifiées
if len(abs) > 0:
# Mise en forme des données
data = [d.to_dict() for d in abs]
return jsonify(data)
return error_response(
200, message="Aucune absence justifié trouvé pour cet étudiant"
)
### Inutil en définitif ###
@bp.route(
"/absences/abs_signale?etudid=<int:etudid>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>",
methods=["POST"],
)
@bp.route(
"/absences/abs_signale?nip=<int:nip>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>",
methods=["POST"],
)
@bp.route(
"/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>",
methods=["POST"],
)
@bp.route(
"/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>&moduleimpl_id=<int:moduleimpl_id>",
methods=["POST"],
)
@token_permission_required(Permission.APIAbsChange)
def abs_signale(
date: datetime,
matin: bool,
justif: bool,
etudid: int = None,
nip: int = None,
ine: int = None, ### Inutil en définitif
description: str = None,
moduleimpl_id: int = None,
):
"""
Permet d'ajouter une absence en base
date : la date de l'absence
matin : True ou False
justif : True ou False
etudid : l'etudid d'un étudiant
nip: le code nip d'un étudiant
ine : le code ine d'un étudiant
description : description possible à ajouter sur l'absence
moduleimpl_id : l'id d'un moduleimpl
"""
# Fonctions utilisées : app.scodoc.sco_abs.add_absence() et app.scodoc.sco_abs.add_justif()
if etudid is None:
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
try:
# Utilisation de la fonction add_absence
add_absence(etudid, date, matin, justif, description, moduleimpl_id)
if justif == True:
# Utilisation de la fonction add_justif
add_justif(etudid, date, matin, description)
except ValueError:
return error_response(
409, message="La requête ne peut être traitée en létat actuel"
)
@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_permission_required(Permission.APIAbsChange)
def abs_annule(
jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None
):
"""
Retourne un html
jour : la date de l'absence a annulé
matin : True ou False
etudid : l'etudid d'un étudiant
nip: le code nip d'un étudiant
ine : le code ine d'un étudiant
"""
# Fonction utilisée : app.scodoc.sco_abs.annule_absence()
if etudid is None:
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
try:
# Utilisation de la fonction annule_absence
annule_absence(etudid, jour, matin)
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que le 'jour' et le 'matin' sont valides",
)
return error_response(200, message="OK")
@bp.route(
"/absences/abs_annule_justif?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>",
methods=["POST"],
)
@bp.route(
"/absences/abs_annule_justif?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>",
methods=["POST"],
)
@bp.route(
"/absences/abs_annule_justif?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>",
methods=["POST"],
)
@token_permission_required(Permission.APIAbsChange)
def abs_annule_justif(
jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None
):
"""
Retourne un html
jour : la date de l'absence a annulé
matin : True ou False
etudid : l'etudid d'un étudiant
nip: le code nip d'un étudiant
ine : le code ine d'un étudiant
"""
# Fonction utilisée : app.scodoc.sco_abs.annule_justif()
if etudid is None:
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
try:
# Utilisation de la fonction annule_justif
annule_justif(etudid, jour, matin)
except ValueError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que le 'jour' et le 'matin' sont valides",
)
return error_response(200, message="OK")
@bp.route(
"/absences/abs_group_etat/?group_id=<int:group_id>&date_debut=date_debut&date_fin=date_fin",
methods=["GET"],
)
@token_permission_required(Permission.APIView)
def abs_groupe_etat(
group_id: int, date_debut, date_fin, with_boursier=True, format="html"
):
"""
Retoune la liste des absences d'un ou plusieurs groupes entre deux dates
"""
# Fonction utilisée : app.scodoc.sco_groups.get_group_members() et app.scodoc.sco_abs.list_abs_date()
try:
# Utilisation de la fonction get_group_members
members = get_group_members(group_id)
except ValueError:
return error_response(
409, message="La requête ne peut être traitée en létat actuel"
)
data = []
# Filtre entre les deux dates renseignées
for member in members:
abs = list_abs_date(member.id, date_debut, date_fin)
data.append(abs)
# return jsonify(data) # XXX TODO faire en sorte de pouvoir renvoyer sa (ex to_dict() dans absences)
return error_response(501, message="Not implemented")