feat: synchronisation mode deconnecte fin chat et stats

2025-08-31 18:21:20 +02:00
parent 41a4505b4b
commit 604294af96
149 changed files with 285769 additions and 250633 deletions
--- a/app/lib/presentation/auth/splash_page.dart
+++ b/app/lib/presentation/auth/splash_page.dart
@@ -3,11 +3,16 @@ import 'package:go_router/go_router.dart';
 import 'package:geosector_app/core/services/app_info_service.dart';
 import 'package:geosector_app/core/services/hive_service.dart';
 import 'package:geosector_app/core/services/location_service.dart';
+import 'package:geosector_app/core/constants/app_keys.dart';
+import 'package:hive_flutter/hive_flutter.dart';
 import 'dart:async';
 import 'dart:math' as math;
 import 'package:flutter/foundation.dart' show kIsWeb;
 import 'package:package_info_plus/package_info_plus.dart';
 import 'package:url_launcher/url_launcher.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+// ignore: avoid_web_libraries_in_flutter
+import 'dart:html' as html if (dart.library.io) '';

 class SplashPage extends StatefulWidget {
  /// Action à effectuer après l'initialisation (login ou register)
@@ -55,6 +60,7 @@ class _SplashPageState extends State<SplashPage> with SingleTickerProviderStateM
  String _appVersion = '';
  bool _showLocationError = false;
  String? _locationErrorMessage;
+  bool _isCleaningCache = false;

  Future<void> _getAppVersion() async {
    try {
@@ -74,6 +80,216 @@ class _SplashPageState extends State<SplashPage> with SingleTickerProviderStateM
    }
  }

+  /// Effectue un nettoyage sélectif du cache
+  /// Préserve la box pending_requests et les données critiques
+  Future<void> _performSelectiveCleanup({bool manual = false}) async {
+    debugPrint('🧹 === DÉBUT DU NETTOYAGE DU CACHE === 🧹');
+    debugPrint('📌 Type: ${manual ? "MANUEL" : "AUTOMATIQUE"}');
+    debugPrint('📱 Platform: ${kIsWeb ? "WEB" : "MOBILE"}');
+    debugPrint('📦 Version actuelle: $_appVersion');
+    
+    try {
+      if (mounted) {
+        setState(() {
+          _isCleaningCache = true;
+          _statusMessage = "Nettoyage du cache en cours...";
+          _progress = 0.1;
+        });
+      }
+
+      // Étape 1: Nettoyer le Service Worker (Web uniquement)
+      if (kIsWeb) {
+        debugPrint('🔄 Nettoyage du Service Worker...');
+        try {
+          // Désenregistrer tous les service workers
+          final registrations = await html.window.navigator.serviceWorker?.getRegistrations();
+          if (registrations != null) {
+            for (final registration in registrations) {
+              await registration.unregister();
+              debugPrint('✅ Service Worker désenregistré');
+            }
+          }
+          
+          // Nettoyer les caches du navigateur
+          if (html.window.caches != null) {
+            final cacheNames = await html.window.caches!.keys();
+            for (final cacheName in cacheNames) {
+              await html.window.caches!.delete(cacheName);
+              debugPrint('✅ Cache "$cacheName" supprimé');
+            }
+          }
+        } catch (e) {
+          debugPrint('⚠️ Erreur lors du nettoyage Service Worker: $e');
+        }
+      }
+
+      if (mounted) {
+        setState(() {
+          _statusMessage = "Fermeture des bases de données...";
+          _progress = 0.3;
+        });
+      }
+
+      // Étape 2: Sauvegarder les données de pending_requests
+      debugPrint('💾 Sauvegarde des requêtes en attente...');
+      List<dynamic>? pendingRequests;
+      try {
+        if (Hive.isBoxOpen(AppKeys.pendingRequestsBoxName)) {
+          final pendingBox = Hive.box(AppKeys.pendingRequestsBoxName);
+          pendingRequests = pendingBox.values.toList();
+          debugPrint('📊 ${pendingRequests.length} requêtes en attente sauvegardées');
+          await pendingBox.close();
+        }
+      } catch (e) {
+        debugPrint('⚠️ Erreur lors de la sauvegarde des requêtes: $e');
+      }
+
+      if (mounted) {
+        setState(() {
+          _statusMessage = "Nettoyage des données locales...";
+          _progress = 0.5;
+        });
+      }
+
+      // Étape 3: Lister toutes les boxes à nettoyer (SAUF pending_requests)
+      final boxesToClean = [
+        AppKeys.userBoxName,
+        AppKeys.operationsBoxName,
+        AppKeys.passagesBoxName,
+        AppKeys.sectorsBoxName,
+        AppKeys.membresBoxName,
+        AppKeys.amicaleBoxName,
+        AppKeys.clientsBoxName,
+        AppKeys.userSectorBoxName,
+        AppKeys.settingsBoxName,
+        AppKeys.chatRoomsBoxName,
+        AppKeys.chatMessagesBoxName,
+      ];
+
+      // Étape 4: Fermer et supprimer les boxes
+      debugPrint('🗑️ Nettoyage des boxes Hive...');
+      for (final boxName in boxesToClean) {
+        try {
+          if (Hive.isBoxOpen(boxName)) {
+            await Hive.box(boxName).close();
+            debugPrint('📦 Box "$boxName" fermée');
+          }
+          await Hive.deleteBoxFromDisk(boxName);
+          debugPrint('✅ Box "$boxName" supprimée');
+        } catch (e) {
+          debugPrint('⚠️ Erreur lors du nettoyage de "$boxName": $e');
+        }
+      }
+
+      if (mounted) {
+        setState(() {
+          _statusMessage = "Réinitialisation de Hive...";
+          _progress = 0.7;
+        });
+      }
+
+      // Étape 5: Réinitialiser Hive proprement
+      debugPrint('🔄 Réinitialisation de Hive...');
+      await Hive.close();
+      await Future.delayed(const Duration(milliseconds: 500));
+      await Hive.initFlutter();
+
+      // Étape 6: Restaurer les requêtes en attente
+      if (pendingRequests != null && pendingRequests.isNotEmpty) {
+        debugPrint('♻️ Restauration des requêtes en attente...');
+        final pendingBox = await Hive.openBox(AppKeys.pendingRequestsBoxName);
+        for (final request in pendingRequests) {
+          await pendingBox.add(request);
+        }
+        debugPrint('✅ ${pendingRequests.length} requêtes restaurées');
+      }
+
+      if (mounted) {
+        setState(() {
+          _statusMessage = "Nettoyage terminé !";
+          _progress = 1.0;
+        });
+      }
+
+      // Étape 7: Sauvegarder la nouvelle version
+      if (!manual && kIsWeb) {
+        final prefs = await SharedPreferences.getInstance();
+        await prefs.setString('app_version', _appVersion);
+        debugPrint('💾 Version $_appVersion sauvegardée');
+      }
+
+      debugPrint('🎉 === NETTOYAGE TERMINÉ AVEC SUCCÈS === 🎉');
+
+      // Petit délai pour voir le message de succès
+      await Future.delayed(const Duration(milliseconds: 500));
+
+      if (mounted) {
+        setState(() {
+          _isCleaningCache = false;
+          _progress = 0.0;
+        });
+      }
+
+    } catch (e) {
+      debugPrint('❌ ERREUR CRITIQUE lors du nettoyage: $e');
+      if (mounted) {
+        setState(() {
+          _isCleaningCache = false;
+          _statusMessage = "Erreur lors du nettoyage";
+          _progress = 0.0;
+        });
+        
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text('Erreur lors du nettoyage: $e'),
+            backgroundColor: Colors.red,
+            duration: const Duration(seconds: 5),
+          ),
+        );
+      }
+    }
+  }
+
+  /// Vérifie si une nouvelle version est disponible et nettoie si nécessaire
+  Future<void> _checkVersionAndCleanIfNeeded() async {
+    if (!kIsWeb) {
+      debugPrint('📱 Plateforme mobile - pas de nettoyage automatique');
+      return;
+    }
+
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final lastVersion = prefs.getString('app_version') ?? '';
+      
+      debugPrint('🔍 Vérification de version:');
+      debugPrint('   Version stockée: $lastVersion');
+      debugPrint('   Version actuelle: $_appVersion');
+
+      // Si changement de version détecté
+      if (lastVersion.isNotEmpty && lastVersion != _appVersion) {
+        debugPrint('🆕 NOUVELLE VERSION DÉTECTÉE !');
+        debugPrint('   Migration de $lastVersion vers $_appVersion');
+        
+        if (mounted) {
+          setState(() {
+            _statusMessage = "Nouvelle version détectée, mise à jour...";
+          });
+        }
+
+        // Effectuer le nettoyage automatique
+        await _performSelectiveCleanup(manual: false);
+      } else if (lastVersion.isEmpty) {
+        // Première installation
+        debugPrint('🎉 Première installation détectée');
+        await prefs.setString('app_version', _appVersion);
+      } else {
+        debugPrint('✅ Même version - pas de nettoyage nécessaire');
+      }
+    } catch (e) {
+      debugPrint('⚠️ Erreur lors de la vérification de version: $e');
+    }
+  }
+
  @override
  void initState() {
    super.initState();
@@ -109,7 +325,10 @@ class _SplashPageState extends State<SplashPage> with SingleTickerProviderStateM
    try {
      debugPrint('🚀 Début de l\'initialisation complète de l\'application...');

-      // Étape 0: Vérification des permissions GPS (obligatoire) - 0 à 10%
+      // Étape 0: Vérifier et nettoyer si nouvelle version (Web uniquement)
+      await _checkVersionAndCleanIfNeeded();
+
+      // Étape 1: Vérification des permissions GPS (obligatoire) - 0 à 10%
      if (!kIsWeb) {
        if (mounted) {
          setState(() {
@@ -183,6 +402,26 @@ class _SplashPageState extends State<SplashPage> with SingleTickerProviderStateM

      // Étape 3: Ouverture des Box - 60 à 80%
      await HiveService.instance.ensureBoxesAreOpen();
+      
+      // Gérer la box pending_requests séparément pour préserver les données
+      try {
+        debugPrint('📦 Gestion de la box pending_requests...');
+        if (!Hive.isBoxOpen(AppKeys.pendingRequestsBoxName)) {
+          // Importer PendingRequest si nécessaire
+          final pendingRequestBox = await Hive.openBox(AppKeys.pendingRequestsBoxName);
+          final pendingCount = pendingRequestBox.length;
+          if (pendingCount > 0) {
+            debugPrint('⏳ $pendingCount requêtes en attente trouvées dans la box');
+          } else {
+            debugPrint('✅ Box pending_requests ouverte (vide)');
+          }
+        } else {
+          debugPrint('✅ Box pending_requests déjà ouverte');
+        }
+      } catch (e) {
+        debugPrint('⚠️ Erreur lors de l\'ouverture de la box pending_requests: $e');
+        // On continue quand même, ce n'est pas critique pour le démarrage
+      }

      if (mounted) {
        setState(() {
@@ -215,6 +454,18 @@ class _SplashPageState extends State<SplashPage> with SingleTickerProviderStateM
          _progress = 1.0;
        });
        
+        // Marquer dans settings que l'initialisation complète de Hive a été effectuée
+        try {
+          if (Hive.isBoxOpen(AppKeys.settingsBoxName)) {
+            final settingsBox = Hive.box(AppKeys.settingsBoxName);
+            await settingsBox.put('hive_initialized', true);
+            await settingsBox.put('hive_initialized_at', DateTime.now().toIso8601String());
+            debugPrint('✅ Clé hive_initialized définie à true dans settings');
+          }
+        } catch (e) {
+          debugPrint('⚠️ Impossible de définir la clé hive_initialized: $e');
+        }
+        
        // Attendre un court instant pour que l'utilisateur voie "Application prête !"
        await Future.delayed(const Duration(milliseconds: 400));
        
@@ -375,7 +626,7 @@ class _SplashPageState extends State<SplashPage> with SingleTickerProviderStateM
                    const Spacer(flex: 1),

                    // Indicateur de chargement
-                    if (_isInitializing && !_showLocationError) ...[
+                    if ((_isInitializing || _isCleaningCache) && !_showLocationError) ...[
                      Padding(
                        padding: const EdgeInsets.symmetric(horizontal: 40),
                        child: Column(
@@ -651,6 +902,65 @@ class _SplashPageState extends State<SplashPage> with SingleTickerProviderStateM
                          ),
                        ),
                      ),
+
+                      const SizedBox(height: 8),
+
+                      // Bouton de nettoyage du cache (en noir)
+                      AnimatedOpacity(
+                        opacity: _showButtons ? 1.0 : 0.0,
+                        duration: const Duration(milliseconds: 500),
+                        child: TextButton.icon(
+                          onPressed: _isCleaningCache ? null : () async {
+                            // Confirmation avant nettoyage
+                            final confirm = await showDialog<bool>(
+                              context: context,
+                              builder: (context) => AlertDialog(
+                                title: const Text('Nettoyer le cache ?'),
+                                content: const Text(
+                                  'Cette action va :\n'
+                                  '• Supprimer toutes les données locales\n'
+                                  '• Préserver les requêtes en attente\n'
+                                  '• Forcer le rechargement de l\'application\n\n'
+                                  'Continuer ?'
+                                ),
+                                actions: [
+                                  TextButton(
+                                    onPressed: () => Navigator.of(context).pop(false),
+                                    child: const Text('Annuler'),
+                                  ),
+                                  ElevatedButton(
+                                    onPressed: () => Navigator.of(context).pop(true),
+                                    style: ElevatedButton.styleFrom(
+                                      backgroundColor: Colors.orange,
+                                    ),
+                                    child: const Text('Nettoyer'),
+                                  ),
+                                ],
+                              ),
+                            );
+
+                            if (confirm == true) {
+                              debugPrint('👤 Utilisateur a demandé un nettoyage manuel');
+                              await _performSelectiveCleanup(manual: true);
+                              
+                              // Après le nettoyage, relancer l'initialisation
+                              _startInitialization();
+                            }
+                          },
+                          icon: Icon(
+                            Icons.cleaning_services,
+                            size: 18,
+                            color: _isCleaningCache ? Colors.grey : Colors.black87,
+                          ),
+                          label: Text(
+                            _isCleaningCache ? 'Nettoyage...' : 'Nettoyer le cache',
+                            style: TextStyle(
+                              color: _isCleaningCache ? Colors.grey : Colors.black87,
+                              fontWeight: FontWeight.w500,
+                            ),
+                          ),
+                        ),
+                      ),
                    ],

                    const Spacer(flex: 1),