Cette mise à jour majeure refactorise entièrement la gestion des utilisateurs pour la faire passer par des Cloud Functions sécurisées et migre une part importante de la logique métier (gestion des événements, maintenances, containers) du client vers le backend.
**Gestion des Utilisateurs (Backend & Frontend):**
- **Nouvelle fonction `createUserWithInvite` :**
- Crée l'utilisateur dans Firebase Auth avec un mot de passe temporaire.
- Crée le document utilisateur correspondant dans Firestore.
- Envoie automatiquement un e-mail de réinitialisation de mot de passe (via l'API REST de Firebase et `axios`) pour que l'utilisateur définisse son propre mot de passe, améliorant la sécurité et l'expérience d'intégration.
- **Refactorisation de `updateUser` et `deleteUser` :**
- Les anciennes fonctions `onCall` sont remplacées par des fonctions `onRequest` (HTTP) standards, alignées avec le reste de l'API.
- La logique de suppression gère désormais la suppression dans Auth et Firestore.
- **Réinitialisation de Mot de Passe (UI) :**
- Ajout d'un bouton "Réinitialiser le mot de passe" sur la carte utilisateur, permettant aux administrateurs d'envoyer un e-mail de réinitialisation à n'importe quel utilisateur.
- **Amélioration de l'UI :**
- Boîte de dialogue de confirmation améliorée pour la suppression d'un utilisateur.
- Notifications (Snackbars) pour les opérations de création, suppression et réinitialisation de mot de passe.
**Migration de la Logique Métier vers les Cloud Functions:**
- **Gestion de la Préparation d'Événements :**
- Migration complète de la logique de validation des étapes (préparation, chargement, déchargement, retour) du client vers de nouvelles Cloud Functions (`validateEquipmentPreparation`, `validateAllLoading`, etc.).
- Le backend gère désormais la mise à jour des statuts de l'événement (`inProgress`, `completed`) et des équipements (`inUse`, `available`).
- Le code frontend (`EventPreparationService`) a été simplifié pour appeler ces nouvelles fonctions au lieu d'effectuer des écritures directes sur Firestore.
- **Création de Maintenance :**
- La fonction `createMaintenance` gère maintenant la mise à jour des équipements associés (`maintenanceIds`) et la création d'alertes (`maintenanceDue`) si une maintenance est prévue prochainement. La logique client a été supprimée.
- **Suppression de Container :**
- La fonction `deleteContainer` a été améliorée pour nettoyer automatiquement les références (`parentBoxIds`) dans tous les équipements contenus avant de supprimer le container.
**Refactorisation et Corrections (Backend & Frontend) :**
- **Fiabilisation des Appels API (Frontend) :**
- Le `ApiService` a été renforcé pour convertir de manière plus robuste les données (notamment les `Map` de type `_JsonMap`) en JSON standard avant de les envoyer aux Cloud Functions, évitant ainsi des erreurs de sérialisation.
- **Correction des Références (Backend) :**
- La fonction `updateUser` convertit correctement les `roleId` (string) en `DocumentReference` Firestore.
- Sécurisation de la vérification de l'assignation d'un utilisateur à un événement (`workforce`) pour éviter les erreurs sur des références nulles.
- **Dépendance (Backend) :**
- Ajout de la librairie `axios` pour effectuer des appels à l'API REST de Firebase.
94 lines
2.6 KiB
Dart
94 lines
2.6 KiB
Dart
import 'package:cloud_firestore/cloud_firestore.dart';
|
|
|
|
class UserModel {
|
|
final String uid;
|
|
final String firstName;
|
|
final String lastName;
|
|
final String role;
|
|
final String profilePhotoUrl;
|
|
final String email;
|
|
final String phoneNumber;
|
|
|
|
UserModel({
|
|
required this.uid,
|
|
required this.firstName,
|
|
required this.lastName,
|
|
required this.role,
|
|
required this.profilePhotoUrl,
|
|
required this.email,
|
|
required this.phoneNumber,
|
|
});
|
|
|
|
// Convertit une Map (Firestore) en UserModel
|
|
factory UserModel.fromMap(Map<String, dynamic> data, String uid) {
|
|
String roleString;
|
|
final roleField = data['role'];
|
|
|
|
if (roleField is String) {
|
|
// Cas 1 : role est déjà un String (ex: "roles/ADMIN")
|
|
roleString = roleField;
|
|
} else if (roleField is DocumentReference) {
|
|
// Cas 2 : role est une DocumentReference
|
|
roleString = roleField.id;
|
|
} else if (roleField is Map) {
|
|
// Cas 3 : role est un Map sérialisé (ex: {"_path": {"segments": ["roles", "ADMIN"]}})
|
|
// On extrait le path
|
|
final pathData = roleField['_path'];
|
|
if (pathData is Map && pathData['segments'] is List) {
|
|
final segments = pathData['segments'] as List;
|
|
if (segments.length >= 2) {
|
|
roleString = segments[1].toString(); // Ex: "ADMIN"
|
|
} else {
|
|
roleString = 'USER';
|
|
}
|
|
} else {
|
|
roleString = 'USER';
|
|
}
|
|
} else {
|
|
// Cas par défaut
|
|
roleString = 'USER';
|
|
}
|
|
|
|
return UserModel(
|
|
uid: uid,
|
|
firstName: data['firstName'] ?? '',
|
|
lastName: data['lastName'] ?? '',
|
|
role: roleString,
|
|
profilePhotoUrl: data['profilePhotoUrl'] ?? '',
|
|
email: data['email'] ?? '',
|
|
phoneNumber: data['phoneNumber'] ?? '',
|
|
);
|
|
}
|
|
|
|
// Convertit un UserModel en Map pour Firestore
|
|
Map<String, dynamic> toMap() {
|
|
return {
|
|
'firstName': firstName,
|
|
'lastName': lastName,
|
|
'role': role, // Envoyer directement le string roleId au lieu de créer une DocumentReference
|
|
'profilePhotoUrl': profilePhotoUrl,
|
|
'email': email,
|
|
'phoneNumber': phoneNumber,
|
|
};
|
|
}
|
|
|
|
UserModel copyWith({
|
|
String? firstName,
|
|
String? lastName,
|
|
String? role,
|
|
String? profilePhotoUrl,
|
|
String? email,
|
|
String? phoneNumber,
|
|
}) {
|
|
return UserModel(
|
|
uid: uid, // L'UID ne change pas
|
|
firstName: firstName ?? this.firstName,
|
|
lastName: lastName ?? this.lastName,
|
|
role: role ?? this.role,
|
|
profilePhotoUrl: profilePhotoUrl ?? this.profilePhotoUrl,
|
|
email: email ?? this.email,
|
|
phoneNumber: phoneNumber ?? this.phoneNumber,
|
|
);
|
|
}
|
|
}
|