refactoring and checkpoint

lib/presentation/state_management/event_bloc.dart

@@ -7,7 +7,10 @@ import 'package:afterwork/data/datasources/event_remote_data_source.dart';
 @immutable
 abstract class EventEvent {}
 
-class LoadEvents extends EventEvent {}
+class LoadEvents extends EventEvent {
+  final String userId;
+  LoadEvents(this.userId);
+}
 
 class AddEvent extends EventEvent {
   final EventModel event;
@@ -15,6 +18,18 @@ class AddEvent extends EventEvent {
   AddEvent(this.event);
 }
 
+class CloseEvent extends EventEvent {
+  final String eventId;
+
+  CloseEvent(this.eventId);
+}
+
+class ReopenEvent extends EventEvent {
+  final String eventId;
+
+  ReopenEvent(this.eventId);
+}
+
 // Déclaration des états
 @immutable
 abstract class EventState {}
@@ -35,39 +50,61 @@ class EventError extends EventState {
   EventError(this.message);
 }
 
-// Bloc principal pour gérer la logique des événements
+// Bloc pour la gestion des événements
 class EventBloc extends Bloc<EventEvent, EventState> {
   final EventRemoteDataSource remoteDataSource;
 
   EventBloc({required this.remoteDataSource}) : super(EventInitial()) {
     on<LoadEvents>(_onLoadEvents);
     on<AddEvent>(_onAddEvent);
+    on<CloseEvent>(_onCloseEvent);
+    on<ReopenEvent>(_onReopenEvent);
   }
 
-  // Gestion de l'événement LoadEvents
+  // Gestion du chargement des événements
   Future<void> _onLoadEvents(LoadEvents event, Emitter<EventState> emit) async {
     emit(EventLoading());
     try {
       final events = await remoteDataSource.getAllEvents();
       emit(EventLoaded(events));
-      print('Événements chargés avec succès.');
     } catch (e) {
       emit(EventError('Erreur lors du chargement des événements.'));
-      print('Erreur lors du chargement des événements: $e');
     }
   }
 
-  // Gestion de l'événement AddEvent
+  // Gestion de l'ajout d'un nouvel événement
   Future<void> _onAddEvent(AddEvent event, Emitter<EventState> emit) async {
     emit(EventLoading());
     try {
       await remoteDataSource.createEvent(event.event);
       final events = await remoteDataSource.getAllEvents();
       emit(EventLoaded(events));
-      print('Événement ajouté avec succès.');
     } catch (e) {
       emit(EventError('Erreur lors de l\'ajout de l\'événement.'));
-      print('Erreur lors de l\'ajout de l\'événement: $e');
+    }
+  }
+
+  // Gestion de la fermeture d'un événement
+  Future<void> _onCloseEvent(CloseEvent event, Emitter<EventState> emit) async {
+    emit(EventLoading());
+    try {
+      await remoteDataSource.closeEvent(event.eventId);
+      final events = await remoteDataSource.getAllEvents();
+      emit(EventLoaded(events));
+    } catch (e) {
+      emit(EventError('Erreur lors de la fermeture de l\'événement.'));
+    }
+  }
+
+  // Gestion de la réouverture d'un événement
+  Future<void> _onReopenEvent(ReopenEvent event, Emitter<EventState> emit) async {
+    emit(EventLoading());
+    try {
+      await remoteDataSource.reopenEvent(event.eventId);
+      final events = await remoteDataSource.getAllEvents();
+      emit(EventLoaded(events));
+    } catch (e) {
+      emit(EventError('Erreur lors de la réouverture de l\'événement.'));
     }
   }
 }

lib/presentation/state_management/user_bloc.dart

@@ -2,42 +2,52 @@ import 'package:afterwork/domain/entities/user.dart';
 import 'package:afterwork/domain/usecases/get_user.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 
+/// Bloc pour la gestion des événements et états liés à l'utilisateur.
 class UserBloc extends Bloc<UserEvent, UserState> {
   final GetUser getUser;
 
+  /// Constructeur avec injection du cas d'utilisation `GetUser`.
   UserBloc({required this.getUser}) : super(UserInitial());
 
+  @override
   Stream<UserState> mapEventToState(UserEvent event) async* {
     if (event is GetUserById) {
       yield UserLoading();
       final either = await getUser(event.id);
 
       yield either.fold(
-        (failure) => UserError(),
-        (user) => UserLoaded(user: user),
+            (failure) => UserError(),
+            (user) => UserLoaded(user: user),
       );
     }
   }
 }
 
+/// Classe abstraite représentant les événements liés à l'utilisateur.
 abstract class UserEvent {}
 
+/// Événement pour récupérer un utilisateur par son ID.
 class GetUserById extends UserEvent {
   final String id;
 
   GetUserById(this.id);
 }
 
+/// Classe abstraite représentant les états possibles du BLoC utilisateur.
 abstract class UserState {}
 
+/// État initial lorsque rien n'est encore chargé.
 class UserInitial extends UserState {}
 
+/// État indiquant que les données utilisateur sont en cours de chargement.
 class UserLoading extends UserState {}
 
+/// État indiquant que les données utilisateur ont été chargées avec succès.
 class UserLoaded extends UserState {
   final User user;
 
   UserLoaded({required this.user});
 }
 
+/// État indiquant qu'une erreur est survenue lors de la récupération des données utilisateur.
 class UserError extends UserState {}