From afe43f98e386660d920b6e7d2a93c85c1f6c7d76 Mon Sep 17 00:00:00 2001 From: leonard_montalbano Date: Fri, 25 Feb 2022 16:03:05 +0100 Subject: [PATCH] =?UTF-8?q?code=20de=20sco=5Fapi.py=20comment=C3=A9=20et?= =?UTF-8?q?=20d=C3=A9but=20des=20tests?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/api/sco_api.py | 835 +++++++++++++++++++++++++++++++++++++-------- 1 file changed, 693 insertions(+), 142 deletions(-) diff --git a/app/api/sco_api.py b/app/api/sco_api.py index f9802abe8..39c1d977e 100644 --- a/app/api/sco_api.py +++ b/app/api/sco_api.py @@ -73,25 +73,32 @@ from app.scodoc.sco_saisie_notes import notes_add @token_auth.login_required def departements(): """ - Liste des ids de départements + Retourne la liste des ids de départements """ + # Récupération de tous les départements depts = models.Departement.query.filter_by(visible=True).all() + + # Mise en place de la liste avec tous les ids de départements data = [d.id for d in depts] + return jsonify(data) @bp.route("/departements//etudiants/liste/", methods=["GET"]) @token_auth.login_required -def liste_etudiants(dept: str, *args, sem_id): # XXX TODO A REVOIR +def liste_etudiants(dept: str, formsemestre_id=None): # XXX TODO A REVOIR """ - Liste des étudiants d'un département + Retourne la liste des étudiants d'un département + + dept: l'acronym d'un département + formsemestre_id: l'id d'un formesemestre """ - # Test si le sem_id à été renseigné ou non - if sem_id is not None: + # Si le formsemestre_id a été renseigné + if formsemestre_id is not None: # Récupération du/des depts list_depts = models.Departement.query.filter( models.Departement.acronym == dept, - models.FormSemestre.semestre_id == sem_id, + models.FormSemestre.semestre_id == formsemestre_id, ) list_etuds = [] for dept in list_depts: @@ -100,7 +107,7 @@ def liste_etudiants(dept: str, *args, sem_id): # XXX TODO A REVOIR for y in x: # Ajout des étudiants dans la liste global list_etuds.append(y) - else: + else: # Si le formsemestre_id n'a pas été renseigné list_depts = models.Departement.query.filter( models.Departement.acronym == dept, models.FormSemestre.semestre_id == models.Departement.formsemestres, @@ -111,6 +118,7 @@ def liste_etudiants(dept: str, *args, sem_id): # XXX TODO A REVOIR for y in x: list_etuds.append(y) + # Mise en forme des données data = [d.to_dict() for d in list_etuds] # return jsonify(data) return error_response(501, message="Not implemented") @@ -121,13 +129,19 @@ def liste_etudiants(dept: str, *args, sem_id): # XXX TODO A REVOIR def liste_semestres_courant(dept: str): """ Liste des semestres actifs d'un départements donné + + dept: l'acronym d'un département """ + # Récupération des départements comportant l'acronym mit en paramètre depts = models.Departement.query.filter_by(acronym=dept).all() + # Récupération de l'id id_dept = depts[0].id + # Récupération des semestres suivant id_dept semestres = models.FormSemestre.query.filter_by(dept_id=id_dept, etat=True).all() + # Mise en forme des données data = semestres[0].to_dict() return jsonify(data) @@ -139,7 +153,10 @@ def liste_semestres_courant(dept: str): ) def referenciel_competences(dept: str, formation_id: int): """ - Le référentiel de compétences + Retourne le référentiel de compétences + + dept : l'acronym d'un département + formation_id : l'id d'une formation """ # depts = models.Departement.query.filter_by(acronym=dept).all() # @@ -174,10 +191,12 @@ def semestre_index(dept: str, formsemestre_id: int): @bp.route("/etudiants", methods=["GET"]) def etudiants(): """ - La liste des étudiants + Retourne la liste de tous les étudiants """ + # Récupération de tous les étudiants etu = models.Identite.query.all() + # Mise en forme des données data = [d.to_dict_bul(include_urls=False) for d in etu] return jsonify(data) @@ -187,11 +206,13 @@ def etudiants(): @bp.route("/etudiants/courant", methods=["GET"]) def etudiants_courant(): """ - La liste des étudiants courant + Retourne la liste des étudiants courant """ + # Récupération de tous les étudiants etus = models.Identite.query.all() data = [] + # Récupère uniquement les étudiants courant for etu in etus: if etu.inscription_courante() is not None: data.append(etu.to_dict_bul(include_urls=False)) @@ -203,18 +224,29 @@ def etudiants_courant(): @bp.route("/etudiant/etudid/", methods=["GET"]) @bp.route("/etudiant/nip/", methods=["GET"]) @bp.route("/etudiant/ine/", methods=["GET"]) -def etudiant(etudid=None, nip=None, ine=None): +def etudiant(etudid: int = None, nip: int = None, ine: int = None): """ - Les informations de l'étudiant correspondant à l'id passé en paramètres. + Retourne les informations de l'étudiant correspondant à l'id passé en paramètres. + + etudid : l'etudid d'un étudiant + nip : le code nip d'un étudiant + ine : le code ine d'un étudiant """ 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() + if etudid is not None: # Si route etudid + # Récupération de l'étudiant + etu = models.Identite.query.filter_by(id=etudid).first() + + if nip is not None: # Si route nip + # Récupération de l'étudiant + etu = models.Identite.query.filter_by(code_nip=nip).first() + + if ine is not None: # Si route ine + # Récupération de l'étudiant + etu = models.Identite.query.filter_by(code_ine=ine).first() + + # Mise en forme des données data = etu.to_dict_bul(include_urls=False) return jsonify(data) @@ -223,36 +255,49 @@ def etudiant(etudid=None, nip=None, ine=None): @bp.route("/etudiant/etudid//formsemestres") @bp.route("/etudiant/nip//formsemestres") @bp.route("/etudiant/ine//formsemestres") -def etudiant_formsemestres(etudid=None, nip=None, ine=None): +def etudiant_formsemestres(etudid: int = None, nip: int = None, ine: int = None): """ - Retourne les semestres qu'un étudiant a suivi + Retourne les semestres qu'un étudiant a suivis + + etudid : l'etudid d'un étudiant + nip : le code nip d'un étudiant + ine : le code ine d'un étudiant """ + # Récupération de toutes les inscriptions inscriptions = models.FormSemestreInscription.query.all() sems = [] + # Filtre les inscriptions contenant l'étudiant for sem in inscriptions: - if etudid is not None: + if etudid is not None: # Si route etudid if sem.etudid == etudid: sems.append(sem) - if nip is not 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() if sem.etudid == etu.etudid: sems.append(sem) - if ine is not None: + + if ine is not None: # Si route ine + # Récupération de l'étudiant etu = models.Identite.query.filter_by(code_ine=ine).firt() if sem.etudid == etu.etudid: sems.append(sem) + # Mise en forme des données data_inscriptions = [d.to_dict() for d in sems] formsemestres = [] + # Filtre les formsemestre contenant les inscriptions de l'étudiant for sem in data_inscriptions: res = models.FormSemestre.query.filter_by(id=sem['formsemestre_id']).first() formsemestres.append(res) data = [] + # Mise en forme des données for formsem in formsemestres: data.append(formsem.to_dict()) @@ -262,23 +307,29 @@ def etudiant_formsemestres(etudid=None, nip=None, ine=None): @bp.route("/etudiant/etudid//formsemestre//bulletin", methods=["GET"]) @bp.route("/etudiant/nip//formsemestre//bulletin", methods=["GET"]) @bp.route("/etudiant/ine//formsemestre//bulletin", methods=["GET"]) -def etudiant_bulletin_semestre(formsemestre_id, etudid=None, nip=None, ine=None): +def etudiant_bulletin_semestre(formsemestre_id, etudid: int = None, nip: int = None, ine: int = None): """ - 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é + + formsemestre_id : l'id d'un formsemestre + etudid : l'etudid d'un étudiant + nip : le code nip d'un étudiant + ine : le code ine d'un étudiant """ - # fonction to use: make_json_formsemestre_bulletinetud() - if etudid is not None: + # Fonction utilisée : app.scodoc.sco_bulletins_json.make_json_formsemestre_bulletinetud() + + etu = None + if etudid is not None: # Si route etudid return make_json_formsemestre_bulletinetud(formsemestre_id, etudid) else: - etu = None - if nip is not None: + if nip is not None: # Si route nip etu = models.Identite.query.filter_by(code_nip=nip).first() - if ine is not None: + if ine is not None: # Si route ine etu = models.Identite.query.filter_by(code_nip=ine).first() - if etu is not None: - return make_json_formsemestre_bulletinetud(formsemestre_id, etu.etudid) + if etu is not None: # Si route nip ou ine + return make_json_formsemestre_bulletinetud(formsemestre_id, etu.etudid) # return error_response(501, message="Not implemented") @@ -292,21 +343,34 @@ def etudiant_bulletin_semestre(formsemestre_id, etudid=None, nip=None, ine=None) @bp.route( "/etudiant/ine//semestre//groups", methods=["GET"] ) -def etudiant_groups(formsemestre_id: int, etudid=None, nip=None, ine=None): +def etudiant_groups(formsemestre_id: int, etudid: int = None, nip: int = None, ine: int = None): """ - Liste des groupes auxquels appartient l'étudiant dans le semestre indiqué + Retourne la liste des groupes auxquels appartient l'étudiant dans le semestre indiqué + + formsemestre_id : l'id d'un formsemestre + etudid : l'etudid d'un étudiant + nip : le code nip d'un étudiant + ine : le code ine d'un étudiant """ - # fonction to use : get_etud_groups + # Fonction utilisée : app.scodoc.sco_groups.get_etud_groups() if etudid is None: - if nip is not 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 sont etudid etudid = etu.etudid - if ine is not None: + + 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 sont etudid etudid = etu.etudid + + # Récupération du formsemestre sem = models.FormSemestre.query.filter_by(id=formsemestre_id).first() try: + # Utilisation de la fonction get_etud_groups 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") @@ -320,10 +384,12 @@ def etudiant_groups(formsemestre_id: int, etudid=None, nip=None, ine=None): @bp.route("/formations", methods=["GET"]) def formations(): """ - Liste des formations + Retourne la liste des formations """ + # Récupération de toutes les formations list_formations = models.Formation.query.all() + # Mise en forme des données data = [d.to_dict() for d in list_formations] return jsonify(data) @@ -332,10 +398,14 @@ def formations(): @bp.route("/formations/", 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() + Retourne une formation en fonction d'un id donné + formation_id : l'id d'une formation + """ + # Récupération de la formation + forma = models.Formation.query.filter_by(id=formation_id).first() + + # Mise en forme des données data = [d.to_dict() for d in forma] return jsonify(data) @@ -344,9 +414,12 @@ def formations_by_id(formation_id: int): @bp.route("/formations/formation_export/", methods=["GET"]) def formation_export_by_formation_id(formation_id: int, export_ids=False): """ - La formation, avec UE, matières, modules + Retourne la formation, avec UE, matières, modules """ + # Fonction utilité : app.scodoc.sco_formations.formation_export() + try: + # 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") @@ -357,14 +430,19 @@ def formation_export_by_formation_id(formation_id: int, export_ids=False): @bp.route("/formations/apo/", methods=["GET"]) def formsemestre_apo(etape_apo: int): """ - Information sur les formsemestres + Retourne les informations sur les formsemestres + + etape_apo : l'id d'une étape apogée """ + # Récupération des formsemestres apos = models.FormSemestreEtape.query.filter_by(etape_apo=etape_apo).all() data = [] + # Filtre les formsemestres correspondant + mise en forme des données for apo in apos: formsem = models.FormSemestre.query.filter_by(id=apo["formsemestre_id"]).first() data.append(formsem.to_dict()) + return jsonify(data) # return error_response(501, message="Not implemented") @@ -372,24 +450,32 @@ def formsemestre_apo(etape_apo: int): @bp.route("/formations/moduleimpl/", methods=["GET"]) def moduleimpls(moduleimpl_id: int): """ - Liste des moduleimpl - """ - list_moduleimpls = models.ModuleImpl.query.filter_by(id=moduleimpl_id) + Retourne la liste des moduleimpl + moduleimpl_id : l'id d'un moduleimpl + """ + # Récupération des tous les moduleimpl + list_moduleimpls = models.ModuleImpl.query.filter_by(id=moduleimpl_id).all() + + # Mise en forme des données data = list_moduleimpls[0].to_dict() return jsonify(data) @bp.route( - "/formations/moduleimpl//formsemestre/", - methods=["GET"], -) + "/formations/moduleimpl//formsemestre/", methods=["GET"]) def moduleimpls_sem(moduleimpl_id: int, formsemestre_id: int): """ - Liste de moduleimpl d'un semestre + Retourne la liste des moduleimpl d'un semestre + + moduleimpl_id : l'id d'un moduleimpl + formsemestre_id : l'id d'un formsemestre """ + # 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") @@ -416,10 +502,15 @@ def eus(dept: str, sem_id: int): @bp.route("/formations/formsemestre/", methods=["GET"]) def formsemestre(formsemestre_id: int): """ - Information sur le formsemestre correspondant au formsemestre_id + Retourne l'information sur le formsemestre correspondant au formsemestre_id + + formsemestre_id : l'id d'un formsemestre + """ + # Récupération de tous les formsemestres list_formsemetre = models.FormSemestre.query.filter_by(id=formsemestre_id) + # Mise en forme des données data = list_formsemetre[0].to_dict() return jsonify(data) @@ -439,8 +530,15 @@ def formsemestre(formsemestre_id: int): ) def etudiant_bulletin(formsemestre_id, dept, etudid, format="json", *args, size): """ - Un bulletin de note + Retourne le bulletin de note d'un étudiant + + formsemestre_id : l'id d'un formsemestre + etudid : l'etudid d'un étudiant + nip : le code nip d'un étudiant + ine : le code ine d'un étudiant """ + # Fonction utilisée : app.scodoc.sco_bulletins.formsemestre_billetinetud_dict() + data = [] if args[0] == "short": data = formsemestre_bulletinetud_dict(formsemestre_id, etudid, version=args[0]) @@ -457,11 +555,14 @@ def etudiant_bulletin(formsemestre_id, dept, etudid, format="json", *args, size) @bp.route("/formsemestre//bulletins", methods=["GET"]) def bulletins(formsemestre_id: int): """ - Les bulletins d'un formsemestre donné + Retourne les bulletins d'un formsemestre donné + + formsemestre_id : l'id d'un formesemestre """ - # fonction to use : formsemestre_recapcomplet + # Fonction utilisée : app.scodoc.sco_recapcomplet.formsemestre_recapcomplet() 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") @@ -472,11 +573,14 @@ def bulletins(formsemestre_id: int): @bp.route("/formsemestre//jury", methods=["GET"]) def jury(formsemestre_id: int): """ - Le récapitulatif des décisions jury + Retourne le récapitulatif des décisions jury + + formsemestre_id : l'id d'un formsemestre """ - # fonction to use : formsemestre_pvjury + # Fonction utilisée : app.scodoc.sco_pvjury.formsemestre_pvjury() 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") @@ -490,13 +594,18 @@ def jury(formsemestre_id: int): @bp.route("/partitions/", methods=["GET"]) def partition(formsemestre_id: int): """ - La liste de toutes les partitions d'un formsemestre + Retourne la liste de toutes les partitions d'un formsemestre + + formsemestre_id : l'id d'un formsemestre """ - partitions = models.Partition.query.filter_by(id=formsemestre_id) + # Récupération de toutes les partitions + partitions = models.Partition.query.filter_by(id=formsemestre_id).all() + + # Mise en forme des données data = [d.to_dict() for d in partitions] - # return jsonify(data) - return error_response(501, message="Not implemented") + return jsonify(data) + # return error_response(501, message="Not implemented") # @bp.route( @@ -507,17 +616,22 @@ def partition(formsemestre_id: int): @bp.route("/partitions/groups//etat/", methods=["GET"]) def etud_in_group(group_id: int, etat=None): """ - Liste des étudiants dans un groupe - """ - # fonction to use : get_group_members + Retourne la liste des étudiants dans un groupe - if etat is None: + group_id : l'id d'un groupe + etat : + """ + # 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: + 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") @@ -526,17 +640,22 @@ def etud_in_group(group_id: int, etat=None): @bp.route( - "/partitions/set_groups?partition_id=&groups_lists=&groups_to_create=&groups_to_delete=", methods=["POST"], + "/partitions/set_groups?partition_id=&groups_lists=&" + "groups_to_create=&groups_to_delete=", methods=["POST"], ) @token_auth.login_required -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 + + partition_id : l'id d'une partition + groups_lists : + groups_ti_delete : les groupes à supprimer + groups_to_create : les groupes à créer """ + # Fonction utilisée : app.scodoc.sco_groups.setGroups() try: + # Utilisation de la fonction setGroups setGroups(partition_id, groups_lists, groups_to_create, groups_to_delete) return error_response(200, message="Groups set") except ValueError: @@ -549,9 +668,14 @@ def set_groups( @bp.route("/evaluations/", methods=["GET"]) def evaluations(moduleimpl_id: int): """ - Liste des évaluations à partir de l'id d'un moduleimpl + Retourne la liste des évaluations à partir de l'id d'un moduleimpl + + moduleimpl_id : l'id d'un moduleimpl """ - evals = models.Evaluation.query.filter_by(id=moduleimpl_id) + # Récupération de toutes les évaluations + evals = models.Evaluation.query.filter_by(id=moduleimpl_id).all() + + # Mise en forme des données data = [d.to_dict() for d in evals] return jsonify(data) @@ -561,10 +685,14 @@ def evaluations(moduleimpl_id: int): @bp.route("/evaluations/eval_notes/", methods=["GET"]) def evaluation_notes(evaluation_id: int): """ - Liste des notes à partir de l'id d'une évaluation donnée + Retourne la liste des notes à partir de l'id d'une évaluation donnée + + evaluation_id : l'id d'une évaluation """ - # fonction to use : do_evaluation_get_all_notes + # Fonction utilisée : app.scodoc.sco_evaluation_db.do_evaluation_get_all_notes() + 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") @@ -576,14 +704,20 @@ def evaluation_notes(evaluation_id: int): @bp.route("/evaluations/eval_set_notes?eval_id=&nip=¬e=", methods=["POST"]) @bp.route("/evaluations/eval_set_notes?eval_id=&ine=¬e=", methods=["POST"]) @token_auth.login_required -def evaluation_set_notes(eval_id: int, etudid: int, note: float): +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 + + eval_id : l'id d'une évaluation + note : la note à attribuer + etudid : l'etudid d'un étudiant + nip : le code nip d'un étudiant + ine : le code ine d'un étudiant """ - # fonction to use : notes_add + # Fonction utilisée : app.scodoc.sco_saisie_notes.notes_add() # Qu'est ce qu'un user ??? - #notes_add() + # notes_add() return error_response(501, message="Not implemented") @@ -594,10 +728,13 @@ def evaluation_set_notes(eval_id: int, etudid: int, note: float): @bp.route("/jury/formsemestre//preparation_jury", methods=["GET"]) def jury_preparation(formsemestre_id: int): # XXX TODO check à quoi resemble le retour de la fonction """ - Feuille de préparation du jury - """ - # fonction to use : feuille_preparation_jury() + Retourne la feuille de préparation du jury + formsemestre_id : l'id d'un formsemestre + """ + # Fonction utilisée : app.scodoc.sco_prepajury.feuille_preparation_jury() + + # Utilisation de la fonction feuille_preparation_jury prepa_jury = feuille_preparation_jury(formsemestre_id) return error_response(501, message="Not implemented") @@ -607,24 +744,35 @@ def jury_preparation(formsemestre_id: int): # XXX TODO check à quoi resemble le def jury_decisions(formsemestre_id: int): # XXX TODO check à quoi resemble le retour de la fonction """ Retourne les décisions du jury suivant un formsemestre donné - """ - # fonction to use : formsemestre_pvjury + formsemestre_id : l'id d'un formsemestre + """ + # Fonction utilisée : app.scodoc.sco_pvjury.formsemestre_pvjury() + + # Utilisation de la fonction formsemestre_pvjury decision_jury = formsemestre_pvjury(formsemestre_id) return error_response(501, message="Not implemented") -@bp.route("/jury/set_decision/etudid?etudid=&formsemestre_id=&jury=&devenir=&assiduite=", methods=["POST"]) -@bp.route("/jury/set_decision/nip?etudid=&formsemestre_id=&jury=&devenir=&assiduite=", methods=["POST"]) -@bp.route("/jury/set_decision/ine?etudid=&formsemestre_id=&jury=&devenir=&assiduite=", methods=["POST"]) -def set_decision_jury(formsemestre_id: int, decision_jury: str, devenir_jury: str, assiduite: bool, etudid=None, - nip=None, ine=None): +@bp.route("/jury/set_decision/etudid?etudid=&formsemestre_id=" + "&jury=&devenir=&assiduite=", methods=["POST"]) +@bp.route("/jury/set_decision/nip?etudid=&formsemestre_id=" + "&jury=&devenir=&assiduite=", methods=["POST"]) +@bp.route("/jury/set_decision/ine?etudid=&formsemestre_id=" + "&jury=&devenir=&assiduite=", 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): """ Attribuer la décision du jury et le devenir à un etudiant + + formsemestre_id : l'id d'un formsemestre + decision_jury : la décision du jury + devenir_jury : le devenir du jury + assiduite : True ou False + etudid : l'etudid d'un étudiant + nip: le code nip d'un étudiant + ine : le code ine d'un étudiant """ return error_response(501, message="Not implemented") @@ -632,9 +780,14 @@ def set_decision_jury(formsemestre_id: int, decision_jury: str, devenir_jury: st @bp.route("/jury/etudid//formsemestre//annule_decision", methods=["DELETE"]) @bp.route("/jury/nip//formsemestre//annule_decision", methods=["DELETE"]) @bp.route("/jury/ine//formsemestre//annule_decision", methods=["DELETE"]) -def annule_decision_jury(formsemestre_id: int, etudid=None, nip=None, ine=None): +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é + + formsemestre_id : l'id d'un formsemestre + etudid : l'etudid d'un étudiant + nip: le code nip d'un étudiant + ine : le code ine d'un étudiant """ return error_response(501, message="Not implemented") @@ -645,22 +798,33 @@ def annule_decision_jury(formsemestre_id: int, etudid=None, nip=None, ine=None): @bp.route("/absences/etudid/", methods=["GET"]) @bp.route("/absences/nip/", methods=["GET"]) @bp.route("/absences/ine/", methods=["GET"]) -def absences(etudid=None, nip=None, ine=None): +def absences(etudid: int = None, nip: int = None, ine: int = None): """ - Liste des absences d'un étudiant donné + Retourne la liste des absences d'un étudiant donné + + etudid : l'etudid d'un étudiant + nip: le code nip d'un étudiant + ine : le code ine d'un étudiant """ - abs = "" - if etudid is not None: + 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: + if nip is not None: # Si route nip + # Récupération de l'étudiant 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() + # Récupération des absences de l'étudiant abs = models.Absence.query.filter_by(etudid=etu.etudid).all() - if abs != "": + 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() + + if abs is not None: # Si des absences ont bien été trouvé + # Mise en forme des données data = [d.to_dict() for d in abs] return jsonify(data) @@ -670,22 +834,33 @@ def absences(etudid=None, nip=None, ine=None): @bp.route("/absences/etudid//abs_just_only", methods=["GET"]) @bp.route("/absences/nip//abs_just_only", methods=["GET"]) @bp.route("/absences/ine//abs_just_only", methods=["GET"]) -def absences_justify(etudid=None, nip=None, ine=None): +def absences_justify(etudid: int = None, nip: int = None, ine: int = None): """ - Liste des absences justifiés d'un étudiant donné + Retourne la liste des absences justifiées d'un étudiant donné + + etudid : l'etudid d'un étudiant + nip: le code nip d'un étudiant + ine : le code ine d'un étudiant """ - abs = "" - if etudid is not None: + 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: + if nip is not None: # Si route nip + # Récupération de l'étudiant 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() + # Récupération des absences justifiées de l'étudiant abs = models.Absence.query.filter_by(etudid=etu.etudid, estjust=True).all() - if abs != "": + 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() + + if abs is not None: # Si des absences ont bien été trouvé + # Mise en forme des données data = [d.to_dict() for d in abs] return jsonify(data) @@ -701,75 +876,117 @@ def absences_justify(etudid=None, nip=None, ine=None): @bp.route("/absences/abs_signale?ine=&date=&matin=&justif=" "&description=&moduleimpl_id=", methods=["POST"]) @token_auth.login_required -def abs_signale(date: datetime, matin: bool, justif: bool, etudid=None, nip=None, ine=None, description=None, - moduleimpl_id=None): +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): """ Permet d'ajouter une absence en base + + date : la date de l'absence + matin : True ou False + justif : True ou False + etudid : l'etudid d'un étudiant + nip: le code nip d'un étudiant + ine : le code ine d'un étudiant + description : description possible à ajouter sur l'absence + moduleimpl_id : l'id d'un moduleimpl """ - # fonction to use : add_absence, add_justif - if description is not None: - if moduleimpl_id is not None: - if etudid is not None: + # 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: + + 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: + + 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: - if etudid is not None: + + 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: + + 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: + + 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: + 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: + + 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: + + 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") @@ -781,19 +998,32 @@ def abs_signale(date: datetime, matin: bool, justif: bool, etudid=None, nip=None @bp.route("/absences/abs_annule?nip=&jour=&matin=", methods=["POST"]) @bp.route("/absences/abs_annule?ine=&jour=&matin=", methods=["POST"]) @token_auth.login_required -def abs_annule(jour: datetime, matin: str, etudid=None, nip=None, ine=None): +def abs_annule(jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None): """ Retourne un html + + jour : la date de l'absence a annulé + matin : True ou False + etudid : l'etudid d'un étudiant + nip: le code nip d'un étudiant + ine : le code ine d'un étudiant """ - # fonction to use : annule_absence + # Fonction utilisée : app.scodoc.sco_abs.annule_absence() + if etudid is None: - if nip is not 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: + + 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") @@ -805,19 +1035,32 @@ def abs_annule(jour: datetime, matin: str, etudid=None, nip=None, ine=None): @bp.route("/absences/abs_annule_justif?nip=&jour=&matin=", methods=["POST"]) @bp.route("/absences/abs_annule_justif?ine=&jour=&matin=", methods=["POST"]) @token_auth.login_required -def abs_annule_justif(jour: datetime, matin: str, etudid=None, nip=None, ine=None): +def abs_annule_justif(jour: datetime, matin: str, etudid: int = None, nip: int = None, ine: int = None): """ Retourne un html + + jour : la date de l'absence a annulé + matin : True ou False + etudid : l'etudid d'un étudiant + nip: le code nip d'un étudiant + ine : le code ine d'un étudiant """ - # fonction to use : annule_justif + # Fonction utilisée : app.scodoc.sco_abs.annule_justif() + if etudid is None: - if nip is not 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: + + 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_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") @@ -825,21 +1068,21 @@ def abs_annule_justif(jour: datetime, matin: str, etudid=None, nip=None, ine=Non return error_response(200, message="OK") -@bp.route( - "/absences/abs_group_etat/?group_id=&date_debut=date_debut&date_fin=date_fin", - methods=["GET"], -) -def abs_groupe_etat( - group_id: int, date_debut, date_fin, with_boursier=True, format="html" -): +@bp.route("/absences/abs_group_etat/?group_id=&date_debut=date_debut&date_fin=date_fin", methods=["GET"]) +def abs_groupe_etat(group_id: int, date_debut, date_fin, with_boursier=True, format="html"): """ - Liste des absences d'un ou plusieurs groupes entre deux dates + Retoune la liste des absences d'un ou plusieurs groupes entre deux dates """ + # Fonction utilisée : app.scodoc.sco_groups.get_group_members() et app.scodoc.sco_abs.list_abs_date() + try: + # 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") + data = [] + # Filtre entre les deux dates renseignées for member in members: abs = list_abs_date(member.id, date_debut, date_fin) data.append(abs) @@ -874,6 +1117,8 @@ def liste_logos(format="json"): def recup_logo_global(logo_name: str): """ Retourne l'image au format png ou jpg + + logo_name : le nom du logo rechercher """ # fonction to use find_logo # try: @@ -887,12 +1132,12 @@ def recup_logo_global(logo_name: str): # return res - - @bp.route("/departements//logos", methods=["GET"]) def logo_dept(dept: str): """ Liste des logos définis pour le département visé. + + dept : l'id d'un département """ # fonction to use: _list_dept_logos # dept_id = models.Departement.query.filter_by(acronym=dept).first() @@ -911,6 +1156,9 @@ def logo_dept(dept: str): def recup_logo_dept_global(dept: str, logo_name: str): """ L'image format png ou jpg + + dept : l'id d'un département + logo_name : le nom du logo rechercher """ # fonction to use find_logo # dept_id = models.Departement.query.filter_by(acronym=dept).first() @@ -923,3 +1171,306 @@ def recup_logo_dept_global(dept: str, logo_name: str): # return error_response(200, message="Aucun logo trouvé correspondant aux informations renseignés") # # return res + + + +################################################## Tests ############################################################## + +import requests +import os + +SCODOC_USER = "" +SCODOC_PASSWORD = "" +SCODOC_URL = "" +CHECK_CERTIFICATE = bool(int(os.environ.get("CHECK_CERTIFICATE", False))) + +r0 = requests.post( + SCODOC_URL + "/ScoDoc/api/tokens", auth=(SCODOC_USER, SCODOC_PASSWORD) + ) +token = r0.json()["token"] +HEADERS = {"Authorization": f"Bearer {token}"} + + +def test_routes_departements(): + """ + Test les routes de la partie Département + """ + # departements + r1 = requests.post( + SCODOC_URL + "/ScoDoc/api/departements", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # liste_etudiants + r2 = requests.post( + SCODOC_URL + "/ScoDoc/api/departements//etudiants/liste/", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # liste_semestres_courant + r3 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # referenciel_competences + r4 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # semestre_index + r5 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + +def test_routes_etudiants(): + """ + Test les routes de la partie Etudiants + """ + r1 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + r2 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + r3 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + r4 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + r5 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + r6 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + +def test_routes_formation(): + """ + Test les routes de la partie Formation + """ + # formations + r1 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # formations_by_id + r2 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # formation_export_by_formation_id + r3 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # formsemestre_apo + r4 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # moduleimpls + r5 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # moduleimpls_sem + r6 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + +def test_routes_formsemestres(): + """ + Test les routes de la partie Formsemestres + """ + # formsemestre + r1 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # etudiant_bulletin + r2 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # bulletins + r3 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # jury + r4 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + +def test_routes_partitions(): + """ + Test les routes de la partie Partitions + """ + # partition + r1 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # etud_in_group + r2 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # set_groups + r3 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + +def test_routes_evaluations(): + """ + Test les routes de la partie Evaluations + """ + # evaluations + r1 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # evaluation_notes + r2 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # evaluation_set_notes + r3 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + +def test_routes_jury(): + """ + Test les routes de la partie Jury + """ + # jury_preparation + r1 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # jury_decisions + r2 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # set_decision_jury + r3 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # annule_decision_jury + r4 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + +def test_routes_absences(): + """ + Test les routes de la partie Absences + """ + # absences + r1 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # absences_justify + r2 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # abs_signale + r3 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # abs_annule + r4 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # abs_annule_justif + r5 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # abs_groupe_etat + r6 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + +def test_routes_logos(): + """ + Test les routes de la partie Logos + """ + # liste_logos + r1 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # recup_logo_global + r2 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # logo_dept + r3 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + ) + + # recup_logo_dept_global + r4 = requests.post( + SCODOC_URL + "/ScoDoc/api", + auth=(SCODOC_USER, SCODOC_PASSWORD) + )