Initial commit: unionflow-mobile-apps

Application Flutter complète (sans build artifacts).

Signed-off-by: lions dev Team

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');
+    }
+  }
+}

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;
+}

lib/features/communication/data/models/conversation_model.g.dart

@@ -0,0 +1,57 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'conversation_model.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+ConversationModel _$ConversationModelFromJson(Map<String, dynamic> json) =>
+    ConversationModel(
+      id: json['id'] as String,
+      name: json['name'] as String,
+      description: json['description'] as String?,
+      type: $enumDecode(_$ConversationTypeEnumMap, json['type']),
+      participantIds: (json['participantIds'] as List<dynamic>)
+          .map((e) => e as String)
+          .toList(),
+      organizationId: json['organizationId'] as String?,
+      lastMessage: ConversationModel._messageFromJson(
+          json['lastMessage'] as Map<String, dynamic>?),
+      unreadCount: (json['unreadCount'] as num?)?.toInt() ?? 0,
+      isMuted: json['isMuted'] as bool? ?? false,
+      isPinned: json['isPinned'] as bool? ?? false,
+      isArchived: json['isArchived'] as bool? ?? false,
+      createdAt: DateTime.parse(json['createdAt'] as String),
+      updatedAt: json['updatedAt'] == null
+          ? null
+          : DateTime.parse(json['updatedAt'] as String),
+      avatarUrl: json['avatarUrl'] as String?,
+      metadata: json['metadata'] as Map<String, dynamic>?,
+    );
+
+Map<String, dynamic> _$ConversationModelToJson(ConversationModel instance) =>
+    <String, dynamic>{
+      'id': instance.id,
+      'name': instance.name,
+      'description': instance.description,
+      'type': _$ConversationTypeEnumMap[instance.type]!,
+      'participantIds': instance.participantIds,
+      'organizationId': instance.organizationId,
+      'unreadCount': instance.unreadCount,
+      'isMuted': instance.isMuted,
+      'isPinned': instance.isPinned,
+      'isArchived': instance.isArchived,
+      'createdAt': instance.createdAt.toIso8601String(),
+      'updatedAt': instance.updatedAt?.toIso8601String(),
+      'avatarUrl': instance.avatarUrl,
+      'metadata': instance.metadata,
+      'lastMessage': ConversationModel._messageToJson(instance.lastMessage),
+    };
+
+const _$ConversationTypeEnumMap = {
+  ConversationType.individual: 'individual',
+  ConversationType.group: 'group',
+  ConversationType.broadcast: 'broadcast',
+  ConversationType.announcement: 'announcement',
+};

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,
+  );
+}

lib/features/communication/data/models/message_model.g.dart

@@ -0,0 +1,84 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'message_model.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+MessageModel _$MessageModelFromJson(Map<String, dynamic> json) => MessageModel(
+      id: json['id'] as String,
+      conversationId: json['conversationId'] as String,
+      senderId: json['senderId'] as String,
+      senderName: json['senderName'] as String,
+      senderAvatar: json['senderAvatar'] as String?,
+      content: json['content'] as String,
+      type: $enumDecode(_$MessageTypeEnumMap, json['type']),
+      status: $enumDecode(_$MessageStatusEnumMap, json['status']),
+      priority:
+          $enumDecodeNullable(_$MessagePriorityEnumMap, json['priority']) ??
+              MessagePriority.normal,
+      recipientIds: (json['recipientIds'] as List<dynamic>)
+          .map((e) => e as String)
+          .toList(),
+      recipientRoles: (json['recipientRoles'] as List<dynamic>?)
+          ?.map((e) => e as String)
+          .toList(),
+      organizationId: json['organizationId'] as String?,
+      createdAt: DateTime.parse(json['createdAt'] as String),
+      readAt: json['readAt'] == null
+          ? null
+          : DateTime.parse(json['readAt'] as String),
+      metadata: json['metadata'] as Map<String, dynamic>?,
+      attachments: (json['attachments'] as List<dynamic>?)
+          ?.map((e) => e as String)
+          .toList(),
+      isEdited: json['isEdited'] as bool? ?? false,
+      editedAt: json['editedAt'] == null
+          ? null
+          : DateTime.parse(json['editedAt'] as String),
+      isDeleted: json['isDeleted'] as bool? ?? false,
+    );
+
+Map<String, dynamic> _$MessageModelToJson(MessageModel instance) =>
+    <String, dynamic>{
+      'id': instance.id,
+      'conversationId': instance.conversationId,
+      'senderId': instance.senderId,
+      'senderName': instance.senderName,
+      'senderAvatar': instance.senderAvatar,
+      'content': instance.content,
+      'type': _$MessageTypeEnumMap[instance.type]!,
+      'status': _$MessageStatusEnumMap[instance.status]!,
+      'priority': _$MessagePriorityEnumMap[instance.priority]!,
+      'recipientIds': instance.recipientIds,
+      'recipientRoles': instance.recipientRoles,
+      'organizationId': instance.organizationId,
+      'createdAt': instance.createdAt.toIso8601String(),
+      'readAt': instance.readAt?.toIso8601String(),
+      'metadata': instance.metadata,
+      'attachments': instance.attachments,
+      'isEdited': instance.isEdited,
+      'editedAt': instance.editedAt?.toIso8601String(),
+      'isDeleted': instance.isDeleted,
+    };
+
+const _$MessageTypeEnumMap = {
+  MessageType.individual: 'individual',
+  MessageType.broadcast: 'broadcast',
+  MessageType.targeted: 'targeted',
+  MessageType.system: 'system',
+};
+
+const _$MessageStatusEnumMap = {
+  MessageStatus.sent: 'sent',
+  MessageStatus.delivered: 'delivered',
+  MessageStatus.read: 'read',
+  MessageStatus.failed: 'failed',
+};
+
+const _$MessagePriorityEnumMap = {
+  MessagePriority.normal: 'normal',
+  MessagePriority.high: 'high',
+  MessagePriority.urgent: 'urgent',
+};

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'));
+  }
+}