martin.murzeau/ScoDocMM
1
0
Fork 0
forked from ScoDoc/ScoDoc
Code Issues Pull Requests Projects Releases Wiki Activity

prise en compte des remarques du 21/04/2022

Browse Source
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

353
app/api/absences.py
View File

@ -5,11 +5,16 @@ from flask import jsonify
from app import models from app import models
from app.api import bp from app.api import bp
from app.api.auth import token_auth
from app.api.errors import error_response from app.api.errors import error_response
from app.decorators import permission_required from app.api.auth import token_permission_required
from app.api.auth import token_auth, 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_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_groups import get_group_members
from app.scodoc.sco_permissions import Permission 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/etudid/<int:etudid>", methods=["GET"])
@bp.route("/absences/nip/<int:nip>", methods=["GET"]) @bp.route("/absences/nip/<int:nip>", methods=["GET"])
@bp.route("/absences/ine/<int:ine>", methods=["GET"]) @bp.route("/absences/ine/<int:ine>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def absences(etudid: int = None, nip: int = None, ine: int = None): 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 nip: le code nip d'un étudiant
ine : le code ine d'un étudiant ine : le code ine d'un étudiant
""" """
abs = None if etudid is None:
if etudid is not None: # Si route etudid # Récupération de l'étudiant
# Récupération des absences de l'étudiant try:
abs = models.Absence.query.filter_by(etudid=etudid).all() etu = get_etu_from_request(etudid, nip, ine)
else: etudid = etu.etudid
if nip is not None: # Si route nip except AttributeError:
# Récupération de l'étudiant return error_response(
etu = models.Identite.query.filter_by(code_nip=nip).first() 409,
# Récupération des absences de l'étudiant message="La requête ne peut être traitée en l’état actuel.\n "
abs = models.Absence.query.filter_by(etudid=etu.etudid).all() "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 des absences de l'étudiant
# Récupération de l'étudiant abs = models.Absence.query.filter_by(etudid=etudid).all()
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()
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 # Mise en forme des données
data = [d.to_dict() for d in abs] data = [d.to_dict() for d in abs]
return jsonify(data) 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/etudid/<int:etudid>/abs_just_only", methods=["GET"])
@bp.route("/absences/nip/<int:nip>/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"]) @bp.route("/absences/ine/<int:ine>/abs_just_only", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def absences_justify(etudid: int = None, nip: int = None, ine: int = None): 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 nip: le code nip d'un étudiant
ine : le code ine d'un étudiant ine : le code ine d'un étudiant
""" """
abs = None if etudid is None:
if etudid is not None: # Si route etudid # Récupération de l'étudiant
# Récupération des absences justifiées de l'étudiant try:
abs = models.Absence.query.filter_by(etudid=etudid, estjust=True).all() etu = get_etu_from_request(etudid, nip, ine)
else: etudid = etu.etudid
if nip is not None: # Si route nip except AttributeError:
# Récupération de l'étudiant return error_response(
etu = models.Identite.query.filter_by(code_nip=nip).first() 409,
# Récupération des absences justifiées de l'étudiant message="La requête ne peut être traitée en l’état actuel.\n "
abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all() "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 des absences justifiées de l'étudiant
# Récupération de l'étudiant abs = models.Absence.query.filter_by(etudid=etudid, estjust=True).all()
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()
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 # Mise en forme des données
data = [d.to_dict() for d in abs] data = [d.to_dict() for d in abs]
return jsonify(data) 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>" ### Inutil en définitif ###
"&description=<string:description>", methods=["POST"]) @bp.route(
@bp.route("/absences/abs_signale?nip=<int:nip>&date=<string:date>&matin=<string:matin>&justif=<string:justif>" "/absences/abs_signale?etudid=<int:etudid>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
"&description=<string:description>", methods=["POST"]) "&description=<string:description>",
@bp.route("/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>" methods=["POST"],
"&description=<string:description>", methods=["POST"]) )
@bp.route("/absences/abs_signale?ine=<int:ine>&date=<string:date>&matin=<string:matin>&justif=<string:justif>" @bp.route(
"&description=<string:description>&moduleimpl_id=<int:moduleimpl_id>", methods=["POST"]) "/absences/abs_signale?nip=<int:nip>&date=<string:date>&matin=<string:matin>&justif=<string:justif>"
@token_auth.login_required "&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) @token_permission_required(Permission.APIAbsChange)
def abs_signale(date: datetime, matin: bool, justif: bool, etudid: int = None, nip: int = None, ine: int = None, def abs_signale(
description: str = None, moduleimpl_id: int = None): 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 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() # 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 etudid is None:
if moduleimpl_id is not None: # Si le moduleimpl a été renseigné # Récupération de l'étudiant
if etudid is not None: # Si route etudid try:
try: etu = get_etu_from_request(etudid, nip, ine)
# Utilisation de la fonction add_absence etudid = etu.etudid
add_absence(etudid, date, matin, justif, description, moduleimpl_id) except AttributeError:
# Utilisation de la fonction add_justif return error_response(
add_justif(etudid, date, matin, description) 409,
except ValueError: message="La requête ne peut être traitée en l’état actuel.\n "
return error_response(409, message="La requête ne peut être traitée en l’état actuel") "Veilliez vérifier que l'id de l'étudiant (etudid, nip, ine) est valide",
)
if nip is not None: # Si route nip try:
# Récupération de l'étudiant # Utilisation de la fonction add_absence
etu = models.Identite.query.filter_by(code_nip=nip).first() add_absence(etudid, date, matin, justif, description, moduleimpl_id)
try: if justif == True:
# Utilisation de la fonction add_absence # Utilisation de la fonction add_justif
add_absence(etu.etudid, date, matin, justif, description, moduleimpl_id) add_justif(etudid, date, matin, description)
# Utilisation de la fonction add_justif except ValueError:
add_justif(etu.etudid, date, matin, description) return error_response(
except ValueError: 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") )
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")
@bp.route("/absences/abs_annule?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>", methods=["POST"]) @bp.route(
@bp.route("/absences/abs_annule?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>", methods=["POST"]) "/absences/abs_annule?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>",
@bp.route("/absences/abs_annule?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>", methods=["POST"]) methods=["POST"],
@token_auth.login_required )
@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) @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 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() # Fonction utilisée : app.scodoc.sco_abs.annule_absence()
if etudid is None: if etudid is None:
if nip is not None: # Si route nip # Récupération de l'étudiant
# Récupération de l'étudiant try:
etu = models.Identite.query.filter_by(code_nip=nip).first() etu = get_etu_from_request(etudid, nip, ine)
# Récupération de l'etudid de l'étudiant
etudid = etu.etudid 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: try:
# Utilisation de la fonction annule_absence # Utilisation de la fonction annule_absence
annule_absence(etudid, jour, matin) annule_absence(etudid, jour, matin)
except ValueError: except AttributeError:
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") 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(
@bp.route("/absences/abs_annule_justif?nip=<int:nip>&jour=<string:jour>&matin=<string:matin>", methods=["POST"]) "/absences/abs_annule_justif?etudid=<int:etudid>&jour=<string:jour>&matin=<string:matin>",
@bp.route("/absences/abs_annule_justif?ine=<int:ine>&jour=<string:jour>&matin=<string:matin>", methods=["POST"]) methods=["POST"],
@token_auth.login_required )
@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) @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 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() # Fonction utilisée : app.scodoc.sco_abs.annule_justif()
if etudid is None: if etudid is None:
if nip is not None: # Si route nip # Récupération de l'étudiant
# Récupération de l'étudiant try:
etu = models.Identite.query.filter_by(code_nip=nip).first() etu = get_etu_from_request(etudid, nip, ine)
# 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
etudid = etu.etudid 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: try:
# Utilisation de la fonction annule_justif # Utilisation de la fonction annule_justif
annule_justif(etudid, jour, matin) annule_justif(etudid, jour, matin)
except ValueError: 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") 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"]) @bp.route(
@token_auth.login_required "/absences/abs_group_etat/?group_id=<int:group_id>&date_debut=date_debut&date_fin=date_fin",
methods=["GET"],
)
@token_permission_required(Permission.APIView) @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 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 # Utilisation de la fonction get_group_members
members = get_group_members(group_id) members = get_group_members(group_id)
except ValueError: 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 = [] data = []
# Filtre entre les deux dates renseignées # Filtre entre les deux dates renseignées

