899 lines
29 KiB
Dart
899 lines
29 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:flutter_map/flutter_map.dart';
|
|
import 'package:latlong2/latlong.dart';
|
|
import 'package:hive_flutter/hive_flutter.dart';
|
|
import 'package:geosector_app/presentation/widgets/mapbox_map.dart';
|
|
import 'package:geosector_app/core/constants/app_keys.dart';
|
|
import 'package:geosector_app/core/services/location_service.dart';
|
|
import 'package:geosector_app/core/data/models/sector_model.dart';
|
|
import 'package:geosector_app/core/data/models/passage_model.dart';
|
|
import 'package:geosector_app/core/theme/app_theme.dart';
|
|
|
|
class AdminMapPage extends StatefulWidget {
|
|
const AdminMapPage({Key? key}) : super(key: key);
|
|
|
|
@override
|
|
State<AdminMapPage> createState() => _AdminMapPageState();
|
|
}
|
|
|
|
class _AdminMapPageState extends State<AdminMapPage> {
|
|
// Contrôleur de carte
|
|
final MapController _mapController = MapController();
|
|
|
|
// Position actuelle et zoom
|
|
LatLng _currentPosition =
|
|
const LatLng(48.117266, -1.6777926); // Position initiale sur Rennes
|
|
double _currentZoom = 12.0; // Zoom initial
|
|
|
|
// Données des secteurs et passages
|
|
final List<Map<String, dynamic>> _sectors = [];
|
|
final List<Map<String, dynamic>> _passages = [];
|
|
|
|
// États
|
|
bool _editMode = false;
|
|
int? _selectedSectorId;
|
|
List<DropdownMenuItem<int?>> _sectorItems = [];
|
|
|
|
// Référence à la boîte Hive pour les paramètres
|
|
late Box _settingsBox;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_initSettings().then((_) {
|
|
_loadSectors();
|
|
_loadPassages();
|
|
});
|
|
}
|
|
|
|
// Initialiser la boîte de paramètres et charger les préférences
|
|
Future<void> _initSettings() async {
|
|
// 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 le secteur sélectionné
|
|
_selectedSectorId = _settingsBox.get('admin_selectedSectorId');
|
|
|
|
// Charger la position et le zoom
|
|
final double? savedLat = _settingsBox.get('admin_mapLat');
|
|
final double? savedLng = _settingsBox.get('admin_mapLng');
|
|
final double? savedZoom = _settingsBox.get('admin_mapZoom');
|
|
|
|
if (savedLat != null && savedLng != null) {
|
|
_currentPosition = LatLng(savedLat, savedLng);
|
|
}
|
|
|
|
if (savedZoom != null) {
|
|
_currentZoom = savedZoom;
|
|
}
|
|
}
|
|
|
|
// Sauvegarder les paramètres utilisateur
|
|
void _saveSettings() {
|
|
// Sauvegarder le secteur sélectionné
|
|
if (_selectedSectorId != null) {
|
|
_settingsBox.put('admin_selectedSectorId', _selectedSectorId);
|
|
}
|
|
|
|
// Sauvegarder la position et le zoom actuels
|
|
_settingsBox.put('admin_mapLat', _currentPosition.latitude);
|
|
_settingsBox.put('admin_mapLng', _currentPosition.longitude);
|
|
_settingsBox.put('admin_mapZoom', _currentZoom);
|
|
}
|
|
|
|
// Charger les secteurs depuis la boîte Hive
|
|
void _loadSectors() {
|
|
try {
|
|
final sectorsBox = Hive.box<SectorModel>(AppKeys.sectorsBoxName);
|
|
final sectors = sectorsBox.values.toList();
|
|
|
|
setState(() {
|
|
_sectors.clear();
|
|
|
|
for (final sector in sectors) {
|
|
final List<List<double>> coordinates = sector.getCoordinates();
|
|
final List<LatLng> points =
|
|
coordinates.map((coord) => LatLng(coord[0], coord[1])).toList();
|
|
|
|
if (points.isNotEmpty) {
|
|
_sectors.add({
|
|
'id': sector.id,
|
|
'name': sector.libelle,
|
|
'color': _hexToColor(sector.color),
|
|
'points': points,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Si un secteur était sélectionné précédemment, le centrer
|
|
// Mettre à jour les items de la combobox de secteurs
|
|
_updateSectorItems();
|
|
|
|
if (_selectedSectorId != null &&
|
|
_sectors.any((s) => s['id'] == _selectedSectorId)) {
|
|
_centerMapOnSpecificSector(_selectedSectorId!);
|
|
}
|
|
// Sinon, centrer la carte sur tous les secteurs
|
|
else if (_sectors.isNotEmpty) {
|
|
_centerMapOnSectors();
|
|
}
|
|
});
|
|
} catch (e) {
|
|
debugPrint('Erreur lors du chargement des secteurs: $e');
|
|
}
|
|
}
|
|
|
|
// Charger les passages depuis la boîte Hive
|
|
void _loadPassages() {
|
|
try {
|
|
// Récupérer la boîte des passages
|
|
final passagesBox = Hive.box<PassageModel>(AppKeys.passagesBoxName);
|
|
|
|
// Créer une nouvelle liste temporaire
|
|
final List<Map<String, dynamic>> newPassages = [];
|
|
|
|
// Parcourir tous les passages dans la boîte
|
|
for (var i = 0; i < passagesBox.length; i++) {
|
|
final passage = passagesBox.getAt(i);
|
|
if (passage != null) {
|
|
// Vérifier si les coordonnées GPS sont valides
|
|
final lat = double.tryParse(passage.gpsLat);
|
|
final lng = double.tryParse(passage.gpsLng);
|
|
|
|
// Filtrer par secteur si un secteur est sélectionné
|
|
if (_selectedSectorId != null &&
|
|
passage.fkSector != _selectedSectorId) {
|
|
continue;
|
|
}
|
|
|
|
if (lat != null && lng != null) {
|
|
// Obtenir la couleur du type de passage
|
|
Color passageColor = Colors.grey; // Couleur par défaut
|
|
|
|
// Vérifier si le type de passage existe dans AppKeys.typesPassages
|
|
if (AppKeys.typesPassages.containsKey(passage.fkType)) {
|
|
// Utiliser la couleur1 du type de passage
|
|
final colorValue =
|
|
AppKeys.typesPassages[passage.fkType]!['couleur1'] as int;
|
|
passageColor = Color(colorValue);
|
|
|
|
// Ajouter le passage à la liste temporaire
|
|
newPassages.add({
|
|
'id': passage.id,
|
|
'position': LatLng(lat, lng),
|
|
'type': passage.fkType,
|
|
'color': passageColor,
|
|
'model': passage, // Ajouter le modèle complet
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mettre à jour la liste des passages dans l'état
|
|
setState(() {
|
|
_passages.clear();
|
|
_passages.addAll(newPassages);
|
|
});
|
|
|
|
// Sauvegarder les paramètres après chargement des passages
|
|
_saveSettings();
|
|
} catch (e) {
|
|
debugPrint('Erreur lors du chargement des passages: $e');
|
|
}
|
|
}
|
|
|
|
// Convertir une couleur hexadécimale en Color
|
|
Color _hexToColor(String hexColor) {
|
|
// Supprimer le # si présent
|
|
final String colorStr =
|
|
hexColor.startsWith('#') ? hexColor.substring(1) : hexColor;
|
|
|
|
// Ajouter FF pour l'opacité si nécessaire (6 caractères -> 8 caractères)
|
|
final String fullColorStr = colorStr.length == 6 ? 'FF$colorStr' : colorStr;
|
|
|
|
// Convertir en entier et créer la couleur
|
|
return Color(int.parse(fullColorStr, radix: 16));
|
|
}
|
|
|
|
// Centrer la carte sur tous les secteurs
|
|
void _centerMapOnSectors() {
|
|
if (_sectors.isEmpty) return;
|
|
|
|
// Trouver les limites de tous les secteurs
|
|
double minLat = 90.0;
|
|
double maxLat = -90.0;
|
|
double minLng = 180.0;
|
|
double maxLng = -180.0;
|
|
|
|
for (final sector in _sectors) {
|
|
final points = sector['points'] as List<LatLng>;
|
|
for (final point in points) {
|
|
minLat = point.latitude < minLat ? point.latitude : minLat;
|
|
maxLat = point.latitude > maxLat ? point.latitude : maxLat;
|
|
minLng = point.longitude < minLng ? point.longitude : minLng;
|
|
maxLng = point.longitude > maxLng ? point.longitude : maxLng;
|
|
}
|
|
}
|
|
|
|
// Ajouter un padding aux limites pour s'assurer que tous les secteurs sont entièrement visibles
|
|
// avec une marge autour (5% de la taille totale)
|
|
final latPadding = (maxLat - minLat) * 0.05;
|
|
final lngPadding = (maxLng - minLng) * 0.05;
|
|
|
|
minLat -= latPadding;
|
|
maxLat += latPadding;
|
|
minLng -= lngPadding;
|
|
maxLng += lngPadding;
|
|
|
|
// Calculer le centre
|
|
final centerLat = (minLat + maxLat) / 2;
|
|
final centerLng = (minLng + maxLng) / 2;
|
|
|
|
// Calculer le zoom approprié en tenant compte des dimensions de l'écran
|
|
final mapWidth = MediaQuery.of(context).size.width;
|
|
final mapHeight = MediaQuery.of(context).size.height *
|
|
0.7; // Estimation de la hauteur de la carte
|
|
final zoom = _calculateOptimalZoom(
|
|
minLat, maxLat, minLng, maxLng, mapWidth, mapHeight);
|
|
|
|
// Centrer la carte sur ces limites avec animation
|
|
_mapController.move(LatLng(centerLat, centerLng), zoom);
|
|
|
|
// Mettre à jour l'état pour refléter la nouvelle position
|
|
setState(() {
|
|
_currentPosition = LatLng(centerLat, centerLng);
|
|
_currentZoom = zoom;
|
|
});
|
|
|
|
debugPrint('Carte centrée sur tous les secteurs avec zoom: $zoom');
|
|
}
|
|
|
|
// Mettre à jour les items de la combobox de secteurs
|
|
void _updateSectorItems() {
|
|
// Créer l'item "Tous les secteurs"
|
|
final List<DropdownMenuItem<int?>> items = [
|
|
const DropdownMenuItem<int?>(
|
|
value: null,
|
|
child: Text('Tous les secteurs'),
|
|
),
|
|
];
|
|
|
|
// Ajouter tous les secteurs
|
|
for (final sector in _sectors) {
|
|
items.add(
|
|
DropdownMenuItem<int?>(
|
|
value: sector['id'] as int,
|
|
child: Text(sector['name'] as String),
|
|
),
|
|
);
|
|
}
|
|
|
|
setState(() {
|
|
_sectorItems = items;
|
|
});
|
|
}
|
|
|
|
// Centrer la carte sur un secteur spécifique
|
|
void _centerMapOnSpecificSector(int sectorId) {
|
|
final sectorIndex = _sectors.indexWhere((s) => s['id'] == sectorId);
|
|
if (sectorIndex == -1) return;
|
|
|
|
// Mettre à jour le secteur sélectionné
|
|
_selectedSectorId = sectorId;
|
|
|
|
final sector = _sectors[sectorIndex];
|
|
final points = sector['points'] as List<LatLng>;
|
|
final sectorName = sector['name'] as String;
|
|
|
|
debugPrint(
|
|
'Centrage sur le secteur: $sectorName (ID: $sectorId) avec ${points.length} points');
|
|
|
|
if (points.isEmpty) {
|
|
debugPrint('Aucun point dans ce secteur!');
|
|
return;
|
|
}
|
|
|
|
// Trouver les limites du secteur
|
|
double minLat = 90.0;
|
|
double maxLat = -90.0;
|
|
double minLng = 180.0;
|
|
double maxLng = -180.0;
|
|
|
|
for (final point in points) {
|
|
minLat = point.latitude < minLat ? point.latitude : minLat;
|
|
maxLat = point.latitude > maxLat ? point.latitude : maxLat;
|
|
minLng = point.longitude < minLng ? point.longitude : minLng;
|
|
maxLng = point.longitude > maxLng ? point.longitude : maxLng;
|
|
}
|
|
|
|
// Vérifier si les coordonnées sont valides
|
|
if (minLat >= maxLat || minLng >= maxLng) {
|
|
debugPrint('Coordonnées invalides pour le secteur $sectorName');
|
|
return;
|
|
}
|
|
|
|
// Calculer la taille du secteur
|
|
final latSpan = maxLat - minLat;
|
|
final lngSpan = maxLng - minLng;
|
|
|
|
// Ajouter un padding minimal aux limites pour s'assurer que le secteur est bien visible
|
|
final double latPadding, lngPadding;
|
|
if (latSpan < 0.01 || lngSpan < 0.01) {
|
|
// Pour les très petits secteurs, utiliser un padding très réduit
|
|
latPadding = 0.0003;
|
|
lngPadding = 0.0003;
|
|
} else if (latSpan < 0.05 || lngSpan < 0.05) {
|
|
// Pour les petits secteurs, padding réduit
|
|
latPadding = 0.0005;
|
|
lngPadding = 0.0005;
|
|
} else {
|
|
// Pour les secteurs plus grands, utiliser un pourcentage minimal
|
|
latPadding = latSpan * 0.03; // 3% au lieu de 10%
|
|
lngPadding = lngSpan * 0.03;
|
|
}
|
|
|
|
minLat -= latPadding;
|
|
maxLat += latPadding;
|
|
minLng -= lngPadding;
|
|
maxLng += lngPadding;
|
|
|
|
// Calculer le centre
|
|
final centerLat = (minLat + maxLat) / 2;
|
|
final centerLng = (minLng + maxLng) / 2;
|
|
|
|
// Déterminer le zoom approprié en fonction de la taille du secteur
|
|
double zoom;
|
|
|
|
// Pour les très petits secteurs (comme des quartiers), utiliser un zoom fixe élevé
|
|
if (latSpan < 0.01 && lngSpan < 0.01) {
|
|
zoom = 16.0; // Zoom élevé pour les petits quartiers
|
|
} else if (latSpan < 0.02 && lngSpan < 0.02) {
|
|
zoom = 15.0; // Zoom élevé pour les petits quartiers
|
|
} else if (latSpan < 0.05 && lngSpan < 0.05) {
|
|
zoom =
|
|
13.0; // Zoom pour les secteurs de taille moyenne (quelques quartiers)
|
|
} else if (latSpan < 0.1 && lngSpan < 0.1) {
|
|
zoom = 12.0; // Zoom pour les grands secteurs (ville)
|
|
} else {
|
|
// Pour les secteurs plus grands, calculer le zoom
|
|
final mapWidth = MediaQuery.of(context).size.width;
|
|
final mapHeight = MediaQuery.of(context).size.height * 0.7;
|
|
zoom = _calculateOptimalZoom(
|
|
minLat, maxLat, minLng, maxLng, mapWidth, mapHeight);
|
|
}
|
|
|
|
// Centrer la carte sur le secteur avec animation
|
|
_mapController.move(LatLng(centerLat, centerLng), zoom);
|
|
|
|
// Mettre à jour l'état pour refléter la nouvelle position
|
|
setState(() {
|
|
_currentPosition = LatLng(centerLat, centerLng);
|
|
_currentZoom = zoom;
|
|
});
|
|
|
|
// Recharger les passages pour appliquer le filtre par secteur
|
|
_loadPassages();
|
|
}
|
|
|
|
// Calculer le zoom optimal pour afficher une zone géographique dans la fenêtre de la carte
|
|
double _calculateOptimalZoom(double minLat, double maxLat, double minLng,
|
|
double maxLng, double mapWidth, double mapHeight) {
|
|
// Vérifier si les coordonnées sont valides
|
|
if (minLat >= maxLat || minLng >= maxLng) {
|
|
debugPrint('Coordonnées invalides pour le calcul du zoom');
|
|
return 12.0; // Valeur par défaut raisonnable
|
|
}
|
|
|
|
// Calculer la taille en degrés
|
|
final latSpan = maxLat - minLat;
|
|
final lngSpan = maxLng - minLng;
|
|
|
|
// Ajouter un facteur de sécurité pour éviter les divisions par zéro
|
|
if (latSpan < 0.0000001 || lngSpan < 0.0000001) {
|
|
return 15.0; // Zoom élevé pour un point très précis
|
|
}
|
|
|
|
// Formule simplifiée pour le calcul du zoom
|
|
double zoom;
|
|
|
|
if (latSpan < 0.005 || lngSpan < 0.005) {
|
|
// Très petite zone (quartier)
|
|
zoom = 16.0;
|
|
} else if (latSpan < 0.01 || lngSpan < 0.01) {
|
|
// Petite zone (quartier)
|
|
zoom = 15.0;
|
|
} else if (latSpan < 0.02 || lngSpan < 0.02) {
|
|
// Petite zone (plusieurs quartiers)
|
|
zoom = 14.0;
|
|
} else if (latSpan < 0.05 || lngSpan < 0.05) {
|
|
// Zone moyenne (ville)
|
|
zoom = 13.0;
|
|
} else if (latSpan < 0.2 || lngSpan < 0.2) {
|
|
// Grande zone (agglomération)
|
|
zoom = 11.0;
|
|
} else if (latSpan < 0.5 || lngSpan < 0.5) {
|
|
// Très grande zone (département)
|
|
zoom = 9.0;
|
|
} else if (latSpan < 2.0 || lngSpan < 2.0) {
|
|
// Région
|
|
zoom = 7.0;
|
|
} else if (latSpan < 5.0 || lngSpan < 5.0) {
|
|
// Pays
|
|
zoom = 5.0;
|
|
} else {
|
|
// Continent ou plus
|
|
zoom = 3.0;
|
|
}
|
|
|
|
return zoom;
|
|
}
|
|
|
|
// Obtenir la position actuelle de l'utilisateur
|
|
Future<void> _getUserLocation() async {
|
|
try {
|
|
// Afficher un indicateur de chargement
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Recherche de votre position...'),
|
|
duration: Duration(seconds: 2),
|
|
),
|
|
);
|
|
|
|
// Obtenir la position actuelle via le service de géolocalisation
|
|
final position = await LocationService.getCurrentPosition();
|
|
|
|
if (position != null) {
|
|
// Mettre à jour la position sur la carte
|
|
_updateMapPosition(position, zoom: 17);
|
|
|
|
// Sauvegarder la nouvelle position
|
|
_settingsBox.put('admin_mapLat', position.latitude);
|
|
_settingsBox.put('admin_mapLng', position.longitude);
|
|
|
|
// Informer l'utilisateur
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Position actualisée'),
|
|
backgroundColor: Colors.green,
|
|
duration: Duration(seconds: 1),
|
|
),
|
|
);
|
|
}
|
|
} else {
|
|
// Informer l'utilisateur en cas d'échec
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text(
|
|
'Impossible d\'obtenir votre position. Vérifiez vos paramètres de localisation.'),
|
|
backgroundColor: Colors.red,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
// Gérer les erreurs
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text('Erreur: $e'),
|
|
backgroundColor: Colors.red,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Méthode pour mettre à jour la position sur la carte
|
|
void _updateMapPosition(LatLng position, {double? zoom}) {
|
|
_mapController.move(
|
|
position,
|
|
zoom ?? _mapController.camera.zoom,
|
|
);
|
|
|
|
// Mettre à jour les variables d'état
|
|
setState(() {
|
|
_currentPosition = position;
|
|
if (zoom != null) {
|
|
_currentZoom = zoom;
|
|
}
|
|
});
|
|
|
|
// Sauvegarder les paramètres après mise à jour de la position
|
|
_saveSettings();
|
|
}
|
|
|
|
// Méthode pour construire les marqueurs des passages
|
|
List<Marker> _buildMarkers() {
|
|
if (_passages.isEmpty) {
|
|
return [];
|
|
}
|
|
|
|
return _passages.map((passage) {
|
|
final int passageType = passage['type'] as int;
|
|
final Color color1 =
|
|
passage['color'] as Color; // couleur1 du type de passage
|
|
|
|
// Récupérer la couleur2 du type de passage
|
|
Color color2 = Colors.white; // Couleur par défaut
|
|
if (AppKeys.typesPassages.containsKey(passageType)) {
|
|
final colorValue =
|
|
AppKeys.typesPassages[passageType]!['couleur2'] as int;
|
|
color2 = Color(colorValue);
|
|
}
|
|
|
|
return Marker(
|
|
point: passage['position'] as LatLng,
|
|
width: 14.0,
|
|
height: 14.0,
|
|
child: GestureDetector(
|
|
onTap: () {
|
|
_showPassageInfo(passage);
|
|
},
|
|
child: Container(
|
|
decoration: BoxDecoration(
|
|
color: color1,
|
|
shape: BoxShape.circle,
|
|
border: Border.all(
|
|
color: color2,
|
|
width: 1.0,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}).toList();
|
|
}
|
|
|
|
// Méthode pour construire les polygones des secteurs
|
|
List<Polygon> _buildPolygons() {
|
|
if (_sectors.isEmpty) {
|
|
return [];
|
|
}
|
|
|
|
return _sectors.map((sector) {
|
|
final bool isSelected = _selectedSectorId == sector['id'];
|
|
final Color sectorColor = sector['color'] as Color;
|
|
|
|
return Polygon(
|
|
points: sector['points'] as List<LatLng>,
|
|
color: isSelected
|
|
? sectorColor.withOpacity(0.5)
|
|
: sectorColor.withOpacity(0.3),
|
|
borderColor: isSelected ? sectorColor : sectorColor.withOpacity(0.8),
|
|
borderStrokeWidth: isSelected ? 3.0 : 2.0,
|
|
);
|
|
}).toList();
|
|
}
|
|
|
|
// Afficher les informations d'un passage lorsqu'on clique dessus
|
|
void _showPassageInfo(Map<String, dynamic> passage) {
|
|
final PassageModel passageModel = passage['model'] as PassageModel;
|
|
final int type = passageModel.fkType;
|
|
|
|
// Construire l'adresse complète
|
|
final String adresse =
|
|
'${passageModel.numero}, ${passageModel.rueBis} ${passageModel.rue}';
|
|
|
|
// Informations sur l'étage, l'appartement et la résidence (si habitat = 2)
|
|
String? etageInfo;
|
|
String? apptInfo;
|
|
String? residenceInfo;
|
|
if (passageModel.fkHabitat == 2) {
|
|
if (passageModel.niveau.isNotEmpty) {
|
|
etageInfo = 'Etage ${passageModel.niveau}';
|
|
}
|
|
if (passageModel.appt.isNotEmpty) {
|
|
apptInfo = 'appt. ${passageModel.appt}';
|
|
}
|
|
if (passageModel.residence.isNotEmpty) {
|
|
residenceInfo = passageModel.residence;
|
|
}
|
|
}
|
|
|
|
// Formater la date (uniquement si le type n'est pas 2)
|
|
String dateInfo = '';
|
|
if (type != 2) {
|
|
dateInfo = 'Date: ${_formatDate(passageModel.passedAt)}';
|
|
}
|
|
|
|
// Récupérer le nom du passage (si le type n'est pas 6 - Maison vide)
|
|
String? nomInfo;
|
|
if (type != 6 && passageModel.name.isNotEmpty) {
|
|
nomInfo = passageModel.name;
|
|
}
|
|
|
|
// Récupérer les informations de règlement si le type est 1 (Effectué) ou 5 (Lot)
|
|
Widget? reglementInfo;
|
|
if (type == 1 || type == 5) {
|
|
final int typeReglementId = passageModel.fkTypeReglement;
|
|
final String montant = passageModel.montant;
|
|
|
|
// Récupérer les informations du type de règlement
|
|
if (AppKeys.typesReglements.containsKey(typeReglementId)) {
|
|
final Map<String, dynamic> typeReglement =
|
|
AppKeys.typesReglements[typeReglementId]!;
|
|
final String titre = typeReglement['titre'] as String;
|
|
final Color couleur = Color(typeReglement['couleur'] as int);
|
|
final IconData iconData = typeReglement['icon_data'] as IconData;
|
|
|
|
reglementInfo = Padding(
|
|
padding: const EdgeInsets.only(top: 8.0),
|
|
child: Row(
|
|
children: [
|
|
Icon(iconData, color: couleur, size: 20),
|
|
const SizedBox(width: 8),
|
|
Text('$titre: $montant €',
|
|
style:
|
|
TextStyle(color: couleur, fontWeight: FontWeight.bold)),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
// Afficher une bulle d'information
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => AlertDialog(
|
|
contentPadding: const EdgeInsets.fromLTRB(24, 20, 24, 0),
|
|
content: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text('Adresse: $adresse'),
|
|
if (residenceInfo != null) ...[
|
|
const SizedBox(height: 4),
|
|
Text(residenceInfo)
|
|
],
|
|
if (etageInfo != null) ...[
|
|
const SizedBox(height: 4),
|
|
Text(etageInfo)
|
|
],
|
|
if (apptInfo != null) ...[
|
|
const SizedBox(height: 4),
|
|
Text(apptInfo)
|
|
],
|
|
if (dateInfo.isNotEmpty) ...[
|
|
const SizedBox(height: 8),
|
|
Text(dateInfo)
|
|
],
|
|
if (nomInfo != null) ...[
|
|
const SizedBox(height: 8),
|
|
Text('Nom: $nomInfo')
|
|
],
|
|
if (reglementInfo != null) reglementInfo,
|
|
],
|
|
),
|
|
actionsPadding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
|
|
actions: [
|
|
Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
Row(
|
|
children: [
|
|
// Bouton d'édition
|
|
IconButton(
|
|
onPressed: () {
|
|
Navigator.of(context).pop();
|
|
// Logique pour éditer le passage
|
|
debugPrint('Éditer le passage ${passageModel.id}');
|
|
},
|
|
icon: const Icon(Icons.edit),
|
|
color: Colors.blue,
|
|
tooltip: 'Modifier',
|
|
),
|
|
|
|
// Bouton de suppression
|
|
IconButton(
|
|
onPressed: () {
|
|
Navigator.of(context).pop();
|
|
// Logique pour supprimer le passage
|
|
debugPrint('Supprimer le passage ${passageModel.id}');
|
|
},
|
|
icon: const Icon(Icons.delete),
|
|
color: Colors.red,
|
|
tooltip: 'Supprimer',
|
|
),
|
|
],
|
|
),
|
|
|
|
// Bouton de fermeture
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('Fermer'),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
// Formater une date
|
|
String _formatDate(DateTime date) {
|
|
return '${date.day.toString().padLeft(2, '0')}/${date.month.toString().padLeft(2, '0')}/${date.year}';
|
|
}
|
|
|
|
// Widget pour les boutons d'action
|
|
Widget _buildActionButton({
|
|
required IconData icon,
|
|
required String tooltip,
|
|
required VoidCallback? onPressed,
|
|
Color color = Colors.blue,
|
|
}) {
|
|
return Container(
|
|
decoration: BoxDecoration(
|
|
shape: BoxShape.circle,
|
|
boxShadow: [
|
|
BoxShadow(
|
|
color: Colors.black.withOpacity(0.2),
|
|
blurRadius: 4,
|
|
offset: const Offset(0, 2),
|
|
),
|
|
],
|
|
),
|
|
child: FloatingActionButton(
|
|
heroTag: tooltip, // Nécessaire pour éviter les conflits de hero tags
|
|
onPressed: onPressed,
|
|
backgroundColor: onPressed != null ? color : Colors.grey,
|
|
tooltip: tooltip,
|
|
mini: true,
|
|
child: Icon(icon),
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Stack(
|
|
children: [
|
|
// Carte MapBox
|
|
MapboxMap(
|
|
initialPosition: _currentPosition,
|
|
initialZoom: _currentZoom,
|
|
mapController: _mapController,
|
|
markers: _buildMarkers(),
|
|
polygons: _buildPolygons(),
|
|
showControls: true,
|
|
onMapEvent: (event) {
|
|
if (event is MapEventMove) {
|
|
setState(() {
|
|
_currentPosition = event.camera.center;
|
|
_currentZoom = event.camera.zoom;
|
|
});
|
|
_saveSettings();
|
|
}
|
|
},
|
|
),
|
|
|
|
// Bouton Mode édition en haut à droite
|
|
Positioned(
|
|
right: 16,
|
|
top: 16,
|
|
child: _buildActionButton(
|
|
icon: Icons.edit,
|
|
tooltip: 'Mode édition',
|
|
color: _editMode ? Colors.green : Colors.blue,
|
|
onPressed: () {
|
|
setState(() {
|
|
_editMode = !_editMode;
|
|
});
|
|
},
|
|
),
|
|
),
|
|
|
|
// Boutons d'action sous le bouton Mode édition
|
|
Positioned(
|
|
right: 16,
|
|
top: 80, // Positionner sous le bouton Mode édition
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.end,
|
|
children: [
|
|
if (_editMode) ...[
|
|
_buildActionButton(
|
|
icon: Icons.add,
|
|
tooltip: 'Ajouter un secteur',
|
|
onPressed: () {
|
|
// Action pour ajouter un secteur
|
|
},
|
|
),
|
|
const SizedBox(height: 8),
|
|
_buildActionButton(
|
|
icon: Icons.edit,
|
|
tooltip: 'Modifier le secteur sélectionné',
|
|
onPressed: _selectedSectorId != null
|
|
? () {
|
|
// Action pour modifier le secteur sélectionné
|
|
}
|
|
: null,
|
|
),
|
|
const SizedBox(height: 8),
|
|
_buildActionButton(
|
|
icon: Icons.delete,
|
|
tooltip: 'Supprimer le secteur sélectionné',
|
|
color: Colors.red,
|
|
onPressed: _selectedSectorId != null
|
|
? () {
|
|
// Action pour supprimer le secteur sélectionné
|
|
}
|
|
: null,
|
|
),
|
|
const SizedBox(height: 16),
|
|
],
|
|
],
|
|
),
|
|
),
|
|
|
|
// Bouton Ma position en bas à droite
|
|
Positioned(
|
|
right: 16,
|
|
bottom: 16,
|
|
child: _buildActionButton(
|
|
icon: Icons.my_location,
|
|
tooltip: 'Ma position',
|
|
onPressed: () {
|
|
_getUserLocation();
|
|
},
|
|
),
|
|
),
|
|
|
|
// Combobox de sélection de secteurs
|
|
Positioned(
|
|
left: 16,
|
|
top: 16,
|
|
child: Material(
|
|
elevation: 4,
|
|
borderRadius: BorderRadius.circular(8),
|
|
child: Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4),
|
|
width: 220, // Largeur fixe pour accommoder les noms longs
|
|
decoration: BoxDecoration(
|
|
color: Colors.white.withOpacity(0.95),
|
|
borderRadius: BorderRadius.circular(8),
|
|
),
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(Icons.location_on, size: 18, color: Colors.blue),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: DropdownButton<int?>(
|
|
value: _selectedSectorId,
|
|
hint: const Text('Tous les secteurs'),
|
|
isExpanded: true,
|
|
underline: Container(), // Supprimer la ligne sous le dropdown
|
|
icon: Icon(Icons.arrow_drop_down, color: Colors.blue),
|
|
items: _sectorItems,
|
|
onChanged: (int? sectorId) {
|
|
setState(() {
|
|
_selectedSectorId = sectorId;
|
|
});
|
|
|
|
if (sectorId != null) {
|
|
_centerMapOnSpecificSector(sectorId);
|
|
} else {
|
|
// Si "Tous les secteurs" est sélectionné
|
|
_centerMapOnSectors();
|
|
// Recharger tous les passages sans filtrage par secteur
|
|
_loadPassages();
|
|
}
|
|
},
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|