forked from ScoDoc/ScoDoc
Merge branch 'master' of https://scodoc.org/git/viennet/ScoDoc into dev93
This commit is contained in:
commit
539041fd0d
@ -5,73 +5,62 @@ from flask import jsonify
|
||||
from app.api import bp
|
||||
from app.api.errors import error_response
|
||||
from app.api.auth import token_auth, token_permission_required
|
||||
from app.api.tools import get_etud_from_etudid_or_nip_or_ine
|
||||
from app.scodoc import notesdb as ndb
|
||||
from app.models import Identite
|
||||
|
||||
from app.scodoc import notesdb as ndb
|
||||
from app.scodoc import sco_abs
|
||||
from app.scodoc.sco_groups import get_group_members
|
||||
from app.scodoc.sco_permissions import Permission
|
||||
|
||||
|
||||
@bp.route("/absences/etudid/<int:etudid>", methods=["GET"])
|
||||
@bp.route("/absences/nip/<string:nip>", methods=["GET"])
|
||||
@bp.route("/absences/ine/<string:ine>", methods=["GET"])
|
||||
@token_auth.login_required
|
||||
@token_permission_required(Permission.APIView)
|
||||
def absences(etudid: int = None, nip: int = None, ine: int = None):
|
||||
def absences(etudid: int = None):
|
||||
"""
|
||||
Retourne la liste des absences d'un étudiant donné
|
||||
|
||||
etudid : l'etudid d'un étudiant
|
||||
nip: le code nip d'un étudiant
|
||||
ine : le code ine d'un étudiant
|
||||
|
||||
Exemple de résultat:
|
||||
[
|
||||
{
|
||||
"jour": "2022-04-15",
|
||||
"matin": true,
|
||||
"estabs": true,
|
||||
"estjust": true,
|
||||
"description": "",
|
||||
"begin": "2022-04-15 08:00:00",
|
||||
"end": "2022-04-15 11:59:59"
|
||||
},
|
||||
{
|
||||
"jour": "2022-04-15",
|
||||
"matin": false,
|
||||
"estabs": true,
|
||||
"estjust": false,
|
||||
"description": "",
|
||||
"begin": "2022-04-15 12:00:00",
|
||||
"end": "2022-04-15 17:59:59"
|
||||
}
|
||||
]
|
||||
[
|
||||
{
|
||||
"jour": "2022-04-15",
|
||||
"matin": true,
|
||||
"estabs": true,
|
||||
"estjust": true,
|
||||
"description": "",
|
||||
"begin": "2022-04-15 08:00:00",
|
||||
"end": "2022-04-15 11:59:59"
|
||||
},
|
||||
{
|
||||
"jour": "2022-04-15",
|
||||
"matin": false,
|
||||
"estabs": true,
|
||||
"estjust": false,
|
||||
"description": "",
|
||||
"begin": "2022-04-15 12:00:00",
|
||||
"end": "2022-04-15 17:59:59"
|
||||
}
|
||||
]
|
||||
"""
|
||||
if etudid is None:
|
||||
# Récupération de l'étudiant
|
||||
etud = get_etud_from_etudid_or_nip_or_ine(etudid, nip, ine)
|
||||
if etud is None:
|
||||
return error_response(
|
||||
404,
|
||||
message="id de l'étudiant (etudid, nip, ine) inconnu",
|
||||
)
|
||||
etudid = etud.etudid
|
||||
|
||||
# Récupération des absences de l'étudiant
|
||||
etud = Identite.query.get(etudid)
|
||||
if etud is None:
|
||||
return error_response(
|
||||
404,
|
||||
message="id de l'étudiant (etudid, nip, ine) inconnu",
|
||||
)
|
||||
# Absences de l'étudiant
|
||||
ndb.open_db_connection()
|
||||
absences = sco_abs.list_abs_date(etudid)
|
||||
absences = sco_abs.list_abs_date(etud.id)
|
||||
for absence in absences:
|
||||
absence["jour"] = absence["jour"].isoformat()
|
||||
return jsonify(absences)
|
||||
|
||||
|
||||
@bp.route("/absences/etudid/<int:etudid>/just", methods=["GET"])
|
||||
@bp.route("/absences/nip/<int:nip>/just", methods=["GET"])
|
||||
@bp.route("/absences/ine/<int:ine>/just", methods=["GET"])
|
||||
@token_auth.login_required
|
||||
@token_permission_required(Permission.APIView)
|
||||
def absences_just(etudid: int = None, nip: int = None, ine: int = None):
|
||||
def absences_just(etudid: int = None):
|
||||
"""
|
||||
Retourne la liste des absences justifiées d'un étudiant donné
|
||||
|
||||
@ -80,39 +69,37 @@ def absences_just(etudid: int = None, nip: int = None, ine: int = None):
|
||||
ine : le code ine d'un étudiant
|
||||
|
||||
Exemple de résultat :
|
||||
[
|
||||
{
|
||||
"jour": "2022-04-15",
|
||||
"matin": true,
|
||||
"estabs": true,
|
||||
"estjust": true,
|
||||
"description": "",
|
||||
"begin": "2022-04-15 08:00:00",
|
||||
"end": "2022-04-15 11:59:59"
|
||||
},
|
||||
{
|
||||
"jour": "Fri, 15 Apr 2022 00:00:00 GMT",
|
||||
"matin": false,
|
||||
"estabs": true,
|
||||
"estjust": true,
|
||||
"description": "",
|
||||
"begin": "2022-04-15 12:00:00",
|
||||
"end": "2022-04-15 17:59:59"
|
||||
}
|
||||
]
|
||||
[
|
||||
{
|
||||
"jour": "2022-04-15",
|
||||
"matin": true,
|
||||
"estabs": true,
|
||||
"estjust": true,
|
||||
"description": "",
|
||||
"begin": "2022-04-15 08:00:00",
|
||||
"end": "2022-04-15 11:59:59"
|
||||
},
|
||||
{
|
||||
"jour": "Fri, 15 Apr 2022 00:00:00 GMT",
|
||||
"matin": false,
|
||||
"estabs": true,
|
||||
"estjust": true,
|
||||
"description": "",
|
||||
"begin": "2022-04-15 12:00:00",
|
||||
"end": "2022-04-15 17:59:59"
|
||||
}
|
||||
]
|
||||
"""
|
||||
if etudid is None:
|
||||
etud = get_etud_from_etudid_or_nip_or_ine(etudid, nip, ine)
|
||||
if etud is None:
|
||||
return error_response(
|
||||
404,
|
||||
message="id de l'étudiant (etudid, nip, ine) inconnu",
|
||||
)
|
||||
etudid = etud.etudid
|
||||
etud = Identite.query.get(etudid)
|
||||
if etud is None:
|
||||
return error_response(
|
||||
404,
|
||||
message="id de l'étudiant (etudid, nip, ine) inconnu",
|
||||
)
|
||||
|
||||
# Récupération des absences justifiées de l'étudiant
|
||||
# Absences justifiées de l'étudiant
|
||||
abs_just = [
|
||||
absence for absence in sco_abs.list_abs_date(etudid) if absence["estjust"]
|
||||
absence for absence in sco_abs.list_abs_date(etud.id) if absence["estjust"]
|
||||
]
|
||||
for absence in abs_just:
|
||||
absence["jour"] = absence["jour"].isoformat()
|
||||
|
@ -1,14 +1,20 @@
|
||||
#################################################### Etudiants ########################################################
|
||||
##############################################################################
|
||||
# ScoDoc
|
||||
# Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved.
|
||||
# See LICENSE
|
||||
##############################################################################
|
||||
|
||||
"""
|
||||
API : accès aux étudiants
|
||||
"""
|
||||
|
||||
from flask import jsonify
|
||||
|
||||
import app
|
||||
from app import models
|
||||
from app.api import bp
|
||||
from app.api.errors import error_response
|
||||
from app.api.auth import token_auth, token_permission_required
|
||||
from app.api.tools import get_etud_from_etudid_or_nip_or_ine
|
||||
from app.models import FormSemestreInscription, FormSemestre, Identite
|
||||
from app.models import Departement, FormSemestreInscription, FormSemestre, Identite
|
||||
from app.scodoc import sco_bulletins
|
||||
from app.scodoc import sco_groups
|
||||
from app.scodoc.sco_permissions import Permission
|
||||
@ -59,53 +65,102 @@ def etudiants_courant(long=False):
|
||||
@bp.route("/etudiant/ine/<string:ine>", methods=["GET"])
|
||||
@token_auth.login_required
|
||||
@token_permission_required(Permission.APIView)
|
||||
def etudiant(etudid: int = None, nip: int = None, ine: int = None):
|
||||
def etudiant(etudid: int = None, nip: str = None, ine: str = None):
|
||||
"""
|
||||
Retourne les informations de l'étudiant correspondant à l'id passé en paramètres.
|
||||
Retourne les informations de l'étudiant correspondant, ou 404 si non trouvé.
|
||||
|
||||
etudid : l'etudid d'un étudiant
|
||||
nip : le code nip d'un étudiant
|
||||
ine : le code ine d'un étudiant
|
||||
etudid : l'etudid de l'étudiant
|
||||
nip : le code nip de l'étudiant
|
||||
ine : le code ine de l'étudiant
|
||||
|
||||
Les codes INE et NIP sont uniques au sein d'un département.
|
||||
Si plusieurs objets ont le même code, on ramène le plus récemment inscrit.
|
||||
|
||||
Exemple de résultat :
|
||||
{
|
||||
"civilite": "X",
|
||||
"code_ine": "1",
|
||||
"code_nip": "1",
|
||||
"date_naissance": "",
|
||||
"email": "SACHA.COSTA@example.com",
|
||||
"emailperso": "",
|
||||
"etudid": 1,
|
||||
"nom": "COSTA",
|
||||
"prenom": "SACHA",
|
||||
"nomprenom": "Sacha COSTA",
|
||||
"lieu_naissance": "",
|
||||
"dept_naissance": "",
|
||||
"nationalite": "",
|
||||
"boursier": "",
|
||||
"id": 1,
|
||||
"codepostaldomicile": "",
|
||||
"paysdomicile": "",
|
||||
"telephonemobile": "",
|
||||
"typeadresse": "domicile",
|
||||
"domicile": "",
|
||||
"villedomicile": "",
|
||||
"telephone": "",
|
||||
"fax": "",
|
||||
"description": ""
|
||||
}
|
||||
{
|
||||
"civilite": "X",
|
||||
"code_ine": "1",
|
||||
"code_nip": "1",
|
||||
"date_naissance": "",
|
||||
"email": "SACHA.COSTA@example.com",
|
||||
"emailperso": "",
|
||||
"etudid": 1,
|
||||
"nom": "COSTA",
|
||||
"prenom": "SACHA",
|
||||
"nomprenom": "Sacha COSTA",
|
||||
"lieu_naissance": "",
|
||||
"dept_naissance": "",
|
||||
"nationalite": "",
|
||||
"boursier": "",
|
||||
"id": 1,
|
||||
"codepostaldomicile": "",
|
||||
"paysdomicile": "",
|
||||
"telephonemobile": "",
|
||||
"typeadresse": "domicile",
|
||||
"domicile": "",
|
||||
"villedomicile": "",
|
||||
"telephone": "",
|
||||
"fax": "",
|
||||
"description": ""
|
||||
}
|
||||
"""
|
||||
# Récupération de l'étudiant
|
||||
etud = get_etud_from_etudid_or_nip_or_ine(etudid, nip, ine)
|
||||
if etudid is not None:
|
||||
etud = Identite.query.get(etudid)
|
||||
else:
|
||||
if nip is not None:
|
||||
query = Identite.query.filter_by(code_nip=nip)
|
||||
elif ine is not None:
|
||||
query = Identite.query.filter_by(code_ine=ine)
|
||||
else:
|
||||
return error_response(
|
||||
404,
|
||||
message="parametre manquant",
|
||||
)
|
||||
if query.count() > 1: # cas rare d'un étudiant présent dans plusieurs depts
|
||||
etuds = []
|
||||
for e in query:
|
||||
admission = e.admission.first()
|
||||
etuds.append((((admission.annee or 0) if admission else 0), e))
|
||||
etuds.sort()
|
||||
etud = etuds[-1][1]
|
||||
else:
|
||||
etud = query.first()
|
||||
|
||||
if etud is None:
|
||||
return error_response(
|
||||
404,
|
||||
message="id de l'étudiant (etudid, nip, ine) inconnu",
|
||||
message="étudiant inconnu",
|
||||
)
|
||||
# Mise en forme des données
|
||||
data = etud.to_dict_bul(include_urls=False)
|
||||
|
||||
return jsonify(data)
|
||||
return jsonify(etud.to_dict_bul(include_urls=False))
|
||||
|
||||
|
||||
@bp.route("/etudiants/etudid/<int:etudid>", methods=["GET"])
|
||||
@bp.route("/etudiants/nip/<string:nip>", methods=["GET"])
|
||||
@bp.route("/etudiants/ine/<string:ine>", methods=["GET"])
|
||||
@token_auth.login_required
|
||||
@token_permission_required(Permission.APIView)
|
||||
def etudiants(etudid: int = None, nip: str = None, ine: str = None):
|
||||
"""
|
||||
Info sur le ou les étudiants correspondant. Comme /etudiant mais renvoie
|
||||
toujours une liste.
|
||||
Si non trouvé, liste vide, pas d'erreur.
|
||||
Dans 99% des cas, la liste contient un seul étudiant, mais si l'étudiant a
|
||||
été inscrit dans plusieurs départements, on a plusieurs objets (1 par dept.).
|
||||
"""
|
||||
if etudid is not None:
|
||||
query = Identite.query.filter_by(id=etudid)
|
||||
elif nip is not None:
|
||||
query = Identite.query.filter_by(code_nip=nip)
|
||||
elif ine is not None:
|
||||
query = Identite.query.filter_by(code_ine=ine)
|
||||
else:
|
||||
return error_response(
|
||||
404,
|
||||
message="parametre manquant",
|
||||
)
|
||||
|
||||
return jsonify([etud.to_dict_bul(include_urls=False) for etud in query])
|
||||
|
||||
|
||||
@bp.route("/etudiant/etudid/<int:etudid>/formsemestres")
|
||||
@ -115,56 +170,65 @@ def etudiant(etudid: int = None, nip: int = None, ine: int = None):
|
||||
@token_permission_required(Permission.APIView)
|
||||
def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None):
|
||||
"""
|
||||
Retourne la liste des semestres qu'un étudiant a suivis, triés par ordre chronologique.
|
||||
|
||||
etudid : l'etudid d'un étudiant
|
||||
nip : le code nip d'un étudiant
|
||||
ine : le code ine d'un étudiant
|
||||
Liste des semestres qu'un étudiant a suivi, triés par ordre chronologique.
|
||||
Accès par etudid, nip ou ine
|
||||
|
||||
Exemple de résultat :
|
||||
[
|
||||
{
|
||||
"date_fin": "31/08/2022",
|
||||
"resp_can_edit": false,
|
||||
"dept_id": 1,
|
||||
"etat": true,
|
||||
"resp_can_change_ens": true,
|
||||
"id": 1,
|
||||
"modalite": "FI",
|
||||
"ens_can_edit_eval": false,
|
||||
"formation_id": 1,
|
||||
"gestion_compensation": false,
|
||||
"elt_sem_apo": null,
|
||||
"semestre_id": 1,
|
||||
"bul_hide_xml": false,
|
||||
"elt_annee_apo": null,
|
||||
"titre": "Semestre test",
|
||||
"block_moyennes": false,
|
||||
"scodoc7_id": null,
|
||||
"date_debut": "01/09/2021",
|
||||
"gestion_semestrielle": false,
|
||||
"bul_bgcolor": "white",
|
||||
"formsemestre_id": 1,
|
||||
"titre_num": "Semestre test semestre 1",
|
||||
"date_debut_iso": "2021-09-01",
|
||||
"date_fin_iso": "2022-08-31",
|
||||
"responsables": []
|
||||
},
|
||||
...
|
||||
]
|
||||
[
|
||||
{
|
||||
"date_fin": "31/08/2022",
|
||||
"resp_can_edit": false,
|
||||
"dept_id": 1,
|
||||
"etat": true,
|
||||
"resp_can_change_ens": true,
|
||||
"id": 1,
|
||||
"modalite": "FI",
|
||||
"ens_can_edit_eval": false,
|
||||
"formation_id": 1,
|
||||
"gestion_compensation": false,
|
||||
"elt_sem_apo": null,
|
||||
"semestre_id": 1,
|
||||
"bul_hide_xml": false,
|
||||
"elt_annee_apo": null,
|
||||
"titre": "Semestre test",
|
||||
"block_moyennes": false,
|
||||
"scodoc7_id": null,
|
||||
"date_debut": "01/09/2021",
|
||||
"gestion_semestrielle": false,
|
||||
"bul_bgcolor": "white",
|
||||
"formsemestre_id": 1,
|
||||
"titre_num": "Semestre test semestre 1",
|
||||
"date_debut_iso": "2021-09-01",
|
||||
"date_fin_iso": "2022-08-31",
|
||||
"responsables": []
|
||||
},
|
||||
...
|
||||
]
|
||||
"""
|
||||
# Récupération de l'étudiant
|
||||
etud = get_etud_from_etudid_or_nip_or_ine(etudid, nip, ine)
|
||||
if etud is None:
|
||||
if etudid is not None:
|
||||
query = FormSemestre.query.filter(
|
||||
FormSemestreInscription.etudid == etudid,
|
||||
FormSemestreInscription.formsemestre_id == FormSemestre.id,
|
||||
)
|
||||
elif nip is not None:
|
||||
query = FormSemestre.query.filter(
|
||||
Identite.code_nip == nip,
|
||||
FormSemestreInscription.etudid == Identite.id,
|
||||
FormSemestreInscription.formsemestre_id == FormSemestre.id,
|
||||
)
|
||||
elif ine is not None:
|
||||
query = FormSemestre.query.filter(
|
||||
Identite.code_ine == ine,
|
||||
FormSemestreInscription.etudid == Identite.id,
|
||||
FormSemestreInscription.formsemestre_id == FormSemestre.id,
|
||||
)
|
||||
else:
|
||||
return error_response(
|
||||
404,
|
||||
message="id de l'étudiant (etudid, nip, ine) inconnu",
|
||||
message="parametre manquant",
|
||||
)
|
||||
|
||||
formsemestres = models.FormSemestre.query.filter(
|
||||
models.FormSemestreInscription.etudid == etud.id,
|
||||
models.FormSemestreInscription.formsemestre_id == models.FormSemestre.id,
|
||||
).order_by(models.FormSemestre.date_debut)
|
||||
formsemestres = query.order_by(FormSemestre.date_debut)
|
||||
|
||||
return jsonify([formsemestre.to_dict() for formsemestre in formsemestres])
|
||||
|
||||
@ -204,8 +268,8 @@ def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None)
|
||||
def etudiant_bulletin_semestre(
|
||||
formsemestre_id,
|
||||
etudid: int = None,
|
||||
nip: int = None,
|
||||
ine: int = None,
|
||||
nip: str = None,
|
||||
ine: str = None,
|
||||
version="long",
|
||||
):
|
||||
"""
|
||||
@ -216,12 +280,12 @@ def etudiant_bulletin_semestre(
|
||||
nip : le code nip d'un étudiant
|
||||
ine : le code ine d'un étudiant
|
||||
Exemple de résultat :
|
||||
{
|
||||
"version": "0",
|
||||
"type": "BUT",
|
||||
"date": "2022-04-27T07:18:16.450634Z",
|
||||
"publie": true,
|
||||
"etudiant": {
|
||||
{
|
||||
"version": "0",
|
||||
"type": "BUT",
|
||||
"date": "2022-04-27T07:18:16.450634Z",
|
||||
"publie": true,
|
||||
"etudiant": {
|
||||
"civilite": "X",
|
||||
"code_ine": "1",
|
||||
"code_nip": "1",
|
||||
@ -247,17 +311,17 @@ def etudiant_bulletin_semestre(
|
||||
"villedomicile": "",
|
||||
"telephone": "",
|
||||
"fax": "",
|
||||
"description": ""
|
||||
},
|
||||
"formation": {
|
||||
"description": "",
|
||||
},
|
||||
"formation": {
|
||||
"id": 1,
|
||||
"acronyme": "BUT R&T",
|
||||
"titre_officiel": "Bachelor technologique r\u00e9seaux et t\u00e9l\u00e9communications",
|
||||
"titre": "BUT R&T"
|
||||
},
|
||||
"formsemestre_id": 1,
|
||||
"etat_inscription": "I",
|
||||
"options": {
|
||||
"titre": "BUT R&T",
|
||||
},
|
||||
"formsemestre_id": 1,
|
||||
"etat_inscription": "I",
|
||||
"options": {
|
||||
"show_abs": true,
|
||||
"show_abs_modules": false,
|
||||
"show_ects": true,
|
||||
@ -276,128 +340,113 @@ def etudiant_bulletin_semestre(
|
||||
"show_temporary": true,
|
||||
"temporary_txt": "Provisoire",
|
||||
"show_uevalid": true,
|
||||
"show_date_inscr": true
|
||||
},
|
||||
"ressources": {
|
||||
"show_date_inscr": true,
|
||||
},
|
||||
"ressources": {
|
||||
"R101": {
|
||||
"id": 1,
|
||||
"titre": "Initiation aux r\u00e9seaux informatiques",
|
||||
"code_apogee": null,
|
||||
"url": "/ScoDoc/TAPI/Scolarite/Notes/moduleimpl_status?moduleimpl_id=1",
|
||||
"moyenne": {},
|
||||
"evaluations": [
|
||||
{
|
||||
"id": 1,
|
||||
"description": "eval1",
|
||||
"date": "2022-04-20",
|
||||
"heure_debut": "08:00",
|
||||
"heure_fin": "09:00",
|
||||
"coef": "01.00",
|
||||
"poids": {
|
||||
"RT1.1": 1.0,
|
||||
},
|
||||
"note": {
|
||||
"value": "12.00",
|
||||
"min": "00.00",
|
||||
"max": "18.00",
|
||||
"moy": "10.88"
|
||||
},
|
||||
"url": "/ScoDoc/TAPI/Scolarite/Notes/evaluation_listenotes?evaluation_id=1"
|
||||
}
|
||||
]
|
||||
"id": 1,
|
||||
"titre": "Initiation aux r\u00e9seaux informatiques",
|
||||
"code_apogee": null,
|
||||
"url": "/ScoDoc/TAPI/Scolarite/Notes/moduleimpl_status?moduleimpl_id=1",
|
||||
"moyenne": {},
|
||||
"evaluations": [
|
||||
{
|
||||
"id": 1,
|
||||
"description": "eval1",
|
||||
"date": "2022-04-20",
|
||||
"heure_debut": "08:00",
|
||||
"heure_fin": "09:00",
|
||||
"coef": "01.00",
|
||||
"poids": {
|
||||
"RT1.1": 1.0,
|
||||
},
|
||||
"note": {
|
||||
"value": "12.00",
|
||||
"min": "00.00",
|
||||
"max": "18.00",
|
||||
"moy": "10.88",
|
||||
},
|
||||
"url": "/ScoDoc/TAPI/Scolarite/Notes/evaluation_listenotes?evaluation_id=1",
|
||||
}
|
||||
],
|
||||
},
|
||||
},
|
||||
"saes": {
|
||||
},
|
||||
"saes": {
|
||||
"SAE11": {
|
||||
"id": 2,
|
||||
"titre": "Se sensibiliser \u00e0 l'hygi\u00e8ne informatique et \u00e0 la cybers\u00e9curit\u00e9",
|
||||
"code_apogee": null,
|
||||
"url": "/ScoDoc/TAPI/Scolarite/Notes/moduleimpl_status?moduleimpl_id=2",
|
||||
"moyenne": {},
|
||||
"evaluations": []
|
||||
"id": 2,
|
||||
"titre": "Se sensibiliser \u00e0 l'hygi\u00e8ne informatique et \u00e0 la cybers\u00e9curit\u00e9",
|
||||
"code_apogee": null,
|
||||
"url": "/ScoDoc/TAPI/Scolarite/Notes/moduleimpl_status?moduleimpl_id=2",
|
||||
"moyenne": {},
|
||||
"evaluations": [],
|
||||
},
|
||||
},
|
||||
"ues": {
|
||||
},
|
||||
"ues": {
|
||||
"RT1.1": {
|
||||
"id": 1,
|
||||
"titre": "Administrer les r\u00e9seaux et l\u2019Internet",
|
||||
"numero": 1,
|
||||
"type": 0,
|
||||
"color": "#B80004",
|
||||
"competence": null,
|
||||
"moyenne": {
|
||||
"value": "08.50",
|
||||
"min": "06.00",
|
||||
"max": "16.50",
|
||||
"moy": "11.31",
|
||||
"rang": "12",
|
||||
"total": 16
|
||||
},
|
||||
"bonus": "00.00",
|
||||
"malus": "00.00",
|
||||
"capitalise": null,
|
||||
"ressources": {
|
||||
"R101": {
|
||||
"id": 1,
|
||||
"coef": 12.0,
|
||||
"moyenne": "12.00"
|
||||
"id": 1,
|
||||
"titre": "Administrer les r\u00e9seaux et l\u2019Internet",
|
||||
"numero": 1,
|
||||
"type": 0,
|
||||
"color": "#B80004",
|
||||
"competence": null,
|
||||
"moyenne": {
|
||||
"value": "08.50",
|
||||
"min": "06.00",
|
||||
"max": "16.50",
|
||||
"moy": "11.31",
|
||||
"rang": "12",
|
||||
"total": 16,
|
||||
},
|
||||
},
|
||||
"saes": {
|
||||
"SAE11": {
|
||||
"id": 2,
|
||||
"coef": 16.0,
|
||||
"moyenne": "~"
|
||||
"bonus": "00.00",
|
||||
"malus": "00.00",
|
||||
"capitalise": null,
|
||||
"ressources": {
|
||||
"R101": {"id": 1, "coef": 12.0, "moyenne": "12.00"},
|
||||
},
|
||||
},
|
||||
"ECTS": {
|
||||
"acquis": 0.0,
|
||||
"total": 12.0
|
||||
}
|
||||
"saes": {
|
||||
"SAE11": {"id": 2, "coef": 16.0, "moyenne": "~"},
|
||||
},
|
||||
"ECTS": {"acquis": 0.0, "total": 12.0},
|
||||
},
|
||||
"semestre": {
|
||||
"etapes": [],
|
||||
"date_debut": "2021-09-01",
|
||||
"date_fin": "2022-08-31",
|
||||
"annee_universitaire": "2021 - 2022",
|
||||
"numero": 1,
|
||||
"inscription": "",
|
||||
"groupes": [],
|
||||
"absences": {
|
||||
"injustifie": 1,
|
||||
"total": 2
|
||||
"semestre": {
|
||||
"etapes": [],
|
||||
"date_debut": "2021-09-01",
|
||||
"date_fin": "2022-08-31",
|
||||
"annee_universitaire": "2021 - 2022",
|
||||
"numero": 1,
|
||||
"inscription": "",
|
||||
"groupes": [],
|
||||
"absences": {"injustifie": 1, "total": 2},
|
||||
"ECTS": {"acquis": 0, "total": 30.0},
|
||||
"notes": {"value": "10.60", "min": "02.40", "moy": "11.05", "max": "17.40"},
|
||||
"rang": {"value": "10", "total": 16},
|
||||
},
|
||||
"ECTS": {
|
||||
"acquis": 0,
|
||||
"total": 30.0
|
||||
},
|
||||
"notes": {
|
||||
"value": "10.60",
|
||||
"min": "02.40",
|
||||
"moy": "11.05",
|
||||
"max": "17.40"
|
||||
},
|
||||
"rang": {
|
||||
"value": "10",
|
||||
"total": 16
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
}
|
||||
"""
|
||||
formsemestre = models.FormSemestre.query.filter_by(
|
||||
id=formsemestre_id
|
||||
).first_or_404()
|
||||
formsemestre = FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
|
||||
dept = Departement.query.filter_by(id=formsemestre.dept_id).first_or_404()
|
||||
|
||||
dept = models.Departement.query.filter_by(id=formsemestre.dept_id).first_or_404()
|
||||
if etudid is not None:
|
||||
query = Identite.query.filter_by(id=etudid)
|
||||
elif nip is not None:
|
||||
query = Identite.query.filter_by(code_nip=nip, dept_id=dept.id)
|
||||
elif ine is not None:
|
||||
query = Identite.query.filter_by(code_ine=ine, dept_id=dept.id)
|
||||
else:
|
||||
return error_response(
|
||||
404,
|
||||
message="parametre manquant",
|
||||
)
|
||||
|
||||
app.set_sco_dept(dept.acronym)
|
||||
|
||||
etud = get_etud_from_etudid_or_nip_or_ine(etudid, nip, ine)
|
||||
etud = query.first()
|
||||
if etud is None:
|
||||
return error_response(
|
||||
404,
|
||||
message="id de l'étudiant (etudid, nip, ine) inconnu",
|
||||
)
|
||||
|
||||
app.set_sco_dept(dept.acronym)
|
||||
return sco_bulletins.get_formsemestre_bulletin_etud_json(
|
||||
formsemestre, etud, version
|
||||
)
|
||||
@ -429,44 +478,57 @@ def etudiant_groups(
|
||||
ine : le code ine d'un étudiant
|
||||
|
||||
Exemple de résultat :
|
||||
[
|
||||
{
|
||||
"partition_id": 1,
|
||||
"id": 1,
|
||||
"formsemestre_id": 1,
|
||||
"partition_name": null,
|
||||
"numero": 0,
|
||||
"bul_show_rank": false,
|
||||
"show_in_lists": true,
|
||||
"group_id": 1,
|
||||
"group_name": null
|
||||
},
|
||||
{
|
||||
"partition_id": 2,
|
||||
"id": 2,
|
||||
"formsemestre_id": 1,
|
||||
"partition_name": "TD",
|
||||
"numero": 1,
|
||||
"bul_show_rank": false,
|
||||
"show_in_lists": true,
|
||||
"group_id": 2,
|
||||
"group_name": "A"
|
||||
}
|
||||
]
|
||||
[
|
||||
{
|
||||
"partition_id": 1,
|
||||
"id": 1,
|
||||
"formsemestre_id": 1,
|
||||
"partition_name": null,
|
||||
"numero": 0,
|
||||
"bul_show_rank": false,
|
||||
"show_in_lists": true,
|
||||
"group_id": 1,
|
||||
"group_name": null
|
||||
},
|
||||
{
|
||||
"partition_id": 2,
|
||||
"id": 2,
|
||||
"formsemestre_id": 1,
|
||||
"partition_name": "TD",
|
||||
"numero": 1,
|
||||
"bul_show_rank": false,
|
||||
"show_in_lists": true,
|
||||
"group_id": 2,
|
||||
"group_name": "A"
|
||||
}
|
||||
]
|
||||
"""
|
||||
if etudid is None:
|
||||
etud = get_etud_from_etudid_or_nip_or_ine(etudid, nip, ine)
|
||||
if etud is None:
|
||||
return error_response(
|
||||
404,
|
||||
message="id de l'étudiant (etudid, nip, ine) inconnu",
|
||||
)
|
||||
etudid = etud.etudid
|
||||
|
||||
# Récupération du formsemestre
|
||||
sem = models.FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
|
||||
dept = models.Departement.query.get(sem.dept_id)
|
||||
formsemestre = FormSemestre.query.filter_by(id=formsemestre_id).first()
|
||||
if formsemestre is None:
|
||||
return error_response(
|
||||
404,
|
||||
message="formsemestre inconnu",
|
||||
)
|
||||
dept = Departement.query.get(formsemestre.dept_id)
|
||||
if etudid is not None:
|
||||
query = Identite.query.filter_by(id=etudid)
|
||||
elif nip is not None:
|
||||
query = Identite.query.filter_by(code_nip=nip, dept_id=dept.id)
|
||||
elif ine is not None:
|
||||
query = Identite.query.filter_by(code_ine=ine, dept_id=dept.id)
|
||||
else:
|
||||
return error_response(
|
||||
404,
|
||||
message="parametre manquant",
|
||||
)
|
||||
etud = query.first()
|
||||
if etud is None:
|
||||
return error_response(
|
||||
404,
|
||||
message="etudiant inconnu",
|
||||
)
|
||||
app.set_sco_dept(dept.acronym)
|
||||
data = sco_groups.get_etud_groups(etudid, sem.id)
|
||||
data = sco_groups.get_etud_groups(etud.id, formsemestre.id)
|
||||
|
||||
return jsonify(data)
|
||||
|
@ -4,6 +4,7 @@ from flask import jsonify
|
||||
import app
|
||||
|
||||
from app import models
|
||||
from app.models import Evaluation
|
||||
from app.api import bp
|
||||
from app.api.auth import token_auth, token_permission_required
|
||||
from app.api.errors import error_response
|
||||
@ -46,7 +47,7 @@ def evaluations(moduleimpl_id: int):
|
||||
]
|
||||
"""
|
||||
# Récupération de toutes les évaluations
|
||||
evals = models.Evaluation.query.filter_by(id=moduleimpl_id)
|
||||
evals = Evaluation.query.filter_by(id=moduleimpl_id)
|
||||
|
||||
# Mise en forme des données
|
||||
data = [d.to_dict() for d in evals]
|
||||
|
@ -59,6 +59,7 @@ def formsemestre(formsemestre_id: int):
|
||||
# pour accéder aux préferences
|
||||
dept = Departement.query.get(formsemestre.dept_id)
|
||||
app.set_sco_dept(dept.acronym)
|
||||
data["annee_scolaire"] = formsemestre.annee_scolaire_str()
|
||||
data["session_id"] = formsemestre.session_id()
|
||||
return jsonify(data)
|
||||
|
||||
|
@ -348,7 +348,7 @@ class User(UserMixin, db.Model):
|
||||
return None
|
||||
|
||||
def get_nom_fmt(self):
|
||||
"""Nom formatté: "Martin" """
|
||||
"""Nom formaté: "Martin" """
|
||||
if self.nom:
|
||||
return sco_etud.format_nom(self.nom, uppercase=False)
|
||||
else:
|
||||
|
@ -14,10 +14,12 @@ from flask import url_for, g
|
||||
|
||||
from app.comp.res_but import ResultatsSemestreBUT
|
||||
from app.models import FormSemestre, Identite
|
||||
from app.models.groups import GroupDescr
|
||||
from app.models.ues import UniteEns
|
||||
from app.scodoc import sco_bulletins, sco_utils as scu
|
||||
from app.scodoc import sco_bulletins_json
|
||||
from app.scodoc import sco_bulletins_pdf
|
||||
from app.scodoc import sco_groups
|
||||
from app.scodoc import sco_preferences
|
||||
from app.scodoc.sco_codes_parcours import UE_SPORT, DEF
|
||||
from app.scodoc.sco_utils import fmt_note
|
||||
@ -64,8 +66,16 @@ class BulletinBUT:
|
||||
# }
|
||||
return d
|
||||
|
||||
def etud_ue_results(self, etud: Identite, ue: UniteEns, decision_ue: dict) -> dict:
|
||||
"dict synthèse résultats UE"
|
||||
def etud_ue_results(
|
||||
self,
|
||||
etud: Identite,
|
||||
ue: UniteEns,
|
||||
decision_ue: dict,
|
||||
etud_groups: list[GroupDescr] = None,
|
||||
) -> dict:
|
||||
"""dict synthèse résultats UE
|
||||
etud_groups : liste des groupes, pour affichage du rang.
|
||||
"""
|
||||
res = self.res
|
||||
|
||||
d = {
|
||||
@ -81,7 +91,7 @@ class BulletinBUT:
|
||||
if res.bonus_ues is not None and ue.id in res.bonus_ues
|
||||
else fmt_note(0.0),
|
||||
"malus": fmt_note(res.malus[ue.id][etud.id]),
|
||||
"capitalise": None, # "AAAA-MM-JJ" TODO #sco92
|
||||
"capitalise": None, # "AAAA-MM-JJ" TODO #sco93
|
||||
"ressources": self.etud_ue_mod_results(etud, ue, res.ressources),
|
||||
"saes": self.etud_ue_mod_results(etud, ue, res.saes),
|
||||
}
|
||||
@ -103,7 +113,18 @@ class BulletinBUT:
|
||||
"moy": fmt_note(res.etud_moy_ue[ue.id].mean()),
|
||||
"rang": rang,
|
||||
"total": effectif, # nb etud avec note dans cette UE
|
||||
"groupes": {},
|
||||
}
|
||||
if self.prefs["bul_show_ue_rangs"]:
|
||||
for group in etud_groups:
|
||||
if group.partition.bul_show_rank:
|
||||
rang, effectif = self.res.get_etud_ue_rang(
|
||||
ue.id, etud.id, group.id
|
||||
)
|
||||
d["moyenne"]["groupes"][group.id] = {
|
||||
"value": rang,
|
||||
"total": effectif,
|
||||
}
|
||||
else:
|
||||
# ceci suppose que l'on a une seule UE bonus,
|
||||
# en tous cas elles auront la même description
|
||||
@ -275,6 +296,9 @@ class BulletinBUT:
|
||||
return d
|
||||
|
||||
nbabs, nbabsjust = formsemestre.get_abs_count(etud.id)
|
||||
etud_groups = sco_groups.get_etud_formsemestre_groups(
|
||||
etud, formsemestre, only_to_show=True
|
||||
)
|
||||
semestre_infos = {
|
||||
"etapes": [str(x.etape_apo) for x in formsemestre.etapes if x.etape_apo],
|
||||
"date_debut": formsemestre.date_debut.isoformat(),
|
||||
@ -282,7 +306,7 @@ class BulletinBUT:
|
||||
"annee_universitaire": formsemestre.annee_scolaire_str(),
|
||||
"numero": formsemestre.semestre_id,
|
||||
"inscription": "", # inutilisé mais nécessaire pour le js de Seb.
|
||||
"groupes": [], # XXX TODO
|
||||
"groupes": [group.to_dict() for group in etud_groups],
|
||||
}
|
||||
if self.prefs["bul_show_abs"]:
|
||||
semestre_infos["absences"] = {
|
||||
@ -306,15 +330,25 @@ class BulletinBUT:
|
||||
"max": fmt_note(res.etud_moy_gen.max()),
|
||||
}
|
||||
if self.prefs["bul_show_rangs"] and not np.isnan(res.etud_moy_gen[etud.id]):
|
||||
# classement wrt moyenne général, indicatif
|
||||
# classement wrt moyenne générale, indicatif
|
||||
semestre_infos["rang"] = {
|
||||
"value": res.etud_moy_gen_ranks[etud.id],
|
||||
"total": nb_inscrits,
|
||||
"groupes": {},
|
||||
}
|
||||
# Rangs par groupes
|
||||
for group in etud_groups:
|
||||
if group.partition.bul_show_rank:
|
||||
rang, effectif = self.res.get_etud_rang_group(etud.id, group.id)
|
||||
semestre_infos["rang"]["groupes"][group.id] = {
|
||||
"value": rang,
|
||||
"total": effectif,
|
||||
}
|
||||
else:
|
||||
semestre_infos["rang"] = {
|
||||
"value": "-",
|
||||
"total": nb_inscrits,
|
||||
"groupes": {},
|
||||
}
|
||||
d.update(
|
||||
{
|
||||
@ -324,7 +358,10 @@ class BulletinBUT:
|
||||
"saes": self.etud_mods_results(etud, res.saes, version=version),
|
||||
"ues": {
|
||||
ue.acronyme: self.etud_ue_results(
|
||||
etud, ue, decision_ue=decisions_ues.get(ue.id, {})
|
||||
etud,
|
||||
ue,
|
||||
decision_ue=decisions_ues.get(ue.id, {}),
|
||||
etud_groups=etud_groups,
|
||||
)
|
||||
for ue in res.ues
|
||||
# si l'UE comporte des modules auxquels on est inscrit:
|
||||
|
@ -481,6 +481,19 @@ class BonusBezier(BonusSportAdditif):
|
||||
proportion_point = 0.03
|
||||
|
||||
|
||||
class BonusBlagnac(BonusSportAdditif):
|
||||
"""Calcul bonus modules optionnels (sport, culture), règle IUT de Blagnac.
|
||||
|
||||
Le bonus est égal à 5% des points au dessus de 10 à appliquer sur toutes
|
||||
les UE du semestre, applicable dans toutes les formations (DUT, BUT, ...).
|
||||
"""
|
||||
|
||||
name = "bonus_iutblagnac"
|
||||
displayed_name = "IUT de Blagnac"
|
||||
proportion_point = 0.05
|
||||
classic_use_bonus_ues = True # toujours sur les UE
|
||||
|
||||
|
||||
class BonusBordeaux1(BonusSportMultiplicatif):
|
||||
"""Calcul bonus modules optionnels (sport, culture), règle IUT Bordeaux 1,
|
||||
sur moyenne générale et UEs.
|
||||
@ -690,6 +703,51 @@ class BonusGrenobleIUT1(BonusSportMultiplicatif):
|
||||
super().compute_bonus(sem_modimpl_moys_inscrits, modimpl_coefs_etuds_no_nan)
|
||||
|
||||
|
||||
class BonusIUTRennes1(BonusSportAdditif):
|
||||
"""Calcul bonus optionnels (sport, langue vivante, engagement étudiant),
|
||||
règle IUT de l'Université de Rennes 1 (Lannion, St Malo).
|
||||
|
||||
<ul>
|
||||
<li>Les étudiants peuvent suivre un ou plusieurs activités optionnelles notées.
|
||||
La meilleure des notes obtenue est prise en compte, si elle est supérieure à 10/20.
|
||||
</li>
|
||||
<li>Le vingtième des points au dessus de 10 est ajouté à la moyenne des UE.
|
||||
</li>
|
||||
<li> Exemple: un étudiant ayant 16/20 bénéficiera d'un bonus de (16-10)/20 = 0,3 points
|
||||
sur chaque UE.
|
||||
</li>
|
||||
</ul>
|
||||
"""
|
||||
|
||||
name = "bonus_iut_rennes1"
|
||||
displayed_name = "IUTs de Rennes 1 (Lannion, St Malo)"
|
||||
seuil_moy_gen = 10.0
|
||||
proportion_point = 1 / 20.0
|
||||
classic_use_bonus_ues = True
|
||||
# Adapté de BonusTarbes, mais s'applique aussi en classic
|
||||
def compute_bonus(self, sem_modimpl_moys_inscrits, modimpl_coefs_etuds_no_nan):
|
||||
"""calcul du bonus"""
|
||||
# Prend la note de chaque modimpl, sans considération d'UE
|
||||
if len(sem_modimpl_moys_inscrits.shape) > 2: # apc
|
||||
sem_modimpl_moys_inscrits = sem_modimpl_moys_inscrits[:, :, 0]
|
||||
# ici sem_modimpl_moys_inscrits est nb_etuds x nb_mods_bonus, en APC et en classic
|
||||
note_bonus_max = np.max(sem_modimpl_moys_inscrits, axis=1) # 1d, nb_etuds
|
||||
nb_ues = self.formsemestre.query_ues(with_sport=False).count()
|
||||
|
||||
bonus_moy_arr = np.where(
|
||||
note_bonus_max > self.seuil_moy_gen,
|
||||
(note_bonus_max - self.seuil_moy_gen) * self.proportion_point,
|
||||
0.0,
|
||||
)
|
||||
# Seuil: bonus dans [min, max] (défaut [0,20])
|
||||
bonus_max = self.bonus_max or 20.0
|
||||
np.clip(bonus_moy_arr, self.bonus_min, bonus_max, out=bonus_moy_arr)
|
||||
if self.formsemestre.formation.is_apc():
|
||||
bonus_moy_arr = np.stack([bonus_moy_arr] * nb_ues).T
|
||||
|
||||
self.bonus_additif(bonus_moy_arr)
|
||||
|
||||
|
||||
class BonusLaRochelle(BonusSportAdditif):
|
||||
"""Calcul bonus modules optionnels (sport, culture), règle IUT de La Rochelle.
|
||||
|
||||
|
@ -18,7 +18,7 @@ from app.auth.models import User
|
||||
from app.comp.res_cache import ResultatsCache
|
||||
from app.comp import res_sem
|
||||
from app.comp.moy_mod import ModuleImplResults
|
||||
from app.models import FormSemestre, FormSemestreUECoef, formsemestre
|
||||
from app.models import FormSemestre, FormSemestreUECoef
|
||||
from app.models import Identite
|
||||
from app.models import ModuleImpl, ModuleImplInscription
|
||||
from app.models.ues import UniteEns
|
||||
@ -151,6 +151,7 @@ class ResultatsSemestre(ResultatsCache):
|
||||
if m.module.module_type == scu.ModuleType.SAE
|
||||
]
|
||||
|
||||
# --- JURY...
|
||||
def get_etud_ue_validables(self, etudid: int) -> list[UniteEns]:
|
||||
"""Liste des UEs du semestre qui doivent être validées
|
||||
|
||||
|
@ -35,7 +35,9 @@ class NotesTableCompat(ResultatsSemestre):
|
||||
"malus",
|
||||
"etud_moy_gen_ranks",
|
||||
"etud_moy_gen_ranks_int",
|
||||
"moy_gen_rangs_by_group",
|
||||
"ue_rangs",
|
||||
"ue_rangs_by_group",
|
||||
)
|
||||
|
||||
def __init__(self, formsemestre: FormSemestre):
|
||||
@ -48,6 +50,8 @@ class NotesTableCompat(ResultatsSemestre):
|
||||
self.moy_min = "NA"
|
||||
self.moy_max = "NA"
|
||||
self.moy_moy = "NA"
|
||||
self.moy_gen_rangs_by_group = {} # { group_id : (Series, Series) }
|
||||
self.ue_rangs_by_group = {} # { ue_id : {group_id : (Series, Series)}}
|
||||
self.expr_diagnostics = ""
|
||||
self.parcours = self.formsemestre.formation.get_parcours()
|
||||
|
||||
@ -153,31 +157,83 @@ class NotesTableCompat(ResultatsSemestre):
|
||||
def compute_rangs(self):
|
||||
"""Calcule les classements
|
||||
Moyenne générale: etud_moy_gen_ranks
|
||||
Par UE (sauf ue bonus)
|
||||
Par UE (sauf ue bonus): ue_rangs[ue.id]
|
||||
Par groupe: classements selon moy_gen et UE:
|
||||
moy_gen_rangs_by_group[group_id]
|
||||
ue_rangs_by_group[group_id]
|
||||
"""
|
||||
(
|
||||
self.etud_moy_gen_ranks,
|
||||
self.etud_moy_gen_ranks_int,
|
||||
) = moy_sem.comp_ranks_series(self.etud_moy_gen)
|
||||
for ue in self.formsemestre.query_ues():
|
||||
ues = self.formsemestre.query_ues()
|
||||
for ue in ues:
|
||||
moy_ue = self.etud_moy_ue[ue.id]
|
||||
self.ue_rangs[ue.id] = (
|
||||
moy_sem.comp_ranks_series(moy_ue)[0], # juste en chaine
|
||||
int(moy_ue.count()),
|
||||
)
|
||||
# .count() -> nb of non NaN values
|
||||
# Rangs dans les groupes (moy. gen et par UE)
|
||||
self.moy_gen_rangs_by_group = {} # { group_id : (Series, Series) }
|
||||
self.ue_rangs_by_group = {}
|
||||
partitions_avec_rang = self.formsemestre.partitions.filter_by(
|
||||
bul_show_rank=True
|
||||
)
|
||||
for partition in partitions_avec_rang:
|
||||
for group in partition.groups:
|
||||
# on prend l'intersection car les groupes peuvent inclure des étudiants désinscrits
|
||||
group_members = list(
|
||||
{etud.id for etud in group.etuds}.intersection(
|
||||
self.etud_moy_gen.index
|
||||
)
|
||||
)
|
||||
# list() car pandas veut une sequence pour take()
|
||||
# Rangs / moyenne générale:
|
||||
group_moys_gen = self.etud_moy_gen[group_members]
|
||||
self.moy_gen_rangs_by_group[group.id] = moy_sem.comp_ranks_series(
|
||||
group_moys_gen
|
||||
)
|
||||
# Rangs / UEs:
|
||||
for ue in ues:
|
||||
group_moys_ue = self.etud_moy_ue[ue.id][group_members]
|
||||
self.ue_rangs_by_group.setdefault(ue.id, {})[
|
||||
group.id
|
||||
] = moy_sem.comp_ranks_series(group_moys_ue)
|
||||
|
||||
def get_etud_ue_rang(self, ue_id, etudid) -> tuple[str, int]:
|
||||
def get_etud_rang(self, etudid: int) -> str:
|
||||
"""Le rang (classement) de l'étudiant dans le semestre.
|
||||
Result: "13" ou "12 ex"
|
||||
"""
|
||||
return self.etud_moy_gen_ranks.get(etudid, 99999)
|
||||
|
||||
def get_etud_ue_rang(self, ue_id, etudid, group_id=None) -> tuple[str, int]:
|
||||
"""Le rang de l'étudiant dans cette ue
|
||||
Si le group_id est spécifié, rang au sein de ce groupe, sinon global.
|
||||
Result: rang:str, effectif:str
|
||||
"""
|
||||
rangs, effectif = self.ue_rangs[ue_id]
|
||||
if rangs is not None:
|
||||
rang = rangs[etudid]
|
||||
if group_id is None:
|
||||
rangs, effectif = self.ue_rangs[ue_id]
|
||||
if rangs is not None:
|
||||
rang = rangs[etudid]
|
||||
else:
|
||||
return "", ""
|
||||
else:
|
||||
return "", ""
|
||||
rangs = self.ue_rangs_by_group[ue_id][group_id][0]
|
||||
rang = rangs[etudid]
|
||||
effectif = len(rangs)
|
||||
return rang, effectif
|
||||
|
||||
def get_etud_rang_group(self, etudid: int, group_id: int) -> tuple[str, int]:
|
||||
"""Rang de l'étudiant (selon moy gen) et effectif dans ce groupe.
|
||||
Si le groupe n'a pas de rang (partition avec bul_show_rank faux), ramène "", 0
|
||||
"""
|
||||
if group_id in self.moy_gen_rangs_by_group:
|
||||
r = self.moy_gen_rangs_by_group[group_id][0] # version en str
|
||||
return (r[etudid], len(r))
|
||||
else:
|
||||
return "", 0
|
||||
|
||||
def etud_check_conditions_ues(self, etudid):
|
||||
"""Vrai si les conditions sur les UE sont remplies.
|
||||
Ne considère que les UE ayant des notes (moyenne calculée).
|
||||
@ -298,16 +354,6 @@ class NotesTableCompat(ResultatsSemestre):
|
||||
"ects_pot_fond": 0.0, # not implemented (anciennemment pour école ingé)
|
||||
}
|
||||
|
||||
def get_etud_rang(self, etudid: int) -> str:
|
||||
"""Le rang (classement) de l'étudiant dans le semestre.
|
||||
Result: "13" ou "12 ex"
|
||||
"""
|
||||
return self.etud_moy_gen_ranks.get(etudid, 99999)
|
||||
|
||||
def get_etud_rang_group(self, etudid: int, group_id: int):
|
||||
"Le rang de l'étudiant dans ce groupe (NON IMPLEMENTE)"
|
||||
return (None, 0) # XXX unimplemented TODO
|
||||
|
||||
def get_evals_in_mod(self, moduleimpl_id: int) -> list[dict]:
|
||||
"""Liste d'informations (compat NotesTable) sur évaluations completes
|
||||
de ce module.
|
||||
|
@ -82,7 +82,9 @@ def configuration():
|
||||
form_bonus.data["bonus_sport_func_name"]
|
||||
)
|
||||
app.clear_scodoc_cache()
|
||||
flash(f"Fonction bonus sport&culture configurée.")
|
||||
flash("""Fonction bonus sport&culture configurée.""")
|
||||
else:
|
||||
flash("Fonction bonus inchangée.")
|
||||
return redirect(url_for("scodoc.index"))
|
||||
elif form_scodoc.submit_scodoc.data and form_scodoc.validate():
|
||||
if ScoDocSiteConfig.enable_entreprises(
|
||||
|
@ -56,11 +56,13 @@ class Identite(db.Model):
|
||||
#
|
||||
adresses = db.relationship("Adresse", lazy="dynamic", backref="etud")
|
||||
billets = db.relationship("BilletAbsence", backref="etudiant", lazy="dynamic")
|
||||
# one-to-one relation:
|
||||
#
|
||||
admission = db.relationship("Admission", backref="identite", lazy="dynamic")
|
||||
|
||||
def __repr__(self):
|
||||
return f"<Etud {self.id} {self.nom!r} {self.prenom!r}>"
|
||||
return (
|
||||
f"<Etud {self.id}/{self.departement.acronym} {self.nom!r} {self.prenom!r}>"
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def from_request(cls, etudid=None, code_nip=None):
|
||||
@ -178,6 +180,8 @@ class Identite(db.Model):
|
||||
"date_naissance": self.date_naissance.strftime("%d/%m/%Y")
|
||||
if self.date_naissance
|
||||
else "",
|
||||
"dept_id": self.dept_id,
|
||||
"dept_acronym": self.departement.acronym,
|
||||
"email": self.get_first_email() or "",
|
||||
"emailperso": self.get_first_email("emailperso"),
|
||||
"etudid": self.id,
|
||||
|
@ -5,8 +5,6 @@
|
||||
import datetime
|
||||
|
||||
from app import db
|
||||
from app.models import formsemestre
|
||||
from app.models.formsemestre import FormSemestre
|
||||
from app.models.moduleimpls import ModuleImpl
|
||||
from app.models.ues import UniteEns
|
||||
|
||||
@ -48,13 +46,25 @@ class Evaluation(db.Model):
|
||||
def __repr__(self):
|
||||
return f"""<Evaluation {self.id} {self.jour.isoformat() if self.jour else ''} "{self.description[:16] if self.description else ''}">"""
|
||||
|
||||
def to_dict(self):
|
||||
def to_dict(self) -> dict:
|
||||
"Représentation dict, pour json"
|
||||
e = dict(self.__dict__)
|
||||
e.pop("_sa_instance_state", None)
|
||||
# ScoDoc7 output_formators
|
||||
e["evaluation_id"] = self.id
|
||||
e["jour"] = ndb.DateISOtoDMY(e["jour"])
|
||||
e["jour"] = e["jour"].strftime("%d/%m/%Y") if e["jour"] else ""
|
||||
if self.jour is None:
|
||||
e["date_debut"] = None
|
||||
e["date_fin"] = None
|
||||
else:
|
||||
e["date_debut"] = datetime.datetime.combine(
|
||||
self.jour, self.heure_debut or datetime.time(0, 0)
|
||||
).isoformat()
|
||||
e["date_fin"] = datetime.datetime.combine(
|
||||
self.jour, self.heure_fin or datetime.time(0, 0)
|
||||
).isoformat()
|
||||
e["numero"] = ndb.int_null_is_zero(e["numero"])
|
||||
e["poids"] = self.get_ue_poids_dict() # { ue_id : poids }
|
||||
return evaluation_enrich_dict(e)
|
||||
|
||||
def from_dict(self, data):
|
||||
@ -153,7 +163,7 @@ class EvaluationUEPoids(db.Model):
|
||||
|
||||
# Fonction héritée de ScoDoc7 à refactorer
|
||||
def evaluation_enrich_dict(e):
|
||||
"""add or convert some fileds in an evaluation dict"""
|
||||
"""add or convert some fields in an evaluation dict"""
|
||||
# For ScoDoc7 compat
|
||||
heure_debut_dt = e["heure_debut"] or datetime.time(
|
||||
8, 00
|
||||
|
@ -287,7 +287,7 @@ class FormSemestre(db.Model):
|
||||
"""
|
||||
if not self.etapes:
|
||||
return ""
|
||||
return ", ".join(sorted([str(x.etape_apo) for x in self.etapes]))
|
||||
return ", ".join(sorted([etape.etape_apo for etape in self.etapes if etape]))
|
||||
|
||||
def responsables_str(self, abbrev_prenom=True) -> str:
|
||||
"""chaîne "J. Dupond, X. Martin"
|
||||
@ -449,10 +449,15 @@ class FormSemestreEtape(db.Model):
|
||||
db.Integer,
|
||||
db.ForeignKey("notes_formsemestre.id"),
|
||||
)
|
||||
# etape_apo aurait du etre not null, mais oublié
|
||||
etape_apo = db.Column(db.String(APO_CODE_STR_LEN), index=True)
|
||||
|
||||
def __bool__(self):
|
||||
"Etape False if code empty"
|
||||
return self.etape_apo is not None and (len(self.etape_apo) > 0)
|
||||
|
||||
def __repr__(self):
|
||||
return f"<Etape {self.id} apo={self.etape_apo}>"
|
||||
return f"<Etape {self.id} apo={self.etape_apo!r}>"
|
||||
|
||||
def as_apovdi(self):
|
||||
return ApoEtapeVDI(self.etape_apo)
|
||||
|
@ -25,9 +25,11 @@ class Partition(db.Model):
|
||||
partition_name = db.Column(db.String(SHORT_STR_LEN))
|
||||
# numero = ordre de presentation)
|
||||
numero = db.Column(db.Integer)
|
||||
# Calculer le rang ?
|
||||
bul_show_rank = db.Column(
|
||||
db.Boolean(), nullable=False, default=False, server_default="false"
|
||||
)
|
||||
# Montrer quand on indique les groupes de l'étudiant ?
|
||||
show_in_lists = db.Column(
|
||||
db.Boolean(), nullable=False, default=True, server_default="true"
|
||||
)
|
||||
@ -50,6 +52,18 @@ class Partition(db.Model):
|
||||
def __repr__(self):
|
||||
return f"""<{self.__class__.__name__} {self.id} "{self.partition_name or '(default)'}">"""
|
||||
|
||||
def to_dict(self, with_groups=False) -> dict:
|
||||
"""as a dict, with or without groups"""
|
||||
d = {
|
||||
"id": self.id,
|
||||
"formsemestre_id": self.partition_id,
|
||||
"name": self.partition_name,
|
||||
"numero": self.numero,
|
||||
}
|
||||
if with_groups:
|
||||
d["groups"] = [group.to_dict(with_partition=False) for group in self.groups]
|
||||
return d
|
||||
|
||||
|
||||
class GroupDescr(db.Model):
|
||||
"""Description d'un groupe d'une partition"""
|
||||
@ -78,6 +92,17 @@ class GroupDescr(db.Model):
|
||||
"Nom avec partition: 'TD A'"
|
||||
return f"{self.partition.partition_name or ''} {self.group_name or '-'}"
|
||||
|
||||
def to_dict(self, with_partition=True) -> dict:
|
||||
"""as a dict, with or without partition"""
|
||||
d = {
|
||||
"id": self.id,
|
||||
"partition_id": self.partition_id,
|
||||
"name": self.group_name,
|
||||
}
|
||||
if with_partition:
|
||||
d["partition"] = self.partition.to_dict(with_groups=False)
|
||||
return d
|
||||
|
||||
|
||||
group_membership = db.Table(
|
||||
"group_membership",
|
||||
@ -85,3 +110,11 @@ group_membership = db.Table(
|
||||
db.Column("group_id", db.Integer, db.ForeignKey("group_descr.id")),
|
||||
db.UniqueConstraint("etudid", "group_id"),
|
||||
)
|
||||
# class GroupMembership(db.Model):
|
||||
# """Association groupe / étudiant"""
|
||||
|
||||
# __tablename__ = "group_membership"
|
||||
# __table_args__ = (db.UniqueConstraint("etudid", "group_id"),)
|
||||
# id = db.Column(db.Integer, primary_key=True)
|
||||
# etudid = db.Column(db.Integer, db.ForeignKey("identite.id"))
|
||||
# group_id = db.Column(db.Integer, db.ForeignKey("group_descr.id"))
|
||||
|
@ -97,7 +97,7 @@ class SetTag(pe_tagtable.TableTag):
|
||||
"""Mémorise les semtag nécessaires au jury."""
|
||||
self.SemTagDict = {fid: SemTagDict[fid] for fid in self.get_Fids_in_settag()}
|
||||
if PE_DEBUG >= 1:
|
||||
pe_print(u" => %d semestres fusionnés" % len(self.SemTagDict))
|
||||
pe_print(" => %d semestres fusionnés" % len(self.SemTagDict))
|
||||
|
||||
# -------------------------------------------------------------------------------------------------------------------
|
||||
def comp_data_settag(self):
|
||||
@ -210,7 +210,7 @@ class SetTagInterClasse(pe_tagtable.TableTag):
|
||||
# -------------------------------------------------------------------------------------------------------------------
|
||||
def __init__(self, nom_combinaison, diplome):
|
||||
|
||||
pe_tagtable.TableTag.__init__(self, nom=nom_combinaison + "_%d" % diplome)
|
||||
pe_tagtable.TableTag.__init__(self, nom=f"{nom_combinaison}_{diplome or ''}")
|
||||
self.combinaison = nom_combinaison
|
||||
self.parcoursDict = {}
|
||||
|
||||
@ -243,7 +243,7 @@ class SetTagInterClasse(pe_tagtable.TableTag):
|
||||
fid: SetTagDict[fid] for fid in self.get_Fids_in_settag() if fid != None
|
||||
}
|
||||
if PE_DEBUG >= 1:
|
||||
pe_print(u" => %d semestres utilisés" % len(self.SetTagDict))
|
||||
pe_print(" => %d semestres utilisés" % len(self.SetTagDict))
|
||||
|
||||
# -------------------------------------------------------------------------------------------------------------------
|
||||
def comp_data_settag(self):
|
||||
|
@ -983,7 +983,8 @@ def _tables_abs_etud(
|
||||
)[0]
|
||||
if format == "html":
|
||||
ex.append(
|
||||
f"""<a href="{url_for('notes.moduleimpl_status',
|
||||
f"""<a title="{mod['module']['titre']}"
|
||||
href="{url_for('notes.moduleimpl_status',
|
||||
scodoc_dept=g.scodoc_dept, moduleimpl_id=mod["moduleimpl_id"])}
|
||||
">{mod["module"]["code"] or '(module sans code)'}</a>"""
|
||||
)
|
||||
|
@ -251,7 +251,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
|
||||
rang = ""
|
||||
|
||||
rang_gr, ninscrits_gr, gr_name = get_etud_rangs_groups(
|
||||
etudid, formsemestre_id, partitions, partitions_etud_groups, nt
|
||||
etudid, partitions, partitions_etud_groups, nt
|
||||
)
|
||||
|
||||
if nt.get_moduleimpls_attente():
|
||||
@ -651,7 +651,7 @@ def _ue_mod_bulletin(
|
||||
|
||||
|
||||
def get_etud_rangs_groups(
|
||||
etudid, formsemestre_id, partitions, partitions_etud_groups, nt
|
||||
etudid: int, partitions, partitions_etud_groups, nt: NotesTableCompat
|
||||
):
|
||||
"""Ramene rang et nb inscrits dans chaque partition"""
|
||||
rang_gr, ninscrits_gr, gr_name = {}, {}, {}
|
||||
|
@ -165,7 +165,7 @@ def formsemestre_bulletinetud_published_dict(
|
||||
else:
|
||||
rang = str(nt.get_etud_rang(etudid))
|
||||
rang_gr, ninscrits_gr, gr_name = sco_bulletins.get_etud_rangs_groups(
|
||||
etudid, formsemestre_id, partitions, partitions_etud_groups, nt
|
||||
etudid, partitions, partitions_etud_groups, nt
|
||||
)
|
||||
|
||||
d["note"] = dict(
|
||||
|
@ -172,7 +172,7 @@ def make_xml_formsemestre_bulletinetud(
|
||||
else:
|
||||
rang = str(nt.get_etud_rang(etudid))
|
||||
rang_gr, ninscrits_gr, gr_name = sco_bulletins.get_etud_rangs_groups(
|
||||
etudid, formsemestre_id, partitions, partitions_etud_groups, nt
|
||||
etudid, partitions, partitions_etud_groups, nt
|
||||
)
|
||||
|
||||
doc.append(
|
||||
|
@ -204,13 +204,14 @@ def module_delete(module_id=None):
|
||||
|
||||
H = [
|
||||
html_sco_header.sco_header(page_title="Suppression d'un module"),
|
||||
"""<h2>Suppression du module %(titre)s (%(code)s)</h2>""" % mod,
|
||||
f"""<h2>Suppression du module {module.titre} ({module.code})</h2>""",
|
||||
]
|
||||
|
||||
dest_url = url_for(
|
||||
"notes.ue_table",
|
||||
scodoc_dept=g.scodoc_dept,
|
||||
formation_id=str(mod["formation_id"]),
|
||||
formation_id=module.formation_id,
|
||||
semestre_idx=module.ue.semestre_idx,
|
||||
)
|
||||
tf = TrivialFormulator(
|
||||
request.base_url,
|
||||
|
@ -157,6 +157,8 @@ def do_ue_delete(ue_id, delete_validations=False, force=False):
|
||||
from app.scodoc import sco_parcours_dut
|
||||
|
||||
ue = UniteEns.query.get_or_404(ue_id)
|
||||
formation_id = ue.formation_id
|
||||
semestre_idx = ue.semestre_idx
|
||||
if not can_delete_ue(ue):
|
||||
raise ScoNonEmptyFormationObject(
|
||||
"UE",
|
||||
@ -164,8 +166,8 @@ def do_ue_delete(ue_id, delete_validations=False, force=False):
|
||||
dest_url=url_for(
|
||||
"notes.ue_table",
|
||||
scodoc_dept=g.scodoc_dept,
|
||||
formation_id=ue.formation_id,
|
||||
semestre_idx=ue.semestre_idx,
|
||||
formation_id=formation_id,
|
||||
semestre_idx=semestre_idx,
|
||||
),
|
||||
)
|
||||
|
||||
@ -188,13 +190,13 @@ def do_ue_delete(ue_id, delete_validations=False, force=False):
|
||||
cancel_url=url_for(
|
||||
"notes.ue_table",
|
||||
scodoc_dept=g.scodoc_dept,
|
||||
formation_id=ue.formation_id,
|
||||
semestre_idx=ue.semestre_idx,
|
||||
formation_id=formation_id,
|
||||
semestre_idx=semestre_idx,
|
||||
),
|
||||
parameters={"ue_id": ue.id, "dialog_confirmed": 1},
|
||||
)
|
||||
if delete_validations:
|
||||
log("deleting all validations of UE %s" % ue.id)
|
||||
log(f"deleting all validations of UE {ue.id}")
|
||||
ndb.SimpleQuery(
|
||||
"DELETE FROM scolar_formsemestre_validation WHERE ue_id=%(ue_id)s",
|
||||
{"ue_id": ue.id},
|
||||
@ -216,10 +218,10 @@ def do_ue_delete(ue_id, delete_validations=False, force=False):
|
||||
# utilisé: acceptable de tout invalider):
|
||||
sco_cache.invalidate_formsemestre()
|
||||
# news
|
||||
F = sco_formations.formation_list(args={"formation_id": ue.formation_id})[0]
|
||||
F = sco_formations.formation_list(args={"formation_id": formation_id})[0]
|
||||
ScolarNews.add(
|
||||
typ=ScolarNews.NEWS_FORM,
|
||||
obj=ue.formation_id,
|
||||
obj=formation_id,
|
||||
text=f"Modification de la formation {F['acronyme']}",
|
||||
max_frequency=10 * 60,
|
||||
)
|
||||
@ -229,8 +231,8 @@ def do_ue_delete(ue_id, delete_validations=False, force=False):
|
||||
url_for(
|
||||
"notes.ue_table",
|
||||
scodoc_dept=g.scodoc_dept,
|
||||
formation_id=ue.formation_id,
|
||||
semestre_idx=ue.semestre_idx,
|
||||
formation_id=formation_id,
|
||||
semestre_idx=semestre_idx,
|
||||
)
|
||||
)
|
||||
return None
|
||||
|
@ -208,25 +208,29 @@ def _build_results_list(dpv_by_sem, etuds_infos):
|
||||
return rows, titles, columns_ids
|
||||
|
||||
|
||||
def get_set_formsemestre_id_dates(start_date, end_date):
|
||||
def get_set_formsemestre_id_dates(start_date, end_date) -> set:
|
||||
"""Ensemble des formsemestre_id entre ces dates"""
|
||||
s = ndb.SimpleDictFetch(
|
||||
"""SELECT id
|
||||
FROM notes_formsemestre
|
||||
WHERE date_debut >= %(start_date)s AND date_fin <= %(end_date)s
|
||||
WHERE date_debut >= %(start_date)s
|
||||
AND date_fin <= %(end_date)s
|
||||
AND dept_id = %(dept_id)s
|
||||
""",
|
||||
{"start_date": start_date, "end_date": end_date},
|
||||
{"start_date": start_date, "end_date": end_date, "dept_id": g.scodoc_dept_id},
|
||||
)
|
||||
return {x["id"] for x in s}
|
||||
|
||||
|
||||
def scodoc_table_results(start_date="", end_date="", types_parcours=[], format="html"):
|
||||
def scodoc_table_results(
|
||||
start_date="", end_date="", types_parcours: list = None, format="html"
|
||||
):
|
||||
"""Page affichant la table des résultats
|
||||
Les dates sont en dd/mm/yyyy (datepicker javascript)
|
||||
types_parcours est la liste des types de parcours à afficher
|
||||
(liste de chaines, eg ['100', '210'] )
|
||||
"""
|
||||
log("scodoc_table_results: start_date=%s" % (start_date,)) # XXX
|
||||
log(f"scodoc_table_results: start_date={start_date!r}")
|
||||
if not types_parcours:
|
||||
types_parcours = []
|
||||
if not isinstance(types_parcours, list):
|
||||
|
@ -256,6 +256,8 @@ def formation_import_xml(doc: str, import_tags=True):
|
||||
mod_info[1]["formation_id"] = formation_id
|
||||
mod_info[1]["matiere_id"] = mat_id
|
||||
mod_info[1]["ue_id"] = ue_id
|
||||
if not "module_type" in mod_info[1]:
|
||||
mod_info[1]["module_type"] = scu.ModuleType.STANDARD
|
||||
mod_id = sco_edit_module.do_module_create(mod_info[1])
|
||||
if xml_module_id:
|
||||
modules_old2new[int(xml_module_id)] = mod_id
|
||||
|
@ -262,7 +262,7 @@ def formsemestre_ext_edit_ue_validations(formsemestre_id, etudid):
|
||||
)
|
||||
|
||||
|
||||
def _make_page(etud, sem, tf, message=""):
|
||||
def _make_page(etud: dict, sem, tf, message="") -> list:
|
||||
formsemestre = FormSemestre.query.get_or_404(sem["formsemestre_id"])
|
||||
nt: NotesTableCompat = res_sem.load_formsemestre_results(formsemestre)
|
||||
moy_gen = nt.get_etud_moy_gen(etud["etudid"])
|
||||
@ -277,21 +277,20 @@ def _make_page(etud, sem, tf, message=""):
|
||||
</p>
|
||||
"""
|
||||
% etud,
|
||||
"""<p>La moyenne de ce semestre serait:
|
||||
<span class="ext_sem_moy"><span class="ext_sem_moy_val">%s</span> / 20</span>
|
||||
f"""<p>La moyenne de ce semestre serait:
|
||||
<span class="ext_sem_moy"><span class="ext_sem_moy_val">{moy_gen}</span> / 20</span>
|
||||
</p>
|
||||
"""
|
||||
% moy_gen,
|
||||
""",
|
||||
'<div id="formsemestre_ext_edit_ue_validations">',
|
||||
tf[1],
|
||||
"</div>",
|
||||
"""<div>
|
||||
<a class="stdlink"
|
||||
href="formsemestre_bulletinetud?formsemestre_id=%s&etudid=%s">
|
||||
retour au bulletin de notes
|
||||
</a></div>
|
||||
"""
|
||||
% (sem["formsemestre_id"], etud["etudid"]),
|
||||
f"""<div>
|
||||
<a class="stdlink"
|
||||
href="{url_for("notes.formsemestre_bulletinetud", scodoc_dept=g.scodoc_dept,
|
||||
formsemestre_id=formsemestre.id, etudid=etud['etudid']
|
||||
)}">retour au bulletin de notes</a>
|
||||
</div>
|
||||
""",
|
||||
html_sco_header.sco_footer(),
|
||||
]
|
||||
return H
|
||||
|
@ -43,13 +43,14 @@ from xml.etree.ElementTree import Element
|
||||
import flask
|
||||
from flask import g, request
|
||||
from flask import url_for, make_response
|
||||
from sqlalchemy.sql import text
|
||||
|
||||
from app import db
|
||||
from app.comp import res_sem
|
||||
from app.comp.res_compat import NotesTableCompat
|
||||
from app.models import FormSemestre, formsemestre
|
||||
from app.models import FormSemestre, Identite
|
||||
from app.models import GROUPNAME_STR_LEN, SHORT_STR_LEN
|
||||
from app.models.groups import Partition
|
||||
from app.models.groups import GroupDescr, Partition
|
||||
import app.scodoc.sco_utils as scu
|
||||
import app.scodoc.notesdb as ndb
|
||||
from app import log, cache
|
||||
@ -61,7 +62,6 @@ from app.scodoc import sco_etud
|
||||
from app.scodoc import sco_permissions_check
|
||||
from app.scodoc import sco_xml
|
||||
from app.scodoc.sco_exceptions import ScoException, AccessDenied, ScoValueError
|
||||
from app.scodoc.sco_permissions import Permission
|
||||
from app.scodoc.TrivialFormulator import TrivialFormulator
|
||||
|
||||
|
||||
@ -413,6 +413,34 @@ def formsemestre_get_etud_groupnames(formsemestre_id, attr="group_name"):
|
||||
return R
|
||||
|
||||
|
||||
def get_etud_formsemestre_groups(
|
||||
etud: Identite, formsemestre: FormSemestre, only_to_show=True
|
||||
) -> list[GroupDescr]:
|
||||
"""Liste les groupes auxquels est inscrit"""
|
||||
# Note: je n'ai pas réussi à cosntruire une requete SQLAlechemy avec
|
||||
# la Table d'association group_membership
|
||||
cursor = db.session.execute(
|
||||
text(
|
||||
"""
|
||||
SELECT g.id
|
||||
FROM group_descr g, group_membership gm, partition p
|
||||
WHERE gm.etudid = :etudid
|
||||
AND gm.group_id = g.id
|
||||
AND g.partition_id = p.id
|
||||
AND p.formsemestre_id = :formsemestre_id
|
||||
AND p.partition_name is not NULL
|
||||
"""
|
||||
+ (" and (p.show_in_lists is True) " if only_to_show else "")
|
||||
+ """
|
||||
ORDER BY p.numero
|
||||
"""
|
||||
),
|
||||
{"etudid": etud.id, "formsemestre_id": formsemestre.id},
|
||||
)
|
||||
return [GroupDescr.query.get(group_id) for group_id in cursor]
|
||||
|
||||
|
||||
# Ancienne fonction:
|
||||
def etud_add_group_infos(etud, formsemestre_id, sep=" ", only_to_show=False):
|
||||
"""Add informations on partitions and group memberships to etud
|
||||
(a dict with an etudid)
|
||||
@ -453,7 +481,7 @@ def etud_add_group_infos(etud, formsemestre_id, sep=" ", only_to_show=False):
|
||||
)
|
||||
etud["partitionsgroupes"] = sep.join(
|
||||
[
|
||||
gr["partition_name"] + ":" + gr["group_name"]
|
||||
(gr["partition_name"] or "") + ":" + gr["group_name"]
|
||||
for gr in infos
|
||||
if gr["group_name"] is not None
|
||||
]
|
||||
|
@ -50,10 +50,10 @@ _SCO_PERMISSIONS = (
|
||||
(1 << 27, "RelationsEntreprisesCorrespondants", "Voir les correspondants"),
|
||||
# 27 à 39 ... réservé pour "entreprises"
|
||||
# Api scodoc9
|
||||
(1 << 40, "APIView", "Voir"),
|
||||
(1 << 41, "APIEtudChangeGroups", "Modifier les groupes"),
|
||||
(1 << 42, "APIEditAllNotes", "Modifier toutes les notes"),
|
||||
(1 << 43, "APIAbsChange", "Saisir des absences"),
|
||||
(1 << 40, "APIView", "API: Lecture"),
|
||||
(1 << 41, "APIEtudChangeGroups", "API: Modifier les groupes"),
|
||||
(1 << 42, "APIEditAllNotes", "API: Modifier toutes les notes"),
|
||||
(1 << 43, "APIAbsChange", "API: Saisir des absences"),
|
||||
)
|
||||
|
||||
|
||||
|
@ -32,7 +32,7 @@ import time
|
||||
from xml.etree import ElementTree
|
||||
|
||||
from flask import g, request
|
||||
from flask import url_for
|
||||
from flask import abort, url_for
|
||||
|
||||
from app import log
|
||||
from app.but import bulletin_but
|
||||
@ -83,9 +83,11 @@ def formsemestre_recapcomplet(
|
||||
force_publishing: publie les xml et json même si bulletins non publiés
|
||||
selected_etudid: etudid sélectionné (pour scroller au bon endroit)
|
||||
"""
|
||||
if not isinstance(formsemestre_id, int):
|
||||
abort(404)
|
||||
formsemestre = FormSemestre.query.get_or_404(formsemestre_id)
|
||||
file_formats = {"csv", "json", "xls", "xlsx", "xlsall", "xml"}
|
||||
supported_formats = file_formats | {"html"}
|
||||
supported_formats = file_formats | {"html", "evals"}
|
||||
if tabformat not in supported_formats:
|
||||
raise ScoValueError(f"Format non supporté: {tabformat}")
|
||||
is_file = tabformat in file_formats
|
||||
@ -131,7 +133,8 @@ def formsemestre_recapcomplet(
|
||||
for (format, label) in (
|
||||
("html", "Tableau"),
|
||||
("evals", "Avec toutes les évaluations"),
|
||||
("xlsx", "Excel non formatté"),
|
||||
("xlsx", "Excel (non formaté)"),
|
||||
("xlsall", "Excel avec évaluations"),
|
||||
("xml", "Bulletins XML (obsolète)"),
|
||||
("json", "Bulletins JSON"),
|
||||
):
|
||||
|
@ -191,7 +191,7 @@ def fmt_note(val, note_max=None, keep_numeric=False):
|
||||
return "EXC" # excuse, note neutralise
|
||||
if val == NOTES_ATTENTE:
|
||||
return "ATT" # attente, note neutralisee
|
||||
if isinstance(val, float) or isinstance(val, int):
|
||||
if not isinstance(val, str):
|
||||
if np.isnan(val):
|
||||
return "~"
|
||||
if (note_max is not None) and note_max > 0:
|
||||
|
@ -100,7 +100,7 @@ $(function () {
|
||||
},
|
||||
{
|
||||
// Elimine les 0 à gauche pour les exports excel et les "copy"
|
||||
targets: ["col_mod", "col_moy_gen", "col_ue", "col_res", "col_sae"],
|
||||
targets: ["col_mod", "col_moy_gen", "col_ue", "col_res", "col_sae", "evaluation"],
|
||||
render: function (data, type, row) {
|
||||
return type === 'export' ? data.replace(/0(\d\..*)/, '$1') : data;
|
||||
}
|
||||
|
@ -292,7 +292,7 @@ def formsemestre_bulletinetud(
|
||||
format = format or "html"
|
||||
|
||||
if not isinstance(formsemestre_id, int):
|
||||
raise ValueError("formsemestre_id must be an integer !")
|
||||
abort(404, description="formsemestre_id must be an integer !")
|
||||
formsemestre = FormSemestre.query.get_or_404(formsemestre_id)
|
||||
if etudid:
|
||||
etud = models.Identite.query.get_or_404(etudid)
|
||||
@ -662,17 +662,6 @@ def formation_export(formation_id, export_ids=False, format=None):
|
||||
)
|
||||
|
||||
|
||||
@bp.route("/formation_import_xml")
|
||||
@scodoc
|
||||
@permission_required(Permission.ScoChangeFormation)
|
||||
@scodoc7func
|
||||
def formation_import_xml(file):
|
||||
"import d'une formation en XML"
|
||||
log("formation_import_xml")
|
||||
doc = file.read()
|
||||
return sco_formations.formation_import_xml(doc)
|
||||
|
||||
|
||||
@bp.route("/formation_import_xml_form", methods=["GET", "POST"])
|
||||
@scodoc
|
||||
@permission_required(Permission.ScoChangeFormation)
|
||||
|
@ -1,7 +1,7 @@
|
||||
# -*- mode: python -*-
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
SCOVERSION = "9.2.18"
|
||||
SCOVERSION = "9.2.22"
|
||||
|
||||
SCONAME = "ScoDoc"
|
||||
|
||||
|
@ -26,13 +26,17 @@ import urllib3
|
||||
from pprint import pprint as pp
|
||||
|
||||
# --- Lecture configuration (variables d'env ou .env)
|
||||
BASEDIR = os.path.abspath(os.path.dirname(__file__))
|
||||
try:
|
||||
BASEDIR = os.path.abspath(os.path.dirname(__file__))
|
||||
except NameError:
|
||||
BASEDIR = "."
|
||||
|
||||
load_dotenv(os.path.join(BASEDIR, ".env"))
|
||||
CHK_CERT = bool(int(os.environ.get("CHECK_CERTIFICATE", False)))
|
||||
SCODOC_URL = os.environ["SCODOC_URL"]
|
||||
SCODOC_URL = os.environ["SCODOC_URL"] or "http://localhost:5000"
|
||||
API_URL = SCODOC_URL + "/ScoDoc/api"
|
||||
SCODOC_USER = os.environ["SCODOC_USER"]
|
||||
SCODOC_PASSWORD = os.environ["SCODOC_PASSWD"]
|
||||
SCODOC_PASSWORD = os.environ["SCODOC_PASSWORD"]
|
||||
print(f"SCODOC_URL={SCODOC_URL}")
|
||||
print(f"API URL={API_URL}")
|
||||
|
||||
@ -90,6 +94,25 @@ formsemestre_id = 1028 # A adapter
|
||||
etudid = 14721
|
||||
bul_dut = GET(f"/etudiant/etudid/{etudid}/formsemestre/{formsemestre_id}/bulletin")
|
||||
|
||||
|
||||
# Infos sur un étudiant
|
||||
etudid = 3561
|
||||
code_nip = "11303314"
|
||||
etud = GET(f"/etudiant/etudid/{etudid}")
|
||||
print(etud)
|
||||
|
||||
etud = GET(f"/etudiant/nip/{code_nip}")
|
||||
print(etud)
|
||||
|
||||
sems = GET(f"/etudiant/etudid/{etudid}/formsemestres")
|
||||
print("\n".join([s["titre_num"] for s in sems]))
|
||||
|
||||
sems = GET(f"/etudiant/nip/{code_nip}/formsemestres")
|
||||
print("\n".join([s["titre_num"] for s in sems]))
|
||||
|
||||
# Evaluation
|
||||
evals = GET("/evaluations/1")
|
||||
|
||||
# # --- Recupere la liste de tous les semestres:
|
||||
# sems = GET(s, "Notes/formsemestre_list?format=json", "Aucun semestre !")
|
||||
|
||||
|
@ -25,6 +25,7 @@ SCODOC_URL = os.environ["SCODOC_URL"]
|
||||
API_URL = SCODOC_URL + "/ScoDoc/api"
|
||||
API_USER = os.environ.get("API_USER", "test")
|
||||
API_PASSWORD = os.environ.get("API_PASSWD", "test")
|
||||
DEPT_ACRONYM = "TAPI"
|
||||
print(f"SCODOC_URL={SCODOC_URL}")
|
||||
print(f"API URL={API_URL}")
|
||||
|
||||
|
@ -22,8 +22,7 @@ from tests.api.setup_test_api import API_URL, CHECK_CERTIFICATE, api_headers
|
||||
|
||||
# Etudiant pour les tests
|
||||
ETUDID = 1
|
||||
INE = "1"
|
||||
NIP = "1"
|
||||
|
||||
|
||||
# absences
|
||||
def test_absences(api_headers):
|
||||
@ -37,20 +36,6 @@ def test_absences(api_headers):
|
||||
)
|
||||
assert r.status_code == 200
|
||||
|
||||
r = requests.get(
|
||||
f"{API_URL}/absences/nip/{NIP}",
|
||||
headers=api_headers,
|
||||
verify=CHECK_CERTIFICATE,
|
||||
)
|
||||
assert r.status_code == 200
|
||||
|
||||
r = requests.get(
|
||||
f"{API_URL}/absences/ine/{INE}",
|
||||
headers=api_headers,
|
||||
verify=CHECK_CERTIFICATE,
|
||||
)
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
# absences_justify
|
||||
def test_absences_justify(api_headers):
|
||||
@ -65,22 +50,6 @@ def test_absences_justify(api_headers):
|
||||
assert r.status_code == 200
|
||||
# TODO vérifier résultat
|
||||
|
||||
r = requests.get(
|
||||
API_URL + f"/absences/nip/{NIP}/just",
|
||||
headers=api_headers,
|
||||
verify=CHECK_CERTIFICATE,
|
||||
)
|
||||
assert r.status_code == 200
|
||||
# TODO vérifier résultat
|
||||
|
||||
r = requests.get(
|
||||
API_URL + f"/absences/ine/{INE}/just",
|
||||
headers=api_headers,
|
||||
verify=CHECK_CERTIFICATE,
|
||||
)
|
||||
assert r.status_code == 200
|
||||
# TODO vérifier résultat
|
||||
|
||||
|
||||
# XXX TODO
|
||||
# def test_abs_groupe_etat(api_headers):
|
||||
|
@ -19,7 +19,12 @@ Utilisation :
|
||||
|
||||
import requests
|
||||
|
||||
from tests.api.setup_test_api import API_URL, CHECK_CERTIFICATE, api_headers
|
||||
from tests.api.setup_test_api import (
|
||||
API_URL,
|
||||
CHECK_CERTIFICATE,
|
||||
DEPT_ACRONYM,
|
||||
api_headers,
|
||||
)
|
||||
from tests.api.tools_test_api import verify_fields
|
||||
|
||||
DEPARTEMENT_FIELDS = [
|
||||
@ -86,7 +91,7 @@ def test_list_etudiants(api_headers):
|
||||
fields = {"id", "nip", "ine", "nom", "nom_usuel", "prenom", "civilite"}
|
||||
|
||||
r = requests.get(
|
||||
API_URL + "/departement/TAPI/etudiants",
|
||||
f"{API_URL}/departement/{DEPT_ACRONYM}/etudiants",
|
||||
headers=api_headers,
|
||||
verify=CHECK_CERTIFICATE,
|
||||
)
|
||||
|
@ -19,7 +19,12 @@ Utilisation :
|
||||
|
||||
import requests
|
||||
|
||||
from tests.api.setup_test_api import API_URL, CHECK_CERTIFICATE, api_headers
|
||||
from tests.api.setup_test_api import (
|
||||
API_URL,
|
||||
CHECK_CERTIFICATE,
|
||||
DEPT_ACRONYM,
|
||||
api_headers,
|
||||
)
|
||||
from tests.api.tools_test_api import verify_fields
|
||||
from tests.api.tools_test_api import ETUD_FIELDS, FSEM_FIELDS
|
||||
|
||||
@ -83,7 +88,7 @@ def test_etudiant(api_headers):
|
||||
etud = r.json()
|
||||
fields_ok = verify_fields(etud, ETUD_FIELDS)
|
||||
assert fields_ok is True
|
||||
|
||||
assert etud["dept_acronym"] == DEPT_ACRONYM
|
||||
######### Test code ine #########
|
||||
|
||||
r = requests.get(
|
||||
@ -93,7 +98,7 @@ def test_etudiant(api_headers):
|
||||
)
|
||||
assert r.status_code == 200
|
||||
etud = r.json()
|
||||
assert len(etud) == 24
|
||||
assert len(etud) == 25
|
||||
fields_ok = verify_fields(etud, ETUD_FIELDS)
|
||||
assert fields_ok is True
|
||||
|
||||
|
@ -24,6 +24,11 @@ from tests.api.setup_test_api import API_URL, CHECK_CERTIFICATE, api_headers
|
||||
from tests.api.tools_test_api import MODIMPL_FIELDS, verify_fields
|
||||
from tests.api.tools_test_api import FSEM_FIELDS, UE_FIELDS, MODULE_FIELDS
|
||||
|
||||
# Etudiant pour les tests
|
||||
ETUDID = 1
|
||||
NIP = "1"
|
||||
INE = "INE1"
|
||||
|
||||
|
||||
def test_formsemestre(api_headers):
|
||||
"""
|
||||
@ -53,7 +58,7 @@ def test_etudiant_bulletin(api_headers):
|
||||
bull_a = r.json()
|
||||
|
||||
r = requests.get(
|
||||
f"{API_URL}/etudiant/nip/1/formsemestre/{formsemestre_id}/bulletin",
|
||||
f"{API_URL}/etudiant/nip/{NIP}/formsemestre/{formsemestre_id}/bulletin",
|
||||
headers=api_headers,
|
||||
verify=CHECK_CERTIFICATE,
|
||||
)
|
||||
@ -61,7 +66,7 @@ def test_etudiant_bulletin(api_headers):
|
||||
bull_b = r.json()
|
||||
|
||||
r = requests.get(
|
||||
f"{API_URL}/etudiant/ine/1/formsemestre/{formsemestre_id}/bulletin",
|
||||
f"{API_URL}/etudiant/ine/{INE}/formsemestre/{formsemestre_id}/bulletin",
|
||||
headers=api_headers,
|
||||
verify=CHECK_CERTIFICATE,
|
||||
)
|
||||
|
@ -21,6 +21,8 @@ ETUD_FIELDS = {
|
||||
"code_nip",
|
||||
"codepostaldomicile",
|
||||
"date_naissance",
|
||||
"dept_acronym",
|
||||
"dept_id",
|
||||
"dept_naissance",
|
||||
"description",
|
||||
"domicile",
|
||||
|
Loading…
Reference in New Issue
Block a user