TestsScoDoc7API/scolars.py

841 lines
24 KiB
Python
Raw Normal View History

2020-09-26 16:19:37 +02:00
# -*- mode: python -*-
# -*- coding: utf-8 -*-
##############################################################################
#
# Gestion scolarite IUT
#
2021-01-01 17:51:08 +01:00
# Copyright (c) 1999 - 2021 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
"""
from sco_utils import *
from notesdb import *
from TrivialFormulator import TrivialFormulator
import safehtml
from scolog import logdb
from notes_table import *
2020-12-26 00:11:55 +01:00
import sco_news
2020-09-26 16:19:37 +02:00
# XXXXXXXXX HACK: zope 2.7.7 bug turaround ?
import locale
locale.setlocale(locale.LC_ALL, ("en_US", SCO_ENCODING))
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
from email.MIMEBase import MIMEBase
from email.Header import Header
from email import Encoders
abbrvmonthsnames = [
"Jan ",
"Fev ",
"Mars",
"Avr ",
"Mai ",
"Juin",
"Jul ",
"Aout",
"Sept",
"Oct ",
"Nov ",
"Dec ",
]
monthsnames = [
"janvier",
"février",
"mars",
"avril",
"mai",
"juin",
"juillet",
"aout",
"septembre",
"octobre",
"novembre",
"décembre",
]
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"])
etud["sexe"] = format_sexe(etud["sexe"])
# 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
if etud["sexe"] == "M.":
etud["ne"] = ""
else:
etud["ne"] = "e"
# 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):
if s:
s = strupper(s)
return s
def format_nomprenom(etud):
"formatte sexe/nom/prenom pour affichages"
return " ".join(
[format_sexe(etud["sexe"]), format_prenom(etud["prenom"]), etud["nom_disp"]]
)
def format_prenom(s):
"formatte prenom etudiant pour affichage"
if not s:
return ""
frags = s.split()
r = []
for frag in frags:
fs = frag.split("-")
r.append(
"-".join(
[
x.decode(SCO_ENCODING).lower().capitalize().encode(SCO_ENCODING)
for x in fs
]
)
)
return " ".join(r)
def format_nom(s, uppercase=True):
if not s:
return ""
if uppercase:
return strupper(s)
else:
return format_prenom(s)
def format_sexe(sexe):
sexe = strlower(sexe)
if sexe == "mr" or sexe == "m." or sexe == "m":
return "M."
else:
return "Mme"
def normalize_sexe(sexe):
"returns 'MR' ou 'MME'"
sexe = strupper(sexe).strip()
if sexe in ("M.", "M", "MR", "H"):
return "MR"
elif sexe in ("MLLE", "MLLE.", "MELLE", "MME", "F"):
return "MME"
raise ValueError("valeur invalide pour le sexe: %s" % sexe)
def format_lycee(nomlycee):
nomlycee = nomlycee.strip()
s = strlower(nomlycee)
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 strupper(s) != "FRANCE":
return s
else:
return ""
PIVOT_YEAR = 70
def pivot_year(y):
if y == "" or y is None:
return None
y = int(round(float(y)))
if y >= 0 and y < 100:
if y < PIVOT_YEAR:
y = y + 2000
else:
y = y + 1900
return y
_identiteEditor = EditableTable(
"identite",
"etudid",
(
"etudid",
"nom",
"nom_usuel",
"prenom",
"sexe",
"date_naissance",
"lieu_naissance",
"dept_naissance",
"nationalite",
"statut",
"boursier",
"foto",
"photo_filename",
"code_ine",
"code_nip",
),
sortkey="nom",
input_formators={
"nom": force_uppercase,
"prenom": force_uppercase,
"sexe": force_uppercase,
"date_naissance": DateDMYtoISO,
},
output_formators={"date_naissance": DateISOtoDMY, "sexe": normalize_sexe},
convert_null_outputs_to_empty=True,
allow_set_id=True, # car on specifie le code Apogee a la creation
)
identite_delete = _identiteEditor.delete
def identite_list(cnx, *a, **kw):
"list, add 'annee_naissance'"
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"]
return objs
def identite_edit_nocheck(cnx, args):
"""Modifie les champs mentionnes dans args, sans verification ni notification."""
2020-09-26 16:19:37 +02:00
_identiteEditor.edit(cnx, args)
def check_nom_prenom(cnx, nom="", prenom="", etudid=None):
"""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, NbHomonyms
"""
if not nom or (not prenom and not CONFIG.ALLOW_NULL_PRENOM):
return False, 0
nom = nom.decode(SCO_ENCODING).lower().strip().encode(SCO_ENCODING)
if prenom:
prenom = prenom.decode(SCO_ENCODING).lower().strip().encode(SCO_ENCODING)
# Don't allow some special cars (eg used in sql regexps)
if FORBIDDEN_CHARS_EXP.search(nom) or FORBIDDEN_CHARS_EXP.search(prenom):
return False, 0
# Now count homonyms:
cursor = cnx.cursor(cursor_factory=ScoDocCursor)
req = "select etudid from identite where lower(nom) ~ %(nom)s and lower(prenom) ~ %(prenom)s"
if etudid:
req += " and etudid <> %(etudid)s"
cursor.execute(req, {"nom": nom, "prenom": prenom, "etudid": etudid})
res = cursor.dictfetchall()
return True, len(res)
def _check_duplicate_code(cnx, args, code_name, context, edit=True, REQUEST=None):
etudid = args.get("etudid", None)
if args.get(code_name, None):
etuds = identite_list(cnx, {code_name: str(args[code_name])})
# log('etuds=%s'%etuds)
nb_max = 0
if edit:
nb_max = 1
if len(etuds) > nb_max:
listh = [] # liste des doubles
for e in etuds:
listh.append(
"""Autre étudiant: <a href="ficheEtud?etudid=%(etudid)s">%(nom)s %(prenom)s</a>"""
% e
)
if etudid:
OK = "retour à la fiche étudiant"
dest_url = "ficheEtud"
parameters = {"etudid": etudid}
else:
if args.has_key("tf-submitted"):
del args["tf-submitted"]
OK = "Continuer"
dest_url = "etudident_create_form"
parameters = args
else:
OK = "Annuler"
dest_url = ""
parameters = {}
if context:
err_page = context.confirmDialog(
message="""<h3>Code étudiant (%s) dupliqué !</h3>""" % code_name,
helpmsg="""Le %s %s 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>"""
% (code_name, args[code_name])
+ "</li><li>".join(listh)
+ "</li></ul><p>",
OK=OK,
dest_url=dest_url,
parameters=parameters,
REQUEST=REQUEST,
)
else:
err_page = """<h3>Code étudiant (%s) dupliqué !</h3>""" % code_name
log("*** error: code %s duplique: %s" % (code_name, args[code_name]))
raise ScoGenError(err_page)
def identite_edit(cnx, args, context=None, REQUEST=None):
"""Modifie l'identite d'un étudiant.
Si context et notification et difference, envoie message notification.
"""
_check_duplicate_code(cnx, args, "code_nip", context, edit=True, REQUEST=REQUEST)
_check_duplicate_code(cnx, args, "code_ine", context, edit=True, REQUEST=REQUEST)
notify_to = None
if context:
try:
notify_to = context.get_preference("notify_etud_changes_to")
except:
pass
if notify_to:
# etat AVANT edition pour envoyer diffs
before = identite_list(cnx, {"etudid": args["etudid"]})[0]
before["sexe"] = format_sexe(before["sexe"])
identite_edit_nocheck(cnx, args)
# Notification du changement par e-mail:
if notify_to:
etud = context.getEtudInfo(etudid=args["etudid"], filled=True)[0]
after = identite_list(cnx, {"etudid": args["etudid"]})[0]
after["sexe"] = format_sexe(after["sexe"])
notify_etud_change(
context,
notify_to,
etud,
before,
after,
"Modification identite %(nomprenom)s" % etud,
)
def identite_create(cnx, args, context=None, REQUEST=None):
"check unique etudid, then create"
_check_duplicate_code(cnx, args, "code_nip", context, edit=False, REQUEST=REQUEST)
_check_duplicate_code(cnx, args, "code_ine", context, edit=False, REQUEST=REQUEST)
if args.has_key("etudid"):
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(context, email_addr, etud, before, after, subject):
"""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"],
"Genre: " + etud["sexe"],
"Nom: " + etud["nom"],
"Prénom: " + etud["prenom"],
"Etudid: " + etud["etudid"],
"\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
log("notify_etud_change: sending notification to %s" % email_addr)
log("notify_etud_change: subject: %s" % subject)
log(txt)
2020-09-26 16:19:37 +02:00
msg = MIMEMultipart()
subj = Header("[ScoDoc] " + subject, SCO_ENCODING)
msg["Subject"] = subj
msg["From"] = context.get_preference("email_from_addr")
msg["To"] = email_addr
mime_txt = MIMEText(txt, "plain", SCO_ENCODING)
msg.attach(mime_txt)
2020-09-26 16:19:37 +02:00
context.sendEmail(msg)
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 = EditableTable(
"adresse",
"adresse_id",
(
"adresse_id",
"etudid",
"email",
"emailperso",
"domicile",
"codepostaldomicile",
"villedomicile",
"paysdomicile",
"telephone",
"telephonemobile",
"fax",
"typeadresse",
"entreprise_id",
"description",
),
convert_null_outputs_to_empty=True,
)
adresse_create = _adresseEditor.create
adresse_delete = _adresseEditor.delete
adresse_list = _adresseEditor.list
def adresse_edit(cnx, args, context=None):
"""Modifie l'adresse d'un étudiant.
Si context et notification et difference, envoie message notification.
"""
notify_to = None
if context:
try:
notify_to = context.get_preference("notify_etud_changes_to")
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 = context.getEtudInfo(etudid=args["etudid"], filled=True)[0]
after = adresse_list(cnx, {"etudid": args["etudid"]})[0]
notify_etud_change(
context,
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 = EditableTable(
"admissions",
"adm_id",
(
"adm_id",
"etudid",
"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",
"debouche",
"type_admission",
"boursier_prec",
),
input_formators={
"annee": pivot_year,
"bac": force_uppercase,
"specialite": force_uppercase,
"annee_bac": pivot_year,
"classement": int_null_is_null,
"apb_classsment_gr": int_null_is_null,
},
output_formators={"type_admission": lambda x: x or TYPE_ADMISSION_DEFAULT},
convert_null_outputs_to_empty=True,
)
admission_create = _admissionEditor.create
admission_delete = _admissionEditor.delete
admission_list = _admissionEditor.list
admission_edit = _admissionEditor.edit
# Edition simultanee de identite et admission
class EtudIdentEditor:
def create(self, cnx, args, context=None, REQUEST=None):
etudid = identite_create(cnx, args, context, REQUEST)
args["etudid"] = etudid
admission_create(cnx, args)
return etudid
def list(self, *args, **kw):
R = identite_list(*args, **kw)
Ra = admission_list(*args, **kw)
# print len(R), len(Ra)
# merge: add admission fields to identite
A = {}
for r in Ra:
A[r["etudid"]] = r
res = []
for i in R:
res.append(i)
if A.has_key(i["etudid"]):
# merge
res[-1].update(A[i["etudid"]])
else: # pas d'etudiant trouve
# print "*** pas d'info admission pour %s" % str(i)
void_adm = {
k: None
for k in scolars._admissionEditor.dbfields
if k != "etudid" and k != "adm_id"
}
res[-1].update(void_adm)
# tri par nom
res.sort(lambda x, y: cmp(x["nom"] + x["prenom"], y["nom"] + y["prenom"]))
return res
def edit(self, cnx, args, context=None, REQUEST=None):
identite_edit(cnx, args, context, REQUEST)
if "adm_id" in args: # safety net
admission_edit(cnx, args)
_etudidentEditor = EtudIdentEditor()
etudident_list = _etudidentEditor.list
etudident_edit = _etudidentEditor.edit
etudident_create = _etudidentEditor.create
def make_etud_args(etudid=None, code_nip=None, REQUEST=None, raise_exc=True):
"""forme args dict pour requete recherche etudiant
On peut specifier etudid
ou bien cherche dans REQUEST.form: etudid, code_nip, code_ine
(dans cet ordre).
"""
args = None
if etudid:
args = {"etudid": etudid}
elif code_nip:
args = {"code_nip": code_nip}
elif REQUEST:
if REQUEST.form.has_key("etudid"):
args = {"etudid": REQUEST.form["etudid"]}
elif REQUEST.form.has_key("code_nip"):
args = {"code_nip": REQUEST.form["code_nip"]}
elif REQUEST.form.has_key("code_ine"):
args = {"code_ine": REQUEST.form["code_ine"]}
if not args and raise_exc:
raise ValueError("getEtudInfo: no parameter !")
return args
2020-12-26 00:11:55 +01:00
def create_etud(context, cnx, args={}, REQUEST=None):
"""Creation d'un étudiant. génère aussi évenement et "news".
Args:
args: dict avec les attributs de l'étudiant
Returns:
etud, l'étudiant créé.
"""
# creation d'un etudiant
etudid = etudident_create(cnx, args, context=context, REQUEST=REQUEST)
# crée une adresse vide (chaque etudiant doit etre dans la table "adresse" !)
_ = adresse_create(
cnx,
{
"etudid": etudid,
"typeadresse": "domicile",
"description": "(creation individuelle)",
},
)
# event
scolar_events_create(
cnx,
args={
"etudid": etudid,
"event_date": time.strftime("%d/%m/%Y"),
"formsemestre_id": None,
"event_type": "CREATION",
},
)
# log
logdb(
REQUEST,
cnx,
method="etudident_edit_form",
etudid=etudid,
msg="creation initiale",
)
etud = scolars.etudident_list(cnx, {"etudid": etudid})[0]
context.fillEtudsInfo([etud])
etud["url"] = "ficheEtud?etudid=%(etudid)s" % etud
sco_news.add(
context,
REQUEST,
typ=sco_news.NEWS_INSCR,
object=None, # pas d'object pour ne montrer qu'un etudiant
text='Nouvel étudiant <a href="%(url)s">%(nomprenom)s</a>' % etud,
url=etud["url"],
)
return etud
2020-09-26 16:19:37 +02:00
# ---------- "EVENTS"
_scolar_eventsEditor = EditableTable(
"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": DateISOtoDMY},
input_formators={"event_date": DateDMYtoISO},
)
# 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
_scolar_eventsEditor.create(cnx, args, has_uniq_values=False)
# --------
_etud_annotationsEditor = EditableTable(
"etud_annotations",
"id",
(
"id",
"date",
"etudid",
"author",
"comment",
"zope_authenticated_user",
"zope_remote_addr",
),
sortkey="date desc",
convert_null_outputs_to_empty=True,
output_formators={"comment": safehtml.HTML2SafeHTML, "date": DateISOtoDMY},
)
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(context, etuds):
"""Add key 'annotations' describing annotations of etuds
(used to list all annotations of a group)
"""
cnx = context.GetDBConnexion()
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)
# -------- APPRECIATIONS (sur bulletins) -------------------
# Les appreciations sont dans la table postgres notes_appreciations
_appreciationsEditor = EditableTable(
"notes_appreciations",
"id",
(
"id",
"date",
"etudid",
"formsemestre_id",
"author",
"comment",
"zope_authenticated_user",
"zope_remote_addr",
),
sortkey="date desc",
convert_null_outputs_to_empty=True,
output_formators={"comment": safehtml.HTML2SafeHTML, "date": DateISOtoDMY},
)
appreciations_create = _appreciationsEditor.create
appreciations_delete = _appreciationsEditor.delete
appreciations_list = _appreciationsEditor.list
appreciations_edit = _appreciationsEditor.edit
# -------- Noms des Lycées à partir du code
def read_etablissements():
filename = SCO_SRCDIR + "/" + CONFIG.ETABL_FILENAME
log("reading %s" % filename)
f = open(filename)
L = [x[:-1].split(";") for x in f]
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( [ strcapitalize(x) for x in fs[1].split() ] )
adr = ' '.join( [ strcapitalize(x) for x in fs[2].split() ] )
ville=' '.join( [ strcapitalize(x) for x in fs[4].split() ] )
o.write( '%s;%s;%s;%s;%s\n' % (fs[0], nom, adr, fs[3], ville))
o.close()
"""