ElPoyo/EM2_ERP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: Remplacement de l'accès direct à Firestore par des Cloud Functions

Browse Source 
Migration complète du backend pour utiliser des Cloud Functions comme couche API sécurisée, en remplacement des appels directs à Firestore depuis le client.

**Backend (Cloud Functions):**
- **Centralisation CORS :** Ajout d'un middleware `withCors` et d'une configuration `httpOptions` pour gérer uniformément les en-têtes CORS et les requêtes `OPTIONS` sur toutes les fonctions.
- **Nouvelles Fonctions de Lecture (GET) :**
    - `getEquipments`, `getContainers`, `getEvents`, `getUsers`, `getOptions`, `getEventTypes`, `getRoles`, `getMaintenances`, `getAlerts`.
    - Ces fonctions gèrent les permissions côté serveur, masquant les données sensibles (ex: prix des équipements) pour les utilisateurs non-autorisés.
    - `getEvents` retourne également une map des utilisateurs (`usersMap`) pour optimiser le chargement des données de la main d'œuvre.
- **Nouvelle Fonction de Recherche :**
    - `getContainersByEquipment` : Endpoint dédié pour trouver efficacement tous les containers qui contiennent un équipement spécifique.
- **Nouvelles Fonctions d'Écriture (CRUD) :**
    - Fonctions CRUD complètes pour `eventTypes` (`create`, `update`, `delete`), incluant la validation (unicité du nom, vérification des événements futurs avant suppression).
- **Mise à jour de Fonctions Existantes :**
    - Toutes les fonctions CRUD existantes (`create/update/deleteEquipment`, `create/update/deleteContainer`, etc.) sont wrappées avec le nouveau gestionnaire CORS.

**Frontend (Flutter):**
- **Introduction du `DataService` :** Nouveau service centralisant tous les appels aux Cloud Functions, servant d'intermédiaire entre l'UI/Providers et l'API.
- **Refactorisation des Providers :**
    - `EquipmentProvider`, `ContainerProvider`, `EventProvider`, `UsersProvider`, `MaintenanceProvider` et `AlertProvider` ont été refactorisés pour utiliser le `DataService` au lieu d'accéder directement à Firestore.
    - Les `Stream` Firestore sont remplacés par des chargements de données via des méthodes `Future` (`loadEquipments`, `loadEvents`, etc.).
- **Gestion des Relations Équipement-Container :**
    - Le modèle `EquipmentModel` ne stocke plus `parentBoxIds`.
    - La relation est maintenant gérée par le `ContainerModel` qui contient `equipmentIds`.
    - Le `ContainerEquipmentService` est introduit pour utiliser la nouvelle fonction `getContainersByEquipment`.
    - L'affichage des boîtes parentes (`EquipmentParentContainers`) et le formulaire d'équipement (`EquipmentFormPage`) ont été mis à jour pour refléter ce nouveau modèle de données, synchronisant les ajouts/suppressions d'équipements dans les containers.
- **Amélioration de l'UI :**
    - Nouveau widget `ParentBoxesSelector` pour une sélection améliorée et visuelle des boîtes parentes dans le formulaire d'équipement.
    - Refonte visuelle de `EquipmentParentContainers` pour une meilleure présentation.
This commit is contained in:
ElPoyo
2026-01-12 20:38:46 +01:00
parent 13a890606d
commit f38d75362c
46 changed files with 3367 additions and 1510 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
em2rp/lib/providers/event_provider.dart
View File

