ScoDoc/app/tables/visu_assiduites.py

216 lines
7.2 KiB
Python
Raw Normal View History

##############################################################################
# ScoDoc
2023-12-31 23:04:06 +01:00
# Copyright (c) 1999 - 2024 Emmanuel Viennet. All rights reserved.
# See LICENSE
##############################################################################
"""Liste simple d'étudiants
"""
import datetime
from flask import g, url_for
from app import log
from app.models import FormSemestre, Identite, Justificatif
from app.tables import table_builder as tb
from app.scodoc import sco_preferences
from app.scodoc import sco_utils as scu
import app.scodoc.sco_assiduites as scass
from app.scodoc.sco_exceptions import ScoValueError
class TableAssi(tb.Table):
2023-10-26 13:12:22 +02:00
"""Table listant les statistiques d'assiduité des étudiants
L'id de la ligne est etudid, et le row stocke etud.
On considère les assiduités entre les dates indiquées.
Si formsemestre_modimpls est spécifié, restreint aux assiduités associées à des
moduleimpls de ce formsemestre.
Si convert_values, transforme les nombre en chaines ("12.34"), pour le html.
"""
def __init__(
self,
etuds: list[Identite] = None,
dates: tuple[str, str] = None,
formsemestre: FormSemestre = None,
formsemestre_modimpls: FormSemestre | None = None,
convert_values=False,
**kwargs,
):
2024-02-27 15:59:48 +01:00
self.rows: list["RowAssi"] = [] # juste pour que VSCode nous aide sur .rows
classes = ["gt_table"]
try:
self.dates = [
datetime.datetime.fromisoformat(str(dates[0]) + "T00:00"),
datetime.datetime.fromisoformat(str(dates[1]) + "T00:00"),
]
except ValueError as exc:
raise ScoValueError("invalid dates") from exc
self.formsemestre = formsemestre
self.formsemestre_modimpls = formsemestre_modimpls
if convert_values:
self.fmt_num = lambda x: f"{x:2.3g}"
else:
self.fmt_num = lambda x: x
super().__init__(
row_class=RowAssi,
classes=classes,
**kwargs,
with_foot_titles=False,
)
self.add_etuds(etuds)
def add_etuds(self, etuds: list[Identite]):
"Ajoute des étudiants à la table"
for etud in etuds:
row = self.row_class(self, etud)
row.add_etud_cols()
self.add_row(row)
class RowAssi(tb.Row):
"Ligne de la table assiduité"
# pour le moment très simple, extensible (codes, liens bulletins, ...)
def __init__(self, table: TableAssi, etud: Identite, *args, **kwargs):
# Etat de l'inscription au formsemestre
if "classes" not in kwargs:
kwargs["classes"] = []
try:
inscription = table.formsemestre.etuds_inscriptions[etud.id]
if inscription.etat == scu.DEMISSION:
kwargs["classes"].append("etuddem")
except KeyError:
log(f"RowAssi: etudid {etud.id} non inscrit à {table.formsemestre.id}")
kwargs["classes"].append("non_inscrit") # ne devrait pas arriver !
super().__init__(table, etud.id, *args, **kwargs)
self.etud = etud
self.dates = table.dates
def add_etud_cols(self):
"""Ajoute les colonnes"""
etud = self.etud
fmt_num = self.table.fmt_num
self.table.group_titles.update(
{
"etud_codes": "Codes",
"identite_detail": "",
"identite_court": "",
}
)
bilan_etud = url_for(
"assiduites.bilan_etud", scodoc_dept=g.scodoc_dept, etudid=etud.id
)
self.add_cell(
"etudid",
"etudid",
etud.etudid,
"etudinfo",
only_excel=True,
)
self.add_cell(
"code_nip",
"code_nip",
etud.code_nip,
"etudinfo",
only_excel=True,
)
self.add_cell(
"nom_disp",
"Nom",
etud.nom_disp(),
"etudinfo",
attrs={"id": str(etud.id)},
data={"order": etud.sort_key},
target=bilan_etud,
target_attrs={"class": "discretelink"},
)
self.add_cell(
"prenom",
"Prénom",
etud.prenom_str,
"etudinfo",
attrs={"id": str(etud.id)},
data={"order": etud.sort_key},
target=bilan_etud,
target_attrs={"class": "discretelink"},
)
stats = self._get_etud_stats(etud)
for key, value in stats.items():
self.add_cell(key, value[0], fmt_num(value[1] - value[2]), "assi_stats")
if key != "present":
self.add_cell(
key + "_justi",
value[0] + " Justifiées",
fmt_num(value[2]),
"assi_stats",
)
compte_justificatifs = scass.filter_by_date(
etud.justificatifs, Justificatif, self.dates[0], self.dates[1]
2023-09-12 09:41:50 +02:00
)
compte_justificatifs_att = compte_justificatifs.filter(Justificatif.etat == 2)
2023-09-12 09:41:50 +02:00
self.add_cell(
"justificatifs_att",
"Justificatifs en Attente",
fmt_num(compte_justificatifs_att.count()),
2023-09-12 09:41:50 +02:00
)
self.add_cell(
"justificatifs", "Justificatifs", fmt_num(compte_justificatifs.count())
2023-09-12 09:41:50 +02:00
)
def _get_etud_stats(self, etud: Identite) -> dict[str, list[str, float, float]]:
2024-01-18 17:05:43 +01:00
"""
Renvoie le comptage (dans la métrique du département) des différents états
d'assiduité d'un étudiant.
Considère les dates.
2024-01-18 17:05:43 +01:00
Returns :
{
"<etat>" : [<Etat version lisible>, <nb total etat>, <nb just etat>]
}
"""
# Préparation du retour
retour: dict[str, tuple[str, float, float]] = {
"absent": ["Absences", 0.0, 0.0],
"retard": ["Retards", 0.0, 0.0],
"present": ["Présences", 0.0, 0.0],
}
2024-01-18 17:05:43 +01:00
# Récupération de la métrique du département
2023-08-22 15:43:10 +02:00
assi_metric = scu.translate_assiduites_metric(
sco_preferences.get_preference("assi_metrique", dept_id=g.scodoc_dept_id),
2023-08-13 22:40:16 +02:00
)
2024-01-18 17:05:43 +01:00
compte_etat: dict[str, dict] = scass.get_assiduites_stats(
assiduites=etud.assiduites,
metric=assi_metric,
filtered={
"date_debut": self.dates[0],
"date_fin": self.dates[1],
"etat": "absent,present,retard", # pour tout compter d'un coup
"formsemestre_modimpls": self.table.formsemestre_modimpls,
2024-01-18 17:05:43 +01:00
"split": 1, # afin d'avoir la division des stats en état, etatjust, etatnonjust
},
)
2024-01-21 23:15:44 +01:00
# Pour chaque état on met à jour les valeurs de retour
for etat, valeur in retour.items():
2024-01-18 17:05:43 +01:00
valeur[1] = compte_etat[etat][assi_metric]
if etat != "present":
valeur[2] = compte_etat[etat]["justifie"][assi_metric]
return retour
def etuds_sorted_from_ids(etudids) -> list[Identite]:
"Liste triée d'etuds à partir d'une collections d'etudids"
etuds = [Identite.get_etud(etudid) for etudid in etudids]
return sorted(etuds, key=lambda etud: etud.sort_key)