Documentation name change

Documentation/Documentation_6juin/Diagramme de Classes Info.txt

@@ -1,26 +1,26 @@
-1-Dans un premier temps, nous avons les classes modèle de l'application, telles que Strategie, Champion et Ability.
-Ces trois classes sont interconnectées, avec Ability étant agrégée dans Champion et Champion étant agrégé dans Strategie.
-
-Nous avons également la classe Utilisateur, qui représente un utilisateur de l'application.
-Cette classe permet à un utilisateur de créer un compte et de le sauvegarder dans la base de données.
-Elle permet également à l'utilisateur de créer ou de supprimer une stratégie.
-
-
-
-2-Il existe aussi la classes de gestion ici Manager.
-
-Manager comprend une liste de champions et une liste d'utilisateurs qui permettent le bon fonctionnement de l'application.
-La classes joue le role de gestionnaire et permet le login et enregistrement d'utilisateur.
-
-
-
-3-Et enfin les trois classes et l'interface suivante sont les clases d'infrastructure :
-DataContract : Elle joue le rôle de gestionnaire de persistance des données en utilisant la sérialisation pour charger et sauvegarder les objets (Liste<Champion> et Liste<Utilisateur>) dans des fichiers spécifiés.
-
-DataToPersist : C'est une classe de modèle de données qui regroupe les objets Champion et Utilisateur dans des listes pour faciliter leur gestion et leur utilisation.
-
-Stub : Cette classe fournit une implémentation de base pour la gestion de la persistance des données des champions et des utilisateurs.
-Elle permet de charger des données simulées et offre un point d'extension pour ajouter la logique de sauvegarde des données.
-
-IPersistanceManager: Cette Interface définit les opérations de base pour charger et sauvegarder les données des champions et des utilisateurs.
+1-Dans un premier temps, nous avons les classes modèle de l'application, telles que Strategie, Champion et Ability.
+Ces trois classes sont interconnectées, avec Ability étant agrégée dans Champion et Champion étant agrégé dans Strategie.
+
+Nous avons également la classe Utilisateur, qui représente un utilisateur de l'application.
+Cette classe permet à un utilisateur de créer un compte et de le sauvegarder dans la base de données.
+Elle permet également à l'utilisateur de créer ou de supprimer une stratégie.
+
+
+
+2-Il existe aussi la classes de gestion ici Manager.
+
+Manager comprend une liste de champions et une liste d'utilisateurs qui permettent le bon fonctionnement de l'application.
+La classes joue le role de gestionnaire et permet le login et enregistrement d'utilisateur.
+
+
+
+3-Et enfin les trois classes et l'interface suivante sont les clases d'infrastructure :
+DataContract : Elle joue le rôle de gestionnaire de persistance des données en utilisant la sérialisation pour charger et sauvegarder les objets (Liste<Champion> et Liste<Utilisateur>) dans des fichiers spécifiés.
+
+DataToPersist : C'est une classe de modèle de données qui regroupe les objets Champion et Utilisateur dans des listes pour faciliter leur gestion et leur utilisation.
+
+Stub : Cette classe fournit une implémentation de base pour la gestion de la persistance des données des champions et des utilisateurs.
+Elle permet de charger des données simulées et offre un point d'extension pour ajouter la logique de sauvegarde des données.
+
+IPersistanceManager: Cette Interface définit les opérations de base pour charger et sauvegarder les données des champions et des utilisateurs.
 Elle est utilisée par la classe Manager et dépend de Stub et DataContract.

Documentation/Documentation_6juin/Diagramme de Paquetage Info.txt

