# -*- mode: python -*- # -*- coding: utf-8 -*- ############################################################################## # # Gestion scolarite IUT # # Copyright (c) 1999 - 2020 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 # ############################################################################## """Evaluations """ from notes_log import log, logCallStack from sco_utils import * from notesdb import * from gen_tables import GenTable import sco_news import sco_formsemestre import sco_groups import ZAbsences # -------------------------------------------------------------------- # # MISC AUXILIARY FUNCTIONS # # -------------------------------------------------------------------- def notes_moyenne_median_mini_maxi(notes): "calcule moyenne et mediane d'une liste de valeurs (floats)" notes = [ x for x in notes if (x != None) and (x != NOTES_NEUTRALISE) and (x != NOTES_ATTENTE) ] n = len(notes) if not n: return None, None, None, None moy = sum(notes) / n median = ListMedian(notes) mini = min(notes) maxi = max(notes) return moy, median, mini, maxi def ListMedian(L): """Median of a list L""" n = len(L) if not n: raise ValueError("empty list") L.sort() if n % 2: return L[n / 2] else: return (L[n / 2] + L[n / 2 - 1]) / 2 # -------------------------------------------------------------------- def do_evaluation_delete(context, REQUEST, evaluation_id): "delete evaluation" the_evals = context.do_evaluation_list({"evaluation_id": evaluation_id}) if not the_evals: raise ValueError("evaluation inexistante !") NotesDB = context._notes_getall(evaluation_id) # { etudid : value } notes = [x["value"] for x in NotesDB.values()] if notes: raise ScoValueError( "Impossible de supprimer cette évaluation: il reste des notes" ) moduleimpl_id = the_evals[0]["moduleimpl_id"] context._evaluation_check_write_access(REQUEST, moduleimpl_id=moduleimpl_id) cnx = context.GetDBConnexion() context._evaluationEditor.delete(cnx, evaluation_id) # inval cache pour ce semestre M = context.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0] context._inval_cache(formsemestre_id=M["formsemestre_id"]) # > eval delete # news mod = context.do_module_list(args={"module_id": M["module_id"]})[0] mod["moduleimpl_id"] = M["moduleimpl_id"] mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod sco_news.add( context, REQUEST, typ=sco_news.NEWS_NOTE, object=moduleimpl_id, text='Suppression d\'une évaluation dans %(titre)s' % mod, url=mod["url"], ) _DEE_TOT = 0 def do_evaluation_etat( context, evaluation_id, partition_id=None, select_first_partition=False ): """donne infos sur l'etat du evaluation { nb_inscrits, nb_notes, nb_abs, nb_neutre, nb_att, moyenne, mediane, mini, maxi, date_last_modif, gr_complets, gr_incomplets, evalcomplete } evalcomplete est vrai si l'eval est complete (tous les inscrits à ce module ont des notes) evalattente est vrai s'il ne manque que des notes en attente """ # global _DEE_TOT # t0=time.time() # if evaluation_id == 'GEAEVAL82883': # log('do_evaluation_etat: evaluation_id=%s partition_id=%s sfp=%s' % (evaluation_id, partition_id, select_first_partition)) nb_inscrits = len( sco_groups.do_evaluation_listeetuds_groups( context, evaluation_id, getallstudents=True ) ) NotesDB = context._notes_getall(evaluation_id) # { etudid : value } notes = [x["value"] for x in NotesDB.values()] nb_abs = len([x for x in notes if x is None]) nb_neutre = len([x for x in notes if x == NOTES_NEUTRALISE]) nb_att = len([x for x in notes if x == NOTES_ATTENTE]) moy_num, median_num, mini_num, maxi_num = notes_moyenne_median_mini_maxi(notes) if moy_num is None: median, moy = "", "" median_num, moy_num = None, None mini, maxi = "", "" mini_num, maxi_num = None, None else: median = fmt_note(median_num) moy = fmt_note(moy_num) mini = fmt_note(mini_num) maxi = fmt_note(maxi_num) # cherche date derniere modif note if len(NotesDB): t = [x["date"] for x in NotesDB.values()] last_modif = max(t) else: last_modif = None # ---- Liste des groupes complets et incomplets E = context.do_evaluation_list(args={"evaluation_id": evaluation_id})[0] M = context.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0] Mod = context.do_module_list(args={"module_id": M["module_id"]})[0] is_malus = Mod["module_type"] == MODULE_MALUS # True si module de malus formsemestre_id = M["formsemestre_id"] # Si partition_id is None, prend 'all' ou bien la premiere: if partition_id is None: if select_first_partition: partitions = sco_groups.get_partitions_list(context, formsemestre_id) partition = partitions[0] else: partition = sco_groups.get_default_partition(context, formsemestre_id) partition_id = partition["partition_id"] # Il faut considerer les inscriptions au semestre # (pour avoir l'etat et le groupe) et aussi les inscriptions # au module (pour gerer les modules optionnels correctement) insem = context.do_formsemestre_inscription_listinscrits(formsemestre_id) insmod = context.do_moduleimpl_inscription_list(moduleimpl_id=E["moduleimpl_id"]) insmodset = set([x["etudid"] for x in insmod]) # retire de insem ceux qui ne sont pas inscrits au module ins = [i for i in insem if i["etudid"] in insmodset] # Nombre de notes valides d'étudiants inscrits au module # (car il peut y avoir des notes d'étudiants désinscrits depuis l'évaluation) nb_notes = len(insmodset.intersection(NotesDB)) nb_notes_total = len(NotesDB) # On considere une note "manquante" lorsqu'elle n'existe pas # ou qu'elle est en attente (ATT) GrNbMissing = DictDefault() # group_id : nb notes manquantes GrNotes = DictDefault(defaultvalue=[]) # group_id: liste notes valides TotalNbMissing = 0 TotalNbAtt = 0 groups = {} # group_id : group etud_groups = sco_groups.get_etud_groups_in_partition(context, partition_id) for i in ins: group = etud_groups.get(i["etudid"], None) if group and not group["group_id"] in groups: groups[group["group_id"]] = group # isMissing = False if NotesDB.has_key(i["etudid"]): val = NotesDB[i["etudid"]]["value"] if val == NOTES_ATTENTE: isMissing = True TotalNbAtt += 1 if group: GrNotes[group["group_id"]].append(val) else: if group: junk = GrNotes[group["group_id"]] # create group isMissing = True if isMissing: TotalNbMissing += 1 if group: GrNbMissing[group["group_id"]] += 1 gr_incomplets = [x for x in GrNbMissing.keys()] gr_incomplets.sort() if ( (TotalNbMissing > 0) and (E["evaluation_type"] != EVALUATION_RATTRAPAGE) and not is_malus ): complete = False else: complete = True if ( TotalNbMissing > 0 and (TotalNbMissing == TotalNbAtt or E["publish_incomplete"] != "0") and not is_malus ): evalattente = True else: evalattente = False # Calcul moyenne dans chaque groupe de TD gr_moyennes = [] # group : {moy,median, nb_notes} for group_id in GrNotes.keys(): notes = GrNotes[group_id] gr_moy, gr_median, gr_mini, gr_maxi = notes_moyenne_median_mini_maxi(notes) gr_moyennes.append( { "group_id": group_id, "group_name": groups[group_id]["group_name"], "gr_moy_num": gr_moy, "gr_moy": fmt_note(gr_moy), "gr_median_num": gr_median, "gr_median": fmt_note(gr_median), "gr_mini": fmt_note(gr_mini), "gr_maxi": fmt_note(gr_maxi), "gr_mini": gr_mini, "gr_maxi": gr_maxi, "gr_nb_notes": len(notes), "gr_nb_att": len([x for x in notes if x == NOTES_ATTENTE]), } ) gr_moyennes.sort(key=operator.itemgetter("group_name")) # log('gr_moyennes=%s' % gr_moyennes) # _DEE_TOT += (time.time() - t0) # log('%s\t_DEE_TOT=%f' % (evaluation_id, _DEE_TOT)) # if evaluation_id == 'GEAEVAL82883': # logCallStack() # retourne mapping return { "evaluation_id": evaluation_id, "nb_inscrits": nb_inscrits, "nb_notes": nb_notes, # nb notes etudiants inscrits "nb_notes_total": nb_notes_total, # nb de notes (incluant desinscrits) "nb_abs": nb_abs, "nb_neutre": nb_neutre, "nb_att": nb_att, "moy": moy, "moy_num": moy_num, "median": median, "mini": mini, "mini_num": mini_num, "maxi": maxi, "maxi_num": maxi_num, "median_num": median_num, "last_modif": last_modif, "gr_incomplets": gr_incomplets, "gr_moyennes": gr_moyennes, "groups": groups, "evalcomplete": complete, "evalattente": evalattente, "is_malus": is_malus, } def do_evaluation_list_in_sem(context, formsemestre_id): """Liste les evaluations de tous les modules de ce semestre. Donne pour chaque eval son état (voir do_evaluation_etat) { evaluation_id,nb_inscrits, nb_notes, nb_abs, nb_neutre, moy, median, last_modif ... } Exemple: [ { 'coefficient': 1.0, 'description': 'QCM et cas pratiques', 'etat': {'evalattente': False, 'evalcomplete': True, 'evaluation_id': 'GEAEVAL82883', 'gr_incomplets': [], 'gr_moyennes': [{'gr_median': '12.00', 'gr_median_num' : 12., 'gr_moy': '11.88', 'gr_moy_num' : 11.88, 'gr_nb_att': 0, 'gr_nb_notes': 166, 'group_id': 'GEAG266762', 'group_name': None}], 'groups': {'GEAG266762': {'etudid': 'GEAEID80603', 'group_id': 'GEAG266762', 'group_name': None, 'partition_id': 'GEAP266761'} }, 'last_modif': datetime.datetime(2015, 12, 3, 15, 15, 16), 'median': '12.00', 'moy': '11.84', 'nb_abs': 2, 'nb_att': 0, 'nb_inscrits': 166, 'nb_neutre': 0, 'nb_notes': 168, 'nb_notes_total': 169 }, 'evaluation_id': 'GEAEVAL82883', 'evaluation_type': 0, 'heure_debut': datetime.time(8, 0), 'heure_fin': datetime.time(9, 30), 'jour': datetime.date(2015, 11, 3), // vide => 1/1/1 'moduleimpl_id': 'GEAMIP80490', 'note_max': 20.0, 'numero': 0, 'publish_incomplete': 0, 'visibulletin': 1} ] """ req = "select E.* from notes_evaluation E, notes_moduleimpl MI where MI.formsemestre_id = %(formsemestre_id)s and MI.moduleimpl_id = E.moduleimpl_id" cnx = context.GetDBConnexion() cursor = cnx.cursor(cursor_factory=ScoDocCursor) cursor.execute(req, {"formsemestre_id": formsemestre_id}) res = cursor.dictfetchall() # etat de chaque evaluation: for r in res: r["jour"] = r["jour"] or datetime.date(1900, 1, 1) # pour les comparaisons r["etat"] = do_evaluation_etat(context, r["evaluation_id"]) return res # remplacé par nt.get_sem_evaluation_etat_list() # # def formsemestre_evaluations_list(context, formsemestre_id): # """Liste (non triée) des evals pour ce semestre""" # req = "select E.* from notes_evaluation E, notes_moduleimpl MI where MI.formsemestre_id = %(formsemestre_id)s and MI.moduleimpl_id = E.moduleimpl_id" # cnx = context.GetDBConnexion() # cursor = cnx.cursor(cursor_factory=ScoDocCursor) # cursor.execute( req, { 'formsemestre_id' : formsemestre_id } ) # return cursor.dictfetchall() def _eval_etat(evals): """evals: list of mappings (etats) -> nb_eval_completes, nb_evals_en_cours, nb_evals_vides, date derniere modif Une eval est "complete" ssi tous les etudiants *inscrits* ont une note. """ nb_evals_completes, nb_evals_en_cours, nb_evals_vides = 0, 0, 0 dates = [] for e in evals: if e["etat"]["evalcomplete"]: nb_evals_completes += 1 elif e["etat"]["nb_notes"] == 0: nb_evals_vides += 1 else: nb_evals_en_cours += 1 dates.append(e["etat"]["last_modif"]) dates = sort_dates(dates) if len(dates): last_modif = dates[-1] # date de derniere modif d'une note dans un module else: last_modif = "" return { "nb_evals_completes": nb_evals_completes, "nb_evals_en_cours": nb_evals_en_cours, "nb_evals_vides": nb_evals_vides, "last_modif": last_modif, } def do_evaluation_etat_in_sem(context, formsemestre_id, REQUEST=None): """-> nb_eval_completes, nb_evals_en_cours, nb_evals_vides, date derniere modif, attente""" nt = context._getNotesCache().get_NotesTable( context, formsemestre_id ) # > liste evaluations et moduleimpl en attente evals = nt.get_sem_evaluation_etat_list() etat = _eval_etat(evals) # Ajoute information sur notes en attente etat["attente"] = len(nt.get_moduleimpls_attente()) > 0 return etat def do_evaluation_etat_in_mod(context, nt, moduleimpl_id): """""" evals = nt.get_mod_evaluation_etat_list(moduleimpl_id) etat = _eval_etat(evals) etat["attente"] = moduleimpl_id in [ m["moduleimpl_id"] for m in nt.get_moduleimpls_attente() ] # > liste moduleimpl en attente return etat def formsemestre_evaluations_cal(context, formsemestre_id, REQUEST=None): """Page avec calendrier de toutes les evaluations de ce semestre""" sem = sco_formsemestre.get_formsemestre(context, formsemestre_id) nt = context._getNotesCache().get_NotesTable( context, formsemestre_id ) # > liste evaluations evals = nt.get_sem_evaluation_etat_list() nb_evals = len(evals) color_incomplete = "#FF6060" color_complete = "#A0FFA0" color_futur = "#70E0FF" today = time.strftime("%Y-%m-%d") year = int(sem["annee_debut"]) if sem["mois_debut_ord"] < 8: year -= 1 # calendrier septembre a septembre events = {} # (day, halfday) : event for e in evals: etat = e["etat"] if not e["jour"]: continue day = e["jour"].strftime("%Y-%m-%d") mod = context.do_moduleimpl_withmodule_list(moduleimpl_id=e["moduleimpl_id"])[0] txt = mod["module"]["code"] or mod["module"]["abbrev"] or "eval" if e["heure_debut"]: debut = e["heure_debut"].strftime("%Hh%M") else: debut = "?" if e["heure_fin"]: fin = e["heure_fin"].strftime("%Hh%M") else: fin = "?" description = "%s, de %s à %s" % (mod["module"]["titre"], debut, fin) if etat["evalcomplete"]: color = color_complete else: color = color_incomplete if day > today: color = color_futur href = "moduleimpl_status?moduleimpl_id=%s" % e["moduleimpl_id"] # if e['heure_debut'].hour < 12: # halfday = True # else: # halfday = False if not day in events: # events[(day,halfday)] = [day, txt, color, href, halfday, description, mod] events[day] = [day, txt, color, href, description, mod] else: e = events[day] if e[-1]["moduleimpl_id"] != mod["moduleimpl_id"]: # plusieurs evals de modules differents a la meme date e[1] += ", " + txt e[4] += ", " + description if not etat["evalcomplete"]: e[2] = color_incomplete if day > today: e[2] = color_futur CalHTML = ZAbsences.YearTable( context.Absences, year, events=events.values(), halfday=False, pad_width=None ) H = [ context.html_sem_header( REQUEST, "Evaluations du semestre", sem, cssstyles=["css/calabs.css"] ), '
', CalHTML, "
", "

