MonScoDocEssai/app/but/jury_but_recap.py

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

"""Jury BUT et classiques: table recap annuelle et liens saisie
"""

import collections
import time
import numpy as np
from flask import g, url_for

from app.but import jury_but
from app.but.jury_but import (
    DecisionsProposeesAnnee,
    DecisionsProposeesRCUE,
    DecisionsProposeesUE,
)
from app.comp.res_but import ResultatsSemestreBUT
from app.comp.res_compat import NotesTableCompat
from app.comp import res_sem
from app.models import UniteEns
from app.models.etudiants import Identite
from app.scodoc.sco_exceptions import ScoNoReferentielCompetences
from app.models.formsemestre import FormSemestre
from app.scodoc import html_sco_header
from app.scodoc.sco_codes_parcours import (
    BUT_BARRE_RCUE,
    BUT_RCUE_SUFFISANT,
)
from app.scodoc import sco_formsemestre_status
from app.scodoc import sco_pvjury
from app.scodoc import sco_utils as scu
from app.tables.recap import RowRecap, TableRecap


class TableJury(TableRecap):
    """Cette table recap reprend les colonnes du tableau recap, sauf les évaluations,
    et ajoute:
    Pour le BUT:
        - les RCUEs (moyenne et code décision)
    Pour toutes les formations:
        - les codes de décisions jury sur les UEs
        - le lien de saisie ou modif de la décision de jury
    """

    def __init__(self, *args, row_class: str = None, read_only=True, **kwargs):
        super().__init__(
            *args, row_class=row_class or RowJury, finalize=False, **kwargs
        )
        # redéclare pour VSCode
        self.rows: list["RowJury"] = self.rows
        self.res: NotesTableCompat = self.res
        self.read_only = read_only
        # Stats jury: fréquence de chaque code enregistré
        self.freq_codes_annuels = collections.Counter()
        # Ajout colonnes spécifiques à la table jury:

        if self.res.is_apc:
            self.add_rcues()
        self.add_jury()
        self.add_groups_header()
        # Termine la table
        self.finalize()

    def add_rcues(self):
        """Ajoute les colonnes indiquant le nb de RCUEs et chaque RCUE
        pour tous les étudiants de la table.
        La table contient des rows avec la clé etudid.
        Les colonnes ont la classe css "rcue".
        """
        self.insert_group("rcue", before="col_ues_validables")
        for row in self.rows:
            etud: Identite = row.etud
            deca = row.deca
            if deca.code_valide:
                self.freq_codes_annuels[deca.code_valide] += 1
            row.add_nb_rcues_cell()
            # --- Les RCUEs
            for rcue in deca.rcues_annee:
                dec_rcue = deca.dec_rcue_by_ue.get(rcue.ue_1.id)
                if dec_rcue is not None:  # None si l'UE n'est pas associée à un niveau
                    row.add_rcue_cols(dec_rcue)

    def add_jury(self):
        """Ajoute la colonne code jury et le lien.
        Le code jury est celui du semestre: cette colonne n'est montrée
        que pour les formations classiques, ce code n'est pas utilisé en BUT.
        """
        res = self.res

        for row in self.rows:
            etud = row.etud
            if not res.is_apc:
                # formations classiques: code semestre
                if res.validations:
                    dec_sem = res.validations.decisions_jury.get(etud.id)
                    jury_code_sem = dec_sem["code"] if dec_sem else ""
                else:
                    jury_code_sem = ""
                row.add_cell(
                    "jury_code_sem", "Jury", jury_code_sem, group="jury_code_sem"
                )
                self.foot_title_row.cells["jury_code_sem"].target_attrs[
                    "title"
                ] = """Code jury sur le semestre"""

            row.add_cell(
                "jury_link",
                "",
                f"""{("modifier" if res.validations and res.validations.has_decision(etud) else "saisir")
                    if res.formsemestre.etat else "voir"} décisions""",
                group="col_jury_link",
                target=url_for(
                    "notes.formsemestre_validation_etud_form",
                    scodoc_dept=g.scodoc_dept,
                    formsemestre_id=res.formsemestre.id,
                    etudid=etud.id,
                ),
                target_attrs={"class": "stdlink"},
            )


