ScoDoc/app/api/absences.py

#################################################### Absences #########################################################

from flask import jsonify

from app.api import bp
from app.api.errors import error_response
from app.api.auth import token_auth, token_permission_required
from app.models import Identite, FormSemestre

from app.scodoc import notesdb as ndb
from app.scodoc import sco_abs
from app.scodoc.sco_abs import list_abs_date, annule_absence, annule_justif, add_abslist
from app.scodoc.sco_groups import get_group_members
from app.scodoc.sco_permissions import Permission


@bp.route("/absences/etudid/<int:etudid>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def absences(etudid: int = None):
    """
    Retourne la liste des absences d'un étudiant donné

    etudid : l'etudid d'un étudiant

    Exemple de résultat:
    [
        {
        "jour": "2022-04-15",
        "matin": true,
        "estabs": true,
        "estjust": true,
        "description": "",
        "begin": "2022-04-15 08:00:00",
        "end": "2022-04-15 11:59:59"
        },
        {
        "jour": "2022-04-15",
        "matin": false,
        "estabs": true,
        "estjust": false,
        "description": "",
        "begin": "2022-04-15 12:00:00",
        "end": "2022-04-15 17:59:59"
        }
    ]
    """
    etud = Identite.query.get(etudid)
    if etud is None:
        return error_response(
            404,
            message="id de l'étudiant (etudid, nip, ine) inconnu",
        )
    # Absences de l'étudiant
    ndb.open_db_connection()
    absences = sco_abs.list_abs_date(etud.id)
    for absence in absences:
        absence["jour"] = absence["jour"].isoformat()
    return jsonify(absences)


@bp.route("/absences/etudid/<int:etudid>/just", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def absences_just(etudid: 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

    Exemple de résultat :
    [
        {
        "jour": "2022-04-15",
        "matin": true,
        "estabs": true,
        "estjust": true,
        "description": "",
        "begin": "2022-04-15 08:00:00",
        "end": "2022-04-15 11:59:59"
        },
        {
        "jour": "Fri, 15 Apr 2022 00:00:00 GMT",
        "matin": false,
        "estabs": true,
        "estjust": true,
        "description": "",
        "begin": "2022-04-15 12:00:00",
        "end": "2022-04-15 17:59:59"
        }
    ]
    """
    etud = Identite.query.get(etudid)
    if etud is None:
        return error_response(
            404,
            message="id de l'étudiant (etudid, nip, ine) inconnu",
        )

    # Absences justifiées de l'étudiant
    abs_just = [
        absence for absence in sco_abs.list_abs_date(etud.id) if absence["estjust"]
    ]
    for absence in abs_just:
        absence["jour"] = absence["jour"].isoformat()
    return jsonify(abs_just)


@bp.route(
    "/absences/abs_group_etat/<int:group_id>",
    methods=["GET"],
)
@bp.route(
    "/absences/abs_group_etat/group_id/<int:group_id>/date_debut/<string:date_debut>/date_fin/<string:date_fin>",
    methods=["GET"],
)
@token_auth.login_required
@token_permission_required(Permission.APIView)
def abs_groupe_etat(group_id: int, date_debut=None, date_fin=None):
    """
    Liste des absences d'un groupe (possibilité de choisir entre deux dates)

    group_id = l'id du groupe
    date_debut = None par défaut, sinon la date ISO du début de notre filtre
    date_fin = None par défaut, sinon la date ISO de la fin de notre filtre

    Exemple de résultat :
        [
          {
            "etudid": 1,
            "list_abs": []
          },
          {
            "etudid": 2,
            "list_abs": [
              {
                "jour": "Fri, 15 Apr 2022 00:00:00 GMT",
                "matin": true,
                "estabs": true,
                "estjust": true,
                "description": "",
                "begin": "2022-04-15 08:00:00",
                "end": "2022-04-15 11:59:59"
              },
              {
                "jour": "Fri, 15 Apr 2022 00:00:00 GMT",
                "matin": false,
                "estabs": true,
                "estjust": false,
                "description": "",
                "begin": "2022-04-15 12:00:00",
                "end": "2022-04-15 17:59:59"
              },
            ]
          },
          ...
        ]
    """
    # Fonction utilisée : app.scodoc.sco_groups.get_group_members() et app.scodoc.sco_abs.list_abs_date()

    # Utilisation de la fonction get_group_members
    members = get_group_members(group_id)

    data = []
    # Filtre entre les deux dates renseignées
    for member in members:
        abs = {
            "etudid": member["etudid"],
            "list_abs": sco_abs.list_abs_date(member["etudid"], date_debut, date_fin),
        }
        data.append(abs)

    return jsonify(data)


@bp.route(
    "/absences/formsemestre/<int:formsemestre_id>/etudid/<int:etudid>/set_etud_abs",
    methods=["GET"],
    defaults={"just_or_not": 0},
)
@bp.route(
    "/absences/formsemestre/<int:formsemestre_id>/etudid/<int:etudid>/set_etud_abs/only_not_just",
    methods=["GET"],
    defaults={"just_or_not": 1},
)
@bp.route(
    "/absences/formsemestre/<int:formsemestre_id>/etudid/<int:etudid>/set_etud_abs/only_just",
    methods=["GET"],
    defaults={"just_or_not": 2},
)
@token_auth.login_required
@token_permission_required(Permission.APIView)
def set_formsemestre_etud_abs(formsemestre_id: int, etudid: int, just_or_not: int = 0):
    """
    Set la liste des absences d'un étudiant sur tout un semestre.
    (les absences existant pour cet étudiant sur cette période sont effacées)

    formsemestre_id : l'id d'un semestre
    etudid : l'id d'un étudiant

    Exemple de résultat :
        [
            {
                "matin": true,
                "estabs": true,
                "estjust": true,
                "description": "",
                "begin": "2022-04-15 08:00:00",
                "end": "2022-04-15 11:59:59"
            },
            ...
        ]
    """
    formsemestre = FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
    date_debut = formsemestre.date_debut
    date_fin = formsemestre.date_fin

    list_abs = list_abs_date(etudid, date_debut, date_fin)

    if just_or_not == 0:
        for abs in list_abs:
            jour = abs["jour"].isoformat()
            if abs["matin"] is True:
                annule_absence(etudid, jour, True)
                annule_justif(etudid, jour, True)
            else:
                annule_absence(etudid, jour, False)
                annule_justif(etudid, jour, False)
        add_abslist(list_abs)
        # return jsonify(list_abs)

    elif just_or_not == 1:
        list_abs_not_just = []
        for abs in list_abs:
            if abs["estjust"] is False:
                list_abs_not_just.append(abs)
        for abs in list_abs:
            jour = abs["jour"].isoformat()
            if abs["matin"] is True:
                annule_absence(etudid, jour, True)
                annule_justif(etudid, jour, True)
            else:
                annule_absence(etudid, jour, False)
                annule_justif(etudid, jour, False)
        add_abslist(list_abs_not_just)
        # return jsonify(res)

    elif just_or_not == 2:
        list_abs_just = []
        for abs in list_abs:
            if abs["estjust"] is True:
                list_abs_just.append(abs)
        for abs in list_abs:
            jour = abs["jour"].isoformat()
            if abs["matin"] is True:
                annule_absence(etudid, jour, True)
                annule_justif(etudid, jour, True)
            else:
                annule_absence(etudid, jour, False)
                annule_justif(etudid, jour, False)
        add_abslist(list_abs_just)
        # return jsonify(res)