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

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

Browse Source 
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.
This commit is contained in:
ElPoyo
2026-01-14 11:18:49 +01:00
parent 4545bdba81
commit 4e4573f57b
14 changed files with 1201 additions and 638 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
em2rp/lib/services/api_service.dart
View File

@@ -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) {

21
em2rp/lib/services/container_service.dart
View File

@@ -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;

29
em2rp/lib/services/data_service.dart
View File

@@ -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');
}
}
}

164
em2rp/lib/services/event_preparation_service.dart
View File

@@ -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) {

193
em2rp/lib/services/event_preparation_service_extended.dart
View File

@@ -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;
}
}
}

81
em2rp/lib/services/maintenance_service.dart
View File

@@ -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;
}
}
}

5
em2rp/lib/services/user_service.dart
View File

@@ -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;
}
}