class RowJury(RowRecap):
    "Ligne de la table saisie jury"

    def __init__(self, table: TableJury, etud: Identite, *args, **kwargs):
        self.table: TableJury = table
        super().__init__(table, etud, *args, **kwargs)
        if table.res.is_apc:
            # Conserve le deca de cet étudiant:
            self.deca = jury_but.DecisionsProposeesAnnee(
                self.etud, self.table.res.formsemestre
            )

    def add_nb_rcues_cell(self):
        "cell avec nb niveaux validables / total"
        deca = self.deca
        classes = ["col_rcue", "col_rcues_validables"]
        if deca.nb_rcues_under_8 > 0:
            classes.append("moy_ue_warning")
        elif deca.nb_validables < deca.nb_competences:
            classes.append("moy_ue_inf")
        else:
            classes.append("moy_ue_valid")

        if len(deca.rcues_annee) > 0:
            # permet un tri par nb de niveaux validables + moyenne gen indicative S_pair
            if deca.res_pair and deca.etud.id in deca.res_pair.etud_moy_gen:
                moy = deca.res_pair.etud_moy_gen[deca.etud.id]
                if np.isnan(moy):
                    moy_gen_d = "x"
                else:
                    moy_gen_d = f"{int(moy*1000):05}"
            else:
                moy_gen_d = "x"
            order = f"{deca.nb_validables:04d}-{moy_gen_d}"
        else:
            # étudiants sans RCUE: pas de semestre impair, ...
            # les classe à la fin
            order = f"{deca.nb_validables:04d}-00000-{deca.etud.sort_key}"

        self.add_cell(
            "rcues_validables",
            "RCUEs",
            f"""{deca.nb_validables}/{deca.nb_competences}"""
            + ((" " + scu.EMO_WARNING) if deca.nb_rcues_under_8 > 0 else ""),
            raw_content=f"""{deca.nb_validables}/{deca.nb_competences}""",
            group="rcue",
            classes=classes,
            data={"order": order},
        )

    def add_ue_cols(self, ue: UniteEns, ue_status: dict, col_group: str = None):
        "Ajoute 2 colonnes: moyenne d'UE et code jury"
        # table recap standard (mais avec group différent)
        super().add_ue_cols(ue, ue_status, col_group=col_group or "col_ue")
        dues = self.table.res.get_etud_decision_ues(self.etud.id)
        if not dues:
            return
        due = dues.get(ue.id)
        if not due:
            return
        col_id = f"moy_ue_{ue.id}_code"
        self.add_cell(
            col_id,
            "",  # titre vide
            due["code"],
            raw_content=due["code"],
            group="col_ue",
            classes=["recorded_code"],
            column_classes={"col_jury", "col_ue_code"},
            target_attrs={
                "title": f"""enregistrée le {due['event_date']}, {
                (due["ects"] or 0):.3g}&nbsp;ECTS."""
            },
        )

    def add_rcue_cols(self, dec_rcue: DecisionsProposeesRCUE):
        "2 cells: moyenne du RCUE, code enregistré"
        self.table.group_titles["rcue"] = "RCUEs en cours"
        rcue = dec_rcue.rcue
        col_id = f"moy_rcue_{rcue.ue_1.niveau_competence_id}"  # le niveau_id
        note_class = ""
        val = rcue.moy_rcue
        if isinstance(val, float):
            if val < BUT_BARRE_RCUE:
                note_class = "moy_ue_inf"
            elif val >= BUT_BARRE_RCUE:
                note_class = "moy_ue_valid"
            if val < BUT_RCUE_SUFFISANT:
                note_class = "moy_ue_warning"  # notes très basses
        self.add_cell(
            col_id,
            f"<div>{rcue.ue_1.acronyme}</div><div>{rcue.ue_2.acronyme}</div>",
            self.table.fmt_note(val),
            raw_content=val,
            group="rcue",
            classes=[note_class],
            column_classes={"col_rcue"},
        )
        self.add_cell(
            col_id + "_code",
            f"<div>{rcue.ue_1.acronyme}</div><div>{rcue.ue_2.acronyme}</div>",
            dec_rcue.code_valide or "",
            group="rcue",
            classes=["col_rcue_code", "recorded_code"],
            column_classes={"col_rcue"},
        )


