forked from ScoDoc/ScoDoc
499 lines
18 KiB
Python
499 lines
18 KiB
Python
# -*- 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
|
|
#
|
|
##############################################################################
|
|
|
|
"""Saisie et gestion des semestres extérieurs à ScoDoc dans un parcours.
|
|
|
|
On va créer/gérer des semestres de la même formation que le semestre ScoDoc
|
|
où est inscrit l'étudiant, leur attribuer la modalité 'EXT'.
|
|
Ces semestres n'auront qu'un seul inscrit !
|
|
"""
|
|
import time
|
|
|
|
import app.scodoc.sco_utils as scu
|
|
import app.scodoc.notesdb as ndb
|
|
from app.scodoc.sco_utils import log
|
|
from app.scodoc.TrivialFormulator import TrivialFormulator, tf_error_message
|
|
from app.scodoc import html_sco_header
|
|
from app.scodoc import sco_core
|
|
from app.scodoc import sco_edit_ue
|
|
from app.scodoc import sco_formations
|
|
from app.scodoc import sco_formsemestre
|
|
from app.scodoc import sco_formsemestre_inscriptions
|
|
from app.scodoc import sco_formsemestre_validation
|
|
from app.scodoc import sco_parcours_dut
|
|
from app.scodoc import sco_etud
|
|
|
|
|
|
def formsemestre_ext_create(context, etudid, sem_params, REQUEST=None):
|
|
"""Crée un formsemestre exterieur et y inscrit l'étudiant.
|
|
sem_params: dict nécessaire à la création du formsemestre
|
|
"""
|
|
# Check args
|
|
_formation = sco_formations.formation_list(
|
|
context, args={"formation_id": sem_params["formation_id"]}
|
|
)[0]
|
|
if etudid:
|
|
_etud = sco_etud.get_etud_info(etudid=etudid, filled=1)[0]
|
|
|
|
# Create formsemestre
|
|
sem_params["modalite"] = "EXT"
|
|
sem_params["etapes"] = None
|
|
sem_params["responsables"] = [str(REQUEST.AUTHENTICATED_USER)]
|
|
formsemestre_id = context.do_formsemestre_create(sem_params, REQUEST, silent=True)
|
|
# nota: le semestre est créé vide: pas de modules
|
|
|
|
# Inscription au semestre
|
|
sco_formsemestre_inscriptions.do_formsemestre_inscription_with_modules(
|
|
context,
|
|
formsemestre_id,
|
|
etudid,
|
|
REQUEST=REQUEST,
|
|
method="formsemestre_ext_create",
|
|
)
|
|
return formsemestre_id
|
|
|
|
|
|
def formsemestre_ext_create_form(context, etudid, formsemestre_id, REQUEST=None):
|
|
"""Formulaire creation/inscription à un semestre extérieur"""
|
|
etud = sco_etud.get_etud_info(etudid=etudid, filled=1)[0]
|
|
H = [
|
|
html_sco_header.sco_header(context, REQUEST),
|
|
"""<h2>Enregistrement d'une inscription antérieure dans un autre établissement</h2>
|
|
<p class="help">
|
|
Cette opération créé un semestre extérieur ("ancien") et y inscrit juste cet étudiant.
|
|
La décision de jury peut ensuite y être saisie.
|
|
</p>
|
|
<p class="help">
|
|
Notez que si un semestre extérieur similaire a déjà été créé pour un autre étudiant,
|
|
il est préférable d'utiliser la fonction
|
|
"<a href="formsemestre_inscription_with_modules_form?etudid=%s&only_ext=1">
|
|
inscrire à un autre semestre</a>"
|
|
</p>
|
|
"""
|
|
% (etudid,),
|
|
"""<h3><a href="ficheEtud?etudid=%s" class="stdlink">Etudiant %s</a></h3>"""
|
|
% (etudid, etud["nomprenom"]),
|
|
]
|
|
F = html_sco_header.sco_footer(context, REQUEST)
|
|
orig_sem = sco_formsemestre.get_formsemestre(context, formsemestre_id)
|
|
# Ne propose que des semestres de semestre_id strictement inférieur au semestre courant
|
|
# et seulement si pas inscrit au même semestre_id d'un semestre ordinaire ScoDoc.
|
|
# Les autres situations (eg redoublements en changeant d'établissement)
|
|
# doivent être gérées par les validations de semestres "antérieurs"
|
|
insem = sco_formsemestre_inscriptions.do_formsemestre_inscription_list(
|
|
context, args={"etudid": etudid, "etat": "I"}
|
|
)
|
|
semlist = [
|
|
sco_formsemestre.get_formsemestre(context, i["formsemestre_id"]) for i in insem
|
|
]
|
|
existing_semestre_ids = set([s["semestre_id"] for s in semlist])
|
|
min_semestre_id = 1
|
|
max_semestre_id = orig_sem["semestre_id"]
|
|
semestre_ids = set(range(min_semestre_id, max_semestre_id)) - existing_semestre_ids
|
|
H.append(
|
|
"""<p>L'étudiant est déjà inscrit dans des semestres ScoDoc de rangs:
|
|
%s
|
|
</p>"""
|
|
% sorted(list(existing_semestre_ids))
|
|
)
|
|
if not semestre_ids:
|
|
H.append("""<p class="warning">pas de semestres extérieurs possibles</p>""")
|
|
return "\n".join(H) + F
|
|
# Formulaire
|
|
semestre_ids_str = [str(x) for x in sorted(semestre_ids)]
|
|
descr = [
|
|
("formsemestre_id", {"input_type": "hidden"}),
|
|
("etudid", {"input_type": "hidden"}),
|
|
(
|
|
"semestre_id",
|
|
{
|
|
"input_type": "menu",
|
|
"title": "Indice du semestre dans le cursus",
|
|
"allowed_values": semestre_ids_str,
|
|
"labels": semestre_ids_str,
|
|
},
|
|
),
|
|
(
|
|
"titre",
|
|
{
|
|
"size": 40,
|
|
"title": "Nom de ce semestre extérieur",
|
|
"explanation": """par exemple: établissement. N'indiquez pas les dates, ni le semestre, ni la modalité dans
|
|
le titre: ils seront automatiquement ajoutés""",
|
|
},
|
|
),
|
|
(
|
|
"date_debut",
|
|
{
|
|
"title": "Date de début", # j/m/a
|
|
"input_type": "date",
|
|
"explanation": "j/m/a (peut être approximatif)",
|
|
"size": 9,
|
|
"allow_null": False,
|
|
},
|
|
),
|
|
(
|
|
"date_fin",
|
|
{
|
|
"title": "Date de fin", # j/m/a
|
|
"input_type": "date",
|
|
"explanation": "j/m/a (peut être approximatif)",
|
|
"size": 9,
|
|
"allow_null": False,
|
|
},
|
|
),
|
|
(
|
|
"elt_help_ue",
|
|
{
|
|
"title": """Les notes et coefficients des UE
|
|
capitalisées seront saisis ensuite""",
|
|
"input_type": "separator",
|
|
},
|
|
),
|
|
]
|
|
|
|
tf = TrivialFormulator(
|
|
REQUEST.URL0,
|
|
REQUEST.form,
|
|
descr,
|
|
cancelbutton="Annuler",
|
|
method="post",
|
|
submitlabel="Créer semestre extérieur et y inscrire l'étudiant",
|
|
cssclass="inscription",
|
|
name="tf",
|
|
)
|
|
if tf[0] == 0:
|
|
H.append(
|
|
"""<p>Ce formulaire sert à enregistrer un semestre antérieur dans la formation
|
|
effectué dans un autre établissement.
|
|
</p>"""
|
|
)
|
|
return "\n".join(H) + "\n" + tf[1] + F
|
|
elif tf[0] == -1:
|
|
return REQUEST.RESPONSE.redirect(
|
|
"%s/formsemestre_bulletinetud?formsemestre_id==%s&etudid=%s"
|
|
% (scu.ScoURL(), formsemestre_id, etudid)
|
|
)
|
|
else:
|
|
tf[2]["formation_id"] = orig_sem["formation_id"]
|
|
formsemestre_ext_create(context, etudid, tf[2], REQUEST=REQUEST)
|
|
return REQUEST.RESPONSE.redirect(
|
|
"%s/ficheEtud?etudid=%s" % (scu.ScoURL(), etudid)
|
|
)
|
|
|
|
|
|
def formsemestre_ext_edit_ue_validations(
|
|
context, formsemestre_id, etudid, REQUEST=None
|
|
):
|
|
"""Edition des validations d'UE et de semestre (jury)
|
|
pour un semestre extérieur.
|
|
On peut saisir pour chaque UE du programme de formation
|
|
sa validation, son code jury, sa note, son coefficient.
|
|
|
|
La moyenne générale du semestre est calculée et affichée,
|
|
mais pas enregistrée.
|
|
"""
|
|
sem = sco_formsemestre.get_formsemestre(context, formsemestre_id)
|
|
etud = sco_etud.get_etud_info(etudid=etudid, filled=True)[0]
|
|
ue_list = _list_ue_with_coef_and_validations(context, sem, etudid)
|
|
descr = _ue_form_description(context, ue_list, REQUEST.form)
|
|
if REQUEST and REQUEST.method == "GET":
|
|
initvalues = {
|
|
"note_" + ue["ue_id"]: ue["validation"].get("moy_ue", "") for ue in ue_list
|
|
}
|
|
else:
|
|
initvalues = {}
|
|
tf = TrivialFormulator(
|
|
REQUEST.URL0,
|
|
REQUEST.form,
|
|
descr,
|
|
cssclass="tf_ext_edit_ue_validations",
|
|
submitlabel="Enregistrer ces validations",
|
|
cancelbutton="Annuler",
|
|
initvalues=initvalues,
|
|
)
|
|
if tf[0] == -1:
|
|
return "<h4>annulation</h4>"
|
|
else:
|
|
H = _make_page(context, etud, sem, tf, REQUEST=REQUEST)
|
|
if tf[0] == 0: # premier affichage
|
|
return "\n".join(H)
|
|
else: # soumission
|
|
# simule erreur
|
|
ok, message = _check_values(context, ue_list, tf[2])
|
|
if not ok:
|
|
H = _make_page(context, etud, sem, tf, message=message, REQUEST=REQUEST)
|
|
return "\n".join(H)
|
|
else:
|
|
# Submit
|
|
_record_ue_validations_and_coefs(
|
|
context, formsemestre_id, etudid, ue_list, tf[2], REQUEST=REQUEST
|
|
)
|
|
return REQUEST.RESPONSE.redirect(
|
|
"formsemestre_bulletinetud?formsemestre_id=%s&etudid=%s"
|
|
% (formsemestre_id, etudid)
|
|
)
|
|
|
|
|
|
def _make_page(context, etud, sem, tf, message="", REQUEST=None):
|
|
nt = sco_core.get_notes_cache(
|
|
context,
|
|
).get_NotesTable(context, sem["formsemestre_id"])
|
|
moy_gen = nt.get_etud_moy_gen(etud["etudid"])
|
|
H = [
|
|
html_sco_header.sco_header(
|
|
context,
|
|
REQUEST,
|
|
page_title="Validation des UE d'un semestre extérieur",
|
|
javascripts=["js/formsemestre_ext_edit_ue_validations.js"],
|
|
),
|
|
tf_error_message(message),
|
|
"""<p><b>%(nomprenom)s</b> est inscrit%(ne)s à ce semestre extérieur.</p>
|
|
<p>Voici les UE entregistrées avec leur notes et coefficients.
|
|
</p>
|
|
"""
|
|
% etud,
|
|
"""<p>La moyenne de ce semestre serait:
|
|
<span class="ext_sem_moy"><span class="ext_sem_moy_val">%s</span> / 20</span>
|
|
</p>
|
|
"""
|
|
% moy_gen,
|
|
'<div id="formsemestre_ext_edit_ue_validations">',
|
|
tf[1],
|
|
"</div>",
|
|
"""<div>
|
|
<a class="stdlink"
|
|
href="formsemestre_bulletinetud?formsemestre_id=%s&etudid=%s">
|
|
retour au bulletin de notes
|
|
</a></div>
|
|
"""
|
|
% (sem["formsemestre_id"], etud["etudid"]),
|
|
html_sco_header.sco_footer(context, REQUEST),
|
|
]
|
|
return H
|
|
|
|
|
|
_UE_VALID_CODES = {
|
|
None: "Non inscrit",
|
|
"ADM": "Capitalisée (ADM)",
|
|
# "CMP": "Acquise (car semestre validé)",
|
|
}
|
|
|
|
|
|
def _ue_form_description(context, ue_list, values):
|
|
"""Description du formulaire de saisie des UE / validations
|
|
Pour chaque UE, on peut saisir: son code jury, sa note, son coefficient.
|
|
"""
|
|
descr = [
|
|
(
|
|
"head_sep",
|
|
{
|
|
"input_type": "separator",
|
|
"template": """<tr %(item_dom_attr)s><th>UE</th>
|
|
<th>Code jury</th><th>Note/20</th><th>Coefficient UE</th></tr>
|
|
""",
|
|
},
|
|
),
|
|
("formsemestre_id", {"input_type": "hidden"}),
|
|
("etudid", {"input_type": "hidden"}),
|
|
]
|
|
for ue in ue_list:
|
|
# Menu pour code validation UE:
|
|
# Ne propose que ADM, CMP et "Non inscrit"
|
|
select_name = "valid_" + ue["ue_id"]
|
|
menu_code_UE = """<select class="ueext_valid_select" name="%s">""" % (
|
|
select_name,
|
|
)
|
|
cur_value = values.get("valid_" + ue["ue_id"], False)
|
|
for code in _UE_VALID_CODES:
|
|
if cur_value is False: # pas dans le form, cherche en base
|
|
cur_value = ue["validation"].get("code", None)
|
|
if str(cur_value) == str(code):
|
|
selected = "selected"
|
|
else:
|
|
selected = ""
|
|
menu_code_UE += '<option value="%s" %s>%s</option>' % (
|
|
code,
|
|
selected,
|
|
_UE_VALID_CODES[code],
|
|
)
|
|
if cur_value is None:
|
|
disabled = 'disabled="1"'
|
|
else:
|
|
disabled = ""
|
|
menu_code_UE += "</select>"
|
|
cur_value = values.get("coef_" + ue["ue_id"], False)
|
|
if cur_value is False: # pas dans le form, cherche en base
|
|
cur_value = ue["uecoef"].get("coefficient", "")
|
|
itemtemplate = (
|
|
"""<tr><td class="tf-fieldlabel">%(label)s</td>"""
|
|
+ "<td>"
|
|
+ menu_code_UE
|
|
+ "</td>" # code jury
|
|
+ '<td class="tf-field tf_field_note">%(elem)s</td>' # note
|
|
+ """<td class="tf-field tf_field_coef">
|
|
<input type="text" size="4" name="coef_%s" value="%s" %s></input></td>
|
|
"""
|
|
% (ue["ue_id"], cur_value, disabled)
|
|
+ "</td></tr>"
|
|
)
|
|
descr.append(
|
|
(
|
|
"note_" + str(ue["ue_id"]),
|
|
{
|
|
"input_type": "text",
|
|
"size": 4,
|
|
"template": itemtemplate,
|
|
"title": "<tt><b>%(acronyme)s</b></tt> %(titre)s" % ue,
|
|
"attributes": [disabled],
|
|
},
|
|
)
|
|
)
|
|
return descr
|
|
|
|
|
|
def _check_values(context, ue_list, values):
|
|
"""Check that form values are ok
|
|
for each UE:
|
|
code != None => note and coef
|
|
note or coef => code != None
|
|
note float in [0, 20]
|
|
note => coef
|
|
coef float >= 0
|
|
"""
|
|
for ue in ue_list:
|
|
pu = " pour UE %s" % ue["acronyme"]
|
|
code = values.get("valid_" + ue["ue_id"], False)
|
|
if code == "None":
|
|
code = None
|
|
note = values.get("note_" + ue["ue_id"], False)
|
|
try:
|
|
note = _convert_field_to_float(note)
|
|
except ValueError:
|
|
return False, "note invalide" + pu
|
|
coef = values.get("coef_" + ue["ue_id"], False)
|
|
try:
|
|
coef = _convert_field_to_float(coef)
|
|
except ValueError:
|
|
return False, "coefficient invalide" + pu
|
|
if code != False:
|
|
if code not in _UE_VALID_CODES:
|
|
return False, "code invalide" + pu
|
|
if code != None:
|
|
if note is False or note is "":
|
|
return False, "note manquante" + pu
|
|
if note != False and note != "":
|
|
if code == None:
|
|
return (
|
|
False,
|
|
"code jury incohérent (code %s, note %s)" % (code, note)
|
|
+ pu
|
|
+ " (supprimer note et coef)",
|
|
)
|
|
if note < 0 or note > 20:
|
|
return False, "valeur note invalide" + pu
|
|
if not isinstance(coef, float):
|
|
return False, "coefficient manquant pour note %s" % note + pu
|
|
if coef != False and coef != "":
|
|
if coef < 0:
|
|
return False, "valeur coefficient invalide" + pu
|
|
return True, "ok"
|
|
|
|
|
|
def _convert_field_to_float(val):
|
|
"""value may be empty, False, or a float. Raise exception"""
|
|
if val != False:
|
|
val = val.strip()
|
|
if val:
|
|
val = float(val)
|
|
return val
|
|
|
|
|
|
def _list_ue_with_coef_and_validations(context, sem, etudid):
|
|
"""Liste des UE de la même formation que sem,
|
|
avec leurs coefs d'UE capitalisée (si déjà saisi)
|
|
et leur validation pour cet étudiant.
|
|
"""
|
|
cnx = ndb.GetDBConnexion()
|
|
formsemestre_id = sem["formsemestre_id"]
|
|
ue_list = sco_edit_ue.do_ue_list(context, {"formation_id": sem["formation_id"]})
|
|
for ue in ue_list:
|
|
# add coefficient
|
|
uecoef = sco_formsemestre.formsemestre_uecoef_list(
|
|
cnx, args={"formsemestre_id": formsemestre_id, "ue_id": ue["ue_id"]}
|
|
)
|
|
if uecoef:
|
|
ue["uecoef"] = uecoef[0]
|
|
else:
|
|
ue["uecoef"] = {}
|
|
# add validation
|
|
validation = sco_parcours_dut.scolar_formsemestre_validation_list(
|
|
cnx,
|
|
args={
|
|
"formsemestre_id": formsemestre_id,
|
|
"etudid": etudid,
|
|
"ue_id": ue["ue_id"],
|
|
},
|
|
)
|
|
if validation:
|
|
ue["validation"] = validation[0]
|
|
else:
|
|
ue["validation"] = {}
|
|
return ue_list
|
|
|
|
|
|
def _record_ue_validations_and_coefs(
|
|
context, formsemestre_id, etudid, ue_list, values, REQUEST=None
|
|
):
|
|
for ue in ue_list:
|
|
code = values.get("valid_" + ue["ue_id"], False)
|
|
if code == "None":
|
|
code = None
|
|
note = values.get("note_" + ue["ue_id"], False)
|
|
note = _convert_field_to_float(note)
|
|
coef = values.get("coef_" + ue["ue_id"], False)
|
|
coef = _convert_field_to_float(coef)
|
|
if coef == "" or coef == False:
|
|
coef = None
|
|
now_dmy = time.strftime("%d/%m/%Y")
|
|
log(
|
|
"_record_ue_validations_and_coefs: %s etudid=%s ue_id=%s moy_ue=%s ue_coef=%s"
|
|
% (formsemestre_id, etudid, ue["ue_id"], note, repr(coef))
|
|
)
|
|
assert code == None or (note) # si code validant, il faut une note
|
|
sco_formsemestre_validation.do_formsemestre_validate_previous_ue(
|
|
context,
|
|
formsemestre_id,
|
|
etudid,
|
|
ue["ue_id"],
|
|
note,
|
|
now_dmy,
|
|
code=code,
|
|
ue_coefficient=coef,
|
|
REQUEST=REQUEST,
|
|
)
|