jmplace/DocScoDoc
1
0
Fork 0
forked from ScoDoc/DocScoDoc
Code Issues Pull Requests Projects Releases Wiki Activity

refactoring (context)

Browse Source
This commit is contained in:
Emmanuel Viennet 2021-08-20 01:09:55 +02:00
parent ccbb021f50
commit 3a8474f12d
53 changed files with 424 additions and 542 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
app/scodoc/notes_table.py
View File

@ -107,17 +107,15 @@ def get_sem_ues_modimpls(context, formsemestre_id, modimpls=None):
(utilisé quand on ne peut pas construire nt et faire nt.get_ues())
"""
if modimpls is None:
modimpls = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=formsemestre_id
)
modimpls = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
uedict = {}
for modimpl in modimpls:
mod = sco_edit_module.do_module_list(
context, args={"module_id": modimpl["module_id"]}
)[0]
mod = sco_edit_module.do_module_list(args={"module_id": modimpl["module_id"]})[
0
]
modimpl["module"] = mod
if not mod["ue_id"] in uedict:
ue = sco_edit_ue.do_ue_list(context, args={"ue_id": mod["ue_id"]})[0]
ue = sco_edit_ue.do_ue_list(args={"ue_id": mod["ue_id"]})[0]
uedict[ue["ue_id"]] = ue
ues = list(uedict.values())
ues.sort(key=lambda u: u["numero"])
@ -231,14 +229,14 @@ class NotesTable(object):
for modimpl in self._modimpls:
mod = modimpl["module"] # has been added here by do_formsemestre_moyennes
if not mod["ue_id"] in uedict:
ue = sco_edit_ue.do_ue_list(context, args={"ue_id": mod["ue_id"]})[0]
ue = sco_edit_ue.do_ue_list(args={"ue_id": mod["ue_id"]})[0]
uedict[ue["ue_id"]] = ue
else:
ue = uedict[mod["ue_id"]]
modimpl["ue"] = ue # add ue dict to moduleimpl
self._matmoys[mod["matiere_id"]] = {}
mat = sco_edit_matiere.do_matiere_list(
context, args={"matiere_id": mod["matiere_id"]}
args={"matiere_id": mod["matiere_id"]}
)[0]
modimpl["mat"] = mat # add matiere dict to moduleimpl
# calcul moyennes du module et stocke dans le module

2
app/scodoc/sco_abs.py
View File

@ -1061,7 +1061,7 @@ def invalidate_abs_count_sem(sem):
"""Invalidate (clear) cached abs counts for all the students of this semestre"""
inscriptions = (
sco_formsemestre_inscriptions.do_formsemestre_inscription_listinscrits(
None, sem["formsemestre_id"]
sem["formsemestre_id"]
)
)
for ins in inscriptions:

6
app/scodoc/sco_abs_views.py
View File

@ -122,7 +122,7 @@ def doSignaleAbsence(
J = "NON "
M = ""
if moduleimpl_id and moduleimpl_id != "NULL":
mod = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
mod = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
formsemestre_id = mod["formsemestre_id"]
nt = sco_cache.NotesTableCache.get(formsemestre_id)
ues = nt.get_ues(etudid=etudid)
@ -967,7 +967,7 @@ def _TablesAbsEtud(
ex = []
for ev in a["evals"]:
mod = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=ev["moduleimpl_id"]
moduleimpl_id=ev["moduleimpl_id"]
)[0]
if format == "html":
ex.append(
@ -984,7 +984,7 @@ def _TablesAbsEtud(
ex = []
for ev in a.get("absent", []):
mod = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=ev["moduleimpl_id"]
moduleimpl_id=ev["moduleimpl_id"]
)[0]
if format == "html":
ex.append(

2
app/scodoc/sco_bulletins_json.py
View File

@ -372,7 +372,7 @@ def formsemestre_bulletinetud_published_dict(
"decisions_ue"
]: # and sco_preferences.get_preference( 'bul_show_uevalid', formsemestre_id): always publish (car utile pour export Apogee)
for ue_id in decision["decisions_ue"].keys():
ue = sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
ue = sco_edit_ue.do_ue_list({"ue_id": ue_id})[0]
d["decision_ue"].append(
dict(
ue_id=ue["ue_id"],

2
app/scodoc/sco_bulletins_xml.py
View File

@ -390,7 +390,7 @@ def make_xml_formsemestre_bulletinetud(
"decisions_ue"
]: # and sco_preferences.get_preference( 'bul_show_uevalid', formsemestre_id): always publish (car utile pour export Apogee)
for ue_id in decision["decisions_ue"].keys():
ue = sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
ue = sco_edit_ue.do_ue_list({"ue_id": ue_id})[0]
doc.append(
Element(
"decision_ue",

2
app/scodoc/sco_cache.py
View File

@ -264,7 +264,7 @@ def invalidate_formsemestre( # was inval_cache( context, formsemestre_id=None,
else:
formsemestre_ids = [
formsemestre_id
] + sco_parcours_dut.list_formsemestre_utilisateurs_uecap(None, formsemestre_id)
] + sco_parcours_dut.list_formsemestre_utilisateurs_uecap(formsemestre_id)
log(f"----- invalidate_formsemestre: clearing {formsemestre_ids} -----")
if not pdfonly:

16
app/scodoc/sco_compute_moy.py
View File

@ -79,9 +79,7 @@ def formsemestre_expressions_use_abscounts(context, formsemestre_id):
if expr and expr[0] != "#" and ab in expr:
return True
# 2- moyennes de modules
for mod in sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=formsemestre_id
):
for mod in sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id):
if moduleimpl_has_expression(context, mod) and ab in mod["computation_expr"]:
return True
return False
@ -203,7 +201,7 @@ def do_moduleimpl_moyennes(context, nt, mod):
is_malus = mod["module"]["module_type"] == scu.MODULE_MALUS
sem = sco_formsemestre.get_formsemestre(mod["formsemestre_id"])
etudids = sco_moduleimpl.do_moduleimpl_listeetuds(
context, moduleimpl_id
moduleimpl_id
) # tous, y compris demissions
# Inscrits au semestre (pour traiter les demissions):
inssem_set = set(
@ -379,9 +377,7 @@ def do_formsemestre_moyennes(context, nt, formsemestre_id):
# args={"formsemestre_id": formsemestre_id}
# )
# etudids = [x["etudid"] for x in inscr]
modimpls = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=formsemestre_id
)
modimpls = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
# recupere les moyennes des etudiants de tous les modules
D = {}
valid_evals = []
@ -389,9 +385,9 @@ def do_formsemestre_moyennes(context, nt, formsemestre_id):
mods_att = []
expr_diags = []
for modimpl in modimpls:
mod = sco_edit_module.do_module_list(
context, args={"module_id": modimpl["module_id"]}
)[0]
mod = sco_edit_module.do_module_list(args={"module_id": modimpl["module_id"]})[
0
]
modimpl["module"] = mod # add module dict to moduleimpl (used by nt)
moduleimpl_id = modimpl["moduleimpl_id"]
assert moduleimpl_id not in D

2
app/scodoc/sco_cost_formation.py
View File

@ -60,7 +60,7 @@ def formsemestre_table_estim_cost(
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
sco_formsemestre_status.fill_formsemestre(sem)
Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=formsemestre_id
formsemestre_id=formsemestre_id
)
T = []
for M in Mlist:

1
app/scodoc/sco_debouche.py
View File

@ -64,7 +64,6 @@ def report_debouche_date(context, start_year=None, format="html", REQUEST=None):
tab.caption = "Récapitulatif débouchés à partir du 1/1/%s." % start_year
tab.base_url = "%s?start_year=%s" % (REQUEST.URL0, start_year)
return tab.make_page(
context,
title="""<h2 class="formsemestre">Débouchés étudiants </h2>""",
init_qtip=True,
javascripts=["js/etud_info.js"],

44
app/scodoc/sco_edit_formation.py
View File

@ -47,7 +47,7 @@ from app.scodoc import sco_formsemestre
from app.scodoc import sco_news
def formation_delete(context, formation_id=None, dialog_confirmed=False, REQUEST=None):
def formation_delete(formation_id=None, dialog_confirmed=False, REQUEST=None):
"""Delete a formation"""
F = sco_formations.formation_list(args={"formation_id": formation_id})
if not F:
@ -84,7 +84,7 @@ def formation_delete(context, formation_id=None, dialog_confirmed=False, REQUEST
parameters={"formation_id": formation_id},
)
else:
do_formation_delete(context, F["formation_id"])
do_formation_delete(F["formation_id"])
H.append(
"""<p>OK, formation supprimée.</p>
<p><a class="stdlink" href="%s">continuer</a></p>"""
@ -95,18 +95,18 @@ def formation_delete(context, formation_id=None, dialog_confirmed=False, REQUEST
return "\n".join(H)
def do_formation_delete(context, oid):
def do_formation_delete(oid):
"""delete a formation (and all its UE, matieres, modules)
XXX delete all ues, will break if there are validations ! USE WITH CARE !
"""
F = sco_formations.formation_list(args={"formation_id": oid})[0]
if sco_formations.formation_has_locked_sems(context, oid):
if sco_formations.formation_has_locked_sems(oid):
raise ScoLockedFormError()
cnx = ndb.GetDBConnexion()
# delete all UE in this formation
ues = sco_edit_ue.do_ue_list(context, {"formation_id": oid})
ues = sco_edit_ue.do_ue_list({"formation_id": oid})
for ue in ues:
sco_edit_ue.do_ue_delete(context, ue["ue_id"], force=True)
sco_edit_ue.do_ue_delete(ue["ue_id"], force=True)
sco_formations._formationEditor.delete(cnx, oid)
@ -119,12 +119,12 @@ def do_formation_delete(context, oid):
)
def formation_create(context, REQUEST=None):
def formation_create(REQUEST=None):
"""Creation d'une formation"""
return formation_edit(context, create=True, REQUEST=REQUEST)
return formation_edit(create=True, REQUEST=REQUEST)
def formation_edit(context, formation_id=None, create=False, REQUEST=None):
def formation_edit(formation_id=None, create=False, REQUEST=None):
"""Edit or create a formation"""
if create:
H = [
@ -147,7 +147,7 @@ def formation_edit(context, formation_id=None, create=False, REQUEST=None):
if not F:
raise ScoValueError("formation inexistante !")
initvalues = F[0]
is_locked = sco_formations.formation_has_locked_sems(context, formation_id)
is_locked = sco_formations.formation_has_locked_sems(formation_id)
submitlabel = "Modifier les valeurs"
H = [
html_sco_header.sco_header(page_title="Modification d'une formation"),
@ -247,9 +247,9 @@ def formation_edit(context, formation_id=None, create=False, REQUEST=None):
)
#
if create:
formation_id = do_formation_create(context, tf[2])
formation_id = do_formation_create(tf[2])
else:
do_formation_edit(context, tf[2])
do_formation_edit(tf[2])
return flask.redirect(
url_for(
"notes.ue_list", scodoc_dept=g.scodoc_dept, formation_id=formation_id
@ -257,7 +257,7 @@ def formation_edit(context, formation_id=None, create=False, REQUEST=None):
)
def do_formation_create(context, args):
def do_formation_create(args):
"create a formation"
cnx = ndb.GetDBConnexion()
# check unique acronyme/titre/version
@ -282,14 +282,14 @@ def do_formation_create(context, args):
return r
def do_formation_edit(context, args):
def do_formation_edit(args):
"edit a formation"
# log('do_formation_edit( args=%s )'%args)
# On autorise la modif de la formation meme si elle est verrouillee
# car cela ne change que du cosmetique, (sauf eventuellement le code formation ?)
# mais si verrouillée on ne peut changer le type de parcours
if sco_formations.formation_has_locked_sems(context, args["formation_id"]):
if sco_formations.formation_has_locked_sems(args["formation_id"]):
if "type_parcours" in args:
del args["type_parcours"]
# On ne peut jamais supprimer le code formation:
@ -311,17 +311,15 @@ def invalidate_sems_in_formation(formation_id):
) # > formation modif.
def module_move(context, module_id, after=0, REQUEST=None, redirect=1):
def module_move(module_id, after=0, REQUEST=None, redirect=1):
"""Move before/after previous one (decrement/increment numero)"""
module = sco_edit_module.do_module_list(context, {"module_id": module_id})[0]
module = sco_edit_module.do_module_list({"module_id": module_id})[0]
redirect = int(redirect)
after = int(after) # 0: deplace avant, 1 deplace apres
if after not in (0, 1):
raise ValueError('invalid value for "after"')
formation_id = module["formation_id"]
others = sco_edit_module.do_module_list(
context, {"matiere_id": module["matiere_id"]}
)
others = sco_edit_module.do_module_list({"matiere_id": module["matiere_id"]})
# log('others=%s' % others)
if len(others) > 1:
idx = [p["module_id"] for p in others].index(module_id)
@ -350,16 +348,16 @@ def module_move(context, module_id, after=0, REQUEST=None, redirect=1):
)
def ue_move(context, ue_id, after=0, REQUEST=None, redirect=1):
def ue_move(ue_id, after=0, REQUEST=None, redirect=1):
"""Move UE before/after previous one (decrement/increment numero)"""
o = sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
o = sco_edit_ue.do_ue_list({"ue_id": ue_id})[0]
# log('ue_move %s (#%s) after=%s' % (ue_id, o['numero'], after))
redirect = int(redirect)
after = int(after) # 0: deplace avant, 1 deplace apres
if after not in (0, 1):
raise ValueError('invalid value for "after"')
formation_id = o["formation_id"]
others = sco_edit_ue.do_ue_list(context, {"formation_id": formation_id})
others = sco_edit_ue.do_ue_list({"formation_id": formation_id})
if len(others) > 1:
idx = [p["ue_id"] for p in others].index(ue_id)
neigh = None # object to swap with

60
app/scodoc/sco_edit_matiere.py
View File

