prise en compte des remarques du 21/04/2022

This commit is contained in:
leonard_montalbano 2022-04-25 15:25:45 +02:00
parent b383c378f6
commit fd597b87d4
11 changed files with 414 additions and 325 deletions

View File

@ -5,11 +5,16 @@ from flask import jsonify
from app import models
from app.api import bp
from app.api.auth import token_auth
from app.api.errors import error_response
from app.decorators import permission_required
from app.api.auth import token_auth, token_permission_required
from app.scodoc.sco_abs import add_absence, add_justif, annule_absence, annule_justif, list_abs_date
from app.api.auth import token_permission_required
from app.api.tools import get_etu_from_request
from app.scodoc.sco_abs import (
add_absence,
add_justif,
annule_absence,
annule_justif,
list_abs_date,
)
from app.scodoc.sco_groups import get_group_members
from app.scodoc.sco_permissions import Permission
@ -17,7 +22,6 @@ from app.scodoc.sco_permissions import Permission
@bp.route("/absences/etudid/<int:etudid>", methods=["GET"])
@bp.route("/absences/nip/<int:nip>", methods=["GET"])
@bp.route("/absences/ine/<int:ine>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def absences(etudid: int = None, nip: int = None, ine: int = None):
"""
@ -27,35 +31,34 @@ def absences(etudid: int = None, nip: int = None, ine: int = None):
nip: le code nip d'un étudiant
ine : le code ine d'un étudiant
"""
abs = None
if etudid is not None: # Si route etudid
# Récupération des absences de l'étudiant
abs = models.Absence.query.filter_by(etudid=etudid).all()
else:
if nip is not None: # Si route nip
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_nip=nip).first()
# Récupération des absences de l'étudiant
abs = models.Absence.query.filter_by(etudid=etu.etudid).all()
if etudid is None:
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
if ine is not None: # Si route ine
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_ine=ine).first()
# Récupération des absences de l'étudiant
abs = models.Absence.query.filter_by(etudid=etu.etudid).all()
# Récupération des absences de l'étudiant
abs = models.Absence.query.filter_by(etudid=etudid).all()
if abs is not None: # Si des absences ont bien été trouvé
# Si l'étudiant a au minimum une absence
if len(abs) > 0:
# Mise en forme des données
data = [d.to_dict() for d in abs]
return jsonify(data)
return error_response(501, message="Not implemented")
return error_response(200, message="Aucune absence trouvé pour cet étudiant")
@bp.route("/absences/etudid/<int:etudid>/abs_just_only", methods=["GET"])
@bp.route("/absences/nip/<int:nip>/abs_just_only", methods=["GET"])
@bp.route("/absences/ine/<int:ine>/abs_just_only", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def absences_justify(etudid: int = None, nip: int = None, ine: int = None):
"""
@ -65,43 +68,65 @@ def absences_justify(etudid: int = None, nip: int = None, ine: int = None):
nip: le code nip d'un étudiant
ine : le code ine d'un étudiant
"""
abs = None
if etudid is not None: # Si route etudid
# Récupération des absences justifiées de l'étudiant
abs = models.Absence.query.filter_by(etudid=etudid, estjust=True).all()
else:
if nip is not None: # Si route nip
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_nip=nip).first()
# Récupération des absences justifiées de l'étudiant
abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all()
if etudid is None:
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
if ine is not None: # Si route ine
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_ine=ine).first()
# Récupération des absences justifiées de l'étudiant
abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all()
# Récupération des absences justifiées de l'étudiant
abs = models.Absence.query.filter_by(etudid=etudid, estjust=True).all()
if abs is not None: # Si des absences ont bien été trouvé
# Si l'étudiant a au minimum une absence justifiées
if len(abs) > 0:
# Mise en forme des données
data = [d.to_dict() for d in abs]
return jsonify(data)
return error_response(501, message="Not implemented")
return error_response(
200, message="Aucune absence justifié trouvé pour cet étudiant"
)
@bp.route("/absences/abs_signale?etudid=<int:etudid>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>", methods=["POST"])
@bp.route("/absences/abs_signale?nip=<int:nip>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>", methods=["POST"])
@bp.route("/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>", methods=["POST"])
@bp.route("/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>&moduleimpl_id=<int:moduleimpl_id>", methods=["POST"])
@token_auth.login_required
### Inutil en définitif ###
@bp.route(
"/absences/abs_signale?etudid=<int:etudid>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>",
methods=["POST"],
)
@bp.route(
"/absences/abs_signale?nip=<int:nip>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>",
methods=["POST"],
)
@bp.route(
"/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>",
methods=["POST"],
)
@bp.route(
"/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>&moduleimpl_id=<int:moduleimpl_id>",
methods=["POST"],
)
@token_permission_required(Permission.APIAbsChange)
def abs_signale(date: datetime, matin: bool, justif: bool, etudid: int = None, nip: int = None, ine: int = None,
description: str = None, moduleimpl_id: int = None):
def abs_signale(
date: datetime,
matin: bool,
justif: bool,
etudid: int = None,
nip: int = None,
ine: int = None, ### Inutil en définitif
description: str = None,
moduleimpl_id: int = None,
):
"""
Permet d'ajouter une absence en base
@ -116,114 +141,45 @@ def abs_signale(date: datetime, matin: bool, justif: bool, etudid: int = None, n
"""
# Fonctions utilisées : app.scodoc.sco_abs.add_absence() et app.scodoc.sco_abs.add_justif()
if description is not None: # Si la description a été renseignée
if moduleimpl_id is not None: # Si le moduleimpl a été renseigné
if etudid is not None: # Si route etudid
try:
# Utilisation de la fonction add_absence
add_absence(etudid, date, matin, justif, description, moduleimpl_id)
# Utilisation de la fonction add_justif
add_justif(etudid, date, matin, description)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
if nip is not None: # Si route nip
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_nip=nip).first()
try:
# Utilisation de la fonction add_absence
add_absence(etu.etudid, date, matin, justif, description, moduleimpl_id)
# Utilisation de la fonction add_justif
add_justif(etu.etudid, date, matin, description)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
if ine is not None: # Si route ine
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_ine=ine).first()
try:
# Utilisation de la fonction add_absence
add_absence(etu.etudid, date, matin, justif, description, moduleimpl_id)
# Utilisation de la fonction add_justif
add_justif(etu.etudid, date, matin, description)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
return error_response(409, message="La requête ne peut être traitée en létat actuel")
else: # Si le moduleimpl n'a pas été renseigné
if etudid is not None: # Si route etudid
try:
# Utilisation de la fonction add_absence
add_absence(etudid, date, matin, justif, description)
# Utilisation de la fonction add_justif
add_justif(etudid, date, matin, description)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
if nip is not None: # Si route nip
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_nip=nip).first()
try:
# Utilisation de la fonction add_absence
add_absence(etu.etudid, date, matin, justif, description)
# Utilisation de la fonction add_justif
add_justif(etu.etudid, date, matin, description)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
if ine is not None: # Si route ine
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_ine=ine).first()
try:
# Utilisation de la fonction add_absence
add_absence(etu.etudid, date, matin, justif, description)
# Utilisation de la fonction add_justif
add_justif(etu.etudid, date, matin, description)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
return error_response(409, message="La requête ne peut être traitée en létat actuel")
else:
if etudid is not None: # Si route etudid
try:
# Utilisation de la fonction add_absence
add_absence(etudid, date, matin, justif)
# Utilisation de la fonction add_justif
add_justif(etudid, date, matin)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
if nip is not None: # Si route nip
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_nip=nip).first()
try:
# Utilisation de la fonction add_absence
add_absence(etu.etudid, date, matin, justif)
# Utilisation de la fonction add_justif
add_justif(etu.etudid, date, matin)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
if ine is not None: # Si route ine
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_ine=ine).first()
try:
# Utilisation de la fonction add_absence
add_absence(etu.etudid, date, matin, justif)
# Utilisation de la fonction add_justif
add_justif(etu.etudid, date, matin)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
return error_response(200, message="OK")
if etudid is None:
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
try:
# Utilisation de la fonction add_absence
add_absence(etudid, date, matin, justif, description, moduleimpl_id)
if justif == True:
# Utilisation de la fonction add_justif
add_justif(etudid, date, matin, description)
except ValueError:
return error_response(
409, message="La requête ne peut être traitée en létat actuel"
)
@bp.route("/absences/abs_annule?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
@bp.route("/absences/abs_annule?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
@bp.route("/absences/abs_annule?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
@token_auth.login_required
@bp.route(
"/absences/abs_annule?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>",
methods=["POST"],
)
@bp.route(
"/absences/abs_annule?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>",
methods=["POST"],
)
@bp.route(
"/absences/abs_annule?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>",
methods=["POST"],
)
@token_permission_required(Permission.APIAbsChange)
def abs_annule(jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None):
def abs_annule(
jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None
):
"""
Retourne un html
@ -236,32 +192,46 @@ def abs_annule(jour: datetime, matin: str, etudid: int = None, nip: int = None,
# Fonction utilisée : app.scodoc.sco_abs.annule_absence()
if etudid is None:
if nip is not None: # Si route nip
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_nip=nip).first()
# Récupération de l'etudid de l'étudiant
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
if ine is not None: # Si route ine
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_ine=ine).first()
# Récupération de l'etudid de l'étudiant
etudid = etu.etudid
try:
# Utilisation de la fonction annule_absence
annule_absence(etudid, jour, matin)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que le 'jour' et le 'matin' sont valides",
)
return error_response(200, message="OK")
@bp.route("/absences/abs_annule_justif?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
@bp.route("/absences/abs_annule_justif?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
@bp.route("/absences/abs_annule_justif?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>", methods=["POST"])
@token_auth.login_required
@bp.route(
"/absences/abs_annule_justif?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>",
methods=["POST"],
)
@bp.route(
"/absences/abs_annule_justif?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>",
methods=["POST"],
)
@bp.route(
"/absences/abs_annule_justif?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>",
methods=["POST"],
)
@token_permission_required(Permission.APIAbsChange)
def abs_annule_justif(jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None):
def abs_annule_justif(
jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None
):
"""
Retourne un html
@ -274,30 +244,37 @@ def abs_annule_justif(jour: datetime, matin: str, etudid: int = None, nip: int =
# Fonction utilisée : app.scodoc.sco_abs.annule_justif()
if etudid is None:
if nip is not None: # Si route nip
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_nip=nip).first()
# Récupération de l'etudid de l'étudiant
etudid = etu.etudid
if ine is not None: # Si route ine
# Récupération de l'étudiant
etu = models.Identite.query.filter_by(code_ine=ine).first()
# Récupération de l'etudid de l'étudiant
# Récupération de l'étudiant
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
try:
# Utilisation de la fonction annule_justif
annule_justif(etudid, jour, matin)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que le 'jour' et le 'matin' sont valides",
)
return error_response(200, message="OK")
@bp.route("/absences/abs_group_etat/?group_id=<int:group_id>&date_debut=date_debut&date_fin=date_fin", methods=["GET"])
@token_auth.login_required
@bp.route(
"/absences/abs_group_etat/?group_id=<int:group_id>&date_debut=date_debut&date_fin=date_fin",
methods=["GET"],
)
@token_permission_required(Permission.APIView)
def abs_groupe_etat(group_id: int, date_debut, date_fin, with_boursier=True, format="html"):
def abs_groupe_etat(
group_id: int, date_debut, date_fin, with_boursier=True, format="html"
):
"""
Retoune la liste des absences d'un ou plusieurs groupes entre deux dates
"""
@ -307,7 +284,9 @@ def abs_groupe_etat(group_id: int, date_debut, date_fin, with_boursier=True, for
# Utilisation de la fonction get_group_members
members = get_group_members(group_id)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
return error_response(
409, message="La requête ne peut être traitée en létat actuel"
)
data = []
# Filtre entre les deux dates renseignées

View File

@ -1,6 +1,5 @@
############################################### Departements ##########################################################
import app
from flask import jsonify
from app import models
from app.api import bp
@ -8,9 +7,10 @@ from app.api.auth import token_auth, token_permission_required
from app.api.errors import error_response
from app.scodoc.sco_permissions import Permission
from flask import jsonify
@bp.route("/departements", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def departements():
"""
@ -31,7 +31,6 @@ def departements():
@bp.route(
"/departements/<string:dept>/etudiants/liste/<int:formsemestre_id>", methods=["GET"]
)
@token_auth.login_required
@token_permission_required(Permission.APIView)
def liste_etudiants(dept: str, formsemestre_id=None):
"""
@ -87,7 +86,6 @@ def liste_etudiants(dept: str, formsemestre_id=None):
@bp.route("/departements/<string:dept>/semestres_courants", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def liste_semestres_courant(dept: str):
"""
@ -150,7 +148,6 @@ def liste_semestres_courant(dept: str):
"/departements/<string:dept>/formations/<int:formation_id>/referentiel_competences",
methods=["GET"],
)
@token_auth.login_required
@token_permission_required(Permission.APIView)
def referenciel_competences(dept: str, formation_id: int):
"""
@ -185,7 +182,6 @@ def referenciel_competences(dept: str, formation_id: int):
"/departements/<string:dept>/formsemestre/<string:formsemestre_id>/programme",
methods=["GET"],
)
@token_auth.login_required
@token_permission_required(Permission.APIView)
def semestre_index(dept: str, formsemestre_id: int):
"""
@ -222,4 +218,4 @@ def semestre_index(dept: str, formsemestre_id: int):
}
return data
#return error_response(501, message="not implemented")
# return error_response(501, message="not implemented")

View File

@ -13,9 +13,7 @@ from app.scodoc.sco_groups import get_etud_groups
from app.scodoc.sco_permissions import Permission
@bp.route("/etudiants", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def etudiants():
"""
@ -56,7 +54,6 @@ def etudiants():
@bp.route("/etudiants/courant", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def etudiants_courant():
"""
@ -102,7 +99,6 @@ def etudiants_courant():
@bp.route("/etudiant/etudid/<int:etudid>", methods=["GET"])
@bp.route("/etudiant/nip/<int:nip>", methods=["GET"])
@bp.route("/etudiant/ine/<int:ine>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def etudiant(etudid: int = None, nip: int = None, ine: int = None):
"""
@ -137,7 +133,6 @@ def etudiant(etudid: int = None, nip: int = None, ine: int = None):
@bp.route("/etudiant/etudid/<int:etudid>/formsemestres")
@bp.route("/etudiant/nip/<int:nip>/formsemestres")
@bp.route("/etudiant/ine/<int:ine>/formsemestres")
@token_auth.login_required
@token_permission_required(Permission.APIView)
def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None):
"""
@ -182,39 +177,46 @@ def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None)
...
]
"""
# Récupération de toutes les inscriptions
inscriptions = models.FormSemestreInscription.query.all()
# Récupération de l'étudiant
etu = get_etu_from_request(etudid, nip, ine)
sems = []
# Filtre les inscriptions contenant l'étudiant
for sem in inscriptions:
if sem.etudid == etu.etudid:
sems.append(sem)
# Récupération de toutes les inscriptions de l'étudiant
formsemestres_inscriptions = models.FormSemestreInscription.query.filter_by(
etud=etu
).all()
formsemestres = []
# Filtre les formsemestre contenant les inscriptions de l'étudiant
for sem in sems: #data_inscriptions:
res = models.FormSemestre.query.filter_by(id=sem.formsemestre_id).first()
# Récupération des formsemestres contenant les inscriptions de l'étudiant
for formsemestre_inscription in formsemestres_inscriptions:
res = models.FormSemestre.query.filter_by(
id=formsemestre_inscription.formsemestre_id
).first()
formsemestres.append(res)
data = []
# Mise en forme des données
for formsem in formsemestres:
data.append(formsem.to_dict())
for formsemestre in formsemestres:
data.append(formsemestre.to_dict())
return jsonify(data)
@bp.route("/etudiant/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"])
@bp.route("/etudiant/nip/<int:nip>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"])
@bp.route("/etudiant/ine/<int:ine>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"])
@token_auth.login_required
@bp.route(
"/etudiant/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/bulletin",
methods=["GET"],
)
@bp.route(
"/etudiant/nip/<int:nip>/formsemestre/<int:formsemestre_id>/bulletin",
methods=["GET"],
)
@bp.route(
"/etudiant/ine/<int:ine>/formsemestre/<int:formsemestre_id>/bulletin",
methods=["GET"],
)
@token_permission_required(Permission.APIView)
def etudiant_bulletin_semestre(formsemestre_id, etudid: int = None, nip: int = None, ine: int = None):
def etudiant_bulletin_semestre(
formsemestre_id, etudid: int = None, nip: int = None, ine: int = None
):
"""
Retourne le bulletin d'un étudiant en fonction de son id et d'un semestre donné
@ -223,7 +225,7 @@ def etudiant_bulletin_semestre(formsemestre_id, etudid: int = None, nip: int = N
nip : le code nip d'un étudiant
ine : le code ine d'un étudiant
"""
# Fonction utilisée : app.scodoc.sco_bulletins_json.make_json_formsemestre_bulletinetud()
# Fonction utilisée : app.scodoc.sco_bulletins_json.make_json_formsemestre_bulletinetud()
formsemestre = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
@ -233,18 +235,33 @@ def etudiant_bulletin_semestre(formsemestre_id, etudid: int = None, nip: int = N
if etudid is None:
# Récupération de l'étudiant
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
return make_json_formsemestre_bulletinetud(formsemestre_id, etudid)
@bp.route("/etudiant/etudid/<int:etudid>/semestre/<int:formsemestre_id>/groups", methods=["GET"])
@bp.route("/etudiant/nip/<int:nip>/semestre/<int:formsemestre_id>/groups", methods=["GET"])
@bp.route("/etudiant/ine/<int:ine>/semestre/<int:formsemestre_id>/groups", methods=["GET"])
@token_auth.login_required
@bp.route(
"/etudiant/etudid/<int:etudid>/semestre/<int:formsemestre_id>/groups",
methods=["GET"],
)
@bp.route(
"/etudiant/nip/<int:nip>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
)
@bp.route(
"/etudiant/ine/<int:ine>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
)
@token_permission_required(Permission.APIView)
def etudiant_groups(formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None):
def etudiant_groups(
formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None
):
"""
Retourne la liste des groupes auxquels appartient l'étudiant dans le semestre indiqué
@ -283,16 +300,27 @@ def etudiant_groups(formsemestre_id: int, etudid: int = None, nip: int = None, i
if etudid is None:
# Récupération de l'étudiant
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
# Récupération du formsemestre
sem = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
#breakpoint()
try:
# Utilisation de la fonction get_etud_groups
data = get_etud_groups(etudid, sem.id)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide"
" et le formsemestre_id sont valides",
)
return jsonify(data)

View File

@ -3,14 +3,13 @@ from flask import jsonify
from app import models
from app.api import bp
from app.api.auth import token_auth, token_permission_required
from app.api.auth import token_permission_required
from app.api.errors import error_response
from app.scodoc.sco_evaluation_db import do_evaluation_get_all_notes
from app.scodoc.sco_permissions import Permission
@bp.route("/evaluations/<int:moduleimpl_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def evaluations(moduleimpl_id: int):
"""
@ -29,7 +28,6 @@ def evaluations(moduleimpl_id: int):
@bp.route("/evaluations/eval_notes/<int:evaluation_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def evaluation_notes(evaluation_id: int):
"""
@ -42,18 +40,32 @@ def evaluation_notes(evaluation_id: int):
try:
# Utilisation de la fonction do_evaluation_get_all_notes
data = do_evaluation_get_all_notes(evaluation_id)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel. \n"
"Veillez vérifier la conformité du 'evaluation_id'",
)
return jsonify(data)
@bp.route("/evaluations/eval_set_notes?eval_id=<int:eval_id>&etudid=<int:etudid>&note=<float:note>", methods=["POST"])
@bp.route("/evaluations/eval_set_notes?eval_id=<int:eval_id>&nip=<int:nip>&note=<float:note>", methods=["POST"])
@bp.route("/evaluations/eval_set_notes?eval_id=<int:eval_id>&ine=<int:ine>&note=<float:note>", methods=["POST"])
@token_auth.login_required
@bp.route(
"/evaluations/eval_set_notes?eval_id=<int:eval_id>&etudid=<int:etudid>&note=<float:note>",
methods=["POST"],
)
@bp.route(
"/evaluations/eval_set_notes?eval_id=<int:eval_id>&nip=<int:nip>&note=<float:note>",
methods=["POST"],
)
@bp.route(
"/evaluations/eval_set_notes?eval_id=<int:eval_id>&ine=<int:ine>&note=<float:note>",
methods=["POST"],
)
@token_permission_required(Permission.APIEditAllNotes)
def evaluation_set_notes(eval_id: int, note: float, etudid: int = None, nip: int = None, ine: int = None):
def evaluation_set_notes(
eval_id: int, note: float, etudid: int = None, nip: int = None, ine: int = None
):
"""
Set les notes d'une évaluation pour un étudiant donnée

View File

@ -5,14 +5,12 @@ 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.decorators import permission_required
from app.scodoc.sco_formations import formation_export
from app.scodoc.sco_moduleimpl import moduleimpl_list
from app.scodoc.sco_permissions import Permission
@bp.route("/formations", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def formations():
"""
@ -28,7 +26,6 @@ def formations():
@bp.route("/formations/<int:formation_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def formations_by_id(formation_id: int):
"""
@ -46,7 +43,6 @@ def formations_by_id(formation_id: int):
@bp.route("/formations/formation_export/<int:formation_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def formation_export_by_formation_id(formation_id: int, export_ids=False):
"""
@ -58,13 +54,16 @@ def formation_export_by_formation_id(formation_id: int, export_ids=False):
# Utilisation de la fonction formation_export
data = formation_export(formation_id)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
return error_response(
409,
message="La requête ne peut être traitée en létat actuel. \n"
"Veillez vérifier la conformité du 'formation_id'",
)
return jsonify(data)
@bp.route("/formations/apo/<string:etape_apo>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def formsemestre_apo(etape_apo: int):
"""
@ -86,7 +85,6 @@ def formsemestre_apo(etape_apo: int):
@bp.route("/formations/moduleimpl/<int:moduleimpl_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def moduleimpls(moduleimpl_id: int):
"""
@ -103,8 +101,10 @@ def moduleimpls(moduleimpl_id: int):
return jsonify(data)
@bp.route("/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>", methods=["GET"])
@token_auth.login_required
@bp.route(
"/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>",
methods=["GET"],
)
@token_permission_required(Permission.APIView)
def moduleimpls_sem(moduleimpl_id: int, formsemestre_id: int):
"""
@ -115,10 +115,15 @@ def moduleimpls_sem(moduleimpl_id: int, formsemestre_id: int):
"""
# Fonction utilisée : app.scodoc.sco_moduleimpl.moduleimpl_list()
try:
# Utilisation de la fonction moduleimpl_list
data = moduleimpl_list(moduleimpl_id, formsemestre_id)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
# Utilisation de la fonction moduleimpl_list
data = moduleimpl_list(moduleimpl_id, formsemestre_id)
if len(data) == 0:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel. \n"
"Aucun moduleimpl ne correspond au 'moduleimpl_id' ou "
"'formsemestre_id' renseigné",
)
return jsonify(data)

View File

@ -10,11 +10,13 @@ from app.api.tools import get_etu_from_request
from app.scodoc.sco_bulletins_json import make_json_formsemestre_bulletinetud
from app.scodoc.sco_permissions import Permission
from app.scodoc.sco_pvjury import formsemestre_pvjury
from app.scodoc.sco_recapcomplet import formsemestre_recapcomplet
from app.scodoc.sco_recapcomplet import (
formsemestre_recapcomplet,
gen_formsemestre_recapcomplet_json,
)
@bp.route("/formations/formsemestre/<int:formsemestre_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def formsemestre(formsemestre_id: int):
"""
@ -44,9 +46,15 @@ def formsemestre(formsemestre_id: int):
"/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/ine/<int:ine>/bulletin",
methods=["GET"],
)
@token_auth.login_required
@token_permission_required(Permission.APIView)
def etudiant_bulletin(formsemestre_id, dept, format="json", etudid: int = None, nip: int = None, ine: int = None, ):#*args, size
def etudiant_bulletin(
formsemestre_id,
dept,
format="json",
etudid: int = None,
nip: int = None,
ine: int = None,
): # *args, size
"""
Retourne le bulletin de note d'un étudiant
@ -59,18 +67,30 @@ def etudiant_bulletin(formsemestre_id, dept, format="json", etudid: int = None,
# make_json_formsemestre_bulletinetud
app.set_sco_dept(dept)
try:
app.set_sco_dept(dept)
except:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que le nom de département est valide",
)
if etudid is None:
# Récupération de l'étudiant
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
try:
etu = get_etu_from_request(etudid, nip, ine)
etudid = etu.etudid
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel.\n "
"Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
data = make_json_formsemestre_bulletinetud(formsemestre_id, etudid)
return data
# if args[0] == "short":
# data = formsemestre_bulletinetud_dict(formsemestre_id, etudid, version=args[0])
# elif args[0] == "selectevals":
@ -83,8 +103,9 @@ def etudiant_bulletin(formsemestre_id, dept, format="json", etudid: int = None,
# return jsonify(data)
@bp.route("/formsemestre/<int:formsemestre_id>/bulletins", methods=["GET"])
@token_auth.login_required
@bp.route(
"/formsemestre/<int:formsemestre_id>/bulletins", methods=["GET"]
) # XXX TODO à revoir
@token_permission_required(Permission.APIView)
def bulletins(formsemestre_id: int):
"""
@ -93,18 +114,23 @@ def bulletins(formsemestre_id: int):
formsemestre_id : l'id d'un formesemestre
"""
# Fonction utilisée : app.scodoc.sco_recapcomplet.formsemestre_recapcomplet()
# gen_formsemestre_recapcomplet_json ??
try:
# Utilisation de la fonction formsemestre_recapcomplet
data = formsemestre_recapcomplet(formsemestre_id)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
# data = formsemestre_recapcomplet(formsemestre_id)
data = gen_formsemestre_recapcomplet_json(formsemestre_id)
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel. \n"
"Veillez vérifier la conformité du 'formation_id'",
)
return jsonify(data)
@bp.route("/formsemestre/<int:formsemestre_id>/jury", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def jury(formsemestre_id: int):
"""
@ -117,7 +143,11 @@ def jury(formsemestre_id: int):
try:
# Utilisation de la fonction formsemestre_pvjury
data = formsemestre_pvjury(formsemestre_id)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
except AttributeError:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel. \n"
"Veillez vérifier la conformité du 'formation_id'",
)
return jsonify(data)

View File

@ -4,13 +4,14 @@ from flask import jsonify
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.auth import token_permission_required
from app.scodoc.sco_prepajury import feuille_preparation_jury
from app.scodoc.sco_pvjury import formsemestre_pvjury
@bp.route("/jury/formsemestre/<int:formsemestre_id>/preparation_jury", methods=["GET"])
def jury_preparation(formsemestre_id: int): # XXX TODO check à quoi resemble le retour de la fonction
# @token_permission_required(Permission.)
def jury_preparation(formsemestre_id: int):
"""
Retourne la feuille de préparation du jury
@ -25,7 +26,8 @@ def jury_preparation(formsemestre_id: int): # XXX TODO check à quoi resemble le
@bp.route("/jury/formsemestre/<int:formsemestre_id>/decisions_jury", methods=["GET"])
def jury_decisions(formsemestre_id: int): # XXX TODO check à quoi resemble le retour de la fonction
# @token_permission_required(Permission.)
def jury_decisions(formsemestre_id: int):
"""
Retourne les décisions du jury suivant un formsemestre donné
@ -39,14 +41,31 @@ def jury_decisions(formsemestre_id: int): # XXX TODO check à quoi resemble le r
return error_response(501, message="Not implemented")
@bp.route("/jury/set_decision/etudid?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
"&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>", methods=["POST"])
@bp.route("/jury/set_decision/nip?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
"&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>", methods=["POST"])
@bp.route("/jury/set_decision/ine?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
"&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>", methods=["POST"])
def set_decision_jury(formsemestre_id: int, decision_jury: str, devenir_jury: str, assiduite: bool,
etudid: int = None, nip: int = None, ine: int = None):
@bp.route(
"/jury/set_decision/etudid?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
"&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>",
methods=["POST"],
)
@bp.route(
"/jury/set_decision/nip?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
"&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>",
methods=["POST"],
)
@bp.route(
"/jury/set_decision/ine?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
"&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>",
methods=["POST"],
)
# @token_permission_required(Permission.)
def set_decision_jury(
formsemestre_id: int,
decision_jury: str,
devenir_jury: str,
assiduite: bool,
etudid: int = None,
nip: int = None,
ine: int = None,
):
"""
Attribuer la décision du jury et le devenir à un etudiant
@ -61,10 +80,22 @@ def set_decision_jury(formsemestre_id: int, decision_jury: str, devenir_jury: st
return error_response(501, message="Not implemented")
@bp.route("/jury/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/annule_decision", methods=["DELETE"])
@bp.route("/jury/nip/<int:nip>/formsemestre/<int:formsemestre_id>/annule_decision", methods=["DELETE"])
@bp.route("/jury/ine/<int:ine>/formsemestre/<int:formsemestre_id>/annule_decision", methods=["DELETE"])
def annule_decision_jury(formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None):
@bp.route(
"/jury/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/annule_decision",
methods=["DELETE"],
)
@bp.route(
"/jury/nip/<int:nip>/formsemestre/<int:formsemestre_id>/annule_decision",
methods=["DELETE"],
)
@bp.route(
"/jury/ine/<int:ine>/formsemestre/<int:formsemestre_id>/annule_decision",
methods=["DELETE"],
)
# @token_permission_required(Permission.)
def annule_decision_jury(
formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None
):
"""
Supprime la déciosion du jury pour un étudiant donné

View File

@ -44,7 +44,6 @@ from app.scodoc.sco_permissions import Permission
@bp.route("/logos", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def api_get_glob_logos():
if not g.current_user.has_permission(Permission.ScoSuperAdmin, None):
@ -57,7 +56,6 @@ def api_get_glob_logos():
@bp.route("/logos/<string:logoname>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def api_get_glob_logo(logoname):
if not g.current_user.has_permission(Permission.ScoSuperAdmin, None):
@ -74,7 +72,6 @@ def api_get_glob_logo(logoname):
@bp.route("/departements/<string:departement>/logos", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def api_get_local_logos(departement):
dept_id = Departement.from_acronym(departement).id
@ -85,7 +82,6 @@ def api_get_local_logos(departement):
@bp.route("/departements/<string:departement>/logos/<string:logoname>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def api_get_local_logo(departement, logoname):
# format = requested_format("jpg", ['png', 'jpg']) XXX ?

View File

@ -3,16 +3,14 @@ from flask import jsonify
from app import models
from app.api import bp
from app.api.auth import token_auth
from app.api.errors import error_response
from app.decorators import permission_required
from app.api.auth import token_auth, token_permission_required
from app.api.auth import token_permission_required
from app.scodoc.sco_groups import get_group_members, setGroups
from app.scodoc.sco_permissions import Permission
@bp.route("/partitions/<int:formsemestre_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def partition(formsemestre_id: int):
"""
@ -30,13 +28,8 @@ def partition(formsemestre_id: int):
# return error_response(501, message="Not implemented")
# @bp.route(
# "/partitions/formsemestre/<int:formsemestre_id>/groups/group_ids?with_codes=&all_groups=&etat=",
# methods=["GET"],
# )
@bp.route("/partitions/groups/<int:group_id>", methods=["GET"])
@bp.route("/partitions/groups/<int:group_id>/etat/<string:etat>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView)
def etud_in_group(group_id: int, etat=None):
"""
@ -47,29 +40,30 @@ def etud_in_group(group_id: int, etat=None):
"""
# Fonction utilisée : app.scodoc.sco_groups.get_group_members()
if etat is None: # Si l'état n'est pas renseigné
try:
# Utilisation de la fonction get_group_members
data = get_group_members(group_id)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
else: # Si l'état est renseigné
try:
# Utilisation de la fonction get_group_members
data = get_group_members(group_id, etat)
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
if etat is None:
data = get_group_members(group_id)
else:
data = get_group_members(group_id, etat)
if len(data) == 0:
return error_response(
409,
message="La requête ne peut être traitée en létat actuel. \n"
"Aucun groupe ne correspond au 'group_id' renseigné",
)
return jsonify(data)
@bp.route(
"/partitions/set_groups?partition_id=<int:partition_id>&groups_lists=<int:groups_lists>&"
"groups_to_create=<int:groups_to_create>&groups_to_delete=<int:groups_to_delete>", methods=["POST"],
"groups_to_create=<int:groups_to_create>&groups_to_delete=<int:groups_to_delete>",
methods=["POST"],
)
@token_auth.login_required
@token_permission_required(Permission.APIEtudChangeGroups)
def set_groups(partition_id: int, groups_lists: int, groups_to_delete: int, groups_to_create: int):
def set_groups(
partition_id: int, groups_lists: int, groups_to_delete: int, groups_to_create: int
):
"""
Set les groups
@ -84,4 +78,8 @@ def set_groups(partition_id: int, groups_lists: int, groups_to_delete: int, grou
setGroups(partition_id, groups_lists, groups_to_create, groups_to_delete)
return error_response(200, message="Groups set")
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
return error_response(
409,
message="La requête ne peut être traitée en létat actuel. \n"
"Veillez vérifier la conformité des éléments passé en paramètres",
)

View File

@ -1,5 +1,6 @@
from app import models
def get_etu_from_request(etudid, nip, ine):
"""
Fonction qui retourne un etudiant en fonction de l'etudid, code nip et code ine rentré en paramètres
@ -10,13 +11,12 @@ def get_etu_from_request(etudid, nip, ine):
Exemple de résultat: <Itendite>
"""
if etudid is None:
if nip is None: # si ine
if nip is None: # si ine
etu = models.Identite.query.filter_by(code_ine=str(ine)).first()
else: # si nip
else: # si nip
etu = models.Identite.query.filter_by(code_nip=str(nip)).first()
else: # si etudid
else: # si etudid
etu = models.Identite.query.filter_by(id=etudid).first()
return etu

View File

@ -27,6 +27,20 @@ class Absence(db.Model):
# XXX TODO: contrainte ajoutée: vérifier suppression du module
# (mettre à NULL sans supprimer)
def to_dict(self):
data = {
"id": self.id,
"etudid": self.etudid,
"jour": self.jour,
"estabs": self.estabs,
"estjust": self.estjust,
"matin": self.matin,
"description": self.description,
"entry_date": self.entry_date,
"moduleimpl_id": self.moduleimpl_id,
}
return data
class AbsenceNotification(db.Model):
"""Notification d'absence émise"""