def formsemestre_saisie_jury_but(
    formsemestre: FormSemestre,
    read_only: bool = False,
    selected_etudid: int = None,
    mode="jury",
) -> str:
    """formsemestre est un semestre PAIR
    Si readonly, ne montre pas le lien "saisir la décision"

    => page html complète

    Si mode == "recap", table recap des codes, sans liens de saisie.
    """
    # pour chaque etud de res2 trié
    #   S1: UE1, ..., UEn
    #   S2: UE1, ..., UEn
    #
    #   UE1_s1, UE1_s2, moy_rcue, UE2...   , Nbrcue_validables, Nbrcue<8, passage_de_droit, valide_moitie_rcue
    #
    # Pour chaque etud de res2 trié
    #   DecisionsProposeesAnnee(etud, formsemestre2)
    #      Pour le 1er etud, faire un check_ues_ready_jury(self) -> page d'erreur
    #   -> rcue .ue_1, .ue_2 -> stroe moy ues, rcue.moy_rcue,  etc

    if formsemestre.formation.referentiel_competence is None:
        raise ScoNoReferentielCompetences(formation=formsemestre.formation)

    res: ResultatsSemestreBUT = res_sem.load_formsemestre_results(formsemestre)
    table = TableJury(
        res,
        convert_values=True,
        mode_jury=True,
        read_only=read_only,
        classes=[
            "table_jury_but_bilan" if mode == "recap" else "",
            "table_recap",
            "apc",
            "jury table_jury_but",
        ],
        selected_row_id=selected_etudid,
    )
    if table.is_empty():
        return (
            '<div class="table_recap"><div class="message">aucun étudiant !</div></div>'
        )
    table.data["filename"] = scu.sanitize_filename(
        f"""jury-but-{formsemestre.titre_num()}-{time.strftime("%Y-%m-%d")}"""
    )
    table_html = table.html()
    H = [
        html_sco_header.sco_header(
            page_title=f"{formsemestre.sem_modalite()}: jury BUT",
            no_side_bar=True,
            init_qtip=True,
            javascripts=["js/etud_info.js", "js/table_recap.js"],
        ),
        sco_formsemestre_status.formsemestre_status_head(
            formsemestre_id=formsemestre.id
        ),
    ]
    if mode == "recap":
        H.append(
            f"""<h3>Décisions de jury enregistrées pour les étudiants de ce semestre</h3>
            <div class="table_jury_but_links">
                <div>
                    <ul>
                    <li><a href="{url_for(
                        "notes.pvjury_table_but",
                        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)
                    }" class="stdlink">Tableau PV de jury</a>
                    </li>
                    <li><a href="{url_for(
                        "notes.formsemestre_lettres_individuelles",
                        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)
                    }" class="stdlink">Courriers individuels (classeur pdf)</a>
                    </li>
                </div>
            </div>
            """
        )
    H.append(
        f"""
    <div class="table_recap">
    {table_html}
    </div>
    
    <div class="table_jury_but_links">
    """
    )

    if (mode == "recap") and not read_only:
        H.append(
            f"""
    <p><a class="stdlink" href="{url_for(
        "notes.formsemestre_saisie_jury",
        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)
    }">Saisie des décisions du jury</a>
    </p>"""
        )
    else:
        H.append(
            f"""
    <p><a class="stdlink" href="{url_for(
        "notes.formsemestre_validation_auto_but",
        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)
    }">Calcul automatique des décisions du jury</a>
    </p>
    <p><a class="stdlink" href="{url_for(
        "notes.formsemestre_jury_but_recap",
        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)
    }">Tableau récapitulatif des décisions du jury</a>
    </p>
    """
        )
    H.append(
        f"""
    </div>

    <div class="jury_stats">
        <div>Nb d'étudiants avec décision annuelle:
            {sum(table.freq_codes_annuels.values())} / {len(table)}
        </div>
        <div><b>Codes annuels octroyés:</b></div>
        <table class="jury_stats_codes">
    """
    )
    for code in sorted(table.freq_codes_annuels.keys()):
        H.append(
            f"""<tr>
            <td>{code}</td>
            <td style="text-align:right">{table.freq_codes_annuels[code]}</td>
            <td style="text-align:right">{
                (100*table.freq_codes_annuels[code] / len(table)):2.1f}%
            </td>
            </tr>"""
        )
    H.append(
        f"""
        </table>
    </div>
    {html_sco_header.sco_footer()}
    """
    )
    return "\n".join(H)


