ScoDoc/app/scodoc/sco_saisie_excel.py

##############################################################################
#
# Gestion scolarite IUT
#
# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#   Emmanuel Viennet      emmanuel.viennet@viennet.net
#
##############################################################################

"""Fichier excel de saisie des notes
"""
from collections import defaultdict
from openpyxl.styles import Font, Border, Side, Alignment, PatternFill
from openpyxl.styles.numbers import FORMAT_GENERAL

from flask import flash, g, request, url_for
from flask_login import current_user

from app.models import Evaluation, Identite, Module, ScolarNews
from app.scodoc.sco_excel import COLORS, ScoExcelSheet
from app.scodoc import (
    html_sco_header,
    sco_evaluations,
    sco_excel,
    sco_groups,
    sco_groups_view,
    sco_saisie_notes,
    sco_users,
)
from app.scodoc.sco_exceptions import AccessDenied, InvalidNoteValue
import app.scodoc.sco_utils as scu
from app.scodoc.TrivialFormulator import TrivialFormulator

FONT_NAME = "Arial"


def excel_feuille_saisie(evaluation: "Evaluation", rows: list[dict]):
    """Genere feuille excel pour saisie des notes.
    E: evaluation (dict)
    lines: liste de tuples
               (etudid, nom, prenom, etat, groupe, val, explanation)
    """
    sheet_name = "Saisie notes"
    ws = ScoExcelSheet(sheet_name)
    styles = _build_styles()
    nb_lines_titles = _insert_top_title(ws, styles, evaluation=evaluation)

    _insert_line_titles(
        ws,
        nb_lines_titles,
        nb_rows_in_table=len(rows),
        evaluations=[evaluation],
        styles=styles,
    )

    # etudiants
    for row in rows:
        st = styles["nom"]
        if row["etat"] != scu.INSCRIT:
            st = styles["dem"]
            if row["etat"] == scu.DEMISSION:  # demissionnaire
                groupe_ou_etat = "DEM"
            else:
                groupe_ou_etat = row["etat"]  # etat autre
        else:
            groupe_ou_etat = row["groupes"]  # groupes TD/TP/...
        try:
            note_str = float(row["note"])  # export numérique excel
        except ValueError:
            note_str = row["note"]  # "ABS", ...
        ws.append_row(
            [
                ws.make_cell("!" + row["etudid"], styles["read-only"]),
                ws.make_cell(row["nom"], st),
                ws.make_cell(row["prenom"], st),
                ws.make_cell(groupe_ou_etat, st),
                ws.make_cell(note_str, styles["notes"]),  # note
                ws.make_cell(row["explanation"], styles["comment"]),  # comment
                ws.make_cell(row["code_nip"], styles["read-only"]),
            ]
        )

    # ligne blanche
    ws.append_blank_row()

    # explication en bas
    _insert_bottom_help(ws, styles)
    ws.set_column_dimension_hidden("A", True)  # colonne etudid cachée
    ws.set_column_dimension_hidden("G", True)  # colonne NIP cachée

    return ws.generate(
        column_widths={
            "A": 11.0 / 7,  # codes
            "B": 164.00 / 7,  # noms
            "C": 109.0 / 7,  # prenoms
            "D": "auto",  # groupes
            "E": 115.0 / 7,  # notes
            "F": 355.0 / 7,  # remarques
            "G": 72.0 / 7,  # colonne NIP
        }
    )


