Restructuration majeure du projet: migration de flutt vers app, ajout de l'API et mise à jour du site web

docs/gestion_hive_boxes.md

@@ -18,6 +18,7 @@ Ce document explique comment les boîtes Hive sont gérées dans l'application G
 Hive est une base de données NoSQL légère et rapide utilisée dans GeoSector pour stocker les données localement. Les données sont organisées en "boîtes" (boxes) qui peuvent être typées pour stocker des modèles spécifiques.
 
 Dans cette application, Hive est utilisé pour :
+
 - Stocker les données utilisateur et maintenir les sessions
 - Conserver les données des opérations, secteurs et passages
 - Permettre l'utilisation de l'application en mode hors ligne
@@ -36,6 +37,7 @@ static const String settingsBoxName = 'settings';
 ```
 
 Chaque boîte stocke un type spécifique de données :
+
 - **users** : Stocke les informations des utilisateurs (`UserModel`)
 - **operations** : Stocke les opérations (`OperationModel`)
 - **sectors** : Stocke les secteurs (`SectorModel`)
@@ -106,10 +108,16 @@ await Hive.openBox(AppKeys.settingsBoxName); // Préférences générales
 
 ### UserRepository
 
-Le `UserRepository` est le principal gestionnaire des boîtes Hive. Il est responsable de :
+Le `UserRepository` est le principal gestionnaire des boîtes Hive et de l'authentification. Il est responsable de :
+
 - L'initialisation des boîtes au démarrage de l'application
 - La gestion des boîtes pendant les processus de connexion et déconnexion
 - Le nettoyage et la recréation des boîtes lorsque nécessaire
+- La gestion complète de l'authentification (connexion et déconnexion)
+- L'affichage des overlays de chargement pendant les opérations d'authentification
+- La redirection vers les pages appropriées après connexion/déconnexion
+
+> **Note importante** : Auparavant, l'application utilisait un service séparé `AuthService` pour gérer l'authentification. Cette classe a été supprimée et ses fonctionnalités ont été intégrées directement dans `UserRepository` pour simplifier l'architecture et éviter les problèmes de synchronisation entre les deux classes.
 
 ### Autres repositories spécialisés
 
@@ -124,14 +132,17 @@ Ces repositories sont injectés dans le `UserRepository` pour traiter les donné
 Le processus de connexion dans `UserRepository.login()` suit ces étapes :
 
 1. **Nettoyage initial** :
+
    - Suppression des boîtes non référencées (`auth`, `locations`, `messages`)
    - Nettoyage adapté à la plateforme (Web, iOS, Android)
 
 2. **Préparation des boîtes** :
+
    - Appel à `_clearAndRecreateBoxes()` pour vider et recréer les boîtes sans les fermer
    - Utilisation de `_ensureBoxIsOpen()` pour garantir que les boîtes sont ouvertes
 
 3. **Appel API et traitement des données** :
+
    - Connexion via l'API
    - Vérification que toutes les boîtes sont ouvertes avant le traitement
    - Traitement des données reçues (opérations, secteurs, passages)
@@ -159,34 +170,93 @@ await _processPassages(passagesData);
 Le processus de déconnexion dans `UserRepository.logout()` suit ces étapes :
 
 1. **Préparation** :
-   - S'assurer que la boîte des utilisateurs est ouverte
-   - Suppression des boîtes non référencées
 
-2. **Gestion de l'utilisateur** :
    - Récupération de l'utilisateur actuel avant nettoyage
    - Déconnexion de la session API
-   - Mise à jour de l'utilisateur pour effacer les données de session
+   - Réinitialisation du cache de l'utilisateur actuel
 
-3. **Nettoyage des données** :
-   - Nettoyage adapté à la plateforme (Web, iOS, Android)
-   - Appel à `_clearAndRecreateBoxes()` pour vider les boîtes sans les fermer
+2. **Nettoyage des données** :
+   - Appel à `_deepCleanHiveBoxes()` pour un nettoyage complet des boîtes Hive
+
+### Méthode \_deepCleanHiveBoxes
+
+La méthode `_deepCleanHiveBoxes()` est cruciale pour le processus de déconnexion et suit ces étapes :
+
+1. **Vidage des boîtes** :
+
+   - Vidage de toutes les boîtes Hive ouvertes sans les fermer
+   - Gestion des erreurs pour chaque boîte avec typage spécifique
+
+2. **Nettoyage spécifique à la plateforme** :
+
+   - Nettoyage adapté selon la plateforme (Web, iOS, Android)
+   - Utilisation de méthodes spécifiques comme `_clearIndexedDB()` pour le web
+
+3. **Réinitialisation** :
+   - Réinitialisation de l'API Service
 
 ### Code clé pour la déconnexion
 
 ```dart