@@ -1,28 +1,28 @@
-Voici la description détaille du diagramme de paquetage de LOLAPP:
-
-Paquetage DataContractPersistance : Ce paquetage regroupe les classes liées à la persistance des objets de contrat de données.
-	DataContract : Cette classe spécifie les contrats de données à utiliser.
-	DataToPersist : Cette classe spécifie les données à persister.
-
-Paquetage Stub : Ce paquetage regroupe les classes de stub utilisées à l'intérieur de l'application. Un stub est un objet simulé qui permet de charger des données de manière contrôlée.
-	Stub : Cette classe spécifique est utilisée pour charger des données.
-
-Paquetage Modele : Ce paquetage regroupe les classes liées au modèle de l'application.
-	Ability : Cette classe spécifie les capacités dans l'applications.
-	Champion : Cette classe représente les champions utilisés dans l'application.
-	IPersistanceManager : Cette classe spécifie l'interface du gestionnaire de persistance.
-	Manager : Cette classe contient le gestionnaire utilisé dans l'application.
-	Strategie : Cette classe représente les stratégies utilisées.
-	Utilisateur : Cette classe spécifie les utilisateurs de l'application.
-
-Paquetage View : Ce paquetage contient les classes de vue de l'application.
-	Main : Cette page représente l'écran principal de l'application et contient les éléments liés aux champions.
-	Strat : Cette page contient les éléments liés aux stratégies de l'utilisateur.
-	Register : Cette page représente l'écran d'inscription de l'application.
-	Login : Cette page représente l'écran de connexion de l'application.
-
-Paquetage App : Ce paquetage regroupe les éléments principaux de l'application.
-
-
-Il est important de noter que le paquetage "App" rassemble les différents éléments essentiels de l'application, tels que les fichiers App.xaml et App.xaml.cs, ainsi que AppShell.xaml etc.
+Voici la description détaille du diagramme de paquetage de LOLAPP:
+
+Paquetage DataContractPersistance : Ce paquetage regroupe les classes liées à la persistance des objets de contrat de données.
+	DataContract : Cette classe spécifie les contrats de données à utiliser.
+	DataToPersist : Cette classe spécifie les données à persister.
+
+Paquetage Stub : Ce paquetage regroupe les classes de stub utilisées à l'intérieur de l'application. Un stub est un objet simulé qui permet de charger des données de manière contrôlée.
+	Stub : Cette classe spécifique est utilisée pour charger des données.
+
+Paquetage Modele : Ce paquetage regroupe les classes liées au modèle de l'application.
+	Ability : Cette classe spécifie les capacités dans l'applications.
+	Champion : Cette classe représente les champions utilisés dans l'application.
+	IPersistanceManager : Cette classe spécifie l'interface du gestionnaire de persistance.
+	Manager : Cette classe contient le gestionnaire utilisé dans l'application.
+	Strategie : Cette classe représente les stratégies utilisées.
+	Utilisateur : Cette classe spécifie les utilisateurs de l'application.
+
+Paquetage View : Ce paquetage contient les classes de vue de l'application.
+	Main : Cette page représente l'écran principal de l'application et contient les éléments liés aux champions.
+	Strat : Cette page contient les éléments liés aux stratégies de l'utilisateur.
+	Register : Cette page représente l'écran d'inscription de l'application.
+	Login : Cette page représente l'écran de connexion de l'application.
+
+Paquetage App : Ce paquetage regroupe les éléments principaux de l'application.
+
+
+Il est important de noter que le paquetage "App" rassemble les différents éléments essentiels de l'application, tels que les fichiers App.xaml et App.xaml.cs, ainsi que AppShell.xaml etc.
 Il semble jouer un rôle central dans le fonctionnement global de l'application.

Documentation/Documentation_6juin/Diagramme de Séquence Login Info.txt

@@ -1,2 +1,2 @@
-L'utilisateur après avoir rentré ses information et cliqué sur le bouton login, les information vont etre envoyer au manager qui va le valider ou non par rapport a sont id et sont mot de pass.
+L'utilisateur après avoir rentré ses information et cliqué sur le bouton login, les information vont etre envoyer au manager qui va le valider ou non par rapport a sont id et sont mot de pass.
 Puis les informations de la réussite de sont login va peu a peu revenir a lui.

Documentation/Documentation_6juin/Diagramme de Séquence Strat Info.txt

@@ -1,4 +1,4 @@
-L'utilisateur après avoir mit les différente information tel que choisir les 5 champions et la description,
-Il va lancé la créationde stratégie depuis le bouton de la Page stratégie (Strat Page).
-La page va "envoyer" les information a la base de donnée plus spécifiquement a celle de l'utilisateur et va rajouter la stratégie dans la liste stratégie.
-Enfin la page va afficher la stratégie.
+L'utilisateur après avoir mit les différente information tel que choisir les 5 champions et la description,
+Il va lancé la créationde stratégie depuis le bouton de la Page stratégie (Strat Page).
+La page va "envoyer" les information a la base de donnée plus spécifiquement a celle de l'utilisateur et va rajouter la stratégie dans la liste stratégie.
+Enfin la page va afficher la stratégie.