def _insert_line_titles(
    ws,
    current_line,
    nb_rows_in_table: int = 0,
    evaluations: list[Evaluation] = None,
    styles: dict = None,
) -> int:
    """Ligne(s) des titres, avec filtre auto excel.
    current_line : nb de lignes déjà dans le tableau
    nb_rows_in_table: nombre de ligne dans tableau à trier pour le filtre (nb d'étudiants)
    Renvoie nombre de lignes ajoutées (si plusieurs évaluations, indique les eval
    ids au dessus des titres)
    """
    # WIP
    assert len(evaluations) == 1
    evaluation = evaluations[0]

    # Filtre auto excel sur colonnes
    filter_top = current_line + 1
    filter_bottom = current_line + 1 + nb_rows_in_table
    filter_left = "A"  # important: le code etudid en col A doit être trié en même temps
    filter_right = "G"
    ws.set_auto_filter(f"${filter_left}${filter_top}:${filter_right}${filter_bottom}")

    # Code et titres colonnes
    ws.append_row(
        [
            ws.make_cell(f"!{evaluation.id}", styles["read-only"]),
            ws.make_cell("Nom", styles["titres"]),
            ws.make_cell("Prénom", styles["titres"]),
            ws.make_cell("Groupe", styles["titres"]),
            ws.make_cell(
                f"Note sur {(evaluation.note_max or 0.0):g}", styles["titres"]
            ),
            ws.make_cell("Remarque", styles["titres"]),
            ws.make_cell("NIP", styles["titres"]),
        ]
    )
    return 1  # WIP


def _build_styles() -> dict:
    """Déclare le styles excel"""

    # bordures
    side_thin = Side(border_style="thin", color=COLORS.BLACK.value)
    border_top = Border(top=side_thin)

    # fonds
    fill_light_yellow = PatternFill(
        patternType="solid", fgColor=COLORS.LIGHT_YELLOW.value
    )

    # styles
    font_base = Font(name=FONT_NAME, size=12)
    return {
        "base": {"font": font_base},
        "titres": {"font": Font(name=FONT_NAME, bold=True, size=14)},
        "explanation": {
            "font": Font(name=FONT_NAME, size=12, italic=True, color=COLORS.RED.value)
        },
        "read-only": {  # cells read-only
            "font": Font(name=FONT_NAME, color=COLORS.PURPLE.value),
            "border": Border(right=side_thin),
        },
        "dem": {
            "font": Font(name=FONT_NAME, color=COLORS.BROWN.value),
            "border": border_top,
        },
        "nom": {  # style pour nom, prenom, groupe
            "font": font_base,
            "border": border_top,
        },
        "notes": {
            "alignment": Alignment(horizontal="right"),
            "font": Font(name=FONT_NAME, bold=True),
            "number_format": FORMAT_GENERAL,
            "fill": fill_light_yellow,
            "border": border_top,
        },
        "comment": {
            "font": Font(name=FONT_NAME, size=9, color=COLORS.BLUE.value),
            "border": border_top,
        },
    }


def _insert_top_title(
    ws, styles: dict, evaluation: Evaluation = None, description=""
) -> int:
    """Insère les lignes de titre de la feuille (suivies d'une ligne blanche)
    renvoie le nb de lignes insérées
    """
    n = 0
    # ligne de titres (utilise prefix pour se placer à partir de la colonne B)
    ws.append_single_cell_row(
        "Feuille saisie note (à enregistrer au format excel)",
        styles["titres"],
        prefix=[""],
    )
    n += 1
    # lignes d'instructions
    ws.append_single_cell_row(
        "Saisir les notes dans la colonne E (cases jaunes)",
        styles["explanation"],
        prefix=[""],
    )
    ws.append_single_cell_row(
        "Ne pas modifier les cases en mauve !", styles["explanation"], prefix=[""]
    )
    n += 2
    # Nom du semestre
    titre_annee = evaluation.moduleimpl.formsemestre.titre_annee()
    ws.append_single_cell_row(
        scu.unescape_html(titre_annee), styles["titres"], prefix=[""]
    )
    n += 1
    # description evaluation
    date_str = (
        f"""du {evaluation.date_debut.strftime(scu.DATE_FMT)}"""
        if evaluation.date_debut
        else "(sans date)"
    )
    eval_titre = f"""{evaluation.description if evaluation.description else "évaluation"
        } {date_str}"""

    mod_responsable = sco_users.user_info(evaluation.moduleimpl.responsable_id)
    description = f"""{eval_titre} en {evaluation.moduleimpl.module.abbrev or ""} ({
        evaluation.moduleimpl.module.code
        }) resp. {mod_responsable["prenomnom"]}"""
    ws.append_single_cell_row(
        scu.unescape_html(description), styles["titres"], prefix=[""]
    )
    ws.append_single_cell_row(
        f"Evaluation {evaluation.descr_date()} (coef. {(evaluation.coefficient):g})",
        styles["base"],
        prefix=[""],
    )
    n += 2
    # ligne blanche
    ws.append_blank_row()
    n += 1
    return n


