forked from ScoDoc/ScoDoc
400 lines
14 KiB
Python
400 lines
14 KiB
Python
# -*- mode: python -*-
|
|
# -*- coding: utf-8 -*-
|
|
|
|
##############################################################################
|
|
#
|
|
# Gestion scolarite IUT
|
|
#
|
|
# Copyright (c) 1999 - 2023 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@gmail.com
|
|
#
|
|
##############################################################################
|
|
|
|
"""Gestion evaluations (ScoDoc7, sans SQlAlchemy)
|
|
"""
|
|
|
|
import pprint
|
|
|
|
import flask
|
|
from flask import url_for, g
|
|
from flask_login import current_user
|
|
|
|
from app import log
|
|
|
|
from app.models import ModuleImpl, ScolarNews
|
|
from app.models.evaluations import evaluation_enrich_dict, check_evaluation_args
|
|
import app.scodoc.sco_utils as scu
|
|
import app.scodoc.notesdb as ndb
|
|
from app.scodoc.sco_exceptions import AccessDenied, ScoValueError
|
|
|
|
from app.scodoc import sco_cache
|
|
from app.scodoc import sco_edit_module
|
|
from app.scodoc import sco_moduleimpl
|
|
from app.scodoc import sco_permissions_check
|
|
|
|
|
|
_evaluationEditor = ndb.EditableTable(
|
|
"notes_evaluation",
|
|
"evaluation_id",
|
|
(
|
|
"evaluation_id",
|
|
"moduleimpl_id",
|
|
"jour",
|
|
"heure_debut",
|
|
"heure_fin",
|
|
"description",
|
|
"note_max",
|
|
"coefficient",
|
|
"visibulletin",
|
|
"publish_incomplete",
|
|
"evaluation_type",
|
|
"numero",
|
|
),
|
|
sortkey="numero desc, jour desc, heure_debut desc", # plus recente d'abord
|
|
output_formators={
|
|
"jour": ndb.DateISOtoDMY,
|
|
"numero": ndb.int_null_is_zero,
|
|
},
|
|
input_formators={
|
|
"jour": ndb.DateDMYtoISO,
|
|
"heure_debut": ndb.TimetoISO8601, # converti par evaluation_enrich_dict
|
|
"heure_fin": ndb.TimetoISO8601, # converti par evaluation_enrich_dict
|
|
"visibulletin": bool,
|
|
"publish_incomplete": bool,
|
|
"evaluation_type": int,
|
|
},
|
|
)
|
|
|
|
|
|
def do_evaluation_list(args, sortkey=None):
|
|
"""List evaluations, sorted by numero (or most recent date first).
|
|
|
|
Ajoute les champs:
|
|
'duree' : '2h30'
|
|
'matin' : 1 (commence avant 12:00) ou 0
|
|
'apresmidi' : 1 (termine après 12:00) ou 0
|
|
'descrheure' : ' de 15h00 à 16h30'
|
|
"""
|
|
# Attention: transformation fonction ScoDoc7 en SQLAlchemy
|
|
cnx = ndb.GetDBConnexion()
|
|
evals = _evaluationEditor.list(cnx, args, sortkey=sortkey)
|
|
# calcule duree (chaine de car.) de chaque evaluation et ajoute jour_iso, matin, apresmidi
|
|
for e in evals:
|
|
evaluation_enrich_dict(e)
|
|
|
|
return evals
|
|
|
|
|
|
def do_evaluation_list_in_formsemestre(formsemestre_id):
|
|
"list evaluations in this formsemestre"
|
|
mods = sco_moduleimpl.moduleimpl_list(formsemestre_id=formsemestre_id)
|
|
evals = []
|
|
for modimpl in mods:
|
|
evals += do_evaluation_list(args={"moduleimpl_id": modimpl["moduleimpl_id"]})
|
|
return evals
|
|
|
|
|
|
def do_evaluation_create(
|
|
moduleimpl_id=None,
|
|
jour=None,
|
|
heure_debut=None,
|
|
heure_fin=None,
|
|
description=None,
|
|
note_max=None,
|
|
coefficient=None,
|
|
visibulletin=None,
|
|
publish_incomplete=None,
|
|
evaluation_type=None,
|
|
numero=None,
|
|
**kw, # ceci pour absorber les arguments excedentaires de tf #sco8
|
|
):
|
|
"""Create an evaluation"""
|
|
if not sco_permissions_check.can_edit_evaluation(moduleimpl_id=moduleimpl_id):
|
|
raise AccessDenied(
|
|
f"Modification évaluation impossible pour {current_user.get_nomplogin()}"
|
|
)
|
|
args = locals()
|
|
log("do_evaluation_create: args=" + str(args))
|
|
modimpl: ModuleImpl = ModuleImpl.query.get(moduleimpl_id)
|
|
if modimpl is None:
|
|
raise ValueError("module not found")
|
|
check_evaluation_args(args)
|
|
# Check numeros
|
|
module_evaluation_renumber(moduleimpl_id, only_if_unumbered=True)
|
|
if not "numero" in args or args["numero"] is None:
|
|
n = None
|
|
# determine le numero avec la date
|
|
# Liste des eval existantes triees par date, la plus ancienne en tete
|
|
mod_evals = do_evaluation_list(
|
|
args={"moduleimpl_id": moduleimpl_id},
|
|
sortkey="jour asc, heure_debut asc",
|
|
)
|
|
if args["jour"]:
|
|
next_eval = None
|
|
t = (
|
|
ndb.DateDMYtoISO(args["jour"], null_is_empty=True),
|
|
ndb.TimetoISO8601(args["heure_debut"], null_is_empty=True),
|
|
)
|
|
for e in mod_evals:
|
|
if (
|
|
ndb.DateDMYtoISO(e["jour"], null_is_empty=True),
|
|
ndb.TimetoISO8601(e["heure_debut"], null_is_empty=True),
|
|
) > t:
|
|
next_eval = e
|
|
break
|
|
if next_eval:
|
|
n = module_evaluation_insert_before(mod_evals, next_eval)
|
|
else:
|
|
n = None # a placer en fin
|
|
if n is None: # pas de date ou en fin:
|
|
if mod_evals:
|
|
log(pprint.pformat(mod_evals[-1]))
|
|
n = mod_evals[-1]["numero"] + 1
|
|
else:
|
|
n = 0 # the only one
|
|
# log("creating with numero n=%d" % n)
|
|
args["numero"] = n
|
|
|
|
#
|
|
cnx = ndb.GetDBConnexion()
|
|
r = _evaluationEditor.create(cnx, args)
|
|
|
|
# news
|
|
sco_cache.invalidate_formsemestre(formsemestre_id=modimpl.formsemestre_id)
|
|
url = url_for(
|
|
"notes.moduleimpl_status",
|
|
scodoc_dept=g.scodoc_dept,
|
|
moduleimpl_id=moduleimpl_id,
|
|
)
|
|
ScolarNews.add(
|
|
typ=ScolarNews.NEWS_NOTE,
|
|
obj=moduleimpl_id,
|
|
text=f"""Création d'une évaluation dans <a href="{url}">{
|
|
modimpl.module.titre or '(module sans titre)'}</a>""",
|
|
url=url,
|
|
)
|
|
|
|
return r
|
|
|
|
|
|
def do_evaluation_edit(args):
|
|
"edit an evaluation"
|
|
evaluation_id = args["evaluation_id"]
|
|
the_evals = do_evaluation_list({"evaluation_id": evaluation_id})
|
|
if not the_evals:
|
|
raise ValueError("evaluation inexistante !")
|
|
moduleimpl_id = the_evals[0]["moduleimpl_id"]
|
|
if not sco_permissions_check.can_edit_evaluation(moduleimpl_id=moduleimpl_id):
|
|
raise AccessDenied(
|
|
"Modification évaluation impossible pour %s" % current_user.get_nomplogin()
|
|
)
|
|
args["moduleimpl_id"] = moduleimpl_id
|
|
check_evaluation_args(args)
|
|
|
|
cnx = ndb.GetDBConnexion()
|
|
_evaluationEditor.edit(cnx, args)
|
|
# inval cache pour ce semestre
|
|
M = sco_moduleimpl.moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
|
|
sco_cache.invalidate_formsemestre(formsemestre_id=M["formsemestre_id"])
|
|
|
|
|
|
def do_evaluation_delete(evaluation_id):
|
|
"delete evaluation"
|
|
the_evals = do_evaluation_list({"evaluation_id": evaluation_id})
|
|
if not the_evals:
|
|
raise ValueError("evaluation inexistante !")
|
|
moduleimpl_id = the_evals[0]["moduleimpl_id"]
|
|
if not sco_permissions_check.can_edit_evaluation(moduleimpl_id=moduleimpl_id):
|
|
raise AccessDenied(
|
|
"Modification évaluation impossible pour %s" % current_user.get_nomplogin()
|
|
)
|
|
notes_db = do_evaluation_get_all_notes(evaluation_id) # { etudid : value }
|
|
notes = [x["value"] for x in notes_db.values()]
|
|
if notes:
|
|
raise ScoValueError(
|
|
"Impossible de supprimer cette évaluation: il reste des notes"
|
|
)
|
|
|
|
cnx = ndb.GetDBConnexion()
|
|
|
|
_evaluationEditor.delete(cnx, evaluation_id)
|
|
# inval cache pour ce semestre
|
|
M = sco_moduleimpl.moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
|
|
sco_cache.invalidate_formsemestre(formsemestre_id=M["formsemestre_id"])
|
|
# news
|
|
|
|
mod = sco_edit_module.module_list(args={"module_id": M["module_id"]})[0]
|
|
mod["moduleimpl_id"] = M["moduleimpl_id"]
|
|
mod["url"] = (
|
|
scu.NotesURL() + "/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
|
|
)
|
|
ScolarNews.add(
|
|
typ=ScolarNews.NEWS_NOTE,
|
|
obj=moduleimpl_id,
|
|
text='Suppression d\'une évaluation dans <a href="%(url)s">%(titre)s</a>' % mod,
|
|
url=mod["url"],
|
|
)
|
|
|
|
|
|
# ancien _notes_getall
|
|
def do_evaluation_get_all_notes(
|
|
evaluation_id, table="notes_notes", filter_suppressed=True, by_uid=None
|
|
):
|
|
"""Toutes les notes pour une evaluation: { etudid : { 'value' : value, 'date' : date ... }}
|
|
Attention: inclut aussi les notes des étudiants qui ne sont plus inscrits au module.
|
|
"""
|
|
do_cache = (
|
|
filter_suppressed and table == "notes_notes" and (by_uid is None)
|
|
) # pas de cache pour (rares) appels via undo_notes ou specifiant un enseignant
|
|
if do_cache:
|
|
r = sco_cache.EvaluationCache.get(evaluation_id)
|
|
if r != None:
|
|
return r
|
|
cnx = ndb.GetDBConnexion()
|
|
cursor = cnx.cursor(cursor_factory=ndb.ScoDocCursor)
|
|
cond = " where evaluation_id=%(evaluation_id)s"
|
|
if by_uid:
|
|
cond += " and uid=%(by_uid)s"
|
|
|
|
cursor.execute(
|
|
"select * from " + table + cond,
|
|
{"evaluation_id": evaluation_id, "by_uid": by_uid},
|
|
)
|
|
res = cursor.dictfetchall()
|
|
d = {}
|
|
if filter_suppressed:
|
|
for x in res:
|
|
if x["value"] != scu.NOTES_SUPPRESS:
|
|
d[x["etudid"]] = x
|
|
else:
|
|
for x in res:
|
|
d[x["etudid"]] = x
|
|
if do_cache:
|
|
status = sco_cache.EvaluationCache.set(evaluation_id, d)
|
|
if not status:
|
|
log(f"Warning: EvaluationCache.set: {evaluation_id}\t{status}")
|
|
return d
|
|
|
|
|
|
def module_evaluation_renumber(moduleimpl_id, only_if_unumbered=False, redirect=0):
|
|
"""Renumber evaluations in this module, according to their date. (numero=0: oldest one)
|
|
Needed because previous versions of ScoDoc did not have eval numeros
|
|
Note: existing numeros are ignored
|
|
"""
|
|
redirect = int(redirect)
|
|
# log('module_evaluation_renumber( moduleimpl_id=%s )' % moduleimpl_id )
|
|
# List sorted according to date/heure, ignoring numeros:
|
|
# (note that we place evaluations with NULL date at the end)
|
|
mod_evals = do_evaluation_list(
|
|
args={"moduleimpl_id": moduleimpl_id},
|
|
sortkey="jour asc, heure_debut asc",
|
|
)
|
|
|
|
all_numbered = False not in [x["numero"] > 0 for x in mod_evals]
|
|
if all_numbered and only_if_unumbered:
|
|
return # all ok
|
|
|
|
# Reset all numeros:
|
|
i = 1
|
|
for e in mod_evals:
|
|
e["numero"] = i
|
|
do_evaluation_edit(e)
|
|
i += 1
|
|
|
|
# If requested, redirect to moduleimpl page:
|
|
if redirect:
|
|
return flask.redirect(
|
|
url_for(
|
|
"notes.moduleimpl_status",
|
|
scodoc_dept=g.scodoc_dept,
|
|
moduleimpl_id=moduleimpl_id,
|
|
)
|
|
)
|
|
|
|
|
|
def module_evaluation_insert_before(mod_evals, next_eval):
|
|
"""Renumber evals such that an evaluation with can be inserted before next_eval
|
|
Returns numero suitable for the inserted evaluation
|
|
"""
|
|
if next_eval:
|
|
n = next_eval["numero"]
|
|
if not n:
|
|
log("renumbering old evals")
|
|
module_evaluation_renumber(next_eval["moduleimpl_id"])
|
|
next_eval = do_evaluation_list(
|
|
args={"evaluation_id": next_eval["evaluation_id"]}
|
|
)[0]
|
|
n = next_eval["numero"]
|
|
else:
|
|
n = 1
|
|
# log('inserting at position numero %s' % n )
|
|
# all numeros >= n are incremented
|
|
for e in mod_evals:
|
|
if e["numero"] >= n:
|
|
e["numero"] += 1
|
|
# log('incrementing %s to %s' % (e['evaluation_id'], e['numero']))
|
|
do_evaluation_edit(e)
|
|
|
|
return n
|
|
|
|
|
|
def module_evaluation_move(evaluation_id, after=0, redirect=1):
|
|
"""Move before/after previous one (decrement/increment numero)
|
|
(published)
|
|
"""
|
|
e = do_evaluation_list(args={"evaluation_id": evaluation_id})[0]
|
|
redirect = int(redirect)
|
|
# access: can change eval ?
|
|
if not sco_permissions_check.can_edit_evaluation(moduleimpl_id=e["moduleimpl_id"]):
|
|
raise AccessDenied(
|
|
"Modification évaluation impossible pour %s" % current_user.get_nomplogin()
|
|
)
|
|
|
|
module_evaluation_renumber(e["moduleimpl_id"], only_if_unumbered=True)
|
|
e = do_evaluation_list(args={"evaluation_id": evaluation_id})[0]
|
|
|
|
after = int(after) # 0: deplace avant, 1 deplace apres
|
|
if after not in (0, 1):
|
|
raise ValueError('invalid value for "after"')
|
|
mod_evals = do_evaluation_list({"moduleimpl_id": e["moduleimpl_id"]})
|
|
if len(mod_evals) > 1:
|
|
idx = [p["evaluation_id"] for p in mod_evals].index(evaluation_id)
|
|
neigh = None # object to swap with
|
|
if after == 0 and idx > 0:
|
|
neigh = mod_evals[idx - 1]
|
|
elif after == 1 and idx < len(mod_evals) - 1:
|
|
neigh = mod_evals[idx + 1]
|
|
if neigh: #
|
|
if neigh["numero"] == e["numero"]:
|
|
log("Warning: module_evaluation_move: forcing renumber")
|
|
module_evaluation_renumber(e["moduleimpl_id"], only_if_unumbered=False)
|
|
else:
|
|
# swap numero with neighbor
|
|
e["numero"], neigh["numero"] = neigh["numero"], e["numero"]
|
|
do_evaluation_edit(e)
|
|
do_evaluation_edit(neigh)
|
|
# redirect to moduleimpl page:
|
|
if redirect:
|
|
return flask.redirect(
|
|
url_for(
|
|
"notes.moduleimpl_status",
|
|
scodoc_dept=g.scodoc_dept,
|
|
moduleimpl_id=e["moduleimpl_id"],
|
|
)
|
|
)
|