feat: refactor de la gestion des utilisateurs et migration de la logique métier vers les Cloud Functions

Cette mise à jour majeure refactorise entièrement la gestion des utilisateurs pour la faire passer par des Cloud Functions sécurisées et migre une part importante de la logique métier (gestion des événements, maintenances, containers) du client vers le backend.

**Gestion des Utilisateurs (Backend & Frontend):**
- **Nouvelle fonction `createUserWithInvite` :**
    - Crée l'utilisateur dans Firebase Auth avec un mot de passe temporaire.
    - Crée le document utilisateur correspondant dans Firestore.
    - Envoie automatiquement un e-mail de réinitialisation de mot de passe (via l'API REST de Firebase et `axios`) pour que l'utilisateur définisse son propre mot de passe, améliorant la sécurité et l'expérience d'intégration.
- **Refactorisation de `updateUser` et `deleteUser` :**
    - Les anciennes fonctions `onCall` sont remplacées par des fonctions `onRequest` (HTTP) standards, alignées avec le reste de l'API.
    - La logique de suppression gère désormais la suppression dans Auth et Firestore.
- **Réinitialisation de Mot de Passe (UI) :**
    - Ajout d'un bouton "Réinitialiser le mot de passe" sur la carte utilisateur, permettant aux administrateurs d'envoyer un e-mail de réinitialisation à n'importe quel utilisateur.
- **Amélioration de l'UI :**
    - Boîte de dialogue de confirmation améliorée pour la suppression d'un utilisateur.
    - Notifications (Snackbars) pour les opérations de création, suppression et réinitialisation de mot de passe.

**Migration de la Logique Métier vers les Cloud Functions:**
- **Gestion de la Préparation d'Événements :**
    - Migration complète de la logique de validation des étapes (préparation, chargement, déchargement, retour) du client vers de nouvelles Cloud Functions (`validateEquipmentPreparation`, `validateAllLoading`, etc.).
    - Le backend gère désormais la mise à jour des statuts de l'événement (`inProgress`, `completed`) et des équipements (`inUse`, `available`).
    - Le code frontend (`EventPreparationService`) a été simplifié pour appeler ces nouvelles fonctions au lieu d'effectuer des écritures directes sur Firestore.
- **Création de Maintenance :**
    - La fonction `createMaintenance` gère maintenant la mise à jour des équipements associés (`maintenanceIds`) et la création d'alertes (`maintenanceDue`) si une maintenance est prévue prochainement. La logique client a été supprimée.
- **Suppression de Container :**
    - La fonction `deleteContainer` a été améliorée pour nettoyer automatiquement les références (`parentBoxIds`) dans tous les équipements contenus avant de supprimer le container.

**Refactorisation et Corrections (Backend & Frontend) :**
- **Fiabilisation des Appels API (Frontend) :**
    - Le `ApiService` a été renforcé pour convertir de manière plus robuste les données (notamment les `Map` de type `_JsonMap`) en JSON standard avant de les envoyer aux Cloud Functions, évitant ainsi des erreurs de sérialisation.
- **Correction des Références (Backend) :**
    - La fonction `updateUser` convertit correctement les `roleId` (string) en `DocumentReference` Firestore.
    - Sécurisation de la vérification de l'assignation d'un utilisateur à un événement (`workforce`) pour éviter les erreurs sur des références nulles.
- **Dépendance (Backend) :**
    - Ajout de la librairie `axios` pour effectuer des appels à l'API REST de Firebase.

em2rp/lib/models/user_model.dart

@@ -65,7 +65,7 @@ class UserModel {
     return {
       'firstName': firstName,
       'lastName': lastName,
-      'role': FirebaseFirestore.instance.collection('roles').doc(role),
+      'role': role, // Envoyer directement le string roleId au lieu de créer une DocumentReference
       'profilePhotoUrl': profilePhotoUrl,
       'email': email,
       'phoneNumber': phoneNumber,

em2rp/lib/providers/users_provider.dart

@@ -1,4 +1,5 @@
 import 'package:flutter/material.dart';
+import 'package:firebase_auth/firebase_auth.dart';
 import 'package:em2rp/models/user_model.dart';
 import 'package:em2rp/services/data_service.dart';
 import 'package:em2rp/services/api_service.dart';
@@ -81,9 +82,21 @@ class UsersProvider with ChangeNotifier {
     required String roleId,
   }) async {
     try {
-      // TODO: Implémenter via Cloud Function
       print('Creating user with email invite: $email');
-      await fetchUsers(); // Recharger la liste
+
+      // Appeler la Cloud Function pour créer l'utilisateur
+      await _dataService.createUserWithInvite(
+        email: email,
+        firstName: firstName,
+        lastName: lastName,
+        phoneNumber: phoneNumber,
+        roleId: roleId,
+      );
+
+      // Recharger la liste des utilisateurs
+      await fetchUsers();
+
+      print('User created successfully: $email');
     } catch (e) {
       print('Error creating user with email invite: $e');
       rethrow;
@@ -92,9 +105,13 @@ class UsersProvider with ChangeNotifier {
 
   /// Réinitialisation du mot de passe
   Future<void> resetPassword(String email) async {
-    // Firebase Auth reste OK
-    // await _userService.resetPassword(email);
-    // TODO: Implémenter via Cloud Function
-    print('Reset password for: $email');
+    try {
+      // Firebase Auth reste OK (ce n'est pas Firestore)
+      await FirebaseAuth.instance.sendPasswordResetEmail(email: email);
+      print('Email de réinitialisation envoyé à $email');
+    } catch (e) {
+      print('Error reset password: $e');
+      rethrow;
+    }
   }
 }

em2rp/lib/services/api_service.dart

@@ -35,38 +35,110 @@ class FirebaseFunctionsApiService implements ApiService {
     };
   }
 
-  /// Convertit récursivement les Timestamps Firestore, DocumentReference et GeoPoint en formats encodables
-  dynamic _convertTimestamps(dynamic value) {
+  /// Convertit récursivement TOUT en types JSON standards (String, num, bool, List, Map)
+  /// Garantit que toutes les Maps sont des Map<String, dynamic> littérales
+  dynamic _toJsonSafe(dynamic value) {
     if (value == null) return null;
 
+    // Types primitifs JSON-safe
+    if (value is String || value is num || value is bool) {
+      return value;
+    }
+
+    // Types Firestore
     if (value is Timestamp) {
-      // Convertir Timestamp en ISO string
       return value.toDate().toIso8601String();
-    } else if (value is DateTime) {
-      // Convertir DateTime en ISO string
+    }
+    if (value is DateTime) {
       return value.toIso8601String();
-    } else if (value is DocumentReference) {
-      // Convertir DocumentReference en path string
+    }
+    if (value is DocumentReference) {
       return value.path;
-    } else if (value is GeoPoint) {
-      // Convertir GeoPoint en objet avec latitude et longitude
-      return {
+    }
+    if (value is GeoPoint) {
+      // Créer une Map littérale explicite
+      return <String, dynamic>{
         'latitude': value.latitude,
         'longitude': value.longitude,
       };
-    } else if (value is Map) {
-      // Parcourir récursivement les Maps et créer une nouvelle Map typée
-      final Map<String, dynamic> result = {};
-      value.forEach((key, val) {
-        result[key.toString()] = _convertTimestamps(val);
-      });
-      return result;
-    } else if (value is List) {
-      // Parcourir récursivement les Lists
-      return value.map((item) => _convertTimestamps(item)).toList();
     }
 
-    return value;
+    // Listes - créer une nouvelle List littérale
+    if (value is List) {
+      final result = <dynamic>[];
+      for (final item in value) {
+        result.add(_toJsonSafe(item));
+      }
+      return result;
+    }
+
+    // Maps - créer une nouvelle Map littérale explicite
+    if (value is Map) {
+      final result = <String, dynamic>{};
+      value.forEach((k, v) {
+        final key = k.toString();
+        final convertedValue = _toJsonSafe(v);
+        result[key] = convertedValue;
+      });
+      return result;
+    }
+
+    // Type non supporté - retourner en String
+    return value.toString();
+  }
+
+  /// Prépare les données pour jsonEncode en faisant un double passage
+  Map<String, dynamic> _prepareForJson(Map<String, dynamic> data) {
+    try {
+      // Premier passage : convertir tous les types Firestore
+      final safeData = _toJsonSafe(data);
+
+      // Deuxième passage : encoder puis décoder pour forcer la normalisation
+      // Cela garantit que tout est 100% compatible JSON et élimine tous les _JsonMap
+      final jsonString = jsonEncode(safeData);
+      final decoded = jsonDecode(jsonString);
+
+      // Force le type Map<String, dynamic>
+      if (decoded is Map) {
+        return Map<String, dynamic>.from(decoded);
+      }
+
+      // Fallback - ne devrait jamais arriver
+      return Map<String, dynamic>.from(safeData as Map);
+    } catch (e) {
+      // Si l'encodage échoue, essayer de créer une copie profonde manuelle
+      print('[API] Error in _prepareForJson: $e');
+      print('[API] Trying manual deep copy...');
+      return _deepCopyMap(data);
+    }
+  }
+
+  /// Copie profonde manuelle d'une Map pour éviter les _JsonMap
+  Map<String, dynamic> _deepCopyMap(Map<String, dynamic> source) {
+    final result = <String, dynamic>{};
+    source.forEach((key, value) {
+      if (value is Map) {
+        result[key] = _deepCopyMap(Map<String, dynamic>.from(value));
+      } else if (value is List) {
+        result[key] = _deepCopyList(value);
+      } else {
+        result[key] = value;
+      }
+    });
+    return result;
+  }
+
+  /// Copie profonde manuelle d'une List
+  List<dynamic> _deepCopyList(List<dynamic> source) {
+    return source.map((item) {
+      if (item is Map) {
+        return _deepCopyMap(Map<String, dynamic>.from(item));
+      } else if (item is List) {
+        return _deepCopyList(item);
+      } else {
+        return item;
+      }
+    }).toList();
   }
 
   @override
@@ -74,26 +146,38 @@ class FirebaseFunctionsApiService implements ApiService {
     final url = Uri.parse('$_baseUrl/$functionName');
     final headers = await _getHeaders();
 
-    // Convertir les Timestamps avant l'envoi
-    final convertedData = _convertTimestamps(data) as Map<String, dynamic>;
+    // Préparer les données avec double passage pour éviter les _JsonMap
+    final preparedData = _prepareForJson(data);
 
     // Log pour débogage
-    print('[API] Calling $functionName with eventId: ${convertedData['eventId']}');
+    print('[API] Calling $functionName with eventId: ${preparedData['eventId']}');
 
-    final response = await http.post(
-      url,
-      headers: headers,
-      body: jsonEncode({'data': convertedData}),
-    );
+    try {
+      // Encoder directement avec jsonEncode standard
+      final bodyJson = jsonEncode({'data': preparedData});
 
-    if (response.statusCode >= 200 && response.statusCode < 300) {
-      final responseData = jsonDecode(response.body);
-      return responseData is Map<String, dynamic> ? responseData : {};
-    } else {
-      final error = jsonDecode(response.body);
+      final response = await http.post(
+        url,
+        headers: headers,
+        body: bodyJson,
+      );
+
+      if (response.statusCode >= 200 && response.statusCode < 300) {
+        final responseData = jsonDecode(response.body);
+        return responseData is Map<String, dynamic> ? responseData : {};
+      } else {
+        final error = jsonDecode(response.body);
+        throw ApiException(
+          message: error['error'] ?? 'Unknown error',
+          statusCode: response.statusCode,
+        );
+      }
+    } catch (e) {
+      print('[API] Error during request: $e');
+      print('[API] Error type: ${e.runtimeType}');
       throw ApiException(
-        message: error['error'] ?? 'Unknown error',
-        statusCode: response.statusCode,
+        message: 'Error calling $functionName: $e',
+        statusCode: 0,
       );
     }
   }
@@ -124,13 +208,13 @@ class FirebaseFunctionsApiService implements ApiService {
     final url = Uri.parse('$_baseUrl/$endpoint');
     final headers = await _getHeaders();
 
-    // Convertir les Timestamps avant l'envoi
-    final convertedData = _convertTimestamps(data) as Map<String, dynamic>;
+    // Préparer les données avec double passage
+    final preparedData = _prepareForJson(data);
 
     final response = await http.post(
       url,
       headers: headers,
-      body: jsonEncode({'data': convertedData}),
+      body: jsonEncode({'data': preparedData}),
     );
 
     if (response.statusCode >= 200 && response.statusCode < 300) {
@@ -150,13 +234,13 @@ class FirebaseFunctionsApiService implements ApiService {
     final url = Uri.parse('$_baseUrl/$endpoint');
     final headers = await _getHeaders();
 
-    // Convertir les Timestamps avant l'envoi
-    final convertedData = _convertTimestamps(data) as Map<String, dynamic>;
+    // Préparer les données avec double passage
+    final preparedData = _prepareForJson(data);
 
     final response = await http.put(
       url,
       headers: headers,
-      body: jsonEncode({'data': convertedData}),
+      body: jsonEncode({'data': preparedData}),
     );
 
     if (response.statusCode >= 200 && response.statusCode < 300) {
@@ -176,13 +260,13 @@ class FirebaseFunctionsApiService implements ApiService {
     final url = Uri.parse('$_baseUrl/$endpoint');
     final headers = await _getHeaders();
 
-    // Convertir les Timestamps avant l'envoi si data existe
-    final convertedData = data != null ? _convertTimestamps(data) as Map<String, dynamic> : null;
+    // Préparer les données avec double passage si data existe
+    final preparedData = data != null ? _prepareForJson(data) : null;
 
     final response = await http.delete(
       url,
       headers: headers,
-      body: convertedData != null ? jsonEncode({'data': convertedData}) : null,
+      body: preparedData != null ? jsonEncode({'data': preparedData}) : null,
     );
 
     if (response.statusCode < 200 || response.statusCode >= 300) {

em2rp/lib/services/container_service.dart

@@ -41,27 +41,8 @@ class ContainerService {
   /// Supprimer un container (via Cloud Function)
   Future<void> deleteContainer(String id) async {
     try {
-      // Récupérer le container pour obtenir les équipements
-      final container = await getContainerById(id);
-      if (container != null && container.equipmentIds.isNotEmpty) {
-        // Retirer le container des parentBoxIds de chaque équipement
-        for (final equipmentId in container.equipmentIds) {
-          final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
-          if (equipmentDoc.exists) {
-            final equipment = EquipmentModel.fromMap(
-              equipmentDoc.data() as Map<String, dynamic>,
-              equipmentDoc.id,
-            );
-            final updatedParents = equipment.parentBoxIds.where((boxId) => boxId != id).toList();
-            await _equipmentCollection.doc(equipmentId).update({
-              'parentBoxIds': updatedParents,
-              'updatedAt': Timestamp.fromDate(DateTime.now()),
-            });
-          }
-        }
-      }
-
       await _apiService.call('deleteContainer', {'containerId': id});
+      // Note: La Cloud Function gère maintenant la mise à jour des équipements
     } catch (e) {
       print('Error deleting container: $e');
       rethrow;

em2rp/lib/services/data_service.dart

@@ -496,11 +496,34 @@ class DataService {
   /// Met à jour un utilisateur
   Future<void> updateUser(String userId, Map<String, dynamic> data) async {
     try {
-      final requestData = {'userId': userId, ...data};
-      await _apiService.call('updateUser', requestData);
+      await _apiService.call('updateUser', {
+        'userId': userId,
+        'data': data,
+      });
     } catch (e) {
       throw Exception('Erreur lors de la mise à jour de l\'utilisateur: $e');
     }
   }
-}
 
+  /// Crée un utilisateur avec invitation par email
+  Future<Map<String, dynamic>> createUserWithInvite({
+    required String email,
+    required String firstName,
+    required String lastName,
+    String? phoneNumber,
+    required String roleId,
+  }) async {
+    try {
+      final result = await _apiService.call('createUserWithInvite', {
+        'email': email,
+        'firstName': firstName,
+        'lastName': lastName,
+        'phoneNumber': phoneNumber ?? '',
+        'roleId': roleId,
+      });
+      return result;
+    } catch (e) {
+      throw Exception('Erreur lors de la création de l\'utilisateur: $e');
+    }
+  }
+}

em2rp/lib/services/event_preparation_service.dart

@@ -1,14 +1,14 @@
 import 'package:cloud_firestore/cloud_firestore.dart';
 import 'package:em2rp/models/event_model.dart';
 import 'package:em2rp/models/equipment_model.dart';
-import 'package:em2rp/services/equipment_service.dart';
 import 'package:em2rp/services/equipment_status_calculator.dart';
+import 'package:em2rp/services/api_service.dart';
 
 class EventPreparationService {
   final FirebaseFirestore _firestore = FirebaseFirestore.instance;
-  final EquipmentService _equipmentService = EquipmentService();
+  final ApiService _apiService = apiService;
 
-  // Collection references
+  // Collection references (utilisées uniquement pour les lectures)
   CollectionReference get _eventsCollection => _firestore.collection('events');
   CollectionReference get _equipmentCollection => _firestore.collection('equipments');
 
@@ -17,34 +17,10 @@ class EventPreparationService {
    /// Valider un équipement individuel en préparation
   Future<void> validateEquipmentPreparation(String eventId, String equipmentId) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) {
-        throw Exception('Event not found');
-      }
-
-      // Mettre à jour le statut de l'équipement dans la liste
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        if (eq.equipmentId == equipmentId) {
-          return eq.copyWith(isPrepared: true);
-        }
-        return eq;
-      }).toList();
-
-      // Vérifier si tous les équipements sont préparés
-      final allPrepared = updatedEquipment.every((eq) => eq.isPrepared);
-
-      final updateData = <String, dynamic>{
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-      };
-
-      // Mettre à jour le statut selon la complétion
-      if (allPrepared) {
-        updateData['preparationStatus'] = preparationStatusToString(PreparationStatus.completed);
-      } else {
-        updateData['preparationStatus'] = preparationStatusToString(PreparationStatus.inProgress);
-      }
-
-      await _eventsCollection.doc(eventId).update(updateData);
+      await _apiService.call('validateEquipmentPreparation', {
+        'eventId': eventId,
+        'equipmentId': equipmentId,
+      });
     } catch (e) {
       print('Error validating equipment preparation: $e');
       rethrow;
@@ -54,32 +30,12 @@ class EventPreparationService {
   /// Valider tous les équipements en préparation
   Future<void> validateAllPreparation(String eventId) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) {
-        throw Exception('Event not found');
-      }
-
-      // Marquer tous les équipements comme préparés
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        return eq.copyWith(isPrepared: true);
-      }).toList();
-
-      await _eventsCollection.doc(eventId).update({
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-        'preparationStatus': preparationStatusToString(PreparationStatus.completed),
+      await _apiService.call('validateAllPreparation', {
+        'eventId': eventId,
       });
 
       // Invalider le cache des statuts d'équipement
       EquipmentStatusCalculator.invalidateGlobalCache();
-
-      // Mettre à jour le statut des équipements à "inUse" (seulement pour les équipements qui existent)
-      for (var equipment in event.assignedEquipment) {
-        // Vérifier si l'équipement existe avant de mettre à jour son statut
-        final doc = await _equipmentCollection.doc(equipment.equipmentId).get();
-        if (doc.exists) {
-          await updateEquipmentStatus(equipment.equipmentId, EquipmentStatus.inUse);
-        }
-      }
     } catch (e) {
       print('Error validating all preparation: $e');
       rethrow;
@@ -128,55 +84,11 @@ class EventPreparationService {
     int? returnedQuantity,
   }) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) {
-        throw Exception('Event not found');
-      }
-
-      // Mettre à jour le statut de l'équipement dans la liste
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        if (eq.equipmentId == equipmentId) {
-          return eq.copyWith(
-            isReturned: true,
-            returnedQuantity: returnedQuantity,
-          );
-        }
-        return eq;
-      }).toList();
-
-      // Vérifier si tous les équipements sont retournés
-      final allReturned = updatedEquipment.every((eq) => eq.isReturned);
-
-      final updateData = <String, dynamic>{
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-      };
-
-      // Mettre à jour le statut selon la complétion
-      if (allReturned) {
-        updateData['returnStatus'] = returnStatusToString(ReturnStatus.completed);
-      } else {
-        updateData['returnStatus'] = returnStatusToString(ReturnStatus.inProgress);
-      }
-
-      await _eventsCollection.doc(eventId).update(updateData);
-
-      // Mettre à jour le stock si c'est un consommable
-      if (returnedQuantity != null) {
-        final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
-        if (equipmentDoc.exists) {
-          final equipment = EquipmentModel.fromMap(
-            equipmentDoc.data() as Map<String, dynamic>,
-            equipmentDoc.id,
-          );
-
-          if (equipment.hasQuantity) {
-            final currentAvailable = equipment.availableQuantity ?? 0;
-            await _equipmentCollection.doc(equipmentId).update({
-              'availableQuantity': currentAvailable + returnedQuantity,
-            });
-          }
-        }
-      }
+      await _apiService.call('validateEquipmentReturn', {
+        'eventId': eventId,
+        'equipmentId': equipmentId,
+        if (returnedQuantity != null) 'returnedQuantity': returnedQuantity,
+      });
     } catch (e) {
       print('Error validating equipment return: $e');
       rethrow;
@@ -189,53 +101,11 @@ class EventPreparationService {
     Map<String, int>? returnedQuantities,
   ]) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) {
-        throw Exception('Event not found');
-      }
-
-      // Marquer tous les équipements comme retournés
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        final returnedQty = returnedQuantities?[eq.equipmentId] ??
-                           eq.returnedQuantity ??
-                           eq.quantity;
-        return eq.copyWith(
-          isReturned: true,
-          returnedQuantity: returnedQty,
-        );
-      }).toList();
-
-      await _eventsCollection.doc(eventId).update({
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-        'returnStatus': returnStatusToString(ReturnStatus.completed),
+      await _apiService.call('validateAllReturn', {
+        'eventId': eventId,
+        if (returnedQuantities != null) 'returnedQuantities': returnedQuantities,
       });
 
-      // Mettre à jour le statut des équipements à "available" et gérer les stocks
-      for (var equipment in updatedEquipment) {
-        // Vérifier si le document existe
-        final equipmentDoc = await _equipmentCollection.doc(equipment.equipmentId).get();
-        if (equipmentDoc.exists) {
-          final equipmentData = EquipmentModel.fromMap(
-            equipmentDoc.data() as Map<String, dynamic>,
-            equipmentDoc.id,
-          );
-
-          // Mettre à jour le statut uniquement pour les équipements non quantifiables
-          if (!equipmentData.hasQuantity) {
-            await updateEquipmentStatus(equipment.equipmentId, EquipmentStatus.available);
-          }
-
-          // Restaurer le stock pour les consommables
-          if (equipmentData.hasQuantity && equipment.returnedQuantity != null) {
-            final currentAvailable = equipmentData.availableQuantity ?? 0;
-            await _equipmentCollection.doc(equipment.equipmentId).update({
-              'availableQuantity': currentAvailable + equipment.returnedQuantity!,
-              'updatedAt': Timestamp.fromDate(DateTime.now()),
-            });
-          }
-        }
-      }
-
       // Invalider le cache des statuts d'équipement
       EquipmentStatusCalculator.invalidateGlobalCache();
     } catch (e) {

em2rp/lib/services/event_preparation_service_extended.dart

@@ -1,45 +1,21 @@
 import 'package:cloud_firestore/cloud_firestore.dart';
-import 'package:em2rp/models/event_model.dart';
-import 'package:em2rp/models/equipment_model.dart';
 import 'package:em2rp/services/equipment_status_calculator.dart';
+import 'package:em2rp/services/api_service.dart';
 
 /// Service étendu pour gérer les 4 étapes : Préparation, Chargement, Déchargement, Retour
 class EventPreparationServiceExtended {
-  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
-  
-  CollectionReference get _eventsCollection => _firestore.collection('events');
-  CollectionReference get _equipmentCollection => _firestore.collection('equipments');
+  final ApiService _apiService = apiService;
+
 
   // === CHARGEMENT (LOADING) ===
 
   /// Valider un équipement individuel pour le chargement
   Future<void> validateEquipmentLoading(String eventId, String equipmentId) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) throw Exception('Event not found');
-
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        if (eq.equipmentId == equipmentId) {
-          return eq.copyWith(isLoaded: true);
-        }
-        return eq;
-      }).toList();
-
-      // Vérifier si tous les équipements sont chargés
-      final allLoaded = updatedEquipment.every((eq) => eq.isLoaded);
-
-      final updateData = <String, dynamic>{
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-      };
-
-      // Si tous sont chargés, mettre à jour le statut
-      if (allLoaded) {
-        updateData['loadingStatus'] = loadingStatusToString(LoadingStatus.completed);
-      } else {
-        updateData['loadingStatus'] = loadingStatusToString(LoadingStatus.inProgress);
-      }
-
-      await _eventsCollection.doc(eventId).update(updateData);
+      await _apiService.call('validateEquipmentLoading', {
+        'eventId': eventId,
+        'equipmentId': equipmentId,
+      });
     } catch (e) {
       print('Error validating equipment loading: $e');
       rethrow;
@@ -49,16 +25,8 @@ class EventPreparationServiceExtended {
   /// Valider tous les équipements pour le chargement
   Future<void> validateAllLoading(String eventId) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) throw Exception('Event not found');
-
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        return eq.copyWith(isLoaded: true);
-      }).toList();
-
-      await _eventsCollection.doc(eventId).update({
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-        'loadingStatus': loadingStatusToString(LoadingStatus.completed),
+      await _apiService.call('validateAllLoading', {
+        'eventId': eventId,
       });
 
       // Invalider le cache des statuts d'équipement
@@ -74,31 +42,10 @@ class EventPreparationServiceExtended {
   /// Valider un équipement individuel pour le déchargement
   Future<void> validateEquipmentUnloading(String eventId, String equipmentId) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) throw Exception('Event not found');
-
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        if (eq.equipmentId == equipmentId) {
-          return eq.copyWith(isUnloaded: true);
-        }
-        return eq;
-      }).toList();
-
-      // Vérifier si tous les équipements sont déchargés
-      final allUnloaded = updatedEquipment.every((eq) => eq.isUnloaded);
-
-      final updateData = <String, dynamic>{
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-      };
-
-      // Si tous sont déchargés, mettre à jour le statut
-      if (allUnloaded) {
-        updateData['unloadingStatus'] = unloadingStatusToString(UnloadingStatus.completed);
-      } else {
-        updateData['unloadingStatus'] = unloadingStatusToString(UnloadingStatus.inProgress);
-      }
-
-      await _eventsCollection.doc(eventId).update(updateData);
+      await _apiService.call('validateEquipmentUnloading', {
+        'eventId': eventId,
+        'equipmentId': equipmentId,
+      });
     } catch (e) {
       print('Error validating equipment unloading: $e');
       rethrow;
@@ -108,16 +55,8 @@ class EventPreparationServiceExtended {
   /// Valider tous les équipements pour le déchargement
   Future<void> validateAllUnloading(String eventId) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) throw Exception('Event not found');
-
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        return eq.copyWith(isUnloaded: true);
-      }).toList();
-
-      await _eventsCollection.doc(eventId).update({
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-        'unloadingStatus': unloadingStatusToString(UnloadingStatus.completed),
+      await _apiService.call('validateAllUnloading', {
+        'eventId': eventId,
       });
 
       // Invalider le cache des statuts d'équipement
@@ -133,26 +72,13 @@ class EventPreparationServiceExtended {
   /// Valider préparation ET chargement en même temps
   Future<void> validateAllPreparationAndLoading(String eventId) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) throw Exception('Event not found');
+      // Note: On pourrait créer une fonction cloud dédiée pour ça,
+      // mais pour l'instant on appelle les deux séquentiellement
+      await _apiService.call('validateAllPreparation', {'eventId': eventId});
+      await _apiService.call('validateAllLoading', {'eventId': eventId});
 
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        return eq.copyWith(isPrepared: true, isLoaded: true);
-      }).toList();
-
-      await _eventsCollection.doc(eventId).update({
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-        'preparationStatus': preparationStatusToString(PreparationStatus.completed),
-        'loadingStatus': loadingStatusToString(LoadingStatus.completed),
-      });
-
-      // Mettre à jour le statut des équipements
-      for (var equipment in event.assignedEquipment) {
-        final doc = await _equipmentCollection.doc(equipment.equipmentId).get();
-        if (doc.exists) {
-          await _updateEquipmentStatus(equipment.equipmentId, EquipmentStatus.inUse);
-        }
-      }
+      // Invalider le cache
+      EquipmentStatusCalculator.invalidateGlobalCache();
     } catch (e) {
       print('Error validating all preparation and loading: $e');
       rethrow;
@@ -167,81 +93,20 @@ class EventPreparationServiceExtended {
     Map<String, int>? returnedQuantities,
   ) async {
     try {
-      final event = await _getEvent(eventId);
-      if (event == null) throw Exception('Event not found');
-
-      final updatedEquipment = event.assignedEquipment.map((eq) {
-        final returnedQty = returnedQuantities?[eq.equipmentId] ??
-                           eq.returnedQuantity ??
-                           eq.quantity;
-        return eq.copyWith(
-          isUnloaded: true,
-          isReturned: true,
-          returnedQuantity: returnedQty,
-        );
-      }).toList();
-
-      await _eventsCollection.doc(eventId).update({
-        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
-        'unloadingStatus': unloadingStatusToString(UnloadingStatus.completed),
-        'returnStatus': returnStatusToString(ReturnStatus.completed),
+      // Note: On pourrait créer une fonction cloud dédiée pour ça,
+      // mais pour l'instant on appelle les deux séquentiellement
+      await _apiService.call('validateAllUnloading', {'eventId': eventId});
+      await _apiService.call('validateAllReturn', {
+        'eventId': eventId,
+        if (returnedQuantities != null) 'returnedQuantities': returnedQuantities,
       });
 
-      // Mettre à jour les statuts et stocks
-      for (var equipment in updatedEquipment) {
-        final equipmentDoc = await _equipmentCollection.doc(equipment.equipmentId).get();
-        if (equipmentDoc.exists) {
-          final equipmentData = EquipmentModel.fromMap(
-            equipmentDoc.data() as Map<String, dynamic>,
-            equipmentDoc.id,
-          );
-
-          if (!equipmentData.hasQuantity) {
-            await _updateEquipmentStatus(equipment.equipmentId, EquipmentStatus.available);
-          }
-
-          if (equipmentData.hasQuantity && equipment.returnedQuantity != null) {
-            final currentAvailable = equipmentData.availableQuantity ?? 0;
-            await _equipmentCollection.doc(equipment.equipmentId).update({
-              'availableQuantity': currentAvailable + equipment.returnedQuantity!,
-              'updatedAt': Timestamp.fromDate(DateTime.now()),
-            });
-          }
-        }
-      }
+      // Invalider le cache
+      EquipmentStatusCalculator.invalidateGlobalCache();
     } catch (e) {
       print('Error validating all unloading and return: $e');
       rethrow;
     }
   }
-
-  // === HELPERS ===
-
-  Future<void> _updateEquipmentStatus(String equipmentId, EquipmentStatus status) async {
-    try {
-      final doc = await _equipmentCollection.doc(equipmentId).get();
-      if (!doc.exists) return;
-
-      await _equipmentCollection.doc(equipmentId).update({
-        'status': equipmentStatusToString(status),
-        'updatedAt': Timestamp.fromDate(DateTime.now()),
-      });
-    } catch (e) {
-      print('Error updating equipment status: $e');
-    }
-  }
-
-  Future<EventModel?> _getEvent(String eventId) async {
-    try {
-      final doc = await _eventsCollection.doc(eventId).get();
-      if (doc.exists) {
-        return EventModel.fromMap(doc.data() as Map<String, dynamic>, doc.id);
-      }
-      return null;
-    } catch (e) {
-      print('Error getting event: $e');
-      rethrow;
-    }
-  }
 }
 

em2rp/lib/services/maintenance_service.dart

@@ -1,13 +1,10 @@
 import 'package:cloud_firestore/cloud_firestore.dart';
 import 'package:em2rp/models/maintenance_model.dart';
 import 'package:em2rp/models/alert_model.dart';
-import 'package:em2rp/models/equipment_model.dart';
-import 'package:em2rp/services/equipment_service.dart';
 import 'package:em2rp/services/api_service.dart';
 
 class MaintenanceService {
   final FirebaseFirestore _firestore = FirebaseFirestore.instance;
-  final EquipmentService _equipmentService = EquipmentService();
   final ApiService _apiService = apiService;
 
   // Collection references
@@ -23,16 +20,7 @@ class MaintenanceService {
   Future<void> createMaintenance(MaintenanceModel maintenance) async {
     try {
       await _apiService.call('createMaintenance', maintenance.toMap());
-
-      // Mettre à jour les équipements concernés (côté client pour l'instant)
-      for (String equipmentId in maintenance.equipmentIds) {
-        await _updateEquipmentMaintenanceList(equipmentId, maintenance.id);
-
-        // Si la maintenance est planifiée dans les 7 prochains jours, créer une alerte
-        if (maintenance.scheduledDate.isBefore(DateTime.now().add(const Duration(days: 7)))) {
-          await _createMaintenanceAlert(equipmentId, maintenance);
-        }
-      }
+      // Note: La Cloud Function gère maintenant la mise à jour des équipements et la création des alertes
     } catch (e) {
       print('Error creating maintenance: $e');
       rethrow;
@@ -55,21 +43,10 @@ class MaintenanceService {
   /// Supprimer une maintenance
   Future<void> deleteMaintenance(String id) async {
     try {
-      // Récupérer la maintenance pour connaître les équipements
-      final doc = await _maintenancesCollection.doc(id).get();
-      if (doc.exists) {
-        final maintenance = MaintenanceModel.fromMap(
-          doc.data() as Map<String, dynamic>,
-          doc.id,
-        );
-
-        // Retirer la maintenance des équipements
-        for (String equipmentId in maintenance.equipmentIds) {
-          await _removeMaintenanceFromEquipment(equipmentId, id);
-        }
-      }
-
-      await _maintenancesCollection.doc(id).delete();
+      await _apiService.call('deleteMaintenance', {
+        'maintenanceId': id,
+      });
+      // Note: La Cloud Function gère la mise à jour des équipements
     } catch (e) {
       print('Error deleting maintenance: $e');
       rethrow;
@@ -236,52 +213,4 @@ class MaintenanceService {
       rethrow;
     }
   }
-
-  /// Mettre à jour la liste des maintenances d'un équipement
-  Future<void> _updateEquipmentMaintenanceList(String equipmentId, String maintenanceId) async {
-    try {
-      final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
-      if (equipmentDoc.exists) {
-        final equipment = EquipmentModel.fromMap(
-          equipmentDoc.data() as Map<String, dynamic>,
-          equipmentDoc.id,
-        );
-
-        final updatedMaintenanceIds = List<String>.from(equipment.maintenanceIds);
-        if (!updatedMaintenanceIds.contains(maintenanceId)) {
-          updatedMaintenanceIds.add(maintenanceId);
-
-          await _equipmentCollection.doc(equipmentId).update({
-            'maintenanceIds': updatedMaintenanceIds,
-          });
-        }
-      }
-    } catch (e) {
-      print('Error updating equipment maintenance list: $e');
-      rethrow;
-    }
-  }
-
-  /// Retirer une maintenance de la liste d'un équipement
-  Future<void> _removeMaintenanceFromEquipment(String equipmentId, String maintenanceId) async {
-    try {
-      final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
-      if (equipmentDoc.exists) {
-        final equipment = EquipmentModel.fromMap(
-          equipmentDoc.data() as Map<String, dynamic>,
-          equipmentDoc.id,
-        );
-
-        final updatedMaintenanceIds = List<String>.from(equipment.maintenanceIds);
-        updatedMaintenanceIds.remove(maintenanceId);
-
-        await _equipmentCollection.doc(equipmentId).update({
-          'maintenanceIds': updatedMaintenanceIds,
-        });
-      }
-    } catch (e) {
-      print('Error removing maintenance from equipment: $e');
-      rethrow;
-    }
-  }
 }

em2rp/lib/services/user_service.dart

@@ -32,10 +32,11 @@ class UserService {
   /// @deprecated Utilisez API deleteUser à la place
   Future<void> deleteUser(String uid) async {
     try {
-      // TODO: Créer une Cloud Function deleteUser
-      print("Suppression d'utilisateur non implémentée via API");
+      final apiService = FirebaseFunctionsApiService();
+      await apiService.call('deleteUser', {'userId': uid});
     } catch (e) {
       print("Erreur suppression: $e");
+      rethrow;
     }
   }
 

em2rp/lib/views/user_management_page.dart

@@ -91,7 +91,8 @@ class _UserManagementPageState extends State<UserManagementPage> {
                     onEdit: () => showDialog(
                         context: context,
                         builder: (_) => EditUserDialog(user: user)),
-                    onDelete: () => usersProvider.deleteUser(user.uid),
+                    onResetPassword: () => _resetPassword(context, user),
+                    onDelete: () => _confirmDeleteUser(context, usersProvider, user),
                   );
                 },
               ),
@@ -259,19 +260,27 @@ class _UserManagementPageState extends State<UserManagementPage> {
                             return;
                           }
                           try {
-                            final newUser = UserModel(
-                              uid: '', // Sera généré par Firebase
-                              firstName: firstNameController.text,
-                              lastName: lastNameController.text,
-                              email: emailController.text,
-                              phoneNumber: phoneController.text,
-                              role: selectedRoleId!,
-                              profilePhotoUrl: '',
-                            );
                             await Provider.of<UsersProvider>(context,
                                     listen: false)
-                                .createUserWithEmailInvite(email: newUser.email, firstName: newUser.firstName, lastName: newUser.lastName, phoneNumber: newUser.phoneNumber, roleId: newUser.role);
-                            Navigator.pop(context);
+                                .createUserWithEmailInvite(
+                              email: emailController.text,
+                              firstName: firstNameController.text,
+                              lastName: lastNameController.text,
+                              phoneNumber: phoneController.text,
+                              roleId: selectedRoleId!,
+                            );
+
+                            if (context.mounted) {
+                              Navigator.pop(context);
+                              ScaffoldMessenger.of(context).showSnackBar(
+                                SnackBar(
+                                  content: Text(
+                                    'Utilisateur créé avec succès. Email de réinitialisation envoyé à ${emailController.text}',
+                                  ),
+                                  backgroundColor: Colors.green,
+                                ),
+                              );
+                            }
                           } catch (e) {
                             if (context.mounted) {
                               ScaffoldMessenger.of(context).showSnackBar(
@@ -307,4 +316,174 @@ class _UserManagementPageState extends State<UserManagementPage> {
       ),
     );
   }
+
+  /// Réinitialise le mot de passe d'un utilisateur
+  Future<void> _resetPassword(BuildContext context, UserModel user) async {
+    try {
+      await Provider.of<UsersProvider>(context, listen: false)
+          .resetPassword(user.email);
+
+      if (context.mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(
+              'Email de réinitialisation envoyé à ${user.email}',
+            ),
+            backgroundColor: Colors.green,
+          ),
+        );
+      }
+    } catch (e) {
+      if (context.mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(
+              'Erreur lors de l\'envoi: ${e.toString()}',
+            ),
+            backgroundColor: Colors.red,
+          ),
+        );
+      }
+    }
+  }
+
+  /// Affiche une confirmation avant de supprimer un utilisateur
+  Future<void> _confirmDeleteUser(
+    BuildContext context,
+    UsersProvider usersProvider,
+    UserModel user,
+  ) async {
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        shape: RoundedRectangleBorder(
+          borderRadius: BorderRadius.circular(16),
+        ),
+        title: Row(
+          children: [
+            const Icon(Icons.warning, color: Colors.orange),
+            const SizedBox(width: 12),
+            Expanded(
+              child: Text(
+                'Confirmer la suppression',
+                style: Theme.of(context).textTheme.titleLarge?.copyWith(
+                      fontWeight: FontWeight.bold,
+                    ),
+              ),
+            ),
+          ],
+        ),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Text(
+              'Êtes-vous sûr de vouloir supprimer cet utilisateur ?',
+              style: Theme.of(context).textTheme.bodyLarge,
+            ),
+            const SizedBox(height: 16),
+            Container(
+              padding: const EdgeInsets.all(12),
+              decoration: BoxDecoration(
+                color: Colors.grey[100],
+                borderRadius: BorderRadius.circular(8),
+              ),
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Row(
+                    children: [
+                      const Icon(Icons.person, size: 20, color: AppColors.noir),
+                      const SizedBox(width: 8),
+                      Expanded(
+                        child: Text(
+                          '${user.firstName} ${user.lastName}',
+                          style: const TextStyle(fontWeight: FontWeight.bold),
+                        ),
+                      ),
+                    ],
+                  ),
+                  const SizedBox(height: 4),
+                  Row(
+                    children: [
+                      const Icon(Icons.email, size: 20, color: AppColors.gris),
+                      const SizedBox(width: 8),
+                      Expanded(
+                        child: Text(
+                          user.email,
+                          style: TextStyle(color: Colors.grey[700]),
+                        ),
+                      ),
+                    ],
+                  ),
+                ],
+              ),
+            ),
+            const SizedBox(height: 16),
+            Text(
+              'Cette action est irréversible. L\'utilisateur sera supprimé et désattribué de tous les événements liés',
+              style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                    color: Colors.red[700],
+                    fontStyle: FontStyle.italic,
+                  ),
+            ),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(false),
+            style: TextButton.styleFrom(
+              padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+            ),
+            child: const Text(
+              'Annuler',
+              style: TextStyle(color: AppColors.gris),
+            ),
+          ),
+          ElevatedButton(
+            onPressed: () => Navigator.of(context).pop(true),
+            style: ElevatedButton.styleFrom(
+              backgroundColor: Colors.red,
+              padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+              shape: RoundedRectangleBorder(
+                borderRadius: BorderRadius.circular(8),
+              ),
+            ),
+            child: const Text(
+              'Supprimer',
+              style: TextStyle(color: Colors.white),
+            ),
+          ),
+        ],
+      ),
+    );
+
+    if (confirmed == true && context.mounted) {
+      try {
+        await usersProvider.deleteUser(user.uid);
+
+        if (context.mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text(
+                'Utilisateur ${user.firstName} ${user.lastName} supprimé avec succès',
+              ),
+              backgroundColor: Colors.green,
+            ),
+          );
+        }
+      } catch (e) {
+        if (context.mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text(
+                'Erreur lors de la suppression: ${e.toString()}',
+              ),
+              backgroundColor: Colors.red,
+            ),
+          );
+        }
+      }
+    }
+  }
 }

