"
+ )
#
def infos(self) -> str:
@@ -581,9 +593,10 @@ class DecisionsProposeesAnnee(DecisionsProposees):
def compute_decisions_niveaux(self) -> dict[int, "DecisionsProposeesRCUE"]:
"""Pour chaque niveau de compétence de cette année, construit
- le DecisionsProposeesRCUE,
- ou None s'il n'y en a pas
+ le DecisionsProposeesRCUE, ou None s'il n'y en a pas
(ne devrait pas arriver car compute_rcues_annee vérifie déjà cela).
+
+ Appelé à la construction du deca, donc avant décisions manuelles.
Return: { niveau_id : DecisionsProposeesRCUE }
"""
# Retrouve le RCUE associé à chaque niveau
@@ -630,6 +643,7 @@ class DecisionsProposeesAnnee(DecisionsProposees):
def record_form(self, form: dict):
"""Enregistre les codes de jury en base
+ à partir d'un dict représentant le formulaire jury BUT:
form dict:
- 'code_ue_1896' : 'AJ' code pour l'UE id 1896
- 'code_rcue_6" : 'ADM' code pour le RCUE du niveau 6
@@ -639,32 +653,42 @@ class DecisionsProposeesAnnee(DecisionsProposees):
et qu'il n'y en a pas déjà, enregistre ceux par défaut.
"""
log("jury_but.DecisionsProposeesAnnee.record_form")
- with sco_cache.DeferredSemCacheManager():
- for key in form:
- code = form[key]
- # Codes d'UE
- m = re.match(r"^code_ue_(\d+)$", key)
+ code_annee = None
+ codes_rcues = [] # [ (dec_rcue, code), ... ]
+ codes_ues = [] # [ (dec_ue, code), ... ]
+ for key in form:
+ code = form[key]
+ # Codes d'UE
+ m = re.match(r"^code_ue_(\d+)$", key)
+ if m:
+ ue_id = int(m.group(1))
+ dec_ue = self.decisions_ues.get(ue_id)
+ if not dec_ue:
+ raise ScoValueError(f"UE invalide ue_id={ue_id}")
+ codes_ues.append((dec_ue, code))
+ else:
+ # Codes de RCUE
+ m = re.match(r"^code_rcue_(\d+)$", key)
if m:
- ue_id = int(m.group(1))
- dec_ue = self.decisions_ues.get(ue_id)
- if not dec_ue:
- raise ScoValueError(f"UE invalide ue_id={ue_id}")
- dec_ue.record(code)
- else:
- # Codes de RCUE
- m = re.match(r"^code_rcue_(\d+)$", key)
- if m:
- niveau_id = int(m.group(1))
- dec_rcue = self.decisions_rcue_by_niveau.get(niveau_id)
- if not dec_rcue:
- raise ScoValueError(f"RCUE invalide niveau_id={niveau_id}")
- dec_rcue.record(code)
- elif key == "code_annee":
- # Code annuel
- self.record(code)
+ niveau_id = int(m.group(1))
+ dec_rcue = self.decisions_rcue_by_niveau.get(niveau_id)
+ if not dec_rcue:
+ raise ScoValueError(f"RCUE invalide niveau_id={niveau_id}")
+ codes_rcues.append((dec_rcue, code))
+ elif key == "code_annee":
+ # Code annuel
+ code_annee = code
+ with sco_cache.DeferredSemCacheManager():
+ # Enregistre les codes, dans l'ordre UE, RCUE, Année
+ for dec_ue, code in codes_ues:
+ dec_ue.record(code)
+ for dec_rcue, code in codes_rcues:
+ dec_rcue.record(code)
+ self.record(code_annee)
self.record_all()
- db.session.commit()
+
+ db.session.commit()
def record(self, code: str, no_overwrite=False):
"""Enregistre le code de l'année, et au besoin l'autorisation d'inscription.
@@ -682,7 +706,7 @@ class DecisionsProposeesAnnee(DecisionsProposees):
return # no change
if self.validation:
db.session.delete(self.validation)
- db.session.flush()
+ db.session.commit()
if code is None:
self.validation = None
else:
@@ -693,12 +717,15 @@ class DecisionsProposeesAnnee(DecisionsProposees):
annee_scolaire=self.annee_scolaire(),
code=code,
)
+ db.session.add(self.validation)
+ db.session.commit()
+ log(f"Recording {self}: {code}")
Scolog.logdb(
method="jury_but",
etudid=self.etud.id,
msg=f"Validation année BUT{self.annee_but}: {code}",
)
- db.session.add(self.validation)
+
# --- Autorisation d'inscription dans semestre suivant ?
if self.formsemestre_pair is not None:
if code is None:
@@ -729,29 +756,49 @@ class DecisionsProposeesAnnee(DecisionsProposees):
if self.formsemestre_pair is not None:
sco_cache.invalidate_formsemestre(formsemestre_id=self.formsemestre_pair.id)
- def record_all(self):
+ def record_all(self, no_overwrite: bool = True):
"""Enregistre les codes qui n'ont pas été spécifiés par le formulaire,
- et sont donc en mode "automatique"
+ et sont donc en mode "automatique".
+ - Si "à cheval", ne modifie pas les codes UE de l'année scolaire précédente.
+ - Pour les RCUE: n'enregistre que si la nouvelle décision est plus favorable que l'ancienne.
"""
- decisions = (
- list(self.decisions_ues.values())
- + list(self.decisions_rcue_by_niveau.values())
- + [self]
- )
- for dec in decisions:
- if not dec.recorded:
+ # Toujours valider dans l'ordre UE, RCUE, Année:
+ annee_scolaire = self.formsemestre.annee_scolaire()
+ # UEs
+ for dec_ue in self.decisions_ues.values():
+ if (
+ not dec_ue.recorded
+ ) and dec_ue.formsemestre.annee_scolaire() == annee_scolaire:
# rappel: le code par défaut est en tête
- code = dec.codes[0] if dec.codes else None
+ code = dec_ue.codes[0] if dec_ue.codes else None
# enregistre le code jury seulement s'il n'y a pas déjà de code
- dec.record(code, no_overwrite=True)
+ # (no_overwrite=True) sauf en mode test yaml
+ dec_ue.record(code, no_overwrite=no_overwrite)
+ # RCUE : enregistre seulement si pas déjà validé "mieux"
+ for dec_rcue in self.decisions_rcue_by_niveau.values():
+ code = dec_rcue.codes[0] if dec_rcue.codes else None
+ if (not dec_rcue.recorded) and (
+ (not dec_rcue.validation)
+ or BUT_CODES_ORDERED.get(dec_rcue.validation.code, 0)
+ < BUT_CODES_ORDERED.get(code, 0)
+ ):
+ dec_rcue.record(code, no_overwrite=no_overwrite)
+ # Année:
+ if not self.recorded:
+ # rappel: le code par défaut est en tête
+ code = self.codes[0] if self.codes else None
+ # enregistre le code jury seulement s'il n'y a pas déjà de code
+ # (no_overwrite=True) sauf en mode test yaml
+ self.record(code, no_overwrite=no_overwrite)
def erase(self, only_one_sem=False):
"""Efface les décisions de jury de cet étudiant
pour cette année: décisions d'UE, de RCUE, d'année,
et autorisations d'inscription émises.
Efface même si étudiant DEM ou DEF.
+ Si à cheval, n'efface que pour le semestre d'origine du deca.
"""
- if only_one_sem:
+ if only_one_sem or self.a_cheval:
# N'efface que les autorisations venant de ce semestre,
# et les validations de ses UEs
ScolarAutorisationInscription.delete_autorisation_etud(
@@ -779,13 +826,23 @@ class DecisionsProposeesAnnee(DecisionsProposees):
ordre=self.annee_but,
)
for validation in validations:
+ db.session.delete(validation)
Scolog.logdb(
"jury_but",
etudid=self.etud.id,
msg=f"Validation année BUT{self.annee_but}: effacée",
)
- db.session.delete(validation)
- db.session.flush()
+
+ # Efface éventuelles validations de semestre
+ # (en principe inutilisées en BUT)
+ # et autres UEs (en cas de changement d'architecture de formation depuis le jury ?)
+ #
+ for validation in ScolarFormSemestreValidation.query.filter_by(
+ etudid=self.etud.id, formsemestre_id=self.formsemestre_id
+ ):
+ db.session.delete(validation)
+
+ db.session.commit()
self.invalidate_formsemestre_cache()
def get_autorisations_passage(self) -> list[int]:
@@ -828,6 +885,27 @@ class DecisionsProposeesAnnee(DecisionsProposees):
validations.append(", ".join(v for v in valids if v))
return line_sep.join(validations)
+ def descr_pb_coherence(self) -> list[str]:
+ """Description d'éventuels problèmes de cohérence entre
+ les décisions *enregistrées* d'UE et de RCUE.
+ Note: en principe, la cohérence RCUE/UE est assurée au moment de
+ l'enregistrement (record).
+ Mais la base peut avoir été modifiée par d'autres voies.
+ """
+ messages = []
+ for dec_rcue in self.decisions_rcue_by_niveau.values():
+ if dec_rcue.code_valide in CODES_RCUE_VALIDES:
+ for ue in (dec_rcue.rcue.ue_1, dec_rcue.rcue.ue_2):
+ dec_ue = self.decisions_ues.get(ue.id)
+ if dec_ue:
+ if dec_ue.code_valide not in CODES_UE_VALIDES:
+ messages.append(
+ f"L'UE {ue.acronyme} n'est pas validée mais son RCUE l'est !"
+ )
+ else:
+ messages.append(f"L'UE {ue.acronyme} n'a pas décision (???)")
+ return messages
+
def list_ue_parcour_etud(
formsemestre: FormSemestre, etud: Identite, res: ResultatsSemestreBUT
@@ -873,6 +951,7 @@ class DecisionsProposeesRCUE(DecisionsProposees):
inscription_etat: str = scu.INSCRIT,
):
super().__init__(etud=dec_prop_annee.etud)
+ self.deca = dec_prop_annee
self.rcue = rcue
if rcue is None: # RCUE non dispo, eg un seul semestre
self.codes = []
@@ -904,9 +983,30 @@ class DecisionsProposeesRCUE(DecisionsProposees):
or dec_prop_annee.formsemestre_pair.modalite == "EXT"
):
self.codes.insert(0, sco_codes.ADM)
+ # S'il y a une décision enregistrée: si elle est plus favorable que celle que l'on
+ # proposerait, la place en tête.
+ # Sinon, la place en seconde place
+ if self.code_valide and self.code_valide != self.codes[0]:
+ code_default = self.codes[0]
+ if self.code_valide in self.codes:
+ self.codes.remove(self.code_valide)
+ if sco_codes.BUT_CODES_ORDERED.get(
+ self.code_valide, 0
+ ) > sco_codes.BUT_CODES_ORDERED.get(code_default, 0):
+ self.codes.insert(0, self.code_valide)
+ else:
+ self.codes.insert(1, self.code_valide)
+
+ def __repr__(self) -> str:
+ return f"""<{self.__class__.__name__} rcue={self.rcue} valid={self.code_valide
+ } codes={self.codes} explanation={self.explanation}"""
def record(self, code: str, no_overwrite=False):
- """Enregistre le code"""
+ """Enregistre le code RCUE.
+ Note:
+ - si le RCUE est ADJ, les UE non validées sont passées à ADJ
+ XXX on pourra imposer ici d'autres règles de cohérence
+ """
if self.rcue is None:
return # pas de RCUE a enregistrer
if self.inscription_etat != scu.INSCRIT:
@@ -921,13 +1021,10 @@ class DecisionsProposeesRCUE(DecisionsProposees):
parcours_id = self.parcour.id if self.parcour is not None else None
if self.validation:
db.session.delete(self.validation)
- db.session.flush()
+ db.session.commit()
if code is None:
self.validation = None
else:
- # log(
- # f"RCUE.record(etudid={self.etud.id}, ue1_id={self.rcue.ue_1.id}, ue2_id={self.rcue.ue_2.id}, code={code} )"
- # )
self.validation = ApcValidationRCUE(
etudid=self.etud.id,
formsemestre_id=self.rcue.formsemestre_2.id,
@@ -936,12 +1033,25 @@ class DecisionsProposeesRCUE(DecisionsProposees):
parcours_id=parcours_id,
code=code,
)
+ db.session.add(self.validation)
+ db.session.commit()
Scolog.logdb(
method="jury_but",
etudid=self.etud.id,
msg=f"Validation {self.rcue}: {code}",
+ commit=True,
)
- db.session.add(self.validation)
+ log(f"rcue.record {self}: {code}")
+
+ # Modifie au besoin les codes d'UE
+ if code == "ADJ":
+ deca = self.deca
+ for ue_id in (self.rcue.ue_1.id, self.rcue.ue_2.id):
+ dec_ue = deca.decisions_ues.get(ue_id)
+ if dec_ue and dec_ue.code_valide not in CODES_UE_VALIDES:
+ log(f"rcue.record: force ADJ sur {dec_ue}")
+ dec_ue.record("ADJ")
+
if self.rcue.formsemestre_1 is not None:
sco_cache.invalidate_formsemestre(
formsemestre_id=self.rcue.formsemestre_1.id
@@ -950,6 +1060,7 @@ class DecisionsProposeesRCUE(DecisionsProposees):
sco_cache.invalidate_formsemestre(
formsemestre_id=self.rcue.formsemestre_2.id
)
+ self.code_valide = code # mise à jour état
self.recorded = True
def erase(self):
@@ -957,6 +1068,7 @@ class DecisionsProposeesRCUE(DecisionsProposees):
# par prudence, on requete toutes les validations, en cas de doublons
validations = self.rcue.query_validations()
for validation in validations:
+ log(f"DecisionsProposeesRCUE: deleting {validation}")
db.session.delete(validation)
db.session.flush()
@@ -1010,14 +1122,14 @@ class DecisionsProposeesUE(DecisionsProposees):
):
# Une UE peut être validée plusieurs fois en cas de redoublement (qu'elle soit capitalisée ou non)
# mais ici on a restreint au formsemestre donc une seule (prend la première)
- self.validation = ScolarFormSemestreValidation.query.filter_by(
+ validation = ScolarFormSemestreValidation.query.filter_by(
etudid=etud.id, formsemestre_id=formsemestre.id, ue_id=ue.id
).first()
super().__init__(
etud=etud,
- code_valide=self.validation.code if self.validation is not None else None,
+ code_valide=validation.code if validation is not None else None,
)
- # log(f"built {self}")
+ self.validation = validation
self.formsemestre = formsemestre
self.ue: UniteEns = ue
self.rcue: RegroupementCoherentUE = None
@@ -1056,11 +1168,11 @@ class DecisionsProposeesUE(DecisionsProposees):
def __repr__(self) -> str:
return f"""<{self.__class__.__name__} ue={self.ue.acronyme} valid={self.code_valide
- } codes={self.codes} explanation={self.explanation}"""
+ } codes={self.codes} explanation={self.explanation}>"""
def set_rcue(self, rcue: RegroupementCoherentUE):
"""Rattache cette UE à un RCUE. Cela peut modifier les codes
- proposés (si compensation)"""
+ proposés par compute_codes() (si compensation)"""
self.rcue = rcue
def compute_codes(self):
@@ -1098,6 +1210,7 @@ class DecisionsProposeesUE(DecisionsProposees):
method="jury_but",
etudid=self.etud.id,
msg=f"Validation UE {self.ue.id} {self.ue.acronyme}: effacée",
+ commit=True,
)
else:
self.validation = ScolarFormSemestreValidation(
@@ -1107,15 +1220,18 @@ class DecisionsProposeesUE(DecisionsProposees):
code=code,
moy_ue=self.moy_ue,
)
+ db.session.add(self.validation)
+ db.session.commit()
Scolog.logdb(
method="jury_but",
etudid=self.etud.id,
msg=f"Validation UE {self.ue.id} {self.ue.acronyme}({self.moy_ue}): {code}",
+ commit=True,
)
- db.session.add(self.validation)
log(f"DecisionsProposeesUE: recording {self.validation}")
sco_cache.invalidate_formsemestre(formsemestre_id=self.formsemestre.id)
+ self.code_valide = code # mise à jour
self.recorded = True
def erase(self):
@@ -1126,13 +1242,14 @@ class DecisionsProposeesUE(DecisionsProposees):
)
for validation in validations:
log(f"DecisionsProposeesUE: deleting {validation}")
+ db.session.delete(validation)
Scolog.logdb(
method="jury_but",
etudid=self.etud.id,
msg=f"Validation UE {validation.ue.id} {validation.ue.acronyme}: effacée",
)
- db.session.delete(validation)
- db.session.flush()
+
+ db.session.commit()
def descr_validation(self) -> str:
"""Description validation niveau enregistrée, pour PV jury.
@@ -1148,7 +1265,7 @@ class BUTCursusEtud: # WIP TODO
def __init__(self, formsemestre: FormSemestre, etud: Identite):
if formsemestre.formation.referentiel_competence is None:
- raise ScoException("BUTCursusEtud: pas de référentiel de compétences")
+ raise ScoNoReferentielCompetences(formation=formsemestre.formation)
assert len(etud.formsemestre_inscriptions) > 0
self.formsemestre = formsemestre
self.etud = etud
diff --git a/app/but/jury_but_pv.py b/app/but/jury_but_pv.py
index 2940345ed..208d1ef2c 100644
--- a/app/but/jury_but_pv.py
+++ b/app/but/jury_but_pv.py
@@ -1,6 +1,6 @@
##############################################################################
# ScoDoc
-# Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet. All rights reserved.
# See LICENSE
##############################################################################
diff --git a/app/but/jury_but_recap.py b/app/but/jury_but_recap.py
index e3c5df9c3..386579575 100644
--- a/app/but/jury_but_recap.py
+++ b/app/but/jury_but_recap.py
@@ -1,6 +1,6 @@
##############################################################################
# ScoDoc
-# Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet. All rights reserved.
# See LICENSE
##############################################################################
@@ -32,7 +32,7 @@ from app.scodoc.sco_codes_parcours import (
from app.scodoc import sco_formsemestre_status
from app.scodoc import sco_pvjury
from app.scodoc import sco_utils as scu
-from app.scodoc.sco_exceptions import ScoValueError
+from app.scodoc.sco_exceptions import ScoNoReferentielCompetences
def formsemestre_saisie_jury_but(
@@ -63,14 +63,7 @@ def formsemestre_saisie_jury_but(
# raise ScoValueError("Cette page ne fonctionne que sur les semestres pairs")
if formsemestre2.formation.referentiel_competence is None:
- raise ScoValueError(
- """
-
Pas de référentiel de compétences associé à la formation !
-
Pour associer un référentiel, passer par le menu Semestre /
- Voir la formation... et suivre le lien "associer à un référentiel
- de compétences"
- """
- )
+ raise ScoNoReferentielCompetences(formation=formsemestre2.formation)
rows, titles, column_ids, jury_stats = get_jury_but_table(
formsemestre2, read_only=read_only, mode=mode
diff --git a/app/but/jury_but_validation_auto.py b/app/but/jury_but_validation_auto.py
index 918bd571e..d5e308ab9 100644
--- a/app/but/jury_but_validation_auto.py
+++ b/app/but/jury_but_validation_auto.py
@@ -1,6 +1,6 @@
##############################################################################
# ScoDoc
-# Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet. All rights reserved.
# See LICENSE
##############################################################################
@@ -15,12 +15,19 @@ from app.scodoc import sco_cache
from app.scodoc.sco_exceptions import ScoValueError
-def formsemestre_validation_auto_but(formsemestre: FormSemestre, only_adm=True) -> int:
+def formsemestre_validation_auto_but(
+ formsemestre: FormSemestre, only_adm: bool = True, no_overwrite: bool = True
+) -> int:
"""Calcul automatique des décisions de jury sur une année BUT.
+ Ne modifie jamais de décisions de l'année scolaire précédente, même
+ si on a des RCUE "à cheval".
Normalement, only_adm est True et on n'enregistre que les décisions ADM (de droit).
Si only_adm est faux, on enregistre la première décision proposée par ScoDoc
(mode à n'utiliser que pour les tests)
+ Si no_overwrite est vrai (défaut), ne ré-écrit jamais les codes déjà enregistrés
+ (utiliser faux pour certains tests)
+
Returns: nombre d'étudiants "admis"
"""
if not formsemestre.formation.is_apc():
@@ -33,7 +40,7 @@ def formsemestre_validation_auto_but(formsemestre: FormSemestre, only_adm=True)
if deca.admis: # année réussie
nb_admis += 1
if deca.admis or not only_adm:
- deca.record_all()
+ deca.record_all(no_overwrite=no_overwrite)
db.session.commit()
return nb_admis
diff --git a/app/but/jury_but_view.py b/app/but/jury_but_view.py
index 1a19a5b78..3140bd02e 100644
--- a/app/but/jury_but_view.py
+++ b/app/but/jury_but_view.py
@@ -1,6 +1,6 @@
##############################################################################
# ScoDoc
-# Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet. All rights reserved.
# See LICENSE
##############################################################################
@@ -30,6 +30,7 @@ from app.models import (
Identite,
UniteEns,
ScolarAutorisationInscription,
+ ScolarFormSemestreValidation,
)
from app.scodoc import html_sco_header
from app.scodoc.sco_exceptions import ScoValueError
@@ -41,32 +42,21 @@ def show_etud(deca: DecisionsProposeesAnnee, read_only: bool = True) -> str:
Si pas read_only, menus sélection codes jury.
"""
H = []
- if deca.code_valide and not read_only:
- erase_span = f"""effacer décisions"""
- else:
- erase_span = ""
H.append("""
""")
- if deca.jury_annuel:
- H.append(
- f"""
-
- Décision de jury pour l'année : {
- _gen_but_select("code_annee", deca.codes, deca.code_valide,
- disabled=True, klass="manual")
- }
- ({'non ' if deca.code_valide is None else ''}enregistrée)
- {erase_span}
-
+ H.append(
+ f"""
+
+ Décision de jury pour l'année : {
+ _gen_but_select("code_annee", deca.codes, deca.code_valide,
+ disabled=True, klass="manual")
+ }
+ ({deca.code_valide or 'non'} enregistrée)
+
"""
@@ -278,17 +291,15 @@ def jury_but_semestriel(
semestre_terminal = (
formsemestre.semestre_id >= formsemestre.formation.get_parcours().NB_SEM
)
+ autorisations_passage = ScolarAutorisationInscription.query.filter_by(
+ etudid=etud.id,
+ origin_formsemestre_id=formsemestre.id,
+ ).all()
# Par défaut: autorisé à passer dans le semestre suivant si sem. impair,
# ou si décision déjà enregistrée:
est_autorise_a_passer = (formsemestre.semestre_id % 2) or (
formsemestre.semestre_id + 1
- ) in (
- a.semestre_id
- for a in ScolarAutorisationInscription.query.filter_by(
- etudid=etud.id,
- origin_formsemestre_id=formsemestre.id,
- )
- )
+ ) in (a.semestre_id for a in autorisations_passage)
decisions_ues = {
ue.id: DecisionsProposeesUE(etud, formsemestre, ue, inscription_etat)
for ue in ues
@@ -312,7 +323,9 @@ def jury_but_semestriel(
flash("codes enregistrés")
if not semestre_terminal:
if request.form.get("autorisation_passage"):
- if not est_autorise_a_passer:
+ if not formsemestre.semestre_id + 1 in (
+ a.semestre_id for a in autorisations_passage
+ ):
ScolarAutorisationInscription.autorise_etud(
etud.id,
formsemestre.formation.formation_code,
@@ -351,7 +364,7 @@ def jury_but_semestriel(
warning = ""
H = [
html_sco_header.sco_header(
- page_title="Validation BUT",
+ page_title=f"Validation BUT S{formsemestre.semestre_id}",
formsemestre_id=formsemestre.id,
etudid=etud.id,
cssstyles=("css/jury_but.css",),
@@ -372,25 +385,35 @@ def jury_but_semestriel(
}">{etud.photo_html(title="fiche de " + etud.nomprenom)}
-
Jury sur un semestre BUT isolé
+
Jury sur un semestre BUT isolé (ne concerne que les UEs)