forked from ScoDoc/ScoDoc
638 lines
22 KiB
Python
638 lines
22 KiB
Python
##############################################################################
|
|
# 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} 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
|