forked from ScoDoc/ScoDoc
1130 lines
42 KiB
Python
1130 lines
42 KiB
Python
# -*- mode: python -*-
|
|
# -*- coding: utf-8 -*-
|
|
|
|
##############################################################################
|
|
#
|
|
# Gestion scolarite IUT
|
|
#
|
|
# Copyright (c) 1999 - 2024 Emmanuel Viennet. All rights reserved.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
#
|
|
# Emmanuel Viennet emmanuel.viennet@viennet.net
|
|
#
|
|
##############################################################################
|
|
|
|
"""Affichage étudiants d'un ou plusieurs groupes
|
|
sous forme: de liste html (table exportable), de trombinoscope (exportable en pdf)
|
|
"""
|
|
|
|
# Re-ecriture en 2014 (re-organisation de l'interface, modernisation du code)
|
|
# Modif en 2024 (9.7/revamp, abandon des tabs bootstrap)
|
|
|
|
import datetime
|
|
from urllib.parse import parse_qs
|
|
|
|
|
|
from flask import url_for, g, render_template, request
|
|
from flask_login import current_user
|
|
|
|
from app import db, log
|
|
from app.models import FormSemestre, Identite, ScolarEvent
|
|
import app.scodoc.sco_utils as scu
|
|
from app.scodoc import html_sco_header
|
|
from app.scodoc import sco_assiduites as scass
|
|
from app.scodoc import sco_excel
|
|
from app.scodoc import sco_formsemestre
|
|
from app.scodoc import sco_groups
|
|
from app.scodoc import sco_moduleimpl
|
|
from app.scodoc import sco_cursus
|
|
from app.scodoc import sco_portal_apogee
|
|
from app.scodoc import sco_preferences
|
|
from app.scodoc import sco_etud
|
|
from app.scodoc.sco_etud import etud_sort_key
|
|
from app.scodoc.gen_tables import GenTable
|
|
from app.scodoc.sco_exceptions import ScoValueError, ScoPermissionDenied
|
|
from app.scodoc.sco_permissions import Permission
|
|
|
|
JAVASCRIPTS = html_sco_header.BOOTSTRAP_JS + [
|
|
"js/groups_view.js",
|
|
"js/multi-select.js",
|
|
]
|
|
|
|
CSSSTYLES = html_sco_header.BOOTSTRAP_CSS
|
|
|
|
|
|
# view
|
|
def groups_lists(
|
|
group_ids=(),
|
|
fmt="html",
|
|
with_codes=0,
|
|
with_date_inscription=0,
|
|
etat=None,
|
|
with_paiement=0,
|
|
with_archives=0,
|
|
with_annotations=0,
|
|
with_bourse=0,
|
|
formsemestre_id=None,
|
|
):
|
|
"""Affichage des étudiants des groupes indiqués
|
|
group_ids: liste de group_id
|
|
fmt: csv, json, xml, xls, allxls, xlsappel, moodlecsv, pdf
|
|
|
|
Options pour listes:
|
|
with_paiement: si vrai, ajoute colonnes infos paiement droits
|
|
et finalisation inscription (lent car interrogation portail)
|
|
with_archives: ajoute colonne avec noms fichiers archivés
|
|
|
|
formsemestre_id est utilisé si aucun groupe selectionné pour construire la liste des groupes.
|
|
"""
|
|
# version sans tabs: juste la liste des étudiants
|
|
# Informations sur les groupes à afficher:
|
|
groups_infos = DisplayedGroupsInfos(
|
|
group_ids,
|
|
formsemestre_id=formsemestre_id,
|
|
etat=etat,
|
|
select_all_when_unspecified=True,
|
|
)
|
|
# Formats spéciaux: download direct
|
|
if fmt != "html":
|
|
return groups_table(
|
|
groups_infos=groups_infos,
|
|
fmt=fmt,
|
|
with_codes=with_codes,
|
|
with_date_inscription=with_date_inscription,
|
|
etat=etat,
|
|
with_paiement=with_paiement,
|
|
with_archives=with_archives,
|
|
with_annotations=with_annotations,
|
|
with_bourse=with_bourse,
|
|
)
|
|
|
|
# Note: le formulaire est soumis a chaque modif des groupes
|
|
# on pourrait faire comme pour le form de saisie des notes. Il faudrait pour cela:
|
|
# - charger tous les etudiants au debut, quels que soient les groupes selectionnés
|
|
# - ajouter du JS pour modifier les liens (arguments group_ids) quand le menu change
|
|
|
|
return render_template(
|
|
"formsemestre/groups_lists.j2",
|
|
form_groups_choice=form_groups_choice(groups_infos, submit_on_change=True),
|
|
groups_table=groups_table(
|
|
groups_infos=groups_infos,
|
|
fmt=fmt,
|
|
with_codes=with_codes,
|
|
with_date_inscription=with_date_inscription,
|
|
etat=etat,
|
|
with_paiement=with_paiement,
|
|
with_archives=with_archives,
|
|
with_annotations=with_annotations,
|
|
with_bourse=with_bourse,
|
|
),
|
|
groups_titles=groups_infos.groups_titles,
|
|
)
|
|
|
|
|
|
# view
|
|
def groups_photos(group_ids=(), etat=None, formsemestre_id=None):
|
|
"""Affichage des photos des étudiants (trombi) des groupes indiqués
|
|
group_ids: liste de group_id
|
|
formsemestre_id est utilisé si aucun groupe selectionné pour construire la liste des groupes.
|
|
"""
|
|
groups_infos = DisplayedGroupsInfos(
|
|
group_ids,
|
|
formsemestre_id=formsemestre_id,
|
|
select_all_when_unspecified=True,
|
|
)
|
|
return render_template(
|
|
"formsemestre/groups_photos.j2",
|
|
form_groups_choice=form_groups_choice(groups_infos, submit_on_change=True),
|
|
tab_photos_html=tab_photos_html(groups_infos, etat=etat),
|
|
groups_titles=groups_infos.groups_titles,
|
|
)
|
|
|
|
|
|
def groups_feuilles(group_ids=(), etat=None, formsemestre_id=None):
|
|
"""Affichage des feuilles d'appel des groupes indiqués
|
|
group_ids: liste de group_id
|
|
formsemestre_id est utilisé si aucun groupe selectionné pour construire la liste des groupes.
|
|
"""
|
|
groups_infos = DisplayedGroupsInfos(
|
|
group_ids,
|
|
formsemestre_id=formsemestre_id,
|
|
select_all_when_unspecified=True,
|
|
)
|
|
return render_template(
|
|
"formsemestre/groups_feuilles.j2",
|
|
form_groups_choice=form_groups_choice(groups_infos, submit_on_change=True),
|
|
tab_absences_html=tab_absences_html(groups_infos, etat=etat),
|
|
groups_titles=groups_infos.groups_titles,
|
|
)
|
|
|
|
|
|
def form_groups_choice(
|
|
groups_infos,
|
|
with_selectall_butt=False,
|
|
with_deselect_butt=False,
|
|
submit_on_change=False,
|
|
default_deselect_others=True,
|
|
):
|
|
"""form pour selection groupes
|
|
group_ids est la liste des groupes actuellement sélectionnés
|
|
et doit comporter au moins un élément, sauf si formsemestre_id est spécifié.
|
|
(utilisé pour retrouver le semestre et proposer la liste des autres groupes)
|
|
|
|
Si submit_on_change, soumet (recharge la page) à chaque modif.
|
|
Si default_deselect_others, désélectionne le groupe "Tous" quand on sélectionne un autre groupe.
|
|
|
|
Ces deux options ajoutent des classes utilisées en JS pour la gestion du formulaire.
|
|
"""
|
|
default_group_id = sco_groups.get_default_group(groups_infos.formsemestre_id)
|
|
|
|
H = [
|
|
f"""
|
|
<form id="group_selector" method="get">
|
|
<input type="hidden" name="formsemestre_id" id="formsemestre_id"
|
|
value="{groups_infos.formsemestre_id}"/>
|
|
<input type="hidden" name="default_group_id" id="default_group_id"
|
|
value="{default_group_id}"/>
|
|
Groupes:
|
|
{
|
|
menu_groups_choice(
|
|
groups_infos,
|
|
submit_on_change=submit_on_change,
|
|
default_deselect_others=default_deselect_others,
|
|
)
|
|
}
|
|
"""
|
|
]
|
|
if with_selectall_butt:
|
|
H.append(
|
|
"""<input type="button" value="sélectionner tous" onmousedown="select_groupe_tous();"/>"""
|
|
)
|
|
if with_deselect_butt:
|
|
H.append(
|
|
"""<input type="button" value="ne pas filtrer" onmousedown="remove_group_filter();"/>"""
|
|
)
|
|
H.append("</form>")
|
|
|
|
return "\n".join(H)
|
|
|
|
|
|
def menu_groups_choice(
|
|
groups_infos,
|
|
submit_on_change=False,
|
|
default_deselect_others=True,
|
|
html_export=True,
|
|
change_event=None, # XXX ???
|
|
):
|
|
"""menu pour selection groupes
|
|
group_ids est la liste des groupes actuellement sélectionnés
|
|
et doit comporter au moins un élément, sauf si formsemestre_id est spécifié.
|
|
(utilisé pour retrouver le semestre et proposer la liste des autres groupes)
|
|
|
|
Si html_export :
|
|
selecteur.value = &group_ids=xxx&group_ids=yyy...
|
|
sinon :
|
|
selecteur.value = [xxx, yyy, ...]
|
|
|
|
Si change_event :
|
|
met à jour l'événement onchange du selecteur
|
|
(attend du js, plus d'informations sur scu.MultiSelect.change_event)
|
|
|
|
"""
|
|
default_group_id = sco_groups.get_default_group(groups_infos.formsemestre_id)
|
|
n_members = len(sco_groups.get_group_members(default_group_id))
|
|
|
|
values: dict = {
|
|
# Choix : Tous (tous les groupes)
|
|
"": [
|
|
{
|
|
"value": default_group_id,
|
|
"label": f"Tous ({n_members})",
|
|
"selected": default_group_id in groups_infos.group_ids,
|
|
"single": default_deselect_others,
|
|
}
|
|
]
|
|
}
|
|
|
|
for partition in groups_infos.partitions:
|
|
p_name: str = partition["partition_name"]
|
|
vals: list[tuple[str, str, bool]] = []
|
|
# Les groupes dans cette partition:
|
|
for grp in sco_groups.get_partition_groups(partition):
|
|
selected: bool = grp["group_id"] in groups_infos.group_ids
|
|
if grp["group_name"]:
|
|
vals.append(
|
|
{
|
|
"value": grp["group_id"],
|
|
"label": f"{grp['group_name']} ({len(sco_groups.get_group_members(grp['group_id']))})",
|
|
"selected": selected,
|
|
}
|
|
)
|
|
|
|
values[p_name] = vals
|
|
|
|
multi_select: scu.MultiSelect = scu.MultiSelect(
|
|
values=values, name="group_ids", html_id="group_ids_sel"
|
|
)
|
|
|
|
if html_export:
|
|
multi_select.export_format('return "&group_ids="+values.join("&group_ids=")')
|
|
|
|
if submit_on_change:
|
|
multi_select.change_event("submit_group_selector();")
|
|
|
|
return multi_select.html()
|
|
|
|
|
|
def menu_group_choice(group_id=None, formsemestre_id=None):
|
|
"""Un bête menu pour choisir un seul groupe
|
|
group_id est le groupe actuellement sélectionné.
|
|
Si aucun groupe selectionné, utilise formsemestre_id pour lister les groupes.
|
|
"""
|
|
if group_id:
|
|
group = sco_groups.get_group(group_id)
|
|
formsemestre_id = group["formsemestre_id"]
|
|
elif not formsemestre_id:
|
|
raise ValueError("missing formsemestre_id")
|
|
H = [
|
|
"""
|
|
<select id="group_selector_u" name="group_id" onchange="reload_selected_group();">
|
|
"""
|
|
]
|
|
if not group_id:
|
|
H.append('<option value="">choisir...</option>')
|
|
for partition in sco_groups.get_partitions_list(formsemestre_id):
|
|
if partition["partition_name"]:
|
|
H.append('<optgroup label="%s">' % partition["partition_name"])
|
|
groups = sco_groups.get_partition_groups(partition)
|
|
for group in groups:
|
|
if group["group_id"] == group_id:
|
|
selected = "selected"
|
|
else:
|
|
selected = ""
|
|
name = group["group_name"] or "Tous"
|
|
n_members = len(sco_groups.get_group_members(group["group_id"]))
|
|
H.append(
|
|
'<option value="%s" %s>%s (%s)</option>'
|
|
% (group["group_id"], selected, name, n_members)
|
|
)
|
|
if partition["partition_name"]:
|
|
H.append("</optgroup>")
|
|
H.append(
|
|
"""</select>
|
|
<script>
|
|
function reload_selected_group() {
|
|
var url = $.url();
|
|
var group_id = $("#group_selector_u").val();
|
|
if (group_id) {
|
|
url.param()['group_id'] = group_id;
|
|
var query_string = $.param(url.param(), traditional=true );
|
|
window.location = url.attr('base') + url.attr('path') + '?' + query_string;
|
|
}
|
|
}
|
|
</script>
|
|
"""
|
|
)
|
|
return "\n".join(H)
|
|
|
|
|
|
class DisplayedGroupsInfos:
|
|
"""Container with attributes describing groups to display in the page
|
|
.groups_query_args : 'group_ids=xxx&group_ids=yyy'
|
|
.base_url : url de la requete, avec les groupes, sans les autres paramètres
|
|
.formsemestre_id : semestre "principal" (en fait celui du 1er groupe de la liste)
|
|
.members :
|
|
.groups_titles
|
|
|
|
etat: filtrage selon l'état de l'inscription
|
|
select_all_when_unspecified : sélectionne le groupe "tous" si aucun groupe n'est indiqué.
|
|
empty_list_select_all: si vrai (défaut) on sélectionne le groupe tous si aucun groupe indiqué.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
group_ids=(), # groupes specifies dans l'URL, ou un seul int
|
|
formsemestre_id: int | None = None,
|
|
etat: str | None = None,
|
|
select_all_when_unspecified=False,
|
|
empty_list_select_all=True,
|
|
moduleimpl_id=None, # used to find formsemestre when unspecified
|
|
):
|
|
group_ids = [] if group_ids is None else group_ids
|
|
if isinstance(group_ids, int):
|
|
if group_ids:
|
|
group_ids = [group_ids] # cas ou un seul parametre, pas de liste
|
|
else:
|
|
try:
|
|
group_ids = [int(g) for g in group_ids]
|
|
except ValueError as exc:
|
|
log(f"DisplayedGroupsInfos: invalid group_id '{group_ids}'")
|
|
raise ScoValueError(
|
|
"identifiant de groupe invalide (mettre à jour vos bookmarks ?)"
|
|
) from exc
|
|
if not formsemestre_id and moduleimpl_id:
|
|
mods = sco_moduleimpl.moduleimpl_list(moduleimpl_id=moduleimpl_id)
|
|
if len(mods) != 1:
|
|
raise ValueError("invalid moduleimpl_id")
|
|
formsemestre_id = mods[0]["formsemestre_id"]
|
|
|
|
if not group_ids: # appel sans groupe (eg page accueil)
|
|
if not formsemestre_id:
|
|
raise ValueError("missing parameter formsemestre_id or group_ids")
|
|
if empty_list_select_all:
|
|
if select_all_when_unspecified:
|
|
group_ids = [
|
|
sco_groups.get_default_group(
|
|
formsemestre_id, fix_if_missing=True
|
|
)
|
|
]
|
|
else:
|
|
# selectionne le premier groupe trouvé, s'il y en a un
|
|
partition = sco_groups.get_partitions_list(
|
|
formsemestre_id, with_default=True
|
|
)[0]
|
|
groups = sco_groups.get_partition_groups(partition)
|
|
if groups:
|
|
group_ids = [groups[0]["group_id"]]
|
|
else:
|
|
group_ids = [sco_groups.get_default_group(formsemestre_id)]
|
|
else:
|
|
group_ids = []
|
|
|
|
gq = []
|
|
for group_id in group_ids:
|
|
gq.append("group_ids=" + str(group_id))
|
|
self.groups_query_args = "&".join(gq)
|
|
self.base_url = request.base_url + "?" + self.groups_query_args
|
|
self.group_ids = group_ids
|
|
self.groups = []
|
|
groups_titles = []
|
|
self.members = []
|
|
self.tous_les_etuds_du_sem = (
|
|
False # affiche tous les etuds du semestre ? (si un seul semestre)
|
|
)
|
|
self.sems = {} # formsemestre_id : sem
|
|
self.formsemestre = None
|
|
self.formsemestre_id = formsemestre_id
|
|
self.nbdem = 0 # nombre d'étudiants démissionnaires en tout
|
|
sem = None
|
|
selected_partitions = set()
|
|
for group_id in group_ids:
|
|
group_members, group, group_tit, sem, nbdem = sco_groups.get_group_infos(
|
|
group_id, etat=etat
|
|
)
|
|
self.groups.append(group)
|
|
self.nbdem += nbdem
|
|
self.sems[sem["formsemestre_id"]] = sem
|
|
if not self.formsemestre_id:
|
|
self.formsemestre_id = sem["formsemestre_id"]
|
|
self.formsemestre = sem
|
|
self.members.extend(group_members)
|
|
groups_titles.append(group_tit)
|
|
if group["partition_name"] is None:
|
|
self.tous_les_etuds_du_sem = True
|
|
else:
|
|
# liste les partitions explicitement sélectionnés (= des groupes de group_ids)
|
|
selected_partitions.add((group["numero"] or 0, group["partition_id"]))
|
|
|
|
self.selected_partitions = [
|
|
x[1] for x in sorted(list(selected_partitions))
|
|
] # -> [ partition_id ]
|
|
|
|
if not self.formsemestre: # aucun groupe selectionne
|
|
self.formsemestre = sco_formsemestre.get_formsemestre(formsemestre_id)
|
|
if formsemestre_id not in self.sems:
|
|
self.sems[formsemestre_id] = self.formsemestre
|
|
self.sortuniq()
|
|
|
|
if len(self.sems) > 1:
|
|
self.tous_les_etuds_du_sem = False # plusieurs semestres
|
|
if self.tous_les_etuds_du_sem:
|
|
if sem and sem["semestre_id"] >= 0:
|
|
self.groups_titles = "S%d" % sem["semestre_id"]
|
|
else:
|
|
self.groups_titles = "tous"
|
|
self.groups_filename = self.groups_titles
|
|
else:
|
|
self.groups_titles = ", ".join(groups_titles)
|
|
self.groups_filename = "_".join(groups_titles).replace(" ", "_")
|
|
# Sanitize filename:
|
|
self.groups_filename = scu.make_filename(self.groups_filename)
|
|
|
|
# colonnes pour affichages nom des groupes:
|
|
# gère le cas où les étudiants appartiennent à des semestres différents
|
|
self.partitions = [] # les partitions, sans celle par defaut
|
|
for formsemestre_id in self.sems:
|
|
for partition in sco_groups.get_partitions_list(formsemestre_id):
|
|
if partition["partition_name"]:
|
|
self.partitions.append(partition)
|
|
|
|
def sortuniq(self):
|
|
"Trie les étudiants (de plusieurs groupes) et élimine les doublons"
|
|
if (len(self.group_ids) <= 1) or len(self.members) <= 1:
|
|
return # on suppose que les etudiants d'un groupe sont deja triés
|
|
# tri selon nom_usuel ou nom, sans accents
|
|
self.members.sort(key=etud_sort_key)
|
|
to_remove = []
|
|
T = self.members
|
|
for i in range(len(T) - 1, 0, -1):
|
|
if T[i - 1]["etudid"] == T[i]["etudid"]:
|
|
to_remove.append(i)
|
|
for i in to_remove:
|
|
del T[i]
|
|
|
|
def get_etudids(self) -> set[int]:
|
|
"Les etudids des groupes choisis"
|
|
return {member["etudid"] for member in self.members}
|
|
|
|
def get_form_elem(self):
|
|
"""html hidden input with groups"""
|
|
H = []
|
|
for group_id in self.group_ids:
|
|
H.append(f'<input type="hidden" name="group_ids" value="{group_id}"/>')
|
|
return "\n".join(H)
|
|
|
|
def get_formsemestre(self) -> FormSemestre:
|
|
return (
|
|
db.session.get(FormSemestre, self.formsemestre_id)
|
|
if self.formsemestre_id
|
|
else None
|
|
)
|
|
|
|
def get_groups_key(self) -> str:
|
|
"clé identifiant les groupes sélectionnés, utile pour cache"
|
|
return "-".join(str(x) for x in sorted(self.group_ids))
|
|
|
|
|
|
# Ancien ZScolar.group_list renommé ici en group_table
|
|
def groups_table(
|
|
groups_infos: DisplayedGroupsInfos = None,
|
|
with_codes=0,
|
|
with_date_inscription=0,
|
|
etat=None,
|
|
fmt="html",
|
|
with_paiement=0, # si vrai, ajoute colonnes infos paiement droits et finalisation inscription (lent car interrogation portail)
|
|
with_archives=0, # ajoute colonne avec noms fichiers archivés
|
|
with_annotations=0,
|
|
with_bourse=0,
|
|
):
|
|
"""liste etudiants inscrits dans ce semestre
|
|
fmt: csv, json, xml, xls, allxls, xlsappel, moodlecsv, pdf
|
|
Si with_codes, ajoute 4 colonnes avec les codes etudid, NIP, INE et etape
|
|
"""
|
|
from app.scodoc import sco_report
|
|
|
|
can_view_etud_data = int(current_user.has_permission(Permission.ViewEtudData))
|
|
with_codes = int(with_codes)
|
|
with_date_inscription = int(with_date_inscription)
|
|
with_paiement = int(with_paiement) and can_view_etud_data
|
|
with_archives = int(with_archives) and can_view_etud_data
|
|
with_annotations = int(with_annotations) and can_view_etud_data
|
|
with_bourse = int(with_bourse) and can_view_etud_data
|
|
|
|
base_url = (
|
|
groups_infos.base_url
|
|
+ f"""&with_codes={with_codes}&with_date_inscription={
|
|
with_date_inscription}&with_paiement={with_paiement}&with_archives={
|
|
with_archives}&with_annotations={with_annotations
|
|
}&with_bourse={with_bourse}"""
|
|
)
|
|
#
|
|
columns_ids = ["civilite_str", "nom_disp", "prenom"] # colonnes a inclure
|
|
titles = {
|
|
"civilite_str": "Civ.",
|
|
"nom_disp": "Nom",
|
|
"prenom": "Prénom",
|
|
"email": "Mail",
|
|
"emailperso": "Personnel",
|
|
"etat": "Etat",
|
|
"etudid": "etudid",
|
|
"code_nip": "code_nip",
|
|
"code_ine": "code_ine",
|
|
"date_inscription": "Date inscription",
|
|
"datefinalisationinscription_str": "Finalisation inscr.",
|
|
"paiementinscription_str": "Paiement",
|
|
"etudarchive": "Fichiers",
|
|
"annotations_str": "Annotations",
|
|
"bourse_str": "Boursier", # requière ViewEtudData
|
|
"etape": "Etape",
|
|
"semestre_groupe": "Semestre-Groupe", # pour Moodle
|
|
"annee": "annee_admission",
|
|
"nationalite": "nationalite", # requière ViewEtudData
|
|
}
|
|
|
|
# ajoute colonnes pour groupes
|
|
columns_ids.extend([p["partition_id"] for p in groups_infos.partitions])
|
|
titles.update(
|
|
dict(
|
|
[(p["partition_id"], p["partition_name"]) for p in groups_infos.partitions]
|
|
)
|
|
)
|
|
partitions_name = {
|
|
p["partition_id"]: p["partition_name"] for p in groups_infos.partitions
|
|
}
|
|
|
|
if fmt != "html": # ne mentionne l'état que en Excel (style en html)
|
|
columns_ids.append("etat")
|
|
columns_ids.append("email")
|
|
if can_view_etud_data:
|
|
columns_ids.append("emailperso")
|
|
|
|
if fmt == "moodlecsv":
|
|
columns_ids = ["email", "semestre_groupe"]
|
|
|
|
if with_codes:
|
|
columns_ids += ["etape", "etudid", "code_nip", "code_ine"]
|
|
if with_date_inscription:
|
|
columns_ids += ["date_inscription"]
|
|
if with_paiement:
|
|
columns_ids += ["datefinalisationinscription_str", "paiementinscription_str"]
|
|
if with_paiement:
|
|
sco_portal_apogee.check_paiement_etuds(groups_infos.members)
|
|
if with_archives:
|
|
from app.scodoc import sco_archives_etud
|
|
|
|
sco_archives_etud.add_archives_info_to_etud_list(groups_infos.members)
|
|
columns_ids += ["etudarchive"]
|
|
if with_annotations:
|
|
sco_etud.add_annotations_to_etud_list(groups_infos.members)
|
|
columns_ids += ["annotations_str"]
|
|
if with_bourse:
|
|
columns_ids += ["bourse_str"]
|
|
moodle_sem_name = groups_infos.formsemestre["session_id"]
|
|
moodle_groupenames = set()
|
|
# ajoute liens
|
|
for etud_info in groups_infos.members:
|
|
if with_date_inscription:
|
|
event = ScolarEvent.query.filter_by(
|
|
etudid=etud_info["etudid"],
|
|
event_type="INSCRIPTION",
|
|
formsemestre_id=groups_infos.formsemestre_id,
|
|
).first()
|
|
if event:
|
|
etud_info["date_inscription"] = event.event_date.strftime(scu.DATE_FMT)
|
|
etud_info["_date_inscription_xls"] = event.event_date
|
|
etud_info["_date_inscription_order"] = event.event_date.isoformat
|
|
if etud_info["email"]:
|
|
etud_info["_email_target"] = "mailto:" + etud_info["email"]
|
|
else:
|
|
etud_info["_email_target"] = ""
|
|
if etud_info["emailperso"]:
|
|
etud_info["_emailperso_target"] = "mailto:" + etud_info["emailperso"]
|
|
else:
|
|
etud_info["_emailperso_target"] = ""
|
|
fiche_url = url_for(
|
|
"scolar.fiche_etud", scodoc_dept=g.scodoc_dept, etudid=etud_info["etudid"]
|
|
)
|
|
etud_info["_nom_disp_target"] = fiche_url
|
|
etud_info["_nom_disp_order"] = etud_sort_key(etud_info)
|
|
etud_info["_prenom_target"] = fiche_url
|
|
|
|
etud_info["_nom_disp_td_attrs"] = (
|
|
f"""id="{etud_info['etudid']}" class="etudinfo" """
|
|
)
|
|
etud_info["bourse_str"] = "oui" if etud_info["boursier"] else "non"
|
|
if etud_info["etat"] == "D":
|
|
etud_info["_css_row_class"] = "etuddem"
|
|
# et groupes:
|
|
for partition_id in etud_info["partitions"]:
|
|
etud_info[partition_id] = etud_info["partitions"][partition_id][
|
|
"group_name"
|
|
]
|
|
# Ajoute colonne pour moodle: semestre_groupe, de la forme
|
|
# RT-DUT-FI-S3-2021-PARTITION-GROUPE
|
|
moodle_groupename = []
|
|
if groups_infos.selected_partitions:
|
|
# il y a des groupes selectionnes, utilise leurs partitions
|
|
for partition_id in groups_infos.selected_partitions:
|
|
if partition_id in etud_info["partitions"]:
|
|
moodle_groupename.append(
|
|
partitions_name[partition_id]
|
|
+ "-"
|
|
+ etud_info["partitions"][partition_id]["group_name"]
|
|
)
|
|
else:
|
|
# pas de groupes sélectionnés: prend le premier s'il y en a un
|
|
moodle_groupename = ["tous"]
|
|
if etud_info["partitions"]:
|
|
for p in etud_info[
|
|
"partitions"
|
|
].items(): # partitions is an OrderedDict
|
|
moodle_groupename = [
|
|
partitions_name[p[0]] + "-" + p[1]["group_name"]
|
|
]
|
|
break
|
|
|
|
moodle_groupenames |= set(moodle_groupename)
|
|
etud_info["semestre_groupe"] = (
|
|
moodle_sem_name + "-" + "+".join(moodle_groupename)
|
|
)
|
|
|
|
if groups_infos.nbdem > 1:
|
|
s = "s"
|
|
else:
|
|
s = ""
|
|
|
|
if fmt == "moodlecsv":
|
|
# de la forme S1-[FI][FA]-groupe.csv
|
|
if not moodle_groupenames:
|
|
moodle_groupenames = {"tous"}
|
|
filename = (
|
|
moodle_sem_name
|
|
+ "-"
|
|
+ groups_infos.formsemestre["modalite"]
|
|
+ "-"
|
|
+ "+".join(sorted(moodle_groupenames))
|
|
)
|
|
else:
|
|
filename = f"etudiants_{groups_infos.groups_filename}"
|
|
|
|
prefs = sco_preferences.SemPreferences(groups_infos.formsemestre_id)
|
|
tab = GenTable(
|
|
rows=groups_infos.members,
|
|
columns_ids=columns_ids,
|
|
titles=titles,
|
|
caption="soit %d étudiants inscrits et %d démissionaire%s."
|
|
% (len(groups_infos.members) - groups_infos.nbdem, groups_infos.nbdem, s),
|
|
base_url=base_url,
|
|
filename=filename,
|
|
pdf_link=False, # pas d'export pdf
|
|
html_sortable=True,
|
|
html_class="table_leftalign table_listegroupe",
|
|
xml_outer_tag="group_list",
|
|
xml_row_tag="etud",
|
|
text_fields_separator=prefs["moodle_csv_separator"],
|
|
text_with_titles=prefs["moodle_csv_with_headerline"],
|
|
preferences=prefs,
|
|
table_id="groups_table",
|
|
)
|
|
#
|
|
if fmt == "html":
|
|
amail_inst = [
|
|
x["email"] for x in groups_infos.members if x["email"] and x["etat"] != "D"
|
|
]
|
|
amail_perso = [
|
|
x["emailperso"]
|
|
for x in groups_infos.members
|
|
if x["emailperso"] and x["etat"] != "D"
|
|
]
|
|
|
|
if len(groups_infos.members):
|
|
if groups_infos.tous_les_etuds_du_sem:
|
|
htitle = "Les %d étudiants inscrits" % len(groups_infos.members)
|
|
else:
|
|
htitle = "Groupe %s (%d étudiants)" % (
|
|
groups_infos.groups_titles,
|
|
len(groups_infos.members),
|
|
)
|
|
else:
|
|
htitle = "Aucun étudiant !"
|
|
H = [
|
|
f"""<div class="tab-content">
|
|
<form>
|
|
<span style="font-weight:bold; font-size:120%;">{htitle}</span>
|
|
"""
|
|
]
|
|
if groups_infos.members:
|
|
options = {
|
|
"with_codes": "Affiche codes",
|
|
"with_date_inscription": "Date inscription",
|
|
}
|
|
if can_view_etud_data:
|
|
options.update(
|
|
{
|
|
"with_paiement": "Paiement inscription",
|
|
"with_archives": "Fichiers archivés",
|
|
"with_annotations": "Annotations",
|
|
"with_bourse": "Statut boursier",
|
|
}
|
|
)
|
|
valeurs: list[tuple[str, str]] = []
|
|
for option, label in options.items():
|
|
selected = locals().get(option, False)
|
|
valeurs.append(
|
|
{
|
|
"value": option,
|
|
"label": label,
|
|
"selected": selected,
|
|
}
|
|
)
|
|
|
|
multi_select: scu.MultiSelect = scu.MultiSelect(
|
|
values={"": valeurs},
|
|
label="Options",
|
|
name="options",
|
|
html_id="group_list_options",
|
|
)
|
|
multi_select.change_event("change_list_options(event.target.value);")
|
|
H.extend(
|
|
# ;
|
|
[
|
|
f"""
|
|
<span style="margin-left: 2em;">
|
|
|
|
{multi_select.html()}
|
|
|
|
</span>
|
|
""",
|
|
(
|
|
"""<span class="warning_unauthorized">accès aux données personnelles interdit</span>"""
|
|
if not can_view_etud_data
|
|
else ""
|
|
),
|
|
]
|
|
)
|
|
H.append("</div></form>")
|
|
if groups_infos.members:
|
|
H.extend(
|
|
[
|
|
tab.html(),
|
|
f"""
|
|
<ul>
|
|
<li><a class="stdlink" href="{tab.base_url}&fmt=xls">Table Excel</a>
|
|
</li>
|
|
<li><a class="stdlink" href="{tab.base_url}&fmt=moodlecsv">Fichier CSV pour Moodle (groupe sélectionné)</a>
|
|
</li>
|
|
<li>
|
|
<a class="stdlink" href="export_groups_as_moodle_csv?formsemestre_id={groups_infos.formsemestre_id}">
|
|
Fichier CSV pour Moodle (tous les groupes)</a>
|
|
<em>(voir le paramétrage pour modifier le format des fichiers Moodle exportés)</em>
|
|
</li>""",
|
|
]
|
|
)
|
|
if amail_inst:
|
|
H.append(
|
|
f"""<li>
|
|
<a class="stdlink" href="mailto:?bcc={','.join(amail_inst)
|
|
}">Envoyer un mail collectif au groupe de {groups_infos.groups_titles}
|
|
(via {len(amail_inst)} adresses institutionnelles)</a>
|
|
</li>"""
|
|
)
|
|
|
|
if can_view_etud_data:
|
|
if amail_perso:
|
|
H.append(
|
|
f"""<li>
|
|
<a class="stdlink" href="mailto:?bcc={','.join(amail_perso)
|
|
}">Envoyer un mail collectif au groupe de {groups_infos.groups_titles}
|
|
(via {len(amail_perso)} adresses personnelles)</a>
|
|
</li>"""
|
|
)
|
|
else:
|
|
H.append("<li><em>Adresses personnelles non renseignées</em></li>")
|
|
else:
|
|
H.append(
|
|
"""<li class="unauthorized">adresses mail personnelles protégées</li>"""
|
|
)
|
|
|
|
H.append("</ul>")
|
|
|
|
return "".join(H)
|
|
|
|
elif fmt in {"pdf", "xml", "json", "xls", "moodlecsv"}:
|
|
if fmt == "moodlecsv":
|
|
fmt = "csv"
|
|
return tab.make_page(fmt=fmt)
|
|
|
|
elif fmt == "xlsappel":
|
|
xls = sco_excel.excel_feuille_listeappel(
|
|
groups_infos.formsemestre,
|
|
groups_infos.groups_titles,
|
|
groups_infos.members,
|
|
partitions=groups_infos.partitions,
|
|
with_codes=with_codes,
|
|
with_date_inscription=with_date_inscription,
|
|
with_paiement=with_paiement,
|
|
server_name=request.url_root,
|
|
)
|
|
filename = f"liste_{groups_infos.groups_filename}"
|
|
return scu.send_file(xls, filename, scu.XLSX_SUFFIX, scu.XLSX_MIMETYPE)
|
|
elif fmt == "allxls":
|
|
if not can_view_etud_data:
|
|
raise ScoPermissionDenied(
|
|
"Vous n'avez pas la permission requise (ViewEtudData)"
|
|
)
|
|
# feuille Excel avec toutes les infos etudiants
|
|
if not groups_infos.members:
|
|
return ""
|
|
keys = [
|
|
"etudid",
|
|
"code_nip",
|
|
"etat",
|
|
"civilite_str",
|
|
"nom",
|
|
"nom_usuel",
|
|
"prenom",
|
|
"inscriptionstr",
|
|
]
|
|
if with_paiement:
|
|
keys.append("paiementinscription")
|
|
keys += [
|
|
"email",
|
|
"emailperso",
|
|
"domicile",
|
|
"villedomicile",
|
|
"codepostaldomicile",
|
|
"paysdomicile",
|
|
"telephone",
|
|
"telephonemobile",
|
|
"fax",
|
|
"date_naissance",
|
|
"lieu_naissance",
|
|
"nationalite",
|
|
"bac",
|
|
"specialite",
|
|
"annee_bac",
|
|
"nomlycee",
|
|
"villelycee",
|
|
"codepostallycee",
|
|
"codelycee",
|
|
"annee",
|
|
"type_admission",
|
|
"boursier_prec",
|
|
"boursier",
|
|
"debouche",
|
|
"parcours",
|
|
"code_cursus",
|
|
]
|
|
titles = keys[:]
|
|
other_partitions = sco_groups.get_group_other_partitions(groups_infos.groups[0])
|
|
keys += [p["partition_id"] for p in other_partitions]
|
|
titles += [p["partition_name"] for p in other_partitions]
|
|
# remplis infos lycee si on a que le code lycée
|
|
# et ajoute infos inscription
|
|
for m in groups_infos.members:
|
|
etud_info = sco_etud.get_etud_info(m["etudid"], filled=True)[0]
|
|
# TODO utiliser Identite
|
|
etud = Identite.get_etud(m["etudid"])
|
|
m.update(etud_info)
|
|
sco_etud.etud_add_lycee_infos(etud_info)
|
|
# et ajoute le parcours
|
|
Se = sco_cursus.get_situation_etud_cursus(
|
|
etud, groups_infos.formsemestre_id
|
|
)
|
|
m["parcours"] = Se.get_cursus_descr()
|
|
m["code_cursus"], _ = sco_report.get_code_cursus_etud(
|
|
etud.id, formsemestres=etud.get_formsemestres()
|
|
)
|
|
# TODO utiliser Identite:
|
|
rows = [[m.get(k, "") for k in keys] for m in groups_infos.members]
|
|
title = f"etudiants_{groups_infos.groups_filename}"
|
|
xls = sco_excel.excel_simple_table(titles=titles, lines=rows, sheet_name=title)
|
|
return scu.send_file(
|
|
xls, filename=title, suffix=scu.XLSX_SUFFIX, mime=scu.XLSX_MIMETYPE
|
|
)
|
|
else:
|
|
raise ScoValueError("unsupported format")
|
|
|
|
|
|
def tab_absences_html(groups_infos, etat=None):
|
|
"""contenu du tab "absences et feuilles diverses" """
|
|
authuser = current_user
|
|
H = ['<div class="tab-content">']
|
|
if not groups_infos.members:
|
|
return "".join(H) + "<h3>Aucun étudiant !</h3></div>"
|
|
|
|
group_ids: str = ",".join(map(str, groups_infos.group_ids))
|
|
formsemestre: FormSemestre = groups_infos.get_formsemestre()
|
|
disable_abs: str | bool = scass.has_assiduites_disable_pref(formsemestre)
|
|
|
|
liens_abs: list = [
|
|
'<ul class="ul_abs">',
|
|
"<li>",
|
|
form_choix_saisie_semaine(groups_infos), # Ajout Le Havre
|
|
"</li>",
|
|
"<li>",
|
|
form_choix_jour_saisie_hebdo(groups_infos),
|
|
"</li>",
|
|
f"""<li><a class="stdlink" href="{
|
|
url_for("assiduites.visu_assi_group", scodoc_dept=g.scodoc_dept,
|
|
group_ids=group_ids,
|
|
date_debut=formsemestre.date_debut.isoformat(),
|
|
date_fin=formsemestre.date_fin.isoformat()
|
|
)
|
|
}">État de l'assiduité du groupe</a></li>""",
|
|
"</ul>",
|
|
]
|
|
|
|
if disable_abs:
|
|
liens_abs = [
|
|
f"""
|
|
<div class="scobox" style="width:fit-content; font-style:italic;">
|
|
La gestion des absences est désactivée dans ScoDoc pour ce semestre:
|
|
{disable_abs}
|
|
</div>
|
|
"""
|
|
]
|
|
|
|
url_feuille_appel: str = (
|
|
url_for(
|
|
"scolar.formulaire_feuille_appel",
|
|
scodoc_dept=g.scodoc_dept,
|
|
formsemestre_id=groups_infos.formsemestre_id,
|
|
)
|
|
+ "?"
|
|
+ groups_infos.groups_query_args
|
|
)
|
|
|
|
H.extend(
|
|
[
|
|
"<h3>Assiduité</h3>",
|
|
*liens_abs,
|
|
"<h3>Feuilles</h3>",
|
|
'<ul class="ul_feuilles">',
|
|
"""<li><a class="stdlink" href="%s">Feuille d'émargement %s (Excel)</a></li>"""
|
|
% (url_feuille_appel, groups_infos.groups_titles),
|
|
"""<li><a class="stdlink" href="trombino?%s&fmt=pdf">Trombinoscope en PDF</a></li>"""
|
|
% groups_infos.groups_query_args,
|
|
"""<li><a class="stdlink" href="pdf_trombino_tours?%s&fmt=pdf">Trombinoscope en PDF (format "IUT de Tours", beta)</a></li>"""
|
|
% groups_infos.groups_query_args,
|
|
"""<li><a class="stdlink" href="pdf_feuille_releve_absences?%s&fmt=pdf">Feuille relevé absences hebdomadaire (beta)</a></li>"""
|
|
% groups_infos.groups_query_args,
|
|
"""<li><a class="stdlink" href="trombino?%s&fmt=pdflist">Liste d'appel avec photos</a></li>"""
|
|
% groups_infos.groups_query_args,
|
|
(
|
|
f"""<li><a class="stdlink" href="groups_export_annotations?{groups_infos.groups_query_args}">Liste des annotations</a></li>"""
|
|
if authuser.has_permission(Permission.ViewEtudData)
|
|
else """<li class="unauthorized" title="non autorisé">Liste des annotations</li>"""
|
|
),
|
|
"</ul>",
|
|
]
|
|
)
|
|
|
|
H.append('<h3>Opérations diverses</h3><ul class="ul_misc">')
|
|
# Lien pour verif codes INE/NIP
|
|
# (pour tous les etudiants du semestre)
|
|
group_id = sco_groups.get_default_group(groups_infos.formsemestre_id)
|
|
if authuser.has_permission(Permission.EtudInscrit):
|
|
H.append(
|
|
f"""<li><a class="stdlink" href="{
|
|
url_for('scolar.check_group_apogee',
|
|
scodoc_dept=g.scodoc_dept,
|
|
group_id=group_id, etat=etat or "")
|
|
}">Vérifier codes Apogée</a> (de tous les groupes)</li>
|
|
"""
|
|
)
|
|
# Lien pour ajout fichiers étudiants
|
|
text = "Télécharger des fichiers associés aux étudiants (e.g. dossiers d'admission)"
|
|
if authuser.has_permission(
|
|
Permission.EtudAddAnnotations
|
|
) and authuser.has_permission(Permission.ViewEtudData):
|
|
H.append(
|
|
f"""<li><a class="stdlink" href="{
|
|
url_for('scolar.etudarchive_import_files_form',
|
|
scodoc_dept=g.scodoc_dept,
|
|
group_id=group_id
|
|
)}">{text}</a></li>"""
|
|
)
|
|
else:
|
|
H.append(f"""<li class="unauthorized" title="non autorisé">{text}</li>""")
|
|
|
|
H.append("</ul></div>")
|
|
return "".join(H)
|
|
|
|
|
|
def tab_photos_html(groups_infos, etat=None):
|
|
"""contenu du tab "photos" """
|
|
from app.scodoc import sco_trombino
|
|
|
|
if not groups_infos.members:
|
|
return '<div class="tab-content"><h3>Aucun étudiant !</h3></div>'
|
|
|
|
return sco_trombino.trombino_html(groups_infos)
|
|
|
|
|
|
def form_choix_jour_saisie_hebdo(groups_infos, moduleimpl_id=None):
|
|
"""Formulaire choix jour semaine pour saisie."""
|
|
authuser = current_user
|
|
if not authuser.has_permission(Permission.AbsChange):
|
|
return ""
|
|
return f"""
|
|
<a class="stdlink" href="{
|
|
url_for(
|
|
"assiduites.signal_assiduites_group",
|
|
scodoc_dept=g.scodoc_dept,
|
|
group_ids=",".join(map(str,groups_infos.group_ids)),
|
|
day=datetime.date.today().isoformat(),
|
|
formsemestre_id=groups_infos.formsemestre_id,
|
|
moduleimpl_id="" if moduleimpl_id is None else moduleimpl_id
|
|
)
|
|
}">Saisie du jour ({datetime.date.today().strftime('%d/%m/%Y')})</a>
|
|
"""
|
|
|
|
|
|
# Saisie de l'assiduité par semaine
|
|
def form_choix_saisie_semaine(groups_infos):
|
|
authuser = current_user
|
|
if not authuser.has_permission(Permission.AbsChange):
|
|
return ""
|
|
query_args = parse_qs(request.query_string)
|
|
moduleimpl_id = query_args.get("moduleimpl_id", [None])[0]
|
|
semaine = datetime.datetime.now().strftime("%G-W%V")
|
|
return f"""
|
|
<a class="stdlink" href="{url_for(
|
|
"assiduites.signal_assiduites_hebdo",
|
|
group_ids=",".join(map(str,groups_infos.group_ids)),
|
|
week=semaine,
|
|
scodoc_dept=g.scodoc_dept,
|
|
formsemestre_id=groups_infos.formsemestre_id,
|
|
moduleimpl_id=moduleimpl_id
|
|
)}">Saisie à la semaine (semaine {''.join(semaine[-2:])})</a>
|
|
"""
|
|
|
|
|
|
def export_groups_as_moodle_csv(formsemestre_id=None):
|
|
"""Export all students/groups, in a CSV format suitable for Moodle
|
|
Each (student,group) will be listed on a separate line
|
|
jo@univ.fr,S3-A
|
|
jo@univ.fr,S3-B1
|
|
if jo belongs to group A in a partition, and B1 in another one.
|
|
Caution: if groups in different partitions share the same name, there will be
|
|
duplicates... should we prefix the group names with the partition's name ?
|
|
"""
|
|
if not formsemestre_id:
|
|
raise ScoValueError("missing parameter: formsemestre_id")
|
|
_, partitions_etud_groups = sco_groups.get_formsemestre_groups(
|
|
formsemestre_id, with_default=True
|
|
)
|
|
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
|
|
moodle_sem_name = sem["session_id"]
|
|
|
|
columns_ids = ("email", "semestre_groupe")
|
|
rows = []
|
|
for partition_id, members in partitions_etud_groups.items():
|
|
partition = sco_groups.get_partition(partition_id)
|
|
for etudid in members:
|
|
etud = sco_etud.get_etud_info(etudid=etudid, filled=True)[0]
|
|
group_name = members[etudid]["group_name"]
|
|
elts = [moodle_sem_name]
|
|
if partition["partition_name"]:
|
|
elts.append(partition["partition_name"])
|
|
if group_name:
|
|
elts.append(group_name)
|
|
rows.append({"email": etud["email"], "semestre_groupe": "-".join(elts)})
|
|
# Make table
|
|
prefs = sco_preferences.SemPreferences(formsemestre_id)
|
|
tab = GenTable(
|
|
columns_ids=("email", "semestre_groupe"),
|
|
filename=moodle_sem_name + "-moodle",
|
|
preferences=prefs,
|
|
rows=rows,
|
|
text_fields_separator=prefs["moodle_csv_separator"],
|
|
text_with_titles=prefs["moodle_csv_with_headerline"],
|
|
table_id="export_groups_as_moodle_csv",
|
|
titles={x: x for x in columns_ids},
|
|
)
|
|
return tab.make_page(fmt="csv")
|