résolution des conflis

This commit is contained in:
leonard_montalbano 2022-02-18 11:26:17 +01:00
parent 716a6bf41f
commit 2e1dcce69d

View File

@ -50,38 +50,17 @@ from app.api.errors import error_response
from app import models from app import models
from app.models import FormSemestre, FormSemestreInscription, Identite from app.models import FormSemestre, FormSemestreInscription, Identite
from app.models import ApcReferentielCompetences from app.models import ApcReferentielCompetences
from app.scodoc.sco_abs import annule_absence, annule_justif
from app.scodoc.sco_bulletins import formsemestre_bulletinetud_dict
from app.scodoc.sco_bulletins_json import make_json_formsemestre_bulletinetud
from app.scodoc.sco_formations import formation_export
from app.scodoc.sco_formsemestre_inscriptions import do_formsemestre_inscription_listinscrits
from app.scodoc.sco_groups import setGroups, get_etud_groups
from app.scodoc.sco_moduleimpl import moduleimpl_list
from app.scodoc.sco_permissions import Permission from app.scodoc.sco_permissions import Permission
@bp.route("/list_depts", methods=["GET"]) ############################################### Departements ##########################################################
@token_auth.login_required
def list_depts():
depts = models.Departement.query.filter_by(visible=True).all()
data = [d.to_dict() for d in depts]
return jsonify(data)
@bp.route("/etudiants/courant", methods=["GET"])
@token_auth.login_required
def etudiants():
"""Liste de tous les étudiants actuellement inscrits à un semestre
en cours.
"""
# Vérification de l'accès: permission Observateur sur tous les départements
# (c'est un exemple à compléter)
if not g.current_user.has_permission(Permission.ScoObservateur, None):
return error_response(401, message="accès interdit")
query = db.session.query(Identite).filter(
FormSemestreInscription.formsemestre_id == FormSemestre.id,
FormSemestreInscription.etudid == Identite.id,
FormSemestre.date_debut <= func.now(),
FormSemestre.date_fin >= func.now(),
)
return jsonify([e.to_dict_bul(include_urls=False) for e in query])
######################## Departements ##################################
@bp.route("/departements", methods=["GET"]) @bp.route("/departements", methods=["GET"])
@ -97,7 +76,7 @@ def departements():
@bp.route("/departements/<string:dept>/etudiants/liste/<int:sem_id>", methods=["GET"]) @bp.route("/departements/<string:dept>/etudiants/liste/<int:sem_id>", methods=["GET"])
@token_auth.login_required @token_auth.login_required
def liste_etudiants(dept, *args, sem_id): # XXX TODO A REVOIR def liste_etudiants(dept: str, *args, sem_id): # XXX TODO A REVOIR
""" """
Liste des étudiants d'un département Liste des étudiants d'un département
""" """
@ -133,145 +112,273 @@ def liste_etudiants(dept, *args, sem_id): # XXX TODO A REVOIR
@bp.route("/departements/<string:dept>/semestres_actifs", methods=["GET"]) @bp.route("/departements/<string:dept>/semestres_actifs", methods=["GET"])
@token_auth.login_required @token_auth.login_required
def liste_semestres_actifs(dept): # TODO : changer nom def liste_semestres_courant(dept: str):
""" """
Liste des semestres actifs d'un départements donné Liste des semestres actifs d'un départements donné
""" """
# Récupération de l'id du dept depts = models.Departement.query.filter_by(acronym=dept).all()
dept_id = models.Departement.query.filter(models.Departement.acronym == dept)
# Puis ici récupération du FormSemestre correspondant
depts_actifs = models.FormSemestre.query.filter_by(
etat=True,
dept_id=dept_id,
)
data = [da.to_dict() for da in depts_actifs]
# return jsonify(data) id_dept = depts[0].id
return error_response(501, message="Not implemented")
semestres = models.FormSemestre.query.filter_by(dept_id=id_dept, etat=True).all()
@bp.route("/referentiel_competences/<int:referentiel_competence_id>") data = semestres[0].to_dict()
@token_auth.login_required
def referentiel_competences(referentiel_competence_id): return jsonify(data)
@bp.route(
"/departements/<string:dept>/formations/<int:formation_id>/referentiel_competences",
methods=["GET"],
)
def referenciel_competences(dept: str, formation_id: int):
""" """
Le référentiel de compétences Le référentiel de compétences
""" """
ref = ApcReferentielCompetences.query.get_or_404(referentiel_competence_id) # depts = models.Departement.query.filter_by(acronym=dept).all()
#
# id_dept = depts[0].id
#
# formations = models.Formation.query.filter_by(id=formation_id, dept_id=id_dept).all()
#
# ref_comp = formations[0].referentiel_competence_id
#
# if ref_comp is None:
# return error_response(204, message="Pas de référenciel de compétences pour cette formation")
# else:
# return jsonify(ref_comp)
ref = ApcReferentielCompetences.query.get_or_404(formation_id)
return jsonify(ref.to_dict()) return jsonify(ref.to_dict())
####################### Etudiants ################################## @bp.route("/departements/<string:dept>/formations/programme/<string:sem_idx>", methods=["GET"])
def semestre_index(dept: str, sem_idx: str):
@bp.route("/etudiant/<int:etudid>", methods=["GET"])
@token_auth.login_required
def etudiant(etudid):
""" """
Un dictionnaire avec les informations de l'étudiant correspondant à l'id passé en paramètres.
""" """
etud: Identite = Identite.query.get_or_404(etudid) return error_response(501, message="not implemented")
return jsonify(etud.to_dict_bul())
@bp.route("/etudiant/<int:etudid>/semestre/<int:sem_id>/bulletin", methods=["GET"]) #################################################### Etudiants ########################################################
@token_auth.login_required
def etudiant_bulletin_semestre(etudid, sem_id):
@bp.route("/etudiants", methods=["GET"])
def etudiants():
"""
La liste des étudiants
"""
etu = models.Identite.query.all()
data = [d.to_dict_bul(include_urls=False) for d in etu]
return jsonify(data)
# return error_response(501, message="Not implemented")
@bp.route("/etudiants/courant", methods=["GET"])
def etudiants_courant():
"""
La liste des étudiants courant
"""
etus = models.Identite.query.all()
data = []
for etu in etus:
if etu.inscription_courante() is not None:
data.append(etu.to_dict_bul(include_urls=False))
return jsonify(data)
# return error_response(501, message="Not implemented")
@bp.route("/etudiant/etudid/<int:etudid>", methods=["GET"])
@bp.route("/etudiant/nip/<int:nip>", methods=["GET"])
@bp.route("/etudiant/ine/<int:ine>", methods=["GET"])
def etudiant(etudid=None, nip=None, ine=None):
"""
Les informations de l'étudiant correspondant à l'id passé en paramètres.
"""
etu = []
if etudid is not None:
etu = models.Identite.query.filter_by(id=etudid).first()
if nip is not None:
etu = models.Identite.query.filter_by(code_nip=etudid).first()
if ine is not None:
etu = models.Identite.query.filter_by(code_ine=etudid).first()
data = etu.to_dict_bul(include_urls=False)
return jsonify(data)
@bp.route("/etudiant/etudid/<int:etudid>/formsemestres")
@bp.route("/etudiant/nip/<int:nip>/formsemestres")
@bp.route("/etudiant/ine/<int:ine>/formsemestres")
def etudiant_formsemestres(etudid=None, nip=None, ine=None):
"""
Retourne les semestres qu'un étudiant a suivi
"""
inscriptions = models.FormSemestreInscription.query.all()
sems = []
for sem in inscriptions:
if etudid is not None:
if sem.etudid == etudid:
sems.append(sem)
if nip is not None:
etu = models.Identite.query.filter_by(code_nip=nip).first()
if sem.etudid == etu.etudid:
sems.append(sem)
if ine is not None:
etu = models.Identite.query.filter_by(code_ine=ine).firt()
if sem.etudid == etu.etudid:
sems.append(sem)
data_inscriptions = [d.to_dict() for d in sems]
formsemestres = []
for sem in data_inscriptions:
res = models.FormSemestre.query.filter_by(id=sem['formsemestre_id']).first()
formsemestres.append(res)
data = []
for formsem in formsemestres:
data.append(formsem.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"])
def etudiant_bulletin_semestre(formsemestre_id, etudid=None, nip=None, ine=None):
""" """
Le bulletin d'un étudiant en fonction de son id et d'un semestre donné Le bulletin d'un étudiant en fonction de son id et d'un semestre donné
""" """
# return jsonify(models.BulAppreciations.query.filter_by(etudid=etudid, formsemestre_id=sem_id)) # fonction to use: make_json_formsemestre_bulletinetud()
return error_response(501, message="Not implemented") if etudid is not None:
return make_json_formsemestre_bulletinetud(formsemestre_id, etudid)
@bp.route(
"/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/nip/<int:NIP>/releve",
methods=["GET"],
)
@bp.route(
"/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/id/<int:etudid>/releve",
methods=["GET"],
)
@bp.route(
"/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/ine/<int:numScodoc>/releve",
methods=["GET"],
)
@token_auth.login_required
def etudiant_bulletin(formsemestre_id, dept, etudid, format="json", *args, size):
"""
Un bulletin de note
"""
formsemestres = models.FormSemestre.query.filter_by(id=formsemestre_id)
depts = models.Departement.query.filter_by(acronym=dept)
etud = ""
data = []
if args[0] == "short":
pass
elif args[0] == "selectevals":
pass
elif args[0] == "long":
pass
else: else:
return "erreur" etu = None
if nip is not None:
etu = models.Identite.query.filter_by(code_nip=nip).first()
# return jsonify(data) if ine is not None:
return error_response(501, message="Not implemented") etu = models.Identite.query.filter_by(code_nip=ine).first()
if etu is not None:
return make_json_formsemestre_bulletinetud(formsemestre_id, etu.etudid)
# return error_response(501, message="Not implemented")
@bp.route( @bp.route(
"/etudiant/<int:etudid>/semestre/<int:formsemestre_id>/groups", methods=["GET"] "/etudiant/etudid/<int:etudid>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
) )
@token_auth.login_required @bp.route(
def etudiant_groups(etudid: int, formsemestre_id: int): "/etudiant/nip/<int:nip>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
)
@bp.route(
"/etudiant/ine/<int:ine>/semestre/<int:formsemestre_id>/groups", methods=["GET"]
)
def etudiant_groups(formsemestre_id: int, etudid=None, nip=None, ine=None):
""" """
Liste des groupes auxquels appartient l'étudiant dans le semestre indiqué Liste des groupes auxquels appartient l'étudiant dans le semestre indiqué
""" """
semestre = models.FormSemestre.query.filter_by(id=formsemestre_id) # fonction to use : get_etud_groups
etudiant = models.Identite.query.filter_by(id=etudid)
groups = models.Partition.query.filter( if etudid is None:
models.Partition.formsemestre_id == semestre, if nip is not None:
models.GroupDescr.etudiants == etudiant, etu = models.Identite.query.filter_by(code_nip=nip).first()
) etudid = etu.etudid
data = [d.to_dict() for d in groups] if ine is not None:
# return jsonify(data) etu = models.Identite.query.filter_by(code_ine=ine).first()
etudid = etu.etudid
sem = models.FormSemestre.query.filter_by(id=formsemestre_id).first()
try:
data = get_etud_groups(etudid, sem.to_dict())
except ValueError:
return error_response(409, message="La requête ne peut être traitée en létat actuel")
return error_response(501, message="Not implemented") return jsonify(data)
##############################################" Formations ############################################################
#######################" Programmes de formations #########################
@bp.route("/formations", methods=["GET"]) @bp.route("/formations", methods=["GET"])
@bp.route("/formations/<int:formation_id>", methods=["GET"]) def formations():
@token_auth.login_required
def formations(formation_id: int):
""" """
Liste des formations Liste des formations
""" """
formations = models.Formation.query.filter_by(id=formation_id) list_formations = models.Formation.query.all()
data = [d.to_dict() for d in formations]
# return jsonify(data)
return error_response(501, message="Not implemented") data = [d.to_dict() for d in list_formations]
return jsonify(data)
@bp.route("/formations/<int:formation_id>", methods=["GET"])
def formations_by_id(formation_id: int):
"""
Formation en fonction d'un id donné
"""
forma = models.Formation.query.filter_by(id=formation_id).all()
data = [d.to_dict() for d in forma]
return jsonify(data)
@bp.route("/formations/formation_export/<int:formation_id>", methods=["GET"]) @bp.route("/formations/formation_export/<int:formation_id>", methods=["GET"])
@token_auth.login_required def formation_export_by_formation_id(formation_id: int, export_ids=False):
def formation_export(formation_id: int, export_ids=False):
""" """
La formation, avec UE, matières, modules La formation, avec UE, matières, modules
""" """
data = formation_export(formation_id)
return jsonify(data)
@bp.route("/formations/apo/<int:etape_apo>", methods=["GET"])
def formsemestre_apo(etape_apo: int):
"""
Information sur les formsemestres
"""
return error_response(501, message="Not implemented") return error_response(501, message="Not implemented")
###################### UE ####################################### @bp.route("/formations/moduleimpl/<int:moduleimpl_id>", methods=["GET"])
def moduleimpls(moduleimpl_id: int):
"""
Liste des moduleimpl
"""
list_moduleimpls = models.ModuleImpl.query.filter_by(id=moduleimpl_id)
data = list_moduleimpls[0].to_dict()
return jsonify(data)
@bp.route(
"/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>",
methods=["GET"],
)
def moduleimpls_sem(moduleimpl_id: int, formsemestre_id: int):
"""
Liste de moduleimpl d'un semestre
"""
data = moduleimpl_list(moduleimpl_id, formsemestre_id)
return jsonify(data)
# return error_response(501, message="Not implemented")
#################################################### UE ###############################################################
@bp.route( @bp.route(
"/departements/<string:dept>/formations/programme/<string:sem_id>", methods=["GET"] "/departements/<string:dept>/formations/programme/<string:sem_id>", methods=["GET"]
) )
@token_auth.login_required
def eus(dept: str, sem_id: int): def eus(dept: str, sem_id: int):
""" """
Liste des UES, ressources et SAE d'un semestre Liste des UES, ressources et SAE d'un semestre
@ -279,42 +386,70 @@ def eus(dept: str, sem_id: int):
return error_response(501, message="Not implemented") return error_response(501, message="Not implemented")
######## Semestres de formation ############### ########################################## Formsemestres ##############################################################
@bp.route("/formations/formsemestre/<int:formsemestre_id>", methods=["GET"]) @bp.route("/formations/formsemestre/<int:formsemestre_id>", methods=["GET"])
@bp.route("/formations/apo/<int:etape_apo>", methods=["GET"]) def formsemestre(formsemestre_id: int):
@token_auth.login_required
def formsemestre(
id: int,
):
""" """
Information sur les formsemestres Information sur le formsemestre correspondant au formsemestre_id
""" """
return error_response(501, message="Not implemented") list_formsemetre = models.FormSemestre.query.filter_by(id=formsemestre_id)
data = list_formsemetre[0].to_dict()
return jsonify(data)
############ Modules de formation ##############
@bp.route("/formations/moduleimpl/<int:moduleimpl_id>", methods=["GET"])
@bp.route( @bp.route(
"/formations/moduleimpl/<int:moduleimpl_id>/formsemestre/<int:formsemestre_id>", "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/etudid/<int:etudid>/bulletin",
methods=["GET"], methods=["GET"],
) )
@token_auth.login_required @bp.route(
def moduleimpl(id: int): "/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/nip/<int:nip>/bulletin",
methods=["GET"],
)
@bp.route(
"/formsemestre/<int:formsemestre_id>/departements/<string:dept>/etudiant/ine/<int:ine>/bulletin",
methods=["GET"],
)
def etudiant_bulletin(formsemestre_id, dept, etudid, format="json", *args, size):
""" """
Liste de moduleimpl Un bulletin de note
"""
data = []
if args[0] == "short":
data = formsemestre_bulletinetud_dict(formsemestre_id, etudid, version=args[0])
elif args[0] == "selectevals":
data = formsemestre_bulletinetud_dict(formsemestre_id, etudid, version=args[0])
elif args[0] == "long":
data = formsemestre_bulletinetud_dict(formsemestre_id, etudid)
else:
return error_response(501, message="Not implemented")
return jsonify(data)
@bp.route("/formsemestre/<int:formsemestre_id>/bulletins", methods=["GET"])
def bulletins(formsemestre_id: int):
"""
Les bulletins d'un formsemestre donné
""" """
return error_response(501, message="Not implemented") return error_response(501, message="Not implemented")
########### Groupes et partitions ############### @bp.route("/formsemestre/<int:formsemestre_id>/jury", methods=["GET"])
def jury(formsemestre_id: int):
"""
"""
return error_response(501, message="Not implemented")
############################################### Partitions ############################################################
@bp.route("/partitions/<int:formsemestre_id>", methods=["GET"]) @bp.route("/partitions/<int:formsemestre_id>", methods=["GET"])
@token_auth.login_required
def partition(formsemestre_id: int): def partition(formsemestre_id: int):
""" """
La liste de toutes les partitions d'un formsemestre La liste de toutes les partitions d'un formsemestre
@ -330,7 +465,6 @@ def partition(formsemestre_id: int):
"/partitions/formsemestre/<int:formsemestre_id>/groups/group_ids?with_codes=&all_groups=&etat=", "/partitions/formsemestre/<int:formsemestre_id>/groups/group_ids?with_codes=&all_groups=&etat=",
methods=["GET"], methods=["GET"],
) )
@token_auth.login_required
def groups(formsemestre_id: int, group_ids: int): def groups(formsemestre_id: int, group_ids: int):
""" """
Liste des étudiants dans un groupe Liste des étudiants dans un groupe
@ -339,24 +473,27 @@ def groups(formsemestre_id: int, group_ids: int):
@bp.route( @bp.route(
"/partitions/set_groups?partition_id=<int:partition_id>&groups=<int:groups>&groups_to_delete=<int:groups_to_delete>&groups_to_create=<int:groups_to_create>", "/partitions/set_groups?partition_id=<int:partition_id>&groups_lists=<int:groups_lists>&groups_to_create=<int"
methods=["POST"], ":groups_to_create>&groups_to_delete=<int:groups_to_delete>", methods=["POST"],
) )
@token_auth.login_required @token_auth.login_required
def set_groups( def set_groups(
partition_id: int, groups: int, groups_to_delete: int, groups_to_create: int partition_id: int, groups_lists: int, groups_to_delete: int, groups_to_create: int
): ):
""" """
Set les groups Set les groups
""" """
return error_response(501, message="Not implemented") try:
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")
####### Bulletins de notes ########### ################################################### Evaluations #######################################################
@bp.route("/evaluations/<int:moduleimpl_id>", methods=["GET"]) @bp.route("/evaluations/<int:moduleimpl_id>", methods=["GET"])
@token_auth.login_required
def evaluations(moduleimpl_id: int): def evaluations(moduleimpl_id: int):
""" """
Liste des évaluations à partir de l'id d'un moduleimpl Liste des évaluations à partir de l'id d'un moduleimpl
@ -364,22 +501,21 @@ def evaluations(moduleimpl_id: int):
evals = models.Evaluation.query.filter_by(id=moduleimpl_id) evals = models.Evaluation.query.filter_by(id=moduleimpl_id)
data = [d.to_dict() for d in evals] data = [d.to_dict() for d in evals]
# return jsonify(data) return jsonify(data)
return error_response(501, message="Not implemented") # return error_response(501, message="Not implemented")
@bp.route("/evaluations/eval_notes/<int:evaluation_id>", methods=["GET"]) @bp.route("/evaluations/eval_notes/<int:evaluation_id>", methods=["GET"])
@token_auth.login_required
def evaluation_notes(evaluation_id: int): def evaluation_notes(evaluation_id: int):
""" """
Liste des notes à partir de l'id d'une évaluation donnée Liste des notes à partir de l'id d'une évaluation donnée
""" """
evals = models.Evaluation.query.filter_by(id=evaluation_id) notes = models.NotesNotes.query.filter_by(evaluation_id=evaluation_id).all()
notes = evals.get_notes()
data = [d.to_dict() for d in notes] data = [d.to_dict() for d in notes]
# return jsonify(data)
return error_response(501, message="Not implemented") return jsonify(data)
# return error_response(501, message="Not implemented")
@bp.route( @bp.route(
@ -394,20 +530,52 @@ def evaluation_set_notes(eval_id: int, etudid: int, note: float):
return error_response(501, message="Not implemented") return error_response(501, message="Not implemented")
############## Absences ############# #################################################### Absences #########################################################
@bp.route("/absences/<int:etudid>", methods=["GET"]) @bp.route("/absences/<int:etudid>", methods=["GET"])
def absences(etudid=None, nip=None, ine=None):
"""
Liste des absences d'un étudiant donné
"""
abs = ""
if etudid is not None:
abs = models.Absence.query.filter_by(etudid=etudid).all()
else:
if nip is not None:
etu = models.Identite.query.filter_by(code_nip=nip).first()
abs = models.Absence.query.filter_by(etudid=etu.etudid).all()
if ine is not None:
etu = models.Identite.query.filter_by(code_ine=ine).first()
abs = models.Absence.query.filter_by(etudid=etu.etudid).all()
if abs != "":
data = [d.to_dict() for d in abs]
return jsonify(data)
return error_response(501, message="Not implemented")
@bp.route("/absences/<int:etudid>/abs_just_only", methods=["GET"]) @bp.route("/absences/<int:etudid>/abs_just_only", methods=["GET"])
def absences(etudid: int): def absences_justify(etudid=None, nip=None, ine=None):
""" """
Liste des absences d'un étudiant donnée Liste des absences justifiés d'un étudiant donné
""" """
abs = models.Absence.query.filter_by(id=etudid) abs = ""
if etudid is not None:
abs = models.Absence.query.filter_by(etudid=etudid, estjust=True).all()
else:
if nip is not None:
etu = models.Identite.query.filter_by(code_nip=nip).first()
abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all()
if ine is not None:
etu = models.Identite.query.filter_by(code_ine=ine).first()
abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all()
data = [d.to_dict() for d in abs] if 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(501, message="Not implemented")
@ -420,43 +588,73 @@ def abs_signale():
return error_response(501, message="Not implemented") return error_response(501, message="Not implemented")
@bp.route("/absences/abs_annule", methods=["POST"]) @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 @token_auth.login_required
def abs_annule(): def abs_annule(jour: datetime, matin: str, etudid=None, nip=None, ine=None):
""" """
Retourne un html Retourne un html
""" """
return error_response(501, message="Not implemented") # fonction to use : annule_absence
if etudid is None:
if nip is not None:
etu = models.Identite.query.filter_by(code_nip=nip).first()
etudid = etu.etudid
if ine is not None:
etu = models.Identite.query.filter_by(code_ine=ine).first()
etudid = etu.etudid
try:
annule_absence(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(200, message="OK")
@bp.route("/absences/abs_annule_justif", methods=["POST"]) @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 @token_auth.login_required
def abs_annule_justif(): def abs_annule_justif(jour: datetime, matin: str, etudid=None, nip=None, ine=None):
""" """
Retourne un html Retourne un html
""" """
return error_response(501, message="Not implemented") # fonction to use : annule_justif
if etudid is None:
if nip is not None:
etu = models.Identite.query.filter_by(code_nip=nip).first()
etudid = etu.etudid
if ine is not None:
etu = models.Identite.query.filter_by(code_ine=ine).first()
etudid = etu.etudid
try:
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(200, message="OK")
@bp.route( @bp.route(
"/absences/abs_group_etat/?group_ids=<int:group_ids>&date_debut=date_debut&date_fin=date_fin", "/absences/abs_group_etat/?group_ids=<int:group_ids>&date_debut=date_debut&date_fin=date_fin",
methods=["GET"], methods=["GET"],
) )
@token_auth.login_required
def abs_groupe_etat( def abs_groupe_etat(
group_ids: int, date_debut, date_fin, with_boursier=True, format="html" group_ids: int, date_debut, date_fin, with_boursier=True, format="html"
): ):
""" """
Liste des absences d'un ou plusieurs groupes entre deux dates Liste des absences d'un ou plusieurs groupes entre deux dates
""" """
# list_abs_date
return error_response(501, message="Not implemented") return error_response(501, message="Not implemented")
################ Logos ################ ###################################################### Logos ##########################################################
@bp.route("/logos", methods=["GET"]) @bp.route("/logos", methods=["GET"])
@token_auth.login_required
def liste_logos(format="json"): def liste_logos(format="json"):
""" """
Liste des logos définis pour le site scodoc. Liste des logos définis pour le site scodoc.
@ -465,7 +663,6 @@ def liste_logos(format="json"):
@bp.route("/logos/<string:nom>", methods=["GET"]) @bp.route("/logos/<string:nom>", methods=["GET"])
@token_auth.login_required
def recup_logo_global(nom: str): def recup_logo_global(nom: str):
""" """
Retourne l'image au format png ou jpg Retourne l'image au format png ou jpg
@ -474,7 +671,6 @@ def recup_logo_global(nom: str):
@bp.route("/departements/<string:dept>/logos", methods=["GET"]) @bp.route("/departements/<string:dept>/logos", methods=["GET"])
@token_auth.login_required
def logo_dept(dept: str): def logo_dept(dept: str):
""" """
Liste des logos définis pour le département visé. Liste des logos définis pour le département visé.
@ -483,7 +679,6 @@ def logo_dept(dept: str):
@bp.route("/departement/<string:dept>/logos/<string:nom>", methods=["GET"]) @bp.route("/departement/<string:dept>/logos/<string:nom>", methods=["GET"])
@token_auth.login_required
def recup_logo_dept_global(dept: str, nom: str): def recup_logo_dept_global(dept: str, nom: str):
""" """
L'image format png ou jpg L'image format png ou jpg