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

app/api/formations.py

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

app/api/semset.py

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

app/but/bulletin_but.py

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

app/comp/res_compat.py

@@ -19,6 +19,7 @@ from app.models import Identite, FormSemestre, ModuleImpl, ScolarAutorisationIns
 from app.scodoc.codes_cursus import UE_SPORT, DEF
 from app.scodoc import sco_utils as scu
 
+
 # Pour raccorder le code des anciens codes qui attendent une NoteTable
 class NotesTableCompat(ResultatsSemestre):
     """Implementation partielle de NotesTable
@@ -266,16 +267,21 @@ class NotesTableCompat(ResultatsSemestre):
                 ue_status_list.append(ue_status)
         return self.parcours.check_barre_ues(ue_status_list)
 
-    def all_etuds_have_sem_decisions(self):
-        """True si tous les étudiants du semestre ont une décision de jury.
-        Ne regarde pas les décisions d'UE.
+    def etudids_without_decisions(self) -> list[int]:
+        """Liste des id d'étudiants du semestre non démissionnaires
+        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:
-            if ins.etat != scu.INSCRIT:
-                continue  # skip démissionnaires
-            if self.get_etud_decision_sem(ins.etudid) is None:
-                return False
-        return True
+        check_func = (
+            self.etud_has_decision if self.is_apc else self.get_etud_decision_sem
+        )
+        etudids = [
+            ins.etudid
+            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):
         """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:
         """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 }
-        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:
             return {

app/models/etudiants.py

@@ -30,6 +30,7 @@ class Identite(db.Model):
         db.UniqueConstraint("dept_id", "code_nip"),
         db.UniqueConstraint("dept_id", "code_ine"),
         db.CheckConstraint("civilite IN ('M', 'F', 'X')"),
+        db.CheckConstraint("civilite_etat_civil IN ('M', 'F', 'X')"),
     )
 
     id = db.Column(db.Integer, primary_key=True)
@@ -41,6 +42,12 @@ class Identite(db.Model):
     nom_usuel = db.Column(db.Text())
     "optionnel (si present, affiché à la place du nom)"
     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)
     lieu_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]
 
+    @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:
         "'M. DUPONTÉ', ou si no_accents, 'M. DUPONTE'"
         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]))
         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
     def nom_short(self):
         "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,
             "prenom": self.prenom,
             "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:
@@ -238,6 +262,8 @@ class Identite(db.Model):
             "dept_naissance": self.dept_naissance or "",
             "nationalite": self.nationalite 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():
             # 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
         """
         if with_paragraph:
-            return f"""{self.nomprenom}{line_sep}n°{self.code_nip or ""}{line_sep}né{self.e} le {
+            return f"""{self.etat_civil}{line_sep}n°{self.code_nip or ""}{line_sep}né{self.e} le {
                 self.date_naissance.strftime("%d/%m/%Y") if self.date_naissance else ""}{
                 line_sep}à {self.lieu_naissance or ""}"""
-        return self.nomprenom
+        return self.etat_civil
 
     def photo_html(self, title=None, size="small") -> str:
         """HTML img tag for the photo, either in small size (h90)

app/models/formsemestre.py

@@ -198,11 +198,14 @@ class FormSemestre(db.Model):
             d["date_fin"] = d["date_fin_iso"] = ""
         d["responsables"] = [u.id for u in self.responsables]
         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["departement"] = self.departement.to_dict()
             d["formation"] = self.formation.to_dict()
             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
 
     def to_dict_api(self):
@@ -923,7 +926,7 @@ class FormSemestreEtape(db.Model):
     def __repr__(self):
         return f"<Etape {self.id} apo={self.etape_apo!r}>"
 
-    def as_apovdi(self):
+    def as_apovdi(self) -> ApoEtapeVDI:
         return ApoEtapeVDI(self.etape_apo)
 
 

app/models/ues.py

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

app/scodoc/sco_apogee_compare.py

