feat: Implement group management with BLoC pattern; add GroupBloc, GroupRepository, and related models

NOT FUNCTIONNAL

lib/repositories/group_repository.dart

@@ -0,0 +1,186 @@
+import 'package:cloud_firestore/cloud_firestore.dart';
+import '../data/models/group.dart';
+import '../data/models/group_member.dart';
+
+class GroupRepository {
+  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
+
+  CollectionReference get _groupsCollection => _firestore.collection('groups');
+
+  CollectionReference _membersCollection(String groupId) {
+    return _groupsCollection.doc(groupId).collection('members');
+  }
+
+  // Créer un groupe avec ses membres (avec ID du trip)
+  Future<String> createGroupWithMembers({
+    required Group group,
+    required List<GroupMember> members,
+  }) async {
+    try {
+      return await _firestore.runTransaction<String>((transaction) async {
+        // Créer le document avec un ID généré
+        final groupRef = _groupsCollection.doc();
+        
+        // Ajouter l'ID dans les données
+        final groupData = group.toMap();
+        transaction.set(groupRef, groupData);
+
+        // Ajouter tous les membres
+        for (var member in members) {
+          final memberRef = groupRef.collection('members').doc(member.userId);
+          transaction.set(memberRef, member.toMap());
+        }
+
+        return groupRef.id;
+      });
+    } catch (e) {
+      throw Exception('Erreur lors de la création du groupe: $e');
+    }
+  }
+
+  // NOUVEAU : Récupérer les groupes où l'utilisateur est membre
+  Stream<List<Group>> getGroupsByUserId(String userId) {
+    return _groupsCollection.snapshots().asyncMap((snapshot) async {
+      List<Group> userGroups = [];
+
+      for (var groupDoc in snapshot.docs) {
+        try {
+          // Vérifier si l'utilisateur est dans la sous-collection members
+          final memberDoc = await groupDoc.reference
+              .collection('members')
+              .doc(userId)
+              .get();
+
+          if (memberDoc.exists) {
+            // Charger le groupe avec tous ses membres
+            final group = Group.fromMap(
+              groupDoc.data() as Map<String, dynamic>,
+              groupDoc.id,
+            );
+            final members = await getGroupMembers(groupDoc.id);
+            userGroups.add(group.copyWith(members: members));
+          }
+        } catch (e) {
+          print('Erreur lors du traitement du groupe ${groupDoc.id}: $e');
+        }
+      }
+
+      return userGroups;
+    });
+  }
+
+  // Récupérer un groupe par son ID avec ses membres
+  Future<Group?> getGroupById(String groupId) async {
+    try {
+      final doc = await _groupsCollection.doc(groupId).get();
+      
+      if (!doc.exists) return null;
+      
+      final group = Group.fromMap(doc.data() as Map<String, dynamic>, doc.id);
+      final members = await getGroupMembers(groupId);
+      
+      return group.copyWith(members: members);
+    } catch (e) {
+      throw Exception('Erreur lors de la récupération du groupe: $e');
+    }
+  }
+
+  // Récupérer un groupe par tripId
+  Future<Group?> getGroupByTripId(String tripId) async {
+    try {
+      final querySnapshot = await _groupsCollection
+          .where('tripId', isEqualTo: tripId)
+          .limit(1)
+          .get();
+
+      if (querySnapshot.docs.isEmpty) return null;
+
+      final doc = querySnapshot.docs.first;
+      final group = Group.fromMap(doc.data() as Map<String, dynamic>, doc.id);
+      final members = await getGroupMembers(doc.id);
+      
+      return group.copyWith(members: members);
+    } catch (e) {
+      throw Exception('Erreur lors de la récupération du groupe: $e');
+    }
+  }
+
+  // Récupérer les membres d'un groupe
+  Future<List<GroupMember>> getGroupMembers(String groupId) async {
+    try {
+      final snapshot = await _membersCollection(groupId).get();
+      
+      return snapshot.docs
+          .map((doc) => GroupMember.fromMap(
+                doc.data() as Map<String, dynamic>,
+                doc.id,
+              ))
+          .toList();
+    } catch (e) {
+      throw Exception('Erreur lors de la récupération des membres: $e');
+    }
+  }
+
+  // Ajouter un membre
+  Future<void> addMember(String groupId, GroupMember member) async {
+    try {
+      await _membersCollection(groupId).doc(member.userId).set(member.toMap());
+      
+      await _groupsCollection.doc(groupId).update({
+        'updatedAt': DateTime.now().millisecondsSinceEpoch,
+      });
+    } catch (e) {
+      throw Exception('Erreur lors de l\'ajout du membre: $e');
+    }
+  }
+
+  // Supprimer un membre
+  Future<void> removeMember(String groupId, String userId) async {
+    try {
+      await _membersCollection(groupId).doc(userId).delete();
+      
+      await _groupsCollection.doc(groupId).update({
+        'updatedAt': DateTime.now().millisecondsSinceEpoch,
+      });
+    } catch (e) {
+      throw Exception('Erreur lors de la suppression du membre: $e');
+    }
+  }
+
+  // Mettre à jour un groupe
+  Future<void> updateGroup(String groupId, Group group) async {
+    try {
+      await _groupsCollection.doc(groupId).update(
+            group.toMap()..['updatedAt'] = DateTime.now().millisecondsSinceEpoch,
+          );
+    } catch (e) {
+      throw Exception('Erreur lors de la mise à jour du groupe: $e');
+    }
+  }
+
+  // Supprimer un groupe
+  Future<void> deleteGroup(String groupId) async {
+    try {
+      final membersSnapshot = await _membersCollection(groupId).get();
+      for (var doc in membersSnapshot.docs) {
+        await doc.reference.delete();
+      }
+      
+      await _groupsCollection.doc(groupId).delete();
+    } catch (e) {
+      throw Exception('Erreur lors de la suppression du groupe: $e');
+    }
+  }
+
+  // Stream des membres en temps réel
+  Stream<List<GroupMember>> watchGroupMembers(String groupId) {
+    return _membersCollection(groupId).snapshots().map(
+          (snapshot) => snapshot.docs
+              .map((doc) => GroupMember.fromMap(
+                    doc.data() as Map<String, dynamic>,
+                    doc.id,
+                  ))
+              .toList(),
+        );
+  }
+}