Documentation/Documentation_6juin/description écrite de l’architecture.txt

@@ -1,64 +1,64 @@
-L'architecture de l'application LOLAPP a été conçue en prenant en compte plusieurs aspects clés pour assurer sa robustesse et sa maintenabilité.
-Pour faciliter la compréhension de son fonctionnement, la description de cette architecture a été divisée en six parties distinctes : les Patrons de conception utilisés, les Composants, la Modélisation des dépendances, les Couches d'architecture, les Interfaces et les Flux de données importants.
-
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-1-Patrons de conception utilisés :
-
-Modèle-Vue-VueModèle (MVVM) : L'application utilise le modèle MVVM pour séparer les préoccupations en utilisant les composants suivants :
-	Modèles : Les classes telles que Champion, Ability et Utilisateur représentent les modèles de données de votre application.
-	Vues : Les pages telles que Main, Strat, Register et Login représentent les vues de l'application.
-	Vue-Modèles : Je n'en ai pas utilisé.
-
-Injection de dépendances : L'injection de dépendances est utilisée pour gérer les dépendances entre les différents composants de l'application, améliorant ainsi la modularité et la testabilité du code.
-
-
-Ces patrons de conception permettent de mettre en place une architecture claire et bien organisée, favorisant la séparation des préoccupations et facilitant la maintenance et l'évolutivité de votre application.
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-2-Composants :
-
-	DataContractPersistance :
-		DataContract : Cette classe spécifie les contrats de données à utiliser. Elle peut définir les propriétés et les méthodes nécessaires pour la sérialisation et la désérialisation des objets de données.
-		DataToPersist : Cette classe spécifie les données à persister. Elle regroupe les objets Champion et Utilisateur dans des listes pour faciliter leur gestion et leur utilisation.
-	Stub :
-		Stub : Cette classe spécifique est utilisée pour charger des données. Elle implémente des méthodes qui retournent des données pré-définies pour le chargement de l'objet Champion.
-	Modele :
-		Ability : Cette classe représente les capacités dans l'application. Elle contenient des propriétés telles que le nom, la description et le nom de l'image.
-		Champion : Cette classe représente les champions utilisés dans l'application. Elle contenient des propriétés telles que le nom, les capacités associées et d'autres informations spécifiques au champion.
-		IPersistanceManager : Cette interface spécifie les opérations de base pour charger et sauvegarder les données des champions et des utilisateurs. Elle définit des méthodes telles que "Chargdon" et "Sauvdon".
-		Manager : Cette classe contient le gestionnaire utilisé dans l'application. Elle implémente l'interface IPersistanceManager et coordonne les opérations de chargement et de sauvegarde des données mais permet aussi l'enregistrement et le login d'utilisateur.
-		Strategie : Cette classe représente les stratégies utilisées dans l'application. Elle contenient des propriétés telles que le nom de la stratégie, les champions associés et d'autres informations pertinentes.
-		Utilisateur : Cette classe représente les utilisateurs de l'application. Elle contenient des propriétés telles que le nom d'utilisateur, le mot de passe et les stratégies associées à l'utilisateur.
-	View :
-		Main : Cette page représente l'écran principal de l'application et contient les éléments liés aux champions. Elle peut afficher la liste des champions disponibles et permettre à l'utilisateur de sélectionner un champion et voir ses informations.
-		Strat : Cette page contient les éléments liés aux stratégies de l'utilisateur. Elle peut afficher les stratégies existantes de l'utilisateur, permettre la création de nouvelles stratégies et la suprésion des stratégies existantes.
-		Register : Cette page représente l'écran d'inscription de l'application. Elle peut afficher les champs nécessaires pour que l'utilisateur crée un compte, tels que le nom d'utilisateur et le mot de passe. Une fois que l'utilisateur remplit les informations requises et les soumet, la classe Manager gère la création du compte et la persistance des données dans la base de données.
-		Login : Cette page représente l'écran de connexion de l'application. Elle permet à l'utilisateur de saisir ses identifiants (nom d'utilisateur et mot de passe) pour accéder à son compte. Une fois les informations d'identification soumises, la classe Manager vérifie leur validité et autorise l'accès à l'application.
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-3-Modélisez les dépendances :
-
-Les dépendances sont représentées dans le diagramme de classes avec les flèches de dépendance entre les différents composants.
-Par exemple, les classes du paquetage "Stub" dépent des classes "IPersistanceManager, "IPersistanceManager" est l'interface de "Manager", "Ability" est agréée dans "Champion" et "Champion" dans "Strategie"...
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-4-Couches d'architecture :
-
-Dans l'architecture de l'application LOLAPP, nous pouvons identifier les couches suivantes :
-La couche de présentation (View) : Cette couche est responsable de l'interface utilisateur de l'application.
-Elle affiche les données et permet à l'utilisateur d'interagir avec l'application.
-
-La couche de logique métier (Modele) : Cette couche contient les classes qui représentent le modèle de l'application, telles que les classes Champion, Strategie et Utilisateur.
-Elle gère la logique métier de l'application, comme la création de comptes, la gestion des champions et des stratégies.
-
-La couche d'infrastructure (DataContractPersistance et Stub) : Cette couche fournit des fonctionnalités d'accès aux données et de persistance.
-Les classes du paquetage DataContractPersistance sont responsables de la sérialisation et de la désérialisation des objets de données, tandis que les classes du paquetage Stub fournissent des données simulées pour le chargement initial.
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-5-Interfaces :
-
-IPersistanceManager : Cette interface spécifie les méthodes de base pour charger et sauvegarder les données des champions et des utilisateurs.
-Les classes qui implémentent cette interface, comme la classe Manager, doivent fournir une implémentation pour ces méthodes.
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-6-Flux de données :
-
-Les flux de données importants dans l'application inclut :
-Le flux de données lors de la création d'un compte utilisateur, où les informations saisies par l'utilisateur sont envoyées à la classe responsable de la création du compte et de la persistance des données, le Manager.
-Le flux de données lors du chargement initial des champions et des utilisateurs, où les données sont soit chargées à partir de la base de données, soit à l'aide de la classe Stub.
+L'architecture de l'application LOLAPP a été conçue en prenant en compte plusieurs aspects clés pour assurer sa robustesse et sa maintenabilité.
+Pour faciliter la compréhension de son fonctionnement, la description de cette architecture a été divisée en six parties distinctes : les Patrons de conception utilisés, les Composants, la Modélisation des dépendances, les Couches d'architecture, les Interfaces et les Flux de données importants.
+
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+1-Patrons de conception utilisés :
+
+Modèle-Vue-VueModèle (MVVM) : L'application utilise le modèle MVVM pour séparer les préoccupations en utilisant les composants suivants :
+	Modèles : Les classes telles que Champion, Ability et Utilisateur représentent les modèles de données de votre application.
+	Vues : Les pages telles que Main, Strat, Register et Login représentent les vues de l'application.
+	Vue-Modèles : Je n'en ai pas utilisé.
+
+Injection de dépendances : L'injection de dépendances est utilisée pour gérer les dépendances entre les différents composants de l'application, améliorant ainsi la modularité et la testabilité du code.
+
+
+Ces patrons de conception permettent de mettre en place une architecture claire et bien organisée, favorisant la séparation des préoccupations et facilitant la maintenance et l'évolutivité de votre application.
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+2-Composants :
+
+	DataContractPersistance :
+		DataContract : Cette classe spécifie les contrats de données à utiliser. Elle peut définir les propriétés et les méthodes nécessaires pour la sérialisation et la désérialisation des objets de données.
+		DataToPersist : Cette classe spécifie les données à persister. Elle regroupe les objets Champion et Utilisateur dans des listes pour faciliter leur gestion et leur utilisation.
+	Stub :
+		Stub : Cette classe spécifique est utilisée pour charger des données. Elle implémente des méthodes qui retournent des données pré-définies pour le chargement de l'objet Champion.
+	Modele :
+		Ability : Cette classe représente les capacités dans l'application. Elle contenient des propriétés telles que le nom, la description et le nom de l'image.
+		Champion : Cette classe représente les champions utilisés dans l'application. Elle contenient des propriétés telles que le nom, les capacités associées et d'autres informations spécifiques au champion.
+		IPersistanceManager : Cette interface spécifie les opérations de base pour charger et sauvegarder les données des champions et des utilisateurs. Elle définit des méthodes telles que "Chargdon" et "Sauvdon".
+		Manager : Cette classe contient le gestionnaire utilisé dans l'application. Elle implémente l'interface IPersistanceManager et coordonne les opérations de chargement et de sauvegarde des données mais permet aussi l'enregistrement et le login d'utilisateur.
+		Strategie : Cette classe représente les stratégies utilisées dans l'application. Elle contenient des propriétés telles que le nom de la stratégie, les champions associés et d'autres informations pertinentes.
+		Utilisateur : Cette classe représente les utilisateurs de l'application. Elle contenient des propriétés telles que le nom d'utilisateur, le mot de passe et les stratégies associées à l'utilisateur.
+	View :
+		Main : Cette page représente l'écran principal de l'application et contient les éléments liés aux champions. Elle peut afficher la liste des champions disponibles et permettre à l'utilisateur de sélectionner un champion et voir ses informations.
+		Strat : Cette page contient les éléments liés aux stratégies de l'utilisateur. Elle peut afficher les stratégies existantes de l'utilisateur, permettre la création de nouvelles stratégies et la suprésion des stratégies existantes.
+		Register : Cette page représente l'écran d'inscription de l'application. Elle peut afficher les champs nécessaires pour que l'utilisateur crée un compte, tels que le nom d'utilisateur et le mot de passe. Une fois que l'utilisateur remplit les informations requises et les soumet, la classe Manager gère la création du compte et la persistance des données dans la base de données.
+		Login : Cette page représente l'écran de connexion de l'application. Elle permet à l'utilisateur de saisir ses identifiants (nom d'utilisateur et mot de passe) pour accéder à son compte. Une fois les informations d'identification soumises, la classe Manager vérifie leur validité et autorise l'accès à l'application.
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+3-Modélisez les dépendances :
+
+Les dépendances sont représentées dans le diagramme de classes avec les flèches de dépendance entre les différents composants.
+Par exemple, les classes du paquetage "Stub" dépent des classes "IPersistanceManager, "IPersistanceManager" est l'interface de "Manager", "Ability" est agréée dans "Champion" et "Champion" dans "Strategie"...
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+4-Couches d'architecture :
+
+Dans l'architecture de l'application LOLAPP, nous pouvons identifier les couches suivantes :
+La couche de présentation (View) : Cette couche est responsable de l'interface utilisateur de l'application.
+Elle affiche les données et permet à l'utilisateur d'interagir avec l'application.
+
+La couche de logique métier (Modele) : Cette couche contient les classes qui représentent le modèle de l'application, telles que les classes Champion, Strategie et Utilisateur.
+Elle gère la logique métier de l'application, comme la création de comptes, la gestion des champions et des stratégies.
+
+La couche d'infrastructure (DataContractPersistance et Stub) : Cette couche fournit des fonctionnalités d'accès aux données et de persistance.
+Les classes du paquetage DataContractPersistance sont responsables de la sérialisation et de la désérialisation des objets de données, tandis que les classes du paquetage Stub fournissent des données simulées pour le chargement initial.
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+5-Interfaces :
+
+IPersistanceManager : Cette interface spécifie les méthodes de base pour charger et sauvegarder les données des champions et des utilisateurs.
+Les classes qui implémentent cette interface, comme la classe Manager, doivent fournir une implémentation pour ces méthodes.
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+6-Flux de données :
+
+Les flux de données importants dans l'application inclut :
+Le flux de données lors de la création d'un compte utilisateur, où les informations saisies par l'utilisateur sont envoyées à la classe responsable de la création du compte et de la persistance des données, le Manager.
+Le flux de données lors du chargement initial des champions et des utilisateurs, où les données sont soit chargées à partir de la base de données, soit à l'aide de la classe Stub.
 Le flux de données lors de la création, de la modification ou de la suppression d'une stratégie par l'utilisateur, où les informations sur la stratégie sont transmises à la classe Utilisateur.