feat: Ajout de la gestion des utilisateurs et optimisation du chargement des données

Cette mise à jour introduit la gestion complète des utilisateurs (création, mise à jour, suppression) via des Cloud Functions et optimise de manière significative le chargement des données dans toute l'application.

**Features :**
- **Gestion des utilisateurs (Backend & Frontend) :**
    - Ajout des Cloud Functions `getUser`, `updateUser` et `deleteUser` pour gérer les utilisateurs de manière sécurisée, en respectant les permissions des rôles.
    - L'authentification passe désormais par `onCall` pour plus de sécurité.
- **Optimisation du chargement des données :**
    - Introduction de nouvelles Cloud Functions `getEquipmentsByIds` et `getContainersByIds` pour récupérer uniquement les documents nécessaires, réduisant ainsi la charge sur le client et Firestore.
    - Les fournisseurs (`EquipmentProvider`, `ContainerProvider`) ont été refactorisés pour utiliser un chargement à la demande (`ensureLoaded`) et mettre en cache les données récupérées.
    - Les écrans de détails et de préparation d'événements n'utilisent plus de `Stream` globaux, mais chargent les équipements et boites spécifiques via ces nouvelles fonctions, améliorant considérablement les performances.

**Refactorisation et Améliorations :**
- **Backend (Cloud Functions) :**
    - Le service de vérification de disponibilité (`checkEquipmentAvailability`) est désormais une Cloud Function, déplaçant la logique métier côté serveur.
    - La récupération des données (utilisateurs, événements, alertes) a été centralisée derrière des Cloud Functions, remplaçant les appels directs à Firestore depuis le client.
    - Amélioration de la sérialisation des données (timestamps, références) dans les réponses des fonctions.
- **Frontend (Flutter) :**
    - `LocalUserProvider` charge désormais les informations de l'utilisateur connecté via la fonction `getCurrentUser`, incluant son rôle et ses permissions en un seul appel.
    - `AlertProvider` utilise des fonctions pour charger et manipuler les alertes, abandonnant le `Stream` Firestore.
    - `EventAvailabilityService` utilise maintenant la Cloud Function `checkEquipmentAvailability` au lieu d'une logique client complexe.
    - Correction de la gestion des références de rôles (`roles/ADMIN`) et des `DocumentReference` pour les utilisateurs dans l'ensemble de l'application.
    - Le service d'export ICS (`IcsExportService`) a été simplifié, partant du principe que les données nécessaires (utilisateurs, options) sont déjà chargées dans l'application.

em2rp/functions/index.js

@@ -3,7 +3,7 @@
  * Architecture backend sécurisée avec authentification et permissions
  */
 
-const { onRequest } = require("firebase-functions/v2/https");
+const { onRequest, onCall } = require("firebase-functions/v2/https");
 const logger = require("firebase-functions/logger");
 const admin = require('firebase-admin');
 const { Storage } = require('@google-cloud/storage');
@@ -257,6 +257,54 @@ exports.getEquipment = onRequest(httpOptions, withCors(async (req, res) => {
   }
 }));
 
+// Récupérer plusieurs équipements par leurs IDs
+exports.getEquipmentsByIds = onRequest(httpOptions, withCors(async (req, res) => {
+  try {
+    const decodedToken = await auth.authenticateUser(req);
+    const hasViewAccess = await auth.hasPermission(decodedToken.uid, 'view_equipment');
+    const hasManageAccess = await auth.hasPermission(decodedToken.uid, 'manage_equipment');
+
+    if (!hasViewAccess && !hasManageAccess) {
+      res.status(403).json({ error: 'Forbidden: Requires view_equipment permission' });
+      return;
+    }
+
+    const { equipmentIds } = req.body.data || {};
+
+    if (!equipmentIds || !Array.isArray(equipmentIds) || equipmentIds.length === 0) {
+      res.status(400).json({ error: 'equipmentIds array is required and must not be empty' });
+      return;
+    }
+
+    // Limiter à 100 équipements max par requête
+    if (equipmentIds.length > 100) {
+      res.status(400).json({ error: 'Maximum 100 equipment IDs per request' });
+      return;
+    }
+
+    // Récupérer tous les documents en parallèle
+    const promises = equipmentIds.map(id => db.collection('equipments').doc(id).get());
+    const docs = await Promise.all(promises);
+
+    const equipments = [];
+    for (const doc of docs) {
+      if (doc.exists) {
+        let data = { id: doc.id, ...doc.data() };
+        data = helpers.serializeTimestamps(data);
+        data = helpers.serializeReferences(data);
+        // Masquer les prix si pas de permission manage_equipment
+        data = helpers.maskSensitiveFields(data, hasManageAccess);
+        equipments.push(data);
+      }
+    }
+
+    res.status(200).json({ equipments });
+  } catch (error) {
+    logger.error("Error getting equipments by IDs:", error);
+    res.status(500).json({ error: error.message });
+  }
+}));
+
 // ============================================================================
 // CONTAINERS - CRUD
 // ============================================================================
