# -*- mode: python -*- # -*- coding: utf-8 -*- ############################################################################## # # Gestion scolarite IUT # # Copyright (c) 1999 - 2021 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 UE """ import flask from flask import g, url_for from flask_login import current_user import app.scodoc.notesdb as ndb import app.scodoc.sco_utils as scu from app import log from app.scodoc.TrivialFormulator import TrivialFormulator, TF from app.scodoc.gen_tables import GenTable from app.scodoc.sco_permissions import Permission from app.scodoc.sco_exceptions import ScoValueError, ScoLockedFormError from app.scodoc import html_sco_header from app.scodoc import sco_cache from app.scodoc import sco_codes_parcours from app.scodoc import sco_edit_formation from app.scodoc import sco_edit_matiere from app.scodoc import sco_edit_module from app.scodoc import sco_etud from app.scodoc import sco_formsemestre from app.scodoc import sco_groups from app.scodoc import sco_moduleimpl from app.scodoc import sco_news from app.scodoc import sco_permissions from app.scodoc import sco_preferences from app.scodoc import sco_tag_module _ueEditor = ndb.EditableTable( "notes_ue", "ue_id", ( "ue_id", "formation_id", "acronyme", "numero", "titre", "type", "ue_code", "ects", "is_external", "code_apogee", "coefficient", ), sortkey="numero", input_formators={ "type": ndb.int_null_is_zero, "is_external": bool, }, output_formators={ "numero": ndb.int_null_is_zero, "ects": ndb.float_null_is_null, "coefficient": ndb.float_null_is_zero, }, ) def do_ue_list(*args, **kw): "list UEs" cnx = ndb.GetDBConnexion() return _ueEditor.list(cnx, *args, **kw) def do_ue_create(args): "create an ue" from app.scodoc import sco_formations cnx = ndb.GetDBConnexion() # check duplicates ues = do_ue_list( {"formation_id": args["formation_id"], "acronyme": args["acronyme"]} ) if ues: raise ScoValueError('Acronyme d\'UE "%s" déjà utilisé !' % args["acronyme"]) # create r = _ueEditor.create(cnx, args) # news F = sco_formations.formation_list(args={"formation_id": args["formation_id"]})[0] sco_news.add( typ=sco_news.NEWS_FORM, object=args["formation_id"], text="Modification de la formation %(acronyme)s" % F, max_frequency=3, ) return r def do_ue_delete(ue_id, delete_validations=False, force=False): "delete UE and attached matieres (but not modules)" from app.scodoc import sco_formations from app.scodoc import sco_parcours_dut cnx = ndb.GetDBConnexion() log("do_ue_delete: ue_id=%s, delete_validations=%s" % (ue_id, delete_validations)) # check ue = do_ue_list({"ue_id": ue_id}) if not ue: raise ScoValueError("UE inexistante !") ue = ue[0] 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 validations = sco_parcours_dut.scolar_formsemestre_validation_list( cnx, args={"ue_id": ue_id} ) if validations and not delete_validations and not force: return scu.confirm_dialog( "

%d étudiants ont validé l'UE %s (%s)

Si vous supprimez cette UE, ces validations vont être supprimées !

" % (len(validations), ue["acronyme"], ue["titre"]), dest_url="", target_variable="delete_validations", cancel_url="ue_list?formation_id=%s" % ue["formation_id"], parameters={"ue_id": ue_id, "dialog_confirmed": 1}, ) if delete_validations: log("deleting all validations of UE %s" % ue_id) ndb.SimpleQuery( "DELETE FROM scolar_formsemestre_validation WHERE ue_id=%(ue_id)s", {"ue_id": ue_id}, ) # delete all matiere in this UE mats = sco_edit_matiere.do_matiere_list({"ue_id": ue_id}) for mat in mats: 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", {"ue_id": ue_id}, ) ndb.SimpleQuery("DELETE FROM scolar_events WHERE ue_id=%(ue_id)s", {"ue_id": ue_id}) cnx = ndb.GetDBConnexion() _ueEditor.delete(cnx, ue_id) # > UE delete + supr. validations associées etudiants (cas compliqué, mais rarement utilisé: acceptable de tout invalider ?): sco_cache.invalidate_formsemestre() # news F = sco_formations.formation_list(args={"formation_id": ue["formation_id"]})[0] sco_news.add( typ=sco_news.NEWS_FORM, object=ue["formation_id"], text="Modification de la formation %(acronyme)s" % F, max_frequency=3, ) # if not force: return flask.redirect( url_for( "notes.ue_list", scodoc_dept=g.scodoc_dept, formation_id=ue["formation_id"], ) ) else: return None def ue_create(formation_id=None, REQUEST=None): """Creation d'une UE""" return ue_edit(create=True, formation_id=formation_id, REQUEST=REQUEST) 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(args={"ue_id": ue_id}) if not U: raise ScoValueError("UE inexistante !") U = U[0] formation_id = U["formation_id"] title = "Modification de l'UE %(titre)s" % U initvalues = U submitlabel = "Modifier les valeurs" else: title = "Création d'une UE" initvalues = {} submitlabel = "Créer cette UE" Fol = sco_formations.formation_list(args={"formation_id": formation_id}) if not Fol: raise ScoValueError( "Formation %s inexistante ! (si vous avez suivi un lien valide, merci de signaler le problème)" % formation_id ) Fo = Fol[0] parcours = sco_codes_parcours.get_parcours_from_code(Fo["type_parcours"]) H = [ html_sco_header.sco_header(page_title=title, javascripts=["js/edit_ue.js"]), "

