ScoDoc-Lille/app/api/absences.py

#################################################### 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")