def build_table_jury_but_html(
    filename: str, rows, titles, column_ids, selected_etudid: int = None, klass=""
) -> str:
    """assemble la table html"""
    footer_rows = []  # inutilisé pour l'instant
    H = [
        f"""<div class="table_recap"><table class="table_recap apc jury table_jury_but {klass}"
            data-filename="{filename}">"""
    ]
    # header
    H.append(
        f"""
    <thead>
        {scu.gen_row(column_ids, titles, "th")}
    </thead>
    """
    )
    # body
    H.append("<tbody>")
    for row in rows:
        H.append(f"{scu.gen_row(column_ids, row, selected_etudid=selected_etudid)}\n")
    H.append("</tbody>\n")
    # footer
    H.append("<tfoot>")
    idx_last = len(footer_rows) - 1
    for i, row in enumerate(footer_rows):
        H.append(f'{scu.gen_row(column_ids, row, "th" if i == idx_last else "td")}\n')
    H.append(
        """
    </tfoot>
    </table>
    </div>
    """
    )
    return "".join(H)


class RowCollector:
    """Une ligne de la table"""

    def __init__(
        self,
        cells: dict = None,
        titles: dict = None,
        convert_values=True,
        column_classes: dict = None,
    ):
        self.titles = titles
        self.row = cells or {}  # col_id : str
        self.column_classes = column_classes  # col_id : str, css class
        self.idx = 0
        self.last_etud_cell_idx = 0
        if convert_values:
            self.fmt_note = scu.fmt_note
        else:
            self.fmt_note = lambda x: x

    def __setitem__(self, key, value):
        self.row[key] = value

    def __getitem__(self, key):
        return self.row[key]

    def get_row_dict(self):
        "La ligne, comme un dict"
        # create empty cells
        for col_id in self.titles:
            if col_id not in self.row:
                self.row[col_id] = ""
                klass = self.column_classes.get(col_id)
                if klass:
                    self.row[f"_{col_id}_class"] = klass
        return self.row

    def add_cell(
        self,
        col_id: str,
        title: str,
        content: str,
        classes: str = "",
        idx: int = None,
        column_class="",
    ):
        """Add a row to our table. classes is a list of css class names"""
        self.idx = idx if idx is not None else self.idx
        self.row[col_id] = content
        if classes:
            self.row[f"_{col_id}_class"] = classes + f" c{self.idx}"
        if not col_id in self.titles:
            self.titles[col_id] = title
            self.titles[f"_{col_id}_col_order"] = self.idx
            if classes:
                self.titles[f"_{col_id}_class"] = classes
        self.column_classes[col_id] = column_class
        self.idx += 1


def get_jury_but_table(  # XXX A SUPPRIMER apres avoir recupéré les stats
    formsemestre2: FormSemestre, read_only: bool = False, mode="jury", with_links=True
) -> tuple[list[dict], list[str], list[str], dict]:
    """Construit la table des résultats annuels pour le jury BUT
    => rows_dict, titles, column_ids, jury_stats
    où jury_stats est un dict donnant des comptages sur le jury.
    """

    # /////// XXX /////// XXX //////
    titles = {}  # column_id : title
    jury_stats = {
        "nb_etuds": len(formsemestre2.etuds_inscriptions),
        "codes_annuels": collections.Counter(),
    }
    table = TableJury(res2, mode_jury=True)
    for etudid in formsemestre2.etuds_inscriptions:
        etud: Identite = Identite.query.get(etudid)
        deca = jury_but.DecisionsProposeesAnnee(etud, formsemestre2)
        # XXX row = RowCollector(titles=titles, column_classes=column_classes)
        row = RowJury(table, etudid)
        table.add_row(row)
        row.add_etud(etud)
        # --- Nombre de niveaux
        row.add_nb_rcues_cell(deca)
        # --- Les RCUEs
        for rcue in deca.rcues_annee:
            dec_rcue = deca.dec_rcue_by_ue.get(rcue.ue_1.id)
            if dec_rcue is not None:  # None si l'UE n'est pas associée à un niveau
                row.add_ue_cells(deca.decisions_ues[rcue.ue_1.id])
                row.add_ue_cells(deca.decisions_ues[rcue.ue_2.id])
                row.add_rcue_cells(dec_rcue)
        # --- Les ECTS validés
        ects_valides = 0.0
        if deca.res_impair:
            ects_valides += deca.res_impair.get_etud_ects_valides(etudid)
        if deca.res_pair:
            ects_valides += deca.res_pair.get_etud_ects_valides(etudid)
        row.add_cell(
            "ects_annee",
            "ECTS",
            f"""{int(ects_valides)}""",
            "col_code_annee",
        )
        # --- Le code annuel existant
        row.add_cell(
            "code_annee",
            "Année",
            f"""{deca.code_valide or ''}""",
            "col_code_annee",
        )
        if deca.code_valide:
            jury_stats["codes_annuels"][deca.code_valide] += 1
        # --- Le lien de saisie
        if mode != "recap" and with_links:
            row.add_cell(
                "lien_saisie",
                "",
                f"""
                    <a href="{url_for(
                    'notes.formsemestre_validation_but',
                    scodoc_dept=g.scodoc_dept,
                    etudid=etud.id,
                    formsemestre_id=formsemestre2.id,
                )}" class="stdlink">
                    {"voir" if read_only else ("modif." if deca.code_valide else "saisie")}
                    décision</a>
                """
                if deca.inscription_etat == scu.INSCRIT
                else deca.inscription_etat,
                "col_lien_saisie_but",
            )
        rows.append(row)
    rows_dict = [row.get_row_dict() for row in rows]
    if len(rows_dict) > 0:
        col_idx = res2.recap_add_partitions(
            rows_dict, titles, col_idx=row.last_etud_cell_idx + 1
        )
        res2.recap_add_cursus(rows_dict, titles, col_idx=col_idx + 1)
    column_ids = [title for title in titles if not title.startswith("_")]
    column_ids.sort(key=lambda col_id: titles.get("_" + col_id + "_col_order", 1000))
    rows_dict.sort(key=lambda row: row["_nom_disp_order"])
    return rows_dict, titles, column_ids, jury_stats


