Renommage dans UI et code des anciens 'Parcours' ScoDoc en 'Cursus'

This commit is contained in:
Emmanuel Viennet 2023-02-12 13:36:47 +01:00
parent 211054a9af
commit d55e393c15
77 changed files with 402 additions and 418 deletions

View File

@ -9,14 +9,14 @@ Edition associations UE <-> Ref. Compétence
""" """
from flask import g, url_for from flask import g, url_for
from app.models import ApcReferentielCompetences, Formation, UniteEns from app.models import ApcReferentielCompetences, Formation, UniteEns
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
def form_ue_choix_niveau(ue: UniteEns) -> str: def form_ue_choix_niveau(ue: UniteEns) -> str:
"""Form. HTML pour associer une UE à un niveau de compétence. """Form. HTML pour associer une UE à un niveau de compétence.
Le menu select lui meême est vide et rempli en JS par appel à get_ue_niveaux_options_html Le menu select lui meême est vide et rempli en JS par appel à get_ue_niveaux_options_html
""" """
if ue.type != sco_codes_parcours.UE_STANDARD: if ue.type != codes_cursus.UE_STANDARD:
return "" return ""
ref_comp = ue.formation.referentiel_competence ref_comp = ue.formation.referentiel_competence
if ref_comp is None: if ref_comp is None:

View File

@ -19,10 +19,10 @@ from app.models.ues import UniteEns
from app.scodoc import sco_bulletins, sco_utils as scu from app.scodoc import sco_bulletins, sco_utils as scu
from app.scodoc import sco_bulletins_json from app.scodoc import sco_bulletins_json
from app.scodoc import sco_bulletins_pdf from app.scodoc import sco_bulletins_pdf
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_groups from app.scodoc import sco_groups
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
from app.scodoc.sco_codes_parcours import UE_SPORT, DEF from app.scodoc.codes_cursus import UE_SPORT, DEF
from app.scodoc.sco_utils import fmt_note from app.scodoc.sco_utils import fmt_note
@ -157,7 +157,7 @@ class BulletinBUT:
for _, ue_capitalisee in self.res.validations.ue_capitalisees.loc[ for _, ue_capitalisee in self.res.validations.ue_capitalisees.loc[
[etud.id] [etud.id]
].iterrows(): ].iterrows():
if sco_codes_parcours.code_ue_validant(ue_capitalisee.code): if codes_cursus.code_ue_validant(ue_capitalisee.code):
ue = UniteEns.query.get(ue_capitalisee.ue_id) # XXX cacher ? ue = UniteEns.query.get(ue_capitalisee.ue_id) # XXX cacher ?
# déjà capitalisé ? montre la meilleure # déjà capitalisé ? montre la meilleure
if ue.acronyme in d: if ue.acronyme in d:

View File

@ -12,7 +12,7 @@ from reportlab.platypus import Paragraph, Spacer
from app.scodoc.sco_bulletins_standard import BulletinGeneratorStandard from app.scodoc.sco_bulletins_standard import BulletinGeneratorStandard
from app.scodoc import gen_tables from app.scodoc import gen_tables
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu

View File

@ -43,7 +43,7 @@ from app.but import bulletin_but
from app.models import FormSemestre, Identite from app.models import FormSemestre, Identite
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
import app.scodoc.notesdb as ndb import app.scodoc.notesdb as ndb
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_edit_ue from app.scodoc import sco_edit_ue
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc import sco_photos from app.scodoc import sco_photos
@ -159,7 +159,7 @@ def bulletin_but_xml_compat(
code_apogee=quote_xml_attr(ue.code_apogee or ""), code_apogee=quote_xml_attr(ue.code_apogee or ""),
) )
doc.append(x_ue) doc.append(x_ue)
if ue.type != sco_codes_parcours.UE_SPORT: if ue.type != codes_cursus.UE_SPORT:
v = results.etud_moy_ue[ue.id][etud.id] v = results.etud_moy_ue[ue.id][etud.id]
vmin = results.etud_moy_ue[ue.id].min() vmin = results.etud_moy_ue[ue.id].min()
vmax = results.etud_moy_ue[ue.id].max() vmax = results.etud_moy_ue[ue.id].max()

View File

@ -44,8 +44,8 @@ from app.models.formations import Formation
from app.models.formsemestre import FormSemestre, FormSemestreInscription from app.models.formsemestre import FormSemestre, FormSemestreInscription
from app.models.ues import UniteEns from app.models.ues import UniteEns
from app.models.validations import ScolarFormSemestreValidation from app.models.validations import ScolarFormSemestreValidation
from app.scodoc import sco_codes_parcours as sco_codes from app.scodoc import codes_cursus as sco_codes
from app.scodoc.sco_codes_parcours import RED, UE_STANDARD from app.scodoc.codes_cursus import RED, UE_STANDARD
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu
from app.scodoc.sco_exceptions import ScoNoReferentielCompetences, ScoValueError from app.scodoc.sco_exceptions import ScoNoReferentielCompetences, ScoValueError

View File

