forked from ScoDoc/ScoDoc
910 lines
29 KiB
Python
910 lines
29 KiB
Python
# -*- mode: python -*-
|
|
# -*- coding: utf-8 -*-
|
|
|
|
##############################################################################
|
|
#
|
|
# Gestion scolarite IUT
|
|
#
|
|
# Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
#
|
|
# Emmanuel Viennet emmanuel.viennet@viennet.net
|
|
#
|
|
##############################################################################
|
|
|
|
"""Ajout/Modification/Suppression modules
|
|
(portage from DTML)
|
|
"""
|
|
import flask
|
|
from flask import url_for, render_template
|
|
from flask import g, request
|
|
from flask_login import current_user
|
|
|
|
from app import log
|
|
from app import models
|
|
from app.models import APO_CODE_STR_LEN
|
|
from app.models import Formation, Matiere, Module, UniteEns
|
|
from app.models import FormSemestre, ModuleImpl
|
|
|
|
import app.scodoc.notesdb as ndb
|
|
import app.scodoc.sco_utils as scu
|
|
from app.scodoc.TrivialFormulator import TrivialFormulator
|
|
from app.scodoc.sco_permissions import Permission
|
|
from app.scodoc.sco_exceptions import (
|
|
ScoValueError,
|
|
ScoLockedFormError,
|
|
ScoGenError,
|
|
ScoNonEmptyFormationObject,
|
|
)
|
|
from app.scodoc import html_sco_header
|
|
from app.scodoc import sco_codes_parcours
|
|
from app.scodoc import sco_edit_matiere
|
|
from app.scodoc import sco_moduleimpl
|
|
from app.scodoc import sco_news
|
|
|
|
_moduleEditor = ndb.EditableTable(
|
|
"notes_modules",
|
|
"module_id",
|
|
(
|
|
"module_id",
|
|
"titre",
|
|
"code",
|
|
"abbrev",
|
|
"heures_cours",
|
|
"heures_td",
|
|
"heures_tp",
|
|
"coefficient",
|
|
"ue_id",
|
|
"matiere_id",
|
|
"formation_id",
|
|
"semestre_id",
|
|
"numero",
|
|
"code_apogee",
|
|
"module_type"
|
|
#'ects'
|
|
),
|
|
sortkey="numero, code, titre",
|
|
output_formators={
|
|
"heures_cours": ndb.float_null_is_zero,
|
|
"heures_td": ndb.float_null_is_zero,
|
|
"heures_tp": ndb.float_null_is_zero,
|
|
"numero": ndb.int_null_is_zero,
|
|
"coefficient": ndb.float_null_is_zero,
|
|
"module_type": ndb.int_null_is_zero
|
|
#'ects' : ndb.float_null_is_null
|
|
},
|
|
)
|
|
|
|
|
|
def module_list(*args, **kw):
|
|
"list modules"
|
|
cnx = ndb.GetDBConnexion()
|
|
return _moduleEditor.list(cnx, *args, **kw)
|
|
|
|
|
|
def do_module_create(args) -> int:
|
|
"Create a module. Returns id of new object."
|
|
# create
|
|
from app.scodoc import sco_formations
|
|
|
|
cnx = ndb.GetDBConnexion()
|
|
r = _moduleEditor.create(cnx, args)
|
|
|
|
# news
|
|
formation = Formation.query.get(args["formation_id"])
|
|
sco_news.add(
|
|
typ=sco_news.NEWS_FORM,
|
|
object=formation.id,
|
|
text=f"Modification de la formation {formation.acronyme}",
|
|
max_frequency=3,
|
|
)
|
|
formation.invalidate_cached_sems()
|
|
return r
|
|
|
|
|
|
def module_create(
|
|
matiere_id=None, module_type=None, semestre_id=None, formation_id=None
|
|
):
|
|
"""Formulaire de création d'un module
|
|
Si matiere_id est spécifié, le module sera créé dans cette matière (cas normal).
|
|
Sinon, donne le choix de l'UE de rattachement et utilise la première
|
|
matière de cette UE (si elle n'existe pas, la crée).
|
|
"""
|
|
if matiere_id:
|
|
matiere = Matiere.query.get_or_404(matiere_id)
|
|
ue = matiere.ue
|
|
formation = ue.formation
|
|
else:
|
|
formation = Formation.query.get_or_404(formation_id)
|
|
parcours = formation.get_parcours()
|
|
is_apc = parcours.APC_SAE
|
|
ues = formation.ues.order_by(
|
|
UniteEns.semestre_idx, UniteEns.numero, UniteEns.acronyme
|
|
).all()
|
|
# cherche le numero adéquat (pour placer le module en fin de liste)
|
|
modules = formation.modules.all()
|
|
if modules:
|
|
default_num = max([m.numero or 0 for m in modules]) + 10
|
|
else:
|
|
default_num = 10
|
|
|
|
if is_apc and module_type is not None:
|
|
object_name = scu.MODULE_TYPE_NAMES[module_type]
|
|
else:
|
|
object_name = "Module"
|
|
H = [
|
|
html_sco_header.sco_header(page_title=f"Création {object_name}"),
|
|
]
|
|
if not matiere_id:
|
|
H += [
|
|
f"""<h2>Création {object_name} dans la formation {formation.acronyme}
|
|
</h2>
|
|
"""
|
|
]
|
|
else:
|
|
H += [
|
|
f"""<h2>Création {object_name} dans la matière {matiere.titre},
|
|
(UE {ue.acronyme}), semestre {ue.semestre_idx}</h2>
|
|
"""
|
|
]
|
|
|
|
H += [
|
|
render_template(
|
|
"scodoc/help/modules.html",
|
|
is_apc=is_apc,
|
|
semestre_id=semestre_id,
|
|
)
|
|
]
|
|
|
|
descr = [
|
|
(
|
|
"code",
|
|
{
|
|
"size": 10,
|
|
"explanation": "code du module, ressource ou SAÉ. Exemple M1203, R2.01, ou SAÉ 3.4. Ce code doit être unique dans la formation.",
|
|
"allow_null": False,
|
|
"validator": lambda val, field, formation_id=formation_id: check_module_code_unicity(
|
|
val, field, formation_id
|
|
),
|
|
},
|
|
),
|
|
(
|
|
"titre",
|
|
{
|
|
"size": 30,
|
|
"explanation": "nom du module. Exemple: <em>Introduction à la démarche ergonomique</em>",
|
|
},
|
|
),
|
|
(
|
|
"abbrev",
|
|
{
|
|
"size": 20,
|
|
"explanation": "nom abrégé (pour les bulletins). Exemple: <em>Intro. à l'ergonomie</em>",
|
|
},
|
|
),
|
|
]
|
|
|
|
if is_apc:
|
|
module_types = scu.ModuleType # tous les types
|
|
else:
|
|
# ne propose pas SAE et Ressources:
|
|
module_types = set(scu.ModuleType) - {
|
|
scu.ModuleType.RESSOURCE,
|
|
scu.ModuleType.SAE,
|
|
}
|
|
|
|
descr += [
|
|
(
|
|
"module_type",
|
|
{
|
|
"input_type": "menu",
|
|
"title": "Type",
|
|
"explanation": "",
|
|
"labels": [x.name.capitalize() for x in module_types],
|
|
"allowed_values": [str(int(x)) for x in module_types],
|
|
},
|
|
),
|
|
(
|
|
"heures_cours",
|
|
{
|
|
"title": "Heures de cours",
|
|
"size": 4,
|
|
"type": "float",
|
|
"explanation": "nombre d'heures de cours (optionnel)",
|
|
},
|
|
),
|
|
(
|
|
"heures_td",
|
|
{
|
|
"title": "Heures de TD",
|
|
"size": 4,
|
|
"type": "float",
|
|
"explanation": "nombre d'heures de Travaux Dirigés (optionnel)",
|
|
},
|
|
),
|
|
(
|
|
"heures_tp",
|
|
{
|
|
"title": "Heures de TP",
|
|
"size": 4,
|
|
"type": "float",
|
|
"explanation": "nombre d'heures de Travaux Pratiques (optionnel)",
|
|
},
|
|
),
|
|
]
|
|
if is_apc:
|
|
descr += [
|
|
(
|
|
"sep_ue_coefs",
|
|
{
|
|
"input_type": "separator",
|
|
"title": """
|
|
<div>(<em>les coefficients vers les UE se fixent sur la page dédiée</em>)
|
|
</div>""",
|
|
},
|
|
),
|
|
]
|
|
else:
|
|
descr += [
|
|
(
|
|
"coefficient",
|
|
{
|
|
"size": 4,
|
|
"type": "float",
|
|
"explanation": "coefficient dans la formation (PPN)",
|
|
"allow_null": False,
|
|
},
|
|
),
|
|
]
|
|
|
|
if matiere_id:
|
|
descr += [
|
|
("ue_id", {"default": ue.id, "input_type": "hidden"}),
|
|
("matiere_id", {"default": matiere_id, "input_type": "hidden"}),
|
|
]
|
|
else:
|
|
# choix de l'UE de rattachement
|
|
descr += [
|
|
(
|
|
"ue_id",
|
|
{
|
|
"input_type": "menu",
|
|
"type": "int",
|
|
"title": "UE de rattachement",
|
|
"explanation": "utilisée notamment pour les malus",
|
|
"labels": [
|
|
f"S{u.semestre_idx if u.semestre_idx is not None else '.'} / {u.acronyme} {u.titre}"
|
|
for u in ues
|
|
],
|
|
"allowed_values": [u.id for u in ues],
|
|
},
|
|
),
|
|
]
|
|
|
|
descr += [
|
|
# ('ects', { 'size' : 4, 'type' : 'float', 'title' : 'ECTS', 'explanation' : 'nombre de crédits ECTS (inutilisés: les crédits sont associés aux UE)' }),
|
|
("formation_id", {"default": formation.id, "input_type": "hidden"}),
|
|
(
|
|
"code_apogee",
|
|
{
|
|
"title": "Code Apogée",
|
|
"size": 25,
|
|
"explanation": "(optionnel) code élément pédagogique Apogée ou liste de codes ELP séparés par des virgules",
|
|
"validator": lambda val, _: len(val) < APO_CODE_STR_LEN,
|
|
},
|
|
),
|
|
(
|
|
"numero",
|
|
{
|
|
"size": 2,
|
|
"explanation": "numéro (1,2,3,4...) pour ordre d'affichage",
|
|
"type": "int",
|
|
"default": default_num,
|
|
},
|
|
),
|
|
]
|
|
args = scu.get_request_args()
|
|
tf = TrivialFormulator(
|
|
request.base_url,
|
|
args,
|
|
descr,
|
|
submitlabel="Créer ce module",
|
|
)
|
|
if tf[0] == 0:
|
|
return "\n".join(H) + tf[1] + html_sco_header.sco_footer()
|
|
else:
|
|
if not matiere_id:
|
|
# formulaire avec choix UE de rattachement
|
|
ue = UniteEns.query.get(tf[2]["ue_id"])
|
|
if ue is None:
|
|
raise ValueError("UE invalide")
|
|
matiere = ue.matieres.first()
|
|
if matiere:
|
|
tf[2]["matiere_id"] = matiere.id
|
|
else:
|
|
matiere_id = sco_edit_matiere.do_matiere_create(
|
|
{"ue_id": ue.id, "titre": ue.titre, "numero": 1},
|
|
)
|
|
tf[2]["matiere_id"] = matiere_id
|
|
|
|
tf[2]["semestre_id"] = ue.semestre_idx
|
|
|
|
_ = do_module_create(tf[2])
|
|
|
|
return flask.redirect(
|
|
url_for(
|
|
"notes.ue_table",
|
|
scodoc_dept=g.scodoc_dept,
|
|
formation_id=formation.id,
|
|
semestre_idx=tf[2]["semestre_id"],
|
|
)
|
|
)
|
|
|
|
|
|
def can_delete_module(module):
|
|
"True si le module n'est pas utilisée dans des formsemestre"
|
|
return len(module.modimpls.all()) == 0
|
|
|
|
|
|
def do_module_delete(oid):
|
|
"delete module"
|
|
from app.scodoc import sco_formations
|
|
|
|
module = Module.query.get_or_404(oid)
|
|
mod = module_list({"module_id": oid})[0] # sco7
|
|
if module_is_locked(module.id):
|
|
raise ScoLockedFormError()
|
|
if not can_delete_module(module):
|
|
raise ScoNonEmptyFormationObject(
|
|
"Module",
|
|
msg=module.titre,
|
|
dest_url=url_for(
|
|
"notes.ue_table",
|
|
scodoc_dept=g.scodoc_dept,
|
|
formation_id=module.formation_id,
|
|
semestre_idx=module.ue.semestre_idx,
|
|
),
|
|
)
|
|
|
|
# S'il y a des moduleimpls, on ne peut pas detruire le module !
|
|
mods = sco_moduleimpl.moduleimpl_list(module_id=oid)
|
|
if mods:
|
|
err_page = f"""<h3>Destruction du module impossible car il est utilisé dans des semestres existants !</h3>
|
|
<p class="help">Il faut d'abord supprimer le semestre (ou en retirer ce module). Mais il est peut être préférable de
|
|
laisser ce programme intact et d'en créer une nouvelle version pour la modifier sans affecter les semestres déjà en place.
|
|
</p>
|
|
<a href="{url_for('notes.ue_table', scodoc_dept=g.scodoc_dept,
|
|
formation_id=mod["formation_id"])}">reprendre</a>
|
|
"""
|
|
raise ScoGenError(err_page)
|
|
# delete
|
|
cnx = ndb.GetDBConnexion()
|
|
_moduleEditor.delete(cnx, oid)
|
|
|
|
# news
|
|
formation = module.formation
|
|
sco_news.add(
|
|
typ=sco_news.NEWS_FORM,
|
|
object=mod["formation_id"],
|
|
text=f"Modification de la formation {formation.acronyme}",
|
|
max_frequency=3,
|
|
)
|
|
formation.invalidate_cached_sems()
|
|
|
|
|
|
def module_delete(module_id=None):
|
|
"""Delete a module"""
|
|
module = Module.query.get_or_404(module_id)
|
|
mod = module_list(args={"module_id": module_id})[0] # sco7
|
|
|
|
if not can_delete_module(module):
|
|
raise ScoNonEmptyFormationObject(
|
|
"Module",
|
|
msg=module.titre,
|
|
dest_url=url_for(
|
|
"notes.ue_table",
|
|
scodoc_dept=g.scodoc_dept,
|
|
formation_id=module.formation_id,
|
|
semestre_idx=module.ue.semestre_idx,
|
|
),
|
|
)
|
|
|
|
H = [
|
|
html_sco_header.sco_header(page_title="Suppression d'un module"),
|
|
"""<h2>Suppression du module %(titre)s (%(code)s)</h2>""" % mod,
|
|
]
|
|
|
|
dest_url = url_for(
|
|
"notes.ue_table",
|
|
scodoc_dept=g.scodoc_dept,
|
|
formation_id=str(mod["formation_id"]),
|
|
)
|
|
tf = TrivialFormulator(
|
|
request.base_url,
|
|
scu.get_request_args(),
|
|
(("module_id", {"input_type": "hidden"}),),
|
|
initvalues=mod,
|
|
submitlabel="Confirmer la suppression",
|
|
cancelbutton="Annuler",
|
|
)
|
|
if tf[0] == 0:
|
|
return "\n".join(H) + tf[1] + html_sco_header.sco_footer()
|
|
elif tf[0] == -1:
|
|
return flask.redirect(dest_url)
|
|
else:
|
|
do_module_delete(module_id)
|
|
return flask.redirect(dest_url)
|
|
|
|
|
|
def do_module_edit(vals: dict) -> None:
|
|
"edit a module"
|
|
# check
|
|
mod = module_list({"module_id": vals["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:
|
|
if f in vals:
|
|
del vals[f]
|
|
# edit
|
|
cnx = ndb.GetDBConnexion()
|
|
_moduleEditor.edit(cnx, vals)
|
|
Formation.query.get(mod["formation_id"]).invalidate_cached_sems()
|
|
|
|
|
|
def check_module_code_unicity(code, field, formation_id, module_id=None):
|
|
"true si code module unique dans la formation"
|
|
Mods = 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(module_id=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 !")
|
|
modules = module_list(args={"module_id": module_id})
|
|
if not modules:
|
|
raise ScoValueError("invalid module !")
|
|
module = modules[0]
|
|
a_module = models.Module.query.get(module_id)
|
|
unlocked = not module_is_locked(module_id)
|
|
formation_id = module["formation_id"]
|
|
formation = sco_formations.formation_list(args={"formation_id": formation_id})[0]
|
|
parcours = sco_codes_parcours.get_parcours_from_code(formation["type_parcours"])
|
|
is_apc = parcours.APC_SAE # BUT
|
|
in_use = len(a_module.modimpls.all()) > 0 # il y a des modimpls
|
|
matieres = Matiere.query.filter(
|
|
Matiere.ue_id == UniteEns.id, UniteEns.formation_id == formation_id
|
|
).order_by(UniteEns.semestre_idx, UniteEns.numero, Matiere.numero)
|
|
if in_use:
|
|
# restreint aux matières du même semestre
|
|
matieres = matieres.filter(UniteEns.semestre_idx == a_module.ue.semestre_idx)
|
|
|
|
if is_apc:
|
|
# ne conserve que la 1ere matière de chaque UE,
|
|
# et celle à laquelle ce module est rattaché
|
|
matieres = [
|
|
mat
|
|
for mat in matieres
|
|
if a_module.matiere.id == mat.id or mat.id == mat.ue.matieres.first().id
|
|
]
|
|
mat_names = [
|
|
"S%s / %s" % (mat.ue.semestre_idx, mat.ue.acronyme) for mat in matieres
|
|
]
|
|
else:
|
|
mat_names = ["%s / %s" % (mat.ue.acronyme, mat.titre or "") for mat in matieres]
|
|
ue_mat_ids = ["%s!%s" % (mat.ue.id, mat.id) for mat in matieres]
|
|
|
|
module["ue_matiere_id"] = "%s!%s" % (module["ue_id"], module["matiere_id"])
|
|
|
|
semestres_indices = list(range(1, parcours.NB_SEM + 1))
|
|
|
|
H = [
|
|
html_sco_header.sco_header(
|
|
page_title="Modification du module %(titre)s" % module,
|
|
cssstyles=["libjs/jQuery-tagEditor/jquery.tag-editor.css"],
|
|
javascripts=[
|
|
"libjs/jQuery-tagEditor/jquery.tag-editor.min.js",
|
|
"libjs/jQuery-tagEditor/jquery.caret.min.js",
|
|
"js/module_tag_editor.js",
|
|
],
|
|
),
|
|
"""<h2>Modification du module %(titre)s""" % module,
|
|
""" (formation %(acronyme)s, version %(version)s)</h2>""" % formation,
|
|
render_template(
|
|
"scodoc/help/modules.html",
|
|
is_apc=is_apc,
|
|
formsemestres=FormSemestre.query.filter(
|
|
ModuleImpl.formsemestre_id == FormSemestre.id,
|
|
ModuleImpl.module_id == module_id,
|
|
)
|
|
.order_by(FormSemestre.date_debut)
|
|
.all(),
|
|
),
|
|
]
|
|
if not unlocked:
|
|
H.append(
|
|
"""<div class="ue_warning"><span>Formation verrouillée, seuls certains éléments peuvent être modifiés</span></div>"""
|
|
)
|
|
if is_apc:
|
|
module_types = scu.ModuleType # tous les types
|
|
else:
|
|
# ne propose pas SAE et Ressources, sauf si déjà de ce type...
|
|
module_types = (
|
|
set(scu.ModuleType) - {scu.ModuleType.RESSOURCE, scu.ModuleType.SAE}
|
|
) | {a_module.module_type or scu.ModuleType.STANDARD}
|
|
|
|
descr = [
|
|
(
|
|
"code",
|
|
{
|
|
"size": 10,
|
|
"explanation": "code du module (doit être unique dans la formation)",
|
|
"allow_null": False,
|
|
"validator": lambda val, field, formation_id=formation_id: check_module_code_unicity(
|
|
val, field, formation_id, module_id=module_id
|
|
),
|
|
},
|
|
),
|
|
("titre", {"size": 30, "explanation": "nom du module"}),
|
|
("abbrev", {"size": 20, "explanation": "nom abrégé (pour bulletins)"}),
|
|
(
|
|
"module_type",
|
|
{
|
|
"input_type": "menu",
|
|
"title": "Type",
|
|
"explanation": "",
|
|
"labels": [x.name.capitalize() for x in module_types],
|
|
"allowed_values": [str(int(x)) for x in module_types],
|
|
"enabled": unlocked,
|
|
},
|
|
),
|
|
(
|
|
"heures_cours",
|
|
{
|
|
"title": "Heures CM :",
|
|
"size": 4,
|
|
"type": "float",
|
|
"explanation": "nombre d'heures de cours",
|
|
},
|
|
),
|
|
(
|
|
"heures_td",
|
|
{
|
|
"title": "Heures TD :",
|
|
"size": 4,
|
|
"type": "float",
|
|
"explanation": "nombre d'heures de Travaux Dirigés",
|
|
},
|
|
),
|
|
(
|
|
"heures_tp",
|
|
{
|
|
"title": "Heures TP :",
|
|
"size": 4,
|
|
"type": "float",
|
|
"explanation": "nombre d'heures de Travaux Pratiques",
|
|
},
|
|
),
|
|
]
|
|
if is_apc:
|
|
coefs_lst = a_module.ue_coefs_list()
|
|
if coefs_lst:
|
|
coefs_descr_txt = ", ".join(
|
|
[f"{ue.acronyme}: {c}" for (ue, c) in coefs_lst]
|
|
)
|
|
else:
|
|
coefs_descr_txt = """<span class="missing_value">non définis</span>"""
|
|
descr += [
|
|
(
|
|
"ue_coefs",
|
|
{
|
|
"readonly": True,
|
|
"title": "Coefficients vers les UE ",
|
|
"default": coefs_descr_txt,
|
|
"explanation": " <br>(passer par la page d'édition de la formation pour modifier les coefficients)",
|
|
},
|
|
)
|
|
]
|
|
else: # Module classique avec coef scalaire:
|
|
descr += [
|
|
(
|
|
"coefficient",
|
|
{
|
|
"size": 4,
|
|
"type": "float",
|
|
"explanation": "coefficient dans la formation (PPN)",
|
|
"allow_null": False,
|
|
"enabled": unlocked,
|
|
},
|
|
),
|
|
]
|
|
descr += [
|
|
("formation_id", {"input_type": "hidden"}),
|
|
("ue_id", {"input_type": "hidden"}),
|
|
("module_id", {"input_type": "hidden"}),
|
|
(
|
|
"ue_matiere_id",
|
|
{
|
|
"input_type": "menu",
|
|
"title": "Rattachement :" if is_apc else "Matière :",
|
|
"explanation": (
|
|
"UE de rattachement"
|
|
+ (
|
|
" module utilisé, ne peut pas être changé de semestre"
|
|
if in_use
|
|
else ""
|
|
)
|
|
)
|
|
if is_apc
|
|
else "un module appartient à une seule matière.",
|
|
"labels": mat_names,
|
|
"allowed_values": ue_mat_ids,
|
|
"enabled": unlocked,
|
|
},
|
|
),
|
|
]
|
|
if is_apc:
|
|
# le semestre du module est toujours celui de son UE
|
|
descr += [
|
|
(
|
|
"semestre_id",
|
|
{
|
|
"input_type": "hidden",
|
|
"type": "int",
|
|
"readonly": True,
|
|
},
|
|
)
|
|
]
|
|
else:
|
|
descr += [
|
|
(
|
|
"semestre_id",
|
|
{
|
|
"input_type": "menu",
|
|
"type": "int",
|
|
"title": parcours.SESSION_NAME.capitalize(),
|
|
"explanation": "%s de début du module dans la formation standard"
|
|
% parcours.SESSION_NAME,
|
|
"labels": [str(x) for x in semestres_indices],
|
|
"allowed_values": semestres_indices,
|
|
"enabled": unlocked,
|
|
},
|
|
)
|
|
]
|
|
descr += [
|
|
(
|
|
"code_apogee",
|
|
{
|
|
"title": "Code Apogée",
|
|
"size": 25,
|
|
"explanation": "(optionnel) code élément pédagogique Apogée ou liste de codes ELP séparés par des virgules",
|
|
"validator": lambda val, _: len(val) < APO_CODE_STR_LEN,
|
|
},
|
|
),
|
|
(
|
|
"numero",
|
|
{
|
|
"size": 2,
|
|
"explanation": "numéro (1,2,3,4...) pour ordre d'affichage",
|
|
"type": "int",
|
|
},
|
|
),
|
|
]
|
|
# force module semestre_idx to its UE
|
|
if a_module.ue.semestre_idx:
|
|
module["semestre_id"] = a_module.ue.semestre_idx
|
|
# Filet de sécurité si jamais l'UE n'a pas non plus de semestre:
|
|
if not module["semestre_id"]:
|
|
module["semestre_id"] = 1
|
|
tf = TrivialFormulator(
|
|
request.base_url,
|
|
scu.get_request_args(),
|
|
descr,
|
|
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(module_id))
|
|
),
|
|
initvalues=module,
|
|
submitlabel="Modifier ce module",
|
|
)
|
|
#
|
|
if tf[0] == 0:
|
|
return "\n".join(H) + tf[1] + html_sco_header.sco_footer()
|
|
elif tf[0] == -1:
|
|
return flask.redirect(
|
|
url_for(
|
|
"notes.ue_table",
|
|
scodoc_dept=g.scodoc_dept,
|
|
formation_id=formation_id,
|
|
semestre_idx=module["semestre_id"],
|
|
)
|
|
)
|
|
else:
|
|
# l'UE de rattachement peut changer
|
|
tf[2]["ue_id"], tf[2]["matiere_id"] = tf[2]["ue_matiere_id"].split("!")
|
|
old_ue_id = a_module.ue.id
|
|
new_ue_id = int(tf[2]["ue_id"])
|
|
if (old_ue_id != new_ue_id) and in_use:
|
|
new_ue = UniteEns.query.get_or_404(new_ue_id)
|
|
if new_ue.semestre_idx != a_module.ue.semestre_idx:
|
|
# pas changer de semestre un module utilisé !
|
|
raise ScoValueError(
|
|
"Module utilisé: il ne peut pas être changé de semestre !"
|
|
)
|
|
# En APC, force le semestre égal à celui de l'UE
|
|
if is_apc:
|
|
selected_ue = UniteEns.query.get(tf[2]["ue_id"])
|
|
if selected_ue is None:
|
|
raise ValueError("UE invalide")
|
|
tf[2]["semestre_id"] = selected_ue.semestre_idx
|
|
# Check unicité code module dans la formation
|
|
do_module_edit(tf[2])
|
|
return flask.redirect(
|
|
url_for(
|
|
"notes.ue_table",
|
|
scodoc_dept=g.scodoc_dept,
|
|
formation_id=formation_id,
|
|
semestre_idx=tf[2]["semestre_id"],
|
|
)
|
|
)
|
|
|
|
|
|
# Edition en ligne du code Apogee
|
|
def edit_module_set_code_apogee(id=None, value=None):
|
|
"Set UE code apogee"
|
|
module_id = id
|
|
value = str(value).strip("-_ \t")
|
|
log("edit_module_set_code_apogee: module_id=%s code_apogee=%s" % (module_id, value))
|
|
|
|
modules = module_list(args={"module_id": module_id})
|
|
if not modules:
|
|
return "module invalide" # should not occur
|
|
|
|
do_module_edit({"module_id": module_id, "code_apogee": value})
|
|
if not value:
|
|
value = scu.APO_MISSING_CODE_STR
|
|
return value
|
|
|
|
|
|
def module_table(formation_id):
|
|
"""Liste des modules de la formation
|
|
(XXX inutile ou a revoir)
|
|
"""
|
|
from app.scodoc import sco_formations
|
|
|
|
if not formation_id:
|
|
raise ScoValueError("invalid formation !")
|
|
F = sco_formations.formation_list(args={"formation_id": formation_id})[0]
|
|
H = [
|
|
html_sco_header.sco_header(page_title="Liste des modules de %(titre)s" % F),
|
|
"""<h2>Listes des modules dans la formation %(titre)s (%(acronyme)s)</h2>"""
|
|
% F,
|
|
'<ul class="notes_module_list">',
|
|
]
|
|
editable = current_user.has_permission(Permission.ScoChangeFormation)
|
|
|
|
for Mod in 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)
|
|
H.append(
|
|
'<a href="module_delete?module_id=%(module_id)s">supprimer</a>' % Mod
|
|
)
|
|
H.append("</li>")
|
|
H.append("</ul>")
|
|
H.append(html_sco_header.sco_footer())
|
|
return "\n".join(H)
|
|
|
|
|
|
def module_is_locked(module_id):
|
|
"""True if module should not be modified
|
|
(used in a locked formsemestre)
|
|
"""
|
|
r = ndb.SimpleDictFetch(
|
|
"""SELECT mi.id
|
|
FROM notes_modules mod, notes_formsemestre sem, notes_moduleimpl mi
|
|
WHERE mi.module_id = mod.id
|
|
AND mi.formsemestre_id = sem.id
|
|
AND mi.module_id = %(module_id)s
|
|
AND sem.etat = false
|
|
""",
|
|
{"module_id": module_id},
|
|
)
|
|
return len(r) > 0
|
|
|
|
|
|
def module_count_moduleimpls(module_id):
|
|
"Number of moduleimpls using this module"
|
|
mods = sco_moduleimpl.moduleimpl_list(module_id=module_id)
|
|
return len(mods)
|
|
|
|
|
|
def formation_add_malus_modules(formation_id, titre=None, redirect=True):
|
|
"""Création d'un module de "malus" dans chaque UE d'une formation"""
|
|
from app.scodoc import sco_edit_ue
|
|
|
|
ues = sco_edit_ue.ue_list(args={"formation_id": formation_id})
|
|
|
|
for ue in ues:
|
|
# Un seul module de malus par UE:
|
|
nb_mod_malus = len(
|
|
[
|
|
mod
|
|
for mod in module_list(args={"ue_id": ue["ue_id"]})
|
|
if mod["module_type"] == scu.ModuleType.MALUS
|
|
]
|
|
)
|
|
if nb_mod_malus == 0:
|
|
ue_add_malus_module(ue["ue_id"], titre=titre)
|
|
|
|
if redirect:
|
|
return flask.redirect(
|
|
url_for(
|
|
"notes.ue_table", scodoc_dept=g.scodoc_dept, formation_id=formation_id
|
|
)
|
|
)
|
|
|
|
|
|
def ue_add_malus_module(ue_id, titre=None, code=None):
|
|
"""Add a malus module in this ue"""
|
|
from app.scodoc import sco_edit_ue
|
|
|
|
ue = sco_edit_ue.ue_list(args={"ue_id": ue_id})[0]
|
|
|
|
if titre is None:
|
|
titre = ""
|
|
if code is 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(ue)
|
|
if semestre_ids:
|
|
semestre_id = semestre_ids[0]
|
|
else:
|
|
# c'est ennuyeux: dans ce cas, on pourrait demander à indiquer explicitement
|
|
# le semestre ? ou affecter le malus au semestre 1 ???
|
|
raise ScoValueError(
|
|
"Impossible d'ajouter un malus s'il n'y a pas d'autres modules"
|
|
)
|
|
|
|
# Matiere pour placer le module malus
|
|
Matlist = sco_edit_matiere.matiere_list(args={"ue_id": ue_id})
|
|
numero = max([mat["numero"] for mat in Matlist]) + 10
|
|
matiere_id = sco_edit_matiere.do_matiere_create(
|
|
{"ue_id": ue_id, "titre": "Malus", "numero": numero}
|
|
)
|
|
|
|
module_id = do_module_create(
|
|
{
|
|
"titre": titre,
|
|
"code": code,
|
|
"coefficient": 0.0, # unused
|
|
"ue_id": ue_id,
|
|
"matiere_id": matiere_id,
|
|
"formation_id": ue["formation_id"],
|
|
"semestre_id": semestre_id,
|
|
"module_type": scu.ModuleType.MALUS,
|
|
},
|
|
)
|
|
|
|
return module_id
|