-// S'assurer que la boîte des utilisateurs est ouverte
-await _ensureBoxIsOpen(AppKeys.usersBoxName);
+// Méthode logout
+Future<bool> logout() async {
+  try {
+    // Récupérer l'utilisateur actuel avant de nettoyer les données
+    final currentUser = getCurrentUser();
 
-// Récupérer l'utilisateur et effacer sa session
-final updatedUser = currentUser.copyWith(
-  sessionId: null,
-  sessionExpiry: null,
-  lastPath: null
-);
-await saveUser(updatedUser);
+    // Déconnecter la session API
+    if (currentUser?.sessionId != null) {
+      await logoutAPI();
+    }
 
-// Vider les boîtes sans les fermer
-await _clearAndRecreateBoxes();
+    // Supprimer la session API
+    setSessionId(null);
+
+    // Réinitialiser le cache de l'utilisateur actuel
+    _cachedCurrentUser = null;
+
+    // Nettoyage complet des boîtes Hive
+    await _deepCleanHiveBoxes();
+
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Méthode de nettoyage des boîtes Hive
+Future<void> _deepCleanHiveBoxes() async {
+  try {
+    // 1. Vider toutes les boîtes sans les fermer
+    if (Hive.isBoxOpen(AppKeys.usersBoxName)) {
+      await Hive.box<UserModel>(AppKeys.usersBoxName).clear();
+    }
+
+    if (Hive.isBoxOpen(AppKeys.operationsBoxName)) {
+      await Hive.box<OperationModel>(AppKeys.operationsBoxName).clear();
+    }
+
+    if (Hive.isBoxOpen(AppKeys.sectorsBoxName)) {
+      await Hive.box<SectorModel>(AppKeys.sectorsBoxName).clear();
+    }
+
+    // Vider les autres boîtes...
+
+    // 2. Nettoyage spécifique à la plateforme
+    if (kIsWeb) {
+      await _clearIndexedDB();
+    } else if (Platform.isIOS) {
+      await _cleanHiveFilesOnIOS();
+    } else if (Platform.isAndroid) {
+      await _cleanHiveFilesOnAndroid();
+    }
+
+    // 3. Réinitialiser l'API Service
+    _apiService.setSessionId(null);
+  } catch (e) {
+    debugPrint('Erreur lors du nettoyage des boîtes Hive: $e');
+  }
+}
 ```
 
 ## Problèmes connus et solutions
@@ -201,7 +271,8 @@ await _clearAndRecreateBoxes();
 
 **Problème** : Des erreurs se produisent lorsqu'on tente d'accéder à une boîte qui a été fermée prématurément.
 
-**Solution** : 
+**Solution** :
+
 - Utiliser la méthode `_ensureBoxIsOpen()` avant d'accéder à une boîte
 - Éviter de fermer les boîtes qui pourraient être utilisées plus tard
 - Préférer `box.clear()` à `box.close()` pour vider les données sans fermer la boîte
@@ -217,11 +288,13 @@ await _clearAndRecreateBoxes();
 ### Initialisation à la demande
 
 1. **Initialiser les boîtes uniquement lorsqu'elles sont nécessaires** :
+
    - N'ouvrir que les boîtes `users` et `settings` au démarrage
    - Initialiser les autres boîtes après connexion réussie
    - Utiliser `_ensureBoxIsOpen()` avant chaque accès à une boîte
 
 2. **Centraliser la gestion des boîtes** :
+
    - Créer un service dédié à la gestion des boîtes Hive
    - Utiliser des méthodes comme `openRequiredBoxes()` et `clearAllBoxes()`
 
@@ -232,10 +305,12 @@ await _clearAndRecreateBoxes();
 ### Éviter l'erreur "Box has already been closed"
 
 1. **Ne jamais fermer une boîte qui pourrait être utilisée plus tard** :
+
    - Utiliser `_ensureBoxIsOpen()` au lieu de fermer et rouvrir les boîtes
    - Vider les boîtes avec `box.clear()` au lieu de les fermer
 
 2. **Vérifier qu'une boîte est ouverte avant de l'utiliser** :
+
    ```dart
    if (!Hive.isBoxOpen(boxName)) {
      await Hive.openBox<T>(boxName);
@@ -246,7 +321,7 @@ await _clearAndRecreateBoxes();
    - Toujours entourer les opérations Hive de blocs try/catch
    - Prévoir des mécanismes de récupération en cas d'erreur
 
-### Méthode utilitaire _ensureBoxIsOpen
+### Méthode utilitaire \_ensureBoxIsOpen
 
 Cette méthode est cruciale pour garantir qu'une boîte est ouverte avant de l'utiliser :