@@ -17,14 +17,18 @@ Ticket décrit sur [cette page](https://scodoc.org/git/ScoDoc/ScoDoc/issues/1030
>*Labels : Enhancement*
>
>Liste tous les modules où est inscrit l'étudiant avec possibilité de saisie de note
>
>(vérifier compatibilité avec l historique des saisies)
>
>**Commentaire 1**
>
>- Lister les évaluations par ordre de modules / évaluation
>- Rappeler note(s) existante(s)
>- Indiquer clairement le barème (notes sur 10, sur N...)
>- Sauvegarder au fur et à mesure (utilisation API notes)
>- Gérer correctement les permissions (le(s) resp. de semestre(s) et admins)
>**Commentaire 2**
>
>En option:
Afficher les notes des modules correspondants semestres précédents (au cas où l utiliser voudrait conserver d anciennes notes)
...
...
@@ -117,29 +121,29 @@ return render_template(
### 2.2 - Proposition d'implémentation
Maintenant que nous savons où l'implémentation doit être faite, il faut savoir ce que nous allons rendre accessible afin de résoudre le ticket, dans ce but nous avons deux idées différentes sur comment permettre la visualisation des modules & notes manquantes:
- Nous pourrions implémenter un menu déroulant sur la page de l'etudiant, similaire à la rubrique "Devenir" déjà présente
- Nous pourrions aussi créer une nouvelle page, accessible depuis un bouton "modifier notes" amenant à une page externe, que nous pourrions faire visuellement ressembler au bouton permettant d'inscrire à un autre semestre
Maintenant que nous savons où l'implémentation doit être faite, il faut déterminer comment rendre accessibles les informations nécessaires pour résoudre le ticket. Pour cela, nous avons envisagé deux approches permettant la visualisation des modules et des notes :
- Ajouter un menu déroulant sur la page de l'étudiant, similaire à la rubrique `Devenir` déjà présente.
- Créer une nouvelle page, accessible via un bouton `Modifier notes`, qui redirigerait vers une page externe. Ce bouton pourrait visuellement ressembler à celui permettant l'inscription à un autre semestre.
Nous avons réfléchi à la manière d'implémenter efficacement l'affichage de toutes les notes sur la page actuelle, car nous travaillerons avec une base existant déjà, et ça serait plus simple d'avoir "simplement" une nouvelle section, visuellement ça serait plus simple à voir, il n'y aurait pas à chercher après.
Nous avons réfléchi à la manière d'afficher efficacement toutes les notes sur la page actuelle. Étant donné que nous travaillons sur une base existante, il serait plus simple d'ajouter une nouvelle section plutôt que de disperser les informations, ce qui faciliterait la lecture et la navigation.
Après avoir regardé ce qui serait le plus logique et s'intégrant le mieux à l'application, nous avons décidé de l'implémenter en menu déroulant.
Après avoir analysé ce qui s'intégrerait le mieux à l'application, nous avons décidé d'opter pour un menu déroulant.
L'idée serait de reproduire ce que l'on retrouve sur la page `Bas de cas de jury` d'un semestre de l'étudiant, avec toutes les notes de chaque module, comprenant un champ modifiable pour chacune :
L'idée est de reproduire le comportement que l'on retrouve sur la page `Bas de cas de jury` d'un semestre de étudiant, avec l'affichage de toutes les notes de chaque module. Chaque note disposerait d'un champ modifiable :
Ce ticket nous demande une implémentation en front-end et en back-end, en effet il faut afficher les notes des évaluations pour chaque modules sur la fiche étudiante, mais également permettre l'ajout et la modification de ces notes.
Ce ticket implique une implémentation à la fois en front-end et en back-end. En effet, il s'agit non seulement d'afficher les notes des évaluations pour chaque module sur la fiche étudiante, mais aussi de permettre leur ajout et leur modification.
#### 2.2.1 - Implémentation graphique
Nous avons plusieurs problèmes qu'il faut palier afin d'implémenter l'interface comme nous le souhaitons. Premièrement il faut récupérer les infos qui composent notre liste.
Nous avons plusieurs étapes pour implémenter l'interface comme nous le souhaitons. La première consiste à récupérer les informations nécessaires pour composer notre liste.
La première difficulté dans l'implémentation est de retrouver cette mise en page dans le code afin de réutiliser le style avec le HTML et les classes CSS correctes.
La première difficulté réside dans l'identification du code responsable de cette mise en page afin de réutiliser le bon style avec le HTML et les classes CSS appropriées.
On retrouve le template de l'affichage dans le fichier `app/static/js/releve-but.js`
Avec le code HTML :
```
On retrouve le template de l'affichage dans le fichier `app/static/js/releve-but.js`, dont le code HTML est :
```html
<section>
<div>
<h2>Ressources</h2>
...
...
@@ -152,15 +156,15 @@ Avec le code HTML :
<divclass=evaluations></div>
</section>
```
Ainsi que les méthodes `module()` et `evaluation()` qui le complètent.
Nous avons utilisé l'API de Scodoc dans Bruno pour identifier où récupérer les informations nécessaires. Cela nous a permis d'explorer plusieurs pistes, notamment l'appel de l'[endpoint bulletin](#problème-dapi).
Surtout, cela nous a amenés à réfléchir aux types utilisés dans le projet, car il nous semblait plus simple de récupérer ces informations de cette manière, en l'absence de fonctions dédiées trouvées pour le simplifier.
Et les methodes qui le complete `module()` et `evaluation()`
Nous avons utilisé l'API de Scodoc dans Bruno afin de savoir où nous pourrions trouver les informations dont nous avons besoin. Cela nous a permis de trouver plusieurs pistes, dont celle de l'appel de l'[endpoint bulletin](#problème-dapi), mais surtout cela nous a fait réfléchir aux types utilisées dans le projet, car cela nous semblait être le moyen de plus simple de récupérer les informations qu'il nous faut, faute de fonction permettant de faire ça déjà implémentées, ou du moins faute de fonctions que nous avons trouvées qui nous permettrait de faire cela plus simplement.
En obervant le code, nous avons vu qu'un étudiant est de représenté par le type "Identite", et que les modules que nous cherchons sont trouvable dans un objet de type FormSemestre, le type représentant un semestre d'une formation.
Depuis l'étudiant, nous avons la fonction ```Identite.get_formsemestres()``` permettant de récupérer les différents semestres auquelles l'étudiant est inscrit, et depuis ces semestres, nous avons l'attribut ```FormSemestre.modimpls_sorted``` permettant de récupérer les modules du semestre, que nous pouvons trier selon leur type, afin de ne garder que les modules étant intéressant pour nous, c'est à dire les ressources et les SAE.
Cela peut se faire de la manière suivante:
En observant le code, nous avons constaté qu'un étudiant est représenté par le type `Identite`, et que les modules que nous cherchons sont accessibles à travers un objet de type `FormSemestre`, qui représente un semestre d'une formation.
Depuis un étudiant, nous pouvons utiliser la méthode ```Identite.get_formsemestres()``` pour récupérer les semestres auxquels il est inscrit. Ensuite, depuis ces semestres, l'attribut ```FormSemestre.modimpls_sorted``` permet d'accéder aux modules d'un semestre.
Nous pouvons alors filtrer les modules selon leur type pour ne conserver que ceux qui nous intéressent, à savoir les ressources et les SAE.
Cela peut se faire ainsi :
```python
m_list={
scu.ModuleType.RESSOURCE:[],
...
...
@@ -173,14 +177,19 @@ Cela peut se faire de la manière suivante:
m_list[modimpl.module.module_type].append(d)
```
Grâce a cela, nous avons tous les modules d'un étudiant, la logique serait d'ensuite récupérer les notes d'un étudiant dans ce module, mais cela n'a pas eu l'occasion d'être implémenter dans le temps qui nous était imparti, ce sont purements des idées qui pourraient ou non fonctionner:
Nous observons dans le code qu'un ModuleImpl à un attribut "evaluations" qui est une liste d'objets Evaluations, triées.
À partir d'ici, nous avons la méthode ```Evaluation.get_etud_note()```, prennant un étudiant et nous donnant sa note.
Grâce à cette approche, nous obtenons tous les modules d'un étudiant. La logique ensuite consisterait à récupérer ses notes pour chaque module.
Faute de temps, cette partie n'a pas pu être implémentée, mais voici une piste potentielle :
Nous observons dans le code qu'un `ModuleImpl` possède un attribut `evaluations`, qui est une liste d'objets `Evaluations` triée.
À partir de ces évaluations, nous avons la méthode ```Evaluation.get_etud_note()``` permettant de récupérer la note de l'étudiant passé en paramètre.
Avec ces éléments, nous serions déjà capable d'obtenir et d'afficher les notes des étudiants. Ce qui poserait maintenant problème est l'affichage dans un champ de saisie dans lequel nous aurions les notes déjà présentes modifiables et un champ vide quand la méthode "get_etud_note()" nous renvois None, en cas de manque de note pour l'évaluation courante.
Avec ces éléments, nous serions déjà capables d'afficher les notes des étudiants.
Ce qu'il faut désormais est l'affichage des notes dans un champ de saisie. Les notes existantes doivent être modifiables, tandis qu'en l'absence de note pour une évaluation, lorsque la méthode `get_etud_note()` renvoie None, le champ doit rester vide.
C'est dans la seconde partie que nous voyons cela.
#### 2.2.2 - Implémenter la phase mise à jour des notes
#### 2.2.2 - Implémenter la mise à jour des notes
Une fois que les notes sont affichées, l'utilisateur doit pouvoir les modifier, et elles doivent être sauvegardées en direct à chaque modification.
Tout d'abord, nous recherchons si cette fonctionnalité est déjà implémentée quelque part. Logiquement, une page permettant de saisir les notes des étudiants pour une évaluation doit exister.
...
...
@@ -188,7 +197,7 @@ Nous avons trouvé un endroit où les notes sont mises à jour comme supposé (p
En ouvrant les devtools pour inspecter un élément note, on retrouve ceci :
@@ -221,9 +230,11 @@ Ainsi, pour enregistrer les changements de notes, il faudrait effectuer une requ
### Problème d'API
Comme dit dans la partie [2.2.1](#221---implémentation-graphique), nous avons utilisé l'API de Scodoc afin de savoir quels pistes seraient utilisable afin de récupérer les informations comme les modules et leurs notes associées pour un étudiant.
En utlisant cette API, nous avons vu l'endpoint ``` /ScoDoc/api/etudiant/<string:code_type>/<string:code>/formsemestre/<int:formsemestre_id>/bulletin ``` qui nous semblais prometteur car l'[exemple d'utilisation de cet endpoint](https://scodoc.org/samples/sample_bulletin.json/) nous montre un accès aux ressources et aux notes associés pour l'élève, hors, lorseque nous avons essayé avec notre instance de Scodoc, nous n'avions pas la liste "ressources" présente sur l'exemple.
Comme mentionné dans la partie [2.2.1](#221---implémentation-graphique), nous avons utilisé l'API de Scodoc afin d'explorer les pistes possibles pour récupérer les informations, notamment les modules et leurs notes associées pour un étudiant.
En utilisant cette API, nous avons identifié l'endpoint ``` /ScoDoc/api/etudiant/<string:code_type>/<string:code>/formsemestre/<int:formsemestre_id>/bulletin ``` comme étant prometteur car l'[exemple d'utilisation de cet endpoint](https://scodoc.org/samples/sample_bulletin.json/) montre un accès aux ressources et aux notes associées à l'élève.
Cependant, lorsque nous avons testé cet appel sur notre instance de Scodoc, nous n'avons pas obtenu la liste "ressources" présente dans l'exemple.
Cela nous a semblé intriguant et donc après avoir chercher dans le code, nous avons trouvé que le fichier ```app\api\etudiants.py``` contient la méthode ```bulletin``` qui est sensé renvoyer ce que nous recevons dans l'API lors de l'appel que nous avons essayé. Dans ce code, le champ "ressources" n'est pas rempli.
Ce comportement nous a semblé intrigant. Après avoir exploré le code, nous avons trouvé que le fichier ```app\api\etudiants.py``` contient la méthode ```bulletin```, qui est censée renvoyer la réponse obtenue via l'API lorsque nous effectuons cet appel. Or, dans ce code, le champ "ressources" n'est pas renseigné.
Cela pourrais dire que la sample n'est pas bonne, ou alors que la documentation n'explique pas comment obtenir ces informations, qui pourraient être importantes.
\ No newline at end of file
Cela pourrait signifier que l'exemple fourni n'est pas correct, ou bien que la documentation ne précise pas les conditions nécessaires pour obtenir ces informations, qui pourraient pourtant être importantes.