@ -47,31 +47,29 @@ _matiereEditor = ndb.EditableTable(
)
def do_matiere_list(context, *args, **kw):
def do_matiere_list(*args, **kw):
"list matieres"
cnx = ndb.GetDBConnexion()
return _matiereEditor.list(cnx, *args, **kw)
def do_matiere_edit(context, *args, **kw):
def do_matiere_edit(*args, **kw):
"edit a matiere"
from app.scodoc import sco_edit_ue
from app.scodoc import sco_edit_formation
cnx = ndb.GetDBConnexion()
# check
mat = do_matiere_list(context, {"matiere_id": args[0]["matiere_id"]})[0]
if matiere_is_locked(context, mat["matiere_id"]):
mat = do_matiere_list({"matiere_id": args[0]["matiere_id"]})[0]
if matiere_is_locked(mat["matiere_id"]):
raise ScoLockedFormError()
# edit
_matiereEditor.edit(cnx, *args, **kw)
formation_id = sco_edit_ue.do_ue_list(None, {"ue_id": mat["ue_id"]})[0][
"formation_id"
]
formation_id = sco_edit_ue.do_ue_list({"ue_id": mat["ue_id"]})[0]["formation_id"]
sco_edit_formation.invalidate_sems_in_formation(formation_id)
def do_matiere_create(context, args):
def do_matiere_create(args):
"create a matiere"
from app.scodoc import sco_edit_ue
from app.scodoc import sco_formations
@ -79,7 +77,7 @@ def do_matiere_create(context, args):
cnx = ndb.GetDBConnexion()
# check
ue = sco_edit_ue.do_ue_list(context, {"ue_id": args["ue_id"]})[0]
ue = sco_edit_ue.do_ue_list({"ue_id": args["ue_id"]})[0]
# create matiere
r = _matiereEditor.create(cnx, args)
@ -94,11 +92,11 @@ def do_matiere_create(context, args):
return r
def matiere_create(context, ue_id=None, REQUEST=None):
def matiere_create(ue_id=None, REQUEST=None):
"""Creation d'une matiere"""
from app.scodoc import sco_edit_ue
UE = sco_edit_ue.do_ue_list(context, args={"ue_id": ue_id})[0]
UE = sco_edit_ue.do_ue_list(args={"ue_id": ue_id})[0]
H = [
html_sco_header.sco_header(page_title="Création d'une matière"),
"""<h2>Création d'une matière dans l'UE %(titre)s (%(acronyme)s)</h2>""" % UE,
@ -145,7 +143,7 @@ associé.
return flask.redirect(dest_url)
else:
# check unicity
mats = do_matiere_list(context, args={"ue_id": ue_id, "titre": tf[2]["titre"]})
mats = do_matiere_list(args={"ue_id": ue_id, "titre": tf[2]["titre"]})
if mats:
return (
"\n".join(H)
@ -153,11 +151,11 @@ associé.
+ tf[1]
+ html_sco_header.sco_footer()
)
_ = do_matiere_create(context, tf[2])
_ = do_matiere_create(tf[2])
return flask.redirect(dest_url)
def do_matiere_delete(context, oid):
def do_matiere_delete(oid):
"delete matiere and attached modules"
from app.scodoc import sco_formations
from app.scodoc import sco_edit_ue
@ -166,9 +164,9 @@ def do_matiere_delete(context, oid):
cnx = ndb.GetDBConnexion()
# check
mat = do_matiere_list(context, {"matiere_id": oid})[0]
ue = sco_edit_ue.do_ue_list(context, {"ue_id": mat["ue_id"]})[0]
locked = matiere_is_locked(context, mat["matiere_id"])
mat = do_matiere_list({"matiere_id": oid})[0]
ue = sco_edit_ue.do_ue_list({"ue_id": mat["ue_id"]})[0]
locked = matiere_is_locked(mat["matiere_id"])
if locked:
log("do_matiere_delete: mat=%s" % mat)
log("do_matiere_delete: ue=%s" % ue)
@ -176,9 +174,9 @@ def do_matiere_delete(context, oid):
raise ScoLockedFormError()
log("do_matiere_delete: matiere_id=%s" % oid)
# delete all modules in this matiere
mods = sco_edit_module.do_module_list(context, {"matiere_id": oid})
mods = sco_edit_module.do_module_list({"matiere_id": oid})
for mod in mods:
sco_edit_module.do_module_delete(context, mod["module_id"])
sco_edit_module.do_module_delete(mod["module_id"])
_matiereEditor.delete(cnx, oid)
# news
@ -191,12 +189,12 @@ def do_matiere_delete(context, oid):
)
def matiere_delete(context, matiere_id=None, REQUEST=None):
def matiere_delete(matiere_id=None, REQUEST=None):
"""Delete an UE"""
from app.scodoc import sco_edit_ue
M = do_matiere_list(context, args={"matiere_id": matiere_id})[0]
UE = sco_edit_ue.do_ue_list(context, args={"ue_id": M["ue_id"]})[0]
M = do_matiere_list(args={"matiere_id": matiere_id})[0]
UE = sco_edit_ue.do_ue_list(args={"ue_id": M["ue_id"]})[0]
H = [
html_sco_header.sco_header(page_title="Suppression d'une matière"),
"<h2>Suppression de la matière %(titre)s" % M,
@ -216,26 +214,26 @@ def matiere_delete(context, matiere_id=None, REQUEST=None):
elif tf[0] == -1:
return flask.redirect(dest_url)
else:
do_matiere_delete(context, matiere_id)
do_matiere_delete(matiere_id)
return flask.redirect(dest_url)
def matiere_edit(context, matiere_id=None, REQUEST=None):
def matiere_edit(matiere_id=None, REQUEST=None):
"""Edit matiere"""
from app.scodoc import sco_formations
from app.scodoc import sco_edit_ue
F = do_matiere_list(context, args={"matiere_id": matiere_id})
F = do_matiere_list(args={"matiere_id": matiere_id})
if not F:
raise ScoValueError("Matière inexistante !")
F = F[0]
U = sco_edit_ue.do_ue_list(context, args={"ue_id": F["ue_id"]})
U = sco_edit_ue.do_ue_list(args={"ue_id": F["ue_id"]})
if not F:
raise ScoValueError("UE inexistante !")
U = U[0]
Fo = sco_formations.formation_list(args={"formation_id": U["formation_id"]})[0]
ues = sco_edit_ue.do_ue_list(context, args={"formation_id": U["formation_id"]})
ues = sco_edit_ue.do_ue_list(args={"formation_id": U["formation_id"]})
ue_names = ["%(acronyme)s (%(titre)s)" % u for u in ues]
ue_ids = [u["ue_id"] for u in ues]
H = [
@ -288,9 +286,7 @@ associé.
return flask.redirect(dest_url)
else:
# check unicity
mats = do_matiere_list(
context, args={"ue_id": tf[2]["ue_id"], "titre": tf[2]["titre"]}
)
mats = do_matiere_list(args={"ue_id": tf[2]["ue_id"], "titre": tf[2]["titre"]})
if len(mats) > 1 or (len(mats) == 1 and mats[0]["matiere_id"] != matiere_id):
return (
"\n".join(H)
@ -307,12 +303,12 @@ associé.
{"ue_id": tf[2]["ue_id"], "matiere_id": matiere_id},
)
do_matiere_edit(context, tf[2])
do_matiere_edit(tf[2])
return flask.redirect(dest_url)
def matiere_is_locked(context, matiere_id):
def matiere_is_locked(matiere_id):
"""True if matiere should not be modified
(contains modules used in a locked formsemestre)
"""

87
app/scodoc/sco_edit_module.py
View File

@ -93,13 +93,13 @@ _moduleEditor = ndb.EditableTable(
)
def do_module_list(context, *args, **kw):
def do_module_list(*args, **kw):
"list modules"
cnx = ndb.GetDBConnexion()
return _moduleEditor.list(cnx, *args, **kw)
def do_module_create(context, args) -> int:
def do_module_create(args) -> int:
"create a module"
# create
from app.scodoc import sco_formations
@ -118,15 +118,15 @@ def do_module_create(context, args) -> int:
return r
def module_create(context, matiere_id=None, REQUEST=None):
def module_create(matiere_id=None, REQUEST=None):
"""Creation d'un module"""
from app.scodoc import sco_formations
from app.scodoc import sco_edit_ue
if matiere_id is None:
raise ScoValueError("invalid matiere !")
M = sco_edit_matiere.do_matiere_list(context, args={"matiere_id": matiere_id})[0]
UE = sco_edit_ue.do_ue_list(context, args={"ue_id": M["ue_id"]})[0]
M = sco_edit_matiere.do_matiere_list(args={"matiere_id": matiere_id})[0]
UE = sco_edit_ue.do_ue_list(args={"ue_id": M["ue_id"]})[0]
Fo = sco_formations.formation_list(args={"formation_id": UE["formation_id"]})[0]
parcours = sco_codes_parcours.get_parcours_from_code(Fo["type_parcours"])
semestres_indices = list(range(1, parcours.NB_SEM + 1))
@ -137,7 +137,7 @@ def module_create(context, matiere_id=None, REQUEST=None):
_MODULE_HELP,
]
# cherche le numero adequat (pour placer le module en fin de liste)
Mods = do_module_list(context, args={"matiere_id": matiere_id})
Mods = do_module_list(args={"matiere_id": matiere_id})
if Mods:
default_num = max([m["numero"] for m in Mods]) + 10
else:
@ -154,7 +154,7 @@ def module_create(context, matiere_id=None, REQUEST=None):
"allow_null": False,
"validator": lambda val, field, formation_id=Fo[
"formation_id"
]: check_module_code_unicity(val, field, formation_id, context),
]: check_module_code_unicity(val, field, formation_id),
},
),
("titre", {"size": 30, "explanation": "nom du module"}),
@ -237,7 +237,7 @@ def module_create(context, matiere_id=None, REQUEST=None):
if tf[0] == 0:
return "\n".join(H) + tf[1] + html_sco_header.sco_footer()
else:
do_module_create(context, tf[2])
do_module_create(tf[2])
return flask.redirect(
url_for(
"notes.ue_list",
@ -247,16 +247,16 @@ def module_create(context, matiere_id=None, REQUEST=None):
)
def do_module_delete(context, oid):
def do_module_delete(oid):
"delete module"
from app.scodoc import sco_formations
mod = do_module_list(context, {"module_id": oid})[0]
if module_is_locked(context, mod["module_id"]):
mod = do_module_list({"module_id": oid})[0]
if module_is_locked(mod["module_id"]):
raise ScoLockedFormError()
# S'il y a des moduleimpls, on ne peut pas detruire le module !
mods = sco_moduleimpl.do_moduleimpl_list(context, module_id=oid)
mods = sco_moduleimpl.do_moduleimpl_list(module_id=oid)
if mods:
err_page = scu.confirm_dialog(
message="""<h3>Destruction du module impossible car il est utilisé dans des semestres existants !</h3>""",
@ -279,11 +279,11 @@ def do_module_delete(context, oid):
)
def module_delete(context, module_id=None, REQUEST=None):
def module_delete(module_id=None, REQUEST=None):
"""Delete a module"""
if not module_id:
raise ScoValueError("invalid module !")
Mods = do_module_list(context, args={"module_id": module_id})
Mods = do_module_list(args={"module_id": module_id})
if not Mods:
raise ScoValueError("Module inexistant !")
Mod = Mods[0]
@ -306,17 +306,17 @@ def module_delete(context, module_id=None, REQUEST=None):
elif tf[0] == -1:
return flask.redirect(dest_url)
else:
do_module_delete(context, module_id)
do_module_delete(module_id)
return flask.redirect(dest_url)
def do_module_edit(context, val):
def do_module_edit(val):
"edit a module"
from app.scodoc import sco_edit_formation
# check
mod = do_module_list(context, {"module_id": val["module_id"]})[0]
if module_is_locked(context, mod["module_id"]):
mod = do_module_list({"module_id": val["module_id"]})[0]
if module_is_locked(mod["module_id"]):
# formation verrouillée: empeche de modifier certains champs:
protected_fields = ("coefficient", "ue_id", "matiere_id", "semestre_id")
for f in protected_fields:
@ -328,27 +328,27 @@ def do_module_edit(context, val):
sco_edit_formation.invalidate_sems_in_formation(mod["formation_id"])
def check_module_code_unicity(code, field, formation_id, context, module_id=None):
def check_module_code_unicity(code, field, formation_id, module_id=None):
"true si code module unique dans la formation"
Mods = do_module_list(context, args={"code": code, "formation_id": formation_id})
Mods = do_module_list(args={"code": code, "formation_id": formation_id})
if module_id: # edition: supprime le module en cours
Mods = [m for m in Mods if m["module_id"] != module_id]
return len(Mods) == 0
def module_edit(context, module_id=None, REQUEST=None):
def module_edit(module_id=None, REQUEST=None):
"""Edit a module"""
from app.scodoc import sco_formations
from app.scodoc import sco_tag_module
if not module_id:
raise ScoValueError("invalid module !")
Mod = do_module_list(context, args={"module_id": module_id})
Mod = do_module_list(args={"module_id": module_id})
if not Mod:
raise ScoValueError("invalid module !")
Mod = Mod[0]
unlocked = not module_is_locked(context, module_id)
unlocked = not module_is_locked(module_id)
Fo = sco_formations.formation_list(args={"formation_id": Mod["formation_id"]})[0]
parcours = sco_codes_parcours.get_parcours_from_code(Fo["type_parcours"])
M = ndb.SimpleDictFetch(
@ -400,7 +400,7 @@ def module_edit(context, module_id=None, REQUEST=None):
"validator": lambda val, field, formation_id=Mod[
"formation_id"
]: check_module_code_unicity(
val, field, formation_id, context, module_id=module_id
val, field, formation_id, module_id=module_id
),
},
),
@ -493,7 +493,7 @@ def module_edit(context, module_id=None, REQUEST=None):
),
),
html_foot_markup="""<div style="width: 90%;"><span class="sco_tag_edit"><textarea data-module_id="{}" class="module_tag_editor">{}</textarea></span></div>""".format(
module_id, ",".join(sco_tag_module.module_tag_list(context, module_id))
module_id, ",".join(sco_tag_module.module_tag_list(module_id))
),
initvalues=Mod,
submitlabel="Modifier ce module",
@ -508,28 +508,28 @@ def module_edit(context, module_id=None, REQUEST=None):
tf[2]["ue_id"], tf[2]["matiere_id"] = tf[2]["ue_matiere_id"].split("!")
# Check unicité code module dans la formation
do_module_edit(context, tf[2])
do_module_edit(tf[2])
return flask.redirect(dest_url)
# Edition en ligne du code Apogee
def edit_module_set_code_apogee(context, id=None, value=None, REQUEST=None):
def edit_module_set_code_apogee(id=None, value=None, REQUEST=None):
"Set UE code apogee"
module_id = id
value = value.strip("-_ \t")
log("edit_module_set_code_apogee: module_id=%s code_apogee=%s" % (module_id, value))
modules = do_module_list(context, args={"module_id": module_id})
modules = do_module_list(args={"module_id": module_id})
if not modules:
return "module invalide" # should not occur
do_module_edit(context, {"module_id": module_id, "code_apogee": value})
do_module_edit({"module_id": module_id, "code_apogee": value})
if not value:
value = scu.APO_MISSING_CODE_STR
return value
def module_list(context, formation_id, REQUEST=None):
def module_list(formation_id, REQUEST=None):
"""Liste des modules de la formation
(XXX inutile ou a revoir)
"""
@ -546,7 +546,7 @@ def module_list(context, formation_id, REQUEST=None):
]
editable = REQUEST.AUTHENTICATED_USER.has_permission(Permission.ScoChangeFormation)
for Mod in do_module_list(context, args={"formation_id": formation_id}):
for Mod in do_module_list(args={"formation_id": formation_id}):
H.append('<li class="notes_module_list">%s' % Mod)
if editable:
H.append('<a href="module_edit?module_id=%(module_id)s">modifier</a>' % Mod)
@ -559,7 +559,7 @@ def module_list(context, formation_id, REQUEST=None):
return "\n".join(H)
def module_is_locked(context, module_id):
def module_is_locked(module_id):
"""True if module should not be modified
(used in a locked formsemestre)
"""
@ -576,39 +576,39 @@ def module_is_locked(context, module_id):
return len(r) > 0
def module_count_moduleimpls(context, module_id):
def module_count_moduleimpls(module_id):
"Number of moduleimpls using this module"
mods = sco_moduleimpl.do_moduleimpl_list(context, module_id=module_id)
mods = sco_moduleimpl.do_moduleimpl_list(module_id=module_id)
return len(mods)
def formation_add_malus_modules(context, formation_id, titre=None, REQUEST=None):
def formation_add_malus_modules(formation_id, titre=None, REQUEST=None):
"""Création d'un module de "malus" dans chaque UE d'une formation"""
from app.scodoc import sco_edit_ue
ue_list = sco_edit_ue.do_ue_list(context, args={"formation_id": formation_id})
ue_list = sco_edit_ue.do_ue_list(args={"formation_id": formation_id})
for ue in ue_list:
# Un seul module de malus par UE:
nb_mod_malus = len(
[
mod
for mod in do_module_list(context, args={"ue_id": ue["ue_id"]})
for mod in do_module_list(args={"ue_id": ue["ue_id"]})
if mod["module_type"] == scu.MODULE_MALUS
]
)
if nb_mod_malus == 0:
ue_add_malus_module(context, ue["ue_id"], titre=titre, REQUEST=REQUEST)
ue_add_malus_module(ue["ue_id"], titre=titre, REQUEST=REQUEST)
if REQUEST:
return flask.redirect("ue_list?formation_id=" + str(formation_id))
def ue_add_malus_module(context, ue_id, titre=None, code=None, REQUEST=None):
def ue_add_malus_module(ue_id, titre=None, code=None, REQUEST=None):
"""Add a malus module in this ue"""
from app.scodoc import sco_edit_ue
ue = sco_edit_ue.do_ue_list(context, args={"ue_id": ue_id})[0]
ue = sco_edit_ue.do_ue_list(args={"ue_id": ue_id})[0]
if titre is None:
titre = ""
@ -616,7 +616,7 @@ def ue_add_malus_module(context, ue_id, titre=None, code=None, REQUEST=None):
code = "MALUS%d" % ue["numero"]
# Tout module doit avoir un semestre_id (indice 1, 2, ...)
semestre_ids = sco_edit_ue.ue_list_semestre_ids(context, ue)
semestre_ids = sco_edit_ue.ue_list_semestre_ids(ue)
if semestre_ids:
semestre_id = semestre_ids[0]
else:
@ -627,14 +627,13 @@ def ue_add_malus_module(context, ue_id, titre=None, code=None, REQUEST=None):
)
# Matiere pour placer le module malus
Matlist = sco_edit_matiere.do_matiere_list(context, args={"ue_id": ue_id})
Matlist = sco_edit_matiere.do_matiere_list(args={"ue_id": ue_id})
numero = max([mat["numero"] for mat in Matlist]) + 10
matiere_id = sco_edit_matiere.do_matiere_create(
context, {"ue_id": ue_id, "titre": "Malus", "numero": numero}
{"ue_id": ue_id, "titre": "Malus", "numero": numero}
)
module_id = do_module_create(
context,
{
"titre": titre,
"code": code,

113
app/scodoc/sco_edit_ue.py
View File

@ -84,20 +84,20 @@ _ueEditor = ndb.EditableTable(
)
def do_ue_list(context, *args, **kw):
def do_ue_list(*args, **kw):
"list UEs"
cnx = ndb.GetDBConnexion()
return _ueEditor.list(cnx, *args, **kw)
def do_ue_create(context, args):
def do_ue_create(args):
"create an ue"
from app.scodoc import sco_formations
cnx = ndb.GetDBConnexion()
# check duplicates
ues = do_ue_list(
context, {"formation_id": args["formation_id"], "acronyme": args["acronyme"]}
{"formation_id": args["formation_id"], "acronyme": args["acronyme"]}
)
if ues:
raise ScoValueError('Acronyme d\'UE "%s" déjà utilisé !' % args["acronyme"])
@ -115,7 +115,7 @@ def do_ue_create(context, args):
return r
def do_ue_delete(context, ue_id, delete_validations=False, REQUEST=None, force=False):
def do_ue_delete(ue_id, delete_validations=False, REQUEST=None, force=False):
"delete UE and attached matieres (but not modules)"
from app.scodoc import sco_formations
from app.scodoc import sco_parcours_dut
@ -123,11 +123,11 @@ def do_ue_delete(context, ue_id, delete_validations=False, REQUEST=None, force=F
cnx = ndb.GetDBConnexion()
log("do_ue_delete: ue_id=%s, delete_validations=%s" % (ue_id, delete_validations))
# check
ue = do_ue_list(context, {"ue_id": ue_id})
ue = do_ue_list({"ue_id": ue_id})
if not ue:
raise ScoValueError("UE inexistante !")
ue = ue[0]
if ue_is_locked(context, ue["ue_id"]):
if ue_is_locked(ue["ue_id"]):
raise ScoLockedFormError()
# Il y a-t-il des etudiants ayant validé cette UE ?
# si oui, propose de supprimer les validations
@ -151,9 +151,9 @@ def do_ue_delete(context, ue_id, delete_validations=False, REQUEST=None, force=F
)
# delete all matiere in this UE
mats = sco_edit_matiere.do_matiere_list(context, {"ue_id": ue_id})
mats = sco_edit_matiere.do_matiere_list({"ue_id": ue_id})
for mat in mats:
sco_edit_matiere.do_matiere_delete(context, mat["matiere_id"])
sco_edit_matiere.do_matiere_delete(mat["matiere_id"])
# delete uecoef and events
ndb.SimpleQuery(
"DELETE FROM notes_formsemestre_uecoef WHERE ue_id=%(ue_id)s",
@ -185,18 +185,18 @@ def do_ue_delete(context, ue_id, delete_validations=False, REQUEST=None, force=F
return None
def ue_create(context, formation_id=None, REQUEST=None):
def ue_create(formation_id=None, REQUEST=None):
"""Creation d'une UE"""
return ue_edit(context, create=True, formation_id=formation_id, REQUEST=REQUEST)
return ue_edit(create=True, formation_id=formation_id, REQUEST=REQUEST)
def ue_edit(context, ue_id=None, create=False, formation_id=None, REQUEST=None):
def ue_edit(ue_id=None, create=False, formation_id=None, REQUEST=None):
"""Modification ou creation d'une UE"""
from app.scodoc import sco_formations
create = int(create)
if not create:
U = do_ue_list(context, args={"ue_id": ue_id})
U = do_ue_list(args={"ue_id": ue_id})
if not U:
raise ScoValueError("UE inexistante !")
U = U[0]
@ -341,19 +341,17 @@ def ue_edit(context, ue_id=None, create=False, formation_id=None, REQUEST=None):
tf[2]["semestre_id"] = 0
# numero regroupant par semestre ou année:
tf[2]["numero"] = next_ue_numero(
context, formation_id, int(tf[2]["semestre_id"] or 0)
formation_id, int(tf[2]["semestre_id"] or 0)
)
ue_id = do_ue_create(context, tf[2])
ue_id = do_ue_create(tf[2])
if parcours.UE_IS_MODULE or tf[2]["create_matiere"]:
matiere_id = sco_edit_matiere.do_matiere_create(
context,
{"ue_id": ue_id, "titre": tf[2]["titre"], "numero": 1},
)
if parcours.UE_IS_MODULE:
# dans ce mode, crée un (unique) module dans l'UE:
_ = sco_edit_module.do_module_create(
context,
{
"titre": tf[2]["titre"],
"code": tf[2]["acronyme"],
@ -365,7 +363,7 @@ def ue_edit(context, ue_id=None, create=False, formation_id=None, REQUEST=None):
},
)
else:
do_ue_edit(context, tf[2])
do_ue_edit(tf[2])
return flask.redirect(
url_for(
"notes.ue_list", scodoc_dept=g.scodoc_dept, formation_id=formation_id
@ -373,31 +371,31 @@ def ue_edit(context, ue_id=None, create=False, formation_id=None, REQUEST=None):
)
def _add_ue_semestre_id(context, ue_list):
def _add_ue_semestre_id(ue_list):
"""ajoute semestre_id dans les ue, en regardant le premier module de chacune.
Les UE sans modules se voient attribuer le numero UE_SEM_DEFAULT (1000000),
qui les place à la fin de la liste.
"""
for ue in ue_list:
Modlist = sco_edit_module.do_module_list(context, args={"ue_id": ue["ue_id"]})
Modlist = sco_edit_module.do_module_list(args={"ue_id": ue["ue_id"]})
if Modlist:
ue["semestre_id"] = Modlist[0]["semestre_id"]
else:
ue["semestre_id"] = 1000000
def next_ue_numero(context, formation_id, semestre_id=None):
def next_ue_numero(formation_id, semestre_id=None):
"""Numero d'une nouvelle UE dans cette formation.
Si le semestre est specifie, cherche les UE ayant des modules de ce semestre
"""
ue_list = do_ue_list(context, args={"formation_id": formation_id})
ue_list = do_ue_list(args={"formation_id": formation_id})
if not ue_list:
return 0
if semestre_id is None:
return ue_list[-1]["numero"] + 1000
else:
# Avec semestre: (prend le semestre du 1er module de l'UE)
_add_ue_semestre_id(context, ue_list)
_add_ue_semestre_id(ue_list)
ue_list_semestre = [ue for ue in ue_list if ue["semestre_id"] == semestre_id]
if ue_list_semestre:
return ue_list_semestre[-1]["numero"] + 10
@ -406,10 +404,10 @@ def next_ue_numero(context, formation_id, semestre_id=None):
def ue_delete(
context, ue_id=None, delete_validations=False, dialog_confirmed=False, REQUEST=None
ue_id=None, delete_validations=False, dialog_confirmed=False, REQUEST=None
):
"""Delete an UE"""
ue = do_ue_list(context, args={"ue_id": ue_id})
ue = do_ue_list(args={"ue_id": ue_id})
if not ue:
raise ScoValueError("UE inexistante !")
ue = ue[0]
@ -422,12 +420,10 @@ def ue_delete(
cancel_url="ue_list?formation_id=%s" % ue["formation_id"],
)
return do_ue_delete(
context, ue_id, delete_validations=delete_validations, REQUEST=REQUEST
)
return do_ue_delete(ue_id, delete_validations=delete_validations, REQUEST=REQUEST)
def ue_list(context, formation_id=None, msg="", REQUEST=None):
def ue_list(formation_id=None, msg="", REQUEST=None):
"""Liste des matières et modules d'une formation, avec liens pour
editer (si non verrouillée).
"""
@ -439,11 +435,11 @@ def ue_list(context, formation_id=None, msg="", REQUEST=None):
raise ScoValueError("invalid formation_id")
F = F[0]
parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"])
locked = sco_formations.formation_has_locked_sems(context, formation_id)
locked = sco_formations.formation_has_locked_sems(formation_id)
ue_list = do_ue_list(context, args={"formation_id": formation_id})
ue_list = do_ue_list(args={"formation_id": formation_id})
# tri par semestre et numero:
_add_ue_semestre_id(context, ue_list)
_add_ue_semestre_id(ue_list)
ue_list.sort(key=lambda u: (u["semestre_id"], u["numero"]))
has_duplicate_ue_codes = len(set([ue["ue_code"] for ue in ue_list])) != len(ue_list)
@ -612,7 +608,7 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
'<span class="ue_type">%s</span>'
% sco_codes_parcours.UE_TYPE_NAME[UE["type"]]
)
ue_editable = editable and not ue_is_locked(context, UE["ue_id"])
ue_editable = editable and not ue_is_locked(UE["ue_id"])
if ue_editable:
H.append(
'<a class="stdlink" href="ue_edit?ue_id=%(ue_id)s">modifier</a>' % UE
@ -621,12 +617,12 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
H.append('<span class="locked">[verrouillé]</span>')
if not parcours.UE_IS_MODULE:
H.append('<ul class="notes_matiere_list">')
Matlist = sco_edit_matiere.do_matiere_list(context, args={"ue_id": UE["ue_id"]})
Matlist = sco_edit_matiere.do_matiere_list(args={"ue_id": UE["ue_id"]})
for Mat in Matlist:
if not parcours.UE_IS_MODULE:
H.append('<li class="notes_matiere_list">')
if editable and not sco_edit_matiere.matiere_is_locked(
context, Mat["matiere_id"]
Mat["matiere_id"]
):
H.append(
f"""<a class="stdlink" href="{
@ -637,18 +633,18 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
)
H.append("%(titre)s" % Mat)
if editable and not sco_edit_matiere.matiere_is_locked(
context, Mat["matiere_id"]
Mat["matiere_id"]
):
H.append("</a>")
H.append('<ul class="notes_module_list">')
Modlist = sco_edit_module.do_module_list(
context, args={"matiere_id": Mat["matiere_id"]}
args={"matiere_id": Mat["matiere_id"]}
)
im = 0
for Mod in Modlist:
Mod["nb_moduleimpls"] = sco_edit_module.module_count_moduleimpls(
context, Mod["module_id"]
Mod["module_id"]
)
klass = "notes_module_list"
if Mod["module_type"] == scu.MODULE_MALUS:
@ -680,7 +676,7 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
H.append(delete_disabled_icon)
H.append("</span>")
mod_editable = editable # and not sco_edit_module.module_is_locked(context, Mod['module_id'])
mod_editable = editable # and not sco_edit_module.module_is_locked( Mod['module_id'])
if mod_editable:
H.append(
'<a class="discretelink" title="Modifier le module numéro %(numero)s, utilisé par %(nb_moduleimpls)d sessions" href="module_edit?module_id=%(module_id)s">'
@ -714,7 +710,7 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
tag_edit = tag_mk.format(
Mod["module_id"],
tag_cls,
",".join(sco_tag_module.module_tag_list(context, Mod["module_id"])),
",".join(sco_tag_module.module_tag_list(Mod["module_id"])),
)
H.append(
" %s %s" % (parcours.SESSION_NAME, Mod["semestre_id"])
@ -825,14 +821,14 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
)
# <li>(debug) <a class="stdlink" href="check_form_integrity?formation_id=%(formation_id)s">Vérifier cohérence</a></li>
warn, _ = sco_formsemestre_validation.check_formation_ues(context, formation_id)
warn, _ = sco_formsemestre_validation.check_formation_ues(formation_id)
H.append(warn)
H.append(html_sco_header.sco_footer())
return "".join(H)
def ue_sharing_code(context, ue_code=None, ue_id=None, hide_ue_id=None):
def ue_sharing_code(ue_code=None, ue_id=None, hide_ue_id=None):
"""HTML list of UE sharing this code
Either ue_code or ue_id may be specified.
hide_ue_id spécifie un id à retirer de la liste.
@ -840,13 +836,13 @@ def ue_sharing_code(context, ue_code=None, ue_id=None, hide_ue_id=None):
from app.scodoc import sco_formations
if ue_id:
ue = do_ue_list(context, args={"ue_id": ue_id})[0]
ue = do_ue_list(args={"ue_id": ue_id})[0]
if not ue_code:
ue_code = ue["ue_code"]
F = sco_formations.formation_list(args={"formation_id": ue["formation_id"]})[0]
formation_code = F["formation_code"]
ue_list_all = do_ue_list(context, args={"ue_code": ue_code})
ue_list_all = do_ue_list(args={"ue_code": ue_code})
if ue_id:
# retire les UE d'autres formations:
# log('checking ucode %s formation %s' % (ue_code, formation_code))
@ -891,19 +887,17 @@ def ue_sharing_code(context, ue_code=None, ue_id=None, hide_ue_id=None):
return "\n".join(H)
def do_ue_edit(context, args, bypass_lock=False, dont_invalidate_cache=False):
def do_ue_edit(args, bypass_lock=False, dont_invalidate_cache=False):
"edit an UE"
# check
ue_id = args["ue_id"]
ue = do_ue_list(context, {"ue_id": ue_id})[0]
if (not bypass_lock) and ue_is_locked(context, ue["ue_id"]):
ue = do_ue_list({"ue_id": ue_id})[0]
if (not bypass_lock) and ue_is_locked(ue["ue_id"]):
raise ScoLockedFormError()
# check: acronyme unique dans cette formation
if "acronyme" in args:
new_acro = args["acronyme"]
ues = do_ue_list(
context, {"formation_id": ue["formation_id"], "acronyme": new_acro}
)
ues = do_ue_list({"formation_id": ue["formation_id"], "acronyme": new_acro})
if ues and ues[0]["ue_id"] != ue_id:
raise ScoValueError('Acronyme d\'UE "%s" déjà utilisé !' % args["acronyme"])
@ -920,18 +914,17 @@ def do_ue_edit(context, args, bypass_lock=False, dont_invalidate_cache=False):
# essai edition en ligne:
def edit_ue_set_code_apogee(context, id=None, value=None, REQUEST=None):
def edit_ue_set_code_apogee(id=None, value=None, REQUEST=None):
"set UE code apogee"
ue_id = id
value = value.strip("-_ \t")
log("edit_ue_set_code_apogee: ue_id=%s code_apogee=%s" % (ue_id, value))
ues = do_ue_list(context, args={"ue_id": ue_id})
ues = do_ue_list(args={"ue_id": ue_id})
if not ues:
return "ue invalide"
do_ue_edit(
context,
{"ue_id": ue_id, "code_apogee": value},
bypass_lock=True,
dont_invalidate_cache=False,
@ -941,7 +934,7 @@ def edit_ue_set_code_apogee(context, id=None, value=None, REQUEST=None):
return value
def ue_is_locked(context, ue_id):
def ue_is_locked(ue_id):
"""True if UE should not be modified
(contains modules used in a locked formsemestre)
"""
@ -958,7 +951,7 @@ def ue_is_locked(context, ue_id):
# ---- Table recap formation
def formation_table_recap(context, formation_id, format="html", REQUEST=None):
def formation_table_recap(formation_id, format="html", REQUEST=None):
"""Table recapitulant formation."""
from app.scodoc import sco_formations
@ -967,16 +960,16 @@ def formation_table_recap(context, formation_id, format="html", REQUEST=None):
raise ScoValueError("invalid formation_id")
F = F[0]
T = []
ue_list = do_ue_list(context, args={"formation_id": formation_id})
ue_list = do_ue_list(args={"formation_id": formation_id})
for UE in ue_list:
Matlist = sco_edit_matiere.do_matiere_list(context, args={"ue_id": UE["ue_id"]})
Matlist = sco_edit_matiere.do_matiere_list(args={"ue_id": UE["ue_id"]})
for Mat in Matlist:
Modlist = sco_edit_module.do_module_list(
context, args={"matiere_id": Mat["matiere_id"]}
args={"matiere_id": Mat["matiere_id"]}
)
for Mod in Modlist:
Mod["nb_moduleimpls"] = sco_edit_module.module_count_moduleimpls(
context, Mod["module_id"]
Mod["module_id"]
)
#
T.append(
@ -1044,11 +1037,11 @@ def formation_table_recap(context, formation_id, format="html", REQUEST=None):
return tab.make_page(format=format, REQUEST=REQUEST)
def ue_list_semestre_ids(context, ue):
def ue_list_semestre_ids(ue):
"""Liste triée des numeros de semestres des modules dans cette UE
Il est recommandable que tous les modules d'une UE aient le même indice de semestre.
Mais cela n'a pas toujours été le cas dans les programmes pédagogiques officiels,
aussi ScoDoc laisse le choix.
"""
Modlist = sco_edit_module.do_module_list(context, args={"ue_id": ue["ue_id"]})
Modlist = sco_edit_module.do_module_list(args={"ue_id": ue["ue_id"]})
return sorted(list(set([mod["semestre_id"] for mod in Modlist])))

46
app/scodoc/sco_evaluations.py
View File

@ -179,7 +179,7 @@ def do_evaluation_list(args, sortkey=None):
def do_evaluation_list_in_formsemestre(formsemestre_id):
"list evaluations in this formsemestre"
context = None # #context
mods = sco_moduleimpl.do_moduleimpl_list(context, formsemestre_id=formsemestre_id)
mods = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
evals = []
for mod in mods:
evals += do_evaluation_list(args={"moduleimpl_id": mod["moduleimpl_id"]})
@ -214,7 +214,7 @@ def _check_evaluation_args(args):
jour = args.get("jour", None)
args["jour"] = jour
if jour:
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
d, m, y = [int(x) for x in sem["date_debut"].split("/")]
date_debut = datetime.date(y, m, d)
@ -304,8 +304,8 @@ def do_evaluation_create(
r = _evaluationEditor.create(cnx, args)
# news
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
mod["moduleimpl_id"] = M["moduleimpl_id"]
mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
sco_news.add(
@ -336,7 +336,7 @@ def do_evaluation_edit(args):
cnx = ndb.GetDBConnexion()
_evaluationEditor.edit(cnx, args)
# inval cache pour ce semestre
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
sco_cache.invalidate_formsemestre(formsemestre_id=M["formsemestre_id"])
@ -362,10 +362,10 @@ def do_evaluation_delete(evaluation_id):
_evaluationEditor.delete(cnx, evaluation_id)
# inval cache pour ce semestre
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
sco_cache.invalidate_formsemestre(formsemestre_id=M["formsemestre_id"])
# news
mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
mod["moduleimpl_id"] = M["moduleimpl_id"]
mod["url"] = (
scu.NotesURL() + "/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
@ -418,8 +418,8 @@ def do_evaluation_etat(evaluation_id, partition_id=None, select_first_partition=
last_modif = None
# ---- Liste des groupes complets et incomplets
E = do_evaluation_list(args={"evaluation_id": evaluation_id})[0]
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
is_malus = Mod["module_type"] == scu.MODULE_MALUS # True si module de malus
formsemestre_id = M["formsemestre_id"]
# Si partition_id is None, prend 'all' ou bien la premiere:
@ -438,7 +438,7 @@ def do_evaluation_etat(evaluation_id, partition_id=None, select_first_partition=
formsemestre_id
)
insmod = sco_moduleimpl.do_moduleimpl_inscription_list(
context, moduleimpl_id=E["moduleimpl_id"]
moduleimpl_id=E["moduleimpl_id"]
)
insmodset = set([x["etudid"] for x in insmod])
# retire de insem ceux qui ne sont pas inscrits au module
@ -743,7 +743,7 @@ def formsemestre_evaluations_cal(formsemestre_id, REQUEST=None):
continue
day = e["jour"].strftime("%Y-%m-%d")
mod = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=e["moduleimpl_id"]
moduleimpl_id=e["moduleimpl_id"]
)[0]
txt = mod["module"]["code"] or mod["module"]["abbrev"] or "eval"
if e["heure_debut"]:
@ -821,10 +821,10 @@ def evaluation_date_first_completion(evaluation_id):
# (pour avoir l'etat et le groupe) et aussi les inscriptions
# au module (pour gerer les modules optionnels correctement)
# E = do_evaluation_list(args={"evaluation_id": evaluation_id})[0]
# M = sco_moduleimpl.do_moduleimpl_list(context,moduleimpl_id=E["moduleimpl_id"])[0]
# M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
# formsemestre_id = M["formsemestre_id"]
# insem = sco_formsemestre_inscriptions.do_formsemestre_inscription_listinscrits( formsemestre_id)
# insmod = sco_moduleimpl.do_moduleimpl_inscription_list(context,moduleimpl_id=E["moduleimpl_id"])
# insmod = sco_moduleimpl.do_moduleimpl_inscription_list(moduleimpl_id=E["moduleimpl_id"])
# insmodset = set([x["etudid"] for x in insmod])
# retire de insem ceux qui ne sont pas inscrits au module
# ins = [i for i in insem if i["etudid"] in insmodset]
@ -866,12 +866,8 @@ def formsemestre_evaluations_delai_correction(
evals = nt.get_sem_evaluation_etat_list()
T = []
for e in evals:
M = sco_moduleimpl.do_moduleimpl_list(
context, moduleimpl_id=e["moduleimpl_id"]
)[0]
Mod = sco_edit_module.do_module_list(
context, args={"module_id": M["module_id"]}
)[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=e["moduleimpl_id"])[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
if (e["evaluation_type"] != scu.EVALUATION_NORMALE) or (
Mod["module_type"] == scu.MODULE_MALUS
):
@ -1050,8 +1046,8 @@ def evaluation_describe(evaluation_id="", edit_in_place=True, REQUEST=None):
E = do_evaluation_list({"evaluation_id": evaluation_id})[0]
moduleimpl_id = E["moduleimpl_id"]
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
formsemestre_id = M["formsemestre_id"]
u = sco_users.user_info(M["responsable_id"])
resp = u["prenomnom"]
@ -1080,7 +1076,7 @@ def evaluation_describe(evaluation_id="", edit_in_place=True, REQUEST=None):
]
if Mod["module_type"] == scu.MODULE_MALUS:
# Indique l'UE
ue = sco_edit_ue.do_ue_list(context, args={"ue_id": Mod["ue_id"]})[0]
ue = sco_edit_ue.do_ue_list(args={"ue_id": Mod["ue_id"]})[0]
H.append("<p><b>UE : %(acronyme)s</b></p>" % ue)
# store min/max values used by JS client-side checks:
H.append(
@ -1132,9 +1128,7 @@ def evaluation_create_form(
the_eval = do_evaluation_list({"evaluation_id": evaluation_id})[0]
moduleimpl_id = the_eval["moduleimpl_id"]
#
M = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=moduleimpl_id
)[0]
M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=moduleimpl_id)[0]
is_malus = M["module"]["module_type"] == scu.MODULE_MALUS # True si module de malus
formsemestre_id = M["formsemestre_id"]
min_note_max = scu.NOTES_PRECISION # le plus petit bareme possible
@ -1193,7 +1187,7 @@ def evaluation_create_form(
else:
min_note_max_str = "0"
#
Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
#
help = """<div class="help"><p class="help">
Le coefficient d'une évaluation n'est utilisé que pour pondérer les évaluations au sein d'un module.

2
app/scodoc/sco_export_results.py
View File

@ -245,7 +245,7 @@ def scodoc_table_results(
)
if format != "html":
return tab.make_page(
context, format=format, with_html_headers=False, REQUEST=REQUEST
format=format, with_html_headers=False, REQUEST=REQUEST
)
tab_html = tab.html()
nb_rows = tab.get_nb_rows()

2
app/scodoc/sco_find_etud.py
View File

@ -378,5 +378,5 @@ def search_inscr_etud_by_nip(context, code_nip, REQUEST=None, format="json"):
tab = GenTable(columns_ids=columns_ids, rows=T)
return tab.make_page(
context, format=format, with_html_headers=False, REQUEST=REQUEST, publish=True
format=format, with_html_headers=False, REQUEST=REQUEST, publish=True
)

44
app/scodoc/sco_formations.py
View File

@ -84,7 +84,7 @@ def formation_list(formation_id=None, args={}):
return r
def formation_has_locked_sems(context, formation_id):
def formation_has_locked_sems(formation_id):
"True if there is a locked formsemestre in this formation"
sems = sco_formsemestre.do_formsemestre_list(
args={"formation_id": formation_id, "etat": False}
@ -93,13 +93,13 @@ def formation_has_locked_sems(context, formation_id):
def formation_export(
context, formation_id, export_ids=False, export_tags=True, format=None, REQUEST=None
formation_id, export_ids=False, export_tags=True, format=None, REQUEST=None
):
"""Get a formation, with UE, matieres, modules
in desired format
"""
F = formation_list(context, args={"formation_id": formation_id})[0]
ues = sco_edit_ue.do_ue_list(context, {"formation_id": formation_id})
F = formation_list(args={"formation_id": formation_id})[0]
ues = sco_edit_ue.do_ue_list({"formation_id": formation_id})
F["ue"] = ues
for ue in ues:
ue_id = ue["ue_id"]
@ -108,21 +108,19 @@ def formation_export(
del ue["formation_id"]
if ue["ects"] is None:
del ue["ects"]
mats = sco_edit_matiere.do_matiere_list(context, {"ue_id": ue_id})
mats = sco_edit_matiere.do_matiere_list({"ue_id": ue_id})
ue["matiere"] = mats
for mat in mats:
matiere_id = mat["matiere_id"]
if not export_ids:
del mat["matiere_id"]
del mat["ue_id"]
mods = sco_edit_module.do_module_list(context, {"matiere_id": matiere_id})
mods = sco_edit_module.do_module_list({"matiere_id": matiere_id})
mat["module"] = mods
for mod in mods:
if export_tags:
# mod['tags'] = sco_tag_module.module_tag_list(context, module_id=mod['module_id'])
tags = sco_tag_module.module_tag_list(
context, module_id=mod["module_id"]
)
# mod['tags'] = sco_tag_module.module_tag_list( module_id=mod['module_id'])
tags = sco_tag_module.module_tag_list(module_id=mod["module_id"])
if tags:
mod["tags"] = [{"name": x} for x in tags]
if not export_ids:
@ -138,7 +136,7 @@ def formation_export(
)
def formation_import_xml(context, doc: str, import_tags=True):
def formation_import_xml(doc: str, import_tags=True):
"""Create a formation from XML representation
(format dumped by formation_export( format='xml' ))
XML may contain object (UE, modules) ids: this function returns two
@ -188,7 +186,7 @@ def formation_import_xml(context, doc: str, import_tags=True):
# create formation
# F_unquoted = F.copy()
# unescape_html_dict(F_unquoted)
formation_id = sco_edit_formation.do_formation_create(context, F)
formation_id = sco_edit_formation.do_formation_create(F)
log("formation %s created" % formation_id)
ues_old2new = {} # xml ue_id : new ue_id
modules_old2new = {} # xml module_id : new module_id
@ -202,14 +200,14 @@ def formation_import_xml(context, doc: str, import_tags=True):
del ue_info[1]["ue_id"]
else:
xml_ue_id = None
ue_id = sco_edit_ue.do_ue_create(context, ue_info[1])
ue_id = sco_edit_ue.do_ue_create(ue_info[1])
if xml_ue_id:
ues_old2new[xml_ue_id] = ue_id
# -- create matieres
for mat_info in ue_info[2]:
assert mat_info[0] == "matiere"
mat_info[1]["ue_id"] = ue_id
mat_id = sco_edit_matiere.do_matiere_create(context, mat_info[1])
mat_id = sco_edit_matiere.do_matiere_create(mat_info[1])
# -- create modules
for mod_info in mat_info[2]:
assert mod_info[0] == "module"
@ -221,23 +219,23 @@ def formation_import_xml(context, doc: str, import_tags=True):
mod_info[1]["formation_id"] = formation_id
mod_info[1]["matiere_id"] = mat_id
mod_info[1]["ue_id"] = ue_id
mod_id = sco_edit_module.do_module_create(context, mod_info[1])
mod_id = sco_edit_module.do_module_create(mod_info[1])
if xml_module_id:
modules_old2new[int(xml_module_id)] = mod_id
if import_tags:
if len(mod_info) > 2:
tag_names = [t[1]["name"] for t in mod_info[2]]
sco_tag_module.module_tag_set(context, mod_id, tag_names)
sco_tag_module.module_tag_set(mod_id, tag_names)
return formation_id, modules_old2new, ues_old2new
def formation_list_table(context, formation_id=None, args={}, REQUEST=None):
def formation_list_table(formation_id=None, args={}, REQUEST=None):
"""List formation, grouped by titre and sorted by versions
and listing associated semestres
returns a table
"""
formations = formation_list(context, formation_id=formation_id, args=args)
formations = formation_list(formation_id=formation_id, args=args)
title = "Programmes pédagogiques"
lockicon = scu.icontag(
"lock32_img", title="Comporte des semestres verrouillés", border="0"
@ -285,7 +283,7 @@ def formation_list_table(context, formation_id=None, args={}, REQUEST=None):
else:
f["date_fin_dernier_sem"] = ""
f["annee_dernier_sem"] = ""
locked = formation_has_locked_sems(context, f["formation_id"])
locked = formation_has_locked_sems(f["formation_id"])
#
if locked:
but_locked = lockicon
@ -354,12 +352,12 @@ def formation_list_table(context, formation_id=None, args={}, REQUEST=None):
)
def formation_create_new_version(context, formation_id, redirect=True, REQUEST=None):
def formation_create_new_version(formation_id, redirect=True, REQUEST=None):
"duplicate formation, with new version number"
xml = formation_export(context, formation_id, export_ids=True, format="xml")
new_id, modules_old2new, ues_old2new = formation_import_xml(context, xml)
xml = formation_export(formation_id, export_ids=True, format="xml")
new_id, modules_old2new, ues_old2new = formation_import_xml(xml)
# news
F = formation_list(context, args={"formation_id": new_id})[0]
F = formation_list(args={"formation_id": new_id})[0]
sco_news.add(
typ=sco_news.NEWS_FORM,
object=new_id,

71
app/scodoc/sco_formsemestre_edit.py
View File

@ -122,7 +122,7 @@ def formsemestre_editwithmodules(context, REQUEST, formsemestre_id):
return "\n".join(H) + html_sco_header.sco_footer()
def can_edit_sem(context, REQUEST, formsemestre_id="", sem=None):
def can_edit_sem(REQUEST, formsemestre_id="", sem=None):
"""Return sem if user can edit it, False otherwise"""
sem = sem or sco_formsemestre.get_formsemestre(formsemestre_id)
if not current_user.has_permission(Permission.ScoImplement): # pas chef
@ -168,9 +168,7 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
initvalues = sem
semestre_id = initvalues["semestre_id"]
# add associated modules to tf-checked:
ams = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=formsemestre_id
)
ams = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
sem_module_ids = set([x["module_id"] for x in ams])
initvalues["tf-checked"] = ["MI" + str(x["module_id"]) for x in ams]
for x in ams:
@ -203,13 +201,11 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
# on pourrait faire un simple module_list( )
# mais si on veut l'ordre du PPN (groupe par UE et matieres) il faut:
mods = [] # liste de dicts
uelist = sco_edit_ue.do_ue_list(context, {"formation_id": formation_id})
uelist = sco_edit_ue.do_ue_list({"formation_id": formation_id})
for ue in uelist:
matlist = sco_edit_matiere.do_matiere_list(context, {"ue_id": ue["ue_id"]})
matlist = sco_edit_matiere.do_matiere_list({"ue_id": ue["ue_id"]})
for mat in matlist:
modsmat = sco_edit_module.do_module_list(
context, {"matiere_id": mat["matiere_id"]}
)
modsmat = sco_edit_module.do_module_list({"matiere_id": mat["matiere_id"]})
# XXX debug checks
for m in modsmat:
if m["ue_id"] != ue["ue_id"]:
@ -736,7 +732,7 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
"formsemestre_id": formsemestre_id,
"responsable_id": tf[2][module_id],
}
_ = sco_moduleimpl.do_moduleimpl_create(context, modargs)
_ = sco_moduleimpl.do_moduleimpl_create(modargs)
return flask.redirect(
"formsemestre_status?formsemestre_id=%s&head_message=Nouveau%%20semestre%%20créé"
% formsemestre_id
@ -751,9 +747,7 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
# (retire le "MI" du début du nom de champs)
checkedmods = [int(x[2:]) for x in tf[2]["tf-checked"]]
sco_formsemestre.do_formsemestre_edit(tf[2])
ams = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=formsemestre_id
)
ams = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
existingmods = [x["module_id"] for x in ams]
mods_tocreate = [x for x in checkedmods if not x in existingmods]
# modules a existants a modifier
@ -768,10 +762,8 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
"formsemestre_id": formsemestre_id,
"responsable_id": tf[2]["MI" + str(module_id)],
}
moduleimpl_id = sco_moduleimpl.do_moduleimpl_create(context, modargs)
mod = sco_edit_module.do_module_list(context, {"module_id": module_id})[
0
]
moduleimpl_id = sco_moduleimpl.do_moduleimpl_create(modargs)
mod = sco_edit_module.do_module_list({"module_id": module_id})[0]
msg += ["création de %s (%s)" % (mod["code"], mod["titre"])]
# INSCRIPTIONS DES ETUDIANTS
log(
@ -788,7 +780,6 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
% (module_id, moduleimpl_id, etudids)
)
sco_moduleimpl.do_moduleimpl_inscrit_etuds(
context,
moduleimpl_id,
formsemestre_id,
etudids,
@ -804,13 +795,11 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
% (module_id, moduleimpl_id)
)
#
ok, diag = formsemestre_delete_moduleimpls(
context, formsemestre_id, mods_todelete
)
ok, diag = formsemestre_delete_moduleimpls(formsemestre_id, mods_todelete)
msg += diag
for module_id in mods_toedit:
moduleimpl_id = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=formsemestre_id, module_id=module_id
formsemestre_id=formsemestre_id, module_id=module_id
)[0]["moduleimpl_id"]
modargs = {
"moduleimpl_id": moduleimpl_id,
@ -819,11 +808,9 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
"responsable_id": tf[2]["MI" + str(module_id)],
}
sco_moduleimpl.do_moduleimpl_edit(
context, modargs, formsemestre_id=formsemestre_id
modargs, formsemestre_id=formsemestre_id
)
mod = sco_edit_module.do_module_list(context, {"module_id": module_id})[
0
]
mod = sco_edit_module.do_module_list({"module_id": module_id})[0]
if msg:
msg_html = (
@ -847,7 +834,7 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
)
def formsemestre_delete_moduleimpls(context, formsemestre_id, module_ids_to_del):
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.
@ -857,9 +844,9 @@ def formsemestre_delete_moduleimpls(context, formsemestre_id, module_ids_to_del)
for module_id in module_ids_to_del:
# get id
moduleimpl_id = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=formsemestre_id, module_id=module_id
formsemestre_id=formsemestre_id, module_id=module_id
)[0]["moduleimpl_id"]
mod = sco_edit_module.do_module_list(context, {"module_id": module_id})[0]
mod = sco_edit_module.do_module_list({"module_id": module_id})[0]
# Evaluations dans ce module ?
evals = sco_evaluations.do_evaluation_list({"moduleimpl_id": moduleimpl_id})
if evals:
@ -871,7 +858,7 @@ def formsemestre_delete_moduleimpls(context, formsemestre_id, module_ids_to_del)
else:
msg += ["suppression de %s (%s)" % (mod["code"], mod["titre"])]
sco_moduleimpl.do_moduleimpl_delete(
context, moduleimpl_id, formsemestre_id=formsemestre_id
moduleimpl_id, formsemestre_id=formsemestre_id
)
return ok, msg
@ -990,7 +977,6 @@ def formsemestre_clone(context, formsemestre_id, REQUEST=None):
)
else:
new_formsemestre_id = do_formsemestre_clone(
context,
formsemestre_id,
User.get_user_id_from_nomplogin(tf[2]["responsable_id"]),
tf[2]["date_debut"],
@ -1006,7 +992,6 @@ def formsemestre_clone(context, formsemestre_id, REQUEST=None):
def do_formsemestre_clone(
context,
orig_formsemestre_id,
responsable_id, # new resp.
date_debut,
@ -1031,21 +1016,19 @@ def do_formsemestre_clone(
formsemestre_id = sco_formsemestre.do_formsemestre_create(args)
log("created formsemestre %s" % formsemestre_id)
# 2- create moduleimpls
mods_orig = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=orig_formsemestre_id
)
mods_orig = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=orig_formsemestre_id)
for mod_orig in mods_orig:
args = mod_orig.copy()
args["formsemestre_id"] = formsemestre_id
mid = sco_moduleimpl.do_moduleimpl_create(context, args)
mid = sco_moduleimpl.do_moduleimpl_create(args)
# copy notes_modules_enseignants
ens = sco_moduleimpl.do_ens_list(
context, args={"moduleimpl_id": mod_orig["moduleimpl_id"]}
args={"moduleimpl_id": mod_orig["moduleimpl_id"]}
)
for e in ens:
args = e.copy()
args["moduleimpl_id"] = mid
sco_moduleimpl.do_ens_create(context, args)
sco_moduleimpl.do_ens_create(args)
# optionally, copy evaluations
if clone_evaluations:
evals = sco_evaluations.do_evaluation_list(
@ -1209,7 +1192,7 @@ def do_formsemestres_associate_new_version(context, formsemestre_ids, REQUEST=No
modules_old2new,
ues_old2new,
) = sco_formations.formation_create_new_version(
context, formation_id, redirect=False, REQUEST=REQUEST
formation_id, redirect=False, REQUEST=REQUEST
)
for formsemestre_id in formsemestre_ids:
@ -1230,12 +1213,10 @@ def _reassociate_moduleimpls(
et met à jour les décisions de jury (validations d'UE).
"""
# re-associate moduleimpls to new modules:
modimpls = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=formsemestre_id
)
modimpls = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
for mod in modimpls:
mod["module_id"] = modules_old2new[mod["module_id"]]
sco_moduleimpl.do_moduleimpl_edit(context, mod, formsemestre_id=formsemestre_id)
sco_moduleimpl.do_moduleimpl_edit(mod, formsemestre_id=formsemestre_id)
# update decisions:
events = sco_etud.scolar_events_list(cnx, args={"formsemestre_id": formsemestre_id})
for e in events:
@ -1353,7 +1334,7 @@ def do_formsemestre_delete(context, formsemestre_id):
sco_cache.EvaluationCache.invalidate_sem(formsemestre_id)
# --- Destruction des modules de ce semestre
mods = sco_moduleimpl.do_moduleimpl_list(context, formsemestre_id=formsemestre_id)
mods = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
for mod in mods:
# evaluations
evals = sco_evaluations.do_evaluation_list(
@ -1374,7 +1355,7 @@ def do_formsemestre_delete(context, formsemestre_id):
)
sco_moduleimpl.do_moduleimpl_delete(
context, mod["moduleimpl_id"], formsemestre_id=formsemestre_id
mod["moduleimpl_id"], formsemestre_id=formsemestre_id
)
# --- Desinscription des etudiants
cursor = cnx.cursor(cursor_factory=ndb.ScoDocCursor)

2
app/scodoc/sco_formsemestre_exterieurs.py
View File

@ -441,7 +441,7 @@ def _list_ue_with_coef_and_validations(context, sem, etudid):
"""
cnx = ndb.GetDBConnexion()
formsemestre_id = sem["formsemestre_id"]
ue_list = sco_edit_ue.do_ue_list(context, {"formation_id": sem["formation_id"]})
ue_list = sco_edit_ue.do_ue_list({"formation_id": sem["formation_id"]})
for ue in ue_list:
# add coefficient
uecoef = sco_formsemestre.formsemestre_uecoef_list(

20
app/scodoc/sco_formsemestre_inscriptions.py
View File

@ -170,7 +170,7 @@ def do_formsemestre_desinscription(context, etudid, formsemestre_id, REQUEST=Non
moduleimpl_inscription_ids = [x[0] for x in res]
for moduleimpl_inscription_id in moduleimpl_inscription_ids:
sco_moduleimpl.do_moduleimpl_inscription_delete(
context, moduleimpl_inscription_id, formsemestre_id=formsemestre_id
moduleimpl_inscription_id, formsemestre_id=formsemestre_id
)
# -- desincription du semestre
do_formsemestre_inscription_delete(
@ -235,12 +235,11 @@ def do_formsemestre_inscription_with_modules(
# inscription a tous les modules de ce semestre
modimpls = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=formsemestre_id
formsemestre_id=formsemestre_id
)
for mod in modimpls:
if mod["ue"]["type"] != UE_SPORT:
sco_moduleimpl.do_moduleimpl_inscription_create(
context,
{"moduleimpl_id": mod["moduleimpl_id"], "etudid": etudid},
REQUEST=REQUEST,
formsemestre_id=formsemestre_id,
@ -454,10 +453,8 @@ def formsemestre_inscription_option(context, etudid, formsemestre_id, REQUEST=No
]
# Cherche les moduleimpls et les inscriptions
mods = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=formsemestre_id
)
inscr = sco_moduleimpl.do_moduleimpl_inscription_list(context, etudid=etudid)
mods = sco_moduleimpl.do_moduleimpl_withmodule_list(formsemestre_id=formsemestre_id)
inscr = sco_moduleimpl.do_moduleimpl_inscription_list(etudid=etudid)
# Formulaire
modimpls_by_ue_ids = scu.DictDefault(defaultvalue=[]) # ue_id : [ moduleimpl_id ]
modimpls_by_ue_names = scu.DictDefault(
@ -680,14 +677,13 @@ def do_moduleimpl_incription_options(
# inscriptions
for moduleimpl_id in a_inscrire:
# verifie que ce module existe bien
mods = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)
mods = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)
if len(mods) != 1:
raise ScoValueError(
"inscription: invalid moduleimpl_id: %s" % moduleimpl_id
)
mod = mods[0]
sco_moduleimpl.do_moduleimpl_inscription_create(
context,
{"moduleimpl_id": moduleimpl_id, "etudid": etudid},
REQUEST=REQUEST,
formsemestre_id=mod["formsemestre_id"],
@ -695,14 +691,14 @@ def do_moduleimpl_incription_options(
# desinscriptions
for moduleimpl_id in a_desinscrire:
# verifie que ce module existe bien
mods = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)
mods = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)
if len(mods) != 1:
raise ScoValueError(
"desinscription: invalid moduleimpl_id: %s" % moduleimpl_id
)
mod = mods[0]
inscr = sco_moduleimpl.do_moduleimpl_inscription_list(
context, moduleimpl_id=moduleimpl_id, etudid=etudid
moduleimpl_id=moduleimpl_id, etudid=etudid
)
if not inscr:
raise ScoValueError(
@ -711,7 +707,7 @@ def do_moduleimpl_incription_options(
)
oid = inscr[0]["moduleimpl_inscription_id"]
sco_moduleimpl.do_moduleimpl_inscription_delete(
context, oid, formsemestre_id=mod["formsemestre_id"]
oid, formsemestre_id=mod["formsemestre_id"]
)
if REQUEST:

24
app/scodoc/sco_formsemestre_status.py
View File

@ -464,9 +464,7 @@ def retreive_formsemestre_from_request():
if "formsemestre_id" in args:
formsemestre_id = args["formsemestre_id"]
elif "moduleimpl_id" in args and args["moduleimpl_id"]:
modimpl = sco_moduleimpl.do_moduleimpl_list(
context, moduleimpl_id=args["moduleimpl_id"]
)
modimpl = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=args["moduleimpl_id"])
if not modimpl:
return None # suppressed ?
modimpl = modimpl[0]
@ -476,9 +474,7 @@ def retreive_formsemestre_from_request():
if not E:
return None # evaluation suppressed ?
E = E[0]
modimpl = sco_moduleimpl.do_moduleimpl_list(
context, moduleimpl_id=E["moduleimpl_id"]
)[0]
modimpl = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
formsemestre_id = modimpl["formsemestre_id"]
elif "group_id" in args:
group = sco_groups.get_group(args["group_id"])
@ -596,7 +592,7 @@ def formsemestre_description_table(
F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0]
parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"])
Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=formsemestre_id
formsemestre_id=formsemestre_id
)
R = []
@ -625,7 +621,7 @@ def formsemestre_description_table(
R.append(ue_info)
ModInscrits = sco_moduleimpl.do_moduleimpl_inscription_list(
context, moduleimpl_id=M["moduleimpl_id"]
moduleimpl_id=M["moduleimpl_id"]
)
enseignants = ", ".join(
[sco_users.user_info(m["ens_id"], REQUEST)["nomprenom"] for m in M["ens"]]
@ -891,7 +887,7 @@ def html_expr_diagnostic(context, diagnostics):
for diag in diagnostics:
if "moduleimpl_id" in diag:
mod = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=diag["moduleimpl_id"]
moduleimpl_id=diag["moduleimpl_id"]
)[0]
H.append(
'<li>module <a href="moduleimpl_status?moduleimpl_id=%s">%s</a>: %s</li>'
@ -903,7 +899,7 @@ def html_expr_diagnostic(context, diagnostics):
)
else:
if diag["ue_id"] != last_id or diag["msg"] != last_msg:
ue = sco_edit_ue.do_ue_list(context, {"ue_id": diag["ue_id"]})[0]
ue = sco_edit_ue.do_ue_list({"ue_id": diag["ue_id"]})[0]
H.append(
'<li>UE "%s": %s</li>'
% (ue["acronyme"] or ue["titre"] or "?", diag["msg"])
@ -987,16 +983,14 @@ def formsemestre_status(context, formsemestre_id=None, REQUEST=None):
cnx = ndb.GetDBConnexion()
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=formsemestre_id
formsemestre_id=formsemestre_id
)
# inscrits = sco_formsemestre_inscriptions.do_formsemestre_inscription_list(
# args={"formsemestre_id": formsemestre_id}
# )
prev_ue_id = None
can_edit = sco_formsemestre_edit.can_edit_sem(
context, REQUEST, formsemestre_id, sem=sem
)
can_edit = sco_formsemestre_edit.can_edit_sem(REQUEST, formsemestre_id, sem=sem)
H = [
html_sco_header.sco_header(page_title="Semestre %s" % sem["titreannee"]),
@ -1040,7 +1034,7 @@ def formsemestre_status(context, formsemestre_id=None, REQUEST=None):
[sco_users.user_info(e["ens_id"])["nomcomplet"] for e in M["ens"]]
)
ModInscrits = sco_moduleimpl.do_moduleimpl_inscription_list(
context, moduleimpl_id=M["moduleimpl_id"]
moduleimpl_id=M["moduleimpl_id"]
)
mails_enseignants.add(
sco_users.user_info(M["responsable_id"], REQUEST)["email"]

8
app/scodoc/sco_formsemestre_validation.py
View File

@ -1018,7 +1018,7 @@ def formsemestre_validate_previous_ue(context, formsemestre_id, etudid, REQUEST=
]
# Toutes les UE de cette formation sont présentées (même celles des autres semestres)
ues = sco_edit_ue.do_ue_list(context, {"formation_id": Fo["formation_id"]})
ues = sco_edit_ue.do_ue_list({"formation_id": Fo["formation_id"]})
ue_names = ["Choisir..."] + ["%(acronyme)s %(titre)s" % ue for ue in ues]
ue_ids = [""] + [ue["ue_id"] for ue in ues]
tf = TrivialFormulator(
@ -1076,7 +1076,7 @@ def formsemestre_validate_previous_ue(context, formsemestre_id, etudid, REQUEST=
<div id="ue_list_etud_validations"><!-- filled by get_etud_ue_cap_html --></div>
<div id="ue_list_code"><!-- filled by ue_sharing_code --></div>
"""
warn, ue_multiples = check_formation_ues(context, Fo["formation_id"])
warn, ue_multiples = check_formation_ues(Fo["formation_id"])
return "\n".join(H) + tf[1] + X + warn + html_sco_header.sco_footer()
elif tf[0] == -1:
return flask.redirect(
@ -1228,13 +1228,13 @@ def etud_ue_suppress_validation(context, etudid, formsemestre_id, ue_id, REQUEST
)
def check_formation_ues(context, formation_id):
def check_formation_ues(formation_id):
"""Verifie que les UE d'une formation sont chacune utilisée dans un seul semestre_id
Si ce n'est pas le cas, c'est probablement (mais pas forcément) une erreur de
définition du programme: cette fonction retourne un bout de HTML
à afficher pour prévenir l'utilisateur, ou '' si tout est ok.
"""
ues = sco_edit_ue.do_ue_list(context, {"formation_id": formation_id})
ues = sco_edit_ue.do_ue_list({"formation_id": formation_id})
ue_multiples = {} # { ue_id : [ liste des formsemestre ] }
for ue in ues:
# formsemestres utilisant cette ue ?

4
app/scodoc/sco_groups_view.py
View File

@ -319,9 +319,7 @@ class DisplayedGroupsInfos(object):
else:
group_ids = []
if not formsemestre_id and moduleimpl_id:
mods = sco_moduleimpl.do_moduleimpl_list(
context, moduleimpl_id=moduleimpl_id
)
mods = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)
if len(mods) != 1:
raise ValueError("invalid moduleimpl_id")
formsemestre_id = mods[0]["formsemestre_id"]

6
app/scodoc/sco_liste_notes.py
View File

@ -234,8 +234,8 @@ def _make_table_notes(
return "<p>Aucune évaluation !</p>"
E = evals[0]
moduleimpl_id = E["moduleimpl_id"]
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
# (debug) check that all evals are in same module:
for e in evals:
@ -888,7 +888,7 @@ def formsemestre_check_absences_html(context, formsemestre_id, REQUEST=None):
]
# Modules, dans l'ordre
Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=formsemestre_id
formsemestre_id=formsemestre_id
)
for M in Mlist:
evals = sco_evaluations.do_evaluation_list(

55
app/scodoc/sco_moduleimpl.py
View File

@ -63,7 +63,7 @@ _modules_enseignantsEditor = ndb.EditableTable(
)
def do_moduleimpl_create(context, args):
def do_moduleimpl_create(args):
"create a moduleimpl"
cnx = ndb.GetDBConnexion()
r = _moduleimplEditor.create(cnx, args)
@ -73,7 +73,7 @@ def do_moduleimpl_create(context, args):
return r
def do_moduleimpl_delete(context, oid, formsemestre_id=None):
def do_moduleimpl_delete(oid, formsemestre_id=None):
"delete moduleimpl (desinscrit tous les etudiants)"
cnx = ndb.GetDBConnexion()
# --- desinscription des etudiants
@ -100,7 +100,7 @@ def do_moduleimpl_delete(context, oid, formsemestre_id=None):
def do_moduleimpl_list(
context, moduleimpl_id=None, formsemestre_id=None, module_id=None, REQUEST=None
moduleimpl_id=None, formsemestre_id=None, module_id=None, REQUEST=None
):
"list moduleimpls"
args = locals()
@ -108,11 +108,11 @@ def do_moduleimpl_list(
modimpls = _moduleimplEditor.list(cnx, args)
# Ajoute la liste des enseignants
for mo in modimpls:
mo["ens"] = do_ens_list(context, args={"moduleimpl_id": mo["moduleimpl_id"]})
mo["ens"] = do_ens_list(args={"moduleimpl_id": mo["moduleimpl_id"]})
return scu.return_text_if_published(modimpls, REQUEST)
def do_moduleimpl_edit(context, args, formsemestre_id=None, cnx=None):
def do_moduleimpl_edit(args, formsemestre_id=None, cnx=None):
"edit a moduleimpl"
if not cnx:
cnx = ndb.GetDBConnexion()
@ -124,7 +124,7 @@ def do_moduleimpl_edit(context, args, formsemestre_id=None, cnx=None):
def do_moduleimpl_withmodule_list(
context, moduleimpl_id=None, formsemestre_id=None, module_id=None, REQUEST=None
moduleimpl_id=None, formsemestre_id=None, module_id=None, REQUEST=None
):
"""Liste les moduleimpls et ajoute dans chacun le module correspondant
Tri la liste par semestre/UE/numero_matiere/numero_module.
@ -136,10 +136,8 @@ def do_moduleimpl_withmodule_list(
from app.scodoc import sco_edit_module
args = locals()
del args["context"]
del args["REQUEST"]
modimpls = do_moduleimpl_list(
context,
**{
"moduleimpl_id": moduleimpl_id,
"formsemestre_id": formsemestre_id,
@ -148,13 +146,11 @@ def do_moduleimpl_withmodule_list(
)
for mo in modimpls:
mo["module"] = sco_edit_module.do_module_list(
context, args={"module_id": mo["module_id"]}
)[0]
mo["ue"] = sco_edit_ue.do_ue_list(
context, args={"ue_id": mo["module"]["ue_id"]}
args={"module_id": mo["module_id"]}
)[0]
mo["ue"] = sco_edit_ue.do_ue_list(args={"ue_id": mo["module"]["ue_id"]})[0]
mo["matiere"] = sco_edit_matiere.do_matiere_list(
context, args={"matiere_id": mo["module"]["matiere_id"]}
args={"matiere_id": mo["module"]["matiere_id"]}
)[0]
# tri par semestre/UE/numero_matiere/numero_module
@ -172,9 +168,7 @@ def do_moduleimpl_withmodule_list(
return scu.return_text_if_published(modimpls, REQUEST)
def do_moduleimpl_inscription_list(
context, moduleimpl_id=None, etudid=None, REQUEST=None
):
def do_moduleimpl_inscription_list(moduleimpl_id=None, etudid=None, REQUEST=None):
"list moduleimpl_inscriptions"
args = locals()
cnx = ndb.GetDBConnexion()
@ -183,7 +177,7 @@ def do_moduleimpl_inscription_list(
)
def do_moduleimpl_listeetuds(context, moduleimpl_id):
def do_moduleimpl_listeetuds(moduleimpl_id):
"retourne liste des etudids inscrits a ce module"
req = """SELECT DISTINCT Im.etudid
FROM notes_moduleimpl_inscription Im,
@ -200,7 +194,7 @@ def do_moduleimpl_listeetuds(context, moduleimpl_id):
return [x[0] for x in res]
def do_moduleimpl_inscrit_tout_semestre(context, moduleimpl_id, formsemestre_id):
def do_moduleimpl_inscrit_tout_semestre(moduleimpl_id, formsemestre_id):
"inscrit tous les etudiants inscrit au semestre a ce module"
# UNUSED
cnx = ndb.GetDBConnexion()
@ -223,7 +217,7 @@ _moduleimpl_inscriptionEditor = ndb.EditableTable(
)
def do_moduleimpl_inscription_create(context, args, REQUEST=None, formsemestre_id=None):
def do_moduleimpl_inscription_create(args, REQUEST=None, formsemestre_id=None):
"create a moduleimpl_inscription"
cnx = ndb.GetDBConnexion()
log("do_moduleimpl_inscription_create: " + str(args))
@ -242,7 +236,7 @@ def do_moduleimpl_inscription_create(context, args, REQUEST=None, formsemestre_i
return r
def do_moduleimpl_inscription_delete(context, oid, formsemestre_id=None):
def do_moduleimpl_inscription_delete(oid, formsemestre_id=None):
"delete moduleimpl_inscription"
cnx = ndb.GetDBConnexion()
_moduleimpl_inscriptionEditor.delete(cnx, oid)
@ -252,7 +246,7 @@ def do_moduleimpl_inscription_delete(context, oid, formsemestre_id=None):
def do_moduleimpl_inscrit_etuds(
context, moduleimpl_id, formsemestre_id, etudids, reset=False, REQUEST=None
moduleimpl_id, formsemestre_id, etudids, reset=False, REQUEST=None
):
"""Inscrit les etudiants (liste d'etudids) a ce module.
Si reset, desinscrit tous les autres.
@ -280,16 +274,13 @@ def do_moduleimpl_inscrit_etuds(
[
# hum ?
x["etudid"]
for x in do_moduleimpl_inscription_list(
context, moduleimpl_id=moduleimpl_id
)
for x in do_moduleimpl_inscription_list(moduleimpl_id=moduleimpl_id)
]
)
for etudid in etudids:
# deja inscrit ?
if not etudid in inmod_set:
do_moduleimpl_inscription_create(
context,
{"moduleimpl_id": moduleimpl_id, "etudid": etudid},
REQUEST=REQUEST,
formsemestre_id=formsemestre_id,
@ -300,31 +291,31 @@ def do_moduleimpl_inscrit_etuds(
) # > moduleimpl_inscrit_etuds
def do_ens_list(context, *args, **kw):
def do_ens_list(*args, **kw):
"liste les enseignants d'un moduleimpl (pas le responsable)"
cnx = ndb.GetDBConnexion()
ens = _modules_enseignantsEditor.list(cnx, *args, **kw)
return ens
def do_ens_edit(context, *args, **kw):
def do_ens_edit(*args, **kw):
"edit ens"
cnx = ndb.GetDBConnexion()
_modules_enseignantsEditor.edit(cnx, *args, **kw)
def do_ens_create(context, args):
def do_ens_create(args):
"create ens"
cnx = ndb.GetDBConnexion()
r = _modules_enseignantsEditor.create(cnx, args)
return r
def can_change_module_resp(context, REQUEST, moduleimpl_id):
def can_change_module_resp(REQUEST, moduleimpl_id):
"""Check if current user can modify module resp. (raise exception if not).
= Admin, et dir des etud. (si option l'y autorise)
"""
M = do_moduleimpl_withmodule_list(context, moduleimpl_id=moduleimpl_id)[0]
M = do_moduleimpl_withmodule_list(moduleimpl_id=moduleimpl_id)[0]
# -- check lock
sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
if not sem["etat"]:
@ -340,9 +331,9 @@ def can_change_module_resp(context, REQUEST, moduleimpl_id):
return M, sem
def can_change_ens(context, REQUEST, moduleimpl_id, raise_exc=True):
def can_change_ens(REQUEST, moduleimpl_id, raise_exc=True):
"check if current user can modify ens list (raise exception if not)"
M = do_moduleimpl_withmodule_list(context, moduleimpl_id=moduleimpl_id)[0]
M = do_moduleimpl_withmodule_list(moduleimpl_id=moduleimpl_id)[0]
# -- check lock
sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
if not sem["etat"]:

20
app/scodoc/sco_moduleimpl_inscriptions.py
View File

@ -64,9 +64,9 @@ def moduleimpl_inscriptions_edit(
* Si pas les droits: idem en readonly
"""
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
formsemestre_id = M["formsemestre_id"]
mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
# -- check lock
if not sem["etat"]:
@ -108,7 +108,7 @@ def moduleimpl_inscriptions_edit(
ins["etud"] = etuds_info[0]
inscrits.sort(key=lambda x: x["etud"]["nom"])
in_m = sco_moduleimpl.do_moduleimpl_inscription_list(
context, moduleimpl_id=M["moduleimpl_id"]
moduleimpl_id=M["moduleimpl_id"]
)
in_module = set([x["etudid"] for x in in_m])
#
@ -199,7 +199,7 @@ def moduleimpl_inscriptions_edit(
else: # SUBMISSION
# inscrit a ce module tous les etuds selectionnes
sco_moduleimpl.do_moduleimpl_inscrit_etuds(
context, moduleimpl_id, formsemestre_id, etuds, reset=True, REQUEST=REQUEST
moduleimpl_id, formsemestre_id, etuds, reset=True, REQUEST=REQUEST
)
return flask.redirect("moduleimpl_status?moduleimpl_id=%s" % (moduleimpl_id))
#
@ -265,7 +265,7 @@ def moduleimpl_inscriptions_stats(context, formsemestre_id, REQUEST=None):
# Liste des modules
Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=formsemestre_id
formsemestre_id=formsemestre_id
)
# Decrit les inscriptions aux modules:
commons = [] # modules communs a tous les etuds du semestre
@ -347,10 +347,7 @@ def moduleimpl_inscriptions_stats(context, formsemestre_id, REQUEST=None):
UECaps = get_etuds_with_capitalized_ue(context, formsemestre_id)
if UECaps:
H.append('<h3>Etudiants avec UEs capitalisées:</h3><ul class="ue_inscr_list">')
ues = [
sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
for ue_id in UECaps.keys()
]
ues = [sco_edit_ue.do_ue_list({"ue_id": ue_id})[0] for ue_id in UECaps.keys()]
ues.sort(key=lambda u: u["numero"])
for ue in ues:
H.append(
@ -428,9 +425,7 @@ def descr_inscrs_module(
context, sem, moduleimpl_id, set_all, partitions, partitions_etud_groups
):
"""returns tous_inscrits, nb_inscrits, descr"""
ins = sco_moduleimpl.do_moduleimpl_inscription_list(
context, moduleimpl_id=moduleimpl_id
)
ins = sco_moduleimpl.do_moduleimpl_inscription_list(moduleimpl_id=moduleimpl_id)
set_m = set([x["etudid"] for x in ins]) # ens. des inscrits au module
non_inscrits = set_all - set_m
if len(non_inscrits) == 0:
@ -589,7 +584,6 @@ def do_etud_inscrit_ue(context, etudid, formsemestre_id, ue_id, REQUEST=None):
res = cursor.dictfetchall()
for moduleimpl_id in [x["moduleimpl_id"] for x in res]:
sco_moduleimpl.do_moduleimpl_inscription_create(
context,
{"moduleimpl_id": moduleimpl_id, "etudid": etudid},
REQUEST=REQUEST,
formsemestre_id=formsemestre_id,

22
app/scodoc/sco_moduleimpl_status.py
View File

@ -57,9 +57,7 @@ from app.scodoc import sco_users
def moduleimpl_evaluation_menu(context, evaluation_id, nbnotes=0, REQUEST=None):
"Menu avec actions sur une evaluation"
E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
modimpl = sco_moduleimpl.do_moduleimpl_list(
context, moduleimpl_id=E["moduleimpl_id"]
)[0]
modimpl = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
group_id = sco_groups.get_default_group(modimpl["formsemestre_id"])
@ -158,13 +156,13 @@ def moduleimpl_evaluation_menu(context, evaluation_id, nbnotes=0, REQUEST=None):
def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=None):
"""Tableau de bord module (liste des evaluations etc)"""
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
formsemestre_id = M["formsemestre_id"]
Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0]
ModInscrits = sco_moduleimpl.do_moduleimpl_inscription_list(
context, moduleimpl_id=M["moduleimpl_id"]
moduleimpl_id=M["moduleimpl_id"]
)
nt = sco_cache.NotesTableCache.get(formsemestre_id)
@ -193,7 +191,7 @@ def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=No
"""<span class="blacktt">(%(responsable_id)s)</span>""" % M,
]
try:
sco_moduleimpl.can_change_module_resp(context, REQUEST, moduleimpl_id)
sco_moduleimpl.can_change_module_resp(REQUEST, moduleimpl_id)
H.append(
"""<a class="stdlink" href="edit_moduleimpl_resp?moduleimpl_id=%s">modifier</a>"""
% moduleimpl_id
@ -206,7 +204,7 @@ def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=No
)
H.append("""</td><td>""")
try:
sco_moduleimpl.can_change_ens(context, REQUEST, moduleimpl_id)
sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id)
H.append(
"""<a class="stdlink" href="edit_enseignants_form?moduleimpl_id=%s">modifier les enseignants</a>"""
% moduleimpl_id
@ -249,9 +247,7 @@ def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=No
'<tr><td class="fichetitre2" colspan="4">Règle de calcul: <span class="formula" title="mode de calcul de la moyenne du module">moyenne=<tt>%s</tt></span>'
% M["computation_expr"]
)
if sco_moduleimpl.can_change_ens(
context, REQUEST, moduleimpl_id, raise_exc=False
):
if sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id, raise_exc=False):
H.append(
'<span class="fl"><a class="stdlink" href="edit_moduleimpl_expr?moduleimpl_id=%s">modifier</a></span>'
% moduleimpl_id
@ -261,9 +257,7 @@ def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=No
H.append(
'<tr><td colspan="4"><em title="mode de calcul de la moyenne du module">règle de calcul standard</em>'
)
if sco_moduleimpl.can_change_ens(
context, REQUEST, moduleimpl_id, raise_exc=False
):
if sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id, raise_exc=False):
H.append(
' (<a class="stdlink" href="edit_moduleimpl_expr?moduleimpl_id=%s">changer</a>)'
% moduleimpl_id

2
app/scodoc/sco_news.py
View File

@ -178,7 +178,7 @@ def _get_formsemestre_infos_from_news(context, n):
formsemestre_id = n["object"]
elif n["type"] == NEWS_NOTE:
moduleimpl_id = n["object"]
mods = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)
mods = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)
if not mods:
return {} # module does not exists anymore
mod = mods[0]

2
app/scodoc/sco_parcours_dut.py
View File

@ -1093,7 +1093,7 @@ def formsemestre_get_etud_capitalisation(context, sem, etudid):
return cursor.dictfetchall()
def list_formsemestre_utilisateurs_uecap(context, formsemestre_id):
def list_formsemestre_utilisateurs_uecap(formsemestre_id):
"""Liste des formsemestres pouvant utiliser une UE capitalisee de ce semestre
(et qui doivent donc etre sortis du cache si l'on modifie ce
semestre): meme code formation, meme semestre_id, date posterieure"""

4
app/scodoc/sco_permissions_check.py
View File

@ -26,7 +26,7 @@ def can_edit_notes(authuser, moduleimpl_id, allow_ens=True):
context = None # XXX #context
uid = str(authuser)
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
if not sem["etat"]:
return False # semestre verrouillé
@ -68,7 +68,7 @@ def can_edit_evaluation(moduleimpl_id=None):
if moduleimpl_id is None:
raise ValueError("no moduleimpl specified") # bug
uid = current_user.user_name
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
if (

10
app/scodoc/sco_placement.py
View File

@ -65,7 +65,7 @@ def do_placement_selectetuds(REQUEST):
if not E:
raise ScoValueError("invalid evaluation_id")
E = E[0]
# M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
# M = sco_moduleimpl.do_moduleimpl_list( moduleimpl_id=E["moduleimpl_id"])[0]
# groupes
groups = sco_groups.do_evaluation_listegroupes(evaluation_id, include_default=True)
grlabs = [g["group_name"] or "tous" for g in groups] # legendes des boutons
@ -283,8 +283,8 @@ def do_placement(context, REQUEST):
if not etudids:
return "<p>Aucun groupe sélectionné !</p>"
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
evalname = "%s-%s" % (Mod["code"], ndb.DateDMYtoISO(E["jour"]))
if E["description"]:
@ -395,9 +395,7 @@ def do_placement(context, REQUEST):
preferences=sco_preferences.SemPreferences(M["formsemestre_id"]),
# html_generate_cells=False # la derniere ligne (moyennes) est incomplete
)
t = tab.make_page(
context, format="pdf", with_html_headers=False, REQUEST=REQUEST
)
t = tab.make_page(format="pdf", with_html_headers=False, REQUEST=REQUEST)
return t

1
app/scodoc/sco_poursuite_dut.py
View File

@ -215,7 +215,6 @@ def formsemestre_poursuite_report(
tab.html_caption = "Récapitulatif %s." % sem["titreannee"]
tab.base_url = "%s?formsemestre_id=%s" % (REQUEST.URL0, formsemestre_id)
return tab.make_page(
context,
title="""<h2 class="formsemestre">Poursuite d'études</h2>""",
init_qtip=True,
javascripts=["js/etud_info.js"],

3
app/scodoc/sco_pvjury.py
View File

@ -92,7 +92,7 @@ def _descr_decisions_ues(context, nt, etudid, decisions_ue, decision_sem):
and sco_codes_parcours.code_semestre_validant(decision_sem["code"])
)
):
ue = sco_edit_ue.do_ue_list(context, args={"ue_id": ue_id})[0]
ue = sco_edit_ue.do_ue_list(args={"ue_id": ue_id})[0]
uelist.append(ue)
except:
log("descr_decisions_ues: ue_id=%s decisions_ue=%s" % (ue_id, decisions_ue))
@ -543,7 +543,6 @@ def formsemestre_pvjury(
)
if format != "html":
return tab.make_page(
context,
format=format,
with_html_headers=False,
REQUEST=REQUEST,

1
app/scodoc/sco_report.py
View File

@ -357,7 +357,6 @@ def formsemestre_report_counts(
F.append("</p></form>")
t = tab.make_page(
context,
title="""<h2 class="formsemestre">Comptes croisés</h2>""",
format=format,
REQUEST=REQUEST,

48
app/scodoc/sco_saisie_notes.py
View File

@ -171,9 +171,9 @@ def do_evaluation_upload_xls(context, REQUEST):
evaluation_id = int(REQUEST.form["evaluation_id"])
comment = REQUEST.form["comment"]
E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
M = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=E["moduleimpl_id"]
)[0]
M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=E["moduleimpl_id"])[
0
]
# Check access
# (admin, respformation, and responsable_id)
if not sco_permissions_check.can_edit_notes(authuser, E["moduleimpl_id"]):
@ -248,12 +248,8 @@ def do_evaluation_upload_xls(context, REQUEST):
)
# news
E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
M = sco_moduleimpl.do_moduleimpl_list(
context, moduleimpl_id=E["moduleimpl_id"]
)[0]
mod = sco_edit_module.do_module_list(
context, args={"module_id": M["module_id"]}
)[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
mod["moduleimpl_id"] = M["moduleimpl_id"]
mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
sco_news.add(
@ -289,9 +285,9 @@ def do_evaluation_set_missing(evaluation_id, value, dialog_confirmed=False):
# ? evaluation_id = REQUEST.form["evaluation_id"]
context = None # XXX #context
E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
M = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=E["moduleimpl_id"]
)[0]
M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=E["moduleimpl_id"])[
0
]
# Check access
# (admin, respformation, and responsable_id)
if not sco_permissions_check.can_edit_notes(current_user, E["moduleimpl_id"]):
@ -337,8 +333,8 @@ def do_evaluation_set_missing(evaluation_id, value, dialog_confirmed=False):
comment = "Initialisation notes manquantes"
nb_changed, _, _ = _notes_add(context, current_user, evaluation_id, L, comment)
# news
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
mod["moduleimpl_id"] = M["moduleimpl_id"]
mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
sco_news.add(
@ -415,8 +411,8 @@ def evaluation_suppress_alln(evaluation_id, dialog_confirmed=False):
% E["moduleimpl_id"]
]
# news
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
mod["moduleimpl_id"] = M["moduleimpl_id"]
mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
sco_news.add(
@ -464,7 +460,7 @@ def _notes_add(
nb_changed = 0
nb_suppress = 0
E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
existing_decisions = (
[]
) # etudids pour lesquels il y a une decision de jury et que la note change
@ -586,7 +582,7 @@ def saisie_notes_tableur(context, evaluation_id, group_ids=[], REQUEST=None):
if not evals:
raise ScoValueError("invalid evaluation_id")
E = evals[0]
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
formsemestre_id = M["formsemestre_id"]
if not sco_permissions_check.can_edit_notes(authuser, E["moduleimpl_id"]):
return (
@ -760,9 +756,9 @@ def feuille_saisie_notes(context, evaluation_id, group_ids=[], REQUEST=None):
if not evals:
raise ScoValueError("invalid evaluation_id")
E = evals[0]
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
formsemestre_id = M["formsemestre_id"]
Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
mod_responsable = sco_users.user_info(M["responsable_id"])
if E["jour"]:
@ -841,7 +837,7 @@ def has_existing_decision(context, M, E, etudid):
return True
dec_ues = nt.get_etud_decision_ues(etudid)
if dec_ues:
mod = sco_edit_module.do_module_list(context, {"module_id": M["module_id"]})[0]
mod = sco_edit_module.do_module_list({"module_id": M["module_id"]})[0]
ue_id = mod["ue_id"]
if ue_id in dec_ues:
return True # decision pour l'UE a laquelle appartient cette evaluation
@ -862,9 +858,9 @@ def saisie_notes(context, evaluation_id, group_ids=[], REQUEST=None):
if not evals:
raise ScoValueError("invalid evaluation_id")
E = evals[0]
M = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=E["moduleimpl_id"]
)[0]
M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=E["moduleimpl_id"])[
0
]
formsemestre_id = M["formsemestre_id"]
# Check access
# (admin, respformation, and responsable_id)
@ -1225,8 +1221,8 @@ def save_note(
% (evaluation_id, etudid, authuser, value)
)
E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
Mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % M
result = {"nbchanged": 0} # JSON
# Check access: admin, respformation, or responsable_id

11
app/scodoc/sco_tag_module.py
View File

@ -212,7 +212,7 @@ def module_tag_search(context, term, REQUEST=None):
return scu.sendJSON(REQUEST, data)
def module_tag_list(context, module_id=""):
def module_tag_list(module_id=""):
"""les noms de tags associés à ce module"""
r = ndb.SimpleDictFetch(
"""SELECT t.title
@ -225,11 +225,12 @@ def module_tag_list(context, module_id=""):
return [x["title"] for x in r]
def module_tag_set(context, module_id="", taglist=None):
def module_tag_set(module_id="", taglist=None):
"""taglist may either be:
a string with tag names separated by commas ("un;deux")
or a list of strings (["un", "deux"])
"""
context = None # #context
if not taglist:
taglist = []
elif isinstance(taglist, str):
@ -237,12 +238,12 @@ def module_tag_set(context, module_id="", taglist=None):
taglist = [t.strip() for t in taglist]
# log("module_tag_set: module_id=%s taglist=%s" % (module_id, taglist))
# Sanity check:
Mod = sco_edit_module.do_module_list(context, args={"module_id": module_id})
Mod = sco_edit_module.do_module_list(args={"module_id": module_id})
if not Mod:
raise ScoValueError("invalid module !")
newtags = set(taglist)
oldtags = set(module_tag_list(context, module_id))
oldtags = set(module_tag_list(module_id))
to_del = oldtags - newtags
to_add = newtags - oldtags
@ -267,7 +268,7 @@ def get_etud_tagged_modules(context, etudid, tagname):
nt = sco_cache.NotesTableCache.get(sem["formsemestre_id"])
modimpls = nt.get_modimpls()
for modimpl in modimpls:
tags = module_tag_list(context, module_id=modimpl["module_id"])
tags = module_tag_list(module_id=modimpl["module_id"])
if tagname in tags:
moy = nt.get_etud_mod_moy(
modimpl["moduleimpl_id"], etudid

12
app/scodoc/sco_ue_external.py
View File

@ -95,11 +95,8 @@ def external_ue_create(
formation_id = sem["formation_id"]
log("creating external UE in %s: %s" % (formsemestre_id, acronyme))
numero = sco_edit_ue.next_ue_numero(
context, formation_id, semestre_id=sem["semestre_id"]
)
numero = sco_edit_ue.next_ue_numero(formation_id, semestre_id=sem["semestre_id"])
ue_id = sco_edit_ue.do_ue_create(
context,
{
"formation_id": formation_id,
"titre": titre,
@ -112,11 +109,10 @@ def external_ue_create(
)
matiere_id = sco_edit_matiere.do_matiere_create(
context, {"ue_id": ue_id, "titre": titre or acronyme, "numero": 1}
{"ue_id": ue_id, "titre": titre or acronyme, "numero": 1}
)
module_id = sco_edit_module.do_module_create(
context,
{
"titre": "UE extérieure",
"code": acronyme,
@ -129,7 +125,6 @@ def external_ue_create(
)
moduleimpl_id = sco_moduleimpl.do_moduleimpl_create(
context,
{
"module_id": module_id,
"formsemestre_id": formsemestre_id,
@ -151,7 +146,6 @@ def external_ue_inscrit_et_note(
)
# Inscription des étudiants
sco_moduleimpl.do_moduleimpl_inscrit_etuds(
context,
moduleimpl_id,
formsemestre_id,
list(notes_etuds.keys()),
@ -188,7 +182,7 @@ def external_ue_inscrit_et_note(
def get_existing_external_ue(context, formation_id):
"la liste de toutes les UE externes définies dans cette formation"
return sco_edit_ue.do_ue_list(
context, args={"formation_id": formation_id, "is_external": True}
args={"formation_id": formation_id, "is_external": True}
)

2
app/scodoc/sco_undo_notes.py
View File

@ -147,7 +147,7 @@ def list_operations(context, evaluation_id):
def evaluation_list_operations(context, REQUEST, evaluation_id):
"""Page listing operations on evaluation"""
E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
Ops = list_operations(context, evaluation_id)

4
app/scodoc/sco_users.py
View File

@ -214,9 +214,7 @@ def list_users(
preferences=sco_preferences.SemPreferences(context),
)
return tab.make_page(
context, format=format, with_html_headers=False, REQUEST=REQUEST
)
return tab.make_page(format=format, with_html_headers=False, REQUEST=REQUEST)
def get_user_list(dept=None, with_inactives=False):

4
app/views/absences.py
View File

@ -353,7 +353,7 @@ def SignaleAbsenceGrHebdo(
[
x["etudid"]
for x in sco_moduleimpl.do_moduleimpl_inscription_list(
context, moduleimpl_id=moduleimpl_id
moduleimpl_id=moduleimpl_id
)
]
)
@ -512,7 +512,7 @@ def SignaleAbsenceGrSemestre(
[
x["etudid"]
for x in sco_moduleimpl.do_moduleimpl_inscription_list(
context, moduleimpl_id=moduleimpl_id
moduleimpl_id=moduleimpl_id
)
]
)

66
app/views/notes.py
View File

@ -394,7 +394,7 @@ def index_html(context, REQUEST=None):
"""<h2>Programmes pédagogiques</h2>
""",
]
T = sco_formations.formation_list_table(context, REQUEST=REQUEST)
T = sco_formations.formation_list_table(REQUEST=REQUEST)
H.append(T.html())
@ -437,7 +437,7 @@ sco_publish(
@scodoc
@permission_required(Permission.ScoView)
@scodoc7func(context)
def formation_list(context, format=None, REQUEST=None, formation_id=None, args={}):
def formation_list(format=None, REQUEST=None, formation_id=None, args={}):
"""List formation(s) with given id, or matching args
(when args is given, formation_id is ignored).
"""
@ -454,7 +454,7 @@ def formation_export(
):
"Export de la formation au format indiqué (xml ou json)"
return sco_formations.formation_export(
context, formation_id, export_ids=export_ids, format=format, REQUEST=REQUEST
formation_id, export_ids=export_ids, format=format, REQUEST=REQUEST
)
@ -462,11 +462,11 @@ def formation_export(
@scodoc
@permission_required(Permission.ScoChangeFormation)
@scodoc7func(context)
def formation_import_xml(context, file):
def formation_import_xml(file):
"import d'une formation en XML"
log("formation_import_xml")
doc = file.read()
return sco_formations.formation_import_xml(context, doc)
return sco_formations.formation_import_xml(doc)
@bp.route("/formation_import_xml_form", methods=["GET", "POST"])
@ -681,7 +681,7 @@ def formsemestre_custommenu_edit(context, REQUEST, formsemestre_id):
@scodoc7func(context)
def edit_enseignants_form(context, REQUEST, moduleimpl_id):
"modif liste enseignants/moduleimpl"
M, sem = sco_moduleimpl.can_change_ens(context, REQUEST, moduleimpl_id)
M, sem = sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id)
# --
header = html_sco_header.html_sem_header(
context,
@ -778,7 +778,7 @@ def edit_enseignants_form(context, REQUEST, moduleimpl_id):
)
else:
sco_moduleimpl.do_ens_create(
context, {"moduleimpl_id": moduleimpl_id, "ens_id": ens_id}
{"moduleimpl_id": moduleimpl_id, "ens_id": ens_id}
)
return flask.redirect(
"edit_enseignants_form?moduleimpl_id=%s" % moduleimpl_id
@ -794,7 +794,7 @@ def edit_moduleimpl_resp(context, REQUEST, moduleimpl_id):
"""Changement d'un enseignant responsable de module
Accessible par Admin et dir des etud si flag resp_can_change_ens
"""
M, sem = sco_moduleimpl.can_change_module_resp(context, REQUEST, moduleimpl_id)
M, sem = sco_moduleimpl.can_change_module_resp(REQUEST, moduleimpl_id)
H = [
html_sco_header.html_sem_header(
context,
@ -861,7 +861,6 @@ def edit_moduleimpl_resp(context, REQUEST, moduleimpl_id):
): # presque impossible: tf verifie les valeurs (mais qui peuvent changer entre temps)
return flask.redirect("moduleimpl_status?moduleimpl_id=" + moduleimpl_id)
sco_moduleimpl.do_moduleimpl_edit(
context,
{"moduleimpl_id": moduleimpl_id, "responsable_id": responsable_id},
formsemestre_id=sem["formsemestre_id"],
)
@ -902,7 +901,7 @@ def edit_moduleimpl_expr(context, REQUEST, moduleimpl_id):
"""Edition formule calcul moyenne module
Accessible par Admin, dir des etud et responsable module
"""
M, sem = sco_moduleimpl.can_change_ens(context, REQUEST, moduleimpl_id)
M, sem = sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id)
H = [
html_sco_header.html_sem_header(
context,
@ -946,7 +945,6 @@ def edit_moduleimpl_expr(context, REQUEST, moduleimpl_id):
return flask.redirect("moduleimpl_status?moduleimpl_id=" + moduleimpl_id)
else:
sco_moduleimpl.do_moduleimpl_edit(
context,
{
"moduleimpl_id": moduleimpl_id,
"computation_expr": tf[2]["computation_expr"],
@ -969,13 +967,11 @@ def edit_moduleimpl_expr(context, REQUEST, moduleimpl_id):
@scodoc7func(context)
def view_module_abs(context, REQUEST, moduleimpl_id, format="html"):
"""Visualisation des absences a un module"""
M = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=moduleimpl_id
)[0]
M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=moduleimpl_id)[0]
sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
debut_sem = ndb.DateDMYtoISO(sem["date_debut"])
fin_sem = ndb.DateDMYtoISO(sem["date_fin"])
list_insc = sco_moduleimpl.do_moduleimpl_listeetuds(context, moduleimpl_id)
list_insc = sco_moduleimpl.do_moduleimpl_listeetuds(moduleimpl_id)
T = []
for etudid in list_insc:
@ -1051,12 +1047,12 @@ def view_module_abs(context, REQUEST, moduleimpl_id, format="html"):
def edit_ue_expr(context, REQUEST, formsemestre_id, ue_id):
"""Edition formule calcul moyenne UE"""
# Check access
sem = sco_formsemestre_edit.can_edit_sem(context, REQUEST, formsemestre_id)
sem = sco_formsemestre_edit.can_edit_sem(REQUEST, formsemestre_id)
if not sem:
raise AccessDenied("vous n'avez pas le droit d'effectuer cette opération")
cnx = ndb.GetDBConnexion()
#
ue = sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
ue = sco_edit_ue.do_ue_list({"ue_id": ue_id})[0]
H = [
html_sco_header.html_sem_header(
context,
@ -1129,9 +1125,7 @@ def formsemestre_enseignants_list(context, REQUEST, formsemestre_id, format="htm
"""
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
# resp. de modules:
mods = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=formsemestre_id
)
mods = sco_moduleimpl.do_moduleimpl_withmodule_list(formsemestre_id=formsemestre_id)
sem_ens = {}
for mod in mods:
if not mod["responsable_id"] in sem_ens:
@ -1210,7 +1204,7 @@ def formsemestre_enseignants_list(context, REQUEST, formsemestre_id, format="htm
preferences=sco_preferences.SemPreferences(formsemestre_id),
)
return T.make_page(
context, page_title=title, title=title, REQUEST=REQUEST, format=format
page_title=title, title=title, REQUEST=REQUEST, format=format
)
@ -1223,7 +1217,7 @@ def edit_enseignants_form_delete(context, REQUEST, moduleimpl_id, ens_id: int):
ens_id: user.id
"""
M, _ = sco_moduleimpl.can_change_ens(context, REQUEST, moduleimpl_id)
M, _ = sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id)
# search ens_id
ok = False
for ens in M["ens"]:
@ -1268,7 +1262,7 @@ sco_publish(
@permission_required(Permission.ScoView)
@scodoc7func(context)
def do_formsemestre_inscription_listinscrits(
context, formsemestre_id, format=None, REQUEST=None
formsemestre_id, format=None, REQUEST=None
):
"""Liste les inscrits (état I) à ce semestre et cache le résultat"""
r = sco_formsemestre_inscriptions.do_formsemestre_inscription_listinscrits(
@ -1454,8 +1448,8 @@ def evaluation_delete(context, REQUEST, evaluation_id):
if not El:
raise ValueError("Evalution inexistante ! (%s)" % evaluation_id)
E = El[0]
M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
tit = "Suppression de l'évaluation %(description)s (%(jour)s)" % E
etat = sco_evaluations.do_evaluation_etat(evaluation_id)
H = [
@ -2378,18 +2372,14 @@ def check_sem_integrity(context, formsemestre_id, REQUEST, fix=False):
"""
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
modimpls = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=formsemestre_id
)
modimpls = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
bad_ue = []
bad_sem = []
formations_set = set() # les formations mentionnées dans les UE et modules
for modimpl in modimpls:
mod = sco_edit_module.do_module_list(
context, {"module_id": modimpl["module_id"]}
)[0]
mod = sco_edit_module.do_module_list({"module_id": modimpl["module_id"]})[0]
formations_set.add(mod["formation_id"])
ue = sco_edit_ue.do_ue_list(context, {"ue_id": mod["ue_id"]})[0]
ue = sco_edit_ue.do_ue_list({"ue_id": mod["ue_id"]})[0]
formations_set.add(ue["formation_id"])
if ue["formation_id"] != mod["formation_id"]:
modimpl["mod"] = mod
@ -2448,14 +2438,12 @@ def check_sem_integrity(context, formsemestre_id, REQUEST, fix=False):
def check_form_integrity(context, formation_id, fix=False, REQUEST=None):
"debug"
log("check_form_integrity: formation_id=%s fix=%s" % (formation_id, fix))
ues = sco_edit_ue.do_ue_list(context, args={"formation_id": formation_id})
ues = sco_edit_ue.do_ue_list(args={"formation_id": formation_id})
bad = []
for ue in ues:
mats = sco_edit_matiere.do_matiere_list(context, args={"ue_id": ue["ue_id"]})
mats = sco_edit_matiere.do_matiere_list(args={"ue_id": ue["ue_id"]})
for mat in mats:
mods = sco_edit_module.do_module_list(
context, {"matiere_id": mat["matiere_id"]}
)
mods = sco_edit_module.do_module_list({"matiere_id": mat["matiere_id"]})
for mod in mods:
if mod["ue_id"] != ue["ue_id"]:
if fix:
@ -2464,7 +2452,7 @@ def check_form_integrity(context, formation_id, fix=False, REQUEST=None):
"fix: mod.ue_id = %s (was %s)" % (ue["ue_id"], mod["ue_id"])
)
mod["ue_id"] = ue["ue_id"]
sco_edit_module.do_module_edit(context, mod)
sco_edit_module.do_module_edit(mod)
bad.append(mod)
if mod["formation_id"] != formation_id:
bad.append(mod)
@ -2495,7 +2483,7 @@ def check_formsemestre_integrity(context, formsemestre_id, REQUEST=None):
diag = []
Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=formsemestre_id
formsemestre_id=formsemestre_id
)
for mod in Mlist:
if mod["module"]["ue_id"] != mod["matiere"]["ue_id"]:

6
scotests/test_api7doc.py
View File

@ -20,7 +20,7 @@ file.close()
# --- Création de la formation
f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
f = sco_formations.formation_import_xml(doc=doc)
# --- Création des semestres
@ -222,9 +222,7 @@ load_lif = json.loads(lif)
assert len(load_lif) == 1
assert load_lif[0]["formation_id"] == f[0]
exp = sco_formations.formation_export(
context.Notes, formation_id=f[0], format="json", REQUEST=REQUEST
)
exp = sco_formations.formation_export(formation_id=f[0], format="json", REQUEST=REQUEST)
load_exp = json.loads(exp)
assert load_exp["acronyme"] == "DUT Info"
assert load_exp["titre_officiel"] == "DUT Informatique"

3
scotests/test_bonusmalus.py
View File

@ -48,8 +48,7 @@ sem, eval_list = G.setup_formsemestre(
)
# --- Recupère le module de malus
modimpls = sco_moduleimpl.do_moduleimpl_list(
context, # pylint: disable=undefined-variable
modimpls = sco_moduleimpl.do_moduleimpl_list( # pylint: disable=undefined-variable
formsemestre_id=sem["formsemestre_id"],
)
# de façon tout à fait inefficace ;-)

4
scotests/test_formation_export_xml.py
View File

@ -19,7 +19,7 @@ print(doc)
print("\n \n \n")
# --- Création de la formation
f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
f = sco_formations.formation_import_xml(doc=doc)
# --- Création des semestres
@ -76,7 +76,7 @@ for mod in li_module:
# --- Test de export_formation format xml
form_exp = context.Notes.formation_export(
form_exp = sco_formations.formation_export(
formation_id=f[0], format="xml", REQUEST=REQUEST
)
print(form_exp[39:])

2
scotests/test_scenario2_formation.py
View File

@ -18,7 +18,7 @@ file.close()
# --- Création de la formation
f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
f = sco_formations.formation_import_xml(doc=doc)
# --- Création des semestres

2
scotests/test_scenario3_formation.py
View File

@ -19,7 +19,7 @@ file.close()
# --- Création de la formation
f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
f = sco_formations.formation_import_xml(doc=doc)
# --- Création des semestres

2
scotests/test_scenario4_formation.py
View File

@ -19,7 +19,7 @@ file.close()
# --- Création de la formation
f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
f = sco_formations.formation_import_xml(doc=doc)
# --- Création des semestres

4
tests/scenarios/test_scenario1_formation.py
View File

@ -33,7 +33,7 @@ def run_scenario1():
doc = f.read()
# --- Création de la formation
f = sco_formations.formation_import_xml(doc=doc, context=context)
f = sco_formations.formation_import_xml(doc=doc)
# --- Création des semestres
formation_id = f[0]
@ -54,7 +54,7 @@ def run_scenario1():
]
# --- Implémentation des modules
modules = sco_edit_module.do_module_list(context, {"formation_id": formation_id})
modules = sco_edit_module.do_module_list({"formation_id": formation_id})
mods_imp = []
for mod in modules:
mi = G.create_moduleimpl(

22
tests/unit/sco_fake_gen.py
View File

@ -153,7 +153,7 @@ class ScoFake(object):
"""Crée une formation"""
if not acronyme:
acronyme = "TEST" + str(random.randint(100000, 999999))
oid = sco_edit_formation.do_formation_create(context, locals())
oid = sco_edit_formation.do_formation_create(locals())
oids = sco_formations.formation_list(formation_id=oid)
if not oids:
raise ScoValueError("formation not created !")
@ -175,17 +175,17 @@ class ScoFake(object):
):
"""Crée une UE"""
if numero is None:
numero = sco_edit_ue.next_ue_numero(context, formation_id, 0)
oid = sco_edit_ue.do_ue_create(context, locals())
oids = sco_edit_ue.do_ue_list(context, args={"ue_id": oid})
numero = sco_edit_ue.next_ue_numero(formation_id, 0)
oid = sco_edit_ue.do_ue_create(locals())
oids = sco_edit_ue.do_ue_list(args={"ue_id": oid})
if not oids:
raise ScoValueError("ue not created !")
return oids[0]
@logging_meth
def create_matiere(self, ue_id=None, titre=None, numero=None):
oid = sco_edit_matiere.do_matiere_create(context, locals())
oids = sco_edit_matiere.do_matiere_list(context, args={"matiere_id": oid})
oid = sco_edit_matiere.do_matiere_create(locals())
oids = sco_edit_matiere.do_matiere_list(args={"matiere_id": oid})
if not oids:
raise ScoValueError("matiere not created !")
return oids[0]
@ -209,8 +209,8 @@ class ScoFake(object):
code_apogee=None,
module_type=None,
):
oid = sco_edit_module.do_module_create(context, locals())
oids = sco_edit_module.do_module_list(context, args={"module_id": oid})
oid = sco_edit_module.do_module_create(locals())
oids = sco_edit_module.do_module_list(args={"module_id": oid})
if not oids:
raise ScoValueError("module not created ! (oid=%s)" % oid)
return oids[0]
@ -256,10 +256,8 @@ class ScoFake(object):
):
if not responsable_id:
responsable_id = self.default_user.id
oid = sco_moduleimpl.do_moduleimpl_create(context, locals())
oids = sco_moduleimpl.do_moduleimpl_list(
context, moduleimpl_id=oid
) # API inconsistency
oid = sco_moduleimpl.do_moduleimpl_create(locals())
oids = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=oid) # API inconsistency
if not oids:
raise ScoValueError("moduleimpl not created !")
return oids[0]

2
tests/unit/test_caches.py
View File

@ -54,7 +54,7 @@ def test_cache_evaluations(test_client):
# prépare le département avec quelques semestres:
run_sco_basic()
#
sems = sco_formsemestre.do_formsemestre_list(None)
sems = sco_formsemestre.do_formsemestre_list()
assert len(sems)
sem_evals = []
for sem in sems:

12
tests/unit/test_departements.py
View File

@ -16,6 +16,8 @@ from app.scodoc import sco_formsemestre
from app.scodoc import sco_preferences
from tests.unit import test_sco_basic
context = None # #context
def test_preferences_orm(test_client):
"""preferences, via ORM and legacy ScoDoc"""
@ -59,7 +61,7 @@ def test_preferences(test_client):
.value
)
# Compare valeurs
sco_val = prefs.get(None, "abs_notification_mail_tmpl")
sco_val = prefs.get(context, "abs_notification_mail_tmpl")
assert orm_val.strip() == sco_val.strip()
# nb: I don't understand why SQLAlchemy strips the string ?!
@ -71,9 +73,9 @@ def test_preferences(test_client):
app.set_sco_dept("D2")
prefs2 = sco_preferences.get_base_preferences()
assert len(prefs2) == len(prefs)
prefs2.set(None, "abs_notification_mail_tmpl", "toto")
assert prefs2.get(None, "abs_notification_mail_tmpl") == "toto"
assert prefs.get(None, "abs_notification_mail_tmpl") != "toto"
prefs2.set(context, "abs_notification_mail_tmpl", "toto")
assert prefs2.get(context, "abs_notification_mail_tmpl") == "toto"
assert prefs.get(context, "abs_notification_mail_tmpl") != "toto"
orm_val = (
ScoPreference.query.filter_by(dept_id=d.id, name="abs_notification_mail_tmpl")
.first()
@ -83,7 +85,7 @@ def test_preferences(test_client):
# --- Preferences d'un semestre
# rejoure ce test pour avoir un semestre créé
test_sco_basic.run_sco_basic()
sem = sco_formsemestre.do_formsemestre_list(None)[0]
sem = sco_formsemestre.do_formsemestre_list()[0]
formsemestre_id = sem["formsemestre_id"]
semp = sco_preferences.SemPreferences(formsemestre_id=formsemestre_id)
assert semp["abs_notification_mail_tmpl"] == "toto"

2
tests/unit/test_export_xml.py
View File

@ -98,7 +98,7 @@ def test_export_xml(test_client):
# test du sendXML compatible ScoDoc7
etuds = [{"x": 1, "etuds": ["allo", "mama"]}, {"x": 2, "etuds": ["un", "deux"]}]
# Le résultat de l'ancien print(sendXML(None, etuds, tagname="etudiants"))
# Le résultat de l'ancien print(sendXML(etuds, tagname="etudiants"))
expected_result = """
<?xml version="1.0" encoding="utf-8"?>
<etudiants_list>

56
tests/unit/test_formations.py
View File

@ -164,7 +164,7 @@ def test_formations(test_client):
# --- Afficher la liste des formations
lif = notes.formation_list(context, format="json", formation_id=f["formation_id"])
lif = notes.formation_list(format="json", formation_id=f["formation_id"])
# lif est une Response car on a appelé une vue (1er appel)
assert isinstance(lif, flask.Response)
load_lif = json.loads(lif.get_data().decode("utf-8"))
@ -174,7 +174,7 @@ def test_formations(test_client):
assert load_lif[0]["formation_id"] == f["formation_id"]
assert load_lif[0]["titre"] == f["titre"]
lif2 = notes.formation_list(context, format="json")
lif2 = notes.formation_list(format="json")
# lif2 est un chaine
assert isinstance(lif2, str)
load_lif2 = json.loads(lif2)
@ -184,9 +184,7 @@ def test_formations(test_client):
# --- Export de formation_id
exp = sco_formations.formation_export(
context, formation_id=f["formation_id"], format="json"
)
exp = sco_formations.formation_export(formation_id=f["formation_id"], format="json")
assert isinstance(exp, str)
load_exp = json.loads(exp)
@ -235,19 +233,19 @@ def test_formations(test_client):
# --- Liste des modules
lim_sem1 = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=sem1["formsemestre_id"]
formsemestre_id=sem1["formsemestre_id"]
)
assert len(lim_sem1) == 2
assert mod["module_id"] in (lim_sem1[0]["module_id"], lim_sem1[1]["module_id"])
assert mod2["module_id"] in (lim_sem1[0]["module_id"], lim_sem1[1]["module_id"])
lim_modid = sco_moduleimpl.do_moduleimpl_list(context, module_id=mod["module_id"])
lim_modid = sco_moduleimpl.do_moduleimpl_list(module_id=mod["module_id"])
assert len(lim_modid) == 1
lim_modimpl_id = sco_moduleimpl.do_moduleimpl_list(
context, moduleimpl_id=mi["moduleimpl_id"]
moduleimpl_id=mi["moduleimpl_id"]
)
# print(lim_modimpl_id)
@ -256,7 +254,7 @@ def test_formations(test_client):
assert lim_modid == lim_modimpl_id # doit etre le meme resultat
liimp_sem1 = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=sem1["formsemestre_id"]
formsemestre_id=sem1["formsemestre_id"]
)
assert len(liimp_sem1) == 2
@ -266,16 +264,16 @@ def test_formations(test_client):
liimp_sem1[1]["module_id"],
)
liimp_sem2 = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, formsemestre_id=sem2["formsemestre_id"]
formsemestre_id=sem2["formsemestre_id"]
)
assert modt["module_id"] == liimp_sem2[0]["module_id"]
liimp_modid = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, module_id=mod["module_id"]
module_id=mod["module_id"]
)
assert len(liimp_modid) == 1
liimp_modimplid = sco_moduleimpl.do_moduleimpl_withmodule_list(
context, moduleimpl_id=mi["moduleimpl_id"]
moduleimpl_id=mi["moduleimpl_id"]
)
assert liimp_modid == liimp_modimplid
@ -299,35 +297,31 @@ def test_formations(test_client):
# RIEN NE SE PASSE AVEC CES FONCTIONS
li_module = sco_edit_module.do_module_list(context)
li_module = sco_edit_module.do_module_list()
assert len(li_module) == 4
sco_edit_module.do_module_delete(
context, oid=modt["module_id"]
) # on supprime le semestre
sco_edit_module.do_module_delete(oid=modt["module_id"]) # on supprime le semestre
# sco_formsemestre_edit.formsemestre_delete_moduleimpls(context.Notes, formsemestre_id=sem2["formsemestre_id"], module_ids_to_del=[modt["module_id"]])
# deuxieme methode de supression d'un module
li_module2 = sco_edit_module.do_module_list(context)
li_module2 = sco_edit_module.do_module_list()
assert len(li_module2) == 3 # verification de la suppression du module
lim_sem2 = sco_moduleimpl.do_moduleimpl_list(
context, formsemestre_id=sem2["formsemestre_id"]
formsemestre_id=sem2["formsemestre_id"]
)
assert len(lim_sem2) == 0 # deuxieme vérification si le module s'est bien sup
li_mat = sco_edit_matiere.do_matiere_list(context)
li_mat = sco_edit_matiere.do_matiere_list()
assert len(li_mat) == 4
sco_edit_matiere.do_matiere_delete(
context, oid=matt["matiere_id"]
) # on supprime la matiere
li_mat2 = sco_edit_matiere.do_matiere_list(context)
sco_edit_matiere.do_matiere_delete(oid=matt["matiere_id"]) # on supprime la matiere
li_mat2 = sco_edit_matiere.do_matiere_list()
assert len(li_mat2) == 3 # verification de la suppression de la matiere
li_ue = sco_edit_ue.do_ue_list(context)
li_ue = sco_edit_ue.do_ue_list()
assert len(li_ue) == 4
sco_edit_ue.ue_delete(context, ue_id=uet["ue_id"], dialog_confirmed=True)
li_ue2 = sco_edit_ue.do_ue_list(context)
sco_edit_ue.ue_delete(ue_id=uet["ue_id"], dialog_confirmed=True)
li_ue2 = sco_edit_ue.do_ue_list()
assert len(li_ue2) == 3 # verification de la suppression de l'UE
# --- Suppression d'une formation
@ -336,8 +330,8 @@ def test_formations(test_client):
context, formsemestre_id=semt["formsemestre_id"]
)
sco_edit_formation.do_formation_delete(context, oid=f2["formation_id"])
lif3 = notes.formation_list(context, format="json")
sco_edit_formation.do_formation_delete(oid=f2["formation_id"])
lif3 = notes.formation_list(format="json")
assert isinstance(lif3, str)
load_lif3 = json.loads(lif3)
assert len(load_lif3) == 1
@ -351,7 +345,7 @@ def test_import_formation(test_client):
doc = f.read()
# --- Création de la formation
f = sco_formations.formation_import_xml(context, doc)
f = sco_formations.formation_import_xml(doc)
assert len(f) == 3 # 3-uple
formation_id = f[0]
# --- Mise en place de 4 semestres
@ -370,7 +364,7 @@ def test_import_formation(test_client):
)
]
# et les modules
modules = sco_edit_module.do_module_list(context, {"formation_id": formation_id})
modules = sco_edit_module.do_module_list({"formation_id": formation_id})
for mod in modules:
mi = G.create_moduleimpl(
module_id=mod["module_id"],
@ -380,5 +374,5 @@ def test_import_formation(test_client):
assert mi["module_id"] == mod["module_id"]
# --- Export formation en XML
doc1 = sco_formations.formation_export(context, formation_id, format="xml")
doc1 = sco_formations.formation_export(formation_id, format="xml")
assert isinstance(doc1, str)