@ -90,8 +90,8 @@ from app.models.formsemestre import FormSemestre, FormSemestreInscription
from app.models.ues import UniteEns from app.models.ues import UniteEns
from app.models.validations import ScolarFormSemestreValidation from app.models.validations import ScolarFormSemestreValidation
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours as sco_codes from app.scodoc import codes_cursus as sco_codes
from app.scodoc.sco_codes_parcours import ( from app.scodoc.codes_cursus import (
BUT_CODES_ORDERED, BUT_CODES_ORDERED,
CODES_RCUE_VALIDES, CODES_RCUE_VALIDES,
CODES_UE_CAPITALISANTS, CODES_UE_CAPITALISANTS,
@ -641,7 +641,7 @@ class DecisionsProposeesAnnee(DecisionsProposees):
ids = set() ids = set()
# La poursuite d'études dans un semestre pair dune même année # La poursuite d'études dans un semestre pair dune même année
# est de droit pour tout étudiant: # est de droit pour tout étudiant:
if (self.formsemestre.semestre_id % 2) and sco_codes.ParcoursBUT.NB_SEM: if (self.formsemestre.semestre_id % 2) and sco_codes.CursusBUT.NB_SEM:
ids.add(self.formsemestre.semestre_id + 1) ids.add(self.formsemestre.semestre_id + 1)
# La poursuite détudes dans un semestre impair est possible si # La poursuite détudes dans un semestre impair est possible si
@ -656,7 +656,7 @@ class DecisionsProposeesAnnee(DecisionsProposees):
if ( if (
self.jury_annuel self.jury_annuel
and code in sco_codes.BUT_CODES_PASSAGE and code in sco_codes.BUT_CODES_PASSAGE
and self.formsemestre_pair.semestre_id < sco_codes.ParcoursBUT.NB_SEM and self.formsemestre_pair.semestre_id < sco_codes.CursusBUT.NB_SEM
): ):
ids.add(self.formsemestre.semestre_id + 1) ids.add(self.formsemestre.semestre_id + 1)
@ -1250,10 +1250,10 @@ class DecisionsProposeesUE(DecisionsProposees):
if self.inscription_etat != scu.INSCRIT: if self.inscription_etat != scu.INSCRIT:
return return
if ( if (
self.moy_ue > (sco_codes.ParcoursBUT.BARRE_MOY - sco_codes.NOTES_TOLERANCE) self.moy_ue > (sco_codes.CursusBUT.BARRE_MOY - sco_codes.NOTES_TOLERANCE)
) or self.formsemestre.modalite == "EXT": ) or self.formsemestre.modalite == "EXT":
self.codes.insert(0, sco_codes.ADM) self.codes.insert(0, sco_codes.ADM)
self.explanation = f"Moyenne >= {sco_codes.ParcoursBUT.BARRE_MOY}/20" self.explanation = f"Moyenne >= {sco_codes.CursusBUT.BARRE_MOY}/20"
elif self.rcue and self.rcue.est_compensable(): elif self.rcue and self.rcue.est_compensable():
self.codes.insert(0, sco_codes.CMP) self.codes.insert(0, sco_codes.CMP)
self.explanation = "compensable dans le RCUE" self.explanation = "compensable dans le RCUE"

View File

@ -291,7 +291,7 @@ def jury_but_semestriel(
parcour, ues = jury_but.list_ue_parcour_etud(formsemestre, etud, res) parcour, ues = jury_but.list_ue_parcour_etud(formsemestre, etud, res)
inscription_etat = etud.inscription_etat(formsemestre.id) inscription_etat = etud.inscription_etat(formsemestre.id)
semestre_terminal = ( semestre_terminal = (
formsemestre.semestre_id >= formsemestre.formation.get_parcours().NB_SEM formsemestre.semestre_id >= formsemestre.formation.get_cursus().NB_SEM
) )
autorisations_passage = ScolarAutorisationInscription.query.filter_by( autorisations_passage = ScolarAutorisationInscription.query.filter_by(
etudid=etud.id, etudid=etud.id,
@ -474,7 +474,7 @@ def jury_but_semestriel(
""" """
) )
else: else:
if formsemestre.semestre_id < formsemestre.formation.get_parcours().NB_SEM: if formsemestre.semestre_id < formsemestre.formation.get_cursus().NB_SEM:
H.append( H.append(
f""" f"""
<div class="but_settings"> <div class="but_settings">

View File

@ -18,8 +18,8 @@ import pandas as pd
from flask import g from flask import g
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_codes_parcours import ParcoursDUT, ParcoursDUTMono from app.scodoc.codes_cursus import CursusDUT, CursusDUTMono
from app.scodoc.sco_utils import ModuleType from app.scodoc.sco_utils import ModuleType
@ -677,11 +677,11 @@ class BonusCalais(BonusSportAdditif):
proportion_point = 0.06 # 6% proportion_point = 0.06 # 6%
def compute_bonus(self, sem_modimpl_moys_inscrits, modimpl_coefs_etuds_no_nan): def compute_bonus(self, sem_modimpl_moys_inscrits, modimpl_coefs_etuds_no_nan):
parcours = self.formsemestre.formation.get_parcours() parcours = self.formsemestre.formation.get_cursus()
# Variantes de DUT ? # Variantes de DUT ?
if ( if (
isinstance(parcours, ParcoursDUT) isinstance(parcours, CursusDUT)
or parcours.TYPE_PARCOURS == ParcoursDUTMono.TYPE_PARCOURS or parcours.TYPE_CURSUS == CursusDUTMono.TYPE_CURSUS
): # DUT ): # DUT
super().compute_bonus(sem_modimpl_moys_inscrits, modimpl_coefs_etuds_no_nan) super().compute_bonus(sem_modimpl_moys_inscrits, modimpl_coefs_etuds_no_nan)
else: else:

View File

@ -12,7 +12,7 @@ from app import db
from app.models import FormSemestre, Identite, ScolarFormSemestreValidation, UniteEns from app.models import FormSemestre, Identite, ScolarFormSemestreValidation, UniteEns
from app.comp.res_cache import ResultatsCache from app.comp.res_cache import ResultatsCache
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
class ValidationsSemestre(ResultatsCache): class ValidationsSemestre(ResultatsCache):
@ -89,7 +89,7 @@ class ValidationsSemestre(ResultatsCache):
if decision.etudid not in decisions_jury_ues: if decision.etudid not in decisions_jury_ues:
decisions_jury_ues[decision.etudid] = {} decisions_jury_ues[decision.etudid] = {}
# Calcul des ECTS associés à cette UE: # Calcul des ECTS associés à cette UE:
if sco_codes_parcours.code_ue_validant(decision.code) and decision.ue: if codes_cursus.code_ue_validant(decision.code) and decision.ue:
ects = decision.ue.ects or 0.0 # 0 if None ects = decision.ue.ects or 0.0 # 0 if None
else: else:
ects = 0.0 ects = 0.0

View File

@ -14,7 +14,7 @@ import pandas as pd
from app.comp import moy_ue from app.comp import moy_ue
from app.models.formsemestre import FormSemestre from app.models.formsemestre import FormSemestre
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_utils import ModuleType from app.scodoc.sco_utils import ModuleType

View File

@ -44,7 +44,7 @@ from app import db
from app.models import Evaluation, EvaluationUEPoids, ModuleImpl from app.models import Evaluation, EvaluationUEPoids, ModuleImpl
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_exceptions import ScoBugCatcher from app.scodoc.sco_exceptions import ScoBugCatcher
from app.scodoc.sco_utils import ModuleType from app.scodoc.sco_utils import ModuleType

View File

@ -40,9 +40,9 @@ from app.models import (
UniteEns, UniteEns,
) )
from app.comp import moy_mod from app.comp import moy_mod
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_utils import ModuleType from app.scodoc.sco_utils import ModuleType
@ -61,7 +61,7 @@ def df_load_module_coefs(formation_id: int, semestre_idx: int = None) -> pd.Data
""" """
ues = ( ues = (
UniteEns.query.filter_by(formation_id=formation_id) UniteEns.query.filter_by(formation_id=formation_id)
.filter(UniteEns.type != sco_codes_parcours.UE_SPORT) .filter(UniteEns.type != codes_cursus.UE_SPORT)
.order_by(UniteEns.semestre_idx, UniteEns.numero, UniteEns.acronyme) .order_by(UniteEns.semestre_idx, UniteEns.numero, UniteEns.acronyme)
) )
modules = ( modules = (
@ -69,10 +69,7 @@ def df_load_module_coefs(formation_id: int, semestre_idx: int = None) -> pd.Data
.filter( .filter(
(Module.module_type == ModuleType.RESSOURCE) (Module.module_type == ModuleType.RESSOURCE)
| (Module.module_type == ModuleType.SAE) | (Module.module_type == ModuleType.SAE)
| ( | ((Module.ue_id == UniteEns.id) & (UniteEns.type == codes_cursus.UE_SPORT))
(Module.ue_id == UniteEns.id)
& (UniteEns.type == sco_codes_parcours.UE_SPORT)
)
) )
.order_by(Module.semestre_id, Module.module_type, Module.numero, Module.code) .order_by(Module.semestre_id, Module.module_type, Module.numero, Module.code)
) )

View File

@ -18,7 +18,7 @@ from app.models import ScoDocSiteConfig
from app.models.moduleimpls import ModuleImpl from app.models.moduleimpls import ModuleImpl
from app.models.ues import DispenseUE, UniteEns from app.models.ues import DispenseUE, UniteEns
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_utils import ModuleType from app.scodoc.sco_utils import ModuleType

View File

@ -22,7 +22,7 @@ from app.models import ScoDocSiteConfig
from app.models.etudiants import Identite from app.models.etudiants import Identite
from app.models.formsemestre import FormSemestre from app.models.formsemestre import FormSemestre
from app.models.ues import UniteEns from app.models.ues import UniteEns
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_exceptions import ScoValueError from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
from app.scodoc.sco_utils import ModuleType from app.scodoc.sco_utils import ModuleType

View File

@ -25,7 +25,7 @@ from app.models import ModuleImpl, ModuleImplInscription
from app.models import ScolarAutorisationInscription from app.models import ScolarAutorisationInscription
from app.models.ues import UniteEns from app.models.ues import UniteEns
from app.scodoc.sco_cache import ResultatsSemestreCache from app.scodoc.sco_cache import ResultatsSemestreCache
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_exceptions import ScoValueError from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu

View File

@ -17,7 +17,7 @@ from app.comp.res_common import ResultatsSemestre
from app.models import FormSemestre from app.models import FormSemestre
from app.models import Identite from app.models import Identite
from app.models import ModuleImpl from app.models import ModuleImpl
from app.scodoc.sco_codes_parcours import UE_SPORT, DEF from app.scodoc.codes_cursus import UE_SPORT, DEF
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu
# Pour raccorder le code des anciens codes qui attendent une NoteTable # Pour raccorder le code des anciens codes qui attendent une NoteTable
@ -52,7 +52,7 @@ class NotesTableCompat(ResultatsSemestre):
self.moy_gen_rangs_by_group = {} # { group_id : (Series, Series) } self.moy_gen_rangs_by_group = {} # { group_id : (Series, Series) }
self.ue_rangs_by_group = {} # { ue_id : {group_id : (Series, Series)}} self.ue_rangs_by_group = {} # { ue_id : {group_id : (Series, Series)}}
self.expr_diagnostics = "" self.expr_diagnostics = ""
self.parcours = self.formsemestre.formation.get_parcours() self.parcours = self.formsemestre.formation.get_cursus()
self._modimpls_dict_by_ue = {} # local cache self._modimpls_dict_by_ue = {} # local cache
def get_inscrits(self, include_demdef=True, order_by=False) -> list[Identite]: def get_inscrits(self, include_demdef=True, order_by=False) -> list[Identite]:

View File

@ -35,14 +35,14 @@ from wtforms.fields.simple import StringField
from app.models import SHORT_STR_LEN from app.models import SHORT_STR_LEN
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
def _build_code_field(code): def _build_code_field(code):
return StringField( return StringField(
label=code, label=code,
default=code, default=code,
description=sco_codes_parcours.CODES_EXPL[code], description=codes_cursus.CODES_EXPL[code],
validators=[ validators=[
validators.regexp( validators.regexp(
r"^[A-Z0-9_]*$", r"^[A-Z0-9_]*$",

View File

@ -13,7 +13,7 @@ from app.models.etudiants import Identite
from app.models.formations import Formation from app.models.formations import Formation
from app.models.formsemestre import FormSemestre from app.models.formsemestre import FormSemestre
from app.models.ues import UniteEns from app.models.ues import UniteEns
from app.scodoc import sco_codes_parcours as sco_codes from app.scodoc import codes_cursus as sco_codes
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu

View File

@ -8,7 +8,7 @@ from app import db, log
from app.comp import bonus_spo from app.comp import bonus_spo
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu
from app.scodoc.sco_codes_parcours import ( from app.scodoc.codes_cursus import (
ABAN, ABAN,
ABL, ABL,
ADC, ADC,

View File

@ -17,9 +17,9 @@ from app.models.modules import Module
from app.models.moduleimpls import ModuleImpl from app.models.moduleimpls import ModuleImpl
from app.models.ues import UniteEns from app.models.ues import UniteEns
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu
from app.scodoc.sco_codes_parcours import UE_STANDARD from app.scodoc.codes_cursus import UE_STANDARD
class Formation(db.Model): class Formation(db.Model):
@ -80,12 +80,12 @@ class Formation(db.Model):
return e return e
def get_parcours(self): def get_cursus(self) -> codes_cursus.TypeCursus:
"""get l'instance de TypeParcours de cette formation """get l'instance de TypeCursus de cette formation
(le TypeParcours définit le genre de formation, à ne pas confondre (le TypeCursus définit le genre de formation, à ne pas confondre
avec les parcours du BUT). avec les parcours du BUT).
""" """
return sco_codes_parcours.get_parcours_from_code(self.type_parcours) return codes_cursus.get_cursus_from_code(self.type_parcours)
def get_titre_version(self) -> str: def get_titre_version(self) -> str:
"""Titre avec version""" """Titre avec version"""
@ -93,7 +93,7 @@ class Formation(db.Model):
def is_apc(self): def is_apc(self):
"True si formation APC avec SAE (BUT)" "True si formation APC avec SAE (BUT)"
return self.get_parcours().APC_SAE return self.get_cursus().APC_SAE
def get_module_coefs(self, semestre_idx: int = None): def get_module_coefs(self, semestre_idx: int = None):
"""Les coefs des modules vers les UE (accès via cache)""" """Les coefs des modules vers les UE (accès via cache)"""

View File

@ -39,7 +39,7 @@ from app.models.moduleimpls import ModuleImpl, ModuleImplInscription
from app.models.modules import Module from app.models.modules import Module
from app.models.ues import UniteEns from app.models.ues import UniteEns
from app.models.validations import ScolarFormSemestreValidation from app.models.validations import ScolarFormSemestreValidation
from app.scodoc import sco_codes_parcours, sco_preferences from app.scodoc import codes_cursus, sco_preferences
from app.scodoc.sco_exceptions import ScoValueError from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission
from app.scodoc.sco_utils import MONTH_NAMES_ABBREV from app.scodoc.sco_utils import MONTH_NAMES_ABBREV
@ -276,7 +276,7 @@ class FormSemestre(db.Model):
- sont associées à l'un des parcours de ce formsemestre (ou à aucun) - sont associées à l'un des parcours de ce formsemestre (ou à aucun)
""" """
if self.formation.get_parcours().APC_SAE: if self.formation.get_cursus().APC_SAE:
sem_ues = UniteEns.query.filter_by( sem_ues = UniteEns.query.filter_by(
formation=self.formation, semestre_idx=self.semestre_id formation=self.formation, semestre_idx=self.semestre_id
) )
@ -294,7 +294,7 @@ class FormSemestre(db.Model):
UniteEns.id == Module.ue_id, UniteEns.id == Module.ue_id,
) )
if not with_sport: if not with_sport:
sem_ues = sem_ues.filter(UniteEns.type != sco_codes_parcours.UE_SPORT) sem_ues = sem_ues.filter(UniteEns.type != codes_cursus.UE_SPORT)
return sem_ues.order_by(UniteEns.numero) return sem_ues.order_by(UniteEns.numero)
def query_ues_parcours_etud(self, etudid: int) -> flask_sqlalchemy.BaseQuery: def query_ues_parcours_etud(self, etudid: int) -> flask_sqlalchemy.BaseQuery:
@ -598,7 +598,7 @@ class FormSemestre(db.Model):
if not imputation_dept: if not imputation_dept:
imputation_dept = prefs["DeptName"] imputation_dept = prefs["DeptName"]
imputation_dept = imputation_dept.upper() imputation_dept = imputation_dept.upper()
parcours_name = self.formation.get_parcours().NAME cursus_name = self.formation.get_cursus().NAME
modalite = self.modalite modalite = self.modalite
# exception pour code Apprentissage: # exception pour code Apprentissage:
modalite = (modalite or "").replace("FAP", "FA").replace("APP", "FA") modalite = (modalite or "").replace("FAP", "FA").replace("APP", "FA")
@ -611,7 +611,7 @@ class FormSemestre(db.Model):
scu.annee_scolaire_debut(self.date_debut.year, self.date_debut.month) scu.annee_scolaire_debut(self.date_debut.year, self.date_debut.month)
) )
return scu.sanitize_string( return scu.sanitize_string(
f"{imputation_dept}-{parcours_name}-{modalite}-{semestre_id}-{annee_sco}" f"{imputation_dept}-{cursus_name}-{modalite}-{semestre_id}-{annee_sco}"
) )
def titre_annee(self) -> str: def titre_annee(self) -> str:
@ -643,9 +643,9 @@ class FormSemestre(db.Model):
def titre_num(self) -> str: def titre_num(self) -> str:
"""Le titre et le semestre, ex ""DUT Informatique semestre 2"" """ """Le titre et le semestre, ex ""DUT Informatique semestre 2"" """
if self.semestre_id == sco_codes_parcours.NO_SEMESTRE_ID: if self.semestre_id == codes_cursus.NO_SEMESTRE_ID:
return self.titre return self.titre
return f"{self.titre} {self.formation.get_parcours().SESSION_NAME} {self.semestre_id}" return f"{self.titre} {self.formation.get_cursus().SESSION_NAME} {self.semestre_id}"
def sem_modalite(self) -> str: def sem_modalite(self) -> str:
"""Le semestre et la modalité, ex "S2 FI" ou "S3 APP" """ """Le semestre et la modalité, ex "S2 FI" ou "S3 APP" """

View File

@ -66,7 +66,7 @@ class ModuleImpl(db.Model):
"""true si les poids des évaluations du module permettent de satisfaire """true si les poids des évaluations du module permettent de satisfaire
les coefficients du PN. les coefficients du PN.
""" """
if not self.module.formation.get_parcours().APC_SAE or ( if not self.module.formation.get_cursus().APC_SAE or (
self.module.module_type != scu.ModuleType.RESSOURCE self.module.module_type != scu.ModuleType.RESSOURCE
and self.module.module_type != scu.ModuleType.SAE and self.module.module_type != scu.ModuleType.SAE
): ):

View File

@ -5,7 +5,7 @@ from app import db
from app.models import APO_CODE_STR_LEN from app.models import APO_CODE_STR_LEN
from app.models.but_refcomp import ApcParcours, app_critiques_modules, parcours_modules from app.models.but_refcomp import ApcParcours, app_critiques_modules, parcours_modules
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_exceptions import ScoValueError from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc.sco_utils import ModuleType from app.scodoc.sco_utils import ModuleType

View File

@ -52,7 +52,7 @@ from app.models import FormSemestre
from app.scodoc.gen_tables import GenTable, SeqGenTable from app.scodoc.gen_tables import GenTable, SeqGenTable
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
from app.scodoc import sco_codes_parcours # sco_codes_parcours.NEXT -> sem suivant from app.scodoc import codes_cursus # codes_cursus.NEXT -> sem suivant
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc import sco_formsemestre from app.scodoc import sco_formsemestre
from app.pe import pe_tagtable from app.pe import pe_tagtable
@ -68,7 +68,7 @@ def comp_nom_semestre_dans_parcours(sem):
from app.scodoc import sco_formations from app.scodoc import sco_formations
F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0] F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0]
parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"]) parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
return "%s %s %s %s" % ( return "%s %s %s %s" % (
parcours.SESSION_NAME, # eg "semestre" parcours.SESSION_NAME, # eg "semestre"
sem["semestre_id"], # eg 2 sem["semestre_id"], # eg 2
@ -457,9 +457,9 @@ class JuryPE(object):
reponse = False reponse = False
etud = self.get_cache_etudInfo_d_un_etudiant(etudid) etud = self.get_cache_etudInfo_d_un_etudiant(etudid)
(_, parcours) = sco_report.get_codeparcoursetud(etud) (_, parcours) = sco_report.get_code_cursus_etud(etud)
if ( if (
len(sco_codes_parcours.CODES_SEM_REO & set(parcours.values())) > 0 len(codes_cursus.CODES_SEM_REO & set(parcours.values())) > 0
): # Eliminé car NAR apparait dans le parcours ): # Eliminé car NAR apparait dans le parcours
reponse = True reponse = True
if pe_tools.PE_DEBUG and pe_tools.PE_DEBUG >= 2: if pe_tools.PE_DEBUG and pe_tools.PE_DEBUG >= 2:
@ -528,14 +528,14 @@ class JuryPE(object):
from app.scodoc import sco_report from app.scodoc import sco_report
etud = self.get_cache_etudInfo_d_un_etudiant(etudid) etud = self.get_cache_etudInfo_d_un_etudiant(etudid)
(code, parcours) = sco_report.get_codeparcoursetud( (code, parcours) = sco_report.get_code_cursus_etud(
etud etud
) # description = '1234:A', parcours = {1:ADM, 2:NAR, ...} ) # description = '1234:A', parcours = {1:ADM, 2:NAR, ...}
sonDernierSemestreValide = max( sonDernierSemestreValide = max(
[ [
int(cle) int(cle)
for (cle, code) in parcours.items() for (cle, code) in parcours.items()
if code in sco_codes_parcours.CODES_SEM_VALIDES if code in codes_cursus.CODES_SEM_VALIDES
] ]
+ [0] + [0]
) # n° du dernier semestre valide, 0 sinon ) # n° du dernier semestre valide, 0 sinon
@ -562,7 +562,7 @@ class JuryPE(object):
dec = nt.get_etud_decision_sem( dec = nt.get_etud_decision_sem(
etudid etudid
) # quelle est la décision du jury ? ) # quelle est la décision du jury ?
if dec and (dec["code"] in sco_codes_parcours.CODES_SEM_VALIDES): if dec and (dec["code"] in codes_cursus.CODES_SEM_VALIDES):
# isinstance( sesMoyennes[i+1], float) and # isinstance( sesMoyennes[i+1], float) and
# mT = sesMoyennes[i+1] # substitue la moyenne si le semestre suivant est "valide" # mT = sesMoyennes[i+1] # substitue la moyenne si le semestre suivant est "valide"
leFid = sem["formsemestre_id"] leFid = sem["formsemestre_id"]

View File

@ -43,7 +43,7 @@ from app.models import FormSemestre
from app.models.moduleimpls import ModuleImpl from app.models.moduleimpls import ModuleImpl
from app.pe import pe_tagtable from app.pe import pe_tagtable
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_tag_module from app.scodoc import sco_tag_module
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu
@ -116,7 +116,7 @@ class SemestreTag(pe_tagtable.TableTag):
self.modimpls = [ self.modimpls = [
modimpl modimpl
for modimpl in self.nt.formsemestre.modimpls_sorted for modimpl in self.nt.formsemestre.modimpls_sorted
if modimpl.module.ue.type == sco_codes_parcours.UE_STANDARD if modimpl.module.ue.type == codes_cursus.UE_STANDARD
] # la liste des modules (objet modimpl) ] # la liste des modules (objet modimpl)
self.somme_coeffs = sum( self.somme_coeffs = sum(
[ [

View File

@ -25,9 +25,10 @@
# #
############################################################################## ##############################################################################
"""Semestres: Codes gestion parcours (constantes) """Semestres: Codes gestion cursus (constantes)
Attention: ne pas confondre avec les "parcours" du BUT.
Renommage des anciens "parcours" -> "cursus" effectué en 9.4.41
""" """
import collections
import enum import enum
import numpy as np import numpy as np
@ -36,8 +37,8 @@ from app import log
@enum.unique @enum.unique
class CodesParcours(enum.IntEnum): class CodesCursus(enum.IntEnum):
"""Codes numériques des parcours, enregistrés en base """Codes numériques des cursus (ex parcours), enregistrés en base
dans notes_formations.type_parcours dans notes_formations.type_parcours
Ne pas modifier. Ne pas modifier.
""" """
@ -79,7 +80,7 @@ UE_STANDARD = 0 # UE "fondamentale"
UE_SPORT = 1 # bonus "sport" UE_SPORT = 1 # bonus "sport"
UE_STAGE_LP = 2 # ue "projet tuteuré et stage" dans les Lic. Pro. UE_STAGE_LP = 2 # ue "projet tuteuré et stage" dans les Lic. Pro.
UE_STAGE_10 = 3 # ue "stage" avec moyenne requise > 10 UE_STAGE_10 = 3 # ue "stage" avec moyenne requise > 10
UE_ELECTIVE = 4 # UE "élective" dans certains parcours (UCAC?, ISCID) UE_ELECTIVE = 4 # UE "élective" dans certains cursus (UCAC?, ISCID)
UE_PROFESSIONNELLE = 5 # UE "professionnelle" (ISCID, ...) UE_PROFESSIONNELLE = 5 # UE "professionnelle" (ISCID, ...)
UE_OPTIONNELLE = 6 # UE non fondamentales (ILEPS, ...) UE_OPTIONNELLE = 6 # UE non fondamentales (ILEPS, ...)
@ -274,7 +275,7 @@ DEVENIRS_NEXT2 = {NEXT_OR_NEXT2: 1, NEXT2: 1}
NO_SEMESTRE_ID = -1 # code semestre si pas de semestres NO_SEMESTRE_ID = -1 # code semestre si pas de semestres
# Règles gestion parcours # Règles gestion cursus
class DUTRule(object): class DUTRule(object):
def __init__(self, rule_id, premise, conclusion): def __init__(self, rule_id, premise, conclusion):
self.rule_id = rule_id self.rule_id = rule_id
@ -296,12 +297,12 @@ class DUTRule(object):
return True return True
# Types de parcours # Types de cursus
DEFAULT_TYPE_PARCOURS = 100 # pour le menu de creation nouvelle formation DEFAULT_TYPE_CURSUS = 100 # pour le menu de creation nouvelle formation
class TypeParcours(object): class TypeCursus:
TYPE_PARCOURS = None # id, utilisé par notes_formation.type_parcours TYPE_CURSUS = None # id, utilisé par notes_formation.type_parcours
NAME = None # required NAME = None # required
NB_SEM = 1 # Nombre de semestres NB_SEM = 1 # Nombre de semestres
COMPENSATION_UE = True # inutilisé COMPENSATION_UE = True # inutilisé
@ -315,9 +316,9 @@ class TypeParcours(object):
SESSION_NAME = "semestre" SESSION_NAME = "semestre"
SESSION_NAME_A = "du " SESSION_NAME_A = "du "
SESSION_ABBRV = "S" # S1, S2, ... SESSION_ABBRV = "S" # S1, S2, ...
UNUSED_CODES = set() # Ensemble des codes jury non autorisés dans ce parcours UNUSED_CODES = set() # Ensemble des codes jury non autorisés dans ce cursus
UE_IS_MODULE = False # 1 seul module par UE (si plusieurs modules, etudiants censéments inscrits à un seul d'entre eux) UE_IS_MODULE = False # 1 seul module par UE (si plusieurs modules, etudiants censéments inscrits à un seul d'entre eux)
ECTS_ONLY = False # Parcours avec progression basée uniquement sur les ECTS ECTS_ONLY = False # Cursus avec progression basée uniquement sur les ECTS
ALLOWED_UE_TYPES = list( ALLOWED_UE_TYPES = list(
UE_TYPE_NAME.keys() UE_TYPE_NAME.keys()
) # par defaut, autorise tous les types d'UE ) # par defaut, autorise tous les types d'UE
@ -363,18 +364,18 @@ class TypeParcours(object):
return False, """<b>%d UE sous la barre</b>""" % n return False, """<b>%d UE sous la barre</b>""" % n
# Parcours définis (instances de sous-classes de TypeParcours): # Cursus définis (instances de sous-classes de TypeCursus):
TYPES_PARCOURS = collections.OrderedDict() # type : Parcours SCO_CURSUS: dict[int, TypeCursus] = {} # type : Cursus
def register_parcours(Parcours): def register_cursus(cursus: TypeCursus):
TYPES_PARCOURS[int(Parcours.TYPE_PARCOURS)] = Parcours SCO_CURSUS[int(cursus.TYPE_CURSUS)] = cursus
class ParcoursBUT(TypeParcours): class CursusBUT(TypeCursus):
"""BUT Bachelor Universitaire de Technologie""" """BUT Bachelor Universitaire de Technologie"""
TYPE_PARCOURS = 700 TYPE_CURSUS = 700
NAME = "BUT" NAME = "BUT"
NB_SEM = 6 NB_SEM = 6
COMPENSATION_UE = False COMPENSATION_UE = False
@ -383,63 +384,63 @@ class ParcoursBUT(TypeParcours):
ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT] ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT]
register_parcours(ParcoursBUT()) register_cursus(CursusBUT())
class ParcoursDUT(TypeParcours): class CursusDUT(TypeCursus):
"""DUT selon l'arrêté d'août 2005""" """DUT selon l'arrêté d'août 2005"""
TYPE_PARCOURS = 100 TYPE_CURSUS = 100
NAME = "DUT" NAME = "DUT"
NB_SEM = 4 NB_SEM = 4
COMPENSATION_UE = True COMPENSATION_UE = True
ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT] ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT]
register_parcours(ParcoursDUT()) register_cursus(CursusDUT())
class ParcoursDUT4(ParcoursDUT): class CursusDUT4(CursusDUT):
"""DUT (en 4 semestres sans compensations)""" """DUT (en 4 semestres sans compensations)"""
TYPE_PARCOURS = 110 TYPE_CURSUS = 110
NAME = "DUT4" NAME = "DUT4"
COMPENSATION_UE = False COMPENSATION_UE = False
register_parcours(ParcoursDUT4()) register_cursus(CursusDUT4())
class ParcoursDUTMono(TypeParcours): class CursusDUTMono(TypeCursus):
"""DUT en un an (FC, Années spéciales)""" """DUT en un an (FC, Années spéciales)"""
TYPE_PARCOURS = 120 TYPE_CURSUS = 120
NAME = "DUT" NAME = "DUT"
NB_SEM = 1 NB_SEM = 1
COMPENSATION_UE = False COMPENSATION_UE = False
UNUSED_CODES = set((ADC, ATT, ATB)) UNUSED_CODES = set((ADC, ATT, ATB))
register_parcours(ParcoursDUTMono()) register_cursus(CursusDUTMono())
class ParcoursDUT2(ParcoursDUT): class CursusDUT2(CursusDUT):
"""DUT en deux semestres (par ex.: années spéciales semestrialisées)""" """DUT en deux semestres (par ex.: années spéciales semestrialisées)"""
TYPE_PARCOURS = CodesParcours.DUT2 TYPE_CURSUS = CodesCursus.DUT2
NAME = "DUT2" NAME = "DUT2"
NB_SEM = 2 NB_SEM = 2
register_parcours(ParcoursDUT2()) register_cursus(CursusDUT2())
class ParcoursLP(TypeParcours): class CursusLP(TypeCursus):
"""Licence Pro (en un "semestre") """Licence Pro (en un "semestre")
(pour anciennes LP. Après 2014, préférer ParcoursLP2014) (pour anciennes LP. Après 2014, préférer CursusLP2014)
""" """
TYPE_PARCOURS = CodesParcours.LP TYPE_CURSUS = CodesCursus.LP
NAME = "LP" NAME = "LP"
NB_SEM = 1 NB_SEM = 1
COMPENSATION_UE = False COMPENSATION_UE = False
@ -450,35 +451,35 @@ class ParcoursLP(TypeParcours):
UNUSED_CODES = set((ADC, ATT, ATB)) UNUSED_CODES = set((ADC, ATT, ATB))
register_parcours(ParcoursLP()) register_cursus(CursusLP())
class ParcoursLP2sem(ParcoursLP): class CursusLP2sem(CursusLP):
"""Licence Pro (en deux "semestres")""" """Licence Pro (en deux "semestres")"""
TYPE_PARCOURS = CodesParcours.LP2sem TYPE_CURSUS = CodesCursus.LP2sem
NAME = "LP2sem" NAME = "LP2sem"
NB_SEM = 2 NB_SEM = 2
COMPENSATION_UE = True COMPENSATION_UE = True
UNUSED_CODES = set((ADC,)) # autorise les codes ATT et ATB, mais pas ADC. UNUSED_CODES = set((ADC,)) # autorise les codes ATT et ATB, mais pas ADC.
register_parcours(ParcoursLP2sem()) register_cursus(CursusLP2sem())
class ParcoursLP2semEvry(ParcoursLP): class CursusLP2semEvry(CursusLP):
"""Licence Pro (en deux "semestres", U. Evry)""" """Licence Pro (en deux "semestres", U. Evry)"""
TYPE_PARCOURS = CodesParcours.LP2semEvry TYPE_CURSUS = CodesCursus.LP2semEvry
NAME = "LP2semEvry" NAME = "LP2semEvry"
NB_SEM = 2 NB_SEM = 2
COMPENSATION_UE = True COMPENSATION_UE = True
register_parcours(ParcoursLP2semEvry()) register_cursus(CursusLP2semEvry())
class ParcoursLP2014(TypeParcours): class CursusLP2014(TypeCursus):
"""Licence Pro (en un "semestre"), selon arrêté du 22/01/2014""" """Licence Pro (en un "semestre"), selon arrêté du 22/01/2014"""
# Note: texte de référence # Note: texte de référence
@ -495,7 +496,7 @@ class ParcoursLP2014(TypeParcours):
# l'établissement d'un coefficient qui peut varier dans un rapport de 1 à 3. ", etc ne sont _pas_ # l'établissement d'un coefficient qui peut varier dans un rapport de 1 à 3. ", etc ne sont _pas_
# vérifiés par ScoDoc) # vérifiés par ScoDoc)
TYPE_PARCOURS = CodesParcours.LP2014 TYPE_CURSUS = CodesCursus.LP2014
NAME = "LP2014" NAME = "LP2014"
NB_SEM = 1 NB_SEM = 1
ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT, UE_STAGE_LP] ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT, UE_STAGE_LP]
@ -533,74 +534,74 @@ class ParcoursLP2014(TypeParcours):
return True, "" # pas de coef, condition ok return True, "" # pas de coef, condition ok
register_parcours(ParcoursLP2014()) register_cursus(CursusLP2014())
class ParcoursLP2sem2014(ParcoursLP): class CursusLP2sem2014(CursusLP):
"""Licence Pro (en deux "semestres", selon arrêté du 22/01/2014)""" """Licence Pro (en deux "semestres", selon arrêté du 22/01/2014)"""
TYPE_PARCOURS = CodesParcours.LP2sem2014 TYPE_CURSUS = CodesCursus.LP2sem2014
NAME = "LP2014_2sem" NAME = "LP2014_2sem"
NB_SEM = 2 NB_SEM = 2
register_parcours(ParcoursLP2sem2014()) register_cursus(CursusLP2sem2014())
# Masters: M2 en deux semestres # Masters: M2 en deux semestres
class ParcoursM2(TypeParcours): class CursusM2(TypeCursus):
"""Master 2 (en deux "semestres")""" """Master 2 (en deux "semestres")"""
TYPE_PARCOURS = CodesParcours.M2 TYPE_CURSUS = CodesCursus.M2
NAME = "M2sem" NAME = "M2sem"
NB_SEM = 2 NB_SEM = 2
COMPENSATION_UE = True COMPENSATION_UE = True
UNUSED_CODES = set((ATT, ATB)) UNUSED_CODES = set((ATT, ATB))
register_parcours(ParcoursM2()) register_cursus(CursusM2())
class ParcoursM2noncomp(ParcoursM2): class CursusM2noncomp(CursusM2):
"""Master 2 (en deux "semestres") sans compensation""" """Master 2 (en deux "semestres") sans compensation"""
TYPE_PARCOURS = CodesParcours.M2noncomp TYPE_CURSUS = CodesCursus.M2noncomp
NAME = "M2noncomp" NAME = "M2noncomp"
COMPENSATION_UE = False COMPENSATION_UE = False
UNUSED_CODES = set((ADC, ATT, ATB)) UNUSED_CODES = set((ADC, ATT, ATB))
register_parcours(ParcoursM2noncomp()) register_cursus(CursusM2noncomp())
class ParcoursMono(TypeParcours): class CursusMono(TypeCursus):
"""Formation générique en une session""" """Formation générique en une session"""
TYPE_PARCOURS = CodesParcours.Mono TYPE_CURSUS = CodesCursus.Mono
NAME = "Mono" NAME = "Mono"
NB_SEM = 1 NB_SEM = 1
COMPENSATION_UE = False COMPENSATION_UE = False
UNUSED_CODES = set((ADC, ATT, ATB)) UNUSED_CODES = set((ADC, ATT, ATB))
register_parcours(ParcoursMono()) register_cursus(CursusMono())
class ParcoursLegacy(TypeParcours): class CursusLegacy(TypeCursus):
"""DUT (ancien ScoDoc, ne plus utiliser)""" """DUT (ancien ScoDoc, ne plus utiliser)"""
TYPE_PARCOURS = CodesParcours.Legacy TYPE_CURSUS = CodesCursus.Legacy
NAME = "DUT" NAME = "DUT"
NB_SEM = 4 NB_SEM = 4
COMPENSATION_UE = None # backward compat: defini dans formsemestre COMPENSATION_UE = None # backward compat: defini dans formsemestre
ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT] ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT]
register_parcours(ParcoursLegacy()) register_cursus(CursusLegacy())
class ParcoursISCID(TypeParcours): class CursusISCID(TypeCursus):
"""Superclasse pour les parcours de l'ISCID""" """Superclasse pour les cursus de l'ISCID"""
# SESSION_NAME = "année" # SESSION_NAME = "année"
# SESSION_NAME_A = "de l'" # SESSION_NAME_A = "de l'"
@ -619,32 +620,32 @@ class ParcoursISCID(TypeParcours):
ECTS_PROF_DIPL = 0 # crédits professionnels requis pour obtenir le diplôme ECTS_PROF_DIPL = 0 # crédits professionnels requis pour obtenir le diplôme
class ParcoursBachelorISCID6(ParcoursISCID): class CursusBachelorISCID6(CursusISCID):
"""ISCID: Bachelor en 3 ans (6 sem.)""" """ISCID: Bachelor en 3 ans (6 sem.)"""
NAME = "ParcoursBachelorISCID6" NAME = "CursusBachelorISCID6"
TYPE_PARCOURS = CodesParcours.ISCID6 TYPE_CURSUS = CodesCursus.ISCID6
NAME = "" NAME = ""
NB_SEM = 6 NB_SEM = 6
ECTS_PROF_DIPL = 8 # crédits professionnels requis pour obtenir le diplôme ECTS_PROF_DIPL = 8 # crédits professionnels requis pour obtenir le diplôme
register_parcours(ParcoursBachelorISCID6()) register_cursus(CursusBachelorISCID6())
class ParcoursMasterISCID4(ParcoursISCID): class CursusMasterISCID4(CursusISCID):
"ISCID: Master en 2 ans (4 sem.)" "ISCID: Master en 2 ans (4 sem.)"
TYPE_PARCOURS = CodesParcours.ISCID4 TYPE_CURSUS = CodesCursus.ISCID4
NAME = "ParcoursMasterISCID4" NAME = "CursusMasterISCID4"
NB_SEM = 4 NB_SEM = 4
ECTS_PROF_DIPL = 15 # crédits professionnels requis pour obtenir le diplôme ECTS_PROF_DIPL = 15 # crédits professionnels requis pour obtenir le diplôme
register_parcours(ParcoursMasterISCID4()) register_cursus(CursusMasterISCID4())
class ParcoursILEPS(TypeParcours): class CursusILEPS(TypeCursus):
"""Superclasse pour les parcours de l'ILEPS""" """Superclasse pour les cursus de l'ILEPS"""
# SESSION_NAME = "année" # SESSION_NAME = "année"
# SESSION_NAME_A = "de l'" # SESSION_NAME_A = "de l'"
@ -660,18 +661,18 @@ class ParcoursILEPS(TypeParcours):
BARRE_UE_DEFAULT = 0.0 # pas de barre sur les autres UE BARRE_UE_DEFAULT = 0.0 # pas de barre sur les autres UE
class ParcoursLicenceILEPS6(ParcoursILEPS): class CursusLicenceILEPS6(CursusILEPS):
"""ILEPS: Licence 6 semestres""" """ILEPS: Licence 6 semestres"""
TYPE_PARCOURS = 1010 TYPE_CURSUS = 1010
NAME = "LicenceILEPS6" NAME = "LicenceILEPS6"
NB_SEM = 6 NB_SEM = 6
register_parcours(ParcoursLicenceILEPS6()) register_cursus(CursusLicenceILEPS6())
class ParcoursUCAC(TypeParcours): class CursusUCAC(TypeCursus):
"""Règles de validation UCAC""" """Règles de validation UCAC"""
SESSION_NAME = "année" SESSION_NAME = "année"
@ -685,79 +686,79 @@ class ParcoursUCAC(TypeParcours):
) )
class ParcoursLicenceUCAC3(ParcoursUCAC): class CursusLicenceUCAC3(CursusUCAC):
"""UCAC: Licence en 3 sessions d'un an""" """UCAC: Licence en 3 sessions d'un an"""
TYPE_PARCOURS = CodesParcours.LicenceUCAC3 TYPE_CURSUS = CodesCursus.LicenceUCAC3
NAME = "Licence UCAC en 3 sessions d'un an" NAME = "Licence UCAC en 3 sessions d'un an"
NB_SEM = 3 NB_SEM = 3
register_parcours(ParcoursLicenceUCAC3()) register_cursus(CursusLicenceUCAC3())
class ParcoursMasterUCAC2(ParcoursUCAC): class CursusMasterUCAC2(CursusUCAC):
"""UCAC: Master en 2 sessions d'un an""" """UCAC: Master en 2 sessions d'un an"""
TYPE_PARCOURS = CodesParcours.MasterUCAC2 TYPE_CURSUS = CodesCursus.MasterUCAC2
NAME = "Master UCAC en 2 sessions d'un an" NAME = "Master UCAC en 2 sessions d'un an"
NB_SEM = 2 NB_SEM = 2
register_parcours(ParcoursMasterUCAC2()) register_cursus(CursusMasterUCAC2())
class ParcoursMonoUCAC(ParcoursUCAC): class CursusMonoUCAC(CursusUCAC):
"""UCAC: Formation en 1 session de durée variable""" """UCAC: Formation en 1 session de durée variable"""
TYPE_PARCOURS = CodesParcours.MonoUCAC TYPE_CURSUS = CodesCursus.MonoUCAC
NAME = "Formation UCAC en 1 session de durée variable" NAME = "Formation UCAC en 1 session de durée variable"
NB_SEM = 1 NB_SEM = 1
UNUSED_CODES = set((ADC, ATT, ATB)) UNUSED_CODES = set((ADC, ATT, ATB))
register_parcours(ParcoursMonoUCAC()) register_cursus(CursusMonoUCAC())
class Parcours6Sem(TypeParcours): class Cursus6Sem(TypeCursus):
"""Parcours générique en 6 semestres""" """Cursus générique en 6 semestres"""
TYPE_PARCOURS = CodesParcours.GEN_6_SEM TYPE_CURSUS = CodesCursus.GEN_6_SEM
NAME = "Formation en 6 semestres" NAME = "Formation en 6 semestres"
NB_SEM = 6 NB_SEM = 6
COMPENSATION_UE = True COMPENSATION_UE = True
register_parcours(Parcours6Sem()) register_cursus(Cursus6Sem())
# # En cours d'implémentation: # # En cours d'implémentation:
# class ParcoursLicenceLMD(TypeParcours): # class CursusLicenceLMD(TypeCursus):
# """Licence standard en 6 semestres dans le LMD""" # """Licence standard en 6 semestres dans le LMD"""
# TYPE_PARCOURS = 401 # TYPE_CURSUS = 401
# NAME = "Licence LMD" # NAME = "Licence LMD"
# NB_SEM = 6 # NB_SEM = 6
# COMPENSATION_UE = True # COMPENSATION_UE = True
# register_parcours(ParcoursLicenceLMD()) # register_cursus(CursusLicenceLMD())
class ParcoursMasterLMD(TypeParcours): class CursusMasterLMD(TypeCursus):
"""Master générique en 4 semestres dans le LMD""" """Master générique en 4 semestres dans le LMD"""
TYPE_PARCOURS = CodesParcours.MasterLMD TYPE_CURSUS = CodesCursus.MasterLMD
NAME = "Master LMD" NAME = "Master LMD"
NB_SEM = 4 NB_SEM = 4
COMPENSATION_UE = True # variabale inutilisée COMPENSATION_UE = True # variabale inutilisée
UNUSED_CODES = set((ADC, ATT, ATB)) UNUSED_CODES = set((ADC, ATT, ATB))
register_parcours(ParcoursMasterLMD()) register_cursus(CursusMasterLMD())
class ParcoursMasterIG(ParcoursMasterLMD): class CursusMasterIG(CursusMasterLMD):
"""Master de l'Institut Galilée (U. Paris 13) en 4 semestres (LMD)""" """Master de l'Institut Galilée (U. Paris 13) en 4 semestres (LMD)"""
TYPE_PARCOURS = CodesParcours.MasterIG TYPE_CURSUS = CodesCursus.MasterIG
NAME = "Master IG P13" NAME = "Master IG P13"
BARRE_MOY = 10.0 BARRE_MOY = 10.0
NOTES_BARRE_VALID_UE_TH = 10.0 # seuil pour valider UE NOTES_BARRE_VALID_UE_TH = 10.0 # seuil pour valider UE
@ -767,7 +768,7 @@ class ParcoursMasterIG(ParcoursMasterLMD):
BARRE_MOY_UE_STAGE = 10.0 BARRE_MOY_UE_STAGE = 10.0
ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT, UE_STAGE_10] ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT, UE_STAGE_10]
def check_barre_ues(self, ues_status): # inspire de la fonction de ParcoursLP2014 def check_barre_ues(self, ues_status): # inspire de la fonction de CursusLP2014
"""True si la ou les conditions sur les UE sont valides """True si la ou les conditions sur les UE sont valides
moyenne d'UE > 7, ou > 10 si UE de stage moyenne d'UE > 7, ou > 10 si UE de stage
""" """
@ -806,10 +807,10 @@ class ParcoursMasterIG(ParcoursMasterLMD):
return True, "" # pas de coef, condition ok return True, "" # pas de coef, condition ok
register_parcours(ParcoursMasterIG()) register_cursus(CursusMasterIG())
# Ajouter ici vos parcours, le TYPE_PARCOURS devant être unique au monde # Ajouter ici vos cursus, le TYPE_CURSUS devant être unique au monde
# (avisez sur la liste de diffusion) # (avisez sur la liste de diffusion)
@ -817,16 +818,16 @@ register_parcours(ParcoursMasterIG())
# ------------------------- # -------------------------
_tp = list(TYPES_PARCOURS.items()) _tp = list(SCO_CURSUS.items())
_tp.sort(key=lambda x: x[1].__doc__) # sort by intitulé _tp.sort(key=lambda x: x[1].__doc__) # sort by intitulé
FORMATION_PARCOURS_DESCRS = [p[1].__doc__ for p in _tp] # intitulés (eg pour menu) FORMATION_CURSUS_DESCRS = [p[1].__doc__ for p in _tp] # intitulés (eg pour menu)
FORMATION_PARCOURS_TYPES = [p[0] for p in _tp] # codes numeriques (TYPE_PARCOURS) FORMATION_CURSUS_TYPES = [p[0] for p in _tp] # codes numeriques (TYPE_CURSUS)
def get_parcours_from_code(code_parcours): def get_cursus_from_code(code_cursus):
parcours = TYPES_PARCOURS.get(code_parcours) cursus = SCO_CURSUS.get(code_cursus)
if parcours is None: if cursus is None:
log(f"Warning: invalid code_parcours: {code_parcours}") log(f"Warning: invalid code_cursus: {code_cursus}")
# default to legacy # default to legacy
parcours = TYPES_PARCOURS.get(0) cursus = SCO_CURSUS.get(0)
return parcours return cursus

View File

@ -4,7 +4,7 @@
# #
# Command: ./csv2rules.py misc/parcoursDUT.csv # Command: ./csv2rules.py misc/parcoursDUT.csv
# #
from app.scodoc.sco_codes_parcours import ( from app.scodoc.codes_cursus import (
DUTRule, DUTRule,
ADC, ADC,
ADJ, ADJ,

View File

@ -48,14 +48,14 @@ from app.scodoc.sco_formsemestre import (
formsemestre_uecoef_list, formsemestre_uecoef_list,
formsemestre_uecoef_create, formsemestre_uecoef_create,
) )
from app.scodoc.sco_codes_parcours import ( from app.scodoc.codes_cursus import (
DEF, DEF,
UE_SPORT, UE_SPORT,
ue_is_fondamentale, ue_is_fondamentale,
ue_is_professionnelle, ue_is_professionnelle,
) )
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_compute_moy from app.scodoc import sco_compute_moy
from app.scodoc.sco_cursus import formsemestre_get_etud_capitalisation from app.scodoc.sco_cursus import formsemestre_get_etud_capitalisation
from app.scodoc import sco_cursus_dut from app.scodoc import sco_cursus_dut
@ -244,7 +244,7 @@ class NotesTable:
self.formation = sco_formations.formation_list( self.formation = sco_formations.formation_list(
args={"formation_id": self.sem["formation_id"]} args={"formation_id": self.sem["formation_id"]}
)[0] )[0]
self.parcours = sco_codes_parcours.get_parcours_from_code( self.parcours = codes_cursus.get_cursus_from_code(
self.formation["type_parcours"] self.formation["type_parcours"]
) )
@ -1048,7 +1048,7 @@ class NotesTable:
decisions_jury_ues[etudid] = {} decisions_jury_ues[etudid] = {}
# Calcul des ECTS associes a cette UE: # Calcul des ECTS associes a cette UE:
ects = 0.0 ects = 0.0
if sco_codes_parcours.code_ue_validant(code): if codes_cursus.code_ue_validant(code):
ue = self.uedict.get(ue_id, None) ue = self.uedict.get(ue_id, None)
if ue is None: # not in list for this sem ??? (probably an error) if ue is None: # not in list for this sem ??? (probably an error)
log( log(

View File

@ -106,8 +106,8 @@ import app.scodoc.sco_utils as scu
from app.scodoc.sco_exceptions import ScoValueError, ScoFormatError from app.scodoc.sco_exceptions import ScoValueError, ScoFormatError
from app.scodoc.gen_tables import GenTable from app.scodoc.gen_tables import GenTable
from app.scodoc.sco_vdi import ApoEtapeVDI from app.scodoc.sco_vdi import ApoEtapeVDI
from app.scodoc.sco_codes_parcours import code_semestre_validant from app.scodoc.codes_cursus import code_semestre_validant
from app.scodoc.sco_codes_parcours import ( from app.scodoc.codes_cursus import (
DEF, DEF,
DEM, DEM,
NAR, NAR,

View File

@ -53,7 +53,7 @@ from app.scodoc import sco_bulletins_generator
from app.scodoc import sco_bulletins_json from app.scodoc import sco_bulletins_json
from app.scodoc import sco_bulletins_pdf from app.scodoc import sco_bulletins_pdf
from app.scodoc import sco_bulletins_xml from app.scodoc import sco_bulletins_xml
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc import sco_evaluation_db from app.scodoc import sco_evaluation_db
from app.scodoc import sco_formations from app.scodoc import sco_formations
@ -174,9 +174,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
"version": 0, "version": 0,
} }
I["formation"] = formation_dict I["formation"] = formation_dict
I["parcours"] = sco_codes_parcours.get_parcours_from_code( I["parcours"] = codes_cursus.get_cursus_from_code(I["formation"]["type_parcours"])
I["formation"]["type_parcours"]
)
# Infos sur l'etudiant # Infos sur l'etudiant
I["etud"] = sco_etud.get_etud_info(etudid=etudid, filled=True)[0] I["etud"] = sco_etud.get_etud_info(etudid=etudid, filled=True)[0]
I["descr_situation"] = I["etud"]["inscriptionstr"] I["descr_situation"] = I["etud"]["inscriptionstr"]
@ -222,7 +220,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
I["demission"] = "" I["demission"] = ""
if I["etud_etat"] == scu.DEMISSION: if I["etud_etat"] == scu.DEMISSION:
I["demission"] = "(Démission)" I["demission"] = "(Démission)"
elif I["etud_etat"] == sco_codes_parcours.DEF: elif I["etud_etat"] == codes_cursus.DEF:
I["demission"] = "(Défaillant)" I["demission"] = "(Défaillant)"
# --- Appreciations # --- Appreciations
@ -239,9 +237,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
I["mention"] = "" I["mention"] = ""
if dpv: if dpv:
decision_sem = dpv["decisions"][0]["decision_sem"] decision_sem = dpv["decisions"][0]["decision_sem"]
if decision_sem and sco_codes_parcours.code_semestre_validant( if decision_sem and codes_cursus.code_semestre_validant(decision_sem["code"]):
decision_sem["code"]
):
I["mention"] = scu.get_mention(moy_gen) I["mention"] = scu.get_mention(moy_gen)
if dpv and dpv["decisions"][0]: if dpv and dpv["decisions"][0]:
@ -307,7 +303,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
continue continue
u["ue_status"] = ue_status # { 'moy', 'coef_ue', ...} u["ue_status"] = ue_status # { 'moy', 'coef_ue', ...}
if ue["type"] != sco_codes_parcours.UE_SPORT: if ue["type"] != codes_cursus.UE_SPORT:
u["cur_moy_ue_txt"] = scu.fmt_note(ue_status["cur_moy_ue"]) u["cur_moy_ue_txt"] = scu.fmt_note(ue_status["cur_moy_ue"])
else: else:
if nt.bonus is not None: if nt.bonus is not None:
@ -335,7 +331,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
and ue["ue_id"] in dpv["decisions"][0]["decisions_ue"] and ue["ue_id"] in dpv["decisions"][0]["decisions_ue"]
): ):
u["ects"] = dpv["decisions"][0]["decisions_ue"][ue["ue_id"]]["ects"] u["ects"] = dpv["decisions"][0]["decisions_ue"][ue["ue_id"]]["ects"]
if ue["type"] == sco_codes_parcours.UE_ELECTIVE: if ue["type"] == codes_cursus.UE_ELECTIVE:
u["ects"] = ( u["ects"] = (
"%g+" % u["ects"] "%g+" % u["ects"]
) # ajoute un "+" pour indiquer ECTS d'une UE élective ) # ajoute un "+" pour indiquer ECTS d'une UE élective
@ -388,7 +384,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
_sort_mod_by_matiere(u["modules_capitalized"], nt_cap, etudid) _sort_mod_by_matiere(u["modules_capitalized"], nt_cap, etudid)
) )
else: else:
if prefs["bul_show_ue_rangs"] and ue["type"] != sco_codes_parcours.UE_SPORT: if prefs["bul_show_ue_rangs"] and ue["type"] != codes_cursus.UE_SPORT:
if ue_attente or nt.ue_rangs[ue["ue_id"]][0] is None: if ue_attente or nt.ue_rangs[ue["ue_id"]][0] is None:
u["ue_descr_txt"] = "%s/%s" % ( u["ue_descr_txt"] = "%s/%s" % (
scu.RANG_ATTENTE_STR, scu.RANG_ATTENTE_STR,

View File

@ -63,7 +63,7 @@ from app import log, ScoValueError
from app.models import FormSemestre from app.models import FormSemestre
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_pdf from app.scodoc import sco_pdf
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
from app.scodoc import sco_etud from app.scodoc import sco_etud
@ -286,7 +286,7 @@ def get_filigranne(etud_etat: str, prefs, decision_sem=None) -> str:
"""Texte à placer en "filigranne" sur le bulletin pdf""" """Texte à placer en "filigranne" sur le bulletin pdf"""
if etud_etat == scu.DEMISSION: if etud_etat == scu.DEMISSION:
return "Démission" return "Démission"
elif etud_etat == sco_codes_parcours.DEF: elif etud_etat == codes_cursus.DEF:
return "Défaillant" return "Défaillant"
elif (prefs["bul_show_temporary"] and not decision_sem) or prefs[ elif (prefs["bul_show_temporary"] and not decision_sem) or prefs[
"bul_show_temporary_forced" "bul_show_temporary_forced"

View File

@ -56,7 +56,7 @@ import app.scodoc.sco_utils as scu
from app.scodoc.sco_pdf import SU, make_paras from app.scodoc.sco_pdf import SU, make_paras
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission
from app.scodoc.sco_codes_parcours import ( from app.scodoc.codes_cursus import (
UE_COLORS, UE_COLORS,
UE_DEFAULT_COLOR, UE_DEFAULT_COLOR,
UE_ELECTIVE, UE_ELECTIVE,

View File

@ -52,7 +52,7 @@ from app import log
from app.but.bulletin_but_xml_compat import bulletin_but_xml_compat from app.but.bulletin_but_xml_compat import bulletin_but_xml_compat
from app.models.formsemestre import FormSemestre from app.models.formsemestre import FormSemestre
from app.scodoc import sco_abs from app.scodoc import sco_abs
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_edit_ue from app.scodoc import sco_edit_ue
from app.scodoc import sco_evaluation_db from app.scodoc import sco_evaluation_db
from app.scodoc import sco_formsemestre from app.scodoc import sco_formsemestre
@ -218,7 +218,7 @@ def make_xml_formsemestre_bulletinetud(
code_apogee=quote_xml_attr(ue["code_apogee"]), code_apogee=quote_xml_attr(ue["code_apogee"]),
) )
doc.append(x_ue) doc.append(x_ue)
if ue["type"] != sco_codes_parcours.UE_SPORT: if ue["type"] != codes_cursus.UE_SPORT:
v = ue_status["cur_moy_ue"] if ue_status else "" v = ue_status["cur_moy_ue"] if ue_status else ""
else: else:
v = nt.bonus[etudid] if nt.bonus is not None else 0.0 v = nt.bonus[etudid] if nt.bonus is not None else 0.0

View File

@ -98,7 +98,7 @@ CONFIG.PUBLISH_PORTAL_PHOTO_URL = False
# (le test cracklib.FascistCheck s'appliquera dans tous les cas) # (le test cracklib.FascistCheck s'appliquera dans tous les cas)
CONFIG.MIN_PASSWORD_LENGTH = 0 CONFIG.MIN_PASSWORD_LENGTH = 0
# Ce dictionnaire est fusionné à celui de sco_codes_parcours # Ce dictionnaire est fusionné à celui de codes_cursus
# pour définir les codes jury et explications associées # pour définir les codes jury et explications associées
CONFIG.CODES_EXPL = { CONFIG.CODES_EXPL = {
# AJ : 'Ajourné (échec)', # AJ : 'Ajourné (échec)',

View File

@ -40,7 +40,7 @@ from app.scodoc.scolog import logdb
from app.scodoc import sco_cache, sco_etud from app.scodoc import sco_cache, sco_etud
from app.scodoc import sco_formsemestre from app.scodoc import sco_formsemestre
from app.scodoc import sco_formations from app.scodoc import sco_formations
from app.scodoc.sco_codes_parcours import ( from app.scodoc.codes_cursus import (
CMP, CMP,
ADC, ADC,
ADJ, ADJ,
@ -353,7 +353,7 @@ class SituationEtudCursusClassic(SituationEtudCursus):
l'étudiant (quelle que soit la formation), le plus ancien en tête""" l'étudiant (quelle que soit la formation), le plus ancien en tête"""
return self.sems return self.sems
def get_parcours_descr(self, filter_futur=False): def get_cursus_descr(self, filter_futur=False):
"""Description brève du parcours: "S1, S2, ..." """Description brève du parcours: "S1, S2, ..."
Si filter_futur, ne mentionne pas les semestres qui sont après le semestre courant. Si filter_futur, ne mentionne pas les semestres qui sont après le semestre courant.
""" """

View File

@ -31,7 +31,7 @@ from app import db
from app.but import apc_edit_ue from app.but import apc_edit_ue
from app.models import UniteEns, Matiere, Module, FormSemestre, ModuleImpl from app.models import UniteEns, Matiere, Module, FormSemestre, ModuleImpl
from app.models.validations import ScolarFormSemestreValidation from app.models.validations import ScolarFormSemestreValidation
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
from app.scodoc import sco_groups from app.scodoc import sco_groups
from app.scodoc.sco_utils import ModuleType from app.scodoc.sco_utils import ModuleType
@ -48,8 +48,8 @@ def html_edit_formation_apc(
- Les ressources - Les ressources
- Les SAÉs - Les SAÉs
""" """
parcours = formation.get_parcours() cursus = formation.get_cursus()
assert parcours.APC_SAE assert cursus.APC_SAE
ressources = formation.modules.filter_by(module_type=ModuleType.RESSOURCE).order_by( ressources = formation.modules.filter_by(module_type=ModuleType.RESSOURCE).order_by(
Module.semestre_id, Module.numero, Module.code Module.semestre_id, Module.numero, Module.code
@ -58,7 +58,7 @@ def html_edit_formation_apc(
Module.semestre_id, Module.numero, Module.code Module.semestre_id, Module.numero, Module.code
) )
if semestre_idx is None: if semestre_idx is None:
semestre_ids = range(1, parcours.NB_SEM + 1) semestre_ids = range(1, cursus.NB_SEM + 1)
else: else:
semestre_ids = [semestre_idx] semestre_ids = [semestre_idx]
other_modules = formation.modules.filter( other_modules = formation.modules.filter(

View File

@ -46,7 +46,7 @@ from app.scodoc.sco_exceptions import ScoValueError, ScoNonEmptyFormationObject
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_edit_ue from app.scodoc import sco_edit_ue
from app.scodoc import sco_formations from app.scodoc import sco_formations
from app.scodoc import sco_formsemestre from app.scodoc import sco_formsemestre
@ -157,7 +157,7 @@ def formation_edit(formation_id=None, create=False):
""", """,
] ]
submitlabel = "Créer cette formation" submitlabel = "Créer cette formation"
initvalues = {"type_parcours": sco_codes_parcours.DEFAULT_TYPE_PARCOURS} initvalues = {"type_parcours": codes_cursus.DEFAULT_TYPE_CURSUS}
is_locked = False is_locked = False
else: else:
# edit an existing formation # edit an existing formation
@ -211,8 +211,8 @@ def formation_edit(formation_id=None, create=False):
"input_type": "menu", "input_type": "menu",
"title": "Type de parcours", "title": "Type de parcours",
"type": "int", "type": "int",
"allowed_values": sco_codes_parcours.FORMATION_PARCOURS_TYPES, "allowed_values": codes_cursus.FORMATION_CURSUS_TYPES,
"labels": sco_codes_parcours.FORMATION_PARCOURS_DESCRS, "labels": codes_cursus.FORMATION_CURSUS_DESCRS,
"explanation": "détermine notamment le nombre de semestres et les règles de validation d'UE et de semestres (barres)", "explanation": "détermine notamment le nombre de semestres et les règles de validation d'UE et de semestres (barres)",
"readonly": is_locked, "readonly": is_locked,
}, },

View File

@ -52,7 +52,7 @@ from app.scodoc.sco_exceptions import (
ScoNonEmptyFormationObject, ScoNonEmptyFormationObject,
) )
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_edit_matiere from app.scodoc import sco_edit_matiere
from app.scodoc import sco_moduleimpl from app.scodoc import sco_moduleimpl
@ -300,7 +300,7 @@ def module_edit(
formation = module.formation formation = module.formation
unlocked = not module_is_locked(module_id) unlocked = not module_is_locked(module_id)
parcours = sco_codes_parcours.get_parcours_from_code(formation.type_parcours) parcours = codes_cursus.get_cursus_from_code(formation.type_parcours)
is_apc = parcours.APC_SAE # BUT is_apc = parcours.APC_SAE # BUT
if not create: if not create:
orig_semestre_idx = module.ue.semestre_idx if is_apc else module.semestre_id orig_semestre_idx = module.ue.semestre_idx if is_apc else module.semestre_id
@ -724,7 +724,7 @@ def module_edit(
) )
] ]
else: else:
if module.ue.type == sco_codes_parcours.UE_STANDARD: if module.ue.type == codes_cursus.UE_STANDARD:
descr += [ descr += [
( (
"app_critiques", "app_critiques",
@ -957,7 +957,7 @@ def formation_add_malus_modules(
if semestre_id is not None: if semestre_id is not None:
ues = ues.filter_by(semestre_idx=semestre_id) ues = ues.filter_by(semestre_idx=semestre_id)
for ue in ues: for ue in ues:
if ue.type == sco_codes_parcours.UE_STANDARD: if ue.type == codes_cursus.UE_STANDARD:
if ue_add_malus_module(ue, titre=titre) != None: if ue_add_malus_module(ue, titre=titre) != None:
nb += 1 nb += 1

View File

@ -59,7 +59,7 @@ from app.scodoc.sco_exceptions import (
) )
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_edit_apc from app.scodoc import sco_edit_apc
from app.scodoc import sco_edit_matiere from app.scodoc import sco_edit_matiere
from app.scodoc import sco_edit_module from app.scodoc import sco_edit_module
@ -273,9 +273,9 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
formation = Formation.query.get(formation_id) formation = Formation.query.get(formation_id)
if not formation: if not formation:
raise ScoValueError(f"Formation inexistante ! (id={formation_id})") raise ScoValueError(f"Formation inexistante ! (id={formation_id})")
parcours = formation.get_parcours() cursus = formation.get_cursus()
is_apc = parcours.APC_SAE is_apc = cursus.APC_SAE
semestres_indices = list(range(1, parcours.NB_SEM + 1)) semestres_indices = list(range(1, cursus.NB_SEM + 1))
H = [ H = [
html_sco_header.sco_header(page_title=title, javascripts=["js/edit_ue.js"]), html_sco_header.sco_header(page_title=title, javascripts=["js/edit_ue.js"]),
"<h2>" + title, "<h2>" + title,
@ -296,9 +296,9 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
else "", else "",
] ]
ue_types = parcours.ALLOWED_UE_TYPES ue_types = cursus.ALLOWED_UE_TYPES
ue_types.sort() ue_types.sort()
ue_types_names = [sco_codes_parcours.UE_TYPE_NAME[k] for k in ue_types] ue_types_names = [codes_cursus.UE_TYPE_NAME[k] for k in ue_types]
ue_types = [str(x) for x in ue_types] ue_types = [str(x) for x in ue_types]
form_descr = [ form_descr = [
@ -324,8 +324,8 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
"input_type": "menu", "input_type": "menu",
"type": "int", "type": "int",
"allow_null": False, "allow_null": False,
"title": parcours.SESSION_NAME.capitalize(), "title": cursus.SESSION_NAME.capitalize(),
"explanation": f"{parcours.SESSION_NAME} de l'UE dans la formation", "explanation": f"{cursus.SESSION_NAME} de l'UE dans la formation",
"labels": ["non spécifié"] + [str(x) for x in semestres_indices], "labels": ["non spécifié"] + [str(x) for x in semestres_indices],
"allowed_values": [""] + semestres_indices, "allowed_values": [""] + semestres_indices,
}, },
@ -433,7 +433,7 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
}, },
), ),
] ]
if create and not parcours.UE_IS_MODULE and not is_apc: if create and not cursus.UE_IS_MODULE and not is_apc:
form_descr.append( form_descr.append(
( (
"create_matiere", "create_matiere",
@ -502,13 +502,13 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
formation_id, int(tf[2]["semestre_idx"]) formation_id, int(tf[2]["semestre_idx"])
) )
ue_id = do_ue_create(tf[2]) ue_id = do_ue_create(tf[2])
if is_apc or parcours.UE_IS_MODULE or tf[2]["create_matiere"]: if is_apc or cursus.UE_IS_MODULE or tf[2]["create_matiere"]:
# rappel: en APC, toutes les UE ont une matière, créée ici # rappel: en APC, toutes les UE ont une matière, créée ici
# (inutilisée mais à laquelle les modules sont rattachés) # (inutilisée mais à laquelle les modules sont rattachés)
matiere_id = sco_edit_matiere.do_matiere_create( matiere_id = sco_edit_matiere.do_matiere_create(
{"ue_id": ue_id, "titre": tf[2]["titre"], "numero": 1}, {"ue_id": ue_id, "titre": tf[2]["titre"], "numero": 1},
) )
if parcours.UE_IS_MODULE: if cursus.UE_IS_MODULE:
# dans ce mode, crée un (unique) module dans l'UE: # dans ce mode, crée un (unique) module dans l'UE:
_ = sco_edit_module.do_module_create( _ = sco_edit_module.do_module_create(
{ {
@ -560,14 +560,14 @@ def _add_ue_semestre_id(ues: list[dict], is_apc):
if ue["semestre_idx"] is not None: if ue["semestre_idx"] is not None:
ue["semestre_id"] = ue["semestre_idx"] ue["semestre_id"] = ue["semestre_idx"]
elif is_apc: elif is_apc:
ue["semestre_id"] = sco_codes_parcours.UE_SEM_DEFAULT ue["semestre_id"] = codes_cursus.UE_SEM_DEFAULT
else: else:
# était le comportement ScoDoc7 # était le comportement ScoDoc7
modules = sco_edit_module.module_list(args={"ue_id": ue["ue_id"]}) modules = sco_edit_module.module_list(args={"ue_id": ue["ue_id"]})
if modules: if modules:
ue["semestre_id"] = modules[0]["semestre_id"] ue["semestre_id"] = modules[0]["semestre_id"]
else: else:
ue["semestre_id"] = sco_codes_parcours.UE_SEM_DEFAULT ue["semestre_id"] = codes_cursus.UE_SEM_DEFAULT
def next_ue_numero(formation_id, semestre_id=None): def next_ue_numero(formation_id, semestre_id=None):
@ -582,7 +582,7 @@ def next_ue_numero(formation_id, semestre_id=None):
return ues[-1]["numero"] + 1000 return ues[-1]["numero"] + 1000
else: else:
# Avec semestre: (prend le semestre du 1er module de l'UE) # Avec semestre: (prend le semestre du 1er module de l'UE)
_add_ue_semestre_id(ues, formation.get_parcours().APC_SAE) _add_ue_semestre_id(ues, formation.get_cursus().APC_SAE)
ue_list_semestre = [ue for ue in ues if ue["semestre_id"] == semestre_id] ue_list_semestre = [ue for ue in ues if ue["semestre_id"] == semestre_id]
if ue_list_semestre: if ue_list_semestre:
return ue_list_semestre[-1]["numero"] + 10 return ue_list_semestre[-1]["numero"] + 10
@ -641,7 +641,7 @@ def ue_table(formation_id=None, semestre_idx=1, msg=""): # was ue_list
formation: Formation = Formation.query.get(formation_id) formation: Formation = Formation.query.get(formation_id)
if not formation: if not formation:
raise ScoValueError("invalid formation_id") raise ScoValueError("invalid formation_id")
parcours = formation.get_parcours() parcours = formation.get_cursus()
is_apc = parcours.APC_SAE is_apc = parcours.APC_SAE
locked = formation.has_locked_sems() locked = formation.has_locked_sems()
if semestre_idx == "all" or semestre_idx == "": if semestre_idx == "all" or semestre_idx == "":
@ -1044,7 +1044,7 @@ def _ue_table_ues(
if cur_ue_semestre_id != ue["semestre_id"]: if cur_ue_semestre_id != ue["semestre_id"]:
cur_ue_semestre_id = ue["semestre_id"] cur_ue_semestre_id = ue["semestre_id"]
if ue["semestre_id"] == sco_codes_parcours.UE_SEM_DEFAULT: if ue["semestre_id"] == codes_cursus.UE_SEM_DEFAULT:
lab = "Pas d'indication de semestre:" lab = "Pas d'indication de semestre:"
else: else:
lab = f"""Semestre {ue["semestre_id"]}:""" lab = f"""Semestre {ue["semestre_id"]}:"""
@ -1076,10 +1076,10 @@ def _ue_table_ues(
""" """
% ue % ue
) )
if ue["type"] != sco_codes_parcours.UE_STANDARD: if ue["type"] != codes_cursus.UE_STANDARD:
H.append( H.append(
'<span class="ue_type">%s</span>' '<span class="ue_type">%s</span>'
% sco_codes_parcours.UE_TYPE_NAME[ue["type"]] % codes_cursus.UE_TYPE_NAME[ue["type"]]
) )
if ue["is_external"]: if ue["is_external"]:
# Cas spécial: si l'UE externe a plus d'un module, c'est peut être une UE # Cas spécial: si l'UE externe a plus d'un module, c'est peut être une UE

View File

@ -37,7 +37,7 @@ import app.scodoc.sco_utils as scu
from app import log from app import log
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_bac from app.scodoc import sco_bac
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_formations from app.scodoc import sco_formations
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
@ -45,7 +45,7 @@ from app.scodoc import sco_pvjury
from app.scodoc import sco_etud from app.scodoc import sco_etud
import sco_version import sco_version
from app.scodoc.gen_tables import GenTable from app.scodoc.gen_tables import GenTable
from app.scodoc.sco_codes_parcours import NO_SEMESTRE_ID from app.scodoc.codes_cursus import NO_SEMESTRE_ID
def _build_results_table(start_date=None, end_date=None, types_parcours=[]): def _build_results_table(start_date=None, end_date=None, types_parcours=[]):
@ -68,10 +68,10 @@ def _build_results_table(start_date=None, end_date=None, types_parcours=[]):
sem["formation"] = sco_formations.formation_list( sem["formation"] = sco_formations.formation_list(
args={"formation_id": sem["formation_id"]} args={"formation_id": sem["formation_id"]}
)[0] )[0]
sem["parcours"] = sco_codes_parcours.get_parcours_from_code( sem["parcours"] = codes_cursus.get_cursus_from_code(
sem["formation"]["type_parcours"] sem["formation"]["type_parcours"]
) )
if sem["parcours"].TYPE_PARCOURS in types_parcours: if sem["parcours"].TYPE_CURSUS in types_parcours:
semlist_parcours.append(sem) semlist_parcours.append(sem)
formsemestre_ids_parcours = [sem["formsemestre_id"] for sem in semlist_parcours] formsemestre_ids_parcours = [sem["formsemestre_id"] for sem in semlist_parcours]
@ -266,18 +266,18 @@ def scodoc_table_results(
menu_options = [] menu_options = []
type_parcours_set = set() type_parcours_set = set()
for sem in sorted(semlist, key=lambda x: x["dateord"]): for sem in sorted(semlist, key=lambda x: x["dateord"]):
if sem["parcours"].TYPE_PARCOURS in types_parcours: if sem["parcours"].TYPE_CURSUS in types_parcours:
selected = "selected" selected = "selected"
else: else:
selected = "" selected = ""
if sem["parcours"].TYPE_PARCOURS not in type_parcours_set: if sem["parcours"].TYPE_CURSUS not in type_parcours_set:
type_parcours_set.add(sem["parcours"].TYPE_PARCOURS) type_parcours_set.add(sem["parcours"].TYPE_CURSUS)
menu_options.append( menu_options.append(
'<option value="%s" %s>%s</option>' '<option value="%s" %s>%s</option>'
% (sem["parcours"].TYPE_PARCOURS, selected, sem["parcours"].__doc__) % (sem["parcours"].TYPE_CURSUS, selected, sem["parcours"].__doc__)
) )
if sem["parcours"].TYPE_PARCOURS in types_parcours: if sem["parcours"].TYPE_CURSUS in types_parcours:
info_sems.append( info_sems.append(
'<li><a class="stdlink" href="formsemestre_status?formsemestre_id=%(formsemestre_id)s">%(titremois)s</a></li>' '<li><a class="stdlink" href="formsemestre_status?formsemestre_id=%(formsemestre_id)s">%(titremois)s</a></li>'
% sem % sem

View File

@ -48,7 +48,7 @@ from app.models.but_refcomp import (
ApcReferentielCompetences, ApcReferentielCompetences,
) )
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_edit_matiere from app.scodoc import sco_edit_matiere
from app.scodoc import sco_edit_module from app.scodoc import sco_edit_module
from app.scodoc import sco_edit_ue from app.scodoc import sco_edit_ue
@ -467,7 +467,7 @@ def formation_list_table(formation_id=None, args={}):
# Traduit/ajoute des champs à afficher: # Traduit/ajoute des champs à afficher:
for f in formations: for f in formations:
try: try:
f["parcours_name"] = sco_codes_parcours.get_parcours_from_code( f["parcours_name"] = codes_cursus.get_cursus_from_code(
f["type_parcours"] f["type_parcours"]
).NAME ).NAME
except: except:

View File

@ -39,9 +39,9 @@ import app.scodoc.sco_utils as scu
from app import log from app import log
from app.models import Departement from app.models import Departement
from app.models import FormSemestre from app.models import FormSemestre
from app.scodoc import sco_cache, sco_codes_parcours, sco_formations, sco_preferences from app.scodoc import sco_cache, codes_cursus, sco_formations, sco_preferences
from app.scodoc.gen_tables import GenTable from app.scodoc.gen_tables import GenTable
from app.scodoc.sco_codes_parcours import NO_SEMESTRE_ID from app.scodoc.codes_cursus import NO_SEMESTRE_ID
from app.scodoc.sco_exceptions import ScoInvalidIdType, ScoValueError from app.scodoc.sco_exceptions import ScoInvalidIdType, ScoValueError
from app.scodoc.sco_vdi import ApoEtapeVDI from app.scodoc.sco_vdi import ApoEtapeVDI
@ -151,7 +151,7 @@ def _formsemestre_enrich(sem):
if not formations: if not formations:
raise ScoValueError("pas de formation pour ce semestre !") raise ScoValueError("pas de formation pour ce semestre !")
F = formations[0] F = formations[0]
parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"]) parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
# 'S1', 'S2', ... ou '' pour les monosemestres # 'S1', 'S2', ... ou '' pour les monosemestres
if sem["semestre_id"] != NO_SEMESTRE_ID: if sem["semestre_id"] != NO_SEMESTRE_ID:
sem["sem_id_txt"] = "S%s" % sem["semestre_id"] sem["sem_id_txt"] = "S%s" % sem["semestre_id"]

View File

@ -50,7 +50,7 @@ from app.scodoc.sco_exceptions import AccessDenied, ScoValueError
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission
from app.scodoc.sco_vdi import ApoEtapeVDI from app.scodoc.sco_vdi import ApoEtapeVDI
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_compute_moy from app.scodoc import sco_compute_moy
from app.scodoc import sco_edit_module from app.scodoc import sco_edit_module
from app.scodoc import sco_etud from app.scodoc import sco_etud
@ -206,7 +206,7 @@ def do_formsemestre_createwithmodules(edit=False, formsemestre: FormSemestre = N
# Liste des ID de semestres # Liste des ID de semestres
if formation.type_parcours is not None: if formation.type_parcours is not None:
parcours = sco_codes_parcours.get_parcours_from_code(formation.type_parcours) parcours = codes_cursus.get_cursus_from_code(formation.type_parcours)
nb_sem = parcours.NB_SEM nb_sem = parcours.NB_SEM
else: else:
nb_sem = 10 # fallback, max 10 semestres nb_sem = 10 # fallback, max 10 semestres
@ -1008,7 +1008,7 @@ def _formsemestre_check_module_list(module_ids, semestre_idx):
def _formsemestre_check_ue_bonus_unicity(module_ids): def _formsemestre_check_ue_bonus_unicity(module_ids):
"""Vérifie qu'il n'y a qu'une seule UE bonus associée aux modules choisis""" """Vérifie qu'il n'y a qu'une seule UE bonus associée aux modules choisis"""
ues = [Module.query.get_or_404(module_id).ue for module_id in module_ids] ues = [Module.query.get_or_404(module_id).ue for module_id in module_ids]
ues_bonus = {ue.id for ue in ues if ue.type == sco_codes_parcours.UE_SPORT} ues_bonus = {ue.id for ue in ues if ue.type == codes_cursus.UE_SPORT}
if len(ues_bonus) > 1: if len(ues_bonus) > 1:
raise ScoValueError( raise ScoValueError(
"""Les modules de bonus sélectionnés ne sont pas tous dans la même UE bonus. """Les modules de bonus sélectionnés ne sont pas tous dans la même UE bonus.

View File

@ -55,7 +55,7 @@ from app.scodoc import sco_formsemestre
from app.scodoc import sco_formsemestre_inscriptions from app.scodoc import sco_formsemestre_inscriptions
from app.scodoc import sco_formsemestre_validation from app.scodoc import sco_formsemestre_validation
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
def formsemestre_ext_create(etudid, sem_params): def formsemestre_ext_create(etudid, sem_params):

View File

@ -43,7 +43,7 @@ import app.scodoc.sco_utils as scu
from app import log from app import log
from app.scodoc.scolog import logdb from app.scodoc.scolog import logdb
from app.scodoc.sco_exceptions import ScoException, ScoValueError from app.scodoc.sco_exceptions import ScoException, ScoValueError
from app.scodoc.sco_codes_parcours import UE_STANDARD, UE_SPORT, UE_TYPE_NAME from app.scodoc.codes_cursus import UE_STANDARD, UE_SPORT, UE_TYPE_NAME
import app.scodoc.notesdb as ndb import app.scodoc.notesdb as ndb
from app.scodoc.TrivialFormulator import TrivialFormulator from app.scodoc.TrivialFormulator import TrivialFormulator
from app.scodoc import sco_find_etud from app.scodoc import sco_find_etud

View File

@ -56,7 +56,7 @@ from app.scodoc import htmlutils
from app.scodoc import sco_abs from app.scodoc import sco_abs
from app.scodoc import sco_archives from app.scodoc import sco_archives
from app.scodoc import sco_bulletins from app.scodoc import sco_bulletins
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_compute_moy from app.scodoc import sco_compute_moy
from app.scodoc import sco_edit_ue from app.scodoc import sco_edit_ue
from app.scodoc import sco_evaluations from app.scodoc import sco_evaluations
@ -89,14 +89,14 @@ def _build_menu_stats(formsemestre_id):
"enabled": True, "enabled": True,
}, },
{ {
"title": "Graphe des parcours", "title": "Graphe des cursus",
"endpoint": "notes.formsemestre_graph_parcours", "endpoint": "notes.formsemestre_graph_cursus",
"args": {"formsemestre_id": formsemestre_id}, "args": {"formsemestre_id": formsemestre_id},
"enabled": True, "enabled": True,
}, },
{ {
"title": "Codes des parcours", "title": "Codes des cursus",
"endpoint": "notes.formsemestre_suivi_parcours", "endpoint": "notes.formsemestre_suivi_cursus",
"args": {"formsemestre_id": formsemestre_id}, "args": {"formsemestre_id": formsemestre_id},
"enabled": True, "enabled": True,
}, },
@ -577,7 +577,7 @@ def fill_formsemestre(sem):
sem["eyelink"] = "" sem["eyelink"] = ""
F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0] F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0]
sem["formation"] = F sem["formation"] = F
parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"]) parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
if sem["semestre_id"] != -1: if sem["semestre_id"] != -1:
sem["num_sem"] = f""", {parcours.SESSION_NAME} {sem["semestre_id"]}""" sem["num_sem"] = f""", {parcours.SESSION_NAME} {sem["semestre_id"]}"""
else: else:
@ -617,7 +617,7 @@ def formsemestre_description_table(
F = sco_formations.formation_list(args={"formation_id": formsemestre.formation_id})[ F = sco_formations.formation_list(args={"formation_id": formsemestre.formation_id})[
0 0
] ]
parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"]) parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
# --- Colonnes à proposer: # --- Colonnes à proposer:
columns_ids = ["UE", "Code", "Module"] columns_ids = ["UE", "Code", "Module"]
if with_parcours: if with_parcours:
@ -969,7 +969,7 @@ def formsemestre_status_head(formsemestre_id: int = None, page_title: str = None
if not sem: if not sem:
raise ScoValueError("Semestre inexistant (il a peut être été supprimé ?)") raise ScoValueError("Semestre inexistant (il a peut être été supprimé ?)")
formation: Formation = sem.formation formation: Formation = sem.formation
parcours = formation.get_parcours() parcours = formation.get_cursus()
page_title = page_title or "Modules de " page_title = page_title or "Modules de "
@ -1268,7 +1268,7 @@ def formsemestre_tableau_modules(
H.append("</td></tr>") H.append("</td></tr>")
if modimpl["ue"]["type"] != sco_codes_parcours.UE_STANDARD: if modimpl["ue"]["type"] != codes_cursus.UE_STANDARD:
fontorange = " fontorange" # style css additionnel fontorange = " fontorange" # style css additionnel
else: else:
fontorange = "" fontorange = ""

View File

@ -48,12 +48,12 @@ from app.models.validations import (
from app.models.but_validations import ApcValidationRCUE, ApcValidationAnnee from app.models.but_validations import ApcValidationRCUE, ApcValidationAnnee
from app.scodoc.sco_exceptions import ScoValueError from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc.scolog import logdb from app.scodoc.scolog import logdb
from app.scodoc.sco_codes_parcours import * from app.scodoc.codes_cursus import *
from app.scodoc.TrivialFormulator import TrivialFormulator, tf_error_message from app.scodoc.TrivialFormulator import TrivialFormulator, tf_error_message
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_abs from app.scodoc import sco_abs
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_edit_ue from app.scodoc import sco_edit_ue
from app.scodoc import sco_etud from app.scodoc import sco_etud
@ -179,13 +179,13 @@ def formsemestre_validation_etud_form(
etud["nomprenom"], etud["nomprenom"],
Se.parcours.SESSION_NAME_A, Se.parcours.SESSION_NAME_A,
Se.parcours.SESSION_NAME, Se.parcours.SESSION_NAME,
Se.get_parcours_descr(), Se.get_cursus_descr(),
) )
) )
else: else:
H.append( H.append(
'<h2 class="formsemestre">Parcours de %s</h2>%s' '<h2 class="formsemestre">Parcours de %s</h2>%s'
% (etud["nomprenom"], Se.get_parcours_descr()) % (etud["nomprenom"], Se.get_cursus_descr())
) )
H.append( H.append(
@ -793,7 +793,7 @@ def form_decision_manuelle(Se, formsemestre_id, etudid, desturl="", sortcol=None
) )
# Choix code semestre: # Choix code semestre:
codes = sorted(sco_codes_parcours.CODES_JURY_SEM) codes = sorted(codes_cursus.CODES_JURY_SEM)
# fortuitement, cet ordre convient bien ! # fortuitement, cet ordre convient bien !
H.append( H.append(
@ -805,7 +805,7 @@ def form_decision_manuelle(Se, formsemestre_id, etudid, desturl="", sortcol=None
if cod != ADC: if cod != ADC:
H.append( H.append(
'<option value="%s">%s (code %s)</option>' '<option value="%s">%s (code %s)</option>'
% (cod, sco_codes_parcours.CODES_EXPL[cod], cod) % (cod, codes_cursus.CODES_EXPL[cod], cod)
) )
elif Se.sem["gestion_compensation"]: elif Se.sem["gestion_compensation"]:
# traitement spécial pour ADC (compensation) # traitement spécial pour ADC (compensation)
@ -845,24 +845,24 @@ def form_decision_manuelle(Se, formsemestre_id, etudid, desturl="", sortcol=None
sel = "" sel = ""
H.append( H.append(
'<option value="%s" %s>%s (code %s)</option>' '<option value="%s" %s>%s (code %s)</option>'
% (cod, sel, sco_codes_parcours.CODES_EXPL[cod], cod) % (cod, sel, codes_cursus.CODES_EXPL[cod], cod)
) )
H.append("</select></td></tr>") H.append("</select></td></tr>")
# Choix code devenir # Choix code devenir
codes = list(sco_codes_parcours.DEVENIR_EXPL.keys()) codes = list(codes_cursus.DEVENIR_EXPL.keys())
codes.sort() # fortuitement, cet ordre convient aussi bien ! codes.sort() # fortuitement, cet ordre convient aussi bien !
if Se.sem["semestre_id"] == -1: if Se.sem["semestre_id"] == -1:
allowed_codes = sco_codes_parcours.DEVENIRS_MONO allowed_codes = codes_cursus.DEVENIRS_MONO
else: else:
allowed_codes = set(sco_codes_parcours.DEVENIRS_STD) allowed_codes = set(codes_cursus.DEVENIRS_STD)
# semestres decales ? # semestres decales ?
if Se.sem["gestion_semestrielle"]: if Se.sem["gestion_semestrielle"]:
allowed_codes = allowed_codes.union(sco_codes_parcours.DEVENIRS_DEC) allowed_codes = allowed_codes.union(codes_cursus.DEVENIRS_DEC)
# n'autorise les codes NEXT2 que si semestres décalés et s'il ne manque qu'un semestre avant le n+2 # n'autorise les codes NEXT2 que si semestres décalés et s'il ne manque qu'un semestre avant le n+2
if Se.can_jump_to_next2(): if Se.can_jump_to_next2():
allowed_codes = allowed_codes.union(sco_codes_parcours.DEVENIRS_NEXT2) allowed_codes = allowed_codes.union(codes_cursus.DEVENIRS_NEXT2)
H.append( H.append(
'<tr><td>Devenir: </td><td><select name="devenir"><option value="" selected>Choisir...</option>' '<tr><td>Devenir: </td><td><select name="devenir"><option value="" selected>Choisir...</option>'

View File

@ -57,7 +57,7 @@ from app import log, cache
from app.scodoc.scolog import logdb from app.scodoc.scolog import logdb
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_cursus from app.scodoc import sco_cursus
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc.sco_etud import etud_sort_key from app.scodoc.sco_etud import etud_sort_key
@ -326,7 +326,7 @@ def get_group_infos(group_id, etat=None): # was _getlisteetud
else: else:
t["etath"] = "(dem.)" t["etath"] = "(dem.)"
nbdem += 1 nbdem += 1
elif t["etat"] == sco_codes_parcours.DEF: elif t["etat"] == codes_cursus.DEF:
t["etath"] = "Défaillant" t["etath"] = "Défaillant"
else: else:
t["etath"] = t["etat"] t["etath"] = t["etat"]

View File

@ -775,7 +775,7 @@ def groups_table(
"boursier", "boursier",
"debouche", "debouche",
"parcours", "parcours",
"codeparcours", "code_cursus",
] ]
titles = keys[:] titles = keys[:]
other_partitions = sco_groups.get_group_other_partitions(groups_infos.groups[0]) other_partitions = sco_groups.get_group_other_partitions(groups_infos.groups[0])
@ -791,8 +791,8 @@ def groups_table(
Se = sco_cursus.get_situation_etud_cursus( Se = sco_cursus.get_situation_etud_cursus(
etud, groups_infos.formsemestre_id etud, groups_infos.formsemestre_id
) )
m["parcours"] = Se.get_parcours_descr() m["parcours"] = Se.get_cursus_descr()
m["codeparcours"], _ = sco_report.get_codeparcoursetud(etud) m["code_cursus"], _ = sco_report.get_code_cursus_etud(etud)
L = [[m.get(k, "") for k in keys] for m in groups_infos.members] L = [[m.get(k, "") for k in keys] for m in groups_infos.members]
title = "etudiants_%s" % groups_infos.groups_filename title = "etudiants_%s" % groups_infos.groups_filename

View File

@ -40,7 +40,7 @@ from app.models import FormSemestre
from app.scodoc.gen_tables import GenTable from app.scodoc.gen_tables import GenTable
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc import sco_formations from app.scodoc import sco_formations
from app.scodoc import sco_formsemestre from app.scodoc import sco_formsemestre
@ -258,11 +258,11 @@ def list_source_sems(sem, delai=None) -> list[dict]:
if date_fin > date_debut_dst: if date_fin > date_debut_dst:
continue # semestre trop récent continue # semestre trop récent
# Elimine les semestres de formations speciales (sans parcours) # Elimine les semestres de formations speciales (sans parcours)
if s["semestre_id"] == sco_codes_parcours.NO_SEMESTRE_ID: if s["semestre_id"] == codes_cursus.NO_SEMESTRE_ID:
continue continue
# #
F = sco_formations.formation_list(args={"formation_id": s["formation_id"]})[0] F = sco_formations.formation_list(args={"formation_id": s["formation_id"]})[0]
parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"]) parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
if not parcours.ALLOW_SEM_SKIP: if not parcours.ALLOW_SEM_SKIP:
if s["semestre_id"] < (sem["semestre_id"] - 1): if s["semestre_id"] < (sem["semestre_id"] - 1):
continue continue

View File

@ -246,7 +246,7 @@ def _make_table_notes(
modimpl = ModuleImpl.query.get_or_404(moduleimpl_id) modimpl = ModuleImpl.query.get_or_404(moduleimpl_id)
module: Module = modimpl.module module: Module = modimpl.module
formsemestre: FormSemestre = modimpl.formsemestre formsemestre: FormSemestre = modimpl.formsemestre
is_apc = module.formation.get_parcours().APC_SAE is_apc = module.formation.get_cursus().APC_SAE
if is_apc: if is_apc:
res: ResultatsSemestreBUT = res_sem.load_formsemestre_results(formsemestre) res: ResultatsSemestreBUT = res_sem.load_formsemestre_results(formsemestre)
is_conforme = modimpl.check_apc_conformity(res) is_conforme = modimpl.check_apc_conformity(res)

View File

@ -43,7 +43,7 @@ from app.scodoc.scolog import logdb
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import htmlutils from app.scodoc import htmlutils
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_edit_module from app.scodoc import sco_edit_module
from app.scodoc import sco_edit_ue from app.scodoc import sco_edit_ue
from app.scodoc import sco_etud from app.scodoc import sco_etud
@ -546,7 +546,7 @@ def _list_but_ue_inscriptions(res: NotesTableCompat, read_only: bool = True) ->
ScolarFormSemestreValidation.formsemestre_id ScolarFormSemestreValidation.formsemestre_id
!= res.formsemestre.id, != res.formsemestre.id,
ScolarFormSemestreValidation.code.in_( ScolarFormSemestreValidation.code.in_(
sco_codes_parcours.CODES_UE_VALIDES codes_cursus.CODES_UE_VALIDES
), ),
) )
.join(UniteEns) .join(UniteEns)
@ -554,7 +554,7 @@ def _list_but_ue_inscriptions(res: NotesTableCompat, read_only: bool = True) ->
.all() .all()
) )
validations_ue.sort( validations_ue.sort(
key=lambda v: sco_codes_parcours.BUT_CODES_ORDERED.get(v.code, 0) key=lambda v: codes_cursus.BUT_CODES_ORDERED.get(v.code, 0)
) )
validation = validations_ue[-1] if validations_ue else None validation = validations_ue[-1] if validations_ue else None
expl_validation = ( expl_validation = (

View File

@ -42,7 +42,7 @@ from app.models import FormSemestre, ModuleImpl
from app.models.evaluations import Evaluation from app.models.evaluations import Evaluation
from app.models.ues import UniteEns from app.models.ues import UniteEns
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_exceptions import ScoInvalidIdType from app.scodoc.sco_exceptions import ScoInvalidIdType
from app.scodoc.sco_cursus_dut import formsemestre_has_decisions from app.scodoc.sco_cursus_dut import formsemestre_has_decisions
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission

View File

@ -43,7 +43,7 @@ from app.scodoc import html_sco_header
from app.scodoc import htmlutils from app.scodoc import htmlutils
from app.scodoc import sco_archives_etud from app.scodoc import sco_archives_etud
from app.scodoc import sco_bac from app.scodoc import sco_bac
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_formsemestre from app.scodoc import sco_formsemestre
from app.scodoc import sco_formsemestre_status from app.scodoc import sco_formsemestre_status
from app.scodoc import sco_groups from app.scodoc import sco_groups
@ -82,10 +82,10 @@ def _menu_scolarite(authuser, sem: dict, etudid: int):
dem_url = "scolar.do_cancel_dem" dem_url = "scolar.do_cancel_dem"
# Note: seul un etudiant inscrit (I) peut devenir défaillant. # Note: seul un etudiant inscrit (I) peut devenir défaillant.
if ins["etat"] != sco_codes_parcours.DEF: if ins["etat"] != codes_cursus.DEF:
def_title = "Déclarer défaillance" def_title = "Déclarer défaillance"
def_url = "scolar.form_def" def_url = "scolar.form_def"
elif ins["etat"] == sco_codes_parcours.DEF: elif ins["etat"] == codes_cursus.DEF:
def_title = "Annuler la défaillance" def_title = "Annuler la défaillance"
def_url = "scolar.do_cancel_def" def_url = "scolar.do_cancel_def"
def_enabled = ( def_enabled = (
@ -611,7 +611,7 @@ def etud_info_html(etudid, with_photo="1", debug=False):
abort(404, "etudiant inconnu") abort(404, "etudiant inconnu")
photo_html = sco_photos.etud_photo_html(etud, title="fiche de " + etud["nom"]) photo_html = sco_photos.etud_photo_html(etud, title="fiche de " + etud["nom"])
# experimental: may be too slow to be here # experimental: may be too slow to be here
codeparcours, _ = sco_report.get_codeparcoursetud(etud, prefix="S", separator=", ") code_cursus, _ = sco_report.get_code_cursus_etud(etud, prefix="S", separator=", ")
bac = sco_bac.Baccalaureat(etud["bac"], etud["specialite"]) bac = sco_bac.Baccalaureat(etud["bac"], etud["specialite"])
bac_abbrev = bac.abbrev() bac_abbrev = bac.abbrev()
@ -619,7 +619,7 @@ def etud_info_html(etudid, with_photo="1", debug=False):
<div class="eid_left"> <div class="eid_left">
<div class="eid_nom"><div>{etud["nomprenom"]}</div></div> <div class="eid_nom"><div>{etud["nomprenom"]}</div></div>
<div class="eid_info eid_bac">Bac: <span class="eid_bac">{bac_abbrev}</span></div> <div class="eid_info eid_bac">Bac: <span class="eid_bac">{bac_abbrev}</span></div>
<div class="eid_info eid_parcours">{codeparcours}</div> <div class="eid_info eid_parcours">{code_cursus}</div>
""" """
# Informations sur l'etudiant dans le semestre courant: # Informations sur l'etudiant dans le semestre courant:

View File

@ -45,7 +45,7 @@ from app.scodoc import sco_preferences
from app.scodoc import sco_etud from app.scodoc import sco_etud
import sco_version import sco_version
from app.scodoc.gen_tables import GenTable from app.scodoc.gen_tables import GenTable
from app.scodoc.sco_codes_parcours import code_semestre_validant, code_semestre_attente from app.scodoc.codes_cursus import code_semestre_validant, code_semestre_attente
def etud_get_poursuite_info(sem, etud): def etud_get_poursuite_info(sem, etud):

View File

@ -39,7 +39,7 @@ from app.comp import res_sem
from app.comp.res_compat import NotesTableCompat from app.comp.res_compat import NotesTableCompat
from app.models import FormSemestre, Identite, ScolarAutorisationInscription from app.models import FormSemestre, Identite, ScolarAutorisationInscription
from app.scodoc import sco_abs from app.scodoc import sco_abs
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_groups from app.scodoc import sco_groups
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc import sco_excel from app.scodoc import sco_excel
@ -129,7 +129,7 @@ def feuille_preparation_jury(formsemestre_id):
[f"S{x.semestre_id}" for x in autorisations_etud] [f"S{x.semestre_id}" for x in autorisations_etud]
) )
# parcours: # parcours:
parcours[etud.id] = Se.get_parcours_descr() parcours[etud.id] = Se.get_cursus_descr()
# groupe principal (td) # groupe principal (td)
groupestd[etud.id] = "" groupestd[etud.id] = ""
for s in Se.etud["sems"]: for s in Se.etud["sems"]:
@ -295,12 +295,12 @@ def feuille_preparation_jury(formsemestre_id):
# #
sheet.append_blank_row() sheet.append_blank_row()
# Explications des codes # Explications des codes
codes = list(sco_codes_parcours.CODES_EXPL.keys()) codes = list(codes_cursus.CODES_EXPL.keys())
codes.sort() codes.sort()
sheet.append_single_cell_row("Explication des codes") sheet.append_single_cell_row("Explication des codes")
for code in codes: for code in codes:
sheet.append_row( sheet.append_row(
sheet.make_row(["", "", "", code, sco_codes_parcours.CODES_EXPL[code]]) sheet.make_row(["", "", "", code, codes_cursus.CODES_EXPL[code]])
) )
sheet.append_row( sheet.append_row(
sheet.make_row( sheet.make_row(

View File

@ -69,7 +69,7 @@ import app.scodoc.sco_utils as scu
import app.scodoc.notesdb as ndb import app.scodoc.notesdb as ndb
from app import log from app import log
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_cursus from app.scodoc import sco_cursus
from app.scodoc import sco_cursus_dut from app.scodoc import sco_cursus_dut
from app.scodoc import sco_edit_ue from app.scodoc import sco_edit_ue
@ -82,7 +82,7 @@ from app.scodoc import sco_pdf
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
from app.scodoc import sco_pvpdf from app.scodoc import sco_pvpdf
from app.scodoc.gen_tables import GenTable from app.scodoc.gen_tables import GenTable
from app.scodoc.sco_codes_parcours import NO_SEMESTRE_ID from app.scodoc.codes_cursus import NO_SEMESTRE_ID
from app.scodoc.sco_pdf import PDFLOCK from app.scodoc.sco_pdf import PDFLOCK
from app.scodoc.TrivialFormulator import TrivialFormulator from app.scodoc.TrivialFormulator import TrivialFormulator
@ -96,16 +96,14 @@ def _descr_decisions_ues(nt, etudid, decisions_ue, decision_sem) -> list[dict]:
for ue_id in decisions_ue.keys(): for ue_id in decisions_ue.keys():
try: try:
if decisions_ue[ue_id] and ( if decisions_ue[ue_id] and (
sco_codes_parcours.code_ue_validant(decisions_ue[ue_id]["code"]) codes_cursus.code_ue_validant(decisions_ue[ue_id]["code"])
or ( or (
(not nt.is_apc) (not nt.is_apc)
and ( and (
# XXX ceci devrait dépendre du parcours et non pas être une option ! #sco8 # XXX ceci devrait dépendre du parcours et non pas être une option ! #sco8
decision_sem decision_sem
and scu.CONFIG.CAPITALIZE_ALL_UES and scu.CONFIG.CAPITALIZE_ALL_UES
and sco_codes_parcours.code_semestre_validant( and codes_cursus.code_semestre_validant(decision_sem["code"])
decision_sem["code"]
)
) )
) )
): ):
@ -134,7 +132,7 @@ def _descr_decision_sem(etat, decision_sem):
else: else:
if decision_sem: if decision_sem:
cod = decision_sem["code"] cod = decision_sem["code"]
decision = sco_codes_parcours.CODES_EXPL.get(cod, "") # + ' (%s)' % cod decision = codes_cursus.CODES_EXPL.get(cod, "") # + ' (%s)' % cod
else: else:
decision = "" decision = ""
return decision return decision
@ -269,7 +267,7 @@ def dict_pvjury(
ects_by_ue_code = _comp_ects_by_ue_code(nt, d["decisions_ue"]) ects_by_ue_code = _comp_ects_by_ue_code(nt, d["decisions_ue"])
d["sum_ects"] = _sum_ects_dicts(ects_capitalises_by_ue_code, ects_by_ue_code) d["sum_ects"] = _sum_ects_dicts(ects_capitalises_by_ue_code, ects_by_ue_code)
if d["decision_sem"] and sco_codes_parcours.code_semestre_validant( if d["decision_sem"] and codes_cursus.code_semestre_validant(
d["decision_sem"]["code"] d["decision_sem"]["code"]
): ):
d["mention"] = scu.get_mention(nt.get_etud_moy_gen(etudid)) d["mention"] = scu.get_mention(nt.get_etud_moy_gen(etudid))
@ -304,7 +302,7 @@ def dict_pvjury(
d["autorisations_descr"] = descr_autorisations(autorisations) d["autorisations_descr"] = descr_autorisations(autorisations)
d["validation_parcours"] = Se.parcours_validated() d["validation_parcours"] = Se.parcours_validated()
d["parcours"] = Se.get_parcours_descr(filter_futur=True) d["parcours"] = Se.get_cursus_descr(filter_futur=True)
if with_parcours_decisions: if with_parcours_decisions:
d["parcours_decisions"] = Se.get_parcours_decisions() d["parcours_decisions"] = Se.get_parcours_decisions()
# Observations sur les compensations: # Observations sur les compensations:
@ -604,7 +602,7 @@ def formsemestre_pvjury(formsemestre_id, format="html", publish=True):
{ {
"code": code, "code": code,
"count": counts[code], "count": counts[code],
"expl": sco_codes_parcours.CODES_EXPL.get(code, ""), "expl": codes_cursus.CODES_EXPL.get(code, ""),
} }
) )

View File

@ -48,7 +48,7 @@ from app.models import FormSemestre, Identite
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
from app.scodoc import sco_bulletins_pdf from app.scodoc import sco_bulletins_pdf
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc import sco_pdf from app.scodoc import sco_pdf
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
@ -892,7 +892,7 @@ def _pvjury_pdf_type(
) )
# Légende des codes # Légende des codes
codes = list(sco_codes_parcours.CODES_EXPL.keys()) codes = list(codes_cursus.CODES_EXPL.keys())
codes.sort() codes.sort()
objects += sco_pdf.make_paras( objects += sco_pdf.make_paras(
"""<para spaceBefore="15mm" fontSize="14"> """<para spaceBefore="15mm" fontSize="14">
@ -901,7 +901,7 @@ def _pvjury_pdf_type(
) )
L = [] L = []
for code in codes: for code in codes:
L.append((code, sco_codes_parcours.CODES_EXPL[code])) L.append((code, codes_cursus.CODES_EXPL[code]))
TableStyle2 = [ TableStyle2 = [
( (
"FONTNAME", "FONTNAME",

View File

@ -49,7 +49,7 @@ from app.models.etudiants import Identite
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
from app.scodoc import notesdb as ndb from app.scodoc import notesdb as ndb
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc import sco_formsemestre from app.scodoc import sco_formsemestre
from app.scodoc import sco_formsemestre_inscriptions from app.scodoc import sco_formsemestre_inscriptions
@ -58,7 +58,7 @@ from app.scodoc import sco_pvjury
import sco_version import sco_version
from app.scodoc.gen_tables import GenTable from app.scodoc.gen_tables import GenTable
from app import log from app import log
from app.scodoc.sco_codes_parcours import code_semestre_validant from app.scodoc.codes_cursus import code_semestre_validant
MAX_ETUD_IN_DESCR = 20 MAX_ETUD_IN_DESCR = 20
@ -960,7 +960,7 @@ def _count_dem_reo(formsemestre_id, etudids):
if nt.get_etud_etat(etudid) == "D": if nt.get_etud_etat(etudid) == "D":
dems.add(etudid) dems.add(etudid)
dec = nt.get_etud_decision_sem(etudid) dec = nt.get_etud_decision_sem(etudid)
if dec and dec["code"] in sco_codes_parcours.CODES_SEM_REO: if dec and dec["code"] in codes_cursus.CODES_SEM_REO:
reos.add(etudid) reos.add(etudid)
return dems, reos return dems, reos
@ -1002,8 +1002,8 @@ def _codesem(sem, short=True, prefix=""):
return "%s%s%s" % (prefix, idx, d) return "%s%s%s" % (prefix, idx, d)
def get_codeparcoursetud(etud, prefix="", separator=""): def get_code_cursus_etud(etud, prefix="", separator=""):
"""calcule un code de parcours pour un etudiant """calcule un code de cursus (parcours) pour un etudiant
exemples: exemples:
1234A pour un etudiant ayant effectué S1, S2, S3, S4 puis diplome 1234A pour un etudiant ayant effectué S1, S2, S3, S4 puis diplome
12D pour un étudiant en S1, S2 puis démission en S2 12D pour un étudiant en S1, S2 puis démission en S2
@ -1017,7 +1017,7 @@ def get_codeparcoursetud(etud, prefix="", separator=""):
# #
p = [] p = []
decisions_jury = {} decisions_jury = {}
# élimine les semestres spéciaux sans parcours (LP...) # élimine les semestres spéciaux hors cursus (LP en 1 sem., ...)
sems = [s for s in etud["sems"] if s["semestre_id"] >= 0] sems = [s for s in etud["sems"] if s["semestre_id"] >= 0]
i = len(sems) - 1 i = len(sems) - 1
while i >= 0: while i >= 0:
@ -1035,14 +1035,14 @@ def get_codeparcoursetud(etud, prefix="", separator=""):
decisions_jury[s["semestre_id"]] = "" decisions_jury[s["semestre_id"]] = ""
else: else:
decisions_jury[s["semestre_id"]] = dec["code"] decisions_jury[s["semestre_id"]] = dec["code"]
# code etat dans le codeparcours sur dernier semestre seulement # code etat dans le code_cursus sur dernier semestre seulement
if i == 0: if i == 0:
# Démission # Démission
if nt.get_etud_etat(etud["etudid"]) == "D": if nt.get_etud_etat(etud["etudid"]) == "D":
p.append(":D") p.append(":D")
else: else:
dec = nt.get_etud_decision_sem(etud["etudid"]) dec = nt.get_etud_decision_sem(etud["etudid"])
if dec and dec["code"] in sco_codes_parcours.CODES_SEM_REO: if dec and dec["code"] in codes_cursus.CODES_SEM_REO:
p.append(":R") p.append(":R")
if ( if (
dec dec
@ -1063,7 +1063,7 @@ def tsp_etud_list(
civilite="", civilite="",
statut="", statut="",
): ):
"""Liste des etuds a considerer dans table suivi parcours """Liste des etuds a considerer dans table suivi cursus
ramene aussi ensembles des bacs, genres, statuts de (tous) les etudiants ramene aussi ensembles des bacs, genres, statuts de (tous) les etudiants
""" """
# log('tsp_etud_list(%s, bac="%s")' % (formsemestre_id,bac)) # log('tsp_etud_list(%s, bac="%s")' % (formsemestre_id,bac))
@ -1102,7 +1102,8 @@ def tsp_etud_list(
def tsp_grouped_list(codes_etuds): def tsp_grouped_list(codes_etuds):
"""Liste pour table regroupant le nombre d'étudiants (+ bulle avec les noms) de chaque parcours""" """Liste pour table regroupant le nombre d'étudiants
(+ bulle avec les noms) de chaque cursus (parcours)"""
L = [] L = []
parcours = list(codes_etuds.keys()) parcours = list(codes_etuds.keys())
parcours.sort() parcours.sort()
@ -1117,7 +1118,7 @@ def tsp_grouped_list(codes_etuds):
return L return L
def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=True): def table_suivi_cursus(formsemestre_id, only_primo=False, grouped_parcours=True):
"""Tableau recapitulant tous les parcours""" """Tableau recapitulant tous les parcours"""
sem = sco_formsemestre.get_formsemestre(formsemestre_id) sem = sco_formsemestre.get_formsemestre(formsemestre_id)
etuds, bacs, bacspecialites, annee_bacs, civilites, statuts = tsp_etud_list( etuds, bacs, bacspecialites, annee_bacs, civilites, statuts = tsp_etud_list(
@ -1125,8 +1126,8 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
) )
codes_etuds = scu.DictDefault(defaultvalue=[]) codes_etuds = scu.DictDefault(defaultvalue=[])
for etud in etuds: for etud in etuds:
etud["codeparcours"], etud["decisions_jury"] = get_codeparcoursetud(etud) etud["code_cursus"], etud["decisions_jury"] = get_code_cursus_etud(etud)
codes_etuds[etud["codeparcours"]].append(etud) codes_etuds[etud["code_cursus"]].append(etud)
fiche_url = url_for( fiche_url = url_for(
"scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etud["etudid"] "scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etud["etudid"]
) )
@ -1135,13 +1136,13 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
etud["_nom_td_attrs"] = 'id="%s" class="etudinfo"' % (etud["etudid"]) etud["_nom_td_attrs"] = 'id="%s" class="etudinfo"' % (etud["etudid"])
titles = { titles = {
"parcours": "Code parcours", "parcours": "Code cursus",
"nb": "Nombre d'étudiants", "nb": "Nombre d'étudiants",
"civilite": "", "civilite": "",
"nom": "Nom", "nom": "Nom",
"prenom": "Prénom", "prenom": "Prénom",
"etudid": "etudid", "etudid": "etudid",
"codeparcours": "Code parcours", "code_cursus": "Code cursus",
"bac": "Bac", "bac": "Bac",
"specialite": "Spe.", "specialite": "Spe.",
} }
@ -1150,7 +1151,7 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
L = tsp_grouped_list(codes_etuds) L = tsp_grouped_list(codes_etuds)
columns_ids = ("parcours", "nb") columns_ids = ("parcours", "nb")
else: else:
# Table avec le parcours de chaque étudiant: # Table avec le cursus de chaque étudiant:
L = etuds L = etuds
columns_ids = ( columns_ids = (
"etudid", "etudid",
@ -1159,7 +1160,7 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
"prenom", "prenom",
"bac", "bac",
"specialite", "specialite",
"codeparcours", "code_cursus",
) )
# Calcule intitulés de colonnes # Calcule intitulés de colonnes
S = set() S = set()
@ -1198,7 +1199,7 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
bottom_titles={ bottom_titles={
"parcours": "Total", "parcours": "Total",
"nb": len(etuds), "nb": len(etuds),
"codeparcours": len(etuds), "code_cursus": len(etuds),
}, },
preferences=sco_preferences.SemPreferences(formsemestre_id), preferences=sco_preferences.SemPreferences(formsemestre_id),
) )
@ -1232,14 +1233,14 @@ def tsp_form_primo_group(only_primo, no_grouping, formsemestre_id, format):
return "\n".join(F) return "\n".join(F)
def formsemestre_suivi_parcours( def formsemestre_suivi_cursus(
formsemestre_id, formsemestre_id,
format="html", format="html",
only_primo=False, only_primo=False,
no_grouping=False, no_grouping=False,
): ):
"""Effectifs dans les differents parcours possibles.""" """Effectifs dans les differents cursus possibles."""
tab = table_suivi_parcours( tab = table_suivi_cursus(
formsemestre_id, formsemestre_id,
only_primo=only_primo, only_primo=only_primo,
grouped_parcours=not no_grouping, grouped_parcours=not no_grouping,
@ -1260,7 +1261,7 @@ def formsemestre_suivi_parcours(
init_qtip=True, init_qtip=True,
javascripts=["js/etud_info.js"], javascripts=["js/etud_info.js"],
), ),
"""<h2 class="formsemestre">Parcours suivis par les étudiants de ce semestre</h2>""", """<h2 class="formsemestre">Cursus suivis par les étudiants de ce semestre</h2>""",
"\n".join(F), "\n".join(F),
t, t,
html_sco_header.sco_footer(), html_sco_header.sco_footer(),
@ -1269,7 +1270,7 @@ def formsemestre_suivi_parcours(
# ------------- # -------------
def graph_parcours( def graph_cursus(
formsemestre_id, formsemestre_id,
format="svg", format="svg",
only_primo=False, only_primo=False,
@ -1289,7 +1290,7 @@ def graph_parcours(
civilite=civilite, civilite=civilite,
statut=statut, statut=statut,
) )
# log('graph_parcours: %s etuds (only_primo=%s)' % (len(etuds), only_primo)) # log('graph_cursus: %s etuds (only_primo=%s)' % (len(etuds), only_primo))
if not etuds: if not etuds:
return "", etuds, bacs, bacspecialites, annee_bacs, civilites, statuts return "", etuds, bacs, bacspecialites, annee_bacs, civilites, statuts
edges = scu.DictDefault( edges = scu.DictDefault(
@ -1354,7 +1355,7 @@ def graph_parcours(
if ( if (
s["formsemestre_id"] == formsemestre_id s["formsemestre_id"] == formsemestre_id
and dec and dec
and dec["code"] == sco_codes_parcours.NAR and dec["code"] == codes_cursus.NAR
): ):
nid = sem_node_name(s, "_nar_") nid = sem_node_name(s, "_nar_")
nar_nodes[s["formsemestre_id"]] = nid nar_nodes[s["formsemestre_id"]] = nid
@ -1421,7 +1422,7 @@ def graph_parcours(
n = g.get_node(nid)[0] n = g.get_node(nid)[0]
n.set_color("red") n.set_color("red")
n.set_shape("Mcircle") n.set_shape("Mcircle")
n.set("label", sco_codes_parcours.NAR) n.set("label", codes_cursus.NAR)
# diplomes: # diplomes:
for nid in diploma_nodes: for nid in diploma_nodes:
n = g.get_node(nid)[0] n = g.get_node(nid)[0]
@ -1493,7 +1494,7 @@ def graph_parcours(
return data, etuds, bacs, bacspecialites, annee_bacs, civilites, statuts return data, etuds, bacs, bacspecialites, annee_bacs, civilites, statuts
def formsemestre_graph_parcours( def formsemestre_graph_cursus(
formsemestre_id, formsemestre_id,
format="html", format="html",
only_primo=False, only_primo=False,
@ -1506,7 +1507,7 @@ def formsemestre_graph_parcours(
): ):
"""Graphe suivi cohortes""" """Graphe suivi cohortes"""
annee_bac = str(annee_bac) annee_bac = str(annee_bac)
# log("formsemestre_graph_parcours") # log("formsemestre_graph_cursus")
sem = sco_formsemestre.get_formsemestre(formsemestre_id) sem = sco_formsemestre.get_formsemestre(formsemestre_id)
if format == "pdf": if format == "pdf":
( (
@ -1517,7 +1518,7 @@ def formsemestre_graph_parcours(
annee_bacs, annee_bacs,
civilites, civilites,
statuts, statuts,
) = graph_parcours( ) = graph_cursus(
formsemestre_id, formsemestre_id,
format="pdf", format="pdf",
only_primo=only_primo, only_primo=only_primo,
@ -1539,7 +1540,7 @@ def formsemestre_graph_parcours(
annee_bacs, annee_bacs,
civilites, civilites,
statuts, statuts,
) = graph_parcours( ) = graph_cursus(
formsemestre_id, formsemestre_id,
format="png", format="png",
only_primo=only_primo, only_primo=only_primo,
@ -1575,7 +1576,7 @@ def formsemestre_graph_parcours(
annee_bacs, annee_bacs,
civilites, civilites,
statuts, statuts,
) = graph_parcours( ) = graph_cursus(
formsemestre_id, formsemestre_id,
only_primo=only_primo, only_primo=only_primo,
bac=bac, bac=bac,
@ -1587,10 +1588,10 @@ def formsemestre_graph_parcours(
H = [ H = [
html_sco_header.sco_header( html_sco_header.sco_header(
page_title="Parcours étudiants de %(titreannee)s" % sem, page_title="Graphe cursus de %(titreannee)s" % sem,
no_side_bar=True, no_side_bar=True,
), ),
"""<h2 class="formsemestre">Parcours des étudiants de ce semestre</h2>""", """<h2 class="formsemestre">Cursus des étudiants de ce semestre</h2>""",
doc, doc,
"<p>%d étudiants sélectionnés</p>" % len(etuds), "<p>%d étudiants sélectionnés</p>" % len(etuds),
_gen_form_selectetuds( _gen_form_selectetuds(
@ -1611,9 +1612,9 @@ def formsemestre_graph_parcours(
"""<p>Origine et devenir des étudiants inscrits dans %(titreannee)s""" """<p>Origine et devenir des étudiants inscrits dans %(titreannee)s"""
% sem, % sem,
"""(<a href="%s">version pdf</a>""" """(<a href="%s">version pdf</a>"""
% url_for("notes.formsemestre_graph_parcours", format="pdf", **url_kw), % url_for("notes.formsemestre_graph_cursus", format="pdf", **url_kw),
""", <a href="%s">image PNG</a>)""" """, <a href="%s">image PNG</a>)"""
% url_for("notes.formsemestre_graph_parcours", format="png", **url_kw), % url_for("notes.formsemestre_graph_cursus", format="png", **url_kw),
"""</p>""", """</p>""",
"""<p class="help">Le graphe permet de suivre les étudiants inscrits dans le semestre """<p class="help">Le graphe permet de suivre les étudiants inscrits dans le semestre
sélectionné (dessiné en vert). Chaque rectangle représente un semestre (cliquez dedans sélectionné (dessiné en vert). Chaque rectangle représente un semestre (cliquez dedans

View File

@ -42,7 +42,7 @@ from app.models.formsemestre import FormSemestreInscription
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc.sco_exceptions import ScoValueError from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
@ -237,7 +237,7 @@ def _indicateurs_enquete_but(
[ [
True True
for deca in decisions_annee.values() for deca in decisions_annee.values()
if deca.code_valide == sco_codes_parcours.NAR if deca.code_valide == codes_cursus.NAR
] ]
), ),
# Redoublants sans aucune RCUE # Redoublants sans aucune RCUE

View File

@ -63,7 +63,7 @@ import app.scodoc.sco_utils as scu
from app import log from app import log
from app.models import UniteEns from app.models import UniteEns
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_edit_matiere from app.scodoc import sco_edit_matiere
from app.scodoc import sco_edit_module from app.scodoc import sco_edit_module
from app.scodoc import sco_edit_ue from app.scodoc import sco_edit_ue
@ -80,7 +80,7 @@ def external_ue_create(
formsemestre_id, formsemestre_id,
titre="", titre="",
acronyme="", acronyme="",
ue_type=sco_codes_parcours.UE_STANDARD, ue_type=codes_cursus.UE_STANDARD,
ects=0.0, ects=0.0,
) -> int: ) -> int:
"""Crée UE/matiere/module dans la formation du formsemestre """Crée UE/matiere/module dans la formation du formsemestre
@ -252,12 +252,12 @@ def external_ue_create_form(formsemestre_id: int, etudid: int):
""", """,
] ]
html_footer = html_sco_header.sco_footer() html_footer = html_sco_header.sco_footer()
parcours = formsemestre.formation.get_parcours() parcours = formsemestre.formation.get_cursus()
ue_types = [ ue_types = [
typ for typ in parcours.ALLOWED_UE_TYPES if typ != sco_codes_parcours.UE_SPORT typ for typ in parcours.ALLOWED_UE_TYPES if typ != codes_cursus.UE_SPORT
] ]
ue_types.sort() ue_types.sort()
ue_types_names = [sco_codes_parcours.UE_TYPE_NAME[k] for k in ue_types] ue_types_names = [codes_cursus.UE_TYPE_NAME[k] for k in ue_types]
ue_types = [str(x) for x in ue_types] ue_types = [str(x) for x in ue_types]
if existing_external_ue: if existing_external_ue:

View File

@ -58,7 +58,7 @@ from werkzeug.http import HTTP_STATUS_CODES
from config import Config from config import Config
from app import log from app import log
from app.scodoc.sco_vdi import ApoEtapeVDI from app.scodoc.sco_vdi import ApoEtapeVDI
from app.scodoc.sco_codes_parcours import NOTES_TOLERANCE, CODES_EXPL from app.scodoc.codes_cursus import NOTES_TOLERANCE, CODES_EXPL
from app.scodoc import sco_xml from app.scodoc import sco_xml
import sco_version import sco_version

View File

@ -26,7 +26,7 @@ from app.models.etudiants import Identite
from app.scodoc.sco_exceptions import ScoNoReferentielCompetences from app.scodoc.sco_exceptions import ScoNoReferentielCompetences
from app.models.formsemestre import FormSemestre from app.models.formsemestre import FormSemestre
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc.sco_codes_parcours import ( from app.scodoc.codes_cursus import (
BUT_BARRE_RCUE, BUT_BARRE_RCUE,
BUT_RCUE_SUFFISANT, BUT_RCUE_SUFFISANT,
) )

View File

@ -14,7 +14,7 @@ from app.auth.models import User
from app.comp.res_common import ResultatsSemestre from app.comp.res_common import ResultatsSemestre
from app.models import Identite from app.models import Identite
from app.models.ues import UniteEns from app.models.ues import UniteEns
from app.scodoc.sco_codes_parcours import UE_SPORT, DEF from app.scodoc.codes_cursus import UE_SPORT, DEF
from app.scodoc import sco_evaluation_db from app.scodoc import sco_evaluation_db
from app.scodoc import sco_groups from app.scodoc import sco_groups
from app.scodoc import sco_utils as scu from app.scodoc import sco_utils as scu
@ -63,10 +63,10 @@ class TableRecap(tb.Table):
self.include_evaluations = include_evaluations self.include_evaluations = include_evaluations
self.mode_jury = mode_jury self.mode_jury = mode_jury
self.read_only = read_only # utilisé seulement dans sous-classes self.read_only = read_only # utilisé seulement dans sous-classes
parcours = res.formsemestre.formation.get_parcours() cursus = res.formsemestre.formation.get_cursus()
self.barre_moy = parcours.BARRE_MOY - scu.NOTES_TOLERANCE self.barre_moy = cursus.BARRE_MOY - scu.NOTES_TOLERANCE
self.barre_valid_ue = parcours.NOTES_BARRE_VALID_UE self.barre_valid_ue = cursus.NOTES_BARRE_VALID_UE
self.barre_warning_ue = parcours.BARRE_UE_DISPLAY_WARNING self.barre_warning_ue = cursus.BARRE_UE_DISPLAY_WARNING
self.cache_nomcomplet = {} # cache uid : nomcomplet self.cache_nomcomplet = {} # cache uid : nomcomplet
if convert_values: if convert_values:
self.fmt_note = scu.fmt_note self.fmt_note = scu.fmt_note

View File

@ -8,7 +8,7 @@
scodoc_dept=g.scodoc_dept, formsemestre_id=sco.sem.id) scodoc_dept=g.scodoc_dept, formsemestre_id=sco.sem.id)
}}">{{sco.sem.titre}}</a> }}">{{sco.sem.titre}}</a>
<a title="{{sco.sem.etapes_apo_str()}}"> <a title="{{sco.sem.etapes_apo_str()}}">
{% if sco.sem.semestre_id != -1 %}, {{sco.sem.formation.get_parcours().SESSION_NAME}} {% if sco.sem.semestre_id != -1 %}, {{sco.sem.formation.get_cursus().SESSION_NAME}}
{{sco.sem.semestre_id}} {{sco.sem.semestre_id}}
{% endif %}</a> {% endif %}</a>
{% if sco.sem.modalite %} en {{sco.sem.modalite}}{% endif %}</span> {% if sco.sem.modalite %} en {{sco.sem.modalite}}{% endif %}</span>

View File

@ -4,31 +4,22 @@
<div class="formsemestre_page_title"> <div class="formsemestre_page_title">
<div class="infos"> <div class="infos">
<span class="semtitle"><a class="stdlink" <span class="semtitle"><a class="stdlink" title="{{formsemestre.session_id()}}" href="{{url_for('notes.formsemestre_status',
title="{{formsemestre.session_id()}}" scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)}}">{{formsemestre.titre}}</a>
href="{{url_for('notes.formsemestre_status',
scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)}}"
>{{formsemestre.titre}}</a>
{%- if formsemestre.semestre_id != -1 -%} {%- if formsemestre.semestre_id != -1 -%}
<a <a title="{{formsemestre.etapes_apo_str()
title="{{formsemestre.etapes_apo_str()
}}">, {{ }}">, {{
formsemestre.formation.get_parcours().SESSION_NAME}} formsemestre.formation.get_cursus().SESSION_NAME}}
{{formsemestre.semestre_id}}</a> {{formsemestre.semestre_id}}</a>
{%- endif -%} {%- endif -%}
{%- if formsemestre.modalite %} en {{formsemestre.modalite}} {%- if formsemestre.modalite %} en {{formsemestre.modalite}}
{%- endif %}</span><span {%- endif %}</span><span class="dates"><a title="du {{formsemestre.date_debut.strftime('%d/%m/%Y')}}
class="dates"><a au {{formsemestre.date_fin.strftime('%d/%m/%Y')}} ">{{formsemestre.mois_debut()}} -
title="du {{formsemestre.date_debut.strftime('%d/%m/%Y')}} {{formsemestre.mois_fin()}}</a></span><span class="resp"><a
au {{formsemestre.date_fin.strftime('%d/%m/%Y')}} " title="{{formsemestre.responsables_str(abbrev_prenom=False)}}">{{formsemestre.responsables_str()}}</a></span><span
>{{formsemestre.mois_debut()}} - {{formsemestre.mois_fin()}}</a></span><span class="nbinscrits"><a class="discretelink" href="{{url_for('scolar.groups_view',
class="resp"><a title="{{formsemestre.responsables_str(abbrev_prenom=False)}}">{{formsemestre.responsables_str()}}</a></span><span
class="nbinscrits"><a class="discretelink"
href="{{url_for('scolar.groups_view',
scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id) scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)
}}" }}">{{formsemestre.etuds_inscriptions|length}} inscrits</a></span><span class="lock">
>{{formsemestre.etuds_inscriptions|length}} inscrits</a></span><span
class="lock">
{%-if not formsemestre.etat -%} {%-if not formsemestre.etat -%}
<a href="{{ url_for( 'notes.formsemestre_change_lock', <a href="{{ url_for( 'notes.formsemestre_change_lock',
scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id )}}">{{ scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id )}}">{{

View File

@ -49,7 +49,7 @@
<span class="formation_module_ue">(<a title="UE de rattachement">{{mod.ue.acronyme}}</a>)</span>, <span class="formation_module_ue">(<a title="UE de rattachement">{{mod.ue.acronyme}}</a>)</span>,
{% endif %} {% endif %}
- parcours <b>{{ mod.get_parcours()|map(attribute="code")|join("</b>, <b>")|default('tronc commun', - parcours <b>{{ mod.get_cursus()|map(attribute="code")|join("</b>, <b>")|default('tronc commun',
true)|safe true)|safe
}}</b> }}</b>
{% if mod.heures_cours or mod.heures_td or mod.heures_tp %} {% if mod.heures_cours or mod.heures_td or mod.heures_tp %}

View File

@ -3207,8 +3207,8 @@ sco_publish(
Permission.ScoView, Permission.ScoView,
) )
sco_publish( sco_publish(
"/formsemestre_suivi_parcours", "/formsemestre_suivi_cursus",
sco_report.formsemestre_suivi_parcours, sco_report.formsemestre_suivi_cursus,
Permission.ScoView, Permission.ScoView,
) )
sco_publish( sco_publish(
@ -3222,8 +3222,8 @@ sco_publish(
Permission.ScoView, Permission.ScoView,
) )
sco_publish( sco_publish(
"/formsemestre_graph_parcours", "/formsemestre_graph_cursus",
sco_report.formsemestre_graph_parcours, sco_report.formsemestre_graph_cursus,
Permission.ScoView, Permission.ScoView,
) )
sco_publish( sco_publish(

View File

@ -37,7 +37,7 @@ from flask import current_app, g, request
from flask.templating import render_template from flask.templating import render_template
from flask_login import current_user from flask_login import current_user
from werkzeug.utils import redirect from werkzeug.utils import redirect
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from config import Config from config import Config
@ -232,7 +232,7 @@ def edit_modules_ue_coefs():
read_only=locked read_only=locked
or not current_user.has_permission(Permission.ScoChangeFormation), or not current_user.has_permission(Permission.ScoChangeFormation),
semestre_idx=semestre_idx, semestre_idx=semestre_idx,
semestre_ids=range(1, formation.get_parcours().NB_SEM + 1), semestre_ids=range(1, formation.get_cursus().NB_SEM + 1),
parcours_id=parcours_id, parcours_id=parcours_id,
), ),
html_sco_header.sco_footer(), html_sco_header.sco_footer(),

View File

@ -75,7 +75,7 @@ from app.scodoc.gen_tables import GenTable
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_import_etuds from app.scodoc import sco_import_etuds
from app.scodoc import sco_archives_etud from app.scodoc import sco_archives_etud
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_cache from app.scodoc import sco_cache
from app.scodoc import sco_debouche from app.scodoc import sco_debouche
from app.scodoc import sco_dept from app.scodoc import sco_dept
@ -1160,7 +1160,7 @@ def do_def_etudiant(etudid, formsemestre_id, event_date=None):
etudid, etudid,
formsemestre_id, formsemestre_id,
event_date=event_date, event_date=event_date,
etat_new=sco_codes_parcours.DEF, etat_new=codes_cursus.DEF,
operation_method="defailleEtudiant", operation_method="defailleEtudiant",
event_type="DEFAILLANCE", event_type="DEFAILLANCE",
) )
@ -1221,7 +1221,7 @@ def do_cancel_def(etudid, formsemestre_id, dialog_confirmed=False, args=None):
dialog_confirmed=dialog_confirmed, dialog_confirmed=dialog_confirmed,
args=args, args=args,
operation_name="défaillance", operation_name="défaillance",
etat_current=sco_codes_parcours.DEF, etat_current=codes_cursus.DEF,
etat_new=scu.INSCRIT, etat_new=scu.INSCRIT,
operation_method="cancel_def", operation_method="cancel_def",
event_type="DEFAILLANCE", event_type="DEFAILLANCE",

View File

@ -48,7 +48,7 @@ HEAD = """# -*- coding: utf-8 -*-
# #
# Command: %s %s # Command: %s %s
# #
from sco_codes_parcours import ( from codes_cursus import (
DUTRule, DUTRule,
ADC, ADC,
ADJ, ADJ,

View File

@ -19,7 +19,7 @@ from config import Config
from app.auth.models import User from app.auth.models import User
from app.models import FormationModalite, Matiere from app.models import FormationModalite, Matiere
from app.scodoc import notesdb as ndb from app.scodoc import notesdb as ndb
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_edit_formation from app.scodoc import sco_edit_formation
from app.scodoc import sco_edit_matiere from app.scodoc import sco_edit_matiere
from app.scodoc import sco_edit_module from app.scodoc import sco_edit_module
@ -154,7 +154,7 @@ class ScoFake(object):
acronyme="test", acronyme="test",
titre="Formation test", titre="Formation test",
titre_officiel="Le titre officiel de la formation test", titre_officiel="Le titre officiel de la formation test",
type_parcours=sco_codes_parcours.ParcoursDUT.TYPE_PARCOURS, type_parcours=codes_cursus.CursusDUT.TYPE_CURSUS,
formation_code=None, formation_code=None,
code_specialite=None, code_specialite=None,
) -> int: ) -> int:
@ -430,8 +430,8 @@ class ScoFake(object):
self, self,
formsemestre_id, formsemestre_id,
etud, etud,
code_etat=sco_codes_parcours.ADM, code_etat=codes_cursus.ADM,
devenir=sco_codes_parcours.NEXT, devenir=codes_cursus.NEXT,
assidu=True, assidu=True,
): ):
"""Affecte décision de jury""" """Affecte décision de jury"""

View File

@ -5,7 +5,7 @@ Quelques fonctions d'initialisation pour tests unitaires
from app import models from app import models
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
# Valeurs des notes saisies par les tests: # Valeurs des notes saisies par les tests:
NOTES_T = [ NOTES_T = [
@ -16,14 +16,14 @@ from tests.unit import sco_fake_gen
def build_formation_test( def build_formation_test(
nb_mods=1, parcours=sco_codes_parcours.ParcoursBUT, with_ue_sport=False nb_mods=1, parcours=codes_cursus.CursusBUT, with_ue_sport=False
): ):
G = sco_fake_gen.ScoFake(verbose=False) G = sco_fake_gen.ScoFake(verbose=False)
formation_id = G.create_formation( formation_id = G.create_formation(
acronyme="F3", acronyme="F3",
titre="Formation 2", titre="Formation 2",
titre_officiel="Titre officiel 2", titre_officiel="Titre officiel 2",
type_parcours=parcours.TYPE_PARCOURS, type_parcours=parcours.TYPE_CURSUS,
) )
_ue1 = G.create_ue( _ue1 = G.create_ue(
formation_id=formation_id, acronyme="UE1", titre="ue 1", semestre_idx=2 formation_id=formation_id, acronyme="UE1", titre="ue 1", semestre_idx=2
@ -59,7 +59,7 @@ def build_formation_test(
acronyme="UESPO", acronyme="UESPO",
titre="ue sport", titre="ue sport",
semestre_idx=2, semestre_idx=2,
type=sco_codes_parcours.UE_SPORT, type=codes_cursus.UE_SPORT,
) )
ue_ids.append(ue_sport) ue_ids.append(ue_sport)
mat_sport = G.create_matiere(ue_id=ue_sport, titre="matière spo") mat_sport = G.create_matiere(ue_id=ue_sport, titre="matière spo")
@ -109,7 +109,7 @@ def build_modules_with_evaluations(
formsemestre_id=formsemestre_id, formsemestre_id=formsemestre_id,
) )
modimpl = models.ModuleImpl.query.get(moduleimpl_id) modimpl = models.ModuleImpl.query.get(moduleimpl_id)
assert modimpl.formsemestre.formation.get_parcours().APC_SAE # BUT assert modimpl.formsemestre.formation.get_cursus().APC_SAE # BUT
# Check ModuleImpl # Check ModuleImpl
ues = modimpl.formsemestre.query_ues().all() ues = modimpl.formsemestre.query_ues().all()
assert len(ues) == 3 assert len(ues) == 3

View File

@ -9,7 +9,7 @@ from app.comp import moy_ue
from app.comp import inscr_mod from app.comp import inscr_mod
from app.models import FormSemestre, Evaluation, ModuleImplInscription from app.models import FormSemestre, Evaluation, ModuleImplInscription
from app.scodoc import sco_saisie_notes from app.scodoc import sco_saisie_notes
from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.codes_cursus import UE_SPORT
from app.scodoc.sco_utils import NOTES_NEUTRALISE from app.scodoc.sco_utils import NOTES_NEUTRALISE
from app.scodoc import sco_exceptions from app.scodoc import sco_exceptions

View File

@ -26,7 +26,7 @@ from app.scodoc import sco_formsemestre
from app.scodoc import sco_abs from app.scodoc import sco_abs
from app.scodoc import sco_abs_views from app.scodoc import sco_abs_views
from app.scodoc import sco_bulletins from app.scodoc import sco_bulletins
from app.scodoc import sco_codes_parcours from app.scodoc import codes_cursus
from app.scodoc import sco_evaluations from app.scodoc import sco_evaluations
from app.scodoc import sco_evaluation_db from app.scodoc import sco_evaluation_db
from app.scodoc import sco_formsemestre_validation from app.scodoc import sco_formsemestre_validation
@ -207,7 +207,7 @@ def run_sco_basic(verbose=False) -> FormSemestre:
# Saisie d'un décision AJ, non assidu # Saisie d'un décision AJ, non assidu
etudid = etuds[-1]["etudid"] etudid = etuds[-1]["etudid"]
sco_cursus_dut.formsemestre_validate_ues( sco_cursus_dut.formsemestre_validate_ues(
formsemestre_id, etudid, sco_codes_parcours.AJ, False formsemestre_id, etudid, codes_cursus.AJ, False
) )
assert sco_cursus_dut.formsemestre_has_decisions( assert sco_cursus_dut.formsemestre_has_decisions(
formsemestre_id formsemestre_id
@ -225,7 +225,7 @@ def run_sco_basic(verbose=False) -> FormSemestre:
sco_formsemestre_validation.formsemestre_validation_etud_manu( sco_formsemestre_validation.formsemestre_validation_etud_manu(
formsemestre_id, formsemestre_id,
etud["etudid"], etud["etudid"],
code_etat=sco_codes_parcours.ADJ, code_etat=codes_cursus.ADJ,
assidu=True, assidu=True,
redirect=False, redirect=False,
) )

View File

@ -126,7 +126,7 @@ CONFIG.PUBLISH_PORTAL_PHOTO_URL = (
CONFIG.MIN_PASSWORD_LENGTH = 0 # si > 0: longueur minimale requise des nouveaux mots de passe (le test cracklib.FascistCheck s'appliquera dans tous les cas) CONFIG.MIN_PASSWORD_LENGTH = 0 # si > 0: longueur minimale requise des nouveaux mots de passe (le test cracklib.FascistCheck s'appliquera dans tous les cas)
# ---------------------------------------------------- # ----------------------------------------------------
# Ce dictionnaire est fusionné à celui de sco_codes_parcours # Ce dictionnaire est fusionné à celui de codes_cursus
# pour définir les codes jury et explications associées # pour définir les codes jury et explications associées
CONFIG.CODES_EXPL = { CONFIG.CODES_EXPL = {
# AJ : 'Ajourné (échec)', # AJ : 'Ajourné (échec)',

View File

@ -113,7 +113,7 @@ CONFIG = CFG()
# CONFIG.MIN_PASSWORD_LENGTH = 0 # CONFIG.MIN_PASSWORD_LENGTH = 0
# Ce dictionnaire est fusionné à celui de sco_codes_parcours # Ce dictionnaire est fusionné à celui de codes_cursus
# pour définir les codes jury et explications associées # pour définir les codes jury et explications associées
# CONFIG.CODES_EXPL = { # CONFIG.CODES_EXPL = {
# # AJ : 'Ajourné (échec)', # # AJ : 'Ajourné (échec)',