ScoDoc/tests/unit/test_but_jury.py

""" Test jury BUT avec parcours
"""
import os
from pathlib import Path
import re

from flask import current_app, g
import pytest
import yaml

import app
from app import db

from app.auth.models import User
from app.but.import_refcomp import orebut_import_refcomp
from app.models import (
    ApcNiveau,
    ApcParcours,
    ApcReferentielCompetences,
    Evaluation,
    Formation,
    FormSemestre,
    Identite,
    Module,
    ModuleImpl,
    ModuleUECoef,
    UniteEns,
)

from app.scodoc import sco_formations
from app.scodoc import sco_formsemestre_inscriptions
from app.scodoc import sco_groups
from app.scodoc import sco_saisie_notes
from app.scodoc import sco_utils as scu
from config import TestConfig

from tests.conftest import RESOURCES_DIR

DEPT = TestConfig.DEPT_TEST


def setup_but_formation(doc: dict) -> Formation:
    """Importe la formation BUT, l'associe au référentiel de compétences.
    Après cette fonction, on a une formation chargée, et associée à son ref. comp.
    """
    app.set_sco_dept(DEPT)
    refcomp_infos = doc["ReferentielCompetences"]
    formation_infos = doc["Formation"]
    refcomp_filename = refcomp_infos["filename"]
    refcomp_specialite = refcomp_infos["specialite"]
    # Lecture fichier XML local:
    with open(
        os.path.join(RESOURCES_DIR, "formations", formation_infos["filename"]),
        encoding="utf-8",
    ) as f:
        doc = f.read()

    # --- Création de la formation
    formation_id, _, _ = sco_formations.formation_import_xml(doc)
    formation: Formation = Formation.query.get(formation_id)
    assert formation
    # --- Chargement Référentiel
    if (
        ApcReferentielCompetences.query.filter_by(
            scodoc_orig_filename=refcomp_filename, dept_id=g.scodoc_dept_id
        ).first()
        is None
    ):
        # pas déjà chargé
        filename = (
            Path(current_app.config["SCODOC_DIR"])
            / "ressources/referentiels/but2022/competences"
            / refcomp_filename
        )
        with open(filename, encoding="utf-8") as f:
            xml_data = f.read()
            referentiel_competence = orebut_import_refcomp(
                xml_data, dept_id=g.scodoc_dept_id, orig_filename=Path(filename).name
            )
            assert referentiel_competence

    # --- Association au référentiel de compétences
    referentiel_competence = ApcReferentielCompetences.query.filter_by(
        specialite=refcomp_specialite
    ).first()  # le recherche à nouveau (test)
    assert referentiel_competence
    formation.referentiel_competence_id = referentiel_competence.id
    db.session.add(formation)
    # --- Association des UEs aux parcours niveaux de compétences
    for ue_acronyme, ue_infos in formation_infos["ues"].items():
        ue: UniteEns = formation.ues.filter_by(acronyme=ue_acronyme).first()
        assert ue is not None  # l'UE doit exister dans la formation avec cet acronyme
        # Parcours:
        if ue_infos.get("parcours", False):
            parcour = referentiel_competence.parcours.filter_by(
                code=ue_infos["parcours"]
            ).first()
            assert parcour is not None  # le parcours indiqué pour cette UE doit exister
            ue.set_parcour(parcour)

        # Niveaux compétences:
        competence = referentiel_competence.competences.filter_by(
            titre=ue_infos["competence"]
        ).first()
        assert competence is not None  # La compétence de titre indiqué doit exister
        niveau: ApcNiveau = competence.niveaux.filter_by(
            annee=ue_infos["annee"]
        ).first()
        assert niveau is not None  # le niveau de l'année indiquée doit exister
        ue.set_niveau_competence(niveau)

    db.session.commit()
    associe_modules_et_parcours(formation, formation_infos)
    return formation


def associe_modules_et_parcours(formation: Formation, formation_infos: dict):
    """Associe les modules à des parcours, grâce au champ modules_parcours"""
    for code_parcours, codes_modules in formation_infos.get(
        "modules_parcours", {}
    ).items():
        parcour = formation.referentiel_competence.parcours.filter_by(
            code=code_parcours
        ).first()
        assert parcour is not None  # code parcours doit exister dans le ref. comp.
        for code_module in codes_modules:
            for module in [
                module
                for module in formation.modules
                if re.match(code_module, module.code)
            ]:
                module.parcours.append(parcour)
                db.session.add(module)
    db.session.commit()


