Refactoring - Version OK

2025-11-17 16:02:04 +00:00
parent 3f00a26308
commit 3b9ffac8cd
198 changed files with 18010 additions and 11383 deletions
--- a/unionflow-mobile-apps/lib/features/dashboard/presentation/bloc/dashboard_bloc.dart
+++ b/unionflow-mobile-apps/lib/features/dashboard/presentation/bloc/dashboard_bloc.dart
@@ -0,0 +1,174 @@
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:equatable/equatable.dart';
+import '../../domain/entities/dashboard_entity.dart';
+import '../../domain/usecases/get_dashboard_data.dart';
+import '../../../../core/error/failures.dart';
+
+part 'dashboard_event.dart';
+part 'dashboard_state.dart';
+
+class DashboardBloc extends Bloc<DashboardEvent, DashboardState> {
+  final GetDashboardData getDashboardData;
+  final GetDashboardStats getDashboardStats;
+  final GetRecentActivities getRecentActivities;
+  final GetUpcomingEvents getUpcomingEvents;
+
+  DashboardBloc({
+    required this.getDashboardData,
+    required this.getDashboardStats,
+    required this.getRecentActivities,
+    required this.getUpcomingEvents,
+  }) : super(DashboardInitial()) {
+    on<LoadDashboardData>(_onLoadDashboardData);
+    on<RefreshDashboardData>(_onRefreshDashboardData);
+    on<LoadDashboardStats>(_onLoadDashboardStats);
+    on<LoadRecentActivities>(_onLoadRecentActivities);
+    on<LoadUpcomingEvents>(_onLoadUpcomingEvents);
+  }
+
+  Future<void> _onLoadDashboardData(
+    LoadDashboardData event,
+    Emitter<DashboardState> emit,
+  ) async {
+    emit(DashboardLoading());
+
+    final result = await getDashboardData(
+      GetDashboardDataParams(
+        organizationId: event.organizationId,
+        userId: event.userId,
+      ),
+    );
+
+    result.fold(
+      (failure) => emit(DashboardError(_mapFailureToMessage(failure))),
+      (dashboardData) => emit(DashboardLoaded(dashboardData)),
+    );
+  }
+
+  Future<void> _onRefreshDashboardData(
+    RefreshDashboardData event,
+    Emitter<DashboardState> emit,
+  ) async {
+    // Garde l'état actuel pendant le refresh
+    if (state is DashboardLoaded) {
+      emit(DashboardRefreshing((state as DashboardLoaded).dashboardData));
+    } else {
+      emit(DashboardLoading());
+    }
+
+    final result = await getDashboardData(
+      GetDashboardDataParams(
+        organizationId: event.organizationId,
+        userId: event.userId,
+      ),
+    );
+
+    result.fold(
+      (failure) => emit(DashboardError(_mapFailureToMessage(failure))),
+      (dashboardData) => emit(DashboardLoaded(dashboardData)),
+    );
+  }
+
+  Future<void> _onLoadDashboardStats(
+    LoadDashboardStats event,
+    Emitter<DashboardState> emit,
+  ) async {
+    final result = await getDashboardStats(
+      GetDashboardStatsParams(
+        organizationId: event.organizationId,
+        userId: event.userId,
+      ),
+    );
+
+    result.fold(
+      (failure) => emit(DashboardError(_mapFailureToMessage(failure))),
+      (stats) {
+        if (state is DashboardLoaded) {
+          final currentData = (state as DashboardLoaded).dashboardData;
+          final updatedData = DashboardEntity(
+            stats: stats,
+            recentActivities: currentData.recentActivities,
+            upcomingEvents: currentData.upcomingEvents,
+            userPreferences: currentData.userPreferences,
+            organizationId: currentData.organizationId,
+            userId: currentData.userId,
+          );
+          emit(DashboardLoaded(updatedData));
+        }
+      },
+    );
+  }
+
+  Future<void> _onLoadRecentActivities(
+    LoadRecentActivities event,
+    Emitter<DashboardState> emit,
+  ) async {
+    final result = await getRecentActivities(
+      GetRecentActivitiesParams(
+        organizationId: event.organizationId,
+        userId: event.userId,
+        limit: event.limit,
+      ),
+    );
+
+    result.fold(
+      (failure) => emit(DashboardError(_mapFailureToMessage(failure))),
+      (activities) {
+        if (state is DashboardLoaded) {
+          final currentData = (state as DashboardLoaded).dashboardData;
+          final updatedData = DashboardEntity(
+            stats: currentData.stats,
+            recentActivities: activities,
+            upcomingEvents: currentData.upcomingEvents,
+            userPreferences: currentData.userPreferences,
+            organizationId: currentData.organizationId,
+            userId: currentData.userId,
+          );
+          emit(DashboardLoaded(updatedData));
+        }
+      },
+    );
+  }
+
+  Future<void> _onLoadUpcomingEvents(
+    LoadUpcomingEvents event,
+    Emitter<DashboardState> emit,
+  ) async {
+    final result = await getUpcomingEvents(
+      GetUpcomingEventsParams(
+        organizationId: event.organizationId,
+        userId: event.userId,
+        limit: event.limit,
+      ),
+    );
+
+    result.fold(
+      (failure) => emit(DashboardError(_mapFailureToMessage(failure))),
+      (events) {
+        if (state is DashboardLoaded) {
+          final currentData = (state as DashboardLoaded).dashboardData;
+          final updatedData = DashboardEntity(
+            stats: currentData.stats,
+            recentActivities: currentData.recentActivities,
+            upcomingEvents: events,
+            userPreferences: currentData.userPreferences,
+            organizationId: currentData.organizationId,
+            userId: currentData.userId,
+          );
+          emit(DashboardLoaded(updatedData));
+        }
+      },
+    );
+  }
+
+  String _mapFailureToMessage(Failure failure) {
+    switch (failure.runtimeType) {
+      case ServerFailure:
+        return 'Erreur serveur. Veuillez réessayer.';
+      case NetworkFailure:
+        return 'Pas de connexion internet. Vérifiez votre connexion.';
+      default:
+        return 'Une erreur inattendue s\'est produite.';
+    }
+  }
+}