ScoDoc/app/scodoc/sco_etud.py

1020 lines
31 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
#
##############################################################################
2020-12-26 00:11:55 +01:00
""" Accès donnees etudiants
2020-09-26 16:19:37 +02:00
"""
# Ancien module "scolars"
import os
import time
2021-09-14 12:21:22 +02:00
from operator import itemgetter
2020-09-26 16:19:37 +02:00
from flask import url_for, g
from app import db, email
2021-09-14 12:21:22 +02:00
from app import log
from app.models import Admission, Identite
2023-05-15 22:20:28 +02:00
from app.models.etudiants import input_civilite, make_etud_args, pivot_year
import app.scodoc.sco_utils as scu
import app.scodoc.notesdb as ndb
from app.scodoc.sco_exceptions import ScoGenError, ScoValueError
from app.scodoc import safehtml
from app.scodoc import sco_preferences
from app.scodoc.scolog import logdb
2020-09-26 16:19:37 +02:00
def format_etud_ident(etud):
"""Format identite de l'étudiant (modifié en place)
nom, prénom et formes associees
"""
etud["nom"] = format_nom(etud["nom"])
if "nom_usuel" in etud:
etud["nom_usuel"] = format_nom(etud["nom_usuel"])
else:
etud["nom_usuel"] = ""
etud["prenom"] = format_prenom(etud["prenom"])
2023-03-13 06:39:36 +01:00
if "prenom_etat_civil" in etud:
etud["prenom_etat_civil"] = format_prenom(etud["prenom_etat_civil"])
else:
etud["prenom_etat_civil"] = ""
etud["civilite_str"] = format_civilite(etud["civilite"])
2023-05-25 18:48:21 +02:00
etud["civilite_etat_civil_str"] = format_civilite(
etud.get("civilite_etat_civil", "X")
)
2020-09-26 16:19:37 +02:00
# Nom à afficher:
if etud["nom_usuel"]:
etud["nom_disp"] = etud["nom_usuel"]
if etud["nom"]:
etud["nom_disp"] += " (" + etud["nom"] + ")"
else:
etud["nom_disp"] = etud["nom"]
etud["nomprenom"] = format_nomprenom(etud) # M. Pierre DUPONT
etud["etat_civil"] = format_etat_civil(etud)
if etud["civilite"] == "M":
2020-09-26 16:19:37 +02:00
etud["ne"] = ""
elif etud["civilite"] == "F":
2020-09-26 16:19:37 +02:00
etud["ne"] = "e"
else: # 'X'
etud["ne"] = "(e)"
2020-09-26 16:19:37 +02:00
# Mail à utiliser pour les envois vers l'étudiant:
# choix qui pourrait être controé par une preference
# ici priorité au mail institutionnel:
etud["email_default"] = etud.get("email", "") or etud.get("emailperso", "")
def force_uppercase(s):
return s.upper() if s else s
2020-09-26 16:19:37 +02:00
def format_nomprenom(etud, reverse=False):
"""Formatte civilité/nom/prenom pour affichages: "M. Pierre Dupont"
Si reverse, "Dupont Pierre", sans civilité.
2021-12-26 19:15:47 +01:00
DEPRECATED: utiliser Identite.nomprenom
"""
nom = etud.get("nom_disp", "") or etud.get("nom_usuel", "") or etud["nom"]
prenom = format_prenom(etud["prenom"])
civilite = format_civilite(etud["civilite"])
if reverse:
fs = [nom, prenom]
else:
fs = [civilite, prenom, nom]
return " ".join([x for x in fs if x])
2020-09-26 16:19:37 +02:00
def format_prenom(s):
2021-12-26 19:15:47 +01:00
"""Formatte prenom etudiant pour affichage
DEPRECATED: utiliser Identite.prenom_str
"""
2020-09-26 16:19:37 +02:00
if not s:
return ""
frags = s.split()
r = []
for frag in frags:
fs = frag.split("-")
2021-07-12 00:25:23 +02:00
r.append("-".join([x.lower().capitalize() for x in fs]))
2020-09-26 16:19:37 +02:00
return " ".join(r)
def format_nom(s, uppercase=True):
if not s:
return ""
if uppercase:
return s.upper()
2020-09-26 16:19:37 +02:00
else:
return format_prenom(s)
def format_civilite(civilite):
"""returns 'M.' ou 'Mme' ou '' (pour le genre neutre,
personne ne souhaitant pas d'affichage).
Raises ScoValueError if conversion fails.
"""
try:
return {
"M": "M.",
"F": "Mme",
"X": "",
}[civilite]
except KeyError:
raise ScoValueError("valeur invalide pour la civilité: %s" % civilite)
2020-09-26 16:19:37 +02:00
def format_etat_civil(etud: dict):
if etud["prenom_etat_civil"]:
2023-05-25 18:48:21 +02:00
civ = {"M": "M.", "F": "Mme", "X": ""}[etud.get("civilite_etat_civil", "X")]
return f'{civ} {etud["prenom_etat_civil"]} {etud["nom"]}'
else:
return etud["nomprenom"]
2020-09-26 16:19:37 +02:00
def format_lycee(nomlycee):
nomlycee = nomlycee.strip()
s = nomlycee.lower()
2020-09-26 16:19:37 +02:00
if s[:5] == "lycee" or s[:5] == "lycée":
return nomlycee[5:]
else:
return nomlycee
def format_telephone(n):
if n is None:
return ""
if len(n) < 7:
return n
else:
n = n.replace(" ", "").replace(".", "")
i = 0
r = ""
j = len(n) - 1
while j >= 0:
r = n[j] + r
if i % 2 == 1 and j != 0:
r = " " + r
i += 1
j -= 1
if len(r) == 13 and r[0] != "0":
r = "0" + r
return r
def format_pays(s):
"laisse le pays seulement si != FRANCE"
if s.upper() != "FRANCE":
2020-09-26 16:19:37 +02:00
return s
else:
return ""
2022-09-02 22:00:34 +02:00
def etud_sort_key(etud: dict) -> tuple:
"""Clé de tri pour les étudiants représentés par des dict (anciens codes).
Equivalent moderne: identite.sort_key
"""
return (
scu.sanitize_string(
etud.get("nom_usuel") or etud["nom"] or "", remove_spaces=False
2022-09-02 22:00:34 +02:00
).lower(),
scu.sanitize_string(etud["prenom"] or "", remove_spaces=False).lower(),
)
_identiteEditor = ndb.EditableTable(
2020-09-26 16:19:37 +02:00
"identite",
"etudid",
(
"etudid",
"nom",
"nom_usuel",
"prenom",
2023-03-13 06:39:36 +01:00
"prenom_etat_civil",
"cas_id",
"cas_allow_login",
"cas_allow_scodoc_login",
"civilite", # 'M", "F", or "X"
2023-03-13 06:39:36 +01:00
"civilite_etat_civil",
2020-09-26 16:19:37 +02:00
"date_naissance",
"lieu_naissance",
"dept_naissance",
"nationalite",
"statut",
"boursier",
"foto",
"photo_filename",
"code_ine",
"code_nip",
),
2021-08-13 00:34:58 +02:00
filter_dept=True,
2020-09-26 16:19:37 +02:00
sortkey="nom",
input_formators={
"nom": force_uppercase,
"prenom": force_uppercase,
2023-03-13 06:39:36 +01:00
"prenom_etat_civil": force_uppercase,
"civilite": input_civilite,
2023-03-13 06:39:36 +01:00
"civilite_etat_civil": input_civilite,
"date_naissance": ndb.DateDMYtoISO,
2021-08-11 00:36:07 +02:00
"boursier": bool,
2020-09-26 16:19:37 +02:00
},
output_formators={"date_naissance": ndb.DateISOtoDMY},
2020-09-26 16:19:37 +02:00
convert_null_outputs_to_empty=True,
2021-08-08 16:01:10 +02:00
# allow_set_id=True, # car on specifie le code Apogee a la creation #sco8
2020-09-26 16:19:37 +02:00
)
identite_delete = _identiteEditor.delete
def identite_list(cnx, *a, **kw):
"""List, adding on the fly 'annee_naissance' and 'civilite_str' (M., Mme, "")."""
2020-09-26 16:19:37 +02:00
objs = _identiteEditor.list(cnx, *a, **kw)
for o in objs:
if o["date_naissance"]:
o["annee_naissance"] = int(o["date_naissance"].split("/")[2])
else:
o["annee_naissance"] = o["date_naissance"]
o["civilite_str"] = format_civilite(o["civilite"])
2023-03-13 06:39:36 +01:00
o["civilite_etat_civil_str"] = format_civilite(o["civilite_etat_civil"])
2020-09-26 16:19:37 +02:00
return objs
def identite_edit_nocheck(cnx, args):
"""Modifie les champs mentionnes dans args, sans verification ni notification."""
etud = db.session.get(Identite, args["etudid"])
etud.from_dict(args)
db.session.commit()
2020-09-26 16:19:37 +02:00
def check_nom_prenom_homonyms(
nom: str = "", prenom: str = "", etudid=None
) -> tuple[bool, list[Identite]]:
2020-09-26 16:19:37 +02:00
"""Check if nom and prenom are valid.
Also check for duplicates (homonyms), excluding etudid :
2020-09-26 16:19:37 +02:00
in general, homonyms are allowed, but it may be useful to generate a warning.
Returns:
True | False, homonyms
2020-09-26 16:19:37 +02:00
"""
if not nom or (not prenom and not scu.CONFIG.ALLOW_NULL_PRENOM):
return False, []
2021-07-12 15:13:10 +02:00
nom = nom.lower().strip()
2020-09-26 16:19:37 +02:00
if prenom:
2021-07-12 15:13:10 +02:00
prenom = prenom.lower().strip()
2020-09-26 16:19:37 +02:00
# Don't allow some special cars (eg used in sql regexps)
if scu.FORBIDDEN_CHARS_EXP.search(nom) or scu.FORBIDDEN_CHARS_EXP.search(prenom):
2020-09-26 16:19:37 +02:00
return False, 0
# Liste homonymes (dans tous les départements):
query = Identite.query.filter(
Identite.nom.ilike(nom + "%"), Identite.prenom.ilike(prenom + "%")
)
if etudid is not None:
query = query.filter(Identite.id != etudid)
return True, query.all()
2020-09-26 16:19:37 +02:00
def _check_duplicate_code(cnx, args, code_name, disable_notify=False, edit=True):
"""Vérifie que le code n'est pas dupliqué"""
2020-09-26 16:19:37 +02:00
etudid = args.get("etudid", None)
if args.get(code_name, None):
etuds = identite_list(cnx, {code_name: str(args[code_name])})
duplicate = False
2020-09-26 16:19:37 +02:00
if edit:
duplicate = (len(etuds) > 1) or (
(len(etuds) == 1) and etuds[0]["id"] != args["etudid"]
)
else:
duplicate = len(etuds) > 0
if duplicate:
2020-09-26 16:19:37 +02:00
listh = [] # liste des doubles
for e in etuds:
listh.append(
f"""Autre étudiant: <a href="{
url_for(
"scolar.ficheEtud",
scodoc_dept=g.scodoc_dept,
etudid=e["etudid"]
)}">{e['nom']} {e['prenom']}</a>"""
2020-09-26 16:19:37 +02:00
)
if etudid:
OK = "retour à la fiche étudiant"
dest_endpoint = "scolar.ficheEtud"
2020-09-26 16:19:37 +02:00
parameters = {"etudid": etudid}
else:
2021-08-15 09:55:35 +02:00
if "tf_submitted" in args:
del args["tf_submitted"]
2020-09-26 16:19:37 +02:00
OK = "Continuer"
dest_endpoint = "scolar.etudident_create_form"
2020-09-26 16:19:37 +02:00
parameters = args
else:
OK = "Annuler"
dest_endpoint = "notes.index_html"
2020-09-26 16:19:37 +02:00
parameters = {}
if not disable_notify:
err_page = f"""<h3><h3>Code étudiant ({code_name}) dupliqué !</h3>
<p class="help">Le {code_name} {args[code_name]} est déjà utilisé: un seul étudiant peut avoir
ce code. Vérifier votre valeur ou supprimer l'autre étudiant avec cette valeur.
</p>
<ul><li>
{ '</li><li>'.join(listh) }
</li></ul>
<p>
<a href="{ url_for(dest_endpoint, scodoc_dept=g.scodoc_dept, **parameters) }
">{OK}</a>
</p>
"""
2020-09-26 16:19:37 +02:00
else:
err_page = f"""<h3>Code étudiant ({code_name}) dupliqué !</h3>"""
log(f"*** error: code {code_name} duplique: {args[code_name]}")
2020-09-26 16:19:37 +02:00
raise ScoGenError(err_page)
def _check_civilite(args):
civilite = args.get("civilite", "X") or "X"
args["civilite"] = input_civilite(civilite) # TODO: A faire valider
def identite_edit(cnx, args, disable_notify=False):
2020-09-26 16:19:37 +02:00
"""Modifie l'identite d'un étudiant.
Si pref notification et difference, envoie message notification, sauf si disable_notify
2020-09-26 16:19:37 +02:00
"""
_check_duplicate_code(
cnx, args, "code_nip", disable_notify=disable_notify, edit=True
)
_check_duplicate_code(
cnx, args, "code_ine", disable_notify=disable_notify, edit=True
)
2020-09-26 16:19:37 +02:00
notify_to = None
if not disable_notify:
2020-09-26 16:19:37 +02:00
try:
notify_to = sco_preferences.get_preference("notify_etud_changes_to")
2020-09-26 16:19:37 +02:00
except:
pass
if notify_to:
# etat AVANT edition pour envoyer diffs
before = identite_list(cnx, {"etudid": args["etudid"]})[0]
identite_edit_nocheck(cnx, args)
# Notification du changement par e-mail:
if notify_to:
etud = get_etud_info(etudid=args["etudid"], filled=True)[0]
2020-09-26 16:19:37 +02:00
after = identite_list(cnx, {"etudid": args["etudid"]})[0]
notify_etud_change(
notify_to,
etud,
before,
after,
"Modification identite %(nomprenom)s" % etud,
)
def identite_create(cnx, args):
2020-09-26 16:19:37 +02:00
"check unique etudid, then create"
_check_duplicate_code(cnx, args, "code_nip", edit=False)
_check_duplicate_code(cnx, args, "code_ine", edit=False)
_check_civilite(args)
2020-09-26 16:19:37 +02:00
2021-07-09 17:47:06 +02:00
if "etudid" in args:
2020-09-26 16:19:37 +02:00
etudid = args["etudid"]
r = identite_list(cnx, {"etudid": etudid})
if r:
raise ScoValueError(
"Code identifiant (etudid) déjà utilisé ! (%s)" % etudid
)
return _identiteEditor.create(cnx, args)
def notify_etud_change(email_addr, etud, before, after, subject):
2020-09-26 16:19:37 +02:00
"""Send email notifying changes to etud
before and after are two dicts, with values before and after the change.
"""
txt = [
"Code NIP:" + etud["code_nip"],
"Civilité: " + etud["civilite_str"],
2020-09-26 16:19:37 +02:00
"Nom: " + etud["nom"],
"Prénom: " + etud["prenom"],
2021-09-13 17:10:38 +02:00
"Etudid: " + str(etud["etudid"]),
2020-09-26 16:19:37 +02:00
"\n",
"Changements effectués:",
]
n = 0
for key in after.keys():
if before[key] != after[key]:
txt.append('%s: %s (auparavant: "%s")' % (key, after[key], before[key]))
n += 1
if not n:
return # pas de changements
txt = "\n".join(txt)
# build mail
2023-10-09 15:29:01 +02:00
log(f"notify_etud_change: sending notification to {email_addr}")
log(f"notify_etud_change: subject: {subject}")
log(txt)
2023-10-09 15:29:01 +02:00
email.send_email("[ScoDoc] " + subject, email.get_from_addr(), [email_addr], txt)
return txt
2020-09-26 16:19:37 +02:00
# --------
# Note: la table adresse n'est pas dans dans la table "identite"
# car on prevoit plusieurs adresses par etudiant (ie domicile, entreprise)
_adresseEditor = ndb.EditableTable(
2020-09-26 16:19:37 +02:00
"adresse",
"adresse_id",
(
"adresse_id",
"etudid",
"email",
"emailperso",
"domicile",
"codepostaldomicile",
"villedomicile",
"paysdomicile",
"telephone",
"telephonemobile",
"fax",
"typeadresse",
"description",
),
convert_null_outputs_to_empty=True,
)
adresse_create = _adresseEditor.create
adresse_delete = _adresseEditor.delete
adresse_list = _adresseEditor.list
def adresse_edit(cnx, args, disable_notify=False):
2020-09-26 16:19:37 +02:00
"""Modifie l'adresse d'un étudiant.
Si pref notification et difference, envoie message notification, sauf si disable_notify
2020-09-26 16:19:37 +02:00
"""
notify_to = None
if not disable_notify:
2020-09-26 16:19:37 +02:00
try:
notify_to = sco_preferences.get_preference("notify_etud_changes_to")
2020-09-26 16:19:37 +02:00
except:
pass
if notify_to:
# etat AVANT edition pour envoyer diffs
before = adresse_list(cnx, {"etudid": args["etudid"]})[0]
_adresseEditor.edit(cnx, args)
# Notification du changement par e-mail:
if notify_to:
etud = get_etud_info(etudid=args["etudid"], filled=True)[0]
2020-09-26 16:19:37 +02:00
after = adresse_list(cnx, {"etudid": args["etudid"]})[0]
notify_etud_change(
notify_to,
etud,
before,
after,
"Modification adresse %(nomprenom)s" % etud,
)
def getEmail(cnx, etudid):
"get email institutionnel etudiant (si plusieurs adresses, prend le premier non null"
adrs = adresse_list(cnx, {"etudid": etudid})
for adr in adrs:
if adr["email"]:
return adr["email"]
return ""
# ---------
_admissionEditor = ndb.EditableTable(
2020-09-26 16:19:37 +02:00
"admissions",
"adm_id",
(
"adm_id",
"annee",
"bac",
"specialite",
"annee_bac",
"math",
"physique",
"anglais",
"francais",
"rang",
"qualite",
"rapporteur",
"decision",
"score",
"classement",
"apb_groupe",
"apb_classement_gr",
"commentaire",
"nomlycee",
"villelycee",
"codepostallycee",
"codelycee",
"type_admission",
"boursier_prec",
),
input_formators={
"annee": pivot_year,
"bac": force_uppercase,
"specialite": force_uppercase,
"annee_bac": pivot_year,
"classement": ndb.int_null_is_null,
"apb_classement_gr": ndb.int_null_is_null,
2021-08-10 17:12:10 +02:00
"boursier_prec": bool,
2020-09-26 16:19:37 +02:00
},
output_formators={"type_admission": lambda x: x or scu.TYPE_ADMISSION_DEFAULT},
2020-09-26 16:19:37 +02:00
convert_null_outputs_to_empty=True,
)
admission_create = _admissionEditor.create
admission_delete = _admissionEditor.delete
admission_list = _admissionEditor.list
admission_edit = _admissionEditor.edit
2020-09-26 16:19:37 +02:00
# Edition simultanee de identite et admission
2021-07-09 23:31:16 +02:00
class EtudIdentEditor(object):
def create(self, cnx, args):
admission_id = admission_create(cnx, args)
args["admission_id"] = admission_id
etudid = identite_create(cnx, args)
2020-09-26 16:19:37 +02:00
return etudid
def list(self, *args, **kw) -> list[dict]:
etuds_dict = identite_list(*args, **kw)
2020-09-26 16:19:37 +02:00
res = []
for etud_dict in etuds_dict:
res.append(etud_dict)
adms_dict = (
admission_list(args[0], args={"id": etud_dict["admission_id"]})
if etud_dict["admission_id"]
else []
)
if adms_dict:
2020-09-26 16:19:37 +02:00
# merge
adms_dict[0].pop("id", None)
adms_dict[0].pop("etudid", None)
res[-1] |= adms_dict[0]
2020-09-26 16:19:37 +02:00
else: # pas d'etudiant trouve
void_adm = {
k: None
for k in _admissionEditor.dbfields
if k not in ("id", "etudid", "adm_id")
2020-09-26 16:19:37 +02:00
}
res[-1] |= void_adm
2020-09-26 16:19:37 +02:00
# tri par nom
2021-07-09 23:19:30 +02:00
res.sort(key=itemgetter("nom", "prenom"))
2020-09-26 16:19:37 +02:00
return res
def edit(self, cnx, args, disable_notify=False):
identite_edit(cnx, args, disable_notify=disable_notify)
2020-09-26 16:19:37 +02:00
if "adm_id" in args: # safety net
admission_edit(cnx, args)
_etudidentEditor = EtudIdentEditor()
etudident_list = _etudidentEditor.list
etudident_edit = _etudidentEditor.edit
def log_unknown_etud():
"""Log request: cas ou getEtudInfo n'a pas ramene de resultat"""
etud_args = make_etud_args(raise_exc=False)
log(f"unknown student: args={etud_args}")
def get_etud_info(etudid=False, code_nip=False, filled=False) -> list[dict]:
"""infos sur un etudiant (API). If not found, returns empty list.
2021-11-20 17:21:51 +01:00
On peut spécifier etudid ou code_nip
ou bien cherche dans les arguments de la requête courante:
etudid, code_nip, code_ine (dans cet ordre).
2021-06-14 00:23:22 +02:00
"""
if etudid is None:
return []
2021-06-15 13:59:56 +02:00
cnx = ndb.GetDBConnexion()
2021-08-22 13:24:36 +02:00
args = make_etud_args(etudid=etudid, code_nip=code_nip)
etud = etudident_list(cnx, args=args)
2021-06-14 00:23:22 +02:00
if filled:
fill_etuds_info(etud)
2021-06-14 00:23:22 +02:00
return etud
def create_etud(cnx, args: dict = None):
"""Création d'un étudiant. Génère aussi évenement et "news".
2020-12-26 00:11:55 +01:00
Args:
args: dict avec les attributs de l'étudiant
Returns:
etud, l'étudiant créé.
"""
2022-04-12 17:12:51 +02:00
from app.models import ScolarNews
2020-12-26 00:11:55 +01:00
# creation d'un etudiant
args_dict = Identite.convert_dict_fields(args)
args_dict["dept_id"] = g.scodoc_dept_id
etud = Identite.create_etud(**args_dict)
db.session.add(etud)
db.session.commit()
admission = etud.admission
2023-05-15 22:20:28 +02:00
admission.from_dict(args)
db.session.add(admission)
db.session.commit()
etudid = etud.id
2020-12-26 00:11:55 +01:00
# event
scolar_events_create(
cnx,
args={
"etudid": etudid,
"event_date": time.strftime("%d/%m/%Y"),
"formsemestre_id": None,
"event_type": "CREATION",
},
)
# log
logdb(
cnx,
method="etudident_edit_form",
etudid=etudid,
msg="creation initiale",
)
etud = etudident_list(cnx, {"etudid": etudid})[0]
fill_etuds_info([etud])
etud["url"] = url_for("scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etudid)
2022-04-12 17:12:51 +02:00
ScolarNews.add(
typ=ScolarNews.NEWS_INSCR,
2020-12-26 00:11:55 +01:00
text='Nouvel étudiant <a href="%(url)s">%(nomprenom)s</a>' % etud,
url=etud["url"],
max_frequency=0,
2020-12-26 00:11:55 +01:00
)
return etud
2020-09-26 16:19:37 +02:00
# ---------- "EVENTS"
_scolar_eventsEditor = ndb.EditableTable(
2020-09-26 16:19:37 +02:00
"scolar_events",
"event_id",
(
"event_id",
"etudid",
"event_date",
"formsemestre_id",
"ue_id",
"event_type",
"comp_formsemestre_id",
),
sortkey="event_date",
convert_null_outputs_to_empty=True,
output_formators={"event_date": ndb.DateISOtoDMY},
input_formators={"event_date": ndb.DateDMYtoISO},
2020-09-26 16:19:37 +02:00
)
# scolar_events_create = _scolar_eventsEditor.create
scolar_events_delete = _scolar_eventsEditor.delete
scolar_events_list = _scolar_eventsEditor.list
scolar_events_edit = _scolar_eventsEditor.edit
def scolar_events_create(cnx, args):
# several "events" may share the same values
2021-08-01 16:33:09 +02:00
_scolar_eventsEditor.create(cnx, args)
2020-09-26 16:19:37 +02:00
# --------
_etud_annotationsEditor = ndb.EditableTable(
2020-09-26 16:19:37 +02:00
"etud_annotations",
"id",
(
"id",
"date",
"etudid",
"author",
"comment",
2021-08-10 17:12:10 +02:00
"author",
2020-09-26 16:19:37 +02:00
),
sortkey="date desc",
convert_null_outputs_to_empty=True,
output_formators={"comment": safehtml.html_to_safe_html, "date": ndb.DateISOtoDMY},
2020-09-26 16:19:37 +02:00
)
etud_annotations_create = _etud_annotationsEditor.create
etud_annotations_delete = _etud_annotationsEditor.delete
etud_annotations_list = _etud_annotationsEditor.list
etud_annotations_edit = _etud_annotationsEditor.edit
def add_annotations_to_etud_list(etuds):
2020-09-26 16:19:37 +02:00
"""Add key 'annotations' describing annotations of etuds
(used to list all annotations of a group)
"""
2021-06-15 13:59:56 +02:00
cnx = ndb.GetDBConnexion()
2020-09-26 16:19:37 +02:00
for etud in etuds:
l = []
for a in etud_annotations_list(cnx, args={"etudid": etud["etudid"]}):
l.append("%(comment)s (%(date)s)" % a)
etud["annotations_str"] = ", ".join(l)
# -------- Noms des Lycées à partir du code
def read_etablissements():
filename = os.path.join(scu.SCO_TOOLS_DIR, scu.CONFIG.ETABL_FILENAME)
2020-09-26 16:19:37 +02:00
log("reading %s" % filename)
with open(filename) as f:
L = [x[:-1].split(";") for x in f]
2020-09-26 16:19:37 +02:00
E = {}
for l in L[1:]:
E[l[0]] = {
"name": l[1],
"address": l[2],
"codepostal": l[3],
"commune": l[4],
"position": l[5] + "," + l[6],
}
return E
ETABLISSEMENTS = None
def get_etablissements():
global ETABLISSEMENTS
if ETABLISSEMENTS is None:
ETABLISSEMENTS = read_etablissements()
return ETABLISSEMENTS
def get_lycee_infos(codelycee):
E = get_etablissements()
return E.get(codelycee, None)
def format_lycee_from_code(codelycee):
"Description lycee à partir du code"
E = get_etablissements()
if codelycee in E:
e = E[codelycee]
nomlycee = e["name"]
return "%s (%s)" % (nomlycee, e["commune"])
else:
return "%s (établissement inconnu)" % codelycee
def etud_add_lycee_infos(etud):
"""Si codelycee est renseigné, ajout les champs au dict"""
if etud["codelycee"]:
il = get_lycee_infos(etud["codelycee"])
if il:
if not etud["codepostallycee"]:
etud["codepostallycee"] = il["codepostal"]
if not etud["nomlycee"]:
etud["nomlycee"] = il["name"]
if not etud["villelycee"]:
etud["villelycee"] = il["commune"]
if not etud.get("positionlycee", None):
if il["position"] != "0.0,0.0":
etud["positionlycee"] = il["position"]
return etud
""" Conversion fichier original:
f = open('etablissements.csv')
o = open('etablissements2.csv', 'w')
o.write( f.readline() )
for l in f:
fs = l.split(';')
nom = ' '.join( [ x.capitalize() for x in fs[1].split() ] )
adr = ' '.join( [ x.capitalize() for x in fs[2].split() ] )
ville=' '.join( [ x.capitalize() for x in fs[4].split() ] )
2020-09-26 16:19:37 +02:00
o.write( '%s;%s;%s;%s;%s\n' % (fs[0], nom, adr, fs[3], ville))
o.close()
"""
def list_scolog(etudid):
"liste des operations effectuees sur cet etudiant"
2021-06-15 13:59:56 +02:00
cnx = ndb.GetDBConnexion()
cursor = cnx.cursor(cursor_factory=ndb.ScoDocCursor)
cursor.execute(
2021-09-13 22:10:01 +02:00
"SELECT * FROM scolog WHERE etudid=%(etudid)s ORDER BY DATE DESC",
{"etudid": etudid},
)
return cursor.dictfetchall()
def fill_etuds_info(etuds: list[dict], add_admission=True):
"""etuds est une liste d'etudiants (mappings)
Pour chaque etudiant, ajoute ou formatte les champs
-> informations pour fiche etudiant ou listes diverses
Si add_admission: ajoute au dict le schamps "admission" s'il n'y sont pas déjà.
"""
2021-06-15 13:59:56 +02:00
cnx = ndb.GetDBConnexion()
for etud in etuds:
etudid = etud["etudid"]
2021-08-21 15:17:14 +02:00
etud["dept"] = g.scodoc_dept
# Admission
if add_admission and "nomlycee" not in etud:
admission = (
Admission.query.filter_by(etudid=etudid).first().to_dict(no_nulls=True)
)
del admission["id"] # pour garder id == etudid dans etud
etud.update(admission)
#
adrs = adresse_list(cnx, {"etudid": etudid})
if not adrs:
# certains "vieux" etudiants n'ont pas d'adresse
adr = {}.fromkeys(_adresseEditor.dbfields, "")
adr["etudid"] = etudid
else:
adr = adrs[0]
if len(adrs) > 1:
log("fill_etuds_info: etudid=%s a %d adresses" % (etudid, len(adrs)))
adr.pop("id", None)
etud.update(adr)
format_etud_ident(etud)
2022-02-13 13:58:09 +01:00
etud.update(etud_inscriptions_infos(etudid, etud["ne"]))
# nettoyage champs souvent vides
etud["codepostallycee"] = etud.get("codepostallycee", "") or ""
etud["nomlycee"] = etud.get("nomlycee", "") or ""
if etud.get("nomlycee"):
etud["ilycee"] = "Lycée " + format_lycee(etud["nomlycee"])
if etud["villelycee"]:
etud["ilycee"] += " (%s)" % etud.get("villelycee", "")
etud["ilycee"] += "<br>"
else:
if etud.get("codelycee"):
etud["ilycee"] = format_lycee_from_code(etud["codelycee"])
else:
etud["ilycee"] = ""
rap = ""
if etud.get("rapporteur") or etud.get("commentaire"):
rap = "Note du rapporteur"
if etud.get("rapporteur"):
rap += " (%s)" % etud["rapporteur"]
rap += ": "
if etud.get("commentaire"):
rap += "<em>%s</em>" % etud["commentaire"]
etud["rap"] = rap
if etud.get("telephone"):
etud["telephonestr"] = "<b>Tél.:</b> " + format_telephone(etud["telephone"])
else:
etud["telephonestr"] = ""
if etud.get("telephonemobile"):
etud["telephonemobilestr"] = "<b>Mobile:</b> " + format_telephone(
etud["telephonemobile"]
)
else:
etud["telephonemobilestr"] = ""
2022-02-13 13:58:09 +01:00
def etud_inscriptions_infos(etudid: int, ne="") -> dict:
"""Dict avec les informations sur les semestres passés et courant.
{
"sems" : , # trie les semestres par date de debut, le plus recent d'abord
"ins" : ,
"cursem" : ,
"inscription" : ,
"inscriptionstr" : ,
"inscription_formsemestre_id" : ,
"etatincursem" : ,
"situation" : ,
}
"""
2022-02-13 13:58:09 +01:00
from app.scodoc import sco_formsemestre
from app.scodoc import sco_formsemestre_inscriptions
etud = {}
# Semestres dans lesquel il est inscrit
ins = sco_formsemestre_inscriptions.do_formsemestre_inscription_list(
{"etudid": etudid}
)
etud["ins"] = ins
sems = []
cursem = None # semestre "courant" ou il est inscrit
for i in ins:
sem = sco_formsemestre.get_formsemestre(i["formsemestre_id"])
if sco_formsemestre.sem_est_courant(sem):
cursem = sem
curi = i
sem["ins"] = i
sems.append(sem)
# trie les semestres par date de debut, le plus recent d'abord
# (important, ne pas changer (suivi cohortes))
sems.sort(key=itemgetter("dateord"), reverse=True)
etud["sems"] = sems
etud["cursem"] = cursem
if cursem:
etud["inscription"] = cursem["titremois"]
etud["inscriptionstr"] = "Inscrit en " + cursem["titremois"]
etud["inscription_formsemestre_id"] = cursem["formsemestre_id"]
etud["etatincursem"] = curi["etat"]
etud["situation"] = descr_situation_etud(etudid, ne)
else:
if etud["sems"]:
if etud["sems"][0]["dateord"] > time.strftime("%Y-%m-%d", time.localtime()):
etud["inscription"] = "futur"
etud["situation"] = "futur élève"
else:
etud["inscription"] = "ancien"
etud["situation"] = "ancien élève"
else:
etud["inscription"] = "non inscrit"
etud["situation"] = etud["inscription"]
etud["inscriptionstr"] = etud["inscription"]
etud["inscription_formsemestre_id"] = None
etud["etatincursem"] = "?"
return etud
def descr_situation_etud(etudid: int, ne="") -> str:
"""Chaîne décrivant la situation actuelle de l'étudiant
XXX Obsolete, utiliser Identite.descr_situation_etud() dans
les nouveaux codes
"""
2021-06-21 10:17:16 +02:00
from app.scodoc import sco_formsemestre
2021-06-15 13:59:56 +02:00
cnx = ndb.GetDBConnexion()
cursor = cnx.cursor(cursor_factory=ndb.ScoDocCursor)
cursor.execute(
2021-08-11 13:01:37 +02:00
"""SELECT I.formsemestre_id, I.etat
FROM notes_formsemestre_inscription I, notes_formsemestre S
WHERE etudid=%(etudid)s
and S.id = I.formsemestre_id
and date_debut < now()
and date_fin > now()
ORDER BY S.date_debut DESC;""",
{"etudid": etudid},
)
r = cursor.dictfetchone()
if not r:
2022-02-13 13:58:09 +01:00
situation = "non inscrit" + ne
else:
2021-08-19 10:28:35 +02:00
sem = sco_formsemestre.get_formsemestre(r["formsemestre_id"])
if r["etat"] == scu.INSCRIT:
situation = "inscrit%s en %s" % (ne, sem["titremois"])
# Cherche la date d'inscription dans scolar_events:
events = scolar_events_list(
cnx,
args={
"etudid": etudid,
"formsemestre_id": sem["formsemestre_id"],
"event_type": "INSCRIPTION",
},
)
if not events:
log(
"*** situation inconsistante pour %s (inscrit mais pas d'event)"
% etudid
)
date_ins = "???" # ???
else:
date_ins = events[0]["event_date"]
situation += " le " + str(date_ins)
else:
situation = "démission de %s" % sem["titremois"]
# Cherche la date de demission dans scolar_events:
events = scolar_events_list(
cnx,
args={
"etudid": etudid,
"formsemestre_id": sem["formsemestre_id"],
"event_type": "DEMISSION",
},
)
if not events:
log(
"*** situation inconsistante pour %s (demission mais pas d'event)"
% etudid
)
date_dem = "???" # ???
else:
date_dem = events[0]["event_date"]
situation += " le " + str(date_dem)
return situation