df6d54a007
Centralise la gestion des libellés, couleurs et icônes pour `EquipmentStatus`, `EquipmentCategory`, et `ContainerType` en utilisant des extensions Dart. - Ajout de nouvelles icônes SVG pour `flight-case`, `truss` et `tape`. - Refactorisation des vues pour utiliser les nouvelles extensions, supprimant ainsi la logique d'affichage dupliquée. - Mise à jour des `ChoiceChip` et des listes de filtres pour afficher les icônes à côté des labels.
473 lines
15 KiB
Dart
473 lines
15 KiB
Dart
import 'package:cloud_firestore/cloud_firestore.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_svg/flutter_svg.dart';
|
|
|
|
enum EquipmentStatus {
|
|
available, // Disponible
|
|
inUse, // En prestation
|
|
rented, // Loué
|
|
lost, // Perdu
|
|
outOfService, // HS
|
|
maintenance, // En maintenance
|
|
}
|
|
|
|
String equipmentStatusToString(EquipmentStatus status) {
|
|
switch (status) {
|
|
case EquipmentStatus.available:
|
|
return 'AVAILABLE';
|
|
case EquipmentStatus.inUse:
|
|
return 'IN_USE';
|
|
case EquipmentStatus.rented:
|
|
return 'RENTED';
|
|
case EquipmentStatus.lost:
|
|
return 'LOST';
|
|
case EquipmentStatus.outOfService:
|
|
return 'OUT_OF_SERVICE';
|
|
case EquipmentStatus.maintenance:
|
|
return 'MAINTENANCE';
|
|
}
|
|
}
|
|
|
|
EquipmentStatus equipmentStatusFromString(String? status) {
|
|
switch (status) {
|
|
case 'AVAILABLE':
|
|
return EquipmentStatus.available;
|
|
case 'IN_USE':
|
|
return EquipmentStatus.inUse;
|
|
case 'RENTED':
|
|
return EquipmentStatus.rented;
|
|
case 'LOST':
|
|
return EquipmentStatus.lost;
|
|
case 'OUT_OF_SERVICE':
|
|
return EquipmentStatus.outOfService;
|
|
case 'MAINTENANCE':
|
|
return EquipmentStatus.maintenance;
|
|
default:
|
|
return EquipmentStatus.available;
|
|
}
|
|
}
|
|
|
|
enum EquipmentCategory {
|
|
lighting, // Lumière
|
|
sound, // Son
|
|
video, // Vidéo
|
|
effect, // Effets spéciaux
|
|
structure, // Structure
|
|
consumable, // Consommable
|
|
cable, // Câble
|
|
other // Autre
|
|
}
|
|
|
|
String equipmentCategoryToString(EquipmentCategory category) {
|
|
switch (category) {
|
|
case EquipmentCategory.lighting:
|
|
return 'LIGHTING';
|
|
case EquipmentCategory.sound:
|
|
return 'SOUND';
|
|
case EquipmentCategory.video:
|
|
return 'VIDEO';
|
|
case EquipmentCategory.structure:
|
|
return 'STRUCTURE';
|
|
case EquipmentCategory.consumable:
|
|
return 'CONSUMABLE';
|
|
case EquipmentCategory.cable:
|
|
return 'CABLE';
|
|
case EquipmentCategory.other:
|
|
return 'OTHER';
|
|
case EquipmentCategory.effect:
|
|
return 'EFFECT';
|
|
}
|
|
}
|
|
|
|
EquipmentCategory equipmentCategoryFromString(String? category) {
|
|
switch (category) {
|
|
case 'LIGHTING':
|
|
return EquipmentCategory.lighting;
|
|
case 'SOUND':
|
|
return EquipmentCategory.sound;
|
|
case 'VIDEO':
|
|
return EquipmentCategory.video;
|
|
case 'STRUCTURE':
|
|
return EquipmentCategory.structure;
|
|
case 'CONSUMABLE':
|
|
return EquipmentCategory.consumable;
|
|
case 'CABLE':
|
|
return EquipmentCategory.cable;
|
|
case 'EFFECT':
|
|
return EquipmentCategory.effect;
|
|
case 'OTHER':
|
|
default:
|
|
return EquipmentCategory.other;
|
|
}
|
|
}
|
|
|
|
// Extensions pour centraliser les informations d'affichage
|
|
extension EquipmentCategoryExtension on EquipmentCategory {
|
|
/// Retourne le label français de la catégorie
|
|
String get label {
|
|
switch (this) {
|
|
case EquipmentCategory.lighting:
|
|
return 'Lumière';
|
|
case EquipmentCategory.sound:
|
|
return 'Son';
|
|
case EquipmentCategory.video:
|
|
return 'Vidéo';
|
|
case EquipmentCategory.effect:
|
|
return 'Effets';
|
|
case EquipmentCategory.structure:
|
|
return 'Structure';
|
|
case EquipmentCategory.consumable:
|
|
return 'Consommable';
|
|
case EquipmentCategory.cable:
|
|
return 'Câble';
|
|
case EquipmentCategory.other:
|
|
return 'Autre';
|
|
}
|
|
}
|
|
|
|
/// Retourne l'icône Material de la catégorie
|
|
IconData get iconData {
|
|
switch (this) {
|
|
case EquipmentCategory.lighting:
|
|
return Icons.light_mode;
|
|
case EquipmentCategory.sound:
|
|
return Icons.volume_up;
|
|
case EquipmentCategory.video:
|
|
return Icons.videocam;
|
|
case EquipmentCategory.effect:
|
|
return Icons.auto_awesome;
|
|
case EquipmentCategory.structure:
|
|
return Icons.construction;
|
|
case EquipmentCategory.consumable:
|
|
return Icons.inventory_2;
|
|
case EquipmentCategory.cable:
|
|
return Icons.cable;
|
|
case EquipmentCategory.other:
|
|
return Icons.more_horiz;
|
|
}
|
|
}
|
|
|
|
/// Retourne le chemin de l'icône personnalisée (si disponible)
|
|
String? get customIconPath {
|
|
switch (this) {
|
|
case EquipmentCategory.structure:
|
|
return 'assets/icons/truss.svg';
|
|
case EquipmentCategory.consumable:
|
|
return 'assets/icons/tape.svg';
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// Vérifie si une icône personnalisée est disponible
|
|
bool get hasCustomIcon => customIconPath != null;
|
|
|
|
/// Retourne l'icône Widget à afficher (unifié pour Material et personnalisé)
|
|
Widget getIcon({double size = 24, Color? color}) {
|
|
final customPath = customIconPath;
|
|
if (customPath != null) {
|
|
// Détection automatique du format (SVG ou PNG)
|
|
final isSvg = customPath.toLowerCase().endsWith('.svg');
|
|
|
|
if (isSvg) {
|
|
// SVG : on peut appliquer la couleur sans dégrader la qualité
|
|
return SvgPicture.asset(
|
|
customPath,
|
|
width: size,
|
|
height: size,
|
|
colorFilter: color != null
|
|
? ColorFilter.mode(color, BlendMode.srcIn)
|
|
: null,
|
|
placeholderBuilder: (context) => Icon(iconData, size: size, color: color),
|
|
);
|
|
} else {
|
|
// PNG : on n'applique PAS le color filter pour préserver la qualité
|
|
return Image.asset(
|
|
customPath,
|
|
width: size,
|
|
height: size,
|
|
filterQuality: FilterQuality.high,
|
|
errorBuilder: (context, error, stackTrace) {
|
|
return Icon(iconData, size: size, color: color);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
return Icon(iconData, size: size, color: color);
|
|
}
|
|
|
|
/// Version pour CircleAvatar et contextes similaires (sans ColorFilter si Material Icon)
|
|
Widget getIconForAvatar({double size = 24, Color? color}) {
|
|
final customPath = customIconPath;
|
|
if (customPath != null) {
|
|
final isSvg = customPath.toLowerCase().endsWith('.svg');
|
|
|
|
if (isSvg) {
|
|
return SvgPicture.asset(
|
|
customPath,
|
|
width: size,
|
|
height: size,
|
|
colorFilter: color != null
|
|
? ColorFilter.mode(color, BlendMode.srcIn)
|
|
: null,
|
|
placeholderBuilder: (context) => Icon(iconData, size: size, color: color),
|
|
);
|
|
} else {
|
|
return Image.asset(
|
|
customPath,
|
|
width: size,
|
|
height: size,
|
|
filterQuality: FilterQuality.high,
|
|
errorBuilder: (context, error, stackTrace) {
|
|
return Icon(iconData, size: size, color: color);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
return Icon(iconData, size: size, color: color);
|
|
}
|
|
}
|
|
|
|
extension EquipmentStatusExtension on EquipmentStatus {
|
|
/// Retourne le label français du statut
|
|
String get label {
|
|
switch (this) {
|
|
case EquipmentStatus.available:
|
|
return 'Disponible';
|
|
case EquipmentStatus.inUse:
|
|
return 'En prestation';
|
|
case EquipmentStatus.rented:
|
|
return 'Loué';
|
|
case EquipmentStatus.lost:
|
|
return 'Perdu';
|
|
case EquipmentStatus.outOfService:
|
|
return 'HS';
|
|
case EquipmentStatus.maintenance:
|
|
return 'Maintenance';
|
|
}
|
|
}
|
|
|
|
/// Retourne la couleur associée au statut
|
|
Color get color {
|
|
switch (this) {
|
|
case EquipmentStatus.available:
|
|
return Colors.green;
|
|
case EquipmentStatus.inUse:
|
|
return Colors.blue;
|
|
case EquipmentStatus.rented:
|
|
return Colors.orange;
|
|
case EquipmentStatus.lost:
|
|
return Colors.red;
|
|
case EquipmentStatus.outOfService:
|
|
return Colors.red.shade900;
|
|
case EquipmentStatus.maintenance:
|
|
return Colors.amber;
|
|
}
|
|
}
|
|
}
|
|
|
|
class EquipmentModel {
|
|
final String id; // Identifiant unique (clé)
|
|
final String name; // Nom de l'équipement
|
|
final String? brand; // Marque (indexé)
|
|
final String? model; // Modèle (indexé)
|
|
final EquipmentCategory category; // Catégorie
|
|
final EquipmentStatus status; // Statut actuel
|
|
|
|
// Prix (visible uniquement avec manage_equipment)
|
|
final double? purchasePrice; // Prix d'achat
|
|
final double? rentalPrice; // Prix de location
|
|
|
|
// Quantité (pour consommables/câbles)
|
|
final int? totalQuantity; // Quantité totale
|
|
final int? availableQuantity; // Quantité disponible
|
|
final int? criticalThreshold; // Seuil critique pour alerte
|
|
|
|
// Boîtes parentes (plusieurs possibles)
|
|
final List<String> parentBoxIds; // IDs des boîtes contenant cet équipement
|
|
|
|
// Caractéristiques physiques
|
|
final double? weight; // Poids (kg)
|
|
final double? length; // Longueur (cm)
|
|
final double? width; // Largeur (cm)
|
|
final double? height; // Hauteur (cm)
|
|
|
|
// Dates & maintenance
|
|
final DateTime? purchaseDate; // Date d'achat
|
|
final DateTime? lastMaintenanceDate; // Dernière maintenance
|
|
final DateTime? nextMaintenanceDate; // Prochaine maintenance prévue
|
|
|
|
// Maintenances (références)
|
|
final List<String> maintenanceIds; // IDs des opérations de maintenance
|
|
|
|
// Image
|
|
final String? imageUrl; // URL de l'image (Storage /materiel)
|
|
|
|
// Métadonnées
|
|
final String? notes; // Notes additionnelles
|
|
final DateTime createdAt; // Date de création
|
|
final DateTime updatedAt; // Date de mise à jour
|
|
|
|
EquipmentModel({
|
|
required this.id,
|
|
required this.name,
|
|
this.brand,
|
|
this.model,
|
|
required this.category,
|
|
this.status = EquipmentStatus.available,
|
|
this.purchasePrice,
|
|
this.rentalPrice,
|
|
this.totalQuantity,
|
|
this.availableQuantity,
|
|
this.criticalThreshold,
|
|
this.parentBoxIds = const [],
|
|
this.weight,
|
|
this.length,
|
|
this.width,
|
|
this.height,
|
|
this.purchaseDate,
|
|
this.lastMaintenanceDate,
|
|
this.nextMaintenanceDate,
|
|
this.maintenanceIds = const [],
|
|
this.imageUrl,
|
|
this.notes,
|
|
required this.createdAt,
|
|
required this.updatedAt,
|
|
});
|
|
|
|
factory EquipmentModel.fromMap(Map<String, dynamic> map, String id) {
|
|
// Gestion des listes
|
|
final List<dynamic> parentBoxIdsRaw = map['parentBoxIds'] ?? [];
|
|
final List<String> parentBoxIds = parentBoxIdsRaw.map((e) => e.toString()).toList();
|
|
|
|
final List<dynamic> maintenanceIdsRaw = map['maintenanceIds'] ?? [];
|
|
final List<String> maintenanceIds = maintenanceIdsRaw.map((e) => e.toString()).toList();
|
|
|
|
return EquipmentModel(
|
|
id: id,
|
|
name: map['name'] ?? '',
|
|
brand: map['brand'],
|
|
model: map['model'],
|
|
category: equipmentCategoryFromString(map['category']),
|
|
status: equipmentStatusFromString(map['status']),
|
|
purchasePrice: map['purchasePrice']?.toDouble(),
|
|
rentalPrice: map['rentalPrice']?.toDouble(),
|
|
totalQuantity: map['totalQuantity']?.toInt(),
|
|
availableQuantity: map['availableQuantity']?.toInt(),
|
|
criticalThreshold: map['criticalThreshold']?.toInt(),
|
|
parentBoxIds: parentBoxIds,
|
|
weight: map['weight']?.toDouble(),
|
|
length: map['length']?.toDouble(),
|
|
width: map['width']?.toDouble(),
|
|
height: map['height']?.toDouble(),
|
|
purchaseDate: (map['purchaseDate'] as Timestamp?)?.toDate(),
|
|
nextMaintenanceDate: (map['nextMaintenanceDate'] as Timestamp?)?.toDate(),
|
|
maintenanceIds: maintenanceIds,
|
|
imageUrl: map['imageUrl'],
|
|
notes: map['notes'],
|
|
createdAt: (map['createdAt'] as Timestamp?)?.toDate() ?? DateTime.now(),
|
|
updatedAt: (map['updatedAt'] as Timestamp?)?.toDate() ?? DateTime.now(),
|
|
);
|
|
}
|
|
|
|
Map<String, dynamic> toMap() {
|
|
return {
|
|
'name': name,
|
|
'brand': brand,
|
|
'model': model,
|
|
'category': equipmentCategoryToString(category),
|
|
'status': equipmentStatusToString(status),
|
|
'purchasePrice': purchasePrice,
|
|
'rentalPrice': rentalPrice,
|
|
'totalQuantity': totalQuantity,
|
|
'availableQuantity': availableQuantity,
|
|
'criticalThreshold': criticalThreshold,
|
|
'parentBoxIds': parentBoxIds,
|
|
'weight': weight,
|
|
'length': length,
|
|
'width': width,
|
|
'height': height,
|
|
'lastMaintenanceDate': lastMaintenanceDate != null ? Timestamp.fromDate(lastMaintenanceDate!) : null,
|
|
'purchaseDate': purchaseDate != null ? Timestamp.fromDate(purchaseDate!) : null,
|
|
'nextMaintenanceDate': nextMaintenanceDate != null ? Timestamp.fromDate(nextMaintenanceDate!) : null,
|
|
'maintenanceIds': maintenanceIds,
|
|
'imageUrl': imageUrl,
|
|
'notes': notes,
|
|
'createdAt': Timestamp.fromDate(createdAt),
|
|
'updatedAt': Timestamp.fromDate(updatedAt),
|
|
};
|
|
}
|
|
|
|
EquipmentModel copyWith({
|
|
String? id,
|
|
String? brand,
|
|
String? name,
|
|
String? model,
|
|
EquipmentCategory? category,
|
|
EquipmentStatus? status,
|
|
double? purchasePrice,
|
|
double? rentalPrice,
|
|
int? totalQuantity,
|
|
int? availableQuantity,
|
|
int? criticalThreshold,
|
|
List<String>? parentBoxIds,
|
|
double? weight,
|
|
double? length,
|
|
double? width,
|
|
double? height,
|
|
DateTime? purchaseDate,
|
|
DateTime? lastMaintenanceDate,
|
|
DateTime? nextMaintenanceDate,
|
|
List<String>? maintenanceIds,
|
|
String? imageUrl,
|
|
String? notes,
|
|
DateTime? createdAt,
|
|
DateTime? updatedAt,
|
|
}) {
|
|
return EquipmentModel(
|
|
id: id ?? this.id,
|
|
brand: brand ?? this.brand,
|
|
name: name ?? this.name,
|
|
model: model ?? this.model,
|
|
category: category ?? this.category,
|
|
status: status ?? this.status,
|
|
purchasePrice: purchasePrice ?? this.purchasePrice,
|
|
rentalPrice: rentalPrice ?? this.rentalPrice,
|
|
totalQuantity: totalQuantity ?? this.totalQuantity,
|
|
availableQuantity: availableQuantity ?? this.availableQuantity,
|
|
criticalThreshold: criticalThreshold ?? this.criticalThreshold,
|
|
parentBoxIds: parentBoxIds ?? this.parentBoxIds,
|
|
weight: weight ?? this.weight,
|
|
length: length ?? this.length,
|
|
width: width ?? this.width,
|
|
height: height ?? this.height,
|
|
lastMaintenanceDate: lastMaintenanceDate ?? this.lastMaintenanceDate,
|
|
purchaseDate: purchaseDate ?? this.purchaseDate,
|
|
nextMaintenanceDate: nextMaintenanceDate ?? this.nextMaintenanceDate,
|
|
maintenanceIds: maintenanceIds ?? this.maintenanceIds,
|
|
imageUrl: imageUrl ?? this.imageUrl,
|
|
notes: notes ?? this.notes,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
updatedAt: updatedAt ?? this.updatedAt,
|
|
);
|
|
}
|
|
|
|
// Helper pour vérifier si c'est un consommable/câble avec quantité
|
|
bool get hasQuantity => category == EquipmentCategory.consumable || category == EquipmentCategory.cable;
|
|
|
|
// Helper pour vérifier si le stock est critique
|
|
bool get isCriticalStock {
|
|
if (!hasQuantity || criticalThreshold == null || availableQuantity == null) {
|
|
return false;
|
|
}
|
|
return availableQuantity! <= criticalThreshold!;
|
|
}
|
|
|
|
// Helper pour vérifier si la maintenance est à venir
|
|
bool get isMaintenanceDue {
|
|
if (nextMaintenanceDate == null) return false;
|
|
return nextMaintenanceDate!.isBefore(DateTime.now().add(const Duration(days: 7)));
|
|
}
|
|
}
|
|
|