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@gmail.com
#
##############################################################################
""" Gestion des groupes, nouvelle mouture (juin/nov 2009)
TODO :
Optimisation possible :
revoir do_evaluation_listeetuds_groups ( ) pour extraire aussi les groupes ( de chaque etudiant )
2021-01-17 22:31:28 +01:00
et éviter ainsi l ' appel ulterieur à get_etud_groups() dans _make_table_notes
2020-09-26 16:19:37 +02:00
"""
2021-02-03 22:00:41 +01:00
import collections
2020-09-26 16:19:37 +02:00
import operator
2021-07-29 16:31:15 +02:00
import re
import time
2020-09-26 16:19:37 +02:00
2021-07-10 17:22:27 +02:00
from xml . etree import ElementTree
from xml . etree . ElementTree import Element
2021-07-29 16:31:15 +02:00
import flask
2021-09-18 10:10:02 +02:00
from flask import g , request
2021-09-27 10:20:10 +02:00
from flask import url_for , make_response
2021-07-29 16:31:15 +02:00
2021-12-16 22:54:24 +01:00
from app . models . groups import Partition
2021-06-19 23:21:37 +02:00
import app . scodoc . sco_utils as scu
import app . scodoc . notesdb as ndb
2021-10-15 14:00:51 +02:00
from app import log , cache
2021-06-19 23:21:37 +02:00
from app . scodoc . scolog import logdb
from app . scodoc import html_sco_header
from app . scodoc import sco_codes_parcours
2021-07-19 19:53:01 +02:00
from app . scodoc import sco_cache
2021-06-19 23:21:37 +02:00
from app . scodoc import sco_etud
2021-06-21 10:17:16 +02:00
from app . scodoc import sco_permissions_check
2021-07-10 17:22:27 +02:00
from app . scodoc import sco_xml
2021-06-19 23:21:37 +02:00
from app . scodoc . sco_exceptions import ScoException , AccessDenied , ScoValueError
from app . scodoc . sco_permissions import Permission
from app . scodoc . TrivialFormulator import TrivialFormulator
2021-07-10 17:22:27 +02:00
2020-09-26 16:19:37 +02:00
2021-02-03 22:00:41 +01:00
partitionEditor = ndb . EditableTable (
2020-09-26 16:19:37 +02:00
" partition " ,
" partition_id " ,
(
" partition_id " ,
" formsemestre_id " ,
" partition_name " ,
" compute_ranks " ,
" numero " ,
" bul_show_rank " ,
" show_in_lists " ,
) ,
2021-08-11 00:36:07 +02:00
input_formators = {
" bul_show_rank " : bool ,
" show_in_lists " : bool ,
} ,
2020-09-26 16:19:37 +02:00
)
2021-02-03 22:00:41 +01:00
groupEditor = ndb . EditableTable (
2020-09-26 16:19:37 +02:00
" group_descr " , " group_id " , ( " group_id " , " partition_id " , " group_name " )
)
group_list = groupEditor . list
2021-08-19 10:28:35 +02:00
def get_group ( group_id ) :
2020-09-26 16:19:37 +02:00
""" Returns group object, with partition """
2021-02-03 22:00:41 +01:00
r = ndb . SimpleDictFetch (
2021-08-08 17:38:46 +02:00
""" SELECT gd.id AS group_id, gd.*, p.id AS partition_id, p.*
2021-10-24 18:28:01 +02:00
FROM group_descr gd , partition p
WHERE gd . id = % ( group_id ) s
2021-08-08 17:38:46 +02:00
AND p . id = gd . partition_id
""" ,
2020-09-26 16:19:37 +02:00
{ " group_id " : group_id } ,
)
if not r :
raise ValueError ( " invalid group_id ( %s ) " % group_id )
return r [ 0 ]
2021-08-19 10:28:35 +02:00
def group_delete ( group , force = False ) :
2020-12-01 16:46:45 +01:00
""" Delete a group. """
2020-09-26 16:19:37 +02:00
# if not group['group_name'] and not force:
# raise ValueError('cannot suppress this group')
# remove memberships:
2021-07-28 17:03:54 +02:00
ndb . SimpleQuery ( " DELETE FROM group_membership WHERE group_id= %(group_id)s " , group )
2020-09-26 16:19:37 +02:00
# delete group:
2021-08-08 16:01:10 +02:00
ndb . SimpleQuery ( " DELETE FROM group_descr WHERE id= %(group_id)s " , group )
2020-09-26 16:19:37 +02:00
2021-08-19 10:28:35 +02:00
def get_partition ( partition_id ) :
2021-02-03 22:00:41 +01:00
r = ndb . SimpleDictFetch (
2021-10-24 18:28:01 +02:00
""" SELECT p.id AS partition_id, p.*
FROM partition p
2021-08-08 17:38:46 +02:00
WHERE p . id = % ( partition_id ) s
""" ,
2020-09-26 16:19:37 +02:00
{ " partition_id " : partition_id } ,
)
if not r :
raise ValueError ( " invalid partition_id ( %s ) " % partition_id )
return r [ 0 ]
2021-08-19 10:28:35 +02:00
def get_partitions_list ( formsemestre_id , with_default = True ) :
2020-09-26 16:19:37 +02:00
""" Liste des partitions pour ce semestre (list of dicts) """
2021-02-03 22:00:41 +01:00
partitions = ndb . SimpleDictFetch (
2021-10-24 18:28:01 +02:00
""" SELECT p.id AS partition_id, p.*
2021-08-08 17:38:46 +02:00
FROM partition p
WHERE formsemestre_id = % ( formsemestre_id ) s
ORDER BY numero """ ,
2020-09-26 16:19:37 +02:00
{ " formsemestre_id " : formsemestre_id } ,
)
# Move 'all' at end of list (for menus)
R = [ p for p in partitions if p [ " partition_name " ] != None ]
if with_default :
R + = [ p for p in partitions if p [ " partition_name " ] == None ]
return R
2021-08-19 10:28:35 +02:00
def get_default_partition ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
""" Get partition for ' all ' students (this one always exists, with NULL name) """
2021-02-03 22:00:41 +01:00
r = ndb . SimpleDictFetch (
2021-08-08 17:38:46 +02:00
""" SELECT p.id AS partition_id, p.* FROM partition p
2021-10-24 18:28:01 +02:00
WHERE formsemestre_id = % ( formsemestre_id ) s
2021-08-08 17:38:46 +02:00
AND partition_name is NULL
""" ,
2020-09-26 16:19:37 +02:00
{ " formsemestre_id " : formsemestre_id } ,
)
if len ( r ) != 1 :
raise ScoException (
" inconsistent partition: %d with NULL name for formsemestre_id= %s "
% ( len ( r ) , formsemestre_id )
)
return r [ 0 ]
2021-08-19 10:28:35 +02:00
def get_formsemestre_groups ( formsemestre_id , with_default = False ) :
2020-12-01 16:46:45 +01:00
""" Returns ( partitions, { partition_id : { etudid : group } } ). """
2021-08-19 10:28:35 +02:00
partitions = get_partitions_list ( formsemestre_id , with_default = with_default )
2020-09-26 16:19:37 +02:00
partitions_etud_groups = { } # { partition_id : { etudid : group } }
for partition in partitions :
pid = partition [ " partition_id " ]
2021-08-19 10:28:35 +02:00
partitions_etud_groups [ pid ] = get_etud_groups_in_partition ( pid )
2020-09-26 16:19:37 +02:00
return partitions , partitions_etud_groups
2021-08-19 10:28:35 +02:00
def get_partition_groups ( partition ) :
2020-09-26 16:19:37 +02:00
""" List of groups in this partition (list of dicts).
Some groups may be empty . """
2021-02-03 22:00:41 +01:00
return ndb . SimpleDictFetch (
2021-10-24 18:28:01 +02:00
""" SELECT gd.id AS group_id, p.id AS partition_id, gd.*, p.*
FROM group_descr gd , partition p
WHERE gd . partition_id = % ( partition_id ) s
AND gd . partition_id = p . id
2021-08-08 17:38:46 +02:00
ORDER BY group_name
""" ,
2020-09-26 16:19:37 +02:00
partition ,
)
2021-07-29 16:31:15 +02:00
def get_default_group ( formsemestre_id , fix_if_missing = False ) :
2020-12-01 16:46:45 +01:00
""" Returns group_id for default ( ' tous ' ) group """
2021-02-03 22:00:41 +01:00
r = ndb . SimpleDictFetch (
2021-08-08 17:38:46 +02:00
""" SELECT gd.id AS group_id
2021-10-24 18:28:01 +02:00
FROM group_descr gd , partition p
WHERE p . formsemestre_id = % ( formsemestre_id ) s
AND p . partition_name is NULL
2021-08-10 09:10:36 +02:00
AND p . id = gd . partition_id
2021-08-08 17:38:46 +02:00
""" ,
2020-09-26 16:19:37 +02:00
{ " formsemestre_id " : formsemestre_id } ,
)
if len ( r ) == 0 and fix_if_missing :
# No default group (problem during sem creation)
# Try to create it
log (
" *** Warning: get_default_group(formsemestre_id= %s ): default group missing, recreating it "
% formsemestre_id
)
try :
2021-08-19 10:28:35 +02:00
partition_id = get_default_partition ( formsemestre_id ) [ " partition_id " ]
2020-09-26 16:19:37 +02:00
except ScoException :
log ( " creating default partition for %s " % formsemestre_id )
2021-08-15 21:33:47 +02:00
partition_id = partition_create (
2021-08-19 10:28:35 +02:00
formsemestre_id , default = True , redirect = False
2021-08-15 21:33:47 +02:00
)
2021-10-12 16:05:50 +02:00
group_id = create_group ( partition_id , default = True )
2020-09-26 16:19:37 +02:00
return group_id
# debug check
if len ( r ) != 1 :
raise ScoException ( " invalid group structure for %s " % formsemestre_id )
group_id = r [ 0 ] [ " group_id " ]
return group_id
2021-08-19 10:28:35 +02:00
def get_sem_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
""" Returns groups for this sem (in all partitions). """
2021-02-03 22:00:41 +01:00
return ndb . SimpleDictFetch (
2021-08-10 09:10:36 +02:00
""" SELECT gd.id AS group_id, p.id AS partition_id, gd.*, p.*
2021-10-24 18:28:01 +02:00
FROM group_descr gd , partition p
WHERE p . formsemestre_id = % ( formsemestre_id ) s
2021-08-10 09:10:36 +02:00
AND p . id = gd . partition_id
2021-08-08 17:38:46 +02:00
""" ,
2020-09-26 16:19:37 +02:00
{ " formsemestre_id " : formsemestre_id } ,
)
2021-08-19 10:28:35 +02:00
def get_group_members ( group_id , etat = None ) :
2020-09-26 16:19:37 +02:00
""" Liste des etudiants d ' un groupe.
Si etat , filtre selon l ' état de l ' inscription
Trié par nom_usuel ( ou nom ) puis prénom
"""
2021-08-10 09:10:36 +02:00
req = """ SELECT i.id as etudid, i.*, a.*, gm.*, ins.etat
2021-08-08 17:38:46 +02:00
FROM identite i , adresse a , group_membership gm ,
group_descr gd , partition p , notes_formsemestre_inscription ins
WHERE i . id = gm . etudid
and a . etudid = i . id
and ins . etudid = i . id
and ins . formsemestre_id = p . formsemestre_id
and p . id = gd . partition_id
and gd . id = gm . group_id
and gm . group_id = % ( group_id ) s
"""
2020-09-26 16:19:37 +02:00
if etat is not None :
req + = " and ins.etat = %(etat)s "
2021-07-28 17:03:54 +02:00
r = ndb . SimpleDictFetch ( req , { " group_id " : group_id , " etat " : etat } )
2020-09-26 16:19:37 +02:00
for etud in r :
2021-06-19 23:21:37 +02:00
sco_etud . format_etud_ident ( etud )
2020-09-26 16:19:37 +02:00
r . sort ( key = operator . itemgetter ( " nom_disp " , " prenom " ) ) # tri selon nom_usuel ou nom
2021-02-04 20:02:44 +01:00
if scu . CONFIG . ALLOW_NULL_PRENOM :
2020-09-26 16:19:37 +02:00
for x in r :
x [ " prenom " ] = x [ " prenom " ] or " "
return r
# obsolete: sco_groups_view.DisplayedGroupsInfos
2021-08-19 10:28:35 +02:00
# def get_groups_members(group_ids, etat=None):
2020-09-26 16:19:37 +02:00
# """Liste les étudiants d'une liste de groupes
# chaque étudiant n'apparait qu'une seule fois dans le résultat.
# La liste est triée par nom / prenom
# """
# D = {} # { etudid : etud }
# for group_id in group_ids:
2021-08-19 10:28:35 +02:00
# members = get_group_members(group_id, etat=etat)
2020-09-26 16:19:37 +02:00
# for m in members:
# D[m['etudid']] = m
# r = D.values()
# r.sort(key=operator.itemgetter('nom_disp', 'prenom')) # tri selon nom_usuel ou nom
# return r
2021-08-19 10:28:35 +02:00
def get_group_infos ( group_id , etat = None ) : # was _getlisteetud
2020-12-01 16:46:45 +01:00
""" legacy code: used by group_list and trombino """
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 ( )
2021-08-19 10:28:35 +02:00
group = get_group ( group_id )
sem = sco_formsemestre . get_formsemestre ( group [ " formsemestre_id " ] )
2020-09-26 16:19:37 +02:00
2021-08-19 10:28:35 +02:00
members = get_group_members ( group_id , etat = etat )
2020-09-26 16:19:37 +02:00
# add human readable description of state:
nbdem = 0
for t in members :
if t [ " etat " ] == " I " :
t [ " etath " ] = " " # etudiant inscrit, ne l'indique pas dans la liste HTML
elif t [ " etat " ] == " D " :
2021-06-19 23:21:37 +02:00
events = sco_etud . scolar_events_list (
2020-09-26 16:19:37 +02:00
cnx ,
args = {
" etudid " : t [ " etudid " ] ,
" formsemestre_id " : group [ " formsemestre_id " ] ,
} ,
)
for event in events :
event_type = event [ " event_type " ]
if event_type == " DEMISSION " :
t [ " date_dem " ] = event [ " event_date " ]
break
if " date_dem " in t :
t [ " etath " ] = " démission le %s " % t [ " date_dem " ]
else :
t [ " etath " ] = " (dem.) "
nbdem + = 1
2021-02-03 22:00:41 +01:00
elif t [ " etat " ] == sco_codes_parcours . DEF :
2020-09-26 16:19:37 +02:00
t [ " etath " ] = " Défaillant "
else :
t [ " etath " ] = t [ " etat " ]
# Add membership for all partitions, 'partition_id' : group
for etud in members : # long: comment eviter ces boucles ?
2021-08-19 10:28:35 +02:00
etud_add_group_infos ( etud , sem )
2020-09-26 16:19:37 +02:00
if group [ " group_name " ] != None :
group_tit = " %s %s " % ( group [ " partition_name " ] , group [ " group_name " ] )
else :
group_tit = " tous "
return members , group , group_tit , sem , nbdem
2021-08-19 10:28:35 +02:00
def get_group_other_partitions ( group ) :
2020-09-26 16:19:37 +02:00
""" Liste des partitions du même semestre que ce groupe,
sans celle qui contient ce groupe .
"""
other_partitions = [
p
2021-08-19 10:28:35 +02:00
for p in get_partitions_list ( group [ " formsemestre_id " ] )
2020-09-26 16:19:37 +02:00
if p [ " partition_id " ] != group [ " partition_id " ] and p [ " partition_name " ]
]
return other_partitions
2021-08-19 10:28:35 +02:00
def get_etud_groups ( etudid , sem , exclude_default = False ) :
2020-09-26 16:19:37 +02:00
""" Infos sur groupes de l ' etudiant dans ce semestre
[ group + partition_name ]
"""
2021-10-24 18:28:01 +02:00
req = """ SELECT p.id AS partition_id, p.*, g.id AS group_id, g.*
2021-08-08 17:38:46 +02:00
FROM group_descr g , partition p , group_membership gm
WHERE gm . etudid = % ( etudid ) s
and gm . group_id = g . id
and g . partition_id = p . id
and p . formsemestre_id = % ( formsemestre_id ) s
"""
2020-09-26 16:19:37 +02:00
if exclude_default :
req + = " and p.partition_name is not NULL "
2021-02-03 22:00:41 +01:00
groups = ndb . SimpleDictFetch (
2020-09-26 16:19:37 +02:00
req + " ORDER BY p.numero " ,
{ " e tudid " : etudid , " formsemestre_id " : sem [ " formsemestre_id " ] } ,
)
return _sortgroups ( groups )
2021-08-19 10:28:35 +02:00
def get_etud_main_group ( etudid , sem ) :
2020-09-26 16:19:37 +02:00
""" Return main group (the first one) for etud, or default one if no groups """
2021-08-19 10:28:35 +02:00
groups = get_etud_groups ( etudid , sem , exclude_default = True )
2020-09-26 16:19:37 +02:00
if groups :
return groups [ 0 ]
else :
2021-08-19 10:28:35 +02:00
return get_group ( get_default_group ( sem [ " formsemestre_id " ] ) )
2020-09-26 16:19:37 +02:00
2021-08-19 10:28:35 +02:00
def formsemestre_get_main_partition ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
""" Return main partition (the first one) for sem, or default one if no groups
( rappel : default == tous , main == principale ( groupes TD habituellement )
"""
2021-08-19 10:28:35 +02:00
return get_partitions_list ( formsemestre_id , with_default = True ) [ 0 ]
2020-09-26 16:19:37 +02:00
2021-08-19 10:28:35 +02:00
def formsemestre_get_etud_groupnames ( formsemestre_id , attr = " group_name " ) :
2020-09-26 16:19:37 +02:00
""" Recupere les groupes de tous les etudiants d ' un semestre
{ etudid : { partition_id : group_name } } ( attr = group_name or group_id )
"""
2021-02-03 22:00:41 +01:00
infos = ndb . SimpleDictFetch (
2021-11-12 11:31:50 +01:00
""" SELECT
i . etudid AS etudid ,
p . id AS partition_id ,
gd . group_name ,
gd . id AS group_id
FROM
notes_formsemestre_inscription i ,
partition p ,
group_descr gd ,
group_membership gm
WHERE
i . formsemestre_id = % ( formsemestre_id ) s
2021-08-11 00:36:07 +02:00
and i . formsemestre_id = p . formsemestre_id
and p . id = gd . partition_id
and gm . etudid = i . etudid
and gm . group_id = gd . id
2021-08-08 17:38:46 +02:00
and p . partition_name is not NULL
""" ,
2020-09-26 16:19:37 +02:00
{ " formsemestre_id " : formsemestre_id } ,
)
R = { }
for info in infos :
if info [ " etudid " ] in R :
R [ info [ " etudid " ] ] [ info [ " partition_id " ] ] = info [ attr ]
else :
R [ info [ " etudid " ] ] = { info [ " partition_id " ] : info [ attr ] }
return R
2021-08-19 10:28:35 +02:00
def etud_add_group_infos ( etud , sem , sep = " " ) :
2020-12-01 16:46:45 +01:00
""" Add informations on partitions and group memberships to etud (a dict with an etudid) """
2020-09-26 16:19:37 +02:00
etud [
" partitions "
] = collections . OrderedDict ( ) # partition_id : group + partition_name
if not sem :
etud [ " groupes " ] = " "
return etud
2021-02-03 22:00:41 +01:00
infos = ndb . SimpleDictFetch (
2021-08-08 17:38:46 +02:00
""" SELECT p.partition_name, g.*, g.id AS group_id
FROM group_descr g , partition p , group_membership gm WHERE gm . etudid = % ( etudid ) s
and gm . group_id = g . id
and g . partition_id = p . id
2021-10-24 18:28:01 +02:00
and p . formsemestre_id = % ( formsemestre_id ) s
2021-08-08 17:38:46 +02:00
ORDER BY p . numero
""" ,
2020-09-26 16:19:37 +02:00
{ " etudid " : etud [ " etudid " ] , " formsemestre_id " : sem [ " formsemestre_id " ] } ,
)
for info in infos :
if info [ " partition_name " ] :
etud [ " partitions " ] [ info [ " partition_id " ] ] = info
# resume textuel des groupes:
etud [ " groupes " ] = sep . join (
[ g [ " group_name " ] for g in infos if g [ " group_name " ] != None ]
)
etud [ " partitionsgroupes " ] = sep . join (
[
g [ " partition_name " ] + " : " + g [ " group_name " ]
for g in infos
if g [ " group_name " ] != None
]
)
return etud
2021-10-15 14:00:51 +02:00
@cache.memoize ( timeout = 50 ) # seconds
2021-08-19 10:28:35 +02:00
def get_etud_groups_in_partition ( partition_id ) :
2020-09-26 16:19:37 +02:00
""" Returns { etudid : group }, with all students in this partition """
2021-02-03 22:00:41 +01:00
infos = ndb . SimpleDictFetch (
2021-08-10 12:57:38 +02:00
""" SELECT gd.id AS group_id, gd.*, etudid
2021-08-08 17:38:46 +02:00
FROM group_descr gd , group_membership gm
WHERE gd . partition_id = % ( partition_id ) s
2021-08-10 12:57:38 +02:00
AND gm . group_id = gd . id
2021-08-08 17:38:46 +02:00
""" ,
2020-09-26 16:19:37 +02:00
{ " partition_id " : partition_id } ,
)
R = { }
for i in infos :
R [ i [ " etudid " ] ] = i
return R
2021-09-27 10:20:10 +02:00
def formsemestre_partition_list ( formsemestre_id , format = " xml " ) :
2020-09-26 16:19:37 +02:00
""" Get partitions and groups in this semestre
Supported formats : xml , json
"""
2021-08-19 10:28:35 +02:00
partitions = get_partitions_list ( formsemestre_id , with_default = True )
2020-09-26 16:19:37 +02:00
# Ajoute les groupes
for p in partitions :
2021-08-19 10:28:35 +02:00
p [ " group " ] = get_partition_groups ( p )
2021-09-21 15:53:33 +02:00
return scu . sendResult ( partitions , name = " partition " , format = format )
2020-09-26 16:19:37 +02:00
2021-07-10 17:22:27 +02:00
# Encore utilisé par groupmgr.js
2021-09-27 10:20:10 +02:00
def XMLgetGroupsInPartition ( partition_id ) : # was XMLgetGroupesTD
2020-09-26 16:19:37 +02:00
"""
Deprecated : use group_list
Liste des étudiants dans chaque groupe de cette partition .
< group partition_id = " " partition_name = " " group_id = " " group_name = " " >
2021-07-10 17:22:27 +02:00
< etud etuid = " " sexe = " " nom = " " prenom = " " civilite = " " origin = " " / >
< / group >
< group . . . >
. . .
2020-09-26 16:19:37 +02:00
"""
2021-06-21 10:17:16 +02:00
from app . scodoc import sco_formsemestre
2021-10-04 22:05:05 +02:00
cnx = ndb . GetDBConnexion ( )
2020-09-26 16:19:37 +02:00
t0 = time . time ( )
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2020-09-26 16:19:37 +02:00
formsemestre_id = partition [ " formsemestre_id " ]
2021-08-19 10:28:35 +02:00
sem = sco_formsemestre . get_formsemestre ( formsemestre_id )
groups = get_partition_groups ( partition )
2021-07-19 19:53:01 +02:00
nt = sco_cache . NotesTableCache . get ( formsemestre_id ) # > inscrdict
2020-09-26 16:19:37 +02:00
etuds_set = set ( nt . inscrdict )
2021-09-27 10:20:10 +02:00
# Build XML:
2021-10-04 22:05:05 +02:00
t1 = time . time ( )
2021-07-10 17:22:27 +02:00
doc = Element ( " ajax-response " )
x_response = Element ( " response " , type = " object " , id = " MyUpdater " )
doc . append ( x_response )
2020-09-26 16:19:37 +02:00
for group in groups :
2021-07-10 17:22:27 +02:00
x_group = Element (
" group " ,
2021-08-11 00:36:07 +02:00
partition_id = str ( partition_id ) ,
2020-09-26 16:19:37 +02:00
partition_name = partition [ " partition_name " ] ,
2021-08-11 00:36:07 +02:00
group_id = str ( group [ " group_id " ] ) ,
2020-09-26 16:19:37 +02:00
group_name = group [ " group_name " ] ,
)
2021-07-10 17:22:27 +02:00
x_response . append ( x_group )
2021-08-19 10:28:35 +02:00
for e in get_group_members ( group [ " group_id " ] ) :
2021-10-04 22:05:05 +02:00
etud = sco_etud . get_etud_info ( etudid = e [ " etudid " ] , filled = True ) [ 0 ]
# etud = sco_etud.get_etud_info_filled_by_etudid(e["etudid"], cnx)
2021-07-10 17:22:27 +02:00
x_group . append (
Element (
" etud " ,
2021-08-11 00:36:07 +02:00
etudid = str ( e [ " etudid " ] ) ,
2021-07-10 17:22:27 +02:00
civilite = etud [ " civilite_str " ] ,
sexe = etud [ " civilite_str " ] , # compat
nom = sco_etud . format_nom ( etud [ " nom " ] ) ,
prenom = sco_etud . format_prenom ( etud [ " prenom " ] ) ,
origin = comp_origin ( etud , sem ) ,
)
2020-09-26 16:19:37 +02:00
)
if e [ " etudid " ] in etuds_set :
etuds_set . remove ( e [ " etudid " ] ) # etudiant vu dans un groupe
# Ajoute les etudiants inscrits au semestre mais dans aucun groupe de cette partition:
if etuds_set :
2021-07-10 17:22:27 +02:00
x_group = Element (
" group " ,
2021-08-11 00:36:07 +02:00
partition_id = str ( partition_id ) ,
2020-09-26 16:19:37 +02:00
partition_name = partition [ " partition_name " ] ,
group_id = " _none_ " ,
group_name = " " ,
)
2021-07-10 17:22:27 +02:00
doc . append ( x_group )
2020-09-26 16:19:37 +02:00
for etudid in etuds_set :
2021-08-22 13:24:36 +02:00
etud = sco_etud . get_etud_info ( etudid = etudid , filled = True ) [ 0 ]
2021-10-04 22:05:05 +02:00
# etud = sco_etud.get_etud_info_filled_by_etudid(etudid, cnx)
2021-07-10 17:22:27 +02:00
x_group . append (
Element (
" etud " ,
2021-08-11 00:36:07 +02:00
etudid = str ( etud [ " etudid " ] ) ,
2021-07-10 17:22:27 +02:00
sexe = etud [ " civilite_str " ] ,
nom = sco_etud . format_nom ( etud [ " nom " ] ) ,
prenom = sco_etud . format_prenom ( etud [ " prenom " ] ) ,
origin = comp_origin ( etud , sem ) ,
)
2020-09-26 16:19:37 +02:00
)
2021-10-04 22:05:05 +02:00
t2 = time . time ( )
log ( f " XMLgetGroupsInPartition: { t2 - t0 } seconds ( { t1 - t0 } + { t2 - t1 } ) " )
2021-09-27 10:20:10 +02:00
# XML response:
data = sco_xml . XML_HEADER + ElementTree . tostring ( doc ) . decode ( scu . SCO_ENCODING )
response = make_response ( data )
response . headers [ " Content-Type " ] = scu . XML_MIMETYPE
return response
2020-09-26 16:19:37 +02:00
def comp_origin ( etud , cur_sem ) :
""" breve description de l ' origine de l ' étudiant (sem. precedent)
( n ' indique l ' origine que si ce n ' est pas le semestre precedent normal)
"""
# cherche le semestre suivant le sem. courant dans la liste
cur_sem_idx = None
for i in range ( len ( etud [ " sems " ] ) ) :
if etud [ " sems " ] [ i ] [ " formsemestre_id " ] == cur_sem [ " formsemestre_id " ] :
cur_sem_idx = i
break
if cur_sem_idx is None or ( cur_sem_idx + 1 ) > = ( len ( etud [ " sems " ] ) - 1 ) :
return " " # on pourrait indiquer le bac mais en general on ne l'a pas en debut d'annee
prev_sem = etud [ " sems " ] [ cur_sem_idx + 1 ]
if prev_sem [ " semestre_id " ] != ( cur_sem [ " semestre_id " ] - 1 ) :
return " (S %s ) " % prev_sem [ " semestre_id " ]
else :
return " " # parcours normal, ne le signale pas
2021-08-19 10:28:35 +02:00
def set_group ( etudid , group_id ) :
2020-09-26 16:19:37 +02:00
""" Inscrit l ' étudiant au groupe.
Return True if ok , False si deja inscrit .
Warning : don ' t check if group_id exists (the caller should check).
"""
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2021-02-03 22:00:41 +01:00
cursor = cnx . cursor ( cursor_factory = ndb . ScoDocCursor )
2020-09-26 16:19:37 +02:00
args = { " etudid " : etudid , " group_id " : group_id }
# déjà inscrit ?
2021-02-03 22:00:41 +01:00
r = ndb . SimpleDictFetch (
2020-09-26 16:19:37 +02:00
" SELECT * FROM group_membership gm WHERE etudid= %(etudid)s and group_id= %(group_id)s " ,
args ,
cursor = cursor ,
)
if len ( r ) :
return False
# inscrit
2021-02-03 22:00:41 +01:00
ndb . SimpleQuery (
2020-09-26 16:19:37 +02:00
" INSERT INTO group_membership (etudid, group_id) VALUES ( %(etudid)s , %(group_id)s ) " ,
args ,
cursor = cursor ,
)
return True
2021-09-02 18:05:22 +02:00
def change_etud_group_in_partition ( etudid , group_id , partition = None ) :
2020-12-01 16:46:45 +01:00
""" Inscrit etud au groupe de cette partition, et le desinscrit d ' autres groupes de cette partition. """
2020-09-26 16:19:37 +02:00
log ( " change_etud_group_in_partition: etudid= %s group_id= %s " % ( etudid , group_id ) )
# 0- La partition
2021-08-19 10:28:35 +02:00
group = get_group ( group_id )
2020-09-26 16:19:37 +02:00
if partition :
# verifie que le groupe est bien dans cette partition:
if group [ " partition_id " ] != partition [ " partition_id " ] :
raise ValueError (
" inconsistent group/partition (group_id= %s , partition_id= %s ) "
% ( group_id , partition [ " partition_id " ] )
)
else :
2021-08-19 10:28:35 +02:00
partition = get_partition ( group [ " partition_id " ] )
2020-09-26 16:19:37 +02:00
# 1- Supprime membership dans cette partition
2021-02-03 22:00:41 +01:00
ndb . SimpleQuery (
2021-08-15 21:33:47 +02:00
""" DELETE FROM group_membership gm
WHERE EXISTS
( SELECT 1 FROM group_descr gd
WHERE gm . etudid = % ( etudid ) s
AND gm . group_id = gd . id
AND gd . partition_id = % ( partition_id ) s )
""" ,
2020-09-26 16:19:37 +02:00
{ " etudid " : etudid , " partition_id " : partition [ " partition_id " ] } ,
)
# 2- associe au nouveau groupe
2021-08-19 10:28:35 +02:00
set_group ( etudid , group_id )
2020-09-26 16:19:37 +02:00
# 3- log
formsemestre_id = partition [ " formsemestre_id " ]
2021-09-02 18:05:22 +02:00
cnx = ndb . GetDBConnexion ( )
logdb (
cnx ,
method = " changeGroup " ,
etudid = etudid ,
msg = " formsemestre_id= %s ,partition_name= %s , group_name= %s "
% ( formsemestre_id , partition [ " partition_name " ] , group [ " group_name " ] ) ,
)
cnx . commit ( )
2020-09-26 16:19:37 +02:00
# 4- invalidate cache
2021-07-19 19:53:01 +02:00
sco_cache . invalidate_formsemestre (
formsemestre_id = formsemestre_id
2021-06-21 11:22:55 +02:00
) # > change etud group
2020-09-26 16:19:37 +02:00
def setGroups (
partition_id ,
groupsLists = " " , # members of each existing group
groupsToCreate = " " , # name and members of new groups
groupsToDelete = " " , # groups to delete
) :
""" Affect groups (Ajax request)
groupsLists : lignes de la forme " group_id;etudid;... \n "
groupsToCreate : lignes " group_name;etudid;... \n "
groupsToDelete : group_id ; group_id ; . . .
"""
2021-06-21 10:17:16 +02:00
from app . scodoc import sco_formsemestre
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2020-09-26 16:19:37 +02:00
formsemestre_id = partition [ " formsemestre_id " ]
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
log ( " ***setGroups: partition_id= %s " % partition_id )
log ( " groupsLists= %s " % groupsLists )
log ( " groupsToCreate= %s " % groupsToCreate )
log ( " groupsToDelete= %s " % groupsToDelete )
2021-08-19 10:28:35 +02:00
sem = sco_formsemestre . get_formsemestre ( formsemestre_id )
2021-08-10 12:57:38 +02:00
if not sem [ " etat " ] :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Modification impossible: semestre verrouillé " )
groupsToDelete = [ g for g in groupsToDelete . split ( " ; " ) if g ]
2021-08-19 10:28:35 +02:00
etud_groups = formsemestre_get_etud_groupnames ( formsemestre_id , attr = " group_id " )
2020-09-26 16:19:37 +02:00
for line in groupsLists . split ( " \n " ) : # for each group_id (one per line)
fs = line . split ( " ; " )
group_id = fs [ 0 ] . strip ( )
if not group_id :
continue
2021-08-19 10:28:35 +02:00
group = get_group ( group_id )
2020-09-26 16:19:37 +02:00
# Anciens membres du groupe:
2021-08-19 10:28:35 +02:00
old_members = get_group_members ( group_id )
2020-09-26 16:19:37 +02:00
old_members_set = set ( [ x [ " etudid " ] for x in old_members ] )
# Place dans ce groupe les etudiants indiqués:
2021-08-11 00:36:07 +02:00
for etudid_str in fs [ 1 : - 1 ] :
etudid = int ( etudid_str )
2020-09-26 16:19:37 +02:00
if etudid in old_members_set :
old_members_set . remove (
etudid
) # a nouveau dans ce groupe, pas besoin de l'enlever
if ( etudid not in etud_groups ) or (
group_id != etud_groups [ etudid ] . get ( partition_id , " " )
) : # pas le meme groupe qu'actuel
2021-09-02 18:05:22 +02:00
change_etud_group_in_partition ( etudid , group_id , partition )
2020-09-26 16:19:37 +02:00
# Retire les anciens membres:
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2021-02-03 22:00:41 +01:00
cursor = cnx . cursor ( cursor_factory = ndb . ScoDocCursor )
2020-09-26 16:19:37 +02:00
for etudid in old_members_set :
log ( " removing %s from group %s " % ( etudid , group_id ) )
2021-02-03 22:00:41 +01:00
ndb . SimpleQuery (
2020-09-26 16:19:37 +02:00
" DELETE FROM group_membership WHERE etudid= %(etudid)s and group_id= %(group_id)s " ,
{ " etudid " : etudid , " group_id " : group_id } ,
cursor = cursor ,
)
logdb (
cnx ,
method = " removeFromGroup " ,
etudid = etudid ,
msg = " formsemestre_id= %s ,partition_name= %s , group_name= %s "
% ( formsemestre_id , partition [ " partition_name " ] , group [ " group_name " ] ) ,
)
# Supprime les groupes indiqués comme supprimés:
for group_id in groupsToDelete :
2021-10-12 16:05:50 +02:00
delete_group ( group_id , partition_id = partition_id )
2020-09-26 16:19:37 +02:00
# Crée les nouveaux groupes
for line in groupsToCreate . split ( " \n " ) : # for each group_name (one per line)
fs = line . split ( " ; " )
group_name = fs [ 0 ] . strip ( )
if not group_name :
continue
2021-10-12 16:05:50 +02:00
group_id = create_group ( partition_id , group_name )
2020-09-26 16:19:37 +02:00
# Place dans ce groupe les etudiants indiqués:
for etudid in fs [ 1 : - 1 ] :
2021-09-02 18:05:22 +02:00
change_etud_group_in_partition ( etudid , group_id , partition )
2020-09-26 16:19:37 +02:00
2021-09-27 10:20:10 +02:00
data = (
2020-09-26 16:19:37 +02:00
' <?xml version= " 1.0 " encoding= " utf-8 " ?><response>Groupes enregistrés</response> '
)
2021-09-27 10:20:10 +02:00
response = make_response ( data )
response . headers [ " Content-Type " ] = scu . XML_MIMETYPE
return response
2020-09-26 16:19:37 +02:00
2021-10-12 16:05:50 +02:00
def create_group ( partition_id , group_name = " " , default = False ) - > int :
2021-07-29 16:31:15 +02:00
""" Create a new group in this partition """
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2020-09-26 16:19:37 +02:00
formsemestre_id = partition [ " formsemestre_id " ]
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
#
if group_name :
group_name = group_name . strip ( )
if not group_name and not default :
raise ValueError ( " invalid group name: () " )
# checkGroupName(group_name)
2021-08-19 10:28:35 +02:00
if group_name in [ g [ " group_name " ] for g in get_partition_groups ( partition ) ] :
2020-09-26 16:19:37 +02:00
raise ValueError (
" group_name %s already exists in partition " % group_name
) # XXX FIX: incorrect error handling (in AJAX)
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2020-09-26 16:19:37 +02:00
group_id = groupEditor . create (
cnx , { " partition_id " : partition_id , " group_name " : group_name }
)
2021-10-12 16:05:50 +02:00
log ( " create_group: created group_id= %s " % group_id )
2020-09-26 16:19:37 +02:00
#
return group_id
2021-10-12 16:05:50 +02:00
def delete_group ( group_id , partition_id = None ) :
2020-09-26 16:19:37 +02:00
""" form suppression d ' un groupe.
( ne desinscrit pas les etudiants , change juste leur
affectation aux groupes )
partition_id est optionnel et ne sert que pour verifier que le groupe
est bien dans cette partition .
"""
2021-08-19 10:28:35 +02:00
group = get_group ( group_id )
2020-09-26 16:19:37 +02:00
if partition_id :
if partition_id != group [ " partition_id " ] :
raise ValueError ( " inconsistent partition/group " )
else :
partition_id = group [ " partition_id " ]
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( partition [ " formsemestre_id " ] ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
log (
2021-10-12 16:05:50 +02:00
" delete_group: group_id= %s group_name= %s partition_name= %s "
2020-09-26 16:19:37 +02:00
% ( group_id , group [ " group_name " ] , partition [ " partition_name " ] )
)
2021-08-19 10:28:35 +02:00
group_delete ( group )
2020-09-26 16:19:37 +02:00
def partition_create (
formsemestre_id ,
partition_name = " " ,
default = False ,
numero = None ,
2021-08-15 21:33:47 +02:00
redirect = True ,
2020-09-26 16:19:37 +02:00
) :
""" Create a new partition """
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
if partition_name :
2021-10-15 14:31:11 +02:00
partition_name = str ( partition_name ) . strip ( )
2020-09-26 16:19:37 +02:00
if default :
partition_name = None
if not partition_name and not default :
raise ScoValueError ( " Nom de partition invalide (vide) " )
redirect = int ( redirect )
# checkGroupName(partition_name)
if partition_name in [
2021-08-19 10:28:35 +02:00
p [ " partition_name " ] for p in get_partitions_list ( formsemestre_id )
2020-09-26 16:19:37 +02:00
] :
raise ScoValueError (
" Il existe déjà une partition %s dans ce semestre " % partition_name
)
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2021-10-20 17:41:38 +02:00
if numero is None :
numero = (
ndb . SimpleQuery (
" SELECT MAX(id) FROM partition WHERE formsemestre_id= %(formsemestre_id)s " ,
{ " formsemestre_id " : formsemestre_id } ,
) . fetchone ( ) [ 0 ]
or 0
)
2020-09-26 16:19:37 +02:00
partition_id = partitionEditor . create (
2021-10-20 17:41:38 +02:00
cnx ,
{
" formsemestre_id " : formsemestre_id ,
" partition_name " : partition_name ,
" numero " : numero ,
} ,
2020-09-26 16:19:37 +02:00
)
log ( " createPartition: created partition_id= %s " % partition_id )
#
if redirect :
2021-07-29 16:31:15 +02:00
return flask . redirect (
url_for (
" scolar.editPartitionForm " ,
scodoc_dept = g . scodoc_dept ,
formsemestre_id = formsemestre_id ,
)
2020-09-26 16:19:37 +02:00
)
else :
return partition_id
2021-10-12 16:05:50 +02:00
def get_arrow_icons_tags ( ) :
2020-09-26 16:19:37 +02:00
""" returns html tags for arrows """
#
2021-02-04 20:02:44 +01:00
arrow_up = scu . icontag ( " arrow_up " , title = " remonter " )
arrow_down = scu . icontag ( " arrow_down " , title = " descendre " )
arrow_none = scu . icontag ( " arrow_none " , title = " " )
2020-09-26 16:19:37 +02:00
return arrow_up , arrow_down , arrow_none
2021-09-27 10:20:10 +02:00
def editPartitionForm ( formsemestre_id = None ) :
2020-09-26 16:19:37 +02:00
""" Form to create/suppress partitions """
# ad-hoc form
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-12-01 16:46:45 +01:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
2021-08-19 10:28:35 +02:00
partitions = get_partitions_list ( formsemestre_id )
2021-10-12 16:05:50 +02:00
arrow_up , arrow_down , arrow_none = get_arrow_icons_tags ( )
2021-02-04 20:02:44 +01:00
suppricon = scu . icontag (
2020-09-26 16:19:37 +02:00
" delete_small_img " , border = " 0 " , alt = " supprimer " , title = " Supprimer "
)
#
H = [
2021-06-13 23:37:14 +02:00
html_sco_header . sco_header (
page_title = " Partitions... " ,
javascripts = [ " js/editPartitionForm.js " ] ,
2020-09-26 16:19:37 +02:00
) ,
2021-01-17 22:31:28 +01:00
r """ <script type= " text/javascript " >
2020-09-26 16:19:37 +02:00
function checkname ( ) {
var val = document . editpart . partition_name . value . replace ( / ^ \s + / , " " ) . replace ( / \s + $ / , " " ) ;
if ( val . length > 0 ) {
document . editpart . ok . disabled = false ;
} else {
document . editpart . ok . disabled = true ;
}
}
< / script >
""" ,
2021-01-17 22:31:28 +01:00
r """ <h2>Partitions du semestre</h2>
2020-09-26 16:19:37 +02:00
< form name = " editpart " id = " editpart " method = " POST " action = " partition_create " >
< div id = " epmsg " > < / div >
< table > < tr class = " eptit " > < th > < / th > < th > < / th > < th > < / th > < th > Partition < / th > < th > Groupes < / th > < th > < / th > < th > < / th > < th > < / th > < / tr >
""" ,
]
i = 0
for p in partitions :
if p [ " partition_name " ] is not None :
H . append (
' <tr><td class= " epnav " ><a class= " stdlink " href= " partition_delete?partition_id= %s " > %s </a> </td><td class= " epnav " > '
% ( p [ " partition_id " ] , suppricon )
)
if i != 0 :
H . append (
2021-05-11 11:48:32 +02:00
' <a href= " partition_move?partition_id= %s &after=0 " > %s </a> '
2020-09-26 16:19:37 +02:00
% ( p [ " partition_id " ] , arrow_up )
)
H . append ( ' </td><td class= " epnav " > ' )
if i < len ( partitions ) - 2 :
H . append (
2021-05-11 11:48:32 +02:00
' <a href= " partition_move?partition_id= %s &after=1 " > %s </a> '
2020-09-26 16:19:37 +02:00
% ( p [ " partition_id " ] , arrow_down )
)
i + = 1
H . append ( " </td> " )
pname = p [ " partition_name " ] or " "
H . append ( " <td> %s </td> " % pname )
H . append ( " <td> " )
lg = [
" %s ( %d ) "
% (
group [ " group_name " ] ,
2021-08-19 10:28:35 +02:00
len ( get_group_members ( group [ " group_id " ] ) ) ,
2020-09-26 16:19:37 +02:00
)
2021-08-19 10:28:35 +02:00
for group in get_partition_groups ( p )
2020-09-26 16:19:37 +02:00
]
H . append ( " , " . join ( lg ) )
H . append (
2021-08-16 08:33:12 +02:00
f """ </td><td><a class= " stdlink " href= " {
2021-10-04 22:05:05 +02:00
url_for ( " scolar.affect_groups " ,
2021-08-16 08:33:12 +02:00
scodoc_dept = g . scodoc_dept ,
partition_id = p [ " partition_id " ] )
} " >répartir</a></td>
"""
2020-09-26 16:19:37 +02:00
)
H . append (
' <td><a class= " stdlink " href= " partition_rename?partition_id= %s " >renommer</a></td> '
% p [ " partition_id " ]
)
# classement:
H . append ( ' <td width= " 250px " > ' )
if p [ " bul_show_rank " ] :
checked = ' checked= " 1 " '
else :
checked = " "
H . append (
' <div><input type= " checkbox " class= " rkbox " data-partition_id= " %s " %s onchange= " update_rk(this); " />afficher rang sur bulletins</div> '
% ( p [ " partition_id " ] , checked )
)
if p [ " show_in_lists " ] :
checked = ' checked= " 1 " '
else :
checked = " "
H . append (
' <div><input type= " checkbox " class= " rkbox " data-partition_id= " %s " %s onchange= " update_show_in_list(this); " />afficher sur noms groupes</div> '
% ( p [ " partition_id " ] , checked )
)
H . append ( " </td> " )
#
H . append ( " </tr> " )
H . append ( " </table> " )
H . append ( ' <div class= " form_rename_partition " > ' )
H . append (
' <input type= " hidden " name= " formsemestre_id " value= " %s " /> ' % formsemestre_id
)
H . append ( ' <input type= " hidden " name= " redirect " value= " 1 " /> ' )
H . append (
' <input type= " text " name= " partition_name " size= " 12 " onkeyup= " checkname(); " /> '
)
H . append ( ' <input type= " submit " name= " ok " disabled= " 1 " value= " Nouvelle partition " /> ' )
H . append ( " </div></form> " )
H . append (
""" <div class= " help " >
< p > Les partitions sont des découpages de l ' ensemble des étudiants.
Par exemple , les " groupes de TD " sont une partition .
On peut créer autant de partitions que nécessaire .
< / p >
< ul >
< li > Dans chaque partition , un nombre de groupes quelconque peuvent être créés ( suivre le lien " répartir " ) .
< li > On peut faire afficher le classement de l ' étudiant dans son groupe d ' une partition en cochant " afficher rang sur bulletins " ( ainsi , on peut afficher le classement en groupes de TD mais pas en groupe de TP , si ce sont deux partitions ) .
< / li >
< li > Décocher " afficher sur noms groupes " pour ne pas que cette partition apparaisse dans les noms de groupes
< / li >
< / ul >
< / div >
"""
)
2021-07-29 10:19:00 +02:00
return " \n " . join ( H ) + html_sco_header . sco_footer ( )
2020-09-26 16:19:37 +02:00
2021-09-27 10:20:10 +02:00
def partition_set_attr ( partition_id , attr , value ) :
2020-09-26 16:19:37 +02:00
""" Set partition attribute: bul_show_rank or show_in_lists """
if attr not in { " bul_show_rank " , " show_in_lists " } :
raise ValueError ( " invalid partition attribute: %s " % attr )
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2020-09-26 16:19:37 +02:00
formsemestre_id = partition [ " formsemestre_id " ]
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
log ( " partition_set_attr( %s , %s , %s ) " % ( partition_id , attr , value ) )
value = int ( value )
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2020-09-26 16:19:37 +02:00
partition [ attr ] = value
partitionEditor . edit ( cnx , partition )
# invalid bulletin cache
2021-07-19 19:53:01 +02:00
sco_cache . invalidate_formsemestre (
pdfonly = True , formsemestre_id = partition [ " formsemestre_id " ]
2020-09-26 16:19:37 +02:00
)
return " enregistré "
2021-09-27 10:20:10 +02:00
def partition_delete ( partition_id , force = False , redirect = 1 , dialog_confirmed = False ) :
2020-09-26 16:19:37 +02:00
""" Suppress a partition (and all groups within).
default partition cannot be suppressed ( unless force ) """
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2020-09-26 16:19:37 +02:00
formsemestre_id = partition [ " formsemestre_id " ]
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
if not partition [ " partition_name " ] and not force :
raise ValueError ( " cannot suppress this partition " )
redirect = int ( redirect )
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2021-08-19 10:28:35 +02:00
groups = get_partition_groups ( partition )
2020-09-26 16:19:37 +02:00
if not dialog_confirmed :
if groups :
grnames = " ( " + " , " . join ( [ g [ " group_name " ] or " " for g in groups ] ) + " ) "
else :
grnames = " "
2021-06-02 22:40:34 +02:00
return scu . confirm_dialog (
2020-09-26 16:19:37 +02:00
""" <h2>Supprimer la partition " %s " ?</h2>
< p > Les groupes % s de cette partition seront supprimés < / p >
"""
% ( partition [ " partition_name " ] , grnames ) ,
dest_url = " " ,
cancel_url = " editPartitionForm?formsemestre_id= %s " % formsemestre_id ,
parameters = { " redirect " : redirect , " partition_id " : partition_id } ,
)
log ( " partition_delete: partition_id= %s " % partition_id )
# 1- groups
for group in groups :
2021-08-19 10:28:35 +02:00
group_delete ( group , force = force )
2020-09-26 16:19:37 +02:00
# 2- partition
partitionEditor . delete ( cnx , partition_id )
# redirect to partition edit page:
if redirect :
2021-08-10 17:12:10 +02:00
return flask . redirect (
" editPartitionForm?formsemestre_id= " + str ( formsemestre_id )
)
2020-09-26 16:19:37 +02:00
2021-09-27 10:20:10 +02:00
def partition_move ( partition_id , after = 0 , redirect = 1 ) :
2020-09-26 16:19:37 +02:00
""" Move before/after previous one (decrement/increment numero) """
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2020-09-26 16:19:37 +02:00
formsemestre_id = partition [ " formsemestre_id " ]
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
#
redirect = int ( redirect )
after = int ( after ) # 0: deplace avant, 1 deplace apres
if after not in ( 0 , 1 ) :
raise ValueError ( ' invalid value for " after " ' )
2021-08-19 10:28:35 +02:00
others = get_partitions_list ( formsemestre_id )
2021-12-16 21:42:23 +01:00
objs = (
Partition . query . filter_by ( formsemestre_id = formsemestre_id )
. order_by ( Partition . numero , Partition . partition_name )
. all ( )
)
if len ( { o . numero for o in objs } ) != len ( objs ) :
# il y a des numeros identiques !
scu . objects_renumber ( objs )
2020-09-26 16:19:37 +02:00
if len ( others ) > 1 :
pidx = [ p [ " partition_id " ] for p in others ] . index ( partition_id )
2021-10-20 17:41:38 +02:00
# log("partition_move: after=%s pidx=%s" % (after, pidx))
2020-09-26 16:19:37 +02:00
neigh = None # partition to swap with
if after == 0 and pidx > 0 :
neigh = others [ pidx - 1 ]
elif after == 1 and pidx < len ( others ) - 1 :
neigh = others [ pidx + 1 ]
if neigh : #
# swap numero between partition and its neighbor
2021-10-20 17:41:38 +02:00
# log("moving partition %s" % partition_id)
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2021-10-20 17:41:38 +02:00
# Si aucun numéro n'a été affecté, le met au minimum
min_numero = (
ndb . SimpleQuery (
" SELECT MIN(numero) FROM partition WHERE formsemestre_id= %(formsemestre_id)s " ,
{ " formsemestre_id " : formsemestre_id } ,
) . fetchone ( ) [ 0 ]
or 0
)
if neigh [ " numero " ] is None :
neigh [ " numero " ] = min_numero - 1
if partition [ " numero " ] is None :
partition [ " numero " ] = min_numero - 1 - after
2020-09-26 16:19:37 +02:00
partition [ " numero " ] , neigh [ " numero " ] = neigh [ " numero " ] , partition [ " numero " ]
partitionEditor . edit ( cnx , partition )
partitionEditor . edit ( cnx , neigh )
# redirect to partition edit page:
if redirect :
2021-08-10 17:12:10 +02:00
return flask . redirect (
" editPartitionForm?formsemestre_id= " + str ( formsemestre_id )
)
2020-09-26 16:19:37 +02:00
2021-09-27 10:20:10 +02:00
def partition_rename ( partition_id ) :
2020-09-26 16:19:37 +02:00
""" Form to rename a partition """
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2020-09-26 16:19:37 +02:00
formsemestre_id = partition [ " formsemestre_id " ]
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
H = [ " <h2>Renommer une partition</h2> " ]
tf = TrivialFormulator (
2021-09-18 10:10:02 +02:00
request . base_url ,
2021-09-27 16:42:14 +02:00
scu . get_request_args ( ) ,
2020-09-26 16:19:37 +02:00
(
( " partition_id " , { " default " : partition_id , " input_type " : " hidden " } ) ,
(
" partition_name " ,
{
" title " : " Nouveau nom " ,
" default " : partition [ " partition_name " ] ,
" allow_null " : False ,
" size " : 12 ,
} ,
) ,
) ,
submitlabel = " Renommer " ,
cancelbutton = " Annuler " ,
)
if tf [ 0 ] == 0 :
return (
2021-07-29 16:31:15 +02:00
html_sco_header . sco_header ( )
2020-09-26 16:19:37 +02:00
+ " \n " . join ( H )
+ " \n "
+ tf [ 1 ]
2021-07-29 10:19:00 +02:00
+ html_sco_header . sco_footer ( )
2020-09-26 16:19:37 +02:00
)
elif tf [ 0 ] == - 1 :
2021-08-10 17:12:10 +02:00
return flask . redirect (
" editPartitionForm?formsemestre_id= " + str ( formsemestre_id )
)
2020-09-26 16:19:37 +02:00
else :
# form submission
2021-09-27 10:20:10 +02:00
return partition_set_name ( partition_id , tf [ 2 ] [ " partition_name " ] )
2020-09-26 16:19:37 +02:00
2021-09-27 10:20:10 +02:00
def partition_set_name ( partition_id , partition_name , redirect = 1 ) :
2020-09-26 16:19:37 +02:00
""" Set partition name """
2021-10-15 14:31:11 +02:00
partition_name = str ( partition_name ) . strip ( )
2020-09-26 16:19:37 +02:00
if not partition_name :
raise ValueError ( " partition name must be non empty " )
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2020-09-26 16:19:37 +02:00
if partition [ " partition_name " ] is None :
raise ValueError ( " can ' t set a name to default partition " )
formsemestre_id = partition [ " formsemestre_id " ]
# check unicity
2021-02-03 22:00:41 +01:00
r = ndb . SimpleDictFetch (
2021-10-24 18:28:01 +02:00
""" SELECT p.* FROM partition p
WHERE p . partition_name = % ( partition_name ) s
2021-08-08 17:38:46 +02:00
AND formsemestre_id = % ( formsemestre_id ) s
""" ,
2020-09-26 16:19:37 +02:00
{ " partition_name " : partition_name , " formsemestre_id " : formsemestre_id } ,
)
2021-10-24 18:28:01 +02:00
if len ( r ) > 1 or ( len ( r ) == 1 and r [ 0 ] [ " id " ] != partition_id ) :
2020-09-26 16:19:37 +02:00
raise ScoValueError (
" Partition %s déjà existante dans ce semestre ! " % partition_name
)
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
redirect = int ( redirect )
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2020-09-26 16:19:37 +02:00
partitionEditor . edit (
cnx , { " partition_id " : partition_id , " partition_name " : partition_name }
)
# redirect to partition edit page:
if redirect :
2021-08-10 17:12:10 +02:00
return flask . redirect (
" editPartitionForm?formsemestre_id= " + str ( formsemestre_id )
)
2020-09-26 16:19:37 +02:00
2021-10-12 16:05:50 +02:00
def group_set_name ( group_id , group_name , redirect = True ) :
2020-09-26 16:19:37 +02:00
""" Set group name """
if group_name :
group_name = group_name . strip ( )
if not group_name :
raise ScoValueError ( " nom de groupe vide ! " )
2021-08-19 10:28:35 +02:00
group = get_group ( group_id )
2020-09-26 16:19:37 +02:00
if group [ " group_name " ] is None :
raise ValueError ( " can ' t set a name to default group " )
formsemestre_id = group [ " formsemestre_id " ]
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
redirect = int ( redirect )
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2020-09-26 16:19:37 +02:00
groupEditor . edit ( cnx , { " group_id " : group_id , " group_name " : group_name } )
# redirect to partition edit page:
if redirect :
2021-08-16 08:33:12 +02:00
return flask . redirect (
url_for (
2021-10-04 22:05:05 +02:00
" scolar.affect_groups " ,
2021-08-16 08:33:12 +02:00
scodoc_dept = g . scodoc_dept ,
partition_id = group [ " partition_id " ] ,
)
)
2020-09-26 16:19:37 +02:00
2021-09-27 10:20:10 +02:00
def group_rename ( group_id ) :
2020-09-26 16:19:37 +02:00
""" Form to rename a group """
2021-08-19 10:28:35 +02:00
group = get_group ( group_id )
2020-09-26 16:19:37 +02:00
formsemestre_id = group [ " formsemestre_id " ]
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
H = [ " <h2>Renommer un groupe de %s </h2> " % group [ " partition_name " ] ]
tf = TrivialFormulator (
2021-09-18 10:10:02 +02:00
request . base_url ,
2021-09-27 16:42:14 +02:00
scu . get_request_args ( ) ,
2020-09-26 16:19:37 +02:00
(
( " group_id " , { " default " : group_id , " input_type " : " hidden " } ) ,
(
" group_name " ,
{
" title " : " Nouveau nom " ,
" default " : group [ " group_name " ] ,
" size " : 12 ,
" allow_null " : False ,
} ,
) ,
) ,
submitlabel = " Renommer " ,
cancelbutton = " Annuler " ,
)
if tf [ 0 ] == 0 :
return (
2021-07-29 16:31:15 +02:00
html_sco_header . sco_header ( )
2020-09-26 16:19:37 +02:00
+ " \n " . join ( H )
+ " \n "
+ tf [ 1 ]
2021-07-29 10:19:00 +02:00
+ html_sco_header . sco_footer ( )
2020-09-26 16:19:37 +02:00
)
elif tf [ 0 ] == - 1 :
2021-08-15 22:08:38 +02:00
return flask . redirect (
url_for (
2021-10-04 22:05:05 +02:00
" scolar.affect_groups " ,
2021-08-15 22:08:38 +02:00
scodoc_dept = g . scodoc_dept ,
partition_id = group [ " partition_id " ] ,
)
)
2020-09-26 16:19:37 +02:00
else :
# form submission
2021-10-12 16:05:50 +02:00
return group_set_name ( group_id , tf [ 2 ] [ " group_name " ] )
2020-09-26 16:19:37 +02:00
2021-09-27 10:20:10 +02:00
def groups_auto_repartition ( partition_id = None ) :
2020-09-26 16:19:37 +02:00
""" Reparti les etudiants dans des groupes dans une partition, en respectant le niveau
et la mixité .
"""
2021-06-21 11:22:55 +02:00
from app . scodoc import sco_formsemestre
2021-08-19 10:28:35 +02:00
partition = get_partition ( partition_id )
2020-09-26 16:19:37 +02:00
formsemestre_id = partition [ " formsemestre_id " ]
2021-02-07 09:10:26 +01:00
# renvoie sur page édition groupes
2021-08-16 08:33:12 +02:00
dest_url = url_for (
2021-10-04 22:05:05 +02:00
" scolar.affect_groups " , scodoc_dept = g . scodoc_dept , partition_id = partition_id
2021-08-16 08:33:12 +02:00
)
2021-07-29 16:31:15 +02:00
if not sco_permissions_check . can_change_groups ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
raise AccessDenied ( " Vous n ' avez pas le droit d ' effectuer cette opération ! " )
2021-08-19 10:28:35 +02:00
sem = sco_formsemestre . get_formsemestre ( formsemestre_id )
2020-09-26 16:19:37 +02:00
descr = [
( " partition_id " , { " input_type " : " hidden " } ) ,
(
" groupNames " ,
{
" size " : 40 ,
" title " : " Groupes à créer " ,
" allow_null " : False ,
" explanation " : " noms des groupes à former, séparés par des virgules (les groupes existants seront effacés) " ,
} ,
) ,
]
H = [
2021-07-29 16:31:15 +02:00
html_sco_header . sco_header ( page_title = " Répartition des groupes " ) ,
2020-09-26 16:19:37 +02:00
" <h2>Répartition des groupes de %s </h2> " % partition [ " partition_name " ] ,
" <p>Semestre %s </p> " % sem [ " titreannee " ] ,
""" <p class= " help " >Les groupes existants seront <b>effacés</b> et remplacés par
ceux créés ici . La répartition aléatoire tente d ' uniformiser le niveau
des groupes ( en utilisant la dernière moyenne générale disponible pour
chaque étudiant ) et de maximiser la mixité de chaque groupe . < / p > """ ,
]
tf = TrivialFormulator (
2021-09-18 10:10:02 +02:00
request . base_url ,
2021-09-27 16:42:14 +02:00
scu . get_request_args ( ) ,
2020-09-26 16:19:37 +02:00
descr ,
{ } ,
cancelbutton = " Annuler " ,
method = " GET " ,
submitlabel = " Créer et peupler les groupes " ,
name = " tf " ,
)
if tf [ 0 ] == 0 :
2021-07-29 10:19:00 +02:00
return " \n " . join ( H ) + " \n " + tf [ 1 ] + html_sco_header . sco_footer ( )
2020-09-26 16:19:37 +02:00
elif tf [ 0 ] == - 1 :
2021-07-31 18:01:10 +02:00
return flask . redirect ( dest_url )
2020-09-26 16:19:37 +02:00
else :
# form submission
log (
" groups_auto_repartition( partition_id= %s partition_name= %s "
% ( partition_id , partition [ " partition_name " ] )
)
groupNames = tf [ 2 ] [ " groupNames " ]
group_names = sorted ( set ( [ x . strip ( ) for x in groupNames . split ( " , " ) ] ) )
# Détruit les groupes existant de cette partition
2021-08-19 10:28:35 +02:00
for old_group in get_partition_groups ( partition ) :
group_delete ( old_group )
2020-09-26 16:19:37 +02:00
# Crée les nouveaux groupes
group_ids = [ ]
for group_name in group_names :
# try:
# checkGroupName(group_name)
# except:
# H.append('<p class="warning">Nom de groupe invalide: %s</p>'%group_name)
2021-09-27 10:20:10 +02:00
# return '\n'.join(H) + tf[1] + html_sco_header.sco_footer()
2021-10-12 16:05:50 +02:00
group_ids . append ( create_group ( partition_id , group_name ) )
2020-09-26 16:19:37 +02:00
#
2021-07-19 19:53:01 +02:00
nt = sco_cache . NotesTableCache . get ( formsemestre_id ) # > identdict
2020-09-26 16:19:37 +02:00
identdict = nt . identdict
2021-02-13 17:28:55 +01:00
# build: { civilite : liste etudids trie par niveau croissant }
2021-07-11 23:02:35 +02:00
civilites = set ( [ x [ " civilite " ] for x in identdict . values ( ) ] )
2020-09-26 16:19:37 +02:00
listes = { }
2021-02-13 17:28:55 +01:00
for civilite in civilites :
listes [ civilite ] = [
2021-08-19 10:28:35 +02:00
( _get_prev_moy ( x [ " etudid " ] , formsemestre_id ) , x [ " etudid " ] )
2020-09-26 16:19:37 +02:00
for x in identdict . values ( )
2021-02-13 17:28:55 +01:00
if x [ " civilite " ] == civilite
2020-09-26 16:19:37 +02:00
]
2021-02-13 17:28:55 +01:00
listes [ civilite ] . sort ( )
log ( " listes[ %s ] = %s " % ( civilite , listes [ civilite ] ) )
2020-09-26 16:19:37 +02:00
# affect aux groupes:
n = len ( identdict )
igroup = 0
nbgroups = len ( group_ids )
while n > 0 :
2021-02-13 17:28:55 +01:00
for civilite in civilites :
if len ( listes [ civilite ] ) :
2020-09-26 16:19:37 +02:00
n - = 1
2021-02-13 17:28:55 +01:00
etudid = listes [ civilite ] . pop ( ) [ 1 ]
2020-09-26 16:19:37 +02:00
group_id = group_ids [ igroup ]
igroup = ( igroup + 1 ) % nbgroups
2021-09-02 18:05:22 +02:00
change_etud_group_in_partition ( etudid , group_id , partition )
2020-09-26 16:19:37 +02:00
log ( " %s in group %s " % ( etudid , group_id ) )
2021-07-31 18:01:10 +02:00
return flask . redirect ( dest_url )
2020-09-26 16:19:37 +02:00
2021-08-19 10:28:35 +02:00
def _get_prev_moy ( etudid , formsemestre_id ) :
2020-09-26 16:19:37 +02:00
""" Donne la derniere moyenne generale calculee pour cette étudiant,
ou 0 si on n ' en trouve pas (nouvel inscrit,...).
"""
2021-06-19 23:21:37 +02:00
from app . scodoc import sco_parcours_dut
2020-09-26 16:19:37 +02:00
2021-06-19 23:21:37 +02:00
info = sco_etud . get_etud_info ( etudid = etudid , filled = True )
2020-09-26 16:19:37 +02:00
if not info :
raise ScoValueError ( " etudiant invalide: etudid= %s " % etudid )
etud = info [ 0 ]
2021-08-19 10:28:35 +02:00
Se = sco_parcours_dut . SituationEtudParcours ( etud , formsemestre_id )
2020-09-26 16:19:37 +02:00
if Se . prev :
2021-07-19 19:53:01 +02:00
nt = sco_cache . NotesTableCache . get (
Se . prev [ " formsemestre_id " ]
2020-09-26 16:19:37 +02:00
) # > get_etud_moy_gen
return nt . get_etud_moy_gen ( etudid )
else :
return 0.0
2021-08-19 10:28:35 +02:00
def create_etapes_partition ( formsemestre_id , partition_name = " apo_etapes " ) :
2020-12-01 16:46:45 +01:00
""" Crée une partition " apo_etapes " avec un groupe par étape Apogée.
Cette partition n ' est crée que si plusieurs étapes différentes existent dans ce
semestre .
Si la partition existe déjà , ses groupes sont mis à jour ( les groupes devenant
vides ne sont pas supprimés ) .
"""
2021-06-19 23:21:37 +02:00
from app . scodoc import sco_formsemestre_inscriptions
2021-10-15 14:31:11 +02:00
partition_name = str ( partition_name )
2020-12-01 16:46:45 +01:00
log ( " create_etapes_partition( %s ) " % formsemestre_id )
2021-06-19 23:21:37 +02:00
ins = sco_formsemestre_inscriptions . do_formsemestre_inscription_list (
2021-08-19 10:28:35 +02:00
args = { " formsemestre_id " : formsemestre_id }
2020-12-01 16:46:45 +01:00
)
etapes = { i [ " etape " ] for i in ins if i [ " etape " ] }
2021-08-19 10:28:35 +02:00
partitions = get_partitions_list ( formsemestre_id , with_default = False )
2020-12-01 16:46:45 +01:00
partition = None
for p in partitions :
if p [ " partition_name " ] == partition_name :
partition = p
break
if len ( etapes ) < 2 and not partition :
return # moins de deux étapes, pas de création
if partition :
pid = partition [ " partition_id " ]
else :
pid = partition_create (
2021-08-19 10:28:35 +02:00
formsemestre_id , partition_name = partition_name , redirect = False
2020-12-01 16:46:45 +01:00
)
2021-08-19 10:28:35 +02:00
partition = get_partition ( pid )
groups = get_partition_groups ( partition )
2020-12-01 16:46:45 +01:00
groups_by_names = { g [ " group_name " ] : g for g in groups }
for etape in etapes :
if not ( etape in groups_by_names ) :
2021-10-12 16:05:50 +02:00
gid = create_group ( pid , etape )
2021-08-19 10:28:35 +02:00
g = get_group ( gid )
2020-12-01 16:46:45 +01:00
groups_by_names [ etape ] = g
# Place les etudiants dans les groupes
for i in ins :
if i [ " etape " ] :
change_etud_group_in_partition (
2021-08-19 10:28:35 +02:00
i [ " etudid " ] , groups_by_names [ i [ " etape " ] ] [ " group_id " ] , partition
2020-12-01 16:46:45 +01:00
)
2020-09-26 16:19:37 +02:00
def do_evaluation_listeetuds_groups (
2021-07-29 10:19:00 +02:00
evaluation_id , groups = None , getallstudents = False , include_dems = False
2020-09-26 16:19:37 +02:00
) :
""" Donne la liste des etudids inscrits a cette evaluation dans les
groupes indiqués .
Si getallstudents == True , donne tous les etudiants inscrits a cette
evaluation .
Si include_dems , compte aussi les etudiants démissionnaires
( sinon , par défaut , seulement les ' I ' )
2021-11-20 17:21:51 +01:00
Résultat : [ ( etudid , etat ) ] , où etat = ' I ' , ' D ' , ' DEF '
2020-09-26 16:19:37 +02:00
"""
2021-10-15 14:00:51 +02:00
# nb: pour notes_table / do_evaluation_etat, getallstudents est vrai et include_dems faux
2020-09-26 16:19:37 +02:00
fromtables = [
" notes_moduleimpl_inscription Im " ,
" notes_formsemestre_inscription Isem " ,
" notes_moduleimpl M " ,
" notes_evaluation E " ,
]
# construit condition sur les groupes
if not getallstudents :
if not groups :
return [ ] # no groups, so no students
rg = [ " gm.group_id = ' %(group_id)s ' " % g for g in groups ]
2021-10-15 14:00:51 +02:00
rq = """ and Isem.etudid = gm.etudid
2021-08-11 14:00:39 +02:00
and gd . partition_id = p . id
and p . formsemestre_id = Isem . formsemestre_id
"""
2020-09-26 16:19:37 +02:00
r = rq + " AND ( " + " or " . join ( rg ) + " ) "
fromtables + = [ " group_membership gm " , " group_descr gd " , " partition p " ]
else :
r = " "
# requete complete
req = (
2021-11-20 17:21:51 +01:00
" SELECT distinct Im.etudid, Isem.etat FROM "
2020-09-26 16:19:37 +02:00
+ " , " . join ( fromtables )
2021-10-15 14:00:51 +02:00
+ """ WHERE Isem.etudid = Im.etudid
2021-08-10 12:57:38 +02:00
and Im . moduleimpl_id = M . id
and Isem . formsemestre_id = M . formsemestre_id
and E . moduleimpl_id = M . id
and E . id = % ( evaluation_id ) s
"""
2020-09-26 16:19:37 +02:00
)
if not include_dems :
req + = " and Isem.etat= ' I ' "
req + = r
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2021-10-15 14:00:51 +02:00
cursor = cnx . cursor ( )
2020-09-26 16:19:37 +02:00
cursor . execute ( req , { " evaluation_id " : evaluation_id } )
2021-11-20 17:21:51 +01:00
return cursor . fetchall ( )
2020-09-26 16:19:37 +02:00
2021-08-19 10:28:35 +02:00
def do_evaluation_listegroupes ( evaluation_id , include_default = False ) :
2020-12-01 16:46:45 +01:00
""" Donne la liste des groupes dans lesquels figurent des etudiants inscrits
2020-09-26 16:19:37 +02:00
au module / semestre auquel appartient cette evaluation .
Si include_default , inclue aussi le groupe par defaut ( ' tous ' )
[ group ]
"""
if include_default :
c = " "
else :
c = " AND p.partition_name is not NULL "
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2021-10-15 14:00:51 +02:00
cursor = cnx . cursor ( )
2020-09-26 16:19:37 +02:00
cursor . execute (
2021-08-11 14:00:39 +02:00
""" SELECT DISTINCT gd.id AS group_id
FROM group_descr gd , group_membership gm , partition p ,
notes_moduleimpl m , notes_evaluation e
WHERE gm . group_id = gd . id
and gd . partition_id = p . id
and p . formsemestre_id = m . formsemestre_id
and m . id = e . moduleimpl_id
and e . id = % ( evaluation_id ) s
"""
2020-09-26 16:19:37 +02:00
+ c ,
{ " evaluation_id " : evaluation_id } ,
)
2021-10-15 14:00:51 +02:00
group_ids = [ x [ 0 ] for x in cursor ]
2021-08-19 10:28:35 +02:00
return listgroups ( group_ids )
2020-09-26 16:19:37 +02:00
2021-08-19 10:28:35 +02:00
def listgroups ( group_ids ) :
2021-06-15 13:59:56 +02:00
cnx = ndb . GetDBConnexion ( )
2021-02-03 22:00:41 +01:00
cursor = cnx . cursor ( cursor_factory = ndb . ScoDocCursor )
2020-09-26 16:19:37 +02:00
groups = [ ]
for group_id in group_ids :
cursor . execute (
2021-10-24 18:28:01 +02:00
""" SELECT gd.id AS group_id, gd.*, p.id AS partition_id, p.*
FROM group_descr gd , partition p
WHERE p . id = gd . partition_id
2021-08-11 13:01:37 +02:00
AND gd . id = % ( group_id ) s
""" ,
2020-09-26 16:19:37 +02:00
{ " group_id " : group_id } ,
)
r = cursor . dictfetchall ( )
if r :
groups . append ( r [ 0 ] )
return _sortgroups ( groups )
def _sortgroups ( groups ) :
# Tri: place 'all' en tête, puis groupe par partition / nom de groupe
R = [ g for g in groups if g [ " partition_name " ] is None ]
o = [ g for g in groups if g [ " partition_name " ] != None ]
2021-09-16 00:16:50 +02:00
o . sort ( key = lambda x : ( x [ " numero " ] or 0 , x [ " group_name " ] ) )
2020-09-26 16:19:37 +02:00
return R + o
def listgroups_filename ( groups ) :
""" Build a filename representing groups """
return " gr " + " + " . join ( [ g [ " group_name " ] or " tous " for g in groups ] )
def listgroups_abbrev ( groups ) :
""" Human readable abbreviation descring groups (eg " A / AB / B3 " )
Ne retient que les partitions avec show_in_lists
"""
return " / " . join (
[ g [ " group_name " ] for g in groups if g [ " group_name " ] and g [ " show_in_lists " ] ]
)
# form_group_choice replaces formChoixGroupe
def form_group_choice (
formsemestre_id ,
allow_none = True , # offre un choix vide dans chaque partition
select_default = True , # Le groupe par defaut est mentionné (hidden).
display_sem_title = False ,
) :
""" Partie de formulaire pour le choix d ' un ou plusieurs groupes.
Variable : group_ids
"""
2021-06-21 11:22:55 +02:00
from app . scodoc import sco_formsemestre
2021-08-19 10:28:35 +02:00
sem = sco_formsemestre . get_formsemestre ( formsemestre_id )
2020-09-26 16:19:37 +02:00
if display_sem_title :
sem_title = " %s : " % sem [ " titremois " ]
else :
sem_title = " "
#
H = [ """ <table> """ ]
2021-08-19 10:28:35 +02:00
for p in get_partitions_list ( formsemestre_id ) :
2020-09-26 16:19:37 +02:00
if p [ " partition_name " ] is None :
if select_default :
H . append (
' <input type= " hidden " name= " group_ids:list " value= " %s " /> '
2021-08-19 10:28:35 +02:00
% get_partition_groups ( p ) [ 0 ] [ " group_id " ]
2020-09-26 16:19:37 +02:00
)
else :
H . append ( " <tr><td>Groupe de %(partition_name)s </td><td> " % p )
H . append ( ' <select name= " group_ids:list " > ' )
if allow_none :
H . append ( ' <option value= " " >aucun</option> ' )
2021-08-19 10:28:35 +02:00
for group in get_partition_groups ( p ) :
2020-09-26 16:19:37 +02:00
H . append (
' <option value= " %s " > %s %s </option> '
% ( group [ " group_id " ] , sem_title , group [ " group_name " ] )
)
H . append ( " </select></td></tr> " )
H . append ( """ </table> """ )
return " \n " . join ( H )
def make_query_groups ( group_ids ) :
if group_ids :
2021-08-10 17:12:10 +02:00
return " & " . join ( [ " group_ids % 3Alist= " + str ( group_id ) for group_id in group_ids ] )
2020-09-26 16:19:37 +02:00
else :
return " "
2021-07-09 23:31:16 +02:00
class GroupIdInferer ( object ) :
2020-09-26 16:19:37 +02:00
""" Sert à retrouver l ' id d ' un groupe dans un semestre donné
à partir de son nom .
Attention : il peut y avoir plusieurs groupes de même nom
dans des partitions différentes . Dans ce cas , prend le dernier listé .
On peut indiquer la partition en écrivant
partition_name : group_name
"""
2021-08-19 10:28:35 +02:00
def __init__ ( self , formsemestre_id ) :
groups = get_sem_groups ( formsemestre_id )
2020-09-26 16:19:37 +02:00
self . name2group_id = { }
self . partitionname2group_id = { }
for group in groups :
self . name2group_id [ group [ " group_name " ] ] = group [ " group_id " ]
self . partitionname2group_id [
( group [ " partition_name " ] , group [ " group_name " ] )
] = group [ " group_id " ]
def __getitem__ ( self , name ) :
""" Get group_id from group_name, or None is nonexistent.
The group name can be prefixed by the partition ' s name, using
syntax partition_name : group_name
"""
l = name . split ( " : " , 1 )
if len ( l ) > 1 :
partition_name , group_name = l
else :
partition_name = None
group_name = name
if partition_name is None :
group_id = self . name2group_id . get ( group_name , None )
if group_id is None and name [ - 2 : ] == " .0 " :
# si nom groupe numerique, excel ajoute parfois ".0" !
group_name = group_name [ : - 2 ]
group_id = self . name2group_id . get ( group_name , None )
else :
group_id = self . partitionname2group_id . get (
( partition_name , group_name ) , None
)
return group_id