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];
-}
+}

lib/blocs/group/group_event.dart

@@ -1,5 +1,6 @@
 import 'package:equatable/equatable.dart';
 import '../../data/models/group.dart';
+import '../../data/models/group_member.dart';
 
 abstract class GroupEvent extends Equatable {
   const GroupEvent();
@@ -8,64 +9,89 @@ abstract class GroupEvent extends Equatable {
   List<Object?> get props => [];
 }
 
-class GroupLoadRequested extends GroupEvent {
+// NOUVEAU : Charger les groupes par userId
+class LoadGroupsByUserId extends GroupEvent {
   final String userId;
 
-  const GroupLoadRequested({required this.userId});
+  const LoadGroupsByUserId(this.userId);
 
   @override
   List<Object?> get props => [userId];
 }
 
-class GroupCreateRequested extends GroupEvent {
+// Charger les groupes d'un voyage (conservé pour compatibilité)
+class LoadGroupsByTrip extends GroupEvent {
+  final String tripId;
+
+  const LoadGroupsByTrip(this.tripId);
+
+  @override
+  List<Object?> get props => [tripId];
+}
+
+// Créer un groupe simple
+class CreateGroup extends GroupEvent {
   final Group group;
 
-  const GroupCreateRequested({required this.group});
+  const CreateGroup(this.group);
 
   @override
   List<Object?> get props => [group];
 }
 
-class GroupUpdateRequested extends GroupEvent {
+// Créer un groupe avec ses membres
+class CreateGroupWithMembers extends GroupEvent {
   final Group group;
+  final List<GroupMember> members;
 
-  const GroupUpdateRequested({required this.group});
+  const CreateGroupWithMembers({
+    required this.group,
+    required this.members,
+  });
 
   @override
-  List<Object?> get props => [group];
+  List<Object?> get props => [group, members];
 }
 
-class GroupDeleteRequested extends GroupEvent {
+// Ajouter un membre
+class AddMemberToGroup extends GroupEvent {
+  final String groupId;
+  final GroupMember member;
+
+  const AddMemberToGroup(this.groupId, this.member);
+
+  @override
+  List<Object?> get props => [groupId, member];
+}
+
+// Supprimer un membre
+class RemoveMemberFromGroup extends GroupEvent {
+  final String groupId;
+  final String userId;
+
+  const RemoveMemberFromGroup(this.groupId, this.userId);
+
+  @override
+  List<Object?> get props => [groupId, userId];
+}
+
+// Mettre à jour un groupe
+class UpdateGroup extends GroupEvent {
+  final String groupId;
+  final Group group;
+
+  const UpdateGroup(this.groupId, this.group);
+
+  @override
+  List<Object?> get props => [groupId, group];
+}
+
+// Supprimer un groupe
+class DeleteGroup extends GroupEvent {
   final String groupId;
 
-  const GroupDeleteRequested({required this.groupId});
+  const DeleteGroup(this.groupId);
 
   @override
   List<Object?> get props => [groupId];
-}
-
-class GroupMemberAddRequested extends GroupEvent {
-  final String groupId;
-  final String memberId;
-
-  const GroupMemberAddRequested({
-    required this.groupId,
-    required this.memberId,
-  });
-
-  @override
-  List<Object?> get props => [groupId, memberId];
-}
-
-class GroupMemberRemoveRequested extends GroupEvent {
-  final String groupId;
-  final String memberId;
-
-  const GroupMemberRemoveRequested({
-    required this.groupId,
-    required this.memberId,
-  });
-
-  @override
-  List<Object?> get props => [groupId, memberId];
-}
+}

lib/blocs/group/group_state.dart

@@ -8,33 +8,38 @@ abstract class GroupState extends Equatable {
   List<Object?> get props => [];
 }
 
+// État initial
 class GroupInitial extends GroupState {}
 
+// Chargement
 class GroupLoading extends GroupState {}
 
-class GroupLoaded extends GroupState {
+// Groupes chargés
+class GroupsLoaded extends GroupState {
   final List<Group> groups;
 
-  const GroupLoaded({required this.groups});
+  const GroupsLoaded(this.groups);
 
   @override
   List<Object?> get props => [groups];
 }
 
+// Succès d'une opération
 class GroupOperationSuccess extends GroupState {
   final String message;
 
-  const GroupOperationSuccess({required this.message});
+  const GroupOperationSuccess(this.message);
 
   @override
   List<Object?> get props => [message];
 }
 
+// Erreur
 class GroupError extends GroupState {
   final String message;
 
-  const GroupError({required this.message});
+  const GroupError(this.message);
 
   @override
   List<Object?> get props => [message];
-}
+}