Clean project: remove test files, debug logs, and add documentation

unionflow-mobile-apps/lib/features/members/bloc/membres_bloc.dart

@@ -0,0 +1,419 @@
+/// BLoC pour la gestion des membres
+library membres_bloc;
+
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:dio/dio.dart';
+import 'membres_event.dart';
+import 'membres_state.dart';
+import '../data/repositories/membre_repository_impl.dart';
+
+/// BLoC pour la gestion des membres
+class MembresBloc extends Bloc<MembresEvent, MembresState> {
+  final MembreRepository _repository;
+
+  MembresBloc(this._repository) : super(const MembresInitial()) {
+    on<LoadMembres>(_onLoadMembres);
+    on<LoadMembreById>(_onLoadMembreById);
+    on<CreateMembre>(_onCreateMembre);
+    on<UpdateMembre>(_onUpdateMembre);
+    on<DeleteMembre>(_onDeleteMembre);
+    on<ActivateMembre>(_onActivateMembre);
+    on<DeactivateMembre>(_onDeactivateMembre);
+    on<SearchMembres>(_onSearchMembres);
+    on<LoadActiveMembres>(_onLoadActiveMembres);
+    on<LoadBureauMembres>(_onLoadBureauMembres);
+    on<LoadMembresStats>(_onLoadMembresStats);
+  }
+
+  /// Charge la liste des membres
+  Future<void> _onLoadMembres(
+    LoadMembres event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      // Si refresh et qu'on a déjà des données, on garde l'état actuel
+      if (event.refresh && state is MembresLoaded) {
+        final currentState = state as MembresLoaded;
+        emit(MembresRefreshing(currentState.membres));
+      } else {
+        emit(const MembresLoading());
+      }
+
+      final result = await _repository.getMembres(
+        page: event.page,
+        size: event.size,
+        recherche: event.recherche,
+      );
+
+      emit(MembresLoaded(
+        membres: result.membres,
+        totalElements: result.totalElements,
+        currentPage: result.currentPage,
+        pageSize: result.pageSize,
+        totalPages: result.totalPages,
+      ));
+    } on DioException catch (e) {
+      emit(MembresNetworkError(
+        message: _getNetworkErrorMessage(e),
+        code: e.response?.statusCode.toString(),
+        error: e,
+      ));
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur inattendue lors du chargement des membres: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Charge un membre par ID
+  Future<void> _onLoadMembreById(
+    LoadMembreById event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      final membre = await _repository.getMembreById(event.id);
+
+      if (membre != null) {
+        emit(MembreDetailLoaded(membre));
+      } else {
+        emit(const MembresError(
+          message: 'Membre non trouvé',
+          code: '404',
+        ));
+      }
+    } on DioException catch (e) {
+      emit(MembresNetworkError(
+        message: _getNetworkErrorMessage(e),
+        code: e.response?.statusCode.toString(),
+        error: e,
+      ));
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors du chargement du membre: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Crée un nouveau membre
+  Future<void> _onCreateMembre(
+    CreateMembre event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      final membre = await _repository.createMembre(event.membre);
+
+      emit(MembreCreated(membre));
+    } on DioException catch (e) {
+      if (e.response?.statusCode == 400) {
+        // Erreur de validation
+        final errors = _extractValidationErrors(e.response?.data);
+        emit(MembresValidationError(
+          message: 'Erreur de validation',
+          validationErrors: errors,
+          code: '400',
+        ));
+      } else {
+        emit(MembresNetworkError(
+          message: _getNetworkErrorMessage(e),
+          code: e.response?.statusCode.toString(),
+          error: e,
+        ));
+      }
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors de la création du membre: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Met à jour un membre
+  Future<void> _onUpdateMembre(
+    UpdateMembre event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      final membre = await _repository.updateMembre(event.id, event.membre);
+
+      emit(MembreUpdated(membre));
+    } on DioException catch (e) {
+      if (e.response?.statusCode == 400) {
+        final errors = _extractValidationErrors(e.response?.data);
+        emit(MembresValidationError(
+          message: 'Erreur de validation',
+          validationErrors: errors,
+          code: '400',
+        ));
+      } else {
+        emit(MembresNetworkError(
+          message: _getNetworkErrorMessage(e),
+          code: e.response?.statusCode.toString(),
+          error: e,
+        ));
+      }
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors de la mise à jour du membre: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Supprime un membre
+  Future<void> _onDeleteMembre(
+    DeleteMembre event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      await _repository.deleteMembre(event.id);
+
+      emit(MembreDeleted(event.id));
+    } on DioException catch (e) {
+      emit(MembresNetworkError(
+        message: _getNetworkErrorMessage(e),
+        code: e.response?.statusCode.toString(),
+        error: e,
+      ));
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors de la suppression du membre: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Active un membre
+  Future<void> _onActivateMembre(
+    ActivateMembre event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      final membre = await _repository.activateMembre(event.id);
+
+      emit(MembreActivated(membre));
+    } on DioException catch (e) {
+      emit(MembresNetworkError(
+        message: _getNetworkErrorMessage(e),
+        code: e.response?.statusCode.toString(),
+        error: e,
+      ));
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors de l\'activation du membre: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Désactive un membre
+  Future<void> _onDeactivateMembre(
+    DeactivateMembre event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      final membre = await _repository.deactivateMembre(event.id);
+
+      emit(MembreDeactivated(membre));
+    } on DioException catch (e) {
+      emit(MembresNetworkError(
+        message: _getNetworkErrorMessage(e),
+        code: e.response?.statusCode.toString(),
+        error: e,
+      ));
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors de la désactivation du membre: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Recherche avancée de membres
+  Future<void> _onSearchMembres(
+    SearchMembres event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      final result = await _repository.searchMembres(
+        criteria: event.criteria,
+        page: event.page,
+        size: event.size,
+      );
+
+      emit(MembresLoaded(
+        membres: result.membres,
+        totalElements: result.totalElements,
+        currentPage: result.currentPage,
+        pageSize: result.pageSize,
+        totalPages: result.totalPages,
+      ));
+    } on DioException catch (e) {
+      emit(MembresNetworkError(
+        message: _getNetworkErrorMessage(e),
+        code: e.response?.statusCode.toString(),
+        error: e,
+      ));
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors de la recherche de membres: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Charge les membres actifs
+  Future<void> _onLoadActiveMembres(
+    LoadActiveMembres event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      final result = await _repository.getActiveMembers(
+        page: event.page,
+        size: event.size,
+      );
+
+      emit(MembresLoaded(
+        membres: result.membres,
+        totalElements: result.totalElements,
+        currentPage: result.currentPage,
+        pageSize: result.pageSize,
+        totalPages: result.totalPages,
+      ));
+    } on DioException catch (e) {
+      emit(MembresNetworkError(
+        message: _getNetworkErrorMessage(e),
+        code: e.response?.statusCode.toString(),
+        error: e,
+      ));
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors du chargement des membres actifs: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Charge les membres du bureau
+  Future<void> _onLoadBureauMembres(
+    LoadBureauMembres event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      final result = await _repository.getBureauMembers(
+        page: event.page,
+        size: event.size,
+      );
+
+      emit(MembresLoaded(
+        membres: result.membres,
+        totalElements: result.totalElements,
+        currentPage: result.currentPage,
+        pageSize: result.pageSize,
+        totalPages: result.totalPages,
+      ));
+    } on DioException catch (e) {
+      emit(MembresNetworkError(
+        message: _getNetworkErrorMessage(e),
+        code: e.response?.statusCode.toString(),
+        error: e,
+      ));
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors du chargement des membres du bureau: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Charge les statistiques
+  Future<void> _onLoadMembresStats(
+    LoadMembresStats event,
+    Emitter<MembresState> emit,
+  ) async {
+    try {
+      emit(const MembresLoading());
+
+      final stats = await _repository.getMembresStats();
+
+      emit(MembresStatsLoaded(stats));
+    } on DioException catch (e) {
+      emit(MembresNetworkError(
+        message: _getNetworkErrorMessage(e),
+        code: e.response?.statusCode.toString(),
+        error: e,
+      ));
+    } catch (e) {
+      emit(MembresError(
+        message: 'Erreur lors du chargement des statistiques: $e',
+        error: e,
+      ));
+    }
+  }
+
+  /// Extrait les erreurs de validation de la réponse
+  Map<String, String> _extractValidationErrors(dynamic data) {
+    final errors = <String, String>{};
+    if (data is Map<String, dynamic> && data.containsKey('errors')) {
+      final errorsData = data['errors'];
+      if (errorsData is Map<String, dynamic>) {
+        errorsData.forEach((key, value) {
+          errors[key] = value.toString();
+        });
+      }
+    }
+    return errors;
+  }
+
+  /// Génère un message d'erreur réseau approprié
+  String _getNetworkErrorMessage(DioException e) {
+    switch (e.type) {
+      case DioExceptionType.connectionTimeout:
+        return 'Délai de connexion dépassé. Vérifiez votre connexion internet.';
+      case DioExceptionType.sendTimeout:
+        return 'Délai d\'envoi dépassé. Vérifiez votre connexion internet.';
+      case DioExceptionType.receiveTimeout:
+        return 'Délai de réception dépassé. Vérifiez votre connexion internet.';
+      case DioExceptionType.badResponse:
+        final statusCode = e.response?.statusCode;
+        if (statusCode == 401) {
+          return 'Non autorisé. Veuillez vous reconnecter.';
+        } else if (statusCode == 403) {
+          return 'Accès refusé. Vous n\'avez pas les permissions nécessaires.';
+        } else if (statusCode == 404) {
+          return 'Ressource non trouvée.';
+        } else if (statusCode == 409) {
+          return 'Conflit. Cette ressource existe déjà.';
+        } else if (statusCode != null && statusCode >= 500) {
+          return 'Erreur serveur. Veuillez réessayer plus tard.';
+        }
+        return 'Erreur lors de la communication avec le serveur.';
+      case DioExceptionType.cancel:
+        return 'Requête annulée.';
+      case DioExceptionType.unknown:
+        return 'Erreur de connexion. Vérifiez votre connexion internet.';
+      default:
+        return 'Erreur réseau inattendue.';
+    }
+  }
+}
+