10
app/api/departements.py
View File

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

102
app/api/etudiants.py
View File

@ -13,9 +13,7 @@ from app.scodoc.sco_groups import get_etud_groups
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission
@bp.route("/etudiants", methods=["GET"]) @bp.route("/etudiants", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def etudiants(): def etudiants():
""" """
@ -56,7 +54,6 @@ def etudiants():
@bp.route("/etudiants/courant", methods=["GET"]) @bp.route("/etudiants/courant", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def etudiants_courant(): def etudiants_courant():
""" """
@ -102,7 +99,6 @@ def etudiants_courant():
@bp.route("/etudiant/etudid/<int:etudid>", methods=["GET"]) @bp.route("/etudiant/etudid/<int:etudid>", methods=["GET"])
@bp.route("/etudiant/nip/<int:nip>", methods=["GET"]) @bp.route("/etudiant/nip/<int:nip>", methods=["GET"])
@bp.route("/etudiant/ine/<int:ine>", methods=["GET"]) @bp.route("/etudiant/ine/<int:ine>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def etudiant(etudid: int = None, nip: int = None, ine: int = None): 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/etudid/<int:etudid>/formsemestres")
@bp.route("/etudiant/nip/<int:nip>/formsemestres") @bp.route("/etudiant/nip/<int:nip>/formsemestres")
@bp.route("/etudiant/ine/<int:ine>/formsemestres") @bp.route("/etudiant/ine/<int:ine>/formsemestres")
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None): 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 # Récupération de l'étudiant
etu = get_etu_from_request(etudid, nip, ine) etu = get_etu_from_request(etudid, nip, ine)
sems = [] # Récupération de toutes les inscriptions de l'étudiant
# Filtre les inscriptions contenant l'étudiant formsemestres_inscriptions = models.FormSemestreInscription.query.filter_by(
for sem in inscriptions: etud=etu
if sem.etudid == etu.etudid: ).all()
sems.append(sem)
formsemestres = [] formsemestres = []
# Récupération des formsemestres contenant les inscriptions de l'étudiant
# Filtre les formsemestre contenant les inscriptions de l'étudiant for formsemestre_inscription in formsemestres_inscriptions:
for sem in sems: #data_inscriptions: res = models.FormSemestre.query.filter_by(
res = models.FormSemestre.query.filter_by(id=sem.formsemestre_id).first() id=formsemestre_inscription.formsemestre_id
).first()
formsemestres.append(res) formsemestres.append(res)
data = [] data = []
# Mise en forme des données # Mise en forme des données
for formsem in formsemestres: for formsemestre in formsemestres:
data.append(formsem.to_dict()) data.append(formsemestre.to_dict())
return jsonify(data) return jsonify(data)
@bp.route("/etudiant/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"]) @bp.route(
@bp.route("/etudiant/nip/<int:nip>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"]) "/etudiant/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/bulletin",
@bp.route("/etudiant/ine/<int:ine>/formsemestre/<int:formsemestre_id>/bulletin", methods=["GET"]) methods=["GET"],
@token_auth.login_required )
@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) @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é 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 nip : le code nip d'un étudiant
ine : le code ine 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() 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: if etudid is None:
# Récupération de l'étudiant # Récupération de l'étudiant
etu = get_etu_from_request(etudid, nip, ine) try:
etudid = etu.etudid 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) return make_json_formsemestre_bulletinetud(formsemestre_id, etudid)
@bp.route("/etudiant/etudid/<int:etudid>/semestre/<int:formsemestre_id>/groups", methods=["GET"]) @bp.route(
@bp.route("/etudiant/nip/<int:nip>/semestre/<int:formsemestre_id>/groups", methods=["GET"]) "/etudiant/etudid/<int:etudid>/semestre/<int:formsemestre_id>/groups",
@bp.route("/etudiant/ine/<int:ine>/semestre/<int:formsemestre_id>/groups", methods=["GET"]) methods=["GET"],
@token_auth.login_required )
@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) @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é 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: if etudid is None:
# Récupération de l'étudiant # Récupération de l'étudiant
etu = get_etu_from_request(etudid, nip, ine) try:
etudid = etu.etudid 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 # Récupération du formsemestre
sem = models.FormSemestre.query.filter_by(id=formsemestre_id).first() sem = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
#breakpoint()
try: try:
# Utilisation de la fonction get_etud_groups # Utilisation de la fonction get_etud_groups
data = get_etud_groups(etudid, sem.id) data = get_etud_groups(etudid, sem.id)
except ValueError: except AttributeError:
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 l'id de l'étudiant (etudid, nip, ine) est valide"
" et le formsemestre_id sont valides",
)
return jsonify(data) return jsonify(data)