def get_jury_but_results(formsemestre: FormSemestre) -> list[dict]:
    """Liste des résultats jury BUT sous forme de dict, pour API"""
    if formsemestre.formation.referentiel_competence is None:
        # pas de ref. comp., donc pas de decisions de jury (ne lance pas d'exception)
        return []
    dpv = sco_pvjury.dict_pvjury(formsemestre.id)
    rows = []
    for etudid in formsemestre.etuds_inscriptions:
        rows.append(get_jury_but_etud_result(formsemestre, dpv, etudid))
    return rows


def get_jury_but_etud_result(
    formsemestre: FormSemestre, dpv: dict, etudid: int
) -> dict:
    """Résultats de jury d'un étudiant sur un semestre pair de BUT"""
    etud: Identite = Identite.query.get(etudid)
    dec_etud = dpv["decisions_dict"][etudid]
    if formsemestre.formation.is_apc():
        deca = jury_but.DecisionsProposeesAnnee(etud, formsemestre)
    else:
        deca = None
    row = {
        "etudid": etud.id,
        "code_nip": etud.code_nip,
        "code_ine": etud.code_ine,
        "is_apc": dpv["is_apc"],  # BUT ou classic ?
        "etat": dec_etud["etat"],  # I ou D ou DEF
        "nb_competences": deca.nb_competences if deca else 0,
    }
    # --- Les RCUEs
    rcue_list = []
    if deca:
        for rcue in deca.rcues_annee:
            dec_rcue = deca.dec_rcue_by_ue.get(rcue.ue_1.id)
            if dec_rcue is not None:  # None si l'UE n'est pas associée à un niveau
                dec_ue1 = deca.decisions_ues[rcue.ue_1.id]
                dec_ue2 = deca.decisions_ues[rcue.ue_2.id]
                rcue_dict = {
                    "ue_1": {
                        "ue_id": rcue.ue_1.id,
                        "moy": None
                        if (dec_ue1.moy_ue is None or np.isnan(dec_ue1.moy_ue))
                        else dec_ue1.moy_ue,
                        "code": dec_ue1.code_valide,
                    },
                    "ue_2": {
                        "ue_id": rcue.ue_2.id,
                        "moy": None
                        if (dec_ue2.moy_ue is None or np.isnan(dec_ue2.moy_ue))
                        else dec_ue2.moy_ue,
                        "code": dec_ue2.code_valide,
                    },
                    "moy": rcue.moy_rcue,
                    "code": dec_rcue.code_valide,
                }
                rcue_list.append(rcue_dict)
    row["rcues"] = rcue_list
    # --- Les UEs
    ue_list = []
    if dec_etud["decisions_ue"]:
        for ue_id, ue_dec in dec_etud["decisions_ue"].items():
            ue_dict = {
                "ue_id": ue_id,
                "code": ue_dec["code"],
                "ects": ue_dec["ects"],
            }
            ue_list.append(ue_dict)
    row["ues"] = ue_list
    # --- Le semestre (pour les formations classiques)
    if dec_etud["decision_sem"]:
        row["semestre"] = {"code": dec_etud["decision_sem"].get("code")}
    else:
        row["semestre"] = {}  # APC, ...
    # --- Autorisations
    row["autorisations"] = dec_etud["autorisations"]
    return row