def _insert_bottom_help(ws, styles: dict):
    ws.append_row([None, ws.make_cell("Code notes", styles["titres"])])
    ws.append_row(
        [
            None,
            ws.make_cell("ABS", styles["explanation"]),
            ws.make_cell("absent (0)", styles["explanation"]),
        ]
    )
    ws.append_row(
        [
            None,
            ws.make_cell("EXC", styles["explanation"]),
            ws.make_cell("pas prise en compte", styles["explanation"]),
        ]
    )
    ws.append_row(
        [
            None,
            ws.make_cell("ATT", styles["explanation"]),
            ws.make_cell("en attente", styles["explanation"]),
        ]
    )
    ws.append_row(
        [
            None,
            ws.make_cell("SUPR", styles["explanation"]),
            ws.make_cell("pour supprimer note déjà entrée", styles["explanation"]),
        ]
    )
    ws.append_row(
        [
            None,
            ws.make_cell("", styles["explanation"]),
            ws.make_cell("cellule vide -> note non modifiée", styles["explanation"]),
        ]
    )


def feuille_saisie_notes(evaluation_id, group_ids: list[int] = None):
    """Vue: document Excel pour saisie notes dans l'évaluation et les groupes indiqués"""
    evaluation = Evaluation.get_evaluation(evaluation_id)
    group_ids = group_ids or []
    modimpl = evaluation.moduleimpl
    formsemestre = modimpl.formsemestre

    if evaluation.date_debut:
        indication_date = evaluation.date_debut.date().isoformat()
    else:
        indication_date = scu.sanitize_filename(evaluation.description)[:12]

    groups_infos = sco_groups_view.DisplayedGroupsInfos(
        group_ids=group_ids,
        formsemestre_id=formsemestre.id,
        select_all_when_unspecified=True,
        etat=None,
    )
    groups = sco_groups.listgroups(groups_infos.group_ids)
    gr_title_filename = sco_groups.listgroups_filename(groups)
    if None in [g["group_name"] for g in groups]:  # tous les etudiants
        getallstudents = True
        gr_title_filename = "tous"
    else:
        getallstudents = False
    etudids = [
        x[0]
        for x in sco_groups.do_evaluation_listeetuds_groups(
            evaluation_id, groups, getallstudents=getallstudents, include_demdef=True
        )
    ]

    # une liste de liste de chaines: lignes de la feuille de calcul
    rows = []
    etuds = sco_saisie_notes.get_sorted_etuds_notes(
        evaluation, etudids, formsemestre.id
    )
    for e in etuds:
        etudid = e["etudid"]
        groups = sco_groups.get_etud_groups(etudid, formsemestre.id)
        grc = sco_groups.listgroups_abbrev(groups)
        rows.append(
            {
                "etudid": str(etudid),
                "code_nip": e["code_nip"],
                "explanation": e["explanation"],
                "nom": e.get("nom_disp", "") or e.get("nom_usuel", "") or e["nom"],
                "prenom": e["prenom"].lower().capitalize(),
                "etat": e["inscr"]["etat"],
                "groupes": grc,
                "note": e["val"],
            }
        )

    eval_name = f"{evaluation.moduleimpl.module.code}-{indication_date}"
    filename = f"notes_{eval_name}_{gr_title_filename}"
    xls = excel_feuille_saisie(evaluation, rows=rows)
    return scu.send_file(xls, filename, scu.XLSX_SUFFIX, mime=scu.XLSX_MIMETYPE)


