]
"""
# menus => case supplementaire pour saisie manuelle, indicée 0
start_i = 0 if etapes else 1
apo_etapes_vdi = []
for n in range(start_i, scu.EDIT_NB_ETAPES + 1):
apo_etapes_vdi.append(
ApoEtapeVDI(etape=args["etape_apo" + str(n)], vdi=args["vdi_apo" + str(n)])
)
# uniques:
apo_etapes_vdi_uniq = {str(e): e for e in apo_etapes_vdi if str(e)}.values()
formsemestre.etapes = []
db.session.add(formsemestre)
db.session.flush()
formsemestre.etapes = [
FormSemestreEtape.create_from_apovdi(formsemestre.id, etape_vdi)
for etape_vdi in apo_etapes_vdi_uniq
]
db.session.add(formsemestre)
db.session.flush()
log(f"setting etapes: {formsemestre}: {formsemestre.etapes}")
def _formsemestre_check_module_list(module_ids, semestre_idx):
"""En APC: Vérifie que tous les modules de la liste
sont dans le semestre indiqué.
Sinon, raise ScoValueError.
"""
# vérification de la cohérence / modules / semestre
mod_sems_idx = {
Module.query.get_or_404(module_id).ue.semestre_idx for module_id in module_ids
}
if mod_sems_idx and mod_sems_idx != {semestre_idx}:
modules = [Module.query.get_or_404(module_id) for module_id in module_ids]
log(
f"""_formsemestre_check_module_list:
{chr(10).join( str(module) + " " + str(module.ue) for module in modules )}
"""
)
for module in modules:
log(
f"{module.code}\tsemestre_id={module.semestre_id}\tue.semestre_idx={module.ue.semestre_idx}"
)
raise ScoValueError(
f"Les modules sélectionnés ne sont pas tous dans le semestre choisi (S{semestre_idx}) !",
dest_url="javascript:history.back();",
)
def _formsemestre_check_ue_bonus_unicity(module_ids):
"""Vérifie qu'il n'y a qu'une seule UE bonus associée aux modules choisis"""
ues = [Module.query.get_or_404(module_id).ue for module_id in module_ids]
ues_bonus = {ue.id for ue in ues if ue.type == codes_cursus.UE_SPORT}
if len(ues_bonus) > 1:
raise ScoValueError(
"""Les modules de bonus sélectionnés ne sont pas tous dans la même UE bonus.
Changez la sélection ou modifiez la structure du programme de formation.""",
dest_url="javascript:history.back();",
)
def formsemestre_delete_moduleimpls(formsemestre_id, module_ids_to_del):
"""Delete moduleimpls
module_ids_to_del: list of module_id (warning: not moduleimpl)
Moduleimpls must have no associated evaluations.
"""
ok = True
msg = []
for module_id in module_ids_to_del:
module = db.session.get(Module, module_id)
if module is None:
continue # ignore invalid ids
modimpls = ModuleImpl.query.filter_by(
formsemestre_id=formsemestre_id, module_id=module_id
)
for modimpl in modimpls:
nb_evals = modimpl.evaluations.count()
if nb_evals > 0:
msg += [
f"""impossible de supprimer {module.code} ({module.titre or ""})
car il y a {nb_evals} évaluations définies
(supprimez-les d\'abord)"""
]
ok = False
else:
msg += [f"""suppression de {module.code} ({module.titre or ""})"""]
db.session.delete(modimpl)
if ok:
db.session.commit()
else:
db.session.rollback()
return ok, msg
def formsemestre_clone(formsemestre_id):
"""
Formulaire clonage d'un semestre
"""
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
# Liste des enseignants avec forme pour affichage / saisie avec suggestion
user_list = sco_users.get_user_list()
uid2display = {} # user_name : forme pour affichage = "NOM Prenom (login)"
for u in user_list:
uid2display[u.id] = u.get_nomplogin()
allowed_user_names = list(uid2display.values()) + [""]
initvalues = {
"formsemestre_id": sem["formsemestre_id"],
"responsable_id": uid2display.get(
sem["responsables"][0], sem["responsables"][0]
),
}
H = [
"""Cette opération duplique un semestre:
on reprend les mêmes modules et responsables.
Aucun étudiant n'est inscrit.
""",
]
descr = [
("formsemestre_id", {"input_type": "hidden"}),
(
"date_debut",
{
"title": "Date de début", # j/m/a
"input_type": "datedmy",
"explanation": "j/m/a",
"size": 9,
"allow_null": False,
},
),
(
"date_fin",
{
"title": "Date de fin", # j/m/a
"input_type": "datedmy",
"explanation": "j/m/a",
"size": 9,
"allow_null": False,
},
),
(
"responsable_id",
{
"input_type": "text_suggest",
"size": 50,
"title": "Directeur des études",
"explanation": "taper le début du nom et choisir dans le menu",
"allowed_values": allowed_user_names,
"allow_null": False,
"text_suggest_options": {
"script": url_for(
"users.get_user_list_xml", scodoc_dept=g.scodoc_dept
)
+ "?",
"varname": "start",
"json": False,
"noresults": "Valeur invalide !",
"timeout": 60000,
},
},
),
(
"clone_evaluations",
{
"title": "Copier aussi les évaluations",
"input_type": "boolcheckbox",
"explanation": "copie toutes les évaluations, sans les dates (ni les notes!)",
},
),
(
"clone_partitions",
{
"title": "Copier aussi les partitions",
"input_type": "boolcheckbox",
"explanation": "copie toutes les partitions (sans les étudiants!)",
},
),
]
tf = TrivialFormulator(
request.base_url,
scu.get_request_args(),
descr,
submitlabel="Dupliquer ce semestre",
cancelbutton="Annuler",
initvalues=initvalues,
)
msg = ""
if tf[0] == 1:
# check dates
if ndb.DateDMYtoISO(tf[2]["date_debut"]) > ndb.DateDMYtoISO(tf[2]["date_fin"]):
msg = '- Dates de début et fin incompatibles !
'
if tf[0] == 0 or msg:
return render_template(
"sco_page.j2",
javascripts=["libjs/AutoSuggest.js"],
cssstyles=["css/autosuggest_inquisitor.css"],
title="Copie du semestre",
content="".join(H) + msg + tf[1],
)
elif tf[0] == -1: # cancel
return flask.redirect(
url_for(
"notes.formsemestre_status",
scodoc_dept=g.scodoc_dept,
formsemestre_id=formsemestre_id,
)
)
else:
resp = User.get_user_from_nomplogin(tf[2]["responsable_id"])
if not resp:
raise ScoValueError("id responsable invalide")
new_formsemestre_id = do_formsemestre_clone(
formsemestre_id,
resp,
tf[2]["date_debut"],
tf[2]["date_fin"],
clone_evaluations=tf[2]["clone_evaluations"],
clone_partitions=tf[2]["clone_partitions"],
)
flash("Nouveau semestre créé")
return flask.redirect(
url_for(
"notes.formsemestre_status",
scodoc_dept=g.scodoc_dept,
formsemestre_id=new_formsemestre_id,
)
)
def do_formsemestre_clone(
orig_formsemestre_id,
responsable: User, # new resp.
date_debut,
date_fin, # 'dd/mm/yyyy'
clone_evaluations=False,
clone_partitions=False,
):
"""Clone a semestre: make copy, same modules, same options, same resps, same partitions.
Clone description.
New dates, responsable_id
"""
log(f"do_formsemestre_clone: {orig_formsemestre_id}")
formsemestre_orig: FormSemestre = FormSemestre.query.get_or_404(
orig_formsemestre_id
)
# 1- create sem
args = formsemestre_orig.to_dict()
del args["formsemestre_id"]
del args["id"]
del args["parcours"] # copiés ensuite
args["responsables"] = [responsable]
args["date_debut"] = date_debut
args["date_fin"] = date_fin
args["etat"] = 1 # non verrouillé
formsemestre = FormSemestre.create_formsemestre(args)
log(f"created formsemestre {formsemestre}")
# 2- create moduleimpls
modimpl_orig: ModuleImpl
for modimpl_orig in formsemestre_orig.modimpls:
assert isinstance(modimpl_orig, ModuleImpl)
assert isinstance(modimpl_orig.id, int)
log(f"cloning {modimpl_orig}")
args = modimpl_orig.to_dict(with_module=False)
args["formsemestre_id"] = formsemestre.id
modimpl_new = ModuleImpl.create_from_dict(args)
log(f"created ModuleImpl from {args}")
db.session.flush()
# copy enseignants
for ens in modimpl_orig.enseignants:
modimpl_new.enseignants.append(ens)
db.session.add(modimpl_new)
db.session.flush()
log(f"new moduleimpl.id = {modimpl_new.id}")
# optionally, copy evaluations
if clone_evaluations:
e: Evaluation
for e in Evaluation.query.filter_by(moduleimpl_id=modimpl_orig.id):
log(f"cloning evaluation {e.id}")
# copie en enlevant la date
args = dict(e.__dict__)
args.pop("_sa_instance_state")
args.pop("id")
args.pop("date_debut", None)
args.pop("date_fin", None)
args["moduleimpl_id"] = modimpl_new.id
new_eval = Evaluation(**args)
db.session.add(new_eval)
db.session.commit()
# Copie les poids APC de l'évaluation
new_eval.set_ue_poids_dict(e.get_ue_poids_dict())
db.session.commit()
if clone_evaluations:
flash(
"Attention: les évaluations n'ont plus de dates: n'oubliez pas de les indiquer"
)
# 3- copy uecoefs
for ue_coef in FormSemestreUECoef.query.filter_by(
formsemestre_id=formsemestre_orig.id
):
new_ue_coef = FormSemestreUECoef(
formsemestre_id=formsemestre.id,
ue_id=ue_coef.ue_id,
coefficient=ue_coef.coefficient,
)
db.session.add(new_ue_coef)
db.session.flush()
# NB: don't copy notes_formsemestre_custommenu (usually specific)
# 4- Copy new style preferences
prefs = sco_preferences.SemPreferences(orig_formsemestre_id)
if orig_formsemestre_id in prefs.base_prefs.prefs:
for pname in prefs.base_prefs.prefs[orig_formsemestre_id]:
if not prefs.is_global(pname):
pvalue = prefs[pname]
try:
prefs.base_prefs.set(formsemestre.id, pname, pvalue)
except ValueError:
log(
f"""do_formsemestre_clone: ignoring old preference {
pname}={pvalue} for {formsemestre}"""
)
# 5- Copie les parcours
formsemestre.parcours = formsemestre_orig.parcours
# 6- Copy description
if formsemestre_orig.description:
formsemestre.description = formsemestre_orig.description.clone()
db.session.add(formsemestre)
db.session.commit()
# 7- Copy partitions and groups
if clone_partitions:
sco_groups_copy.clone_partitions_and_groups(
orig_formsemestre_id, formsemestre.id
)
return formsemestre.id
def formsemestre_delete(formsemestre_id: int) -> str | flask.Response:
"""Delete a formsemestre (affiche avertissements)"""
formsemestre: FormSemestre = FormSemestre.get_formsemestre(formsemestre_id)
H = [
"""Suppression du semestre
Attention !
A n'utiliser qu'en cas d'erreur lors de la saisie d'une formation. Normalement,
un semestre ne doit jamais être supprimé
(on perd la mémoire des notes et de tous les événements liés à ce semestre !).
Tous les modules de ce semestre seront supprimés.
Ceci n'est possible que si :
- aucune décision de jury n'a été entrée dans ce semestre;
- et aucun étudiant de ce semestre ne le compense avec un autre semestre.
""",
]
evaluations = (
Evaluation.query.join(ModuleImpl)
.filter_by(formsemestre_id=formsemestre.id)
.all()
)
if evaluations:
H.append(
f"""Attention: il y a {len(evaluations)} évaluations
dans ce semestre
(sa suppression entrainera l'effacement définif des notes) !
"""
)
submit_label = f"Confirmer la suppression (du semestre et des {len(evaluations)} évaluations !)"
else:
submit_label = "Confirmer la suppression du semestre"
tf = TrivialFormulator(
request.base_url,
scu.get_request_args(),
(("formsemestre_id", {"input_type": "hidden"}),),
initvalues=formsemestre.to_dict(),
submitlabel=submit_label,
cancelbutton="Annuler",
)
if tf[0] == 0:
has_decisions, message = formsemestre_has_decisions_or_compensations(
formsemestre
)
if has_decisions:
H.append(
f"""Ce semestre ne peut pas être supprimé !
il y a des décisions de jury ou des compensations par d'autres semestres:
"""
)
else:
H.append(tf[1])
return render_template(
"sco_page.j2", title="Suppression du semestre", content="\n".join(H)
)
if tf[0] == -1: # cancel
return flask.redirect(
url_for(
"notes.formsemestre_status",
scodoc_dept=g.scodoc_dept,
formsemestre_id=formsemestre_id,
)
)
return flask.redirect(
"formsemestre_delete2?formsemestre_id=" + str(formsemestre_id)
)
def formsemestre_delete2(formsemestre_id, dialog_confirmed=False):
"""Delete a formsemestre (confirmation)"""
formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
# Confirmation dialog
if not dialog_confirmed:
return scu.confirm_dialog(
"""Vous voulez vraiment supprimer ce semestre ???
(opération irréversible)
""",
dest_url="",
cancel_url=url_for(
"notes.formsemestre_status",
scodoc_dept=g.scodoc_dept,
formsemestre_id=formsemestre.id,
),
parameters={"formsemestre_id": formsemestre.id},
)
# Bon, s'il le faut...
do_formsemestre_delete(formsemestre.id)
flash("Semestre supprimé !")
return flask.redirect(url_for("scolar.index_html", scodoc_dept=g.scodoc_dept))
def formsemestre_has_decisions_or_compensations(
formsemestre: FormSemestre,
) -> tuple[bool, str]:
"""True if decision de jury (sem. UE, RCUE, année) émanant de ce semestre
ou compensation de ce semestre par d'autres semestres
ou autorisations de passage.
"""
# Validations de semestre ou d'UEs
nb_validations = ScolarFormSemestreValidation.query.filter_by(
formsemestre_id=formsemestre.id
).count()
if nb_validations:
return True, f"{nb_validations} validations de semestre ou d'UE"
nb_validations = ScolarFormSemestreValidation.query.filter_by(
compense_formsemestre_id=formsemestre.id
).count()
if nb_validations:
return True, f"{nb_validations} compensations utilisées dans d'autres semestres"
# Autorisations d'inscription:
nb_validations = ScolarAutorisationInscription.query.filter_by(
origin_formsemestre_id=formsemestre.id
).count()
if nb_validations:
return (
True,
f"{nb_validations} autorisations d'inscriptions émanant de ce semestre",
)
# Validations d'années BUT
nb_validations = ApcValidationAnnee.query.filter_by(
formsemestre_id=formsemestre.id
).count()
if nb_validations:
return True, f"{nb_validations} validations d'année BUT utilisant ce semestre"
# Validations de RCUEs
nb_validations = ApcValidationRCUE.query.filter_by(
formsemestre_id=formsemestre.id
).count()
if nb_validations:
return True, f"{nb_validations} validations de RCUE utilisant ce semestre"
return False, ""
def do_formsemestre_delete(formsemestre_id: int):
"""delete formsemestre, and all its moduleimpls.
No checks, no warnings: erase all !
"""
formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
sco_cache.EvaluationCache.invalidate_sem(formsemestre.id)
titre_sem = formsemestre.titre_annee()
# --- Destruction des modules de ce semestre
for modimpl in formsemestre.modimpls:
# evaluations
for e in modimpl.evaluations:
db.session.execute(
sa.text(
"""DELETE FROM notes_notes WHERE evaluation_id=:evaluation_id"""
),
{"evaluation_id": e.id},
)
db.session.execute(
sa.text(
"""DELETE FROM notes_notes_log WHERE evaluation_id=:evaluation_id"""
),
{"evaluation_id": e.id},
)
db.session.delete(e)
db.session.delete(modimpl)
# --- Desinscription des etudiants
db.session.execute(
sa.text(
"DELETE FROM notes_formsemestre_inscription WHERE formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- Suppression des evenements
db.session.execute(
sa.text("DELETE FROM scolar_events WHERE formsemestre_id=:formsemestre_id"),
{"formsemestre_id": formsemestre_id},
)
# --- Suppression des appreciations
db.session.execute(
sa.text(
"DELETE FROM notes_appreciations WHERE formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- Supression des validations (!!!)
db.session.execute(
sa.text(
"DELETE FROM scolar_formsemestre_validation WHERE formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- Supression des references a ce semestre dans les compensations:
db.session.execute(
sa.text(
"""UPDATE scolar_formsemestre_validation
SET compense_formsemestre_id=NULL
WHERE compense_formsemestre_id=:formsemestre_id"""
),
{"formsemestre_id": formsemestre_id},
)
# --- Suppression des autorisations
db.session.execute(
sa.text(
"DELETE FROM scolar_autorisation_inscription WHERE origin_formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- Suppression des coefs d'UE capitalisées
db.session.execute(
sa.text(
"DELETE FROM notes_formsemestre_uecoef WHERE formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- Suppression des item du menu custom
db.session.execute(
sa.text(
"DELETE FROM notes_formsemestre_custommenu WHERE formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- Suppression des formules
db.session.execute(
sa.text(
"DELETE FROM notes_formsemestre_ue_computation_expr WHERE formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- Suppression des preferences
db.session.execute(
sa.text("DELETE FROM sco_prefs WHERE formsemestre_id=:formsemestre_id"),
{"formsemestre_id": formsemestre_id},
)
# --- Suppression des groupes et partitions
db.session.execute(
sa.text(
"""
DELETE FROM group_membership
WHERE group_id IN
(SELECT gm.group_id FROM group_membership gm, partition p, group_descr gd
WHERE gm.group_id = gd.id AND gd.partition_id = p.id
AND p.formsemestre_id=:formsemestre_id)
"""
),
{"formsemestre_id": formsemestre_id},
)
db.session.execute(
sa.text(
"""
DELETE FROM group_descr
WHERE id IN
(SELECT gd.id FROM group_descr gd, partition p
WHERE gd.partition_id = p.id
AND p.formsemestre_id=:formsemestre_id)
"""
),
{"formsemestre_id": formsemestre_id},
)
db.session.execute(
sa.text("DELETE FROM partition WHERE formsemestre_id=:formsemestre_id"),
{"formsemestre_id": formsemestre_id},
)
# --- Responsables
db.session.execute(
sa.text(
"DELETE FROM notes_formsemestre_responsables WHERE formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- Etapes
db.session.execute(
sa.text(
"DELETE FROM notes_formsemestre_etapes WHERE formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- SemSets
db.session.execute(
sa.text(
"DELETE FROM notes_semset_formsemestre WHERE formsemestre_id=:formsemestre_id"
),
{"formsemestre_id": formsemestre_id},
)
# --- Dispenses d'UE
db.session.execute(
sa.text("""DELETE FROM "dispenseUE" WHERE formsemestre_id=:formsemestre_id"""),
{"formsemestre_id": formsemestre_id},
)
# --- Destruction du semestre
db.session.delete(formsemestre)
# news
ScolarNews.add(
typ=ScolarNews.NEWS_SEM,
obj=formsemestre_id,
text=f"Suppression du semestre {titre_sem}",
max_frequency=0,
)
# ---------------------------------------------------------------------------------------
def formsemestre_edit_options(formsemestre_id):
"""dialog to change formsemestre options
(accessible par EditFormSemestre ou dir. etudes)
"""
formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
ok, err = sco_permissions_check.check_access_diretud(formsemestre)
if not ok:
return err
return sco_preferences.SemPreferences(formsemestre_id).edit(
categories=["bul", "bul_but_pdf"]
)
def formsemestre_change_publication_bul(formsemestre_id, dialog_confirmed=False):
"""Change état publication bulletins sur portail"""
formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
ok, err = sco_permissions_check.check_access_diretud(formsemestre)
if not ok:
return err
etat = not formsemestre.bul_hide_xml
status_url = url_for(
"notes.formsemestre_status",
scodoc_dept=g.scodoc_dept,
formsemestre_id=formsemestre.id,
)
if not dialog_confirmed:
msg = "non" if etat else ""
return scu.confirm_dialog(
f"Confirmer la {msg} publication des bulletins ?
",
help_msg="""Il est parfois utile de désactiver la diffusion des bulletins,
par exemple pendant la tenue d'un jury ou avant harmonisation des notes.
Ce réglage n'a d'effet que si votre établissement a interfacé ScoDoc avec
une passerelle étudiant.
""",
dest_url="",
cancel_url=status_url,
parameters={"bul_hide_xml": etat, "formsemestre_id": formsemestre_id},
)
formsemestre.bul_hide_xml = etat
db.session.add(formsemestre)
db.session.commit()
log(f"formsemestre_change_publication_bul: {formsemestre} -> {etat}")
return flask.redirect(status_url)
def formsemestre_edit_uecoefs(formsemestre_id, err_ue_id=None):
"""Changement manuel des coefficients des UE capitalisées."""
formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
ok, err = sco_permissions_check.check_access_diretud(formsemestre)
if not ok:
return err
help_msg = """
Seuls les modules ont un coefficient. Cependant, il est nécessaire d'affecter un coefficient aux UE capitalisée pour pouvoir les prendre en compte dans la moyenne générale.
ScoDoc calcule normalement le coefficient d'une UE comme la somme des
coefficients des modules qui la composent.
Dans certains cas, on n'a pas les mêmes modules dans le semestre antérieur
(capitalisé) et dans le semestre courant, et le coefficient d'UE est alors variable.
Il est alors possible de forcer la valeur du coefficient d'UE.
Indiquez "auto" (ou laisser vide) pour que ScoDoc calcule automatiquement le coefficient,
ou bien entrez une valeur (nombre réel).
Dans le doute, si le mode auto n'est pas applicable et que tous les étudiants sont inscrits aux mêmes modules de ce semestre, prenez comme coefficient la somme indiquée.
Sinon, référez vous au programme pédagogique. Les lignes en rouge
sont à changer.
Les coefficients indiqués ici ne s'appliquent que pour le traitement des UE capitalisées.
"""
H = [
help_msg,
]
#
ues, modimpls = _get_sem_ues_modimpls(formsemestre)
sum_coefs_by_ue_id = {}
for ue in ues:
sum_coefs_by_ue_id[ue.id] = sum(
modimpl.module.coefficient or 0.0
for modimpl in modimpls
if modimpl.module.ue_id == ue.id
)
cnx = ndb.GetDBConnexion()
initvalues = {"formsemestre_id": formsemestre_id}
form = [("formsemestre_id", {"input_type": "hidden"})]
for ue in ues:
coefs = sco_formsemestre.formsemestre_uecoef_list(
cnx, args={"formsemestre_id": formsemestre_id, "ue_id": ue.id}
)
if coefs:
initvalues["ue_" + str(ue.id)] = coefs[0]["coefficient"]
else:
initvalues["ue_" + str(ue.id)] = "auto"
descr = {
"size": 10,
"title": ue.acronyme,
"explanation": f"somme coefs modules = {sum_coefs_by_ue_id[ue.id]}",
}
if ue.id == err_ue_id:
descr["dom_id"] = "erroneous_ue"
form.append(("ue_" + str(ue.id), descr))
tf = TrivialFormulator(
request.base_url,
scu.get_request_args(),
form,
submitlabel="Changer les coefficients",
cancelbutton="Annuler",
initvalues=initvalues,
)
if tf[0] == 0:
return render_template(
"sco_page.j2",
title="Coefficients des UE du semestre",
content="Coefficients des UE du semestre
" + "\n".join(H) + tf[1],
)
elif tf[0] == -1:
return redirect(
url_for(
"notes.formsemestre_editwithmodules",
scodoc_dept=g.scodoc_dept,
formsemestre_id=formsemestre_id,
)
)
else:
# change values
# 1- supprime les coef qui ne sont plus forcés
# 2- modifie ou cree les coefs
ue_deleted = []
ue_modified: list[tuple[UniteEns, float]] = []
msg = []
for ue in ues:
val = tf[2]["ue_" + str(ue.id)]
coefs = sco_formsemestre.formsemestre_uecoef_list(
cnx, args={"formsemestre_id": formsemestre_id, "ue_id": ue.id}
)
if val == "" or val == "auto":
# supprime ce coef (il sera donc calculé automatiquement)
if coefs:
ue_deleted.append(ue)
else:
try:
val = float(val)
if (not coefs) or (coefs[0]["coefficient"] != val):
ue_modified.append((ue, val))
except ValueError:
ok = False
msg.append(
f"valeur invalide ({val}) pour le coefficient de l'UE {ue.acronyme}"
)
if not ok:
render_template(
"sco_page.j2",
title="Coefficients des UE du semestre",
content="Coefficients des UE du semestre
"
+ "\n".join(H)
+ "" % "".join(msg)
+ tf[1],
)
# apply modifications
for ue, val in ue_modified:
sco_formsemestre.do_formsemestre_uecoef_edit_or_create(
cnx, formsemestre_id, ue.id, val
)
for ue in ue_deleted:
sco_formsemestre.do_formsemestre_uecoef_delete(cnx, formsemestre_id, ue.id)
if ue_modified or ue_deleted:
message = ["""Modification effectuées
"""]
if ue_modified:
message.append("""Coefs modifiés dans les UE:""")
for ue, val in ue_modified:
message.append(f"- {ue.acronyme} : {val}
")
message.append("
")
if ue_deleted:
message.append("""Coefs supprimés dans les UE:""")
for ue in ue_deleted:
message.append(f"- {ue.acronyme}
")
message.append("
")
sco_cache.invalidate_formsemestre(
formsemestre_id=formsemestre_id
) # > modif coef UE cap (modifs notes de _certains_ etudiants)
else:
message = ["""Aucune modification
"""]
return render_template(
"sco_page.j2",
title="Coefficients des UE du semestre",
content=f"""
Coefficients des UE du semestre
{" ".join(message)}
Revenir au tableau de bord
""",
)
def _get_sem_ues_modimpls(
formsemestre: FormSemestre,
) -> tuple[list[UniteEns], list[ModuleImpl]]:
"""Get liste des UE du semestre (à partir des moduleimpls)
(utilisé quand on ne peut pas construire nt et faire nt.get_ues_stat_dict())
"""
uedict = {}
modimpls = formsemestre.modimpls.all()
for modimpl in modimpls:
if not modimpl.module.ue_id in uedict:
uedict[modimpl.module.ue.id] = modimpl.module.ue
ues = list(uedict.values())
ues.sort(key=lambda u: u.numero)
return ues, modimpls
# ----- identification externe des sessions (pour SOJA et autres logiciels)
def get_formsemestre_session_id(sem, code_specialite, parcours):
"""Identifiant de session pour ce semestre
Obsolete: vooir FormSemestre.session_id() #sco7
"""
imputation_dept = sco_preferences.get_preference(
"ImputationDept", sem["formsemestre_id"]
)
if not imputation_dept:
imputation_dept = sco_preferences.get_preference("DeptName") or ""
imputation_dept = imputation_dept.upper()
parcours_type = parcours.NAME
modalite = sem["modalite"]
modalite = (
(modalite or "").replace("FAP", "FA").replace("APP", "FA")
) # exception pour code Apprentissage
if sem["semestre_id"] > 0:
decale = scu.sem_decale_str(sem)
semestre_id = "S%d" % sem["semestre_id"] + decale
else:
semestre_id = code_specialite
annee_sco = str(scu.annee_scolaire_debut(sem["annee_debut"], sem["mois_debut_ord"]))
return scu.sanitize_string(
"-".join(
(imputation_dept, parcours_type, modalite, semestre_id or "", annee_sco)
)
)