32
app/api/evaluations.py
View File

@ -3,14 +3,13 @@ from flask import jsonify
from app import models from app import models
from app.api import bp 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.api.errors import error_response
from app.scodoc.sco_evaluation_db import do_evaluation_get_all_notes from app.scodoc.sco_evaluation_db import do_evaluation_get_all_notes
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission
@bp.route("/evaluations/<int:moduleimpl_id>", methods=["GET"]) @bp.route("/evaluations/<int:moduleimpl_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def evaluations(moduleimpl_id: int): def evaluations(moduleimpl_id: int):
""" """
@ -29,7 +28,6 @@ def evaluations(moduleimpl_id: int):
@bp.route("/evaluations/eval_notes/<int:evaluation_id>", methods=["GET"]) @bp.route("/evaluations/eval_notes/<int:evaluation_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def evaluation_notes(evaluation_id: int): def evaluation_notes(evaluation_id: int):
""" """
@ -42,18 +40,32 @@ def evaluation_notes(evaluation_id: int):
try: try:
# Utilisation de la fonction do_evaluation_get_all_notes # Utilisation de la fonction do_evaluation_get_all_notes
data = do_evaluation_get_all_notes(evaluation_id) data = do_evaluation_get_all_notes(evaluation_id)
except ValueError: except AttributeError:
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 'evaluation_id'",
)
return jsonify(data) return jsonify(data)
@bp.route("/evaluations/eval_set_notes?eval_id=<int:eval_id>&etudid=<int:etudid>&note=<float:note>", methods=["POST"]) @bp.route(
@bp.route("/evaluations/eval_set_notes?eval_id=<int:eval_id>&nip=<int:nip>&note=<float:note>", methods=["POST"]) "/evaluations/eval_set_notes?eval_id=<int:eval_id>&etudid=<int:etudid>&note=<float:note>",
@bp.route("/evaluations/eval_set_notes?eval_id=<int:eval_id>&ine=<int:ine>&note=<float:note>", methods=["POST"]) methods=["POST"],
@token_auth.login_required )
@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) @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 Set les notes d'une évaluation pour un étudiant donnée

