ScoDoc/app/scodoc/sco_bulletins_json.py

522 lines
19 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
#
##############################################################################
"""Génération du bulletin en format JSON
2020-09-26 16:19:37 +02:00
"""
2021-02-01 16:23:11 +01:00
import datetime
2020-09-26 16:19:37 +02:00
import json
2022-08-08 10:34:13 +02:00
from flask import abort
from app import ScoDocJSONEncoder
2022-02-09 23:22:00 +01:00
from app.comp import res_sem
from app.comp.res_compat import NotesTableCompat
from app.models import but_validations
from app.models import Matiere, ModuleImpl, UniteEns
2021-12-17 21:36:34 +01:00
from app.models.etudiants import Identite
from app.models.formsemestre import FormSemestre
import app.scodoc.sco_utils as scu
import app.scodoc.notesdb as ndb
from app.scodoc import sco_abs
from app.scodoc import sco_edit_ue
from app.scodoc import sco_evaluations
from app.scodoc import sco_evaluation_db
from app.scodoc import sco_formsemestre
from app.scodoc import sco_groups
from app.scodoc import sco_photos
from app.scodoc import sco_preferences
from app.scodoc import sco_etud
from app.scodoc.sco_preferences import SemPreferences
from app.scodoc.sco_xml import quote_xml_attr
2020-09-26 16:19:37 +02:00
# -------- Bulletin en JSON
def make_json_formsemestre_bulletinetud(
formsemestre_id: int,
etudid: int,
2020-09-26 16:19:37 +02:00
xml_with_decisions=False,
version="long",
force_publishing=False, # force publication meme si semestre non publie sur "portail"
) -> str:
2020-09-26 16:19:37 +02:00
"""Renvoie bulletin en chaine JSON"""
d = formsemestre_bulletinetud_published_dict(
formsemestre_id,
etudid,
force_publishing=force_publishing,
xml_with_decisions=xml_with_decisions,
version=version,
)
return json.dumps(d, cls=ScoDocJSONEncoder)
2020-09-26 16:19:37 +02:00
# (fonction séparée: n'utilise pas formsemestre_bulletinetud_dict()
# pour simplifier le code, mais attention a la maintenance !)
#
def formsemestre_bulletinetud_published_dict(
formsemestre_id,
etudid,
force_publishing=False,
xml_nodate=False,
xml_with_decisions=False, # inclue les decisions même si non publiées
version="long",
) -> dict:
2020-09-26 16:19:37 +02:00
"""Dictionnaire representant les informations _publiees_ du bulletin de notes
Utilisé pour JSON, devrait l'être aussi pour XML. (todo)
version:
short (sans les évaluations)
long (avec les évaluations)
short_mat (sans évaluations, et structuration en matières)
long_mat (avec évaluations, et structuration en matières)
2020-09-26 16:19:37 +02:00
"""
from app.scodoc import sco_bulletins
2020-09-26 16:19:37 +02:00
with_matieres = False
if version.endswith("_mat"):
version = version[:-4] # enlève le "_mat"
with_matieres = True
formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
prefs = sco_preferences.SemPreferences(formsemestre_id)
etud = Identite.get_etud(etudid)
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
2022-02-09 23:22:00 +01:00
nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
2022-08-08 10:34:13 +02:00
if not etudid in nt.identdict:
abort(404, "etudiant non inscrit dans ce semestre")
d = {"type": "classic", "version": "0"}
2021-08-11 00:36:07 +02:00
if (not sem["bul_hide_xml"]) or force_publishing:
2022-01-25 13:24:08 +01:00
published = True
2020-09-26 16:19:37 +02:00
else:
2022-01-25 13:24:08 +01:00
published = False
2020-09-26 16:19:37 +02:00
if xml_nodate:
docdate = ""
else:
docdate = datetime.datetime.now().isoformat()
el = {
"etudid": etudid,
"formsemestre_id": formsemestre_id,
"date": docdate,
"publie": published,
"etapes": sem["etapes"],
}
# backward compat:
if sem["etapes"]:
el["etape_apo"] = sem["etapes"][0] or ""
n = 2
for et in sem["etapes"][1:]:
el["etape_apo" + str(n)] = et or ""
n += 1
d.update(**el)
# Infos sur l'etudiant
2021-08-22 13:24:36 +02:00
etudinfo = sco_etud.get_etud_info(etudid=etudid, filled=True)[0]
2020-09-26 16:19:37 +02:00
d["etudiant"] = dict(
etudid=etudid,
code_nip=etudinfo["code_nip"],
code_ine=etudinfo["code_ine"],
nom=quote_xml_attr(etudinfo["nom"]),
prenom=quote_xml_attr(etudinfo["prenom"]),
civilite=quote_xml_attr(etudinfo["civilite_str"]),
photo_url=quote_xml_attr(sco_photos.etud_photo_url(etudinfo, fast=True)),
email=quote_xml_attr(etudinfo["email"]),
emailperso=quote_xml_attr(etudinfo["emailperso"]),
2020-09-26 16:19:37 +02:00
)
d["etudiant"]["sexe"] = d["etudiant"]["civilite"] # backward compat for our clients
2020-09-26 16:19:37 +02:00
# Disponible pour publication ?
2022-07-05 20:40:21 +02:00
d["publie"] = published
2020-09-26 16:19:37 +02:00
if not published:
return d # stop !
etat_inscription = etud.inscription_etat(formsemestre.id)
2021-12-17 21:36:34 +01:00
if etat_inscription != scu.INSCRIT:
d.update(dict_decision_jury(etud, formsemestre, with_decisions=True))
2021-12-17 21:36:34 +01:00
return d
2020-09-26 16:19:37 +02:00
# Groupes:
2021-08-19 10:28:35 +02:00
partitions = sco_groups.get_partitions_list(formsemestre_id, with_default=False)
2020-09-26 16:19:37 +02:00
partitions_etud_groups = {} # { partition_id : { etudid : group } }
for partition in partitions:
pid = partition["partition_id"]
2021-08-19 10:28:35 +02:00
partitions_etud_groups[pid] = sco_groups.get_etud_groups_in_partition(pid)
2020-09-26 16:19:37 +02:00
ues_stat = nt.get_ues_stat_dict()
2021-12-26 19:15:47 +01:00
modimpls = nt.get_modimpls_dict()
2021-12-24 00:08:25 +01:00
nbetuds = len(nt.etud_moy_gen_ranks)
moy_gen = scu.fmt_note(nt.get_etud_moy_gen(etudid))
if nt.get_moduleimpls_attente() or not prefs["bul_show_rangs"]:
2020-09-26 16:19:37 +02:00
# n'affiche pas le rang sur le bulletin s'il y a des
# notes en attente dans ce semestre
rang = ""
rang_gr = {}
ninscrits_gr = {}
else:
rang = str(nt.get_etud_rang(etudid))
rang_gr, ninscrits_gr, gr_name = sco_bulletins.get_etud_rangs_groups(
etudid, partitions, partitions_etud_groups, nt
2020-09-26 16:19:37 +02:00
)
d["note"] = dict(
value=moy_gen,
2021-02-01 16:23:11 +01:00
min=scu.fmt_note(nt.moy_min),
max=scu.fmt_note(nt.moy_max),
moy=scu.fmt_note(nt.moy_moy),
2020-09-26 16:19:37 +02:00
)
d["rang"] = dict(value=rang, ninscrits=nbetuds)
d["rang_group"] = []
if rang_gr:
for partition in partitions:
d["rang_group"].append(
dict(
group_type=partition["partition_name"],
group_name=gr_name[partition["partition_id"]],
value=rang_gr[partition["partition_id"]],
ninscrits=ninscrits_gr[partition["partition_id"]],
)
)
d["note_max"] = dict(value=20) # notes toujours sur 20
2022-01-25 10:45:13 +01:00
d["bonus_sport_culture"] = dict(
value=nt.bonus[etudid] if nt.bonus is not None else 0.0
)
2020-09-26 16:19:37 +02:00
# Liste les UE / modules /evals
d["ue"] = []
d["ue_capitalisee"] = []
for ue_st in ues_stat:
2022-12-05 21:59:10 +01:00
ue_id = ue_st["ue_id"]
ue_status = nt.get_etud_ue_status(etudid, ue_id)
if ue_st["ects"] is None:
2020-09-26 16:19:37 +02:00
ects_txt = ""
2021-08-30 16:43:18 +02:00
else:
ects_txt = f"{ue_st['ects']:2.3g}"
2022-12-05 21:59:10 +01:00
rang, effectif = nt.get_etud_ue_rang(ue_id, etudid)
2020-09-26 16:19:37 +02:00
u = dict(
2022-12-05 21:59:10 +01:00
id=ue_id,
numero=quote_xml_attr(ue_st["numero"]),
acronyme=quote_xml_attr(ue_st["acronyme"]),
titre=quote_xml_attr(ue_st["titre"]),
2020-09-26 16:19:37 +02:00
note=dict(
2022-02-12 22:57:46 +01:00
value=scu.fmt_note(ue_status["cur_moy_ue"] if ue_status else ""),
min=scu.fmt_note(ue_st["min"]),
max=scu.fmt_note(ue_st["max"]),
moy=scu.fmt_note(ue_st["moy"]),
2020-09-26 16:19:37 +02:00
),
2022-02-09 23:22:00 +01:00
rang=rang,
effectif=effectif,
2020-09-26 16:19:37 +02:00
ects=ects_txt,
code_apogee=quote_xml_attr(ue_st["code_apogee"]),
2020-09-26 16:19:37 +02:00
)
d["ue"].append(u)
if with_matieres:
u["module"] = []
# Structure UE/Matière/Module
# Recodé en 2022
2022-12-05 21:59:10 +01:00
ue = UniteEns.query.get(ue_id)
u["matiere"] = [
{
"matiere_id": mat.id,
"note": scu.fmt_note(nt.get_etud_mat_moy(mat.id, etudid)),
"titre": mat.titre,
"module": _list_modimpls(
nt,
etudid,
[
mod
for mod in modimpls
if mod["module"]["matiere_id"] == mat.id
],
prefs,
version,
),
}
for mat in ue.matieres.order_by(Matiere.numero)
]
else:
# Liste les modules de l'UE
u["module"] = _list_modimpls(
nt,
etudid,
2022-12-05 21:59:10 +01:00
[mod for mod in modimpls if mod["module"]["ue_id"] == ue_id],
prefs,
version,
2020-09-26 16:19:37 +02:00
)
# UE capitalisée (listée seulement si meilleure que l'UE courante)
2020-09-26 16:19:37 +02:00
if ue_status["is_capitalized"]:
try:
ects_txt = str(int(ue_status["ue"].get("ects", "") or 0.0))
except ValueError:
2020-09-26 16:19:37 +02:00
ects_txt = ""
d["ue_capitalisee"].append(
dict(
2022-12-05 21:59:10 +01:00
id=ue_id,
2022-12-06 13:06:50 +01:00
numero=quote_xml_attr(ue_st["numero"]),
acronyme=quote_xml_attr(ue_st["acronyme"]),
titre=quote_xml_attr(ue_st["titre"]),
2021-02-01 16:23:11 +01:00
note=scu.fmt_note(ue_status["moy"]),
coefficient_ue=scu.fmt_note(ue_status["coef_ue"]),
date_capitalisation=ndb.DateDMYtoISO(ue_status["event_date"]),
2020-09-26 16:19:37 +02:00
ects=ects_txt,
)
)
# --- Absences
if prefs["bul_show_abs"]:
2021-07-19 19:53:01 +02:00
nbabs, nbabsjust = sco_abs.get_abs_count(etudid, sem)
2020-09-26 16:19:37 +02:00
d["absences"] = dict(nbabs=nbabs, nbabsjust=nbabsjust)
# --- Décision Jury
d.update(dict_decision_jury(etud, formsemestre, with_decisions=xml_with_decisions))
# --- Appréciations
cnx = ndb.GetDBConnexion()
apprecs = sco_etud.appreciations_list(
cnx, args={"etudid": etudid, "formsemestre_id": formsemestre_id}
)
d["appreciation"] = []
for app in apprecs:
d["appreciation"].append(
dict(
comment=quote_xml_attr(app["comment"]),
date=ndb.DateDMYtoISO(app["date"]),
)
)
#
return d
def _list_modimpls(
nt: NotesTableCompat,
etudid: int,
modimpls: list[ModuleImpl],
prefs: SemPreferences,
version: str,
) -> list[dict]:
modules_dict = []
for modimpl in modimpls:
mod_moy = scu.fmt_note(nt.get_etud_mod_moy(modimpl["moduleimpl_id"], etudid))
if mod_moy == "NI": # ne mentionne pas les modules ou n'est pas inscrit
continue
mod = modimpl["module"]
# if mod['ects'] is None:
# ects = ''
# else:
# ects = str(mod['ects'])
modstat = nt.get_mod_stats(modimpl["moduleimpl_id"])
mod_dict = dict(
id=modimpl["moduleimpl_id"],
code=mod["code"],
coefficient=mod["coefficient"],
numero=mod["numero"],
titre=quote_xml_attr(mod["titre"]),
abbrev=quote_xml_attr(mod["abbrev"]),
# ects=ects, ects des modules maintenant inutilisés
note=dict(value=mod_moy),
code_apogee=quote_xml_attr(mod["code_apogee"]),
matiere_id=mod["matiere_id"],
)
mod_dict["note"].update(modstat)
for k in ("min", "max", "moy"): # formatte toutes les notes
mod_dict["note"][k] = scu.fmt_note(mod_dict["note"][k])
if prefs["bul_show_mod_rangs"] and nt.mod_rangs is not None:
mod_dict["rang"] = dict(
value=nt.mod_rangs[modimpl["moduleimpl_id"]][0][etudid]
)
mod_dict["effectif"] = dict(value=nt.mod_rangs[modimpl["moduleimpl_id"]][1])
# --- notes de chaque eval:
evals = nt.get_evals_in_mod(modimpl["moduleimpl_id"])
mod_dict["evaluation"] = []
if version != "short":
for e in evals:
if e["visibulletin"] or version == "long":
val = e["notes"].get(etudid, {"value": "NP"})["value"]
# nb: val est NA si etud démissionnaire
val = scu.fmt_note(val, note_max=e["note_max"])
eval_dict = dict(
jour=ndb.DateDMYtoISO(e["jour"], null_is_empty=True),
heure_debut=ndb.TimetoISO8601(
e["heure_debut"], null_is_empty=True
),
heure_fin=ndb.TimetoISO8601(e["heure_fin"], null_is_empty=True),
coefficient=e["coefficient"],
evaluation_type=e["evaluation_type"],
# CM : ajout pour permettre de faire le lien sur
# les bulletins en ligne avec l'évaluation:
evaluation_id=e["evaluation_id"],
description=quote_xml_attr(e["description"]),
note=val,
)
if prefs["bul_show_minmax_eval"] or prefs["bul_show_moypromo"]:
etat = sco_evaluations.do_evaluation_etat(e["evaluation_id"])
if prefs["bul_show_minmax_eval"]:
eval_dict["min"] = etat["mini"] # chaine, sur 20
eval_dict["max"] = etat["maxi"]
if prefs["bul_show_moypromo"]:
eval_dict["moy"] = etat["moy"]
mod_dict["evaluation"].append(eval_dict)
# Evaluations incomplètes ou futures:
complete_eval_ids = set([e["evaluation_id"] for e in evals])
if prefs["bul_show_all_evals"]:
all_evals = sco_evaluation_db.do_evaluation_list(
args={"moduleimpl_id": modimpl["moduleimpl_id"]}
)
all_evals.reverse() # plus ancienne d'abord
for e in all_evals:
if e["evaluation_id"] not in complete_eval_ids:
mod_dict["evaluation"].append(
dict(
jour=ndb.DateDMYtoISO(e["jour"], null_is_empty=True),
heure_debut=ndb.TimetoISO8601(
e["heure_debut"], null_is_empty=True
),
heure_fin=ndb.TimetoISO8601(
e["heure_fin"], null_is_empty=True
),
coefficient=e["coefficient"],
description=quote_xml_attr(e["description"]),
incomplete="1",
)
)
modules_dict.append(mod_dict)
return modules_dict
def dict_decision_jury(
etud: Identite, formsemestre: FormSemestre, with_decisions: bool = False
) -> dict:
2022-07-05 20:40:21 +02:00
"""dict avec decision pour bulletins json
- decision : décision semestre
- decision_ue : list des décisions UE
- situation
with_decision donne les décision même si bul_show_decision est faux.
Si formation APC, indique aussi validations année et RCUEs
2022-07-05 20:40:21 +02:00
Exemple:
{
'autorisation_inscription': [{'semestre_id': 4}],
'decision': {'code': 'ADM',
'compense_formsemestre_id': None,
'date': '2022-01-21',
'etat': 'I'},
'decision_ue': [
{
'acronyme': 'UE31',
'code': 'ADM',
'ects': 16.0,
'numero': 23,
'titre': 'Approfondissement métiers',
'ue_id': 1787
},
...
],
'situation': 'Inscrit le 25/06/2021. Décision jury: Validé. UE acquises: '
'UE31, UE32. Diplôme obtenu.'}
"""
from app.scodoc import sco_bulletins
prefs = sco_preferences.SemPreferences(formsemestre.id)
d = {}
if prefs["bul_show_decision"] or with_decisions:
2020-09-26 16:19:37 +02:00
infos, dpv = sco_bulletins.etud_descr_situation_semestre(
etud.id,
formsemestre,
show_uevalid=prefs["bul_show_uevalid"],
2020-09-26 16:19:37 +02:00
)
d["situation"] = infos["situation"]
2020-09-26 16:19:37 +02:00
if dpv:
decision = dpv["decisions"][0]
etat = decision["etat"]
if decision["decision_sem"]:
code = decision["decision_sem"]["code"]
2021-12-17 00:39:06 +01:00
date = ndb.DateDMYtoISO(
dpv["decisions"][0]["decision_sem"]["event_date"]
)
2020-09-26 16:19:37 +02:00
else:
code = ""
2021-12-17 00:39:06 +01:00
date = ""
2020-09-26 16:19:37 +02:00
d["decision"] = dict(
code=code,
etat=etat,
2021-12-17 00:39:06 +01:00
date=date,
)
2020-09-26 16:19:37 +02:00
if (
decision["decision_sem"]
and "compense_formsemestre_id" in decision["decision_sem"]
):
d["decision"]["compense_formsemestre_id"] = decision["decision_sem"][
"compense_formsemestre_id"
]
d["decision_ue"] = []
if decision[
"decisions_ue"
]: # and sco_preferences.get_preference( 'bul_show_uevalid', formsemestre_id): always publish (car utile pour export Apogee)
2020-09-26 16:19:37 +02:00
for ue_id in decision["decisions_ue"].keys():
2021-10-17 23:19:26 +02:00
ue = sco_edit_ue.ue_list({"ue_id": ue_id})[0]
2020-09-26 16:19:37 +02:00
d["decision_ue"].append(
dict(
ue_id=ue["ue_id"],
numero=ue["numero"],
acronyme=ue["acronyme"],
titre=ue["titre"],
2020-09-26 16:19:37 +02:00
code=decision["decisions_ue"][ue_id]["code"],
ects=ue["ects"] or "",
2020-09-26 16:19:37 +02:00
)
)
d["autorisation_inscription"] = []
for aut in decision["autorisations"]:
d["autorisation_inscription"].append(
dict(semestre_id=aut["semestre_id"])
)
else:
d["decision"] = dict(code="", etat="DEM")
# Ajout jury BUT:
if formsemestre.formation.is_apc():
d.update(but_validations.dict_decision_jury(etud, formsemestre))
2020-09-26 16:19:37 +02:00
return d