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

NOT FUNCTIONNAL

lib/blocs/group/group_bloc.dart

@@ -1,104 +1,140 @@
 import 'dart:async';
 import 'package:flutter_bloc/flutter_bloc.dart';
-import '../../services/group_service.dart';
 import 'group_event.dart';
 import 'group_state.dart';
-import '../../data/models/group.dart';
+import '../../repositories/group_repository.dart';
 
 class GroupBloc extends Bloc<GroupEvent, GroupState> {
-  final GroupService _groupService;
+  final GroupRepository _repository;
   StreamSubscription? _groupsSubscription;
 
-  GroupBloc({GroupService? groupService})
-      : _groupService = groupService ?? GroupService(),
-        super(GroupInitial()) {
-    on<GroupLoadRequested>(_onLoadRequested);
-    on<_GroupUpdated>(_onGroupUpdated);
-    on<GroupCreateRequested>(_onCreateRequested);
-    on<GroupUpdateRequested>(_onUpdateRequested);
-    on<GroupDeleteRequested>(_onDeleteRequested);
-    on<GroupMemberAddRequested>(_onMemberAddRequested);
-    on<GroupMemberRemoveRequested>(_onMemberRemoveRequested);
+  GroupBloc(this._repository) : super(GroupInitial()) {
+    on<LoadGroupsByUserId>(_onLoadGroupsByUserId);
+    on<LoadGroupsByTrip>(_onLoadGroupsByTrip);
+    on<CreateGroup>(_onCreateGroup);
+    on<CreateGroupWithMembers>(_onCreateGroupWithMembers);
+    on<AddMemberToGroup>(_onAddMemberToGroup);
+    on<RemoveMemberFromGroup>(_onRemoveMemberFromGroup);
+    on<UpdateGroup>(_onUpdateGroup);
+    on<DeleteGroup>(_onDeleteGroup);
   }
 
-  Future<void> _onLoadRequested(
-    GroupLoadRequested event,
+  // NOUVEAU : Charger les groupes par userId
+  Future<void> _onLoadGroupsByUserId(
+    LoadGroupsByUserId event,
     Emitter<GroupState> emit,
   ) async {
     emit(GroupLoading());
 
     await _groupsSubscription?.cancel();
     
-    _groupsSubscription = _groupService.getGroupsStreamByUser(event.userId).listen(
-      (groups) => add(_GroupUpdated(groups: groups)),
-      onError: (error) => emit(GroupError(message: error.toString())),
+    _groupsSubscription = _repository.getGroupsByUserId(event.userId).listen(
+      (groups) => emit(GroupsLoaded(groups)),
+      onError: (error) => emit(GroupError(error.toString())),
     );
   }
 
-  Future<void> _onGroupUpdated(
-    _GroupUpdated event,
-    Emitter<GroupState> emit,
-  ) async {
-    emit(GroupLoaded(groups: event.groups));
-  }
-
-  Future<void> _onCreateRequested(
-    GroupCreateRequested event,
+  // Charger les groupes d'un voyage (conservé)
+  Future<void> _onLoadGroupsByTrip(
+    LoadGroupsByTrip event,
     Emitter<GroupState> emit,
   ) async {
     try {
-      await _groupService.createGroup(event.group);
-      emit(const GroupOperationSuccess(message: 'Groupe créé avec succès'));
+      emit(GroupLoading());
+      final group = await _repository.getGroupByTripId(event.tripId);
+      if (group != null) {
+        emit(GroupsLoaded([group]));
+      } else {
+        emit(const GroupsLoaded([]));
+      }
     } catch (e) {
-      emit(GroupError(message: e.toString()));
+      emit(GroupError(e.toString()));
     }
   }
 
-  Future<void> _onUpdateRequested(
-    GroupUpdateRequested event,
+  // Créer un groupe simple
+  Future<void> _onCreateGroup(
+    CreateGroup event,
     Emitter<GroupState> emit,
   ) async {
     try {
-      await _groupService.updateGroup(event.group);
-      emit(const GroupOperationSuccess(message: 'Groupe mis à jour'));
+      emit(GroupLoading());
+      await _repository.createGroupWithMembers(
+        group: event.group,
+        members: [],
+      );
+      emit(const GroupOperationSuccess('Groupe créé avec succès'));
     } catch (e) {
-      emit(GroupError(message: e.toString()));
+      emit(GroupError('Erreur lors de la création: $e'));
     }
   }
 
-  Future<void> _onDeleteRequested(
-    GroupDeleteRequested event,
+  // Créer un groupe avec ses membres
+  Future<void> _onCreateGroupWithMembers(
+    CreateGroupWithMembers event,
     Emitter<GroupState> emit,
   ) async {
     try {
-      await _groupService.deleteGroup(event.groupId);
-      emit(const GroupOperationSuccess(message: 'Groupe supprimé'));
+      emit(GroupLoading());
+      await _repository.createGroupWithMembers(
+        group: event.group,
+        members: event.members,
+      );
+      emit(const GroupOperationSuccess('Groupe créé avec succès'));
     } catch (e) {
-      emit(GroupError(message: e.toString()));
+      emit(GroupError('Erreur lors de la création: $e'));
     }
   }
 
-  Future<void> _onMemberAddRequested(
-    GroupMemberAddRequested event,
+  // Ajouter un membre
+  Future<void> _onAddMemberToGroup(
+    AddMemberToGroup event,
     Emitter<GroupState> emit,
   ) async {
     try {
-      await _groupService.addMemberToGroup(event.groupId, event.memberId);
-      emit(const GroupOperationSuccess(message: 'Membre ajouté'));
+      await _repository.addMember(event.groupId, event.member);
+      emit(const GroupOperationSuccess('Membre ajouté'));
     } catch (e) {
-      emit(GroupError(message: e.toString()));
+      emit(GroupError('Erreur lors de l\'ajout: $e'));
     }
   }
 
-  Future<void> _onMemberRemoveRequested(
-    GroupMemberRemoveRequested event,
+  // Supprimer un membre
+  Future<void> _onRemoveMemberFromGroup(
+    RemoveMemberFromGroup event,
     Emitter<GroupState> emit,
   ) async {
     try {
-      await _groupService.removeMemberFromGroup(event.groupId, event.memberId);
-      emit(const GroupOperationSuccess(message: 'Membre retiré'));
+      await _repository.removeMember(event.groupId, event.userId);
+      emit(const GroupOperationSuccess('Membre supprimé'));
     } catch (e) {
-      emit(GroupError(message: e.toString()));
+      emit(GroupError('Erreur lors de la suppression: $e'));
+    }
+  }
+
+  // Mettre à jour un groupe
+  Future<void> _onUpdateGroup(
+    UpdateGroup event,
+    Emitter<GroupState> emit,
+  ) async {
+    try {
+      await _repository.updateGroup(event.groupId, event.group);
+      emit(const GroupOperationSuccess('Groupe mis à jour'));
+    } catch (e) {
+      emit(GroupError('Erreur lors de la mise à jour: $e'));
+    }
+  }
+
+  // Supprimer un groupe
+  Future<void> _onDeleteGroup(
+    DeleteGroup event,
+    Emitter<GroupState> emit,
+  ) async {
+    try {
+      await _repository.deleteGroup(event.groupId);
+      emit(const GroupOperationSuccess('Groupe supprimé'));
+    } catch (e) {
+      emit(GroupError('Erreur lors de la suppression: $e'));
     }
   }
 
@@ -107,14 +143,4 @@ class GroupBloc extends Bloc<GroupEvent, GroupState> {
     _groupsSubscription?.cancel();
     return super.close();
   }
-}
-
-// Événement interne pour les mises à jour du stream
-class _GroupUpdated extends GroupEvent {
-  final List<Group> groups;
-
-  const _GroupUpdated({required this.groups});
-
-  @override
-  List<Object?> get props => [groups];
-}
+}