soit %s évaluations planifiées;" % nb_evals, """

""" % (color_incomplete, color_complete, color_futur), """

voir les délais de correction

""" % (formsemestre_id,), context.sco_footer(REQUEST), ] return "\n".join(H) def evaluation_date_first_completion(context, evaluation_id): """Première date à laquelle l'évaluation a été complète ou None si actuellement incomplète """ etat = do_evaluation_etat(context, evaluation_id) if not etat["evalcomplete"]: return None E = context.do_evaluation_list(args={"evaluation_id": evaluation_id})[0] M = context.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0] formsemestre_id = M["formsemestre_id"] # Il faut considerer les inscriptions au semestre # (pour avoir l'etat et le groupe) et aussi les inscriptions # au module (pour gerer les modules optionnels correctement) insem = context.do_formsemestre_inscription_listinscrits(formsemestre_id) insmod = context.do_moduleimpl_inscription_list(moduleimpl_id=E["moduleimpl_id"]) insmodset = set([x["etudid"] for x in insmod]) # retire de insem ceux qui ne sont pas inscrits au module ins = [i for i in insem if i["etudid"] in insmodset] notes = context._notes_getall(evaluation_id, filter_suppressed=False).values() notes_log = context._notes_getall( evaluation_id, filter_suppressed=False, table="notes_notes_log" ).values() date_premiere_note = {} # etudid : date for note in notes + notes_log: etudid = note["etudid"] if etudid in date_premiere_note: date_premiere_note[etudid] = min(note["date"], date_premiere_note[etudid]) else: date_premiere_note[etudid] = note["date"] if not date_premiere_note: return None # complete mais aucun etudiant non démissionnaires # complet au moment du max (date la plus tardive) des premieres dates de saisie return max(date_premiere_note.values()) def formsemestre_evaluations_delai_correction( context, formsemestre_id, format="html", REQUEST=None ): """Experimental: un tableau indiquant pour chaque évaluation le nombre de jours avant la publication des notes. N'indique pas les évaluations de ratrapage ni celles des modules de bonus/malus. """ sem = sco_formsemestre.get_formsemestre(context, formsemestre_id) nt = context._getNotesCache().get_NotesTable( context, formsemestre_id ) # > liste evaluations evals = nt.get_sem_evaluation_etat_list() T = [] for e in evals: M = context.do_moduleimpl_list(moduleimpl_id=e["moduleimpl_id"])[0] Mod = context.do_module_list(args={"module_id": M["module_id"]})[0] if (e["evaluation_type"] != EVALUATION_NORMALE) or ( Mod["module_type"] == MODULE_MALUS ): continue e["date_first_complete"] = evaluation_date_first_completion( context, e["evaluation_id"] ) if e["date_first_complete"]: e["delai_correction"] = (e["date_first_complete"].date() - e["jour"]).days else: e["delai_correction"] = None e["module_code"] = Mod["code"] e["_module_code_target"] = ( "moduleimpl_status?moduleimpl_id=" + M["moduleimpl_id"] ) e["module_titre"] = Mod["titre"] e["responsable_id"] = M["responsable_id"] e["responsable_nomplogin"] = context.Users.user_info(M["responsable_id"])[ "nomplogin" ] e["_jour_target"] = "evaluation_listenotes?evaluation_id=" + e["evaluation_id"] T.append(e) columns_ids = ( "module_code", "module_titre", "responsable_nomplogin", "jour", "date_first_complete", "delai_correction", "description", ) titles = { "module_code": "Code", "module_titre": "Module", "responsable_nomplogin": "Responsable", "jour": "Date", "date_first_complete": "Fin saisie", "delai_correction": "Délai", "description": "Description", } tab = GenTable( titles=titles, columns_ids=columns_ids, rows=T, html_class="table_leftalign table_coldate", html_sortable=True, html_title="

