95e9af23e2
- Sauvegarde des fichiers critiques - Préparation transformation ApiService en singleton - Préparation création CurrentUserService et CurrentAmicaleService - Objectif: renommer Box users -> user
352 lines
10 KiB
Dart
352 lines
10 KiB
Dart
import 'package:geosector_app/app.dart'; // Pour accéder aux instances globales
|
|
import 'package:flutter/material.dart';
|
|
import 'package:hive_flutter/hive_flutter.dart';
|
|
import 'package:geosector_app/presentation/widgets/dashboard_layout.dart';
|
|
import 'package:geosector_app/core/constants/app_keys.dart';
|
|
import 'dart:math' as math;
|
|
|
|
// Import des pages admin
|
|
import 'admin_dashboard_home_page.dart';
|
|
import 'admin_statistics_page.dart';
|
|
import 'admin_history_page.dart';
|
|
import 'admin_communication_page.dart';
|
|
import 'admin_map_page.dart';
|
|
import 'admin_amicale_page.dart';
|
|
|
|
/// Class pour dessiner les petits points blancs sur le fond
|
|
class DotsPainter extends CustomPainter {
|
|
@override
|
|
void paint(Canvas canvas, Size size) {
|
|
final paint = Paint()
|
|
..color = Colors.white.withOpacity(0.5)
|
|
..style = PaintingStyle.fill;
|
|
|
|
final random = math.Random(42); // Seed fixe pour consistance
|
|
final numberOfDots = (size.width * size.height) ~/ 1500;
|
|
|
|
for (int i = 0; i < numberOfDots; i++) {
|
|
final x = random.nextDouble() * size.width;
|
|
final y = random.nextDouble() * size.height;
|
|
final radius = 1.0 + random.nextDouble() * 2.0;
|
|
canvas.drawCircle(Offset(x, y), radius, paint);
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool shouldRepaint(covariant CustomPainter oldDelegate) => false;
|
|
}
|
|
|
|
class AdminDashboardPage extends StatefulWidget {
|
|
const AdminDashboardPage({super.key});
|
|
|
|
@override
|
|
State<AdminDashboardPage> createState() => _AdminDashboardPageState();
|
|
}
|
|
|
|
class _AdminDashboardPageState extends State<AdminDashboardPage> with WidgetsBindingObserver {
|
|
int _selectedIndex = 0;
|
|
|
|
// Liste des pages à afficher
|
|
late final List<Widget> _pages;
|
|
|
|
// Référence à la boîte Hive pour les paramètres
|
|
late Box _settingsBox;
|
|
|
|
// Liste des éléments de navigation de base (toujours visibles)
|
|
final List<_NavigationItem> _baseNavigationItems = [
|
|
const _NavigationItem(
|
|
label: 'Tableau de bord',
|
|
icon: Icons.dashboard_outlined,
|
|
selectedIcon: Icons.dashboard,
|
|
pageType: _PageType.dashboardHome,
|
|
),
|
|
const _NavigationItem(
|
|
label: 'Statistiques',
|
|
icon: Icons.bar_chart_outlined,
|
|
selectedIcon: Icons.bar_chart,
|
|
pageType: _PageType.statistics,
|
|
),
|
|
const _NavigationItem(
|
|
label: 'Historique',
|
|
icon: Icons.history_outlined,
|
|
selectedIcon: Icons.history,
|
|
pageType: _PageType.history,
|
|
),
|
|
const _NavigationItem(
|
|
label: 'Messages',
|
|
icon: Icons.chat_outlined,
|
|
selectedIcon: Icons.chat,
|
|
pageType: _PageType.communication,
|
|
),
|
|
const _NavigationItem(
|
|
label: 'Carte',
|
|
icon: Icons.map_outlined,
|
|
selectedIcon: Icons.map,
|
|
pageType: _PageType.map,
|
|
),
|
|
];
|
|
|
|
// Éléments de navigation supplémentaires pour le rôle 2
|
|
final List<_NavigationItem> _adminNavigationItems = [
|
|
const _NavigationItem(
|
|
label: 'Amicale & membres',
|
|
icon: Icons.business_outlined,
|
|
selectedIcon: Icons.business,
|
|
pageType: _PageType.amicale,
|
|
requiredRole: 2,
|
|
),
|
|
const _NavigationItem(
|
|
label: 'Opérations',
|
|
icon: Icons.calendar_today_outlined,
|
|
selectedIcon: Icons.calendar_today,
|
|
pageType: _PageType.operations,
|
|
requiredRole: 2,
|
|
),
|
|
];
|
|
|
|
// Construire la page basée sur le type
|
|
Widget _buildPage(_PageType pageType) {
|
|
switch (pageType) {
|
|
case _PageType.dashboardHome:
|
|
return const AdminDashboardHomePage();
|
|
case _PageType.statistics:
|
|
return const AdminStatisticsPage();
|
|
case _PageType.history:
|
|
return const AdminHistoryPage();
|
|
case _PageType.communication:
|
|
return const AdminCommunicationPage();
|
|
case _PageType.map:
|
|
return const AdminMapPage();
|
|
case _PageType.amicale:
|
|
return AdminAmicalePage(
|
|
userRepository: userRepository,
|
|
amicaleRepository: amicaleRepository,
|
|
membreRepository: membreRepository,
|
|
);
|
|
case _PageType.operations:
|
|
return const Scaffold(body: Center(child: Text('Page Opérations')));
|
|
}
|
|
}
|
|
|
|
// Construire la liste des destinations de navigation en fonction du rôle
|
|
List<NavigationDestination> _buildNavigationDestinations() {
|
|
final destinations = <NavigationDestination>[];
|
|
final currentUser = userRepository.getCurrentUser();
|
|
|
|
// Ajouter les éléments de base
|
|
for (final item in _baseNavigationItems) {
|
|
destinations.add(
|
|
NavigationDestination(
|
|
icon: Icon(item.icon),
|
|
selectedIcon: Icon(item.selectedIcon),
|
|
label: item.label,
|
|
),
|
|
);
|
|
}
|
|
|
|
// Ajouter les éléments admin si l'utilisateur a le rôle requis
|
|
if (currentUser?.role == 2) {
|
|
for (final item in _adminNavigationItems) {
|
|
if (item.requiredRole == null || item.requiredRole == 2) {
|
|
destinations.add(
|
|
NavigationDestination(
|
|
icon: Icon(item.icon),
|
|
selectedIcon: Icon(item.selectedIcon),
|
|
label: item.label,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return destinations;
|
|
}
|
|
|
|
// Construire la liste des pages en fonction du rôle
|
|
List<Widget> _buildPages() {
|
|
final pages = <Widget>[];
|
|
final currentUser = userRepository.getCurrentUser();
|
|
|
|
// Ajouter les pages de base
|
|
for (final item in _baseNavigationItems) {
|
|
pages.add(_buildPage(item.pageType));
|
|
}
|
|
|
|
// Ajouter les pages admin si l'utilisateur a le rôle requis
|
|
if (currentUser?.role == 2) {
|
|
for (final item in _adminNavigationItems) {
|
|
if (item.requiredRole == null || item.requiredRole == 2) {
|
|
pages.add(_buildPage(item.pageType));
|
|
}
|
|
}
|
|
}
|
|
|
|
return pages;
|
|
}
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
WidgetsBinding.instance.addObserver(this);
|
|
|
|
try {
|
|
debugPrint('Initialisation de AdminDashboardPage');
|
|
|
|
// Vérifier que userRepository est correctement initialisé
|
|
debugPrint('userRepository est correctement initialisé');
|
|
final currentUser = userRepository.getCurrentUser();
|
|
if (currentUser == null) {
|
|
debugPrint('ERREUR: Aucun utilisateur connecté dans AdminDashboardPage');
|
|
} else {
|
|
debugPrint('Utilisateur connecté: ${currentUser.username} (${currentUser.id})');
|
|
}
|
|
userRepository.addListener(_handleUserRepositoryChanges);
|
|
|
|
// Initialiser les pages et les destinations
|
|
_pages = _buildPages();
|
|
|
|
// Initialiser et charger les paramètres
|
|
_initSettings();
|
|
|
|
// Vérifier si des données sont en cours de chargement
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
_checkLoadingState();
|
|
});
|
|
} catch (e) {
|
|
debugPrint('ERREUR CRITIQUE dans AdminDashboardPage.initState: $e');
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
WidgetsBinding.instance.removeObserver(this);
|
|
userRepository.removeListener(_handleUserRepositoryChanges);
|
|
super.dispose();
|
|
}
|
|
|
|
// Méthode pour gérer les changements d'état du UserRepository
|
|
void _handleUserRepositoryChanges() {
|
|
_checkLoadingState();
|
|
}
|
|
|
|
// Méthode pour vérifier l'état de chargement (barre de progression désactivée)
|
|
void _checkLoadingState() {
|
|
// La barre de progression est désactivée, ne rien faire
|
|
}
|
|
|
|
// Initialiser la boîte de paramètres et charger les préférences
|
|
Future<void> _initSettings() async {
|
|
try {
|
|
// Ouvrir la boîte de paramètres si elle n'est pas déjà ouverte
|
|
if (!Hive.isBoxOpen(AppKeys.settingsBoxName)) {
|
|
_settingsBox = await Hive.openBox(AppKeys.settingsBoxName);
|
|
} else {
|
|
_settingsBox = Hive.box(AppKeys.settingsBoxName);
|
|
}
|
|
|
|
// Charger l'index de page sélectionné
|
|
final savedIndex = _settingsBox.get('adminSelectedPageIndex');
|
|
|
|
// Vérifier si l'index sauvegardé est valide
|
|
if (savedIndex != null && savedIndex is int) {
|
|
debugPrint('Index sauvegardé trouvé: $savedIndex');
|
|
|
|
// S'assurer que l'index est dans les limites valides
|
|
if (savedIndex >= 0 && savedIndex < _pages.length) {
|
|
setState(() {
|
|
_selectedIndex = savedIndex;
|
|
});
|
|
debugPrint('Index sauvegardé valide, utilisé: $_selectedIndex');
|
|
} else {
|
|
debugPrint(
|
|
'Index sauvegardé invalide ($savedIndex), utilisation de l\'index par défaut: 0',
|
|
);
|
|
// Réinitialiser l'index sauvegardé à 0 si invalide
|
|
_settingsBox.put('adminSelectedPageIndex', 0);
|
|
}
|
|
} else {
|
|
debugPrint(
|
|
'Aucun index sauvegardé trouvé, utilisation de l\'index par défaut: 0',
|
|
);
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Erreur lors du chargement des paramètres: $e');
|
|
}
|
|
}
|
|
|
|
// Sauvegarder les paramètres utilisateur
|
|
void _saveSettings() {
|
|
try {
|
|
// Sauvegarder l'index de page sélectionné
|
|
_settingsBox.put('adminSelectedPageIndex', _selectedIndex);
|
|
} catch (e) {
|
|
debugPrint('Erreur lors de la sauvegarde des paramètres: $e');
|
|
}
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Stack(
|
|
children: [
|
|
// Fond dégradé avec petits points blancs
|
|
Container(
|
|
decoration: BoxDecoration(
|
|
gradient: LinearGradient(
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
colors: [Colors.white, Colors.red.shade300],
|
|
),
|
|
),
|
|
child: CustomPaint(
|
|
painter: DotsPainter(),
|
|
child: const SizedBox(width: double.infinity, height: double.infinity),
|
|
),
|
|
),
|
|
// Contenu de la page
|
|
DashboardLayout(
|
|
title: 'Tableau de bord Administration',
|
|
selectedIndex: _selectedIndex,
|
|
onDestinationSelected: (index) {
|
|
setState(() {
|
|
_selectedIndex = index;
|
|
_saveSettings(); // Sauvegarder l'index de page sélectionné
|
|
});
|
|
},
|
|
destinations: _buildNavigationDestinations(),
|
|
showNewPassageButton: false,
|
|
isAdmin: true,
|
|
body: _pages[_selectedIndex],
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
// Enum pour les types de pages
|
|
enum _PageType {
|
|
dashboardHome,
|
|
statistics,
|
|
history,
|
|
communication,
|
|
map,
|
|
amicale,
|
|
operations,
|
|
}
|
|
|
|
// Classe pour représenter une destination de navigation avec sa page associée
|
|
class _NavigationItem {
|
|
final String label;
|
|
final IconData icon;
|
|
final IconData selectedIcon;
|
|
final _PageType pageType;
|
|
final int? requiredRole; // null si accessible à tous les rôles
|
|
|
|
const _NavigationItem({
|
|
required this.label,
|
|
required this.icon,
|
|
required this.selectedIcon,
|
|
required this.pageType,
|
|
this.requiredRole,
|
|
});
|
|
}
|