feat: WebSocket temps réel + Finance Workflow + corrections

- Task #6: WebSocket /ws/dashboard + Kafka events (5 topics)
  * Backend: KafkaEventProducer, KafkaEventConsumer
  * Mobile: WebSocketService (reconnection, heartbeat, typed events)
  * DashboardBloc: Auto-refresh depuis WebSocket events

- Finance Workflow: approbations + budgets (backend + mobile)
  * Backend: entities, services, resources, migrations Flyway V6
  * Mobile: features finance_workflow complète avec BLoC

- Corrections DI: interfaces IRepository partout
  * IProfileRepository, IOrganizationRepository, IMembreRepository
  * GetIt configuré avec @injectable

- Spec-Kit: constitution + templates mis à jour
  * .specify/memory/constitution.md enrichie
  * Templates agent, plan, spec, tasks, checklist

- Nettoyage: fichiers temporaires supprimés

Signed-off-by: lions dev Team

unionflow/unionflow-mobile-apps/lib/features/communication/README.md

@@ -0,0 +1,192 @@
+# Feature Communication/Messaging
+
+**Status**: ✅ **Implémenté** (MVP Fonctionnel)
+**Date**: 2026-03-13
+**Priorité**: P0 (Bloquant Production)
+
+## 📋 Vue d'ensemble
+
+Module de communication permettant la messagerie entre membres et les broadcasts organisation selon les permissions RBAC.
+
+## 🎯 Fonctionnalités Implémentées
+
+### ✅ MVP (V1.0)
+
+1. **Liste des Conversations**
+   - Affichage conversations triées par date
+   - Badge compteur messages non lus
+   - Indicateurs visuels (pinned, muted)
+   - Pull-to-refresh
+   - Navigation vers détail conversation
+
+2. **Permissions Respectées**
+   - `COMM_SEND_ALL` - OrgAdmin, SuperAdmin
+   - `COMM_SEND_MEMBERS` - Moderator
+   - `COMM_BROADCAST` - OrgAdmin
+   - Menu "Messages" visible selon rôle (OrgAdmin, SuperAdmin, Moderator)
+
+3. **Architecture Clean + BLoC**
+   - Domain : Entities (Message, Conversation, MessageTemplate)
+   - Data : Models avec JSON serialization, Repository, Datasource
+   - Presentation : BLoC (Events, States), Pages, Widgets
+
+4. **Intégration App**
+   - Routes : `/messages`, `/communication`
+   - Navigation : Menu "Plus" avec vérification permissions
+   - DI : Injectable + GetIt
+
+## 🏗️ Architecture
+
+```
+communication/
+├── domain/
+│   ├── entities/
+│   │   ├── message.dart (Message, MessageType, MessageStatus, MessagePriority)
+│   │   ├── conversation.dart (Conversation, ConversationType)
+│   │   └── message_template.dart (MessageTemplate, TemplateCategory)
+│   ├── repositories/
+│   │   └── messaging_repository.dart (interface)
+│   └── usecases/
+│       ├── get_conversations.dart
+│       ├── get_messages.dart
+│       ├── send_message.dart
+│       └── send_broadcast.dart
+├── data/
+│   ├── models/
+│   │   ├── message_model.dart (.g.dart généré)
+│   │   └── conversation_model.dart (.g.dart généré)
+│   ├── datasources/
+│   │   └── messaging_remote_datasource.dart (API REST)
+│   └── repositories/
+│       └── messaging_repository_impl.dart
+└── presentation/
+    ├── bloc/
+    │   ├── messaging_event.dart
+    │   ├── messaging_state.dart
+    │   └── messaging_bloc.dart
+    ├── pages/
+    │   └── conversations_page.dart
+    └── widgets/
+        └── conversation_tile.dart
+```
+
+## 📡 API Endpoints Utilisés
+
+| Endpoint | Méthode | Description |
+|----------|---------|-------------|
+| `/api/messaging/conversations` | GET | Liste conversations |
+| `/api/messaging/conversations/:id` | GET | Détail conversation |
+| `/api/messaging/conversations` | POST | Créer conversation |
+| `/api/messaging/conversations/:id/messages` | GET | Messages d'une conversation |
+| `/api/messaging/conversations/:id/messages` | POST | Envoyer message |
+| `/api/messaging/broadcast` | POST | Envoyer broadcast |
+| `/api/messaging/messages/:id/read` | PUT | Marquer message lu |
+| `/api/messaging/unread/count` | GET | Compteur non lus |
+
+**⚠️ Note**: Backend endpoints à implémenter côté serveur Quarkus
+
+## 🔄 États BLoC
+
+- `MessagingInitial` - État initial
+- `MessagingLoading` - Chargement en cours
+- `ConversationsLoaded` - Conversations chargées avec compteur non lus
+- `MessagesLoaded` - Messages d'une conversation chargés
+- `MessageSent` - Message envoyé avec succès
+- `BroadcastSent` - Broadcast envoyé avec succès
+- `MessagingError` - Erreur avec message utilisateur
+
+## 🚀 Prochaines Étapes (V2.0+)
+
+### P1 - Fonctionnalités Avancées
+
+- [ ] Page détail conversation (chat thread)
+- [ ] Envoi pièces jointes (images, documents)
+- [ ] Édition/suppression messages
+- [ ] Recherche dans conversations
+- [ ] Filtres conversations (non lus, pinned, archivées)
+- [ ] Templates messages personnalisables (CRUD)
+- [ ] Messages ciblés par rôles (COMM_TARGETED)
+- [ ] Modération messages (MODERATION_CONTENT)
+- [ ] Statistiques communication (dashboard analytics)
+
+### P2 - Optimisations
+
+- [ ] WebSocket temps réel pour nouveaux messages
+- [ ] Cache local conversations récentes
+- [ ] Pagination messages (infinite scroll)
+- [ ] Compression images avant envoi
+- [ ] Mode offline avec synchronisation
+- [ ] Notifications push (FCM)
+- [ ] Read receipts (accusés de lecture)
+- [ ] Typing indicators (en train d'écrire)
+
+## 🧪 Tests
+
+### À Implémenter
+
+- [ ] Unit tests BLoC (bloc_test)
+- [ ] Unit tests UseCases (mockito)
+- [ ] Unit tests Repository (mockito)
+- [ ] Widget tests ConversationsPage
+- [ ] Integration tests flux complet
+
+## 📝 Notes Techniques
+
+### JSON Serialization
+
+Le champ `lastMessage` dans `Conversation` utilise une sérialisation custom car `Message` est un type nested :
+
+```dart
+@JsonKey(
+  fromJson: _messageFromJson,
+  toJson: _messageToJson,
+)
+final Message? lastMessage;
+```
+
+### Gestion d'Erreurs
+
+Toutes les méthodes repository retournent `Either<Failure, T>` pour une gestion fonctionnelle des erreurs :
+
+- `NetworkFailure` - Pas de connexion Internet
+- `UnauthorizedFailure` - Token expiré (401)
+- `ForbiddenFailure` - Permission insuffisante (403)
+- `NotFoundFailure` - Ressource non trouvée (404)
+- `ServerFailure` - Erreur serveur (5xx)
+- `ValidationFailure` - Données invalides
+- `UnexpectedFailure` - Erreur inattendue
+- `NotImplementedFailure` - Fonctionnalité en développement
+
+### Dépendances Externes
+
+Module `RegisterModule` enregistre :
+- `http.Client` pour requêtes HTTP
+- `FlutterSecureStorage` pour tokens
+- `Connectivity` pour état réseau
+
+## 📚 Documentation Connexe
+
+- [Permission Matrix](../../features/authentication/data/models/permission_matrix.dart)
+- [User Roles](../../features/authentication/data/models/user_role.dart)
+- [API Design](../../specs/000-unionflow-baseline/spec.md)
+- [Audit Métier](../../AUDIT_METIER_COMPLET.md)
+
+## ✅ Critères d'Acceptation
+
+- [x] Architecture Clean + BLoC respectée
+- [x] Permissions RBAC vérifiées (OrgAdmin, SuperAdmin, Moderator)
+- [x] Routes intégrées (/messages, /communication)
+- [x] Menu navigation avec vérification rôles
+- [x] Page liste conversations fonctionnelle
+- [x] Gestion erreurs complète (Failures)
+- [x] DI configuré (Injectable + GetIt)
+- [x] JSON serialization (.g.dart générés)
+- [x] Code compilable sans erreurs
+- [ ] Backend endpoints implémentés (Quarkus)
+- [ ] Tests unitaires BLoC
+- [ ] Tests intégration E2E
+
+---
+
+**Développé avec**: Flutter 3.5.3+, Dart 3.x, BLoC 8.1.6, Clean Architecture
+**Gap comblé**: Communication/Messaging (P0 Bloquant Production)

unionflow/unionflow-mobile-apps/lib/features/communication/data/datasources/messaging_remote_datasource.dart

@@ -0,0 +1,230 @@
+/// Datasource distant pour la communication (API)
+library messaging_remote_datasource;
+
+import 'dart:convert';
+import 'package:http/http.dart' as http;
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+import 'package:injectable/injectable.dart';
+import '../../../../core/config/environment.dart';
+import '../../../../core/error/exceptions.dart';
+import '../models/message_model.dart';
+import '../models/conversation_model.dart';
+import '../../domain/entities/message.dart';
+
+@lazySingleton
+class MessagingRemoteDatasource {
+  final http.Client client;
+  final FlutterSecureStorage secureStorage;
+
+  MessagingRemoteDatasource({
+    required this.client,
+    required this.secureStorage,
+  });
+
+  /// Headers HTTP avec authentification
+  Future<Map<String, String>> _getHeaders() async {
+    final token = await secureStorage.read(key: 'access_token');
+    return {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      if (token != null) 'Authorization': 'Bearer $token',
+    };
+  }
+
+  // === CONVERSATIONS ===
+
+  Future<List<ConversationModel>> getConversations({
+    String? organizationId,
+    bool includeArchived = false,
+  }) async {
+    final uri = Uri.parse('${AppConfig.apiBaseUrl}/api/messaging/conversations')
+        .replace(queryParameters: {
+      if (organizationId != null) 'organizationId': organizationId,
+      'includeArchived': includeArchived.toString(),
+    });
+
+    final response = await client.get(uri, headers: await _getHeaders());
+
+    if (response.statusCode == 200) {
+      final List<dynamic> jsonList = json.decode(response.body);
+      return jsonList
+          .map((json) => ConversationModel.fromJson(json))
+          .toList();
+    } else if (response.statusCode == 401) {
+      throw UnauthorizedException();
+    } else {
+      throw ServerException('Erreur lors de la récupération des conversations');
+    }
+  }
+
+  Future<ConversationModel> getConversationById(String conversationId) async {
+    final uri = Uri.parse(
+        '${AppConfig.apiBaseUrl}/api/messaging/conversations/$conversationId');
+
+    final response = await client.get(uri, headers: await _getHeaders());
+
+    if (response.statusCode == 200) {
+      return ConversationModel.fromJson(json.decode(response.body));
+    } else if (response.statusCode == 404) {
+      throw NotFoundException('Conversation non trouvée');
+    } else if (response.statusCode == 401) {
+      throw UnauthorizedException();
+    } else {
+      throw ServerException('Erreur lors de la récupération de la conversation');
+    }
+  }
+
+  Future<ConversationModel> createConversation({
+    required String name,
+    required List<String> participantIds,
+    String? organizationId,
+    String? description,
+  }) async {
+    final uri =
+        Uri.parse('${AppConfig.apiBaseUrl}/api/messaging/conversations');
+
+    final body = json.encode({
+      'name': name,
+      'participantIds': participantIds,
+      if (organizationId != null) 'organizationId': organizationId,
+      if (description != null) 'description': description,
+    });
+
+    final response = await client.post(
+      uri,
+      headers: await _getHeaders(),
+      body: body,
+    );
+
+    if (response.statusCode == 201 || response.statusCode == 200) {
+      return ConversationModel.fromJson(json.decode(response.body));
+    } else if (response.statusCode == 401) {
+      throw UnauthorizedException();
+    } else {
+      throw ServerException('Erreur lors de la création de la conversation');
+    }
+  }
+
+  // === MESSAGES ===
+
+  Future<List<MessageModel>> getMessages({
+    required String conversationId,
+    int? limit,
+    String? beforeMessageId,
+  }) async {
+    final uri = Uri.parse(
+        '${AppConfig.apiBaseUrl}/api/messaging/conversations/$conversationId/messages')
+        .replace(queryParameters: {
+      if (limit != null) 'limit': limit.toString(),
+      if (beforeMessageId != null) 'beforeMessageId': beforeMessageId,
+    });
+
+    final response = await client.get(uri, headers: await _getHeaders());
+
+    if (response.statusCode == 200) {
+      final List<dynamic> jsonList = json.decode(response.body);
+      return jsonList.map((json) => MessageModel.fromJson(json)).toList();
+    } else if (response.statusCode == 401) {
+      throw UnauthorizedException();
+    } else {
+      throw ServerException('Erreur lors de la récupération des messages');
+    }
+  }
+
+  Future<MessageModel> sendMessage({
+    required String conversationId,
+    required String content,
+    List<String>? attachments,
+    MessagePriority priority = MessagePriority.normal,
+  }) async {
+    final uri = Uri.parse(
+        '${AppConfig.apiBaseUrl}/api/messaging/conversations/$conversationId/messages');
+
+    final body = json.encode({
+      'content': content,
+      if (attachments != null) 'attachments': attachments,
+      'priority': priority.name,
+    });
+
+    final response = await client.post(
+      uri,
+      headers: await _getHeaders(),
+      body: body,
+    );
+
+    if (response.statusCode == 201 || response.statusCode == 200) {
+      return MessageModel.fromJson(json.decode(response.body));
+    } else if (response.statusCode == 401) {
+      throw UnauthorizedException();
+    } else {
+      throw ServerException('Erreur lors de l\'envoi du message');
+    }
+  }
+
+  Future<MessageModel> sendBroadcast({
+    required String organizationId,
+    required String subject,
+    required String content,
+    MessagePriority priority = MessagePriority.normal,
+    List<String>? attachments,
+  }) async {
+    final uri = Uri.parse('${AppConfig.apiBaseUrl}/api/messaging/broadcast');
+
+    final body = json.encode({
+      'organizationId': organizationId,
+      'subject': subject,
+      'content': content,
+      'priority': priority.name,
+      if (attachments != null) 'attachments': attachments,
+    });
+
+    final response = await client.post(
+      uri,
+      headers: await _getHeaders(),
+      body: body,
+    );
+
+    if (response.statusCode == 201 || response.statusCode == 200) {
+      return MessageModel.fromJson(json.decode(response.body));
+    } else if (response.statusCode == 401) {
+      throw UnauthorizedException();
+    } else if (response.statusCode == 403) {
+      throw ForbiddenException('Permission insuffisante pour envoyer un broadcast');
+    } else {
+      throw ServerException('Erreur lors de l\'envoi du broadcast');
+    }
+  }
+
+  Future<void> markMessageAsRead(String messageId) async {
+    final uri =
+        Uri.parse('${AppConfig.apiBaseUrl}/api/messaging/messages/$messageId/read');
+
+    final response = await client.put(uri, headers: await _getHeaders());
+
+    if (response.statusCode != 200 && response.statusCode != 204) {
+      if (response.statusCode == 401) {
+        throw UnauthorizedException();
+      } else {
+        throw ServerException('Erreur lors du marquage du message comme lu');
+      }
+    }
+  }
+
+  Future<int> getUnreadCount({String? organizationId}) async {
+    final uri = Uri.parse('${AppConfig.apiBaseUrl}/api/messaging/unread/count')
+        .replace(queryParameters: {
+      if (organizationId != null) 'organizationId': organizationId,
+    });
+
+    final response = await client.get(uri, headers: await _getHeaders());
+
+    if (response.statusCode == 200) {
+      final data = json.decode(response.body);
+      return data['count'] as int;
+    } else if (response.statusCode == 401) {
+      throw UnauthorizedException();
+    } else {
+      throw ServerException('Erreur lors de la récupération du compte non lu');
+    }
+  }
+}

unionflow/unionflow-mobile-apps/lib/features/communication/data/models/conversation_model.dart

@@ -0,0 +1,70 @@
+/// Model de données Conversation avec sérialisation JSON
+library conversation_model;
+
+import 'package:json_annotation/json_annotation.dart';
+import '../../domain/entities/conversation.dart';
+import '../../domain/entities/message.dart';
+import 'message_model.dart';
+
+part 'conversation_model.g.dart';
+
+@JsonSerializable(explicitToJson: true)
+class ConversationModel extends Conversation {
+  @JsonKey(
+    fromJson: _messageFromJson,
+    toJson: _messageToJson,
+  )
+  @override
+  final Message? lastMessage;
+
+  const ConversationModel({
+    required super.id,
+    required super.name,
+    super.description,
+    required super.type,
+    required super.participantIds,
+    super.organizationId,
+    this.lastMessage,
+    super.unreadCount,
+    super.isMuted,
+    super.isPinned,
+    super.isArchived,
+    required super.createdAt,
+    super.updatedAt,
+    super.avatarUrl,
+    super.metadata,
+  }) : super(lastMessage: lastMessage);
+
+  static Message? _messageFromJson(Map<String, dynamic>? json) =>
+      json == null ? null : MessageModel.fromJson(json);
+
+  static Map<String, dynamic>? _messageToJson(Message? message) =>
+      message == null ? null : MessageModel.fromEntity(message).toJson();
+
+  factory ConversationModel.fromJson(Map<String, dynamic> json) =>
+      _$ConversationModelFromJson(json);
+
+  Map<String, dynamic> toJson() => _$ConversationModelToJson(this);
+
+  factory ConversationModel.fromEntity(Conversation conversation) {
+    return ConversationModel(
+      id: conversation.id,
+      name: conversation.name,
+      description: conversation.description,
+      type: conversation.type,
+      participantIds: conversation.participantIds,
+      organizationId: conversation.organizationId,
+      lastMessage: conversation.lastMessage,
+      unreadCount: conversation.unreadCount,
+      isMuted: conversation.isMuted,
+      isPinned: conversation.isPinned,
+      isArchived: conversation.isArchived,
+      createdAt: conversation.createdAt,
+      updatedAt: conversation.updatedAt,
+      avatarUrl: conversation.avatarUrl,
+      metadata: conversation.metadata,
+    );
+  }
+
+  Conversation toEntity() => this;
+}

unionflow/unionflow-mobile-apps/lib/features/communication/data/models/message_model.dart

@@ -0,0 +1,83 @@
+/// Model de données Message avec sérialisation JSON
+library message_model;
+
+import 'package:json_annotation/json_annotation.dart';
+import '../../domain/entities/message.dart';
+
+part 'message_model.g.dart';
+
+@JsonSerializable(explicitToJson: true)
+class MessageModel extends Message {
+  const MessageModel({
+    required super.id,
+    required super.conversationId,
+    required super.senderId,
+    required super.senderName,
+    super.senderAvatar,
+    required super.content,
+    required super.type,
+    required super.status,
+    super.priority,
+    required super.recipientIds,
+    super.recipientRoles,
+    super.organizationId,
+    required super.createdAt,
+    super.readAt,
+    super.metadata,
+    super.attachments,
+    super.isEdited,
+    super.editedAt,
+    super.isDeleted,
+  });
+
+  factory MessageModel.fromJson(Map<String, dynamic> json) =>
+      _$MessageModelFromJson(json);
+
+  Map<String, dynamic> toJson() => _$MessageModelToJson(this);
+
+  factory MessageModel.fromEntity(Message message) {
+    return MessageModel(
+      id: message.id,
+      conversationId: message.conversationId,
+      senderId: message.senderId,
+      senderName: message.senderName,
+      senderAvatar: message.senderAvatar,
+      content: message.content,
+      type: message.type,
+      status: message.status,
+      priority: message.priority,
+      recipientIds: message.recipientIds,
+      recipientRoles: message.recipientRoles,
+      organizationId: message.organizationId,
+      createdAt: message.createdAt,
+      readAt: message.readAt,
+      metadata: message.metadata,
+      attachments: message.attachments,
+      isEdited: message.isEdited,
+      editedAt: message.editedAt,
+      isDeleted: message.isDeleted,
+    );
+  }
+
+  Message toEntity() => Message(
+    id: id,
+    conversationId: conversationId,
+    senderId: senderId,
+    senderName: senderName,
+    senderAvatar: senderAvatar,
+    content: content,
+    type: type,
+    status: status,
+    priority: priority,
+    recipientIds: recipientIds,
+    recipientRoles: recipientRoles,
+    organizationId: organizationId,
+    createdAt: createdAt,
+    readAt: readAt,
+    metadata: metadata,
+    attachments: attachments,
+    isEdited: isEdited,
+    editedAt: editedAt,
+    isDeleted: isDeleted,
+  );
+}

unionflow/unionflow-mobile-apps/lib/features/communication/data/repositories/messaging_repository_impl.dart

@@ -0,0 +1,329 @@
+/// Implémentation du repository de messagerie
+library messaging_repository_impl;
+
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../../core/error/exceptions.dart';
+import '../../../../core/error/failures.dart';
+import '../../../../core/network/network_info.dart';
+import '../../domain/entities/conversation.dart';
+import '../../domain/entities/message.dart';
+import '../../domain/entities/message_template.dart';
+import '../../domain/repositories/messaging_repository.dart';
+import '../datasources/messaging_remote_datasource.dart';
+
+@LazySingleton(as: MessagingRepository)
+class MessagingRepositoryImpl implements MessagingRepository {
+  final MessagingRemoteDatasource remoteDatasource;
+  final NetworkInfo networkInfo;
+
+  MessagingRepositoryImpl({
+    required this.remoteDatasource,
+    required this.networkInfo,
+  });
+
+  @override
+  Future<Either<Failure, List<Conversation>>> getConversations({
+    String? organizationId,
+    bool includeArchived = false,
+  }) async {
+    if (!await networkInfo.isConnected) {
+      return Left(NetworkFailure('Pas de connexion Internet'));
+    }
+
+    try {
+      final conversations = await remoteDatasource.getConversations(
+        organizationId: organizationId,
+        includeArchived: includeArchived,
+      );
+      return Right(conversations);
+    } on UnauthorizedException {
+      return Left(UnauthorizedFailure('Session expirée'));
+    } on ServerException catch (e) {
+      return Left(ServerFailure(e.message));
+    } catch (e) {
+      return Left(UnexpectedFailure('Erreur inattendue: $e'));
+    }
+  }
+
+  @override
+  Future<Either<Failure, Conversation>> getConversationById(
+      String conversationId) async {
+    if (!await networkInfo.isConnected) {
+      return Left(NetworkFailure('Pas de connexion Internet'));
+    }
+
+    try {
+      final conversation =
+          await remoteDatasource.getConversationById(conversationId);
+      return Right(conversation);
+    } on NotFoundException {
+      return Left(NotFoundFailure('Conversation non trouvée'));
+    } on UnauthorizedException {
+      return Left(UnauthorizedFailure('Session expirée'));
+    } on ServerException catch (e) {
+      return Left(ServerFailure(e.message));
+    } catch (e) {
+      return Left(UnexpectedFailure('Erreur inattendue: $e'));
+    }
+  }
+
+  @override
+  Future<Either<Failure, Conversation>> createConversation({
+    required String name,
+    required List<String> participantIds,
+    String? organizationId,
+    String? description,
+  }) async {
+    if (!await networkInfo.isConnected) {
+      return Left(NetworkFailure('Pas de connexion Internet'));
+    }
+
+    try {
+      final conversation = await remoteDatasource.createConversation(
+        name: name,
+        participantIds: participantIds,
+        organizationId: organizationId,
+        description: description,
+      );
+      return Right(conversation);
+    } on UnauthorizedException {
+      return Left(UnauthorizedFailure('Session expirée'));
+    } on ServerException catch (e) {
+      return Left(ServerFailure(e.message));
+    } catch (e) {
+      return Left(UnexpectedFailure('Erreur inattendue: $e'));
+    }
+  }
+
+  @override
+  Future<Either<Failure, List<Message>>> getMessages({
+    required String conversationId,
+    int? limit,
+    String? beforeMessageId,
+  }) async {
+    if (!await networkInfo.isConnected) {
+      return Left(NetworkFailure('Pas de connexion Internet'));
+    }
+
+    try {
+      final messages = await remoteDatasource.getMessages(
+        conversationId: conversationId,
+        limit: limit,
+        beforeMessageId: beforeMessageId,
+      );
+      return Right(messages);
+    } on UnauthorizedException {
+      return Left(UnauthorizedFailure('Session expirée'));
+    } on ServerException catch (e) {
+      return Left(ServerFailure(e.message));
+    } catch (e) {
+      return Left(UnexpectedFailure('Erreur inattendue: $e'));
+    }
+  }
+
+  @override
+  Future<Either<Failure, Message>> sendMessage({
+    required String conversationId,
+    required String content,
+    List<String>? attachments,
+    MessagePriority priority = MessagePriority.normal,
+  }) async {
+    if (!await networkInfo.isConnected) {
+      return Left(NetworkFailure('Pas de connexion Internet'));
+    }
+
+    try {
+      final message = await remoteDatasource.sendMessage(
+        conversationId: conversationId,
+        content: content,
+        attachments: attachments,
+        priority: priority,
+      );
+      return Right(message);
+    } on UnauthorizedException {
+      return Left(UnauthorizedFailure('Session expirée'));
+    } on ServerException catch (e) {
+      return Left(ServerFailure(e.message));
+    } catch (e) {
+      return Left(UnexpectedFailure('Erreur inattendue: $e'));
+    }
+  }
+
+  @override
+  Future<Either<Failure, Message>> sendBroadcast({
+    required String organizationId,
+    required String subject,
+    required String content,
+    MessagePriority priority = MessagePriority.normal,
+    List<String>? attachments,
+  }) async {
+    if (!await networkInfo.isConnected) {
+      return Left(NetworkFailure('Pas de connexion Internet'));
+    }
+
+    try {
+      final message = await remoteDatasource.sendBroadcast(
+        organizationId: organizationId,
+        subject: subject,
+        content: content,
+        priority: priority,
+        attachments: attachments,
+      );
+      return Right(message);
+    } on ForbiddenException catch (e) {
+      return Left(ForbiddenFailure(e.message));
+    } on UnauthorizedException {
+      return Left(UnauthorizedFailure('Session expirée'));
+    } on ServerException catch (e) {
+      return Left(ServerFailure(e.message));
+    } catch (e) {
+      return Left(UnexpectedFailure('Erreur inattendue: $e'));
+    }
+  }
+
+  @override
+  Future<Either<Failure, void>> markMessageAsRead(String messageId) async {
+    if (!await networkInfo.isConnected) {
+      return Left(NetworkFailure('Pas de connexion Internet'));
+    }
+
+    try {
+      await remoteDatasource.markMessageAsRead(messageId);
+      return const Right(null);
+    } on UnauthorizedException {
+      return Left(UnauthorizedFailure('Session expirée'));
+    } on ServerException catch (e) {
+      return Left(ServerFailure(e.message));
+    } catch (e) {
+      return Left(UnexpectedFailure('Erreur inattendue: $e'));
+    }
+  }
+
+  @override
+  Future<Either<Failure, int>> getUnreadCount({String? organizationId}) async {
+    if (!await networkInfo.isConnected) {
+      return Left(NetworkFailure('Pas de connexion Internet'));
+    }
+
+    try {
+      final count =
+          await remoteDatasource.getUnreadCount(organizationId: organizationId);
+      return Right(count);
+    } on UnauthorizedException {
+      return Left(UnauthorizedFailure('Session expirée'));
+    } on ServerException catch (e) {
+      return Left(ServerFailure(e.message));
+    } catch (e) {
+      return Left(UnexpectedFailure('Erreur inattendue: $e'));
+    }
+  }
+
+  // === MÉTHODES NON IMPLÉMENTÉES (Stubs pour compilation) ===
+  // À implémenter selon besoins backend
+
+  @override
+  Future<Either<Failure, void>> archiveConversation(String conversationId) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, Message>> sendTargetedMessage({
+    required String organizationId,
+    required List<String> targetRoles,
+    required String subject,
+    required String content,
+    MessagePriority priority = MessagePriority.normal,
+  }) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, void>> markConversationAsRead(String conversationId) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, void>> toggleMuteConversation(String conversationId) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, void>> togglePinConversation(String conversationId) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, Message>> editMessage({
+    required String messageId,
+    required String newContent,
+  }) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, void>> deleteMessage(String messageId) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, List<MessageTemplate>>> getTemplates({
+    String? organizationId,
+    TemplateCategory? category,
+  }) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, MessageTemplate>> getTemplateById(String templateId) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, MessageTemplate>> createTemplate({
+    required String name,
+    required String description,
+    required TemplateCategory category,
+    required String subject,
+    required String body,
+    List<Map<String, dynamic>>? variables,
+    String? organizationId,
+  }) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, MessageTemplate>> updateTemplate({
+    required String templateId,
+    String? name,
+    String? description,
+    String? subject,
+    String? body,
+    bool? isActive,
+  }) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, void>> deleteTemplate(String templateId) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, Message>> sendFromTemplate({
+    required String templateId,
+    required Map<String, String> variables,
+    required List<String> recipientIds,
+  }) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+
+  @override
+  Future<Either<Failure, Map<String, dynamic>>> getMessagingStats({
+    required String organizationId,
+    DateTime? startDate,
+    DateTime? endDate,
+  }) async {
+    return Left(NotImplementedFailure('Fonctionnalité en cours de développement'));
+  }
+}

unionflow/unionflow-mobile-apps/lib/features/communication/domain/entities/conversation.dart

@@ -0,0 +1,127 @@
+/// Entité métier Conversation
+///
+/// Représente une conversation (fil de messages) dans UnionFlow
+library conversation;
+
+import 'package:equatable/equatable.dart';
+import 'message.dart';
+
+/// Type de conversation
+enum ConversationType {
+  /// Conversation individuelle (1-1)
+  individual,
+
+  /// Conversation de groupe
+  group,
+
+  /// Canal broadcast (lecture seule pour la plupart)
+  broadcast,
+
+  /// Canal d'annonces organisation
+  announcement,
+}
+
+/// Entité Conversation
+class Conversation extends Equatable {
+  final String id;
+  final String name;
+  final String? description;
+  final ConversationType type;
+  final List<String> participantIds;
+  final String? organizationId;
+  final Message? lastMessage;
+  final int unreadCount;
+  final bool isMuted;
+  final bool isPinned;
+  final bool isArchived;
+  final DateTime createdAt;
+  final DateTime? updatedAt;
+  final String? avatarUrl;
+  final Map<String, dynamic>? metadata;
+
+  const Conversation({
+    required this.id,
+    required this.name,
+    this.description,
+    required this.type,
+    required this.participantIds,
+    this.organizationId,
+    this.lastMessage,
+    this.unreadCount = 0,
+    this.isMuted = false,
+    this.isPinned = false,
+    this.isArchived = false,
+    required this.createdAt,
+    this.updatedAt,
+    this.avatarUrl,
+    this.metadata,
+  });
+
+  /// Vérifie si la conversation a des messages non lus
+  bool get hasUnread => unreadCount > 0;
+
+  /// Vérifie si c'est une conversation individuelle
+  bool get isIndividual => type == ConversationType.individual;
+
+  /// Vérifie si c'est un broadcast
+  bool get isBroadcast => type == ConversationType.broadcast;
+
+  /// Nombre de participants
+  int get participantCount => participantIds.length;
+
+  /// Copie avec modifications
+  Conversation copyWith({
+    String? id,
+    String? name,
+    String? description,
+    ConversationType? type,
+    List<String>? participantIds,
+    String? organizationId,
+    Message? lastMessage,
+    int? unreadCount,
+    bool? isMuted,
+    bool? isPinned,
+    bool? isArchived,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+    String? avatarUrl,
+    Map<String, dynamic>? metadata,
+  }) {
+    return Conversation(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      description: description ?? this.description,
+      type: type ?? this.type,
+      participantIds: participantIds ?? this.participantIds,
+      organizationId: organizationId ?? this.organizationId,
+      lastMessage: lastMessage ?? this.lastMessage,
+      unreadCount: unreadCount ?? this.unreadCount,
+      isMuted: isMuted ?? this.isMuted,
+      isPinned: isPinned ?? this.isPinned,
+      isArchived: isArchived ?? this.isArchived,
+      createdAt: createdAt ?? this.createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+      avatarUrl: avatarUrl ?? this.avatarUrl,
+      metadata: metadata ?? this.metadata,
+    );
+  }
+
+  @override
+  List<Object?> get props => [
+    id,
+    name,
+    description,
+    type,
+    participantIds,
+    organizationId,
+    lastMessage,
+    unreadCount,
+    isMuted,
+    isPinned,
+    isArchived,
+    createdAt,
+    updatedAt,
+    avatarUrl,
+    metadata,
+  ];
+}

unionflow/unionflow-mobile-apps/lib/features/communication/domain/entities/message.dart

@@ -0,0 +1,173 @@
+/// Entité métier Message
+///
+/// Représente un message dans le système de communication UnionFlow
+library message;
+
+import 'package:equatable/equatable.dart';
+
+/// Type de message
+enum MessageType {
+  /// Message individuel (membre à membre)
+  individual,
+
+  /// Broadcast organisation (OrgAdmin → tous)
+  broadcast,
+
+  /// Message ciblé par rôle (Moderator → groupe)
+  targeted,
+
+  /// Notification système
+  system,
+}
+
+/// Statut de lecture du message
+enum MessageStatus {
+  /// Envoyé mais non lu
+  sent,
+
+  /// Livré (reçu par le serveur)
+  delivered,
+
+  /// Lu par le destinataire
+  read,
+
+  /// Échec d'envoi
+  failed,
+}
+
+/// Priorité du message
+enum MessagePriority {
+  /// Priorité normale
+  normal,
+
+  /// Priorité élevée (important)
+  high,
+
+  /// Priorité urgente (critique)
+  urgent,
+}
+
+/// Entité Message
+class Message extends Equatable {
+  final String id;
+  final String conversationId;
+  final String senderId;
+  final String senderName;
+  final String? senderAvatar;
+  final String content;
+  final MessageType type;
+  final MessageStatus status;
+  final MessagePriority priority;
+  final List<String> recipientIds;
+  final List<String>? recipientRoles;
+  final String? organizationId;
+  final DateTime createdAt;
+  final DateTime? readAt;
+  final Map<String, dynamic>? metadata;
+  final List<String>? attachments;
+  final bool isEdited;
+  final DateTime? editedAt;
+  final bool isDeleted;
+
+  const Message({
+    required this.id,
+    required this.conversationId,
+    required this.senderId,
+    required this.senderName,
+    this.senderAvatar,
+    required this.content,
+    required this.type,
+    required this.status,
+    this.priority = MessagePriority.normal,
+    required this.recipientIds,
+    this.recipientRoles,
+    this.organizationId,
+    required this.createdAt,
+    this.readAt,
+    this.metadata,
+    this.attachments,
+    this.isEdited = false,
+    this.editedAt,
+    this.isDeleted = false,
+  });
+
+  /// Vérifie si le message a été lu
+  bool get isRead => status == MessageStatus.read;
+
+  /// Vérifie si le message est urgent
+  bool get isUrgent => priority == MessagePriority.urgent;
+
+  /// Vérifie si le message est un broadcast
+  bool get isBroadcast => type == MessageType.broadcast;
+
+  /// Vérifie si le message a des pièces jointes
+  bool get hasAttachments => attachments != null && attachments!.isNotEmpty;
+
+  /// Copie avec modifications
+  Message copyWith({
+    String? id,
+    String? conversationId,
+    String? senderId,
+    String? senderName,
+    String? senderAvatar,
+    String? content,
+    MessageType? type,
+    MessageStatus? status,
+    MessagePriority? priority,
+    List<String>? recipientIds,
+    List<String>? recipientRoles,
+    String? organizationId,
+    DateTime? createdAt,
+    DateTime? readAt,
+    Map<String, dynamic>? metadata,
+    List<String>? attachments,
+    bool? isEdited,
+    DateTime? editedAt,
+    bool? isDeleted,
+  }) {
+    return Message(
+      id: id ?? this.id,
+      conversationId: conversationId ?? this.conversationId,
+      senderId: senderId ?? this.senderId,
+      senderName: senderName ?? this.senderName,
+      senderAvatar: senderAvatar ?? this.senderAvatar,
+      content: content ?? this.content,
+      type: type ?? this.type,
+      status: status ?? this.status,
+      priority: priority ?? this.priority,
+      recipientIds: recipientIds ?? this.recipientIds,
+      recipientRoles: recipientRoles ?? this.recipientRoles,
+      organizationId: organizationId ?? this.organizationId,
+      createdAt: createdAt ?? this.createdAt,
+      readAt: readAt ?? this.readAt,
+      metadata: metadata ?? this.metadata,
+      attachments: attachments ?? this.attachments,
+      isEdited: isEdited ?? this.isEdited,
+      editedAt: editedAt ?? this.editedAt,
+      isDeleted: isDeleted ?? this.isDeleted,
+    );
+  }
+
+  @override
+  List<Object?> get props => [
+    id,
+    conversationId,
+    senderId,
+    senderName,
+    senderAvatar,
+    content,
+    type,
+    status,
+    priority,
+    recipientIds,
+    recipientRoles,
+    organizationId,
+    createdAt,
+    readAt,
+    metadata,
+    attachments,
+    isEdited,
+    editedAt,
+    isDeleted,
+  ];
+}

unionflow/unionflow-mobile-apps/lib/features/communication/domain/entities/message_template.dart

@@ -0,0 +1,154 @@
+/// Entité métier Template de Message
+///
+/// Templates réutilisables pour notifications et broadcasts
+library message_template;
+
+import 'package:equatable/equatable.dart';
+
+/// Catégorie de template
+enum TemplateCategory {
+  /// Événements
+  events,
+
+  /// Finances
+  finances,
+
+  /// Adhésions
+  membership,
+
+  /// Solidarité
+  solidarity,
+
+  /// Système
+  system,
+
+  /// Personnalisé
+  custom,
+}
+
+/// Variables dynamiques dans les templates
+class TemplateVariable {
+  final String name;
+  final String description;
+  final String placeholder;
+  final bool required;
+
+  const TemplateVariable({
+    required this.name,
+    required this.description,
+    required this.placeholder,
+    this.required = true,
+  });
+}
+
+/// Entité Template de Message
+class MessageTemplate extends Equatable {
+  final String id;
+  final String name;
+  final String description;
+  final TemplateCategory category;
+  final String subject;
+  final String body;
+  final List<TemplateVariable> variables;
+  final String? organizationId;
+  final String createdBy;
+  final DateTime createdAt;
+  final DateTime? updatedAt;
+  final bool isActive;
+  final bool isSystem;
+  final int usageCount;
+  final Map<String, dynamic>? metadata;
+
+  const MessageTemplate({
+    required this.id,
+    required this.name,
+    required this.description,
+    required this.category,
+    required this.subject,
+    required this.body,
+    this.variables = const [],
+    this.organizationId,
+    required this.createdBy,
+    required this.createdAt,
+    this.updatedAt,
+    this.isActive = true,
+    this.isSystem = false,
+    this.usageCount = 0,
+    this.metadata,
+  });
+
+  /// Vérifie si le template est éditable (pas système)
+  bool get isEditable => !isSystem;
+
+  /// Génère un message à partir du template avec des valeurs
+  String generateMessage(Map<String, String> values) {
+    String result = body;
+
+    for (final variable in variables) {
+      final value = values[variable.name];
+      if (value != null) {
+        result = result.replaceAll('{{${variable.name}}}', value);
+      } else if (variable.required) {
+        throw ArgumentError('Variable requise manquante: ${variable.name}');
+      }
+    }
+
+    return result;
+  }
+
+  /// Copie avec modifications
+  MessageTemplate copyWith({
+    String? id,
+    String? name,
+    String? description,
+    TemplateCategory? category,
+    String? subject,
+    String? body,
+    List<TemplateVariable>? variables,
+    String? organizationId,
+    String? createdBy,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+    bool? isActive,
+    bool? isSystem,
+    int? usageCount,
+    Map<String, dynamic>? metadata,
+  }) {
+    return MessageTemplate(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      description: description ?? this.description,
+      category: category ?? this.category,
+      subject: subject ?? this.subject,
+      body: body ?? this.body,
+      variables: variables ?? this.variables,
+      organizationId: organizationId ?? this.organizationId,
+      createdBy: createdBy ?? this.createdBy,
+      createdAt: createdAt ?? this.createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+      isActive: isActive ?? this.isActive,
+      isSystem: isSystem ?? this.isSystem,
+      usageCount: usageCount ?? this.usageCount,
+      metadata: metadata ?? this.metadata,
+    );
+  }
+
+  @override
+  List<Object?> get props => [
+    id,
+    name,
+    description,
+    category,
+    subject,
+    body,
+    variables,
+    organizationId,
+    createdBy,
+    createdAt,
+    updatedAt,
+    isActive,
+    isSystem,
+    usageCount,
+    metadata,
+  ];
+}

unionflow/unionflow-mobile-apps/lib/features/communication/domain/repositories/messaging_repository.dart

@@ -0,0 +1,145 @@
+/// Repository interface pour la communication
+///
+/// Contrat de données pour les messages, conversations et templates
+library messaging_repository;
+
+import 'package:dartz/dartz.dart';
+import '../../../../core/error/failures.dart';
+import '../entities/message.dart';
+import '../entities/conversation.dart';
+import '../entities/message_template.dart';
+
+/// Interface du repository de messagerie
+abstract class MessagingRepository {
+  // === CONVERSATIONS ===
+
+  /// Récupère toutes les conversations de l'utilisateur
+  Future<Either<Failure, List<Conversation>>> getConversations({
+    String? organizationId,
+    bool includeArchived = false,
+  });
+
+  /// Récupère une conversation par son ID
+  Future<Either<Failure, Conversation>> getConversationById(String conversationId);
+
+  /// Crée une nouvelle conversation
+  Future<Either<Failure, Conversation>> createConversation({
+    required String name,
+    required List<String> participantIds,
+    String? organizationId,
+    String? description,
+  });
+
+  /// Archive une conversation
+  Future<Either<Failure, void>> archiveConversation(String conversationId);
+
+  /// Marque une conversation comme lue
+  Future<Either<Failure, void>> markConversationAsRead(String conversationId);
+
+  /// Mute/démute une conversation
+  Future<Either<Failure, void>> toggleMuteConversation(String conversationId);
+
+  /// Pin/unpin une conversation
+  Future<Either<Failure, void>> togglePinConversation(String conversationId);
+
+  // === MESSAGES ===
+
+  /// Récupère les messages d'une conversation
+  Future<Either<Failure, List<Message>>> getMessages({
+    required String conversationId,
+    int? limit,
+    String? beforeMessageId,
+  });
+
+  /// Envoie un message individuel
+  Future<Either<Failure, Message>> sendMessage({
+    required String conversationId,
+    required String content,
+    List<String>? attachments,
+    MessagePriority priority = MessagePriority.normal,
+  });
+
+  /// Envoie un broadcast à toute l'organisation
+  Future<Either<Failure, Message>> sendBroadcast({
+    required String organizationId,
+    required String subject,
+    required String content,
+    MessagePriority priority = MessagePriority.normal,
+    List<String>? attachments,
+  });
+
+  /// Envoie un message ciblé par rôles
+  Future<Either<Failure, Message>> sendTargetedMessage({
+    required String organizationId,
+    required List<String> targetRoles,
+    required String subject,
+    required String content,
+    MessagePriority priority = MessagePriority.normal,
+  });
+
+  /// Marque un message comme lu
+  Future<Either<Failure, void>> markMessageAsRead(String messageId);
+
+  /// Édite un message
+  Future<Either<Failure, Message>> editMessage({
+    required String messageId,
+    required String newContent,
+  });
+
+  /// Supprime un message
+  Future<Either<Failure, void>> deleteMessage(String messageId);
+
+  // === TEMPLATES ===
+
+  /// Récupère tous les templates disponibles
+  Future<Either<Failure, List<MessageTemplate>>> getTemplates({
+    String? organizationId,
+    TemplateCategory? category,
+  });
+
+  /// Récupère un template par son ID
+  Future<Either<Failure, MessageTemplate>> getTemplateById(String templateId);
+
+  /// Crée un nouveau template
+  Future<Either<Failure, MessageTemplate>> createTemplate({
+    required String name,
+    required String description,
+    required TemplateCategory category,
+    required String subject,
+    required String body,
+    List<Map<String, dynamic>>? variables,
+    String? organizationId,
+  });
+
+  /// Met à jour un template
+  Future<Either<Failure, MessageTemplate>> updateTemplate({
+    required String templateId,
+    String? name,
+    String? description,
+    String? subject,
+    String? body,
+    bool? isActive,
+  });
+
+  /// Supprime un template
+  Future<Either<Failure, void>> deleteTemplate(String templateId);
+
+  /// Envoie un message à partir d'un template
+  Future<Either<Failure, Message>> sendFromTemplate({
+    required String templateId,
+    required Map<String, String> variables,
+    required List<String> recipientIds,
+  });
+
+  // === STATISTIQUES ===
+
+  /// Récupère le nombre de messages non lus
+  Future<Either<Failure, int>> getUnreadCount({String? organizationId});
+
+  /// Récupère les statistiques de communication
+  Future<Either<Failure, Map<String, dynamic>>> getMessagingStats({
+    required String organizationId,
+    DateTime? startDate,
+    DateTime? endDate,
+  });
+}

unionflow/unionflow-mobile-apps/lib/features/communication/domain/usecases/get_conversations.dart

@@ -0,0 +1,25 @@
+/// Use case: Récupérer les conversations
+library get_conversations;
+
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../../core/error/failures.dart';
+import '../entities/conversation.dart';
+import '../repositories/messaging_repository.dart';
+
+@lazySingleton
+class GetConversations {
+  final MessagingRepository repository;
+
+  GetConversations(this.repository);
+
+  Future<Either<Failure, List<Conversation>>> call({
+    String? organizationId,
+    bool includeArchived = false,
+  }) async {
+    return await repository.getConversations(
+      organizationId: organizationId,
+      includeArchived: includeArchived,
+    );
+  }
+}

unionflow/unionflow-mobile-apps/lib/features/communication/domain/usecases/get_messages.dart

@@ -0,0 +1,31 @@
+/// Use case: Récupérer les messages d'une conversation
+library get_messages;
+
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../../core/error/failures.dart';
+import '../entities/message.dart';
+import '../repositories/messaging_repository.dart';
+
+@lazySingleton
+class GetMessages {
+  final MessagingRepository repository;
+
+  GetMessages(this.repository);
+
+  Future<Either<Failure, List<Message>>> call({
+    required String conversationId,
+    int? limit,
+    String? beforeMessageId,
+  }) async {
+    if (conversationId.isEmpty) {
+      return Left(ValidationFailure('ID conversation requis'));
+    }
+
+    return await repository.getMessages(
+      conversationId: conversationId,
+      limit: limit,
+      beforeMessageId: beforeMessageId,
+    );
+  }
+}

unionflow/unionflow-mobile-apps/lib/features/communication/domain/usecases/send_broadcast.dart

@@ -0,0 +1,44 @@
+/// Use case: Envoyer un broadcast organisation
+library send_broadcast;
+
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../../core/error/failures.dart';
+import '../entities/message.dart';
+import '../repositories/messaging_repository.dart';
+
+@lazySingleton
+class SendBroadcast {
+  final MessagingRepository repository;
+
+  SendBroadcast(this.repository);
+
+  Future<Either<Failure, Message>> call({
+    required String organizationId,
+    required String subject,
+    required String content,
+    MessagePriority priority = MessagePriority.normal,
+    List<String>? attachments,
+  }) async {
+    // Validation
+    if (subject.trim().isEmpty) {
+      return Left(ValidationFailure('Le sujet ne peut pas être vide'));
+    }
+
+    if (content.trim().isEmpty) {
+      return Left(ValidationFailure('Le message ne peut pas être vide'));
+    }
+
+    if (organizationId.isEmpty) {
+      return Left(ValidationFailure('ID organisation requis'));
+    }
+
+    return await repository.sendBroadcast(
+      organizationId: organizationId,
+      subject: subject,
+      content: content,
+      priority: priority,
+      attachments: attachments,
+    );
+  }
+}

unionflow/unionflow-mobile-apps/lib/features/communication/domain/usecases/send_message.dart

@@ -0,0 +1,34 @@
+/// Use case: Envoyer un message
+library send_message;
+
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../../core/error/failures.dart';
+import '../entities/message.dart';
+import '../repositories/messaging_repository.dart';
+
+@lazySingleton
+class SendMessage {
+  final MessagingRepository repository;
+
+  SendMessage(this.repository);
+
+  Future<Either<Failure, Message>> call({
+    required String conversationId,
+    required String content,
+    List<String>? attachments,
+    MessagePriority priority = MessagePriority.normal,
+  }) async {
+    // Validation
+    if (content.trim().isEmpty) {
+      return Left(ValidationFailure('Le message ne peut pas être vide'));
+    }
+
+    return await repository.sendMessage(
+      conversationId: conversationId,
+      content: content,
+      attachments: attachments,
+      priority: priority,
+    );
+  }
+}

unionflow/unionflow-mobile-apps/lib/features/communication/presentation/bloc/messaging_bloc.dart

@@ -0,0 +1,105 @@
+/// BLoC de gestion de la messagerie
+library messaging_bloc;
+
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:injectable/injectable.dart';
+import '../../domain/usecases/get_conversations.dart';
+import '../../domain/usecases/get_messages.dart';
+import '../../domain/usecases/send_message.dart';
+import '../../domain/usecases/send_broadcast.dart';
+import 'messaging_event.dart';
+import 'messaging_state.dart';
+
+@injectable
+class MessagingBloc extends Bloc<MessagingEvent, MessagingState> {
+  final GetConversations getConversations;
+  final GetMessages getMessages;
+  final SendMessage sendMessage;
+  final SendBroadcast sendBroadcast;
+
+  MessagingBloc({
+    required this.getConversations,
+    required this.getMessages,
+    required this.sendMessage,
+    required this.sendBroadcast,
+  }) : super(MessagingInitial()) {
+    on<LoadConversations>(_onLoadConversations);
+    on<LoadMessages>(_onLoadMessages);
+    on<SendMessageEvent>(_onSendMessage);
+    on<SendBroadcastEvent>(_onSendBroadcast);
+  }
+
+  Future<void> _onLoadConversations(
+    LoadConversations event,
+    Emitter<MessagingState> emit,
+  ) async {
+    emit(MessagingLoading());
+
+    final result = await getConversations(
+      organizationId: event.organizationId,
+      includeArchived: event.includeArchived,
+    );
+
+    result.fold(
+      (failure) => emit(MessagingError(failure.message)),
+      (conversations) => emit(ConversationsLoaded(conversations: conversations)),
+    );
+  }
+
+  Future<void> _onLoadMessages(
+    LoadMessages event,
+    Emitter<MessagingState> emit,
+  ) async {
+    emit(MessagingLoading());
+
+    final result = await getMessages(
+      conversationId: event.conversationId,
+      limit: event.limit,
+      beforeMessageId: event.beforeMessageId,
+    );
+
+    result.fold(
+      (failure) => emit(MessagingError(failure.message)),
+      (messages) => emit(MessagesLoaded(
+        conversationId: event.conversationId,
+        messages: messages,
+        hasMore: messages.length == (event.limit ?? 50),
+      )),
+    );
+  }
+
+  Future<void> _onSendMessage(
+    SendMessageEvent event,
+    Emitter<MessagingState> emit,
+  ) async {
+    final result = await sendMessage(
+      conversationId: event.conversationId,
+      content: event.content,
+      attachments: event.attachments,
+      priority: event.priority,
+    );
+
+    result.fold(
+      (failure) => emit(MessagingError(failure.message)),
+      (message) => emit(MessageSent(message)),
+    );
+  }
+
+  Future<void> _onSendBroadcast(
+    SendBroadcastEvent event,
+    Emitter<MessagingState> emit,
+  ) async {
+    final result = await sendBroadcast(
+      organizationId: event.organizationId,
+      subject: event.subject,
+      content: event.content,
+      priority: event.priority,
+      attachments: event.attachments,
+    );
+
+    result.fold(
+      (failure) => emit(MessagingError(failure.message)),
+      (message) => emit(BroadcastSent(message)),
+    );
+  }
+}

unionflow/unionflow-mobile-apps/lib/features/communication/presentation/bloc/messaging_event.dart

@@ -0,0 +1,118 @@
+/// Événements du BLoC Messaging
+library messaging_event;
+
+import 'package:equatable/equatable.dart';
+import '../../domain/entities/message.dart';
+
+abstract class MessagingEvent extends Equatable {
+  const MessagingEvent();
+
+  @override
+  List<Object?> get props => [];
+}
+
+/// Charger les conversations
+class LoadConversations extends MessagingEvent {
+  final String? organizationId;
+  final bool includeArchived;
+
+  const LoadConversations({
+    this.organizationId,
+    this.includeArchived = false,
+  });
+
+  @override
+  List<Object?> get props => [organizationId, includeArchived];
+}
+
+/// Charger les messages d'une conversation
+class LoadMessages extends MessagingEvent {
+  final String conversationId;
+  final int? limit;
+  final String? beforeMessageId;
+
+  const LoadMessages({
+    required this.conversationId,
+    this.limit,
+    this.beforeMessageId,
+  });
+
+  @override
+  List<Object?> get props => [conversationId, limit, beforeMessageId];
+}
+
+/// Envoyer un message
+class SendMessageEvent extends MessagingEvent {
+  final String conversationId;
+  final String content;
+  final List<String>? attachments;
+  final MessagePriority priority;
+
+  const SendMessageEvent({
+    required this.conversationId,
+    required this.content,
+    this.attachments,
+    this.priority = MessagePriority.normal,
+  });
+
+  @override
+  List<Object?> get props => [conversationId, content, attachments, priority];
+}
+
+/// Envoyer un broadcast
+class SendBroadcastEvent extends MessagingEvent {
+  final String organizationId;
+  final String subject;
+  final String content;
+  final MessagePriority priority;
+  final List<String>? attachments;
+
+  const SendBroadcastEvent({
+    required this.organizationId,
+    required this.subject,
+    required this.content,
+    this.priority = MessagePriority.normal,
+    this.attachments,
+  });
+
+  @override
+  List<Object?> get props => [organizationId, subject, content, priority, attachments];
+}
+
+/// Marquer un message comme lu
+class MarkMessageAsReadEvent extends MessagingEvent {
+  final String messageId;
+
+  const MarkMessageAsReadEvent(this.messageId);
+
+  @override
+  List<Object?> get props => [messageId];
+}
+
+/// Charger le nombre de messages non lus
+class LoadUnreadCount extends MessagingEvent {
+  final String? organizationId;
+
+  const LoadUnreadCount({this.organizationId});
+
+  @override
+  List<Object?> get props => [organizationId];
+}
+
+/// Créer une nouvelle conversation
+class CreateConversationEvent extends MessagingEvent {
+  final String name;
+  final List<String> participantIds;
+  final String? organizationId;
+  final String? description;
+
+  const CreateConversationEvent({
+    required this.name,
+    required this.participantIds,
+    this.organizationId,
+    this.description,
+  });
+
+  @override
+  List<Object?> get props => [name, participantIds, organizationId, description];
+}

unionflow/unionflow-mobile-apps/lib/features/communication/presentation/bloc/messaging_state.dart

@@ -0,0 +1,99 @@
+/// États du BLoC Messaging
+library messaging_state;
+
+import 'package:equatable/equatable.dart';
+import '../../domain/entities/conversation.dart';
+import '../../domain/entities/message.dart';
+
+abstract class MessagingState extends Equatable {
+  const MessagingState();
+
+  @override
+  List<Object?> get props => [];
+}
+
+/// État initial
+class MessagingInitial extends MessagingState {}
+
+/// Chargement en cours
+class MessagingLoading extends MessagingState {}
+
+/// Conversations chargées
+class ConversationsLoaded extends MessagingState {
+  final List<Conversation> conversations;
+  final int unreadCount;
+
+  const ConversationsLoaded({
+    required this.conversations,
+    this.unreadCount = 0,
+  });
+
+  @override
+  List<Object?> get props => [conversations, unreadCount];
+}
+
+/// Messages d'une conversation chargés
+class MessagesLoaded extends MessagingState {
+  final String conversationId;
+  final List<Message> messages;
+  final bool hasMore;
+
+  const MessagesLoaded({
+    required this.conversationId,
+    required this.messages,
+    this.hasMore = false,
+  });
+
+  @override
+  List<Object?> get props => [conversationId, messages, hasMore];
+}
+
+/// Message envoyé avec succès
+class MessageSent extends MessagingState {
+  final Message message;
+
+  const MessageSent(this.message);
+
+  @override
+  List<Object?> get props => [message];
+}
+
+/// Broadcast envoyé avec succès
+class BroadcastSent extends MessagingState {
+  final Message message;
+
+  const BroadcastSent(this.message);
+
+  @override
+  List<Object?> get props => [message];
+}
+
+/// Conversation créée
+class ConversationCreated extends MessagingState {
+  final Conversation conversation;
+
+  const ConversationCreated(this.conversation);
+
+  @override
+  List<Object?> get props => [conversation];
+}
+
+/// Compteur de non lus chargé
+class UnreadCountLoaded extends MessagingState {
+  final int count;
+
+  const UnreadCountLoaded(this.count);
+
+  @override
+  List<Object?> get props => [count];
+}
+
+/// Erreur
+class MessagingError extends MessagingState {
+  final String message;
+
+  const MessagingError(this.message);
+
+  @override
+  List<Object?> get props => [message];
+}

unionflow/unionflow-mobile-apps/lib/features/communication/presentation/pages/conversations_page.dart

@@ -0,0 +1,150 @@
+/// Page liste des conversations
+library conversations_page;
+
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import '../../../../core/di/injection_container.dart';
+import '../../../../shared/design_system/unionflow_design_system.dart';
+import '../bloc/messaging_bloc.dart';
+import '../bloc/messaging_event.dart';
+import '../bloc/messaging_state.dart';
+import '../widgets/conversation_tile.dart';
+
+class ConversationsPage extends StatelessWidget {
+  final String? organizationId;
+
+  const ConversationsPage({
+    super.key,
+    this.organizationId,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return BlocProvider(
+      create: (_) => sl<MessagingBloc>()
+        ..add(LoadConversations(organizationId: organizationId)),
+      child: Scaffold(
+        backgroundColor: ColorTokens.background,
+        appBar: const UFAppBar(
+          title: 'MESSAGES',
+          automaticallyImplyLeading: true,
+        ),
+        body: BlocBuilder<MessagingBloc, MessagingState>(
+          builder: (context, state) {
+            if (state is MessagingLoading) {
+              return const Center(child: CircularProgressIndicator());
+            }
+
+            if (state is MessagingError) {
+              return Center(
+                child: Column(
+                  mainAxisAlignment: MainAxisAlignment.center,
+                  children: [
+                    const Icon(
+                      Icons.error_outline,
+                      size: 64,
+                      color: AppColors.error,
+                    ),
+                    const SizedBox(height: SpacingTokens.md),
+                    Text(
+                      'Erreur',
+                      style: AppTypography.headerSmall,
+                    ),
+                    const SizedBox(height: SpacingTokens.sm),
+                    Text(
+                      state.message,
+                      style: AppTypography.bodyTextSmall,
+                      textAlign: TextAlign.center,
+                    ),
+                    const SizedBox(height: SpacingTokens.lg),
+                    UFPrimaryButton(
+                      label: 'Réessayer',
+                      onPressed: () {
+                        context.read<MessagingBloc>().add(
+                          LoadConversations(organizationId: organizationId),
+                        );
+                      },
+                    ),
+                  ],
+                ),
+              );
+            }
+
+            if (state is ConversationsLoaded) {
+              final conversations = state.conversations;
+
+              if (conversations.isEmpty) {
+                return Center(
+                  child: Column(
+                    mainAxisAlignment: MainAxisAlignment.center,
+                    children: [
+                      const Icon(
+                        Icons.chat_bubble_outline,
+                        size: 64,
+                        color: AppColors.textSecondaryLight,
+                      ),
+                      const SizedBox(height: SpacingTokens.md),
+                      Text(
+                        'Aucune conversation',
+                        style: AppTypography.headerSmall.copyWith(
+                          color: AppColors.textSecondaryLight,
+                        ),
+                      ),
+                      const SizedBox(height: SpacingTokens.sm),
+                      Text(
+                        'Commencez une nouvelle conversation',
+                        style: AppTypography.bodyTextSmall.copyWith(
+                          color: AppColors.textSecondaryLight,
+                        ),
+                      ),
+                    ],
+                  ),
+                );
+              }
+
+              return RefreshIndicator(
+                onRefresh: () async {
+                  context.read<MessagingBloc>().add(
+                    LoadConversations(organizationId: organizationId),
+                  );
+                },
+                child: ListView.separated(
+                  padding: const EdgeInsets.all(SpacingTokens.md),
+                  itemCount: conversations.length,
+                  separatorBuilder: (_, __) => const SizedBox(height: SpacingTokens.sm),
+                  itemBuilder: (context, index) {
+                    final conversation = conversations[index];
+                    return ConversationTile(
+                      conversation: conversation,
+                      onTap: () {
+                        // Navigation vers la page de chat
+                        // TODO: Implémenter navigation
+                        ScaffoldMessenger.of(context).showSnackBar(
+                          SnackBar(
+                            content: Text('Ouvrir conversation: ${conversation.name}'),
+                          ),
+                        );
+                      },
+                    );
+                  },
+                ),
+              );
+            }
+
+            return const SizedBox.shrink();
+          },
+        ),
+        floatingActionButton: FloatingActionButton(
+          backgroundColor: AppColors.primaryGreen,
+          onPressed: () {
+            // TODO: Ouvrir dialogue nouvelle conversation
+            ScaffoldMessenger.of(context).showSnackBar(
+              const SnackBar(content: Text('Nouvelle conversation (à implémenter)')),
+            );
+          },
+          child: const Icon(Icons.add, color: Colors.white),
+        ),
+      ),
+    );
+  }
+}

unionflow/unionflow-mobile-apps/lib/features/communication/presentation/widgets/conversation_tile.dart

@@ -0,0 +1,166 @@
+/// Widget tuile de conversation
+library conversation_tile;
+
+import 'package:flutter/material.dart';
+import 'package:intl/intl.dart';
+import '../../../../shared/design_system/unionflow_design_system.dart';
+import '../../domain/entities/conversation.dart';
+
+class ConversationTile extends StatelessWidget {
+  final Conversation conversation;
+  final VoidCallback onTap;
+
+  const ConversationTile({
+    super.key,
+    required this.conversation,
+    required this.onTap,
+  });
+
+  String _formatDate(DateTime date) {
+    final now = DateTime.now();
+    final difference = now.difference(date);
+
+    if (difference.inDays == 0) {
+      return DateFormat('HH:mm').format(date);
+    } else if (difference.inDays == 1) {
+      return 'Hier';
+    } else if (difference.inDays < 7) {
+      return DateFormat('EEEE', 'fr_FR').format(date);
+    } else {
+      return DateFormat('dd/MM/yy').format(date);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return InkWell(
+      onTap: onTap,
+      borderRadius: BorderRadius.circular(SpacingTokens.radiusMd),
+      child: Container(
+        padding: const EdgeInsets.all(SpacingTokens.md),
+        decoration: BoxDecoration(
+          color: ColorTokens.surface,
+          borderRadius: BorderRadius.circular(SpacingTokens.radiusMd),
+          border: Border.all(
+            color: conversation.hasUnread
+                ? AppColors.primaryGreen.withOpacity(0.3)
+                : ColorTokens.outline,
+          ),
+        ),
+        child: Row(
+          children: [
+            // Avatar
+            CircleAvatar(
+              radius: 24,
+              backgroundColor: AppColors.primaryGreen.withOpacity(0.1),
+              backgroundImage: conversation.avatarUrl != null
+                  ? NetworkImage(conversation.avatarUrl!)
+                  : null,
+              child: conversation.avatarUrl == null
+                  ? Text(
+                      conversation.name.isNotEmpty
+                          ? conversation.name[0].toUpperCase()
+                          : '?',
+                      style: AppTypography.actionText.copyWith(
+                        color: AppColors.primaryGreen,
+                      ),
+                    )
+                  : null,
+            ),
+
+            const SizedBox(width: SpacingTokens.md),
+
+            // Contenu
+            Expanded(
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Row(
+                    children: [
+                      Expanded(
+                        child: Text(
+                          conversation.name,
+                          style: AppTypography.actionText.copyWith(
+                            fontWeight: conversation.hasUnread
+                                ? FontWeight.bold
+                                : FontWeight.normal,
+                          ),
+                          maxLines: 1,
+                          overflow: TextOverflow.ellipsis,
+                        ),
+                      ),
+                      if (conversation.lastMessage != null)
+                        Text(
+                          _formatDate(conversation.lastMessage!.createdAt),
+                          style: AppTypography.subtitleSmall.copyWith(
+                            color: AppColors.textSecondaryLight,
+                          ),
+                        ),
+                    ],
+                  ),
+                  if (conversation.lastMessage != null) ...[
+                    const SizedBox(height: 4),
+                    Text(
+                      conversation.lastMessage!.content,
+                      style: AppTypography.bodyTextSmall.copyWith(
+                        color: AppColors.textSecondaryLight,
+                        fontWeight: conversation.hasUnread
+                            ? FontWeight.w600
+                            : FontWeight.normal,
+                      ),
+                      maxLines: 2,
+                      overflow: TextOverflow.ellipsis,
+                    ),
+                  ],
+                ],
+              ),
+            ),
+
+            // Badge non lus
+            if (conversation.hasUnread) ...[
+              const SizedBox(width: SpacingTokens.sm),
+              Container(
+                padding: const EdgeInsets.symmetric(
+                  horizontal: 8,
+                  vertical: 4,
+                ),
+                decoration: BoxDecoration(
+                  color: AppColors.primaryGreen,
+                  borderRadius: BorderRadius.circular(SpacingTokens.radiusCircular),
+                ),
+                child: Text(
+                  '${conversation.unreadCount}',
+                  style: AppTypography.badgeText.copyWith(
+                    color: Colors.white,
+                    fontWeight: FontWeight.bold,
+                  ),
+                ),
+              ),
+            ],
+
+            // Icônes statut
+            if (conversation.isPinned || conversation.isMuted) ...[
+              const SizedBox(width: SpacingTokens.sm),
+              Column(
+                children: [
+                  if (conversation.isPinned)
+                    Icon(
+                      Icons.push_pin,
+                      size: 16,
+                      color: AppColors.textSecondaryLight,
+                    ),
+                  if (conversation.isMuted)
+                    Icon(
+                      Icons.volume_off,
+                      size: 16,
+                      color: AppColors.textSecondaryLight,
+                    ),
+                ],
+              ),
+            ],
+          ],
+        ),
+      ),
+    );
+  }
+}