33
app/api/formations.py
View File

@ -5,14 +5,12 @@ from app import models
from app.api import bp from app.api import bp
from app.api.errors import error_response from app.api.errors import error_response
from app.api.auth import token_auth, token_permission_required 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_formations import formation_export
from app.scodoc.sco_moduleimpl import moduleimpl_list from app.scodoc.sco_moduleimpl import moduleimpl_list
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission
@bp.route("/formations", methods=["GET"]) @bp.route("/formations", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def formations(): def formations():
""" """
@ -28,7 +26,6 @@ def formations():
@bp.route("/formations/<int:formation_id>", methods=["GET"]) @bp.route("/formations/<int:formation_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def formations_by_id(formation_id: int): 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"]) @bp.route("/formations/formation_export/<int:formation_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def formation_export_by_formation_id(formation_id: int, export_ids=False): 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 # Utilisation de la fonction formation_export
data = formation_export(formation_id) data = formation_export(formation_id)
except ValueError: 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) return jsonify(data)
@bp.route("/formations/apo/<string:etape_apo>", methods=["GET"]) @bp.route("/formations/apo/<string:etape_apo>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def formsemestre_apo(etape_apo: int): 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"]) @bp.route("/formations/moduleimpl/<int:moduleimpl_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def moduleimpls(moduleimpl_id: int): def moduleimpls(moduleimpl_id: int):
""" """
@ -103,8 +101,10 @@ def moduleimpls(moduleimpl_id: int):
return jsonify(data) return jsonify(data)
@bp.route("/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>", methods=["GET"]) @bp.route(
@token_auth.login_required "/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>",
methods=["GET"],
)
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def moduleimpls_sem(moduleimpl_id: int, formsemestre_id: int): 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() # Fonction utilisée : app.scodoc.sco_moduleimpl.moduleimpl_list()
try: # Utilisation de la fonction moduleimpl_list
# Utilisation de la fonction moduleimpl_list data = moduleimpl_list(moduleimpl_id, formsemestre_id)
data = moduleimpl_list(moduleimpl_id, formsemestre_id)
except ValueError: if len(data) == 0:
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"
"Aucun moduleimpl ne correspond au 'moduleimpl_id' ou "
"'formsemestre_id' renseigné",
)
return jsonify(data) return jsonify(data)

