',
formsemestre_status_head(
formsemestre_id=formsemestre_id, page_title="Tableau de bord"
),
formsemestre_warning_etuds_sans_note(formsemestre, nt)
if can_change_all_notes
else "",
"""
Tableau de bord : """,
]
if formsemestre.est_courant():
H.append(
"""cliquez sur un module pour saisir des notes"""
)
elif datetime.date.today() > formsemestre.date_fin:
if formsemestre.etat:
H.append(
"""semestre terminé mais non verrouillé"""
)
else:
H.append(
"""semestre pas encore commencé"""
)
H.append("
")
if sco_preferences.get_preference("bul_show_all_evals", formsemestre_id):
H.append(
"""
Toutes évaluations (même incomplètes) visibles
"""
)
if nt.expr_diagnostics:
H.append(html_expr_diagnostic(nt.expr_diagnostics))
if nt.parcours.APC_SAE:
# BUT: tableau ressources puis SAE
ressources = [
m for m in modimpls if m["module"]["module_type"] == ModuleType.RESSOURCE
]
saes = [m for m in modimpls if m["module"]["module_type"] == ModuleType.SAE]
autres = [
m
for m in modimpls
if m["module"]["module_type"] not in (ModuleType.RESSOURCE, ModuleType.SAE)
]
H += [
f"""
{_TABLEAU_MODULES_HEAD}
|
Ressources
|
{formsemestre_tableau_modules(
ressources, nt, formsemestre, can_edit=can_edit, show_ues=False
)}
|
SAÉs
|
""",
formsemestre_tableau_modules(
saes, nt, formsemestre, can_edit=can_edit, show_ues=False
),
]
if autres:
H += [
"""
|
Autres modules
|
""",
formsemestre_tableau_modules(
autres, nt, formsemestre, can_edit=can_edit, show_ues=False
),
]
H += [_TABLEAU_MODULES_FOOT, ""]
else:
# formations classiques: groupe par UE
H += [
"
",
_TABLEAU_MODULES_HEAD,
formsemestre_tableau_modules(
modimpls,
nt,
formsemestre,
can_edit=can_edit,
use_ue_coefs=use_ue_coefs,
),
_TABLEAU_MODULES_FOOT,
"
",
]
if use_ue_coefs and not formsemestre.formation.is_apc():
H.append(
"""
utilise les coefficients d'UE pour calculer la moyenne générale.
"""
)
# --- LISTE DES ETUDIANTS
H += [
'
',
_make_listes_sem(formsemestre),
"
",
]
# --- Lien mail enseignants:
adrlist = list(mails_enseignants - {None, ""})
if adrlist:
H.append(
'
Courrier aux %d enseignants du semestre
'
% (",".join(adrlist), len(adrlist))
)
return "".join(H) + html_sco_header.sco_footer()
_TABLEAU_MODULES_HEAD = """
"""
def formsemestre_tableau_modules(
modimpls: list[dict],
nt,
formsemestre: FormSemestre,
can_edit=True,
show_ues=True,
use_ue_coefs=False,
) -> str:
"Lignes table HTML avec modules du semestre"
H = []
prev_ue_id = None
for modimpl in modimpls:
mod: Module = Module.query.get(modimpl["module_id"])
moduleimpl_status_url = url_for(
"notes.moduleimpl_status",
scodoc_dept=g.scodoc_dept,
moduleimpl_id=modimpl["moduleimpl_id"],
)
mod_descr = "Module " + (mod.titre or "")
if mod.is_apc():
coef_descr = ", ".join(
[f"{ue.acronyme}: {co}" for ue, co in mod.ue_coefs_list()]
)
if coef_descr:
mod_descr += " Coefs: " + coef_descr
else:
mod_descr += " (pas de coefficients) "
else:
mod_descr += ", coef. " + str(mod.coefficient)
mod_ens = sco_users.user_info(modimpl["responsable_id"])["nomcomplet"]
if modimpl["ens"]:
mod_ens += " (resp.), " + ", ".join(
[sco_users.user_info(e["ens_id"])["nomcomplet"] for e in modimpl["ens"]]
)
mod_inscrits = sco_moduleimpl.do_moduleimpl_inscription_list(
moduleimpl_id=modimpl["moduleimpl_id"]
)
ue = modimpl["ue"]
if show_ues and (prev_ue_id != ue["ue_id"]):
prev_ue_id = ue["ue_id"]
titre = ue["titre"]
if use_ue_coefs:
titre += f"""
(coef. {ue["coefficient"] or 0.0})"""
H.append(
f"""
|
{ue["acronyme"]}
{titre}
| """
)
expr = sco_compute_moy.get_ue_expression(
formsemestre.id, ue["ue_id"], html_quote=True
)
if expr:
H.append(
f""" {expr}
formule inutilisée en 9.2: supprimer"""
)
H.append(" |
")
if modimpl["ue"]["type"] != codes_cursus.UE_STANDARD:
fontorange = " fontorange" # style css additionnel
else:
fontorange = ""
etat = sco_evaluations.do_evaluation_etat_in_mod(nt, modimpl["moduleimpl_id"])
# if nt.parcours.APC_SAE:
# tbd style si module non conforme
if (
etat["nb_evals_completes"] > 0
and etat["nb_evals_en_cours"] == 0
and etat["nb_evals_vides"] == 0
):
H.append(f'
')
else:
H.append(f'
')
H.append(
f"""
| {mod.code} |
{mod.abbrev or mod.titre or ""}
|
{len(mod_inscrits)} |
{
sco_users.user_info(modimpl["responsable_id"])["prenomnom"]
}
|
"""
)
if mod.module_type in (ModuleType.RESSOURCE, ModuleType.SAE):
coefs = mod.ue_coefs_list(ues=formsemestre.query_ues().all())
H.append(f'')
for coef in coefs:
if coef[1] > 0:
H.append(
f""""""
)
else:
H.append("""""")
H.append("")
H.append(" | ")
if mod.module_type in (
None, # ne devrait pas être nécessaire car la migration a remplacé les NULLs
ModuleType.STANDARD,
ModuleType.RESSOURCE,
ModuleType.SAE,
):
H.append('')
nb_evals = (
etat["nb_evals_completes"]
+ etat["nb_evals_en_cours"]
+ etat["nb_evals_vides"]
)
if nb_evals != 0:
H.append(
f"""{nb_evals} prévues,
{etat["nb_evals_completes"]} ok"""
)
if etat["nb_evals_en_cours"] > 0:
H.append(
f""", {
etat["nb_evals_en_cours"]
} en cours"""
)
if etat["attente"]:
H.append(
f""" [en attente]"""
)
elif mod.module_type == ModuleType.MALUS:
nb_malus_notes = sum(
[
e["etat"]["nb_notes"]
for e in nt.get_mod_evaluation_etat_list(modimpl["moduleimpl_id"])
]
)
H.append(
f""" |
malus
({nb_malus_notes} notes)
"""
)
else:
raise ValueError(f"Invalid module_type {mod.module_type}") # a bug
H.append(" |
")
return "\n".join(H)
# Expérimental
def get_formsemestre_etudids_sans_notes(
formsemestre: FormSemestre, res: ResultatsSemestre
) -> set[int]:
"""Les étudids d'étudiants de ce semestre n'ayant aucune note
alors que d'autres en ont.
"""
# Il y a-t-il des notes déjà saisies ?
nb_notes_sem = (
NotesNotes.query.join(Evaluation)
.join(ModuleImpl)
.filter_by(formsemestre_id=formsemestre.id)
.count()
)
if not nb_notes_sem:
return set()
etudids_sans_notes = set.intersection(
*[
set.intersection(*m_res.evals_etudids_sans_note.values())
for m_res in res.modimpls_results.values()
if m_res.evals_etudids_sans_note
]
)
nb_sans_notes = len(etudids_sans_notes)
if nb_sans_notes > 0 and nb_sans_notes < len(
formsemestre.get_inscrits(include_demdef=False)
):
return etudids_sans_notes
return set()
def formsemestre_warning_etuds_sans_note(
formsemestre: FormSemestre, res: ResultatsSemestre
) -> str:
"""Vérifie si on est dans la situation où certains (mais pas tous) étudiants
n'ont aucune note alors que d'autres en ont.
Ce cas se produit typiquement quand on inscrit un étudiant en cours de semestre.
Il est alors utile de proposer de mettre toutes ses notes à ABS, ATT ou EXC
pour éviter de laisser toutes les évaluations "incomplètes".
"""
etudids_sans_notes = get_formsemestre_etudids_sans_notes(formsemestre, res)
if not etudids_sans_notes:
return ""
nb_sans_notes = len(etudids_sans_notes)
if nb_sans_notes < 5:
# peu d'étudiants, affiche leurs noms
etuds: list[Identite] = sorted(
[Identite.query.get(etudid) for etudid in etudids_sans_notes],
key=lambda e: e.sort_key,
)
noms = ", ".join(
[
f"""
{etud.nomprenom}"""
for etud in etuds
]
)
msg_etuds = (
f"""{noms} n'{"a" if nb_sans_notes == 1 else "ont"} aucune note :"""
)
else:
msg_etuds = f"""{nb_sans_notes} étudiants n'ont aucune note :"""
return f"""
"""
def formsemestre_note_etuds_sans_notes(
formsemestre_id: int, code: str = None, etudid: int = None
):
"""Affichage et saisie des étudiants sans notes
Si etudid est spécifié, traite un seul étudiant."""
formsemestre: FormSemestre = FormSemestre.query.filter_by(
id=formsemestre_id, dept_id=g.scodoc_dept_id
).first_or_404()
res: ResultatsSemestre = res_sem.load_formsemestre_results(formsemestre)
etudids_sans_notes = get_formsemestre_etudids_sans_notes(formsemestre, res)
if etudid:
etudids_sans_notes = etudids_sans_notes.intersection({etudid})
etuds: list[Identite] = sorted(
[Identite.query.get_or_404(eid) for eid in etudids_sans_notes],
key=lambda e: e.sort_key,
)
if request.method == "POST":
if not code in ("ATT", "EXC", "ABS"):
raise ScoValueError("code invalide: doit être ATT, ABS ou EXC")
for etud in etuds:
formsemestre.etud_set_all_missing_notes(etud, code)
flash(f"Notes de {len(etuds)} étudiants affectées à {code}")
return redirect(
url_for(
"notes.formsemestre_status",
scodoc_dept=g.scodoc_dept,
formsemestre_id=formsemestre.id,
)
)
if not etuds:
if etudid is None:
message = """
aucun étudiant sans notes
"""
else:
flash(
f"""{Identite.query.get_or_404(etudid).nomprenom}
a déjà des notes"""
)
return redirect(
url_for("scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etudid)
)
else:
noms = "
".join(
[
f"""{etud.nomprenom}"""
for etud in etuds
]
)
message = f"""
Étudiants sans notes:
"""
return f"""
{html_sco_header.sco_header(
page_title=f"{formsemestre.sem_modalite()} {formsemestre.titre_annee()}"
)}
{formsemestre_status_head(
formsemestre_id=formsemestre_id, page_title="Étudiants sans notes"
)}
{message}
{html_sco_header.sco_footer()}
"""