ScoDoc-Lille/app/tables/recap.py

806 lines
30 KiB
Python
Raw Normal View History

2023-02-04 02:20:25 +01:00
##############################################################################
# ScoDoc
# Copyright (c) 1999 - 2023 Emmanuel Viennet. All rights reserved.
# See LICENSE
##############################################################################
"""Table récapitulatif des résultats d'un semestre
"""
from flask import g, url_for
import numpy as np
from app.auth.models import User
from app.comp.res_common import ResultatsSemestre
from app.models import Identite, FormSemestre, UniteEns
from app.scodoc.codes_cursus import UE_SPORT, DEF
2023-02-04 02:20:25 +01:00
from app.scodoc import sco_evaluation_db
from app.scodoc import sco_groups
from app.scodoc import sco_utils as scu
from app.tables import table_builder as tb
class TableRecap(tb.Table):
"""Table récap. des résultats.
allow_html: si vrai, peut mettre du HTML dans les valeurs
Result: Table, le contenu étant une ligne par étudiant.
Si convert_values, transforme les notes en chaines ("12.34").
Les colonnes générées sont:
etudid
rang : rang indicatif (basé sur moy gen)
moy_gen : moy gen indicative
moy_ue_<ue_id>, ..., les moyennes d'UE
moy_res_<modimpl_id>_<ue_id>, ... les moyennes de ressources dans l'UE
moy_sae_<modimpl_id>_<ue_id>, ... les moyennes de SAE dans l'UE
On ajoute aussi des classes:
- les colonnes:
- la moyenne générale a la classe col_moy_gen
- les colonnes SAE ont la classe col_sae
- les colonnes Resources ont la classe col_res
- les colonnes d'UE ont la classe col_ue
- les colonnes de modules (SAE ou res.) d'une UE ont la classe mod_ue_<ue_id>
"""
def __init__(
self,
res: ResultatsSemestre,
convert_values=False,
include_evaluations=False,
mode_jury=False,
2023-02-05 18:38:52 +01:00
row_class=None,
finalize=True,
read_only: bool = True,
2023-02-05 18:38:52 +01:00
**kwargs,
2023-02-04 02:20:25 +01:00
):
2023-02-05 18:38:52 +01:00
self.rows: list["RowRecap"] = [] # juste pour que VSCode nous aide sur .rows
super().__init__(row_class=row_class or RowRecap, **kwargs)
2023-02-04 02:20:25 +01:00
self.res = res
self.include_evaluations = include_evaluations
self.mode_jury = mode_jury
self.read_only = read_only # utilisé seulement dans sous-classes
cursus = res.formsemestre.formation.get_cursus()
self.barre_moy = cursus.BARRE_MOY - scu.NOTES_TOLERANCE
self.barre_valid_ue = cursus.NOTES_BARRE_VALID_UE
self.barre_warning_ue = cursus.BARRE_UE_DISPLAY_WARNING
2023-02-04 02:20:25 +01:00
self.cache_nomcomplet = {} # cache uid : nomcomplet
if convert_values:
self.fmt_note = scu.fmt_note
else:
self.fmt_note = lambda x: x
# couples (modimpl, ue) effectivement présents dans la table:
self.modimpl_ue_ids = set()
ues = res.formsemestre.query_ues(with_sport=True) # avec bonus
ues_sans_bonus = [ue for ue in ues if ue.type != UE_SPORT]
2023-02-06 13:05:39 +01:00
if res.formsemestre.etuds_inscriptions: # table non vide
# Fixe l'ordre des groupes de colonnes communs:
groups = [
2023-02-09 15:27:19 +01:00
"etud_codes",
"rang",
"identite_court",
"identite_detail",
"partition",
"cursus",
2023-02-09 12:50:38 +01:00
"col_ues_validables",
]
if not res.formsemestre.block_moyenne_generale:
groups.append("col_moy_gen")
2023-02-21 00:59:26 +01:00
groups.append("abs")
self.set_groups(groups)
for etudid in res.formsemestre.etuds_inscriptions:
etud = Identite.get_etud(etudid)
row = self.row_class(self, etud)
self.add_row(row)
row.add_etud_cols()
row.add_moyennes_cols(ues_sans_bonus)
2023-02-21 00:59:26 +01:00
row.add_abs()
2023-02-06 13:05:39 +01:00
self.add_partitions()
self.add_cursus()
self.add_admissions()
# Tri par rang croissant
2023-02-06 13:05:39 +01:00
if not res.formsemestre.block_moyenne_generale:
2023-02-25 11:33:28 +01:00
self.sort_rows(key=lambda row: row.rang_order or 10000000)
2023-02-06 13:05:39 +01:00
else:
2023-02-25 11:33:28 +01:00
self.sort_rows(key=lambda row: row.nb_ues_validables or 0, reverse=True)
2023-02-06 13:05:39 +01:00
# Lignes footer (min, max, ects, apo, ...)
self.add_bottom_rows(ues_sans_bonus)
# Evaluations:
if include_evaluations:
self.add_evaluations()
2023-02-04 02:20:25 +01:00
if finalize:
self.finalize()
2023-02-05 18:38:52 +01:00
def finalize(self):
"""Termine la table: ajoute ligne avec les types,
et ajoute classe sur les colonnes vides"""
2023-02-04 02:20:25 +01:00
self.mark_empty_cols()
self.add_type_row()
def mark_empty_cols(self):
2023-02-05 18:38:52 +01:00
"""Ajoute classe "col_empty" aux colonnes de modules vides"""
2023-02-04 02:20:25 +01:00
# identifie les col. vides par la classe sur leur moyenne
row_moy = self.get_row_by_id("moy")
for col_id in self.column_ids:
cell: tb.Cell = row_moy.cells.get(col_id)
if cell and "col_empty" in cell.classes:
2023-02-04 14:22:24 +01:00
self.column_classes[col_id].add("col_empty")
2023-02-04 02:20:25 +01:00
def add_type_row(self):
"""Ligne avec la classe de chaque colonne recap."""
2023-02-04 14:22:24 +01:00
# récupère le type à partir du groupe (enlève le préfixe "col_" si présent)
2023-02-04 02:20:25 +01:00
row_type = tb.BottomRow(
self,
"type_col",
left_title="Type col.",
left_title_col_ids=["prenom", "nom_short"],
category="bottom_infos",
2023-02-04 14:22:24 +01:00
classes=["bottom_info", "type_col"],
2023-02-04 02:20:25 +01:00
)
for col_id in self.column_ids:
group_name = self.column_group.get(col_id, "")
if group_name.startswith("col_"):
group_name = group_name[4:]
row_type.add_cell(col_id, None, group_name)
def add_bottom_rows(self, ues):
"""Les informations à mettre en bas de la table recap:
min, max, moy, ECTS, Apo."""
res = self.res
# Ordre des lignes: Min, Max, Moy, Coef, ECTS, Apo
row_min = tb.BottomRow(
self,
"min",
left_title="Min.",
left_title_col_ids=["prenom", "nom_short"],
category="bottom_infos",
classes=["bottom_info"],
)
row_max = tb.BottomRow(
self,
"max",
left_title="Max.",
left_title_col_ids=["prenom", "nom_short"],
category="bottom_infos",
classes=["bottom_info"],
)
row_moy = tb.BottomRow(
self,
"moy",
left_title="Moy.",
left_title_col_ids=["prenom", "nom_short"],
category="bottom_infos",
classes=["bottom_info"],
)
row_coef = tb.BottomRow(
self,
"coef",
left_title="Coef.",
left_title_col_ids=["prenom", "nom_short"],
category="bottom_infos",
classes=["bottom_info"],
)
row_ects = tb.BottomRow(
self,
"ects",
left_title="ECTS",
left_title_col_ids=["prenom", "nom_short"],
category="bottom_infos",
classes=["bottom_info"],
)
row_apo = tb.BottomRow(
self,
"apo",
left_title="Code Apogée",
left_title_col_ids=["prenom", "nom_short"],
category="bottom_infos",
2023-02-04 14:22:24 +01:00
classes=["bottom_info", "apo"],
2023-02-04 02:20:25 +01:00
)
# --- ECTS
# titre (à gauche) sur 2 colonnes pour s'adapter à l'affichage des noms/prenoms
for ue in ues:
col_id = f"moy_ue_{ue.id}"
row_ects.add_cell(col_id, None, ue.ects)
2023-02-04 14:22:24 +01:00
# la colonne où placer les valeurs agrégats
col_id = "moy_gen" if "moy_gen" in self.column_ids else "code_cursus"
col_group = "col_moy_gen" if "moy_gen" in self.column_ids else "cursus"
2023-02-04 02:20:25 +01:00
row_ects.add_cell(
col_id,
2023-02-04 02:20:25 +01:00
None,
sum([ue.ects or 0 for ue in ues if ue.type != UE_SPORT]),
group=col_group,
2023-02-04 02:20:25 +01:00
)
# --- MIN, MAX, MOY, APO
2023-02-04 14:22:24 +01:00
row_min.add_cell(
col_id,
2023-02-04 14:22:24 +01:00
None,
self.fmt_note(res.etud_moy_gen.min()),
group=col_group,
2023-02-04 14:22:24 +01:00
)
row_max.add_cell(
col_id,
2023-02-04 14:22:24 +01:00
None,
self.fmt_note(res.etud_moy_gen.max()),
group=col_group,
2023-02-04 14:22:24 +01:00
)
row_moy.add_cell(
col_id,
2023-02-04 14:22:24 +01:00
None,
self.fmt_note(res.etud_moy_gen.mean()),
group=col_group,
2023-02-04 14:22:24 +01:00
)
2023-02-04 02:20:25 +01:00
for ue in ues:
col_id = f"moy_ue_{ue.id}"
2023-02-04 14:22:24 +01:00
row_min.add_cell(
col_id,
None,
self.fmt_note(res.etud_moy_ue[ue.id].min()),
classes=["col_ue", "col_moy_ue"],
)
row_max.add_cell(
col_id,
None,
self.fmt_note(res.etud_moy_ue[ue.id].max()),
classes=["col_ue", "col_moy_ue"],
)
row_moy.add_cell(
col_id,
None,
self.fmt_note(res.etud_moy_ue[ue.id].mean()),
classes=["col_ue", "col_moy_ue"],
)
row_apo.add_cell(
col_id,
None,
ue.code_apogee or "",
classes=["col_ue", "col_moy_ue"],
)
2023-02-04 02:20:25 +01:00
for modimpl in res.formsemestre.modimpls_sorted:
if (modimpl.id, ue.id) in self.modimpl_ue_ids:
col_id = f"moy_{modimpl.module.type_abbrv()}_{modimpl.id}_{ue.id}"
if res.is_apc:
coef = res.modimpl_coefs_df[modimpl.id][ue.id]
else:
coef = modimpl.module.coefficient or 0
row_coef.add_cell(
col_id,
None,
self.fmt_note(coef),
group=f"col_ue_{ue.id}_modules",
)
notes = res.modimpl_notes(modimpl.id, ue.id)
if np.isnan(notes).all():
# aucune note valide
row_min.add_cell(col_id, None, np.nan)
row_max.add_cell(col_id, None, np.nan)
moy = np.nan
else:
row_min.add_cell(col_id, None, self.fmt_note(np.nanmin(notes)))
row_max.add_cell(col_id, None, self.fmt_note(np.nanmax(notes)))
moy = np.nanmean(notes)
row_moy.add_cell(
col_id,
None,
self.fmt_note(moy),
# aucune note dans ce module ?
classes=["col_empty" if np.isnan(moy) else ""],
)
row_apo.add_cell(col_id, None, modimpl.module.code_apogee or "")
def add_partitions(self):
"""Ajoute les colonnes indiquant les groupes
2023-02-05 18:38:52 +01:00
pour tous les étudiants de la table.
2023-02-04 02:20:25 +01:00
La table contient des rows avec la clé etudid.
2023-02-05 18:38:52 +01:00
Les colonnes ont la classe css "partition".
2023-02-04 02:20:25 +01:00
"""
2023-02-05 18:38:52 +01:00
self.group_titles["partition"] = "Partitions"
2023-02-04 02:20:25 +01:00
partitions, partitions_etud_groups = sco_groups.get_formsemestre_groups(
self.res.formsemestre.id
)
first_partition = True
for partition in partitions:
cid = f"part_{partition['partition_id']}"
partition_etud_groups = partitions_etud_groups[partition["partition_id"]]
for row in self.rows:
etudid = row.id
group = None # group (dict) de l'étudiant dans cette partition
# dans NotesTableCompat, à revoir
etud_etat = self.res.get_etud_etat(row.id) # row.id == etudid
if etud_etat == scu.DEMISSION:
gr_name = "Dém."
2023-02-04 14:22:24 +01:00
row.add_class("dem")
2023-02-04 02:20:25 +01:00
elif etud_etat == DEF:
gr_name = "Déf."
2023-02-04 14:22:24 +01:00
row.add_class("def")
2023-02-04 02:20:25 +01:00
else:
group = partition_etud_groups.get(etudid)
gr_name = group["group_name"] if group else ""
if gr_name:
row.add_cell(
cid,
partition["partition_name"],
gr_name,
group="partition",
classes=[] if first_partition else ["partition_aux"],
# la classe "partition" est ajoutée par la Table car c'est le group
# la classe "partition_aux" est ajoutée à partir de la 2eme partition affichée
)
first_partition = False
# Rangs dans groupe
if (
partition["bul_show_rank"]
and (group is not None)
and (group["id"] in self.res.moy_gen_rangs_by_group)
):
rang = self.res.moy_gen_rangs_by_group[group["id"]][0]
rg_cid = cid + "_rg" # rang dans la partition
row.add_cell(
rg_cid,
f"Rg {partition['partition_name']}",
rang.get(etudid, ""),
group="partition",
classes=["partition_aux", "partition_rangs"],
)
def add_evaluations(self):
"""Ajoute les colonnes avec les notes aux évaluations
pour tous les étudiants de la table.
Les colonnes ont la classe css "evaluation"
"""
self.group_titles["eval"] = "Évaluations"
2023-02-04 02:20:25 +01:00
# nouvelle ligne pour description évaluations:
row_descr_eval = tb.BottomRow(
self,
"evaluations",
left_title="Description évaluations",
left_title_col_ids=["prenom", "nom_short"],
category="bottom_infos",
classes=["bottom_info"],
)
first_eval = True
for modimpl in self.res.formsemestre.modimpls_sorted:
evals = self.res.modimpls_results[modimpl.id].get_evaluations_completes(
modimpl
)
eval_index = len(evals) - 1
inscrits = {i.etudid for i in modimpl.inscriptions}
first_eval_of_mod = True
for e in evals:
col_id = f"eval_{e.id}"
title = f'{modimpl.module.code} {eval_index} {e.jour.isoformat() if e.jour else ""}'
col_classes = []
2023-02-04 02:20:25 +01:00
if first_eval:
col_classes.append("first")
elif first_eval_of_mod:
col_classes.append("first_of_mod")
first_eval_of_mod = first_eval = False
eval_index -= 1
notes_db = sco_evaluation_db.do_evaluation_get_all_notes(
e.evaluation_id
)
for row in self.rows:
etudid = row.id
if etudid in inscrits:
if etudid in notes_db:
val = notes_db[etudid]["value"]
else:
# Note manquante mais prise en compte immédiate: affiche ATT
val = scu.NOTES_ATTENTE
content = self.fmt_note(val)
classes = col_classes + [
{
"ABS": "abs",
"ATT": "att",
"EXC": "exc",
}.get(content, "")
]
row.add_cell(
col_id, title, content, group="eval", classes=classes
)
2023-02-04 02:20:25 +01:00
else:
row.add_cell(
col_id,
title,
"ni",
group="eval",
2023-02-04 02:20:25 +01:00
classes=col_classes + ["non_inscrit"],
)
row_coef = self.get_row_by_id("coef")
row_coef.add_cell(
col_id,
None,
self.fmt_note(e.coefficient),
group="eval",
)
row_min = self.get_row_by_id("min")
row_min.add_cell(
col_id,
None,
0,
group="eval",
)
row_max = self.get_row_by_id("max")
row_max.add_cell(
col_id,
None,
self.fmt_note(e.note_max),
group="eval",
)
2023-02-04 02:20:25 +01:00
row_descr_eval.add_cell(
col_id,
None,
e.description or "",
target=url_for(
"notes.evaluation_listenotes",
scodoc_dept=g.scodoc_dept,
evaluation_id=e.id,
),
2023-02-05 18:38:52 +01:00
target_attrs={"class": "stdlink"},
2023-02-04 02:20:25 +01:00
)
def add_admissions(self):
"""Ajoute les colonnes "admission" pour tous les étduiants de la table
Les colonnes ont la classe css "admission"
"""
fields = {
"bac": "Bac",
"specialite": "Spécialité",
"type_admission": "Type Adm.",
"classement": "Rg. Adm.",
}
first = True
for cid, title in fields.items():
cell_head, cell_foot = self.add_title(cid, title)
cell_head.classes.append("admission")
cell_foot.classes.append("admission")
if first:
cell_head.classes.append("admission_first")
cell_foot.classes.append("admission_first")
first = False
for row in self.rows:
etud = row.etud
admission = etud.admission.first()
first = True
for cid, title in fields.items():
cell = row.add_cell(
cid,
title,
getattr(admission, cid) or "",
"admission",
)
if first:
cell.classes.append("admission_first")
first = False
def add_cursus(self):
"""Ajoute colonne avec code cursus, eg 'S1 S2 S1'
pour tous les étudiants de la table"""
cid = "code_cursus"
2023-02-04 02:20:25 +01:00
formation_code = self.res.formsemestre.formation.formation_code
for row in self.rows:
row.add_cell(
cid,
"Cursus",
" ".join(
[
f"S{ins.formsemestre.semestre_id}"
for ins in reversed(row.etud.inscriptions())
if ins.formsemestre.formation.formation_code == formation_code
]
),
group="cursus",
2023-02-04 02:20:25 +01:00
)
def html(self, extra_classes: list[str] = None) -> str:
"""HTML: pour les tables recap, un div au contenu variable"""
return f"""
<div class="table_recap">
{
'<div class="message">aucun étudiant !</div>'
if self.is_empty()
else super().html(
extra_classes=[
"table_recap",
"apc" if self.res.formsemestre.formation.is_apc() else "classic",
"jury" if self.mode_jury else "",
"with_evaluations" if self.include_evaluations else "",
])
}
</div>
"""
2023-02-04 02:20:25 +01:00
class RowRecap(tb.Row):
"Ligne de la table recap, pour un étudiant"
def __init__(self, table: TableRecap, etud: Identite, *args, **kwargs):
super().__init__(table, etud.id, *args, **kwargs)
self.etud = etud
self.rang_order = None
"valeur pour tri rangs"
self.nb_ues_validables = None
self.nb_ues_warning = None
self.nb_ues_etud_parcours = None
def add_etud_cols(self):
"""Ajoute colonnes étudiant: codes, noms"""
res = self.table.res
etud = self.etud
2023-02-05 18:38:52 +01:00
self.table.group_titles.update(
{
"etud_codes": "Codes",
"identite_detail": "",
"identite_court": "",
}
)
2023-02-04 02:20:25 +01:00
# --- Codes (seront cachés, mais exportés en excel)
self.add_cell("etudid", "etudid", etud.id, "etud_codes")
self.add_cell(
"code_nip",
"code_nip",
etud.code_nip or "",
"etud_codes",
)
# --- Rang
if not res.formsemestre.block_moyenne_generale:
self.rang_order = res.etud_moy_gen_ranks_int[etud.id]
self.add_cell(
"rang",
"Rg",
res.etud_moy_gen_ranks[etud.id],
"rang",
data={"order": f"{self.rang_order:05d}"},
)
else:
self.rang_order = -1
# --- Identité étudiant
url_bulletin = url_for(
"notes.formsemestre_bulletinetud",
scodoc_dept=g.scodoc_dept,
formsemestre_id=res.formsemestre.id,
etudid=etud.id,
)
self.add_cell("civilite_str", "Civ.", etud.civilite_str, "identite_detail")
self.add_cell(
"nom_disp",
"Nom",
etud.nom_disp(),
"identite_detail",
data={"order": etud.sort_key},
target=url_bulletin,
target_attrs={"class": "etudinfo", "id": str(etud.id)},
)
self.add_cell("prenom", "Prénom", etud.prenom, "identite_detail")
self.add_cell(
"nom_short",
"Nom",
etud.nom_short,
"identite_court",
data={
"order": etud.sort_key,
"etudid": etud.id,
"nomprenom": etud.nomprenom,
},
target=url_bulletin,
target_attrs={"class": "etudinfo", "id": str(etud.id)},
)
2023-02-21 00:59:26 +01:00
def add_abs(self):
"Ajoute les colonnes absences"
# Absences (nb d'abs non just. dans ce semestre)
nbabs, nbabsjust = self.table.res.formsemestre.get_abs_count(self.etud.id)
self.add_cell("nbabs", "Abs", nbabs, "abs")
self.add_cell("nbabsjust", "Just.", nbabsjust, "abs")
2023-02-04 02:20:25 +01:00
def add_moyennes_cols(
self,
ues_sans_bonus: list[UniteEns],
):
"""Ajoute cols moy_gen moy_ue et tous les modules..."""
etud = self.etud
table = self.table
res = table.res
# --- Si DEM ou DEF, ne montre aucun résultat d'UE ni moy. gen.
if res.get_etud_etat(etud.id) != scu.INSCRIT:
return
2023-02-04 02:20:25 +01:00
# --- Moyenne générale
if not res.formsemestre.block_moyenne_generale:
moy_gen = res.etud_moy_gen.get(etud.id, False)
note_class = ""
if moy_gen is False:
moy_gen = scu.NO_NOTE_STR
elif isinstance(moy_gen, float) and moy_gen < table.barre_moy:
note_class = "moy_ue_warning" # en rouge
self.add_cell(
"moy_gen",
"Moy",
table.fmt_note(moy_gen),
2023-02-04 14:22:24 +01:00
group="col_moy_gen",
2023-02-04 02:20:25 +01:00
classes=[note_class],
)
# Ajoute bulle sur titre du pied de table:
cell = table.foot_title_row.cells.get("moy_gen")
if cell:
table.foot_title_row.cells["moy_gen"].target_attrs["title"] = (
"Moyenne générale indicative"
if res.is_apc
else "Moyenne générale du semestre"
)
2023-02-04 02:20:25 +01:00
# --- Moyenne d'UE
self.nb_ues_validables, self.nb_ues_warning = 0, 0
for ue in ues_sans_bonus:
ue_status = res.get_etud_ue_status(etud.id, ue.id)
if ue_status is not None:
self.add_ue_cols(ue, ue_status)
if table.mode_jury:
# pas d'autre colonnes de résultats
continue
# Bonus (sport) dans cette UE ?
# Le bonus sport appliqué sur cette UE
if (res.bonus_ues is not None) and (ue.id in res.bonus_ues):
val = res.bonus_ues[ue.id][etud.id] or ""
val_fmt = val_fmt_html = table.fmt_note(val)
if val:
val_fmt_html = f"""<span class="green-arrow-up"></span><span class="sp2l">{
val_fmt
}</span>"""
self.add_cell(
f"bonus_ue_{ue.id}",
f"Bonus {ue.acronyme}",
val_fmt_html,
raw_content=val_fmt,
group=f"col_ue_{ue.id}",
column_classes={"col_ue_bonus", "col_res"},
2023-02-04 02:20:25 +01:00
)
# Les moyennes des modules (ou ressources et SAÉs) dans cette UE
self.add_ue_modimpls_cols(ue, ue_status["is_capitalized"])
self.nb_ues_etud_parcours = len(res.etud_ues_ids(etud.id))
ue_valid_txt = (
ue_valid_txt_html
) = f"{self.nb_ues_validables}/{self.nb_ues_etud_parcours}"
if self.nb_ues_warning:
ue_valid_txt_html += " " + scu.EMO_WARNING
2023-02-04 14:22:24 +01:00
cell_class = ""
2023-02-04 02:20:25 +01:00
if self.nb_ues_warning:
2023-02-04 14:22:24 +01:00
cell_class = "moy_ue_warning"
2023-02-04 02:20:25 +01:00
elif self.nb_ues_validables < len(ues_sans_bonus):
2023-02-04 14:22:24 +01:00
cell_class = "moy_inf"
2023-02-04 02:20:25 +01:00
self.add_cell(
"ues_validables",
"UEs",
ue_valid_txt_html,
group="col_ues_validables",
2023-02-04 14:22:24 +01:00
classes=[cell_class],
column_classes={"col_ue"},
2023-02-04 02:20:25 +01:00
raw_content=ue_valid_txt,
data={"order": self.nb_ues_validables}, # tri
)
def add_ue_cols(self, ue: UniteEns, ue_status: dict, col_group: str = None):
2023-02-04 02:20:25 +01:00
"Ajoute résultat UE au row (colonne col_ue)"
2023-02-05 18:38:52 +01:00
# sous-classé par JuryRow pour ajouter les codes
2023-02-04 02:20:25 +01:00
table = self.table
formsemestre: FormSemestre = table.res.formsemestre
table.group_titles[
"col_ue"
] = f"UEs du S{formsemestre.semestre_id} {formsemestre.annee_scolaire()}"
2023-02-04 02:20:25 +01:00
col_id = f"moy_ue_{ue.id}"
val = ue_status["moy"]
note_classes = []
2023-02-04 02:20:25 +01:00
if isinstance(val, float):
if val < table.barre_moy:
note_classes = ["moy_inf"]
2023-02-04 02:20:25 +01:00
elif val >= table.barre_valid_ue:
note_classes = ["moy_ue_valid"]
2023-02-04 02:20:25 +01:00
self.nb_ues_validables += 1
if val < table.barre_warning_ue:
note_classes = ["moy_ue_warning"] # notes très basses
2023-02-04 02:20:25 +01:00
self.nb_ues_warning += 1
if ue_status["is_capitalized"]:
note_classes.append("ue_capitalized")
2023-02-04 02:20:25 +01:00
self.add_cell(
col_id,
ue.acronyme,
table.fmt_note(val),
group=col_group or f"col_ue_{ue.id}",
classes=note_classes,
column_classes={f"col_ue_{ue.id}", "col_moy_ue", "col_ue"},
2023-02-04 02:20:25 +01:00
)
table.foot_title_row.cells[col_id].target_attrs[
"title"
] = f"""{ue.titre} S{ue.semestre_idx or '?'}"""
def add_ue_modimpls_cols(self, ue: UniteEns, is_capitalized: bool):
"""Ajoute à row les moyennes des modules (ou ressources et SAÉs) dans l'UE"""
# pylint: disable=invalid-unary-operand-type
etud = self.etud
table = self.table
res = table.res
for modimpl in res.modimpls_in_ue(ue, etud.id, with_bonus=False):
if is_capitalized:
val = "-c-"
else:
modimpl_results = res.modimpls_results.get(modimpl.id)
if modimpl_results: # pas bonus
if res.is_apc: # BUT
moys_vers_ue = modimpl_results.etuds_moy_module.get(ue.id)
val = (
moys_vers_ue.get(etud.id, "?")
if moys_vers_ue is not None
else ""
)
else: # classique: Series indépendantes de l'UE
val = modimpl_results.etuds_moy_module.get(etud.id, "?")
else:
val = ""
col_id = f"moy_{modimpl.module.type_abbrv()}_{modimpl.id}_{ue.id}"
val_fmt_html = val_fmt = table.fmt_note(val)
if modimpl.module.module_type == scu.ModuleType.MALUS:
if val and not isinstance(val, str) and not np.isnan(val):
if val >= 0:
val_fmt_html = f"""<span class="sp2l">-{
2023-02-04 02:20:25 +01:00
val_fmt
}</span>"""
else:
val_fmt_html = f"""<span class="sp2l malus_negatif">+{
2023-02-04 02:20:25 +01:00
table.fmt_note(-val)}</span>"""
else:
val_fmt = val_fmt_html = "" # inscrit à ce malus, mais sans note
cell = self.add_cell(
col_id,
modimpl.module.code,
val_fmt_html,
raw_content=val_fmt,
group=f"col_ue_{ue.id}_modules",
2023-02-04 14:22:24 +01:00
column_classes={
2023-02-04 02:20:25 +01:00
f"col_{modimpl.module.type_abbrv()}",
f"mod_ue_{ue.id}",
2023-02-04 14:22:24 +01:00
},
2023-02-04 02:20:25 +01:00
)
if modimpl.module.module_type == scu.ModuleType.MALUS:
# positionne la colonne à droite de l'UE
cell.group = f"col_ue_{ue.id}_malus"
table.insert_group(cell.group, after=f"col_ue_{ue.id}")
table.foot_title_row.cells[col_id].target = url_for(
"notes.moduleimpl_status",
scodoc_dept=g.scodoc_dept,
moduleimpl_id=modimpl.id,
)
nom_resp = table.cache_nomcomplet.get(modimpl.responsable_id)
if nom_resp is None:
user = User.query.get(modimpl.responsable_id)
nom_resp = user.get_nomcomplet() if user else ""
table.cache_nomcomplet[modimpl.responsable_id] = nom_resp
table.foot_title_row.cells[col_id].target_attrs[
"title"
] = f"{modimpl.module.titre} ({nom_resp})"
table.modimpl_ue_ids.add((modimpl.id, ue.id))