def _un_semestre(
    formation: Formation,
    parcours: list[ApcParcours],
    semestre_id: int,
    titre: str,
    date_debut: str,
    date_fin: str,
) -> FormSemestre:
    "Création d'un formsemetre"
    formsemestre = FormSemestre(
        formation=formation,
        parcours=parcours,
        dept_id=g.scodoc_dept_id,
        titre=titre,
        semestre_id=semestre_id,
        date_debut=date_debut,
        date_fin=date_fin,
    )
    # set responsable (list)
    a_user = User.query.first()
    formsemestre.responsables = [a_user]
    db.session.add(formsemestre)
    # Ajoute pour chaque UE une ressource avec un coef vers cette UE
    added_ressources = set()
    for parcour in parcours + [None]:
        for ue in formation.query_ues_parcour(parcour):
            ressource = (
                Module.query.filter_by(
                    formation=formation,
                    semestre_id=1,
                    module_type=scu.ModuleType.RESSOURCE,
                )
                .join(ModuleUECoef)
                .filter_by(ue=ue)
                .first()
            )
            if ressource is not None:
                if ressource.id not in added_ressources:
                    modimpl = ModuleImpl(module=ressource, responsable_id=a_user.id)
                    db.session.add(modimpl)
                    formsemestre.modimpls.append(modimpl)
                    added_ressources.add(ressource.id)

    # Ajoute la première SAE
    sae = formation.modules.filter_by(
        semestre_id=1, module_type=scu.ModuleType.SAE
    ).first()
    modimpl = ModuleImpl(module=sae, responsable_id=a_user.id)
    formsemestre.modimpls.append(modimpl)
    # Crée une évaluation dans chaque module
    create_evaluations(formsemestre)

    # Partition par défaut:
    db.session.commit()
    partition_id = sco_groups.partition_create(
        formsemestre.id, default=True, redirect=False
    )
    _ = sco_groups.create_group(partition_id, default=True)
    # Partition de parcours:
    formsemestre.setup_parcours_groups()

    return formsemestre


def create_evaluations(formsemestre: FormSemestre):
    """Crée une évaluation dans chaque module du semestre"""
    for modimpl in formsemestre.modimpls:
        evaluation = Evaluation(
            moduleimpl=modimpl,
            jour=formsemestre.date_debut,
            description=f"Exam {modimpl.module.titre}",
            coefficient=1.0,
            note_max=20.0,
            numero=1,
        )
        db.session.add(evaluation)
        # Affecte les mêmes poids que les coefs APC:
        ue_coef_dict = modimpl.module.get_ue_coef_dict()  # { ue_id : coef }
        evaluation.set_ue_poids_dict(ue_coef_dict)


def note_les_modules(doc: dict):
    """Saisie les notes des étudiants"""
    a_user = User.query.first()
    for nom, infos in doc["Etudiants"].items():
        etud: Identite = Identite.query.filter_by(nom=nom).first()
        assert etud is not None
        for titre, sem_infos in infos["formsemestres"].items():
            formsemestre: FormSemestre = FormSemestre.query.filter_by(
                titre=titre
            ).first()
            assert formsemestre is not None
            for code_module, note in sem_infos.get("notes_modules", {}).items():
                modimpl = (
                    formsemestre.modimpls.join(Module)
                    .filter_by(code=code_module)
                    .first()
                )
                # le sem. doit avoir un module du code indiqué:
                assert modimpl is not None
                for evaluation in modimpl.evaluations:
                    # s'il y a plusieurs evals, affecte la même note à chacune
                    sco_saisie_notes.notes_add(
                        a_user,
                        evaluation.id,
                        [(etud.id, float(note))],
                        comment="note_les_modules",
                    )


def setup_but_formsemestres(formation: Formation, doc: str):
    """Création des formsemestres pour tester les parcours BUT"""
    for titre, infos in doc["FormSemestres"].items():
        parcours = []
        for code_parcour in infos["codes_parcours"]:
            parcour = formation.referentiel_competence.parcours.filter_by(
                code=code_parcour
            ).first()
            assert parcour is not None
            parcours.append(parcour)
        _ = _un_semestre(
            formation,
            parcours,
            infos["idx"],
            titre,
            infos["date_debut"],
            infos["date_fin"],
        )

    db.session.flush()
    assert FormSemestre.query.count() == len(doc["FormSemestres"])


def inscrit_les_etudiants(formation: Formation, doc: dict):
    """Inscrit les étudiants dans chacun de leurs formsemestres"""
    for nom, infos in doc["Etudiants"].items():
        etud = Identite.create_etud(
            dept_id=g.scodoc_dept_id,
            nom=nom,
            prenom=infos["prenom"],
            civilite=infos["civilite"],
        )
        db.session.add(etud)
        db.session.commit()
        # L'inscrire à ses formsemestres
        for titre, sem_infos in infos["formsemestres"].items():
            formsemestre: FormSemestre = FormSemestre.query.filter_by(
                titre=titre
            ).first()
            assert formsemestre is not None
            partition_parcours = formsemestre.partitions.filter_by(
                partition_name=scu.PARTITION_PARCOURS
            ).first()
            if partition_parcours is None:
                group_ids = []
            else:
                group = partition_parcours.groups.filter_by(
                    group_name=sem_infos["parcours"]
                ).first()
                assert group is not None  # le groupe de parcours doit exister
                group_ids = [group.id]
            sco_formsemestre_inscriptions.do_formsemestre_inscription_with_modules(
                formsemestre.id,
                etud.id,
                group_ids=group_ids,
                etat=scu.INSCRIT,
                method="tests/unit/inscrit_les_etudiants",
            )
    # Met à jour les inscriptions:
    for formsemestre in formation.formsemestres:
        formsemestre.update_inscriptions_parcours_from_groups()


def test_but_jury(test_client):
    "Test jurys BUT1, BUT2 avec parcours"
    with open("tests/unit/cursus_but_gb.yaml", encoding="utf-8") as f:
        doc = yaml.safe_load(f.read())

    formation = setup_but_formation(doc)
    setup_but_formsemestres(formation, doc)

    inscrit_les_etudiants(formation, doc)

    note_les_modules(doc)