Add equipment management features (and qr generation support)
This commit is contained in:
ElPoyo
373
em2rp/lib/services/equipment_service.dart
Normal file
373
em2rp/lib/services/equipment_service.dart
Normal file
@@ -0,0 +1,373 @@
|
||||
import 'package:cloud_firestore/cloud_firestore.dart';
|
||||
import 'package:em2rp/models/equipment_model.dart';
|
||||
import 'package:em2rp/models/alert_model.dart';
|
||||
|
||||
class EquipmentService {
|
||||
final FirebaseFirestore _firestore = FirebaseFirestore.instance;
|
||||
|
||||
// Collection references
|
||||
CollectionReference get _equipmentCollection => _firestore.collection('equipments');
|
||||
CollectionReference get _alertsCollection => _firestore.collection('alerts');
|
||||
CollectionReference get _eventsCollection => _firestore.collection('events');
|
||||
|
||||
// CRUD Operations
|
||||
|
||||
/// Créer un nouvel équipement
|
||||
Future<void> createEquipment(EquipmentModel equipment) async {
|
||||
try {
|
||||
await _equipmentCollection.doc(equipment.id).set(equipment.toMap());
|
||||
} catch (e) {
|
||||
print('Error creating equipment: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Mettre à jour un équipement
|
||||
Future<void> updateEquipment(String id, Map<String, dynamic> data) async {
|
||||
try {
|
||||
data['updatedAt'] = Timestamp.fromDate(DateTime.now());
|
||||
await _equipmentCollection.doc(id).update(data);
|
||||
} catch (e) {
|
||||
print('Error updating equipment: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Supprimer un équipement
|
||||
Future<void> deleteEquipment(String id) async {
|
||||
try {
|
||||
await _equipmentCollection.doc(id).delete();
|
||||
} catch (e) {
|
||||
print('Error deleting equipment: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer un équipement par ID
|
||||
Future<EquipmentModel?> getEquipmentById(String id) async {
|
||||
try {
|
||||
final doc = await _equipmentCollection.doc(id).get();
|
||||
if (doc.exists) {
|
||||
return EquipmentModel.fromMap(doc.data() as Map<String, dynamic>, doc.id);
|
||||
}
|
||||
return null;
|
||||
} catch (e) {
|
||||
print('Error getting equipment: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer les équipements avec filtres
|
||||
Stream<List<EquipmentModel>> getEquipment({
|
||||
EquipmentCategory? category,
|
||||
EquipmentStatus? status,
|
||||
String? model,
|
||||
String? searchQuery,
|
||||
}) {
|
||||
try {
|
||||
Query query = _equipmentCollection;
|
||||
|
||||
// Filtre par catégorie
|
||||
if (category != null) {
|
||||
query = query.where('category', isEqualTo: equipmentCategoryToString(category));
|
||||
}
|
||||
|
||||
// Filtre par statut
|
||||
if (status != null) {
|
||||
query = query.where('status', isEqualTo: equipmentStatusToString(status));
|
||||
}
|
||||
|
||||
// Filtre par modèle
|
||||
if (model != null && model.isNotEmpty) {
|
||||
query = query.where('model', isEqualTo: model);
|
||||
}
|
||||
|
||||
return query.snapshots().map((snapshot) {
|
||||
List<EquipmentModel> equipmentList = snapshot.docs
|
||||
.map((doc) => EquipmentModel.fromMap(doc.data() as Map<String, dynamic>, doc.id))
|
||||
.toList();
|
||||
|
||||
// Filtre par recherche texte (côté client car Firestore ne supporte pas les recherches texte complexes)
|
||||
if (searchQuery != null && searchQuery.isNotEmpty) {
|
||||
final lowerSearch = searchQuery.toLowerCase();
|
||||
equipmentList = equipmentList.where((equipment) {
|
||||
return equipment.name.toLowerCase().contains(lowerSearch) ||
|
||||
(equipment.model?.toLowerCase().contains(lowerSearch) ?? false) ||
|
||||
equipment.id.toLowerCase().contains(lowerSearch);
|
||||
}).toList();
|
||||
}
|
||||
|
||||
return equipmentList;
|
||||
});
|
||||
} catch (e) {
|
||||
print('Error streaming equipment: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Vérifier la disponibilité d'un équipement pour une période donnée
|
||||
Future<List<String>> checkAvailability(
|
||||
String equipmentId,
|
||||
DateTime startDate,
|
||||
DateTime endDate,
|
||||
) async {
|
||||
try {
|
||||
final conflicts = <String>[];
|
||||
|
||||
// Récupérer tous les événements qui chevauchent la période
|
||||
final eventsQuery = await _eventsCollection
|
||||
.where('StartDateTime', isLessThanOrEqualTo: Timestamp.fromDate(endDate))
|
||||
.where('EndDateTime', isGreaterThanOrEqualTo: Timestamp.fromDate(startDate))
|
||||
.get();
|
||||
|
||||
for (var eventDoc in eventsQuery.docs) {
|
||||
final eventData = eventDoc.data() as Map<String, dynamic>;
|
||||
final assignedEquipmentRaw = eventData['assignedEquipment'] ?? [];
|
||||
|
||||
if (assignedEquipmentRaw is List) {
|
||||
for (var eq in assignedEquipmentRaw) {
|
||||
if (eq is Map && eq['equipmentId'] == equipmentId) {
|
||||
conflicts.add(eventDoc.id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return conflicts;
|
||||
} catch (e) {
|
||||
print('Error checking availability: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Trouver des alternatives (même modèle) disponibles
|
||||
Future<List<EquipmentModel>> findAlternatives(
|
||||
String model,
|
||||
DateTime startDate,
|
||||
DateTime endDate,
|
||||
) async {
|
||||
try {
|
||||
// Récupérer tous les équipements du même modèle
|
||||
final equipmentQuery = await _equipmentCollection
|
||||
.where('model', isEqualTo: model)
|
||||
.get();
|
||||
|
||||
final alternatives = <EquipmentModel>[];
|
||||
|
||||
for (var doc in equipmentQuery.docs) {
|
||||
final equipment = EquipmentModel.fromMap(
|
||||
doc.data() as Map<String, dynamic>,
|
||||
doc.id,
|
||||
);
|
||||
|
||||
// Vérifier la disponibilité
|
||||
final conflicts = await checkAvailability(equipment.id, startDate, endDate);
|
||||
|
||||
if (conflicts.isEmpty && equipment.status == EquipmentStatus.available) {
|
||||
alternatives.add(equipment);
|
||||
}
|
||||
}
|
||||
|
||||
return alternatives;
|
||||
} catch (e) {
|
||||
print('Error finding alternatives: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Mettre à jour le stock d'un consommable/câble
|
||||
Future<void> updateStock(String id, int quantityChange) async {
|
||||
try {
|
||||
final equipment = await getEquipmentById(id);
|
||||
if (equipment == null) {
|
||||
throw Exception('Equipment not found');
|
||||
}
|
||||
|
||||
if (!equipment.hasQuantity) {
|
||||
throw Exception('Equipment does not have quantity tracking');
|
||||
}
|
||||
|
||||
final newAvailableQuantity = (equipment.availableQuantity ?? 0) + quantityChange;
|
||||
|
||||
await updateEquipment(id, {
|
||||
'availableQuantity': newAvailableQuantity,
|
||||
});
|
||||
|
||||
// Vérifier si le seuil critique est atteint
|
||||
if (equipment.criticalThreshold != null &&
|
||||
newAvailableQuantity <= equipment.criticalThreshold!) {
|
||||
await _createLowStockAlert(equipment);
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error updating stock: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Vérifier les stocks critiques et créer des alertes
|
||||
Future<void> checkCriticalStock() async {
|
||||
try {
|
||||
final equipmentQuery = await _equipmentCollection
|
||||
.where('category', whereIn: [
|
||||
equipmentCategoryToString(EquipmentCategory.consumable),
|
||||
equipmentCategoryToString(EquipmentCategory.cable),
|
||||
])
|
||||
.get();
|
||||
|
||||
for (var doc in equipmentQuery.docs) {
|
||||
final equipment = EquipmentModel.fromMap(
|
||||
doc.data() as Map<String, dynamic>,
|
||||
doc.id,
|
||||
);
|
||||
|
||||
if (equipment.isCriticalStock) {
|
||||
await _createLowStockAlert(equipment);
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error checking critical stock: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Créer une alerte de stock faible
|
||||
Future<void> _createLowStockAlert(EquipmentModel equipment) async {
|
||||
try {
|
||||
// Vérifier si une alerte existe déjà pour cet équipement
|
||||
final existingAlerts = await _alertsCollection
|
||||
.where('equipmentId', isEqualTo: equipment.id)
|
||||
.where('type', isEqualTo: alertTypeToString(AlertType.lowStock))
|
||||
.where('isRead', isEqualTo: false)
|
||||
.get();
|
||||
|
||||
if (existingAlerts.docs.isEmpty) {
|
||||
final alert = AlertModel(
|
||||
id: _alertsCollection.doc().id,
|
||||
type: AlertType.lowStock,
|
||||
message: 'Stock critique pour ${equipment.name} (${equipment.model ?? ""}): ${equipment.availableQuantity}/${equipment.criticalThreshold}',
|
||||
equipmentId: equipment.id,
|
||||
createdAt: DateTime.now(),
|
||||
);
|
||||
|
||||
await _alertsCollection.doc(alert.id).set(alert.toMap());
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error creating low stock alert: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Générer les données du QR code (ID de l'équipement)
|
||||
String generateQRCodeData(String equipmentId) {
|
||||
// Pour l'instant, on retourne simplement l'ID
|
||||
// On pourrait aussi générer une URL complète : https://app.em2events.fr/equipment/$equipmentId
|
||||
return equipmentId;
|
||||
}
|
||||
|
||||
/// Récupérer tous les modèles uniques (pour l'indexation/autocomplete)
|
||||
Future<List<String>> getAllModels() async {
|
||||
try {
|
||||
final equipmentQuery = await _equipmentCollection.get();
|
||||
final models = <String>{};
|
||||
|
||||
for (var doc in equipmentQuery.docs) {
|
||||
final data = doc.data() as Map<String, dynamic>;
|
||||
final model = data['model'] as String?;
|
||||
if (model != null && model.isNotEmpty) {
|
||||
models.add(model);
|
||||
}
|
||||
}
|
||||
|
||||
return models.toList()..sort();
|
||||
} catch (e) {
|
||||
print('Error getting all models: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer toutes les marques uniques (pour l'indexation/autocomplete)
|
||||
Future<List<String>> getAllBrands() async {
|
||||
try {
|
||||
final equipmentQuery = await _equipmentCollection.get();
|
||||
final brands = <String>{};
|
||||
|
||||
for (var doc in equipmentQuery.docs) {
|
||||
final data = doc.data() as Map<String, dynamic>;
|
||||
final brand = data['brand'] as String?;
|
||||
if (brand != null && brand.isNotEmpty) {
|
||||
brands.add(brand);
|
||||
}
|
||||
}
|
||||
|
||||
return brands.toList()..sort();
|
||||
} catch (e) {
|
||||
print('Error getting all brands: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer les modèles filtrés par marque
|
||||
Future<List<String>> getModelsByBrand(String brand) async {
|
||||
try {
|
||||
final equipmentQuery = await _equipmentCollection
|
||||
.where('brand', isEqualTo: brand)
|
||||
.get();
|
||||
final models = <String>{};
|
||||
|
||||
for (var doc in equipmentQuery.docs) {
|
||||
final data = doc.data() as Map<String, dynamic>;
|
||||
final model = data['model'] as String?;
|
||||
if (model != null && model.isNotEmpty) {
|
||||
models.add(model);
|
||||
}
|
||||
}
|
||||
|
||||
return models.toList()..sort();
|
||||
} catch (e) {
|
||||
print('Error getting models by brand: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Vérifier si un ID existe déjà
|
||||
Future<bool> isIdUnique(String id) async {
|
||||
try {
|
||||
final doc = await _equipmentCollection.doc(id).get();
|
||||
return !doc.exists;
|
||||
} catch (e) {
|
||||
print('Error checking ID uniqueness: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer toutes les boîtes (équipements qui peuvent contenir d'autres équipements)
|
||||
Future<List<EquipmentModel>> getBoxes() async {
|
||||
try {
|
||||
// Les boîtes sont généralement des équipements de catégorie "structure" ou "other"
|
||||
// On pourrait aussi ajouter un champ spécifique "isBox" dans le modèle
|
||||
final equipmentQuery = await _equipmentCollection
|
||||
.where('category', whereIn: [
|
||||
equipmentCategoryToString(EquipmentCategory.structure),
|
||||
equipmentCategoryToString(EquipmentCategory.other),
|
||||
])
|
||||
.get();
|
||||
|
||||
final boxes = <EquipmentModel>[];
|
||||
for (var doc in equipmentQuery.docs) {
|
||||
final equipment = EquipmentModel.fromMap(
|
||||
doc.data() as Map<String, dynamic>,
|
||||
doc.id,
|
||||
);
|
||||
// On pourrait ajouter un filtre supplémentaire ici si besoin
|
||||
boxes.add(equipment);
|
||||
}
|
||||
|
||||
return boxes;
|
||||
} catch (e) {
|
||||
print('Error getting boxes: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
363
em2rp/lib/services/event_preparation_service.dart
Normal file
363
em2rp/lib/services/event_preparation_service.dart
Normal file
@@ -0,0 +1,363 @@
|
||||
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';
|
||||
|
||||
class EventPreparationService {
|
||||
final FirebaseFirestore _firestore = FirebaseFirestore.instance;
|
||||
final EquipmentService _equipmentService = EquipmentService();
|
||||
|
||||
// Collection references
|
||||
CollectionReference get _eventsCollection => _firestore.collection('events');
|
||||
CollectionReference get _equipmentCollection => _firestore.collection('equipment');
|
||||
|
||||
// === PRÉPARATION ===
|
||||
|
||||
/// 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();
|
||||
|
||||
await _eventsCollection.doc(eventId).update({
|
||||
'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
|
||||
});
|
||||
} catch (e) {
|
||||
print('Error validating equipment preparation: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// 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),
|
||||
});
|
||||
|
||||
// Mettre à jour le statut des équipements à "inUse"
|
||||
for (var equipment in event.assignedEquipment) {
|
||||
await updateEquipmentStatus(equipment.equipmentId, EquipmentStatus.inUse);
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error validating all preparation: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Finaliser la préparation avec des équipements manquants
|
||||
Future<void> completePreparationWithMissing(
|
||||
String eventId,
|
||||
List<String> missingEquipmentIds,
|
||||
) async {
|
||||
try {
|
||||
final event = await _getEvent(eventId);
|
||||
if (event == null) {
|
||||
throw Exception('Event not found');
|
||||
}
|
||||
|
||||
// Marquer comme complété avec manquants
|
||||
await _eventsCollection.doc(eventId).update({
|
||||
'preparationStatus': preparationStatusToString(PreparationStatus.completedWithMissing),
|
||||
});
|
||||
|
||||
// Mettre à jour le statut des équipements préparés à "inUse"
|
||||
for (var equipment in event.assignedEquipment) {
|
||||
if (equipment.isPrepared && !missingEquipmentIds.contains(equipment.equipmentId)) {
|
||||
await updateEquipmentStatus(equipment.equipmentId, EquipmentStatus.inUse);
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error completing preparation with missing: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
// === RETOUR ===
|
||||
|
||||
|
||||
/// Valider le retour d'un équipement individuel
|
||||
Future<void> validateEquipmentReturn(
|
||||
String eventId,
|
||||
String equipmentId, {
|
||||
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();
|
||||
|
||||
await _eventsCollection.doc(eventId).update({
|
||||
'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
|
||||
});
|
||||
|
||||
// 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,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error validating equipment return: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Valider tous les retours
|
||||
Future<void> validateAllReturn(String eventId) 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) {
|
||||
return eq.copyWith(
|
||||
isReturned: true,
|
||||
returnedQuantity: eq.returnedQuantity ?? eq.quantity,
|
||||
);
|
||||
}).toList();
|
||||
|
||||
await _eventsCollection.doc(eventId).update({
|
||||
'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
|
||||
'returnStatus': returnStatusToString(ReturnStatus.completed),
|
||||
});
|
||||
|
||||
// Mettre à jour le statut des équipements à "available" et gérer les stocks
|
||||
for (var equipment in updatedEquipment) {
|
||||
await updateEquipmentStatus(equipment.equipmentId, EquipmentStatus.available);
|
||||
|
||||
// Restaurer le stock pour les consommables
|
||||
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 && equipment.returnedQuantity != null) {
|
||||
final currentAvailable = equipmentData.availableQuantity ?? 0;
|
||||
await _equipmentCollection.doc(equipment.equipmentId).update({
|
||||
'availableQuantity': currentAvailable + equipment.returnedQuantity!,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error validating all return: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Finaliser le retour avec des équipements manquants
|
||||
Future<void> completeReturnWithMissing(
|
||||
String eventId,
|
||||
List<String> missingEquipmentIds,
|
||||
) async {
|
||||
try {
|
||||
final event = await _getEvent(eventId);
|
||||
if (event == null) {
|
||||
throw Exception('Event not found');
|
||||
}
|
||||
|
||||
// Marquer comme complété avec manquants
|
||||
await _eventsCollection.doc(eventId).update({
|
||||
'returnStatus': returnStatusToString(ReturnStatus.completedWithMissing),
|
||||
});
|
||||
|
||||
// Mettre à jour le statut des équipements retournés à "available"
|
||||
for (var equipment in event.assignedEquipment) {
|
||||
if (equipment.isReturned && !missingEquipmentIds.contains(equipment.equipmentId)) {
|
||||
await updateEquipmentStatus(equipment.equipmentId, EquipmentStatus.available);
|
||||
|
||||
// Restaurer le stock pour les consommables
|
||||
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 && equipment.returnedQuantity != null) {
|
||||
final currentAvailable = equipmentData.availableQuantity ?? 0;
|
||||
await _equipmentCollection.doc(equipment.equipmentId).update({
|
||||
'availableQuantity': currentAvailable + equipment.returnedQuantity!,
|
||||
});
|
||||
}
|
||||
}
|
||||
} else if (missingEquipmentIds.contains(equipment.equipmentId)) {
|
||||
// Marquer comme perdu
|
||||
await updateEquipmentStatus(equipment.equipmentId, EquipmentStatus.lost);
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error completing return with missing: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
// === HELPERS ===
|
||||
|
||||
/// Mettre à jour le statut d'un équipement
|
||||
Future<void> updateEquipmentStatus(String equipmentId, EquipmentStatus status) async {
|
||||
try {
|
||||
await _equipmentCollection.doc(equipmentId).update({
|
||||
'status': equipmentStatusToString(status),
|
||||
'updatedAt': Timestamp.fromDate(DateTime.now()),
|
||||
});
|
||||
} catch (e) {
|
||||
print('Error updating equipment status: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer un événement
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
/// Ajouter un équipement à un événement
|
||||
Future<void> addEquipmentToEvent(
|
||||
String eventId,
|
||||
String equipmentId, {
|
||||
int quantity = 1,
|
||||
}) async {
|
||||
try {
|
||||
final event = await _getEvent(eventId);
|
||||
if (event == null) {
|
||||
throw Exception('Event not found');
|
||||
}
|
||||
|
||||
// Vérifier que l'équipement n'est pas déjà ajouté
|
||||
final alreadyAdded = event.assignedEquipment.any((eq) => eq.equipmentId == equipmentId);
|
||||
if (alreadyAdded) {
|
||||
throw Exception('Equipment already added to event');
|
||||
}
|
||||
|
||||
final newEquipment = EventEquipment(
|
||||
equipmentId: equipmentId,
|
||||
quantity: quantity,
|
||||
);
|
||||
|
||||
final updatedEquipment = [...event.assignedEquipment, newEquipment];
|
||||
|
||||
await _eventsCollection.doc(eventId).update({
|
||||
'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
|
||||
});
|
||||
|
||||
// Décrémenter le stock pour les consommables
|
||||
final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
|
||||
if (equipmentDoc.exists) {
|
||||
final equipmentData = EquipmentModel.fromMap(
|
||||
equipmentDoc.data() as Map<String, dynamic>,
|
||||
equipmentDoc.id,
|
||||
);
|
||||
|
||||
if (equipmentData.hasQuantity) {
|
||||
final currentAvailable = equipmentData.availableQuantity ?? 0;
|
||||
await _equipmentCollection.doc(equipmentId).update({
|
||||
'availableQuantity': currentAvailable - quantity,
|
||||
});
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error adding equipment to event: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Retirer un équipement d'un événement
|
||||
Future<void> removeEquipmentFromEvent(String eventId, String equipmentId) async {
|
||||
try {
|
||||
final event = await _getEvent(eventId);
|
||||
if (event == null) {
|
||||
throw Exception('Event not found');
|
||||
}
|
||||
|
||||
final equipmentToRemove = event.assignedEquipment.firstWhere(
|
||||
(eq) => eq.equipmentId == equipmentId,
|
||||
);
|
||||
|
||||
final updatedEquipment = event.assignedEquipment
|
||||
.where((eq) => eq.equipmentId != equipmentId)
|
||||
.toList();
|
||||
|
||||
await _eventsCollection.doc(eventId).update({
|
||||
'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
|
||||
});
|
||||
|
||||
// Restaurer le stock pour les consommables
|
||||
final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
|
||||
if (equipmentDoc.exists) {
|
||||
final equipmentData = EquipmentModel.fromMap(
|
||||
equipmentDoc.data() as Map<String, dynamic>,
|
||||
equipmentDoc.id,
|
||||
);
|
||||
|
||||
if (equipmentData.hasQuantity) {
|
||||
final currentAvailable = equipmentData.availableQuantity ?? 0;
|
||||
await _equipmentCollection.doc(equipmentId).update({
|
||||
'availableQuantity': currentAvailable + equipmentToRemove.quantity,
|
||||
});
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error removing equipment from event: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
}
|
||||
281
em2rp/lib/services/maintenance_service.dart
Normal file
281
em2rp/lib/services/maintenance_service.dart
Normal file
@@ -0,0 +1,281 @@
|
||||
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';
|
||||
|
||||
class MaintenanceService {
|
||||
final FirebaseFirestore _firestore = FirebaseFirestore.instance;
|
||||
final EquipmentService _equipmentService = EquipmentService();
|
||||
|
||||
// Collection references
|
||||
CollectionReference get _maintenancesCollection => _firestore.collection('maintenances');
|
||||
CollectionReference get _equipmentCollection => _firestore.collection('equipment');
|
||||
CollectionReference get _alertsCollection => _firestore.collection('alerts');
|
||||
|
||||
// CRUD Operations
|
||||
|
||||
/// Créer une nouvelle maintenance
|
||||
Future<void> createMaintenance(MaintenanceModel maintenance) async {
|
||||
try {
|
||||
await _maintenancesCollection.doc(maintenance.id).set(maintenance.toMap());
|
||||
|
||||
// Mettre à jour les équipements concernés
|
||||
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);
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error creating maintenance: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Mettre à jour une maintenance
|
||||
Future<void> updateMaintenance(String id, Map<String, dynamic> data) async {
|
||||
try {
|
||||
data['updatedAt'] = Timestamp.fromDate(DateTime.now());
|
||||
await _maintenancesCollection.doc(id).update(data);
|
||||
} catch (e) {
|
||||
print('Error updating maintenance: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// 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();
|
||||
} catch (e) {
|
||||
print('Error deleting maintenance: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer une maintenance par ID
|
||||
Future<MaintenanceModel?> getMaintenanceById(String id) async {
|
||||
try {
|
||||
final doc = await _maintenancesCollection.doc(id).get();
|
||||
if (doc.exists) {
|
||||
return MaintenanceModel.fromMap(doc.data() as Map<String, dynamic>, doc.id);
|
||||
}
|
||||
return null;
|
||||
} catch (e) {
|
||||
print('Error getting maintenance: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer l'historique des maintenances pour un équipement
|
||||
Stream<List<MaintenanceModel>> getMaintenances(String equipmentId) {
|
||||
try {
|
||||
return _maintenancesCollection
|
||||
.where('equipmentIds', arrayContains: equipmentId)
|
||||
.orderBy('scheduledDate', descending: true)
|
||||
.snapshots()
|
||||
.map((snapshot) {
|
||||
return snapshot.docs
|
||||
.map((doc) => MaintenanceModel.fromMap(
|
||||
doc.data() as Map<String, dynamic>,
|
||||
doc.id,
|
||||
))
|
||||
.toList();
|
||||
});
|
||||
} catch (e) {
|
||||
print('Error streaming maintenances: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer toutes les maintenances
|
||||
Stream<List<MaintenanceModel>> getAllMaintenances() {
|
||||
try {
|
||||
return _maintenancesCollection
|
||||
.orderBy('scheduledDate', descending: true)
|
||||
.snapshots()
|
||||
.map((snapshot) {
|
||||
return snapshot.docs
|
||||
.map((doc) => MaintenanceModel.fromMap(
|
||||
doc.data() as Map<String, dynamic>,
|
||||
doc.id,
|
||||
))
|
||||
.toList();
|
||||
});
|
||||
} catch (e) {
|
||||
print('Error streaming all maintenances: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Marquer une maintenance comme complétée
|
||||
Future<void> completeMaintenance(String id, {String? performedBy, double? cost}) async {
|
||||
try {
|
||||
final updateData = <String, dynamic>{
|
||||
'completedDate': Timestamp.fromDate(DateTime.now()),
|
||||
'updatedAt': Timestamp.fromDate(DateTime.now()),
|
||||
};
|
||||
|
||||
if (performedBy != null) {
|
||||
updateData['performedBy'] = performedBy;
|
||||
}
|
||||
|
||||
if (cost != null) {
|
||||
updateData['cost'] = cost;
|
||||
}
|
||||
|
||||
await updateMaintenance(id, updateData);
|
||||
|
||||
// Mettre à jour la date de dernière maintenance des équipements
|
||||
final maintenance = await getMaintenanceById(id);
|
||||
if (maintenance != null) {
|
||||
for (String equipmentId in maintenance.equipmentIds) {
|
||||
await _equipmentCollection.doc(equipmentId).update({
|
||||
'lastMaintenanceDate': Timestamp.fromDate(DateTime.now()),
|
||||
});
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error completing maintenance: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Vérifier les maintenances à venir et créer des alertes
|
||||
Future<void> checkUpcomingMaintenances() async {
|
||||
try {
|
||||
final sevenDaysFromNow = DateTime.now().add(const Duration(days: 7));
|
||||
|
||||
// Récupérer les maintenances planifiées dans les 7 prochains jours
|
||||
final maintenancesQuery = await _maintenancesCollection
|
||||
.where('scheduledDate', isLessThanOrEqualTo: Timestamp.fromDate(sevenDaysFromNow))
|
||||
.where('completedDate', isNull: true)
|
||||
.get();
|
||||
|
||||
for (var doc in maintenancesQuery.docs) {
|
||||
final maintenance = MaintenanceModel.fromMap(
|
||||
doc.data() as Map<String, dynamic>,
|
||||
doc.id,
|
||||
);
|
||||
|
||||
for (String equipmentId in maintenance.equipmentIds) {
|
||||
await _createMaintenanceAlert(equipmentId, maintenance);
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error checking upcoming maintenances: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Créer une alerte de maintenance à venir
|
||||
Future<void> _createMaintenanceAlert(String equipmentId, MaintenanceModel maintenance) async {
|
||||
try {
|
||||
// Vérifier si une alerte existe déjà
|
||||
final existingAlerts = await _alertsCollection
|
||||
.where('equipmentId', isEqualTo: equipmentId)
|
||||
.where('type', isEqualTo: alertTypeToString(AlertType.maintenanceDue))
|
||||
.where('isRead', isEqualTo: false)
|
||||
.get();
|
||||
|
||||
// Vérifier si l'alerte concerne la même maintenance
|
||||
bool alertExists = false;
|
||||
for (var alertDoc in existingAlerts.docs) {
|
||||
final alertData = alertDoc.data() as Map<String, dynamic>;
|
||||
if (alertData['message']?.contains(maintenance.name) ?? false) {
|
||||
alertExists = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!alertExists) {
|
||||
// Récupérer l'équipement pour le nom
|
||||
final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
|
||||
String equipmentName = equipmentId;
|
||||
if (equipmentDoc.exists) {
|
||||
final equipmentData = equipmentDoc.data() as Map<String, dynamic>;
|
||||
equipmentName = equipmentData['name'] ?? equipmentId;
|
||||
}
|
||||
|
||||
final daysUntil = maintenance.scheduledDate.difference(DateTime.now()).inDays;
|
||||
final alert = AlertModel(
|
||||
id: _alertsCollection.doc().id,
|
||||
type: AlertType.maintenanceDue,
|
||||
message: 'Maintenance "${maintenance.name}" prévue dans $daysUntil jour(s) pour $equipmentName',
|
||||
equipmentId: equipmentId,
|
||||
createdAt: DateTime.now(),
|
||||
);
|
||||
|
||||
await _alertsCollection.doc(alert.id).set(alert.toMap());
|
||||
}
|
||||
} catch (e) {
|
||||
print('Error creating maintenance alert: $e');
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user