@@ -46,13 +46,14 @@ Pour chaque étudiant commun:
 from flask import g, url_for
 
 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.sco_exceptions import ScoValueError
 from app.scodoc import html_sco_header
 from app.scodoc import sco_preferences
 
-_help_txt = """
+_HELP_TXT = """
 <div class="help">
 <p>Outil de comparaison de fichiers (maquettes CSV) Apogée.
 </p>
@@ -69,7 +70,7 @@ def apo_compare_csv_form():
         """<h2>Comparaison de fichiers Apogée</h2>
         <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">
         Fichier Apogée A: 
@@ -109,14 +110,14 @@ def apo_compare_csv(file_a, file_b, autodetect=True):
             raise ScoValueError(
                 f"""
             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,
             ) from exc
     H = [
         html_sco_header.sco_header(page_title="Comparaison de fichiers Apogée"),
         "<h2>Comparaison de fichiers Apogée</h2>",
-        _help_txt,
+        _HELP_TXT,
         '<div class="apo_compare_csv">',
         _apo_compare_csv(apo_data_a, apo_data_b),
         "</div>",
@@ -130,17 +131,17 @@ def _load_apo_data(csvfile, autodetect=True):
     "Read data from request variable and build ApoData"
     data_b = csvfile.read()
     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:
             log(f"apo_compare_csv: {message}")
         if not data_b:
             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)
     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
     representing Apogee CSV maquettes.
     """
@@ -148,74 +149,75 @@ def _apo_compare_csv(A, B):
     # 1-- Check etape and codes
     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(A.orig_filename)
+    L.append(apo_a.orig_filename)
     L.append("</span></div>")
     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('<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(
-            '<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:
-        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><span class="key">VDI Apogée:</span>')
-    if A.vdi_apogee != B.vdi_apogee:
-        L.append('<span class="val_dif">%s != %s</span>' % (A.vdi_apogee, B.vdi_apogee))
+    if apo_a.vdi_apogee != apo_b.vdi_apogee:
+        L.append(
+            f"""<span class="val_dif">{apo_a.vdi_apogee} != {apo_b.vdi_apogee}</span>"""
+        )
     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><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(
-            '<span class="val_dif">%s != %s</span>'
-            % (A.cod_dip_apogee, B.cod_dip_apogee)
+            f"""<span class="val_dif">{apo_a.cod_dip_apogee} != {apo_b.cod_dip_apogee}</span>"""
         )
     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><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(
             '<span class="val_dif">%s != %s</span>'
-            % (A.annee_scolaire, B.annee_scolaire)
+            % (apo_a.annee_scolaire, apo_b.annee_scolaire)
         )
     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>")
 
     # Colonnes:
-    A_elts = set(A.apo_elts.keys())
-    B_elts = set(B.apo_elts.keys())
+    a_elts = set(apo_a.apo_csv.apo_elts.keys())
+    b_elts = set(apo_b.apo_csv.apo_elts.keys())
     L.append('<div><span class="key">Éléments Apogée :</span>')
-    if A_elts == B_elts:
-        L.append('<span class="val_ok">%d</span>' % len(A_elts))
+    if a_elts == b_elts:
+        L.append(f"""<span class="val_ok">{len(a_elts)}</span>""")
     else:
-        elts_communs = 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_communs = 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)
         L.append(
             '<span class="val_dif">différents (%d en commun, %d seulement dans A, %d seulement dans B)</span>'
             % (
                 len(elts_communs),
-                len(elts_only_A),
-                len(elts_only_B),
+                len(elts_only_a),
+                len(elts_only_b),
             )
         )
-        if elts_only_A:
+        if elts_only_a:
             L.append(
                 '<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(
                 '<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>")  # /section
@@ -223,22 +225,21 @@ def _apo_compare_csv(A, B):
     # 2--
     L.append('<div class="section"><div class="tit">Étudiants</div>')
 
-    A_nips = set(A.etud_by_nip)
-    B_nips = set(B.etud_by_nip)
-    nb_etuds_communs = len(A_nips.intersection(B_nips))
-    nb_etuds_dif = len(A_nips.union(B_nips) - A_nips.intersection(B_nips))
+    a_nips = set(apo_a.etud_by_nip)
+    b_nips = set(apo_b.etud_by_nip)
+    nb_etuds_communs = len(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>""")
-    if A_nips == B_nips:
+    if a_nips == b_nips:
         L.append(
-            """<span class="s_ok">
-        %d étudiants (tous présents dans chaque fichier)</span>
+            f"""<span class="s_ok">
+        {len(a_nips)} étudiants (tous présents dans chaque fichier)</span>
         """
-            % len(A_nips)
         )
     else:
         L.append(
-            '<span class="val_dif">différents (%d en commun, %d différents)</span>'
-            % (nb_etuds_communs, nb_etuds_dif)
+            f"""<span class="val_dif">différents ({nb_etuds_communs} en commun, {
+                    nb_etuds_dif} différents)</span>"""
         )
     L.append("</div>")
     L.append("</div>")  # /section
@@ -247,19 +248,22 @@ def _apo_compare_csv(A, B):
     if nb_etuds_communs > 0:
         L.append(
             """<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>
         """
         )
-        T = apo_table_compare_etud_results(A, B)
+        T = apo_table_compare_etud_results(apo_a, apo_b)
         if T.get_nb_rows() > 0:
             L.append(T.html())
         else:
             L.append(
-                """<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>
+                f"""<p class="p_ok">aucune différence de résultats 
+            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
 
@@ -290,19 +294,17 @@ def apo_table_compare_etud_results(A, B):
 
 def _build_etud_res(e, apo_data):
     r = {}
-    for elt_code in apo_data.apo_elts:
-        elt = apo_data.apo_elts[elt_code]
+    for elt_code in apo_data.apo_csv.apo_elts:
+        elt = apo_data.apo_csv.apo_elts[elt_code]
         try:
             # les colonnes de cet élément
-            col_ids_type = [
-                (ec["apoL_a01_code"], ec["Type R\xc3\xa9s."]) for ec in elt.cols
-            ]
+            col_ids_type = [(ec["apoL_a01_code"], ec["Type Rés."]) for ec in elt.cols]
         except KeyError as exc:
             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
         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]
     return r
 

app/scodoc/sco_apogee_reader.py

@@ -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

app/scodoc/sco_bulletins_generator.py

@@ -167,8 +167,9 @@ class BulletinGenerator:
 
         formsemestre_id = self.bul_dict["formsemestre_id"]
         nomprenom = self.bul_dict["etud"]["nomprenom"]
+        etat_civil = self.bul_dict["etud"]["etat_civil"]
         marque_debut_bulletin = sco_pdf.DebutBulletin(
-            nomprenom,
+            self.bul_dict["etat_civil"],
             filigranne=self.bul_dict["filigranne"],
             footer_content=f"""ScoDoc - Bulletin de {nomprenom} - {time.strftime("%d/%m/%Y %H:%M")}""",
         )
@@ -211,7 +212,7 @@ class BulletinGenerator:
                     document,
                     author="%s %s (E. Viennet) [%s]"
                     % (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",
                     margins=self.margins,
                     server_name=self.server_name,

app/scodoc/sco_etape_apogee.py

@@ -76,7 +76,7 @@ import re
 
 import app.scodoc.sco_utils as scu
 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
 
 
@@ -108,7 +108,7 @@ def apo_csv_store(csv_data: str, annee_scolaire, sem_id):
     # sanity check
     filesize = len(csv_data)
     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:
         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):
         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)
-    description = "%s;%s;%s" % (str(apo_data.etape), annee_scolaire, sem_id)
+    oid = f"{annee_scolaire}-{sem_id}"
+    description = f"""{str(apo_data.etape)};{annee_scolaire};{sem_id}"""
     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)
 
     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")
     # ce fichier a été archivé donc généré par ScoDoc
     # 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)
 
 
 # ------------------------------------------------------------------------

app/scodoc/sco_etape_apogee_view.py

@@ -32,13 +32,13 @@ import io
 from zipfile import ZipFile
 
 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
 from app import log
 from app.models import Formation
 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_formsemestre
 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_etud
 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
 
 
@@ -240,7 +240,11 @@ def apo_semset_maq_status(
     if semset["jury_ok"]:
         H.append("""<li>Décisions de jury saisies</li>""")
     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:
         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:
         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="hidden" name="semset_id" value="%s"/>
+        <input type="hidden" name="semset_id" value="{semset_id}"/>
         """
-            % (semset_id,)
         )
         H.append('<div id="param_export_res">')
 