@@ -1,110 +1,99 @@
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:flutter/material.dart';
import 'package:em2rp/services/equipment_status_calculator.dart';
import '../models/event_model.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:em2rp/models/event_model.dart';
import 'package:em2rp/services/data_service.dart';
import 'package:em2rp/services/api_service.dart';
class EventProvider with ChangeNotifier {
final FirebaseFirestore _firestore = FirebaseFirestore.instance;
final DataService _dataService = DataService(FirebaseFunctionsApiService());
List<EventModel> _events = [];
bool _isLoading = false;
List<EventModel> get events => _events;
bool get isLoading => _isLoading;
// Récupérer les événements pour un utilisateur spécifique
Future<void> loadUserEvents(String userId,
{bool canViewAllEvents = false}) async {
// Cache des utilisateurs chargés depuis getEvents
Map<String, Map<String, dynamic>> _usersCache = {};
/// Charger les événements d'un utilisateur via l'API
Future<void> loadUserEvents(String userId, {bool canViewAllEvents = false}) async {
_isLoading = true;
notifyListeners();
try {
print(
'Loading events for user: $userId (canViewAllEvents: $canViewAllEvents)');
// Sauvegarder les paramètres
_saveLastLoadParams(userId, canViewAllEvents);
QuerySnapshot eventsSnapshot = await _firestore.collection('events').get();
print('Found ${eventsSnapshot.docs.length} events total');
try {
print('Loading events for user: $userId (canViewAllEvents: $canViewAllEvents)');
// Charger via l'API - les permissions sont vérifiées côté serveur
final result = await _dataService.getEvents(userId: userId);
final eventsData = result['events'] as List<Map<String, dynamic>>;
final usersData = result['users'] as Map<String, dynamic>;
// Stocker les utilisateurs dans le cache
_usersCache = usersData.map((key, value) =>
MapEntry(key, value as Map<String, dynamic>)
);
print('Found ${eventsData.length} events from API');
List<EventModel> allEvents = [];
int failedCount = 0;
// Parser chaque événement individuellement pour éviter qu'une erreur interrompe tout
for (var doc in eventsSnapshot.docs) {
// Parser chaque événement
for (var eventData in eventsData) {
try {
final data = doc.data() as Map<String, dynamic>;
final event = EventModel.fromMap(data, doc.id);
final event = EventModel.fromMap(eventData, eventData['id'] as String);
allEvents.add(event);
} catch (e) {
print('Failed to parse event ${doc.id}: $e');
print('Failed to parse event ${eventData['id']}: $e');
failedCount++;
// Continue avec les autres événements au lieu d'arrêter
}
}
// Filtrage amélioré pour les utilisateurs non-admin
if (canViewAllEvents) {
_events = allEvents;
print('Admin user: showing all ${_events.length} events');
} else {
// Créer la référence utilisateur correctement
final userDocRef = _firestore.collection('users').doc(userId);
_events = allEvents.where((event) {
// Vérifier si l'utilisateur est dans l'équipe de l'événement
bool isInWorkforce = event.workforce.any((workforceRef) {
return workforceRef.path == userDocRef.path;
});
if (isInWorkforce) {
print('Event ${event.name} includes user $userId');
}
return isInWorkforce;
}).toList();
}
_events = allEvents;
print('Successfully loaded ${_events.length} events (${failedCount} failed)');
_isLoading = false;
notifyListeners();
} catch (e) {
print('Error loading events: $e');
_isLoading = false;
_events = []; // S'assurer que la liste est vide en cas d'erreur
notifyListeners();
rethrow;
}
}
// Récupérer un événement spécifique
Future<EventModel?> getEvent(String eventId) async {
/// Recharger les événements (utilise le dernier userId)
Future<void> refreshEvents(String userId, {bool canViewAllEvents = false}) async {
await loadUserEvents(userId, canViewAllEvents: canViewAllEvents);
}
/// Récupérer un événement spécifique par ID
EventModel? getEventById(String eventId) {
try {
final doc = await _firestore.collection('events').doc(eventId).get();
if (doc.exists) {
return EventModel.fromMap(doc.data()!, doc.id);
}
return null;
return _events.firstWhere((event) => event.id == eventId);
} catch (e) {
print('Error getting event: $e');
rethrow;
return null;
}
}
// Ajouter un nouvel événement
/// Ajouter un nouvel événement
Future<void> addEvent(EventModel event) async {
try {
final docRef = await _firestore.collection('events').add(event.toMap());
final newEvent = EventModel.fromMap(event.toMap(), docRef.id);
_events.add(newEvent);
notifyListeners();
// L'événement est créé via l'API dans le service
await refreshEvents(_lastUserId ?? '', canViewAllEvents: _lastCanViewAll);
} catch (e) {
print('Error adding event: $e');
rethrow;
}
}
// Mettre à jour un événement
/// Mettre à jour un événement
Future<void> updateEvent(EventModel event) async {
try {
await _firestore.collection('events').doc(event.id).update(event.toMap());
// Mise à jour locale immédiate
final index = _events.indexWhere((e) => e.id == event.id);
if (index != -1) {
_events[index] = event;
@@ -116,15 +105,11 @@ class EventProvider with ChangeNotifier {
}
}
// Supprimer un événement
/// Supprimer un événement
Future<void> deleteEvent(String eventId) async {
try {
await _firestore.collection('events').doc(eventId).delete();
await _dataService.deleteEvent(eventId);
_events.removeWhere((event) => event.id == eventId);
// Invalider le cache des statuts d'équipement
EquipmentStatusCalculator.invalidateGlobalCache();
notifyListeners();
} catch (e) {
print('Error deleting event: $e');
@@ -132,9 +117,56 @@ class EventProvider with ChangeNotifier {
}
}
// Vider la liste des événements
/// Récupérer les données d'un utilisateur depuis le cache
Map<String, dynamic>? getUserFromCache(String uid) {
return _usersCache[uid];
}
/// Récupérer les utilisateurs de la workforce d'un événement
List<Map<String, dynamic>> getWorkforceUsers(EventModel event) {
final users = <Map<String, dynamic>>[];
for (final dynamic userRef in event.workforce) {
try {
String? uid;
// Tenter d'extraire l'UID
if (userRef is String) {
uid = userRef;
} else {
// Essayer d'extraire l'ID si c'est une DocumentReference
final ref = userRef as DocumentReference?;
uid = ref?.id;
}
if (uid != null) {
final userData = getUserFromCache(uid);
if (userData != null) {
users.add(userData);
}
}
} catch (e) {
// Ignorer les références invalides
print('Skipping invalid workforce reference: $userRef');
}
}
return users;
}
/// Vider la liste des événements
void clearEvents() {
_events = [];
notifyListeners();
}
// Variables pour stocker le dernier appel
String? _lastUserId;
bool _lastCanViewAll = false;
/// Sauvegarder les paramètres du dernier chargement
void _saveLastLoadParams(String userId, bool canViewAllEvents) {
_lastUserId = userId;
_lastCanViewAll = canViewAllEvents;
}
}