ScoDoc-PE/app/scodoc/sco_moduleimpl_inscriptions.py

786 lines
29 KiB
Python
Raw Normal View History

2020-09-26 16:19:37 +02:00
# -*- mode: python -*-
# -*- coding: utf-8 -*-
##############################################################################
#
# Gestion scolarite IUT
#
2023-01-02 13:16:27 +01:00
# Copyright (c) 1999 - 2023 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@viennet.net
#
##############################################################################
"""Opérations d'inscriptions aux modules (interface pour gérer options ou parcours)
"""
2021-07-09 23:19:30 +02:00
from operator import itemgetter
2020-09-26 16:19:37 +02:00
2021-08-01 10:16:16 +02:00
import flask
from flask import url_for, g, request
from flask_login import current_user
2022-02-13 15:50:16 +01:00
from app.comp import res_sem
from app.comp.res_compat import NotesTableCompat
from app.models import FormSemestre, Identite, ScolarFormSemestreValidation, UniteEns
2022-02-13 15:50:16 +01:00
2021-08-29 19:57:32 +02:00
from app import log
from app.tables import list_etuds
from app.scodoc.scolog import logdb
from app.scodoc import html_sco_header
from app.scodoc import htmlutils
2023-01-23 11:05:06 +01:00
from app.scodoc import sco_cache
from app.scodoc import codes_cursus
from app.scodoc import sco_edit_module
from app.scodoc import sco_edit_ue
from app.scodoc import sco_etud
from app.scodoc import sco_formsemestre
from app.scodoc import sco_formsemestre_inscriptions
from app.scodoc import sco_groups
from app.scodoc import sco_moduleimpl
import app.scodoc.notesdb as ndb
from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc.sco_permissions import Permission
import app.scodoc.sco_utils as scu
2020-09-26 16:19:37 +02:00
def moduleimpl_inscriptions_edit(moduleimpl_id, etuds=[], submitted=False):
2020-09-26 16:19:37 +02:00
"""Formulaire inscription des etudiants a ce module
* Gestion des inscriptions
Nom TD TA TP (triable)
[x] M. XXX YYY - - -
2021-01-01 17:46:05 +01:00
2020-09-26 16:19:37 +02:00
ajouter TD A, TD B, TP 1, TP 2 ...
supprimer TD A, TD B, TP 1, TP 2 ...
2021-01-01 17:46:05 +01:00
2020-09-26 16:19:37 +02:00
* Si pas les droits: idem en readonly
"""
M = sco_moduleimpl.moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
2020-09-26 16:19:37 +02:00
formsemestre_id = M["formsemestre_id"]
2021-10-16 19:20:36 +02:00
mod = sco_edit_module.module_list(args={"module_id": M["module_id"]})[0]
2021-08-19 10:28:35 +02:00
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
2020-09-26 16:19:37 +02:00
# -- check lock
2021-08-10 12:57:38 +02:00
if not sem["etat"]:
2020-09-26 16:19:37 +02:00
raise ScoValueError("opération impossible: semestre verrouille")
2021-06-13 23:37:14 +02:00
header = html_sco_header.sco_header(
2020-09-26 16:19:37 +02:00
page_title="Inscription au module",
init_qtip=True,
javascripts=["js/etud_info.js"],
)
footer = html_sco_header.sco_footer()
2020-09-26 16:19:37 +02:00
H = [
header,
"""<h2>Inscriptions au module <a href="moduleimpl_status?moduleimpl_id=%s">%s</a> (%s)</a></h2>
<p class="help">Cette page permet d'éditer les étudiants inscrits à ce module
(ils doivent évidemment être inscrits au semestre).
Les étudiants cochés sont (ou seront) inscrits. Vous pouvez facilement inscrire ou
désinscrire tous les étudiants d'un groupe à l'aide des menus "Ajouter" et "Enlever".
</p>
<p class="help">Aucune modification n'est prise en compte tant que l'on n'appuie pas sur le bouton
"Appliquer les modifications".
</p>
"""
% (
moduleimpl_id,
mod["titre"] or "(module sans titre)",
mod["code"] or "(module sans code)",
),
2020-09-26 16:19:37 +02:00
]
# Liste des inscrits à ce semestre
2021-06-21 10:17:16 +02:00
inscrits = sco_formsemestre_inscriptions.do_formsemestre_inscription_listinscrits(
2021-08-19 10:28:35 +02:00
formsemestre_id
2021-06-21 10:17:16 +02:00
)
2020-09-26 16:19:37 +02:00
for ins in inscrits:
etuds_info = sco_etud.get_etud_info(etudid=ins["etudid"], filled=1)
2020-09-26 16:19:37 +02:00
if not etuds_info:
log(
f"""moduleimpl_inscriptions_edit: inconsistency for etudid={ins['etudid']} !"""
2020-09-26 16:19:37 +02:00
)
raise ScoValueError(
f"""Étudiant {ins['etudid']} inscrit mais inconnu dans la base !"""
2020-09-26 16:19:37 +02:00
)
ins["etud"] = etuds_info[0]
inscrits.sort(key=lambda inscr: sco_etud.etud_sort_key(inscr["etud"]))
in_m = sco_moduleimpl.do_moduleimpl_inscription_list(
2021-08-20 01:09:55 +02:00
moduleimpl_id=M["moduleimpl_id"]
)
2020-09-26 16:19:37 +02:00
in_module = set([x["etudid"] for x in in_m])
#
2021-08-19 10:28:35 +02:00
partitions = sco_groups.get_partitions_list(formsemestre_id)
2020-09-26 16:19:37 +02:00
#
if not submitted:
H.append(
"""<script type="text/javascript">
function group_select(groupName, partitionIdx, check) {
var nb_inputs_to_skip = 2; // nb d'input avant les checkbox !!!
var elems = document.getElementById("mi_form").getElementsByTagName("input");
if (partitionIdx==-1) {
for (var i =nb_inputs_to_skip; i < elems.length; i++) {
elems[i].checked=check;
}
} else {
for (var i =nb_inputs_to_skip; i < elems.length; i++) {
var cells = elems[i].parentNode.parentNode.getElementsByTagName("td")[partitionIdx].childNodes;
if (cells.length && cells[0].nodeValue == groupName) {
elems[i].checked=check;
}
}
}
}
</script>"""
)
H.append(
f"""<form method="post" id="mi_form" action="{request.base_url}">
<input type="hidden" name="moduleimpl_id" value="{M['moduleimpl_id']}"/>
<input type="submit" name="submitted" value="Appliquer les modifications"/>
<p></p>
<table><tr>
{ _make_menu(partitions, "Ajouter", "true") }
{ _make_menu(partitions, "Enlever", "false")}
</tr></table>
<p><br></p>
<table class="sortable" id="mi_table">
<tr>
<th>Nom</th>
"""
2020-09-26 16:19:37 +02:00
)
for partition in partitions:
if partition["partition_name"]:
H.append("<th>%s</th>" % partition["partition_name"])
H.append("</tr>")
for ins in inscrits:
etud = ins["etud"]
if etud["etudid"] in in_module:
checked = 'checked="checked"'
else:
checked = ""
H.append(
"""<tr><td><input type="checkbox" name="etuds:list" value="%s" %s>"""
% (etud["etudid"], checked)
)
H.append(
"""<a class="discretelink etudinfo" href="%s" id="%s">%s</a>"""
% (
url_for(
"scolar.ficheEtud",
scodoc_dept=g.scodoc_dept,
etudid=etud["etudid"],
),
etud["etudid"],
etud["nomprenom"],
)
2020-09-26 16:19:37 +02:00
)
H.append("""</input></td>""")
groups = sco_groups.get_etud_groups(etud["etudid"], formsemestre_id)
2020-09-26 16:19:37 +02:00
for partition in partitions:
if partition["partition_name"]:
gr_name = ""
for group in groups:
if group["partition_id"] == partition["partition_id"]:
gr_name = group["group_name"]
break
# gr_name == '' si etud non inscrit dans un groupe de cette partition
H.append(f"<td>{gr_name}</td>")
2020-09-26 16:19:37 +02:00
H.append("""</table></form>""")
else: # SUBMISSION
# inscrit a ce module tous les etuds selectionnes
sco_moduleimpl.do_moduleimpl_inscrit_etuds(
moduleimpl_id, formsemestre_id, etuds, reset=True
2020-09-26 16:19:37 +02:00
)
return flask.redirect(
url_for(
"notes.moduleimpl_status",
scodoc_dept=g.scodoc_dept,
moduleimpl_id=moduleimpl_id,
)
)
2020-09-26 16:19:37 +02:00
#
H.append(footer)
return "\n".join(H)
def _make_menu(partitions: list[dict], title="", check="true") -> str:
2020-09-26 16:19:37 +02:00
"""Menu with list of all groups"""
2021-01-01 17:46:05 +01:00
items = [{"title": "Tous", "attr": "onclick=\"group_select('', -1, %s)\"" % check}]
2020-09-26 16:19:37 +02:00
p_idx = 0
for partition in partitions:
if partition["partition_name"] != None:
p_idx += 1
2021-08-19 10:28:35 +02:00
for group in sco_groups.get_partition_groups(partition):
2020-09-26 16:19:37 +02:00
items.append(
{
2021-01-01 17:46:05 +01:00
"title": "%s %s"
% (partition["partition_name"], group["group_name"]),
"attr": "onclick=\"group_select('%s', %s, %s)\""
% (group["group_name"], p_idx, check),
2020-09-26 16:19:37 +02:00
}
)
2021-01-01 17:46:05 +01:00
return (
'<td class="inscr_addremove_menu">'
2021-06-14 18:08:52 +02:00
+ htmlutils.make_menu(title, items, alone=True)
2021-01-01 17:46:05 +01:00
+ "</td>"
)
2020-09-26 16:19:37 +02:00
def moduleimpl_inscriptions_stats(formsemestre_id):
2020-09-26 16:19:37 +02:00
"""Affiche quelques informations sur les inscriptions
aux modules de ce semestre.
Inscrits au semestre: <nb>
Modules communs (tous inscrits): <liste des modules (codes)
Autres modules: (regroupés par UE)
UE 1
<code du module>: <nb inscrits> (<description en termes de groupes>)
...
En APC, n'affiche pas la colonne UE, car le rattachement n'a pas
d'importance pédagogique.
2020-09-26 16:19:37 +02:00
descriptions:
groupes de TD A, B et C
tous sauf groupe de TP Z (?)
tous sauf <liste d'au plus 7 noms>
2021-01-01 17:46:05 +01:00
2020-09-26 16:19:37 +02:00
"""
authuser = current_user
formsemestre = FormSemestre.query.get_or_404(formsemestre_id)
res: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
is_apc = formsemestre.formation.is_apc()
inscrits = sco_formsemestre_inscriptions.do_formsemestre_inscription_list(
2021-08-19 10:28:35 +02:00
args={"formsemestre_id": formsemestre_id}
2020-09-26 16:19:37 +02:00
)
set_all = set([x["etudid"] for x in inscrits])
partitions, _ = sco_groups.get_formsemestre_groups(formsemestre_id)
2020-09-26 16:19:37 +02:00
can_change = (
authuser.has_permission(Permission.ScoEtudInscrit) and formsemestre.etat
2021-12-12 12:32:21 +01:00
)
# Décrit les inscriptions aux modules:
2020-09-26 16:19:37 +02:00
commons = [] # modules communs a tous les etuds du semestre
options = [] # modules ou seuls quelques etudiants sont inscrits
mod_description = {} # modimplid : str
mod_nb_inscrits = {} # modimplid : int
if is_apc:
modimpls = sorted(formsemestre.modimpls, key=lambda m: m.module.sort_key_apc())
else:
modimpls = formsemestre.modimpls_sorted
for modimpl in modimpls:
2021-01-01 17:46:05 +01:00
tous_inscrits, nb_inscrits, descr = descr_inscrs_module(
modimpl.id,
2020-09-26 16:19:37 +02:00
set_all,
partitions,
)
2021-01-01 17:46:05 +01:00
if tous_inscrits:
commons.append(modimpl)
2020-09-26 16:19:37 +02:00
else:
mod_description[modimpl.id] = descr
mod_nb_inscrits[modimpl.id] = nb_inscrits
options.append(modimpl)
2020-09-26 16:19:37 +02:00
# Page HTML:
H = [
html_sco_header.html_sem_header(
"Inscriptions aux modules et UE du semestre",
javascripts=["js/etud_info.js", "js/moduleimpl_inscriptions_stats.js"],
init_qtip=True,
)
]
2020-09-26 16:19:37 +02:00
H.append(f"<h3>Inscrits au semestre: {len(inscrits)} étudiants</h3>")
2020-09-26 16:19:37 +02:00
if options:
H.append("<h3>Modules auxquels tous les étudiants ne sont pas inscrits:</h3>")
H.append(
f"""<table class="formsemestre_status formsemestre_inscr">
<tr>
{'<th>UE</th>' if not is_apc else ""}
<th>Code</th>
<th>Inscrits</th>
<th></th>
</tr>
"""
2020-09-26 16:19:37 +02:00
)
for modimpl in options:
2020-09-26 16:19:37 +02:00
if can_change:
c_link = f"""<a class="discretelink" href="{url_for(
'notes.moduleimpl_inscriptions_edit',
scodoc_dept=g.scodoc_dept,
moduleimpl_id=modimpl.id)
}">{mod_description[modimpl.id] or "<i>(inscrire des étudiants)</i>"}</a>
"""
2020-09-26 16:19:37 +02:00
else:
c_link = mod_description[modimpl.id]
H.append("""<tr class="formsemestre_status">""")
if not is_apc:
H.append(
f"""
<td>{
modimpl.module.ue.acronyme or ""
}</td>
"""
)
2020-09-26 16:19:37 +02:00
H.append(
f"""
<td class="formsemestre_status_code">{
modimpl.module.code or "(module sans code)"
}</td>
<td class="formsemestre_status_inscrits">{
mod_nb_inscrits[modimpl.id]}</td><td>{c_link}</td>
</tr>
"""
2020-09-26 16:19:37 +02:00
)
H.append("</table>")
else:
H.append(
"""<span style="font-size:110%; font-style:italic; color: red;"
>Tous les étudiants sont inscrits à tous les modules.</span>"""
2020-09-26 16:19:37 +02:00
)
if commons:
H.append(
f"""<h3>Modules communs (auxquels tous les étudiants sont inscrits):</h3>
<table class="formsemestre_status formsemestre_inscr">
<tr>
{'<th>UE</th>' if not is_apc else ""}
<th>Code</th>
<th>Module</th>"""
2020-09-26 16:19:37 +02:00
)
if is_apc:
H.append("<th>Parcours</th>")
H.append("""</tr>""")
for modimpl in commons:
2020-09-26 16:19:37 +02:00
if can_change:
c_link = f"""<a class="discretelink" href="{
url_for("notes.moduleimpl_inscriptions_edit",
scodoc_dept=g.scodoc_dept, moduleimpl_id=modimpl.id)
}">{modimpl.module.titre}</a>"""
2020-09-26 16:19:37 +02:00
else:
c_link = modimpl.module.titre
H.append("""<tr class="formsemestre_status_green">""")
if not is_apc:
H.append(
f"""
<td>{modimpl.module.ue.acronyme or ""}</td>
"""
)
2020-09-26 16:19:37 +02:00
H.append(
f"""
<td class="formsemestre_status_code">{
modimpl.module.code or "(module sans code)"
}</td><td>{c_link}</td>"""
2020-09-26 16:19:37 +02:00
)
if is_apc:
H.append(
f"""<td><em>{', '.join(p.code for p in modimpl.module.parcours)}</em></td>"""
)
H.append("</tr>")
2020-09-26 16:19:37 +02:00
H.append("</table>")
# Etudiants "dispensés" d'une UE (capitalisée)
ues_cap_info = get_etuds_with_capitalized_ue(formsemestre_id)
if ues_cap_info:
H.append(
'<h3>Étudiants avec UEs capitalisées (ADM):</h3><ul class="ue_inscr_list">'
)
ues = [
sco_edit_ue.ue_list({"ue_id": ue_id})[0] for ue_id in ues_cap_info.keys()
]
2020-09-26 16:19:37 +02:00
ues.sort(key=lambda u: u["numero"])
for ue in ues:
H.append(
f"""<li class="tit"><span class="tit">{ue['acronyme']}: {ue['titre']}</span>"""
2020-09-26 16:19:37 +02:00
)
H.append("<ul>")
for info in ues_cap_info[ue["ue_id"]]:
etud = sco_etud.get_etud_info(etudid=info["etudid"], filled=True)[0]
2020-09-26 16:19:37 +02:00
H.append(
f"""<li class="etud"><a class="discretelink" href="{
url_for(
"scolar.ficheEtud",
scodoc_dept=g.scodoc_dept,
etudid=etud["etudid"],
)
}">{etud["nomprenom"]}</a>"""
2020-09-26 16:19:37 +02:00
)
if info["ue_status"]["event_date"]:
H.append(
f"""(cap. le {info["ue_status"]["event_date"].strftime("%d/%m/%Y")})"""
2020-09-26 16:19:37 +02:00
)
if is_apc:
is_inscrit_ue = (etud["etudid"], ue["id"]) not in res.dispense_ues
else:
# CLASSIQUE
is_inscrit_ue = info["is_ins"]
if is_inscrit_ue:
dm = ", ".join(
[
m["code"] or m["abbrev"] or "pas_de_code"
for m in info["is_ins"]
]
)
H.append(
f"""actuellement inscrit dans <a title="{dm}" class="discretelink"
>{len(info["is_ins"])} modules</a>"""
)
if is_inscrit_ue:
2020-09-26 16:19:37 +02:00
if info["ue_status"]["is_capitalized"]:
H.append(
"""<div><em style="font-size: 70%">UE actuelle moins bonne que
l'UE capitalisée</em>
</div>"""
2020-09-26 16:19:37 +02:00
)
else:
H.append(
"""<div><em style="font-size: 70%">UE actuelle meilleure que
l'UE capitalisée</em>
</div>"""
2020-09-26 16:19:37 +02:00
)
if can_change:
H.append(
f"""<div><a class="stdlink" href="{
url_for("notes.etud_desinscrit_ue",
scodoc_dept=g.scodoc_dept, etudid=etud["etudid"],
formsemestre_id=formsemestre_id, ue_id=ue["ue_id"])
}">désinscrire {"des modules" if not is_apc else ""} de cette UE</a></div>
"""
2020-09-26 16:19:37 +02:00
)
else:
H.append("(non réinscrit dans cette UE)")
if can_change:
H.append(
f"""<div><a class="stdlink" href="{
url_for("notes.etud_inscrit_ue",
scodoc_dept=g.scodoc_dept, etudid=etud["etudid"],
formsemestre_id=formsemestre_id, ue_id=ue["ue_id"])
}">inscrire à {"" if is_apc else "tous les modules de"} cette UE</a></div>
"""
2020-09-26 16:19:37 +02:00
)
H.append("</li>")
H.append("</ul></li>")
H.append("</ul>")
# BUT: propose dispense de toutes UEs
if is_apc:
H.append(_list_but_ue_inscriptions(res, read_only=not can_change))
2020-09-26 16:19:37 +02:00
2022-02-13 14:11:15 +01:00
H.append(
"""<hr/><p class="help">Cette page décrit les inscriptions actuelles.
Vous pouvez changer (si vous en avez le droit) les inscrits dans chaque module en
2022-02-13 14:11:15 +01:00
cliquant sur la ligne du module.</p>
<p class="help">Note: la déinscription d'un module ne perd pas les notes. Ainsi, si
2022-02-13 14:11:15 +01:00
l'étudiant est ensuite réinscrit au même module, il retrouvera ses notes.</p>
"""
)
2020-09-26 16:19:37 +02:00
H.append(html_sco_header.sco_footer())
2020-09-26 16:19:37 +02:00
return "\n".join(H)
def _list_but_ue_inscriptions(res: NotesTableCompat, read_only: bool = True) -> str:
"""HTML pour dispenser/reinscrire chaque étudiant à chaque UE du BUT"""
H = [
"""
<div class="list_but_ue_inscriptions">
<h3>Inscriptions/déinscription aux UEs du BUT</h3>
<form class="list_but_ue_inscriptions">
"""
]
table_inscr = _table_but_ue_inscriptions(res)
ue_ids = (
set.union(*(set(x.keys()) for x in table_inscr.values()))
if table_inscr
else set()
)
ues = sorted(
(UniteEns.query.get(ue_id) for ue_id in ue_ids),
key=lambda u: (u.numero or 0, u.acronyme),
)
H.append("""<table><tr><th></th>""")
for ue in ues:
H.append(f"""<th title="{ue.titre or ''}">{ue.acronyme}</th>""")
H.append("""</tr>""")
etuds = list_etuds.etuds_sorted_from_ids(table_inscr.keys())
for etud in etuds:
ues_etud = table_inscr[etud.id]
H.append(
f"""<tr><td><a class="discretelink etudinfo" id={etud.id}
href="{url_for(
"scolar.ficheEtud",
scodoc_dept=g.scodoc_dept,
etudid=etud.id,
)}"
>{etud.nomprenom}</a></td>"""
)
for ue in ues:
td_class = ""
est_inscr = ues_etud.get(ue.id) # None si pas concerné
if est_inscr is None:
content = ""
else:
# Validations d'UE déjà enregistrées dans d'autres semestres
validations_ue = (
ScolarFormSemestreValidation.query.filter_by(etudid=etud.id)
.filter(
ScolarFormSemestreValidation.formsemestre_id
!= res.formsemestre.id,
ScolarFormSemestreValidation.code.in_(
codes_cursus.CODES_UE_VALIDES
),
)
.join(UniteEns)
.filter_by(ue_code=ue.ue_code)
.all()
)
validations_ue.sort(
key=lambda v: codes_cursus.BUT_CODES_ORDERED.get(v.code, 0)
)
validation = validations_ue[-1] if validations_ue else None
expl_validation = (
f"""Validée ({validation.code}) le {
validation.event_date.strftime("%d/%m/%Y")}"""
if validation
else ""
)
td_class = ' class="ue_validee"' if validation else ""
content = f"""<input type="checkbox"
{'checked' if est_inscr else ''}
{'disabled' if read_only else ''}
title="{etud.nomprenom} {'inscrit' if est_inscr else 'non inscrit'} à l'UE {ue.acronyme}. {expl_validation}",
onchange="change_ue_inscr(this);"
data-url_inscr={
url_for("notes.etud_inscrit_ue",
scodoc_dept=g.scodoc_dept, etudid=etud.id,
formsemestre_id=res.formsemestre.id, ue_id=ue.id)
}
data-url_desinscr={
url_for("notes.etud_desinscrit_ue",
scodoc_dept=g.scodoc_dept, etudid=etud.id,
formsemestre_id=res.formsemestre.id, ue_id=ue.id)
}
/>
"""
H.append(f"""<td{td_class}>{content}</td>""")
H.append(
"""</table>
</form>
<div class="help">
L'inscription ou désinscription aux UEs du BUT n'affecte pas les inscriptions aux modules
mais permet de "dispenser" un étudiant de suivre certaines UEs de son parcours.
Il peut s'agit d'étudiants redoublants ayant déjà acquis l'UE, ou d'autres cas particuliers.
La dispense d'UE est réversible à tout moment (avant le jury de fin de semestre)
et n'affecte pas les notes saisies.
</div>
</div>
"""
)
return "\n".join(H)
def _table_but_ue_inscriptions(res: NotesTableCompat) -> dict[int, dict]:
""" "table" avec les inscriptions aux UEs de chaque étudiant
{
etudid : { ue_id : True | False }
}
"""
return {
etudid: {
ue_id: (etudid, ue_id) not in res.dispense_ues
for ue_id in res.etud_ues_ids(etudid)
}
for etudid, inscr in res.formsemestre.etuds_inscriptions.items()
if inscr.etat == scu.INSCRIT
}
def descr_inscrs_module(moduleimpl_id, set_all, partitions):
2021-01-01 17:46:05 +01:00
"""returns tous_inscrits, nb_inscrits, descr"""
2021-08-20 01:09:55 +02:00
ins = sco_moduleimpl.do_moduleimpl_inscription_list(moduleimpl_id=moduleimpl_id)
2020-09-26 16:19:37 +02:00
set_m = set([x["etudid"] for x in ins]) # ens. des inscrits au module
non_inscrits = set_all - set_m
if len(non_inscrits) == 0:
return True, len(ins), "" # tous inscrits
if len(non_inscrits) <= 7: # seuil arbitraire
return False, len(ins), "tous sauf " + _fmt_etud_set(non_inscrits)
2020-09-26 16:19:37 +02:00
# Cherche les groupes:
gr = [] # [ ( partition_name , [ group_names ] ) ]
for partition in partitions:
grp = [] # groupe de cette partition
2021-08-19 10:28:35 +02:00
for group in sco_groups.get_partition_groups(partition):
members = sco_groups.get_group_members(group["group_id"])
2020-09-26 16:19:37 +02:00
set_g = set([m["etudid"] for m in members])
if set_g.issubset(set_m):
grp.append(group["group_name"])
set_m = set_m - set_g
gr.append((partition["partition_name"], grp))
#
d = []
for (partition_name, grp) in gr:
if grp:
d.append("groupes de %s: %s" % (partition_name, ", ".join(grp)))
r = []
if d:
r.append(", ".join(d))
if set_m:
r.append(_fmt_etud_set(set_m))
2020-09-26 16:19:37 +02:00
#
return False, len(ins), " et ".join(r)
def _fmt_etud_set(ins, max_list_size=7):
2020-09-26 16:19:37 +02:00
# max_list_size est le nombre max de noms d'etudiants listés
# au delà, on indique juste le nombre, sans les noms.
if len(ins) > max_list_size:
return "%d étudiants" % len(ins)
etuds = []
for etudid in ins:
etuds.append(sco_etud.get_etud_info(etudid=etudid, filled=True)[0])
2021-07-10 13:58:25 +02:00
etuds.sort(key=itemgetter("nom"))
2020-09-26 16:19:37 +02:00
return ", ".join(
[
'<a class="discretelink" href="%s">%s</a>'
% (
url_for(
"scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etud["etudid"]
),
etud["nomprenom"],
)
2020-09-26 16:19:37 +02:00
for etud in etuds
]
)
def get_etuds_with_capitalized_ue(formsemestre_id: int) -> list[dict]:
2020-09-26 16:19:37 +02:00
"""For each UE, computes list of students capitalizing the UE.
returns { ue_id : [ { infos } ] }
"""
ues_cap_info = scu.DictDefault(defaultvalue=[])
2022-02-13 15:50:16 +01:00
formsemestre = FormSemestre.query.get_or_404(formsemestre_id)
nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
inscrits = sco_formsemestre_inscriptions.do_formsemestre_inscription_list(
2021-08-19 10:28:35 +02:00
args={"formsemestre_id": formsemestre_id}
2020-09-26 16:19:37 +02:00
)
2021-12-24 00:08:25 +01:00
ues = nt.get_ues_stat_dict()
2020-09-26 16:19:37 +02:00
for ue in ues:
for etud in inscrits:
2022-02-12 22:57:46 +01:00
ue_status = nt.get_etud_ue_status(etud["etudid"], ue["ue_id"])
if ue_status and ue_status["was_capitalized"]:
ues_cap_info[ue["ue_id"]].append(
2020-09-26 16:19:37 +02:00
{
"etudid": etud["etudid"],
2022-02-12 22:57:46 +01:00
"ue_status": ue_status,
"is_ins": etud_modules_ue_inscr(
etud["etudid"], formsemestre_id, ue["ue_id"]
2020-09-26 16:19:37 +02:00
),
}
)
return ues_cap_info
2020-09-26 16:19:37 +02:00
def etud_modules_ue_inscr(etudid, formsemestre_id, ue_id) -> list[int]:
2020-09-26 16:19:37 +02:00
"""Modules de cette UE dans ce semestre
auxquels l'étudiant est inscrit.
Utile pour formations classiques seulement.
2020-09-26 16:19:37 +02:00
"""
2021-02-03 22:00:41 +01:00
r = ndb.SimpleDictFetch(
"""SELECT mod.id AS module_id, mod.*
2020-09-26 16:19:37 +02:00
FROM notes_moduleimpl mi, notes_modules mod,
notes_formsemestre sem, notes_moduleimpl_inscription i
WHERE sem.id = %(formsemestre_id)s
AND mi.formsemestre_id = sem.id
AND mod.id = mi.module_id
2020-09-26 16:19:37 +02:00
AND mod.ue_id = %(ue_id)s
AND i.moduleimpl_id = mi.id
2020-09-26 16:19:37 +02:00
AND i.etudid = %(etudid)s
ORDER BY mod.numero
""",
{"etudid": etudid, "formsemestre_id": formsemestre_id, "ue_id": ue_id},
)
return r
def do_etud_desinscrit_ue_classic(etudid, formsemestre_id, ue_id):
"""Désinscrit l'etudiant de tous les modules de cette UE dans ce semestre.
N'utiliser que pour les formations classiques, pas APC.
"""
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
cursor.execute(
2021-09-13 22:10:01 +02:00
"""DELETE FROM notes_moduleimpl_inscription
WHERE id IN (
SELECT i.id FROM
2021-09-13 22:10:01 +02:00
notes_moduleimpl mi, notes_modules mod,
2020-09-26 16:19:37 +02:00
notes_formsemestre sem, notes_moduleimpl_inscription i
WHERE sem.id = %(formsemestre_id)s
AND mi.formsemestre_id = sem.id
AND mod.id = mi.module_id
2020-09-26 16:19:37 +02:00
AND mod.ue_id = %(ue_id)s
AND i.moduleimpl_id = mi.id
2020-09-26 16:19:37 +02:00
AND i.etudid = %(etudid)s
)
""",
{"etudid": etudid, "formsemestre_id": formsemestre_id, "ue_id": ue_id},
)
logdb(
cnx,
method="etud_desinscrit_ue",
etudid=etudid,
msg=f"desinscription UE {ue_id}",
commit=False,
)
2021-07-19 19:53:01 +02:00
sco_cache.invalidate_formsemestre(
formsemestre_id=formsemestre_id
2020-09-26 16:19:37 +02:00
) # > desinscription etudiant des modules
def do_etud_inscrit_ue(etudid, formsemestre_id, ue_id):
2021-01-01 17:46:05 +01:00
"""Incrit l'etudiant de tous les modules de cette UE dans ce semestre."""
2020-09-26 16:19:37 +02:00
# Verifie qu'il est bien inscrit au semestre
insem = sco_formsemestre_inscriptions.do_formsemestre_inscription_list(
2021-08-19 10:28:35 +02:00
args={"formsemestre_id": formsemestre_id, "etudid": etudid}
2020-09-26 16:19:37 +02:00
)
if not insem:
raise ScoValueError("%s n'est pas inscrit au semestre !" % etudid)
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
cursor.execute(
2022-01-27 11:53:16 +01:00
"""SELECT mi.id
2020-09-26 16:19:37 +02:00
FROM notes_moduleimpl mi, notes_modules mod, notes_formsemestre sem
2022-01-27 11:53:16 +01:00
WHERE sem.id = %(formsemestre_id)s
AND mi.formsemestre_id = sem.id
AND mod.id = mi.module_id
2020-09-26 16:19:37 +02:00
AND mod.ue_id = %(ue_id)s
""",
{"formsemestre_id": formsemestre_id, "ue_id": ue_id},
)
res = cursor.dictfetchall()
2022-01-27 11:53:16 +01:00
for moduleimpl_id in [x["id"] for x in res]:
sco_moduleimpl.do_moduleimpl_inscription_create(
2020-09-26 16:19:37 +02:00
{"moduleimpl_id": moduleimpl_id, "etudid": etudid},
formsemestre_id=formsemestre_id,
)