@@ -372,7 +375,7 @@ def apo_semset_maq_status(
     H.append("</div>")
     # Aide:
     H.append(
-        """
+        f"""
     <p><a class="stdlink" href="semset_page">Retour aux ensembles de semestres</a></p>
     
     <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.
     </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>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">
  XX-APO_TITRES-XX
  apoC_annee	2007/2008
@@ -427,7 +432,6 @@ def apo_semset_maq_status(
     </p>
     </div>
     """
-        % (APO_INPUT_ENCODING,)
     )
     H.append(html_sco_header.sco_footer())
     return "\n".join(H)
@@ -446,21 +450,25 @@ def table_apo_csv_list(semset):
         # Ajoute qq infos pour affichage:
         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"])
-        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["date_str"] = t["date"].strftime("%d/%m/%Y à %H:%M")
-        view_link = "view_apo_csv?etape_apo=%s&semset_id=%s" % (
-            t["etape_apo"],
-            semset["semset_id"],
+        view_link = url_for(
+            "notes.view_apo_csv",
+            scodoc_dept=g.scodoc_dept,
+            etape_apo=t["etape_apo"],
+            semset_id=semset["semset_id"],
         )
         t["_filename_target"] = view_link
         t["_etape_apo_target"] = view_link
         t["suppress"] = scu.icontag(
             "delete_small_img", border="0", alt="supprimer", title="Supprimer"
         )
-        t["_suppress_target"] = "view_apo_csv_delete?etape_apo=%s&semset_id=%s" % (
-            t["etape_apo"],
-            semset["semset_id"],
+        t["_suppress_target"] = url_for(
+            "notes.view_apo_csv_delete",
+            scodoc_dept=g.scodoc_dept,
+            etape_apo=t["etape_apo"],
+            semset_id=semset["semset_id"],
         )
 
     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():
         etud_sco = sco_etud.get_etud_info(code_nip=etud["nip"], filled=True)
         if etud_sco:
-            e = etud_sco[0]
             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(
-                        s=sem, e=e
-                    )
-                    for sem in e["sems"]
+                    f"""<a href="{
+                        url_for('notes.formsemestre_bulletinetud',
+                        scodoc_dept=g.scodoc_dept,
+                        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"])
         e["_nom_target"] = tgt
         e["_prenom_target"] = tgt
-        e["_nom_td_attrs"] = 'id="%s" class="etudinfo"' % (e["etudid"],)
-        e["_prenom_td_attrs"] = 'id="pre-%s" class="etudinfo"' % (e["etudid"],)
+        e["_nom_td_attrs"] = f"""id="{e['etudid']}" class="etudinfo" """
+        e["_prenom_td_attrs"] = f"""id="pre-{e['etudid']}" class="etudinfo" """
 
     return _view_etuds_page(
         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:
-    if etuds:
+    if etuds:  # XXX TODO modifier pour utiliser clé de tri
         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(
         titles={
             "nip": "Code NIP",
@@ -579,14 +584,23 @@ def _view_etuds_page(semset_id, title="", etuds=[], keys=(), format="html"):
     if format != "html":
         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(
-        """<p><a href="apo_semset_maq_status?semset_id=%s">Retour à la page d'export Apogée</a>"""
-        % semset_id
-    )
+        {tab.html()}
 
-    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):
@@ -603,7 +617,7 @@ def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=
             if autodetect:
                 # 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:
                     log(f"view_apo_csv_store: {message}")
             else:
@@ -623,7 +637,7 @@ def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=
                 f"""
                     Erreur: l'encodage du fichier est mal détecté.
                     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,
             ) from exc
@@ -631,7 +645,7 @@ def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=
             raise ScoValueError(
                 f"""
                     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,
             ) from exc
@@ -640,21 +654,21 @@ def view_apo_csv_store(semset_id="", csvfile=None, data: bytes = "", autodetect=
     apo_data = sco_apogee_csv.ApoData(
         data_str, periode=semset["sem_id"]
     )  # parse le fichier -> exceptions
-    if apo_data.etape not in semset["etapes"]:
-        raise ScoValueError(
-            "Le code étape de ce fichier ne correspond pas à ceux de cet ensemble"
-        )
-
-    sco_etape_apogee.apo_csv_store(data_str, semset["annee_scolaire"], semset["sem_id"])
-
-    return flask.redirect(
-        url_for(
+    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"]:
+        raise ScoValueError(
+            "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"])
+
+    return flask.redirect(dest_url)
+
 
 def view_apo_csv_download_and_store(etape_apo="", semset_id=""):
     """Download maquette and store it"""
@@ -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}"
     if not dialog_confirmed:
         return scu.confirm_dialog(
-            """<h2>Confirmer la suppression du fichier étape <tt>%s</tt>?</h2>
-               <p>La suppression sera définitive.</p>"""
-            % (etape_apo,),
+            f"""<h2>Confirmer la suppression du fichier étape <tt>{etape_apo}</tt>?</h2>
+               <p>La suppression sera définitive.</p>""",
             dest_url="",
             cancel_url=dest_url,
             parameters={"semset_id": semset_id, "etape_apo": etape_apo},
@@ -727,24 +740,24 @@ def view_apo_csv(etape_apo="", semset_id="", format="html"):
 
     H = [
         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,
             javascripts=["js/etud_info.js"],
         ),
-        """<h2>Etudiants dans la maquette Apogée %s</h2>""" % etape_apo,
-        """<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>"""
-        % semset,
-    ]
-    # Infos générales
-    H.append(
-        """
+        f"""<h2>Étudiants dans la maquette Apogée {etape_apo}</h2>
+        <p>Pour l'ensemble <a class="stdlink" href="{
+        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>{0.etape_apogee} VDI {0.vdi_apogee} (année {0.annee_scolaire})</span></div>
+            <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>
-    """.format(
-            apo_data
-        )
-    )
+        </div>
+        """,
+    ]
 
     # Liste des étudiants (sans les résultats pour le moment): TODO
     etuds = apo_data.etuds
@@ -789,12 +802,21 @@ def view_apo_csv(etape_apo="", semset_id="", format="html"):
         return tab.make_page(format=format)
 
     H += [
-        tab.html(),
-        """<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>"""
-        % (etape_apo, semset_id),
-        """<div><a class="stdlink" href="apo_semset_maq_status?semset_id=%s">Retour</a>    
-        </div>"""
-        % semset_id,
+        f"""
+        {tab.html()}
+        <p><a class="stdlink" href="{
+            url_for("notes.view_apo_csv",
+                scodoc_dept=g.scodoc_dept,
+                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(),
     ]
 
@@ -809,7 +831,7 @@ def apo_csv_export_results(
     block_export_res_ues=False,
     block_export_res_modules=False,
     block_export_res_sdj=False,
-):
+) -> Response:
     """Remplit les fichiers CSV archivés
     et donne un ZIP avec tous les résultats.
     """
@@ -833,8 +855,7 @@ def apo_csv_export_results(
     periode = semset["sem_id"]
 
     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(
             annee_scolaire, periode, etapes=semset.list_etapes()
         )
@@ -852,12 +873,10 @@ def apo_csv_export_results(
                 dest_zip=dest_zip,
             )
 
-    dest_zip.close()
     data.seek(0)
     basename = (
         sco_preferences.get_preference("DeptName")
-        + str(annee_scolaire)
-        + "-%s-" % periode
+        + f"{annee_scolaire}-{periode}-"
         + "-".join(etapes_apo)
     )
     basename = scu.unescape_html(basename)

app/scodoc/sco_etape_bilan.py

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

app/scodoc/sco_etud.py

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

app/scodoc/sco_exceptions.py

@@ -29,6 +29,7 @@
 """
 from flask_login import current_user
 
+
 # --- Exceptions
 class ScoException(Exception):
     "super classe de toutes les exceptions ScoDoc."
@@ -44,6 +45,7 @@ class ScoInvalidCSRF(ScoException):
 
 class ScoValueError(ScoException):
     "Exception avec page d'erreur utilisateur, et qui stoque dest_url"
+
     # mal nommée: super classe de toutes les exceptions avec page
     # d'erreur gentille.
     def __init__(self, msg, dest_url=None):
@@ -75,7 +77,11 @@ class InvalidEtudId(NoteProcessError):
 
 
 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):

app/scodoc/sco_formations.py

@@ -127,7 +127,7 @@ def formation_export_dict(
                 ue_dict["apc_niveau_libelle"] = ue.niveau_competence.libelle
                 ue_dict["apc_niveau_annee"] = ue.niveau_competence.annee
                 ue_dict["apc_niveau_ordre"] = ue.niveau_competence.ordre
-            # Et le parcour:
+            # Et les parcours:
             if ue.parcours:
                 ue_dict["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(
     referentiel_competence_id: int, ue_dict: dict
 ) -> int:
-    """Recherche dans le ref. de comp. un niveau pour cette UE
-    utilise comme clé (libelle, annee, ordre)
+    """Recherche dans le ref. de comp. un niveau pour cette UE.
+    Utilise (libelle, annee, ordre) comme clé.
     """
     libelle = ue_dict.get("apc_niveau_libelle")
     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
             if xml_ue_id:
                 ues_old2new[xml_ue_id] = ue_id
+            # parcours BUT
+            # TODO XXX
             # élément optionnel présent dans les exports BUT:
             ue_reference = ue_info[1].get("reference")
             if ue_reference:

app/scodoc/sco_import_etuds.py

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

app/scodoc/sco_page_etud.py

@@ -176,6 +176,18 @@ def ficheEtud(etudid=None):
     sco_etud.fill_etuds_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["authuser"] = authuser
     info["info_naissance"] = info["date_naissance"]
@@ -325,9 +337,9 @@ def ficheEtud(etudid=None):
         if not sco_permissions_check.can_suppress_annotation(a["id"]):
             a["dellink"] = ""
         else:
-            a["dellink"] = (
-                '<td class="annodel"><a href="doSuppressAnnotation?etudid=%s&annotation_id=%s">%s</a></td>'
-                % (
+            a[
+                "dellink"
+            ] = '<td class="annodel"><a href="doSuppressAnnotation?etudid=%s&annotation_id=%s">%s</a></td>' % (
                 etudid,
                 a["id"],
                 scu.icontag(
@@ -337,7 +349,6 @@ def ficheEtud(etudid=None):
                     title="Supprimer cette annotation",
                 ),
             )
-            )
         author = sco_users.user_info(a["author"])
         alist.append(
             f"""<tr><td><span class="annodate">Le {a['date']} par {author['prenomnom']} : 
@@ -473,7 +484,7 @@ def ficheEtud(etudid=None):
 <div class="ficheEtud" id="ficheEtud"><table>
 <tr><td>
 <h2>%(nomprenom)s (%(inscription)s)</h2>
-
+%(etat_civil)s
 <span>%(emaillink)s</span> 
 </td><td class="photocell">
 <a href="etud_photo_orig_page?etudid=%(etudid)s">%(etudfoto)s</a>

app/scodoc/sco_preferences.py

@@ -111,9 +111,9 @@ get_base_preferences(formsemestre_id)
 
 """
 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.scodoc import sco_cache
@@ -2234,7 +2234,6 @@ class SemPreferences:
             raise ScoValueError(
                 "sem_preferences.edit doit etre appele sur un semestre !"
             )  # a bug !
-        sem = sco_formsemestre.get_formsemestre(self.formsemestre_id)
         H = [
             html_sco_header.html_sem_header(
                 "Préférences du semestre",

app/scodoc/sco_semset.py

@@ -84,15 +84,17 @@ class SemSet(dict):
         self.semset_id = semset_id
         self["semset_id"] = semset_id
         self.sems = []
-        self.formsemestre_ids = []
+        self.formsemestres = []  # modernisation en cours...
+        self.is_apc = False
+        self.formsemestre_ids = set()
         cnx = ndb.GetDBConnexion()
         if semset_id:  # read existing set
-            L = semset_list(cnx, args={"semset_id": semset_id})
-            if not L:
+            semsets = semset_list(cnx, args={"semset_id": semset_id})
+            if not semsets:
                 raise ScoValueError(f"Ensemble inexistant ! (semset {semset_id})")
-            self["title"] = L[0]["title"]
-            self["annee_scolaire"] = L[0]["annee_scolaire"]
-            self["sem_id"] = L[0]["sem_id"]
+            self["title"] = semsets[0]["title"]
+            self["annee_scolaire"] = semsets[0]["annee_scolaire"]
+            self["sem_id"] = semsets[0]["sem_id"]
             r = ndb.SimpleDictFetch(
                 "SELECT formsemestre_id FROM notes_semset_formsemestre WHERE semset_id = %(semset_id)s",
                 {"semset_id": semset_id},
@@ -123,8 +125,13 @@ class SemSet(dict):
     def load_sems(self):
         """Load formsemestres"""
         self.sems = []
+        self.formsemestres = []
         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:
             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]
 
         # 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"] = [(pattern % sem) for sem in self.sems]
+        self["semlinks"] = [
+            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"])
 
     def fill_formsemestres(self):
@@ -149,6 +163,8 @@ class SemSet(dict):
 
     def add(self, formsemestre_id):
         "Ajoute ce semestre à l'ensemble"
+        # check for valid formsemestre_id
+        formsemestre: FormSemestre = FormSemestre.query.get_or_404(formsemestre_id)
         # check
         if formsemestre_id in self.formsemestre_ids:
             return  # already there
@@ -159,6 +175,17 @@ class SemSet(dict):
                 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(
             """INSERT INTO notes_semset_formsemestre
             (formsemestre_id, semset_id)
@@ -242,17 +269,28 @@ class SemSet(dict):
     def load_etuds(self):
         self["etuds_without_nip"] = set()  # etudids
         self["jury_ok"] = True
+        self["jury_nb_missing"] = 0
+        is_apc = None
         for sem in self.sems:
             formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"])
             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["nips"] = {e["code_nip"] for e in sem["etuds"] if e["code_nip"]}
             sem["etuds_without_nip"] = {
                 e["etudid"] for e in sem["etuds"] if not e["code_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_nb_missing"] += len(sem["etudids_no_jury"])
+        self["is_apc"] = bool(is_apc)
 
     def html_descr(self):
         """Short HTML description"""
@@ -272,36 +310,21 @@ class SemSet(dict):
                 )
             H.append("</p>")
 
-        H.append(
-            f"""<p>Période: <select name="periode" onchange="set_periode(this);">
-        <option value="1" {"selected" if self["sem_id"] == 1 else ""}>1re période (S1, S3)</option>
-        <option value="2" {"selected" if self["sem_id"] == 2 else ""}>2de période (S2, S4)</option>
-        <option value="0" {"selected" if self["sem_id"] == 0 else ""}>non semestrialisée (LP, ...)</option>
-        </select>
-        </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>
-        """
-        )
+        if self["sem_id"] == 1:
+            periode = "1re période (S1, S3)"
+        elif self["sem_id"] == 2:
+            periode = "2de période (S2, S4)"
+        else:
+            periode = "non semestrialisée (LP, ...). Incompatible avec BUT."
 
         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:
             H.append(
@@ -364,7 +387,6 @@ class SemSet(dict):
         """
         if sco_portal_apogee.has_portal():
             return self.bilan.html_diagnostic()
-        else:
         return ""
 
 
@@ -423,13 +445,15 @@ def do_semset_add_sem(semset_id, formsemestre_id):
         raise ScoValueError("empty semset_id")
     if formsemestre_id == "":
         raise ScoValueError("pas de semestre choisi !")
-    s = SemSet(semset_id=semset_id)
-    # check for valid formsemestre_id
-    _ = sco_formsemestre.get_formsemestre(formsemestre_id)  # raise exc
-
-    s.add(formsemestre_id)
-
-    return flask.redirect("apo_semset_maq_status?semset_id=%s" % semset_id)
+    semset = SemSet(semset_id=semset_id)
+    semset.add(formsemestre_id)
+    return flask.redirect(
+        url_for(
+            "notes.apo_semset_maq_status",
+            scodoc_dept=g.scodoc_dept,
+            semset_id=semset_id,
+        )
+    )
 
 
 def do_semset_remove_sem(semset_id, formsemestre_id):
@@ -535,7 +559,7 @@ def semset_page(format="html"):
     <select name="sem_id">
     <option value="1">1re période (S1, S3)</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>
     <input type="text" name="title" size="32"/>
     <input type="submit" value="Créer"/>

app/templates/but/parcour_formation.j2

@@ -2,8 +2,8 @@
 
 {% block styles %}
     {{super()}}
-    <link href="{{sco.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/refcomp_parcours_niveaux.css" rel="stylesheet" type="text/css" />
+    <link href="{{scu.STATIC_DIR}}/css/parcour_formation.css" rel="stylesheet" type="text/css" />
 {% endblock %}
 
 {% macro menu_ue(niv, sem="pair", sem_idx=0) -%}
@@ -37,7 +37,7 @@
         {% if niv['ue_'+sem] %}
             {{ niv['ue_'+sem].acronyme }}
         {% 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 %}

app/templates/formsemestre_header.j2

@@ -14,23 +14,23 @@
             {% if sco.sem.modalite %} en {{sco.sem.modalite}}{% endif %}</span>
         <span class="dates">
             <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]}}
-                {{sco.sem.date_debut.year}} - {{sco.scu.MONTH_NAMES_ABBREV[sco.sem.date_fin.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}} - {{scu.MONTH_NAMES_ABBREV[sco.sem.date_fin.month - 1]}}
                 {{sco.sem.date_fin.year}}</a></span>
         <span class="resp"><a
                 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,
         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,
-                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">
             {% if sco.prefs["bul_display_publication"] %}
             <a href="{{url_for('notes.formsemestre_change_publication_bul', scodoc_dept=g.scodoc_dept,
                 formsemestre_id=sco.sem.id)}}">
                 {% 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 %}
-                {{ 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 %}
         </span>

app/views/scolar.py

@@ -559,6 +559,7 @@ def etud_info(etudid=None, format="xml"):
         "nom_usuel",
         "prenom",
         "nomprenom",
+        "prenom_etat_civil",
         "email",
         "emailperso",
         "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["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["photo_url"] = sco_photos.etud_photo_url(etud)
 
@@ -1444,6 +1448,25 @@ def _etudident_create_or_edit_form(edit):
                 "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",
             {

migrations/versions/054dd6133b9c_association_ues_parcours.py

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

migrations/versions/cf29790ca6f6_ajout_prenom_civilite__etat_civil.py

@@ -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")

sco_version.py

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

tests/ressources/apogee/V1RET!117.txt

@@ -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

tests/unit/test_apogee_csv.py

@@ -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

tools/format_import_etudiants.txt

@@ -9,6 +9,8 @@ nom;          text;     identite;   0;  nom de l'etudiant;
 nom_usuel; text;    identite;   1;  nom usuel (si different);
 prenom;       text;     identite;   0;  prenom de l'etudiant
 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)
 lieu_naissance;text;identite; 1; lieu de naissance
 nationalite;  text;     identite;   1;  nationalite