app/scodoc/sco_etape_bilan.py

@@ -301,7 +301,6 @@ class EtapeBilan:
         :return: None
         """
         self.semestres[sem["formsemestre_id"]] = sem
-        # if anneeapogee == None:  # année d'inscription par défaut
         annee_apogee = str(
             annee_scolaire_debut(sem["annee_debut"], sem["mois_debut_ord"])
         )
@@ -313,7 +312,7 @@ class EtapeBilan:
         """
         Prise en compte d'une étape apogée
         :param etape_str: La clé de l'étape à prendre en compte
-        :param anneeapogee:  l'année de l'étape à prendre en compte
+        :param annee_apogee:  l'année de l'étape à prendre en compte
         :return: None
         """
         if etape_str != "":
@@ -405,9 +404,9 @@ class EtapeBilan:
                 self.etu_semestre[formsemestre_id].add(key_etu)
 
         for key_etape in self.etapes:
-            anneeapogee, etapestr = key_to_values(key_etape)
+            annee_apogee, etapestr = key_to_values(key_etape)
             self.etu_etapes[key_etape] = set()
-            for etud in get_inscrits_etape(etapestr, anneeapogee):
+            for etud in get_inscrits_etape(etapestr, annee_apogee):
                 key_etu = self.register_etud_apogee(etud, key_etape)
                 self.etu_etapes[key_etape].add(key_etu)
 
@@ -771,8 +770,8 @@ class EtapeBilan:
         return "\n".join(H)
 
 
-def etape_to_key(anneeapogee, etapestr):
-    return anneeapogee, etapestr
+def etape_to_key(annee_apogee, etape_str):
+    return annee_apogee, etape_str
 
 
 def key_to_values(key_etape):

app/scodoc/sco_portal_apogee.py

@@ -147,17 +147,17 @@ get_maquette_url = _PI.get_maquette_url
 get_portal_api_version = _PI.get_portal_api_version
 
 
-def get_inscrits_etape(code_etape, anneeapogee=None, ntrials=4, use_cache=True):
+def get_inscrits_etape(code_etape, annee_apogee=None, ntrials=4, use_cache=True):
     """Liste des inscrits à une étape Apogée
     Result = list of dicts
     ntrials: try several time the same request, useful for some bad web services
     use_cache: use (redis) cache
     """
-    log(f"get_inscrits_etape: code={code_etape} anneeapogee={anneeapogee}")
-    if anneeapogee is None:
-        anneeapogee = str(time.localtime()[0])
+    log(f"get_inscrits_etape: code={code_etape} annee_apogee={annee_apogee}")
+    if annee_apogee is None:
+        annee_apogee = str(time.localtime()[0])
     if use_cache:
-        obj = ApoInscritsEtapeCache.get((code_etape, anneeapogee))
+        obj = ApoInscritsEtapeCache.get((code_etape, annee_apogee))
         if obj:
             log("get_inscrits_etape: using cached data")
             return obj
@@ -171,7 +171,7 @@ def get_inscrits_etape(code_etape, anneeapogee=None, ntrials=4, use_cache=True):
         req = (
             etud_url
             + "?"
-            + urllib.parse.urlencode((("etape", code_etape), ("annee", anneeapogee)))
+            + urllib.parse.urlencode((("etape", code_etape), ("annee", annee_apogee)))
         )
     else:
         req = etud_url + "?" + urllib.parse.urlencode((("etape", code_etape),))
@@ -191,7 +191,7 @@ def get_inscrits_etape(code_etape, anneeapogee=None, ntrials=4, use_cache=True):
     # Filtre sur annee inscription Apogee:
     def check_inscription(e):
         if "inscription" in e:
-            if e["inscription"] == anneeapogee:
+            if e["inscription"] == annee_apogee:
                 return True
             else:
                 return False
@@ -204,7 +204,7 @@ def get_inscrits_etape(code_etape, anneeapogee=None, ntrials=4, use_cache=True):
 
     etuds = [e for e in etuds if check_inscription(e)]
     if use_cache and etuds:
-        ApoInscritsEtapeCache.set((code_etape, anneeapogee), etuds)
+        ApoInscritsEtapeCache.set((code_etape, annee_apogee), etuds)
     return etuds
 
 

app/scodoc/sco_synchro_etuds.py

@@ -59,15 +59,20 @@ EKEY_NAME = "code NIP"
 # view:
 def formsemestre_synchro_etuds(
     formsemestre_id,
-    etuds=[],  # liste des codes NIP des etudiants a inscrire (ou deja inscrits)
-    inscrits_without_key=[],  # codes etudid des etudiants sans code NIP a laisser inscrits
-    anneeapogee=None,
+    etuds: list = None,
+    inscrits_without_key: list = None,
+    annee_apogee=None,
     submitted=False,
     dialog_confirmed=False,
     export_cat_xls=None,
-    read_only=False,  # Affiche sans permettre modifications
+    read_only=False,
 ):
     """Synchronise les étudiants de ce semestre avec ceux d'Apogée.
