Refactoring

unionflow-mobile-apps/lib/features/notifications/domain/usecases/gerer_notifications_usecase.dart

@@ -0,0 +1,388 @@
+import 'package:dartz/dartz.dart';
+import '../../../../core/error/failures.dart';
+import '../../../../core/usecases/usecase.dart';
+import '../entities/notification.dart';
+import '../repositories/notifications_repository.dart';
+
+/// Use case pour marquer une notification comme lue
+class MarquerCommeLueUseCase implements UseCase<void, MarquerCommeLueParams> {
+  final NotificationsRepository repository;
+
+  MarquerCommeLueUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(MarquerCommeLueParams params) async {
+    return await repository.marquerCommeLue(
+      params.notificationId,
+      params.utilisateurId,
+    );
+  }
+}
+
+/// Paramètres pour marquer comme lue
+class MarquerCommeLueParams {
+  final String notificationId;
+  final String utilisateurId;
+
+  const MarquerCommeLueParams({
+    required this.notificationId,
+    required this.utilisateurId,
+  });
+
+  @override
+  String toString() {
+    return 'MarquerCommeLueParams{notificationId: $notificationId, utilisateurId: $utilisateurId}';
+  }
+}
+
+/// Use case pour marquer toutes les notifications comme lues
+class MarquerToutesCommeLuesUseCase implements UseCase<void, String> {
+  final NotificationsRepository repository;
+
+  MarquerToutesCommeLuesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(String utilisateurId) async {
+    return await repository.marquerToutesCommeLues(utilisateurId);
+  }
+}
+
+/// Use case pour marquer une notification comme importante
+class MarquerCommeImportanteUseCase implements UseCase<void, MarquerCommeImportanteParams> {
+  final NotificationsRepository repository;
+
+  MarquerCommeImportanteUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(MarquerCommeImportanteParams params) async {
+    return await repository.marquerCommeImportante(
+      params.notificationId,
+      params.utilisateurId,
+      params.importante,
+    );
+  }
+}
+
+/// Paramètres pour marquer comme importante
+class MarquerCommeImportanteParams {
+  final String notificationId;
+  final String utilisateurId;
+  final bool importante;
+
+  const MarquerCommeImportanteParams({
+    required this.notificationId,
+    required this.utilisateurId,
+    required this.importante,
+  });
+
+  @override
+  String toString() {
+    return 'MarquerCommeImportanteParams{notificationId: $notificationId, utilisateurId: $utilisateurId, importante: $importante}';
+  }
+}
+
+/// Use case pour archiver une notification
+class ArchiverNotificationUseCase implements UseCase<void, ArchiverNotificationParams> {
+  final NotificationsRepository repository;
+
+  ArchiverNotificationUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(ArchiverNotificationParams params) async {
+    return await repository.archiverNotification(
+      params.notificationId,
+      params.utilisateurId,
+    );
+  }
+}
+
+/// Paramètres pour archiver une notification
+class ArchiverNotificationParams {
+  final String notificationId;
+  final String utilisateurId;
+
+  const ArchiverNotificationParams({
+    required this.notificationId,
+    required this.utilisateurId,
+  });
+
+  @override
+  String toString() {
+    return 'ArchiverNotificationParams{notificationId: $notificationId, utilisateurId: $utilisateurId}';
+  }
+}
+
+/// Use case pour archiver toutes les notifications lues
+class ArchiverToutesLuesUseCase implements UseCase<void, String> {
+  final NotificationsRepository repository;
+
+  ArchiverToutesLuesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(String utilisateurId) async {
+    return await repository.archiverToutesLues(utilisateurId);
+  }
+}
+
+/// Use case pour supprimer une notification
+class SupprimerNotificationUseCase implements UseCase<void, SupprimerNotificationParams> {
+  final NotificationsRepository repository;
+
+  SupprimerNotificationUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(SupprimerNotificationParams params) async {
+    return await repository.supprimerNotification(
+      params.notificationId,
+      params.utilisateurId,
+    );
+  }
+}
+
+/// Paramètres pour supprimer une notification
+class SupprimerNotificationParams {
+  final String notificationId;
+  final String utilisateurId;
+
+  const SupprimerNotificationParams({
+    required this.notificationId,
+    required this.utilisateurId,
+  });
+
+  @override
+  String toString() {
+    return 'SupprimerNotificationParams{notificationId: $notificationId, utilisateurId: $utilisateurId}';
+  }
+}
+
+/// Use case pour supprimer toutes les notifications archivées
+class SupprimerToutesArchiveesUseCase implements UseCase<void, String> {
+  final NotificationsRepository repository;
+
+  SupprimerToutesArchiveesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(String utilisateurId) async {
+    return await repository.supprimerToutesArchivees(utilisateurId);
+  }
+}
+
+/// Use case pour exécuter une action rapide
+class ExecuterActionRapideUseCase implements UseCase<Map<String, dynamic>, ExecuterActionRapideParams> {
+  final NotificationsRepository repository;
+
+  ExecuterActionRapideUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, Map<String, dynamic>>> call(ExecuterActionRapideParams params) async {
+    return await repository.executerActionRapide(
+      params.notificationId,
+      params.actionId,
+      params.utilisateurId,
+      parametres: params.parametres,
+    );
+  }
+}
+
+/// Paramètres pour exécuter une action rapide
+class ExecuterActionRapideParams {
+  final String notificationId;
+  final String actionId;
+  final String utilisateurId;
+  final Map<String, dynamic>? parametres;
+
+  const ExecuterActionRapideParams({
+    required this.notificationId,
+    required this.actionId,
+    required this.utilisateurId,
+    this.parametres,
+  });
+
+  ExecuterActionRapideParams copyWith({
+    String? notificationId,
+    String? actionId,
+    String? utilisateurId,
+    Map<String, dynamic>? parametres,
+  }) {
+    return ExecuterActionRapideParams(
+      notificationId: notificationId ?? this.notificationId,
+      actionId: actionId ?? this.actionId,
+      utilisateurId: utilisateurId ?? this.utilisateurId,
+      parametres: parametres ?? this.parametres,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'ExecuterActionRapideParams{notificationId: $notificationId, actionId: $actionId, utilisateurId: $utilisateurId, parametres: $parametres}';
+  }
+}
+
+/// Use case pour signaler une notification comme spam
+class SignalerSpamUseCase implements UseCase<void, SignalerSpamParams> {
+  final NotificationsRepository repository;
+
+  SignalerSpamUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(SignalerSpamParams params) async {
+    return await repository.signalerSpam(
+      params.notificationId,
+      params.utilisateurId,
+      params.raison,
+    );
+  }
+}
+
+/// Paramètres pour signaler comme spam
+class SignalerSpamParams {
+  final String notificationId;
+  final String utilisateurId;
+  final String raison;
+
+  const SignalerSpamParams({
+    required this.notificationId,
+    required this.utilisateurId,
+    required this.raison,
+  });
+
+  @override
+  String toString() {
+    return 'SignalerSpamParams{notificationId: $notificationId, utilisateurId: $utilisateurId, raison: $raison}';
+  }
+}
+
+/// Use case pour synchroniser les notifications
+class SynchroniserNotificationsUseCase implements UseCase<void, SynchroniserNotificationsParams> {
+  final NotificationsRepository repository;
+
+  SynchroniserNotificationsUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(SynchroniserNotificationsParams params) async {
+    return await repository.synchroniser(
+      params.utilisateurId,
+      forceSync: params.forceSync,
+    );
+  }
+}
+
+/// Paramètres pour synchroniser les notifications
+class SynchroniserNotificationsParams {
+  final String utilisateurId;
+  final bool forceSync;
+
+  const SynchroniserNotificationsParams({
+    required this.utilisateurId,
+    this.forceSync = false,
+  });
+
+  SynchroniserNotificationsParams copyWith({
+    String? utilisateurId,
+    bool? forceSync,
+  }) {
+    return SynchroniserNotificationsParams(
+      utilisateurId: utilisateurId ?? this.utilisateurId,
+      forceSync: forceSync ?? this.forceSync,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'SynchroniserNotificationsParams{utilisateurId: $utilisateurId, forceSync: $forceSync}';
+  }
+}
+
+/// Use case pour vider le cache des notifications
+class ViderCacheNotificationsUseCase implements UseCase<void, String?> {
+  final NotificationsRepository repository;
+
+  ViderCacheNotificationsUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(String? utilisateurId) async {
+    return await repository.viderCache(utilisateurId);
+  }
+}
+
+/// Use case pour envoyer une notification de test
+class EnvoyerNotificationTestUseCase implements UseCase<NotificationEntity, EnvoyerNotificationTestParams> {
+  final NotificationsRepository repository;
+
+  EnvoyerNotificationTestUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, NotificationEntity>> call(EnvoyerNotificationTestParams params) async {
+    return await repository.envoyerNotificationTest(
+      params.utilisateurId,
+      params.type,
+    );
+  }
+}
+
+/// Paramètres pour envoyer une notification de test
+class EnvoyerNotificationTestParams {
+  final String utilisateurId;
+  final TypeNotification type;
+
+  const EnvoyerNotificationTestParams({
+    required this.utilisateurId,
+    required this.type,
+  });
+
+  @override
+  String toString() {
+    return 'EnvoyerNotificationTestParams{utilisateurId: $utilisateurId, type: $type}';
+  }
+}
+
+/// Use case pour exporter les notifications
+class ExporterNotificationsUseCase implements UseCase<String, ExporterNotificationsParams> {
+  final NotificationsRepository repository;
+
+  ExporterNotificationsUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, String>> call(ExporterNotificationsParams params) async {
+    return await repository.exporterNotifications(
+      params.utilisateurId,
+      params.format,
+      dateDebut: params.dateDebut,
+      dateFin: params.dateFin,
+    );
+  }
+}
+
+/// Paramètres pour exporter les notifications
+class ExporterNotificationsParams {
+  final String utilisateurId;
+  final String format;
+  final DateTime? dateDebut;
+  final DateTime? dateFin;
+
+  const ExporterNotificationsParams({
+    required this.utilisateurId,
+    required this.format,
+    this.dateDebut,
+    this.dateFin,
+  });
+
+  ExporterNotificationsParams copyWith({
+    String? utilisateurId,
+    String? format,
+    DateTime? dateDebut,
+    DateTime? dateFin,
+  }) {
+    return ExporterNotificationsParams(
+      utilisateurId: utilisateurId ?? this.utilisateurId,
+      format: format ?? this.format,
+      dateDebut: dateDebut ?? this.dateDebut,
+      dateFin: dateFin ?? this.dateFin,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'ExporterNotificationsParams{utilisateurId: $utilisateurId, format: $format, dateDebut: $dateDebut, dateFin: $dateFin}';
+  }
+}

unionflow-mobile-apps/lib/features/notifications/domain/usecases/gerer_preferences_usecase.dart

@@ -0,0 +1,369 @@
+import 'package:dartz/dartz.dart';
+import '../../../../core/error/failures.dart';
+import '../../../../core/usecases/usecase.dart';
+import '../entities/notification.dart';
+import '../entities/preferences_notification.dart';
+import '../repositories/notifications_repository.dart';
+
+/// Use case pour obtenir les préférences de notification
+class ObtenirPreferencesUseCase implements UseCase<PreferencesNotificationEntity, String> {
+  final NotificationsRepository repository;
+
+  ObtenirPreferencesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, PreferencesNotificationEntity>> call(String utilisateurId) async {
+    return await repository.obtenirPreferences(utilisateurId);
+  }
+}
+
+/// Use case pour mettre à jour les préférences de notification
+class MettreAJourPreferencesUseCase implements UseCase<void, PreferencesNotificationEntity> {
+  final NotificationsRepository repository;
+
+  MettreAJourPreferencesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(PreferencesNotificationEntity preferences) async {
+    return await repository.mettreAJourPreferences(preferences);
+  }
+}
+
+/// Use case pour réinitialiser les préférences
+class ReinitialiserPreferencesUseCase implements UseCase<PreferencesNotificationEntity, String> {
+  final NotificationsRepository repository;
+
+  ReinitialiserPreferencesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, PreferencesNotificationEntity>> call(String utilisateurId) async {
+    return await repository.reinitialiserPreferences(utilisateurId);
+  }
+}
+
+/// Use case pour activer/désactiver un type de notification
+class ToggleTypeNotificationUseCase implements UseCase<void, ToggleTypeNotificationParams> {
+  final NotificationsRepository repository;
+
+  ToggleTypeNotificationUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(ToggleTypeNotificationParams params) async {
+    return await repository.toggleTypeNotification(
+      params.utilisateurId,
+      params.type,
+      params.active,
+    );
+  }
+}
+
+/// Paramètres pour activer/désactiver un type de notification
+class ToggleTypeNotificationParams {
+  final String utilisateurId;
+  final TypeNotification type;
+  final bool active;
+
+  const ToggleTypeNotificationParams({
+    required this.utilisateurId,
+    required this.type,
+    required this.active,
+  });
+
+  @override
+  String toString() {
+    return 'ToggleTypeNotificationParams{utilisateurId: $utilisateurId, type: $type, active: $active}';
+  }
+}
+
+/// Use case pour activer/désactiver un canal de notification
+class ToggleCanalNotificationUseCase implements UseCase<void, ToggleCanalNotificationParams> {
+  final NotificationsRepository repository;
+
+  ToggleCanalNotificationUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(ToggleCanalNotificationParams params) async {
+    return await repository.toggleCanalNotification(
+      params.utilisateurId,
+      params.canal,
+      params.active,
+    );
+  }
+}
+
+/// Paramètres pour activer/désactiver un canal de notification
+class ToggleCanalNotificationParams {
+  final String utilisateurId;
+  final CanalNotification canal;
+  final bool active;
+
+  const ToggleCanalNotificationParams({
+    required this.utilisateurId,
+    required this.canal,
+    required this.active,
+  });
+
+  @override
+  String toString() {
+    return 'ToggleCanalNotificationParams{utilisateurId: $utilisateurId, canal: $canal, active: $active}';
+  }
+}
+
+/// Use case pour configurer le mode silencieux
+class ConfigurerModeSilencieuxUseCase implements UseCase<void, ConfigurerModeSilencieuxParams> {
+  final NotificationsRepository repository;
+
+  ConfigurerModeSilencieuxUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(ConfigurerModeSilencieuxParams params) async {
+    return await repository.configurerModeSilencieux(
+      params.utilisateurId,
+      params.active,
+      heureDebut: params.heureDebut,
+      heureFin: params.heureFin,
+      jours: params.jours,
+    );
+  }
+}
+
+/// Paramètres pour configurer le mode silencieux
+class ConfigurerModeSilencieuxParams {
+  final String utilisateurId;
+  final bool active;
+  final String? heureDebut;
+  final String? heureFin;
+  final Set<int>? jours;
+
+  const ConfigurerModeSilencieuxParams({
+    required this.utilisateurId,
+    required this.active,
+    this.heureDebut,
+    this.heureFin,
+    this.jours,
+  });
+
+  ConfigurerModeSilencieuxParams copyWith({
+    String? utilisateurId,
+    bool? active,
+    String? heureDebut,
+    String? heureFin,
+    Set<int>? jours,
+  }) {
+    return ConfigurerModeSilencieuxParams(
+      utilisateurId: utilisateurId ?? this.utilisateurId,
+      active: active ?? this.active,
+      heureDebut: heureDebut ?? this.heureDebut,
+      heureFin: heureFin ?? this.heureFin,
+      jours: jours ?? this.jours,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'ConfigurerModeSilencieuxParams{utilisateurId: $utilisateurId, active: $active, heureDebut: $heureDebut, heureFin: $heureFin, jours: $jours}';
+  }
+}
+
+/// Use case pour enregistrer le token FCM
+class EnregistrerTokenFCMUseCase implements UseCase<void, EnregistrerTokenFCMParams> {
+  final NotificationsRepository repository;
+
+  EnregistrerTokenFCMUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(EnregistrerTokenFCMParams params) async {
+    return await repository.enregistrerTokenFCM(
+      params.utilisateurId,
+      params.token,
+      params.plateforme,
+    );
+  }
+}
+
+/// Paramètres pour enregistrer le token FCM
+class EnregistrerTokenFCMParams {
+  final String utilisateurId;
+  final String token;
+  final String plateforme;
+
+  const EnregistrerTokenFCMParams({
+    required this.utilisateurId,
+    required this.token,
+    required this.plateforme,
+  });
+
+  @override
+  String toString() {
+    return 'EnregistrerTokenFCMParams{utilisateurId: $utilisateurId, token: $token, plateforme: $plateforme}';
+  }
+}
+
+/// Use case pour supprimer le token FCM
+class SupprimerTokenFCMUseCase implements UseCase<void, String> {
+  final NotificationsRepository repository;
+
+  SupprimerTokenFCMUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(String utilisateurId) async {
+    return await repository.supprimerTokenFCM(utilisateurId);
+  }
+}
+
+/// Use case pour s'abonner à un topic
+class AbonnerAuTopicUseCase implements UseCase<void, AbonnerAuTopicParams> {
+  final NotificationsRepository repository;
+
+  AbonnerAuTopicUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(AbonnerAuTopicParams params) async {
+    return await repository.abonnerAuTopic(
+      params.utilisateurId,
+      params.topic,
+    );
+  }
+}
+
+/// Paramètres pour s'abonner à un topic
+class AbonnerAuTopicParams {
+  final String utilisateurId;
+  final String topic;
+
+  const AbonnerAuTopicParams({
+    required this.utilisateurId,
+    required this.topic,
+  });
+
+  @override
+  String toString() {
+    return 'AbonnerAuTopicParams{utilisateurId: $utilisateurId, topic: $topic}';
+  }
+}
+
+/// Use case pour se désabonner d'un topic
+class DesabonnerDuTopicUseCase implements UseCase<void, DesabonnerDuTopicParams> {
+  final NotificationsRepository repository;
+
+  DesabonnerDuTopicUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(DesabonnerDuTopicParams params) async {
+    return await repository.desabonnerDuTopic(
+      params.utilisateurId,
+      params.topic,
+    );
+  }
+}
+
+/// Paramètres pour se désabonner d'un topic
+class DesabonnerDuTopicParams {
+  final String utilisateurId;
+  final String topic;
+
+  const DesabonnerDuTopicParams({
+    required this.utilisateurId,
+    required this.topic,
+  });
+
+  @override
+  String toString() {
+    return 'DesabonnerDuTopicParams{utilisateurId: $utilisateurId, topic: $topic}';
+  }
+}
+
+/// Use case pour obtenir les topics auxquels l'utilisateur est abonné
+class ObtenirTopicsAbornesUseCase implements UseCase<List<String>, String> {
+  final NotificationsRepository repository;
+
+  ObtenirTopicsAbornesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, List<String>>> call(String utilisateurId) async {
+    return await repository.obtenirTopicsAbornes(utilisateurId);
+  }
+}
+
+/// Use case pour configurer les préférences avancées
+class ConfigurerPreferencesAvanceesUseCase implements UseCase<void, ConfigurerPreferencesAvanceesParams> {
+  final NotificationsRepository repository;
+
+  ConfigurerPreferencesAvanceesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, void>> call(ConfigurerPreferencesAvanceesParams params) async {
+    // Récupération des préférences actuelles
+    final preferencesResult = await repository.obtenirPreferences(params.utilisateurId);
+    
+    return preferencesResult.fold(
+      (failure) => Left(failure),
+      (preferences) async {
+        // Mise à jour des préférences avec les nouveaux paramètres
+        final preferencesModifiees = preferences.copyWith(
+          vibrationActivee: params.vibrationActivee ?? preferences.vibrationActivee,
+          sonActive: params.sonActive ?? preferences.sonActive,
+          ledActivee: params.ledActivee ?? preferences.ledActivee,
+          sonPersonnalise: params.sonPersonnalise ?? preferences.sonPersonnalise,
+          patternVibrationPersonnalise: params.patternVibrationPersonnalise ?? preferences.patternVibrationPersonnalise,
+          couleurLEDPersonnalisee: params.couleurLEDPersonnalisee ?? preferences.couleurLEDPersonnalisee,
+          apercuEcranVerrouillage: params.apercuEcranVerrouillage ?? preferences.apercuEcranVerrouillage,
+          dureeAffichageSecondes: params.dureeAffichageSecondes ?? preferences.dureeAffichageSecondes,
+          frequenceRegroupementMinutes: params.frequenceRegroupementMinutes ?? preferences.frequenceRegroupementMinutes,
+          maxNotificationsSimultanees: params.maxNotificationsSimultanees ?? preferences.maxNotificationsSimultanees,
+          marquageLectureAutomatique: params.marquageLectureAutomatique ?? preferences.marquageLectureAutomatique,
+          delaiMarquageLectureSecondes: params.delaiMarquageLectureSecondes ?? preferences.delaiMarquageLectureSecondes,
+          archivageAutomatique: params.archivageAutomatique ?? preferences.archivageAutomatique,
+          delaiArchivageHeures: params.delaiArchivageHeures ?? preferences.delaiArchivageHeures,
+          dureeConservationJours: params.dureeConservationJours ?? preferences.dureeConservationJours,
+        );
+        
+        return await repository.mettreAJourPreferences(preferencesModifiees);
+      },
+    );
+  }
+}
+
+/// Paramètres pour configurer les préférences avancées
+class ConfigurerPreferencesAvanceesParams {
+  final String utilisateurId;
+  final bool? vibrationActivee;
+  final bool? sonActive;
+  final bool? ledActivee;
+  final String? sonPersonnalise;
+  final List<int>? patternVibrationPersonnalise;
+  final String? couleurLEDPersonnalisee;
+  final bool? apercuEcranVerrouillage;
+  final int? dureeAffichageSecondes;
+  final int? frequenceRegroupementMinutes;
+  final int? maxNotificationsSimultanees;
+  final bool? marquageLectureAutomatique;
+  final int? delaiMarquageLectureSecondes;
+  final bool? archivageAutomatique;
+  final int? delaiArchivageHeures;
+  final int? dureeConservationJours;
+
+  const ConfigurerPreferencesAvanceesParams({
+    required this.utilisateurId,
+    this.vibrationActivee,
+    this.sonActive,
+    this.ledActivee,
+    this.sonPersonnalise,
+    this.patternVibrationPersonnalise,
+    this.couleurLEDPersonnalisee,
+    this.apercuEcranVerrouillage,
+    this.dureeAffichageSecondes,
+    this.frequenceRegroupementMinutes,
+    this.maxNotificationsSimultanees,
+    this.marquageLectureAutomatique,
+    this.delaiMarquageLectureSecondes,
+    this.archivageAutomatique,
+    this.delaiArchivageHeures,
+    this.dureeConservationJours,
+  });
+
+  @override
+  String toString() {
+    return 'ConfigurerPreferencesAvanceesParams{utilisateurId: $utilisateurId, vibrationActivee: $vibrationActivee, sonActive: $sonActive, ledActivee: $ledActivee, ...}';
+  }
+}

unionflow-mobile-apps/lib/features/notifications/domain/usecases/obtenir_notifications_usecase.dart

@@ -0,0 +1,274 @@
+import 'package:dartz/dartz.dart';
+import '../../../../core/error/failures.dart';
+import '../../../../core/usecases/usecase.dart';
+import '../entities/notification.dart';
+import '../repositories/notifications_repository.dart';
+
+/// Use case pour obtenir les notifications d'un utilisateur
+class ObtenirNotificationsUseCase implements UseCase<List<NotificationEntity>, ObtenirNotificationsParams> {
+  final NotificationsRepository repository;
+
+  ObtenirNotificationsUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, List<NotificationEntity>>> call(ObtenirNotificationsParams params) async {
+    // Vérification du cache en premier
+    final cacheValide = await repository.isCacheValide(
+      params.utilisateurId,
+      maxAgeMinutes: params.maxAgeCacheMinutes,
+    );
+
+    if (!cacheValide || params.forceRefresh) {
+      // Synchronisation avec le serveur si nécessaire
+      final syncResult = await repository.synchroniser(
+        params.utilisateurId,
+        forceSync: params.forceRefresh,
+      );
+      
+      // On continue même si la sync échoue (mode offline)
+      if (syncResult.isLeft()) {
+        // Log de l'erreur mais on continue avec les données en cache
+        print('Erreur de synchronisation: ${syncResult.fold((l) => l.toString(), (r) => '')}');
+      }
+    }
+
+    // Récupération des notifications
+    return await repository.obtenirNotifications(
+      utilisateurId: params.utilisateurId,
+      includeArchivees: params.includeArchivees,
+      limite: params.limite,
+      offset: params.offset,
+    );
+  }
+}
+
+/// Paramètres pour obtenir les notifications
+class ObtenirNotificationsParams {
+  final String utilisateurId;
+  final bool includeArchivees;
+  final int limite;
+  final int offset;
+  final bool forceRefresh;
+  final int maxAgeCacheMinutes;
+
+  const ObtenirNotificationsParams({
+    required this.utilisateurId,
+    this.includeArchivees = false,
+    this.limite = 50,
+    this.offset = 0,
+    this.forceRefresh = false,
+    this.maxAgeCacheMinutes = 5,
+  });
+
+  ObtenirNotificationsParams copyWith({
+    String? utilisateurId,
+    bool? includeArchivees,
+    int? limite,
+    int? offset,
+    bool? forceRefresh,
+    int? maxAgeCacheMinutes,
+  }) {
+    return ObtenirNotificationsParams(
+      utilisateurId: utilisateurId ?? this.utilisateurId,
+      includeArchivees: includeArchivees ?? this.includeArchivees,
+      limite: limite ?? this.limite,
+      offset: offset ?? this.offset,
+      forceRefresh: forceRefresh ?? this.forceRefresh,
+      maxAgeCacheMinutes: maxAgeCacheMinutes ?? this.maxAgeCacheMinutes,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'ObtenirNotificationsParams{utilisateurId: $utilisateurId, includeArchivees: $includeArchivees, limite: $limite, offset: $offset, forceRefresh: $forceRefresh}';
+  }
+}
+
+/// Use case pour obtenir les notifications non lues
+class ObtenirNotificationsNonLuesUseCase implements UseCase<List<NotificationEntity>, String> {
+  final NotificationsRepository repository;
+
+  ObtenirNotificationsNonLuesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, List<NotificationEntity>>> call(String utilisateurId) async {
+    return await repository.obtenirNotificationsNonLues(utilisateurId);
+  }
+}
+
+/// Use case pour obtenir le nombre de notifications non lues
+class ObtenirNombreNonLuesUseCase implements UseCase<int, String> {
+  final NotificationsRepository repository;
+
+  ObtenirNombreNonLuesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, int>> call(String utilisateurId) async {
+    return await repository.obtenirNombreNonLues(utilisateurId);
+  }
+}
+
+/// Use case pour rechercher des notifications
+class RechercherNotificationsUseCase implements UseCase<List<NotificationEntity>, RechercherNotificationsParams> {
+  final NotificationsRepository repository;
+
+  RechercherNotificationsUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, List<NotificationEntity>>> call(RechercherNotificationsParams params) async {
+    return await repository.rechercherNotifications(
+      utilisateurId: params.utilisateurId,
+      query: params.query,
+      types: params.types,
+      statuts: params.statuts,
+      dateDebut: params.dateDebut,
+      dateFin: params.dateFin,
+      limite: params.limite,
+    );
+  }
+}
+
+/// Paramètres pour la recherche de notifications
+class RechercherNotificationsParams {
+  final String utilisateurId;
+  final String? query;
+  final List<TypeNotification>? types;
+  final List<StatutNotification>? statuts;
+  final DateTime? dateDebut;
+  final DateTime? dateFin;
+  final int limite;
+
+  const RechercherNotificationsParams({
+    required this.utilisateurId,
+    this.query,
+    this.types,
+    this.statuts,
+    this.dateDebut,
+    this.dateFin,
+    this.limite = 50,
+  });
+
+  RechercherNotificationsParams copyWith({
+    String? utilisateurId,
+    String? query,
+    List<TypeNotification>? types,
+    List<StatutNotification>? statuts,
+    DateTime? dateDebut,
+    DateTime? dateFin,
+    int? limite,
+  }) {
+    return RechercherNotificationsParams(
+      utilisateurId: utilisateurId ?? this.utilisateurId,
+      query: query ?? this.query,
+      types: types ?? this.types,
+      statuts: statuts ?? this.statuts,
+      dateDebut: dateDebut ?? this.dateDebut,
+      dateFin: dateFin ?? this.dateFin,
+      limite: limite ?? this.limite,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'RechercherNotificationsParams{utilisateurId: $utilisateurId, query: $query, types: $types, statuts: $statuts, dateDebut: $dateDebut, dateFin: $dateFin, limite: $limite}';
+  }
+}
+
+/// Use case pour obtenir les notifications par type
+class ObtenirNotificationsParTypeUseCase implements UseCase<List<NotificationEntity>, ObtenirNotificationsParTypeParams> {
+  final NotificationsRepository repository;
+
+  ObtenirNotificationsParTypeUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, List<NotificationEntity>>> call(ObtenirNotificationsParTypeParams params) async {
+    return await repository.obtenirNotificationsParType(
+      params.utilisateurId,
+      params.type,
+      limite: params.limite,
+    );
+  }
+}
+
+/// Paramètres pour obtenir les notifications par type
+class ObtenirNotificationsParTypeParams {
+  final String utilisateurId;
+  final TypeNotification type;
+  final int limite;
+
+  const ObtenirNotificationsParTypeParams({
+    required this.utilisateurId,
+    required this.type,
+    this.limite = 50,
+  });
+
+  ObtenirNotificationsParTypeParams copyWith({
+    String? utilisateurId,
+    TypeNotification? type,
+    int? limite,
+  }) {
+    return ObtenirNotificationsParTypeParams(
+      utilisateurId: utilisateurId ?? this.utilisateurId,
+      type: type ?? this.type,
+      limite: limite ?? this.limite,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'ObtenirNotificationsParTypeParams{utilisateurId: $utilisateurId, type: $type, limite: $limite}';
+  }
+}
+
+/// Use case pour obtenir les notifications importantes
+class ObtenirNotificationsImportantesUseCase implements UseCase<List<NotificationEntity>, String> {
+  final NotificationsRepository repository;
+
+  ObtenirNotificationsImportantesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, List<NotificationEntity>>> call(String utilisateurId) async {
+    return await repository.obtenirNotificationsImportantes(utilisateurId);
+  }
+}
+
+/// Use case pour obtenir les statistiques des notifications
+class ObtenirStatistiquesNotificationsUseCase implements UseCase<Map<String, dynamic>, ObtenirStatistiquesParams> {
+  final NotificationsRepository repository;
+
+  ObtenirStatistiquesNotificationsUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, Map<String, dynamic>>> call(ObtenirStatistiquesParams params) async {
+    return await repository.obtenirStatistiques(
+      params.utilisateurId,
+      periode: params.periode,
+    );
+  }
+}
+
+/// Paramètres pour obtenir les statistiques
+class ObtenirStatistiquesParams {
+  final String utilisateurId;
+  final int periode;
+
+  const ObtenirStatistiquesParams({
+    required this.utilisateurId,
+    this.periode = 30,
+  });
+
+  ObtenirStatistiquesParams copyWith({
+    String? utilisateurId,
+    int? periode,
+  }) {
+    return ObtenirStatistiquesParams(
+      utilisateurId: utilisateurId ?? this.utilisateurId,
+      periode: periode ?? this.periode,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'ObtenirStatistiquesParams{utilisateurId: $utilisateurId, periode: $periode}';
+  }
+}