def do_evaluation_upload_xls() -> tuple[bool, str]:
    """
    Soumission d'un fichier XLS (evaluation_id, notefile)
    return:
        ok: bool
        msg: message diagonistic à affciher
    """
    args = scu.get_request_args()
    comment = args["comment"]
    evaluation = Evaluation.get_evaluation(args["evaluation_id"])

    # Check access (admin, respformation, responsable_id, ens)
    if not evaluation.moduleimpl.can_edit_notes(current_user):
        raise AccessDenied(f"Modification des notes impossible pour {current_user}")
    #
    diag, rows = sco_excel.excel_file_to_list(args["notefile"])
    try:
        if not rows:
            raise InvalidNoteValue()

        row_title_idx, evaluations, evaluations_col_idx = _get_sheet_evaluations(
            rows, evaluation=evaluation, diag=diag
        )
        # --- get notes -> list (etudid, value)
        # ignore toutes les lignes ne commençant pas par !
        notes_by_eval = defaultdict(
            list
        )  # { evaluation_id : [ (etudid, note_value), ... ] }
        ni = row_title_idx + 1
        for row in rows[row_title_idx + 1 :]:
            if row:
                cell0 = row[0].strip()
                if cell0 and cell0[0] == "!":
                    etudid = cell0[1:]
                    # check etud
                    etud = Identite.get_etud(etudid, accept_none=True)
                    if not etud:
                        diag.append(
                            f"étudiant id invalide en ligne {ni+1}"
                        )  # ligne excel à partir de 1
                    else:
                        _read_notes_evaluations(
                            row,
                            etud,
                            evaluations,
                            notes_by_eval,
                            evaluations_col_idx,
                        )
            ni += 1

        # -- Check values de chaque évaluation
        valid_notes_by_eval, etudids_without_notes_by_eval, etudids_absents_by_eval = (
            _check_notes_evaluations(evaluations, notes_by_eval, diag)
        )

        # -- Enregistre les notes de chaque évaluation
        messages_by_eval: dict[int, str] = {}
        etudids_with_decisions = set()
        for evaluation in evaluations:
            valid_notes = valid_notes_by_eval.get(evaluation.id)
            if not valid_notes:
                continue
            etudids_changed, nb_suppress, etudids_with_decisions_eval, messages = (
                sco_saisie_notes.notes_add(
                    current_user,
                    evaluation.id,
                    valid_notes_by_eval[evaluation.id],
                    comment,
                )
            )
            etudids_with_decisions |= set(etudids_with_decisions_eval)
            msg = f"""<div class="diag-evaluation">
                <ul>
                <li><div>Module {evaluation.moduleimpl.module.code} :
                    évaluation {evaluation.description} {evaluation.descr_date()}
                    </div>
                    <div>
                        {len(etudids_changed)} notes changées
                        ({len(etudids_without_notes_by_eval[evaluation.id])} sans notes,
                        {len(etudids_absents_by_eval[evaluation.id])} absents,
                        {nb_suppress} note supprimées)
                    </div>
                </li>
                </ul>
            """
            if messages:
                msg += f"""<div class="warning">Attention&nbsp;:
                    <ul>
                        <li>{
                        '</li><li>'.join(messages)
                        }
                        </li>
                    </ul>
                </div>"""
            msg += """</div>"""
            messages_by_eval[evaluation.id] = msg

        # -- News
        module: Module = evaluation.moduleimpl.module
        status_url = url_for(
            "notes.moduleimpl_status",
            scodoc_dept=g.scodoc_dept,
            moduleimpl_id=evaluation.moduleimpl_id,
            _external=True,
        )
        ScolarNews.add(
            typ=ScolarNews.NEWS_NOTE,
            obj=evaluation.moduleimpl_id,
            text=f"""Chargement notes dans <a href="{status_url}">{
                        module.titre or module.code}</a>""",
            url=status_url,
            max_frequency=30 * 60,  # 30 minutes
        )

        if etudids_with_decisions:
            msg += """<p class="warning"><b>Important:</b> il y avait déjà des décisions de jury
                enregistrées, qui sont à revoir suite à cette modification !</p>
                """
        return True, msg

    except InvalidNoteValue:
        if diag:
            msg = (
                '<ul class="tf-msg"><li class="tf_msg">'
                + '</li><li class="tf_msg">'.join(diag)
                + "</li></ul>"
            )
        else:
            msg = '<ul class="tf-msg"><li class="tf_msg">Une erreur est survenue</li></ul>'
        return False, msg + "<p>(pas de notes modifiées)</p>"