64
app/api/formsemestres.py
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_bulletins_json import make_json_formsemestre_bulletinetud
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission
from app.scodoc.sco_pvjury import formsemestre_pvjury 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"]) @bp.route("/formations/formsemestre/<int:formsemestre_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def formsemestre(formsemestre_id: int): 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", "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/ine/<int:ine>/bulletin",
methods=["GET"], methods=["GET"],
) )
@token_auth.login_required
@token_permission_required(Permission.APIView) @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 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 # 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: if etudid is None:
# Récupération de l'étudiant # Récupération de l'étudiant
etu = get_etu_from_request(etudid, nip, ine) try:
etudid = etu.etudid 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) data = make_json_formsemestre_bulletinetud(formsemestre_id, etudid)
return data return data
# if args[0] == "short": # if args[0] == "short":
# data = formsemestre_bulletinetud_dict(formsemestre_id, etudid, version=args[0]) # data = formsemestre_bulletinetud_dict(formsemestre_id, etudid, version=args[0])
# elif args[0] == "selectevals": # elif args[0] == "selectevals":
@ -83,8 +103,9 @@ def etudiant_bulletin(formsemestre_id, dept, format="json", etudid: int = None,
# return jsonify(data) # return jsonify(data)
@bp.route("/formsemestre/<int:formsemestre_id>/bulletins", methods=["GET"]) @bp.route(
@token_auth.login_required "/formsemestre/<int:formsemestre_id>/bulletins", methods=["GET"]
) # XXX TODO à revoir
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def bulletins(formsemestre_id: int): def bulletins(formsemestre_id: int):
""" """
@ -93,18 +114,23 @@ def bulletins(formsemestre_id: int):
formsemestre_id : l'id d'un formesemestre formsemestre_id : l'id d'un formesemestre
""" """
# Fonction utilisée : app.scodoc.sco_recapcomplet.formsemestre_recapcomplet() # Fonction utilisée : app.scodoc.sco_recapcomplet.formsemestre_recapcomplet()
# gen_formsemestre_recapcomplet_json ??
try: try:
# Utilisation de la fonction formsemestre_recapcomplet # Utilisation de la fonction formsemestre_recapcomplet
data = formsemestre_recapcomplet(formsemestre_id) # data = formsemestre_recapcomplet(formsemestre_id)
except ValueError: data = gen_formsemestre_recapcomplet_json(formsemestre_id)
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) return jsonify(data)
@bp.route("/formsemestre/<int:formsemestre_id>/jury", methods=["GET"]) @bp.route("/formsemestre/<int:formsemestre_id>/jury", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def jury(formsemestre_id: int): def jury(formsemestre_id: int):
""" """
@ -117,7 +143,11 @@ def jury(formsemestre_id: int):
try: try:
# Utilisation de la fonction formsemestre_pvjury # Utilisation de la fonction formsemestre_pvjury
data = formsemestre_pvjury(formsemestre_id) data = formsemestre_pvjury(formsemestre_id)
except ValueError: except AttributeError:
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) return jsonify(data)

61
app/api/jury.py
View File

