---
# System prepended metadata

title: BackLogTmp

---

# BackLogTmp

| ID          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | US liée(s) |
| ----------- |:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|:----------:|
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                            Création d'un fichier `authentification.ejs` correspondant à la page ou l'utilisateur doit se connecter. Au centre de la page se trouve un cadre ayant un texte "username". En dessous se trouve un `form` ou l'utilisateur doit rentrer son username. Et ensuite un bouton `submit` permettant d'envoyer les informations.                                                                                                                                                                                                                                                                                                                                                                                                                            |     U1     |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                  Création d'un fichier `authentification.js` correspondant à la page `authentification.ejs`. Ce fichier doit pouvoir récupérer l'username entré par l'utilisateur via un `GET` et faire un lien à notre base de données concernant l'authentification. Si l'username n'est pas existant alors cela crée un nouveau compte. Une fois fait, la page `home.ejs` doit être renvoyer.                                                                                                                                                                                                                                                                                                                                                                                                  |     U1     |
| T GHERKIN   |                                                                                                                                                                                                                                                                                                                                                                                                                         Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient que si un nouvel utilisateur se connecte pour la premiere fois, et qu'il utilise un nom non-utilisé, alors il est bien ajouté à la base. Si le nom est déja utilisé, alors rien est ajouté à la base et l'utilisateur est redirigé vers la page `home`.                                                                                                                                                                                                                                                                                                                                                                                                                          |     U1     |
| T           |                                                                                                                                                                                                                                                                                                                                     Création d'un fichier `header.ejs` qui contient une `navBar` qui sera affichée sur toutes les pages (excépté sur `autentification.ejs`). La `navBar` contient le nom du projet et en dessous une liste de bouton telle que : issue, task, sprint, planif, release, dev, test, documentation et homeProject. Chaque bouton redirige respectivement vers les pages `issues.ejs`, `task.ejs`, `sprint.ejs`, `planif.ejs`, `realease.ejs`, `dev.ejs`, `test.ejs` , `documentation.ejs `et `projectName.ejs`.                                                                                                                                                                                                                                                                                                                                      |            |
| T GHERKIN   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient que les différents boutons de la navbar redirige bien vers les pages correspondantes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |            |
| T           |                                                                                                                                                                                                                                                                                                       Creation d'un fichier `home.ejs` correspondant à la page ou l'utilisateur va pouvoir selectionner ou créer ses projets. En haut de la page se trouvera une bande prenant toute la largueur de la fenetre avec un texte centré indiquant `my projects`. En dessous de la bande `my Projects` ajouter une liste horizontale contenant les différents projets appartenant à l'utilisateur. Un projet est représenté par un cadre de forme carré qui à son centre contient le titre du projet. Un clic gauche effectué sur le cadre envoie la page principale du projet.                                                                                                                                                                                                                                                                                                        |            |
| T           |                                                                                                                                                                                                                                                                                                                                           Dans le fichier `home.ejs` ajouter à la fin de la liste contenant les projets un autre cadre de forme carré qui à son centre contient un `+`. Ce carré permettra l'affichage de la création d'un nouveau projet en cliquant dessus. Une fois après avoir cliqué sur le carré, la liste des projets sera mise verticalement sur le coté gauche de l'écran et sur la partie droite de l'écran se trouvera la partie contenant les champs pour ajouter le `name` du projet et sa `description`.                                                                                                                                                                                                                                                                                                                                            |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                         Création d'un fichier `home.js` correspondant à la page `home.ejs`. Ce script doit pouvoir lors de l'affichage de la page `home.ejs` récupérer la liste des projets de l'utilisateur contenu dans notre base de données (`db.collection.find(UserID)`) et l'afficher sur notre liste horizontale.                                                                                                                                                                                                                                                                                                                                                                                                                                         |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dans le fichier `home.js`, si l'utilisateur effectue un clic gauche sur un projet alors il sera redirigé sur la page `homeProject.ejs`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Dans le fichier `home.js`, si l'utilisateur effectue un clic droit sur un projet, alors un menu sera affiché à l'endroit du curseur avec les options `edit` et `delete`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |            |
| T           |                                                                                                                                                                                                                                                                                                                                L'option `edit` correspondra à la fonction `projectEdit()`. Elle permettra la mise en place de l'affichage permettant de modifier un projet, c'est-à-dire l'affichage des champs `name` et `description` avec des formes pour récupérer les informations et un bouton `submit` pour envoyer les informations. Une fois le bouton `submit` appuyé la base de données sera mise à jour (`db.collection.update(query)`), l'affichage du menu sera enlevé pour laissé place à la liste des projets (liste horizontale).                                                                                                                                                                                                                                                                                                                                |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                   L'option `delete` correspondra à la fonction `projectDelete()`. Elle demandera à l'utilisateur si celui-ci est sûr de vouloir supprimer le projet via un pop-up. S'il répond positivement alors le projet sera effacé de la base de données (`db.collection.remove(query)`).                                                                                                                                                                                                                                                                                                                                                                                                                                                    |            |
| T           |                                                                                                                                                                                                            Dans le fichier `home.js`, si l'utilisateur clique sur le carré contenant `+` alors l'affichage sera changé comme explique dans la `T?`. L'utilisateur pourra entrer le nom du project (obligatoire) à travers un champ ainsi que sa description (facultative). Une fois le ou les champs remplis il pourra appuyer le bouton `submit` afin de valider la création de son projet. Si le champ `name` est déjà dans la base de données alors un message d'erreur s'affichera pour indiquer à l'utilisateur que le nom du projet est déja prit. La base de données sera mise à jour (`db.collection.insert(query)`) avec les données entrées. Il pourra également annuler son souhait de vouloir créer un nouveau projet en appuyant sur le bouton `cancel`.                                                                                                                                                                                                             |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dans le fichier `home.js`, après que l'utilisateur ait appuyé sur le bouton `submit` ou `cancel` l'affichage de la partie edit sera enlevé pour laisser place à la liste des projets qui sera remise à l'horizontale grâce à la fonction `projectDefaultDisplay()`.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |            |
| T GHERKIN   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient que les données récupérées correspondent bien aux projets de l'utilisateur courant.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |     U3     |
| T GHERKIN   |                                                                                                                                                                                                                                                                                                                                                                                                      Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient que le projet a bien été supprimé ou modifié sur la page `home.ejs` et dans la base de données. Lors de la modification, on vérifie également que les données entrées par l'utilisateurs correspondent bien aux données enregistrées dans la base et à celle présente sur la page `home.ejs`.                                                                                                                                                                                                                                                                                                                                                                                                       |            |
| T           |                                                                                                                                                                                                                                                                                                           Création d'un fichier `homeProject.ejs` suite à la sélection d'un projet. Dans le header de la page se trouvera le fichier `header.ejs` afin d'avoir la `navBar`. En dessous de celle-ci se trouvera les informations liées au projet telles que : le nombre d'US totales, le nombre d'US réalisée, le pourcentage d'US réalisée, pareillement pour les tâches, la version actuelle du projet et le sprint actuel. Egalement, il devra avoir un graphique ayant pour but d'informer l'utilisateur sur le nombre de tâches réalisées pour chaque contributeur.                                                                                                                                                                                                                                                                                                           |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                Dans le fichier `homeProject.ejs` ajouter un bouton `Export` permettant à l'utilisateur de télécharger le backlog du projet en `.pdf` ou `.md`. Une fois le bouton appuyé une liste déroulante doit apparaitre laissant le choix à l'utilisateur du type de fichier qu'il souhaite.                                                                                                                                                                                                                                                                                                                                                                                                                                                |            |
| T           |                                                                                                                                                                                                                                                                      Création d'un fichier `homeProject.js` correspondant à la page `homeProject.ejs`. Ce script doit pouvoir lors de l'affichage de la page `homeProject.ejs` afficher les différentes informations liées au projet en faisant des requêtes à la base de données telles que : le nombre d'US totales (`db.collection.count()`), le nombre d'US réalisée (`db.collection.find(query).count`), le pourcentage d'US réalisée (`db.collection.count() / db.collection.find(query).count) * 100`), pareillement pour les tâches, la version actuelle du projet (`db.collection.find(query)`) et le sprint actuel (`db.collection.find(query)`).                                                                                                                                                                                                                                                                       |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                     Dans le fichier `homeProject.js`, aprés que l'utilisateur ait choisi le type de fichier qu'il veut exporter pour avoir le backlog du projet la fonction `projectExportBacklog(type)` doit être lancée avec `type` qui est soit `pdf` soit `md`. Cette fonction permettra de générer le backlog et lancera le téléchargement du fichier via le `browse` de l'utilisateur.                                                                                                                                                                                                                                                                                                                                                                                                      |            |
| T A CHANGER |                                                                                                                                                                                                                                                                                                                                                                                                                                                                         Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient que le nom de la page correspond à celui du projet et que les données sur le projet affichées sont les mêmes que les données de ce projet dans la base.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |            |
| T GHERKIN   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient qu'un fichier a bien été créé apres avoir cliqué sur le bouton export.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                          Création d'un fichier `dev.ejs` correspondant à la page ou l'utilisateur va gérer la partie developpeur du project. Dans le header de la page se trouvera le fichier `header.ejs` afin d'avoir la `navBar`. En dessous de celle-ci se trouvera une liste horizontale contenant les différents developpeur du projet. Un developpeur est représenté par un cadre de forme carré qui à son centre contient le nom du developpeur.                                                                                                                                                                                                                                                                                                                                                                          |            |
| T           |                                                                                                                                                                                                                                                                                                                                              Dans le fichier `dev.ejs` ajouter à la fin de la liste contenant les developpeurs un autre cadre de forme carré qui à son centre contient un `+`. Ce carré permettra l'affichage de l'ajout d'un nouveau developpeur en cliquant dessus. Une fois après avoir cliqué sur le carré, la liste des developpeurs sera mise verticalement sur le coté gauche de l'écran et sur la partie droite de l'écran se trouvera la partie contenant les champs pour ajouter le `name` du developpeur.                                                                                                                                                                                                                                                                                                                                              |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                              Création d'un fichier `dev.js` correspondant à la page `dev.ejs`. Ce script doit pouvoir lors de l'affichage de la page `dev.ejs` récupérer la liste des developpeurs du projet contenu dans notre base de données (`db.collection.find()`) et l'afficher sur notre liste horizontale.                                                                                                                                                                                                                                                                                                                                                                                                                                               |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Dans le fichier `dev.js`, si l'utilisateur effectue un clic droit sur un developpeur, alors un menu sera affiché à l'endroit du curseur avec les options `edit` et `delete`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |            |
| T           |                                                                                                                                                                                                                                                                                                                                        L'option `edit` correspondra à la fonction `devEdit()`. Cette fonction permettra la mise en place de l'affichage permettant de modifier un projet, c'est-à-dire l'affichage du champ `name` un forme pour récupérer les informations et un bouton `submit` pour envoyer l'informations. Une fois le bouton `submit` appuyé la base de données sera mise à jour (`db.collection.update(query)`), l'affichage du menu sera enlevé pour laissé place à la liste des developpeurs (liste horizontale).                                                                                                                                                                                                                                                                                                                                         |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                             L'option `delete` correspondra à la fonction `devDelete()`. Cette fonction demandera à l'utilisateur si celui-ci est sûr de vouloir supprimer le developpeur via un pop-up. S'il répond positivement alors le projet sera effacer de la base de données (`db.collection.remove(query)`).                                                                                                                                                                                                                                                                                                                                                                                                                                              |            |
| T           |                                                                                                                                                                                                                              Dans le fichier `dev.js`, si l'utilisateur clique sur le carré contenant `+` alors l'affichage sera changé comme explique dans la `T?`. L'utilisateur pourra entrer le nom du developpeur (obligatoire) à travers un champ. Une fois le champ rempli il pourra appuyer le bouton `submit` afin de valider la création de son projet. Si le champ `name` est déjà dans la base de données alors un message d'erreur s'affichera pour indiquer à l'utilisateur que le nom du developpeur est déja pris. La base de données sera mise à jour (`db.collection.insert(query)`) avec la données entrée. Il pourra également annuler son souhait de vouloir ajouter un nouveau developpeur en appuyant sur le bouton `cancel`.                                                                                                                                                                                                                              |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dans le fichier `dev.js`, aprés que l'utilisateur ait appuyé sur le bouton `submit` ou `cancel` l'affichage de la parte edit sera enlevé pour laisser place à la liste des developpeurs qui sera remise à l'horizontale grâce à la fonction `devDefaultDisplay()`.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |            |
| T GHERKIN   |                                                                                                                                                                                                                                                                                                                                                                                                   Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient que le nom des contributeurs affichés sont bien ceux associées au projets dans la base de données. Vérifier également si la suppression et la modification fonctionne correctement au niveau de l'affichage et de la base de données (vérifier l'entrée utilisateur dans le cas de la modification).                                                                                                                                                                                                                                                                                                                                                                                                   |            |
| T           |                                                                                                                                                                                                                                                                      Création d'un fichier `issues.ejs` correspondant à la page ou l'utilisateur va gérer les différentes issues du projet. Dans le header de la page se trouvera le fichier `header.ejs` afin d'avoir la `navBar`. En dessous de celle-ci se trouvera un tableau `backlog` contenant la liste des différentes issues du projet tel que (ID, Description, Difficulté, Priorité, Sprint). Sous ce tableau se trouvera un bouton `newIssue` permettant d'ajouter une nouvelle issue. Il sera possible de modifier les issues, donc un menu `edit` s'affichera sur la partie droite de l'écran et le backlog sera sur la partie gauche réduit.                                                                                                                                                                                                                                                                       |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Dans le fichier `issues.ejs`, au dessus du backlog se trouvera une liste déroulante permattant à l'utilisateur de choisir comment il veut trier le backlog, soit en fonction de la difficulté, soit de l'importance ou soit de l'id.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                         Création d'un fichier `issues.js` correspondant à la page `issues.ejs`. Si l'utilisateur effectue un clic droit sur une issue du backlog , alors un menu sera affiché à l'endroit du curseur avec les options `edit` et `delete`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |            |
| T           |                                                                                                                                                                         L'option `edit` correspondra à la fonction `issueEdit()`. Cette fonction permettra la mise en place de l'affichage permettant de modifier une issue, c'est-à-dire l'affichage de différent champs tels que `description`, `difficulté` et `l'importance` et un bouton `submit` pour envoyer l'informations. La `difficulté` devra être une valeur numérique appartenant à la suite de `Fibonacci`. Si le nombre n'appartient pas à la suite alors un message d'erreur sera affiché. `L'importance` sera affichée avec une liste déroulante contenant les valeurs `low/medium/high` avec `high` la plus grande importance. Une fois le bouton `submit` appuyé la base de données sera mise à jour (`db.collection.update(query)`) et l'affichage du menu sera enlevé pour laisser place à la liste des issues (liste horizontale).                                                                                                                                                                         |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                 L'option `delete` correspondra à la fonction `issueDelete()`. Cette fonction demandera à l'utilisateur si celui-ci est sûr de vouloir supprimer l'issue via un pop-up. S'il répond positivement alors l'issue sera effacée de la base de données (`db.collection.remove(query)`).                                                                                                                                                                                                                                                                                                                                                                                                                                                 |            |
| T           |                                                                                                                                                                                                                    Dans le fichier `issue.js`, si l'utilisateur clique sur le bouton `newIssue` alors l'affichage sera changé comme explique dans la `T?`. L'utilisateur pourra entrer la description de l'issue (obligatoire) à travers un champ. Une fois le champ rempli il pourra appuyer sur le bouton `submit` afin de valider la création de son projet. On enverra à la base de données la description entrée par l'utilisateur ainsi que l'ID de l'issue qui sera générée automatiquement en récupérant la derniere id du tableau et en lui ajoutant + 1. La base de données sera mise à jour (`db.collection.insert(query)`) .Il pourra également annuler son souhait de vouloir ajouter un nouveau developpeur en appuyant sur le bouton `cancel`.                                                                                                                                                                                                                     |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dans le fichier `issue.js`, aprés que l'utilisateur ait appuyé sur le bouton `submit` ou `cancel` l'affichage de la parte edit sera enlevée pour laissé place à la liste des developpeurs qui sera remise à l'horizontale grâce à la fonction `issueDefaultDisplay()`.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                              Dans le fichier `issue.js`, après que l'utilisateur ait choisi le type de tri qu'il veut avoir pour le backlog, la fonction `sortBacklog(type)` doit être lancée avec `type` qui est soit `difficulty`, `importance` ou `id`. Cette fonction mettra à jour l'affichage du backlog en fonction du tableau aprés le tri.                                                                                                                                                                                                                                                                                                                                                                                                                               |            |
| T GHERKIN   |                                                                                                                                                                                                                                                                                                                                                                                                                     Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient qu'une ligne est bien ajouté dans l'affichage de la liste des issues quand on appuis sur `newIssue` dans la page `issues.js`. Une fois la description ajoutée, on vérifie si l'issue est bien présente dans la base de données et si la description correspond.                                                                                                                                                                                                                                                                                                                                                                                                                      |            |
| T GHERKIN   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient si lors de la modification les données ont bien été modifiée au niveau de la base et de l'affichage, et si elles correspondent à ce qu'a entré l'utilisateur.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |            |
| T GHERKIN   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ecrire un scénario en Gherkin et créer un test en selenium qui vérifient si lors de la suppression les données ont bién été misent à jour dans la base et dans le backlog, et au niveau des ID des US.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |            |
| T           | Création de la base de données `Cdp2020` avec les tables : `User(UserName)` (userName : String - unique key) - `Project(Id, Title, Description, UserId)` (Id : int - unique, Title : String - unique, Description : String, UserId : String) - `UserStory(Id, Description, Difficulty, Priority, Sprint, ProjectsId)` (Id : int - unique, Description : String, Priority : PriorityType, Sprint : int, ProjectId : int) - `Task(Id, Description, UserStoriesId, Dependences, EstimatedTime, State, ContributorId)` (Id : int - unique, Description : String, USId : int, Dependences : DependencesType, EstimadedTime : Date, State : TaskStateType, UserStoriesId : int) - `Contributor(ContributorName)` (contributorName : String - unique key) - `Documentation(ProjectId, Title, Description, File, Version, Type)` (ProjectId : int, Title : String, Description : String, File : , Version : VersionType, Type : DocumentationType) - `Test(ProjectId, Type, Version)` (ProjectId : int, Type : TestType, Version : VersionType) - `Sprint(Id, Number, Duration, BeginingDate, Tasks)` (Id : int, Number : int, Duration : Date, BeginingDate : Date, Tasks : ListIdTasks) |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Création d'un fichier `dockerFile` et d'un fichier `docker-compose.yaml` afin d'éxécuter l'architecture de l'application web. # TO DO                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |            |
| T           |                                                                                                                                                                                                                                                                                               Création d'un fichier `planification.ejs` correspondant à la page ou l'utilisateur va pouvoir associer des développeurs à des tâches. Dans le header de la page se trouvera le fichier `header.ejs` afin d'avoir la `navBar`. En dessous de celle-ci se trouvera sur la partie gauche de l'écran un tableau composé des développeurs liés au projet. Sur la partie droite de l'écran se trouvera un tableau composé des tâches liées au projet. Et en dessous des deux tableaux se trouvera un bouton `Pert` permettant de générer et d'afficher le diagramme de Pert lié au projet.                                                                                                                                                                                                                                                                                                |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                     Dans la page `planification.ejs`, il pourra être fait des glisser-deposer afin d'ajouter un développeur à une tache. Cependant, il ne pourra avoir qu'un seul développeur par tache. On pourra enlever le développeur d'une tache en le selectionnant et en le déposant dans le contenu vide de la page.                                                                                                                                                                                                                                                                                                                                                                                                                                      |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                    Création d'un fichier `planification.js` correspondant à la page `planification.ejs`. Ce script doit pouvoir lors de l'affichage de la page `planification.ejs` récupérer la liste des développeurs du projet (`db.collection.find()`) et la la liste des tâches (`db.collection.find()`) et les afficher.                                                                                                                                                                                                                                                                                                                                                                                                                                     |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dans le fichier `planification.js`, une fois le bouton `Pert` appuyé il faut créer un diagramme de Pert en utilisant les données de la table `tâche` (`db.collection.find()`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                  Dans le fichier `planification.js`, doit se trouver une fonction permettant de gérer le glisser-deposer des développeurs aux taches. Une fois le glisser-deposer effectué, il faudra mettre à jour la base de données des tâches (`db.collection.update(query)`). Cependant, le développeur ayant été glisser-deposer doit toujours apparaitre dans la liste des développeurs.                                                                                                                                                                                                                                                                                                                                                                                                   |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                              Dans le fichier `planification.js`, si le développeur a été selectionné depuis la liste des tâches, une fois celui-ci déposer dans le vide il faudra mettre à jour la table des tâches (`db.collection.update()`). Egalement si le développeur a été selectionne depuis la liste des développeurs et qu'il est deposé dans le vide alors on le fera juste disparaitre de la sélection.                                                                                                                                                                                                                                                                                                                                                                                               |            |
| T           |                                                                                                                                                                                                                                                                                                                 Création d'un fichier `sprint.ejs` correspondant à la page ou l'utilisateur peut gérer les sprints du projet. Dans le header de la page se trouvera le fichier `header.ejs` afin d'avoir la `navBar`. La premiere fois que l'utilisateur se rendra sur la page, il y aura au centre de la fenetre un formulaire avec un champ pour mettre le nombre de sprint voulu et un champ pour la durée d'un sprint (identique pour tous les sprints). En dessous de ces deux champs se trouvera un bouton `submit` permettant d'envoyer les informations.                                                                                                                                                                                                                                                                                                                  |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dans la page `sprint.ejs`, une fois le tableau de sprints crée, il sera affiché en dessous du header. En dessous du tableau se trouvera la liste des issues du projet.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dans la page `sprint.ejs`, il sera possible de selectionner une issue et de faire un glisser-deposer afin de la mettre dans un sprint.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Dans la page `sprint.ejs`, lors qu'un clic droit sera effectué sur une case du tableau de sprint, alors un petit menu s'affichera afin de sélectionner une date de début.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                     Création d'un fichier `sprint.js` correspondant à la page `sprint.ejs`. Ce script doit pouvoir lors de l'affichage de la page `sprint.ejs` aficher le tableau de création de sprint lorsque c'est la premiere fois qu'on y accéde. Si ce n'est pas la premiere fois, le script doit pouvoir récupérer la liste des sprints du projet (`db.collection.find()`) et la liste des issues du projet (`db.collection.find()`) et les afficher.                                                                                                                                                                                                                                                                                                                                                                      |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                       Dans le fichier `sprint.js`, si une case du tableau de sprint est sélectionnée avec un clic droit, alors il devra être possible de lui associer une date de début (`db.collection.update()`). Cependant, la case `sprint x` ne peut pas avoir une date de début antérieure à celle du `sprint x - 1`.                                                                                                                                                                                                                                                                                                                                                                                                                                       |            |
| T A CHANGER |                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dans le fichier `sprint.js`, doit se trouver une fonction permettant de gérer le glisser-deposer des issues aux sprints. Une fois le glisser-deposer effectué, il faudra mettre à jour la base de données des sprints (`db.collection.update(query)`).                                                                                                                                                                                                                                                                                                                                                                                                                                                               |            |
| T A CHANGER |                                                                                                                                                                                                                                                                                                                                                                                                      Dans le fichier `sprint.js`, si l'issue a été selectionnée depuis les sprints, une fois celle-ci déposée dans le vide il faudra mettre à jour la table des sprints et des issues (`db.collection.update()`). Egalement si l'issue a été selectionnée depuis la liste des issues et qu'elle est deposée dans le vide alors on la fera juste disparaitre de la sélection.                                                                                                                                                                                                                                                                                                                                                                                                      |            |
| T           |                                                                                                                                                                                                                                                                                                         Création d'un fichier `documentation.ejs` correspondant à la page ou l'utilisateur va pouvoir gérer sa documentation. Dans le header de la page se trouvera le fichier `header.ejs` afin d'avoir la `navBar`. En dessous de celle-ci se trouvera dans un tableau une liste de la documentation du projet. Ce tableau contiendra le type du fichier de documentation (conception, user, administrator), le nom du fichier ainsi que sa version. En dessous de ce tableau se trouvera un bouton `addDocumentation` permettant d'ajouter une nouvelle documentation.                                                                                                                                                                                                                                                                                                         |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                               Dans la page `documentation.ejs`, il sera possible de trier les documentations en fonction de leur type et de la version via une liste déroulante ayant comme attributs `old version to current version`, `current version to old version`, `conception`, `user` et `administrator`.                                                                                                                                                                                                                                                                                                                                                                                                                                                |            |
| T           |                                                                                                                                                                                                                                                                                 Création d'un fichier `documentation.js` correspondant à la page `documentation.ejs`. Ce script doit pouvoir lors de l'affichage de la page `documentation.ejs` faire une requete à notre base de données (`db.collection.find()`) afin d'afficher les différents documents de documentation dans le tableau de la page. Si l'utilisateur effectue un clic droit sur une tache, alors un menu sera affiché à l'endroit du curseur avec les options `edit` et `delete`. L'option `edit` correspondra à la fonction `documentationEdit()` et l'option `delete` correspondra à la fonction `documentationDelete()`.                                                                                                                                                                                                                                                                                  |            |
| T           |                                                                                                                                                                                                                                                                 L'option `edit` correspondra à la fonction `documentationEdit()`. Cette fonction permettra la mise en place de l'affichage permettant de modifier une documentation, c'est-à-dire l'affichage des champs tels que `typeDocumentation`, `nameFile`, `version` et un bouton `submit` pour envoyer l'informations. Il y a aura également un champ permettant à l'utilisateur de pouvoir importer son fichier depuis son ordinateur. Une fois le bouton `submit` appuyé, la base de données sera mise à jour (`db.documentation.update(query)`), l'affichage du menu sera enlevé pour laissé place à la liste des documentations (liste horizontale).                                                                                                                                                                                                                                                                 |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                   L'option `delete` correspondra à la fonction `documentationDelete()`. Cette fonction demandera à l'utilisateur si celui-ci est sûr de vouloir supprimer la documentation via un pop-up. S'il répond positivement alors la documentaton sera effacée de la base de données (`db.documentation.remove(query)`).                                                                                                                                                                                                                                                                                                                                                                                                                                   |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                             Dans le fichier `documentation.js`, lorsqu'un clic sera effectué sur `addDocumentation` le menu `edit` s'ouvrira sur la partie droite de l'écran laissant le choix à l'utilisateur de soit créer un fichier  en ajoutant un `name`, une `description`, un `type` et une `version` (on mettra à jour la base de données en fonction de ces informations).                                                                                                                                                                                                                                                                                                                                                                                                              |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Dans le fichier `documentation.js`, lorsque le menu `edit` sera affiché il sera possible de pouvoir glisser-deposer un fichier déjà existant de son ordinateur, mais il devra quand meme precisé le `type`, la `version` et le `nom`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                           Dans le fichier `documentation.js`, si un clic gauche est effectué sur une ligne du tableau de la documentation, alors sur la partie droite de l'écran sera affiché la description du fichier (.md). Egalement, il sera possible de trier la documentation via une liste déroulante ayant comme attributs type et la version.                                                                                                                                                                                                                                                                                                                                                                                                                           |            |
| T           |                                                                                                                                                                                                                                                          Création d'un fichier `task.ejs` correspond à la page ou l'utilisateur va pouvoir gérer les différentes taches du projet. Dans le header de la page se trouvera le fichier `header.ejs` afin d'avoir la `navBar`. En dessous de celle-ci se trouvera un tableau contenant la liste des différentes tâches du projet tel que (ID, Description, USLiees, TaskDependance, EstimatedTime, State). Sous ce tableau se trouvera un bouton `newTask` permettant d'ajouter une nouvelle tâche. Il sera possible de modifier les taches, donc un menu `edit` s'affichera sur la partie droite de l'écran et le tableau des tâches sera sur la partie gauche de l'écran.                                                                                                                                                                                                                                                           |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                     Création d'un fichier `task.js` correspondant à la page `task.ejs`. Si l'utilisateur effectue un clic droit sur une tache, alors un menu sera affiché à l'endroit du curseur avec les options `edit` et `delete`. L'option `edit` correspondra à la fonction `taskEdit()` et l'option `delete` correspondra à la fonction `taskDelete()`.                                                                                                                                                                                                                                                                                                                                                                                                                     |            |
| T           |                                                                                                                    Dans le fichier `task.js`, la fonction `taskEdit()` permettra la mise en place de l'affichage permettant de modifier une tache, c'est-à-dire l'affichage de différent champs tels que `description`, `us liees` et `tache dépendante`, `temps estimé` et `sate` et un bouton `submit` pour envoyer l'informations. Le champ `us liee` aura une liste déroulante contenant la liste des us du projet (`db.userStory.find()`) mais indiquera seulement l'id de l'us et non sa description. Le champ `tache dépendante` aura une liste déroulante contenant la liste des tâches du projet (`db.task.find()`). Le champ `estimed time` ne pourra être rempli que par des valeurs soit en `djH` (demie-journée homme) ou en `jH` (journée Homme). Une fois le bouton `submit` appuyé la base de données sera mise à jour (`db.task.update(query)`), l'affichage du menu sera enlevé pour laissé place à la liste des taches (liste horizontale).                                                                                                                    |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                               Dans le fichier `task.js`, la fonction `taskDelete()` demandera à l'utilisateur si celui-ci est sûr de vouloir supprimer l'issue via un pop-up. S'il répond positivement alors l'issue sera effacée de la base de données (`db.task.remove(query)`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                |            |
| T           |                                                                                                                                                                                                                           Dans le fichier `task.js`, si l'utilisateur clique sur le bouton `newTask` alors l'affichage sera changé comme explique dans la `T?`.L'utilisateur pourra entrer la description de la tache (obligatoire) à travers un champ. Une fois le champ rempli il pourra appuyer le bouton `submit` afin de valider la création de la tache. On enverra à la base de données la description entrée par l'utilisateur ainsi que l'ID de l'issue qui sera générée automatiquement en récupérant la derniere id du tableau et en lui ajoutant + 1. La base de données sera mise à jour (`db.task.insert(query)`). Il pourra également annuler son souhait de vouloir ajouter un nouveau developpeur en appuyant sur le bouton `cancel`.                                                                                                                                                                                                                            |            |
| T           |                                                                                                                                                                                                                                                   Création d'un fichier `release.ejs` qui correspond à la page ou l'utilisateur va pouvoir gérer les différentes releases liées au projet. Dans le header de la page se trouvera le fichier `header.ejs` afin d'avoir la `navBar`. En dessous de celle-ci, se trouvera un tableau contenant la liste des différentes releases du projet tel que (fileName, file (bouton de téléchargement), version). Sous ce tableau se trouvera un bouton `newRelease` permettant d'ajouter une nouvelle release. Il sera possible de modifier les releases, donc un menu `edit` s'affichera sur la partie droite de l'écran et le tableau des releases sera sur la partie gauche de l'écran.                                                                                                                                                                                                                                                   |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dans la page `release.ejs`, il sera possible de trier les releases en fonction de leur version via une liste déroulante ayant comme attributs `old version to current version` et `current version to old version`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Dans la page `release.ejs`, si un clic est effectué sur le file de la release alors un téléchargement sera effectué sur le browser de l'utilisateur.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                Création d'un fichier `release.js` correspond à la page `release.ejs`. Si l'utilisateur effectue un clic droit sur une tache, alors un menu sera affiché à l'endroit du curseur avec les options `edit` et `delete`. L'option `edit` correspondra à la fonction `releaseEdit()` et l'option `delete` correspondra à la fonction `releaseDelete()`.                                                                                                                                                                                                                                                                                                                                                                                                                 |            |
| T           |                                                                                                                                                                                                                                                                                                      Dans le fichier `release.js`, la fonction `releaseEdit()` permettra la mise en place de l'affichage permettant de modifier une release, c'est-à-dire l'affichage du champ tel que `fileName` et un bouton `submit` pour envoyer l'informations. Il y a aura également un champ permettant à l'utilisateur de pouvoir importer son fichier depuis son ordinateur. Une fois le bouton `submit` appuyé, la base de données sera mise à jour (`db.release.update(query)`) et l'affichage du menu sera enlevé pour laissé place à la liste des releases (liste horizontale).                                                                                                                                                                                                                                                                                                      |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dans le fichier `release.js`, la fonction `releaseDelete()` demandera à l'utilisateur si celui-ci est sûr de vouloir supprimer la release via un pop-up. S'il répond positivement alors la release sera effacée de la base de données (`db.release.remove(query)`)                                                                                                                                                                                                                                                                                                                                                                                                                                                         |            |
| T           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Dans le fichier `release.js`, si un clic gauche est effectué sur le bouton de téléchargement d'une release, alors l'utilisateur aura via son browser le téléchargement de la release en question (`db.release.find(query)`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |            |
| T           |                                                                                                                                                                                                                                                                                                                                   Dans le fichier `release.js`, après que l'utilisateur ait choisi le type de tri qu'il veut avoir pour le tableau des releases, la fonction `sortRelease(type)` doit être lancée avec `type` qui est soit `oldToRecent` ou `recentToOld`. On devra trier les releases en fonction de leur version, c'est à dire que par exemple la version `1.5.01` est plus récente que la version `1.4.15`. Cette fonction mettre à jour l'affichage du tableau des releases en fonction du résultat obtenu via la fonction.                                                                                                                                                                                                                                                                                                                                   |            |