def _check_notes_evaluations(
    evaluations: list[Evaluation],
    notes_by_eval: dict[int, list[tuple[int, str]]],
    diag: list[str],
) -> tuple[dict[int, list[tuple[int, str]]], list[int], list[int]]:
    """Vérifie que les notes pour ces évaluations sont valides.
    Raise InvalidNoteValue et rempli diag si ce n'est pas le cas.
    Renvoie un dict donnant la liste des notes converties pour chaque évaluation.
    """
    valid_notes_by_eval = {}
    etudids_without_notes_by_eval = {}
    etudids_absents_by_eval = {}
    for evaluation in evaluations:
        (
            valid_notes_by_eval[evaluation.id],
            invalids,
            etudids_without_notes_by_eval[evaluation.id],
            etudids_absents_by_eval[evaluation.id],
            etudids_non_inscrits,
        ) = sco_saisie_notes.check_notes(notes_by_eval[evaluation.id], evaluation)
        if invalids:
            diag.append(
                f"Erreur: la feuille contient {len(invalids)} notes invalides</p>"
            )
            if len(invalids) < 25:
                etudsnames = [
                    Identite.get_etud(etudid).nom_prenom() for etudid in invalids
                ]
                diag.append("Notes invalides pour: " + ", ".join(etudsnames))
            else:
                diag.append("Notes invalides pour plus de 25 étudiants")
            raise InvalidNoteValue()
        if etudids_non_inscrits:
            diag.append(
                f"""Erreur: la feuille contient {len(etudids_non_inscrits)
                    } étudiants non inscrits</p>"""
            )
            if len(etudids_non_inscrits) < 25:
                diag.append(
                    "etudid invalides (inexistants ou non inscrits): "
                    + ", ".join(str(etudid) for etudid in etudids_non_inscrits)
                )
            else:
                diag.append("etudid invalides sur plus de 25 lignes")
            raise InvalidNoteValue()
    return valid_notes_by_eval, etudids_without_notes_by_eval, etudids_absents_by_eval


def _read_notes_evaluations(
    row: list[str],
    etud: Identite,
    evaluations: list[Evaluation],
    notes_by_eval: dict[int, list[tuple[int, str]]],
    evaluations_col_idx: dict[int, int],
):
    """Lit les notes sur une ligne (étudiant etud).
    Ne vérifie pas la valeur de la note.
    """
    for evaluation in evaluations:
        col_idx = evaluations_col_idx[evaluation.id]
        if len(row) > col_idx:
            val = row[col_idx].strip()
        else:
            val = ""  # ligne courte: cellule vide
        notes_by_eval[evaluation.id].append((etud.id, val))


def _get_sheet_evaluations(
    rows: list[list[str]], evaluation: Evaluation | None = None, diag: list[str] = None
) -> tuple[int, list[Evaluation], dict[int, int]]:
    """
    rows: les valeurs (str) des cellules de la feuille
    diag: liste dans laquelle accumuler les messages d'erreur
    evaluation (optionnel): l'évaluation que l'on cherche à remplir (pour feuille mono-évaluation)
    formsemestre (optionnel): le formsemestre dans lequel sont les évaluations à remplir
        formsemestre ou evaluation doivent être indiqués.

    Résultat:
    row_title_idx: l'indice (à partir de 0) de la ligne titre (après laquelle commencent les notes)
    evaluations: liste des évaluations à remplir
    evaluations_col_idx: { evaluation_id : indice de sa colonne dans la feuille }
    """
    # -- search eval code: first cell in 1st column beginning by "!"
    eval_code = None
    for i, row in enumerate(rows):
        if not row:
            diag.append("Erreur: format invalide (ligne vide ?)")
            raise InvalidNoteValue()
        eval_code = row[0].strip()
        if eval_code.startswith("!"):
            break
    if not eval_code:
        diag.append("Erreur: format invalide ! (pas de ligne evaluation_id)")
        raise InvalidNoteValue()

    try:
        sheet_eval_id = int(eval_code[1:])
    except ValueError:
        sheet_eval_id = None
    if sheet_eval_id != evaluation.id:
        diag.append(
            f"""Erreur: fichier invalide: le code d'évaluation de correspond pas ! ('{
                sheet_eval_id or ('non trouvé')}' != '{evaluation.id}')"""
        )
        raise InvalidNoteValue()

    return i, [evaluation], {evaluation.id: 4}


