Project Report: Task Manager
1. Titre
Task Manager - Gestionnaire de Tâches
2. Autheurs
[ELBAH Mohamed Abd Erraouf]
Contribution: [work together]
[ZENDAGUI Nazim]
Contribution: [work together]
3. Date
[1/1/2024]
4. Introduction
4.1 Contexte
Le projet Task Manager vise à fournir une application conviviale pour gérer efficacement les tâches. Il
intègre des fonctionnalités telles que la création, la modification, la suppression de tâches, ainsi que
des fonctionnalités de recherche et de filtrage.
4.2 Objectif du Logiciel
Créer un système de gestion des tâches avec une interface graphique.
Mettre en œuvre l'authentification utilisateur pour un accès sécurisé.
Autoriser les opérations CRUD sur les tâches.
Fournir des fonctionnalités supplémentaires telles que la recherche, le filtrage et la catégorisation.
4.3 Importance du Logiciel
Le Task Manager facilite la gestion quotidienne des tâches, améliorant ainsi l'efficacité et la
productivité individuelles.
4.4 L'Organisation du Document
Le rapport est structuré en plusieurs sections, couvrant l'introduction, l'analyse des besoins, la
conception du logiciel, la conception détaillée, les technologies utilisées, le modèle de
développement, la grande d'utilisation, et la conclusion.
5. Analyse et Définition des Besoins
5.1 Besoins Fonctionnels et Non Fonctionnels
[Décrire les besoins fonctionnels et non fonctionnels]
Besoins fonctionnels :
Gestion des tâches :
Ajouter une tâche avec un nom, une description et une date/heure associée.
Modifier une tâche existante.
Supprimer une tâche.
Affichage des tâches :
Afficher toutes les tâches.
Afficher les tâches complétées.
Afficher les tâches pour aujourd'hui.
Gestion des utilisateurs :
Système d'authentification avec une vérification du login et affichage d'une fenêtre de connexion.
Besoins non fonctionnels :
Sécurité :
Utilisation de paramètres sécurisés pour la connexion à la base de données.
Gestion sécurisée des informations d'identification utilisateur.
Performances :
Gestion efficace des opérations de base de données pour éviter les retards.
Capacité à gérer une grande quantité de tâches et d'utilisateurs.
Fiabilité :
Gestion des erreurs et exceptions pour assurer une expérience utilisateur fiable.
Sauvegarde régulière des données pour éviter toute perte d'informations.
Convivialité (Usabilité) :
Interface utilisateur intuitive pour faciliter l'utilisation.
Affichage clair des informations liées aux tâches.
Extensibilité :
5.2 Use Case Diagramme
[Insérer le diagramme de cas d'utilisation]
6. Conception du Logiciel
6.1 Diagramme de Package et Classes
[Insérer les diagrammes de package et de classes]
6.2 Explication de Chaque Entité
[Expliquer chaque composant du diagramme de package et de classes]
Main est de servir de point d'entrée principal pour l'application. Elle étend la classe
Application, qui est une classe de base pour toutes les applications JavaFX. Voici un résumé
des objectifs principaux de la classe Main :
Lancement de l'Application JavaFX :
La méthode main de la classe Main est le point d'entrée principal de l'application. Elle
appelle la méthode launch de la classe Application, qui démarre le cycle de vie de
l'application JavaFX.
Gestion des Fenêtres et des Scènes :
La méthode start est appelée après le lancement de l'application. Elle initialise et affiche la
fenêtre principale de l'application en créant une scène avec un layout basé sur BorderPane
et en la montrant dans une fenêtre (Stage).
La fenêtre principale contient une barre de recherche (searchTextField), une liste de tâches
(taskListView), et d'autres éléments d'interface utilisateur.
Gestion des Tâches et des Listes de Tâches :
La classe Main maintient des listes observables (tasks et taskLists) qui sont probablement
utilisées pour stocker les tâches et les listes de tâches.
Des méthodes comme showAddTaskDialog, showModifyTaskDialog, deleteSelectedTask,
etc., gèrent l'interaction avec les tâches, permettant à l'utilisateur d'ajouter, de modifier ou de
supprimer des tâches.
Interaction avec une Base de Données :
La méthode login semble être responsable de la vérification des informations de connexion
dans une base de données MySQL. Une connexion à la base de données est établie pour
vérifier le login.
Il existe des méthodes liées à la manipulation de données de tâches dans la base de
données, comme showTasksByCategory qui filtre les tâches en fonction des catégories
stockées dans la base de données.
Affichage de la Scène Principale :
La méthode showPrimaryStage configure et affiche la scène principale de l'application. Elle
initialise des composants tels que les boutons pour afficher les tâches, la barre de recherche,
etc.
Gestion des Événements Utilisateur :
Des gestionnaires d'événements sont utilisés pour détecter les actions de l'utilisateur,
comme le clic sur un bouton, le double-clic sur une tâche, etc. Ces événements déclenchent
des actions spécifiques définies dans des méthodes correspondantes.
Autres Fonctionnalités :
L'application semble avoir des fonctionnalités telles que la recherche de tâches, l'affichage
des tâches pour aujourd'hui, l'affichage de toutes les tâches, etc.
du class task:////////////////////////
l'interface Task est de définir un contrat (ensemble de méthodes) que toute classe
représentant une tâche dans l'application doit implémenter. Voici un résumé des objectifs
principaux de l'interface Task :
Encapsulation des Informations de Tâche :
Les méthodes getName, setName, getDescription, et setDescription sont utilisées pour
accéder et définir les informations de base d'une tâche, telles que son nom et sa description.
Cela permet d'encapsuler les détails de mise en œuvre de ces attributs à l'intérieur de
chaque classe qui implémente l'interface.
Gestion de la Date et de l'Heure :
Les méthodes getDateTime et setDateTime permettent de récupérer et de définir la date et
l'heure associées à une tâche. Cela permet de gérer les tâches planifiées à des moments
spécifiques.
Gestion de l'État de Complétion :
Les méthodes isCompleted et setCompleted permettent de déterminer et de modifier l'état
de complétion d'une tâche. Cela offre la possibilité de marquer une tâche comme complétée
ou non.
Association avec une Liste de Tâches :
La méthode setTaskList permet d'associer une tâche à une liste de tâches spécifique. Cela
peut être utile pour organiser les tâches en fonction de catégories ou de listes définies par
l'utilisateur.
Gestion de la Catégorie de Tâche :
Les méthodes getCategory et setCategory permettent de récupérer et de définir la catégorie
à laquelle appartient une tâche. Cela peut être utilisé pour classer les tâches dans différentes
catégories, offrant ainsi une organisation supplémentaire.
Identification Unique de la Tâche :
La méthode getTaskId est probablement utilisée pour récupérer une identifiant unique
associé à chaque tâche. Cela peut être utile pour la gestion interne des données, notamment
lorsqu'on travaille avec une base de données.
du class taskimpl:///
TaskImpl semble être de fournir une implémentation concrète de l'interface Task pour
représenter une tâche dans l'application. Voici un résumé des objectifs de cette classe :
Implémentation de l'Interface Task :
La classe TaskImpl implémente l'interface Task, ce qui signifie qu'elle doit fournir des
implémentations concrètes pour toutes les méthodes déclarées dans cette interface. Cela
garantit que chaque instance de TaskImpl peut être utilisée comme une tâche dans le
contexte de l'application.
Gestion des Attributs de Tâche :
Les attributs privés tels que name, description, dateTime, completed, category, et TaskId sont
utilisés pour stocker les informations spécifiques à chaque tâche. Les méthodes getName,
setName, getDescription, setDateTime, isCompleted, setCompleted, getCategory,
setCategory, et getTaskId sont utilisées pour accéder et modifier ces attributs.
Conversion en Chaîne (toString) :
La méthode toString est surchargée pour fournir une représentation textuelle personnalisée
d'une tâche. Cette représentation inclut des détails tels que le nom, la description, la date et
l'état de complétion de la tâche.
Insertion et Modification dans la Base de Données :
Les méthodes insertToDB et editTaskDB sont mises en œuvre pour insérer une nouvelle
tâche dans la base de données et modifier une tâche existante, respectivement. Ces
méthodes utilisent des requêtes SQL préparées pour interagir avec la base de données
MySQL.
Gestion de l'État d'Insertion :
La variable inserted est utilisée pour suivre l'état d'insertion d'une tâche dans la base de
données. Elle est initialisée à false et modifiée à true une fois que la tâche a été insérée
dans la base de données.
Connexion à la Base de Données :
La classe utilise la classe DriverManager pour établir une connexion à la base de données
MySQL. Les détails de connexion, tels que l'URL, le nom d'utilisateur et le mot de passe,
sont inclus dans le code.
Gestion des Exceptions :
Des blocs try-catch sont utilisés pour gérer les exceptions potentielles liées à la gestion de la
base de données et à la connexion JDBC.
du class taskList:////
Purpose of the Class:
The TaskList class appears to be an abstract class representing a list of tasks. It has
attributes like name, description, and a list of Task objects. It also declares an abstract
method getTaskListCategories(), which suggests that subclasses should provide functionality
related to task categories.
Visibility of addTask Method:
The addTask method has default/package-private visibility. Depending on your design, you
might want to make it protected or public if you want subclasses or external classes to be
able to add tasks directly.
Encapsulation:
The class has getters and setters for name and description, which are good for
encapsulation. However, the addTask method is currently empty, and it's not clear how you
intend to manage the tasks in the list. You might want to add logic to validate or process
tasks being added.
Initialization:
The TaskList class initializes the tasks list in its constructor. It's good practice to initialize
variables in the constructor to ensure they are not null.
du class tasklistimpl:
The TaskListImpl class appears to be an implementation of the abstract class TaskList with
additional functionality related to tasks and database operations. Here are some
observations and suggestions:
Initialization of Lists:
The class initializes its own tasks list, but since it extends TaskList, which also has a tasks
list, you may want to rethink this structure. It might be better to use the tasks list from the
superclass (TaskList) and avoid redundancy.
Unused Field categories:
The TaskListImpl class has a field categories that is declared but not used. If you don't intend
to use it, consider removing it to avoid confusion.
Unused Constructor Parameters:
The constructor of TaskListImpl takes name and description as parameters but does not
seem to use them. You might want to either utilize these parameters or remove them if they
are unnecessary.
Database Operations:
The class includes methods for deleting tasks from a database (deleteTaskDB), checking
task existence (checkExistance), and retrieving tasks from the database based on different
criteria (getTasksFromDb). These methods seem to be specific to database interactions, and
they are not part of the original abstract TaskList class. Depending on your design, you may
want to create a separate class for handling database operations rather than including them
in the task list implementation.
Correcting Errors:
There are a couple of issues in the getTasksFromDb method. It references variables like
TaskId and status that are not declared in the provided code. Make sure to correct these
errors.
Resource Management:
It's important to manage resources properly, especially when dealing with database
connections. Consider using try-with-resources to automatically close connections,
statements, and result sets.
Consistency in Naming:
There is inconsistency in naming conventions. For example, in the getTasksFromDb method,
there are variables like cat1, Discription, and status. Make sure to use consistent naming
conventions throughout your code.
Logging:
Instead of printing directly to the console using System.out.println, consider using a logging
framework for better flexibility and control over log messages.
Capacité à étendre le système avec de nouvelles fonctionnalités ou modules.
Conformité :
Respect des normes de sécurité et de confidentialité.
7. Conception Détaillée
7.1 Diagramme de Classes
[Insérer le diagramme de classes détaillé]
7.2 Diagramme de Séquence
[Insérer le diagramme de séquence]
7.3 Diagramme d'État
[Insérer le diagramme d'état]
8. Technologies Utilisées
Java
JavaFX
JDBC (Java Database Connectivity)
MySQL
9. Modèle de Développement Utilisé: en cascade
9.1 Justification
Le choix du modèle de développement en cascade peut être justifié en fonction des
caractéristiques du projet. Ce modèle convient particulièrement aux projets où les exigences
sont bien définies dès le départ et ne devraient pas subir de changements significatifs tout
au long du cycle de développement. Si les besoins du client sont stables et les risques bien
compris, le modèle en cascade peut offrir une structure linéaire qui facilite la planification, la
conception et la mise en œuvre du projet.
9.2 Avantages
Structure linéaire : Le modèle en cascade suit une approche séquentielle, chaque phase
étant clairement définie et suivant la précédente. Cela facilite la compréhension et la gestion
du processus de développement.
Documentation complète : Chaque phase du cycle de vie du développement en cascade est
accompagnée de documentation détaillée, ce qui facilite la traçabilité des décisions et des
choix de conception.
Facilité de gestion : La nature prévisible et structurée du modèle en cascade facilite la
gestion des projets, avec des jalons clairement définis à chaque phase.
Contrôle strict des changements : En raison de sa structure linéaire, le modèle en cascade
est moins susceptible aux changements de dernière minute, ce qui peut être un avantage
lorsque les exigences du projet sont bien définies dès le départ.
10. Grande d'Utilisation
[Expliquer comment le logiciel répond aux besoins de l'utilisateur]
Pour expliquer comment le logiciel répond aux besoins de l'utilisateur, il est important de
mettre en avant les fonctionnalités et caractéristiques du logiciel qui correspondent
directement aux besoins et attentes des utilisateurs. Voici une structure que vous pourriez
suivre pour détailler la grande utilisation du logiciel par rapport aux besoins des utilisateurs :
10.1 Caractéristiques Clés
Identifiez les caractéristiques clés du logiciel qui répondent directement aux besoins des
utilisateurs. Cela pourrait inclure des fonctionnalités spécifiques, des interfaces utilisateur
conviviales, des capacités de personnalisation, etc.
10.2 Expérience Utilisateur
Décrivez comment l'expérience utilisateur a été optimisée pour répondre aux attentes. Cela
peut inclure des interfaces intuitives, des processus simplifiés, des guides d'utilisateur
intégrés, etc.
10.3 Personnalisation
Si le logiciel offre des fonctionnalités de personnalisation, expliquez comment cela permet
aux utilisateurs d'ajuster le logiciel en fonction de leurs besoins spécifiques. Par exemple,
des préférences utilisateur, des paramètres de configuration, etc.
10.4 Performances
Met en avant les performances du logiciel en termes de rapidité, de réactivité et de gestion
des ressources. Les performances doivent être en adéquation avec les attentes des
utilisateurs et les exigences du système.
10.5 Sécurité et Fiabilité
Expliquez comment le logiciel garantit la sécurité des données et la fiabilité des opérations.
La confiance des utilisateurs dans la sécurité de leurs informations est cruciale.
10.6 Réponses aux Retours Utilisateurs
Si des fonctionnalités ont été ajoutées ou améliorées en réponse aux retours des utilisateurs,
mettez en avant cette capacité du logiciel à évoluer en fonction des besoins réels.
10.7 Support Utilisateur
Décrivez les mécanismes de support intégrés, tels que la documentation, les forums en
ligne, le support client, etc., qui aident les utilisateurs à comprendre et à utiliser efficacement
le logiciel.
10.8 Intégrations et Compatibilité
Si le logiciel est compatible avec d'autres outils ou plateformes, expliquez comment cela
facilite l'intégration dans l'écosystème existant des utilisateurs.
10.9 Évolutivité
Si le logiciel est conçu pour évoluer avec les besoins changeants des utilisateurs, assurez-
vous de souligner cette évolutivité pour montrer comment le logiciel peut continuer à être
pertinent à mesure que les exigences évoluent.
10.10 Témoignages et Retours Utilisateurs
Si possible, incluez des témoignages ou des retours d'utilisateurs qui démontrent comment
le logiciel a répondu de manière positive à leurs besoins.
11. Conclusion
11.1 Récapitulation
En récapitulant les points clés de ce rapport, nous avons examiné en détail le logiciel de
gestion de tâches, mettant l'accent sur sa conception, son implémentation, et comment il
répond aux besoins spécifiques des utilisateurs. Nous avons exploré les caractéristiques
clés telles que la gestion avancée des tâches, la catégorisation, la personnalisation, et la
recherche avancée.
11.2 Les Gains
Les utilisateurs ont bénéficié de plusieurs manières de ce logiciel. Les avantages incluent
une meilleure organisation des tâches, une expérience utilisateur fluide, une
personnalisation adaptée aux préférences individuelles, et une recherche efficace. Les
performances et la sécurité du logiciel ont contribué à renforcer la confiance des utilisateurs.
11.3 Futures Améliorations
Pour continuer à améliorer le logiciel, quelques pistes d'améliorations futures sont
suggérées. Il pourrait être bénéfique d'explorer davantage les retours des utilisateurs pour
identifier des opportunités d'amélioration spécifiques. L'intégration de fonctionnalités
collaboratives, telles que le partage de tâches entre utilisateurs, pourrait être envisagée pour
répondre à des besoins de collaboration plus avancés.
En outre, une attention particulière pourrait être accordée à l'optimisation des performances
pour des environnements d'utilisation plus étendus. L'expansion de la compatibilité avec
d'autres outils et plates-formes populaires pourrait également élargir l'impact du logiciel.
En conclusion, le logiciel actuel offre une solution robuste pour la gestion de tâches, mais il
reste toujours des opportunités pour évoluer et s'adapter aux besoins changeants de ses
utilisateurs. Ces améliorations futures garantiront que le logiciel demeure pertinent et
efficace dans un environnement en constante évolution.
