Merge branch 'table' of https://scodoc.org/git/ScoDoc/ScoDoc into bac_a_sable_prod

This commit is contained in:
ScoDoc service 2023-05-11 16:51:11 +02:00
commit 395dca1f32
30 changed files with 1356 additions and 825 deletions

View File

@ -321,6 +321,8 @@ def set_ue_parcours(ue_id: int):
] ]
log(f"set_ue_parcours: ue_id={ue.id} parcours_ids={parcours_ids}") log(f"set_ue_parcours: ue_id={ue.id} parcours_ids={parcours_ids}")
ok, error_message = ue.set_parcours(parcours) ok, error_message = ue.set_parcours(parcours)
if not ok:
return json_error(404, error_message)
return {"status": ok, "message": error_message} return {"status": ok, "message": error_message}

View File

@ -7,33 +7,34 @@
""" """
ScoDoc 9 API : accès aux formsemestres ScoDoc 9 API : accès aux formsemestres
""" """
from flask import g, jsonify, request # from flask import g, jsonify, request
from flask_login import login_required # from flask_login import login_required
import app # import app
from app.api import api_bp as bp, api_web_bp, API_CLIENT_ERROR # from app.api import api_bp as bp, api_web_bp, API_CLIENT_ERROR
from app.decorators import scodoc, permission_required # from app.decorators import scodoc, permission_required
from app.scodoc.sco_utils import json_error # from app.scodoc.sco_utils import json_error
from app.models.formsemestre import NotesSemSet # from app.models.formsemestre import NotesSemSet
from app.scodoc.sco_permissions import Permission # from app.scodoc.sco_permissions import Permission
@bp.route("/semset/set_periode/<int:semset_id>", methods=["POST"]) # Impossible de changer la période à cause des archives
@api_web_bp.route("/semset/set_periode/<int:semset_id>", methods=["POST"]) # @bp.route("/semset/set_periode/<int:semset_id>", methods=["POST"])
@login_required # @api_web_bp.route("/semset/set_periode/<int:semset_id>", methods=["POST"])
@scodoc # @login_required
@permission_required(Permission.ScoEditApo) # @scodoc
# TODO à modifier pour utiliser @as_json # @permission_required(Permission.ScoEditApo)
def semset_set_periode(semset_id: int): # # TODO à modifier pour utiliser @as_json
"Change la période d'un semset" # def semset_set_periode(semset_id: int):
query = NotesSemSet.query.filter_by(semset_id=semset_id) # "Change la période d'un semset"
if g.scodoc_dept: # query = NotesSemSet.query.filter_by(semset_id=semset_id)
query = query.filter_by(dept_id=g.scodoc_dept_id) # if g.scodoc_dept:
semset: NotesSemSet = query.first_or_404() # query = query.filter_by(dept_id=g.scodoc_dept_id)
data = request.get_json(force=True) # may raise 400 Bad Request # semset: NotesSemSet = query.first_or_404()
try: # data = request.get_json(force=True) # may raise 400 Bad Request
periode = int(data) # try:
semset.set_periode(periode) # periode = int(data)
except ValueError: # semset.set_periode(periode)
return json_error(API_CLIENT_ERROR, "invalid periode value") # except ValueError:
return jsonify({"OK": True}) # return json_error(API_CLIENT_ERROR, "invalid periode value")
# return jsonify({"OK": True})

View File

@ -484,6 +484,7 @@ class BulletinBUT:
d["etudid"] = etud.id d["etudid"] = etud.id
d["etud"] = d["etudiant"] d["etud"] = d["etudiant"]
d["etud"]["nomprenom"] = etud.nomprenom d["etud"]["nomprenom"] = etud.nomprenom
d["etud"]["etat_civil"] = etud.etat_civil
d.update(self.res.sem) d.update(self.res.sem)
etud_etat = self.res.get_etud_etat(etud.id) etud_etat = self.res.get_etud_etat(etud.id)
d["filigranne"] = sco_bulletins_pdf.get_filigranne( d["filigranne"] = sco_bulletins_pdf.get_filigranne(

View File

@ -19,6 +19,7 @@ from app.models import Identite, FormSemestre, ModuleImpl, ScolarAutorisationIns
from app.scodoc.codes_cursus 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
class NotesTableCompat(ResultatsSemestre): class NotesTableCompat(ResultatsSemestre):
"""Implementation partielle de NotesTable """Implementation partielle de NotesTable
@ -266,16 +267,21 @@ class NotesTableCompat(ResultatsSemestre):
ue_status_list.append(ue_status) ue_status_list.append(ue_status)
return self.parcours.check_barre_ues(ue_status_list) return self.parcours.check_barre_ues(ue_status_list)
def all_etuds_have_sem_decisions(self): def etudids_without_decisions(self) -> list[int]:
"""True si tous les étudiants du semestre ont une décision de jury. """Liste des id d'étudiants du semestre non démissionnaires
Ne regarde pas les décisions d'UE. n'ayant pas de décision de jury.
- En classic: ne regarde pas que la décision de semestre (pas les décisions d'UE).
- en BUT: utilise etud_has_decision
""" """
for ins in self.formsemestre.inscriptions: check_func = (
if ins.etat != scu.INSCRIT: self.etud_has_decision if self.is_apc else self.get_etud_decision_sem
continue # skip démissionnaires )
if self.get_etud_decision_sem(ins.etudid) is None: etudids = [
return False ins.etudid
return True for ins in self.formsemestre.inscriptions
if (ins.etat == scu.INSCRIT) and (not check_func(ins.etudid))
]
return etudids
def etud_has_decision(self, etudid): def etud_has_decision(self, etudid):
"""True s'il y a une décision de jury pour cet étudiant émanant de ce formsemestre. """True s'il y a une décision de jury pour cet étudiant émanant de ce formsemestre.
@ -316,7 +322,8 @@ class NotesTableCompat(ResultatsSemestre):
def get_etud_decision_sem(self, etudid: int) -> dict: def get_etud_decision_sem(self, etudid: int) -> dict:
"""Decision du jury semestre prise pour cet etudiant, ou None s'il n'y en pas eu. """Decision du jury semestre prise pour cet etudiant, ou None s'il n'y en pas eu.
{ 'code' : None|ATT|..., 'assidu' : 0|1, 'event_date' : , compense_formsemestre_id } { 'code' : None|ATT|..., 'assidu' : 0|1, 'event_date' : , compense_formsemestre_id }
Si état défaillant, force le code a DEF Si état défaillant, force le code a DEF.
Toujours None en BUT.
""" """
if self.get_etud_etat(etudid) == DEF: if self.get_etud_etat(etudid) == DEF:
return { return {

View File

@ -30,6 +30,7 @@ class Identite(db.Model):
db.UniqueConstraint("dept_id", "code_nip"), db.UniqueConstraint("dept_id", "code_nip"),
db.UniqueConstraint("dept_id", "code_ine"), db.UniqueConstraint("dept_id", "code_ine"),
db.CheckConstraint("civilite IN ('M', 'F', 'X')"), db.CheckConstraint("civilite IN ('M', 'F', 'X')"),
db.CheckConstraint("civilite_etat_civil IN ('M', 'F', 'X')"),
) )
id = db.Column(db.Integer, primary_key=True) id = db.Column(db.Integer, primary_key=True)
@ -41,6 +42,12 @@ class Identite(db.Model):
nom_usuel = db.Column(db.Text()) nom_usuel = db.Column(db.Text())
"optionnel (si present, affiché à la place du nom)" "optionnel (si present, affiché à la place du nom)"
civilite = db.Column(db.String(1), nullable=False) civilite = db.Column(db.String(1), nullable=False)
# données d'état-civil. Si présent remplace les données d'usage dans les documents officiels (bulletins, PV)
# cf nomprenom_etat_civil()
civilite_etat_civil = db.Column(db.String(1), nullable=False, server_default="X")
prenom_etat_civil = db.Column(db.Text(), nullable=False, server_default="")
date_naissance = db.Column(db.Date) date_naissance = db.Column(db.Date)
lieu_naissance = db.Column(db.Text()) lieu_naissance = db.Column(db.Text())
dept_naissance = db.Column(db.Text()) dept_naissance = db.Column(db.Text())
@ -108,6 +115,13 @@ class Identite(db.Model):
""" """
return {"M": "M.", "F": "Mme", "X": ""}[self.civilite] return {"M": "M.", "F": "Mme", "X": ""}[self.civilite]
@property
def civilite_etat_civil_str(self):
"""returns 'M.' ou 'Mme' ou '' (pour le genre neutre,
personnes ne souhaitant pas d'affichage).
"""
return {"M": "M.", "F": "Mme", "X": ""}[self.civilite_etat_civil]
def sex_nom(self, no_accents=False) -> str: def sex_nom(self, no_accents=False) -> str:
"'M. DUPONTÉ', ou si no_accents, 'M. DUPONTE'" "'M. DUPONTÉ', ou si no_accents, 'M. DUPONTE'"
s = f"{self.civilite_str} {(self.nom_usuel or self.nom).upper()}" s = f"{self.civilite_str} {(self.nom_usuel or self.nom).upper()}"
@ -154,6 +168,14 @@ class Identite(db.Model):
r.append("-".join([x.lower().capitalize() for x in fields])) r.append("-".join([x.lower().capitalize() for x in fields]))
return " ".join(r) return " ".join(r)
@property
def etat_civil(self):
if self.prenom_etat_civil:
civ = {"M": "M.", "F": "Mme", "X": ""}[self.civilite_etat_civil]
return f"{civ} {self.prenom_etat_civil} {self.nom}"
else:
return self.nomprenom
@property @property
def nom_short(self): def nom_short(self):
"Nom et début du prénom pour table recap: 'DUPONT Pi.'" "Nom et début du prénom pour table recap: 'DUPONT Pi.'"
@ -195,6 +217,8 @@ class Identite(db.Model):
"nom_usuel": self.nom_usuel, "nom_usuel": self.nom_usuel,
"prenom": self.prenom, "prenom": self.prenom,
"sort_key": self.sort_key, "sort_key": self.sort_key,
"civilite_etat_civil": self.civilite_etat_civil,
"prenom_etat_civil": self.prenom_etat_civil,
} }
def to_dict_scodoc7(self) -> dict: def to_dict_scodoc7(self) -> dict:
@ -238,6 +262,8 @@ class Identite(db.Model):
"dept_naissance": self.dept_naissance or "", "dept_naissance": self.dept_naissance or "",
"nationalite": self.nationalite or "", "nationalite": self.nationalite or "",
"boursier": self.boursier or "", "boursier": self.boursier or "",
"civilite_etat_civil": self.civilite_etat_civil,
"prenom_etat_civil": self.prenom_etat_civil,
} }
if include_urls and has_request_context(): if include_urls and has_request_context():
# test request context so we can use this func in tests under the flask shell # test request context so we can use this func in tests under the flask shell
@ -454,10 +480,10 @@ class Identite(db.Model):
M. Pierre Dupont M. Pierre Dupont
""" """
if with_paragraph: if with_paragraph:
return f"""{self.nomprenom}{line_sep}{self.code_nip or ""}{line_sep}{self.e} le { return f"""{self.etat_civil}{line_sep}{self.code_nip or ""}{line_sep}{self.e} le {
self.date_naissance.strftime("%d/%m/%Y") if self.date_naissance else ""}{ self.date_naissance.strftime("%d/%m/%Y") if self.date_naissance else ""}{
line_sep}à {self.lieu_naissance or ""}""" line_sep}à {self.lieu_naissance or ""}"""
return self.nomprenom return self.etat_civil
def photo_html(self, title=None, size="small") -> str: def photo_html(self, title=None, size="small") -> str:
"""HTML img tag for the photo, either in small size (h90) """HTML img tag for the photo, either in small size (h90)

View File

@ -198,11 +198,14 @@ class FormSemestre(db.Model):
d["date_fin"] = d["date_fin_iso"] = "" d["date_fin"] = d["date_fin_iso"] = ""
d["responsables"] = [u.id for u in self.responsables] d["responsables"] = [u.id for u in self.responsables]
d["titre_formation"] = self.titre_formation() d["titre_formation"] = self.titre_formation()
if convert_objects: if convert_objects: # pour API
d["parcours"] = [p.to_dict() for p in self.get_parcours_apc()] d["parcours"] = [p.to_dict() for p in self.get_parcours_apc()]
d["departement"] = self.departement.to_dict() d["departement"] = self.departement.to_dict()
d["formation"] = self.formation.to_dict() d["formation"] = self.formation.to_dict()
d["etape_apo"] = self.etapes_apo_str() d["etape_apo"] = self.etapes_apo_str()
else:
# Converti les étapes Apogee sous forme d'ApoEtapeVDI (compat scodoc7)
d["etapes"] = [e.as_apovdi() for e in self.etapes]
return d return d
def to_dict_api(self): def to_dict_api(self):
@ -923,7 +926,7 @@ class FormSemestreEtape(db.Model):
def __repr__(self): def __repr__(self):
return f"<Etape {self.id} apo={self.etape_apo!r}>" return f"<Etape {self.id} apo={self.etape_apo!r}>"
def as_apovdi(self): def as_apovdi(self) -> ApoEtapeVDI:
return ApoEtapeVDI(self.etape_apo) return ApoEtapeVDI(self.etape_apo)

View File