def saisie_notes_tableur(evaluation_id: int, group_ids=()):
    """Saisie des notes via un fichier Excel"""
    evaluation = Evaluation.query.get_or_404(evaluation_id)
    moduleimpl_id = evaluation.moduleimpl.id
    formsemestre_id = evaluation.moduleimpl.formsemestre_id
    if not evaluation.moduleimpl.can_edit_notes(current_user):
        return (
            html_sco_header.sco_header()
            + f"""
                <h2>Modification des notes impossible pour {current_user.user_name}</h2>
                <p>(vérifiez que le semestre n'est pas verrouillé et que vous
                avez l'autorisation d'effectuer cette opération)
                </p>
                <p><a class="stdlink" href="{
                url_for("notes.moduleimpl_status", scodoc_dept=g.scodoc_dept,
                    moduleimpl_id=moduleimpl_id)
                }">Continuer</a></p>
               """
            + html_sco_header.sco_footer()
        )

    page_title = "Saisie des notes" + (
        f""" de {evaluation.description}""" if evaluation.description else ""
    )

    # Informations sur les groupes à afficher:
    groups_infos = sco_groups_view.DisplayedGroupsInfos(
        group_ids=group_ids,
        formsemestre_id=formsemestre_id,
        select_all_when_unspecified=True,
        etat=None,
    )

    H = [
        html_sco_header.sco_header(
            page_title=page_title,
            javascripts=sco_groups_view.JAVASCRIPTS,
            cssstyles=sco_groups_view.CSSSTYLES,
            init_qtip=True,
        ),
        sco_evaluations.evaluation_describe(evaluation_id=evaluation_id),
        """<span class="eval_title">Saisie des notes par fichier</span>""",
    ]

    # Menu choix groupe:
    H.append("""<div id="group-tabs"><table><tr><td>""")
    H.append(sco_groups_view.form_groups_choice(groups_infos))
    H.append("</td></tr></table></div>")

    H.append(
        f"""<div class="saisienote_etape1">
        <span class="titredivsaisienote">Etape 1 : </span>
        <ul>
        <li><a class="stdlink" href="feuille_saisie_notes?evaluation_id={evaluation_id}&{
            groups_infos.groups_query_args}"
            id="lnk_feuille_saisie">obtenir le fichier tableur à remplir</a>
        </li>
        <li>ou <a class="stdlink" href="{url_for("notes.saisie_notes",
            scodoc_dept=g.scodoc_dept, evaluation_id=evaluation_id)
        }">aller au formulaire de saisie</a></li>
        </ul>
        </div>
        <form>
            <input type="hidden" name="evaluation_id" id="formnotes_evaluation_id"
                value="{evaluation_id}"/>
        </form>
        """
    )

    H.append(
        """<div class="saisienote_etape2">
    <span class="titredivsaisienote">Etape 2 : chargement d'un fichier de notes</span>"""  # '
    )

    nf = TrivialFormulator(
        request.base_url,
        scu.get_request_args(),
        (
            ("evaluation_id", {"default": evaluation_id, "input_type": "hidden"}),
            (
                "notefile",
                {"input_type": "file", "title": "Fichier de note (.xls)", "size": 44},
            ),
            (
                "comment",
                {
                    "size": 44,
                    "title": "Commentaire",
                    "explanation": "(la colonne remarque du fichier excel est ignorée)",
                },
            ),
        ),
        formid="notesfile",
        submitlabel="Télécharger",
    )
    if nf[0] == 0:
        H.append(
            """<p>Le fichier doit être un fichier tableur obtenu via
        l'étape 1 ci-dessus, puis complété et enregistré au format Excel.
        </p>"""
        )
        H.append(nf[1])
    elif nf[0] == -1:
        H.append("<p>Annulation</p>")
    elif nf[0] == 1:
        updiag = do_evaluation_upload_xls()
        if updiag[0]:
            H.append(
                f"""
            <div class="notes-chargees">
                <div><b>Notes chargées !</b></div>
                {updiag[1]}
            </div>
            <a class="stdlink" href="{
                url_for("notes.moduleimpl_status",
                    scodoc_dept=g.scodoc_dept, moduleimpl_id=moduleimpl_id)
            }">
            Revenir au tableau de bord du module</a>
            &nbsp;&nbsp;&nbsp;
            <a class="stdlink" href="{url_for("notes.saisie_notes_tableur",
                scodoc_dept=g.scodoc_dept, evaluation_id=evaluation.id)
            }">Charger un autre fichier de notes</a>
            &nbsp;&nbsp;&nbsp;
            <a class="stdlink" href="{url_for("notes.saisie_notes",
                scodoc_dept=g.scodoc_dept, evaluation_id=evaluation.id)
            }">Formulaire de saisie des notes</a>
            </div>"""
            )
        else:
            H.append(
                f"""
            <p class="redboldtext">Notes non chargées !</p>
            {updiag[1]}
            <p><a class="stdlink" href="{url_for("notes.saisie_notes_tableur",
                scodoc_dept=g.scodoc_dept, evaluation_id=evaluation.id)
                }">
                Reprendre</a>
            </p>
            """
            )

    #
    H.append("""</div>""")
    if evaluation.moduleimpl.can_edit_notes(current_user, allow_ens=False):
        H.append(
            f"""
        <div class="scobox explanation">
        <div class="scobox-title">Autres opérations</div>
        <div>
        <ul>
        <li>
        <form action="do_evaluation_set_missing" method="POST">
        Mettre toutes les notes manquantes à <input type="text" size="5" name="value"/>
        <input type="submit" value="OK"/>
        <input type="hidden" name="evaluation_id" value="{evaluation_id}"/>
        <em>ABS indique "absent" (zéro), EXC "excusé" (neutralisées), ATT "attente"</em>
        </form>
        </li>
        <li><a class="stdlink" href="{url_for("notes.evaluation_suppress_alln",
            scodoc_dept=g.scodoc_dept, evaluation_id=evaluation_id)
        }">Effacer toutes les notes de cette évaluation</a>
        (ceci permet ensuite de supprimer l'évaluation si besoin)
        </li>
        <li><a class="stdlink" href="{url_for("notes.moduleimpl_status",
            scodoc_dept=g.scodoc_dept, moduleimpl_id=moduleimpl_id)
        }">Revenir au module</a>
        </li>
        <li><a class="stdlink" href="{url_for("notes.saisie_notes",
            scodoc_dept=g.scodoc_dept, evaluation_id=evaluation.id)
        }">Revenir au formulaire de saisie</a>
        </li>
        </ul>
        </div>
        </div>

        <div class="scobox explanation">
        <div class="scobox-title">Explications</div>
            <div>
<ol>
<li><b>Etape 1</b>:
<ol><li>choisir le ou les groupes d'étudiants;</li>
    <li>télécharger le fichier Excel à remplir.</li>
</ol>
</li>
<li><b>Etape 2</b> (cadre vert): Indiquer le fichier Excel
    <em>téléchargé à l'étape 1</em> et dans lequel on a saisi des notes.
    Remarques:
    <ul>
    <li>le fichier Excel peut être incomplet: on peut ne saisir que quelques notes
    et répéter l'opération (en téléchargeant un nouveau fichier) plus tard;
    </li>
    <li>seules les valeurs des notes modifiées sont prises en compte;
    </li>
    <li>seules les notes sont extraites du fichier Excel;
    </li>
    <li>on peut optionnellement ajouter un commentaire (type "copies corrigées
    par Dupont", ou "Modif. suite à contestation") dans la case "Commentaire".
    </li>
    <li>le fichier Excel <em>doit impérativement être celui chargé à l'étape 1
    pour cette évaluation</em>. Il n'est pas possible d'utiliser une liste d'appel
    ou autre document Excel téléchargé d'une autre page.
    </li>
    </ul>
</li>
</ol>
            </div>
        </div>
"""
        )
    H.append(html_sco_header.sco_footer())
    return "\n".join(H)