em2rp/lib/views/widgets/user_management/user_card.dart

@@ -6,6 +6,7 @@ class UserCard extends StatefulWidget {
   final UserModel user;
   final VoidCallback onEdit;
   final VoidCallback onDelete;
+  final VoidCallback onResetPassword;
 
   static const double _desktopMaxWidth = 280;
 
@@ -14,6 +15,7 @@ class UserCard extends StatefulWidget {
     required this.user,
     required this.onEdit,
     required this.onDelete,
+    required this.onResetPassword,
   });
 
   @override
@@ -128,6 +130,17 @@ class _UserCardState extends State<UserCard> {
         Row(
           mainAxisSize: MainAxisSize.min,
           children: [
+            IconButton(
+              icon: const Icon(Icons.lock_reset, size: 20),
+              onPressed: widget.onResetPassword,
+              color: AppColors.noir,
+              padding: const EdgeInsets.all(8),
+              constraints: const BoxConstraints(
+                minWidth: 32,
+                minHeight: 32,
+              ),
+              tooltip: 'Réinitialiser le mot de passe',
+            ),
             IconButton(
               icon: const Icon(Icons.edit, size: 20),
               onPressed: widget.onEdit,
@@ -205,6 +218,14 @@ class _UserCardState extends State<UserCard> {
                   ? Column(
                       mainAxisSize: MainAxisSize.min,
                       children: [
+                        _buildButton(
+                          icon: Icons.lock_reset,
+                          label: "Réinit. MDP",
+                          onPressed: widget.onResetPassword,
+                          color: AppColors.noir,
+                          isNarrow: true,
+                        ),
+                        const SizedBox(height: 4),
                         _buildButton(
                           icon: Icons.edit,
                           label: "Modifier",
@@ -225,20 +246,34 @@ class _UserCardState extends State<UserCard> {
                   : Row(
                       mainAxisAlignment: MainAxisAlignment.center,
                       children: [
-                        _buildButton(
-                          icon: Icons.edit,
-                          label: "Modifier",
-                          onPressed: widget.onEdit,
-                          color: AppColors.rouge,
-                          isNarrow: false,
+                        Expanded(
+                          child: _buildButton(
+                            icon: Icons.lock_reset,
+                            label: "Réinit.",
+                            onPressed: widget.onResetPassword,
+                            color: AppColors.noir,
+                            isNarrow: false,
+                          ),
                         ),
-                        const SizedBox(width: 8),
-                        _buildButton(
-                          icon: Icons.delete,
-                          label: "Supprimer",
-                          onPressed: widget.onDelete,
-                          color: AppColors.gris,
-                          isNarrow: false,
+                        const SizedBox(width: 4),
+                        Expanded(
+                          child: _buildButton(
+                            icon: Icons.edit,
+                            label: "Edit",
+                            onPressed: widget.onEdit,
+                            color: AppColors.rouge,
+                            isNarrow: false,
+                          ),
+                        ),
+                        const SizedBox(width: 4),
+                        Expanded(
+                          child: _buildButton(
+                            icon: Icons.delete,
+                            label: "Suppr",
+                            onPressed: widget.onDelete,
+                            color: AppColors.gris,
+                            isNarrow: false,
+                          ),
                         ),
                       ],
                     ),