Correction des évaluations du semestre

", caption="Correction des évaluations du semestre", preferences=context.get_preferences(formsemestre_id), base_url="%s?formsemestre_id=%s" % (REQUEST.URL0, formsemestre_id), origin="Généré par %s le " % VERSION.SCONAME + timedate_human_repr() + "", filename=make_filename("evaluations_delais_" + sem["titreannee"]), ) return tab.make_page(context, format=format, REQUEST=REQUEST) def module_evaluation_insert_before(context, ModEvals, next_eval, REQUEST): """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(context, next_eval["moduleimpl_id"], REQUEST) next_eval = context.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 ModEvals: if e["numero"] >= n: e["numero"] += 1 # log('incrementing %s to %s' % (e['evaluation_id'], e['numero'])) context.do_evaluation_edit(REQUEST, e) return n def module_evaluation_move(context, evaluation_id, after=0, REQUEST=None, redirect=1): """Move before/after previous one (decrement/increment numero) (published) """ e = context.do_evaluation_list(args={"evaluation_id": evaluation_id})[0] redirect = int(redirect) # access: can change eval ? (raises exception) context._evaluation_check_write_access(REQUEST, moduleimpl_id=e["moduleimpl_id"]) module_evaluation_renumber( context, e["moduleimpl_id"], REQUEST=REQUEST, only_if_unumbered=True ) e = context.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"') ModEvals = context.do_evaluation_list({"moduleimpl_id": e["moduleimpl_id"]}) # log('ModEvals=%s' % [ x['evaluation_id'] for x in ModEvals] ) if len(ModEvals) > 1: idx = [p["evaluation_id"] for p in ModEvals].index(evaluation_id) neigh = None # object to swap with if after == 0 and idx > 0: neigh = ModEvals[idx - 1] elif after == 1 and idx < len(ModEvals) - 1: neigh = ModEvals[idx + 1] if neigh: # # swap numero with neighbor e["numero"], neigh["numero"] = neigh["numero"], e["numero"] context.do_evaluation_edit(REQUEST, e) context.do_evaluation_edit(REQUEST, neigh) # redirect to moduleimpl page: if redirect: return REQUEST.RESPONSE.redirect( "moduleimpl_status?moduleimpl_id=" + e["moduleimpl_id"] ) def module_evaluation_renumber( context, moduleimpl_id, REQUEST=None, 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) ModEvals = context.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 ModEvals] if all_numbered and only_if_unumbered: return # all ok # log('module_evaluation_renumber') # Reset all numeros: i = 1 for e in ModEvals: e["numero"] = i context.do_evaluation_edit(REQUEST, e) i += 1 # If requested, redirect to moduleimpl page: if redirect: return REQUEST.RESPONSE.redirect( "moduleimpl_status?moduleimpl_id=" + moduleimpl_id ) # -------------- VIEWS def evaluation_describe(context, evaluation_id="", edit_in_place=True, REQUEST=None): """HTML description of evaluation, for page headers edit_in_place: allow in-place editing when permitted (not implemented) """ E = context.do_evaluation_list({"evaluation_id": evaluation_id})[0] moduleimpl_id = E["moduleimpl_id"] M = context.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0] Mod = context.do_module_list(args={"module_id": M["module_id"]})[0] formsemestre_id = M["formsemestre_id"] sem = sco_formsemestre.get_formsemestre(context, formsemestre_id) u = context.Users.user_info(M["responsable_id"]) resp = u["prenomnom"] nomcomplet = u["nomcomplet"] can_edit = context.can_edit_notes( REQUEST.AUTHENTICATED_USER, moduleimpl_id, allow_ens=False ) link = ( 'voir toutes les notes du module' % moduleimpl_id ) mod_descr = ( '%s %s (resp. %s) %s' % (moduleimpl_id, Mod["code"], Mod["titre"], nomcomplet, resp, link) ) etit = E["description"] or "" if etit: etit = ' "' + etit + '"' if Mod["module_type"] == MODULE_MALUS: etit += ' (points de malus)' H = [ 'Evaluation%s

