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

feat: ajout de la gestion de la préparation d'un événement avec page permettant de le gérer

Browse Source
This commit is contained in:
ElPoyo
2026-01-06 10:53:23 +01:00
parent fa1d6a4295
commit 25d395b41a
18 changed files with 2121 additions and 500 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
em2rp/lib/services/event_availability_service.dart
View File

@@ -1,6 +1,15 @@
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';
/// Type de conflit
enum ConflictType {
equipmentUnavailable, // Équipement non quantifiable utilisé
insufficientQuantity, // Quantité insuffisante pour consommable/câble
containerFullyUsed, // Boîte complète utilisée
containerPartiallyUsed, // Certains équipements de la boîte utilisés
}
/// Informations sur un conflit de disponibilité
class AvailabilityConflict {
@@ -8,13 +17,48 @@ class AvailabilityConflict {
final String equipmentName;
final EventModel conflictingEvent;
final int overlapDays;
final ConflictType type;
// Pour les quantités (consommables/câbles)
final int? totalQuantity;
final int? availableQuantity;
final int? requestedQuantity;
final int? reservedQuantity;
// Pour les boîtes
final String? containerId;
final String? containerName;
final List<String>? conflictingChildrenIds;
AvailabilityConflict({
required this.equipmentId,
required this.equipmentName,
required this.conflictingEvent,
required this.overlapDays,
this.type = ConflictType.equipmentUnavailable,
this.totalQuantity,
this.availableQuantity,
this.requestedQuantity,
this.reservedQuantity,
this.containerId,
this.containerName,
this.conflictingChildrenIds,
});
/// Message descriptif du conflit
String get conflictMessage {
switch (type) {
case ConflictType.equipmentUnavailable:
return 'Équipement déjà utilisé';
case ConflictType.insufficientQuantity:
return 'Stock insuffisant : $availableQuantity/$totalQuantity disponible (demandé: $requestedQuantity)';
case ConflictType.containerFullyUsed:
return 'Boîte complète déjà utilisée';
case ConflictType.containerPartiallyUsed:
final count = conflictingChildrenIds?.length ?? 0;
return '$count équipement(s) de la boîte déjà utilisé(s)';
}
}
}
/// Service pour vérifier la disponibilité du matériel
@@ -32,21 +76,22 @@ class EventAvailabilityService {
final conflicts = <AvailabilityConflict>[];
try {
print('[EventAvailabilityService] Checking availability for equipment: $equipmentId');
print('[EventAvailabilityService] Date range: $startDate - $endDate');
// Récupérer TOUS les événements (on filtre côté client car arrayContains avec objet ne marche pas)
final eventsSnapshot = await _firestore.collection('events').get();
print('[EventAvailabilityService] Found ${eventsSnapshot.docs.length} total events');
for (var doc in eventsSnapshot.docs) {
if (excludeEventId != null && doc.id == excludeEventId) {
continue; // Ignorer l'événement en cours d'édition
}
try {
final event = EventModel.fromMap(doc.data(), doc.id);
final data = doc.data();
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(
@@ -54,21 +99,26 @@ class EventAvailabilityService {
orElse: () => EventEquipment(equipmentId: ''),
);
// Si l'équipement est assigné et non retourné
if (assignedEquipment.equipmentId.isNotEmpty && !assignedEquipment.isReturned) {
print('[EventAvailabilityService] Equipment $equipmentId found in event: ${event.name}');
// 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, event.startDateTime, event.endDateTime)) {
if (_datesOverlap(startDate, endDate, eventRealStartDate, eventRealEndDate)) {
final overlapDays = _calculateOverlapDays(
startDate,
endDate,
event.startDateTime,
event.endDateTime,
eventRealStartDate,
eventRealEndDate,
);
print('[EventAvailabilityService] CONFLICT detected! Overlap: $overlapDays days');
conflicts.add(AvailabilityConflict(
equipmentId: equipmentId,
equipmentName: equipmentName,
@@ -81,15 +131,18 @@ class EventAvailabilityService {
print('[EventAvailabilityService] Error processing event ${doc.id}: $e');
}
}
print('[EventAvailabilityService] Total conflicts found for $equipmentId: ${conflicts.length}');
} catch (e) {
print('[EventAvailabilityService] Error checking equipment availability: $e');
print('[EventAvailabilityService] Error checking availability: $e');
}
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,
@@ -114,6 +167,7 @@ class EventAvailabilityService {
}
}
return allConflicts;
}
@@ -160,14 +214,29 @@ class EventAvailabilityService {
try {
final event = EventModel.fromMap(doc.data(), doc.id);
// Ignorer les événements annulés
if (event.status == EventStatus.canceled) {
continue;
}
// 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, event.startDateTime, event.endDateTime)) {
if (_datesOverlap(startDate, endDate, eventRealStartDate, eventRealEndDate)) {
final assignedEquipment = event.assignedEquipment.firstWhere(
(eq) => eq.equipmentId == equipment.id,
orElse: () => EventEquipment(equipmentId: ''),
);
if (assignedEquipment.equipmentId.isNotEmpty && !assignedEquipment.isReturned) {
// Si l'équipement est assigné, réserver la quantité
// (peu importe le statut de préparation/retour)
if (assignedEquipment.equipmentId.isNotEmpty) {
reservedQuantity += assignedEquipment.quantity;
}
}
@@ -181,5 +250,179 @@ class EventAvailabilityService {
return totalQuantity - reservedQuantity;
}
/// Vérifie la disponibilité d'un équipement avec gestion des quantités
Future<List<AvailabilityConflict>> checkEquipmentAvailabilityWithQuantity({
required EquipmentModel equipment,
required int requestedQuantity,
required DateTime startDate,
required DateTime endDate,
String? excludeEventId,
}) async {
final conflicts = <AvailabilityConflict>[];
// Si équipement quantifiable (consommable/câble)
if (equipment.hasQuantity) {
final totalQuantity = equipment.totalQuantity ?? 0;
final availableQty = await getAvailableQuantity(
equipment: equipment,
startDate: startDate,
endDate: endDate,
excludeEventId: excludeEventId,
);
final reservedQty = totalQuantity - availableQty;
// ✅ 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();
for (var doc in eventsSnapshot.docs) {
if (excludeEventId != null && doc.id == excludeEventId) continue;
try {
final event = EventModel.fromMap(doc.data(), doc.id);
if (_datesOverlap(startDate, endDate, event.startDateTime, event.endDateTime)) {
final assignedEquipment = event.assignedEquipment.firstWhere(
(eq) => eq.equipmentId == equipment.id,
orElse: () => EventEquipment(equipmentId: ''),
);
if (assignedEquipment.equipmentId.isNotEmpty && !assignedEquipment.isReturned) {
conflicts.add(AvailabilityConflict(
equipmentId: equipment.id,
equipmentName: equipment.name,
conflictingEvent: event,
overlapDays: _calculateOverlapDays(startDate, endDate, event.startDateTime, event.endDateTime),
type: ConflictType.insufficientQuantity,
totalQuantity: totalQuantity,
availableQuantity: availableQty,
requestedQuantity: requestedQuantity,
reservedQuantity: reservedQty,
));
}
}
} catch (e) {
print('[EventAvailabilityService] Error processing event ${doc.id}: $e');
}
}
}
} else {
// Équipement non quantifiable : vérification classique
return await checkEquipmentAvailability(
equipmentId: equipment.id,
equipmentName: equipment.name,
startDate: startDate,
endDate: endDate,
excludeEventId: excludeEventId,
);
}
return conflicts;
}
/// Vérifie la disponibilité d'une boîte et de son contenu
Future<List<AvailabilityConflict>> checkContainerAvailability({
required ContainerModel container,
required List<EquipmentModel> containerEquipment,
required DateTime startDate,
required DateTime endDate,
String? excludeEventId,
}) async {
final conflicts = <AvailabilityConflict>[];
final conflictingChildrenIds = <String>[];
// Vérifier d'abord si la boîte complète est utilisée
final eventsSnapshot = await _firestore.collection('events').get();
bool isContainerFullyUsed = false;
EventModel? containerConflictingEvent;
for (var doc in eventsSnapshot.docs) {
if (excludeEventId != null && doc.id == excludeEventId) continue;
try {
final event = EventModel.fromMap(doc.data(), doc.id);
// Ignorer les événements annulés
if (event.status == EventStatus.canceled) {
continue;
}
// 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 si cette boîte est assignée
if (event.assignedContainers.contains(container.id)) {
if (_datesOverlap(startDate, endDate, eventRealStartDate, eventRealEndDate)) {
isContainerFullyUsed = true;
containerConflictingEvent = event;
break;
}
}
} catch (e) {
print('[EventAvailabilityService] Error processing event ${doc.id}: $e');
}
}
if (isContainerFullyUsed && containerConflictingEvent != null) {
// Boîte complète utilisée
conflicts.add(AvailabilityConflict(
equipmentId: container.id,
equipmentName: container.name,
conflictingEvent: containerConflictingEvent,
overlapDays: _calculateOverlapDays(
startDate,
endDate,
containerConflictingEvent.startDateTime,
containerConflictingEvent.endDateTime,
),
type: ConflictType.containerFullyUsed,
containerId: container.id,
containerName: container.name,
));
} else {
// Vérifier chaque équipement enfant individuellement
for (var equipment in containerEquipment) {
final equipmentConflicts = await checkEquipmentAvailability(
equipmentId: equipment.id,
equipmentName: equipment.name,
startDate: startDate,
endDate: endDate,
excludeEventId: excludeEventId,
);
if (equipmentConflicts.isNotEmpty) {
conflictingChildrenIds.add(equipment.id);
conflicts.addAll(equipmentConflicts);
}
}
// Si au moins un enfant en conflit, ajouter un conflit pour la boîte
if (conflictingChildrenIds.isNotEmpty && conflicts.isNotEmpty) {
conflicts.insert(
0,
AvailabilityConflict(
equipmentId: container.id,
equipmentName: container.name,
conflictingEvent: conflicts.first.conflictingEvent,
overlapDays: conflicts.first.overlapDays,
type: ConflictType.containerPartiallyUsed,
containerId: container.id,
containerName: container.name,
conflictingChildrenIds: conflictingChildrenIds,
),
);
}
}
return conflicts;
}
}