Ajout d'utilisateur OK

Ajout bouton de deconnexion

em2rp/lib/providers/local_user_provider.dart

@@ -22,12 +22,61 @@ class LocalUserProvider with ChangeNotifier {
 
   /// Charge les données de l'utilisateur actuel
   Future<void> loadUserData() async {
-    if (_auth.currentUser == null) return;
-    DocumentSnapshot userDoc =
-        await _firestore.collection('users').doc(_auth.currentUser!.uid).get();
-    if (userDoc.exists) {
-      setUser(UserModel.fromMap(
-          userDoc.data() as Map<String, dynamic>, userDoc.id));
+    if (_auth.currentUser == null) {
+      print('No current user in Auth');
+      return;
+    }
+
+    print('Loading user data for: ${_auth.currentUser!.uid}');
+    try {
+      DocumentSnapshot userDoc = await _firestore
+          .collection('users')
+          .doc(_auth.currentUser!.uid)
+          .get();
+
+      if (userDoc.exists) {
+        print('User document found in Firestore');
+        final userData = userDoc.data() as Map<String, dynamic>;
+        print('User data: $userData');
+
+        // Si le document n'a pas d'UID, l'ajouter
+        if (!userData.containsKey('uid')) {
+          await userDoc.reference.update({'uid': _auth.currentUser!.uid});
+          userData['uid'] = _auth.currentUser!.uid;
+        }
+
+        setUser(UserModel.fromMap(userData, userDoc.id));
+        print('User data loaded successfully');
+      } else {
+        print('No user document found in Firestore');
+        // Créer un document utilisateur par défaut
+        final defaultUser = UserModel(
+          uid: _auth.currentUser!.uid,
+          email: _auth.currentUser!.email ?? '',
+          firstName: '',
+          lastName: '',
+          role: 'USER',
+          phoneNumber: '',
+          profilePhotoUrl: '',
+        );
+
+        await _firestore.collection('users').doc(_auth.currentUser!.uid).set({
+          'uid': _auth.currentUser!.uid,
+          'email': _auth.currentUser!.email,
+          'firstName': '',
+          'lastName': '',
+          'role': 'USER',
+          'phoneNumber': '',
+          'profilePhotoUrl': '',
+          'createdAt': FieldValue.serverTimestamp(),
+        });
+
+        setUser(defaultUser);
+        print('Default user document created');
+      }
+    } catch (e) {
+      print('Error loading user data: $e');
+      rethrow;
     }
   }
 

em2rp/lib/providers/users_provider.dart

@@ -1,9 +1,14 @@
 import 'package:flutter/material.dart';
 import '../models/user_model.dart';
 import '../services/user_service.dart';
+import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:firebase_auth/firebase_auth.dart';
+import 'package:flutter/foundation.dart';
 
 class UsersProvider with ChangeNotifier {
   final UserService _userService;
+  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
+  final FirebaseAuth _auth = FirebaseAuth.instance;
   List<UserModel> _users = [];
   bool _isLoading = false;
 
@@ -16,28 +21,146 @@ class UsersProvider with ChangeNotifier {
   Future<void> fetchUsers() async {
     _isLoading = true;
     notifyListeners();
+
     try {
-      _users = await _userService.fetchUsers();
-    } finally {
-      _isLoading = false;
-      notifyListeners();
+      final snapshot = await _firestore.collection('users').get();
+      _users = snapshot.docs
+          .map((doc) => UserModel.fromMap(doc.data(), doc.id))
+          .toList();
+    } catch (e) {
+      print('Error fetching users: $e');
     }
+
+    _isLoading = false;
+    notifyListeners();
   }
 
   /// Mise à jour d'un utilisateur
   Future<void> updateUser(UserModel user) async {
-    await _userService.updateUser(user);
-    await fetchUsers();
+    try {
+      await _firestore.collection('users').doc(user.uid).update({
+        'firstName': user.firstName,
+        'lastName': user.lastName,
+        'email': user.email,
+        'phoneNumber': user.phoneNumber,
+        'role': user.role,
+        'profilePhotoUrl': user.profilePhotoUrl,
+      });
+
+      final index = _users.indexWhere((u) => u.uid == user.uid);
+      if (index != -1) {
+        _users[index] = user;
+        notifyListeners();
+      }
+    } catch (e) {
+      print('Error updating user: $e');
+      rethrow;
+    }
   }
 
   /// Suppression d'un utilisateur
   Future<void> deleteUser(String uid) async {
-    await _userService.deleteUser(uid);
-    await fetchUsers();
+    try {
+      await _firestore.collection('users').doc(uid).delete();
+      _users.removeWhere((user) => user.uid == uid);
+      notifyListeners();
+    } catch (e) {
+      print('Error deleting user: $e');
+      rethrow;
+    }
   }
 
   /// Réinitialisation du mot de passe
   Future<void> resetPassword(String email) async {
     await _userService.resetPassword(email);
   }
+
+  Future<void> createUserWithEmailInvite(UserModel user) async {
+    String? authUid;
+
+    try {
+      // Vérifier l'état de l'authentification
+      final currentUser = _auth.currentUser;
+      print('Current user: ${currentUser?.email}');
+
+      if (currentUser == null) {
+        throw Exception('Aucun utilisateur connecté');
+      }
+
+      // Vérifier le rôle de l'utilisateur actuel
+      final currentUserDoc =
+          await _firestore.collection('users').doc(currentUser.uid).get();
+      print('Current user role: ${currentUserDoc.data()?['role']}');
+
+      if (currentUserDoc.data()?['role'] != 'ADMIN') {
+        throw Exception(
+            'Seuls les administrateurs peuvent créer des utilisateurs');
+      }
+
+      try {
+        // Créer l'utilisateur dans Firebase Authentication
+        final userCredential = await _auth.createUserWithEmailAndPassword(
+          email: user.email,
+          password: 'TemporaryPassword123!', // Mot de passe temporaire
+        );
+
+        authUid = userCredential.user!.uid;
+        print('User created in Auth with UID: $authUid');
+
+        // Créer le document dans Firestore avec l'UID de Auth comme ID
+        await _firestore.collection('users').doc(authUid).set({
+          'uid': authUid,
+          'firstName': user.firstName,
+          'lastName': user.lastName,
+          'email': user.email,
+          'phoneNumber': user.phoneNumber,
+          'role': user.role,
+          'profilePhotoUrl': user.profilePhotoUrl,
+          'createdAt': FieldValue.serverTimestamp(),
+        });
+
+        print('User document created in Firestore with Auth UID');
+
+        // Envoyer un email de réinitialisation de mot de passe
+        await _auth.sendPasswordResetEmail(
+          email: user.email,
+          actionCodeSettings: ActionCodeSettings(
+            url: 'http://localhost:63337/finishSignUp?email=${user.email}',
+            handleCodeInApp: true,
+            androidPackageName: 'com.em2rp.app',
+            androidInstallApp: true,
+            androidMinimumVersion: '12',
+          ),
+        );
+
+        print('Password reset email sent');
+
+        // Ajouter l'utilisateur à la liste locale
+        final newUser = UserModel(
+          uid: authUid,
+          firstName: user.firstName,
+          lastName: user.lastName,
+          email: user.email,
+          phoneNumber: user.phoneNumber,
+          role: user.role,
+          profilePhotoUrl: user.profilePhotoUrl,
+        );
+        _users.add(newUser);
+        notifyListeners();
+      } catch (e) {
+        // En cas d'erreur, supprimer l'utilisateur Auth si créé
+        if (authUid != null) {
+          try {
+            await _auth.currentUser?.delete();
+          } catch (deleteError) {
+            print('Warning: Could not delete Auth user: $deleteError');
+          }
+        }
+        rethrow;
+      }
+    } catch (e) {
+      print('Error creating user: $e');
+      rethrow;
+    }
+  }
 }