a182f1b922
Cette mise à jour refactorise en profondeur le chargement des données pour les équipements et les containers, en remplaçant la récupération complète de la collection par un système de pagination côté serveur. Ce changement améliore considérablement les performances, réduit la consommation de mémoire et accélère le temps de chargement initial, en particulier pour les larges inventaires.
**Changements Backend (Cloud Functions) :**
- **Nouveaux Endpoints Paginés :**
- `getEquipmentsPaginated` et `getContainersPaginated` ont été créés pour remplacer les anciens `getEquipments` et `getContainers`.
- Ces nouvelles fonctions supportent le filtrage (catégorie, statut, type), la recherche textuelle et le tri directement côté serveur, limitant la quantité de données transférées.
- La pagination est gérée via les paramètres `limit` et `startAfter`, assurant un chargement par lots efficace.
- **Optimisation de `getContainersPaginated` :**
- Peuple désormais les containers avec leurs équipements enfants via une requête `in` optimisée, réduisant le nombre de lectures Firestore.
- **Suppression des Anciens Endpoints :** Les fonctions `getEquipments` et `getContainers`, qui chargeaient l'intégralité des collections, ont été supprimées.
- **Nouveau Script de Migration :** Ajout d'un script (`migrate_equipment_ids.js`) pour s'assurer que chaque équipement dans Firestore possède un champ `id` correspondant à son ID de document, ce qui est crucial pour le tri et la pagination.
**Changements Frontend (Flutter) :**
- **`EquipmentProvider` et `ContainerProvider` :**
- La logique de chargement a été entièrement réécrite pour utiliser les nouveaux endpoints paginés.
- Introduction d'un mode `usePagination` pour basculer entre le chargement paginé (pour les pages de gestion) et le chargement complet (pour les dialogues de sélection).
- Implémentation de `loadFirstPage` et `loadNextPage` pour gérer le scroll infini.
- Ajout d'un "debouncing" sur la recherche pour éviter les appels API excessifs lors de la saisie.
- **Pages de Gestion (`EquipmentManagementPage`, `ContainerManagementPage`) :**
- Utilisent désormais un `ScrollController` pour déclencher `loadNextPage` et implémenter un scroll infini.
- Le chargement initial et les rechargements (après filtre) sont beaucoup plus rapides.
- Refonte de l'UI avec un nouveau widget `SearchActionsBar` pour uniformiser la barre de recherche et les actions.
- **Dialogue de Sélection d'Équipement (`EquipmentSelectionDialog`) :**
- Passe également à un système de lazy loading basé sur des `ChoiceChip` pour afficher soit les équipements, soit les containers.
- Charge les pages de manière asynchrone au fur et à mesure du scroll, améliorant drastiquement la réactivité du dialogue.
- La logique de chargement des données a été fiabilisée pour attendre la disponibilité des données avant l'affichage.
- **Optimisations diverses :**
- Les sections qui listent les événements associés à un équipement (`EquipmentCurrentEventsSection`, etc.) chargent désormais uniquement les containers pertinents via `getContainersByIds` au lieu de toute la collection.
- Le calcul du statut d'un équipement (`EquipmentStatusBadge`) est maintenant synchrone, simplifiant le code et évitant des `FutureBuilder`.
**Correction mineure :**
- **Nom de l'application :** Le nom de l'application a été mis à jour de "EM2 ERP" à "EM2 Hub" dans `main.dart` et dans les exports ICS.
1205 lines
41 KiB
Dart
1205 lines
41 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:em2rp/utils/colors.dart';
|
|
import 'package:em2rp/utils/permission_gate.dart';
|
|
import 'package:em2rp/views/widgets/nav/main_drawer.dart';
|
|
import 'package:em2rp/views/widgets/nav/custom_app_bar.dart';
|
|
import 'package:em2rp/providers/equipment_provider.dart';
|
|
import 'package:em2rp/providers/container_provider.dart';
|
|
import 'package:em2rp/models/equipment_model.dart';
|
|
import 'package:em2rp/models/container_model.dart';
|
|
import 'package:em2rp/views/equipment_form_page.dart';
|
|
import 'package:em2rp/views/equipment_detail_page.dart';
|
|
import 'package:em2rp/views/container_detail_page.dart';
|
|
import 'package:em2rp/views/widgets/common/qr_code_dialog.dart';
|
|
import 'package:em2rp/views/widgets/common/qr_code_scanner_dialog.dart';
|
|
import 'package:em2rp/views/widgets/common/qr_code_format_selector_dialog.dart';
|
|
import 'package:em2rp/views/widgets/equipment/equipment_status_badge.dart';
|
|
import 'package:em2rp/utils/debug_log.dart';
|
|
import 'package:em2rp/mixins/selection_mode_mixin.dart';
|
|
import 'package:em2rp/views/widgets/management/management_list.dart';
|
|
import 'package:em2rp/views/widgets/common/search_actions_bar.dart';
|
|
import 'package:em2rp/views/widgets/notification_badge.dart';
|
|
|
|
class EquipmentManagementPage extends StatefulWidget {
|
|
const EquipmentManagementPage({super.key});
|
|
|
|
@override
|
|
State<EquipmentManagementPage> createState() =>
|
|
_EquipmentManagementPageState();
|
|
}
|
|
|
|
|
|
class _EquipmentManagementPageState extends State<EquipmentManagementPage>
|
|
with SelectionModeMixin<EquipmentManagementPage> {
|
|
final TextEditingController _searchController = TextEditingController();
|
|
final ScrollController _scrollController = ScrollController();
|
|
EquipmentCategory? _selectedCategory;
|
|
List<EquipmentModel>? _cachedEquipment;
|
|
bool _isLoadingMore = false; // Flag pour éviter les appels multiples
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
DebugLog.info('[EquipmentManagementPage] initState called');
|
|
|
|
// Activer le mode pagination
|
|
final provider = context.read<EquipmentProvider>();
|
|
provider.enablePagination();
|
|
|
|
// Ajouter le listener de scroll pour le chargement infini
|
|
_scrollController.addListener(_onScroll);
|
|
|
|
// Charger la première page au démarrage
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
DebugLog.info('[EquipmentManagementPage] Loading first page...');
|
|
provider.loadFirstPage();
|
|
});
|
|
}
|
|
|
|
void _onScroll() {
|
|
// Éviter les appels multiples
|
|
if (_isLoadingMore) return;
|
|
|
|
final provider = context.read<EquipmentProvider>();
|
|
|
|
// Charger la page suivante quand on arrive à 300px du bas
|
|
if (_scrollController.hasClients &&
|
|
_scrollController.position.pixels >=
|
|
_scrollController.position.maxScrollExtent - 300) {
|
|
|
|
// Vérifier qu'on peut charger plus
|
|
if (provider.hasMore && !provider.isLoadingMore) {
|
|
setState(() => _isLoadingMore = true);
|
|
|
|
provider.loadNextPage().then((_) {
|
|
if (mounted) {
|
|
setState(() => _isLoadingMore = false);
|
|
}
|
|
}).catchError((error) {
|
|
if (mounted) {
|
|
setState(() => _isLoadingMore = false);
|
|
}
|
|
DebugLog.error('[EquipmentManagementPage] Error loading next page', error);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_scrollController.removeListener(_onScroll);
|
|
_scrollController.dispose();
|
|
_searchController.dispose();
|
|
// Désactiver le mode pagination en quittant
|
|
context.read<EquipmentProvider>().disablePagination();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final isMobile = MediaQuery.of(context).size.width < 800;
|
|
|
|
return PermissionGate(
|
|
requiredPermissions: const ['view_equipment'],
|
|
fallback: Scaffold(
|
|
appBar: const CustomAppBar(title: 'Accès refusé'),
|
|
drawer: const MainDrawer(currentPage: '/equipment_management'),
|
|
body: const Center(
|
|
child: Padding(
|
|
padding: EdgeInsets.all(24.0),
|
|
child: Text(
|
|
'Vous n\'avez pas les permissions nécessaires pour accéder à la gestion du matériel.',
|
|
textAlign: TextAlign.center,
|
|
style: TextStyle(fontSize: 16),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
child: Scaffold(
|
|
appBar: isSelectionMode
|
|
? AppBar(
|
|
backgroundColor: AppColors.rouge,
|
|
leading: IconButton(
|
|
icon: const Icon(Icons.close, color: Colors.white),
|
|
onPressed: toggleSelectionMode,
|
|
),
|
|
title: Text(
|
|
'$selectedCount sélectionné(s)',
|
|
style: const TextStyle(color: Colors.white),
|
|
),
|
|
actions: [
|
|
const NotificationBadge(),
|
|
if (hasSelection) ...[
|
|
IconButton(
|
|
icon: const Icon(Icons.qr_code, color: Colors.white),
|
|
tooltip: 'Générer QR Codes',
|
|
onPressed: _generateQRCodesForSelected,
|
|
),
|
|
IconButton(
|
|
icon: const Icon(Icons.delete, color: Colors.white),
|
|
tooltip: 'Supprimer',
|
|
onPressed: _deleteSelectedEquipment,
|
|
),
|
|
],
|
|
],
|
|
)
|
|
: CustomAppBar(
|
|
title: 'Gestion du matériel',
|
|
),
|
|
drawer: const MainDrawer(currentPage: '/equipment_management'),
|
|
body: isMobile ? _buildMobileLayout() : _buildDesktopLayout(),
|
|
floatingActionButton: isSelectionMode ? null : _buildFAB(),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildFAB() {
|
|
return PermissionGate(
|
|
requiredPermissions: const ['manage_equipment'],
|
|
child: FloatingActionButton.extended(
|
|
onPressed: _createNewEquipment,
|
|
backgroundColor: AppColors.rouge,
|
|
icon: const Icon(Icons.add),
|
|
label: const Text('Ajouter un équipement'),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildMobileLayout() {
|
|
return Column(
|
|
children: [
|
|
// Barre de recherche et boutons d'action
|
|
SearchActionsBar(
|
|
controller: _searchController,
|
|
hintText: 'Rechercher par nom, modèle ou ID...',
|
|
onChanged: (value) {
|
|
context.read<EquipmentProvider>().setSearchQuery(value);
|
|
},
|
|
onClear: () {
|
|
_searchController.clear();
|
|
context.read<EquipmentProvider>().setSearchQuery('');
|
|
},
|
|
actions: [
|
|
IconButton.filled(
|
|
onPressed: _scanQRCode,
|
|
icon: const Icon(Icons.qr_code_scanner),
|
|
tooltip: 'Scanner un QR Code',
|
|
style: IconButton.styleFrom(
|
|
backgroundColor: Colors.grey[700],
|
|
foregroundColor: Colors.white,
|
|
),
|
|
),
|
|
IconButton.filled(
|
|
onPressed: () {
|
|
Navigator.pushNamed(context, '/container_management');
|
|
},
|
|
icon: const Icon(Icons.inventory_2),
|
|
tooltip: 'Gérer les boîtes',
|
|
style: IconButton.styleFrom(
|
|
backgroundColor: AppColors.rouge,
|
|
foregroundColor: Colors.white,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
// Menu horizontal de filtres par catégorie
|
|
SizedBox(
|
|
height: 60,
|
|
child: ListView(
|
|
scrollDirection: Axis.horizontal,
|
|
padding: const EdgeInsets.symmetric(horizontal: 8),
|
|
children: [
|
|
Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 4.0),
|
|
child: ChoiceChip(
|
|
label: const Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(Icons.all_inclusive, size: 16, color: Colors.white),
|
|
SizedBox(width: 8),
|
|
Text('Tout'),
|
|
],
|
|
),
|
|
selected: _selectedCategory == null,
|
|
onSelected: (selected) {
|
|
if (selected) {
|
|
setState(() => _selectedCategory = null);
|
|
context
|
|
.read<EquipmentProvider>()
|
|
.setSelectedCategory(null);
|
|
}
|
|
},
|
|
selectedColor: AppColors.rouge,
|
|
labelStyle: TextStyle(
|
|
color: _selectedCategory == null
|
|
? Colors.white
|
|
: AppColors.rouge,
|
|
fontWeight: _selectedCategory == null
|
|
? FontWeight.bold
|
|
: FontWeight.normal,
|
|
),
|
|
),
|
|
),
|
|
..._buildCategoryChips(),
|
|
],
|
|
),
|
|
),
|
|
const Divider(),
|
|
// Liste des équipements
|
|
Expanded(child: _buildEquipmentList()),
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _buildDesktopLayout() {
|
|
return Row(
|
|
children: [
|
|
// Sidebar gauche avec filtres
|
|
Container(
|
|
width: 280,
|
|
decoration: BoxDecoration(
|
|
color: Colors.grey[100],
|
|
border: const Border(
|
|
right: BorderSide(color: Colors.grey, width: 1),
|
|
),
|
|
),
|
|
child: Column(
|
|
children: [
|
|
const SizedBox(height: 16),
|
|
// En-tête filtres
|
|
Padding(
|
|
padding: const EdgeInsets.fromLTRB(16, 8, 16, 8),
|
|
child: Row(
|
|
children: [
|
|
Icon(Icons.filter_list, color: AppColors.rouge, size: 20),
|
|
const SizedBox(width: 12),
|
|
Expanded(
|
|
child: Text(
|
|
'Filtres',
|
|
style:
|
|
Theme.of(context).textTheme.titleMedium?.copyWith(
|
|
fontWeight: FontWeight.bold,
|
|
color: AppColors.rouge,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
// Filtres par catégorie
|
|
Padding(
|
|
padding:
|
|
const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8),
|
|
child: Align(
|
|
alignment: Alignment.centerLeft,
|
|
child: Text(
|
|
'Catégories',
|
|
style: Theme.of(context).textTheme.titleSmall?.copyWith(
|
|
fontWeight: FontWeight.bold,
|
|
color: Colors.grey[700],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
Expanded(
|
|
child: ListView(
|
|
children: [
|
|
ListTile(
|
|
leading: Icon(
|
|
Icons.all_inclusive,
|
|
color: _selectedCategory == null
|
|
? AppColors.rouge
|
|
: Colors.grey[600],
|
|
),
|
|
title: Text(
|
|
'Tout',
|
|
style: TextStyle(
|
|
color: _selectedCategory == null
|
|
? AppColors.rouge
|
|
: Colors.black87,
|
|
fontWeight: _selectedCategory == null
|
|
? FontWeight.bold
|
|
: FontWeight.normal,
|
|
),
|
|
),
|
|
selected: _selectedCategory == null,
|
|
selectedTileColor: AppColors.rouge.withOpacity(0.1),
|
|
onTap: () {
|
|
setState(() => _selectedCategory = null);
|
|
context
|
|
.read<EquipmentProvider>()
|
|
.setSelectedCategory(null);
|
|
},
|
|
),
|
|
..._buildCategoryListTiles(),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
// Contenu principal
|
|
Expanded(
|
|
child: Column(
|
|
children: [
|
|
SearchActionsBar(
|
|
controller: _searchController,
|
|
hintText: 'Rechercher par nom, modèle ou ID...',
|
|
onChanged: (value) {
|
|
context.read<EquipmentProvider>().setSearchQuery(value);
|
|
},
|
|
onClear: () {
|
|
_searchController.clear();
|
|
context.read<EquipmentProvider>().setSearchQuery('');
|
|
},
|
|
actions: [
|
|
IconButton.filled(
|
|
onPressed: _scanQRCode,
|
|
icon: const Icon(Icons.qr_code_scanner),
|
|
tooltip: 'Scanner un QR Code',
|
|
style: IconButton.styleFrom(
|
|
backgroundColor: Colors.grey[700],
|
|
foregroundColor: Colors.white,
|
|
),
|
|
),
|
|
IconButton.filled(
|
|
onPressed: () {
|
|
Navigator.pushNamed(context, '/container_management');
|
|
},
|
|
icon: const Icon(Icons.inventory_2),
|
|
tooltip: 'Gérer les boîtes',
|
|
style: IconButton.styleFrom(
|
|
backgroundColor: AppColors.rouge,
|
|
foregroundColor: Colors.white,
|
|
),
|
|
),
|
|
if (!isSelectionMode)
|
|
IconButton.filled(
|
|
onPressed: toggleSelectionMode,
|
|
icon: const Icon(Icons.checklist),
|
|
tooltip: 'Mode sélection',
|
|
style: IconButton.styleFrom(
|
|
backgroundColor: AppColors.rouge,
|
|
foregroundColor: Colors.white,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
Expanded(child: _buildEquipmentList()),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
List<Widget> _buildCategoryChips() {
|
|
return EquipmentCategory.values.map((category) {
|
|
final isSelected = _selectedCategory == category;
|
|
final color = isSelected ? Colors.white : AppColors.rouge;
|
|
|
|
return Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 4.0),
|
|
child: ChoiceChip(
|
|
label: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
category.getIcon(
|
|
size: 16,
|
|
color: color,
|
|
),
|
|
const SizedBox(width: 8),
|
|
Text(category.label),
|
|
],
|
|
),
|
|
selected: isSelected,
|
|
onSelected: (selected) {
|
|
if (selected) {
|
|
setState(() => _selectedCategory = category);
|
|
context.read<EquipmentProvider>().setSelectedCategory(category);
|
|
}
|
|
},
|
|
selectedColor: AppColors.rouge,
|
|
labelStyle: TextStyle(
|
|
color: color,
|
|
fontWeight: isSelected ? FontWeight.bold : FontWeight.normal,
|
|
),
|
|
),
|
|
);
|
|
}).toList();
|
|
}
|
|
|
|
List<Widget> _buildCategoryListTiles() {
|
|
return EquipmentCategory.values.map((category) {
|
|
final isSelected = _selectedCategory == category;
|
|
final color = isSelected ? AppColors.rouge : Colors.grey[600]!;
|
|
|
|
return ListTile(
|
|
leading: category.getIcon(
|
|
size: 24,
|
|
color: color,
|
|
),
|
|
title: Text(
|
|
category.label,
|
|
style: TextStyle(
|
|
color: isSelected ? AppColors.rouge : Colors.black87,
|
|
fontWeight: isSelected ? FontWeight.bold : FontWeight.normal,
|
|
),
|
|
),
|
|
selected: isSelected,
|
|
selectedTileColor: AppColors.rouge.withOpacity(0.1),
|
|
onTap: () {
|
|
setState(() => _selectedCategory = category);
|
|
context.read<EquipmentProvider>().setSelectedCategory(category);
|
|
},
|
|
);
|
|
}).toList();
|
|
}
|
|
|
|
Widget _buildEquipmentList() {
|
|
return Consumer<EquipmentProvider>(
|
|
builder: (context, provider, child) {
|
|
DebugLog.info('[EquipmentManagementPage] Building list - isLoading: ${provider.isLoading}, equipment count: ${provider.equipment.length}');
|
|
|
|
// Afficher l'indicateur de chargement initial uniquement
|
|
if (provider.isLoading && provider.equipment.isEmpty) {
|
|
DebugLog.info('[EquipmentManagementPage] Showing initial loading indicator');
|
|
return const Center(child: CircularProgressIndicator());
|
|
}
|
|
|
|
final equipments = provider.equipment;
|
|
|
|
if (equipments.isEmpty && !provider.isLoading) {
|
|
DebugLog.info('[EquipmentManagementPage] No equipment found');
|
|
return Center(
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
Icon(
|
|
Icons.inventory_2_outlined,
|
|
size: 64,
|
|
color: Colors.grey[400],
|
|
),
|
|
const SizedBox(height: 16),
|
|
Text(
|
|
'Aucun équipement trouvé',
|
|
style: TextStyle(
|
|
fontSize: 18,
|
|
color: Colors.grey[600],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
DebugLog.info('[EquipmentManagementPage] Building list with ${equipments.length} items');
|
|
|
|
// Calculer le nombre total d'items (équipements + indicateur de chargement)
|
|
final itemCount = equipments.length + (provider.hasMore ? 1 : 0);
|
|
|
|
return ListView.builder(
|
|
controller: _scrollController,
|
|
itemCount: itemCount,
|
|
itemBuilder: (context, index) {
|
|
// Dernier élément = indicateur de chargement
|
|
if (index == equipments.length) {
|
|
return Center(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(16.0),
|
|
child: provider.isLoadingMore
|
|
? const CircularProgressIndicator()
|
|
: const SizedBox.shrink(),
|
|
),
|
|
);
|
|
}
|
|
|
|
return _buildEquipmentCard(equipments[index]);
|
|
},
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Widget _buildEquipmentCard(EquipmentModel equipment) {
|
|
final isSelected = isItemSelected(equipment.id);
|
|
|
|
return Card(
|
|
margin: const EdgeInsets.only(bottom: 12),
|
|
color: isSelectionMode && isSelected
|
|
? AppColors.rouge.withValues(alpha: 0.1)
|
|
: null,
|
|
child: ListTile(
|
|
leading: isSelectionMode
|
|
? Checkbox(
|
|
value: isSelected,
|
|
onChanged: (value) => toggleItemSelection(equipment.id),
|
|
activeColor: AppColors.rouge,
|
|
)
|
|
: CircleAvatar(
|
|
backgroundColor: equipment.category.color.withValues(alpha: 0.2),
|
|
child: equipment.category.getIcon(
|
|
size: 20,
|
|
color: equipment.category.color,
|
|
),
|
|
),
|
|
title: Row(
|
|
children: [
|
|
Expanded(
|
|
child: Text(
|
|
equipment.id,
|
|
style: const TextStyle(fontWeight: FontWeight.bold),
|
|
),
|
|
),
|
|
// Afficher le badge de statut calculé dynamiquement
|
|
if (equipment.category != EquipmentCategory.consumable &&
|
|
equipment.category != EquipmentCategory.cable)
|
|
EquipmentStatusBadge(equipment: equipment),
|
|
],
|
|
),
|
|
subtitle: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
'${equipment.brand ?? ''} ${equipment.model ?? ''}'
|
|
.trim()
|
|
.isNotEmpty
|
|
? '${equipment.brand ?? ''} ${equipment.model ?? ''}'.trim()
|
|
: 'Marque/Modèle non défini',
|
|
style: TextStyle(color: Colors.grey[600], fontSize: 14),
|
|
),
|
|
// Afficher la sous-catégorie si elle existe
|
|
if (equipment.subCategory != null && equipment.subCategory!.isNotEmpty) ...[
|
|
const SizedBox(height: 2),
|
|
Text(
|
|
'📁 ${equipment.subCategory}',
|
|
style: TextStyle(
|
|
color: Colors.grey[500],
|
|
fontSize: 12,
|
|
fontStyle: FontStyle.italic,
|
|
),
|
|
),
|
|
],
|
|
// Afficher la quantité disponible pour les consommables/câbles
|
|
if (equipment.category == EquipmentCategory.consumable ||
|
|
equipment.category == EquipmentCategory.cable) ...[
|
|
const SizedBox(height: 4),
|
|
_buildQuantityDisplay(equipment),
|
|
],
|
|
],
|
|
),
|
|
trailing: isSelectionMode
|
|
? null
|
|
: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
// Bouton Restock (uniquement pour consommables/câbles avec permission)
|
|
if (equipment.category == EquipmentCategory.consumable ||
|
|
equipment.category == EquipmentCategory.cable)
|
|
PermissionGate(
|
|
requiredPermissions: const ['manage_equipment'],
|
|
child: IconButton(
|
|
icon: const Icon(Icons.add_shopping_cart,
|
|
color: AppColors.rouge),
|
|
tooltip: 'Restock',
|
|
onPressed: () => _showRestockDialog(equipment),
|
|
),
|
|
),
|
|
// Bouton QR Code
|
|
IconButton(
|
|
icon: const Icon(Icons.qr_code, color: AppColors.rouge),
|
|
tooltip: 'QR Code',
|
|
onPressed: () => showDialog(
|
|
context: context,
|
|
builder: (context) => QRCodeDialog.forEquipment(equipment),
|
|
),
|
|
),
|
|
// Bouton Modifier (permission required)
|
|
PermissionGate(
|
|
requiredPermissions: const ['manage_equipment'],
|
|
child: IconButton(
|
|
icon: const Icon(Icons.edit, color: AppColors.rouge),
|
|
tooltip: 'Modifier',
|
|
onPressed: () => _editEquipment(equipment),
|
|
),
|
|
),
|
|
// Bouton Supprimer (permission required)
|
|
PermissionGate(
|
|
requiredPermissions: const ['manage_equipment'],
|
|
child: IconButton(
|
|
icon: const Icon(Icons.delete, color: Colors.red),
|
|
tooltip: 'Supprimer',
|
|
onPressed: () => _deleteEquipment(equipment),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
onTap: isSelectionMode
|
|
? () => toggleItemSelection(equipment.id)
|
|
: () => _viewEquipmentDetails(equipment),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildQuantityDisplay(EquipmentModel equipment) {
|
|
final availableQty = equipment.availableQuantity ?? 0;
|
|
final totalQty = equipment.totalQuantity ?? 0;
|
|
final criticalThreshold = equipment.criticalThreshold ?? 0;
|
|
final isCritical =
|
|
criticalThreshold > 0 && availableQty <= criticalThreshold;
|
|
|
|
return Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
|
|
decoration: BoxDecoration(
|
|
color: isCritical
|
|
? Colors.red.withOpacity(0.15)
|
|
: Colors.grey.withOpacity(0.1),
|
|
borderRadius: BorderRadius.circular(8),
|
|
border: Border.all(
|
|
color: isCritical ? Colors.red : Colors.grey.shade400,
|
|
width: isCritical ? 2 : 1,
|
|
),
|
|
),
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(
|
|
isCritical ? Icons.warning : Icons.inventory,
|
|
size: 16,
|
|
color: isCritical ? Colors.red : Colors.grey[700],
|
|
),
|
|
const SizedBox(width: 6),
|
|
Text(
|
|
'Disponible: $availableQty / $totalQty',
|
|
style: TextStyle(
|
|
fontSize: 13,
|
|
fontWeight: isCritical ? FontWeight.bold : FontWeight.normal,
|
|
color: isCritical ? Colors.red : Colors.grey[700],
|
|
),
|
|
),
|
|
if (isCritical) ...[
|
|
const SizedBox(width: 6),
|
|
Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 2),
|
|
decoration: BoxDecoration(
|
|
color: Colors.red,
|
|
borderRadius: BorderRadius.circular(10),
|
|
),
|
|
child: const Text(
|
|
'CRITIQUE',
|
|
style: TextStyle(
|
|
fontSize: 10,
|
|
fontWeight: FontWeight.bold,
|
|
color: Colors.white,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
|
|
// Actions
|
|
void _createNewEquipment() {
|
|
Navigator.push(
|
|
context,
|
|
MaterialPageRoute(
|
|
builder: (context) => const EquipmentFormPage(),
|
|
),
|
|
);
|
|
}
|
|
|
|
void _editEquipment(EquipmentModel equipment) {
|
|
Navigator.push(
|
|
context,
|
|
MaterialPageRoute(
|
|
builder: (context) => EquipmentFormPage(equipment: equipment),
|
|
),
|
|
);
|
|
}
|
|
|
|
void _deleteEquipment(EquipmentModel equipment) {
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => AlertDialog(
|
|
title: const Text('Confirmer la suppression'),
|
|
content: Text('Voulez-vous vraiment supprimer "${equipment.name}" ?'),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.pop(context),
|
|
child: const Text('Annuler'),
|
|
),
|
|
TextButton(
|
|
onPressed: () async {
|
|
Navigator.pop(context);
|
|
try {
|
|
await context
|
|
.read<EquipmentProvider>()
|
|
.deleteEquipment(equipment.id);
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Équipement supprimé avec succès')),
|
|
);
|
|
}
|
|
} catch (e) {
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(content: Text('Erreur: $e')),
|
|
);
|
|
}
|
|
}
|
|
},
|
|
style: TextButton.styleFrom(foregroundColor: Colors.red),
|
|
child: const Text('Supprimer'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
void _deleteSelectedEquipment() async {
|
|
if (!hasSelection) return;
|
|
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => AlertDialog(
|
|
title: const Text('Confirmer la suppression'),
|
|
content: Text(
|
|
'Voulez-vous vraiment supprimer $selectedCount équipement(s) ?',
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.pop(context),
|
|
child: const Text('Annuler'),
|
|
),
|
|
TextButton(
|
|
onPressed: () async {
|
|
Navigator.pop(context);
|
|
try {
|
|
final provider = context.read<EquipmentProvider>();
|
|
for (final id in selectedIds) {
|
|
await provider.deleteEquipment(id);
|
|
}
|
|
disableSelectionMode();
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text(
|
|
'$selectedCount équipement(s) supprimé(s) avec succès'),
|
|
backgroundColor: Colors.green,
|
|
),
|
|
);
|
|
}
|
|
} catch (e) {
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(content: Text('Erreur: $e')),
|
|
);
|
|
}
|
|
}
|
|
},
|
|
style: TextButton.styleFrom(foregroundColor: Colors.red),
|
|
child: const Text('Supprimer'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
void _generateQRCodesForSelected() async {
|
|
if (!hasSelection) return;
|
|
|
|
// Afficher un indicateur de chargement
|
|
showDialog(
|
|
context: context,
|
|
barrierDismissible: false,
|
|
builder: (context) => const Center(
|
|
child: CircularProgressIndicator(color: AppColors.rouge),
|
|
),
|
|
);
|
|
|
|
try {
|
|
// Récupérer les équipements sélectionnés
|
|
final provider = context.read<EquipmentProvider>();
|
|
final List<EquipmentModel> selectedEquipment = [];
|
|
|
|
// On doit récupérer les équipements depuis le stream
|
|
await for (final equipmentList in provider.equipmentStream.take(1)) {
|
|
for (final equipment in equipmentList) {
|
|
if (isItemSelected(equipment.id)) {
|
|
selectedEquipment.add(equipment);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Fermer l'indicateur de chargement
|
|
if (mounted) {
|
|
Navigator.of(context).pop();
|
|
}
|
|
|
|
if (selectedEquipment.isEmpty) return;
|
|
|
|
if (selectedEquipment.length == 1) {
|
|
// Un seul équipement : afficher le dialogue simple
|
|
if (mounted) {
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => QRCodeDialog.forEquipment(selectedEquipment.first),
|
|
);
|
|
}
|
|
} else {
|
|
// Plusieurs équipements : afficher le sélecteur de format
|
|
if (mounted) {
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => QRCodeFormatSelectorDialog<EquipmentModel>(
|
|
itemList: selectedEquipment,
|
|
getId: (eq) => eq.id,
|
|
getTitle: (eq) => '${eq.brand ?? ''} ${eq.model ?? ''}'.trim(),
|
|
dialogTitle: 'Générer ${selectedEquipment.length} QR Code(s)',
|
|
),
|
|
);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
// Fermer l'indicateur si une erreur survient
|
|
if (mounted) {
|
|
Navigator.of(context).pop();
|
|
}
|
|
|
|
DebugLog.error('[EquipmentManagementPage] Error generating QR codes', e);
|
|
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text('Erreur lors de la génération : ${e.toString()}'),
|
|
backgroundColor: Colors.red,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
void _showRestockDialog(EquipmentModel equipment) {
|
|
final TextEditingController quantityController = TextEditingController();
|
|
bool addToTotal = false;
|
|
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => StatefulBuilder(
|
|
builder: (context, setState) {
|
|
return AlertDialog(
|
|
title: Row(
|
|
children: [
|
|
const Icon(Icons.add_shopping_cart, color: AppColors.rouge),
|
|
const SizedBox(width: 12),
|
|
Expanded(
|
|
child: Text('Restock - ${equipment.name}'),
|
|
),
|
|
],
|
|
),
|
|
content: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Container(
|
|
padding: const EdgeInsets.all(12),
|
|
decoration: BoxDecoration(
|
|
color: Colors.grey[100],
|
|
borderRadius: BorderRadius.circular(8),
|
|
),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
'Quantités actuelles',
|
|
style: TextStyle(
|
|
fontWeight: FontWeight.bold,
|
|
color: Colors.grey[700],
|
|
),
|
|
),
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
const Text('Disponible:'),
|
|
Text(
|
|
'${equipment.availableQuantity ?? 0}',
|
|
style: const TextStyle(fontWeight: FontWeight.bold),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 4),
|
|
Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
const Text('Total:'),
|
|
Text(
|
|
'${equipment.totalQuantity ?? 0}',
|
|
style: const TextStyle(fontWeight: FontWeight.bold),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
const SizedBox(height: 20),
|
|
TextField(
|
|
controller: quantityController,
|
|
decoration: const InputDecoration(
|
|
labelText: 'Quantité à ajouter/retirer',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.inventory),
|
|
hintText: 'Ex: 10 ou -5',
|
|
helperText:
|
|
'Nombre positif pour ajouter, négatif pour retirer',
|
|
),
|
|
keyboardType:
|
|
const TextInputType.numberWithOptions(signed: true),
|
|
autofocus: true,
|
|
),
|
|
const SizedBox(height: 16),
|
|
CheckboxListTile(
|
|
title: const Text('Ajouter à la quantité totale'),
|
|
subtitle:
|
|
const Text('Mettre à jour aussi la quantité totale'),
|
|
value: addToTotal,
|
|
contentPadding: EdgeInsets.zero,
|
|
onChanged: (bool? value) {
|
|
setState(() {
|
|
addToTotal = value ?? false;
|
|
});
|
|
},
|
|
),
|
|
],
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.pop(context),
|
|
child: const Text('Annuler'),
|
|
),
|
|
ElevatedButton(
|
|
onPressed: () async {
|
|
final quantityText = quantityController.text.trim();
|
|
if (quantityText.isEmpty) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Veuillez entrer une quantité')),
|
|
);
|
|
return;
|
|
}
|
|
|
|
final quantity = int.tryParse(quantityText);
|
|
if (quantity == null) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('Quantité invalide')),
|
|
);
|
|
return;
|
|
}
|
|
|
|
Navigator.pop(context);
|
|
|
|
try {
|
|
final currentAvailable = equipment.availableQuantity ?? 0;
|
|
final currentTotal = equipment.totalQuantity ?? 0;
|
|
|
|
final newAvailable = currentAvailable + quantity;
|
|
final newTotal =
|
|
addToTotal ? currentTotal + quantity : currentTotal;
|
|
|
|
if (newAvailable < 0) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text(
|
|
'La quantité disponible ne peut pas être négative')),
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (newTotal < 0) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text(
|
|
'La quantité totale ne peut pas être négative')),
|
|
);
|
|
return;
|
|
}
|
|
|
|
final updatedData = {
|
|
'availableQuantity': newAvailable,
|
|
'totalQuantity': newTotal,
|
|
'updatedAt': DateTime.now().toIso8601String(),
|
|
};
|
|
|
|
final updatedEquipment = equipment.copyWith(
|
|
availableQuantity: newAvailable,
|
|
totalQuantity: newTotal,
|
|
updatedAt: DateTime.now(),
|
|
);
|
|
|
|
await context.read<EquipmentProvider>().updateEquipment(updatedEquipment);
|
|
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text(
|
|
quantity > 0
|
|
? 'Ajout de $quantity unité(s) effectué'
|
|
: 'Retrait de ${quantity.abs()} unité(s) effectué',
|
|
),
|
|
backgroundColor: Colors.green,
|
|
),
|
|
);
|
|
}
|
|
} catch (e) {
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(content: Text('Erreur: $e')),
|
|
);
|
|
}
|
|
}
|
|
},
|
|
style: ElevatedButton.styleFrom(
|
|
backgroundColor: AppColors.rouge,
|
|
),
|
|
child: const Text('Valider',
|
|
style: TextStyle(color: Colors.white)),
|
|
),
|
|
],
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
void _viewEquipmentDetails(EquipmentModel equipment) {
|
|
Navigator.push(
|
|
context,
|
|
MaterialPageRoute(
|
|
builder: (context) => EquipmentDetailPage(equipment: equipment),
|
|
),
|
|
);
|
|
}
|
|
|
|
/// Scanner un QR Code et ouvrir la vue de détail correspondante
|
|
Future<void> _scanQRCode() async {
|
|
try {
|
|
// Ouvrir le scanner
|
|
final scannedCode = await showDialog<String>(
|
|
context: context,
|
|
builder: (context) => const QRCodeScannerDialog(),
|
|
);
|
|
|
|
if (scannedCode == null || scannedCode.isEmpty) {
|
|
return; // L'utilisateur a annulé
|
|
}
|
|
|
|
if (!mounted) return;
|
|
|
|
// Afficher un indicateur de chargement
|
|
showDialog(
|
|
context: context,
|
|
barrierDismissible: false,
|
|
builder: (context) => const Center(
|
|
child: CircularProgressIndicator(color: AppColors.rouge),
|
|
),
|
|
);
|
|
|
|
// Rechercher d'abord dans les équipements
|
|
final equipmentProvider = context.read<EquipmentProvider>();
|
|
await equipmentProvider.ensureLoaded();
|
|
|
|
final equipment = equipmentProvider.allEquipment.firstWhere(
|
|
(eq) => eq.id == scannedCode,
|
|
orElse: () => EquipmentModel(
|
|
id: '',
|
|
name: '',
|
|
category: EquipmentCategory.other,
|
|
status: EquipmentStatus.available,
|
|
maintenanceIds: [],
|
|
createdAt: DateTime.now(),
|
|
updatedAt: DateTime.now(),
|
|
),
|
|
);
|
|
|
|
if (mounted) {
|
|
Navigator.of(context).pop(); // Fermer l'indicateur
|
|
}
|
|
|
|
if (equipment.id.isNotEmpty) {
|
|
// Équipement trouvé
|
|
if (mounted) {
|
|
Navigator.push(
|
|
context,
|
|
MaterialPageRoute(
|
|
builder: (context) => EquipmentDetailPage(equipment: equipment),
|
|
),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Si pas trouvé dans les équipements, chercher dans les conteneurs
|
|
final containerProvider = context.read<ContainerProvider>();
|
|
if (containerProvider.containers.isEmpty) {
|
|
await containerProvider.loadContainers();
|
|
}
|
|
|
|
final container = containerProvider.containers.firstWhere(
|
|
(c) => c.id == scannedCode,
|
|
orElse: () => ContainerModel(
|
|
id: '',
|
|
name: '',
|
|
type: ContainerType.flightCase,
|
|
status: EquipmentStatus.available,
|
|
equipmentIds: [],
|
|
createdAt: DateTime.now(),
|
|
updatedAt: DateTime.now(),
|
|
),
|
|
);
|
|
|
|
if (container.id.isNotEmpty) {
|
|
// Conteneur trouvé
|
|
if (mounted) {
|
|
Navigator.push(
|
|
context,
|
|
MaterialPageRoute(
|
|
builder: (context) => ContainerDetailPage(container: container),
|
|
),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Rien trouvé
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text('Aucun équipement ou conteneur trouvé avec l\'ID : $scannedCode'),
|
|
backgroundColor: Colors.orange,
|
|
),
|
|
);
|
|
}
|
|
} catch (e) {
|
|
DebugLog.error('[EquipmentManagementPage] Error scanning QR code', e);
|
|
if (mounted) {
|
|
// Fermer l'indicateur si ouvert
|
|
Navigator.of(context).popUntil((route) => route.isFirst);
|
|
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text('Erreur lors du scan : ${e.toString()}'),
|
|
backgroundColor: Colors.red,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|