MonScoDocEssai/app/comp/res_compat.py

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

"""Classe résultats pour compatibilité avec le code ScoDoc 7
"""
from functools import cached_property

from flask import flash, g, Markup, url_for

from app import log
from app.comp import moy_sem
from app.comp.aux_stats import StatsMoyenne
from app.comp.res_common import ResultatsSemestre
from app.comp import res_sem
from app.models import FormSemestre
from app.models import Identite
from app.models import ModuleImpl
from app.scodoc.sco_codes_parcours import UE_SPORT, DEF
from app.scodoc import sco_utils as scu

# Pour raccorder le code des anciens codes qui attendent une NoteTable
class NotesTableCompat(ResultatsSemestre):
    """Implementation partielle de NotesTable

    Les méthodes définies dans cette classe sont là
    pour conserver la compatibilité abvec les codes anciens et
    il n'est pas recommandé de les utiliser dans de nouveaux
    développements (API malcommode et peu efficace).
    """

    _cached_attrs = ResultatsSemestre._cached_attrs + (
        "malus",
        "etud_moy_gen_ranks",
        "etud_moy_gen_ranks_int",
        "ue_rangs",
    )

    def __init__(self, formsemestre: FormSemestre):
        super().__init__(formsemestre)

        nb_etuds = len(self.etuds)
        self.ue_rangs = {u.id: (None, nb_etuds) for u in self.ues}
        self.mod_rangs = None  # sera surchargé en Classic, mais pas en APC
        """{ modimpl_id : (rangs, effectif) }"""
        self.moy_min = "NA"
        self.moy_max = "NA"
        self.moy_moy = "NA"
        self.expr_diagnostics = ""
        self.parcours = self.formsemestre.formation.get_parcours()

    def get_inscrits(self, include_demdef=True, order_by=False) -> list[Identite]:
        """Liste des étudiants inscrits
        order_by = False|'nom'|'moy' tri sur nom ou sur moyenne générale (indicative)

        Note: pour récupérer les etudids des inscrits, non triés, il est plus efficace
        d'utiliser `[ ins.etudid for ins in nt.formsemestre.inscriptions ]`
        """
        etuds = self.formsemestre.get_inscrits(
            include_demdef=include_demdef, order=(order_by == "nom")
        )
        if order_by == "moy":
            etuds.sort(
                key=lambda e: (
                    self.etud_moy_gen_ranks_int.get(e.id, 100000),
                    e.sort_key,
                )
            )
        return etuds

    def get_etudids(self) -> list[int]:
        """(deprecated)
        Liste des etudids inscrits, incluant les démissionnaires.
        triée par ordre alphabetique de NOM
        (à éviter: renvoie les etudids, mais est moins efficace que get_inscrits)
        """
        # Note: pour avoir les inscrits non triés,
        # utiliser [ ins.etudid for ins in self.formsemestre.inscriptions ]
        return [x["etudid"] for x in self.inscrlist]

    @cached_property
    def sem(self) -> dict:
        """le formsemestre, comme un gros et gras dict (nt.sem)"""
        return self.formsemestre.get_infos_dict()

    @cached_property
    def inscrlist(self) -> list[dict]:  # utilisé par PE
        """Liste des inscrits au semestre (avec DEM et DEF),
        sous forme de dict etud,
        classée dans l'ordre alphabétique de noms.
        """
        etuds = self.formsemestre.get_inscrits(include_demdef=True, order=True)
        return [e.to_dict_scodoc7() for e in etuds]

    @cached_property
    def stats_moy_gen(self):
        """Stats (moy/min/max) sur la moyenne générale"""
        return StatsMoyenne(self.etud_moy_gen)

    def get_ues_stat_dict(
        self, filter_sport=False, check_apc_ects=True
    ) -> list[dict]:  # was get_ues()
        """Liste des UEs, ordonnée par numero.
        Si filter_sport, retire les UE de type SPORT.
        Résultat: liste de dicts { champs UE U stats moyenne UE }
        """
        ues = self.formsemestre.query_ues(with_sport=not filter_sport)
        ues_dict = []
        for ue in ues:
            d = ue.to_dict()
            if ue.type != UE_SPORT:
                moys = self.etud_moy_ue[ue.id]
            else:
                moys = None
            d.update(StatsMoyenne(moys).to_dict())
            ues_dict.append(d)
        if check_apc_ects and self.is_apc and not hasattr(g, "checked_apc_ects"):
            g.checked_apc_ects = True
            if None in [ue.ects for ue in ues if ue.type != UE_SPORT]:
                formation = self.formsemestre.formation
                ue_sans_ects = [
                    ue for ue in ues if ue.type != UE_SPORT and ue.ects is None
                ]
                flash(
                    Markup(
                        f"""Calcul moyenne générale impossible: ECTS des UE manquants !<br>
                    (dans {' ,'.join([ue.acronyme for ue in ue_sans_ects])}
                    de la formation: <a href="{url_for("notes.ue_table",
                    scodoc_dept=g.scodoc_dept, formation_id=formation.id)
                    }">{formation.get_titre_version()}</a>)
                    )
                    """
                    ),
                    category="danger",
                )
        return ues_dict

    def get_modimpls_dict(self, ue_id=None) -> list[dict]:
        """Liste des modules pour une UE (ou toutes si ue_id==None),
        triés par numéros (selon le type de formation)
        """
        modimpls_dict = []
        for modimpl in self.formsemestre.modimpls_sorted:
            if (ue_id is None) or (modimpl.module.ue.id == ue_id):
                d = modimpl.to_dict()
                # compat ScoDoc < 9.2: ajoute matières
                d["mat"] = modimpl.module.matiere.to_dict()
                modimpls_dict.append(d)
        return modimpls_dict

    def compute_rangs(self):
        """Calcule les classements
        Moyenne générale: etud_moy_gen_ranks
        Par UE (sauf ue bonus)
        """
        (
            self.etud_moy_gen_ranks,
            self.etud_moy_gen_ranks_int,
        ) = moy_sem.comp_ranks_series(self.etud_moy_gen)
        for ue in self.formsemestre.query_ues():
            moy_ue = self.etud_moy_ue[ue.id]
            self.ue_rangs[ue.id] = (
                moy_sem.comp_ranks_series(moy_ue)[0],  # juste en chaine
                int(moy_ue.count()),
            )
            # .count() -> nb of non NaN values

    def get_etud_ue_rang(self, ue_id, etudid) -> tuple[str, int]:
        """Le rang de l'étudiant dans cette ue
        Result: rang:str, effectif:str
        """
        rangs, effectif = self.ue_rangs[ue_id]
        if rangs is not None:
            rang = rangs[etudid]
        else:
            return "", ""
        return rang, effectif

    def etud_check_conditions_ues(self, etudid):
        """Vrai si les conditions sur les UE sont remplies.
        Ne considère que les UE ayant des notes (moyenne calculée).
        (les UE sans notes ne sont pas comptées comme sous la barre)
        Prend en compte les éventuelles UE capitalisées.

        Pour les parcours habituels, cela revient à vérifier que
        les moyennes d'UE sont toutes > à leur barre (sauf celles sans notes)

        Pour les parcours non standards (LP2014), cela peut être plus compliqué.

        Return: True|False, message explicatif
        """
        ue_status_list = []
        for ue in self.formsemestre.query_ues():
            ue_status = self.get_etud_ue_status(etudid, ue.id)
            if ue_status:
                ue_status_list.append(ue_status)
        return self.parcours.check_barre_ues(ue_status_list)

    def all_etuds_have_sem_decisions(self):
        """True si tous les étudiants du semestre ont une décision de jury.
        Ne regarde pas les décisions d'UE.
        """
        for ins in self.formsemestre.inscriptions:
            if ins.etat != scu.INSCRIT:
                continue  # skip démissionnaires
            if self.get_etud_decision_sem(ins.etudid) is None:
                return False
        return True

    def etud_has_decision(self, etudid):
        """True s'il y a une décision de jury pour cet étudiant"""
        return self.get_etud_decision_ues(etudid) or self.get_etud_decision_sem(etudid)

    def get_etud_decision_ues(self, etudid: int) -> dict:
        """Decisions du jury pour les UE de cet etudiant, ou None s'il n'y en pas eu.
        Ne tient pas compte des UE capitalisées.
        { ue_id : { 'code' : ADM|CMP|AJ, 'event_date' : }
        Ne renvoie aucune decision d'UE pour les défaillants
        """
        if self.get_etud_etat(etudid) == DEF:
            return {}
        else:
            if not self.validations:
                self.validations = res_sem.load_formsemestre_validations(
                    self.formsemestre
                )
            return self.validations.decisions_jury_ues.get(etudid, None)

    def get_etud_decision_sem(self, etudid: int) -> dict:
        """Decision du jury prise pour cet etudiant, ou None s'il n'y en pas eu.
        { 'code' : None|ATT|..., 'assidu' : 0|1, 'event_date' : , compense_formsemestre_id }
        Si état défaillant, force le code a DEF
        """
        if self.get_etud_etat(etudid) == DEF:
            return {
                "code": DEF,
                "assidu": False,
                "event_date": "",
                "compense_formsemestre_id": None,
            }
        else:
            if not self.validations:
                self.validations = res_sem.load_formsemestre_validations(
                    self.formsemestre
                )
            return self.validations.decisions_jury.get(etudid, None)

    def get_etud_mat_moy(self, matiere_id: int, etudid: int) -> str:
        """moyenne d'un étudiant dans une matière (ou NA si pas de notes)"""
        if not self.moyennes_matieres:
            return "nd"
        return (
            self.moyennes_matieres[matiere_id].get(etudid, "-")
            if matiere_id in self.moyennes_matieres
            else "-"
        )

    def get_etud_mod_moy(self, moduleimpl_id: int, etudid: int) -> float:
        """La moyenne de l'étudiant dans le moduleimpl
        En APC, il s'agira d'une moyenne indicative sans valeur.
        Result: valeur float (peut être naN) ou chaîne "NI" (non inscrit ou DEM)
        """
        raise NotImplementedError()  # virtual method

    def get_etud_moy_gen(self, etudid):  # -> float | str
        """Moyenne générale de cet etudiant dans ce semestre.
        Prend en compte les UE capitalisées.
        Si apc, moyenne indicative.
        Si pas de notes: 'NA'
        """
        return self.etud_moy_gen[etudid]

    def get_etud_ects_pot(self, etudid: int) -> dict:
        """
        Un dict avec les champs
         ects_pot : (float) nb de crédits ECTS qui seraient validés
                    (sous réserve de validation par le jury)
         ects_pot_fond: (float) nb d'ECTS issus d'UE fondamentales (non électives)

        Ce sont les ECTS des UE au dessus de la barre (10/20 en principe), avant le jury (donc non
        encore enregistrées).
        """
        # was nt.get_etud_moy_infos
        # XXX pour compat nt, à remplacer ultérieurement
        ues = self.get_etud_ue_validables(etudid)
        ects_pot = 0.0
        for ue in ues:
            if (
                ue.id in self.etud_moy_ue
                and ue.ects is not None
                and self.etud_moy_ue[ue.id][etudid] > self.parcours.NOTES_BARRE_VALID_UE
            ):
                ects_pot += ue.ects
        return {
            "ects_pot": ects_pot,
            "ects_pot_fond": 0.0,  # not implemented (anciennemment pour école ingé)
        }

    def get_etud_rang(self, etudid: int) -> str:
        """Le rang (classement) de l'étudiant dans le semestre.
        Result: "13" ou "12 ex"
        """
        return self.etud_moy_gen_ranks.get(etudid, 99999)

    def get_etud_rang_group(self, etudid: int, group_id: int):
        "Le rang de l'étudiant dans ce groupe (NON IMPLEMENTE)"
        return (None, 0)  # XXX unimplemented TODO

    def get_evals_in_mod(self, moduleimpl_id: int) -> list[dict]:
        """Liste d'informations (compat NotesTable) sur évaluations completes
        de ce module.
        Évaluation "complete" ssi toutes notes saisies ou en attente.
        """
        modimpl = ModuleImpl.query.get(moduleimpl_id)
        modimpl_results = self.modimpls_results.get(moduleimpl_id)
        if not modimpl_results:
            return []  # safeguard
        evals_results = []
        for e in modimpl.evaluations:
            if modimpl_results.evaluations_completes_dict.get(e.id, False):
                d = e.to_dict()
                d["heure_debut"] = e.heure_debut  # datetime.time
                d["heure_fin"] = e.heure_fin
                d["jour"] = e.jour  # datetime
                d["notes"] = {
                    etud.id: {
                        "etudid": etud.id,
                        "value": modimpl_results.evals_notes[e.id][etud.id],
                    }
                    for etud in self.etuds
                }
                d["etat"] = {
                    "evalattente": modimpl_results.evaluations_etat[e.id].nb_attente,
                }
                evals_results.append(d)
            elif e.id not in modimpl_results.evaluations_completes_dict:
                # ne devrait pas arriver ? XXX
                log(
                    f"Warning: 220213 get_evals_in_mod {e.id} not in mod {moduleimpl_id} ?"
                )
        return evals_results

    def get_evaluations_etats(self):
        """[ {...evaluation et son etat...} ]"""
        # TODO: à moderniser
        from app.scodoc import sco_evaluations

        if not hasattr(self, "_evaluations_etats"):
            self._evaluations_etats = sco_evaluations.do_evaluation_list_in_sem(
                self.formsemestre.id
            )

        return self._evaluations_etats

    def get_mod_evaluation_etat_list(self, moduleimpl_id) -> list[dict]:
        """Liste des états des évaluations de ce module"""
        # XXX TODO à moderniser: lent, recharge des données que l'on a déjà...
        return [
            e
            for e in self.get_evaluations_etats()
            if e["moduleimpl_id"] == moduleimpl_id
        ]

    def get_moduleimpls_attente(self):
        """Liste des modimpls du semestre ayant des notes en attente"""
        return [
            modimpl
            for modimpl in self.formsemestre.modimpls_sorted
            if self.modimpls_results[modimpl.id].en_attente
        ]

    def get_mod_stats(self, moduleimpl_id: int) -> dict:
        """Stats sur les notes obtenues dans un modimpl
        Vide en APC
        """
        return {
            "moy": "-",
            "max": "-",
            "min": "-",
            "nb_notes": "-",
            "nb_missing": "-",
            "nb_valid_evals": "-",
        }

    def get_nom_short(self, etudid):
        "formatte nom d'un etud (pour table recap)"
        etud = self.identdict[etudid]
        return (
            (etud["nom_usuel"] or etud["nom"]).upper()
            + " "
            + etud["prenom"].capitalize()[:2]
            + "."
        )

    @cached_property
    def T(self):
        return self.get_table_moyennes_triees()

    def get_table_moyennes_triees(self) -> list:
        """Result: liste de tuples
        moy_gen, moy_ue_0, ..., moy_ue_n, moy_mod1, ..., moy_mod_n, etudid
        """
        table_moyennes = []
        etuds_inscriptions = self.formsemestre.etuds_inscriptions
        ues = self.formsemestre.query_ues(with_sport=True)  # avec bonus
        for etudid in etuds_inscriptions:
            moy_gen = self.etud_moy_gen.get(etudid, False)
            if moy_gen is False:
                # pas de moyenne: démissionnaire ou def
                t = (
                    ["-"]
                    + ["0.00"] * len(self.ues)
                    + ["NI"] * len(self.formsemestre.modimpls_sorted)
                )
            else:
                moy_ues = []
                ue_is_cap = {}
                for ue in ues:
                    ue_status = self.get_etud_ue_status(etudid, ue.id)
                    if ue_status:
                        moy_ues.append(ue_status["moy"])
                        ue_is_cap[ue.id] = ue_status["is_capitalized"]
                    else:
                        moy_ues.append("?")
                t = [moy_gen] + list(moy_ues)
                # Moyennes modules:
                for modimpl in self.formsemestre.modimpls_sorted:
                    if ue_is_cap.get(modimpl.module.ue.id, False):
                        val = "-c-"
                    else:
                        val = self.get_etud_mod_moy(modimpl.id, etudid)
                    t.append(val)
            t.append(etudid)
            table_moyennes.append(t)
        # tri par moyennes décroissantes,
        # en laissant les démissionnaires à la fin, par ordre alphabetique
        etuds = [ins.etud for ins in etuds_inscriptions.values()]
        etuds.sort(key=lambda e: e.sort_key)
        self._rang_alpha = {e.id: i for i, e in enumerate(etuds)}
        table_moyennes.sort(key=self._row_key)
        return table_moyennes

    def _row_key(self, x):
        """clé de tri par moyennes décroissantes,
        en laissant les demissionnaires à la fin, par ordre alphabetique.
        (moy_gen, rang_alpha)
        """
        try:
            moy = -float(x[0])
        except (ValueError, TypeError):
            moy = 1000.0
        return (moy, self._rang_alpha[x[-1]])

    @cached_property
    def identdict(self) -> dict:
        """{ etudid : etud_dict } pour tous les inscrits au semestre"""
        return {
            ins.etud.id: ins.etud.to_dict_scodoc7()
            for ins in self.formsemestre.inscriptions
        }