+
+    etuds : liste des codes NIP des etudiants a inscrire (ou deja inscrits)
+    inscrits_without_key : etudids des etudiants sans code NIP a laisser inscrits
+    read_only : Affiche sans permettre modifications
+
     On a plusieurs cas de figure: L'étudiant peut être
     1- présent dans Apogée et inscrit dans le semestre ScoDoc (etuds_ok)
     2- dans Apogée, dans ScoDoc, mais pas inscrit dans le semestre (etuds_noninscrits)
@@ -88,6 +93,8 @@ def formsemestre_synchro_etuds(
     etuds: apres sélection par l'utilisateur, la liste des étudiants selectionnés
     que l'on va importer/inscrire
     """
+    etuds = etuds or []
+    inscrits_without_key = inscrits_without_key or []
     log(f"formsemestre_synchro_etuds: formsemestre_id={formsemestre_id}")
     sem = sco_formsemestre.get_formsemestre(formsemestre_id)
     sem["etape_apo_str"] = sco_formsemestre.formsemestre_etape_apo_str(sem)
@@ -113,14 +120,14 @@ def formsemestre_synchro_etuds(
         "notes.formsemestre_synchro_etuds",
         scodoc_dept=g.scodoc_dept,
         formsemestre_id=formsemestre_id,
-        anneeapogee=anneeapogee or None,  # si None, le param n'est pas dans l'URL
+        annee_apogee=annee_apogee or None,  # si None, le param n'est pas dans l'URL
     )
 
-    if anneeapogee is None:  # année d'inscription par défaut
-        anneeapogee = scu.annee_scolaire_debut(
+    if annee_apogee is None:  # année d'inscription par défaut
+        annee_apogee = scu.annee_scolaire_debut(
             sem["annee_debut"], sem["mois_debut_ord"]
         )
-    anneeapogee = str(anneeapogee)
+    annee_apogee = str(annee_apogee)
 
     if isinstance(etuds, str):
         etuds = etuds.split(",")  # vient du form de confirmation
@@ -140,13 +147,13 @@ def formsemestre_synchro_etuds(
         inscrits_set,
         inscrits_without_key_all,
         etudsapo_ident,
-    ) = list_synch(sem, anneeapogee=anneeapogee)
+    ) = list_synch(sem, annee_apogee=annee_apogee)
     if export_cat_xls:
         filename = export_cat_xls
         xls = build_page(
             sem,
             etuds_by_cat,
-            anneeapogee,
+            annee_apogee,
             export_cat_xls=export_cat_xls,
             base_url=base_url,
             read_only=read_only,
@@ -163,7 +170,7 @@ def formsemestre_synchro_etuds(
         H += build_page(
             sem,
             etuds_by_cat,
-            anneeapogee,
+            annee_apogee,
             base_url=base_url,
             read_only=read_only,
         )
@@ -237,7 +244,7 @@ def formsemestre_synchro_etuds(
                             [str(x) for x in inscrits_without_key]
                         ),
                         "submitted": 1,
-                        "anneeapogee": anneeapogee,
+                        "annee_apogee": annee_apogee,
                     },
                 )
             )
@@ -284,7 +291,7 @@ def formsemestre_synchro_etuds(
 def build_page(
     sem,
     etuds_by_cat,
-    anneeapogee,
+    annee_apogee,
     export_cat_xls=None,
     base_url="",
     read_only=False,
@@ -294,21 +301,23 @@ def build_page(
             etuds_by_cat, export_cat_xls=export_cat_xls, base_url=base_url
         )
     year = time.localtime()[0]
-    if anneeapogee and abs(year - int(anneeapogee)) < 50:
+    if annee_apogee and abs(year - int(annee_apogee)) < 50:
         years = list(
-            range(min(year - 1, int(anneeapogee) - 1), max(year, int(anneeapogee)) + 1)
+            range(
+                min(year - 1, int(annee_apogee) - 1), max(year, int(annee_apogee)) + 1
+            )
         )
     else:
         years = list(range(year - 1, year + 1))
-        anneeapogee = ""
+        annee_apogee = ""
     options = []
     for y in years:
-        if str(y) == anneeapogee:
+        if str(y) == annee_apogee:
             sel = "selected"
         else:
             sel = ""
         options.append('<option value="%s" %s>%s</option>' % (str(y), sel, str(y)))
-    if anneeapogee:
+    if annee_apogee:
         sel = ""
     else:
         sel = "selected"
@@ -328,8 +337,8 @@ def build_page(
         """
         % sem,
         """
-        Année Apogée: <select id="anneeapogee" name="anneeapogee" 
-        onchange="document.location='formsemestre_synchro_etuds?formsemestre_id=%s&anneeapogee='+document.getElementById('anneeapogee').value">"""
+        Année Apogée: <select id="anne_eapogee" name="annee_apogee" 
+        onchange="document.location='formsemestre_synchro_etuds?formsemestre_id=%s&annee_apogee='+document.getElementById('annee_apogee').value">"""
         % (sem["formsemestre_id"]),
         "\n".join(options),
         """
@@ -359,7 +368,7 @@ def build_page(
     return H
 
 
-def list_synch(sem, anneeapogee=None):
+def list_synch(sem, annee_apogee=None):
     """"""
     inscrits = sco_inscr_passage.list_inscrits(sem["formsemestre_id"], with_dems=True)
     # Tous les ensembles d'etudiants sont ici des ensembles de codes NIP (voir EKEY_SCO)
@@ -372,39 +381,35 @@ def list_synch(sem, anneeapogee=None):
             e["inscrit"] = True  # checkbox state
         else:
             inscrits_set.add(e[EKEY_SCO])
-    #     allinscrits_set = set() # tous les inscrits scodoc avec code_nip, y compris les demissionnaires
-    #     for e in inscrits.values():
-    #         if e[EKEY_SCO]:
-    #             allinscrits_set.add(e[EKEY_SCO])
 
-    datefinalisationinscription_by_NIP = {}  # nip : datefinalisationinscription_str
+    date_finalisation_inscr_by_nip = {}  # nip : datefinalisationinscription_str
 
     etapes = sem["etapes"]
     etudsapo_set = set()
     etudsapo_ident = {}
+    etuds_payes = set()  # étudiants ayant payé (avec balise <paiementinscription> true)
     for etape in etapes:
         if etape:
             etudsapo = sco_portal_apogee.get_inscrits_etape(
-                etape, anneeapogee=anneeapogee
+                etape, annee_apogee=annee_apogee
             )
-            etudsapo_set = etudsapo_set.union(set([x[EKEY_APO] for x in etudsapo]))
+            etudsapo_set |= {x[EKEY_APO] for x in etudsapo}
             for e in etudsapo:
                 if e[EKEY_APO] not in etudsapo_ident:
                     etudsapo_ident[e[EKEY_APO]] = e
-                datefinalisationinscription_by_NIP[e[EKEY_APO]] = e[
+                date_finalisation_inscr_by_nip[e[EKEY_APO]] = e[
                     "datefinalisationinscription"
                 ]
+            # note: si le portail ne renseigne pas cette balise, suppose que paiement ok
+            etuds_payes |= {
+                x[EKEY_APO] for x in etudsapo if x.get("paiementinscription", True)
+            }
 
     # categories:
     etuds_ok = etudsapo_set.intersection(inscrits_set)
     etuds_aposco, a_importer, key2etudid = list_all(etudsapo_set)
     etuds_noninscrits = etuds_aposco - inscrits_set
     etuds_nonapogee = inscrits_set - etudsapo_set
-    # Etudiants ayant payé (avec balise <paiementinscription> true)
-    # note: si le portail ne renseigne pas cette balise, suppose que paiement ok
-    etuds_payes = set(
-        [x[EKEY_APO] for x in etudsapo if x.get("paiementinscription", True)]
-    )
     #
     cnx = ndb.GetDBConnexion()
 
@@ -420,7 +425,7 @@ def list_synch(sem, anneeapogee=None):
                 etud["inscrit"] = is_inscrit  # checkbox state
                 etud[
                     "datefinalisationinscription"
-                ] = datefinalisationinscription_by_NIP.get(key, None)
+                ] = date_finalisation_inscr_by_nip.get(key, None)
                 if key in etudsapo_ident:
                     etud["etape"] = etudsapo_ident[key].get("etape", "")
             else:
@@ -827,12 +832,14 @@ def formsemestre_import_etud_admission(
     # Essaie de recuperer les etudiants des étapes, car
     # la requete get_inscrits_etape est en général beaucoup plus
     # rapide que les requetes individuelles get_etud_apogee
-    anneeapogee = str(
+    annee_apogee = str(
         scu.annee_scolaire_debut(sem["annee_debut"], sem["mois_debut_ord"])
     )
     apo_etuds = {}  # nip : etud apo
     for etape in sem["etapes"]:
-        etudsapo = sco_portal_apogee.get_inscrits_etape(etape, anneeapogee=anneeapogee)
+        etudsapo = sco_portal_apogee.get_inscrits_etape(
+            etape, annee_apogee=annee_apogee
+        )
         apo_etuds.update({e["nip"]: e for e in etudsapo})
 
     for i in ins: