')
disable_abs: str | bool = scass.has_assiduites_disable_pref(formsemestre)
show_abs: str = "hidden" if disable_abs else ""
# Genere liste pour chaque partition (categorie de groupes)
for partition in formsemestre.get_partitions_list():
groups = partition.groups.all()
effectifs = {g.id: g.get_nb_inscrits() for g in groups}
partition_is_empty = sum(effectifs.values()) == 0
if partition_is_empty and (partition.is_default() or partition.is_parcours()):
continue # inutile de montrer des partitions vides non éditables
H.append(
f"""
{
'Groupes de ' + partition.partition_name
if partition.partition_name else
('aucun étudiant inscrit' if partition_is_empty else 'Tous les étudiants')}
{
"Assiduité" if not partition_is_empty and not show_abs else ""
}
"""
)
if groups:
for group in groups:
n_members = effectifs[group.id]
if n_members == 0:
continue # skip empty groups
partition_is_empty = False
group_label = f"{group.group_name}" if group.group_name else "liste"
H.append(
f"""
"""
)
if can_edit_abs:
H.append(
f"""
"""
)
# YYYY-Www (ISO 8601) :
current_week: str = datetime.datetime.now().strftime("%G-W%V")
H.append(
f"""
"""
)
if can_edit_abs:
H.append(
f"""
"""
)
H.append(
f"""
"""
)
H.append("
") # /sem-groups-assi
if partition_is_empty and not (
partition.is_default() or partition.is_parcours()
):
H.append(
'
Aucun groupe peuplé dans cette partition'
)
if formsemestre.can_change_groups():
H.append(
f""" (
créer)"""
)
H.append("
")
H.append("
") # /sem-groups-partition
# Boite avec liens divers
autres_liens = []
if formsemestre.can_change_groups():
autres_liens.append(
f"""
Ajouter une partition"""
)
# --- Formulaire importation Assiduité excel (si autorisé)
if current_user.has_permission(Permission.AbsChange) and not disable_abs:
autres_liens.append(
f"""
Importation de l'assiduité depuis un fichier excel
"""
)
# --- Lien Traitement Justificatifs:
if (
current_user.has_permission(Permission.AbsJustifView)
and current_user.has_permission(Permission.JustifValidate)
and not disable_abs
):
autres_liens.append(
f"""
Traitement des justificatifs d'absence
"""
)
# --- Lien pour mail aux enseignants
# Construit la liste de tous les enseignants de ce semestre:
mails_enseignants = set(u.email for u in formsemestre.responsables)
for modimpl in formsemestre.modimpls_sorted:
mails_enseignants.add(sco_users.user_info(modimpl.responsable_id)["email"])
mails_enseignants |= {u.email for u in modimpl.enseignants if u.email}
adrlist = list(mails_enseignants - {None, ""})
if adrlist:
autres_liens.append(
f"""
Courrier aux {
len(adrlist)} enseignants du semestre
"""
)
# Met le tout en boite
if autres_liens:
H.append(
f"""
"""
)
H.append("
La gestion des absences est désactivée dans ScoDoc pour ce semestre:
{disable_abs}
"""
)
return "\n".join(H)
def formsemestre_status_head(formsemestre_id: int = None, page_title: str = None):
"""En-tête HTML des pages "semestre" """
formsemestre: FormSemestre = db.session.get(FormSemestre, formsemestre_id)
if not formsemestre:
raise ScoValueError("Semestre inexistant (il a peut être été supprimé ?)")
formation: Formation = formsemestre.formation
parcours = formation.get_cursus()
page_title = page_title or "Modules de "
H = [
f"""',
formsemestre_status_head(
formsemestre_id=formsemestre_id, page_title="Tableau de bord"
),
formsemestre_warning_apc_setup(formsemestre, nt),
(
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.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 des Ressources et SAEs
{_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
# élimine les modules BUT qui aurait pu se glisser là suite à un
# changement de type de formation par exemple
modimpls_classic = [
m
for m in modimpls
if m.module.module_type not in (ModuleType.RESSOURCE, ModuleType.SAE)
]
H += [
"
",
_TABLEAU_MODULES_HEAD,
formsemestre_tableau_modules(
modimpls_classic,
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),
"
",
]
return render_template(
"sco_page.j2",
content="".join(H),
title=f"{formsemestre.sem_modalite()} {formsemestre.titre_annee()}",
)
_TABLEAU_MODULES_HEAD = """
"""
def formsemestre_tableau_modules(
modimpls: list[ModuleImpl],
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 = modimpl.module
moduleimpl_status_url = url_for(
"notes.moduleimpl_status",
scodoc_dept=g.scodoc_dept,
moduleimpl_id=modimpl.id,
)
mod_descr = "Module " + (mod.titre or "")
is_apc = mod.is_apc() # SAE ou ressource
if is_apc:
mod_descr += " " + mod.get_ue_coefs_descr()
else:
mod_descr += ", coef. " + str(mod.coefficient)
mod_ens = sco_users.user_info(modimpl.responsable_id)["nomcomplet"]
if modimpl.enseignants.count():
mod_ens += " (resp.), " + ", ".join(
[u.get_nomcomplet() for u in modimpl.enseignants]
)
mod_nb_inscrits = nt.modimpls_results[modimpl.id].nb_inscrits_module
mod_is_conforme = modimpl.check_apc_conformity(nt)
ue = modimpl.module.ue
if show_ues and (prev_ue_id != ue.id):
prev_ue_id = ue.id
titre = ue.titre or ""
if use_ue_coefs:
titre += f"""
(coef. {ue.coefficient or 0.0})"""
H.append(
f"""
|
{ue.acronyme}
{titre}
|
"""
)
H.append(" |
")
if ue.type != codes_cursus.UE_STANDARD:
fontorange = " fontorange" # style css additionnel
else:
fontorange = ""
etat = sco_evaluations.do_evaluation_etat_in_mod(nt, modimpl)
if (
etat["nb_evals_completes"] > 0
and etat["nb_evals_en_cours"] == 0
and etat["nb_evals_vides"] == 0
and not etat["attente"]
and not etat["nb_evals_blocked"] > 0
):
tr_classes = f"formsemestre_status_green{fontorange}"
else:
tr_classes = f"formsemestre_status{fontorange}"
if etat["attente"]:
tr_classes += " modimpl_attente"
if not mod_is_conforme:
tr_classes += " modimpl_non_conforme"
if etat["nb_evals_blocked"] > 0:
tr_classes += " modimpl_has_blocked"
classes = "formsemestre_status_link"
if current_user.id == modimpl.responsable_id or current_user.id in (
u.id for u in modimpl.enseignants
):
classes += " enseignant"
H.append(
f"""
| {mod.code} |
{mod.abbrev or mod.titre or ""}
|
{mod_nb_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.get_ues())
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"]
if nb_evals != 0:
if etat["nb_evals_blocked"] > 0:
blocked_txt = f"""{
etat["nb_evals_blocked"]} bloquée{'s'
if etat["nb_evals_blocked"] > 1 else ''}"""
else:
blocked_txt = ""
H.append(
f"""{nb_evals} prévues,
{etat["nb_evals_completes"]} ok {blocked_txt}
"""
)
if etat["nb_evals_en_cours"] > 0:
H.append(
f""", {
etat["nb_evals_en_cours"]
} en cours"""
)
if etat["attente"]:
H.append(
f""" {
etat["nb_evals_attente"]
} en attente"""
)
if not mod_is_conforme:
H.append(
f""" [non conforme]"""
)
elif mod.module_type == ModuleType.MALUS:
nb_malus_notes = sum(
e["etat"]["nb_notes"] for e in nt.get_mod_evaluation_etat_list(modimpl)
)
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()
notes_modimpls = [
set.intersection(*m_res.evals_etudids_sans_note.values())
for m_res in res.modimpls_results.values()
if m_res.evals_etudids_sans_note
]
if not notes_modimpls:
return set()
etudids_sans_notes = set.intersection(*notes_modimpls)
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.get_etud(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.
"""
from app.views import ScoData
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.get_etud(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")
with sco_cache.DeferredSemCacheManager():
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 and etudid is not None:
flash(
f"""{Identite.get_etud(etudid).nomprenom}
a déjà des notes"""
)
return redirect(
url_for("scolar.fiche_etud", scodoc_dept=g.scodoc_dept, etudid=etudid)
)
etud = Identite.get_etud(etudid) if etudid is not None else None
return render_template(
"formsemestre/etuds_sans_notes.j2",
etudid=etudid,
etuds=etuds,
sco=ScoData(formsemestre=formsemestre, etud=etud),
title=f"{formsemestre.sem_modalite()} {formsemestre.titre_annee()}",
)