Pierre
206c76c7db
- Amélioration de la gestion des entités et des utilisateurs - Mise à jour des modèles Amicale et Client avec champs supplémentaires - Ajout du service de logging et amélioration du chargement UI - Refactoring des formulaires utilisateur et amicale - Intégration de file_picker et image_picker pour la gestion des fichiers - Amélioration de la gestion des membres et de leur suppression - Optimisation des performances de l'API - Mise à jour de la documentation technique 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
1011 lines
40 KiB
Dart
Executable File
1011 lines
40 KiB
Dart
Executable File
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:intl/intl.dart';
|
|
import 'dart:math';
|
|
import 'package:geosector_app/core/data/models/user_model.dart';
|
|
import 'package:geosector_app/core/data/models/amicale_model.dart';
|
|
import 'package:geosector_app/core/services/api_service.dart';
|
|
import 'custom_text_field.dart';
|
|
|
|
class UserForm extends StatefulWidget {
|
|
final UserModel? user;
|
|
final Function(UserModel)? onSubmit;
|
|
final bool readOnly;
|
|
final bool allowUsernameEdit;
|
|
final bool allowSectNameEdit;
|
|
final AmicaleModel? amicale; // Nouveau paramètre pour l'amicale
|
|
final bool isAdmin; // Nouveau paramètre pour savoir si c'est un admin
|
|
|
|
const UserForm({
|
|
super.key,
|
|
this.user,
|
|
this.onSubmit,
|
|
this.readOnly = false,
|
|
this.allowUsernameEdit = false,
|
|
this.allowSectNameEdit = false,
|
|
this.amicale,
|
|
this.isAdmin = false,
|
|
});
|
|
|
|
@override
|
|
State<UserForm> createState() => _UserFormState();
|
|
}
|
|
|
|
class _UserFormState extends State<UserForm> {
|
|
final _formKey = GlobalKey<FormState>();
|
|
|
|
// Controllers
|
|
late final TextEditingController _usernameController;
|
|
late final TextEditingController _firstNameController;
|
|
late final TextEditingController _nameController;
|
|
late final TextEditingController _sectNameController;
|
|
late final TextEditingController _phoneController;
|
|
late final TextEditingController _mobileController;
|
|
late final TextEditingController _emailController;
|
|
late final TextEditingController _dateNaissanceController;
|
|
late final TextEditingController _dateEmbaucheController;
|
|
late final TextEditingController _passwordController; // Nouveau controller pour le mot de passe
|
|
|
|
// Form values
|
|
int _fkTitre = 1; // 1 = M., 2 = Mme
|
|
DateTime? _dateNaissance;
|
|
DateTime? _dateEmbauche;
|
|
|
|
// Pour la génération automatique d'username
|
|
bool _isGeneratingUsername = false;
|
|
final Random _random = Random();
|
|
|
|
// Pour afficher/masquer le mot de passe
|
|
bool _obscurePassword = true;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
|
|
// Initialize controllers with user data if available
|
|
final user = widget.user;
|
|
_usernameController = TextEditingController(text: user?.username ?? '');
|
|
_firstNameController = TextEditingController(text: user?.firstName ?? '');
|
|
_nameController = TextEditingController(text: user?.name ?? '');
|
|
_sectNameController = TextEditingController(text: user?.sectName ?? '');
|
|
_phoneController = TextEditingController(text: user?.phone ?? '');
|
|
_mobileController = TextEditingController(text: user?.mobile ?? '');
|
|
_emailController = TextEditingController(text: user?.email ?? '');
|
|
|
|
_dateNaissance = user?.dateNaissance;
|
|
_dateEmbauche = user?.dateEmbauche;
|
|
|
|
_dateNaissanceController = TextEditingController(text: _dateNaissance != null ? DateFormat('dd/MM/yyyy').format(_dateNaissance!) : '');
|
|
|
|
_dateEmbaucheController = TextEditingController(text: _dateEmbauche != null ? DateFormat('dd/MM/yyyy').format(_dateEmbauche!) : '');
|
|
|
|
_passwordController = TextEditingController(); // Initialiser le controller du mot de passe
|
|
|
|
_fkTitre = user?.fkTitre ?? 1;
|
|
|
|
// Ajouter des listeners pour auto-générer l'username en création
|
|
if (widget.user?.id == 0 && widget.isAdmin && widget.amicale?.chkUsernameManuel == true) {
|
|
_nameController.addListener(_onNameOrSectNameChanged);
|
|
_sectNameController.addListener(_onNameOrSectNameChanged);
|
|
}
|
|
}
|
|
|
|
void _onNameOrSectNameChanged() {
|
|
// Auto-générer username seulement en création et si le champ username est vide
|
|
if (widget.user?.id == 0 &&
|
|
_usernameController.text.isEmpty &&
|
|
(_nameController.text.isNotEmpty || _sectNameController.text.isNotEmpty)) {
|
|
_generateAndCheckUsername();
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
// Retirer les listeners si ajoutés
|
|
if (widget.user?.id == 0 && widget.isAdmin && widget.amicale?.chkUsernameManuel == true) {
|
|
_nameController.removeListener(_onNameOrSectNameChanged);
|
|
_sectNameController.removeListener(_onNameOrSectNameChanged);
|
|
}
|
|
|
|
_usernameController.dispose();
|
|
_firstNameController.dispose();
|
|
_nameController.dispose();
|
|
_sectNameController.dispose();
|
|
_phoneController.dispose();
|
|
_mobileController.dispose();
|
|
_emailController.dispose();
|
|
_dateNaissanceController.dispose();
|
|
_dateEmbaucheController.dispose();
|
|
_passwordController.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
// Validation conditionnelle pour name/sectName
|
|
String? _validateNameOrSectName(String? value, bool isNameField) {
|
|
final nameValue = _nameController.text.trim();
|
|
final sectNameValue = _sectNameController.text.trim();
|
|
|
|
// Si les deux sont vides
|
|
if (nameValue.isEmpty && sectNameValue.isEmpty) {
|
|
return isNameField ? "Veuillez renseigner soit le nom soit le nom de tournée" : "Veuillez renseigner soit le nom de tournée soit le nom";
|
|
}
|
|
|
|
return null; // Validation OK si au moins un des deux est rempli
|
|
}
|
|
|
|
// Méthode simplifiée pour sélectionner une date
|
|
void _selectDate(BuildContext context, bool isDateNaissance) {
|
|
// Utiliser un bloc try-catch pour capturer toutes les erreurs possibles
|
|
try {
|
|
// Déterminer la date initiale
|
|
DateTime initialDate;
|
|
if (isDateNaissance) {
|
|
initialDate = _dateNaissance ?? DateTime.now().subtract(const Duration(days: 365 * 30)); // 30 ans par défaut
|
|
} else {
|
|
initialDate = _dateEmbauche ?? DateTime.now();
|
|
}
|
|
|
|
// S'assurer que la date initiale est dans la plage autorisée
|
|
if (initialDate.isAfter(DateTime.now())) {
|
|
initialDate = DateTime.now();
|
|
}
|
|
if (initialDate.isBefore(DateTime(1900))) {
|
|
initialDate = DateTime(1950);
|
|
}
|
|
|
|
// Afficher le sélecteur de date avec locale française
|
|
showDatePicker(
|
|
context: context,
|
|
initialDate: initialDate,
|
|
firstDate: DateTime(1900),
|
|
lastDate: DateTime.now(),
|
|
locale: const Locale('fr', 'FR'), // Forcer la locale française
|
|
builder: (context, child) {
|
|
return Theme(
|
|
data: Theme.of(context).copyWith(
|
|
colorScheme: Theme.of(context).colorScheme.copyWith(
|
|
primary: Theme.of(context).colorScheme.primary,
|
|
onPrimary: Colors.white,
|
|
surface: Colors.white,
|
|
onSurface: Colors.black,
|
|
),
|
|
),
|
|
child: child!,
|
|
);
|
|
},
|
|
helpText: isDateNaissance ? 'SÉLECTIONNER LA DATE DE NAISSANCE' : 'SÉLECTIONNER LA DATE D\'EMBAUCHE',
|
|
cancelText: 'ANNULER',
|
|
confirmText: 'VALIDER',
|
|
fieldLabelText: 'Entrer une date',
|
|
fieldHintText: 'jj/mm/aaaa',
|
|
errorFormatText: 'Format de date invalide',
|
|
errorInvalidText: 'Date invalide',
|
|
).then((DateTime? picked) {
|
|
// Vérifier si une date a été sélectionnée
|
|
if (picked != null) {
|
|
setState(() {
|
|
// Mettre à jour la date et le texte du contrôleur
|
|
if (isDateNaissance) {
|
|
_dateNaissance = picked;
|
|
_dateNaissanceController.text = DateFormat('dd/MM/yyyy').format(picked);
|
|
} else {
|
|
_dateEmbauche = picked;
|
|
_dateEmbaucheController.text = DateFormat('dd/MM/yyyy').format(picked);
|
|
}
|
|
});
|
|
}
|
|
}).catchError((error) {
|
|
// Gérer les erreurs spécifiques au sélecteur de date
|
|
debugPrint('Erreur lors de la sélection de la date: $error');
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Erreur lors de la sélection de la date'),
|
|
backgroundColor: Colors.red,
|
|
),
|
|
);
|
|
});
|
|
} catch (e) {
|
|
// Gérer toutes les autres erreurs
|
|
debugPrint('Exception lors de l\'affichage du sélecteur de date: $e');
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Impossible d\'afficher le sélecteur de date'),
|
|
backgroundColor: Colors.red,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
// Nettoyer une chaîne pour l'username
|
|
String _cleanString(String input) {
|
|
return input.toLowerCase()
|
|
.replaceAll(RegExp(r'[^a-z0-9]'), ''); // Garder seulement lettres et chiffres
|
|
}
|
|
|
|
// Extraire une partie aléatoire d'une chaîne
|
|
String _extractRandomPart(String input, int minLength, int maxLength) {
|
|
if (input.isEmpty) return '';
|
|
final cleaned = _cleanString(input);
|
|
if (cleaned.isEmpty) return '';
|
|
|
|
final length = minLength + _random.nextInt(maxLength - minLength + 1);
|
|
if (cleaned.length <= length) return cleaned;
|
|
|
|
// Prendre les premiers caractères jusqu'à la longueur désirée
|
|
return cleaned.substring(0, length);
|
|
}
|
|
|
|
// Générer un username selon l'algorithme spécifié
|
|
String _generateUsername() {
|
|
// Récupérer les données nécessaires
|
|
final nom = _nameController.text.isNotEmpty ? _nameController.text : _sectNameController.text;
|
|
final codePostal = widget.amicale?.codePostal ?? '';
|
|
final ville = widget.amicale?.ville ?? '';
|
|
|
|
// Nettoyer et extraire les parties
|
|
final nomPart = _extractRandomPart(nom, 2, 5);
|
|
final cpPart = _extractRandomPart(codePostal, 2, 3);
|
|
final villePart = _extractRandomPart(ville, 2, 4);
|
|
final nombreAleatoire = 10 + _random.nextInt(990); // 10 à 999
|
|
|
|
// Choisir des séparateurs aléatoires (uniquement ceux autorisés: ., _, -)
|
|
final separateurs = ['', '.', '_', '-'];
|
|
final sep1 = separateurs[_random.nextInt(separateurs.length)];
|
|
final sep2 = separateurs[_random.nextInt(separateurs.length)];
|
|
|
|
// Assembler l'username
|
|
String username = '$nomPart$sep1$cpPart$sep2$villePart$nombreAleatoire';
|
|
|
|
// Si trop court, ajouter des chiffres pour atteindre minimum 10 caractères
|
|
while (username.length < 10) {
|
|
username += _random.nextInt(10).toString();
|
|
}
|
|
|
|
// S'assurer que l'username ne contient que des caractères autorisés (a-z, 0-9, ., -, _)
|
|
// Normalement déjà le cas avec notre algorithme, mais au cas où
|
|
username = username.toLowerCase().replaceAll(RegExp(r'[^a-z0-9._-]'), '');
|
|
|
|
return username;
|
|
}
|
|
|
|
// Vérifier la disponibilité d'un username via l'API
|
|
Future<Map<String, dynamic>> _checkUsernameAvailability(String username) async {
|
|
try {
|
|
final response = await ApiService.instance.post(
|
|
'/users/check-username',
|
|
data: {'username': username},
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.data;
|
|
}
|
|
return {'available': false};
|
|
} catch (e) {
|
|
debugPrint('Erreur lors de la vérification de l\'username: $e');
|
|
return {'available': false};
|
|
}
|
|
}
|
|
|
|
// Générer et vérifier un username jusqu'à en trouver un disponible
|
|
Future<void> _generateAndCheckUsername() async {
|
|
if (_isGeneratingUsername) return; // Éviter les appels multiples
|
|
|
|
setState(() {
|
|
_isGeneratingUsername = true;
|
|
});
|
|
|
|
try {
|
|
int attempts = 0;
|
|
const maxAttempts = 10;
|
|
|
|
while (attempts < maxAttempts) {
|
|
final username = _generateUsername();
|
|
debugPrint('Tentative ${attempts + 1}: Vérification de $username');
|
|
|
|
final result = await _checkUsernameAvailability(username);
|
|
|
|
if (result['available'] == true) {
|
|
// Username disponible, l'utiliser
|
|
setState(() {
|
|
_usernameController.text = username;
|
|
});
|
|
debugPrint('✅ Username disponible trouvé: $username');
|
|
break;
|
|
} else {
|
|
// Si l'API propose des suggestions, essayer la première
|
|
if (result['suggestions'] != null && result['suggestions'].isNotEmpty) {
|
|
final suggestion = result['suggestions'][0];
|
|
debugPrint('Vérification de la suggestion: $suggestion');
|
|
|
|
final suggestionResult = await _checkUsernameAvailability(suggestion);
|
|
if (suggestionResult['available'] == true) {
|
|
setState(() {
|
|
_usernameController.text = suggestion;
|
|
});
|
|
debugPrint('✅ Suggestion disponible utilisée: $suggestion');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
attempts++;
|
|
}
|
|
|
|
if (attempts >= maxAttempts) {
|
|
debugPrint('⚠️ Impossible de trouver un username disponible après $maxAttempts tentatives');
|
|
}
|
|
} finally {
|
|
setState(() {
|
|
_isGeneratingUsername = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
// Valider le mot de passe selon les règles
|
|
String? _validatePassword(String? value) {
|
|
if (value == null || value.isEmpty) {
|
|
// Pour un nouveau membre, le mot de passe est obligatoire si le champ est affiché
|
|
if (widget.user?.id == 0) {
|
|
return "Veuillez entrer un mot de passe";
|
|
}
|
|
return null; // En modification, vide = garder l'ancien
|
|
}
|
|
|
|
// Faire un trim pour retirer les espaces en début/fin
|
|
final trimmedValue = value.trim();
|
|
if (trimmedValue.isEmpty) {
|
|
return "Le mot de passe ne peut pas être vide";
|
|
}
|
|
|
|
// Vérifier qu'il n'y a pas d'espaces dans le mot de passe
|
|
if (trimmedValue.contains(' ')) {
|
|
return "Le mot de passe ne doit pas contenir d'espaces";
|
|
}
|
|
|
|
// Vérifier la longueur
|
|
if (trimmedValue.length < 12) {
|
|
return "Le mot de passe doit contenir au moins 12 caractères";
|
|
}
|
|
if (trimmedValue.length > 16) {
|
|
return "Le mot de passe ne doit pas dépasser 16 caractères";
|
|
}
|
|
|
|
// Vérifier qu'il n'est pas égal au username (après trim des deux)
|
|
if (trimmedValue == _usernameController.text.trim()) {
|
|
return "Le mot de passe ne doit pas être identique au nom d'utilisateur";
|
|
}
|
|
|
|
// Vérifier la présence d'au moins une minuscule
|
|
if (!trimmedValue.contains(RegExp(r'[a-z]'))) {
|
|
return "Le mot de passe doit contenir au moins une lettre minuscule";
|
|
}
|
|
|
|
// Vérifier la présence d'au moins une majuscule
|
|
if (!trimmedValue.contains(RegExp(r'[A-Z]'))) {
|
|
return "Le mot de passe doit contenir au moins une lettre majuscule";
|
|
}
|
|
|
|
// Vérifier la présence d'au moins un chiffre
|
|
if (!trimmedValue.contains(RegExp(r'[0-9]'))) {
|
|
return "Le mot de passe doit contenir au moins un chiffre";
|
|
}
|
|
|
|
// Vérifier la présence d'au moins un caractère spécial
|
|
if (!trimmedValue.contains(RegExp(r'[!@#$%^&*()_+\-=\[\]{}|;:,.<>?]'))) {
|
|
return "Le mot de passe doit contenir au moins un caractère spécial (!@#\$%^&*()_+-=[]{}|;:,.<>?)";
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
// Générer un mot de passe aléatoire respectant les règles
|
|
String _generatePassword() {
|
|
const String lowercase = 'abcdefghijklmnopqrstuvwxyz';
|
|
const String uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
|
|
const String digits = '0123456789';
|
|
const String special = '!@#\$%^&*()_+-=[]{}|;:,.<>?';
|
|
|
|
// Longueur aléatoire entre 12 et 16
|
|
final length = 12 + _random.nextInt(5);
|
|
|
|
// S'assurer d'avoir au moins un caractère de chaque type
|
|
List<String> password = [];
|
|
password.add(lowercase[_random.nextInt(lowercase.length)]);
|
|
password.add(uppercase[_random.nextInt(uppercase.length)]);
|
|
password.add(digits[_random.nextInt(digits.length)]);
|
|
password.add(special[_random.nextInt(special.length)]);
|
|
|
|
// Compléter avec des caractères aléatoires
|
|
const String allChars = lowercase + uppercase + digits + special;
|
|
for (int i = password.length; i < length; i++) {
|
|
password.add(allChars[_random.nextInt(allChars.length)]);
|
|
}
|
|
|
|
// Mélanger les caractères
|
|
password.shuffle(_random);
|
|
|
|
return password.join('');
|
|
}
|
|
|
|
// Méthode publique pour récupérer le mot de passe si défini
|
|
String? getPassword() {
|
|
final password = _passwordController.text.trim();
|
|
return password.isNotEmpty ? password : null;
|
|
}
|
|
|
|
// Méthode publique pour valider et récupérer l'utilisateur
|
|
UserModel? validateAndGetUser() {
|
|
if (_formKey.currentState!.validate()) {
|
|
return widget.user?.copyWith(
|
|
username: _usernameController.text.trim(), // Appliquer trim
|
|
firstName: _firstNameController.text.trim(),
|
|
name: _nameController.text.trim(),
|
|
sectName: _sectNameController.text.trim(),
|
|
phone: _phoneController.text.trim(),
|
|
mobile: _mobileController.text.trim(),
|
|
email: _emailController.text.trim(),
|
|
fkTitre: _fkTitre,
|
|
dateNaissance: _dateNaissance,
|
|
dateEmbauche: _dateEmbauche,
|
|
) ??
|
|
UserModel(
|
|
id: 0,
|
|
username: _usernameController.text.trim(), // Appliquer trim
|
|
firstName: _firstNameController.text.trim(),
|
|
name: _nameController.text.trim(),
|
|
sectName: _sectNameController.text.trim(),
|
|
phone: _phoneController.text.trim(),
|
|
mobile: _mobileController.text.trim(),
|
|
email: _emailController.text.trim(),
|
|
fkTitre: _fkTitre,
|
|
dateNaissance: _dateNaissance,
|
|
dateEmbauche: _dateEmbauche,
|
|
role: 1,
|
|
createdAt: DateTime.now(),
|
|
lastSyncedAt: DateTime.now(),
|
|
);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final theme = Theme.of(context);
|
|
final isWideScreen = MediaQuery.of(context).size.width > 900;
|
|
|
|
// Déterminer si on doit afficher le champ username selon les règles
|
|
final bool shouldShowUsernameField = widget.isAdmin && widget.amicale?.chkUsernameManuel == true;
|
|
// Déterminer si le username est éditable (seulement en création, jamais en modification)
|
|
final bool canEditUsername = shouldShowUsernameField && widget.allowUsernameEdit && widget.user?.id == 0;
|
|
// Déterminer si on doit afficher le champ mot de passe
|
|
final bool shouldShowPasswordField = widget.isAdmin && widget.amicale?.chkMdpManuel == true;
|
|
|
|
return Form(
|
|
key: _formKey,
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
// Email seul sur la première ligne
|
|
CustomTextField(
|
|
controller: _emailController,
|
|
label: "Email",
|
|
keyboardType: TextInputType.emailAddress,
|
|
readOnly: widget.readOnly,
|
|
isRequired: true,
|
|
validator: (value) {
|
|
if (value == null || value.isEmpty) {
|
|
return "Veuillez entrer l'adresse email";
|
|
}
|
|
if (!value.contains('@') || !value.contains('.')) {
|
|
return "Veuillez entrer une adresse email valide";
|
|
}
|
|
return null;
|
|
},
|
|
),
|
|
const SizedBox(height: 16),
|
|
|
|
// Titre (M. ou Mme)
|
|
Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
"Titre",
|
|
style: theme.textTheme.titleSmall?.copyWith(
|
|
fontWeight: FontWeight.w500,
|
|
color: theme.colorScheme.onSurface,
|
|
),
|
|
),
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
children: [
|
|
_buildRadioOption(
|
|
value: 1,
|
|
label: 'M.',
|
|
groupValue: _fkTitre,
|
|
onChanged: widget.readOnly
|
|
? null
|
|
: (value) {
|
|
setState(() {
|
|
_fkTitre = value!;
|
|
});
|
|
},
|
|
),
|
|
const SizedBox(width: 40),
|
|
_buildRadioOption(
|
|
value: 2,
|
|
label: 'Mme',
|
|
groupValue: _fkTitre,
|
|
onChanged: widget.readOnly
|
|
? null
|
|
: (value) {
|
|
setState(() {
|
|
_fkTitre = value!;
|
|
});
|
|
},
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 16),
|
|
|
|
// Ligne 2: Prénom et Nom
|
|
if (isWideScreen)
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: CustomTextField(
|
|
controller: _firstNameController,
|
|
label: "Prénom",
|
|
readOnly: widget.readOnly,
|
|
),
|
|
),
|
|
const SizedBox(width: 16),
|
|
Expanded(
|
|
child: CustomTextField(
|
|
controller: _nameController,
|
|
label: "Nom",
|
|
readOnly: widget.readOnly,
|
|
validator: (value) => _validateNameOrSectName(value, true),
|
|
onChanged: (value) {
|
|
// Revalider sectName quand name change
|
|
if (widget.allowSectNameEdit) {
|
|
_formKey.currentState?.validate();
|
|
}
|
|
},
|
|
),
|
|
),
|
|
],
|
|
)
|
|
else ...[
|
|
// Version mobile: Prénom et nom séparés
|
|
CustomTextField(
|
|
controller: _firstNameController,
|
|
label: "Prénom",
|
|
readOnly: widget.readOnly,
|
|
),
|
|
const SizedBox(height: 16),
|
|
CustomTextField(
|
|
controller: _nameController,
|
|
label: "Nom",
|
|
readOnly: widget.readOnly,
|
|
validator: (value) => _validateNameOrSectName(value, true),
|
|
onChanged: (value) {
|
|
// Revalider sectName quand name change
|
|
if (widget.allowSectNameEdit) {
|
|
_formKey.currentState?.validate();
|
|
}
|
|
},
|
|
),
|
|
],
|
|
const SizedBox(height: 16),
|
|
|
|
// Ligne 2.5: Nom de tournée (sectName) - uniquement si éditable
|
|
if (widget.allowSectNameEdit) ...[
|
|
CustomTextField(
|
|
controller: _sectNameController,
|
|
label: "Nom de tournée",
|
|
readOnly: widget.readOnly,
|
|
validator: (value) => _validateNameOrSectName(value, false),
|
|
onChanged: (value) {
|
|
// Revalider name quand sectName change
|
|
_formKey.currentState?.validate();
|
|
},
|
|
hintText: "Nom utilisé pour identifier la tournée",
|
|
),
|
|
const SizedBox(height: 16),
|
|
],
|
|
|
|
// Ligne 2: Téléphones (fixe et mobile)
|
|
if (isWideScreen)
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: CustomTextField(
|
|
controller: _phoneController,
|
|
label: "Téléphone fixe",
|
|
keyboardType: TextInputType.phone,
|
|
readOnly: widget.readOnly,
|
|
inputFormatters: [
|
|
FilteringTextInputFormatter.digitsOnly,
|
|
LengthLimitingTextInputFormatter(10),
|
|
],
|
|
validator: (value) {
|
|
if (value != null && value.isNotEmpty && value.length < 10) {
|
|
return "Le numéro doit contenir 10 chiffres";
|
|
}
|
|
return null;
|
|
},
|
|
),
|
|
),
|
|
const SizedBox(width: 16),
|
|
Expanded(
|
|
child: CustomTextField(
|
|
controller: _mobileController,
|
|
label: "Téléphone mobile",
|
|
keyboardType: TextInputType.phone,
|
|
readOnly: widget.readOnly,
|
|
inputFormatters: [
|
|
FilteringTextInputFormatter.digitsOnly,
|
|
LengthLimitingTextInputFormatter(10),
|
|
],
|
|
validator: (value) {
|
|
if (value != null && value.isNotEmpty && value.length < 10) {
|
|
return "Le numéro doit contenir 10 chiffres";
|
|
}
|
|
return null;
|
|
},
|
|
),
|
|
),
|
|
],
|
|
)
|
|
else ...[
|
|
// Version mobile: Téléphones séparés
|
|
CustomTextField(
|
|
controller: _phoneController,
|
|
label: "Téléphone fixe",
|
|
keyboardType: TextInputType.phone,
|
|
readOnly: widget.readOnly,
|
|
inputFormatters: [
|
|
FilteringTextInputFormatter.digitsOnly,
|
|
LengthLimitingTextInputFormatter(10),
|
|
],
|
|
validator: (value) {
|
|
if (value != null && value.isNotEmpty && value.length < 10) {
|
|
return "Le numéro doit contenir 10 chiffres";
|
|
}
|
|
return null;
|
|
},
|
|
),
|
|
const SizedBox(height: 16),
|
|
CustomTextField(
|
|
controller: _mobileController,
|
|
label: "Téléphone mobile",
|
|
keyboardType: TextInputType.phone,
|
|
readOnly: widget.readOnly,
|
|
inputFormatters: [
|
|
FilteringTextInputFormatter.digitsOnly,
|
|
LengthLimitingTextInputFormatter(10),
|
|
],
|
|
validator: (value) {
|
|
if (value != null && value.isNotEmpty && value.length < 10) {
|
|
return "Le numéro doit contenir 10 chiffres";
|
|
}
|
|
return null;
|
|
},
|
|
),
|
|
],
|
|
const SizedBox(height: 16),
|
|
|
|
// Ligne 3: Username et Password (si applicable)
|
|
if (shouldShowUsernameField || shouldShowPasswordField) ...[
|
|
if (isWideScreen)
|
|
Row(
|
|
children: [
|
|
if (shouldShowUsernameField)
|
|
Expanded(
|
|
child: CustomTextField(
|
|
controller: _usernameController,
|
|
label: "Nom d'utilisateur",
|
|
readOnly: !canEditUsername,
|
|
prefixIcon: Icons.account_circle,
|
|
isRequired: canEditUsername,
|
|
suffixIcon: (widget.user?.id == 0 && canEditUsername)
|
|
? _isGeneratingUsername
|
|
? SizedBox(
|
|
width: 20,
|
|
height: 20,
|
|
child: CircularProgressIndicator(
|
|
strokeWidth: 2,
|
|
valueColor: AlwaysStoppedAnimation<Color>(
|
|
Theme.of(context).colorScheme.primary,
|
|
),
|
|
),
|
|
)
|
|
: IconButton(
|
|
icon: Icon(Icons.refresh),
|
|
onPressed: _generateAndCheckUsername,
|
|
tooltip: "Générer un nom d'utilisateur",
|
|
)
|
|
: null,
|
|
helperText: canEditUsername
|
|
? "Min. 10 caractères (a-z, 0-9, . - _)"
|
|
: null,
|
|
validator: canEditUsername
|
|
? (value) {
|
|
if (value == null || value.isEmpty) {
|
|
return "Veuillez entrer le nom d'utilisateur";
|
|
}
|
|
// Faire un trim pour retirer les espaces en début/fin
|
|
final trimmedValue = value.trim();
|
|
if (trimmedValue.isEmpty) {
|
|
return "Le nom d'utilisateur ne peut pas être vide";
|
|
}
|
|
// Vérifier qu'il n'y a pas d'espaces dans l'username
|
|
if (trimmedValue.contains(' ')) {
|
|
return "Le nom d'utilisateur ne doit pas contenir d'espaces";
|
|
}
|
|
// Vérifier la longueur minimale
|
|
if (trimmedValue.length < 10) {
|
|
return "Le nom d'utilisateur doit contenir au moins 10 caractères";
|
|
}
|
|
// Vérifier les caractères autorisés (a-z, 0-9, ., -, _)
|
|
if (!RegExp(r'^[a-z0-9._-]+$').hasMatch(trimmedValue)) {
|
|
return "Caractères autorisés : lettres minuscules, chiffres, . - _";
|
|
}
|
|
return null;
|
|
}
|
|
: null,
|
|
),
|
|
),
|
|
if (shouldShowUsernameField && shouldShowPasswordField)
|
|
const SizedBox(width: 16),
|
|
if (shouldShowPasswordField)
|
|
Expanded(
|
|
child: CustomTextField(
|
|
controller: _passwordController,
|
|
label: "Mot de passe",
|
|
obscureText: _obscurePassword,
|
|
readOnly: widget.readOnly,
|
|
prefixIcon: Icons.lock,
|
|
suffixIcon: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
// Bouton pour afficher/masquer le mot de passe
|
|
IconButton(
|
|
icon: Icon(_obscurePassword ? Icons.visibility : Icons.visibility_off),
|
|
onPressed: () {
|
|
setState(() {
|
|
_obscurePassword = !_obscurePassword;
|
|
});
|
|
},
|
|
tooltip: _obscurePassword ? "Afficher le mot de passe" : "Masquer le mot de passe",
|
|
),
|
|
// Bouton pour générer un mot de passe (seulement si éditable)
|
|
if (!widget.readOnly)
|
|
IconButton(
|
|
icon: Icon(Icons.auto_awesome),
|
|
onPressed: () {
|
|
final newPassword = _generatePassword();
|
|
setState(() {
|
|
_passwordController.text = newPassword;
|
|
_obscurePassword = false; // Afficher le mot de passe généré
|
|
});
|
|
// Revalider le formulaire
|
|
_formKey.currentState?.validate();
|
|
},
|
|
tooltip: "Générer un mot de passe sécurisé",
|
|
),
|
|
],
|
|
),
|
|
helperText: widget.user?.id != 0
|
|
? "Laissez vide pour conserver le mot de passe actuel"
|
|
: "12-16 car. avec min/maj, chiffres et spéciaux (!@#\$%^&*()_+-=[]{}|;:,.<>?)",
|
|
validator: _validatePassword,
|
|
),
|
|
),
|
|
// Si seulement un des deux est affiché, ajouter un Expanded vide pour garder l'alignement
|
|
if ((shouldShowUsernameField && !shouldShowPasswordField) || (!shouldShowUsernameField && shouldShowPasswordField))
|
|
const Expanded(child: SizedBox()),
|
|
],
|
|
)
|
|
else ...[
|
|
// Version mobile: Username et Password séparés
|
|
if (shouldShowUsernameField) ...[
|
|
CustomTextField(
|
|
controller: _usernameController,
|
|
label: "Nom d'utilisateur",
|
|
readOnly: !canEditUsername,
|
|
prefixIcon: Icons.account_circle,
|
|
isRequired: canEditUsername,
|
|
suffixIcon: (widget.user?.id == 0 && canEditUsername)
|
|
? _isGeneratingUsername
|
|
? SizedBox(
|
|
width: 20,
|
|
height: 20,
|
|
child: CircularProgressIndicator(
|
|
strokeWidth: 2,
|
|
valueColor: AlwaysStoppedAnimation<Color>(
|
|
Theme.of(context).colorScheme.primary,
|
|
),
|
|
),
|
|
)
|
|
: IconButton(
|
|
icon: Icon(Icons.refresh),
|
|
onPressed: _generateAndCheckUsername,
|
|
tooltip: "Générer un nom d'utilisateur",
|
|
)
|
|
: null,
|
|
helperText: canEditUsername
|
|
? "Min. 10 caractères (a-z, 0-9, . - _)"
|
|
: null,
|
|
validator: canEditUsername
|
|
? (value) {
|
|
if (value == null || value.isEmpty) {
|
|
return "Veuillez entrer le nom d'utilisateur";
|
|
}
|
|
// Faire un trim pour retirer les espaces en début/fin
|
|
final trimmedValue = value.trim();
|
|
if (trimmedValue.isEmpty) {
|
|
return "Le nom d'utilisateur ne peut pas être vide";
|
|
}
|
|
// Vérifier qu'il n'y a pas d'espaces dans l'username
|
|
if (trimmedValue.contains(' ')) {
|
|
return "Le nom d'utilisateur ne doit pas contenir d'espaces";
|
|
}
|
|
// Vérifier la longueur minimale
|
|
if (trimmedValue.length < 10) {
|
|
return "Le nom d'utilisateur doit contenir au moins 10 caractères";
|
|
}
|
|
// Vérifier les caractères autorisés (a-z, 0-9, ., -, _)
|
|
if (!RegExp(r'^[a-z0-9._-]+$').hasMatch(trimmedValue)) {
|
|
return "Caractères autorisés : lettres minuscules, chiffres, . - _";
|
|
}
|
|
return null;
|
|
}
|
|
: null,
|
|
),
|
|
const SizedBox(height: 16),
|
|
],
|
|
if (shouldShowPasswordField) ...[
|
|
CustomTextField(
|
|
controller: _passwordController,
|
|
label: "Mot de passe",
|
|
obscureText: _obscurePassword,
|
|
readOnly: widget.readOnly,
|
|
prefixIcon: Icons.lock,
|
|
suffixIcon: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
// Bouton pour afficher/masquer le mot de passe
|
|
IconButton(
|
|
icon: Icon(_obscurePassword ? Icons.visibility : Icons.visibility_off),
|
|
onPressed: () {
|
|
setState(() {
|
|
_obscurePassword = !_obscurePassword;
|
|
});
|
|
},
|
|
tooltip: _obscurePassword ? "Afficher le mot de passe" : "Masquer le mot de passe",
|
|
),
|
|
// Bouton pour générer un mot de passe (seulement si éditable)
|
|
if (!widget.readOnly)
|
|
IconButton(
|
|
icon: Icon(Icons.auto_awesome),
|
|
onPressed: () {
|
|
final newPassword = _generatePassword();
|
|
setState(() {
|
|
_passwordController.text = newPassword;
|
|
_obscurePassword = false; // Afficher le mot de passe généré
|
|
});
|
|
// Revalider le formulaire
|
|
_formKey.currentState?.validate();
|
|
},
|
|
tooltip: "Générer un mot de passe sécurisé",
|
|
),
|
|
],
|
|
),
|
|
helperText: widget.user?.id != 0
|
|
? "Laissez vide pour conserver le mot de passe actuel"
|
|
: "12-16 car. avec min/maj, chiffres et spéciaux (!@#\$%^&*()_+-=[]{}|;:,.<>?)",
|
|
validator: _validatePassword,
|
|
),
|
|
const SizedBox(height: 16),
|
|
],
|
|
],
|
|
const SizedBox(height: 16),
|
|
],
|
|
|
|
// Ligne 4: Dates (naissance et embauche)
|
|
if (isWideScreen)
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: CustomTextField(
|
|
controller: _dateNaissanceController,
|
|
label: "Date de naissance",
|
|
readOnly: true,
|
|
onTap: widget.readOnly ? null : () => _selectDate(context, true),
|
|
suffixIcon: Icon(
|
|
Icons.calendar_today,
|
|
color: theme.colorScheme.primary,
|
|
),
|
|
),
|
|
),
|
|
const SizedBox(width: 16),
|
|
Expanded(
|
|
child: CustomTextField(
|
|
controller: _dateEmbaucheController,
|
|
label: "Date d'embauche",
|
|
readOnly: true,
|
|
onTap: widget.readOnly ? null : () => _selectDate(context, false),
|
|
suffixIcon: Icon(
|
|
Icons.calendar_today,
|
|
color: theme.colorScheme.primary,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
)
|
|
else ...[
|
|
// Version mobile: Dates séparées
|
|
CustomTextField(
|
|
controller: _dateNaissanceController,
|
|
label: "Date de naissance",
|
|
readOnly: true,
|
|
onTap: widget.readOnly ? null : () => _selectDate(context, true),
|
|
suffixIcon: Icon(
|
|
Icons.calendar_today,
|
|
color: theme.colorScheme.primary,
|
|
),
|
|
),
|
|
const SizedBox(height: 16),
|
|
CustomTextField(
|
|
controller: _dateEmbaucheController,
|
|
label: "Date d'embauche",
|
|
readOnly: true,
|
|
onTap: widget.readOnly ? null : () => _selectDate(context, false),
|
|
suffixIcon: Icon(
|
|
Icons.calendar_today,
|
|
color: theme.colorScheme.primary,
|
|
),
|
|
),
|
|
],
|
|
|
|
const SizedBox(height: 16),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildRadioOption({
|
|
required int value,
|
|
required String label,
|
|
required int groupValue,
|
|
required Function(int?)? onChanged,
|
|
}) {
|
|
final theme = Theme.of(context);
|
|
final isSelected = value == groupValue;
|
|
|
|
return Row(
|
|
children: [
|
|
Radio<int>(
|
|
value: value,
|
|
groupValue: groupValue,
|
|
onChanged: onChanged,
|
|
activeColor: const Color(0xFF20335E),
|
|
),
|
|
Text(
|
|
label,
|
|
style: theme.textTheme.bodyMedium?.copyWith(
|
|
color: theme.colorScheme.onSurface,
|
|
fontWeight: FontWeight.w500,
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
// Exporter la classe State pour pouvoir l'utiliser avec GlobalKey
|
|
typedef UserFormState = _UserFormState;
|