" + title, " (formation %(acronyme)s, version %(version)s)

" % Fo, """

Les UE sont des groupes de modules dans une formation donnée, utilisés pour l'évaluation (on calcule des moyennes par UE et applique des seuils ("barres")).

Note: L'UE n'a pas de coefficient associé. Seuls les modules ont des coefficients.

""", ] ue_types = parcours.ALLOWED_UE_TYPES ue_types.sort() ue_types_names = [sco_codes_parcours.UE_TYPE_NAME[k] for k in ue_types] ue_types = [str(x) for x in ue_types] fw = [ ("ue_id", {"input_type": "hidden"}), ("create", {"input_type": "hidden", "default": create}), ("formation_id", {"input_type": "hidden", "default": formation_id}), ("titre", {"size": 30, "explanation": "nom de l'UE"}), ("acronyme", {"size": 8, "explanation": "abbréviation", "allow_null": False}), ( "numero", { "size": 2, "explanation": "numéro (1,2,3,4) de l'UE pour l'ordre d'affichage", "type": "int", }, ), ( "type", { "explanation": "type d'UE", "input_type": "menu", "allowed_values": ue_types, "labels": ue_types_names, }, ), ( "ects", { "size": 4, "type": "float", "title": "ECTS", "explanation": "nombre de crédits ECTS", }, ), ( "coefficient", { "size": 4, "type": "float", "title": "Coefficient", "explanation": """les coefficients d'UE ne sont utilisés que lorsque l'option Utiliser les coefficients d'UE pour calculer la moyenne générale est activée. Par défaut, le coefficient d'une UE est simplement la somme des coefficients des modules dans lesquels l'étudiant a des notes. """, }, ), ( "ue_code", { "size": 12, "title": "Code UE", "explanation": "code interne (optionnel). Toutes les UE partageant le même code (et le même code de formation) sont compatibles (compensation de semestres, capitalisation d'UE). Voir liste ci-dessous.", }, ), ( "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", }, ), ] if parcours.UE_IS_MODULE: # demande le semestre pour creer le module immediatement: semestres_indices = list(range(1, parcours.NB_SEM + 1)) fw.append( ( "semestre_id", { "input_type": "menu", "type": "int", "title": parcours.SESSION_NAME.capitalize(), "explanation": "%s de début du module dans la formation" % parcours.SESSION_NAME, "labels": [str(x) for x in semestres_indices], "allowed_values": semestres_indices, }, ) ) if create and not parcours.UE_IS_MODULE: fw.append( ( "create_matiere", { "input_type": "boolcheckbox", "default": False, "title": "Créer matière identique", "explanation": "créer immédiatement une matière dans cette UE (utile si on n'utilise pas de matières)", }, ) ) tf = TrivialFormulator( REQUEST.URL0, REQUEST.form, fw, initvalues=initvalues, submitlabel=submitlabel ) if tf[0] == 0: X = """
""" return "\n".join(H) + tf[1] + X + html_sco_header.sco_footer() else: if create: if not tf[2]["ue_code"]: del tf[2]["ue_code"] if not tf[2]["numero"]: if not "semestre_id" in tf[2]: tf[2]["semestre_id"] = 0 # numero regroupant par semestre ou année: tf[2]["numero"] = next_ue_numero( formation_id, int(tf[2]["semestre_id"] or 0) ) 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( {"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( { "titre": tf[2]["titre"], "code": tf[2]["acronyme"], "coefficient": 1.0, # tous les modules auront coef 1, et on utilisera les ECTS "ue_id": ue_id, "matiere_id": matiere_id, "formation_id": formation_id, "semestre_id": tf[2]["semestre_id"], }, ) else: do_ue_edit(tf[2]) return flask.redirect( url_for( "notes.ue_list", scodoc_dept=g.scodoc_dept, formation_id=formation_id ) ) 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(args={"ue_id": ue["ue_id"]}) if Modlist: ue["semestre_id"] = Modlist[0]["semestre_id"] else: ue["semestre_id"] = 1000000 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(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(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 else: return ue_list[-1]["numero"] + 1000 def ue_delete( ue_id=None, delete_validations=False, dialog_confirmed=False, REQUEST=None ): """Delete an UE""" ue = do_ue_list(args={"ue_id": ue_id}) if not ue: raise ScoValueError("UE inexistante !") ue = ue[0] if not dialog_confirmed: return scu.confirm_dialog( "

Suppression de l'UE %(titre)s (%(acronyme)s))

" % ue, dest_url="", parameters={"ue_id": ue_id}, cancel_url="ue_list?formation_id=%s" % ue["formation_id"], ) return do_ue_delete(ue_id, delete_validations=delete_validations) def ue_list(formation_id=None, msg=""): """Liste des matières et modules d'une formation, avec liens pour editer (si non verrouillée). """ from app.scodoc import sco_formations from app.scodoc import sco_formsemestre_validation F = sco_formations.formation_list(args={"formation_id": formation_id}) if not F: 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(formation_id) ue_list = do_ue_list(args={"formation_id": formation_id}) # tri par semestre et numero: _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) perm_change = current_user.has_permission(Permission.ScoChangeFormation) # editable = (not locked) and perm_change # On autorise maintanant la modification des formations qui ont des semestres verrouillés, # sauf si cela affect les notes passées (verrouillées): # - pas de modif des modules utilisés dans des semestres verrouillés # - pas de changement des codes d'UE utilisés dans des semestres verrouillés editable = perm_change tag_editable = ( current_user.has_permission(Permission.ScoEditFormationTags) or perm_change ) if locked: lockicon = scu.icontag("lock32_img", title="verrouillé") else: lockicon = "" arrow_up, arrow_down, arrow_none = sco_groups.getArrowIconsTags() delete_icon = scu.icontag( "delete_small_img", title="Supprimer (module inutilisé)", alt="supprimer" ) delete_disabled_icon = scu.icontag( "delete_small_dis_img", title="Suppression impossible (module utilisé)" ) H = [ html_sco_header.sco_header( cssstyles=["libjs/jQuery-tagEditor/jquery.tag-editor.css"], javascripts=[ "libjs/jinplace-1.2.1.min.js", "js/ue_list.js", "libjs/jQuery-tagEditor/jquery.tag-editor.min.js", "libjs/jQuery-tagEditor/jquery.caret.min.js", "js/module_tag_editor.js", ], page_title="Programme %s" % F["acronyme"], ), """

Formation %(titre)s (%(acronyme)s) [version %(version)s] code %(formation_code)s""" % F, lockicon, "

", ] if locked: H.append( f"""

Cette formation est verrouillée car {len(locked)} semestres verrouillés s'y réferent. Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module), vous devez:

""" ) if msg: H.append('

' + msg + "

") if has_duplicate_ue_codes: H.append( """
Attention: plusieurs UE de cette formation ont le même code. Il faut corriger cela ci-dessous, sinon les calculs d'ECTS seront erronés !
""" ) # Description de la formation H.append('
') H.append( '
Titre:%(titre)s
' % F ) H.append( '
Titre officiel:%(titre_officiel)s
' % F ) H.append( '
Acronyme:%(acronyme)s
' % F ) H.append( '
Code:%(formation_code)s
' % F ) H.append( '
Version:%(version)s
' % F ) H.append( '
Type parcours:%s
' % parcours.__doc__ ) if parcours.UE_IS_MODULE: H.append( '
(Chaque module est une UE)
' ) if editable: H.append( '
modifier ces informations
' % F ) H.append("
") # Description des UE/matières/modules H.append('
') H.append('
Programme pédagogique:
') H.append( '
montrer les tags
' ) cur_ue_semestre_id = None iue = 0 for UE in ue_list: if UE["ects"]: UE["ects_str"] = ", %g ECTS" % UE["ects"] else: UE["ects_str"] = "" if editable: klass = "span_apo_edit" else: klass = "" UE["code_apogee_str"] = ( """, Apo: """ % (klass, UE["ue_id"], scu.APO_MISSING_CODE_STR) + (UE["code_apogee"] or "") + "" ) if cur_ue_semestre_id != UE["semestre_id"]: cur_ue_semestre_id = UE["semestre_id"] if iue > 0: H.append("") if UE["semestre_id"] == sco_codes_parcours.UE_SEM_DEFAULT: lab = "Pas d'indication de semestre:" else: lab = "Semestre %s:" % UE["semestre_id"] H.append('
%s
' % lab) H.append('") if editable: H.append( '' % F ) H.append("
") # formation_ue_list H.append("

""" % F ) if perm_change: H.append( """

Semestres ou sessions de cette formation

") if current_user.has_permission(Permission.ScoImplement): H.append( """""" % F ) #
  • (debug) Vérifier cohérence
  • 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(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. """ from app.scodoc import sco_formations if ue_id: 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(args={"ue_code": ue_code}) if ue_id: # retire les UE d'autres formations: # log('checking ucode %s formation %s' % (ue_code, formation_code)) ue_list = [] for ue in ue_list_all: F = sco_formations.formation_list( args={"formation_id": ue["formation_id"]} )[0] if formation_code == F["formation_code"]: ue_list.append(ue) else: ue_list = ue_list_all if hide_ue_id: # enlève l'ue de depart ue_list = [ue for ue in ue_list if ue["ue_id"] != hide_ue_id] if not ue_list: if ue_id: return """Seule UE avec code %s""" % ue_code else: return """Aucune UE avec code %s""" % ue_code H = [] if ue_id: H.append('Autres UE avec le code %s:' % ue_code) else: H.append('UE avec le code %s:' % ue_code) H.append("") return "\n".join(H) 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({"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({"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"]) # On ne peut pas supprimer le code UE: if "ue_code" in args and not args["ue_code"]: del args["ue_code"] cnx = ndb.GetDBConnexion() _ueEditor.edit(cnx, args) if not dont_invalidate_cache: # Invalide les semestres utilisant cette formation: sco_edit_formation.invalidate_sems_in_formation(ue["formation_id"]) # essai edition en ligne: def edit_ue_set_code_apogee(id=None, value=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(args={"ue_id": ue_id}) if not ues: return "ue invalide" do_ue_edit( {"ue_id": ue_id, "code_apogee": value}, bypass_lock=True, dont_invalidate_cache=False, ) if not value: value = scu.APO_MISSING_CODE_STR return value def ue_is_locked(ue_id): """True if UE should not be modified (contains modules used in a locked formsemestre) """ r = ndb.SimpleDictFetch( """SELECT ue.id FROM notes_ue ue, notes_modules mod, notes_formsemestre sem, notes_moduleimpl mi WHERE ue.id = mod.ue_id AND mi.module_id = mod.id AND mi.formsemestre_id = sem.id AND ue.id = %(ue_id)s AND sem.etat = false """, {"ue_id": ue_id}, ) return len(r) > 0 # ---- Table recap formation def formation_table_recap(formation_id, format="html", REQUEST=None): """Table recapitulant formation.""" from app.scodoc import sco_formations F = sco_formations.formation_list(args={"formation_id": formation_id}) if not F: raise ScoValueError("invalid formation_id") F = F[0] T = [] ue_list = do_ue_list(args={"formation_id": formation_id}) for UE in ue_list: Matlist = sco_edit_matiere.do_matiere_list(args={"ue_id": UE["ue_id"]}) for Mat in Matlist: Modlist = sco_edit_module.do_module_list( args={"matiere_id": Mat["matiere_id"]} ) for Mod in Modlist: Mod["nb_moduleimpls"] = sco_edit_module.module_count_moduleimpls( Mod["module_id"] ) # T.append( { "UE_acro": UE["acronyme"], "Mat_tit": Mat["titre"], "Mod_tit": Mod["abbrev"] or Mod["titre"], "Mod_code": Mod["code"], "Mod_coef": Mod["coefficient"], "Mod_sem": Mod["semestre_id"], "nb_moduleimpls": Mod["nb_moduleimpls"], "heures_cours": Mod["heures_cours"], "heures_td": Mod["heures_td"], "heures_tp": Mod["heures_tp"], "ects": Mod["ects"], } ) columns_ids = [ "UE_acro", "Mat_tit", "Mod_tit", "Mod_code", "Mod_coef", "Mod_sem", "nb_moduleimpls", "heures_cours", "heures_td", "heures_tp", "ects", ] titles = { "UE_acro": "UE", "Mat_tit": "Matière", "Mod_tit": "Module", "Mod_code": "Code", "Mod_coef": "Coef.", "Mod_sem": "Sem.", "nb_moduleimpls": "Nb utilisé", "heures_cours": "Cours (h)", "heures_td": "TD (h)", "heures_tp": "TP (h)", "ects": "ECTS", } title = ( """Formation %(titre)s (%(acronyme)s) [version %(version)s] code %(formation_code)s""" % F ) tab = GenTable( columns_ids=columns_ids, rows=T, titles=titles, origin="Généré par %s le " % scu.sco_version.SCONAME + scu.timedate_human_repr() + "", caption=title, html_caption=title, html_class="table_leftalign", base_url="%s?formation_id=%s" % (REQUEST.URL0, formation_id), page_title=title, html_title="

    " + title + "

    ", pdf_title=title, preferences=sco_preferences.SemPreferences(), ) return tab.make_page(format=format, REQUEST=REQUEST) 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(args={"ue_id": ue["ue_id"]}) return sorted(list(set([mod["semestre_id"] for mod in Modlist])))