iziram/ScoDoc
1
0
Fork 0
forked from ScoDoc/ScoDoc
Code Issues 12 Pull Requests Projects 1 Releases Wiki Activity

Apo: export BUT element annuel

Browse Source
This commit is contained in:
Emmanuel Viennet 2023-04-19 11:51:58 +02:00
parent 54bcbff179
commit 8f844f5191
3 changed files with 156 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
app/comp/res_compat.py
View File

@ -322,7 +322,8 @@ class NotesTableCompat(ResultatsSemestre):
def get_etud_decision_sem(self, etudid: int) -> dict: def get_etud_decision_sem(self, etudid: int) -> dict:
"""Decision du jury semestre prise pour cet etudiant, ou None s'il n'y en pas eu. """Decision du jury semestre prise pour cet etudiant, ou None s'il n'y en pas eu.
{ 'code' : None|ATT|..., 'assidu' : 0|1, 'event_date' : , compense_formsemestre_id } { 'code' : None|ATT|..., 'assidu' : 0|1, 'event_date' : , compense_formsemestre_id }
Si état défaillant, force le code a DEF Si état défaillant, force le code a DEF.
Toujours None en BUT.
""" """
if self.get_etud_etat(etudid) == DEF: if self.get_etud_etat(etudid) == DEF:
return { return {

232
app/scodoc/sco_apogee_csv.py
View File

@ -265,7 +265,6 @@ class ApoEtud(dict):
"Vrai si BUT" "Vrai si BUT"
self.col_elts = {} self.col_elts = {}
"{'V1RT': {'R': 'ADM', 'J': '', 'B': 20, 'N': '12.14'}}" "{'V1RT': {'R': 'ADM', 'J': '', 'B': 20, 'N': '12.14'}}"
self.new_cols = {} # { col_id : value to record in csv }
self.etud: Identite = None self.etud: Identite = None
"etudiant ScoDoc associé" "etudiant ScoDoc associé"
self.etat = None # ETUD_OK, ... self.etat = None # ETUD_OK, ...
@ -283,6 +282,17 @@ class ApoEtud(dict):
self.fmt_note = functools.partial( self.fmt_note = functools.partial(
_apo_fmt_note, fmt=ScoDocSiteConfig.get_code_apo("NOTES_FMT") or "3.2f" _apo_fmt_note, fmt=ScoDocSiteConfig.get_code_apo("NOTES_FMT") or "3.2f"
) )
# Initialisés par associate_sco:
self.autre_sem: dict = None
self.autre_res: NotesTableCompat = None
self.cur_sem: dict = None
self.cur_res: NotesTableCompat = None
self.new_cols = {}
"{ col_id : value to record in csv }"
# Pour le BUT:
self.validation_annee_but: ApcValidationAnnee = None
"validation de jury annuelle BUT, ou None"
def __repr__(self): def __repr__(self):
return f"""ApoEtud( nom='{self["nom"]}', nip='{self["nip"]}' )""" return f"""ApoEtud( nom='{self["nom"]}', nip='{self["nip"]}' )"""
@ -336,18 +346,17 @@ class ApoEtud(dict):
sco_elts = {} # valeurs trouvées dans ScoDoc code : { N, B, J, R } sco_elts = {} # valeurs trouvées dans ScoDoc code : { N, B, J, R }
for col_id in apo_data.col_ids[4:]: for col_id in apo_data.col_ids[4:]:
code = apo_data.cols[col_id]["Code"] # 'V1RT' code = apo_data.cols[col_id]["Code"] # 'V1RT'
el = sco_elts.get( elt = sco_elts.get(code, None)
code, None # elt est {'R': ADM, 'J': '', 'B': 20, 'N': '12.14'}
) # {'R': ADM, 'J': '', 'B': 20, 'N': '12.14'} if elt is None: # pas déjà trouvé
if el is None: # pas déjà trouvé self.etud_set_semestres_de_etape(apo_data)
cur_sem, autre_sem = self.etud_semestres_de_etape(apo_data)
for sem in apo_data.sems_etape: for sem in apo_data.sems_etape:
el = self.search_elt_in_sem(code, sem, cur_sem, autre_sem) elt = self.search_elt_in_sem(code, sem)
if el is not None: if elt is not None:
sco_elts[code] = el sco_elts[code] = elt
break break
self.col_elts[code] = el self.col_elts[code] = elt
if el is None: if elt is None:
self.new_cols[col_id] = self.cols[col_id] self.new_cols[col_id] = self.cols[col_id]
else: else:
try: try:
@ -373,7 +382,7 @@ class ApoEtud(dict):
# codes = set([apo_data.cols[col_id].code for col_id in apo_data.col_ids]) # codes = set([apo_data.cols[col_id].code for col_id in apo_data.col_ids])
# return codes - set(sco_elts) # return codes - set(sco_elts)
def search_elt_in_sem(self, code, sem, cur_sem, autre_sem) -> dict: def search_elt_in_sem(self, code, sem) -> dict:
""" """
VET code jury etape (en BUT, le code annuel) VET code jury etape (en BUT, le code annuel)
ELP élément pédagogique: UE, module ELP élément pédagogique: UE, module
@ -387,20 +396,29 @@ class ApoEtud(dict):
code (str): code apo de l'element cherché code (str): code apo de l'element cherché
sem (dict): semestre dans lequel on cherche l'élément sem (dict): semestre dans lequel on cherche l'élément
cur_sem (dict): semestre "courant" pour résultats annuels (VET) cur_sem (dict): semestre "courant" pour résultats annuels (VET)
autre_sem (dict): autre semestre utilisé pour calculé les résultats annuels (VET) autre_sem (dict): autre semestre utilisé pour calculer les résultats annuels (VET)
Returns: Returns:
dict: with N, B, J, R keys, ou None si elt non trouvé dict: with N, B, J, R keys, ou None si elt non trouvé
""" """
etudid = self.etud["etudid"] etudid = self.etud["etudid"]
formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"]) if not self.cur_res:
nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre) log("search_elt_in_sem: no cur_res !")
return None
if sem["formsemestre_id"] == self.cur_res.formsemestre.id:
res = self.cur_res
elif (
self.autre_res and sem["formsemestre_id"] == self.autre_res.formsemestre.id
):
res = self.autre_res
else:
formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"])
res: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
if etudid not in nt.identdict: if etudid not in res.identdict:
return None # etudiant non inscrit dans ce semestre return None # etudiant non inscrit dans ce semestre
decision = nt.get_etud_decision_sem(etudid) if not self.export_res_sdj and not res.etud_has_decision(etudid):
if not self.export_res_sdj and not decision:
# pas de decision de jury, on n'enregistre rien # pas de decision de jury, on n'enregistre rien
# (meme si démissionnaire) # (meme si démissionnaire)
if not self.has_logged_no_decision: if not self.has_logged_no_decision:
@ -408,43 +426,46 @@ class ApoEtud(dict):
self.has_logged_no_decision = True self.has_logged_no_decision = True
return VOID_APO_RES return VOID_APO_RES
if decision and decision["code"] == NAR: if res.is_apc: # export BUT
self.is_NAR = True self._but_load_validation_annuelle()
else:
decision = res.get_etud_decision_sem(etudid)
if decision and decision["code"] == NAR:
self.is_NAR = True
# Element semestre: (non BUT donc)
if code in {x.strip() for x in sem["elt_sem_apo"].split(",")}:
if self.export_res_sem:
return self.comp_elt_semestre(res, decision, etudid)
else:
return VOID_APO_RES
# Element etape (annuel ou non): # Element etape (annuel ou non):
if sco_formsemestre.sem_has_etape(sem, code) or ( if sco_formsemestre.sem_has_etape(sem, code) or (
code in {x.strip() for x in sem["elt_annee_apo"].split(",")} code in {x.strip() for x in sem["elt_annee_apo"].split(",")}
): ):
export_res_etape = self.export_res_etape export_res_etape = self.export_res_etape
if (not export_res_etape) and cur_sem: if (not export_res_etape) and self.cur_sem:
# exporte toujours le résultat de l'étape si l'étudiant est diplômé # exporte toujours le résultat de l'étape si l'étudiant est diplômé
Se = sco_cursus.get_situation_etud_cursus( Se = sco_cursus.get_situation_etud_cursus(
self.etud, cur_sem["formsemestre_id"] self.etud, self.cur_sem["formsemestre_id"]
) )
export_res_etape = Se.all_other_validated() export_res_etape = Se.all_other_validated()
if export_res_etape: if export_res_etape:
return self.comp_elt_annuel(etudid, cur_sem, autre_sem) return self.comp_elt_annuel(etudid)
else: else:
self.log.append("export étape désactivé") self.log.append("export étape désactivé")
return VOID_APO_RES return VOID_APO_RES
# Element semestre:
if code in {x.strip() for x in sem["elt_sem_apo"].split(",")}:
if self.export_res_sem:
return self.comp_elt_semestre(nt, decision, etudid)
else:
return VOID_APO_RES
# Elements UE # Elements UE
decisions_ue = nt.get_etud_decisions_ue(etudid) decisions_ue = res.get_etud_decisions_ue(etudid)
for ue in nt.get_ues_stat_dict(): for ue in res.get_ues_stat_dict():
if ue["code_apogee"] and code in { if ue["code_apogee"] and code in {
x.strip() for x in ue["code_apogee"].split(",") x.strip() for x in ue["code_apogee"].split(",")
}: }:
if self.export_res_ues: if self.export_res_ues:
if decisions_ue and ue["ue_id"] in decisions_ue: if decisions_ue and ue["ue_id"] in decisions_ue:
ue_status = nt.get_etud_ue_status(etudid, ue["ue_id"]) ue_status = res.get_etud_ue_status(etudid, ue["ue_id"])
code_decision_ue = decisions_ue[ue["ue_id"]]["code"] code_decision_ue = decisions_ue[ue["ue_id"]]["code"]
return dict( return dict(
N=self.fmt_note(ue_status["moy"] if ue_status else ""), N=self.fmt_note(ue_status["moy"] if ue_status else ""),
@ -459,14 +480,14 @@ class ApoEtud(dict):
return VOID_APO_RES return VOID_APO_RES
# Elements Modules # Elements Modules
modimpls = nt.get_modimpls_dict() modimpls = res.get_modimpls_dict()
module_code_found = False module_code_found = False
for modimpl in modimpls: for modimpl in modimpls:
module = modimpl["module"] module = modimpl["module"]
if module["code_apogee"] and code in { if module["code_apogee"] and code in {
x.strip() for x in module["code_apogee"].split(",") x.strip() for x in module["code_apogee"].split(",")
}: }:
n = nt.get_etud_mod_moy(modimpl["moduleimpl_id"], etudid) n = res.get_etud_mod_moy(modimpl["moduleimpl_id"], etudid)
if n != "NI" and self.export_res_modules: if n != "NI" and self.export_res_modules:
return dict(N=self.fmt_note(n), B=20, J="", R="") return dict(N=self.fmt_note(n), B=20, J="", R="")
else: else:
@ -480,8 +501,7 @@ class ApoEtud(dict):
"""Calcul résultat apo semestre. """Calcul résultat apo semestre.
Toujours vide pour en BUT/APC. Toujours vide pour en BUT/APC.
""" """
if self.is_apc: if self.is_apc: # garde fou: pas de code semestre en APC !
# pas de code semestre en APC !
return dict(N="", B=20, J="", R="", M="") return dict(N="", B=20, J="", R="", M="")
if decision is None: if decision is None:
etud = Identite.get_etud(etudid) etud = Identite.get_etud(etudid)
@ -498,7 +518,7 @@ class ApoEtud(dict):
note_str = self.fmt_note(note) note_str = self.fmt_note(note)
return dict(N=note_str, B=20, J="", R=decision_apo, M="") return dict(N=note_str, B=20, J="", R=decision_apo, M="")
def comp_elt_annuel(self, etudid, cur_sem, autre_sem): def comp_elt_annuel(self, etudid):
"""Calcul resultat annuel (VET) à partir du semestre courant """Calcul resultat annuel (VET) à partir du semestre courant
et de l'autre (le suivant ou le précédent complétant l'année scolaire) et de l'autre (le suivant ou le précédent complétant l'année scolaire)
En BUT, c'est la décision de jury annuelle (ApcValidationAnnee). En BUT, c'est la décision de jury annuelle (ApcValidationAnnee).
@ -516,18 +536,16 @@ class ApoEtud(dict):
# XXX cette règle est discutable, à valider # XXX cette règle est discutable, à valider
# log('comp_elt_annuel cur_sem=%s autre_sem=%s' % (cur_sem['formsemestre_id'], autre_sem['formsemestre_id'])) # log('comp_elt_annuel cur_sem=%s autre_sem=%s' % (cur_sem['formsemestre_id'], autre_sem['formsemestre_id']))
if not cur_sem: if not self.cur_sem:
# l'étudiant n'a pas de semestre courant ?! # l'étudiant n'a pas de semestre courant ?!
self.log.append("pas de semestre courant") self.log.append("pas de semestre courant")
log(f"comp_elt_annuel: etudid {etudid} has no cur_sem") log(f"comp_elt_annuel: etudid {etudid} has no cur_sem")
return VOID_APO_RES return VOID_APO_RES
cur_formsemestre = FormSemestre.query.get_or_404(cur_sem["formsemestre_id"])
cur_nt: NotesTableCompat = res_sem.load_formsemestre_results(cur_formsemestre)
if self.is_apc: if self.is_apc:
cur_decision = {} # comp_elt_semestre sera vide. cur_decision = {} # comp_elt_semestre sera vide.
else: else:
cur_decision = cur_nt.get_etud_decision_sem(etudid) cur_decision = self.cur_res.get_etud_decision_sem(etudid)
if not cur_decision: if not cur_decision:
# pas de decision => pas de résultat annuel # pas de decision => pas de résultat annuel
return VOID_APO_RES return VOID_APO_RES
@ -536,21 +554,17 @@ class ApoEtud(dict):
# ne touche pas aux RATs # ne touche pas aux RATs
return VOID_APO_RES return VOID_APO_RES
if not autre_sem: if not self.autre_sem:
# formations monosemestre, ou code VET semestriel, # formations monosemestre, ou code VET semestriel,
# ou jury intermediaire et etudiant non redoublant... # ou jury intermediaire et etudiant non redoublant...
return self.comp_elt_semestre(cur_nt, cur_decision, etudid) return self.comp_elt_semestre(self.cur_res, cur_decision, etudid)
autre_formsemestre = FormSemestre.query.get_or_404(autre_sem["formsemestre_id"])
autre_nt: NotesTableCompat = res_sem.load_formsemestre_results(
autre_formsemestre
)
# --- Traite le BUT à part: # --- Traite le BUT à part:
if self.is_apc: if self.is_apc:
return self.comp_elt_annuel_apc(cur_nt, autre_nt, etudid) return self.comp_elt_annuel_apc()
# --- Formations classiques # --- Formations classiques
decision_apo = ScoDocSiteConfig.get_code_apo(cur_decision["code"]) decision_apo = ScoDocSiteConfig.get_code_apo(cur_decision["code"])
autre_decision = autre_nt.get_etud_decision_sem(etudid) autre_decision = self.autre_res.get_etud_decision_sem(etudid)
if not autre_decision: if not autre_decision:
# pas de decision dans l'autre => pas de résultat annuel # pas de decision dans l'autre => pas de résultat annuel
return VOID_APO_RES return VOID_APO_RES
@ -566,8 +580,8 @@ class ApoEtud(dict):
): ):
note_str = "0,01" # note non nulle pour les démissionnaires note_str = "0,01" # note non nulle pour les démissionnaires
else: else:
note = cur_nt.get_etud_moy_gen(etudid) note = self.cur_res.get_etud_moy_gen(etudid)
autre_note = autre_nt.get_etud_moy_gen(etudid) autre_note = self.autre_res.get_etud_moy_gen(etudid)
# print 'note=%s autre_note=%s' % (note, autre_note) # print 'note=%s autre_note=%s' % (note, autre_note)
try: try:
moy_annuelle = (note + autre_note) / 2 moy_annuelle = (note + autre_note) / 2
@ -582,40 +596,46 @@ class ApoEtud(dict):
return dict(N=note_str, B=20, J="", R=decision_apo_annuelle, M="") return dict(N=note_str, B=20, J="", R=decision_apo_annuelle, M="")
def comp_elt_annuel_apc( def comp_elt_annuel_apc(self):
self,
cur_res: ResultatsSemestreBUT,
autre_res: ResultatsSemestreBUT,
etudid: int,
):
"""L'élément Apo pour un résultat annuel BUT. """L'élément Apo pour un résultat annuel BUT.
cur_res : les résultats du semestre sur lequel a été appelé l'export. self.cur_res == résultats du semestre sur lequel a été appelé l'export.
""" """
if not self.validation_annee_but:
# pas de décision ou pas de sem. impair
return VOID_APO_RES
return dict(
N="",
B=20,
J="",
R=ScoDocSiteConfig.get_code_apo(self.validation_annee_but.code),
M="",
)
def _but_load_validation_annuelle(self):
"charge la validation de jury BUT annuelle"
# le semestre impair de l'année scolaire # le semestre impair de l'année scolaire
if cur_res.formsemestre.semestre_id % 2: if self.cur_res.formsemestre.semestre_id % 2:
formsemestre = cur_res.formsemestre formsemestre = self.cur_res.formsemestre
elif ( elif (
autre_res self.autre_res
and autre_res.formsemestre.annee_scolaire() and self.autre_res.formsemestre.annee_scolaire()
== cur_res.formsemestre.annee_scolaire() == self.cur_res.formsemestre.annee_scolaire()
): ):
formsemestre = autre_res.formsemestre formsemestre = self.autre_res.formsemestre
assert formsemestre.semestre_id % 2 assert formsemestre.semestre_id % 2
else: else:
# ne trouve pas de semestre impair # ne trouve pas de semestre impair
return VOID_APO_RES self.validation_annee_but = None
return
validation: ApcValidationAnnee = ApcValidationAnnee.query.filter_by( self.validation_annee_but: ApcValidationAnnee = (
formsemestre_id=formsemestre.id, etudid=etudid ApcValidationAnnee.query.filter_by(
).first() formsemestre_id=formsemestre.id, etudid=self.etud["etudid"]
if validation is None: ).first()
return VOID_APO_RES
return dict(
N="", B=20, J="", R=ScoDocSiteConfig.get_code_apo(validation.code), M=""
) )
def etud_semestres_de_etape(self, apo_data): def etud_set_semestres_de_etape(self, apo_data):
""" """Set .cur_sem and .autre_sem et charge les résultats.
Lorsqu'on a une formation semestrialisée mais avec un code étape annuel, Lorsqu'on a une formation semestrialisée mais avec un code étape annuel,
il faut considérer les deux semestres ((S1,S2) ou (S3,S4)) pour calculer il faut considérer les deux semestres ((S1,S2) ou (S3,S4)) pour calculer
le code annuel (VET ou VRT1A (voir elt_annee_apo)). le code annuel (VET ou VRT1A (voir elt_annee_apo)).
@ -623,7 +643,7 @@ class ApoEtud(dict):
Pour les jurys intermediaires (janvier, S1 ou S3): (S2 ou S4) de la même Pour les jurys intermediaires (janvier, S1 ou S3): (S2 ou S4) de la même
étape lors d'une année précédente ? étape lors d'une année précédente ?
Renvoie le semestre "courant" et l'autre semestre, ou None s'il n'y en a pas. Set cur_sem: le semestre "courant" et autre_sem, ou None s'il n'y en a pas.
""" """
# Cherche le semestre "courant": # Cherche le semestre "courant":
cur_sems = [ cur_sems = [
@ -648,19 +668,29 @@ class ApoEtud(dict):
cur_sem = None cur_sem = None
for sem in cur_sems: for sem in cur_sems:
formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"]) formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"])
nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre) res: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
has_decision = nt.etud_has_decision(self.etud["etudid"]) has_decision = res.etud_has_decision(self.etud["etudid"])
if has_decision: if has_decision:
cur_sem = sem cur_sem = sem
self.cur_res = res
break break
if cur_sem is None: if cur_sem is None:
cur_sem = cur_sems[0] # aucun avec décision, prend le plus recent cur_sem = cur_sems[0] # aucun avec décision, prend le plus recent
if res.formsemestre.id == cur_sem["formsemestre_id"]:
self.cur_res = res
else:
formsemestre = FormSemestre.query.get_or_404(
cur_sem["formsemestre_id"]
)
self.cur_res = res_sem.load_formsemestre_results(formsemestre)
self.cur_sem = cur_sem
if apo_data.cur_semestre_id <= 0: if apo_data.cur_semestre_id <= 0:
return ( # "autre_sem" non pertinent pour sessions sans semestres:
cur_sem, self.autre_sem = None
None, self.autre_res = None
) # "autre_sem" non pertinent pour sessions sans semestres return
if apo_data.jury_intermediaire: # jury de janvier if apo_data.jury_intermediaire: # jury de janvier
# Le semestre suivant: exemple 2 si on est en jury de S1 # Le semestre suivant: exemple 2 si on est en jury de S1
@ -678,7 +708,7 @@ class ApoEtud(dict):
courant_annee_debut = apo_data.annee_scolaire + 1 courant_annee_debut = apo_data.annee_scolaire + 1
courant_mois_debut = 1 # ou 2 (fev-jul) courant_mois_debut = 1 # ou 2 (fev-jul)
else: else:
raise ValueError("invalid pediode value !") # bug ? raise ValueError("invalid periode value !") # bug ?
courant_date_debut = "%d-%02d-01" % ( courant_date_debut = "%d-%02d-01" % (
courant_annee_debut, courant_annee_debut,
courant_mois_debut, courant_mois_debut,
@ -709,15 +739,24 @@ class ApoEtud(dict):
autre_sem = None autre_sem = None
for sem in autres_sems: for sem in autres_sems:
formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"]) formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"])
nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre) res: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
decision = nt.get_etud_decision_sem(self.etud["etudid"]) if res.is_apc:
if decision: has_decision = res.etud_has_decision(self.etud["etudid"])
else:
has_decision = res.get_etud_decision_sem(self.etud["etudid"])
if has_decision:
autre_sem = sem autre_sem = sem
break break
if autre_sem is None: if autre_sem is None:
autre_sem = autres_sems[0] # aucun avec decision, prend le plus recent autre_sem = autres_sems[0] # aucun avec decision, prend le plus recent
return cur_sem, autre_sem self.autre_sem = autre_sem
# Charge les résultats:
if autre_sem:
formsemestre = FormSemestre.query.get_or_404(autre_sem["formsemestre_id"])
self.autre_res = res_sem.load_formsemestre_results(formsemestre)
else:
self.autre_res = None
class ApoData: class ApoData:
@ -911,8 +950,12 @@ class ApoData:
return elts # { code apo : ApoElt } return elts # { code apo : ApoElt }
def apo_read_etuds(self, f) -> list[ApoEtud]: def apo_read_etuds(self, f) -> list[ApoEtud]:
"""Lecture des etudiants (et resultats) du fichier CSV Apogée""" """Lecture des étudiants (et résultats) du fichier CSV Apogée.
L = [] Les lignes "étudiant" commencent toujours par
`12345678 NOM PRENOM 15/05/2003`
le premier code étant le NIP.
"""
apo_etuds = []
while True: while True:
line = f.readline() line = f.readline()
if not line: if not line:
@ -921,10 +964,15 @@ class ApoData:
continue # silently ignore blank lines continue # silently ignore blank lines
line = line.strip(APO_NEWLINE) line = line.strip(APO_NEWLINE)
fields = line.split(APO_SEP) fields = line.split(APO_SEP)
if len(fields) < 4:
raise ScoValueError(
"""Ligne étudiant invalide
(doit commencer par 'NIP NOM PRENOM dd/mm/yyyy')"""
)
cols = {} # { col_id : value } cols = {} # { col_id : value }
for i, field in enumerate(fields): for i, field in enumerate(fields):
cols[self.col_ids[i]] = field cols[self.col_ids[i]] = field
L.append( apo_etuds.append(
ApoEtud( ApoEtud(
nip=fields[0], # id etudiant nip=fields[0], # id etudiant
nom=fields[1], nom=fields[1],
@ -940,7 +988,7 @@ class ApoData:
) )
) )
return L return apo_etuds
def get_etape_apogee(self): def get_etape_apogee(self):
"""Le code etape: 'V1RT', donné par le code de l'élément VET""" """Le code etape: 'V1RT', donné par le code de l'élément VET"""

