1
0
forked from ScoDoc/ScoDoc
ScoDoc-Front/app/scodoc/sco_recapcomplet.py

481 lines
17 KiB
Python
Raw Normal View History

2020-09-26 16:19:37 +02:00
# -*- mode: python -*-
# -*- coding: utf-8 -*-
##############################################################################
#
# Gestion scolarite IUT
#
2023-01-02 13:16:27 +01:00
# Copyright (c) 1999 - 2023 Emmanuel Viennet. All rights reserved.
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
#
##############################################################################
2022-02-06 16:09:17 +01:00
"""Tableau récapitulatif des notes d'un semestre
2020-09-26 16:19:37 +02:00
"""
2021-02-04 20:02:44 +01:00
import datetime
import time
2021-07-10 17:40:40 +02:00
from xml.etree import ElementTree
2020-09-26 16:19:37 +02:00
from flask import g, request
from flask import abort, url_for
2021-08-29 19:57:32 +02:00
from app import log
2021-12-11 20:27:58 +01:00
from app.but import bulletin_but
from app.comp import res_sem
from app.comp.res_common import ResultatsSemestre
from app.comp.res_compat import NotesTableCompat
2021-12-17 21:59:28 +01:00
from app.models import FormSemestre
from app.models.etudiants import Identite
2021-12-11 20:27:58 +01:00
2022-04-06 18:51:01 +02:00
from app.scodoc.gen_tables import GenTable
2021-12-11 20:27:58 +01:00
import app.scodoc.sco_utils as scu
from app.scodoc import html_sco_header
from app.scodoc import sco_bulletins_json
from app.scodoc import sco_bulletins_xml
2022-04-05 22:23:55 +02:00
from app.scodoc import sco_cache
from app.scodoc import sco_evaluations
2022-04-06 18:51:01 +02:00
from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc import sco_formsemestre
from app.scodoc import sco_formsemestre_status
from app.scodoc import sco_permissions_check
from app.scodoc import sco_preferences
2023-02-03 22:39:45 +01:00
from app.tables.recap import TableRecap
2020-09-26 16:19:37 +02:00
def formsemestre_recapcomplet(
formsemestre_id=None,
2022-06-29 16:30:01 +02:00
mode_jury=False,
2020-09-26 16:19:37 +02:00
tabformat="html",
sortcol=None,
xml_with_decisions=False,
force_publishing=True,
selected_etudid=None,
2020-09-26 16:19:37 +02:00
):
"""Page récapitulant les notes d'un semestre.
Grand tableau récapitulatif avec toutes les notes de modules
pour tous les étudiants, les moyennes par UE et générale,
trié par moyenne générale décroissante.
2022-04-06 18:51:01 +02:00
tabformat:
html : page web
evals : page web, avec toutes les évaluations dans le tableau
xls, xlsx: export excel simple
xlsall : export excel simple, avec toutes les évaluations dans le tableau
csv : export CSV, avec toutes les évaluations
xml, json : concaténation de tous les bulletins, au format demandé
pdf : NON SUPPORTE (car tableau trop grand pour générer un pdf utilisable)
2022-06-29 16:30:01 +02:00
mode_jury: cache modules, affiche lien saisie decision jury
xml_with_decisions: publie décisions de jury dans xml et json
force_publishing: publie les xml et json même si bulletins non publiés
selected_etudid: etudid sélectionné (pour scroller au bon endroit)
2020-09-26 16:19:37 +02:00
"""
if not isinstance(formsemestre_id, int):
abort(404)
2021-12-11 20:27:58 +01:00
formsemestre = FormSemestre.query.get_or_404(formsemestre_id)
2022-05-09 18:32:54 +02:00
file_formats = {"csv", "json", "xls", "xlsx", "xlsall", "xml"}
supported_formats = file_formats | {"html", "evals"}
2022-05-09 18:32:54 +02:00
if tabformat not in supported_formats:
raise ScoValueError(f"Format non supporté: {tabformat}")
is_file = tabformat in file_formats
2022-06-29 16:30:01 +02:00
mode_jury = int(mode_jury)
2020-09-26 16:19:37 +02:00
xml_with_decisions = int(xml_with_decisions)
force_publishing = int(force_publishing)
2022-05-09 18:32:54 +02:00
data = _do_formsemestre_recapcomplet(
formsemestre_id,
format=tabformat,
2022-06-29 16:30:01 +02:00
mode_jury=mode_jury,
sortcol=sortcol,
xml_with_decisions=xml_with_decisions,
force_publishing=force_publishing,
selected_etudid=selected_etudid,
2020-09-26 16:19:37 +02:00
)
if is_file:
return data
H = [
html_sco_header.sco_header(
2022-04-21 16:39:17 +02:00
page_title=f"{formsemestre.sem_modalite()}: moyennes",
no_side_bar=True,
init_qtip=True,
javascripts=["js/etud_info.js", "js/table_recap.js"],
),
sco_formsemestre_status.formsemestre_status_head(
formsemestre_id=formsemestre_id
),
]
if len(formsemestre.inscriptions) > 0:
H.append(
f"""<form name="f" method="get" action="{request.base_url}">
<input type="hidden" name="formsemestre_id" value="{formsemestre_id}"></input>
"""
)
2022-06-29 16:30:01 +02:00
if mode_jury:
2020-09-26 16:19:37 +02:00
H.append(
2022-06-29 16:30:01 +02:00
f'<input type="hidden" name="mode_jury" value="{mode_jury}"></input>'
2020-09-26 16:19:37 +02:00
)
H.append(
'<select name="tabformat" onchange="document.f.submit()" class="noprint">'
)
for (format, label) in (
("html", "Tableau"),
("evals", "Avec toutes les évaluations"),
2022-05-10 20:32:25 +02:00
("xlsx", "Excel (non formaté)"),
("xlsall", "Excel avec évaluations"),
("xml", "Bulletins XML (obsolète)"),
("json", "Bulletins JSON"),
):
if format == tabformat:
selected = " selected"
else:
selected = ""
H.append(f'<option value="{format}"{selected}>{label}</option>')
H.append("</select>")
H.append(
f"""&nbsp;(cliquer sur un nom pour afficher son bulletin ou <a class="stdlink"
href="{url_for('notes.formsemestre_bulletins_pdf',
scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre_id)
}">ici avoir le classeur papier</a>)
"""
)
H.append(data)
if len(formsemestre.inscriptions) > 0:
H.append("</form>")
H.append(
f"""<p><a class="stdlink" href="{url_for('notes.formsemestre_pvjury',
scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre_id)
}">Voir les décisions du jury</a></p>"""
)
if sco_permissions_check.can_validate_sem(formsemestre_id):
H.append("<p>")
2022-06-29 16:30:01 +02:00
if mode_jury:
2022-03-27 23:19:17 +02:00
H.append(
f"""<p><a class="stdlink" href="{url_for('notes.formsemestre_validation_auto',
scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre_id)
}">Calcul automatique des décisions du jury</a>
</p><a class="stdlink" href="{url_for('notes.formsemestre_jury_but_erase',
scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre_id, only_one_sem=1)
}">Effacer <em>toutes</em> les décisions de jury du semestre</a>
<p>
</p>
"""
)
else:
H.append(
f"""<a class="stdlink" href="{url_for('notes.formsemestre_recapcomplet',
2022-06-29 16:30:01 +02:00
scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre_id, mode_jury=1)
}">Saisie des décisions du jury</a>"""
2022-03-27 23:19:17 +02:00
)
H.append("</p>")
if sco_preferences.get_preference("use_ue_coefs", formsemestre_id):
H.append(
"""
<p class="infop">utilise les coefficients d'UE pour calculer la moyenne générale.</p>
"""
)
H.append(html_sco_header.sco_footer())
# HTML or binary data ?
if len(H) > 1:
return "".join(H)
elif len(H) == 1:
return H[0]
else:
return H
2020-09-26 16:19:37 +02:00
def _do_formsemestre_recapcomplet(
2020-09-26 16:19:37 +02:00
formsemestre_id=None,
format="html", # html, xml, xls, xlsall, json
2020-09-26 16:19:37 +02:00
xml_nodate=False, # format XML sans dates (sert pour debug cache: comparaison de XML)
2022-06-29 16:30:01 +02:00
mode_jury=False, # saisie décisions jury
2020-09-26 16:19:37 +02:00
sortcol=None, # indice colonne a trier dans table T
xml_with_decisions=False,
force_publishing=True,
selected_etudid=None,
2020-09-26 16:19:37 +02:00
):
"""Calcule et renvoie le tableau récapitulatif."""
2022-03-26 23:33:57 +01:00
formsemestre = FormSemestre.query.get_or_404(formsemestre_id)
2022-04-06 18:51:01 +02:00
filename = scu.sanitize_filename(
f"""recap-{formsemestre.titre_num()}-{time.strftime("%Y-%m-%d")}"""
)
if format == "html" or format == "evals":
res: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
2022-04-06 18:51:01 +02:00
data = gen_formsemestre_recapcomplet_html(
formsemestre,
res,
include_evaluations=(format == "evals"),
2022-06-29 16:30:01 +02:00
mode_jury=mode_jury,
2022-04-06 18:51:01 +02:00
filename=filename,
selected_etudid=selected_etudid,
2022-03-26 23:33:57 +01:00
)
2020-09-26 16:19:37 +02:00
return data
2022-04-06 18:51:01 +02:00
elif format.startswith("xls") or format == "csv":
res: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
include_evaluations = format in {"xlsall", "csv "}
if format != "csv":
format = "xlsx"
data, filename = gen_formsemestre_recapcomplet_excel(
formsemestre,
res,
include_evaluations=include_evaluations,
format=format,
filename=filename,
)
2022-04-06 18:51:01 +02:00
return scu.send_file(data, filename=filename, mime=scu.get_mime_suffix(format))
elif format == "xml":
data = gen_formsemestre_recapcomplet_xml(
formsemestre_id,
xml_nodate,
xml_with_decisions=xml_with_decisions,
force_publishing=force_publishing,
2020-09-26 16:19:37 +02:00
)
2022-04-06 18:51:01 +02:00
return scu.send_file(data, filename=filename, suffix=scu.XML_SUFFIX)
elif format == "json":
2022-04-06 18:51:01 +02:00
data = gen_formsemestre_recapcomplet_json(
formsemestre_id,
xml_nodate=xml_nodate,
xml_with_decisions=xml_with_decisions,
force_publishing=force_publishing,
)
2022-04-06 18:51:01 +02:00
return scu.sendJSON(data, filename=filename)
2022-04-06 18:51:01 +02:00
raise ScoValueError(f"Format demandé invalide: {format}")
2020-09-26 16:19:37 +02:00
2022-04-06 18:51:01 +02:00
def gen_formsemestre_recapcomplet_xml(
formsemestre_id,
xml_nodate,
xml_with_decisions=False,
force_publishing=True,
2022-04-06 18:51:01 +02:00
) -> str:
"XML export: liste tous les bulletins XML."
2022-02-12 22:57:46 +01:00
formsemestre = FormSemestre.query.get_or_404(formsemestre_id)
nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
2020-09-26 16:19:37 +02:00
T = nt.get_table_moyennes_triees()
if not T:
return "", "", "xml"
if xml_nodate:
docdate = ""
else:
docdate = datetime.datetime.now().isoformat()
2021-07-10 17:40:40 +02:00
doc = ElementTree.Element(
2021-08-22 17:18:15 +02:00
"recapsemestre", formsemestre_id=str(formsemestre_id), date=docdate
2021-07-10 17:40:40 +02:00
)
evals = sco_evaluations.do_evaluation_etat_in_sem(formsemestre_id)
2021-07-10 17:40:40 +02:00
doc.append(
ElementTree.Element(
"evals_info",
nb_evals_completes=str(evals["nb_evals_completes"]),
nb_evals_en_cours=str(evals["nb_evals_en_cours"]),
nb_evals_vides=str(evals["nb_evals_vides"]),
date_derniere_note=str(evals["last_modif"]),
)
2020-09-26 16:19:37 +02:00
)
for t in T:
etudid = t[-1]
sco_bulletins_xml.make_xml_formsemestre_bulletinetud(
formsemestre_id,
etudid,
doc=doc,
force_publishing=force_publishing,
2020-09-26 16:19:37 +02:00
xml_nodate=xml_nodate,
xml_with_decisions=xml_with_decisions,
)
2022-04-06 18:51:01 +02:00
return ElementTree.tostring(doc).decode(scu.SCO_ENCODING)
2022-04-06 18:51:01 +02:00
def gen_formsemestre_recapcomplet_json(
formsemestre_id,
xml_nodate=False,
xml_with_decisions=False,
force_publishing=True,
2022-04-06 18:51:01 +02:00
) -> dict:
"""JSON export: liste tous les bulletins JSON
:param xml_nodate(bool): indique la date courante (attribut docdate)
:param force_publishing: donne les bulletins même si non "publiés sur portail"
2022-04-06 18:51:01 +02:00
:returns: dict
"""
2021-12-17 21:59:28 +01:00
formsemestre = FormSemestre.query.get_or_404(formsemestre_id)
is_apc = formsemestre.formation.is_apc()
if xml_nodate:
docdate = ""
else:
docdate = datetime.datetime.now().isoformat()
evals = sco_evaluations.do_evaluation_etat_in_sem(formsemestre_id)
2022-04-06 18:51:01 +02:00
js_data = {
"docdate": docdate,
"formsemestre_id": formsemestre_id,
"evals_info": {
"nb_evals_completes": evals["nb_evals_completes"],
"nb_evals_en_cours": evals["nb_evals_en_cours"],
"nb_evals_vides": evals["nb_evals_vides"],
"date_derniere_note": evals["last_modif"],
},
"bulletins": [],
}
2022-04-06 18:51:01 +02:00
bulletins = js_data["bulletins"]
2022-02-12 22:57:46 +01:00
formsemestre = FormSemestre.query.get_or_404(formsemestre_id)
nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
T = nt.get_table_moyennes_triees()
for t in T:
etudid = t[-1]
2021-12-17 21:59:28 +01:00
if is_apc:
etud = Identite.query.get(etudid)
2021-12-24 00:08:25 +01:00
r = bulletin_but.BulletinBUT(formsemestre)
2021-12-17 21:59:28 +01:00
bul = r.bulletin_etud(etud, formsemestre)
else:
bul = sco_bulletins_json.formsemestre_bulletinetud_published_dict(
formsemestre_id,
etudid,
force_publishing=force_publishing,
xml_with_decisions=xml_with_decisions,
)
2021-12-17 21:59:28 +01:00
bulletins.append(bul)
2022-04-06 18:51:01 +02:00
return js_data
def formsemestres_bulletins(annee_scolaire):
"""Tous les bulletins des semestres publiés des semestres de l'année indiquée.
2022-02-09 23:22:00 +01:00
:param annee_scolaire(int): année de début de l'année scolaire
:returns: JSON
"""
2022-04-06 18:51:01 +02:00
js_list = []
2021-08-19 10:28:35 +02:00
sems = sco_formsemestre.list_formsemestre_by_etape(annee_scolaire=annee_scolaire)
log("formsemestres_bulletins(%s): %d sems" % (annee_scolaire, len(sems)))
for sem in sems:
2022-04-06 18:51:01 +02:00
js_data = gen_formsemestre_recapcomplet_json(
sem["formsemestre_id"], force_publishing=False
)
2022-04-06 18:51:01 +02:00
js_list.append(js_data)
2022-04-06 18:51:01 +02:00
return scu.sendJSON(js_list)
2022-03-26 23:33:57 +01:00
def gen_formsemestre_recapcomplet_html(
2022-04-06 18:51:01 +02:00
formsemestre: FormSemestre,
res: NotesTableCompat,
include_evaluations=False,
2022-06-29 16:30:01 +02:00
mode_jury=False,
2022-04-06 18:51:01 +02:00
filename="",
selected_etudid=None,
):
2022-03-26 23:33:57 +01:00
"""Construit table recap pour le BUT
Cache le résultat pour le semestre (sauf en mode jury).
2022-06-29 16:30:01 +02:00
Si mode_jury, cache colonnes modules et affiche un lien vers la saisie de la décision de jury
2022-03-26 23:33:57 +01:00
Return: data, filename
2022-04-06 18:51:01 +02:00
data est une chaine, le <div>...</div> incluant le tableau.
2022-03-26 23:33:57 +01:00
"""
table_html = None
2022-06-29 16:30:01 +02:00
if not (mode_jury or selected_etudid):
2022-04-05 22:23:55 +02:00
if include_evaluations:
table_html = sco_cache.TableRecapWithEvalsCache.get(formsemestre.id)
2022-04-05 22:23:55 +02:00
else:
table_html = sco_cache.TableRecapCache.get(formsemestre.id)
2022-07-11 18:31:58 +02:00
# en mode jury ne cache pas la table html
2022-06-29 16:30:01 +02:00
if mode_jury or (table_html is None):
table_html = _gen_formsemestre_recapcomplet_html(
formsemestre,
res,
include_evaluations,
2022-06-29 16:30:01 +02:00
mode_jury,
filename,
selected_etudid=selected_etudid,
)
2022-06-29 16:30:01 +02:00
if not mode_jury:
if include_evaluations:
sco_cache.TableRecapWithEvalsCache.set(formsemestre.id, table_html)
else:
sco_cache.TableRecapCache.set(formsemestre.id, table_html)
2022-04-05 22:23:55 +02:00
2022-04-06 18:51:01 +02:00
return table_html
2022-04-05 22:23:55 +02:00
def _gen_formsemestre_recapcomplet_html(
formsemestre: FormSemestre,
res: ResultatsSemestre,
2022-04-05 22:23:55 +02:00
include_evaluations=False,
2022-06-29 16:30:01 +02:00
mode_jury=False,
2022-04-05 22:23:55 +02:00
filename: str = "",
selected_etudid=None,
2022-04-05 22:23:55 +02:00
) -> str:
"""Génère le html"""
2023-02-03 22:39:45 +01:00
table = TableRecap(
res,
2022-06-29 16:30:01 +02:00
convert_values=True,
include_evaluations=include_evaluations,
mode_jury=mode_jury,
)
2023-02-03 22:39:45 +01:00
2023-01-29 21:52:39 +01:00
table.data["filename"] = filename
table.select_row(selected_etudid)
return f"""
<div class="table_recap">
2023-01-22 20:39:46 +01:00
{
2023-01-29 21:52:39 +01:00
'<div class="message">aucun étudiant !</div>'
if table.is_empty()
else table.html(
extra_classes=[
2023-01-22 20:39:46 +01:00
'table_recap',
'apc' if formsemestre.formation.is_apc() else 'classic',
'jury' if mode_jury else ''
2023-01-29 21:52:39 +01:00
])
2023-01-22 20:39:46 +01:00
}
2023-01-29 21:52:39 +01:00
</div>
"""
2022-04-06 18:51:01 +02:00
def gen_formsemestre_recapcomplet_excel(
formsemestre: FormSemestre,
res: NotesTableCompat,
include_evaluations=False,
filename: str = "",
format="xls",
) -> tuple:
"""Génère le tableau recap en excel (xlsx) ou CSV.
Utilisé pour archives et autres besoins particuliers (API).
Attention: le tableau exporté depuis la page html est celui généré en js par DataTables,
et non celui-ci.
"""
suffix = scu.CSV_SUFFIX if format == "csv" else scu.XLSX_SUFFIX
filename += suffix
2023-02-03 22:39:45 +01:00
# XXX TODO A ADAPTER XXX !!! !!!
table = TableRecap(
res,
convert_values=False,
include_evaluations=include_evaluations,
2022-04-06 18:51:01 +02:00
preferences=sco_preferences.SemPreferences(formsemestre_id=formsemestre.id),
)
2023-02-03 22:39:45 +01:00
# tab = GenTable(
# columns_ids=column_ids,
# titles=titles,
# rows=rows + footer_rows,
# preferences=sco_preferences.SemPreferences(formsemestre_id=formsemestre.id),
# )
return table.gen(format=format), filename