# -*- mode: python -*- # -*- coding: utf-8 -*- ############################################################################## # # Gestion scolarite IUT # # Copyright (c) 1999 - 2021 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 # ############################################################################## ############################################################################## # Module "Avis de poursuite d'étude" # conçu et développé par Cléo Baras (IUT de Grenoble) ############################################################################## import os import codecs import re from app.scodoc import pe_jurype from app.scodoc import pe_tagtable from app.scodoc import pe_tools import app.scodoc.sco_utils as scu import app.scodoc.notesdb as ndb from app.scodoc.notes_log import log from app.scodoc.gen_tables import GenTable, SeqGenTable from app.scodoc import sco_preferences from app.scodoc import sco_etud DEBUG = False # Pour debug et repérage des prints à changer en Log DONNEE_MANQUANTE = ( u"" # Caractère de remplacement des données manquantes dans un avis PE ) # ---------------------------------------------------------------------------------------- def get_code_latex_from_modele(fichier): """Lit le code latex à partir d'un modèle. Renvoie une chaine unicode. Le fichier doit contenir le chemin relatif vers le modele : attention pas de vérification du format d'encodage Le fichier doit donc etre enregistré avec le même codage que ScoDoc (utf-8) """ fid_latex = codecs.open(fichier, "r", encoding=scu.SCO_ENCODING) un_avis_latex = fid_latex.read() fid_latex.close() return un_avis_latex # ---------------------------------------------------------------------------------------- def get_code_latex_from_scodoc_preference( context, formsemestre_id, champ="pe_avis_latex_tmpl" ): """ Extrait le template (ou le tag d'annotation au regard du champ fourni) des préférences LaTeX et s'assure qu'il est renvoyé au format unicode """ template_latex = sco_preferences.get_preference(champ, formsemestre_id) return template_latex or "" # ---------------------------------------------------------------------------------------- def get_tags_latex(code_latex): """Recherche tous les tags présents dans un code latex (ce code étant obtenu à la lecture d'un modèle d'avis pe). Ces tags sont répérés par les balises **, débutant et finissant le tag et sont renvoyés sous la forme d'une liste. result: liste de chaines unicode """ if code_latex: # changé par EV: était r"([\*]{2}[a-zA-Z0-9:éèàâêëïôöù]+[\*]{2})" res = re.findall(r"([\*]{2}[^ \t\n\r\f\v\*]+[\*]{2})", code_latex) return [tag[2:-2] for tag in res] else: return [] def comp_latex_parcourstimeline(etudiant, promo, taille=17): """Interprète un tag dans un avis latex **parcourstimeline** et génère le code latex permettant de retracer le parcours d'un étudiant sous la forme d'une frise temporelle. Nota: modeles/parcourstimeline.tex doit avoir été inclu dans le préambule result: chaine unicode (EV:) """ codelatexDebut = ( u""" \\begin{parcourstimeline}{**debut**}{**fin**}{**nbreSemestres**}{%d} """ % taille ) modeleEvent = u""" \\parcoursevent{**nosem**}{**nomsem**}{**descr**} """ codelatexFin = u""" \\end{parcourstimeline} """ reslatex = codelatexDebut reslatex = reslatex.replace("**debut**", etudiant["entree"]) reslatex = reslatex.replace("**fin**", str(etudiant["promo"])) reslatex = reslatex.replace("**nbreSemestres**", str(etudiant["nbSemestres"])) # Tri du parcours par ordre croissant : de la forme descr, nom sem date-date parcours = etudiant["parcours"][::-1] # EV: XXX je ne comprend pas ce commentaire ? for no_sem in range(etudiant["nbSemestres"]): descr = modeleEvent nom_semestre_dans_parcours = parcours[no_sem]["nom_semestre_dans_parcours"] descr = descr.replace(u"**nosem**", str(no_sem + 1)) if no_sem % 2 == 0: descr = descr.replace(u"**nomsem**", nom_semestre_dans_parcours) descr = descr.replace(u"**descr**", u"") else: descr = descr.replace(u"**nomsem**", u"") descr = descr.replace(u"**descr**", nom_semestre_dans_parcours) reslatex += descr reslatex += codelatexFin return reslatex # ---------------------------------------------------------------------------------------- def interprete_tag_latex(tag): """Découpe les tags latex de la forme S1:groupe:dut:min et renvoie si possible le résultat sous la forme d'un quadruplet. """ infotag = tag.split(":") if len(infotag) == 4: return ( infotag[0].upper(), infotag[1].lower(), infotag[2].lower(), infotag[3].lower(), ) else: return (None, None, None, None) # ---------------------------------------------------------------------------------------- def get_code_latex_avis_etudiant( donnees_etudiant, un_avis_latex, annotationPE, footer_latex, prefs ): """ Renvoie le code latex permettant de générer l'avis d'un étudiant en utilisant ses donnees_etudiant contenu dans le dictionnaire de synthèse du jury PE et en suivant un fichier modele donné result: chaine unicode """ if not donnees_etudiant or not un_avis_latex: # Cas d'un template vide return annotationPE if annotationPE else u"" # Le template latex (corps + footer) code = un_avis_latex + "\n\n" + footer_latex # Recherche des tags dans le fichier tags_latex = get_tags_latex(code) if DEBUG: log("Les tags" + str(tags_latex)) # Interprète et remplace chaque tags latex par les données numériques de l'étudiant (y compris les # tags "macros" tels que parcourstimeline for tag_latex in tags_latex: # les tags numériques valeur = DONNEE_MANQUANTE if ":" in tag_latex: (aggregat, groupe, tag_scodoc, champ) = interprete_tag_latex(tag_latex) valeur = str_from_syntheseJury( donnees_etudiant, aggregat, groupe, tag_scodoc, champ ) # La macro parcourstimeline elif tag_latex == u"parcourstimeline": valeur = comp_latex_parcourstimeline( donnees_etudiant, donnees_etudiant["promo"] ) # Le tag annotationPE elif tag_latex == u"annotation": valeur = annotationPE # Le tag bilanParTag elif tag_latex == u"bilanParTag": valeur = get_bilanParTag(donnees_etudiant) # Les tags "simples": par ex. nom, prenom, civilite, ... else: if tag_latex in donnees_etudiant: valeur = donnees_etudiant[tag_latex] elif tag_latex in prefs: # les champs **NomResponsablePE**, ... valeur = pe_tools.escape_for_latex(prefs[tag_latex]) # Vérification des pb d'encodage (debug) # assert isinstance(tag_latex, unicode) # assert isinstance(valeur, unicode) # Substitution code = code.replace("**" + tag_latex + "**", valeur) return code # ---------------------------------------------------------------------------------------- def get_annotation_PE(context, etudid, tag_annotation_pe): """Renvoie l'annotation PE dans la liste de ces annotations ; Cette annotation est reconnue par la présence d'un tag **PE** (cf. .get_preferences -> pe_tag_annotation_avis_latex). Result: chaine unicode """ if tag_annotation_pe: cnx = ndb.GetDBConnexion() annotations = sco_etud.etud_annotations_list( cnx, args={"etudid": etudid} ) # Les annotations de l'étudiant annotationsPE = [] exp = re.compile(r"^" + tag_annotation_pe) for a in annotations: commentaire = scu.unescape_html(a["comment"]) if exp.match(commentaire): # tag en début de commentaire ? a["comment_u"] = commentaire # unicode, HTML non quoté annotationsPE.append( a ) # sauvegarde l'annotation si elle contient le tag if annotationsPE: # Si des annotations existent, prend la plus récente annotationPE = sorted(annotationsPE, key=lambda a: a["date"], reverse=True)[ 0 ]["comment_u"] annotationPE = exp.sub( u"", annotationPE ) # Suppression du tag d'annotation PE annotationPE = annotationPE.replace(u"\r", u"") # Suppression des \r annotationPE = annotationPE.replace( u"<br/>", u"\n\n" ) # Interprète les retours chariots html return annotationPE return u"" # pas d'annotations # ---------------------------------------------------------------------------------------- def str_from_syntheseJury(donnees_etudiant, aggregat, groupe, tag_scodoc, champ): """Extrait du dictionnaire de synthèse du juryPE pour un étudiant donnée, une valeur indiquée par un champ ; si champ est une liste, renvoie la liste des valeurs extraites. Result: chaine unicode ou liste de chaines unicode """ if isinstance(champ, list): return [ str_from_syntheseJury(donnees_etudiant, aggregat, groupe, tag_scodoc, chp) for chp in champ ] else: # champ = str à priori valeur = DONNEE_MANQUANTE if ( (aggregat in donnees_etudiant) and (groupe in donnees_etudiant[aggregat]) and (tag_scodoc in donnees_etudiant[aggregat][groupe]) ): donnees_numeriques = donnees_etudiant[aggregat][groupe][tag_scodoc] if champ == "rang": valeur = u"%s/%d" % ( donnees_numeriques[ pe_tagtable.TableTag.FORMAT_DONNEES_ETUDIANTS.index("rang") ], donnees_numeriques[ pe_tagtable.TableTag.FORMAT_DONNEES_ETUDIANTS.index( "nbinscrits" ) ], ) elif champ in pe_tagtable.TableTag.FORMAT_DONNEES_ETUDIANTS: indice_champ = pe_tagtable.TableTag.FORMAT_DONNEES_ETUDIANTS.index( champ ) if ( len(donnees_numeriques) > indice_champ and donnees_numeriques[indice_champ] != None ): if isinstance( donnees_numeriques[indice_champ], float ): # valeur numérique avec formattage unicode valeur = u"%2.2f" % donnees_numeriques[indice_champ] else: valeur = u"%s" % donnees_numeriques[indice_champ] return valeur # ---------------------------------------------------------------------------------------- def get_bilanParTag(donnees_etudiant, groupe="groupe"): """Renvoie le code latex d'un tableau récapitulant, pour tous les tags trouvés dans les données étudiants, ses résultats. result: chaine unicode """ entete = [ ( agg, pe_jurype.JuryPE.PARCOURS[agg]["affichage_court"], pe_jurype.JuryPE.PARCOURS[agg]["ordre"], ) for agg in pe_jurype.JuryPE.PARCOURS ] entete = sorted(entete, key=lambda t: t[2]) lignes = [] valeurs = {"note": [], "rang": []} for (indice_aggregat, (aggregat, intitule, _)) in enumerate(entete): # print("> " + aggregat) # listeTags = jury.get_allTagForAggregat(aggregat) # les tags de l'aggrégat listeTags = [ tag for tag in donnees_etudiant[aggregat][groupe].keys() if tag != "dut" ] # for tag in listeTags: if tag not in lignes: lignes.append(tag) valeurs["note"].append( [""] * len(entete) ) # Ajout d'une ligne de données valeurs["rang"].append( [""] * len(entete) ) # Ajout d'une ligne de données indice_tag = lignes.index(tag) # l'indice de ligne du tag # print(" --- " + tag + "(" + str(indice_tag) + "," + str(indice_aggregat) + ")") [note, rang] = str_from_syntheseJury( donnees_etudiant, aggregat, groupe, tag, ["note", "rang"] ) valeurs["note"][indice_tag][indice_aggregat] = "" + note + "" valeurs["rang"][indice_tag][indice_aggregat] = ( ("\\textit{" + rang + "}") if note else "" ) # rang masqué si pas de notes code_latex = u"\\begin{tabular}{|c|" + "|c" * (len(entete)) + "|}\n" code_latex += u"\\hline \n" code_latex += ( u" & " + " & ".join(["\\textbf{" + intitule + "}" for (agg, intitule, _) in entete]) + " \\\\ \n" ) code_latex += u"\\hline" code_latex += u"\\hline \n" for (i, ligne_val) in enumerate(valeurs["note"]): titre = lignes[i] # règle le pb d'encodage code_latex += ( u"\\textbf{" + titre + u"} & " + " & ".join(ligne_val) + u"\\\\ \n" ) code_latex += ( u" & " + u" & ".join( [u"{\\scriptsize " + clsmt + u"}" for clsmt in valeurs["rang"][i]] ) + u"\\\\ \n" ) code_latex += u"\\hline \n" code_latex += u"\\end{tabular}" return code_latex # ---------------------------------------------------------------------------------------- def get_avis_poursuite_par_etudiant( context, jury, etudid, template_latex, tag_annotation_pe, footer_latex, prefs ): """Renvoie un nom de fichier et le contenu de l'avis latex d'un étudiant dont l'etudid est fourni. result: [ chaine unicode, chaine unicode ] """ if pe_tools.PE_DEBUG: pe_tools.pe_print(jury.syntheseJury[etudid]["nom"] + " " + str(etudid)) civilite_str = jury.syntheseJury[etudid]["civilite_str"] nom = jury.syntheseJury[etudid]["nom"].replace(" ", "-") prenom = jury.syntheseJury[etudid]["prenom"].replace(" ", "-") nom_fichier = ( u"avis_poursuite_" + pe_tools.remove_accents(nom) + "_" + pe_tools.remove_accents(prenom) + "_" + str(etudid) ) if pe_tools.PE_DEBUG: pe_tools.pe_print("fichier latex =" + nom_fichier, type(nom_fichier)) # Entete (commentaire) contenu_latex = ( u"%% ---- Etudiant: " + civilite_str + " " + nom + " " + prenom + u"\n" ) # les annnotations annotationPE = get_annotation_PE( context, etudid, tag_annotation_pe=tag_annotation_pe ) if pe_tools.PE_DEBUG: pe_tools.pe_print(annotationPE, type(annotationPE)) # le LaTeX avis = get_code_latex_avis_etudiant( jury.syntheseJury[etudid], template_latex, annotationPE, footer_latex, prefs ) # if pe_tools.PE_DEBUG: pe_tools.pe_print(avis, type(avis)) contenu_latex += avis + "\n" return [nom_fichier, contenu_latex] def get_templates_from_distrib(template="avis"): """Récupère le template (soit un_avis.tex soit le footer.tex) à partir des fichiers mémorisés dans la distrib des avis pe (distrib local ou par défaut et le renvoie""" if template == "avis": pe_local_tmpl = pe_tools.PE_LOCAL_AVIS_LATEX_TMPL pe_default_tmpl = pe_tools.PE_DEFAULT_AVIS_LATEX_TMPL elif template == "footer": pe_local_tmpl = pe_tools.PE_LOCAL_FOOTER_TMPL pe_default_tmpl = pe_tools.PE_DEFAULT_FOOTER_TMPL if template in ["avis", "footer"]: # pas de preference pour le template: utilise fichier du serveur if os.path.exists(pe_local_tmpl): template_latex = get_code_latex_from_modele(pe_local_tmpl) else: if os.path.exists(pe_default_tmpl): template_latex = get_code_latex_from_modele(pe_default_tmpl) else: template_latex = "" # fallback: avis vides return template_latex # ---------------------------------------------------------------------------------------- def table_syntheseAnnotationPE(context, syntheseJury, tag_annotation_pe): """Génère un fichier excel synthétisant les annotations PE telles qu'inscrites dans les fiches de chaque étudiant""" sT = SeqGenTable() # le fichier excel à générer # Les etudids des étudiants à afficher, triés par ordre alphabétiques de nom+prénom donnees_tries = sorted( [ (etudid, syntheseJury[etudid]["nom"] + " " + syntheseJury[etudid]["prenom"]) for etudid in syntheseJury.keys() ], key=lambda c: c[1], ) etudids = [e[0] for e in donnees_tries] if not etudids: # Si pas d'étudiants T = GenTable( columns_ids=["pas d'étudiants"], rows=[], titles={"pas d'étudiants": "pas d'étudiants"}, html_sortable=True, xls_sheet_name="dut", ) sT.add_genTable("Annotation PE", T) return sT # Si des étudiants maxParcours = max( [syntheseJury[etudid]["nbSemestres"] for etudid in etudids] ) # le nombre de semestre le + grand infos = ["civilite", "nom", "prenom", "age", "nbSemestres"] entete = ["etudid"] entete.extend(infos) entete.extend(["P%d" % i for i in range(1, maxParcours + 1)]) # ajout du parcours entete.append("Annotation PE") columns_ids = entete # les id et les titres de colonnes sont ici identiques titles = {i: i for i in columns_ids} rows = [] for ( etudid ) in etudids: # parcours des étudiants par ordre alphabétique des nom+prénom e = syntheseJury[etudid] # Les info générales: row = { "etudid": etudid, "civilite": e["civilite"], "nom": e["nom"], "prenom": e["prenom"], "age": e["age"], "nbSemestres": e["nbSemestres"], } # Les parcours: P1, P2, ... n = 1 for p in e["parcours"]: row["P%d" % n] = p["titreannee"] n += 1 # L'annotation PE annotationPE = get_annotation_PE( context, etudid, tag_annotation_pe=tag_annotation_pe ) row["Annotation PE"] = annotationPE if annotationPE else "" rows.append(row) T = GenTable( columns_ids=columns_ids, rows=rows, titles=titles, html_sortable=True, xls_sheet_name="Annotation PE", ) sT.add_genTable("Annotation PE", T) return sT