@ -325,7 +325,8 @@ class UniteEns(db.Model):
if self.niveau_competence_id is not None: if self.niveau_competence_id is not None:
return ( return (
False, False,
f"{self.acronyme} déjà associée à un niveau de compétences", f"""{self.acronyme} déjà associée à un niveau de compétences ({
self.id}, {self.niveau_competence_id})""",
) )
if ( if (
niveau.competence.referentiel.id niveau.competence.referentiel.id
@ -358,6 +359,7 @@ class UniteEns(db.Model):
Si un niveau est déjà associé, vérifie sa cohérence. Si un niveau est déjà associé, vérifie sa cohérence.
Renvoie (True, "") si ok, sinon (False, error_message) Renvoie (True, "") si ok, sinon (False, error_message)
""" """
msg = ""
# Le niveau est-il dans tous ces parcours ? Sinon, l'enlève # Le niveau est-il dans tous ces parcours ? Sinon, l'enlève
prev_niveau = self.niveau_competence prev_niveau = self.niveau_competence
if ( if (
@ -366,6 +368,7 @@ class UniteEns(db.Model):
and self.niveau_competence.id not in self._parcours_niveaux_ids(parcours) and self.niveau_competence.id not in self._parcours_niveaux_ids(parcours)
): ):
self.niveau_competence = None self.niveau_competence = None
msg = " (niveau compétence désassocié !)"
if parcours and self.niveau_competence: if parcours and self.niveau_competence:
ok, error_message = self.check_niveau_unique_dans_parcours( ok, error_message = self.check_niveau_unique_dans_parcours(
@ -381,12 +384,12 @@ class UniteEns(db.Model):
# Invalidation du cache # Invalidation du cache
self.formation.invalidate_cached_sems() self.formation.invalidate_cached_sems()
log(f"ue.set_parcours( {self}, {parcours} )") log(f"ue.set_parcours( {self}, {parcours} )")
return True, "" return True, "parcours enregistrés" + msg
def add_parcour(self, parcour: ApcParcours) -> tuple[bool, str]: def add_parcour(self, parcour: ApcParcours) -> tuple[bool, str]:
"""Ajoute ce parcours à ceux de l'UE""" """Ajoute ce parcours à ceux de l'UE"""
if parcour.id in {p.id for p in self.parcours}: if parcour.id in {p.id for p in self.parcours}:
return True, "" return True, "" # déjà présent
if parcour.referentiel.id != self.formation.referentiel_competence.id: if parcour.referentiel.id != self.formation.referentiel_competence.id:
return False, "Le parcours n'appartient pas au référentiel de la formation" return False, "Le parcours n'appartient pas au référentiel de la formation"

View File

@ -46,13 +46,14 @@ Pour chaque étudiant commun:
from flask import g, url_for from flask import g, url_for
from app import log from app import log
from app.scodoc import sco_apogee_csv from app.scodoc import sco_apogee_csv, sco_apogee_reader
from app.scodoc.sco_apogee_csv import ApoData
from app.scodoc.gen_tables import GenTable from app.scodoc.gen_tables import GenTable
from app.scodoc.sco_exceptions import ScoValueError from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_preferences from app.scodoc import sco_preferences
_help_txt = """ _HELP_TXT = """
<div class="help"> <div class="help">
<p>Outil de comparaison de fichiers (maquettes CSV) Apogée. <p>Outil de comparaison de fichiers (maquettes CSV) Apogée.
</p> </p>
@ -69,7 +70,7 @@ def apo_compare_csv_form():
"""<h2>Comparaison de fichiers Apogée</h2> """<h2>Comparaison de fichiers Apogée</h2>
<form id="apo_csv_add" action="apo_compare_csv" method="post" enctype="multipart/form-data"> <form id="apo_csv_add" action="apo_compare_csv" method="post" enctype="multipart/form-data">
""", """,
_help_txt, _HELP_TXT,
""" """
<div class="apo_compare_csv_form_but"> <div class="apo_compare_csv_form_but">
Fichier Apogée A: Fichier Apogée A:
@ -109,14 +110,14 @@ def apo_compare_csv(file_a, file_b, autodetect=True):
raise ScoValueError( raise ScoValueError(
f""" f"""
Erreur: l'encodage de l'un des fichiers est incorrect. Erreur: l'encodage de l'un des fichiers est incorrect.
Vérifiez qu'il est bien en {sco_apogee_csv.APO_INPUT_ENCODING} Vérifiez qu'il est bien en {sco_apogee_reader.APO_INPUT_ENCODING}
""", """,
dest_url=dest_url, dest_url=dest_url,
) from exc ) from exc
H = [ H = [
html_sco_header.sco_header(page_title="Comparaison de fichiers Apogée"), html_sco_header.sco_header(page_title="Comparaison de fichiers Apogée"),
"<h2>Comparaison de fichiers Apogée</h2>", "<h2>Comparaison de fichiers Apogée</h2>",
_help_txt, _HELP_TXT,
'<div class="apo_compare_csv">', '<div class="apo_compare_csv">',
_apo_compare_csv(apo_data_a, apo_data_b), _apo_compare_csv(apo_data_a, apo_data_b),
"</div>", "</div>",
@ -130,17 +131,17 @@ def _load_apo_data(csvfile, autodetect=True):
"Read data from request variable and build ApoData" "Read data from request variable and build ApoData"
data_b = csvfile.read() data_b = csvfile.read()
if autodetect: if autodetect:
data_b, message = sco_apogee_csv.fix_data_encoding(data_b) data_b, message = sco_apogee_reader.fix_data_encoding(data_b)
if message: if message:
log(f"apo_compare_csv: {message}") log(f"apo_compare_csv: {message}")
if not data_b: if not data_b:
raise ScoValueError("fichier vide ? (apo_compare_csv: no data)") raise ScoValueError("fichier vide ? (apo_compare_csv: no data)")
data = data_b.decode(sco_apogee_csv.APO_INPUT_ENCODING) data = data_b.decode(sco_apogee_reader.APO_INPUT_ENCODING)
apo_data = sco_apogee_csv.ApoData(data, orig_filename=csvfile.filename) apo_data = sco_apogee_csv.ApoData(data, orig_filename=csvfile.filename)
return apo_data return apo_data
def _apo_compare_csv(A, B): def _apo_compare_csv(apo_a: ApoData, apo_b: ApoData):
"""Generate html report comparing A and B, two instances of ApoData """Generate html report comparing A and B, two instances of ApoData
representing Apogee CSV maquettes. representing Apogee CSV maquettes.
""" """
@ -148,74 +149,75 @@ def _apo_compare_csv(A, B):
# 1-- Check etape and codes # 1-- Check etape and codes
L.append('<div class="section"><div class="tit">En-tête</div>') L.append('<div class="section"><div class="tit">En-tête</div>')
L.append('<div><span class="key">Nom fichier A:</span><span class="val_ok">') L.append('<div><span class="key">Nom fichier A:</span><span class="val_ok">')
L.append(A.orig_filename) L.append(apo_a.orig_filename)
L.append("</span></div>") L.append("</span></div>")
L.append('<div><span class="key">Nom fichier B:</span><span class="val_ok">') L.append('<div><span class="key">Nom fichier B:</span><span class="val_ok">')
L.append(B.orig_filename) L.append(apo_b.orig_filename)
L.append("</span></div>") L.append("</span></div>")
L.append('<div><span class="key">Étape Apogée:</span>') L.append('<div><span class="key">Étape Apogée:</span>')
if A.etape_apogee != B.etape_apogee: if apo_a.etape_apogee != apo_b.etape_apogee:
L.append( L.append(
'<span class="val_dif">%s != %s</span>' % (A.etape_apogee, B.etape_apogee) f"""<span class="val_dif">{apo_a.etape_apogee} != {apo_b.etape_apogee}</span>"""
) )
else: else:
L.append('<span class="val_ok">%s</span>' % (A.etape_apogee,)) L.append(f"""<span class="val_ok">{apo_a.etape_apogee}</span>""")
L.append("</div>") L.append("</div>")
L.append('<div><span class="key">VDI Apogée:</span>') L.append('<div><span class="key">VDI Apogée:</span>')
if A.vdi_apogee != B.vdi_apogee: if apo_a.vdi_apogee != apo_b.vdi_apogee:
L.append('<span class="val_dif">%s != %s</span>' % (A.vdi_apogee, B.vdi_apogee)) L.append(
f"""<span class="val_dif">{apo_a.vdi_apogee} != {apo_b.vdi_apogee}</span>"""
)
else: else:
L.append('<span class="val_ok">%s</span>' % (A.vdi_apogee,)) L.append(f"""<span class="val_ok">{apo_a.vdi_apogee}</span>""")
L.append("</div>") L.append("</div>")
L.append('<div><span class="key">Code diplôme :</span>') L.append('<div><span class="key">Code diplôme :</span>')
if A.cod_dip_apogee != B.cod_dip_apogee: if apo_a.cod_dip_apogee != apo_b.cod_dip_apogee:
L.append( L.append(
'<span class="val_dif">%s != %s</span>' f"""<span class="val_dif">{apo_a.cod_dip_apogee} != {apo_b.cod_dip_apogee}</span>"""
% (A.cod_dip_apogee, B.cod_dip_apogee)
) )
else: else:
L.append('<span class="val_ok">%s</span>' % (A.cod_dip_apogee,)) L.append(f"""<span class="val_ok">{apo_a.cod_dip_apogee}</span>""")
L.append("</div>") L.append("</div>")
L.append('<div><span class="key">Année scolaire :</span>') L.append('<div><span class="key">Année scolaire :</span>')
if A.annee_scolaire != B.annee_scolaire: if apo_a.annee_scolaire != apo_b.annee_scolaire:
L.append( L.append(
'<span class="val_dif">%s != %s</span>' '<span class="val_dif">%s != %s</span>'
% (A.annee_scolaire, B.annee_scolaire) % (apo_a.annee_scolaire, apo_b.annee_scolaire)
) )
else: else:
L.append('<span class="val_ok">%s</span>' % (A.annee_scolaire,)) L.append('<span class="val_ok">%s</span>' % (apo_a.annee_scolaire,))
L.append("</div>") L.append("</div>")
# Colonnes: # Colonnes:
A_elts = set(A.apo_elts.keys()) a_elts = set(apo_a.apo_csv.apo_elts.keys())
B_elts = set(B.apo_elts.keys()) b_elts = set(apo_b.apo_csv.apo_elts.keys())
L.append('<div><span class="key">Éléments Apogée :</span>') L.append('<div><span class="key">Éléments Apogée :</span>')
if A_elts == B_elts: if a_elts == b_elts:
L.append('<span class="val_ok">%d</span>' % len(A_elts)) L.append(f"""<span class="val_ok">{len(a_elts)}</span>""")
else: else:
elts_communs = A_elts.intersection(B_elts) elts_communs = a_elts.intersection(b_elts)
elts_only_A = A_elts - A_elts.intersection(B_elts) elts_only_a = a_elts - a_elts.intersection(b_elts)
elts_only_B = B_elts - A_elts.intersection(B_elts) elts_only_b = b_elts - a_elts.intersection(b_elts)
L.append( L.append(
'<span class="val_dif">différents (%d en commun, %d seulement dans A, %d seulement dans B)</span>' '<span class="val_dif">différents (%d en commun, %d seulement dans A, %d seulement dans B)</span>'
% ( % (
len(elts_communs), len(elts_communs),
len(elts_only_A), len(elts_only_a),
len(elts_only_B), len(elts_only_b),
) )
) )
if elts_only_A: if elts_only_a:
L.append( L.append(
'<div span class="key">Éléments seulement dans A : </span><span class="val_dif">%s</span></div>' '<div span class="key">Éléments seulement dans A : </span><span class="val_dif">%s</span></div>'
% ", ".join(sorted(elts_only_A)) % ", ".join(sorted(elts_only_a))
) )
if elts_only_B: if elts_only_b:
L.append( L.append(
'<div span class="key">Éléments seulement dans B : </span><span class="val_dif">%s</span></div>' '<div span class="key">Éléments seulement dans B : </span><span class="val_dif">%s</span></div>'
% ", ".join(sorted(elts_only_B)) % ", ".join(sorted(elts_only_b))
) )
L.append("</div>") L.append("</div>")
L.append("</div>") # /section L.append("</div>") # /section
@ -223,22 +225,21 @@ def _apo_compare_csv(A, B):
# 2-- # 2--
L.append('<div class="section"><div class="tit">Étudiants</div>') L.append('<div class="section"><div class="tit">Étudiants</div>')
A_nips = set(A.etud_by_nip) a_nips = set(apo_a.etud_by_nip)
B_nips = set(B.etud_by_nip) b_nips = set(apo_b.etud_by_nip)
nb_etuds_communs = len(A_nips.intersection(B_nips)) nb_etuds_communs = len(a_nips.intersection(b_nips))
nb_etuds_dif = len(A_nips.union(B_nips) - A_nips.intersection(B_nips)) nb_etuds_dif = len(a_nips.union(b_nips) - a_nips.intersection(b_nips))
L.append("""<div><span class="key">Liste d'étudiants :</span>""") L.append("""<div><span class="key">Liste d'étudiants :</span>""")
if A_nips == B_nips: if a_nips == b_nips:
L.append( L.append(
"""<span class="s_ok"> f"""<span class="s_ok">
%d étudiants (tous présents dans chaque fichier)</span> {len(a_nips)} étudiants (tous présents dans chaque fichier)</span>
""" """
% len(A_nips)
) )
else: else:
L.append( L.append(
'<span class="val_dif">différents (%d en commun, %d différents)</span>' f"""<span class="val_dif">différents ({nb_etuds_communs} en commun, {
% (nb_etuds_communs, nb_etuds_dif) nb_etuds_dif} différents)</span>"""
) )
L.append("</div>") L.append("</div>")
L.append("</div>") # /section L.append("</div>") # /section
@ -247,19 +248,22 @@ def _apo_compare_csv(A, B):
if nb_etuds_communs > 0: if nb_etuds_communs > 0:
L.append( L.append(
"""<div class="section sec_table"> """<div class="section sec_table">
<div class="tit">Différences de résultats des étudiants présents dans les deux fichiers</div> <div class="tit">Différences de résultats des étudiants présents dans les deux fichiers
</div>
<p> <p>
""" """
) )
T = apo_table_compare_etud_results(A, B) T = apo_table_compare_etud_results(apo_a, apo_b)
if T.get_nb_rows() > 0: if T.get_nb_rows() > 0:
L.append(T.html()) L.append(T.html())
else: else:
L.append( L.append(
"""<p class="p_ok">aucune différence de résultats f"""<p class="p_ok">aucune différence de résultats
sur les %d étudiants communs (<em>les éléments Apogée n'apparaissant pas dans les deux fichiers sont omis</em>)</p> sur les {nb_etuds_communs} étudiants communs
(<em>les éléments Apogée n'apparaissant pas dans les deux
fichiers sont omis</em>)
</p>
""" """
% nb_etuds_communs
) )
L.append("</div>") # /section L.append("</div>") # /section
@ -290,19 +294,17 @@ def apo_table_compare_etud_results(A, B):
def _build_etud_res(e, apo_data): def _build_etud_res(e, apo_data):
r = {} r = {}
for elt_code in apo_data.apo_elts: for elt_code in apo_data.apo_csv.apo_elts:
elt = apo_data.apo_elts[elt_code] elt = apo_data.apo_csv.apo_elts[elt_code]
try: try:
# les colonnes de cet élément # les colonnes de cet élément
col_ids_type = [ col_ids_type = [(ec["apoL_a01_code"], ec["Type Rés."]) for ec in elt.cols]
(ec["apoL_a01_code"], ec["Type R\xc3\xa9s."]) for ec in elt.cols
]
except KeyError as exc: except KeyError as exc:
raise ScoValueError( raise ScoValueError(
"Erreur: un élément sans 'Type R\xc3\xa9s.'. Vérifiez l'encodage de vos fichiers." "Erreur: un élément sans 'Type Rés.'. Vérifiez l'encodage de vos fichiers."
) from exc ) from exc
r[elt_code] = {} r[elt_code] = {}
for (col_id, type_res) in col_ids_type: for col_id, type_res in col_ids_type:
r[elt_code][type_res] = e.cols[col_id] r[elt_code][type_res] = e.cols[col_id]
return r return r

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,483 @@
##############################################################################
#
# Gestion scolarite IUT
#
# Copyright (c) 1999 - 2023 Emmanuel Viennet. All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# Emmanuel Viennet emmanuel.viennet@viennet.net
#
##############################################################################
"""Lecture du fichier "maquette" Apogée
Le fichier CSV, champs séparés par des tabulations, a la structure suivante:
<pre>
XX-APO_TITRES-XX
apoC_annee 2007/2008
apoC_cod_dip VDTCJ
apoC_Cod_Exp 1
apoC_cod_vdi 111
apoC_Fichier_Exp VDTCJ_V1CJ.txt
apoC_lib_dip DUT CJ
apoC_Titre1 Export Apogée du 13/06/2008 à 14:29
apoC_Titre2
XX-APO_TYP_RES-XX
...section optionnelle au contenu quelconque...
XX-APO_COLONNES-XX
apoL_a01_code Type Objet Code Version Année Session Admission/Admissibilité Type Rés. Etudiant Numéro
apoL_a02_nom 1 Nom
apoL_a03_prenom 1 Prénom
apoL_a04_naissance Session Admissibilité Naissance
APO_COL_VAL_DEB
apoL_c0001 VET V1CJ 111 2007 0 1 N V1CJ - DUT CJ an1 0 1 Note
apoL_c0002 VET V1CJ 111 2007 0 1 B 0 1 Barème
apoL_c0003 VET V1CJ 111 2007 0 1 R 0 1 Résultat
APO_COL_VAL_FIN
apoL_c0030 APO_COL_VAL_FIN
XX-APO_VALEURS-XX
apoL_a01_code apoL_a02_nom apoL_a03_prenom apoL_a04_naissance apoL_c0001 apoL_c0002 apoL_c0003 apoL_c0004 apoL_c0005 apoL_c0006 apoL_c0007 apoL_c0008 apoL_c0009 apoL_c0010 apoL_c0011 apoL_c0012 apoL_c0013 apoL_c0014 apoL_c0015 apoL_c0016 apoL_c0017 apoL_c0018 apoL_c0019 apoL_c0020 apoL_c0021 apoL_c0022 apoL_c0023 apoL_c0024 apoL_c0025 apoL_c0026 apoL_c0027 apoL_c0028 apoL_c0029
10601232 AARIF MALIKA 22/09/1986 18 20 ADM 18 20 ADM 18 20 ADM 18 20 ADM 18 20 ADM 18 20 18 20 ADM 18 20 ADM 18 20 ADM 18 20 ADM
</pre>
On récupère nos éléments pédagogiques dans la section XX-APO-COLONNES-XX et
notre liste d'étudiants dans la section XX-APO_VALEURS-XX. Les champs de la
section XX-APO_VALEURS-XX sont décrits par les lignes successives de la
section XX-APO_COLONNES-XX.
Le fichier CSV correspond à une étape, qui est récupérée sur la ligne
<pre>
apoL_c0001 VET V1CJ ...
</pre>
"""
from collections import namedtuple
import io
import pprint
import re
# Pour la détection auto de l'encodage des fichiers Apogée:
from chardet import detect as chardet_detect
from app import log
from app.scodoc.sco_exceptions import ScoFormatError
APO_PORTAL_ENCODING = (
"utf8" # encodage du fichier CSV Apogée (était 'ISO-8859-1' avant jul. 2016)
)
APO_INPUT_ENCODING = "ISO-8859-1" #
APO_OUTPUT_ENCODING = APO_INPUT_ENCODING # encodage des fichiers Apogee générés
APO_DECIMAL_SEP = "," # separateur décimal: virgule
APO_SEP = "\t"
APO_NEWLINE = "\r\n"
ApoEtudTuple = namedtuple("ApoEtudTuple", ("nip", "nom", "prenom", "naissance", "cols"))
class DictCol(dict):
"A dict, where we can add attributes"
class StringIOWithLineNumber(io.StringIO):
"simple wrapper to use a string as a file with line numbers"
def __init__(self, data: str):
super().__init__(data)
self.lineno = 0
def readline(self):
self.lineno += 1
return super().readline()
class ApoCSVReadWrite:
"Gestion lecture/écriture de fichiers csv Apogée"
def __init__(self, data: str):
if not data:
raise ScoFormatError("Fichier Apogée vide !")
self.data = data
self._file = StringIOWithLineNumber(data) # pour traiter comme un fichier
self.apo_elts: dict = None
self.cols: dict[str, dict[str, str]] = None
self.column_titles: str = None
self.col_ids: list[str] = None
self.csv_etuds: list[ApoEtudTuple] = []
# section_str: utilisé pour ré-écrire les headers sans aucune altération
self.sections_str: dict[str, str] = {}
"contenu initial de chaque section"
# self.header: str = ""
# "début du fichier Apogée jusqu'à XX-APO_TYP_RES-XX non inclu (sera ré-écrit non modifié)"
self.header_apo_typ_res: str = ""
"section XX-APO_TYP_RES-XX (qui peut en option ne pas être ré-écrite)"
self.titles: dict[str, str] = {}
"titres Apogée (section XX-APO_TITRES-XX)"
self.read_sections()
# Check that we have collected all requested infos:
if not self.header_apo_typ_res:
# on pourrait rendre XX-APO_TYP_RES-XX optionnelle mais mieux vaut vérifier:
raise ScoFormatError(
"format incorrect: pas de XX-APO_TYP_RES-XX",
filename=self.get_filename(),
)
if self.cols is None:
raise ScoFormatError(
"format incorrect: pas de XX-APO_COLONNES-XX",
filename=self.get_filename(),
)
if self.column_titles is None:
raise ScoFormatError(
"format incorrect: pas de XX-APO_VALEURS-XX",
filename=self.get_filename(),
)
def read_sections(self):
"""Lit une à une les sections du fichier Apogée"""
# sanity check: we are at the begining of Apogee CSV
start_pos = self._file.tell()
section = self._file.readline().strip()
if section != "XX-APO_TITRES-XX":
raise ScoFormatError("format incorrect: pas de XX-APO_TITRES-XX")
while True:
self.read_section(section)
line, end_pos = _apo_next_non_blank_line(self._file)
self.sections_str[section] = self.data[start_pos:end_pos]
if not line:
break
section = line
start_pos = end_pos
def read_section(self, section_name: str):
"""Read a section: _file is on the first line after section title"""
if section_name == "XX-APO_TITRES-XX":
# Titres:
# on va y chercher apoC_Fichier_Exp qui donnera le nom du fichier
# ainsi que l'année scolaire et le code diplôme.
self.titles = self._apo_read_titres(self._file)
elif section_name == "XX-APO_TYP_RES-XX":
self.header_apo_typ_res = _apo_read_typ_res(self._file)
elif section_name == "XX-APO_COLONNES-XX":
self.cols = self.apo_read_cols()
self.apo_elts = self.group_elt_cols(self.cols)
elif section_name == "XX-APO_VALEURS-XX":
# les étudiants
self.apo_read_section_valeurs()
else:
raise ScoFormatError(
f"format incorrect: section inconnue: {section_name}",
filename=self.get_filename(),
)
def apo_read_cols(self):
"""Lecture colonnes apo :
Démarre après la balise XX-APO_COLONNES-XX
et s'arrête après la ligne suivant la balise APO_COL_VAL_FIN
Colonne Apogee: les champs sont données par la ligne
apoL_a01_code de la section XX-APO_COLONNES-XX
col_id est apoL_c0001, apoL_c0002, ...
:return: { col_id : { title : value } }
Example: { 'apoL_c0001' : { 'Type Objet' : 'VET', 'Code' : 'V1IN', ... }, ... }
"""
line = self._file.readline().strip(" " + APO_NEWLINE)
fields = line.split(APO_SEP)
if fields[0] != "apoL_a01_code":
raise ScoFormatError(
f"invalid line: {line} (expecting apoL_a01_code)",
filename=self.get_filename(),
)
col_keys = fields
while True: # skip premiere partie (apoL_a02_nom, ...)
line = self._file.readline().strip(" " + APO_NEWLINE)
if line == "APO_COL_VAL_DEB":
break
# après APO_COL_VAL_DEB
cols = {}
i = 0
while True:
line = self._file.readline().strip(" " + APO_NEWLINE)
if line == "APO_COL_VAL_FIN":
break
i += 1
fields = line.split(APO_SEP)
# sanity check
col_id = fields[0] # apoL_c0001, ...
if col_id in cols:
raise ScoFormatError(
f"duplicate column definition: {col_id}",
filename=self.get_filename(),
)
m = re.match(r"^apoL_c([0-9]{4})$", col_id)
if not m:
raise ScoFormatError(
f"invalid column id: {line} (expecting apoL_c{col_id})",
filename=self.get_filename(),
)
if int(m.group(1)) != i:
raise ScoFormatError(
f"invalid column id: {col_id} for index {i}",
filename=self.get_filename(),
)
cols[col_id] = DictCol(list(zip(col_keys, fields)))
cols[col_id].lineno = self._file.lineno # for debuging purpose
self._file.readline() # skip next line
return cols
def group_elt_cols(self, cols) -> dict:
"""Return (ordered) dict of ApoElt from list of ApoCols.
Clé: id apogée, eg 'V1RT', 'V1GE2201', ...
Valeur: ApoElt, avec les attributs code, type_objet
Si les id Apogée ne sont pas uniques (ce n'est pas garanti), garde le premier
"""
elts = {}
for col_id in sorted(list(cols.keys()), reverse=True):
col = cols[col_id]
if col["Code"] in elts:
elts[col["Code"]].append(col)
else:
elts[col["Code"]] = ApoElt([col])
return elts # { code apo : ApoElt }
def apo_read_section_valeurs(self):
"traitement de la section XX-APO_VALEURS-XX"
self.column_titles = self._file.readline()
self.col_ids = self.column_titles.strip().split()
self.csv_etuds = self.apo_read_etuds()
def apo_read_etuds(self) -> list[ApoEtudTuple]:
"""Lecture des étudiants (et résultats) du fichier CSV Apogée.
Les lignes "étudiant" commencent toujours par
`12345678 NOM PRENOM 15/05/2003`
le premier code étant le NIP.
"""
etud_tuples = []
while True:
line = self._file.readline()
# cette section est impérativement la dernière du fichier
# donc on arrête ici:
if not line:
break
if not line.strip():
continue # silently ignore blank lines
line = line.strip(APO_NEWLINE)
fields = line.split(APO_SEP)
if len(fields) < 4:
raise ScoFormatError(
"""Ligne étudiant invalide
(doit commencer par 'NIP NOM PRENOM dd/mm/yyyy')""",
filename=self.get_filename(),
)
cols = {} # { col_id : value }
for i, field in enumerate(fields):
cols[self.col_ids[i]] = field
etud_tuples.append(
ApoEtudTuple(
nip=fields[0], # id etudiant
nom=fields[1],
prenom=fields[2],
naissance=fields[3],
cols=cols,
)
# XXX à remettre dans apogee_csv.py
# export_res_etape=self.export_res_etape,
# export_res_sem=self.export_res_sem,
# export_res_ues=self.export_res_ues,
# export_res_modules=self.export_res_modules,
# export_res_sdj=self.export_res_sdj,
# export_res_rat=self.export_res_rat,
# )
)
return etud_tuples
def _apo_read_titres(self, f) -> dict:
"Lecture section TITRES du fichier Apogée, renvoie dict"
d = {}
while True:
line = f.readline().strip(
" " + APO_NEWLINE
) # ne retire pas le \t (pour les clés vides)
if not line.strip(): # stoppe sur ligne pleines de \t
break
fields = line.split(APO_SEP)
if len(fields) == 2:
k, v = fields
else:
log(f"Error read CSV: \nline={line}\nfields={fields}")
log(dir(f))
raise ScoFormatError(
f"Fichier Apogee incorrect (section titres, {len(fields)} champs au lieu de 2)",
filename=self.get_filename(),
)
d[k] = v
#
if not d.get("apoC_Fichier_Exp", None):
raise ScoFormatError(
"Fichier Apogee incorrect: pas de titre apoC_Fichier_Exp",
filename=self.get_filename(),
)
# keep only basename: may be a windows or unix pathname
s = d["apoC_Fichier_Exp"].split("/")[-1]
s = s.split("\\")[-1] # for DOS paths, eg C:\TEMP\VL4RT_V3ASR.TXT
d["apoC_Fichier_Exp"] = s
return d
def get_filename(self) -> str:
"""Le nom du fichier APogée, tel qu'indiqué dans le fichier
ou vide."""
if self.titles:
return self.titles.get("apoC_Fichier_Exp", "")
return ""
def write(self, apo_etuds: list["ApoEtud"]) -> bytes:
"""Renvoie le contenu actualisé du fichier Apogée"""
f = io.StringIO()
self._write_header(f)
self._write_etuds(f, apo_etuds)
return f.getvalue().encode(APO_OUTPUT_ENCODING)
def _write_etuds(self, f, apo_etuds: list["ApoEtud"]):
"""write apo CSV etuds on f"""
for apo_etud in apo_etuds:
fields = [] # e['nip'], e['nom'], e['prenom'], e['naissance'] ]
for col_id in self.col_ids:
try:
fields.append(str(apo_etud.new_cols[col_id]))
except KeyError:
log(
f"""Error: {apo_etud["nip"]} {apo_etud["nom"]} missing column key {col_id}
Details:\napo_etud = {pprint.pformat(apo_etud)}
col_ids={pprint.pformat(self.col_ids)}
étudiant ignoré.
"""
)
f.write(APO_SEP.join(fields) + APO_NEWLINE)
def _write_header(self, f):
"""write apo CSV header on f
(beginning of CSV until columns titles just after XX-APO_VALEURS-XX line)
"""
for section, data in self.sections_str.items():
if section != "XX-APO_VALEURS-XX":
# XXX TODO ici on va filtrer XX-APO_TYP_RES-XX
f.write(data)
f.write("XX-APO_VALEURS-XX" + APO_NEWLINE)
f.write(self.column_titles)
class ApoElt:
"""Définition d'un Element Apogée
sur plusieurs colonnes du fichier CSV
"""
def __init__(self, cols):
assert len(cols) > 0
assert len(set([c["Code"] for c in cols])) == 1 # colonnes de meme code
assert len(set([c["Type Objet"] for c in cols])) == 1 # colonnes de meme type
self.cols = cols
self.code = cols[0]["Code"]
self.version = cols[0]["Version"]
self.type_objet = cols[0]["Type Objet"]
def append(self, col):
"""ajoute une "colonne" à l'élément"""
assert col["Code"] == self.code
if col["Type Objet"] != self.type_objet:
log(
f"""Warning: ApoElt: duplicate id {
self.code} ({self.type_objet} and {col["Type Objet"]})"""
)
self.type_objet = col["Type Objet"]
self.cols.append(col)
def __repr__(self):
return f"ApoElt(code='{self.code}', cols={pprint.pformat(self.cols)})"
def guess_data_encoding(text: bytes, threshold=0.6):
"""Guess string encoding, using chardet heuristics.
Returns encoding, or None if detection failed (confidence below threshold)
"""
r = chardet_detect(text)
if r["confidence"] < threshold:
return None
else:
return r["encoding"]
def fix_data_encoding(
text: bytes,
default_source_encoding=APO_INPUT_ENCODING,
dest_encoding=APO_INPUT_ENCODING,
) -> tuple[bytes, str]:
"""Try to ensure that text is using dest_encoding
returns converted text, and a message describing the conversion.
Raises UnicodeEncodeError en cas de problème, en général liée à
une auto-détection errornée.
"""
message = ""
detected_encoding = guess_data_encoding(text)
if not detected_encoding:
if default_source_encoding != dest_encoding:
message = f"converting from {default_source_encoding} to {dest_encoding}"
text = text.decode(default_source_encoding).encode(dest_encoding)
else:
if detected_encoding != dest_encoding:
message = (
f"converting from detected {default_source_encoding} to {dest_encoding}"
)
text = text.decode(detected_encoding).encode(dest_encoding)
return text, message
def _apo_read_typ_res(f) -> str:
"Lit la section XX-APO_TYP_RES-XX"
text = "XX-APO_TYP_RES-XX" + APO_NEWLINE
while True:
line = f.readline()
stripped_line = line.strip()
if not stripped_line:
break
text += line
return text
def _apo_next_non_blank_line(f: StringIOWithLineNumber) -> tuple[str, int]:
"Ramène prochaine ligne non blanche, stripped, et l'indice de son début"
while True:
pos = f.tell()
line = f.readline()
if not line:
return "", -1
stripped_line = line.strip()
if stripped_line:
return stripped_line, pos

View File

@ -167,8 +167,9 @@ class BulletinGenerator:
formsemestre_id = self.bul_dict["formsemestre_id"] formsemestre_id = self.bul_dict["formsemestre_id"]
nomprenom = self.bul_dict["etud"]["nomprenom"] nomprenom = self.bul_dict["etud"]["nomprenom"]
etat_civil = self.bul_dict["etud"]["etat_civil"]
marque_debut_bulletin = sco_pdf.DebutBulletin( marque_debut_bulletin = sco_pdf.DebutBulletin(
nomprenom, self.bul_dict["etat_civil"],
filigranne=self.bul_dict["filigranne"], filigranne=self.bul_dict["filigranne"],
footer_content=f"""ScoDoc - Bulletin de {nomprenom} - {time.strftime("%d/%m/%Y %H:%M")}""", footer_content=f"""ScoDoc - Bulletin de {nomprenom} - {time.strftime("%d/%m/%Y %H:%M")}""",
) )
@ -211,7 +212,7 @@ class BulletinGenerator:
document, document,
author="%s %s (E. Viennet) [%s]" author="%s %s (E. Viennet) [%s]"
% (sco_version.SCONAME, sco_version.SCOVERSION, self.description), % (sco_version.SCONAME, sco_version.SCOVERSION, self.description),
title=f"""Bulletin {sem["titremois"]} de {nomprenom}""", title=f"""Bulletin {sem["titremois"]} de {etat_civil}""",
subject="Bulletin de note", subject="Bulletin de note",
margins=self.margins, margins=self.margins,
server_name=self.server_name, server_name=self.server_name,

View File

@ -76,7 +76,7 @@ import re
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
from app.scodoc import sco_archives from app.scodoc import sco_archives
from app.scodoc import sco_apogee_csv from app.scodoc import sco_apogee_csv, sco_apogee_reader
from app.scodoc.sco_exceptions import ScoValueError from app.scodoc.sco_exceptions import ScoValueError
@ -108,7 +108,7 @@ def apo_csv_store(csv_data: str, annee_scolaire, sem_id):
# sanity check # sanity check
filesize = len(csv_data) filesize = len(csv_data)
if filesize < 10 or filesize > scu.CONFIG.ETUD_MAX_FILE_SIZE: if filesize < 10 or filesize > scu.CONFIG.ETUD_MAX_FILE_SIZE:
raise ScoValueError("Fichier csv de taille invalide ! (%d)" % filesize) raise ScoValueError(f"Fichier csv de taille invalide ! ({filesize})")
if not annee_scolaire: if not annee_scolaire:
raise ScoValueError("Impossible de déterminer l'année scolaire !") raise ScoValueError("Impossible de déterminer l'année scolaire !")
@ -121,13 +121,13 @@ def apo_csv_store(csv_data: str, annee_scolaire, sem_id):
if str(apo_data.etape) in apo_csv_list_stored_etapes(annee_scolaire, sem_id=sem_id): if str(apo_data.etape) in apo_csv_list_stored_etapes(annee_scolaire, sem_id=sem_id):
raise ScoValueError( raise ScoValueError(
"Etape %s déjà stockée pour cette année scolaire !" % apo_data.etape f"Etape {apo_data.etape} déjà stockée pour cette année scolaire !"
) )
oid = "%d-%d" % (annee_scolaire, sem_id) oid = f"{annee_scolaire}-{sem_id}"
description = "%s;%s;%s" % (str(apo_data.etape), annee_scolaire, sem_id) description = f"""{str(apo_data.etape)};{annee_scolaire};{sem_id}"""
archive_id = ApoCSVArchive.create_obj_archive(oid, description) archive_id = ApoCSVArchive.create_obj_archive(oid, description)
csv_data_bytes = csv_data.encode(sco_apogee_csv.APO_OUTPUT_ENCODING) csv_data_bytes = csv_data.encode(sco_apogee_reader.APO_OUTPUT_ENCODING)
ApoCSVArchive.store(archive_id, filename, csv_data_bytes) ApoCSVArchive.store(archive_id, filename, csv_data_bytes)
return apo_data.etape return apo_data.etape
@ -212,7 +212,7 @@ def apo_csv_get(etape_apo="", annee_scolaire="", sem_id="") -> str:
data = ApoCSVArchive.get(archive_id, etape_apo + ".csv") data = ApoCSVArchive.get(archive_id, etape_apo + ".csv")
# ce fichier a été archivé donc généré par ScoDoc # ce fichier a été archivé donc généré par ScoDoc
# son encodage est donc APO_OUTPUT_ENCODING # son encodage est donc APO_OUTPUT_ENCODING
return data.decode(sco_apogee_csv.APO_OUTPUT_ENCODING) return data.decode(sco_apogee_reader.APO_OUTPUT_ENCODING)
# ------------------------------------------------------------------------ # ------------------------------------------------------------------------

View File

@ -32,13 +32,13 @@ import io
from zipfile import ZipFile from zipfile import ZipFile
import flask import flask
from flask import flash, g, request, send_file, url_for from flask import flash, g, request, Response, send_file, url_for
import app.scodoc.sco_utils as scu import app.scodoc.sco_utils as scu
from app import log from app import log
from app.models import Formation from app.models import Formation
from app.scodoc import html_sco_header from app.scodoc import html_sco_header
from app.scodoc import sco_apogee_csv from app.scodoc import sco_apogee_csv, sco_apogee_reader
from app.scodoc import sco_etape_apogee from app.scodoc import sco_etape_apogee
from app.scodoc import sco_formsemestre from app.scodoc import sco_formsemestre
from app.scodoc import sco_portal_apogee from app.scodoc import sco_portal_apogee
@ -46,7 +46,7 @@ from app.scodoc import sco_preferences
from app.scodoc import sco_semset from app.scodoc import sco_semset
from app.scodoc import sco_etud from app.scodoc import sco_etud
from app.scodoc.gen_tables import GenTable from app.scodoc.gen_tables import GenTable
from app.scodoc.sco_apogee_csv import APO_INPUT_ENCODING, APO_OUTPUT_ENCODING from app.scodoc.sco_apogee_reader import APO_INPUT_ENCODING, APO_OUTPUT_ENCODING
from app.scodoc.sco_exceptions import ScoValueError from app.scodoc.sco_exceptions import ScoValueError
@ -240,7 +240,11 @@ def apo_semset_maq_status(
if semset["jury_ok"]: if semset["jury_ok"]:
H.append("""<li>Décisions de jury saisies</li>""") H.append("""<li>Décisions de jury saisies</li>""")
else: else:
H.append("""<li>Il manque des décisions de jury !</li>""") H.append(
f"""<li>Il manque de {semset["jury_nb_missing"]}
décision{"s" if semset["jury_nb_missing"] > 1 else ""}
de jury !</li>"""
)
if ok_for_export: if ok_for_export:
H.append("""<li>%d étudiants, prêt pour l'export.</li>""" % len(nips_ok)) H.append("""<li>%d étudiants, prêt pour l'export.</li>""" % len(nips_ok))
@ -275,11 +279,10 @@ def apo_semset_maq_status(
if semset and ok_for_export: if semset and ok_for_export:
H.append( H.append(
"""<form class="form_apo_export" action="apo_csv_export_results" method="get"> f"""<form class="form_apo_export" action="apo_csv_export_results" method="get">
<input type="submit" value="Export vers Apogée"> <input type="submit" value="Export vers Apogée">
<input type="hidden" name="semset_id" value="%s"/> <input type="hidden" name="semset_id" value="{semset_id}"/>
""" """
% (semset_id,)
) )
H.append('<div id="param_export_res">') H.append('<div id="param_export_res">')
@ -372,7 +375,7 @@ def apo_semset_maq_status(
H.append("</div>") H.append("</div>")
# Aide: # Aide:
H.append( H.append(
""" f"""
<p><a class="stdlink" href="semset_page">Retour aux ensembles de semestres</a></p> <p><a class="stdlink" href="semset_page">Retour aux ensembles de semestres</a></p>
<div class="pas_help"> <div class="pas_help">
@ -381,10 +384,12 @@ def apo_semset_maq_status(
l'export des résultats après les jurys, puis de remplir et exporter ces fichiers. l'export des résultats après les jurys, puis de remplir et exporter ces fichiers.
</p> </p>
<p> <p>
Les fichiers ("maquettes") Apogée sont de type CSV, du texte codé en %s. Les fichiers ("maquettes") Apogée sont de type CSV, du texte codé en {APO_INPUT_ENCODING}.
</p>
<p>On a un fichier par étape Apogée. Pour les obtenir, soit on peut les télécharger
directement (si votre ScoDoc est interfacé avec Apogée), soit se débrouiller pour
exporter le fichier texte depuis Apogée. Son contenu ressemble à cela:
</p> </p>
<p>On a un fichier par étape Apogée. Pour les obtenir, soit on peut les télécharger directement (si votre ScoDoc est interfacé avec Apogée), soit se débrouiller pour exporter le fichier
texte depuis Apogée. Son contenu ressemble à cela:</p>
<pre class="small_pre_acc"> <pre class="small_pre_acc">
XX-APO_TITRES-XX XX-APO_TITRES-XX
apoC_annee 2007/2008 apoC_annee 2007/2008
@ -427,7 +432,6 @@ def apo_semset_maq_status(
</p> </p>
</div> </div>
""" """
% (APO_INPUT_ENCODING,)
) )
H.append(html_sco_header.sco_footer()) H.append(html_sco_header.sco_footer())
return "\n".join(H) return "\n".join(H)
@ -446,21 +450,25 @@ def table_apo_csv_list(semset):
# Ajoute qq infos pour affichage: # Ajoute qq infos pour affichage:
csv_data = sco_etape_apogee.apo_csv_get(t["etape_apo"], annee_scolaire, sem_id) csv_data = sco_etape_apogee.apo_csv_get(t["etape_apo"], annee_scolaire, sem_id)
apo_data = sco_apogee_csv.ApoData(csv_data, periode=semset["sem_id"]) apo_data = sco_apogee_csv.ApoData(csv_data, periode=semset["sem_id"])
t["filename"] = apo_data.titles["apoC_Fichier_Exp"] t["filename"] = apo_data.apo_csv.titles["apoC_Fichier_Exp"]
t["nb_etuds"] = len(apo_data.etuds) t["nb_etuds"] = len(apo_data.etuds)
t["date_str"] = t["date"].strftime("%d/%m/%Y à %H:%M") t["date_str"] = t["date"].strftime("%d/%m/%Y à %H:%M")
view_link = "view_apo_csv?etape_apo=%s&semset_id=%s" % ( view_link = url_for(
t["etape_apo"], "notes.view_apo_csv",
semset["semset_id"], scodoc_dept=g.scodoc_dept,
etape_apo=t["etape_apo"],
semset_id=semset["semset_id"],
) )
t["_filename_target"] = view_link t["_filename_target"] = view_link
t["_etape_apo_target"] = view_link t["_etape_apo_target"] = view_link
t["suppress"] = scu.icontag( t["suppress"] = scu.icontag(
"delete_small_img", border="0", alt="supprimer", title="Supprimer" "delete_small_img", border="0", alt="supprimer", title="Supprimer"
) )
t["_suppress_target"] = "view_apo_csv_delete?etape_apo=%s&semset_id=%s" % ( t["_suppress_target"] = url_for(
t["etape_apo"], "notes.view_apo_csv_delete",
semset["semset_id"], scodoc_dept=g.scodoc_dept,
etape_apo=t["etape_apo"],
semset_id=semset["semset_id"],
) )
columns_ids = ["filename", "etape_apo", "date_str", "nb_etuds"] columns_ids = ["filename", "etape_apo", "date_str", "nb_etuds"]
@ -504,13 +512,16 @@ def view_apo_etuds(semset_id, title="", nip_list="", format="html"):
for etud in etuds.values(): for etud in etuds.values():
etud_sco = sco_etud.get_etud_info(code_nip=etud["nip"], filled=True) etud_sco = sco_etud.get_etud_info(code_nip=etud["nip"], filled=True)
if etud_sco: if etud_sco:
e = etud_sco[0]
etud["inscriptions_scodoc"] = ", ".join( etud["inscriptions_scodoc"] = ", ".join(
[ [
'<a href="formsemestre_bulletinetud?formsemestre_id={s[formsemestre_id]}&etudid={e[etudid]}">{s[etapes_apo_str]} (S{s[semestre_id]})</a>'.format( f"""<a href="{
s=sem, e=e url_for('notes.formsemestre_bulletinetud',
) scodoc_dept=g.scodoc_dept,
for sem in e["sems"] formsemestre_id=sem["formsemestre_id"],
etudid=etud_sco[0]["etudid"])
}">{sem["etapes_apo_str"]} (S{sem["semestre_id"]})</a>
"""
for sem in etud_sco[0]["sems"]
] ]
) )
@ -534,8 +545,8 @@ def view_scodoc_etuds(semset_id, title="", nip_list="", format="html"):
tgt = url_for("scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=e["etudid"]) tgt = url_for("scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=e["etudid"])
e["_nom_target"] = tgt e["_nom_target"] = tgt
e["_prenom_target"] = tgt e["_prenom_target"] = tgt
e["_nom_td_attrs"] = 'id="%s" class="etudinfo"' % (e["etudid"],) e["_nom_td_attrs"] = f"""id="{e['etudid']}" class="etudinfo" """
e["_prenom_td_attrs"] = 'id="pre-%s" class="etudinfo"' % (e["etudid"],) e["_prenom_td_attrs"] = f"""id="pre-{e['etudid']}" class="etudinfo" """
return _view_etuds_page( return _view_etuds_page(
semset_id, semset_id,
@ -546,20 +557,14 @@ def view_scodoc_etuds(semset_id, title="", nip_list="", format="html"):
) )
def _view_etuds_page(semset_id, title="", etuds=[], keys=(), format="html"): def _view_etuds_page(
semset_id: int, title="", etuds: list = None, keys=(), format="html"
) -> str:
"Affiche les étudiants indiqués"
# Tri les étudiants par nom: # Tri les étudiants par nom:
if etuds: if etuds: # XXX TODO modifier pour utiliser clé de tri
etuds.sort(key=lambda x: (x["nom"], x["prenom"])) etuds.sort(key=lambda x: (x["nom"], x["prenom"]))
H = [
html_sco_header.sco_header(
page_title=title,
init_qtip=True,
javascripts=["js/etud_info.js"],
),
"<h2>%s</h2>" % title,
]
tab = GenTable( tab = GenTable(
titles={ titles={
"nip": "Code NIP", "nip": "Code NIP",
@ -579,14 +584,23 @@ def _view_etuds_page(semset_id, title="", etuds=[], keys=(), format="html"):
if format != "html": if format != "html":
return tab.make_page(format=format) return tab.make_page(format=format)
H.append(tab.html()) return f"""
{html_sco_header.sco_header(
page_title=title,
init_qtip=True,
javascripts=["js/etud_info.js"],
)}
<h2>{title}</h2>
H.append( {tab.html()}
"""<p><a href="apo_semset_maq_status?semset_id=%s">Retour à la page d'export Apogée</a>"""
% semset_id
)
return "\n".join(H) + html_sco_header.sco_footer() <p><a href="{
url_for("notes.apo_semset_maq_status",
scodoc_dept=g.scodoc_dept, semset_id=semset_id)
}">Retour à la page d'export Apogée</a>
</p>
{html_sco_header.sco_footer()}
"""
def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=False): def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=False):
@ -603,7 +617,7 @@ def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=
if autodetect: if autodetect:
# check encoding (although documentation states that users SHOULD upload LATIN1) # check encoding (although documentation states that users SHOULD upload LATIN1)
data, message = sco_apogee_csv.fix_data_encoding(data) data, message = sco_apogee_reader.fix_data_encoding(data)
if message: if message:
log(f"view_apo_csv_store: {message}") log(f"view_apo_csv_store: {message}")
else: else:
@ -623,7 +637,7 @@ def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=
f""" f"""
Erreur: l'encodage du fichier est mal détecté. Erreur: l'encodage du fichier est mal détecté.
Essayez sans auto-détection, ou vérifiez le codage et le contenu Essayez sans auto-détection, ou vérifiez le codage et le contenu
du fichier (qui doit être en {sco_apogee_csv.APO_INPUT_ENCODING}). du fichier (qui doit être en {sco_apogee_reader.APO_INPUT_ENCODING}).
""", """,
dest_url=dest_url, dest_url=dest_url,
) from exc ) from exc
@ -631,7 +645,7 @@ def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=
raise ScoValueError( raise ScoValueError(
f""" f"""
Erreur: l'encodage du fichier est incorrect. Erreur: l'encodage du fichier est incorrect.
Vérifiez qu'il est bien en {sco_apogee_csv.APO_INPUT_ENCODING} Vérifiez qu'il est bien en {sco_apogee_reader.APO_INPUT_ENCODING}
""", """,
dest_url=dest_url, dest_url=dest_url,
) from exc ) from exc
@ -640,20 +654,20 @@ def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=
apo_data = sco_apogee_csv.ApoData( apo_data = sco_apogee_csv.ApoData(
data_str, periode=semset["sem_id"] data_str, periode=semset["sem_id"]
) # parse le fichier -> exceptions ) # parse le fichier -> exceptions
dest_url = url_for(
"notes.apo_semset_maq_status",
scodoc_dept=g.scodoc_dept,
semset_id=semset_id,
)
if apo_data.etape not in semset["etapes"]: if apo_data.etape not in semset["etapes"]:
raise ScoValueError( raise ScoValueError(
"Le code étape de ce fichier ne correspond pas à ceux de cet ensemble" "Le code étape de ce fichier ne correspond pas à ceux de cet ensemble",
dest_url=dest_url,
) )
sco_etape_apogee.apo_csv_store(data_str, semset["annee_scolaire"], semset["sem_id"]) sco_etape_apogee.apo_csv_store(data_str, semset["annee_scolaire"], semset["sem_id"])
return flask.redirect( return flask.redirect(dest_url)
url_for(
"notes.apo_semset_maq_status",
scodoc_dept=g.scodoc_dept,
semset_id=semset_id,
)
)
def view_apo_csv_download_and_store(etape_apo="", semset_id=""): def view_apo_csv_download_and_store(etape_apo="", semset_id=""):
@ -679,9 +693,8 @@ def view_apo_csv_delete(etape_apo="", semset_id="", dialog_confirmed=False):
dest_url = f"apo_semset_maq_status?semset_id={semset_id}" dest_url = f"apo_semset_maq_status?semset_id={semset_id}"
if not dialog_confirmed: if not dialog_confirmed:
return scu.confirm_dialog( return scu.confirm_dialog(
"""<h2>Confirmer la suppression du fichier étape <tt>%s</tt>?</h2> f"""<h2>Confirmer la suppression du fichier étape <tt>{etape_apo}</tt>?</h2>
<p>La suppression sera définitive.</p>""" <p>La suppression sera définitive.</p>""",
% (etape_apo,),
dest_url="", dest_url="",
cancel_url=dest_url, cancel_url=dest_url,
parameters={"semset_id": semset_id, "etape_apo": etape_apo}, parameters={"semset_id": semset_id, "etape_apo": etape_apo},
@ -727,24 +740,24 @@ def view_apo_csv(etape_apo="", semset_id="", format="html"):
H = [ H = [
html_sco_header.sco_header( html_sco_header.sco_header(
page_title="Maquette Apogée enregistrée pour %s" % etape_apo, page_title=f"""Maquette Apogée enregistrée pour {etape_apo}""",
init_qtip=True, init_qtip=True,
javascripts=["js/etud_info.js"], javascripts=["js/etud_info.js"],
), ),
"""<h2>Etudiants dans la maquette Apogée %s</h2>""" % etape_apo, f"""<h2>Étudiants dans la maquette Apogée {etape_apo}</h2>
"""<p>Pour l'ensemble <a class="stdlink" href="apo_semset_maq_status?semset_id=%(semset_id)s">%(title)s</a> (indice semestre: %(sem_id)s)</p>""" <p>Pour l'ensemble <a class="stdlink" href="{
% semset, url_for("notes.apo_semset_maq_status",
scodoc_dept=g.scodoc_dept, semset_id=semset["semset_id"])
}">{semset['title']}</a> (indice semestre: {semset['sem_id']})
</p>
<div class="apo_csv_infos">
<div class="apo_csv_etape"><span>Code étape:</span><span>{
apo_data.etape_apogee} VDI {apo_data.vdi_apogee} (année {apo_data.annee_scolaire
})</span>
</div>
</div>
""",
] ]
# Infos générales
H.append(
"""
<div class="apo_csv_infos">
<div class="apo_csv_etape"><span>Code étape:</span><span>{0.etape_apogee} VDI {0.vdi_apogee} (année {0.annee_scolaire})</span></div>
</div>
""".format(
apo_data
)
)
# Liste des étudiants (sans les résultats pour le moment): TODO # Liste des étudiants (sans les résultats pour le moment): TODO
etuds = apo_data.etuds etuds = apo_data.etuds
@ -789,12 +802,21 @@ def view_apo_csv(etape_apo="", semset_id="", format="html"):
return tab.make_page(format=format) return tab.make_page(format=format)
H += [ H += [
tab.html(), f"""
"""<p><a class="stdlink" href="view_apo_csv?etape_apo=%s&semset_id=%s&format=raw">fichier maquette CSV brut (non rempli par ScoDoc)</a></p>""" {tab.html()}
% (etape_apo, semset_id), <p><a class="stdlink" href="{
"""<div><a class="stdlink" href="apo_semset_maq_status?semset_id=%s">Retour</a> url_for("notes.view_apo_csv",
</div>""" scodoc_dept=g.scodoc_dept,
% semset_id, etape_apo=etape_apo, semset_id=semset_id, format="raw")
}">fichier maquette CSV brut (non rempli par ScoDoc)</a>
</p>
<div>
<a class="stdlink" href="{
url_for("notes.apo_semset_maq_status",
scodoc_dept=g.scodoc_dept, semset_id=semset_id)
}">Retour</a>
</div>
""",
html_sco_header.sco_footer(), html_sco_header.sco_footer(),
] ]
@ -809,7 +831,7 @@ def apo_csv_export_results(
block_export_res_ues=False, block_export_res_ues=False,
block_export_res_modules=False, block_export_res_modules=False,
block_export_res_sdj=False, block_export_res_sdj=False,
): ) -> Response:
"""Remplit les fichiers CSV archivés """Remplit les fichiers CSV archivés
et donne un ZIP avec tous les résultats. et donne un ZIP avec tous les résultats.
""" """
@ -833,31 +855,28 @@ def apo_csv_export_results(
periode = semset["sem_id"] periode = semset["sem_id"]
data = io.BytesIO() data = io.BytesIO()
dest_zip = ZipFile(data, "w") with ZipFile(data, "w") as dest_zip:
etapes_apo = sco_etape_apogee.apo_csv_list_stored_etapes(
etapes_apo = sco_etape_apogee.apo_csv_list_stored_etapes( annee_scolaire, periode, etapes=semset.list_etapes()
annee_scolaire, periode, etapes=semset.list_etapes()
)
for etape_apo in etapes_apo:
apo_csv = sco_etape_apogee.apo_csv_get(etape_apo, annee_scolaire, periode)
sco_apogee_csv.export_csv_to_apogee(
apo_csv,
periode=periode,
export_res_etape=export_res_etape,
export_res_sem=export_res_sem,
export_res_ues=export_res_ues,
export_res_modules=export_res_modules,
export_res_sdj=export_res_sdj,
export_res_rat=export_res_rat,
dest_zip=dest_zip,
) )
for etape_apo in etapes_apo:
apo_csv = sco_etape_apogee.apo_csv_get(etape_apo, annee_scolaire, periode)
sco_apogee_csv.export_csv_to_apogee(
apo_csv,
periode=periode,
export_res_etape=export_res_etape,
export_res_sem=export_res_sem,
export_res_ues=export_res_ues,
export_res_modules=export_res_modules,
export_res_sdj=export_res_sdj,
export_res_rat=export_res_rat,
dest_zip=dest_zip,
)
dest_zip.close()
data.seek(0) data.seek(0)
basename = ( basename = (
sco_preferences.get_preference("DeptName") sco_preferences.get_preference("DeptName")
+ str(annee_scolaire) + f"{annee_scolaire}-{periode}-"
+ "-%s-" % periode
+ "-".join(etapes_apo) + "-".join(etapes_apo)
) )
basename = scu.unescape_html(basename) basename = scu.unescape_html(basename)

View File

@ -174,7 +174,7 @@ class DataEtudiant(object):
return self.data_apogee["nom"] + self.data_apogee["prenom"] return self.data_apogee["nom"] + self.data_apogee["prenom"]
def help(): def _help() -> str:
return """ return """
<div id="export_help" class="pas_help"> <span>Explications sur les tableaux des effectifs et liste des <div id="export_help" class="pas_help"> <span>Explications sur les tableaux des effectifs et liste des
étudiants</span> étudiants</span>
@ -501,7 +501,7 @@ class EtapeBilan:
entete_liste_etudiant(), entete_liste_etudiant(),
self.table_effectifs(), self.table_effectifs(),
"""</details>""", """</details>""",
help(), _help(),
] ]
return "\n".join(H) return "\n".join(H)

View File

@ -57,7 +57,12 @@ def format_etud_ident(etud):
else: else:
etud["nom_usuel"] = "" etud["nom_usuel"] = ""
etud["prenom"] = format_prenom(etud["prenom"]) etud["prenom"] = format_prenom(etud["prenom"])
if "prenom_etat_civil" in etud:
etud["prenom_etat_civil"] = format_prenom(etud["prenom_etat_civil"])
else:
etud["prenom_etat_civil"] = ""
etud["civilite_str"] = format_civilite(etud["civilite"]) etud["civilite_str"] = format_civilite(etud["civilite"])
etud["civilite_etat_civil_str"] = format_civilite(etud["civilite_etat_civil"])
# Nom à afficher: # Nom à afficher:
if etud["nom_usuel"]: if etud["nom_usuel"]:
etud["nom_disp"] = etud["nom_usuel"] etud["nom_disp"] = etud["nom_usuel"]
@ -225,7 +230,12 @@ _identiteEditor = ndb.EditableTable(
"nom", "nom",
"nom_usuel", "nom_usuel",
"prenom", "prenom",
"prenom_etat_civil",
"cas_id",
"cas_allow_login",
"cas_allow_scodoc_login",
"civilite", # 'M", "F", or "X" "civilite", # 'M", "F", or "X"
"civilite_etat_civil",
"date_naissance", "date_naissance",
"lieu_naissance", "lieu_naissance",
"dept_naissance", "dept_naissance",
@ -242,7 +252,9 @@ _identiteEditor = ndb.EditableTable(
input_formators={ input_formators={
"nom": force_uppercase, "nom": force_uppercase,
"prenom": force_uppercase, "prenom": force_uppercase,
"prenom_etat_civil": force_uppercase,
"civilite": input_civilite, "civilite": input_civilite,
"civilite_etat_civil": input_civilite,
"date_naissance": ndb.DateDMYtoISO, "date_naissance": ndb.DateDMYtoISO,
"boursier": bool, "boursier": bool,
}, },
@ -263,6 +275,7 @@ def identite_list(cnx, *a, **kw):
else: else:
o["annee_naissance"] = o["date_naissance"] o["annee_naissance"] = o["date_naissance"]
o["civilite_str"] = format_civilite(o["civilite"]) o["civilite_str"] = format_civilite(o["civilite"])
o["civilite_etat_civil_str"] = format_civilite(o["civilite_etat_civil"])
return objs return objs

View File

@ -29,6 +29,7 @@
""" """
from flask_login import current_user from flask_login import current_user
# --- Exceptions # --- Exceptions
class ScoException(Exception): class ScoException(Exception):
"super classe de toutes les exceptions ScoDoc." "super classe de toutes les exceptions ScoDoc."
@ -44,6 +45,7 @@ class ScoInvalidCSRF(ScoException):
class ScoValueError(ScoException): class ScoValueError(ScoException):
"Exception avec page d'erreur utilisateur, et qui stoque dest_url" "Exception avec page d'erreur utilisateur, et qui stoque dest_url"
# mal nommée: super classe de toutes les exceptions avec page # mal nommée: super classe de toutes les exceptions avec page
# d'erreur gentille. # d'erreur gentille.
def __init__(self, msg, dest_url=None): def __init__(self, msg, dest_url=None):
@ -75,7 +77,11 @@ class InvalidEtudId(NoteProcessError):
class ScoFormatError(ScoValueError): class ScoFormatError(ScoValueError):
pass "Erreur lecture d'un fichier fourni par l'utilisateur"
def __init__(self, msg, filename="", dest_url=None):
super().__init__(msg, dest_url=dest_url)
self.filename = filename
class ScoInvalidParamError(ScoValueError): class ScoInvalidParamError(ScoValueError):

View File

@ -127,7 +127,7 @@ def formation_export_dict(
ue_dict["apc_niveau_libelle"] = ue.niveau_competence.libelle ue_dict["apc_niveau_libelle"] = ue.niveau_competence.libelle
ue_dict["apc_niveau_annee"] = ue.niveau_competence.annee ue_dict["apc_niveau_annee"] = ue.niveau_competence.annee
ue_dict["apc_niveau_ordre"] = ue.niveau_competence.ordre ue_dict["apc_niveau_ordre"] = ue.niveau_competence.ordre
# Et le parcour: # Et les parcours:
if ue.parcours: if ue.parcours:
ue_dict["parcours"] = [ ue_dict["parcours"] = [
parcour.to_dict(with_annees=False) for parcour in ue.parcours parcour.to_dict(with_annees=False) for parcour in ue.parcours
@ -268,8 +268,8 @@ def _formation_retreive_refcomp(f_dict: dict) -> int:
def _formation_retreive_apc_niveau( def _formation_retreive_apc_niveau(
referentiel_competence_id: int, ue_dict: dict referentiel_competence_id: int, ue_dict: dict
) -> int: ) -> int:
"""Recherche dans le ref. de comp. un niveau pour cette UE """Recherche dans le ref. de comp. un niveau pour cette UE.
utilise comme clé (libelle, annee, ordre) Utilise (libelle, annee, ordre) comme clé.
""" """
libelle = ue_dict.get("apc_niveau_libelle") libelle = ue_dict.get("apc_niveau_libelle")
annee = ue_dict.get("apc_niveau_annee") annee = ue_dict.get("apc_niveau_annee")
@ -367,6 +367,8 @@ def formation_import_xml(doc: str, import_tags=True, use_local_refcomp=False):
assert ue assert ue
if xml_ue_id: if xml_ue_id:
ues_old2new[xml_ue_id] = ue_id ues_old2new[xml_ue_id] = ue_id
# parcours BUT
# TODO XXX
# élément optionnel présent dans les exports BUT: # élément optionnel présent dans les exports BUT:
ue_reference = ue_info[1].get("reference") ue_reference = ue_info[1].get("reference")
if ue_reference: if ue_reference:

View File

@ -71,6 +71,8 @@ FORMAT_FILE = "format_import_etudiants.txt"
ADMISSION_MODIFIABLE_FIELDS = ( ADMISSION_MODIFIABLE_FIELDS = (
"code_nip", "code_nip",
"code_ine", "code_ine",
"prenom_etat_civil",
"civilite_etat_civil",
"date_naissance", "date_naissance",
"lieu_naissance", "lieu_naissance",
"bac", "bac",

View File

@ -176,6 +176,18 @@ def ficheEtud(etudid=None):
sco_etud.fill_etuds_info([etud_]) sco_etud.fill_etuds_info([etud_])
# #
info = etud_ info = etud_
if etud.prenom_etat_civil:
info["etat_civil"] = (
"<h3>Etat-civil: "
+ etud.civilite_etat_civil_str
+ " "
+ etud.prenom_etat_civil
+ " "
+ etud.nom
+ "</h3>"
)
else:
info["etat_civil"] = ""
info["ScoURL"] = scu.ScoURL() info["ScoURL"] = scu.ScoURL()
info["authuser"] = authuser info["authuser"] = authuser
info["info_naissance"] = info["date_naissance"] info["info_naissance"] = info["date_naissance"]
@ -325,18 +337,17 @@ def ficheEtud(etudid=None):
if not sco_permissions_check.can_suppress_annotation(a["id"]): if not sco_permissions_check.can_suppress_annotation(a["id"]):
a["dellink"] = "" a["dellink"] = ""
else: else:
a["dellink"] = ( a[
'<td class="annodel"><a href="doSuppressAnnotation?etudid=%s&annotation_id=%s">%s</a></td>' "dellink"
% ( ] = '<td class="annodel"><a href="doSuppressAnnotation?etudid=%s&annotation_id=%s">%s</a></td>' % (
etudid, etudid,
a["id"], a["id"],
scu.icontag( scu.icontag(
"delete_img", "delete_img",
border="0", border="0",
alt="suppress", alt="suppress",
title="Supprimer cette annotation", title="Supprimer cette annotation",
), ),
)
) )
author = sco_users.user_info(a["author"]) author = sco_users.user_info(a["author"])
alist.append( alist.append(
@ -473,7 +484,7 @@ def ficheEtud(etudid=None):
<div class="ficheEtud" id="ficheEtud"><table> <div class="ficheEtud" id="ficheEtud"><table>
<tr><td> <tr><td>
<h2>%(nomprenom)s (%(inscription)s)</h2> <h2>%(nomprenom)s (%(inscription)s)</h2>
%(etat_civil)s
<span>%(emaillink)s</span> <span>%(emaillink)s</span>
</td><td class="photocell"> </td><td class="photocell">
<a href="etud_photo_orig_page?etudid=%(etudid)s">%(etudfoto)s</a> <a href="etud_photo_orig_page?etudid=%(etudid)s">%(etudfoto)s</a>

View File

@ -111,9 +111,9 @@ get_base_preferences(formsemestre_id)
""" """
import flask import flask
from flask import flash, g, request, url_for
# from flask_login import current_user from flask import current_app, flash, g, request, url_for
from app.models import Departement from app.models import Departement
from app.scodoc import sco_cache from app.scodoc import sco_cache
@ -2234,7 +2234,6 @@ class SemPreferences:
raise ScoValueError( raise ScoValueError(
"sem_preferences.edit doit etre appele sur un semestre !" "sem_preferences.edit doit etre appele sur un semestre !"
) # a bug ! ) # a bug !
sem = sco_formsemestre.get_formsemestre(self.formsemestre_id)
H = [ H = [
html_sco_header.html_sem_header( html_sco_header.html_sem_header(
"Préférences du semestre", "Préférences du semestre",

View File

@ -84,15 +84,17 @@ class SemSet(dict):
self.semset_id = semset_id self.semset_id = semset_id
self["semset_id"] = semset_id self["semset_id"] = semset_id
self.sems = [] self.sems = []
self.formsemestre_ids = [] self.formsemestres = [] # modernisation en cours...
self.is_apc = False
self.formsemestre_ids = set()
cnx = ndb.GetDBConnexion() cnx = ndb.GetDBConnexion()
if semset_id: # read existing set if semset_id: # read existing set
L = semset_list(cnx, args={"semset_id": semset_id}) semsets = semset_list(cnx, args={"semset_id": semset_id})
if not L: if not semsets:
raise ScoValueError(f"Ensemble inexistant ! (semset {semset_id})") raise ScoValueError(f"Ensemble inexistant ! (semset {semset_id})")
self["title"] = L[0]["title"] self["title"] = semsets[0]["title"]
self["annee_scolaire"] = L[0]["annee_scolaire"] self["annee_scolaire"] = semsets[0]["annee_scolaire"]
self["sem_id"] = L[0]["sem_id"] self["sem_id"] = semsets[0]["sem_id"]
r = ndb.SimpleDictFetch( r = ndb.SimpleDictFetch(
"SELECT formsemestre_id FROM notes_semset_formsemestre WHERE semset_id = %(semset_id)s", "SELECT formsemestre_id FROM notes_semset_formsemestre WHERE semset_id = %(semset_id)s",
{"semset_id": semset_id}, {"semset_id": semset_id},
@ -123,8 +125,13 @@ class SemSet(dict):
def load_sems(self): def load_sems(self):
"""Load formsemestres""" """Load formsemestres"""
self.sems = [] self.sems = []
self.formsemestres = []
for formsemestre_id in self.formsemestre_ids: for formsemestre_id in self.formsemestre_ids:
self.sems.append(sco_formsemestre.get_formsemestre(formsemestre_id)) formsemestre: FormSemestre = FormSemestre.query.get(formsemestre_id)
self.formsemestres.append(formsemestre)
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
self.sems.append(sem)
self["is_apc"] = formsemestre.formation.is_apc()
if self.sems: if self.sems:
self["date_debut"] = min([sem["date_debut_iso"] for sem in self.sems]) self["date_debut"] = min([sem["date_debut_iso"] for sem in self.sems])
@ -137,8 +144,15 @@ class SemSet(dict):
self["semtitles"] = [sem["titre_num"] for sem in self.sems] self["semtitles"] = [sem["titre_num"] for sem in self.sems]
# Construction du ou des lien(s) vers le semestre # Construction du ou des lien(s) vers le semestre
pattern = '<a class="stdlink" href="formsemestre_status?formsemestre_id=%(formsemestre_id)s">%(titreannee)s</a>' self["semlinks"] = [
self["semlinks"] = [(pattern % sem) for sem in self.sems] f"""<a class="stdlink" href="{
url_for("notes.formsemestre_status", scodoc_dept=g.scodoc_dept,
formsemestre_id=formsemestre.id)
}">{formsemestre.titre_annee()}</a>
"""
for formsemestre in self.formsemestres
]
self["semtitles_str"] = "<br>".join(self["semlinks"]) self["semtitles_str"] = "<br>".join(self["semlinks"])
def fill_formsemestres(self): def fill_formsemestres(self):
@ -149,6 +163,8 @@ class SemSet(dict):
def add(self, formsemestre_id): def add(self, formsemestre_id):
"Ajoute ce semestre à l'ensemble" "Ajoute ce semestre à l'ensemble"
# check for valid formsemestre_id
formsemestre: FormSemestre = FormSemestre.query.get_or_404(formsemestre_id)
# check # check
if formsemestre_id in self.formsemestre_ids: if formsemestre_id in self.formsemestre_ids:
return # already there return # already there
@ -159,6 +175,17 @@ class SemSet(dict):
f"can't add {formsemestre_id} to set {self.semset_id}: incompatible sem_id" f"can't add {formsemestre_id} to set {self.semset_id}: incompatible sem_id"
) )
if self.formsemestre_ids and formsemestre.formation.is_apc() != self["is_apc"]:
raise ScoValueError(
"""On ne peut pas mélanger des semestres BUT/APC
avec des semestres ordinaires dans le même export.""",
dest_url=url_for(
"notes.apo_semset_maq_status",
scodoc_dept=g.scodoc_dept,
semset_id=self.semset_id,
),
)
ndb.SimpleQuery( ndb.SimpleQuery(
"""INSERT INTO notes_semset_formsemestre """INSERT INTO notes_semset_formsemestre
(formsemestre_id, semset_id) (formsemestre_id, semset_id)
@ -242,17 +269,28 @@ class SemSet(dict):
def load_etuds(self): def load_etuds(self):
self["etuds_without_nip"] = set() # etudids self["etuds_without_nip"] = set() # etudids
self["jury_ok"] = True self["jury_ok"] = True
self["jury_nb_missing"] = 0
is_apc = None
for sem in self.sems: for sem in self.sems:
formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"]) formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"])
nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre) nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
if is_apc is not None and is_apc != nt.is_apc:
raise ScoValueError(
"Incohérence: semestre APC (BUT) et ordinaires mélangés !"
)
else:
is_apc = nt.is_apc
sem["etuds"] = list(nt.identdict.values()) sem["etuds"] = list(nt.identdict.values())
sem["nips"] = {e["code_nip"] for e in sem["etuds"] if e["code_nip"]} sem["nips"] = {e["code_nip"] for e in sem["etuds"] if e["code_nip"]}
sem["etuds_without_nip"] = { sem["etuds_without_nip"] = {
e["etudid"] for e in sem["etuds"] if not e["code_nip"] e["etudid"] for e in sem["etuds"] if not e["code_nip"]
} }
self["etuds_without_nip"] |= sem["etuds_without_nip"] self["etuds_without_nip"] |= sem["etuds_without_nip"]
sem["jury_ok"] = nt.all_etuds_have_sem_decisions() sem["etudids_no_jury"] = nt.etudids_without_decisions()
sem["jury_ok"] = not sem["etudids_no_jury"]
self["jury_ok"] &= sem["jury_ok"] self["jury_ok"] &= sem["jury_ok"]
self["jury_nb_missing"] += len(sem["etudids_no_jury"])
self["is_apc"] = bool(is_apc)
def html_descr(self): def html_descr(self):
"""Short HTML description""" """Short HTML description"""
@ -272,36 +310,21 @@ class SemSet(dict):
) )
H.append("</p>") H.append("</p>")
H.append( if self["sem_id"] == 1:
f"""<p>Période: <select name="periode" onchange="set_periode(this);"> periode = "1re période (S1, S3)"
<option value="1" {"selected" if self["sem_id"] == 1 else ""}>1re période (S1, S3)</option> elif self["sem_id"] == 2:
<option value="2" {"selected" if self["sem_id"] == 2 else ""}>2de période (S2, S4)</option> periode = "2de période (S2, S4)"
<option value="0" {"selected" if self["sem_id"] == 0 else ""}>non semestrialisée (LP, ...)</option> else:
</select> periode = "non semestrialisée (LP, ...). Incompatible avec BUT."
</p>
<script>
function set_periode(elt) {{
fetch(
"{ url_for("apiweb.semset_set_periode", scodoc_dept=g.scodoc_dept,
semset_id=self.semset_id )
}",
{{
method: "POST",
headers: {{
'Content-Type': 'application/json'
}},
body: JSON.stringify( elt.value )
}},
).then(sco_message("période modifiée"));
}};
</script>
"""
)
H.append( H.append(
f"<p>Etapes: <tt>{sco_formsemestre.etapes_apo_str(self.list_etapes())}</tt></p>" f"""
<p>Période: <b>{periode}</b></p>
<p>Etapes: <tt>{sco_formsemestre.etapes_apo_str(self.list_etapes())}</tt></p>
<h4>Semestres de l'ensemble:</h4><ul class="semset_listsems">
"""
) )
H.append("""<h4>Semestres de l'ensemble:</h4><ul class="semset_listsems">""")
for sem in self.sems: for sem in self.sems:
H.append( H.append(
@ -364,8 +387,7 @@ class SemSet(dict):
""" """
if sco_portal_apogee.has_portal(): if sco_portal_apogee.has_portal():
return self.bilan.html_diagnostic() return self.bilan.html_diagnostic()
else: return ""
return ""
def get_semsets_list(): def get_semsets_list():
@ -423,13 +445,15 @@ def do_semset_add_sem(semset_id, formsemestre_id):
raise ScoValueError("empty semset_id") raise ScoValueError("empty semset_id")
if formsemestre_id == "": if formsemestre_id == "":
raise ScoValueError("pas de semestre choisi !") raise ScoValueError("pas de semestre choisi !")
s = SemSet(semset_id=semset_id) semset = SemSet(semset_id=semset_id)
# check for valid formsemestre_id semset.add(formsemestre_id)
_ = sco_formsemestre.get_formsemestre(formsemestre_id) # raise exc return flask.redirect(
url_for(
s.add(formsemestre_id) "notes.apo_semset_maq_status",
scodoc_dept=g.scodoc_dept,
return flask.redirect("apo_semset_maq_status?semset_id=%s" % semset_id) semset_id=semset_id,
)
)
def do_semset_remove_sem(semset_id, formsemestre_id): def do_semset_remove_sem(semset_id, formsemestre_id):
@ -535,7 +559,7 @@ def semset_page(format="html"):
<select name="sem_id"> <select name="sem_id">
<option value="1">1re période (S1, S3)</option> <option value="1">1re période (S1, S3)</option>
<option value="2">2de période (S2, S4)</option> <option value="2">2de période (S2, S4)</option>
<option value="0">non semestrialisée (LP, ...)</option> <option value="0">non semestrialisée (LP, ... mais pas pour le BUT !)</option>
</select> </select>
<input type="text" name="title" size="32"/> <input type="text" name="title" size="32"/>
<input type="submit" value="Créer"/> <input type="submit" value="Créer"/>

View File

@ -2,8 +2,8 @@
{% block styles %} {% block styles %}
{{super()}} {{super()}}
<link href="{{sco.scu.STATIC_DIR}}/css/refcomp_parcours_niveaux.css" rel="stylesheet" type="text/css" /> <link href="{{scu.STATIC_DIR}}/css/refcomp_parcours_niveaux.css" rel="stylesheet" type="text/css" />
<link href="{{sco.scu.STATIC_DIR}}/css/parcour_formation.css" rel="stylesheet" type="text/css" /> <link href="{{scu.STATIC_DIR}}/css/parcour_formation.css" rel="stylesheet" type="text/css" />
{% endblock %} {% endblock %}
{% macro menu_ue(niv, sem="pair", sem_idx=0) -%} {% macro menu_ue(niv, sem="pair", sem_idx=0) -%}
@ -37,7 +37,7 @@
{% if niv['ue_'+sem] %} {% if niv['ue_'+sem] %}
{{ niv['ue_'+sem].acronyme }} {{ niv['ue_'+sem].acronyme }}
{% else %} {% else %}
<span class="fontred">{{sco.scu.EMO_WARNING|safe}} non associé</span> <span class="fontred">{{scu.EMO_WARNING|safe}} non associé</span>
{% endif %} {% endif %}
{% endif %} {% endif %}
{% endif %} {% endif %}

View File

@ -14,23 +14,23 @@
{% if sco.sem.modalite %} en {{sco.sem.modalite}}{% endif %}</span> {% if sco.sem.modalite %} en {{sco.sem.modalite}}{% endif %}</span>
<span class="dates"> <span class="dates">
<a title="du {{sco.sem.date_debut.strftime('%d/%m/%Y')}} <a title="du {{sco.sem.date_debut.strftime('%d/%m/%Y')}}
au {{sco.sem.date_fin.strftime('%d/%m/%Y')}} ">{{sco.scu.MONTH_NAMES_ABBREV[ sco.sem.date_debut.month - 1]}} au {{sco.sem.date_fin.strftime('%d/%m/%Y')}} ">{{scu.MONTH_NAMES_ABBREV[ sco.sem.date_debut.month - 1]}}
{{sco.sem.date_debut.year}} - {{sco.scu.MONTH_NAMES_ABBREV[sco.sem.date_fin.month - 1]}} {{sco.sem.date_debut.year}} - {{scu.MONTH_NAMES_ABBREV[sco.sem.date_fin.month - 1]}}
{{sco.sem.date_fin.year}}</a></span> {{sco.sem.date_fin.year}}</a></span>
<span class="resp"><a <span class="resp"><a
title="{{sco.sem.responsables_str(abbrev_prenom=False)}}">{{sco.sem.responsables_str()}}</a></span> title="{{sco.sem.responsables_str(abbrev_prenom=False)}}">{{sco.sem.responsables_str()}}</a></span>
<span class="nbinscrits"><a class="discretelink" href="{{url_for('scolar.groups_view', scodoc_dept=g.scodoc_dept, <span class="nbinscrits"><a class="discretelink" href="{{url_for('scolar.groups_view', scodoc_dept=g.scodoc_dept,
formsemestre_id=sco.sem.id)}}">{{sco.sem.inscriptions|length}} inscrits</a></span><span class="lock">{% if formsemestre_id=sco.sem.id)}}">{{sco.sem.inscriptions|length}} inscrits</a></span><span class="lock">{% if
not sco.sem.etat %}<a href="{{url_for('notes.formsemestre_flip_lock', scodoc_dept=g.scodoc_dept, not sco.sem.etat %}<a href="{{url_for('notes.formsemestre_flip_lock', scodoc_dept=g.scodoc_dept,
formsemestre_id=sco.sem.id)}}">{{sco.scu.icontag("lock_img", border="0", title="Semestre formsemestre_id=sco.sem.id)}}">{{scu.icontag("lock_img", border="0", title="Semestre
verrouillé")|safe}}</a>{% endif %}</span><span class="eye"> verrouillé")|safe}}</a>{% endif %}</span><span class="eye">
{% if sco.prefs["bul_display_publication"] %} {% if sco.prefs["bul_display_publication"] %}
<a href="{{url_for('notes.formsemestre_change_publication_bul', scodoc_dept=g.scodoc_dept, <a href="{{url_for('notes.formsemestre_change_publication_bul', scodoc_dept=g.scodoc_dept,
formsemestre_id=sco.sem.id)}}"> formsemestre_id=sco.sem.id)}}">
{% if sco.sem.bul_hide_xml %} {% if sco.sem.bul_hide_xml %}
{{ sco.scu.icontag("hide_img", border="0", title="Bulletins NON publiés")|safe}} {{ scu.icontag("hide_img", border="0", title="Bulletins NON publiés")|safe}}
{% else %} {% else %}
{{ sco.scu.icontag("eye_img", border="0", title="Bulletins publiés")|safe }} {{ scu.icontag("eye_img", border="0", title="Bulletins publiés")|safe }}
{% endif %} {% endif %}
{% endif %} {% endif %}
</span> </span>

View File

@ -559,6 +559,7 @@ def etud_info(etudid=None, format="xml"):
"nom_usuel", "nom_usuel",
"prenom", "prenom",
"nomprenom", "nomprenom",
"prenom_etat_civil",
"email", "email",
"emailperso", "emailperso",
"domicile", "domicile",
@ -579,6 +580,9 @@ def etud_info(etudid=None, format="xml"):
): ):
d[a] = etud[a] # ne pas quoter car ElementTree.tostring quote déjà d[a] = etud[a] # ne pas quoter car ElementTree.tostring quote déjà
d["civilite"] = etud["civilite_str"] # exception: ne sort pas la civilite brute d["civilite"] = etud["civilite_str"] # exception: ne sort pas la civilite brute
d["civilite_etat_civil"] = etud[
"civilite_etat_civil_str"
] # exception: ne sort pas la civilite brute
d["sexe"] = d["civilite"] # backward compat pour anciens clients d["sexe"] = d["civilite"] # backward compat pour anciens clients
d["photo_url"] = sco_photos.etud_photo_url(etud) d["photo_url"] = sco_photos.etud_photo_url(etud)
@ -1444,6 +1448,25 @@ def _etudident_create_or_edit_form(edit):
"title": "Civilité", "title": "Civilité",
}, },
), ),
(
"prenom_etat_civil",
{
"size": 25,
"title": "Prénom (état-civil)",
"allow_null": True,
"explanation": "Si précisé, remplace le prénom d'usage dans les documents officiels",
},
),
(
"civilite_etat_civil",
{
"input_type": "menu",
"labels": ["Homme", "Femme", "Autre/neutre"],
"allowed_values": ["M", "F", "X"],
"title": "Civilité (état-civil)",
"explanation": "Si précisé: remplace la civilité d'usage dans les documents officiels",
},
),
( (
"date_naissance", "date_naissance",
{ {

View File

@ -12,7 +12,7 @@ from sqlalchemy.orm import sessionmaker # added by ev
# revision identifiers, used by Alembic. # revision identifiers, used by Alembic.
revision = "054dd6133b9c" revision = "054dd6133b9c"
down_revision = "6520faf67508" down_revision = "cf29790ca6f6"
branch_labels = None branch_labels = None
depends_on = None depends_on = None

View File

@ -0,0 +1,46 @@
"""ajout (prenom,civilite)_etat_civil
Revision ID: cf29790ca6f6
Revises: 6520faf67508
Create Date: 2023-02-25 10:55:42.831526
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = "cf29790ca6f6"
down_revision = "6520faf67508"
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
with op.batch_alter_table("identite", schema=None) as batch_op:
batch_op.add_column(
sa.Column(
"civilite_etat_civil",
sa.String(length=1),
server_default="X",
nullable=False,
)
)
batch_op.add_column(
sa.Column("prenom_etat_civil", sa.Text(), server_default="", nullable=False)
)
batch_op.create_check_constraint(
"identite_civ_etat_civ_check",
"civilite_etat_civil IN ('M', 'F', 'X')",
)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
with op.batch_alter_table("identite", schema=None) as batch_op:
batch_op.drop_column("prenom_etat_civil")
batch_op.drop_column("civilite_etat_civil")

View File

@ -1,7 +1,7 @@
# -*- mode: python -*- # -*- mode: python -*-
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
SCOVERSION = "9.4.71" SCOVERSION = "9.4.74"
SCONAME = "ScoDoc" SCONAME = "ScoDoc"

View File

@ -0,0 +1,93 @@
XX-APO_TITRES-XX
apoC_annee 2021/2022
apoC_cod_dip VBTRET
apoC_Cod_Exp 2
apoC_cod_vdi 17
apoC_Fichier_Exp C:\TEMP\VBTRET-V1RET-V1RETW2.TXT
apoC_lib_dip BUT R et T
apoC_Titre1 Export Apogée du 17/04/2023 à 13:23
apoC_Titre2
XX-APO_TYP_RES-XX
10 AB1 AB2 ABI ABJ ADM AJ AJRO C1 DEF DIF
18 AB1 AB2 ABI ABJ ADM ADMC ADMD AJ AJAC AJAR AJRO ATT B1 C1 COMP DEF DIF NAR
45 ABI ABJ ADAC ADM ADMC ADMD AIR AJ AJAR AJCP AJRO AJS ATT B1 B2 C1 COMP CRED DEF DES DETT DIF ENER ENRA EXC INFA INFO INST LC MACS N1 N2 NAR NON NSUI NVAL OUI SUIV SUPS TELE TOEF TOIE VAL VALC VALR
10 ABI ABJ ADMC COMP DEF DIS NVAL VAL VALC VALR
AB1 : Ajourné en B2 mais admis en B1 AB2 : ADMIS en B1 mais ajourné en B2 ABI : Absence ABJ : Absence justifiée ADM : Admis AJ : Ajourné AJRO : Ajourné - Réorientation Obligatoire C1 : Niveau C1 DEF : Défaillant DIF : Décision différée
AB1 : Ajourné en B2 mais admis en B1 AB2 : ADMIS en B1 mais ajourné en B2 ABI : Absence ABJ : Absence justifiée ADM : Admis ADMC : Admis avec compensation ADMD : Admis (passage avec dette) AJ : Ajourné AJAC : Ajourné mais accès autorisé à étape sup. AJAR : Ajourné et Admis A Redoubler AJRO : Ajourné - Réorientation Obligatoire ATT : En attente de décison B1 : Niveau B1 C1 : Niveau C1 COMP : Compensé DEF : Défaillant DIF : Décision différée NAR : Ajourné non admis à redoubler
ABI : Absence ABJ : Absence justifiée ADAC : Admis avant choix ADM : Admis ADMC : Admis avec compensation ADMD : Admis (passage avec dette) AIR : Ingénieur spécialité Informatique appr AJ : Ajourné AJAR : Ajourné et Admis A Redoubler AJCP : Ajourné mais autorisé à compenser AJRO : Ajourné - Réorientation Obligatoire AJS : Ajourné (note éliminatoire) ATT : En attente de décison B1 : Niveau B1 B2 : Niveau B2 C1 : Niveau C1 COMP : Compensé CRED : Eléments en crédits DEF : Défaillant DES : Désistement DETT : Eléments en dettes DIF : Décision différée ENER : Ingénieur spécialité Energétique ENRA : Ingénieur spécialité Energétique appr EXC : Exclu INFA : Ingénieur spécialité Informatique appr INFO : Ingénieur spécialié Informatique INST : Ingénieur spécialité Instrumentation LC : Liste complémentaire MACS : Ingénieur spécialité MACS N1 : Compétences CLES N2 : Niveau N2 NAR : Ajourné non admis à redoubler NON : Non NSUI : Non suivi(e) NVAL : Non Validé(e) OUI : Oui SUIV : Suivi(e) SUPS : Supérieur au seuil TELE : Ingénieur spéciailté Télécommunications TOEF : TOEFL TOIE : TOEIC VAL : Validé(e) VALC : Validé(e) par compensation VALR : Validé(e) Retrospectivement
ABI : Absence ABJ : Absence justifiée ADMC : Admis avec compensation COMP : Compensé DEF : Défaillant DIS : Dispense examen NVAL : Non Validé(e) VAL : Validé(e) VALC : Validé(e) par compensation VALR : Validé(e) Retrospectivement
XX-APO_COLONNES-XX
apoL_a01_code Type Objet Code Version Année Session Admission/Admissibilité Type Rés. Etudiant Numéro
apoL_a02_nom Nom
apoL_a03_prenom Prénom
apoL_a04_naissance Session Admissibilité Naissance
APO_COL_VAL_DEB
apoL_c0001 ELP V1RETU21 2021 0 1 N V1RETU21 - UE 2.1 Administrer réseau 0 1 Note
apoL_c0002 ELP V1RETU21 2021 0 1 B 0 1 Barème
apoL_c0003 ELP V1RETU21 2021 0 1 J 0 1 Pts Jury
apoL_c0004 ELP V1RETU21 2021 0 1 R 0 1 Résultat
apoL_c0005 ELP V1RETU22 2021 0 1 N V1RETU22 - UE 2.2 Connecter entrep. 0 1 Note
apoL_c0006 ELP V1RETU22 2021 0 1 B 0 1 Barème
apoL_c0007 ELP V1RETU22 2021 0 1 J 0 1 Pts Jury
apoL_c0008 ELP V1RETU22 2021 0 1 R 0 1 Résultat
apoL_c0009 ELP V1RETU23 2021 0 1 N V1RETU23 - UE 2.3 Créer des outils 0 1 Note
apoL_c0010 ELP V1RETU23 2021 0 1 B 0 1 Barème
apoL_c0011 ELP V1RETU23 2021 0 1 J 0 1 Pts Jury
apoL_c0012 ELP V1RETU23 2021 0 1 R 0 1 Résultat
apoL_c0013 ELP VRETR201 2021 0 1 N VRETR201 - Technologie internet 0 1 Note
apoL_c0014 ELP VRETR201 2021 0 1 B 0 1 Barème
apoL_c0015 ELP VRETR202 2021 0 1 N VRETR202 - Administration système 0 1 Note
apoL_c0016 ELP VRETR202 2021 0 1 B 0 1 Barème
apoL_c0017 ELP VRETR203 2021 0 1 N VRETR203 - Bases service réseaux 0 1 Note
apoL_c0018 ELP VRETR203 2021 0 1 B 0 1 Barème
apoL_c0019 ELP VRETR204 2021 0 1 N VRETR204 - Initiation téléphonie 0 1 Note
apoL_c0020 ELP VRETR204 2021 0 1 B 0 1 Barème
apoL_c0021 ELP VRETR205 2021 0 1 N VRETR205 - Signaux et systèmes 0 1 Note
apoL_c0022 ELP VRETR205 2021 0 1 B 0 1 Barème
apoL_c0023 ELP VRETR206 2021 0 1 N VRETR206 - Numérisation information 0 1 Note
apoL_c0024 ELP VRETR206 2021 0 1 B 0 1 Barème
apoL_c0025 ELP VRETR207 2021 0 1 N VRETR207 - Sources de données 0 1 Note
apoL_c0026 ELP VRETR207 2021 0 1 B 0 1 Barème
apoL_c0027 ELP VRETR208 2021 0 1 N VRETR208 - Analyse et traitement 0 1 Note
apoL_c0028 ELP VRETR208 2021 0 1 B 0 1 Barème
apoL_c0029 ELP VRETR209 2021 0 1 N VRETR209 - Initiation au dév. 0 1 Note
apoL_c0030 ELP VRETR209 2021 0 1 B 0 1 Barème
apoL_c0031 ELP VRETR210 2021 0 1 N VRETR210 - Anglais de communication 0 1 Note
apoL_c0032 ELP VRETR210 2021 0 1 B 0 1 Barème
apoL_c0033 ELP VRETR211 2021 0 1 N VRETR211 - Exp., culture, com. pro2 0 1 Note
apoL_c0034 ELP VRETR211 2021 0 1 B 0 1 Barème
apoL_c0035 ELP VRETR212 2021 0 1 N VRETR212 - PPP 0 1 Note
apoL_c0036 ELP VRETR212 2021 0 1 B 0 1 Barème
apoL_c0037 ELP VRETR213 2021 0 1 N VRETR213 - Maths des syst. num 0 1 Note
apoL_c0038 ELP VRETR213 2021 0 1 B 0 1 Barème
apoL_c0039 ELP VRETR214 2021 0 1 N VRETR214 - Analyse mathématique 0 1 Note
apoL_c0040 ELP VRETR214 2021 0 1 B 0 1 Barème
apoL_c0041 ELP VRETS21 2021 0 1 N VRETS21 - Construire un réseau 0 1 Note
apoL_c0042 ELP VRETS21 2021 0 1 B 0 1 Barème
apoL_c0043 ELP VRETS22 2021 0 1 N VRETS22 - Mesurer et car. un signal 0 1 Note
apoL_c0044 ELP VRETS22 2021 0 1 B 0 1 Barème
apoL_c0045 ELP VRETS23 2021 0 1 N VRETS23 - Mettre en place une solut 0 1 Note
apoL_c0046 ELP VRETS23 2021 0 1 B 0 1 Barème
apoL_c0047 ELP VRETS24 2021 0 1 N VRETS24 - Projet intégratif 0 1 Note
apoL_c0048 ELP VRETS24 2021 0 1 B 0 1 Barème
apoL_c0049 ELP VRETS25 2021 0 1 N VRETS25 - Portfolio 0 1 Note
apoL_c0050 ELP VRETS25 2021 0 1 B 0 1 Barème
apoL_c0051 ELP V1RETW2 2021 0 1 N V1RETW2 - Semestre 2 BUT RT 2 0 1 Note
apoL_c0052 ELP V1RETW2 2021 0 1 B 0 1 Barème
apoL_c0053 ELP V1RETW2 2021 0 1 J 0 1 Pts Jury
apoL_c0054 ELP V1RETW2 2021 0 1 R 0 1 Résultat
apoL_c0055 ELP V1RETO 2021 0 1 N V1RETO - Année BUT 1 RT 0 1 Note
apoL_c0056 ELP V1RETO 2021 0 1 B 0 1 Barème
apoL_c0057 VET V1RET 117 2021 0 1 N V1RET - BUT RT an1 0 1 Note
apoL_c0058 VET V1RET 117 2021 0 1 B 0 1 Barème
apoL_c0059 VET V1RET 117 2021 0 1 J 0 1 Pts Jury
apoL_c0060 VET V1RET 117 2021 0 1 R 0 1 Résultat
APO_COL_VAL_FIN
apoL_c0061 APO_COL_VAL_FIN
XX-APO_VALEURS-XX
apoL_a01_code apoL_a02_nom apoL_a03_prenom apoL_a04_naissance apoL_c0001 apoL_c0002 apoL_c0003 apoL_c0004 apoL_c0005 apoL_c0006 apoL_c0007 apoL_c0008 apoL_c0009 apoL_c0010 apoL_c0011 apoL_c0012 apoL_c0013 apoL_c0014 apoL_c0015 apoL_c0016 apoL_c0017 apoL_c0018 apoL_c0019 apoL_c0020 apoL_c0021 apoL_c0022 apoL_c0023 apoL_c0024 apoL_c0025 apoL_c0026 apoL_c0027 apoL_c0028 apoL_c0029 apoL_c0030 apoL_c0031 apoL_c0032 apoL_c0033 apoL_c0034 apoL_c0035 apoL_c0036 apoL_c0037 apoL_c0038 apoL_c0039 apoL_c0040 apoL_c0041 apoL_c0042 apoL_c0043 apoL_c0044 apoL_c0045 apoL_c0046 apoL_c0047 apoL_c0048 apoL_c0049 apoL_c0050 apoL_c0051 apoL_c0052 apoL_c0053 apoL_c0054 apoL_c0055 apoL_c0056 apoL_c0057 apoL_c0058 apoL_c0059 apoL_c0060
12345678 INCONNU ETUDIANT 10/01/2003 ADM
22345678 UN CONNU ETUDIANT 10/07/2003 AJ

View File

@ -0,0 +1,67 @@
##############################################################################
# ScoDoc
# Copyright (c) 1999 - 2023 Emmanuel Viennet. All rights reserved.
# See LICENSE
##############################################################################
""" Test lecture/érciture fichiers Apogée
"""
import pytest
from flask import g
import app
from app import db
from app.models import Formation, FormSemestreEtape
from app.scodoc import sco_apogee_csv, sco_apogee_reader
from config import TestConfig
from tests.conftest import RESOURCES_DIR
from tests.unit import yaml_setup
DEPT = TestConfig.DEPT_TEST
APO_CSV_FILE = RESOURCES_DIR + "/apogee/V1RET!117.txt"
def test_apogee_csv(test_client):
"""Lecture/écriture d'un fichier Apogée: vérifie que le fichier écrit est
strictement identique au fichier lu.
(le semestre n'ayant aucun résultat)
"""
app.set_sco_dept(DEPT)
# Met en place une formation et un semestre
formation = Formation(
dept_id=g.scodoc_dept_id,
acronyme="TESTAPO",
titre="Test Apo",
titre_officiel="Test Apof",
)
db.session.add(formation)
formsemestre = yaml_setup.create_formsemestre(
formation, [], 1, "S1_apo", "2021-09-01", "2022-01-15"
)
etape = FormSemestreEtape(etape_apo="V1RET!117")
formsemestre.etapes.append(etape)
db.session.add(formsemestre)
db.session.commit()
#
with open(APO_CSV_FILE, encoding=sco_apogee_reader.APO_INPUT_ENCODING) as f:
data = f.read()
assert "ETUDIANT" in data
#
apo_data = sco_apogee_csv.ApoData(data, periode=2)
apo_data.setup()
assert len(apo_data.apo_csv.csv_etuds) == 2
apo_etuds = apo_data.etud_by_nip.values()
for apo_etud in apo_etuds:
apo_etud.is_apc = apo_data.is_apc
apo_etud.lookup_scodoc(apo_data.etape_formsemestre_ids)
apo_etud.associate_sco(apo_data)
data_2 = (
apo_data.apo_csv.write(apo_etuds)
.decode(sco_apogee_reader.APO_INPUT_ENCODING)
.replace("\r", "")
)
# open("toto.txt", "w", encoding=sco_apogee_reader.APO_INPUT_ENCODING).write(data_2)
assert data == data_2

View File

@ -9,6 +9,8 @@ nom; text; identite; 0; nom de l'etudiant;
nom_usuel; text; identite; 1; nom usuel (si different); nom_usuel; text; identite; 1; nom usuel (si different);
prenom; text; identite; 0; prenom de l'etudiant prenom; text; identite; 0; prenom de l'etudiant
civilite; text; identite; 1; sexe ('M', 'F', 'X');sexe;genre civilite; text; identite; 1; sexe ('M', 'F', 'X');sexe;genre
prenom_etat_civil; text; identite; 1; prenom à l'état-civil (si différent);prenom_etat_civil
civilite_etat_civil; text; identite; 1; sexe ('M', 'F', 'X') à l'état civil;civilite_etat_civil
date_naissance;text;identite; 1; date de naissance (jj/mm/aaaa) date_naissance;text;identite; 1; date de naissance (jj/mm/aaaa)
lieu_naissance;text;identite; 1; lieu de naissance lieu_naissance;text;identite; 1; lieu de naissance
nationalite; text; identite; 1; nationalite nationalite; text; identite; 1; nationalite