lehmann/ScoDoc-Front
1
0
Fork 0
forked from ScoDoc/ScoDoc
Code Pull Requests Activity
0afab38f6e
ScoDoc-Front/app/scodoc/sco_etape_bilan.py

770 lines
30 KiB
Python
Raw Normal View History

Upload from subversion 1932
2020-09-26 16:19:37 +02:00
# -*- mode: python -*-
# -*- coding: utf-8 -*-
##############################################################################
#
# Gestion scolarite IUT
#
update copyright year
2021-01-01 17:51:08 +01:00
# Copyright (c) 1999 - 2021 Emmanuel Viennet. All rights reserved.
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
#
# 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
#
##############################################################################
"""
# Outil de comparaison Apogée/ScoDoc (J.-M. Place, Jan 2020)
## fonctionalités
Le menu 'synchronisation avec Apogée' ne permet pas de traiter facilement les cas
où un même code étape est implementé dans des semestres (au sens ScoDoc) différents.
La proposition est d'ajouter à la page de description des ensembles de semestres
une section permettant de faire le point sur les cas particuliers.
Cette section est composée de deux parties:
* Une partie effectif où figurent le nombre d'étudiants selon un répartition par
semestre (en ligne) et par code étape (en colonne). On ajoute également des
colonnes/lignes correspondant à des anomalies (étudiant sans code étape, sans
semestre, avec deux semestres, sans NIP, etc.).
* La seconde partie présente la liste des étudiants. Il est possible qu'un
même nom figure deux fois dans la liste (si on a pas pu faire la correspondance
entre une inscription apogée et un étudiant d'un semestre, par exemple).
L'activation d'un des nombres du tableau 'effectifs' restreint l'affichage de
la liste aux étudiants qui contribuent à ce nombre.
## Réalisation
Les modifications logicielles portent sur:
### La création d'une classe sco_etape_bilan.py
Cette classe compile la totalité des données:
** Liste des semestres
** Listes des étapes
** Liste des étudiants
** constitution des listes d'anomalies
Cette classe explore la suite semestres du semset.
Pour chaque semestre, elle recense les étudiants du semestre et
les codes étapes concernés.
puis tous les codes étapes (toujours en important les étudiants de l'étape
via le portail)
enfin on dispatch chaque étudiant dans une case - soit ordinaire, soit
correspondant à une anomalie.
### Modification de sco_etape_apogee_view.py
Pour insertion de l'affichage ajouté
### Modification de sco_semset.py
Affichage proprement dit
### Modification de scp_formsemestre.py
Modification/ajout de la méthode sem_in_semestre_scolaire pour permettre
l'inscrition de semestres décalés (S1 en septembre, ...).
Le filtrage s'effctue sur la date et non plus sur la parité du semestre (1-3/2-4).
"""
Fix: bug display selected students on export apo
2021-02-05 19:06:42 +01:00
import json
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
Massive refactoring/reorganization of imports. Work in progress.
2021-06-19 23:21:37 +02:00
from app.scodoc.sco_portal_apogee import get_inscrits_etape
from app.scodoc.notes_log import log
from app.scodoc.sco_utils import annee_scolaire_debut
from app.scodoc.gen_tables import GenTable
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
COL_PREFIX = "COL_"
# Les indicatifs sont des marqueurs de classe CSS insérés dans la table étudiant
# et utilisés par le javascript pour permettre un filtrage de la liste étudiants
# sur un 'cas' considéré
# indicatifs
COL_CUMUL = "C9"
ROW_CUMUL = "R9"
# Constante d'anomalie
PAS_DE_NIP = "C1"
PAS_D_ETAPE = "C2"
PLUSIEURS_ETAPES = "C3"
PAS_DE_SEMESTRE = "R4"
PLUSIEURS_SEMESTRES = "R5"
NIP_NON_UNIQUE = "U"
FLAG = {
PAS_DE_NIP: "A",
PAS_D_ETAPE: "B",
PLUSIEURS_ETAPES: "C",
PAS_DE_SEMESTRE: "D",
PLUSIEURS_SEMESTRES: "E",
NIP_NON_UNIQUE: "U",
}
New-Style Classes
2021-07-09 23:31:16 +02:00
class DataEtudiant(object):
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
"""
Structure de donnée des informations pour un étudiant
"""
def __init__(self, nip="", etudid=""):
self.nip = nip
self.etudid = etudid
self.data_apogee = None
self.data_scodoc = None
self.etapes = set() # l'ensemble des étapes où il est inscrit
self.semestres = set() # l'ensemble des semestres où il est inscrit
self.tags = set() # les anomalies relevées
self.ind_row = "-" # là où il compte dans les effectifs (ligne et colonne)
self.ind_col = "-"
def add_etape(self, etape):
self.etapes.add(etape)
def add_semestre(self, semestre):
self.semestres.add(semestre)
def set_apogee(self, data_apogee):
self.data_apogee = data_apogee
def set_scodoc(self, data_scodoc):
self.data_scodoc = data_scodoc
def add_tag(self, tag):
self.tags.add(tag)
def set_ind_row(self, indicatif):
self.ind_row = indicatif
def set_ind_col(self, indicatif):
self.ind_col = indicatif
def get_identity(self):
"""
Calcul le nom/prénom de l'étudiant (données ScoDoc en priorité, sinon données Apogée)
:return: L'identité calculée
"""
if self.data_scodoc is not None:
return self.data_scodoc["nom"] + self.data_scodoc["prenom"]
else:
return self.data_apogee["nom"] + self.data_apogee["prenom"]
def help():
return """
<div id="export_help" class="pas_help"> <span>Explications sur les tableaux des effectifs et liste des
étudiants</span>
<div> <p>Le tableau des effectifs présente le nombre d'étudiants selon deux critères:</p>
<ul>
<li>En colonne le statut de l'étudiant par rapport à Apogée:
<ul>
<li><span class="libelle">Hors Apogée</span>
<span class="anomalie">(anomalie A</span>): Le NIP de l'étudiant n'est pas connu d'apogée ou
l'étudiant n'a pas de NIP</li>
<li><span class="libelle">Pas d'étape</span> <span class="anomalie">(anomalie B</span>): Le NIP de
l'étudiant ne correspond à aucune des étapes connues pour cet ensemble de semestre. Il est
possible qu'il soit inscrit ailleurs (dans une autre ensemble de semestres, un autre département,
une autre composante de l'université) ou en mobilité internationale.</li>
<li><span class="libelle">Plusieurs étapes</span> <span class="anomalie">(anomalie C)</span>:
Les étudiants inscrits dans plusieurs étapes apogée de l'ensemble de semestres</li>
<li>Un des codes étapes connus (la liste des codes étapes connus est l'union des codes étapes
déclarés pour chaque semestre particpant</li>
<li><span class="libelle">Total semestre</span>: cumul des effectifs de la ligne</li>
</ul>
</li>
<li>En ligne le statut de l'étudiant par rapport à ScoDoc:
<ul>
<li>Inscription dans un des semestres de l'ensemble</li>
<li><span class="libelle">Hors semestre</span> <span class="anomalie">(anomalie D)</span>:
L'étudiant, bien qu'enregistré par apogée dans un des codes étapes connus, ne figure dans aucun
des semestres de l'ensemble. On y trouve par exemple les étudiants régulièrement inscrits
mais non présents à la rentrée (donc non enregistrés dans ScoDoc) <p>Note: On ne considère
ici que les semestres de l'ensemble (l'inscription de l'étudiant dans un semestre étranger à
l'ensemble actuel n'est pas vérifiée).</p> </li>
<li><span class="libelle">Plusieurs semestres</span> <span class="anomalie">(anomalie E)</span>:
L'étudiant est enregistré dans plusieurs semestres de l'ensemble.</li>
<li><span class="libelle">Total</span>: cumul des effectifs de la colonne</li>
</ul>
</li>
<li>(<span class="anomalie">anomalie U</span>) On présente également les cas où un même NIP est affecté
à deux dossiers différents (Un dossier d'apogée et un dossier de ScoDoc). Un tel cas compte pour
deux unités dans le tableau des effcetifs et engendre 2 lignes distinctes dans la liste des étudiants</li>
</ul>
</div>
</div> """
def entete_liste_etudiant():
return """
<h4 id='effectifs'>Liste des étudiants <span id='compte'></span>
<ul>
<li id='sans_filtre'>Pas de filtrage: Cliquez sur un des nombres du tableau ci-dessus pour
n'afficher que les étudiants correspondants</li>
<li id='filtre_row' style='display:none'></li>
<li id='filtre_col' style='display:none'></li>
</ul>
</h4>
"""
New-Style Classes
2021-07-09 23:31:16 +02:00
class EtapeBilan(object):
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
"""
Structure de donnée représentation l'état global de la comparaison ScoDoc/Apogée
"""
def __init__(self, context):
self.context = context
self.semestres = (
{}
) # Dictionnaire des formsemestres du semset (formsemestre_id -> semestre)
self.etapes = [] # Liste des étapes apogées du semset (clé_apogée)
# pour les descriptions qui suivents:
# cle_etu = nip si non vide, sinon etudid
# data_etu = { nip, etudid, data_apogee, data_scodoc }
self.etudiants = {} # cle_etu -> data_etu
self.keys_etu = {} # nip -> [ etudid* ]
self.etu_semestre = {} # semestre -> { key_etu }
self.etu_etapes = {} # etape -> { key_etu }
self.repartition = {} # (ind_row, ind_col) -> nombre d étudiants
self.tag_count = {} # nombre d'animalies détectées (par type d'anomalie)
# on collectionne les indicatifs trouvés pour n'afficher que les indicatifs 'utiles'
self.indicatifs = {}
self.top_row = 0
self.top_col = 0
self.all_rows_ind = [PAS_DE_SEMESTRE, PLUSIEURS_SEMESTRES]
self.all_cols_ind = [PAS_DE_NIP, PAS_D_ETAPE, PLUSIEURS_ETAPES]
self.all_rows_str = None
self.all_cols_str = None
self.titres = {
PAS_DE_NIP: "PAS_DE_NIP",
PAS_D_ETAPE: "PAS_D_ETAPE",
PLUSIEURS_ETAPES: "PLUSIEURS_ETAPES",
PAS_DE_SEMESTRE: "PAS_DE_SEMESTRE",
PLUSIEURS_SEMESTRES: "PLUSIEURS_SEMESTRES",
NIP_NON_UNIQUE: "NIP_NON_UNIQUE",
}
def inc_tag_count(self, tag):
if tag not in self.tag_count:
self.tag_count[tag] = 0
self.tag_count[tag] += 1
def set_indicatif(self, item, as_row): # item = semestre ou key_etape
if as_row:
indicatif = "R" + chr(self.top_row + 97)
self.all_rows_ind.append(indicatif)
self.top_row += 1
else:
indicatif = "C" + chr(self.top_col + 97)
self.all_cols_ind.append(indicatif)
self.top_col += 1
self.indicatifs[item] = indicatif
if self.top_row > 26:
log("Dépassement (plus de 26 semestres dans la table diagnostic")
if self.top_col > 26:
log("Dépassement (plus de 26 étapes dans la table diagnostic")
def add_sem(self, semestre):
"""
Prise en compte d'un semestre dans le bilan.
* ajoute le semestre et les étudiants du semestre
* ajoute les étapes du semestre et (via portail) les étudiants pour ces codes étapes
:param semestre: Le semestre à prendre en compte
:return: None
"""
self.semestres[semestre["formsemestre_id"]] = semestre
# if anneeapogee == None: # année d'inscription par défaut
anneeapogee = str(
annee_scolaire_debut(semestre["annee_debut"], semestre["mois_debut_ord"])
)
self.set_indicatif(semestre["formsemestre_id"], True)
for etape in semestre["etapes"]:
self.add_etape(etape.etape_vdi, anneeapogee)
def add_etape(self, etape_str, anneeapogee):
"""
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
:return: None
"""
if etape_str != "":
key_etape = etape_to_key(anneeapogee, etape_str)
if key_etape not in self.etapes:
self.etapes.append(key_etape)
self.set_indicatif(
key_etape, False
) # ajout de la colonne/indicatif supplémentaire
def compute_key_etu(self, nip, etudid):
"""
Calcul de la clé étudiant:
* Le nip si il existe
* sinon l'identifiant ScoDoc
Tient à jour le dictionnaire key_etu (référentiel des étudiants)
La problèmatique est de gérer toutes les anomalies possibles:
- étudiant sans nip,
- plusieurs étudiants avec le même nip,
- etc.
:param nip: le nip de l'étudiant
:param etudid: l'identifiant ScoDoc
:return: L'identifiant unique de l'étudiant
"""
if nip not in self.keys_etu:
self.keys_etu[nip] = []
if etudid not in self.keys_etu[nip]:
if etudid is None:
if len(self.keys_etu[nip]) == 1:
etudid = self.keys_etu[nip][0]
else: # nip non trouvé ou utilisé par plusieurs étudiants
self.keys_etu[nip].append(None)
else:
self.keys_etu[nip].append(etudid)
return nip, etudid
def register_etud_apogee(self, etud, etape):
"""
Enregistrement des données de l'étudiant par rapport à apogée.
L'étudiant peut avoir été déjà enregistré auparavant (par exemple connu par son semestre)
Dans ce cas, on ne met à jour que son association à l'étape apogée
:param etud: les données étudiant
:param etape: l'étape apogée
:return:
"""
nip = etud["nip"]
key_etu = self.compute_key_etu(nip, None)
if key_etu not in self.etudiants:
data = DataEtudiant(nip)
data.set_apogee(etud)
data.add_etape(etape)
self.etudiants[key_etu] = data
else:
self.etudiants[key_etu].set_apogee(etud)
self.etudiants[key_etu].add_etape(etape)
return key_etu
def register_etud_scodoc(self, etud, semestre):
"""
Enregistrement de l'étudiant par rapport à son semestre
:param etud: Les données de l'étudiant
:param semestre: Le semestre où il est à enregistrer
:return: la clé unique pour cet étudiant
"""
nip = etud["code_nip"]
etudid = etud["etudid"]
key_etu = self.compute_key_etu(nip, etudid)
if key_etu not in self.etudiants:
data = DataEtudiant(nip, etudid)
data.set_scodoc(etud)
data.add_semestre(semestre)
self.etudiants[key_etu] = data
else:
self.etudiants[key_etu].add_semestre(semestre)
return key_etu
def load_listes(self):
"""
Inventaire complet des étudiants:
* Pour tous les semestres d'abord
* Puis pour toutes les étapes
:return: None
"""
for semestre in self.semestres:
etuds = self.semestres[semestre]["etuds"]
self.etu_semestre[semestre] = set()
for etud in etuds:
key_etu = self.register_etud_scodoc(etud, semestre)
self.etu_semestre[semestre].add(key_etu)
for key_etape in self.etapes:
anneeapogee, etapestr = key_to_values(key_etape)
self.etu_etapes[key_etape] = set()
for etud in get_inscrits_etape(self.context, etapestr, anneeapogee):
key_etu = self.register_etud_apogee(etud, key_etape)
self.etu_etapes[key_etape].add(key_etu)
def dispatch(self):
"""
Réparti l'ensemble des étudiants selon les lignes (semestres) et les colonnes (étapes).
:return: None
"""
# Initialisation des cumuls
self.repartition[ROW_CUMUL, COL_CUMUL] = 0
self.repartition[PAS_DE_SEMESTRE, COL_CUMUL] = 0
self.repartition[PLUSIEURS_SEMESTRES, COL_CUMUL] = 0
self.repartition[ROW_CUMUL, PAS_DE_NIP] = 0
self.repartition[ROW_CUMUL, PAS_D_ETAPE] = 0
self.repartition[ROW_CUMUL, PLUSIEURS_ETAPES] = 0
for semestre in self.semestres:
self.repartition[self.indicatifs[semestre], COL_CUMUL] = 0
for key_etape in self.etapes:
self.repartition[ROW_CUMUL, self.indicatifs[key_etape]] = 0
# recherche des nip identiques
for nip in self.keys_etu:
if nip != "":
nbnips = len(self.keys_etu[nip])
if nbnips > 1:
for i, etudid in enumerate(self.keys_etu[nip]):
data_etu = self.etudiants[nip, etudid]
data_etu.add_tag(NIP_NON_UNIQUE)
data_etu.nip = data_etu.nip + "&nbsp;(%d/%d)" % (i + 1, nbnips)
self.inc_tag_count(NIP_NON_UNIQUE)
for nip in self.keys_etu:
for etudid in self.keys_etu[nip]:
key_etu = (nip, etudid)
data_etu = self.etudiants[key_etu]
ind_col = "-"
ind_row = "-"
# calcul de la colonne
if len(data_etu.etapes) == 1:
ind_col = self.indicatifs[list(data_etu.etapes)[0]]
elif nip == "":
data_etu.add_tag(FLAG[PAS_DE_NIP])
ind_col = PAS_DE_NIP
elif len(data_etu.etapes) == 0:
self.etudiants[key_etu].add_tag(FLAG[PAS_D_ETAPE])
ind_col = PAS_D_ETAPE
if len(data_etu.etapes) > 1:
data_etu.add_tag(FLAG[PLUSIEURS_ETAPES])
ind_col = PLUSIEURS_ETAPES
if len(data_etu.semestres) == 1:
ind_row = self.indicatifs[list(data_etu.semestres)[0]]
elif len(data_etu.semestres) > 1:
data_etu.add_tag(FLAG[PLUSIEURS_SEMESTRES])
ind_row = PLUSIEURS_SEMESTRES
elif len(data_etu.semestres) < 1:
self.etudiants[key_etu].add_tag(FLAG[PAS_DE_SEMESTRE])
ind_row = PAS_DE_SEMESTRE
data_etu.set_ind_col(ind_col)
data_etu.set_ind_row(ind_row)
self._inc_count(ind_row, ind_col)
self.inc_tag_count(ind_row)
self.inc_tag_count(ind_col)
def html_diagnostic(self):
"""
affichage de l'html
:return: Le code html à afficher
"""
self.load_listes() # chargement des données
self.dispatch() # analyse et répartition
# calcul de la liste des colonnes et des lignes de la table des effectifs
self.all_rows_str = "'" + ",".join(["." + r for r in self.all_rows_ind]) + "'"
self.all_cols_str = "'" + ",".join(["." + c for c in self.all_cols_ind]) + "'"
H = [
'<div id="synthese" class=u"semset_description"><h4>Tableau des effectifs</h4>',
self._diagtable(),
self.display_tags(),
entete_liste_etudiant(),
self.table_effectifs(),
help(),
]
return "\n".join(H)
def _inc_count(self, ind_row, ind_col):
if (ind_row, ind_col) not in self.repartition:
self.repartition[ind_row, ind_col] = 0
self.repartition[ind_row, ind_col] += 1
self.repartition[ROW_CUMUL, ind_col] += 1
self.repartition[ind_row, COL_CUMUL] += 1
self.repartition[ROW_CUMUL, COL_CUMUL] += 1
def _get_count(self, ind_row, ind_col):
if (ind_row, ind_col) in self.repartition:
count = self.repartition[ind_row, ind_col]
if count > 1:
comptage = "(%d étudiants)" % count
else:
comptage = "(1 étudiant)"
else:
count = 0
return ""
# Ajoute l'appel à la routine javascript de filtrage (apo_semset_maq_status.js
# signature:
# function show_css(elt, all_rows, all_cols, row, col, precision)
# elt: le lien cliqué
# all_rows: la liste de toutes les lignes existantes dans le tableau répartition
# (exemple: ".Rb,.R1,.R2,.R3")
# all_cols: la liste de toutes les colonnes existantes dans le tableau répartition
# (exemple: ".Ca,.C1,.C2,.C3")
# row: la ligne sélectionnée (sélecteur css) (expl: ".R1")
# ; '*' si pas de sélection sur la ligne
# col: la (les) colonnes sélectionnées (sélecteur css) (exple: ".C2")
# ; '*' si pas de sélection sur colonne
# precision: ajout sur le titre (en général, le nombre d'étudiant)
# filtre_row: explicitation du filtre ligne éventuelle
# filtre_col: explicitation du filtre colonne évnetuelle
if ind_row == ROW_CUMUL and ind_col == COL_CUMUL:
javascript = "doFiltrage(%s, %s, '*', '*', '%s', '%s', '%s');" % (
self.all_rows_str,
self.all_cols_str,
comptage,
"",
"",
)
elif ind_row == ROW_CUMUL:
javascript = "doFiltrage(%s, %s, '*', '.%s', '%s', '%s', '%s');" % (
self.all_rows_str,
self.all_cols_str,
ind_col,
comptage,
"",
Fix: bug display selected students on export apo
2021-02-05 19:06:42 +01:00
json.dumps(self.titres[ind_col].replace("<br/>", " / "))[1:-1],
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
)
elif ind_col == COL_CUMUL:
javascript = "doFiltrage(%s, %s, '.%s', '*', '%s', '%s', '%s');" % (
self.all_rows_str,
self.all_cols_str,
ind_row,
" (%d étudiants)" % count,
Fix: bug display selected students on export apo
2021-02-05 19:06:42 +01:00
json.dumps(self.titres[ind_row])[1:-1],
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
"",
)
else:
javascript = "doFiltrage(%s, %s, '.%s', '.%s', '%s', '%s', '%s');" % (
self.all_rows_str,
self.all_cols_str,
ind_row,
ind_col,
comptage,
Fix: bug display selected students on export apo
2021-02-05 19:06:42 +01:00
json.dumps(self.titres[ind_row])[1:-1],
json.dumps(self.titres[ind_col].replace("<br/>", " / "))[1:-1],
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
)
Fix: bug display selected students on export apo
2021-02-05 19:06:42 +01:00
return '<a href="#synthese" onclick="%s">%d</a>' % (javascript, count)
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
def _diagtable(self):
H = []
liste_semestres = sorted(self.semestres.keys())
liste_etapes = []
for key_etape in self.etapes:
liste_etapes.append(key_etape)
liste_etapes.sort(key=lambda key: etape_to_col(key_etape))
col_ids = []
if PAS_DE_NIP in self.tag_count:
col_ids.append(PAS_DE_NIP)
if PAS_D_ETAPE in self.tag_count:
col_ids.append(PAS_D_ETAPE)
if PLUSIEURS_ETAPES in self.tag_count:
col_ids.append(PLUSIEURS_ETAPES)
self.titres["row_title"] = "Semestre"
self.titres[PAS_DE_NIP] = "Hors Apogée (" + FLAG[PAS_DE_NIP] + ")"
self.titres[PAS_D_ETAPE] = "Pas d'étape (" + FLAG[PAS_D_ETAPE] + ")"
self.titres[PLUSIEURS_ETAPES] = (
"Plusieurs etapes (" + FLAG[PLUSIEURS_ETAPES] + ")"
)
for key_etape in liste_etapes:
col_id = self.indicatifs[key_etape]
col_ids.append(col_id)
self.titres[col_id] = "%s<br/>%s" % key_to_values(key_etape)
col_ids.append(COL_CUMUL)
self.titres[COL_CUMUL] = "Total<br/>semestre"
rows = []
for semestre in liste_semestres:
ind_row = self.indicatifs[semestre]
self.titres[ind_row] = (
"%(titre_num)s (%(formsemestre_id)s)" % self.semestres[semestre]
)
row = {
"row_title": self.link_semestre(semestre),
PAS_DE_NIP: self._get_count(ind_row, PAS_DE_NIP),
PAS_D_ETAPE: self._get_count(ind_row, PAS_D_ETAPE),
PLUSIEURS_ETAPES: self._get_count(ind_row, PLUSIEURS_ETAPES),
COL_CUMUL: self._get_count(ind_row, COL_CUMUL),
"_css_row_class": ind_row,
}
for key_etape in liste_etapes:
ind_col = self.indicatifs[key_etape]
row[ind_col] = self._get_count(ind_row, ind_col)
rows.append(row)
if PAS_DE_SEMESTRE in self.tag_count:
row = {
"row_title": "Hors semestres (" + FLAG[PAS_DE_SEMESTRE] + ")",
PAS_DE_NIP: "",
PAS_D_ETAPE: "",
PLUSIEURS_ETAPES: "",
COL_CUMUL: self._get_count(PAS_DE_SEMESTRE, COL_CUMUL),
"_css_row_class": PAS_DE_SEMESTRE,
}
for key_etape in liste_etapes:
ind_col = self.indicatifs[key_etape]
row[ind_col] = self._get_count(PAS_DE_SEMESTRE, ind_col)
rows.append(row)
if PLUSIEURS_SEMESTRES in self.tag_count:
row = {
"row_title": "Plusieurs semestres (" + FLAG[PLUSIEURS_SEMESTRES] + ")",
PAS_DE_NIP: "",
PAS_D_ETAPE: "",
PLUSIEURS_ETAPES: "",
COL_CUMUL: self._get_count(PLUSIEURS_SEMESTRES, COL_CUMUL),
"_css_row_class": PLUSIEURS_SEMESTRES,
}
for key_etape in liste_etapes:
ind_col = self.indicatifs[key_etape]
row[ind_col] = self._get_count(PLUSIEURS_SEMESTRES, ind_col)
rows.append(row)
row = {
"row_title": "Total",
PAS_DE_NIP: self._get_count(ROW_CUMUL, PAS_DE_NIP),
PAS_D_ETAPE: self._get_count(ROW_CUMUL, PAS_D_ETAPE),
PLUSIEURS_ETAPES: self._get_count(ROW_CUMUL, PLUSIEURS_ETAPES),
COL_CUMUL: self._get_count(ROW_CUMUL, COL_CUMUL),
"_css_row_class": COL_CUMUL,
}
for key_etape in liste_etapes:
ind_col = self.indicatifs[key_etape]
row[ind_col] = self._get_count(ROW_CUMUL, ind_col)
rows.append(row)
H.append(
GenTable(
rows,
col_ids,
self.titres,
html_class="repartition",
html_with_td_classes=True,
).gen(format="html")
)
return "\n".join(H)
def display_tags(self):
H = []
if NIP_NON_UNIQUE in self.tag_count:
H.append("<h4>Anomalies</h4>")
javascript = "show_tag(%s, %s, '%s');" % (
self.all_rows_str,
self.all_cols_str,
NIP_NON_UNIQUE,
)
H.append(
'Code(s) nip) partagé(s) par <a href="#synthèse" onclick="%s">%d</a> étudiants<br/>'
% (javascript, self.tag_count[NIP_NON_UNIQUE])
)
return "\n".join(H)
@staticmethod
def link_etu(etudid, nom):
return '<a class="stdlink" href="ficheEtud?etudid=%s">%s</a>' % (etudid, nom)
def link_semestre(self, semestre, short=False):
if short:
return (
'<a class="stdlink" href="formsemestre_status?formsemestre_id=%(formsemestre_id)s">%('
"formsemestre_id)s</a> " % self.semestres[semestre]
)
else:
return (
'<a class="stdlink" href="formsemestre_status?formsemestre_id=%(formsemestre_id)s">%(titre_num)s'
" %(mois_debut)s - %(mois_fin)s)</a>" % self.semestres[semestre]
)
def table_effectifs(self):
H = []
col_ids = ["tag", "etudiant", "prenom", "nip", "semestre", "apogee", "annee"]
titles = {
"tag": "Etat",
"etudiant": "Nom",
"prenom": "Prenom",
"nip": "code nip",
"semestre": "semestre",
"annee": "année",
"apogee": "etape",
}
rows = []
for data_etu in sorted(
python-modernize
2021-07-09 17:47:06 +02:00
list(self.etudiants.values()), key=lambda etu: etu.get_identity()
Upload from subversion 1932
2020-09-26 16:19:37 +02:00
):
nip = data_etu.nip
etudid = data_etu.etudid
if data_etu.data_scodoc is None:
nom = data_etu.data_apogee["nom"]
prenom = data_etu.data_apogee["prenom"]
link = nom
else:
nom = data_etu.data_scodoc["nom"]
prenom = data_etu.data_scodoc["prenom"]
link = self.link_etu(etudid, nom)
tag = ", ".join([tag for tag in sorted(data_etu.tags)])
semestre = "<br/>".join(
[self.link_semestre(sem, True) for sem in data_etu.semestres]
)
annees = "<br/>".join([etape[0] for etape in data_etu.etapes])
etapes = "<br/>".join([etape[1] for etape in data_etu.etapes])
classe = data_etu.ind_row + data_etu.ind_col
if NIP_NON_UNIQUE in data_etu.tags:
classe += " " + NIP_NON_UNIQUE
row = {
"tag": tag,
"etudiant": link,
"prenom": prenom.capitalize(),
"nip": nip,
"semestre": semestre,
"annee": annees,
"apogee": etapes,
"_css_row_class": classe,
}
rows.append(row)
H.append(
GenTable(
rows,
col_ids,
titles,
table_id="detail",
html_class="table_leftalign",
html_sortable=True,
).gen(format="html")
)
return "\n".join(H)
def etape_to_key(anneeapogee, etapestr):
return anneeapogee, etapestr
def key_to_values(key_etape):
return key_etape
def etape_to_col(key_etape):
return "%s@%s" % key_etape
Copy Permalink