@ -4,13 +4,14 @@ from flask import jsonify
from app import models from app import models
from app.api import bp from app.api import bp
from app.api.errors import error_response 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_prepajury import feuille_preparation_jury
from app.scodoc.sco_pvjury import formsemestre_pvjury from app.scodoc.sco_pvjury import formsemestre_pvjury
@bp.route("/jury/formsemestre/<int:formsemestre_id>/preparation_jury", methods=["GET"]) @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 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"]) @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é 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") return error_response(501, message="Not implemented")
@bp.route("/jury/set_decision/etudid?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>" @bp.route(
"&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>", methods=["POST"]) "/jury/set_decision/etudid?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
@bp.route("/jury/set_decision/nip?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>" "&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>",
"&jury=<string:decision_jury>&devenir=<string:devenir_jury>&assiduite=<bool>", methods=["POST"]) 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"]) @bp.route(
def set_decision_jury(formsemestre_id: int, decision_jury: str, devenir_jury: str, assiduite: bool, "/jury/set_decision/nip?etudid=<int:etudid>&formsemestre_id=<int:formesemestre_id>"
etudid: int = None, nip: int = None, ine: int = None): "&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 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") return error_response(501, message="Not implemented")
@bp.route("/jury/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/annule_decision", methods=["DELETE"]) @bp.route(
@bp.route("/jury/nip/<int:nip>/formsemestre/<int:formsemestre_id>/annule_decision", methods=["DELETE"]) "/jury/etudid/<int:etudid>/formsemestre/<int:formsemestre_id>/annule_decision",
@bp.route("/jury/ine/<int:ine>/formsemestre/<int:formsemestre_id>/annule_decision", methods=["DELETE"]) methods=["DELETE"],
def annule_decision_jury(formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None): )
@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é Supprime la déciosion du jury pour un étudiant donné

4
app/api/logos.py
View File

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

48
app/api/partitions.py
View File

@ -3,16 +3,14 @@ from flask import jsonify
from app import models from app import models
from app.api import bp from app.api import bp
from app.api.auth import token_auth
from app.api.errors import error_response from app.api.errors import error_response
from app.decorators import permission_required from app.api.auth import token_permission_required
from app.api.auth import token_auth, token_permission_required
from app.scodoc.sco_groups import get_group_members, setGroups from app.scodoc.sco_groups import get_group_members, setGroups
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission
@bp.route("/partitions/<int:formsemestre_id>", methods=["GET"]) @bp.route("/partitions/<int:formsemestre_id>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def partition(formsemestre_id: int): def partition(formsemestre_id: int):
""" """
@ -30,13 +28,8 @@ def partition(formsemestre_id: int):
# return error_response(501, message="Not implemented") # 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>", methods=["GET"])
@bp.route("/partitions/groups/<int:group_id>/etat/<string:etat>", methods=["GET"]) @bp.route("/partitions/groups/<int:group_id>/etat/<string:etat>", methods=["GET"])
@token_auth.login_required
@token_permission_required(Permission.APIView) @token_permission_required(Permission.APIView)
def etud_in_group(group_id: int, etat=None): 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() # Fonction utilisée : app.scodoc.sco_groups.get_group_members()
if etat is None: # Si l'état n'est pas renseigné if etat is None:
try: data = get_group_members(group_id)
# Utilisation de la fonction get_group_members else:
data = get_group_members(group_id) 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 len(data) == 0:
else: # Si l'état est renseigné return error_response(
try: 409,
# Utilisation de la fonction get_group_members message="La requête ne peut être traitée en l’état actuel. \n"
data = get_group_members(group_id, etat) "Aucun groupe ne correspond au 'group_id' renseigné",
except ValueError: )
return error_response(409, message="La requête ne peut être traitée en l’état actuel")
return jsonify(data) return jsonify(data)
@bp.route( @bp.route(
"/partitions/set_groups?partition_id=<int:partition_id>&groups_lists=<int:groups_lists>&" "/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) @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 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) setGroups(partition_id, groups_lists, groups_to_create, groups_to_delete)
return error_response(200, message="Groups set") return error_response(200, message="Groups set")
except ValueError: 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",
)

8
app/api/tools.py
View File

@ -1,5 +1,6 @@
from app import models from app import models
def get_etu_from_request(etudid, nip, ine): 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 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> Exemple de résultat: <Itendite>
""" """
if etudid is None: 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() 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() 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() etu = models.Identite.query.filter_by(id=etudid).first()
return etu return etu

14
app/models/absences.py
View File

@ -27,6 +27,20 @@ class Absence(db.Model):
# XXX TODO: contrainte ajoutée: vérifier suppression du module # XXX TODO: contrainte ajoutée: vérifier suppression du module
# (mettre à NULL sans supprimer) # (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): class AbsenceNotification(db.Model):
"""Notification d'absence émise""" """Notification d'absence émise"""