Module : %s

' % (etit, mod_descr) ] if Mod["module_type"] == MODULE_MALUS: # Indique l'UE ue = context.do_ue_list(args={"ue_id": Mod["ue_id"]})[0] H.append("

UE : %(acronyme)s

" % ue) # store min/max values used by JS client-side checks: H.append( '-20.20.' ) else: # date et absences (pas pour evals de malus) jour = E["jour"] or "pas de date" H.append( "

Réalisée le %s de %s à %s " % (jour, E["heure_debut"], E["heure_fin"]) ) if E["jour"]: group_id = sco_groups.get_default_group(context, formsemestre_id) H.append( '(absences ce jour)' % (context.ScoURL(), group_id, urllib.quote(E["jour"], safe="")) ) H.append( '

Coefficient dans le module: %s, notes sur %g ' % (E["coefficient"], E["note_max"]) ) H.append('0.') if can_edit: H.append( '(modifier l\'évaluation)' % evaluation_id ) H.append("

") return '
' + "\n".join(H) + "
" def evaluation_create_form( context, moduleimpl_id=None, evaluation_id=None, REQUEST=None, edit=False, readonly=False, page_title="Evaluation", ): "formulaire creation/edition des evaluations (pas des notes)" if evaluation_id != None: the_eval = context.do_evaluation_list({"evaluation_id": evaluation_id})[0] moduleimpl_id = the_eval["moduleimpl_id"] # M = context.do_moduleimpl_withmodule_list(moduleimpl_id=moduleimpl_id)[0] is_malus = M["module"]["module_type"] == MODULE_MALUS # True si module de malus formsemestre_id = M["formsemestre_id"] min_note_max = NOTES_PRECISION # le plus petit bareme possible if not readonly: try: context._evaluation_check_write_access(REQUEST, moduleimpl_id=moduleimpl_id) except AccessDenied as e: return ( context.sco_header(REQUEST) + "

Opération non autorisée

" + str(e) + "

" + '

Revenir

' % (str(REQUEST.HTTP_REFERER),) + context.sco_footer(REQUEST) ) if readonly: edit = True # montre les donnees existantes if not edit: # creation nouvel if moduleimpl_id is None: raise ValueError("missing moduleimpl_id parameter") initvalues = { "note_max": 20, "jour": time.strftime("%d/%m/%Y", time.localtime()), "publish_incomplete": is_malus, } submitlabel = "Créer cette évaluation" action = "Création d'une é" link = "" else: # edition donnees existantes # setup form init values if evaluation_id is None: raise ValueError("missing evaluation_id parameter") initvalues = the_eval moduleimpl_id = initvalues["moduleimpl_id"] submitlabel = "Modifier les données" if readonly: action = "E" link = ( 'voir toutes les notes du module' % M["moduleimpl_id"] ) else: action = "Modification d'une é" link = "" # Note maximale actuelle dans cette eval ? etat = do_evaluation_etat(context, evaluation_id) if etat["maxi_num"] is not None: min_note_max = max(NOTES_PRECISION, etat["maxi_num"]) else: min_note_max = NOTES_PRECISION # if min_note_max > NOTES_PRECISION: min_note_max_str = fmt_note(min_note_max) else: min_note_max_str = "0" # Mod = context.do_module_list(args={"module_id": M["module_id"]})[0] sem = sco_formsemestre.get_formsemestre(context, M["formsemestre_id"]) # help = """

Le coefficient d'une évaluation n'est utilisé que pour pondérer les évaluations au sein d'un module. Il est fixé librement par l'enseignant pour refléter l'importance de ses différentes notes (examens, projets, travaux pratiques...). Ce coefficient est utilisé pour calculer la note moyenne de chaque étudiant dans ce module.

Ne pas confondre ce coefficient avec le coefficient du module, qui est lui fixé par le programme pédagogique (le PPN pour les DUT) et pondère les moyennes de chaque module pour obtenir les moyennes d'UE et la moyenne générale.

L'option Visible sur bulletins indique que la note sera reportée sur les bulletins en version dite "intermédiaire" (dans cette version, on peut ne faire apparaitre que certaines notes, en sus des moyennes de modules. Attention, cette option n'empêche pas la publication sur les bulletins en version "longue" (la note est donc visible par les étudiants sur le portail).

La modalité "rattrapage" permet de définir une évaluation dont les notes remplaceront les moyennes du modules si elles sont meilleures que celles calculées. Dans ce cas, le coefficient est ignoré, et toutes les notes n'ont pas besoin d'être rentrées.

Les évaluations des modules de type "malus" sont spéciales: le coefficient n'est pas utilisé. Les notes de malus sont toujours comprises entre -20 et 20. Les points sont soustraits à la moyenne de l'UE à laquelle appartient le module malus (si la note est négative, la moyenne est donc augmentée).

""" mod_descr = '%s %s %s' % ( moduleimpl_id, Mod["code"], Mod["titre"], link, ) if not readonly: H = ["

%svaluation en %s

" % (action, mod_descr)] else: return sco_evaluations.evaluation_describe( context, evaluation_id, REQUEST=REQUEST ) heures = ["%02dh%02d" % (h, m) for h in range(8, 19) for m in (0, 30)] # initvalues["visibulletin"] = initvalues.get("visibulletin", "1") if initvalues["visibulletin"] == "1": initvalues["visibulletinlist"] = ["X"] else: initvalues["visibulletinlist"] = [] if REQUEST.form.get("tf-submitted", False) and not REQUEST.form.has_key( "visibulletinlist" ): REQUEST.form["visibulletinlist"] = [] # form = [ ("evaluation_id", {"default": evaluation_id, "input_type": "hidden"}), ("formsemestre_id", {"default": formsemestre_id, "input_type": "hidden"}), ("moduleimpl_id", {"default": moduleimpl_id, "input_type": "hidden"}), # ('jour', { 'title' : 'Date (j/m/a)', 'size' : 12, 'explanation' : 'date de l\'examen, devoir ou contrôle' }), ( "jour", { "input_type": "date", "title": "Date", "size": 12, "explanation": "date de l'examen, devoir ou contrôle", }, ), ( "heure_debut", { "title": "Heure de début", "explanation": "heure du début de l'épreuve", "input_type": "menu", "allowed_values": heures, "labels": heures, }, ), ( "heure_fin", { "title": "Heure de fin", "explanation": "heure de fin de l'épreuve", "input_type": "menu", "allowed_values": heures, "labels": heures, }, ), ] if is_malus: # pas de coefficient form.append(("coefficient", {"input_type": "hidden", "default": "1."})) else: form.append( ( "coefficient", { "size": 10, "type": "float", "explanation": "coef. dans le module (choisi librement par l'enseignant)", "allow_null": False, }, ) ) form += [ ( "note_max", { "size": 4, "type": "float", "title": "Notes de 0 à", "explanation": "barème (note max actuelle: %s)" % min_note_max_str, "allow_null": False, "max_value": NOTES_MAX, "min_value": min_note_max, }, ), ( "description", { "size": 36, "type": "text", "explanation": 'type d\'évaluation, apparait sur le bulletins longs. Exemples: "contrôle court", "examen de TP", "examen final".', }, ), ( "visibulletinlist", { "input_type": "checkbox", "allowed_values": ["X"], "labels": [""], "title": "Visible sur bulletins", "explanation": "(pour les bulletins en version intermédiaire)", }, ), ( "publish_incomplete", { "input_type": "boolcheckbox", "title": "Prise en compte immédiate", "explanation": "notes utilisées même si incomplètes", }, ), ( "evaluation_type", { "input_type": "menu", "title": "Modalité", "allowed_values": (EVALUATION_NORMALE, EVALUATION_RATTRAPAGE), "type": "int", "labels": ("Normale", "Rattrapage"), }, ), ] tf = TrivialFormulator( REQUEST.URL0, REQUEST.form, form, cancelbutton="Annuler", submitlabel=submitlabel, initvalues=initvalues, readonly=readonly, ) dest_url = "moduleimpl_status?moduleimpl_id=%s" % M["moduleimpl_id"] if tf[0] == 0: head = context.sco_header(REQUEST, page_title=page_title) return head + "\n".join(H) + "\n" + tf[1] + help + context.sco_footer(REQUEST) elif tf[0] == -1: return REQUEST.RESPONSE.redirect(dest_url) else: # form submission if tf[2]["visibulletinlist"]: tf[2]["visibulletin"] = 1 else: tf[2]["visibulletin"] = 0 if not edit: # creation d'une evaluation evaluation_id = context.do_evaluation_create(REQUEST=REQUEST, **tf[2]) return REQUEST.RESPONSE.redirect(dest_url) else: context.do_evaluation_edit(REQUEST, tf[2]) return REQUEST.RESPONSE.redirect(dest_url)