22
app/scodoc/sco_semset.py
View File

@ -87,12 +87,12 @@ class SemSet(dict):
self.formsemestre_ids = [] self.formsemestre_ids = []
cnx = ndb.GetDBConnexion() cnx = ndb.GetDBConnexion()
if semset_id: # read existing set if semset_id: # read existing set
L = semset_list(cnx, args={"semset_id": semset_id}) semsets = semset_list(cnx, args={"semset_id": semset_id})
if not L: if not semsets:
raise ScoValueError(f"Ensemble inexistant ! (semset {semset_id})") raise ScoValueError(f"Ensemble inexistant ! (semset {semset_id})")
self["title"] = L[0]["title"] self["title"] = semsets[0]["title"]
self["annee_scolaire"] = L[0]["annee_scolaire"] self["annee_scolaire"] = semsets[0]["annee_scolaire"]
self["sem_id"] = L[0]["sem_id"] self["sem_id"] = semsets[0]["sem_id"]
r = ndb.SimpleDictFetch( r = ndb.SimpleDictFetch(
"SELECT formsemestre_id FROM notes_semset_formsemestre WHERE semset_id = %(semset_id)s", "SELECT formsemestre_id FROM notes_semset_formsemestre WHERE semset_id = %(semset_id)s",
{"semset_id": semset_id}, {"semset_id": semset_id},
@ -307,7 +307,7 @@ class SemSet(dict):
if self["sem_id"] == 1: if self["sem_id"] == 1:
periode = "1re période (S1, S3)" periode = "1re période (S1, S3)"
elif self["sem_id"] == 1: elif self["sem_id"] == 2:
periode = "2de période (S2, S4)" periode = "2de période (S2, S4)"
else: else:
periode = "non semestrialisée (LP, ...). Incompatible avec BUT." periode = "non semestrialisée (LP, ...). Incompatible avec BUT."
@ -441,8 +441,14 @@ def do_semset_add_sem(semset_id, formsemestre_id):
if formsemestre_id == "": if formsemestre_id == "":
raise ScoValueError("pas de semestre choisi !") raise ScoValueError("pas de semestre choisi !")
semset = SemSet(semset_id=semset_id) semset = SemSet(semset_id=semset_id)
semset.add(formsemestre.id) semset.add(formsemestre_id)
return flask.redirect("apo_semset_maq_status?semset_id=%s" % semset_id) return flask.redirect(
url_for(
"notes.apo_semset_maq_status",
scodoc_dept=g.scodoc_dept,
semset_id=semset_id,
)
)
def do_semset_remove_sem(semset_id, formsemestre_id): def do_semset_remove_sem(semset_id, formsemestre_id):