ScoDoc/app/api/partitions.py

##############################################################################
# ScoDoc
# Copyright (c) 1999 - 2022 Emmanuel Viennet.  All rights reserved.
# See LICENSE
##############################################################################

"""
  ScoDoc 9 API : partitions
"""
from flask import abort, jsonify, request

from app import db
from app.api import bp
from app.api.auth import token_auth, token_permission_required
from app.models import FormSemestre, FormSemestreInscription, Identite
from app.models import GroupDescr, Partition
from app.models.groups import group_membership
from app.scodoc import sco_cache
from app.scodoc.sco_permissions import Permission
from app.scodoc import sco_utils as scu


@bp.route("/partition/<int:partition_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def partition_info(partition_id: int):
    """
    Exemple de résultat :
    ```
    {
        'bul_show_rank': False,
        'formsemestre_id': 39,
        'groups': [
            {'id': 268, 'name': 'A', 'partition_id': 100},
            {'id': 269, 'name': 'B', 'partition_id': 100}
        ],
        'groups_editable': True,
        'id': 100,
        'numero': 100,
        'partition_name': 'TD',
        'show_in_lists': True
    }
    ```
    """
    partition = Partition.query.get_or_404(partition_id)
    return jsonify(partition.to_dict(with_groups=True))


@bp.route("/formsemestre/<int:formsemestre_id>/partitions", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def formsemestre_partitions(formsemestre_id: int):
    """
    Retourne la liste de toutes les partitions d'un formsemestre

    formsemestre_id : l'id d'un formsemestre

    """
    formsemestre: FormSemestre = FormSemestre.query.get_or_404(formsemestre_id)
    return jsonify(
        [partition.to_dict(with_groups=True) for partition in formsemestre.partitions]
    )


@bp.route("/group/<int:group_id>/etudiants", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def etud_in_group(group_id: int):
    """
    Retourne la liste des étudiants dans un groupe

    group_id : l'id d'un groupe

    Exemple de résultat :
    [
        {
        'civilite': 'M',
        'id': 123456,
        'ine': None,
        'nip': '987654321',
        'nom': 'MARTIN',
        'nom_usuel': null,
        'prenom': 'JEAN'}
        },
        ...
    ]
    """
    group = GroupDescr.query.get_or_404(group_id)
    return jsonify([etud.to_dict_short() for etud in group.etuds])


@bp.route("/group/<int:group_id>/etudiants/query", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def etud_in_group_query(group_id: int):
    """Etudiants du groupe, filtrés par état"""
    etat = request.args.get("etat")
    if etat not in {scu.INSCRIT, scu.DEMISSION, scu.DEF}:
        abort(404, "etat invalid")
    group = GroupDescr.query.get_or_404(group_id)
    query = (
        Identite.query.join(FormSemestreInscription)
        .filter_by(formsemestre_id=group.partition.formsemestre_id, etat=etat)
        .join(group_membership)
        .filter_by(group_id=group_id)
    )

    return jsonify([etud.to_dict_short() for etud in query])


@bp.route("/group/<int:group_id>/set_etudiant/<int:etudid>", methods=["POST"])
@token_auth.login_required
@token_permission_required(Permission.APIEditGroups)
def set_etud_group(etudid: int, group_id: int):
    """Affecte l'étudiant au groupe indiqué"""
    etud = Identite.query.get_or_404(etudid)
    group = GroupDescr.query.get_or_404(group_id)
    if etud.id not in {e.id for e in group.partition.formsemestre.etuds}:
        abort(404, "etud non inscrit au formsemestre du groupe")
    groups = (
        GroupDescr.query.filter_by(partition_id=group.partition.id)
        .join(group_membership)
        .filter_by(etudid=etudid)
    )
    ok = False
    for g in groups:
        if g.id == group_id:
            ok = True
        else:
            g.etuds.remove(etud)
    if not ok:
        group.etuds.append(etud)
    db.session.commit()
    return jsonify({"group_id": group_id, "etudid": etudid})


@bp.route("/partition/<int:partition_id>/group/create", methods=["POST"])
@token_auth.login_required
@token_permission_required(Permission.APIEditGroups)
def group_create(partition_id: int):
    """Création d'un groupe dans une partition

    The request content type should be "application/json":
    {
        "group_name" : nom_du_groupe,
    }
    """
    partition: Partition = Partition.query.get_or_404(partition_id)
    if not partition.groups_editable:
        abort(404, "partition non editable")
    data = request.get_json(force=True)  # may raise 400 Bad Request
    group_name = data.get("group_name")
    if group_name is None:
        abort(404, "missing group name or invalid data format")
    if not GroupDescr.check_name(partition, group_name):
        abort(404, "invalid group_name")
    group_name = group_name.strip()

    group = GroupDescr(group_name=group_name, partition_id=partition_id)
    db.session.add(group)
    db.session.commit()
    sco_cache.invalidate_formsemestre(partition.formsemestre_id)
    return jsonify(group.to_dict(with_partition=True))


@bp.route("/group/<int:group_id>/delete", methods=["POST"])
@token_auth.login_required
@token_permission_required(Permission.APIEditGroups)
def group_delete(group_id: int):
    """Suppression d'un groupe"""
    group = GroupDescr.query.get_or_404(group_id)
    if not group.partition.groups_editable:
        abort(404, "partition non editable")
    formsemestre_id = group.partition.formsemestre_id
    db.session.delete(group)
    db.session.commit()
    sco_cache.invalidate_formsemestre(formsemestre_id)
    return jsonify({"OK": 1})


@bp.route("/group/<int:group_id>/edit", methods=["POST"])
@token_auth.login_required
@token_permission_required(Permission.APIEditGroups)
def group_edit(group_id: int):
    """Edit a group"""
    group: GroupDescr = GroupDescr.query.get_or_404(group_id)
    if not group.partition.groups_editable:
        abort(404, "partition non editable")
    data = request.get_json(force=True)  # may raise 400 Bad Request
    group_name = data.get("group_name")
    if group_name is not None:
        if not GroupDescr.check_name(group.partition, group_name, existing=True):
            abort(404, "invalid group_name")
        group.group_name = group_name.strip()
        db.session.add(group)
        db.session.commit()
    sco_cache.invalidate_formsemestre(group.partition.formsemestre_id)
    return jsonify(group.to_dict(with_partition=True))


@bp.route("/formsemestre/<int:formsemestre_id>/partition/create", methods=["POST"])
@token_auth.login_required
@token_permission_required(Permission.APIEditGroups)
def partition_create(formsemestre_id: int):
    """Création d'une partition dans un semestre

    The request content type should be "application/json":
    {
        "partition_name": str,
        "numero":int,
        "bul_show_rank":bool,
        "show_in_lists":bool,
        "groups_editable":bool
    }
    """
    formsemestre: FormSemestre = FormSemestre.query.get_or_404(formsemestre_id)
    data = request.get_json(force=True)  # may raise 400 Bad Request
    partition_name = data.get("partition_name")
    if partition_name is None:
        abort(404, "missing partition_name or invalid data format")
    if not Partition.check_name(formsemestre, partition_name):
        abort(404, "invalid partition_name")
    numero = data.get("numero", 0)
    if not isinstance(numero, int):
        abort(404, "invalid type for numero")
    args = {
        "formsemestre_id": formsemestre_id,
        "partition_name": partition_name.strip(),
        "numero": numero,
    }
    for boolean_field in ("bul_show_rank", "show_in_lists", "groups_editable"):
        value = data.get(
            boolean_field, False if boolean_field != "groups_editable" else True
        )
        if not isinstance(boolean_field, bool):
            abort(404, f"invalid type for {boolean_field}")
        args[boolean_field] = value

    partition = Partition(**args)
    db.session.add(partition)
    db.session.commit()
    sco_cache.invalidate_formsemestre(formsemestre_id)
    return jsonify(partition.to_dict(with_groups=True))


@bp.route("/partition/<int:partition_id>/edit", methods=["POST"])
@token_auth.login_required
@token_permission_required(Permission.APIEditGroups)
def partition_edit(partition_id: int):
    """Modification d'une partition dans un semestre

    The request content type should be "application/json"
    All fields are optional:
    {
        "partition_name": str,
        "numero":int,
        "bul_show_rank":bool,
        "show_in_lists":bool,
        "groups_editable":bool
    }
    """
    partition = Partition.query.get_or_404(partition_id)
    data = request.get_json(force=True)  # may raise 400 Bad Request
    modified = False
    partition_name = data.get("partition_name")
    if partition_name is not None and partition_name != partition.partition_name:
        if not Partition.check_name(
            partition.formsemestre, partition_name, existing=True
        ):
            abort(404, "invalid partition_name")
        partition.partition_name = partition_name.strip()
        modified = True

    numero = data.get("numero")
    if numero is not None and numero != partition.numero:
        if not isinstance(numero, int):
            abort(404, "invalid type for numero")
        partition.numero = numero
        modified = True

    for boolean_field in ("bul_show_rank", "show_in_lists", "groups_editable"):
        value = data.get(boolean_field)
        if value is not None and value != getattr(partition, boolean_field):
            if not isinstance(boolean_field, bool):
                abort(404, f"invalid type for {boolean_field}")
            setattr(partition, boolean_field, value)
            modified = True

    if modified:
        db.session.add(partition)
        db.session.commit()
        sco_cache.invalidate_formsemestre(partition.formsemestre_id)

    return jsonify(partition.to_dict(with_groups=True))


@bp.route("/partition/<int:partition_id>/delete", methods=["POST"])
@token_auth.login_required
@token_permission_required(Permission.APIEditGroups)
def partition_delete(partition_id: int):
    """Suppression d'une partition (et de tous ses groupes).

    Note 1: La partition par défaut (tous les étudiants du sem.) ne peut
        pas être supprimée.
    Note 2: Si la partition de parcours est supprimée, les étudiants
        sont désinscrits des parcours.
    """
    partition = Partition.query.get_or_404(partition_id)
    if not partition.partition_name:
        abort(404, "ne peut pas supprimer la partition par défaut")
    is_parcours = partition.is_parcours()
    formsemestre: FormSemestre = partition.formsemestre
    db.session.delete(partition)
    sco_cache.invalidate_formsemestre(formsemestre.id)
    if is_parcours:
        formsemestre.update_inscriptions_parcours_from_groups()
    return jsonify({"OK": 1})