@@ -366,20 +414,19 @@ exports.getContainersByEquipment = onRequest(httpOptions, withCors(async (req, r
       return;
     }
 
-    const { equipmentId } = req.body.data || req.query;
+    const { equipmentId } = req.body.data || {};
 
     if (!equipmentId) {
       res.status(400).json({ error: 'equipmentId is required' });
       return;
     }
 
-    // Récupérer tous les containers qui contiennent cet équipement
+    const snapshot = await db.collection('containers')
-    const containersSnapshot = await db.collection('containers')
       .where('equipmentIds', 'array-contains', equipmentId)
       .get();
 
     const containers = [];
-    containersSnapshot.forEach(doc => {
+    snapshot.forEach(doc => {
       let data = { id: doc.id, ...doc.data() };
       data = helpers.serializeTimestamps(data);
       data = helpers.serializeReferences(data);
@@ -393,6 +440,53 @@ exports.getContainersByEquipment = onRequest(httpOptions, withCors(async (req, r
   }
 }));
 
+// Récupérer plusieurs containers par leurs IDs
+exports.getContainersByIds = onRequest(httpOptions, withCors(async (req, res) => {
+  try {
+    const decodedToken = await auth.authenticateUser(req);
+    const hasViewAccess = await auth.hasPermission(decodedToken.uid, 'view_equipment');
+    const hasManageAccess = await auth.hasPermission(decodedToken.uid, 'manage_equipment');
+
+    if (!hasViewAccess && !hasManageAccess) {
+      res.status(403).json({ error: 'Forbidden: Requires view_equipment permission' });
+      return;
+    }
+
+    const { containerIds } = req.body.data || {};
+
+    if (!containerIds || !Array.isArray(containerIds) || containerIds.length === 0) {
+      res.status(400).json({ error: 'containerIds array is required and must not be empty' });
+      return;
+    }
+
+    // Limiter à 100 conteneurs max par requête
+    if (containerIds.length > 100) {
+      res.status(400).json({ error: 'Maximum 100 container IDs per request' });
+      return;
+    }
+
+    // Récupérer tous les documents en parallèle
+    const promises = containerIds.map(id => db.collection('containers').doc(id).get());
+    const docs = await Promise.all(promises);
+
+    const containers = [];
+    for (const doc of docs) {
+      if (doc.exists) {
+        let data = { id: doc.id, ...doc.data() };
+        data = helpers.serializeTimestamps(data);
+        data = helpers.serializeReferences(data);
+        containers.push(data);
+      }
+    }
+
+    res.status(200).json({ containers });
+  } catch (error) {
+    logger.error("Error getting containers by IDs:", error);
+    res.status(500).json({ error: error.message });
+  }
+}));
+
+
 // ============================================================================
 // EVENTS - CRUD
 // ============================================================================
@@ -1345,11 +1439,14 @@ exports.getUsers = onRequest(httpOptions, withCors(async (req, res) => {
         return;
       }
 
-      const userData = userDoc.data();
+      let userData = userDoc.data();
+      userData = helpers.serializeTimestamps(userData);
+      userData = helpers.serializeReferences(userData);
+
       res.status(200).json({
         users: [{
           id: userDoc.id,
-          ...helpers.serializeTimestamps(userData)
+          ...userData
         }]
       });
       return;
@@ -1357,10 +1454,15 @@ exports.getUsers = onRequest(httpOptions, withCors(async (req, res) => {
 
     // Admin : tous les utilisateurs
     const snapshot = await db.collection('users').get();
-    const users = snapshot.docs.map(doc => ({
+    const users = snapshot.docs.map(doc => {
+      let data = doc.data();
+      data = helpers.serializeTimestamps(data);
+      data = helpers.serializeReferences(data);
+      return {
         id: doc.id,
-      ...helpers.serializeTimestamps(doc.data())
+        ...data
-    }));
+      };
+    });
 
     res.status(200).json({ users });
   } catch (error) {
@@ -1370,46 +1472,200 @@ exports.getUsers = onRequest(httpOptions, withCors(async (req, res) => {
 }));
 
 // ============================================================================
-// CONTAINERS - Récupération par équipement
+// USER - Récupération individuelle
+// ============================================================================
+
+
+/**
+ * Récupère un utilisateur spécifique par son ID
+ * Tout utilisateur authentifié peut accéder aux données publiques
+ */
+exports.getUser = onCall(async (request) => {
+  try {
+    await authenticateUser(request);
+    const db = getFirestore();
+
+    const { userId } = request.data;
+    if (!userId) {
+      throw new Error("userId is required");
+    }
+
+    const userDoc = await db.collection("users").doc(userId).get();
+    if (!userDoc.exists) {
+      throw new Error("User not found");
+    }
+
+    const user = userDoc.data();
+
+    // Données publiques accessibles à tous
+    const userData = {
+      id: userDoc.id,
+      uid: user.uid || userDoc.id,
+      email: user.email || "",
+      firstName: user.firstName || "",
+      lastName: user.lastName || "",
+      phoneNumber: user.phoneNumber || "",
+      profilePhotoUrl: user.profilePhotoUrl || "",
+    };
+
+    // Inclure le rôle si disponible
+    if (user.role) {
+      const roleDoc = await user.role.get();
+      if (roleDoc.exists) {
+        userData.role = {
+          id: roleDoc.id,
+          ...roleDoc.data(),
+        };
+      }
+    }
+
+    return { user: userData };
+  } catch (error) {
+    logger.error("Error fetching user:", error);
+    throw new Error(error.message || "Failed to fetch user");
+  }
+});
+
+// ============================================================================
+// USER MANAGEMENT - Delete & Update
 // ============================================================================
 
 /**
- * Récupère tous les containers contenant un équipement spécifique
+ * Supprime un utilisateur (Auth + Firestore)
- * Accessible à tous les utilisateurs authentifiés
+ * Permissions: 'delete_user' OU propriétaire
  */
-exports.getContainersByEquipment = onRequest(httpOptions, withCors(async (req, res) => {
+exports.deleteUser = onCall(async (request) => {
+  const { auth, data } = request;
+
+  if (!auth) {
+    throw new Error("Unauthorized: Authentication required");
+  }
+
+  const { userId } = data;
+  if (!userId) {
+    throw new Error("userId is required");
+  }
+
   try {
-    // Vérifier l'authentification
+    // Vérifier les permissions
-    const user = await auth.authenticateUser(req);
+    const callerDoc = await db.collection("users").doc(auth.uid).get();
+    const callerData = callerDoc.data();
 
-    const equipmentId = req.body.data?.equipmentId;
+    if (!callerData) {
-
+      throw new Error("Caller user not found");
-    if (!equipmentId) {
-      res.status(400).json({ error: 'equipmentId is required' });
-      return;
     }
 
-    logger.info(`Fetching containers for equipment: ${equipmentId}`);
+    // Vérifier si l'utilisateur a la permission delete_user
+    let canDelete = false;
+    if (callerData.role) {
+      const roleDoc = await callerData.role.get();
+      const roleData = roleDoc.data();
+      canDelete = roleData?.permissions?.includes("delete_user") || false;
+    }
 
-    // Requête pour trouver tous les containers contenant cet équipement
+    // Ou si c'est le propriétaire (mais on ne peut pas se supprimer soi-même)
-    const containersSnapshot = await db.collection('containers')
+    if (userId === auth.uid) {
-      .where('equipmentIds', 'array-contains', equipmentId)
+      throw new Error("Cannot delete your own account");
-      .get();
+    }
 
-    const containers = containersSnapshot.docs.map(doc => ({
+    if (!canDelete) {
-      id: doc.id,
+      throw new Error("Unauthorized: Missing delete_user permission");
-      ...helpers.serializeTimestamps(doc.data())
+    }
-    }));
 
-    logger.info(`Found ${containers.length} container(s) for equipment ${equipmentId}`);
+    // Supprimer de Firebase Auth
+    try {
+      await admin.auth().deleteUser(userId);
+    } catch (authError) {
+      logger.warn(`Could not delete user from Auth: ${authError.message}`);
+      // Continuer même si Auth échoue (l'utilisateur peut ne plus exister dans Auth)
+    }
 
-    res.status(200).json({
+    // Supprimer de Firestore
-      containers,
+    await db.collection("users").doc(userId).delete();
-      count: containers.length
+
-    });
+    logger.info(`User ${userId} deleted by ${auth.uid}`);
+    return { success: true, message: "User deleted successfully" };
   } catch (error) {
-    logger.error("Error fetching containers by equipment:", error);
+    logger.error("Error deleting user:", error);
-    res.status(500).json({ error: error.message });
+    throw new Error(error.message || "Failed to delete user");
   }
-}));
+});
+
+/**
+ * Met à jour un utilisateur
+ * Permissions: 'edit_user' OU propriétaire (modifications limitées)
+ */
+exports.updateUser = onCall(async (request) => {
+  const { auth, data } = request;
+
+  if (!auth) {
+    throw new Error("Unauthorized: Authentication required");
+  }
+
+  const { userId, userData } = data;
+  if (!userId || !userData) {
+    throw new Error("userId and userData are required");
+  }
+
+  try {
+    // Vérifier les permissions
+    const callerDoc = await db.collection("users").doc(auth.uid).get();
+    const callerData = callerDoc.data();
+
+    if (!callerData) {
+      throw new Error("Caller user not found");
+    }
+
+    let canEditAll = false;
+    if (callerData.role) {
+      const roleDoc = await callerData.role.get();
+      const roleData = roleDoc.data();
+      canEditAll = roleData?.permissions?.includes("edit_user") || false;
+    }
+
+    const isOwner = userId === auth.uid;
+
+    // Si pas de permission edit_user et pas propriétaire, refuser
+    if (!canEditAll && !isOwner) {
+      throw new Error("Unauthorized: Missing edit_user permission");
+    }
+
+    // Préparer les données à mettre à jour
+    const updateData = {
+      firstName: userData.firstName,
+      lastName: userData.lastName,
+      email: userData.email,
+      phoneNumber: userData.phoneNumber || "",
+    };
+
+    // Seuls ceux avec edit_user peuvent changer le rôle
+    if (userData.role) {
+      if (!canEditAll) {
+        throw new Error("Unauthorized: Cannot change role without edit_user permission");
+      }
+      // Créer la référence au rôle
+      updateData.role = db.collection("roles").doc(userData.role);
+    }
+
+    // Mettre à jour Firestore
+    await db.collection("users").doc(userId).update(updateData);
+
+    // Mettre à jour Firebase Auth si email a changé (seulement avec edit_user)
+    if (userData.email && canEditAll) {
+      try {
+        await admin.auth().updateUser(userId, {
+          email: userData.email,
+        });
+      } catch (authError) {
+        logger.warn(`Could not update email in Auth: ${authError.message}`);
+      }
+    }
+
+    logger.info(`User ${userId} updated by ${auth.uid}`);
+    return { success: true, message: "User updated successfully" };
+  } catch (error) {
+    logger.error("Error updating user:", error);
+    throw new Error(error.message || "Failed to update user");
+  }
+});
 

em2rp/lib/controllers/event_form_controller.dart

@@ -335,7 +335,7 @@ class EventFormController extends ChangeNotifier {
           customerId: existingEvent.customerId,
           address: addressController.text.trim(),
           workforce: _selectedUserIds
-              .map((id) => FirebaseFirestore.instance.collection('users').doc(id))
+              .map((id) => FirebaseFirestore.instance.doc('users/$id'))
               .toList(),
           latitude: existingEvent.latitude,
           longitude: existingEvent.longitude,
@@ -380,7 +380,7 @@ class EventFormController extends ChangeNotifier {
           customerId: '',
           address: addressController.text.trim(),
           workforce: _selectedUserIds
-              .map((id) => FirebaseFirestore.instance.collection('users').doc(id))
+              .map((id) => FirebaseFirestore.instance.doc('users/$id'))
               .toList(),
           latitude: 0.0,
           longitude: 0.0,

em2rp/lib/models/user_model.dart

@@ -23,13 +23,32 @@ class UserModel {
   factory UserModel.fromMap(Map<String, dynamic> data, String uid) {
     String roleString;
     final roleField = data['role'];
+
     if (roleField is String) {
+      // Cas 1 : role est déjà un String (ex: "roles/ADMIN")
       roleString = roleField;
     } else if (roleField is DocumentReference) {
+      // Cas 2 : role est une DocumentReference
       roleString = roleField.id;
+    } else if (roleField is Map) {
+      // Cas 3 : role est un Map sérialisé (ex: {"_path": {"segments": ["roles", "ADMIN"]}})
+      // On extrait le path
+      final pathData = roleField['_path'];
+      if (pathData is Map && pathData['segments'] is List) {
+        final segments = pathData['segments'] as List;
+        if (segments.length >= 2) {
+          roleString = segments[1].toString(); // Ex: "ADMIN"
         } else {
           roleString = 'USER';
         }
+      } else {
+        roleString = 'USER';
+      }
+    } else {
+      // Cas par défaut
+      roleString = 'USER';
+    }
+
     return UserModel(
       uid: uid,
       firstName: data['firstName'] ?? '',

em2rp/lib/providers/alert_provider.dart

@@ -1,14 +1,16 @@
 import 'package:flutter/foundation.dart';
-import 'package:cloud_firestore/cloud_firestore.dart';
 import 'package:em2rp/models/alert_model.dart';
+import 'package:em2rp/services/api_service.dart';
 
 class AlertProvider extends ChangeNotifier {
-  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
+  final ApiService _apiService = apiService;
 
   List<AlertModel> _alerts = [];
+  bool _isLoading = false;
 
   // Getters
   List<AlertModel> get alerts => _alerts;
+  bool get isLoading => _isLoading;
 
   /// Nombre d'alertes non lues
   int get unreadCount => _alerts.where((alert) => !alert.isRead).length;
@@ -25,57 +27,58 @@ class AlertProvider extends ChangeNotifier {
   /// Alertes de conflit
   List<AlertModel> get conflictAlerts => _alerts.where((alert) => alert.type == AlertType.conflict).toList();
 
-  /// Stream des alertes
+  /// Charger toutes les alertes via Cloud Function
-  Stream<List<AlertModel>> get alertsStream {
+  Future<void> loadAlerts() async {
-    return _firestore
+    _isLoading = true;
-        .collection('alerts')
+    notifyListeners();
-        .orderBy('createdAt', descending: true)
+
-        .snapshots()
+    try {
-        .map((snapshot) {
+      final result = await _apiService.call('getAlerts', {});
-      _alerts = snapshot.docs
+      final alertsData = result['alerts'] as List<dynamic>;
-          .map((doc) => AlertModel.fromMap(doc.data(), doc.id))
+
-          .toList();
+      _alerts = alertsData.map((data) {
-      return _alerts;
+        return AlertModel.fromMap(data as Map<String, dynamic>, data['id'] as String);
-    });
+      }).toList();
+    } catch (e) {
+      print('Error loading alerts: $e');
+      _alerts = [];
+    } finally {
+      _isLoading = false;
+      notifyListeners();
+    }
   }
 
-  /// Marquer une alerte comme lue
+  /// Marquer une alerte comme lue via Cloud Function
   Future<void> markAsRead(String alertId) async {
     try {
-      await _firestore.collection('alerts').doc(alertId).update({
+      await _apiService.call('markAlertAsRead', {'alertId': alertId});
-        'isRead': true,
+
-      });
+      // Mettre à jour localement
+      final index = _alerts.indexWhere((a) => a.id == alertId);
+      if (index != -1) {
+        _alerts[index] = AlertModel(
+          id: _alerts[index].id,
+          type: _alerts[index].type,
+          message: _alerts[index].message,
+          equipmentId: _alerts[index].equipmentId,
+          isRead: true,
+          createdAt: _alerts[index].createdAt,
+        );
         notifyListeners();
+      }
     } catch (e) {
       print('Error marking alert as read: $e');
       rethrow;
     }
   }
 
-  /// Marquer toutes les alertes comme lues
+  /// Supprimer une alerte via Cloud Function
-  Future<void> markAllAsRead() async {
-    try {
-      final batch = _firestore.batch();
-
-      for (var alert in _alerts.where((a) => !a.isRead)) {
-        batch.update(
-          _firestore.collection('alerts').doc(alert.id),
-          {'isRead': true},
-        );
-      }
-
-      await batch.commit();
-      notifyListeners();
-    } catch (e) {
-      print('Error marking all alerts as read: $e');
-      rethrow;
-    }
-  }
-
-  /// Supprimer une alerte
   Future<void> deleteAlert(String alertId) async {
     try {
-      await _firestore.collection('alerts').doc(alertId).delete();
+      await _apiService.call('deleteAlert', {'alertId': alertId});
+
+      // Supprimer localement
+      _alerts.removeWhere((a) => a.id == alertId);
       notifyListeners();
     } catch (e) {
       print('Error deleting alert: $e');
@@ -83,46 +86,32 @@ class AlertProvider extends ChangeNotifier {
     }
   }
 
-  /// Supprimer toutes les alertes lues
+  /// Marquer toutes les alertes comme lues
-  Future<void> deleteReadAlerts() async {
+  Future<void> markAllAsRead() async {
     try {
-      final batch = _firestore.batch();
+      final unreadAlertIds = _alerts.where((a) => !a.isRead).map((a) => a.id).toList();
 
-      for (var alert in _alerts.where((a) => a.isRead)) {
+      for (final alertId in unreadAlertIds) {
-        batch.delete(_firestore.collection('alerts').doc(alert.id));
+        await markAsRead(alertId);
+      }
+    } catch (e) {
+      print('Error marking all alerts as read: $e');
+      rethrow;
+    }
   }
 
-      await batch.commit();
+  /// Supprimer toutes les alertes lues via Cloud Function
-      notifyListeners();
+  Future<void> deleteReadAlerts() async {
+    try {
+      final readAlertIds = _alerts.where((a) => a.isRead).map((a) => a.id).toList();
+
+      for (final alertId in readAlertIds) {
+        await deleteAlert(alertId);
+      }
     } catch (e) {
       print('Error deleting read alerts: $e');
       rethrow;
     }
   }
-
-  /// Créer une alerte (utilisé principalement par les services)
-  Future<void> createAlert(AlertModel alert) async {
-    try {
-      await _firestore.collection('alerts').doc(alert.id).set(alert.toMap());
-      notifyListeners();
-    } catch (e) {
-      print('Error creating alert: $e');
-      rethrow;
-    }
-  }
-
-  /// Récupérer les alertes pour un équipement spécifique
-  Stream<List<AlertModel>> getAlertsForEquipment(String equipmentId) {
-    return _firestore
-        .collection('alerts')
-        .where('equipmentId', isEqualTo: equipmentId)
-        .orderBy('createdAt', descending: true)
-        .snapshots()
-        .map((snapshot) {
-      return snapshot.docs
-          .map((doc) => AlertModel.fromMap(doc.data(), doc.id))
-          .toList();
-    });
-  }
 }
 

em2rp/lib/providers/container_provider.dart

@@ -2,21 +2,36 @@ import 'package:flutter/foundation.dart';
 import 'package:em2rp/models/container_model.dart';
 import 'package:em2rp/models/equipment_model.dart';
 import 'package:em2rp/services/container_service.dart';
+import 'package:em2rp/services/data_service.dart';
+import 'package:em2rp/services/api_service.dart';
 
 class ContainerProvider with ChangeNotifier {
   final ContainerService _containerService = ContainerService();
+  final DataService _dataService = DataService(FirebaseFunctionsApiService());
 
   List<ContainerModel> _containers = [];
   ContainerType? _selectedType;
   EquipmentStatus? _selectedStatus;
   String _searchQuery = '';
   bool _isLoading = false;
+  bool _isInitialized = false;
 
   List<ContainerModel> get containers => _containers;
   ContainerType? get selectedType => _selectedType;
   EquipmentStatus? get selectedStatus => _selectedStatus;
   String get searchQuery => _searchQuery;
   bool get isLoading => _isLoading;
+  bool get isInitialized => _isInitialized;
+
+  /// S'assure que les conteneurs sont chargés (charge si nécessaire)
+  Future<void> ensureLoaded() async {
+    if (_isInitialized || _isLoading) {
+      print('[ContainerProvider] Containers already loaded or loading, skipping...');
+      return;
+    }
+    print('[ContainerProvider] Containers not loaded, loading now...');
+    await loadContainers();
+  }
 
   /// Charger tous les containers via l'API
   Future<void> loadContainers() async {
@@ -32,6 +47,7 @@ class ContainerProvider with ChangeNotifier {
       ).listen((containers) {
         _containers = containers;
         _isLoading = false;
+        _isInitialized = true;
         notifyListeners();
       });
     } catch (e) {
@@ -91,6 +107,69 @@ class ContainerProvider with ChangeNotifier {
     return await _containerService.getContainerById(id);
   }
 
+  /// Charge plusieurs conteneurs par leurs IDs (optimisé pour les détails d'événement)
+  Future<List<ContainerModel>> getContainersByIds(List<String> containerIds) async {
+    if (containerIds.isEmpty) return [];
+
+    print('[ContainerProvider] Loading ${containerIds.length} containers by IDs...');
+
+    try {
+      // Vérifier d'abord le cache local
+      final cachedContainers = <ContainerModel>[];
+      final missingIds = <String>[];
+
+      for (final id in containerIds) {
+        final cached = _containers.firstWhere(
+          (c) => c.id == id,
+          orElse: () => ContainerModel(
+            id: '',
+            name: '',
+            type: ContainerType.flightCase,
+            status: EquipmentStatus.available,
+            equipmentIds: [],
+            createdAt: DateTime.now(),
+            updatedAt: DateTime.now(),
+          ),
+        );
+
+        if (cached.id.isNotEmpty) {
+          cachedContainers.add(cached);
+        } else {
+          missingIds.add(id);
+        }
+      }
+
+      print('[ContainerProvider] Found ${cachedContainers.length} in cache, ${missingIds.length} missing');
+
+      // Si tous sont en cache, retourner directement
+      if (missingIds.isEmpty) {
+        return cachedContainers;
+      }
+
+      // Charger les manquants depuis l'API
+      final containersData = await _dataService.getContainersByIds(missingIds);
+
+      final loadedContainers = containersData.map((data) {
+        return ContainerModel.fromMap(data, data['id'] as String);
+      }).toList();
+
+      // Ajouter au cache
+      for (final container in loadedContainers) {
+        if (!_containers.any((c) => c.id == container.id)) {
+          _containers.add(container);
+        }
+      }
+
+      print('[ContainerProvider] Loaded ${loadedContainers.length} containers from API');
+
+      // Retourner tous les conteneurs (cache + chargés)
+      return [...cachedContainers, ...loadedContainers];
+    } catch (e) {
+      print('[ContainerProvider] Error loading containers by IDs: $e');
+      rethrow;
+    }
+  }
+
   /// Ajouter un équipement à un container
   Future<Map<String, dynamic>> addEquipmentToContainer({
     required String containerId,

em2rp/lib/providers/equipment_provider.dart

@@ -15,6 +15,11 @@ class EquipmentProvider extends ChangeNotifier {
   String? _selectedModel;
   String _searchQuery = '';
   bool _isLoading = false;
+  bool _isInitialized = false; // Flag pour savoir si les équipements ont été chargés
+
+  // Constructeur - Ne charge PAS automatiquement
+  // Les équipements seront chargés à la demande (page de gestion ou via getEquipmentsByIds)
+  EquipmentProvider();
 
   // Getters
   List<EquipmentModel> get equipment => _filteredEquipment;
@@ -25,8 +30,19 @@ class EquipmentProvider extends ChangeNotifier {
   String? get selectedModel => _selectedModel;
   String get searchQuery => _searchQuery;
   bool get isLoading => _isLoading;
+  bool get isInitialized => _isInitialized;
 
-  /// Charger tous les équipements via l'API
+  /// S'assure que les équipements sont chargés (charge si nécessaire)
+  Future<void> ensureLoaded() async {
+    if (_isInitialized || _isLoading) {
+      print('[EquipmentProvider] Equipment already loaded or loading, skipping...');
+      return;
+    }
+    print('[EquipmentProvider] Equipment not loaded, loading now...');
+    await loadEquipments();
+  }
+
+  /// Charger tous les équipements via l'API (utilisé par la page de gestion)
   Future<void> loadEquipments() async {
     print('[EquipmentProvider] Starting to load equipments...');
     _isLoading = true;
@@ -45,6 +61,8 @@ class EquipmentProvider extends ChangeNotifier {
       // Extraire les modèles et marques uniques
       _extractUniqueValues();
 
+      _isInitialized = true;
+
       _isLoading = false;
       notifyListeners();
       print('[EquipmentProvider] Equipment loading complete');
@@ -56,6 +74,70 @@ class EquipmentProvider extends ChangeNotifier {
     }
   }
 
+  /// Charge plusieurs équipements par leurs IDs (optimisé pour les détails d'événement)
+  Future<List<EquipmentModel>> getEquipmentsByIds(List<String> equipmentIds) async {
+    if (equipmentIds.isEmpty) return [];
+
+    print('[EquipmentProvider] Loading ${equipmentIds.length} equipments by IDs...');
+
+    try {
+      // Vérifier d'abord le cache local
+      final cachedEquipments = <EquipmentModel>[];
+      final missingIds = <String>[];
+
+      for (final id in equipmentIds) {
+        final cached = _equipment.firstWhere(
+          (eq) => eq.id == id,
+          orElse: () => EquipmentModel(
+            id: '',
+            name: '',
+            category: EquipmentCategory.other,
+            status: EquipmentStatus.available,
+            parentBoxIds: [],
+            maintenanceIds: [],
+            createdAt: DateTime.now(),
+            updatedAt: DateTime.now(),
+          ),
+        );
+
+        if (cached.id.isNotEmpty) {
+          cachedEquipments.add(cached);
+        } else {
+          missingIds.add(id);
+        }
+      }
+
+      print('[EquipmentProvider] Found ${cachedEquipments.length} in cache, ${missingIds.length} missing');
+
+      // Si tous sont en cache, retourner directement
+      if (missingIds.isEmpty) {
+        return cachedEquipments;
+      }
+
+      // Charger les manquants depuis l'API
+      final equipmentsData = await _dataService.getEquipmentsByIds(missingIds);
+
+      final loadedEquipments = equipmentsData.map((data) {
+        return EquipmentModel.fromMap(data, data['id'] as String);
+      }).toList();
+
+      // Ajouter au cache
+      for (final eq in loadedEquipments) {
+        if (!_equipment.any((e) => e.id == eq.id)) {
+          _equipment.add(eq);
+        }
+      }
+
+      print('[EquipmentProvider] Loaded ${loadedEquipments.length} equipments from API');
+
+      // Retourner tous les équipements (cache + chargés)
+      return [...cachedEquipments, ...loadedEquipments];
+    } catch (e) {
+      print('[EquipmentProvider] Error loading equipments by IDs: $e');
+      rethrow;
+    }
+  }
+
   /// Extraire modèles et marques uniques
   void _extractUniqueValues() {
     final modelSet = <String>{};

em2rp/lib/providers/local_user_provider.dart

@@ -1,17 +1,18 @@
-import 'package:cloud_firestore/cloud_firestore.dart';
 import 'package:firebase_auth/firebase_auth.dart';
 import 'package:flutter/material.dart';
 import 'package:image_picker/image_picker.dart';
 import '../models/user_model.dart';
 import '../models/role_model.dart';
 import '../utils/firebase_storage_manager.dart';
+import '../services/api_service.dart';
+import '../services/data_service.dart';
 
 class LocalUserProvider with ChangeNotifier {
   UserModel? _currentUser;
   RoleModel? _currentRole;
   final FirebaseAuth _auth = FirebaseAuth.instance;
-  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
   final FirebaseStorageManager _storageManager = FirebaseStorageManager();
+  final DataService _dataService = DataService(apiService);
 
   UserModel? get currentUser => _currentUser;
   String? get uid => _currentUser?.uid;
@@ -24,7 +25,7 @@ class LocalUserProvider with ChangeNotifier {
   RoleModel? get currentRole => _currentRole;
   List<String> get permissions => _currentRole?.permissions ?? [];
 
-  /// Charge les données de l'utilisateur actuel
+  /// Charge les données de l'utilisateur actuel via Cloud Function
   Future<void> loadUserData() async {
     if (_auth.currentUser == null) {
       print('No current user in Auth');
@@ -33,53 +34,31 @@ class LocalUserProvider with ChangeNotifier {
 
     print('Loading user data for: ${_auth.currentUser!.uid}');
     try {
-      DocumentSnapshot userDoc = await _firestore
+      // Utiliser la Cloud Function getCurrentUser
-          .collection('users')
+      final result = await apiService.call('getCurrentUser', {});
-          .doc(_auth.currentUser!.uid)
+      final userData = result['user'] as Map<String, dynamic>;
-          .get();
 
-      if (userDoc.exists) {
+      print('User data loaded from API: ${userData['uid']}');
-        print('User document found in Firestore');
-        final userData = userDoc.data() as Map<String, dynamic>;
-        print('User data: $userData');
 
-        // Si le document n'a pas d'UID, l'ajouter
+      // Extraire le rôle
-        if (!userData.containsKey('uid')) {
+      final roleData = userData['role'] as Map<String, dynamic>?;
-          await userDoc.reference.update({'uid': _auth.currentUser!.uid});
+      if (roleData != null) {
-          userData['uid'] = _auth.currentUser!.uid;
+        _currentRole = RoleModel.fromMap(roleData, roleData['id'] as String);
       }
 
-        setUser(UserModel.fromMap(userData, userDoc.id));
+      // Créer le UserModel
-        print('User data loaded successfully');
+      _currentUser = UserModel(
-        await loadRole();
+        uid: userData['uid'] as String,
-      } else {
+        email: userData['email'] as String? ?? '',
-        print('No user document found in Firestore');
+        firstName: userData['firstName'] as String? ?? '',
-        // Créer un document utilisateur par défaut
+        lastName: userData['lastName'] as String? ?? '',
-        final defaultUser = UserModel(
+        role: roleData?['id'] as String? ?? 'USER',
-          uid: _auth.currentUser!.uid,
+        phoneNumber: userData['phoneNumber'] as String? ?? '',
-          email: _auth.currentUser!.email ?? '',
+        profilePhotoUrl: userData['profilePhotoUrl'] as String? ?? '',
-          firstName: '',
-          lastName: '',
-          role: 'USER',
-          phoneNumber: '',
-          profilePhotoUrl: '',
       );
 
-        await _firestore.collection('users').doc(_auth.currentUser!.uid).set({
+      print('User data loaded successfully');
-          'uid': _auth.currentUser!.uid,
+      notifyListeners();
-          'email': _auth.currentUser!.email,
-          'firstName': '',
-          'lastName': '',
-          'role': 'USER',
-          'phoneNumber': '',
-          'profilePhotoUrl': '',
-          'createdAt': FieldValue.serverTimestamp(),
-        });
-
-        setUser(defaultUser);
-        print('Default user document created');
-        await loadRole();
-      }
     } catch (e) {
       print('Error loading user data: $e');
       rethrow;
@@ -95,28 +74,36 @@ class LocalUserProvider with ChangeNotifier {
   /// Efface les données utilisateur
   void clearUser() {
     _currentUser = null;
+    _currentRole = null;
     notifyListeners();
   }
 
-  /// Mise à jour des informations utilisateur
+  /// Mise à jour des informations utilisateur via Cloud Function
-  Future<void> updateUserData(
+  Future<void> updateUserData({
-      {String? firstName, String? lastName, String? phoneNumber}) async {
+    String? firstName,
+    String? lastName,
+    String? phoneNumber,
+  }) async {
     if (_currentUser == null) return;
     try {
-      await _firestore.collection('users').doc(_currentUser!.uid).set({
+      await _dataService.updateUser(
+        _currentUser!.uid,
+        {
           'firstName': firstName ?? _currentUser!.firstName,
           'lastName': lastName ?? _currentUser!.lastName,
-        'phone': phoneNumber ?? _currentUser!.phoneNumber,
+          'phoneNumber': phoneNumber ?? _currentUser!.phoneNumber,
-      }, SetOptions(merge: true));
+        },
+      );
 
       _currentUser = _currentUser!.copyWith(
-        firstName: firstName ?? _currentUser!.firstName,
+        firstName: firstName,
-        lastName: lastName ?? _currentUser!.lastName,
+        lastName: lastName,
-        phoneNumber: phoneNumber ?? _currentUser!.phoneNumber,
+        phoneNumber: phoneNumber,
       );
       notifyListeners();
     } catch (e) {
       debugPrint('Erreur mise à jour utilisateur : $e');
+      rethrow;
     }
   }
 
@@ -129,16 +116,18 @@ class LocalUserProvider with ChangeNotifier {
         uid: _currentUser!.uid,
       );
       if (newProfilePhotoUrl != null) {
-        _firestore
+        // Mettre à jour via Cloud Function
-            .collection('users')
+        await _dataService.updateUser(
-            .doc(_currentUser!.uid)
+          _currentUser!.uid,
-            .update({'profilePhotoUrl': newProfilePhotoUrl});
+          {'profilePhotoUrl': newProfilePhotoUrl},
-        _currentUser =
+        );
-            _currentUser!.copyWith(profilePhotoUrl: newProfilePhotoUrl);
+
+        _currentUser = _currentUser!.copyWith(profilePhotoUrl: newProfilePhotoUrl);
         notifyListeners();
       }
     } catch (e) {
       debugPrint('Erreur mise à jour photo de profil : $e');
+      rethrow;
     }
   }
 
@@ -161,22 +150,7 @@ class LocalUserProvider with ChangeNotifier {
     clearUser();
   }
 
-  Future<void> loadRole() async {
+  /// Vérifie si l'utilisateur a une permission spécifique
-    if (_currentUser == null) return;
-    final roleId = _currentUser!.role;
-    if (roleId.isEmpty) return;
-    try {
-      final doc = await _firestore.collection('roles').doc(roleId).get();
-      if (doc.exists) {
-        _currentRole =
-            RoleModel.fromMap(doc.data() as Map<String, dynamic>, doc.id);
-        notifyListeners();
-      }
-    } catch (e) {
-      print('Error loading role: $e');
-    }
-  }
-
   bool hasPermission(String permission) {
     return _currentRole?.permissions.contains(permission) ?? false;
   }

em2rp/lib/providers/users_provider.dart

@@ -60,10 +60,10 @@ class UsersProvider with ChangeNotifier {
     }
   }
 
-  /// Suppression d'un utilisateur
+  /// Suppression d'un utilisateur via Cloud Function
   Future<void> deleteUser(String uid) async {
     try {
-      // TODO: Créer une Cloud Function deleteUser
+      await _dataService.deleteUser(uid);
       _users.removeWhere((user) => user.uid == uid);
       notifyListeners();
     } catch (e) {

em2rp/lib/services/data_service.dart

@@ -84,16 +84,6 @@ 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);
-    } catch (e) {
-      throw Exception('Erreur lors de la mise à jour de l\'utilisateur: $e');
-    }
-  }
-
   /// Met à jour un événement
   Future<void> updateEvent(String eventId, Map<String, dynamic> data) async {
     try {
@@ -271,6 +261,28 @@ class DataService {
     }
   }
 
+  /// Récupère plusieurs équipements par leurs IDs
+  Future<List<Map<String, dynamic>>> getEquipmentsByIds(List<String> equipmentIds) async {
+    try {
+      if (equipmentIds.isEmpty) return [];
+
+      print('[DataService] Getting equipments by IDs: ${equipmentIds.length} items');
+      final result = await _apiService.call('getEquipmentsByIds', {
+        'equipmentIds': equipmentIds,
+      });
+      final equipments = result['equipments'] as List<dynamic>?;
+      if (equipments == null) {
+        print('[DataService] No equipments in result');
+        return [];
+      }
+      print('[DataService] Found ${equipments.length} equipments by IDs');
+      return equipments.map((e) => e as Map<String, dynamic>).toList();
+    } catch (e) {
+      print('[DataService] Error getting equipments by IDs: $e');
+      throw Exception('Erreur lors de la récupération des équipements: $e');
+    }
+  }
+
   /// Récupère tous les conteneurs
   Future<List<Map<String, dynamic>>> getContainers() async {
     try {
@@ -283,6 +295,28 @@ class DataService {
     }
   }
 
+  /// Récupère plusieurs conteneurs par leurs IDs
+  Future<List<Map<String, dynamic>>> getContainersByIds(List<String> containerIds) async {
+    try {
+      if (containerIds.isEmpty) return [];
+
+      print('[DataService] Getting containers by IDs: ${containerIds.length} items');
+      final result = await _apiService.call('getContainersByIds', {
+        'containerIds': containerIds,
+      });
+      final containers = result['containers'] as List<dynamic>?;
+      if (containers == null) {
+        print('[DataService] No containers in result');
+        return [];
+      }
+      print('[DataService] Found ${containers.length} containers by IDs');
+      return containers.map((e) => e as Map<String, dynamic>).toList();
+    } catch (e) {
+      print('[DataService] Error getting containers by IDs: $e');
+      throw Exception('Erreur lors de la récupération des conteneurs: $e');
+    }
+  }
+
   /// Récupère les maintenances (optionnellement filtrées par équipement)
   Future<List<Map<String, dynamic>>> getMaintenances({String? equipmentId}) async {
     try {
@@ -298,29 +332,6 @@ class DataService {
     }
   }
 
-  /// Récupère les alertes
-  Future<List<Map<String, dynamic>>> getAlerts() async {
-    try {
-      final result = await _apiService.call('getAlerts', {});
-      final alerts = result['alerts'] as List<dynamic>?;
-      if (alerts == null) return [];
-      return alerts.map((e) => e as Map<String, dynamic>).toList();
-    } catch (e) {
-      throw Exception('Erreur lors de la récupération des alertes: $e');
-    }
-  }
-
-  /// Récupère les utilisateurs (filtrés selon permissions)
-  Future<List<Map<String, dynamic>>> getUsers() async {
-    try {
-      final result = await _apiService.call('getUsers', {});
-      final users = result['users'] as List<dynamic>?;
-      if (users == null) return [];
-      return users.map((e) => e as Map<String, dynamic>).toList();
-    } catch (e) {
-      throw Exception('Erreur lors de la récupération des utilisateurs: $e');
-    }
-  }
 
   /// Récupère les containers contenant un équipement spécifique
   Future<List<Map<String, dynamic>>> getContainersByEquipment(String equipmentId) async {
@@ -335,5 +346,138 @@ class DataService {
       throw Exception('Erreur lors de la récupération des containers pour l\'équipement: $e');
     }
   }
+
+  // ============================================================================
+  // USER - Current User
+  // ============================================================================
+
+  /// Récupère l'utilisateur actuellement authentifié avec son rôle
+  Future<Map<String, dynamic>> getCurrentUser() async {
+    try {
+      print('[DataService] Calling getCurrentUser API...');
+      final result = await _apiService.call('getCurrentUser', {});
+      print('[DataService] Current user loaded successfully');
+      return result['user'] as Map<String, dynamic>;
+    } catch (e) {
+      print('[DataService] Error getting current user: $e');
+      throw Exception('Erreur lors de la récupération de l\'utilisateur actuel: $e');
+    }
+  }
+
+  // ============================================================================
+  // ALERTS
+  // ============================================================================
+
+  /// Récupère toutes les alertes
+  Future<List<Map<String, dynamic>>> getAlerts() async {
+    try {
+      final result = await _apiService.call('getAlerts', {});
+      final alerts = result['alerts'] as List<dynamic>?;
+      if (alerts == null) return [];
+      return alerts.map((e) => e as Map<String, dynamic>).toList();
+    } catch (e) {
+      throw Exception('Erreur lors de la récupération des alertes: $e');
+    }
+  }
+
+  /// Marque une alerte comme lue
+  Future<void> markAlertAsRead(String alertId) async {
+    try {
+      await _apiService.call('markAlertAsRead', {'alertId': alertId});
+    } catch (e) {
+      throw Exception('Erreur lors du marquage de l\'alerte comme lue: $e');
+    }
+  }
+
+  /// Supprime une alerte
+  Future<void> deleteAlert(String alertId) async {
+    try {
+      await _apiService.call('deleteAlert', {'alertId': alertId});
+    } catch (e) {
+      throw Exception('Erreur lors de la suppression de l\'alerte: $e');
+    }
+  }
+
+  // ============================================================================
+  // EQUIPMENT AVAILABILITY
+  // ============================================================================
+
+  /// Vérifie la disponibilité d'un équipement
+  Future<Map<String, dynamic>> checkEquipmentAvailability({
+    required String equipmentId,
+    required DateTime startDate,
+    required DateTime endDate,
+    String? excludeEventId,
+  }) async {
+    try {
+      final result = await _apiService.call('checkEquipmentAvailability', {
+        'equipmentId': equipmentId,
+        'startDate': startDate.toIso8601String(),
+        'endDate': endDate.toIso8601String(),
+        if (excludeEventId != null) 'excludeEventId': excludeEventId,
+      });
+      return result;
+    } catch (e) {
+      throw Exception('Erreur lors de la vérification de disponibilité: $e');
+    }
+  }
+
+  // ============================================================================
+  // MAINTENANCES
+  // ============================================================================
+
+  /// Supprime une maintenance
+  Future<void> deleteMaintenance(String maintenanceId) async {
+    try {
+      await _apiService.call('deleteMaintenance', {'maintenanceId': maintenanceId});
+    } catch (e) {
+      throw Exception('Erreur lors de la suppression de la maintenance: $e');
+    }
+  }
+
+  // ============================================================================
+  // USERS
+  // ============================================================================
+
+  /// Récupère tous les utilisateurs (selon permissions)
+  Future<List<Map<String, dynamic>>> getUsers() async {
+    try {
+      final result = await _apiService.call('getUsers', {});
+      final users = result['users'] as List<dynamic>?;
+      if (users == null) return [];
+      return users.map((e) => e as Map<String, dynamic>).toList();
+    } catch (e) {
+      throw Exception('Erreur lors de la récupération des utilisateurs: $e');
+    }
+  }
+
+  /// Récupère un utilisateur spécifique
+  Future<Map<String, dynamic>> getUser(String userId) async {
+    try {
+      final result = await _apiService.call('getUser', {'userId': userId});
+      return result['user'] as Map<String, dynamic>;
+    } catch (e) {
+      throw Exception('Erreur lors de la récupération de l\'utilisateur: $e');
+    }
+  }
+
+  /// Supprime un utilisateur (Auth + Firestore)
+  Future<void> deleteUser(String userId) async {
+    try {
+      await _apiService.call('deleteUser', {'userId': userId});
+    } catch (e) {
+      throw Exception('Erreur lors de la suppression de l\'utilisateur: $e');
+    }
+  }
+
+  /// 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);
+    } catch (e) {
+      throw Exception('Erreur lors de la mise à jour de l\'utilisateur: $e');
+    }
+  }
 }
 

em2rp/lib/services/event_availability_service.dart

@@ -1,7 +1,8 @@
-import 'package:cloud_firestore/cloud_firestore.dart';
 import 'package:em2rp/models/event_model.dart';
 import 'package:em2rp/models/equipment_model.dart';
 import 'package:em2rp/models/container_model.dart';
+import 'package:em2rp/services/api_service.dart';
+import 'package:em2rp/services/data_service.dart';
 
 /// Type de conflit
 enum ConflictType {
@@ -63,9 +64,16 @@ class AvailabilityConflict {
 
 /// Service pour vérifier la disponibilité du matériel
 class EventAvailabilityService {
-  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
+  final DataService _dataService = DataService(apiService);
 
-  /// Vérifie si un équipement est disponible pour une plage de dates
+  /// Helper pour récupérer uniquement la liste d'événements
+  Future<List<Map<String, dynamic>>> _getEventsList() async {
+    final result = await _dataService.getEvents();
+    final events = result['events'] as List<dynamic>? ?? [];
+    return events.map((e) => e as Map<String, dynamic>).toList();
+  }
+
+  /// Vérifie si un équipement est disponible pour une plage de dates via Cloud Function
   Future<List<AvailabilityConflict>> checkEquipmentAvailability({
     required String equipmentId,
     required String equipmentName,
@@ -76,59 +84,44 @@ class EventAvailabilityService {
     final conflicts = <AvailabilityConflict>[];
 
     try {
-      // Récupérer TOUS les événements (on filtre côté client car arrayContains avec objet ne marche pas)
+      // Utiliser la Cloud Function pour vérifier la disponibilité
-      final eventsSnapshot = await _firestore.collection('events').get();
+      final result = await _dataService.checkEquipmentAvailability(
+        equipmentId: equipmentId,
+        startDate: startDate,
+        endDate: endDate,
+        excludeEventId: excludeEventId,
+      );
 
-      for (var doc in eventsSnapshot.docs) {
+      final available = result['available'] as bool? ?? true;
-        if (excludeEventId != null && doc.id == excludeEventId) {
+      if (!available) {
-          continue; // Ignorer l'événement en cours d'édition
+        final conflictsData = result['conflicts'] as List<dynamic>? ?? [];
-        }
 
+        // Récupérer les détails des événements en conflit
+        final eventsData = await _getEventsList();
+
+        for (final conflictData in conflictsData) {
+          final conflict = conflictData as Map<String, dynamic>;
+          final eventId = conflict['eventId'] as String;
+
+          // Trouver l'événement correspondant
+          final eventData = eventsData.firstWhere(
+            (e) => e['id'] == eventId,
+            orElse: () => <String, dynamic>{},
+          );
+
+          if (eventData.isNotEmpty) {
             try {
-          final data = doc.data();
+              final event = EventModel.fromMap(eventData, eventId);
-          final event = EventModel.fromMap(data, doc.id);
-
-          // Ignorer les événements annulés
-          if (event.status == EventStatus.canceled) {
-            continue;
-          }
-
-          // Vérifier si cet événement contient l'équipement recherché
-          final assignedEquipment = event.assignedEquipment.firstWhere(
-            (eq) => eq.equipmentId == equipmentId,
-            orElse: () => EventEquipment(equipmentId: ''),
-          );
-
-          // Si l'équipement est assigné à cet événement, il est indisponible
-          // (peu importe le statut de préparation/chargement/retour)
-          if (assignedEquipment.equipmentId.isNotEmpty) {
-            // Calculer les dates réelles avec temps d'installation et démontage
-            final eventRealStartDate = event.startDateTime.subtract(
-              Duration(hours: event.installationTime),
-            );
-            final eventRealEndDate = event.endDateTime.add(
-              Duration(hours: event.disassemblyTime),
-            );
-
-            // Vérifier le chevauchement des dates
-            if (_datesOverlap(startDate, endDate, eventRealStartDate, eventRealEndDate)) {
-              final overlapDays = _calculateOverlapDays(
-                startDate,
-                endDate,
-                eventRealStartDate,
-                eventRealEndDate,
-              );
-
               conflicts.add(AvailabilityConflict(
                 equipmentId: equipmentId,
                 equipmentName: equipmentName,
                 conflictingEvent: event,
-                overlapDays: overlapDays,
+                overlapDays: conflict['overlapDays'] as int? ?? 0,
               ));
-            }
-          }
             } catch (e) {
-          print('[EventAvailabilityService] Error processing event ${doc.id}: $e');
+              print('[EventAvailabilityService] Error creating EventModel: $e');
+            }
+          }
         }
       }
     } catch (e) {
@@ -138,11 +131,6 @@ class EventAvailabilityService {
     return conflicts;
   }
 
-  /// Helper pour formater les dates dans les logs
-  String _formatDate(DateTime date) {
-    return '${date.day.toString().padLeft(2, '0')}/${date.month.toString().padLeft(2, '0')}/${date.year} ${date.hour.toString().padLeft(2, '0')}:${date.minute.toString().padLeft(2, '0')}';
-  }
-
   /// Vérifie la disponibilité pour une liste d'équipements
   Future<Map<String, List<AvailabilityConflict>>> checkMultipleEquipmentAvailability({
     required List<String> equipmentIds,
@@ -203,16 +191,17 @@ class EventAvailabilityService {
     int reservedQuantity = 0;
 
     try {
-      // Récupérer tous les événements (on filtre côté client)
+      // Récupérer tous les événements via Cloud Function
-      final eventsSnapshot = await _firestore.collection('events').get();
+      final eventsData = await _getEventsList();
 
-      for (var doc in eventsSnapshot.docs) {
+      for (var eventData in eventsData) {
-        if (excludeEventId != null && doc.id == excludeEventId) {
+        final eventId = eventData['id'] as String;
+        if (excludeEventId != null && eventId == excludeEventId) {
           continue;
         }
 
         try {
-          final event = EventModel.fromMap(doc.data(), doc.id);
+          final event = EventModel.fromMap(eventData, eventId);
 
           // Ignorer les événements annulés
           if (event.status == EventStatus.canceled) {
@@ -241,7 +230,7 @@ class EventAvailabilityService {
             }
           }
         } catch (e) {
-          print('[EventAvailabilityService] Error processing event ${doc.id} for quantity: $e');
+          print('[EventAvailabilityService] Error processing event $eventId for quantity: $e');
         }
       }
     } catch (e) {
@@ -275,13 +264,14 @@ class EventAvailabilityService {
       // ✅ Ne créer un conflit que si la quantité est VRAIMENT insuffisante
       if (availableQty < requestedQuantity) {
         // Trouver les événements qui réservent cette quantité
-        final eventsSnapshot = await _firestore.collection('events').get();
+        final eventsData = await _getEventsList();
 
-        for (var doc in eventsSnapshot.docs) {
+        for (var eventData in eventsData) {
-          if (excludeEventId != null && doc.id == excludeEventId) continue;
+          final eventId = eventData['id'] as String;
+          if (excludeEventId != null && eventId == excludeEventId) continue;
 
           try {
-            final event = EventModel.fromMap(doc.data(), doc.id);
+            final event = EventModel.fromMap(eventData, eventId);
 
             if (_datesOverlap(startDate, endDate, event.startDateTime, event.endDateTime)) {
               final assignedEquipment = event.assignedEquipment.firstWhere(
@@ -304,7 +294,7 @@ class EventAvailabilityService {
               }
             }
           } catch (e) {
-            print('[EventAvailabilityService] Error processing event ${doc.id}: $e');
+            print('[EventAvailabilityService] Error processing event $eventId: $e');
           }
         }
       }
@@ -334,15 +324,16 @@ class EventAvailabilityService {
     final conflictingChildrenIds = <String>[];
 
     // Vérifier d'abord si la boîte complète est utilisée
-    final eventsSnapshot = await _firestore.collection('events').get();
+    final eventsData = await _getEventsList();
     bool isContainerFullyUsed = false;
     EventModel? containerConflictingEvent;
 
-    for (var doc in eventsSnapshot.docs) {
+    for (var eventData in eventsData) {
-      if (excludeEventId != null && doc.id == excludeEventId) continue;
+      final eventId = eventData['id'] as String;
+      if (excludeEventId != null && eventId == excludeEventId) continue;
 
       try {
-        final event = EventModel.fromMap(doc.data(), doc.id);
+        final event = EventModel.fromMap(eventData, eventId);
 
         // Ignorer les événements annulés
         if (event.status == EventStatus.canceled) {
@@ -366,7 +357,7 @@ class EventAvailabilityService {
           }
         }
       } catch (e) {
-        print('[EventAvailabilityService] Error processing event ${doc.id}: $e');
+        print('[EventAvailabilityService] Error processing event $eventId: $e');
       }
     }
 

em2rp/lib/services/ics_export_service.dart

@@ -45,56 +45,47 @@ END:VCALENDAR''';
     return icsContent;
   }
 
-  /// Récupère le nom du type d'événement
+  /// Récupère le nom du type d'événement depuis EventModel (déjà chargé)
+  /// Note: Les eventTypes sont maintenant chargés via Cloud Function dans l'EventModel
   static Future<String> _getEventTypeName(String eventTypeId) async {
     if (eventTypeId.isEmpty) return 'Non spécifié';
 
-    try {
+    // Les eventTypes sont publics et déjà chargés dans l'app via Cloud Function
-      final doc = await FirebaseFirestore.instance
+    // On retourne simplement l'ID, le nom sera résolu par l'app
-          .collection('eventTypes')
-          .doc(eventTypeId)
-          .get();
-
-      if (doc.exists) {
-        return doc.data()?['name'] as String? ?? eventTypeId;
-      }
-    } catch (e) {
-      print('Erreur lors de la récupération du type d\'événement: $e');
-    }
-
     return eventTypeId;
   }
 
   /// Récupère les détails de la main d'œuvre
+  /// Note: Les données users devraient être passées directement depuis l'app
+  /// qui les a déjà récupérées via Cloud Function
   static Future<List<String>> _getWorkforceDetails(List<dynamic> workforce) async {
     final List<String> workforceNames = [];
 
     for (final ref in workforce) {
       try {
-        DocumentReference? docRef;
+        // Si c'est déjà une Map avec les données, l'utiliser directement
-
+        if (ref is Map<String, dynamic>) {
-        // Gérer String (UID) ou DocumentReference
+          final firstName = ref['firstName'] ?? '';
-        if (ref is String) {
+          final lastName = ref['lastName'] ?? '';
-          docRef = FirebaseFirestore.instance.collection('users').doc(ref);
-        } else if (ref is DocumentReference) {
-          docRef = ref;
-        }
-
-        if (docRef != null) {
-          final doc = await docRef.get();
-          if (doc.exists) {
-            final data = doc.data() as Map<String, dynamic>?;
-            if (data != null) {
-              final firstName = data['firstName'] ?? '';
-              final lastName = data['lastName'] ?? '';
           if (firstName.isNotEmpty || lastName.isNotEmpty) {
             workforceNames.add('$firstName $lastName'.trim());
           }
+          continue;
         }
+
+        // Si c'est un String (UID), on ne peut pas récupérer les données ici
+        // Les données devraient être passées directement
+        if (ref is String) {
+          workforceNames.add('Utilisateur $ref');
+          continue;
         }
+
+        // Si c'est une DocumentReference, extraire l'ID seulement
+        if (ref is DocumentReference) {
+          workforceNames.add('Utilisateur ${ref.id}');
         }
       } catch (e) {
-        print('Erreur lors de la récupération des détails utilisateur: $e');
+        print('Erreur lors du traitement des détails utilisateur: $e');
       }
     }
 
@@ -102,46 +93,19 @@ END:VCALENDAR''';
   }
 
   /// Récupère les détails des options
+  /// Note: Les options sont publiques et déjà chargées via Cloud Function
   static Future<List<Map<String, dynamic>>> _getOptionsDetails(List<Map<String, dynamic>> options) async {
     final List<Map<String, dynamic>> optionsWithNames = [];
 
     for (final option in options) {
       try {
-        final optionId = option['id'] ?? option['optionId'];
+        // Les options devraient déjà contenir le nom
-        if (optionId == null || optionId.toString().isEmpty) {
-          // Si pas d'ID, garder le nom tel quel
         optionsWithNames.add({
-            'name': option['name'] ?? 'Option inconnue',
+          'name': option['name'] ?? option['optionId'] ?? 'Option inconnue',
           'quantity': option['quantity'],
         });
-          continue;
-        }
-
-        // Récupérer le nom depuis Firestore
-        final doc = await FirebaseFirestore.instance
-            .collection('options')
-            .doc(optionId.toString())
-            .get();
-
-        if (doc.exists) {
-          final data = doc.data();
-          optionsWithNames.add({
-            'name': data?['name'] ?? option['name'] ?? 'Option inconnue',
-            'quantity': option['quantity'],
-          });
-        } else {
-          // Document n'existe pas, garder le nom de l'option
-          optionsWithNames.add({
-            'name': option['name'] ?? 'Option inconnue',
-            'quantity': option['quantity'],
-          });
-        }
       } catch (e) {
-        print('Erreur lors de la récupération des détails option: $e');
+        print('Erreur lors du traitement des options: $e');
-        optionsWithNames.add({
-          'name': option['name'] ?? 'Option inconnue',
-          'quantity': option['quantity'],
-        });
       }
     }
 

em2rp/lib/views/event_preparation_page.dart

@@ -1,6 +1,5 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
-import 'package:cloud_firestore/cloud_firestore.dart';
 import 'package:em2rp/models/event_model.dart';
 import 'package:em2rp/models/equipment_model.dart';
 import 'package:em2rp/models/container_model.dart';
@@ -10,6 +9,7 @@ import 'package:em2rp/providers/event_provider.dart';
 import 'package:em2rp/providers/local_user_provider.dart';
 import 'package:em2rp/services/data_service.dart';
 import 'package:em2rp/services/api_service.dart';
+import 'package:em2rp/services/api_service.dart';
 import 'package:em2rp/views/widgets/equipment/equipment_checklist_item.dart' show EquipmentChecklistItem, ChecklistStep;
 import 'package:em2rp/views/widgets/equipment/missing_equipment_dialog.dart';
 import 'package:em2rp/utils/colors.dart';
@@ -96,7 +96,7 @@ class _EventPreparationPageState extends State<EventPreparationPage> with Single
       duration: const Duration(milliseconds: 500),
     );
 
-    // Vérification de sécurité : bloquer l'accès si toutes les étapes sont complétées
+    // Vérification de sécurité et chargement après le premier frame
     WidgetsBinding.instance.addPostFrameCallback((_) {
       if (_isCurrentStepCompleted()) {
         ScaffoldMessenger.of(context).showSnackBar(
@@ -108,9 +108,10 @@ class _EventPreparationPageState extends State<EventPreparationPage> with Single
         Navigator.of(context).pop();
         return;
       }
-    });
 
+      // Charger les équipements après le premier frame pour éviter setState pendant build
       _loadEquipmentAndContainers();
+    });
   }
 
   /// Vérifie si l'étape actuelle est déjà complétée
@@ -140,6 +141,10 @@ class _EventPreparationPageState extends State<EventPreparationPage> with Single
       final equipmentProvider = context.read<EquipmentProvider>();
       final containerProvider = context.read<ContainerProvider>();
 
+      // S'assurer que les équipements sont chargés
+      await equipmentProvider.ensureLoaded();
+      await containerProvider.ensureLoaded();
+
       final equipment = await equipmentProvider.equipmentStream.first;
       final containers = await containerProvider.containersStream.first;
 

em2rp/lib/views/widgets/event/equipment_selection_dialog.dart

@@ -104,10 +104,26 @@ class _EquipmentSelectionDialogState extends State<EquipmentSelectionDialog> {
   @override
   void initState() {
     super.initState();
+
+    // Charger après le premier frame pour éviter setState pendant build
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      _ensureEquipmentsLoaded();
       _initializeAlreadyAssigned();
       _loadAvailableQuantities();
       _loadEquipmentConflicts();
       _loadContainerConflicts();
+    });
+  }
+
+  /// S'assure que les équipements sont chargés avant d'utiliser le dialog
+  Future<void> _ensureEquipmentsLoaded() async {
+    final equipmentProvider = context.read<EquipmentProvider>();
+    final containerProvider = context.read<ContainerProvider>();
+    await equipmentProvider.ensureLoaded();
+    // Charger aussi les conteneurs si nécessaire
+    if (!containerProvider.isLoading && containerProvider.containers.isEmpty) {
+      await containerProvider.loadContainers();
+    }
   }
 
   /// Initialise la sélection avec le matériel déjà assigné

em2rp/lib/views/widgets/event_form/event_assigned_equipment_section.dart

@@ -63,9 +63,16 @@ class _EventAssignedEquipmentSectionState extends State<EventAssignedEquipmentSe
       final equipmentProvider = context.read<EquipmentProvider>();
       final containerProvider = context.read<ContainerProvider>();
 
-      // Charger depuis les streams
+      // Extraire les IDs des équipements assignés
-      final equipment = await equipmentProvider.equipmentStream.first;
+      final equipmentIds = widget.assignedEquipment
-      final containers = await containerProvider.containersStream.first;
+          .map((eq) => eq.equipmentId)
+          .toList();
+
+      // Charger UNIQUEMENT les équipements nécessaires (optimisé)
+      final equipment = await equipmentProvider.getEquipmentsByIds(equipmentIds);
+
+      // Charger UNIQUEMENT les conteneurs nécessaires (optimisé)
+      final containers = await containerProvider.getContainersByIds(widget.assignedContainers);
 
       // Créer le cache des équipements
       for (var eq in widget.assignedEquipment) {

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

@@ -42,9 +42,17 @@ class _EditUserDialogState extends State<EditUserDialog> {
         availableRoles = rolesData
             .map((data) => RoleModel.fromMap(data, data['id'] as String))
             .toList();
-        selectedRoleId = widget.user.role.isEmpty
+        // Extraire l'ID du rôle depuis le path "roles/ADMIN" -> "ADMIN"
-            ? (availableRoles.isNotEmpty ? availableRoles.first.id : null)
+        String roleId = widget.user.role.isEmpty
+            ? (availableRoles.isNotEmpty ? availableRoles.first.id : '')
             : widget.user.role;
+
+        // Si le rôle contient un slash, extraire seulement l'ID
+        if (roleId.contains('/')) {
+          roleId = roleId.split('/').last;
+        }
+
+        selectedRoleId = roleId;
         isLoadingRoles = false;
       });
     } catch (e) {

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

@@ -73,6 +73,14 @@ class _UserCardState extends State<UserCard> {
     }
   }
 
+  /// Extrait le nom du rôle depuis le path "roles/ADMIN" -> "ADMIN"
+  String _extractRoleName(String rolePath) {
+    if (rolePath.contains('/')) {
+      return rolePath.split('/').last;
+    }
+    return rolePath;
+  }
+
   @override
   Widget build(BuildContext context) {
     final width = MediaQuery.of(context).size.width;
@@ -178,7 +186,7 @@ class _UserCardState extends State<UserCard> {
                     if (widget.user.role.isNotEmpty) ...[
                       const SizedBox(height: 4),
                       Text(
-                        widget.user.role,
+                        _extractRoleName(widget.user.role),
                         style: Theme.of(context).textTheme.bodySmall!.copyWith(
                               color: AppColors.gris,
                               fontSize: 11,