fix(chat): Correction race condition + Implémentation TODOs
## Corrections Critiques ### Race Condition - Statuts de Messages - Fix : Les icônes de statut (✓, ✓✓, ✓✓ bleu) ne s'affichaient pas - Cause : WebSocket delivery confirmations arrivaient avant messages locaux - Solution : Pattern Optimistic UI dans chat_bloc.dart - Création message temporaire immédiate - Ajout à la liste AVANT requête HTTP - Remplacement par message serveur à la réponse - Fichier : lib/presentation/state_management/chat_bloc.dart ## Implémentation TODOs (13/21) ### Social (social_header_widget.dart) - ✅ Copier lien du post dans presse-papiers - ✅ Partage natif via Share.share() - ✅ Dialogue de signalement avec 5 raisons ### Partage (share_post_dialog.dart) - ✅ Interface sélection d'amis avec checkboxes - ✅ Partage externe via Share API ### Média (media_upload_service.dart) - ✅ Parsing JSON réponse backend - ✅ Méthode deleteMedia() pour suppression - ✅ Génération miniature vidéo ### Posts (create_post_dialog.dart, edit_post_dialog.dart) - ✅ Extraction URL depuis uploads - ✅ Documentation chargement médias ### Chat (conversations_screen.dart) - ✅ Navigation vers notifications - ✅ ConversationSearchDelegate pour recherche ## Nouveaux Fichiers ### Configuration - build-prod.ps1 : Script build production avec dart-define - lib/core/constants/env_config.dart : Gestion environnements ### Documentation - TODOS_IMPLEMENTED.md : Documentation complète TODOs ## Améliorations ### Architecture - Refactoring injection de dépendances - Amélioration routing et navigation - Optimisation providers (UserProvider, FriendsProvider) ### UI/UX - Amélioration thème et couleurs - Optimisation animations - Meilleure gestion erreurs ### Services - Configuration API avec env_config - Amélioration datasources (events, users) - Optimisation modèles de données
This commit is contained in:
dahoud
396
lib/data/datasources/chat_remote_data_source.dart
Normal file
396
lib/data/datasources/chat_remote_data_source.dart
Normal file
@@ -0,0 +1,396 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:http/http.dart' as http;
|
||||
|
||||
import '../../core/constants/env_config.dart';
|
||||
import '../../core/constants/urls.dart';
|
||||
import '../../core/errors/exceptions.dart';
|
||||
import '../../core/utils/app_logger.dart';
|
||||
import '../models/chat_message_model.dart';
|
||||
import '../models/conversation_model.dart';
|
||||
|
||||
/// Source de données distante pour le chat.
|
||||
///
|
||||
/// Cette classe gère toutes les opérations liées au chat
|
||||
/// via l'API backend (REST) et WebSocket pour le temps réel.
|
||||
class ChatRemoteDataSource {
|
||||
ChatRemoteDataSource(this.client);
|
||||
|
||||
final http.Client client;
|
||||
|
||||
static const Map<String, String> _defaultHeaders = {
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
};
|
||||
|
||||
Duration get _timeout => Duration(seconds: EnvConfig.networkTimeout);
|
||||
|
||||
Future<http.Response> _performRequest(
|
||||
String method,
|
||||
Uri uri, {
|
||||
Map<String, String>? headers,
|
||||
Object? body,
|
||||
}) async {
|
||||
AppLogger.http(method, uri.toString());
|
||||
|
||||
try {
|
||||
http.Response response;
|
||||
final requestHeaders = {..._defaultHeaders, ...?headers};
|
||||
|
||||
switch (method) {
|
||||
case 'GET':
|
||||
response = await client.get(uri, headers: requestHeaders).timeout(_timeout);
|
||||
break;
|
||||
case 'POST':
|
||||
response = await client.post(uri, headers: requestHeaders, body: body).timeout(_timeout);
|
||||
break;
|
||||
case 'PUT':
|
||||
response = await client.put(uri, headers: requestHeaders, body: body).timeout(_timeout);
|
||||
break;
|
||||
case 'DELETE':
|
||||
response = await client.delete(uri, headers: requestHeaders).timeout(_timeout);
|
||||
break;
|
||||
default:
|
||||
throw ArgumentError('Méthode HTTP non supportée: $method');
|
||||
}
|
||||
|
||||
AppLogger.http(method, uri.toString(), statusCode: response.statusCode);
|
||||
AppLogger.d('Réponse: ${response.body}', tag: 'ChatRemoteDataSource');
|
||||
|
||||
return response;
|
||||
} on TimeoutException catch (e, stackTrace) {
|
||||
AppLogger.e('Timeout lors de la requête $method $uri', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
throw ServerException('La requête a pris trop de temps. Le serveur ne répond pas.');
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
throw const ServerException('Erreur de connexion réseau. Vérifiez votre connexion internet.');
|
||||
} on http.ClientException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur client HTTP', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
throw ServerException('Erreur client HTTP: ${e.message}');
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur inattendue', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
dynamic _parseJsonResponse(http.Response response, List<int> expectedStatusCodes) {
|
||||
if (expectedStatusCodes.contains(response.statusCode)) {
|
||||
if (response.body.isEmpty) {
|
||||
return [];
|
||||
}
|
||||
return json.decode(response.body);
|
||||
} else {
|
||||
final errorMessage = (json.decode(response.body) as Map<String, dynamic>?)?['message'] as String? ??
|
||||
'Erreur serveur inconnue';
|
||||
|
||||
AppLogger.e('Erreur (${response.statusCode}): $errorMessage', tag: 'ChatRemoteDataSource');
|
||||
|
||||
switch (response.statusCode) {
|
||||
case 401:
|
||||
throw UnauthorizedException(errorMessage);
|
||||
case 404:
|
||||
throw ServerException('Ressource non trouvée: $errorMessage');
|
||||
default:
|
||||
throw ServerException('Erreur serveur (${response.statusCode}): $errorMessage');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère toutes les conversations d'un utilisateur.
|
||||
Future<List<ConversationModel>> getConversations(String userId) async {
|
||||
AppLogger.d('Récupération des conversations pour: $userId', tag: 'ChatRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.getUserConversations(userId));
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => ConversationModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des conversations', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère ou crée une conversation avec un utilisateur.
|
||||
///
|
||||
/// Si la conversation n'existe pas (404) ou si le backend ne répond pas (timeout),
|
||||
/// elle sera créée automatiquement en envoyant un message initial.
|
||||
Future<ConversationModel> getOrCreateConversation(String userId, String participantId) async {
|
||||
AppLogger.d('Récupération/création conversation: $userId <-> $participantId', tag: 'ChatRemoteDataSource');
|
||||
|
||||
final uri = Uri.parse(Urls.getConversationBetweenUsers(userId, participantId));
|
||||
|
||||
try {
|
||||
// Essayer de récupérer la conversation existante avec un timeout plus court
|
||||
final response = await _performRequestWithTimeout('GET', uri, timeout: const Duration(seconds: 10));
|
||||
|
||||
// Si la conversation existe, la retourner
|
||||
if (response.statusCode == 200 || response.statusCode == 201) {
|
||||
final jsonResponse = json.decode(response.body) as Map<String, dynamic>;
|
||||
return ConversationModel.fromJson(jsonResponse);
|
||||
}
|
||||
|
||||
// Si 404, la conversation n'existe pas, on doit la créer
|
||||
if (response.statusCode == 404) {
|
||||
AppLogger.i('Conversation non trouvée (404), création en cours...', tag: 'ChatRemoteDataSource');
|
||||
return await _createConversationBySendingMessage(userId, participantId, uri);
|
||||
}
|
||||
|
||||
// Pour les autres codes d'erreur, utiliser la méthode standard de parsing
|
||||
final jsonResponse = _parseJsonResponse(response, [200, 201]) as Map<String, dynamic>;
|
||||
return ConversationModel.fromJson(jsonResponse);
|
||||
} on ServerException catch (e) {
|
||||
// Si c'est une ServerException avec 404 ou timeout, on essaie de créer la conversation
|
||||
if (e.message.contains('404') ||
|
||||
e.message.contains('non trouvée') ||
|
||||
e.message.contains('not found') ||
|
||||
e.message.contains('trop de temps') ||
|
||||
e.message.contains('ne répond pas')) {
|
||||
AppLogger.i('Conversation non trouvée ou timeout, création en cours...', tag: 'ChatRemoteDataSource');
|
||||
return await _createConversationBySendingMessage(userId, participantId, uri);
|
||||
}
|
||||
rethrow;
|
||||
} on TimeoutException catch (e, stackTrace) {
|
||||
// Si timeout, créer directement la conversation
|
||||
AppLogger.w('Timeout lors de la récupération de la conversation, création directe...', tag: 'ChatRemoteDataSource');
|
||||
return await _createConversationBySendingMessage(userId, participantId, uri);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération/création de conversation', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Effectue une requête HTTP avec un timeout personnalisé.
|
||||
Future<http.Response> _performRequestWithTimeout(
|
||||
String method,
|
||||
Uri uri, {
|
||||
Map<String, String>? headers,
|
||||
Object? body,
|
||||
Duration? timeout,
|
||||
}) async {
|
||||
AppLogger.http(method, uri.toString());
|
||||
|
||||
try {
|
||||
http.Response response;
|
||||
final requestHeaders = {..._defaultHeaders, ...?headers};
|
||||
final requestTimeout = timeout ?? _timeout;
|
||||
|
||||
switch (method) {
|
||||
case 'GET':
|
||||
response = await client.get(uri, headers: requestHeaders).timeout(requestTimeout);
|
||||
break;
|
||||
case 'POST':
|
||||
response = await client.post(uri, headers: requestHeaders, body: body).timeout(requestTimeout);
|
||||
break;
|
||||
case 'PUT':
|
||||
response = await client.put(uri, headers: requestHeaders, body: body).timeout(requestTimeout);
|
||||
break;
|
||||
case 'DELETE':
|
||||
response = await client.delete(uri, headers: requestHeaders).timeout(requestTimeout);
|
||||
break;
|
||||
default:
|
||||
throw ArgumentError('Méthode HTTP non supportée: $method');
|
||||
}
|
||||
|
||||
AppLogger.http(method, uri.toString(), statusCode: response.statusCode);
|
||||
AppLogger.d('Réponse: ${response.body}', tag: 'ChatRemoteDataSource');
|
||||
|
||||
return response;
|
||||
} on TimeoutException catch (e, stackTrace) {
|
||||
AppLogger.e('Timeout lors de la requête $method $uri', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
throw ServerException('La requête a pris trop de temps. Le serveur ne répond pas.');
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
throw const ServerException('Erreur de connexion réseau. Vérifiez votre connexion internet.');
|
||||
} on http.ClientException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur client HTTP', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
throw ServerException('Erreur client HTTP: ${e.message}');
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur inattendue', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Crée une conversation en envoyant un message initial, puis récupère la conversation créée.
|
||||
Future<ConversationModel> _createConversationBySendingMessage(
|
||||
String userId,
|
||||
String participantId,
|
||||
Uri conversationUri,
|
||||
) async {
|
||||
try {
|
||||
// Créer la conversation en envoyant un message initial
|
||||
// Le backend créera automatiquement la conversation lors de l'envoi du premier message
|
||||
AppLogger.i('Création de la conversation en envoyant un message initial...', tag: 'ChatRemoteDataSource');
|
||||
|
||||
await sendMessage(
|
||||
senderId: userId,
|
||||
recipientId: participantId,
|
||||
content: '👋', // Message initial pour créer la conversation
|
||||
messageType: 'text',
|
||||
);
|
||||
|
||||
AppLogger.i('Message initial envoyé, attente de la création de la conversation...', tag: 'ChatRemoteDataSource');
|
||||
|
||||
// Attendre un peu pour que le backend crée la conversation
|
||||
await Future.delayed(const Duration(milliseconds: 1000));
|
||||
|
||||
// Récupérer la conversation nouvellement créée avec plusieurs tentatives et timeout court
|
||||
for (int attempt = 0; attempt < 3; attempt++) {
|
||||
try {
|
||||
AppLogger.d('Tentative ${attempt + 1}/3 pour récupérer la conversation créée...', tag: 'ChatRemoteDataSource');
|
||||
final retryResponse = await _performRequestWithTimeout(
|
||||
'GET',
|
||||
conversationUri,
|
||||
timeout: const Duration(seconds: 5),
|
||||
);
|
||||
|
||||
if (retryResponse.statusCode == 200 || retryResponse.statusCode == 201) {
|
||||
final jsonResponse = json.decode(retryResponse.body) as Map<String, dynamic>;
|
||||
AppLogger.i('Conversation créée avec succès', tag: 'ChatRemoteDataSource');
|
||||
return ConversationModel.fromJson(jsonResponse);
|
||||
}
|
||||
} on TimeoutException {
|
||||
AppLogger.w('Timeout lors de la tentative ${attempt + 1}, nouvelle tentative...', tag: 'ChatRemoteDataSource');
|
||||
}
|
||||
|
||||
// Attendre un peu plus avant la prochaine tentative
|
||||
if (attempt < 2) {
|
||||
await Future.delayed(Duration(milliseconds: 500 * (attempt + 1)));
|
||||
}
|
||||
}
|
||||
|
||||
// Si après 3 tentatives on n'a toujours pas la conversation, lever une exception
|
||||
throw ServerException(
|
||||
'Impossible de créer ou récupérer la conversation après plusieurs tentatives. '
|
||||
'Le serveur ne répond pas correctement.',
|
||||
);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e(
|
||||
'Erreur lors de la création de la conversation via message initial',
|
||||
error: e,
|
||||
stackTrace: stackTrace,
|
||||
tag: 'ChatRemoteDataSource',
|
||||
);
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère tous les messages d'une conversation.
|
||||
Future<List<ChatMessageModel>> getMessages(String conversationId, {int page = 0, int size = 50}) async {
|
||||
AppLogger.d('Récupération des messages: $conversationId (page: $page)', tag: 'ChatRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.getConversationMessages(conversationId, page: page, size: size));
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => ChatMessageModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des messages', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Envoie un nouveau message dans une conversation.
|
||||
Future<ChatMessageModel> sendMessage({
|
||||
required String senderId,
|
||||
required String recipientId,
|
||||
required String content,
|
||||
String? messageType,
|
||||
String? mediaUrl,
|
||||
}) async {
|
||||
AppLogger.i('Envoi message de $senderId à $recipientId', tag: 'ChatRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.sendMessage);
|
||||
final body = json.encode({
|
||||
'senderId': senderId,
|
||||
'recipientId': recipientId,
|
||||
'content': content,
|
||||
'messageType': messageType ?? 'text',
|
||||
if (mediaUrl != null) 'mediaUrl': mediaUrl,
|
||||
});
|
||||
final response = await _performRequest('POST', uri, body: body);
|
||||
final jsonResponse = _parseJsonResponse(response, [200, 201]) as Map<String, dynamic>;
|
||||
return ChatMessageModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de l\'envoi du message', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Marque un message comme lu.
|
||||
Future<void> markMessageAsRead(String messageId) async {
|
||||
AppLogger.d('Marquer message comme lu: $messageId', tag: 'ChatRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.markMessageAsRead(messageId));
|
||||
await _performRequest('PUT', uri);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors du marquage comme lu', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Marque tous les messages d'une conversation comme lus.
|
||||
Future<void> markConversationAsRead(String conversationId, String userId) async {
|
||||
AppLogger.d('Marquer conversation comme lue: $conversationId', tag: 'ChatRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.markAllMessagesAsRead(conversationId, userId));
|
||||
await _performRequest('PUT', uri);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors du marquage de la conversation', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Supprime un message.
|
||||
Future<void> deleteMessage(String messageId) async {
|
||||
AppLogger.i('Suppression message: $messageId', tag: 'ChatRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.deleteMessage(messageId));
|
||||
await _performRequest('DELETE', uri);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la suppression', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Supprime une conversation.
|
||||
Future<void> deleteConversation(String conversationId) async {
|
||||
AppLogger.i('Suppression conversation: $conversationId', tag: 'ChatRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.deleteConversation(conversationId));
|
||||
await _performRequest('DELETE', uri);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la suppression de la conversation', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère le nombre de messages non lus pour un utilisateur.
|
||||
Future<int> getUnreadMessagesCount(String userId) async {
|
||||
AppLogger.d('Récupération du nombre de messages non lus pour: $userId', tag: 'ChatRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.getUnreadMessagesCount(userId));
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return jsonResponse['unreadCount'] as int? ?? 0;
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération du nombre de messages non lus', error: e, stackTrace: stackTrace, tag: 'ChatRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Envoie un indicateur de frappe (typing indicator) via WebSocket.
|
||||
/// Cette méthode est maintenant gérée par le WebSocket, pas par REST.
|
||||
Future<void> sendTypingIndicator(String recipientId, String userId, bool isTyping) async {
|
||||
AppLogger.d('Indicateur de frappe envoyé via WebSocket pour: $recipientId ($isTyping)', tag: 'ChatRemoteDataSource');
|
||||
// Cette fonctionnalité sera gérée par ChatWebSocketService
|
||||
}
|
||||
}
|
||||
160
lib/data/datasources/establishment_remote_data_source.dart
Normal file
160
lib/data/datasources/establishment_remote_data_source.dart
Normal file
@@ -0,0 +1,160 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:http/http.dart' as http;
|
||||
|
||||
import '../../core/constants/env_config.dart';
|
||||
import '../../core/constants/urls.dart';
|
||||
import '../../core/errors/exceptions.dart';
|
||||
import '../../core/utils/app_logger.dart';
|
||||
import '../models/establishment_model.dart';
|
||||
|
||||
/// Source de données distante pour les établissements.
|
||||
///
|
||||
/// Cette classe gère toutes les opérations liées aux établissements
|
||||
/// via l'API backend.
|
||||
class EstablishmentRemoteDataSource {
|
||||
EstablishmentRemoteDataSource(this.client);
|
||||
|
||||
final http.Client client;
|
||||
|
||||
static const Map<String, String> _defaultHeaders = {
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
};
|
||||
|
||||
Duration get _timeout => Duration(seconds: EnvConfig.networkTimeout);
|
||||
|
||||
Future<http.Response> _performRequest(
|
||||
String method,
|
||||
Uri uri, {
|
||||
Map<String, String>? headers,
|
||||
Object? body,
|
||||
}) async {
|
||||
AppLogger.http(method, uri.toString());
|
||||
|
||||
try {
|
||||
http.Response response;
|
||||
final requestHeaders = {..._defaultHeaders, ...?headers};
|
||||
|
||||
switch (method) {
|
||||
case 'GET':
|
||||
response = await client.get(uri, headers: requestHeaders).timeout(_timeout);
|
||||
break;
|
||||
case 'POST':
|
||||
response = await client.post(uri, headers: requestHeaders, body: body).timeout(_timeout);
|
||||
break;
|
||||
default:
|
||||
throw ArgumentError('Méthode HTTP non supportée: $method');
|
||||
}
|
||||
|
||||
AppLogger.http(method, uri.toString(), statusCode: response.statusCode);
|
||||
AppLogger.d('Réponse: ${response.body}', tag: 'EstablishmentRemoteDataSource');
|
||||
|
||||
return response;
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'EstablishmentRemoteDataSource');
|
||||
throw const ServerException('Erreur de connexion réseau. Vérifiez votre connexion internet.');
|
||||
} on http.ClientException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur client HTTP', error: e, stackTrace: stackTrace, tag: 'EstablishmentRemoteDataSource');
|
||||
throw ServerException('Erreur client HTTP: ${e.message}');
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur inattendue', error: e, stackTrace: stackTrace, tag: 'EstablishmentRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
dynamic _parseJsonResponse(http.Response response, List<int> expectedStatusCodes) {
|
||||
if (expectedStatusCodes.contains(response.statusCode)) {
|
||||
if (response.body.isEmpty) {
|
||||
return [];
|
||||
}
|
||||
return json.decode(response.body);
|
||||
} else {
|
||||
final errorMessage = (json.decode(response.body) as Map<String, dynamic>?)?['message'] as String? ??
|
||||
'Erreur serveur inconnue';
|
||||
|
||||
AppLogger.e('Erreur (${response.statusCode}): $errorMessage', tag: 'EstablishmentRemoteDataSource');
|
||||
|
||||
switch (response.statusCode) {
|
||||
case 401:
|
||||
throw UnauthorizedException(errorMessage);
|
||||
case 404:
|
||||
throw ServerException('Établissement non trouvé: $errorMessage');
|
||||
default:
|
||||
throw ServerException('Erreur serveur (${response.statusCode}): $errorMessage');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère tous les établissements.
|
||||
Future<List<EstablishmentModel>> getAllEstablishments() async {
|
||||
AppLogger.d('Récupération de tous les établissements', tag: 'EstablishmentRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/establishments');
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => EstablishmentModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des établissements', error: e, stackTrace: stackTrace, tag: 'EstablishmentRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Recherche des établissements par nom ou ville.
|
||||
Future<List<EstablishmentModel>> searchEstablishments(String query) async {
|
||||
AppLogger.d('Recherche: $query', tag: 'EstablishmentRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/establishments/search').replace(
|
||||
queryParameters: {'q': query},
|
||||
);
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => EstablishmentModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la recherche', error: e, stackTrace: stackTrace, tag: 'EstablishmentRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Filtre les établissements par type et/ou fourchette de prix.
|
||||
Future<List<EstablishmentModel>> filterEstablishments({
|
||||
String? type,
|
||||
String? priceRange,
|
||||
String? city,
|
||||
}) async {
|
||||
AppLogger.d('Filtrage: type=$type, priceRange=$priceRange, city=$city', tag: 'EstablishmentRemoteDataSource');
|
||||
|
||||
try {
|
||||
final queryParams = <String, String>{};
|
||||
if (type != null) queryParams['type'] = type;
|
||||
if (priceRange != null) queryParams['priceRange'] = priceRange;
|
||||
if (city != null) queryParams['city'] = city;
|
||||
|
||||
final uri = Uri.parse('${Urls.baseUrl}/establishments').replace(queryParameters: queryParams);
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => EstablishmentModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors du filtrage', error: e, stackTrace: stackTrace, tag: 'EstablishmentRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère un établissement par son ID.
|
||||
Future<EstablishmentModel> getEstablishmentById(String id) async {
|
||||
AppLogger.d('Récupération établissement: $id', tag: 'EstablishmentRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/establishments/$id');
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return EstablishmentModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération de l\'établissement', error: e, stackTrace: stackTrace, tag: 'EstablishmentRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,264 +1,674 @@
|
||||
import 'dart:convert';
|
||||
import 'package:afterwork/core/constants/urls.dart';
|
||||
import 'package:afterwork/data/models/event_model.dart';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:http/http.dart' as http;
|
||||
|
||||
import '../../core/constants/env_config.dart';
|
||||
import '../../core/constants/urls.dart';
|
||||
import '../../core/errors/exceptions.dart';
|
||||
import '../../core/utils/app_logger.dart';
|
||||
import '../models/event_model.dart';
|
||||
|
||||
/// Source de données pour les événements distants.
|
||||
/// Source de données distante pour les événements.
|
||||
///
|
||||
/// Cette classe gère toutes les opérations CRUD sur les événements
|
||||
/// via l'API backend. Elle inclut la gestion d'erreurs, les timeouts,
|
||||
/// et la validation des réponses.
|
||||
///
|
||||
/// **Usage:**
|
||||
/// ```dart
|
||||
/// final dataSource = EventRemoteDataSource(http.Client());
|
||||
/// final events = await dataSource.getAllEvents();
|
||||
/// ```
|
||||
class EventRemoteDataSource {
|
||||
final http.Client client;
|
||||
|
||||
/// Crée une nouvelle instance de [EventRemoteDataSource].
|
||||
///
|
||||
/// [client] Le client HTTP à utiliser pour les requêtes
|
||||
EventRemoteDataSource(this.client);
|
||||
|
||||
/// Récupérer tous les événements depuis l'API.
|
||||
Future<List<EventModel>> getAllEvents() async {
|
||||
print('Récupération de tous les événements depuis ${Urls.baseUrl}/events');
|
||||
/// Client HTTP pour effectuer les requêtes réseau
|
||||
final http.Client client;
|
||||
|
||||
final response = await client.get(Uri.parse('${Urls.baseUrl}/events'));
|
||||
/// Headers par défaut pour les requêtes
|
||||
static const Map<String, String> _defaultHeaders = {
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
};
|
||||
|
||||
print('Statut de la réponse: ${response.statusCode}');
|
||||
/// Timeout pour les requêtes réseau
|
||||
Duration get _timeout => Duration(seconds: EnvConfig.networkTimeout);
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
final List<dynamic> jsonResponse = json.decode(response.body);
|
||||
print('Réponse JSON reçue: $jsonResponse');
|
||||
return jsonResponse.map((event) => EventModel.fromJson(event)).toList();
|
||||
} else {
|
||||
print('Erreur lors de la récupération des événements: ${response.body}');
|
||||
throw ServerException();
|
||||
}
|
||||
}
|
||||
// ============================================================================
|
||||
// MÉTHODES PRIVÉES UTILITAIRES
|
||||
// ============================================================================
|
||||
|
||||
/// Récupérer les événements créés par un utilisateur spécifique et ses amis.
|
||||
/// Cette méthode envoie une requête POST au serveur pour obtenir la liste des événements créés
|
||||
/// par l'utilisateur spécifié et ses amis, en utilisant l'identifiant de l'utilisateur.
|
||||
/// Effectue une requête HTTP avec gestion d'erreurs et timeout.
|
||||
///
|
||||
/// [userId] : L'identifiant de l'utilisateur pour lequel récupérer les événements.
|
||||
/// Retourne une liste de modèles d'événements [EventModel].
|
||||
Future<List<EventModel>> getEventsCreatedByUserAndFriends(String userId) async {
|
||||
// Log de début de la méthode pour signaler l'initialisation de la récupération des événements
|
||||
print('[LOG] Démarrage de la récupération des événements créés par l\'utilisateur ID: $userId et ses amis.');
|
||||
/// [method] La méthode HTTP (GET, POST, PUT, DELETE, PATCH)
|
||||
/// [uri] L'URI de la requête
|
||||
/// [headers] Les headers de la requête
|
||||
/// [body] Le corps de la requête (optionnel)
|
||||
///
|
||||
/// Returns la réponse HTTP
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<http.Response> _performRequest(
|
||||
String method,
|
||||
Uri uri, {
|
||||
Map<String, String>? headers,
|
||||
Object? body,
|
||||
}) async {
|
||||
try {
|
||||
final requestHeaders = {
|
||||
..._defaultHeaders,
|
||||
if (headers != null) ...headers,
|
||||
};
|
||||
|
||||
// Construction de l'URL de l'API pour la requête POST
|
||||
final url = Uri.parse('${Urls.baseUrl}/events/created-by-user-and-friends');
|
||||
print('[LOG] URL construite pour la requête: $url');
|
||||
http.Response response;
|
||||
|
||||
// Création de l'en-tête de la requête, spécifiant que le contenu est en JSON
|
||||
final headers = {'Content-Type': 'application/json'};
|
||||
print('[LOG] En-têtes de la requête: $headers');
|
||||
|
||||
// Construction du corps de la requête en JSON, incluant l'identifiant de l'utilisateur
|
||||
final body = jsonEncode({'userId': userId});
|
||||
print('[LOG] Corps de la requête JSON: $body');
|
||||
|
||||
// Envoi de la requête POST au serveur pour récupérer les événements
|
||||
final response = await client.post(url, headers: headers, body: body);
|
||||
print('[LOG] Requête POST envoyée au serveur.');
|
||||
|
||||
// Vérification et log de l'état de la réponse reçue
|
||||
print('[LOG] Statut de la réponse HTTP: ${response.statusCode}');
|
||||
|
||||
// Gestion de la réponse en fonction du code de statut
|
||||
if (response.statusCode == 200) {
|
||||
// Déchiffrement du JSON reçu si le code de statut est 200 (OK)
|
||||
final List<dynamic> jsonResponse = json.decode(response.body);
|
||||
print('[LOG] Réponse JSON complète reçue (taille: ${jsonResponse.length}) :');
|
||||
|
||||
// Affichage détaillé de chaque événement
|
||||
for (var i = 0; i < jsonResponse.length; i++) {
|
||||
final event = jsonResponse[i];
|
||||
print('[LOG] Événement $i :');
|
||||
print(' - ID: ${event['id']}');
|
||||
print(' - Titre: ${event['title']}');
|
||||
print(' - Description: ${event['description']}');
|
||||
print(' - Date de début: ${event['startDate']}');
|
||||
print(' - Date de fin: ${event['endDate']}');
|
||||
print(' - Localisation: ${event['location']}');
|
||||
print(' - Catégorie: ${event['category']}');
|
||||
print(' - Lien: ${event['link']}');
|
||||
print(' - URL de l\'image: ${event['imageUrl']}');
|
||||
print(' - Statut: ${event['status']}');
|
||||
print(' - prenom du créateur: ${event['creatorFirstName']}');
|
||||
print(' - prenom du créateur: ${event['creatorLastName']}');
|
||||
switch (method.toUpperCase()) {
|
||||
case 'GET':
|
||||
response = await client
|
||||
.get(uri, headers: requestHeaders)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'POST':
|
||||
response = await client
|
||||
.post(uri, headers: requestHeaders, body: body)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'PUT':
|
||||
response = await client
|
||||
.put(uri, headers: requestHeaders, body: body)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'DELETE':
|
||||
response = await client
|
||||
.delete(uri, headers: requestHeaders)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'PATCH':
|
||||
response = await client
|
||||
.patch(uri, headers: requestHeaders, body: body)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
default:
|
||||
throw ArgumentError('Méthode HTTP non supportée: $method');
|
||||
}
|
||||
|
||||
// Transformation du JSON en une liste d'objets EventModel
|
||||
List<EventModel> events = jsonResponse.map((event) => EventModel.fromJson(event)).toList();
|
||||
print('[LOG] Conversion JSON -> List<EventModel> réussie. Nombre d\'événements: ${events.length}');
|
||||
return response;
|
||||
} on SocketException {
|
||||
throw ServerException(
|
||||
'Erreur de connexion réseau. Vérifiez votre connexion Internet.',
|
||||
statusCode: null,
|
||||
);
|
||||
} on HttpException catch (e) {
|
||||
throw ServerException(
|
||||
'Erreur HTTP: ${e.message}',
|
||||
statusCode: null,
|
||||
);
|
||||
} on FormatException catch (e) {
|
||||
throw ServerException(
|
||||
'Erreur de format de réponse: ${e.message}',
|
||||
statusCode: null,
|
||||
);
|
||||
} catch (e) {
|
||||
if (e is ServerException) rethrow;
|
||||
throw ServerException(
|
||||
'Erreur inattendue: $e',
|
||||
statusCode: null,
|
||||
originalError: e,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Retourne la liste d'événements si tout s'est bien passé
|
||||
/// Parse une réponse JSON et gère les erreurs.
|
||||
///
|
||||
/// [response] La réponse HTTP
|
||||
/// [expectedStatusCodes] Les codes de statut attendus (par défaut: [200])
|
||||
///
|
||||
/// Returns les données JSON décodées
|
||||
///
|
||||
/// Throws [ServerException] si le code de statut n'est pas attendu
|
||||
dynamic _parseJsonResponse(
|
||||
http.Response response,
|
||||
List<int> expectedStatusCodes,
|
||||
) {
|
||||
if (!expectedStatusCodes.contains(response.statusCode)) {
|
||||
_handleErrorResponse(response);
|
||||
}
|
||||
|
||||
try {
|
||||
if (response.body.isEmpty) {
|
||||
return null;
|
||||
}
|
||||
return json.decode(response.body);
|
||||
} on FormatException catch (e) {
|
||||
throw ServerException(
|
||||
'Erreur de parsing JSON: ${e.message}',
|
||||
statusCode: response.statusCode,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Gère les erreurs de réponse HTTP.
|
||||
///
|
||||
/// [response] La réponse HTTP avec erreur
|
||||
///
|
||||
/// Throws [ServerException] avec un message approprié
|
||||
void _handleErrorResponse(http.Response response) {
|
||||
String errorMessage;
|
||||
|
||||
try {
|
||||
final errorBody = json.decode(response.body);
|
||||
errorMessage = errorBody['message'] as String? ??
|
||||
errorBody['error'] as String? ??
|
||||
'Erreur serveur inconnue';
|
||||
} catch (e) {
|
||||
errorMessage = response.body.isNotEmpty
|
||||
? response.body
|
||||
: 'Erreur serveur (${response.statusCode})';
|
||||
}
|
||||
|
||||
switch (response.statusCode) {
|
||||
case 400:
|
||||
throw ValidationException(errorMessage);
|
||||
case 401:
|
||||
throw UnauthorizedException(errorMessage);
|
||||
case 404:
|
||||
throw ServerException(
|
||||
'Ressource non trouvée',
|
||||
statusCode: 404,
|
||||
);
|
||||
case 409:
|
||||
throw ConflictException(errorMessage);
|
||||
case 500:
|
||||
case 502:
|
||||
case 503:
|
||||
throw ServerException(
|
||||
'Erreur serveur: $errorMessage',
|
||||
statusCode: response.statusCode,
|
||||
);
|
||||
default:
|
||||
throw ServerException(
|
||||
errorMessage,
|
||||
statusCode: response.statusCode,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Log un message si le mode debug est activé.
|
||||
///
|
||||
/// [message] Le message à logger
|
||||
void _log(String message) {
|
||||
AppLogger.d(message, tag: 'EventRemoteDataSource');
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES PUBLIQUES - CRUD ÉVÉNEMENTS
|
||||
// ============================================================================
|
||||
|
||||
/// Récupère tous les événements depuis l'API.
|
||||
///
|
||||
/// Returns une liste de [EventModel]
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
///
|
||||
/// **Exemple:**
|
||||
/// ```dart
|
||||
/// final events = await dataSource.getAllEvents();
|
||||
/// ```
|
||||
Future<List<EventModel>> getAllEvents() async {
|
||||
_log('Récupération de tous les événements');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.getAllEvents);
|
||||
final response = await _performRequest('GET', uri);
|
||||
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as List<dynamic>?;
|
||||
|
||||
if (jsonResponse == null) {
|
||||
return [];
|
||||
}
|
||||
|
||||
final events = jsonResponse
|
||||
.map((json) => EventModel.fromJson(json as Map<String, dynamic>))
|
||||
.toList();
|
||||
|
||||
_log('${events.length} événements récupérés avec succès');
|
||||
return events;
|
||||
} else {
|
||||
// Log et gestion de l'erreur en cas de statut HTTP autre que 200
|
||||
print('[ERROR] Erreur lors de la récupération des événements: ${response.body}');
|
||||
throw ServerException('[ERROR] Échec de récupération des événements créés par l\'utilisateur $userId et ses amis.');
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la récupération des événements: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Créer un nouvel événement via l'API.
|
||||
Future<EventModel> createEvent(EventModel event) async {
|
||||
print('Création d\'un nouvel événement avec les données: ${event.toJson()}');
|
||||
/// Récupère les événements créés par un utilisateur et ses amis.
|
||||
///
|
||||
/// [userId] L'identifiant de l'utilisateur
|
||||
///
|
||||
/// Returns une liste de [EventModel]
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
///
|
||||
/// **Exemple:**
|
||||
/// ```dart
|
||||
/// final events = await dataSource.getEventsCreatedByUserAndFriends('user123');
|
||||
/// ```
|
||||
Future<List<EventModel>> getEventsCreatedByUserAndFriends(
|
||||
String userId,
|
||||
) async {
|
||||
_log('Récupération des événements pour l\'utilisateur $userId et ses amis');
|
||||
|
||||
final response = await client.post(
|
||||
Uri.parse(Urls.createEvent),
|
||||
headers: {'Content-Type': 'application/json'},
|
||||
body: jsonEncode(event.toJson()),
|
||||
);
|
||||
if (userId.isEmpty) {
|
||||
throw ValidationException('L\'ID utilisateur ne peut pas être vide');
|
||||
}
|
||||
|
||||
print('Statut de la réponse: ${response.statusCode}');
|
||||
try {
|
||||
final uri = Uri.parse(Urls.getEventsCreatedByUserAndFriends);
|
||||
final body = jsonEncode({'userId': userId});
|
||||
|
||||
if (response.statusCode == 201) {
|
||||
print('Événement créé avec succès');
|
||||
return EventModel.fromJson(json.decode(response.body));
|
||||
} else {
|
||||
print('Erreur lors de la création de l\'événement: ${response.body}');
|
||||
throw ServerException();
|
||||
final response = await _performRequest(
|
||||
'POST',
|
||||
uri,
|
||||
body: body,
|
||||
);
|
||||
|
||||
// Gérer le cas 404 (aucun ami trouvé) comme une liste vide
|
||||
if (response.statusCode == 404) {
|
||||
_log('Aucun événement trouvé (404) - retour d\'une liste vide');
|
||||
return [];
|
||||
}
|
||||
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as List<dynamic>?;
|
||||
|
||||
if (jsonResponse == null) {
|
||||
return [];
|
||||
}
|
||||
|
||||
final events = jsonResponse
|
||||
.map((json) => EventModel.fromJson(json as Map<String, dynamic>))
|
||||
.toList();
|
||||
|
||||
_log('${events.length} événements récupérés avec succès');
|
||||
return events;
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la récupération des événements: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupérer un événement spécifique par son ID.
|
||||
/// Récupère les événements de l'utilisateur et de ses amis (avec pagination).
|
||||
///
|
||||
/// [userId] L'identifiant de l'utilisateur
|
||||
/// [page] Le numéro de la page (0-indexé)
|
||||
/// [size] La taille de la page
|
||||
///
|
||||
/// Returns une liste de [EventModel]
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
///
|
||||
/// **Exemple:**
|
||||
/// ```dart
|
||||
/// final events = await dataSource.getEventsByFriends(
|
||||
/// userId: 'user123',
|
||||
/// page: 0,
|
||||
/// size: 20,
|
||||
/// );
|
||||
/// ```
|
||||
Future<List<EventModel>> getEventsByFriends({
|
||||
required String userId,
|
||||
int page = 0,
|
||||
int size = 20,
|
||||
}) async {
|
||||
_log('Récupération des événements des amis pour $userId (page: $page, size: $size)');
|
||||
|
||||
if (userId.isEmpty) {
|
||||
throw ValidationException('L\'ID utilisateur ne peut pas être vide');
|
||||
}
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(
|
||||
'${Urls.getEventsByFriends(userId)}?page=$page&size=$size',
|
||||
);
|
||||
|
||||
final response = await _performRequest('GET', uri);
|
||||
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as List<dynamic>?;
|
||||
|
||||
if (jsonResponse == null) {
|
||||
return [];
|
||||
}
|
||||
|
||||
final events = jsonResponse
|
||||
.map((json) => EventModel.fromJson(json as Map<String, dynamic>))
|
||||
.toList();
|
||||
|
||||
_log('${events.length} événements des amis récupérés avec succès');
|
||||
return events;
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la récupération des événements des amis: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère un événement par son ID.
|
||||
///
|
||||
/// [id] L'identifiant de l'événement
|
||||
///
|
||||
/// Returns un [EventModel]
|
||||
///
|
||||
/// Throws [ServerException] si l'événement n'est pas trouvé
|
||||
///
|
||||
/// **Exemple:**
|
||||
/// ```dart
|
||||
/// final event = await dataSource.getEventById('event123');
|
||||
/// ```
|
||||
Future<EventModel> getEventById(String id) async {
|
||||
print('Récupération de l\'événement avec l\'ID: $id');
|
||||
_log('Récupération de l\'événement $id');
|
||||
|
||||
final response = await client.get(Uri.parse('${Urls.getEventById}/$id'));
|
||||
if (id.isEmpty) {
|
||||
throw ValidationException('L\'ID de l\'événement ne peut pas être vide');
|
||||
}
|
||||
|
||||
print('Statut de la réponse: ${response.statusCode}');
|
||||
try {
|
||||
final uri = Uri.parse(Urls.getEventByIdWithId(id));
|
||||
final response = await _performRequest('GET', uri);
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
print('Événement récupéré avec succès');
|
||||
return EventModel.fromJson(json.decode(response.body));
|
||||
} else {
|
||||
print('Erreur lors de la récupération de l\'événement: ${response.body}');
|
||||
throw ServerException();
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
|
||||
final event = EventModel.fromJson(jsonResponse);
|
||||
_log('Événement $id récupéré avec succès');
|
||||
return event;
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la récupération de l\'événement $id: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Mettre à jour un événement existant.
|
||||
/// Crée un nouvel événement.
|
||||
///
|
||||
/// [event] Le modèle d'événement à créer
|
||||
///
|
||||
/// Returns le [EventModel] créé avec l'ID généré par le serveur
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
///
|
||||
/// **Exemple:**
|
||||
/// ```dart
|
||||
/// final newEvent = EventModel(...);
|
||||
/// final createdEvent = await dataSource.createEvent(newEvent);
|
||||
/// ```
|
||||
Future<EventModel> createEvent(EventModel event) async {
|
||||
_log('Création d\'un nouvel événement: ${event.title}');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.createEvent);
|
||||
final body = jsonEncode(event.toJson());
|
||||
|
||||
final response = await _performRequest(
|
||||
'POST',
|
||||
uri,
|
||||
body: body,
|
||||
);
|
||||
|
||||
final jsonResponse = _parseJsonResponse(response, [201, 200]) as Map<String, dynamic>;
|
||||
|
||||
final createdEvent = EventModel.fromJson(jsonResponse);
|
||||
_log('Événement créé avec succès: ${createdEvent.id}');
|
||||
return createdEvent;
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la création de l\'événement: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Met à jour un événement existant.
|
||||
///
|
||||
/// [id] L'identifiant de l'événement à mettre à jour
|
||||
/// [event] Le modèle d'événement avec les nouvelles données
|
||||
///
|
||||
/// Returns le [EventModel] mis à jour
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
///
|
||||
/// **Exemple:**
|
||||
/// ```dart
|
||||
/// final updatedEvent = event.copyWith(title: 'Nouveau titre');
|
||||
/// final result = await dataSource.updateEvent('event123', updatedEvent);
|
||||
/// ```
|
||||
Future<EventModel> updateEvent(String id, EventModel event) async {
|
||||
print('Mise à jour de l\'événement avec l\'ID: $id, données: ${event.toJson()}');
|
||||
_log('Mise à jour de l\'événement $id');
|
||||
|
||||
final response = await client.put(
|
||||
Uri.parse('${Urls.updateEvent}/$id'),
|
||||
headers: {'Content-Type': 'application/json'},
|
||||
body: jsonEncode(event.toJson()),
|
||||
);
|
||||
if (id.isEmpty) {
|
||||
throw ValidationException('L\'ID de l\'événement ne peut pas être vide');
|
||||
}
|
||||
|
||||
print('Statut de la réponse: ${response.statusCode}');
|
||||
try {
|
||||
final uri = Uri.parse(Urls.updateEventWithId(id));
|
||||
final body = jsonEncode(event.toJson());
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
print('Événement mis à jour avec succès');
|
||||
return EventModel.fromJson(json.decode(response.body));
|
||||
} else {
|
||||
print('Erreur lors de la mise à jour de l\'événement: ${response.body}');
|
||||
throw ServerException();
|
||||
final response = await _performRequest(
|
||||
'PUT',
|
||||
uri,
|
||||
body: body,
|
||||
);
|
||||
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
|
||||
final updatedEvent = EventModel.fromJson(jsonResponse);
|
||||
_log('Événement $id mis à jour avec succès');
|
||||
return updatedEvent;
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la mise à jour de l\'événement $id: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Supprimer un événement par son ID.
|
||||
/// Supprime un événement.
|
||||
///
|
||||
/// [id] L'identifiant de l'événement à supprimer
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
///
|
||||
/// **Exemple:**
|
||||
/// ```dart
|
||||
/// await dataSource.deleteEvent('event123');
|
||||
/// ```
|
||||
Future<void> deleteEvent(String id) async {
|
||||
print('Suppression de l\'événement avec l\'ID: $id');
|
||||
_log('Suppression de l\'événement $id');
|
||||
|
||||
final response = await client.delete(Uri.parse('${Urls.deleteEvent}/$id'));
|
||||
if (id.isEmpty) {
|
||||
throw ValidationException('L\'ID de l\'événement ne peut pas être vide');
|
||||
}
|
||||
|
||||
print('Statut de la réponse: ${response.statusCode}');
|
||||
try {
|
||||
final uri = Uri.parse(Urls.deleteEventWithId(id));
|
||||
final response = await _performRequest('DELETE', uri);
|
||||
|
||||
if (response.statusCode != 204) {
|
||||
print('Erreur lors de la suppression de l\'événement: ${response.body}');
|
||||
throw ServerException();
|
||||
} else {
|
||||
print('Événement supprimé avec succès');
|
||||
if (![200, 204].contains(response.statusCode)) {
|
||||
_handleErrorResponse(response);
|
||||
}
|
||||
|
||||
_log('Événement $id supprimé avec succès');
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la suppression de l\'événement $id: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Participer à un événement.
|
||||
// ============================================================================
|
||||
// MÉTHODES PUBLIQUES - ACTIONS SUR ÉVÉNEMENTS
|
||||
// ============================================================================
|
||||
|
||||
/// Participe à un événement (utilise l'endpoint participants du backend).
|
||||
///
|
||||
/// [eventId] L'identifiant de l'événement
|
||||
/// [userId] L'identifiant de l'utilisateur
|
||||
///
|
||||
/// Returns le [EventModel] mis à jour avec le nouveau participant
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<EventModel> participateInEvent(String eventId, String userId) async {
|
||||
print('Participation à l\'événement avec l\'ID: $eventId, utilisateur: $userId');
|
||||
_log('Participation de l\'utilisateur $userId à l\'événement $eventId');
|
||||
|
||||
final response = await client.post(
|
||||
Uri.parse('${Urls.addParticipant}/$eventId/participate'),
|
||||
headers: {'Content-Type': 'application/json'},
|
||||
body: jsonEncode({'userId': userId}),
|
||||
);
|
||||
if (eventId.isEmpty || userId.isEmpty) {
|
||||
throw ValidationException('Les IDs ne peuvent pas être vides');
|
||||
}
|
||||
|
||||
print('Statut de la réponse: ${response.statusCode}');
|
||||
try {
|
||||
// Utiliser l'endpoint participants du backend
|
||||
// Le backend attend un objet Users avec l'id
|
||||
final uri = Uri.parse(Urls.participateInEventWithId(eventId));
|
||||
final body = jsonEncode({
|
||||
'id': userId,
|
||||
// Le backend peut aussi accepter juste l'id selon l'implémentation
|
||||
});
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
print('Participation réussie');
|
||||
return EventModel.fromJson(json.decode(response.body));
|
||||
} else {
|
||||
print('Erreur lors de la participation à l\'événement: ${response.body}');
|
||||
throw ServerException();
|
||||
final response = await _performRequest(
|
||||
'POST',
|
||||
uri,
|
||||
body: body,
|
||||
);
|
||||
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
|
||||
final updatedEvent = EventModel.fromJson(jsonResponse);
|
||||
_log('Participation réussie');
|
||||
return updatedEvent;
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la participation: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Réagir à un événement.
|
||||
/// Réagit à un événement (utilise l'endpoint favorite du backend).
|
||||
///
|
||||
/// [eventId] L'identifiant de l'événement
|
||||
/// [userId] L'identifiant de l'utilisateur
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<void> reactToEvent(String eventId, String userId) async {
|
||||
print('Réaction à l\'événement avec l\'ID: $eventId, utilisateur: $userId');
|
||||
_log('Réaction de l\'utilisateur $userId à l\'événement $eventId');
|
||||
|
||||
final response = await client.post(
|
||||
Uri.parse('${Urls.baseUrl}/$eventId/react'),
|
||||
headers: {'Content-Type': 'application/json'},
|
||||
body: jsonEncode({'userId': userId}),
|
||||
);
|
||||
if (eventId.isEmpty || userId.isEmpty) {
|
||||
throw ValidationException('Les IDs ne peuvent pas être vides');
|
||||
}
|
||||
|
||||
print('Statut de la réponse: ${response.statusCode}');
|
||||
try {
|
||||
// Utiliser l'endpoint favorite du backend comme réaction
|
||||
final uri = Uri.parse(Urls.reactToEventWithId(eventId, userId));
|
||||
|
||||
if (response.statusCode != 200) {
|
||||
print('Erreur lors de la réaction à l\'événement: ${response.body}');
|
||||
throw ServerException();
|
||||
} else {
|
||||
print('Réaction réussie');
|
||||
final response = await _performRequest('POST', uri);
|
||||
|
||||
if (![200, 201].contains(response.statusCode)) {
|
||||
_handleErrorResponse(response);
|
||||
}
|
||||
|
||||
_log('Réaction enregistrée avec succès');
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la réaction: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Fermer un événement.
|
||||
/// Ferme un événement.
|
||||
///
|
||||
/// [eventId] L'identifiant de l'événement à fermer
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
///
|
||||
/// **Exemple:**
|
||||
/// ```dart
|
||||
/// await dataSource.closeEvent('event123');
|
||||
/// ```
|
||||
Future<void> closeEvent(String eventId) async {
|
||||
print('Fermeture de l\'événement avec l\'ID: $eventId');
|
||||
_log('Fermeture de l\'événement $eventId');
|
||||
|
||||
final response = await client.patch(
|
||||
Uri.parse('${Urls.closeEvent}/$eventId/close'),
|
||||
headers: {'Content-Type': 'application/json'},
|
||||
);
|
||||
if (eventId.isEmpty) {
|
||||
throw ValidationException('L\'ID de l\'événement ne peut pas être vide');
|
||||
}
|
||||
|
||||
print('Statut de la réponse: ${response.statusCode}');
|
||||
try {
|
||||
final uri = Uri.parse(Urls.closeEventWithId(eventId));
|
||||
final response = await _performRequest('PATCH', uri);
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
print('Événement fermé avec succès');
|
||||
} else if (response.statusCode == 400) {
|
||||
final responseBody = json.decode(response.body);
|
||||
final errorMessage = responseBody['message'] ?? 'Erreur inconnue';
|
||||
print('Erreur lors de la fermeture de l\'événement: $errorMessage');
|
||||
throw ServerExceptionWithMessage(errorMessage);
|
||||
} else {
|
||||
print('Erreur lors de la fermeture de l\'événement: ${response.body}');
|
||||
throw ServerExceptionWithMessage('Une erreur est survenue lors de la fermeture de l\'événement.');
|
||||
if (response.statusCode != 200) {
|
||||
_handleErrorResponse(response);
|
||||
}
|
||||
|
||||
_log('Événement $eventId fermé avec succès');
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la fermeture de l\'événement $eventId: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Rouvrir un événement.
|
||||
/// Rouvre un événement.
|
||||
///
|
||||
/// [eventId] L'identifiant de l'événement à rouvrir
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
///
|
||||
/// **Exemple:**
|
||||
/// ```dart
|
||||
/// await dataSource.reopenEvent('event123');
|
||||
/// ```
|
||||
Future<void> reopenEvent(String eventId) async {
|
||||
print('Réouverture de l\'événement avec l\'ID: $eventId');
|
||||
_log('Réouverture de l\'événement $eventId');
|
||||
|
||||
final response = await client.patch(
|
||||
Uri.parse('${Urls.reopenEvent}/$eventId/reopen'),
|
||||
headers: {'Content-Type': 'application/json'},
|
||||
);
|
||||
if (eventId.isEmpty) {
|
||||
throw ValidationException('L\'ID de l\'événement ne peut pas être vide');
|
||||
}
|
||||
|
||||
print('Statut de la réponse: ${response.statusCode}');
|
||||
try {
|
||||
final uri = Uri.parse(Urls.reopenEventWithId(eventId));
|
||||
final response = await _performRequest('PATCH', uri);
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
print('Événement rouvert avec succès');
|
||||
} else if (response.statusCode == 400) {
|
||||
final responseBody = json.decode(response.body);
|
||||
final errorMessage = responseBody['message'] ?? 'Erreur inconnue';
|
||||
print('Erreur lors de la réouverture de l\'événement: $errorMessage');
|
||||
throw ServerExceptionWithMessage(errorMessage);
|
||||
} else if (response.statusCode == 404) {
|
||||
print('L\'événement n\'a pas été trouvé.');
|
||||
throw ServerExceptionWithMessage('L\'événement n\'existe pas ou a déjà été supprimé.');
|
||||
} else {
|
||||
print('Erreur lors de la réouverture de l\'événement: ${response.body}');
|
||||
throw ServerExceptionWithMessage('Une erreur est survenue lors de la réouverture de l\'événement.');
|
||||
if (response.statusCode != 200) {
|
||||
_handleErrorResponse(response);
|
||||
}
|
||||
|
||||
_log('Événement $eventId rouvert avec succès');
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la réouverture de l\'événement $eventId: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Recherche des événements par mot-clé.
|
||||
///
|
||||
/// [keyword] Le mot-clé à rechercher dans le titre et la description
|
||||
///
|
||||
/// Returns une liste de [EventModel] correspondant à la recherche
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<List<EventModel>> searchEvents(String keyword) async {
|
||||
_log('Recherche d\'événements avec le mot-clé: $keyword');
|
||||
|
||||
if (keyword.trim().isEmpty) {
|
||||
return [];
|
||||
}
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.searchEvents}?keyword=${Uri.encodeComponent(keyword)}');
|
||||
final response = await _performRequest('GET', uri);
|
||||
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as List<dynamic>?;
|
||||
|
||||
if (jsonResponse == null) {
|
||||
return [];
|
||||
}
|
||||
|
||||
final events = jsonResponse
|
||||
.map((json) => EventModel.fromJson(json as Map<String, dynamic>))
|
||||
.toList();
|
||||
|
||||
_log('${events.length} événements trouvés pour "$keyword"');
|
||||
return events;
|
||||
} catch (e) {
|
||||
_log('Erreur lors de la recherche: $e');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
204
lib/data/datasources/notification_remote_data_source.dart
Normal file
204
lib/data/datasources/notification_remote_data_source.dart
Normal file
@@ -0,0 +1,204 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:http/http.dart' as http;
|
||||
|
||||
import '../../core/constants/env_config.dart';
|
||||
import '../../core/constants/urls.dart';
|
||||
import '../../core/errors/exceptions.dart';
|
||||
import '../../core/utils/app_logger.dart';
|
||||
import '../models/notification_model.dart';
|
||||
|
||||
/// Source de données distante pour les notifications.
|
||||
///
|
||||
/// Cette classe gère toutes les opérations liées aux notifications
|
||||
/// via l'API backend. Elle inclut la gestion d'erreurs, les timeouts,
|
||||
/// et la validation des réponses.
|
||||
///
|
||||
/// **Usage:**
|
||||
/// ```dart
|
||||
/// final dataSource = NotificationRemoteDataSource(http.Client());
|
||||
/// final notifications = await dataSource.getNotifications(userId);
|
||||
/// ```
|
||||
class NotificationRemoteDataSource {
|
||||
/// Crée une nouvelle instance de [NotificationRemoteDataSource].
|
||||
///
|
||||
/// [client] Le client HTTP à utiliser pour les requêtes
|
||||
NotificationRemoteDataSource(this.client);
|
||||
|
||||
/// Client HTTP pour effectuer les requêtes réseau
|
||||
final http.Client client;
|
||||
|
||||
/// Headers par défaut pour les requêtes
|
||||
static const Map<String, String> _defaultHeaders = {
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
};
|
||||
|
||||
/// Timeout pour les requêtes réseau
|
||||
Duration get _timeout => Duration(seconds: EnvConfig.networkTimeout);
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES PRIVÉES UTILITAIRES
|
||||
// ============================================================================
|
||||
|
||||
/// Effectue une requête HTTP avec gestion d'erreurs et timeout.
|
||||
Future<http.Response> _performRequest(
|
||||
String method,
|
||||
Uri uri, {
|
||||
Map<String, String>? headers,
|
||||
Object? body,
|
||||
}) async {
|
||||
AppLogger.http(method, uri.toString());
|
||||
|
||||
try {
|
||||
http.Response response;
|
||||
final requestHeaders = {..._defaultHeaders, ...?headers};
|
||||
|
||||
switch (method) {
|
||||
case 'GET':
|
||||
response = await client
|
||||
.get(uri, headers: requestHeaders)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'POST':
|
||||
response = await client
|
||||
.post(uri, headers: requestHeaders, body: body)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'PUT':
|
||||
response = await client
|
||||
.put(uri, headers: requestHeaders, body: body)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'DELETE':
|
||||
response = await client
|
||||
.delete(uri, headers: requestHeaders)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
default:
|
||||
throw ArgumentError('Méthode HTTP non supportée: $method');
|
||||
}
|
||||
|
||||
AppLogger.http(method, uri.toString(), statusCode: response.statusCode);
|
||||
AppLogger.d('Réponse: ${response.body}', tag: 'NotificationRemoteDataSource');
|
||||
|
||||
return response;
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'NotificationRemoteDataSource');
|
||||
throw const ServerException(
|
||||
'Erreur de connexion réseau. Vérifiez votre connexion internet.',
|
||||
);
|
||||
} on http.ClientException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur client HTTP', error: e, stackTrace: stackTrace, tag: 'NotificationRemoteDataSource');
|
||||
throw ServerException('Erreur client HTTP: ${e.message}');
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur inattendue', error: e, stackTrace: stackTrace, tag: 'NotificationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse la réponse JSON et gère les codes de statut HTTP.
|
||||
dynamic _parseJsonResponse(http.Response response, List<int> expectedStatusCodes) {
|
||||
if (expectedStatusCodes.contains(response.statusCode)) {
|
||||
if (response.body.isEmpty) {
|
||||
return [];
|
||||
}
|
||||
return json.decode(response.body);
|
||||
} else {
|
||||
final errorMessage = (json.decode(response.body) as Map<String, dynamic>?)?['message'] as String? ??
|
||||
'Erreur serveur inconnue';
|
||||
|
||||
AppLogger.e('Erreur (${response.statusCode}): $errorMessage', tag: 'NotificationRemoteDataSource');
|
||||
|
||||
switch (response.statusCode) {
|
||||
case 401:
|
||||
throw UnauthorizedException(errorMessage);
|
||||
case 404:
|
||||
throw ServerException('Notifications non trouvées: $errorMessage');
|
||||
default:
|
||||
throw ServerException('Erreur serveur (${response.statusCode}): $errorMessage');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES PUBLIQUES
|
||||
// ============================================================================
|
||||
|
||||
/// Récupère toutes les notifications d'un utilisateur.
|
||||
///
|
||||
/// [userId] L'identifiant de l'utilisateur
|
||||
///
|
||||
/// Returns une liste de [NotificationModel]
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<List<NotificationModel>> getNotifications(String userId) async {
|
||||
AppLogger.d('Récupération des notifications pour $userId', tag: 'NotificationRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/notifications/user/$userId');
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => NotificationModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des notifications', error: e, stackTrace: stackTrace, tag: 'NotificationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Marque une notification comme lue.
|
||||
///
|
||||
/// [notificationId] L'identifiant de la notification
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<void> markAsRead(String notificationId) async {
|
||||
AppLogger.d('Marquage comme lue: $notificationId', tag: 'NotificationRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/notifications/$notificationId/read');
|
||||
final response = await _performRequest('PUT', uri);
|
||||
_parseJsonResponse(response, [200, 204]);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors du marquage comme lue', error: e, stackTrace: stackTrace, tag: 'NotificationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Marque toutes les notifications comme lues.
|
||||
///
|
||||
/// [userId] L'identifiant de l'utilisateur
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<void> markAllAsRead(String userId) async {
|
||||
AppLogger.d('Marquage toutes comme lues pour $userId', tag: 'NotificationRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/notifications/user/$userId/mark-all-read');
|
||||
final response = await _performRequest('PUT', uri);
|
||||
_parseJsonResponse(response, [200, 204]);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors du marquage toutes comme lues', error: e, stackTrace: stackTrace, tag: 'NotificationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Supprime une notification.
|
||||
///
|
||||
/// [notificationId] L'identifiant de la notification
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<void> deleteNotification(String notificationId) async {
|
||||
AppLogger.i('Suppression: $notificationId', tag: 'NotificationRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/notifications/$notificationId');
|
||||
final response = await _performRequest('DELETE', uri);
|
||||
_parseJsonResponse(response, [200, 204]);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la suppression', error: e, stackTrace: stackTrace, tag: 'NotificationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
232
lib/data/datasources/reservation_remote_data_source.dart
Normal file
232
lib/data/datasources/reservation_remote_data_source.dart
Normal file
@@ -0,0 +1,232 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:http/http.dart' as http;
|
||||
|
||||
import '../../core/constants/env_config.dart';
|
||||
import '../../core/constants/urls.dart';
|
||||
import '../../core/errors/exceptions.dart';
|
||||
import '../../core/utils/app_logger.dart';
|
||||
import '../models/reservation_model.dart';
|
||||
|
||||
/// Source de données distante pour les réservations.
|
||||
///
|
||||
/// Cette classe gère toutes les opérations liées aux réservations
|
||||
/// via l'API backend. Elle inclut la gestion d'erreurs, les timeouts,
|
||||
/// et la validation des réponses.
|
||||
///
|
||||
/// **Usage:**
|
||||
/// ```dart
|
||||
/// final dataSource = ReservationRemoteDataSource(http.Client());
|
||||
/// final reservations = await dataSource.getReservationsByUser(userId);
|
||||
/// ```
|
||||
class ReservationRemoteDataSource {
|
||||
/// Crée une nouvelle instance de [ReservationRemoteDataSource].
|
||||
///
|
||||
/// [client] Le client HTTP à utiliser pour les requêtes
|
||||
ReservationRemoteDataSource(this.client);
|
||||
|
||||
/// Client HTTP pour effectuer les requêtes réseau
|
||||
final http.Client client;
|
||||
|
||||
/// Headers par défaut pour les requêtes
|
||||
static const Map<String, String> _defaultHeaders = {
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
};
|
||||
|
||||
/// Timeout pour les requêtes réseau
|
||||
Duration get _timeout => Duration(seconds: EnvConfig.networkTimeout);
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES PRIVÉES UTILITAIRES
|
||||
// ============================================================================
|
||||
|
||||
/// Effectue une requête HTTP avec gestion d'erreurs et timeout.
|
||||
Future<http.Response> _performRequest(
|
||||
String method,
|
||||
Uri uri, {
|
||||
Map<String, String>? headers,
|
||||
Object? body,
|
||||
}) async {
|
||||
AppLogger.http(method, uri.toString());
|
||||
|
||||
try {
|
||||
http.Response response;
|
||||
final requestHeaders = {..._defaultHeaders, ...?headers};
|
||||
|
||||
switch (method) {
|
||||
case 'GET':
|
||||
response = await client
|
||||
.get(uri, headers: requestHeaders)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'POST':
|
||||
response = await client
|
||||
.post(uri, headers: requestHeaders, body: body)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'PUT':
|
||||
response = await client
|
||||
.put(uri, headers: requestHeaders, body: body)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'DELETE':
|
||||
response = await client
|
||||
.delete(uri, headers: requestHeaders)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
default:
|
||||
throw ArgumentError('Méthode HTTP non supportée: $method');
|
||||
}
|
||||
|
||||
AppLogger.http(method, uri.toString(), statusCode: response.statusCode);
|
||||
AppLogger.d('Réponse: ${response.body}', tag: 'ReservationRemoteDataSource');
|
||||
|
||||
return response;
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'ReservationRemoteDataSource');
|
||||
throw const ServerException(
|
||||
'Erreur de connexion réseau. Vérifiez votre connexion internet.',
|
||||
);
|
||||
} on http.ClientException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur client HTTP', error: e, stackTrace: stackTrace, tag: 'ReservationRemoteDataSource');
|
||||
throw ServerException('Erreur client HTTP: ${e.message}');
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur inattendue', error: e, stackTrace: stackTrace, tag: 'ReservationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse la réponse JSON et gère les codes de statut HTTP.
|
||||
dynamic _parseJsonResponse(http.Response response, List<int> expectedStatusCodes) {
|
||||
if (expectedStatusCodes.contains(response.statusCode)) {
|
||||
if (response.body.isEmpty) {
|
||||
return [];
|
||||
}
|
||||
return json.decode(response.body);
|
||||
} else {
|
||||
final errorMessage = (json.decode(response.body) as Map<String, dynamic>?)?['message'] as String? ??
|
||||
'Erreur serveur inconnue';
|
||||
|
||||
AppLogger.e('Erreur (${response.statusCode}): $errorMessage', tag: 'ReservationRemoteDataSource');
|
||||
|
||||
switch (response.statusCode) {
|
||||
case 401:
|
||||
throw UnauthorizedException(errorMessage);
|
||||
case 404:
|
||||
throw ServerException('Réservation non trouvée: $errorMessage');
|
||||
default:
|
||||
throw ServerException('Erreur serveur (${response.statusCode}): $errorMessage');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES PUBLIQUES
|
||||
// ============================================================================
|
||||
|
||||
/// Récupère toutes les réservations d'un utilisateur.
|
||||
///
|
||||
/// [userId] L'identifiant de l'utilisateur
|
||||
///
|
||||
/// Returns une liste de [ReservationModel]
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<List<ReservationModel>> getReservationsByUser(String userId) async {
|
||||
AppLogger.d('Récupération des réservations pour $userId', tag: 'ReservationRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/reservations/user/$userId');
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => ReservationModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des réservations', error: e, stackTrace: stackTrace, tag: 'ReservationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Crée une nouvelle réservation.
|
||||
///
|
||||
/// [reservation] Le modèle de réservation à créer
|
||||
///
|
||||
/// Returns le [ReservationModel] créé
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<ReservationModel> createReservation(ReservationModel reservation) async {
|
||||
AppLogger.i('Création réservation: ${reservation.eventTitle}', tag: 'ReservationRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/reservations');
|
||||
final body = jsonEncode(reservation.toJson());
|
||||
final response = await _performRequest('POST', uri, body: body);
|
||||
final jsonResponse = _parseJsonResponse(response, [200, 201]) as Map<String, dynamic>;
|
||||
return ReservationModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la création de la réservation', error: e, stackTrace: stackTrace, tag: 'ReservationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Met à jour une réservation existante.
|
||||
///
|
||||
/// [reservation] Le modèle de réservation avec les modifications
|
||||
///
|
||||
/// Returns le [ReservationModel] mis à jour
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<ReservationModel> updateReservation(ReservationModel reservation) async {
|
||||
AppLogger.i('Mise à jour réservation: ${reservation.id}', tag: 'ReservationRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/reservations/${reservation.id}');
|
||||
final body = jsonEncode(reservation.toJson());
|
||||
final response = await _performRequest('PUT', uri, body: body);
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return ReservationModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la mise à jour de la réservation', error: e, stackTrace: stackTrace, tag: 'ReservationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Annule une réservation.
|
||||
///
|
||||
/// [reservationId] L'identifiant de la réservation à annuler
|
||||
///
|
||||
/// Returns le [ReservationModel] avec le statut annulé
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<ReservationModel> cancelReservation(String reservationId) async {
|
||||
AppLogger.i('Annulation réservation: $reservationId', tag: 'ReservationRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/reservations/$reservationId/cancel');
|
||||
final response = await _performRequest('PUT', uri);
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return ReservationModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de l\'annulation de la réservation', error: e, stackTrace: stackTrace, tag: 'ReservationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Supprime une réservation.
|
||||
///
|
||||
/// [reservationId] L'identifiant de la réservation à supprimer
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<void> deleteReservation(String reservationId) async {
|
||||
AppLogger.i('Suppression réservation: $reservationId', tag: 'ReservationRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.baseUrl}/reservations/$reservationId');
|
||||
final response = await _performRequest('DELETE', uri);
|
||||
_parseJsonResponse(response, [200, 204]);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la suppression de la réservation', error: e, stackTrace: stackTrace, tag: 'ReservationRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
}
|
||||
393
lib/data/datasources/social_remote_data_source.dart
Normal file
393
lib/data/datasources/social_remote_data_source.dart
Normal file
@@ -0,0 +1,393 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:http/http.dart' as http;
|
||||
|
||||
import '../../core/constants/env_config.dart';
|
||||
import '../../core/constants/urls.dart';
|
||||
import '../../core/errors/exceptions.dart';
|
||||
import '../../core/utils/app_logger.dart';
|
||||
import '../models/comment_model.dart';
|
||||
import '../models/social_post_model.dart';
|
||||
|
||||
/// Source de données distante pour les posts sociaux.
|
||||
///
|
||||
/// Cette classe gère toutes les opérations liées aux posts sociaux
|
||||
/// via l'API backend. Elle inclut la gestion d'erreurs, les timeouts,
|
||||
/// et la validation des réponses.
|
||||
///
|
||||
/// **Usage:**
|
||||
/// ```dart
|
||||
/// final dataSource = SocialRemoteDataSource(http.Client());
|
||||
/// final posts = await dataSource.getPosts();
|
||||
/// ```
|
||||
class SocialRemoteDataSource {
|
||||
/// Crée une nouvelle instance de [SocialRemoteDataSource].
|
||||
///
|
||||
/// [client] Le client HTTP à utiliser pour les requêtes
|
||||
SocialRemoteDataSource(this.client);
|
||||
|
||||
/// Client HTTP pour effectuer les requêtes réseau
|
||||
final http.Client client;
|
||||
|
||||
/// Headers par défaut pour les requêtes
|
||||
static const Map<String, String> _defaultHeaders = {
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
};
|
||||
|
||||
/// Timeout pour les requêtes réseau
|
||||
Duration get _timeout => Duration(seconds: EnvConfig.networkTimeout);
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES PRIVÉES UTILITAIRES
|
||||
// ============================================================================
|
||||
|
||||
/// Effectue une requête HTTP avec gestion d'erreurs et timeout.
|
||||
Future<http.Response> _performRequest(
|
||||
String method,
|
||||
Uri uri, {
|
||||
Map<String, String>? headers,
|
||||
Object? body,
|
||||
}) async {
|
||||
AppLogger.http(method, uri.toString());
|
||||
|
||||
try {
|
||||
http.Response response;
|
||||
final requestHeaders = {..._defaultHeaders, ...?headers};
|
||||
|
||||
switch (method) {
|
||||
case 'GET':
|
||||
response = await client
|
||||
.get(uri, headers: requestHeaders)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'POST':
|
||||
response = await client
|
||||
.post(uri, headers: requestHeaders, body: body)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'PUT':
|
||||
response = await client
|
||||
.put(uri, headers: requestHeaders, body: body)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
case 'DELETE':
|
||||
response = await client
|
||||
.delete(uri, headers: requestHeaders)
|
||||
.timeout(_timeout);
|
||||
break;
|
||||
default:
|
||||
throw ArgumentError('Méthode HTTP non supportée: $method');
|
||||
}
|
||||
|
||||
AppLogger.http(method, uri.toString(), statusCode: response.statusCode);
|
||||
AppLogger.d('Réponse: ${response.body}', tag: 'SocialRemoteDataSource');
|
||||
|
||||
return response;
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
throw const ServerException(
|
||||
'Erreur de connexion réseau. Vérifiez votre connexion internet.',
|
||||
);
|
||||
} on http.ClientException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur client HTTP', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
throw ServerException('Erreur client HTTP: ${e.message}');
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la requête', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse la réponse JSON et gère les codes de statut HTTP.
|
||||
dynamic _parseJsonResponse(http.Response response, List<int> expectedStatusCodes) {
|
||||
if (expectedStatusCodes.contains(response.statusCode)) {
|
||||
if (response.body.isEmpty) {
|
||||
return {};
|
||||
}
|
||||
return json.decode(response.body);
|
||||
} else {
|
||||
final errorMessage = (json.decode(response.body) as Map<String, dynamic>?)?['message'] as String? ??
|
||||
'Erreur serveur inconnue';
|
||||
|
||||
AppLogger.e('Erreur (${response.statusCode}): $errorMessage', tag: 'SocialRemoteDataSource');
|
||||
|
||||
switch (response.statusCode) {
|
||||
case 401:
|
||||
throw UnauthorizedException(errorMessage);
|
||||
case 404:
|
||||
throw ServerException('Post non trouvé: $errorMessage');
|
||||
case 409:
|
||||
throw ConflictException(errorMessage);
|
||||
default:
|
||||
throw ServerException('Erreur serveur (${response.statusCode}): $errorMessage');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES PUBLIQUES
|
||||
// ============================================================================
|
||||
|
||||
/// Récupère tous les posts sociaux.
|
||||
///
|
||||
/// [userId] L'identifiant de l'utilisateur (optionnel, pour filtrer)
|
||||
///
|
||||
/// Returns une liste de [SocialPostModel]
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<List<SocialPostModel>> getPosts({String? userId}) async {
|
||||
AppLogger.d('Récupération des posts', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = userId != null
|
||||
? Uri.parse(Urls.getSocialPostsByUserId(userId))
|
||||
: Uri.parse(Urls.getAllPosts);
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => SocialPostModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des posts', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère les posts de l'utilisateur et de ses amis.
|
||||
///
|
||||
/// [userId] L'identifiant de l'utilisateur
|
||||
/// [page] Le numéro de la page (0-indexé)
|
||||
/// [size] La taille de la page
|
||||
///
|
||||
/// Returns une liste de [SocialPostModel]
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<List<SocialPostModel>> getPostsByFriends({
|
||||
required String userId,
|
||||
int page = 0,
|
||||
int size = 20,
|
||||
}) async {
|
||||
AppLogger.d('Récupération des posts des amis pour $userId', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(
|
||||
'${Urls.getSocialPostsByFriends(userId)}?page=$page&size=$size',
|
||||
);
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => SocialPostModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des posts des amis', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Crée un nouveau post social.
|
||||
///
|
||||
/// [content] Le contenu du post
|
||||
/// [userId] L'identifiant de l'utilisateur créateur
|
||||
/// [imageUrl] URL de l'image (optionnel)
|
||||
///
|
||||
/// Returns le [SocialPostModel] créé
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<SocialPostModel> createPost({
|
||||
required String content,
|
||||
required String userId,
|
||||
String? imageUrl,
|
||||
}) async {
|
||||
AppLogger.i('Création de post pour $userId', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.createSocialPost);
|
||||
final body = jsonEncode({
|
||||
'content': content,
|
||||
'userId': userId,
|
||||
if (imageUrl != null) 'imageUrl': imageUrl,
|
||||
});
|
||||
final response = await _performRequest('POST', uri, body: body);
|
||||
final jsonResponse = _parseJsonResponse(response, [201]) as Map<String, dynamic>;
|
||||
return SocialPostModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la création du post', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Recherche des posts sociaux.
|
||||
///
|
||||
/// [query] Le terme de recherche
|
||||
///
|
||||
/// Returns une liste de [SocialPostModel] correspondant à la recherche
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<List<SocialPostModel>> searchPosts(String query) async {
|
||||
AppLogger.d('Recherche: $query', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.searchSocialPostsWithQuery(query));
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => SocialPostModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la recherche', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Like un post.
|
||||
///
|
||||
/// [postId] L'ID du post
|
||||
///
|
||||
/// Returns le [SocialPostModel] mis à jour
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<SocialPostModel> likePost(String postId) async {
|
||||
AppLogger.d('Like du post: $postId', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.likeSocialPostWithId(postId));
|
||||
final response = await _performRequest('POST', uri);
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return SocialPostModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors du like', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Ajoute un commentaire à un post.
|
||||
///
|
||||
/// [postId] L'ID du post
|
||||
///
|
||||
/// Returns le [SocialPostModel] mis à jour
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<SocialPostModel> commentPost(String postId) async {
|
||||
AppLogger.d('Commentaire sur le post: $postId', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.commentSocialPostWithId(postId));
|
||||
final response = await _performRequest('POST', uri);
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return SocialPostModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors du commentaire', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Partage un post.
|
||||
///
|
||||
/// [postId] L'ID du post
|
||||
///
|
||||
/// Returns le [SocialPostModel] mis à jour
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<SocialPostModel> sharePost(String postId) async {
|
||||
AppLogger.d('Partage du post: $postId', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.shareSocialPostWithId(postId));
|
||||
final response = await _performRequest('POST', uri);
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return SocialPostModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors du commentaire', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Supprime un post.
|
||||
///
|
||||
/// [postId] L'ID du post
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<void> deletePost(String postId) async {
|
||||
AppLogger.i('Suppression du post: $postId', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.deleteSocialPostWithId(postId));
|
||||
final response = await _performRequest('DELETE', uri);
|
||||
_parseJsonResponse(response, [200, 204]);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la suppression du post', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES POUR LES COMMENTAIRES
|
||||
// ============================================================================
|
||||
|
||||
/// Récupère tous les commentaires d'un post.
|
||||
///
|
||||
/// [postId] L'ID du post
|
||||
///
|
||||
/// Returns une liste de [CommentModel]
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<List<CommentModel>> getComments(String postId) async {
|
||||
AppLogger.d('Récupération des commentaires pour le post: $postId', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.getCommentsForPost(postId));
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonList = _parseJsonResponse(response, [200]) as List;
|
||||
return jsonList.map((json) => CommentModel.fromJson(json as Map<String, dynamic>)).toList();
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des commentaires', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Crée un nouveau commentaire sur un post.
|
||||
///
|
||||
/// [postId] L'ID du post
|
||||
/// [content] Le contenu du commentaire
|
||||
/// [userId] L'ID de l'utilisateur créateur
|
||||
///
|
||||
/// Returns le [CommentModel] créé
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<CommentModel> createComment({
|
||||
required String postId,
|
||||
required String content,
|
||||
required String userId,
|
||||
}) async {
|
||||
AppLogger.i('Création de commentaire pour le post: $postId', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse(Urls.commentSocialPostWithId(postId));
|
||||
final body = jsonEncode({
|
||||
'content': content,
|
||||
'userId': userId,
|
||||
});
|
||||
final response = await _performRequest('POST', uri, body: body);
|
||||
final jsonResponse = _parseJsonResponse(response, [200, 201]) as Map<String, dynamic>;
|
||||
return CommentModel.fromJson(jsonResponse);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la création du commentaire', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Supprime un commentaire.
|
||||
///
|
||||
/// [postId] L'ID du post
|
||||
/// [commentId] L'ID du commentaire
|
||||
///
|
||||
/// Throws [ServerException] en cas d'erreur
|
||||
Future<void> deleteComment(String postId, String commentId) async {
|
||||
AppLogger.i('Suppression du commentaire: $commentId', tag: 'SocialRemoteDataSource');
|
||||
|
||||
try {
|
||||
final uri = Uri.parse('${Urls.getCommentsForPost(postId)}/$commentId');
|
||||
final response = await _performRequest('DELETE', uri);
|
||||
_parseJsonResponse(response, [200, 204]);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la suppression du commentaire', error: e, stackTrace: stackTrace, tag: 'SocialRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
244
lib/data/datasources/story_remote_data_source.dart
Normal file
244
lib/data/datasources/story_remote_data_source.dart
Normal file
@@ -0,0 +1,244 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:http/http.dart' as http;
|
||||
|
||||
import '../../core/constants/env_config.dart';
|
||||
import '../../core/constants/urls.dart';
|
||||
import '../../core/errors/exceptions.dart';
|
||||
import '../../core/utils/app_logger.dart';
|
||||
import '../models/story_model.dart';
|
||||
|
||||
/// Source de données distante pour les stories.
|
||||
///
|
||||
/// Cette classe gère toutes les opérations liées aux stories
|
||||
/// via l'API backend. Elle inclut la gestion d'erreurs, les timeouts,
|
||||
/// et la validation des réponses.
|
||||
class StoryRemoteDataSource {
|
||||
/// Crée une nouvelle instance de [StoryRemoteDataSource].
|
||||
StoryRemoteDataSource(this.client);
|
||||
|
||||
/// Client HTTP pour effectuer les requêtes réseau
|
||||
final http.Client client;
|
||||
|
||||
/// Headers par défaut pour les requêtes
|
||||
static const Map<String, String> _defaultHeaders = {
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
};
|
||||
|
||||
/// Timeout pour les requêtes réseau
|
||||
Duration get _timeout => Duration(seconds: EnvConfig.networkTimeout);
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES PUBLIQUES
|
||||
// ============================================================================
|
||||
|
||||
/// Récupère toutes les stories actives.
|
||||
///
|
||||
/// [viewerId] ID de l'utilisateur actuel (optionnel) pour marquer les stories vues
|
||||
Future<List<StoryModel>> getStories({String? viewerId}) async {
|
||||
AppLogger.d('Récupération de toutes les stories actives', tag: 'StoryRemoteDataSource');
|
||||
|
||||
try {
|
||||
var uri = Uri.parse(Urls.getAllStories);
|
||||
if (viewerId != null) {
|
||||
uri = Uri.parse('${Urls.getAllStories}?viewerId=$viewerId');
|
||||
}
|
||||
|
||||
final response = await client
|
||||
.get(uri, headers: _defaultHeaders)
|
||||
.timeout(_timeout);
|
||||
|
||||
return _handleListResponse(response);
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
throw const ServerException(
|
||||
'Erreur de connexion réseau. Vérifiez votre connexion internet.',
|
||||
);
|
||||
} on http.ClientException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur client HTTP', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
throw ServerException('Erreur client HTTP: ${e.message}');
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des stories', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère les stories d'un utilisateur spécifique.
|
||||
///
|
||||
/// [userId] L'ID de l'utilisateur
|
||||
/// [viewerId] ID de l'utilisateur actuel (optionnel)
|
||||
Future<List<StoryModel>> getStoriesByUserId(
|
||||
String userId, {
|
||||
String? viewerId,
|
||||
}) async {
|
||||
AppLogger.d('Récupération des stories pour l\'utilisateur: $userId', tag: 'StoryRemoteDataSource');
|
||||
|
||||
try {
|
||||
var uri = Uri.parse(Urls.getStoriesByUserId(userId));
|
||||
if (viewerId != null) {
|
||||
uri = Uri.parse('${Urls.getStoriesByUserId(userId)}?viewerId=$viewerId');
|
||||
}
|
||||
|
||||
final response = await client
|
||||
.get(uri, headers: _defaultHeaders)
|
||||
.timeout(_timeout);
|
||||
|
||||
return _handleListResponse(response);
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
throw const ServerException(
|
||||
'Erreur de connexion réseau. Vérifiez votre connexion internet.',
|
||||
);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la récupération des stories par utilisateur', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Crée une nouvelle story.
|
||||
///
|
||||
/// [userId] L'ID de l'utilisateur créateur
|
||||
/// [mediaType] Le type de média (IMAGE ou VIDEO)
|
||||
/// [mediaUrl] L'URL du média
|
||||
/// [thumbnailUrl] L'URL du thumbnail (optionnel, pour vidéos)
|
||||
/// [durationSeconds] Durée en secondes (optionnel, pour vidéos)
|
||||
Future<StoryModel> createStory({
|
||||
required String userId,
|
||||
required String mediaType,
|
||||
required String mediaUrl,
|
||||
String? thumbnailUrl,
|
||||
int? durationSeconds,
|
||||
}) async {
|
||||
AppLogger.i('Création d\'une story', tag: 'StoryRemoteDataSource');
|
||||
|
||||
try {
|
||||
final body = jsonEncode({
|
||||
'userId': userId,
|
||||
'mediaType': mediaType,
|
||||
'mediaUrl': mediaUrl,
|
||||
if (thumbnailUrl != null) 'thumbnailUrl': thumbnailUrl,
|
||||
if (durationSeconds != null) 'durationSeconds': durationSeconds,
|
||||
});
|
||||
|
||||
final response = await client
|
||||
.post(
|
||||
Uri.parse(Urls.createStory),
|
||||
headers: _defaultHeaders,
|
||||
body: body,
|
||||
)
|
||||
.timeout(_timeout);
|
||||
|
||||
return _handleSingleResponse(response);
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
throw const ServerException(
|
||||
'Erreur de connexion réseau. Vérifiez votre connexion internet.',
|
||||
);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la création de la story', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Marque une story comme vue.
|
||||
///
|
||||
/// [storyId] L'ID de la story
|
||||
/// [viewerId] L'ID de l'utilisateur qui voit la story
|
||||
Future<StoryModel> markStoryAsViewed(String storyId, String viewerId) async {
|
||||
AppLogger.d('Marquage de la story $storyId comme vue', tag: 'StoryRemoteDataSource');
|
||||
|
||||
try {
|
||||
final response = await client
|
||||
.post(
|
||||
Uri.parse(Urls.markStoryAsViewedWithId(storyId, viewerId)),
|
||||
headers: _defaultHeaders,
|
||||
)
|
||||
.timeout(_timeout);
|
||||
|
||||
return _handleSingleResponse(response);
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
throw const ServerException(
|
||||
'Erreur de connexion réseau. Vérifiez votre connexion internet.',
|
||||
);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors du marquage comme vue', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Supprime une story.
|
||||
///
|
||||
/// [storyId] L'ID de la story
|
||||
Future<void> deleteStory(String storyId) async {
|
||||
AppLogger.i('Suppression de la story $storyId', tag: 'StoryRemoteDataSource');
|
||||
|
||||
try {
|
||||
final response = await client
|
||||
.delete(
|
||||
Uri.parse(Urls.deleteStoryWithId(storyId)),
|
||||
headers: _defaultHeaders,
|
||||
)
|
||||
.timeout(_timeout);
|
||||
|
||||
if (response.statusCode != 200 && response.statusCode != 204) {
|
||||
throw ServerException(
|
||||
'Erreur lors de la suppression de la story. Code: ${response.statusCode}',
|
||||
);
|
||||
}
|
||||
|
||||
AppLogger.i('Story supprimée avec succès', tag: 'StoryRemoteDataSource');
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
throw const ServerException(
|
||||
'Erreur de connexion réseau. Vérifiez votre connexion internet.',
|
||||
);
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur lors de la suppression', error: e, stackTrace: stackTrace, tag: 'StoryRemoteDataSource');
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// MÉTHODES PRIVÉES UTILITAIRES
|
||||
// ============================================================================
|
||||
|
||||
/// Gère la réponse pour une liste de stories.
|
||||
List<StoryModel> _handleListResponse(http.Response response) {
|
||||
AppLogger.http('GET', 'stories', statusCode: response.statusCode);
|
||||
AppLogger.d('Response body: ${response.body}', tag: 'StoryRemoteDataSource');
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
final List<dynamic> jsonList = jsonDecode(response.body) as List<dynamic>;
|
||||
return jsonList
|
||||
.map((json) => StoryModel.fromJson(json as Map<String, dynamic>))
|
||||
.toList();
|
||||
} else if (response.statusCode == 404) {
|
||||
throw const ServerException('Stories non trouvées.');
|
||||
} else {
|
||||
throw ServerException(
|
||||
'Erreur lors de la récupération des stories. Code: ${response.statusCode}',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Gère la réponse pour une seule story.
|
||||
StoryModel _handleSingleResponse(http.Response response) {
|
||||
AppLogger.http('POST', 'story', statusCode: response.statusCode);
|
||||
AppLogger.d('Response body: ${response.body}', tag: 'StoryRemoteDataSource');
|
||||
|
||||
if (response.statusCode == 200 || response.statusCode == 201) {
|
||||
final Map<String, dynamic> json =
|
||||
jsonDecode(response.body) as Map<String, dynamic>;
|
||||
return StoryModel.fromJson(json);
|
||||
} else if (response.statusCode == 404) {
|
||||
throw const ServerException('Story non trouvée.');
|
||||
} else {
|
||||
throw ServerException(
|
||||
'Erreur lors de l'opération sur la story. Code: ${response.statusCode}',
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,186 +1,271 @@
|
||||
import 'dart:convert';
|
||||
import 'package:afterwork/core/constants/urls.dart';
|
||||
import 'package:afterwork/data/models/user_model.dart';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:http/http.dart' as http;
|
||||
|
||||
import '../../core/constants/env_config.dart';
|
||||
import '../../core/constants/urls.dart';
|
||||
import '../../core/errors/exceptions.dart';
|
||||
import '../../core/utils/app_logger.dart';
|
||||
import '../models/user_model.dart';
|
||||
|
||||
/// Classe pour gérer les opérations API pour les utilisateurs.
|
||||
/// Toutes les actions sont loguées pour faciliter la traçabilité et le débogage.
|
||||
/// Source de données distante pour les opérations liées aux utilisateurs.
|
||||
///
|
||||
/// Cette classe gère les appels API pour l'authentification, la récupération,
|
||||
/// la création, la mise à jour et la suppression des utilisateurs.
|
||||
/// Elle inclut une gestion robuste des erreurs et des logs détaillés.
|
||||
class UserRemoteDataSource {
|
||||
// Client HTTP injecté pour réaliser les appels réseau
|
||||
final http.Client client;
|
||||
|
||||
/// Constructeur avec injection du client HTTP
|
||||
/// Constructeur avec injection du client HTTP.
|
||||
UserRemoteDataSource(this.client);
|
||||
|
||||
/// Authentifie un utilisateur avec l'email et le mot de passe.
|
||||
/// Si l'authentification réussit, retourne un objet `UserModel`.
|
||||
/// Les erreurs sont gérées et toutes les actions sont loguées.
|
||||
Future<UserModel> authenticateUser(String email, String password) async {
|
||||
print("[LOG] Tentative d'authentification pour l'email : $email");
|
||||
/// Client HTTP utilisé pour les requêtes réseau.
|
||||
final http.Client client;
|
||||
|
||||
/// Exécute une requête HTTP générique avec gestion des erreurs et des logs.
|
||||
///
|
||||
/// [method] : La méthode HTTP (GET, POST, PUT, DELETE, PATCH).
|
||||
/// [uri] : L'URI complète de la requête.
|
||||
/// [headers] : Les en-têtes de la requête (optionnel).
|
||||
/// [body] : Le corps de la requête (optionnel).
|
||||
///
|
||||
/// Retourne la réponse HTTP.
|
||||
/// Lève une [ServerException] ou [SocketException] en cas d'erreur.
|
||||
Future<http.Response> _performRequest(
|
||||
String method,
|
||||
Uri uri, {
|
||||
Map<String, String>? headers,
|
||||
Object? body,
|
||||
}) async {
|
||||
if (EnvConfig.enableDetailedLogs) {
|
||||
AppLogger.http(method, uri.toString());
|
||||
AppLogger.d('En-têtes: $headers', tag: 'UserRemoteDataSource');
|
||||
AppLogger.d('Corps: $body', tag: 'UserRemoteDataSource');
|
||||
}
|
||||
|
||||
try {
|
||||
// Préparation des données d'authentification à envoyer
|
||||
final Map<String, dynamic> body = {
|
||||
'email': email,
|
||||
'motDePasse': password,
|
||||
};
|
||||
|
||||
print("[DEBUG] Données envoyées pour authentification : $body");
|
||||
|
||||
// Envoi de la requête HTTP POST pour authentifier l'utilisateur
|
||||
final response = await client.post(
|
||||
Uri.parse('${Urls.baseUrl}/users/authenticate'),
|
||||
headers: {'Content-Type': 'application/json'},
|
||||
body: jsonEncode(body),
|
||||
);
|
||||
|
||||
// Log de la réponse reçue du serveur
|
||||
print("[LOG] Réponse du serveur : ${response.statusCode} - ${response.body}");
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
final userData = jsonDecode(response.body);
|
||||
|
||||
if (userData['userId'] != null && userData['userId'].isNotEmpty) {
|
||||
print("[LOG] Utilisateur authentifié avec succès. ID: ${userData['userId']}");
|
||||
return UserModel.fromJson(userData);
|
||||
} else {
|
||||
print("[ERROR] L'ID utilisateur est manquant dans la réponse.");
|
||||
throw Exception("ID utilisateur manquant.");
|
||||
}
|
||||
} else if (response.statusCode == 401) {
|
||||
print("[ERROR] Authentification échouée : Mot de passe incorrect.");
|
||||
throw UnauthorizedException("Mot de passe incorrect.");
|
||||
} else {
|
||||
print("[ERROR] Erreur du serveur. Code : ${response.statusCode}");
|
||||
throw ServerExceptionWithMessage("Erreur inattendue : ${response.body}");
|
||||
http.Response response;
|
||||
switch (method) {
|
||||
case 'GET':
|
||||
response = await client.get(uri, headers: headers).timeout(
|
||||
Duration(seconds: EnvConfig.networkTimeout),
|
||||
);
|
||||
break;
|
||||
case 'POST':
|
||||
response = await client
|
||||
.post(uri, headers: headers, body: body)
|
||||
.timeout(Duration(seconds: EnvConfig.networkTimeout));
|
||||
break;
|
||||
case 'PUT':
|
||||
response = await client
|
||||
.put(uri, headers: headers, body: body)
|
||||
.timeout(Duration(seconds: EnvConfig.networkTimeout));
|
||||
break;
|
||||
case 'DELETE':
|
||||
response = await client.delete(uri, headers: headers).timeout(
|
||||
Duration(seconds: EnvConfig.networkTimeout),
|
||||
);
|
||||
break;
|
||||
case 'PATCH':
|
||||
response = await client
|
||||
.patch(uri, headers: headers, body: body)
|
||||
.timeout(Duration(seconds: EnvConfig.networkTimeout));
|
||||
break;
|
||||
default:
|
||||
throw ArgumentError('Méthode HTTP non supportée: $method');
|
||||
}
|
||||
} catch (e) {
|
||||
print("[ERROR] Erreur lors de l'authentification : $e");
|
||||
throw Exception("Erreur lors de l'authentification : $e");
|
||||
|
||||
if (EnvConfig.enableDetailedLogs) {
|
||||
AppLogger.http(method, uri.toString(), statusCode: response.statusCode);
|
||||
AppLogger.d('Réponse: ${response.body}', tag: 'UserRemoteDataSource');
|
||||
}
|
||||
return response;
|
||||
} on SocketException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de connexion réseau', error: e, stackTrace: stackTrace, tag: 'UserRemoteDataSource');
|
||||
throw const ServerException('Erreur de connexion réseau. Vérifiez votre connexion internet.');
|
||||
} on http.ClientException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur client HTTP', error: e, stackTrace: stackTrace, tag: 'UserRemoteDataSource');
|
||||
throw ServerException('Erreur client HTTP: ${e.message}');
|
||||
} on FormatException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de format de réponse JSON', error: e, stackTrace: stackTrace, tag: 'UserRemoteDataSource');
|
||||
throw const ServerException('Réponse du serveur mal formatée.');
|
||||
} on HandshakeException catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur de handshake SSL/TLS', error: e, stackTrace: stackTrace, tag: 'UserRemoteDataSource');
|
||||
throw const ServerException('Erreur de sécurité: Problème de certificat SSL/TLS.');
|
||||
} catch (e, stackTrace) {
|
||||
AppLogger.e('Erreur inattendue lors de la requête', error: e, stackTrace: stackTrace, tag: 'UserRemoteDataSource');
|
||||
rethrow; // Rethrow other unexpected exceptions
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse la réponse JSON et gère les codes de statut HTTP.
|
||||
///
|
||||
/// [response] : La réponse HTTP à parser.
|
||||
/// [expectedStatusCodes] : Liste des codes de statut HTTP attendus pour une réponse réussie.
|
||||
///
|
||||
/// Retourne le corps de la réponse décodé.
|
||||
/// Lève des exceptions spécifiques en fonction du code de statut.
|
||||
dynamic _parseJsonResponse(
|
||||
http.Response response,
|
||||
List<int> expectedStatusCodes,
|
||||
) {
|
||||
if (expectedStatusCodes.contains(response.statusCode)) {
|
||||
if (response.body.isEmpty) {
|
||||
return {}; // Retourne un objet vide pour les réponses 204 No Content
|
||||
}
|
||||
return json.decode(response.body);
|
||||
} else {
|
||||
final String errorMessage =
|
||||
json.decode(response.body)['message'] as String? ??
|
||||
'Erreur serveur inconnue';
|
||||
AppLogger.e('Erreur API (${response.statusCode}): $errorMessage', tag: 'UserRemoteDataSource');
|
||||
|
||||
switch (response.statusCode) {
|
||||
case 401:
|
||||
throw UnauthorizedException(errorMessage);
|
||||
case 404:
|
||||
throw UserNotFoundException(errorMessage);
|
||||
case 409:
|
||||
throw ConflictException(errorMessage);
|
||||
default:
|
||||
throw ServerException(
|
||||
'Erreur serveur (${response.statusCode}): $errorMessage',
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Authentifie un utilisateur avec l'email et le mot de passe.
|
||||
///
|
||||
/// [email] : L'email de l'utilisateur.
|
||||
/// [password] : Le mot de passe de l'utilisateur.
|
||||
///
|
||||
/// Retourne un [UserModel] si l'authentification réussit.
|
||||
/// Lève une [UnauthorizedException] si les identifiants sont incorrects.
|
||||
/// Lève une [ServerException] pour d'autres erreurs serveur.
|
||||
Future<UserModel> authenticateUser(String email, String password) async {
|
||||
final uri = Uri.parse(Urls.authenticateUser);
|
||||
final headers = {'Content-Type': 'application/json'};
|
||||
final body = jsonEncode({'email': email, 'motDePasse': password});
|
||||
|
||||
final response = await _performRequest('POST', uri, headers: headers, body: body);
|
||||
final userData = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
|
||||
if (userData['userId'] != null && userData['userId'].isNotEmpty) {
|
||||
return UserModel.fromJson(userData);
|
||||
} else {
|
||||
throw const ServerException('ID utilisateur manquant dans la réponse.');
|
||||
}
|
||||
}
|
||||
|
||||
/// Récupère un utilisateur par son identifiant.
|
||||
/// Les erreurs et les succès sont logués pour un suivi complet.
|
||||
///
|
||||
/// [id] : L'identifiant unique de l'utilisateur.
|
||||
///
|
||||
/// Retourne un [UserModel] si l'utilisateur est trouvé.
|
||||
/// Lève une [UserNotFoundException] si l'utilisateur n'existe pas.
|
||||
/// Lève une [ServerException] pour d'autres erreurs serveur.
|
||||
Future<UserModel> getUser(String id) async {
|
||||
print("[LOG] Tentative de récupération de l'utilisateur avec l'ID : $id");
|
||||
final uri = Uri.parse(Urls.getUserByIdWithId(id));
|
||||
final response = await _performRequest('GET', uri);
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return UserModel.fromJson(jsonResponse);
|
||||
}
|
||||
|
||||
try {
|
||||
// Envoi de la requête GET pour obtenir l'utilisateur par son ID
|
||||
final response = await client.get(Uri.parse('${Urls.baseUrl}/users/$id'));
|
||||
print("[LOG] Réponse du serveur pour getUser : ${response.statusCode} - ${response.body}");
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
// Utilisateur trouvé, retour de l'objet UserModel
|
||||
return UserModel.fromJson(json.decode(response.body));
|
||||
}
|
||||
// Gestion du cas où l'utilisateur n'est pas trouvé
|
||||
else if (response.statusCode == 404) {
|
||||
print("[ERROR] Utilisateur non trouvé.");
|
||||
throw UserNotFoundException();
|
||||
}
|
||||
// Gestion des autres erreurs serveur
|
||||
else {
|
||||
print("[ERROR] Erreur du serveur lors de la récupération de l'utilisateur.");
|
||||
throw ServerException();
|
||||
}
|
||||
} catch (e) {
|
||||
print("[ERROR] Erreur lors de la récupération de l'utilisateur : $e");
|
||||
throw Exception("Erreur lors de la récupération de l'utilisateur : $e");
|
||||
/// Recherche un utilisateur par email.
|
||||
///
|
||||
/// [email] : L'email de l'utilisateur à rechercher.
|
||||
///
|
||||
/// Retourne un [UserModel] si l'utilisateur est trouvé.
|
||||
/// Lève une [UserNotFoundException] si l'utilisateur n'existe pas.
|
||||
/// Lève une [ServerException] pour d'autres erreurs serveur.
|
||||
Future<UserModel> searchUserByEmail(String email) async {
|
||||
final uri = Uri.parse(Urls.searchUserByEmail(email));
|
||||
final response = await _performRequest('GET', uri);
|
||||
|
||||
if (response.statusCode == 404) {
|
||||
throw UserNotFoundException('Utilisateur non trouvé avec l\'email : $email');
|
||||
}
|
||||
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return UserModel.fromJson(jsonResponse);
|
||||
}
|
||||
|
||||
/// Crée un nouvel utilisateur dans le backend.
|
||||
/// Toutes les actions, succès ou erreurs sont logués pour un suivi précis.
|
||||
///
|
||||
/// [user] : Le [UserModel] à créer.
|
||||
///
|
||||
/// Retourne le [UserModel] créé avec les données du serveur.
|
||||
/// Lève une [ConflictException] si un utilisateur avec le même email existe déjà.
|
||||
/// Lève une [ServerException] pour d'autres erreurs serveur.
|
||||
Future<UserModel> createUser(UserModel user) async {
|
||||
print("[LOG] Création d'un nouvel utilisateur : ${user.toJson()}");
|
||||
final uri = Uri.parse(Urls.createUser);
|
||||
final headers = {'Content-Type': 'application/json'};
|
||||
final body = jsonEncode(user.toJson());
|
||||
|
||||
try {
|
||||
// Envoi de la requête POST pour créer un nouvel utilisateur
|
||||
final response = await client.post(
|
||||
Uri.parse('${Urls.baseUrl}/users'),
|
||||
headers: {'Content-Type': 'application/json'},
|
||||
body: jsonEncode(user.toJson()), // Conversion du modèle utilisateur en JSON
|
||||
);
|
||||
print("[LOG] Réponse du serveur pour createUser : ${response.statusCode} - ${response.body}");
|
||||
|
||||
if (response.statusCode == 201) {
|
||||
// Utilisateur créé avec succès
|
||||
return UserModel.fromJson(json.decode(response.body));
|
||||
}
|
||||
// Gestion des conflits (ex: utilisateur déjà existant)
|
||||
else if (response.statusCode == 409) {
|
||||
print("[ERROR] Conflit lors de la création de l'utilisateur : Utilisateur déjà existant.");
|
||||
throw ConflictException();
|
||||
}
|
||||
// Gestion des autres erreurs serveur
|
||||
else {
|
||||
print("[ERROR] Erreur du serveur lors de la création de l'utilisateur.");
|
||||
throw ServerException();
|
||||
}
|
||||
} catch (e) {
|
||||
print("[ERROR] Erreur lors de la création de l'utilisateur : $e");
|
||||
throw Exception("Erreur lors de la création de l'utilisateur : $e");
|
||||
}
|
||||
final response = await _performRequest('POST', uri, headers: headers, body: body);
|
||||
final jsonResponse = _parseJsonResponse(response, [201]) as Map<String, dynamic>;
|
||||
return UserModel.fromJson(jsonResponse);
|
||||
}
|
||||
|
||||
/// Met à jour un utilisateur existant.
|
||||
/// Chaque étape est loguée pour faciliter le débogage.
|
||||
///
|
||||
/// [user] : Le [UserModel] avec les données mises à jour.
|
||||
///
|
||||
/// Retourne le [UserModel] mis à jour avec les données du serveur.
|
||||
/// Lève une [UserNotFoundException] si l'utilisateur n'existe pas.
|
||||
/// Lève une [ServerException] pour d'autres erreurs serveur.
|
||||
Future<UserModel> updateUser(UserModel user) async {
|
||||
print("[LOG] Mise à jour de l'utilisateur : ${user.toJson()}");
|
||||
final uri = Uri.parse(Urls.updateUserWithId(user.userId));
|
||||
final headers = {'Content-Type': 'application/json'};
|
||||
final body = jsonEncode(user.toJson());
|
||||
|
||||
try {
|
||||
// Envoi de la requête PUT pour mettre à jour un utilisateur
|
||||
final response = await client.put(
|
||||
Uri.parse('${Urls.baseUrl}/users/${user.userId}'),
|
||||
headers: {'Content-Type': 'application/json'},
|
||||
body: jsonEncode(user.toJson()), // Conversion du modèle utilisateur en JSON
|
||||
);
|
||||
print("[LOG] Réponse du serveur pour updateUser : ${response.statusCode} - ${response.body}");
|
||||
|
||||
if (response.statusCode == 200) {
|
||||
// Mise à jour réussie
|
||||
return UserModel.fromJson(json.decode(response.body));
|
||||
}
|
||||
// Gestion du cas où l'utilisateur n'est pas trouvé
|
||||
else if (response.statusCode == 404) {
|
||||
print("[ERROR] Utilisateur non trouvé.");
|
||||
throw UserNotFoundException();
|
||||
}
|
||||
// Gestion des autres erreurs serveur
|
||||
else {
|
||||
print("[ERROR] Erreur du serveur lors de la mise à jour de l'utilisateur.");
|
||||
throw ServerException();
|
||||
}
|
||||
} catch (e) {
|
||||
print("[ERROR] Erreur lors de la mise à jour de l'utilisateur : $e");
|
||||
throw Exception("Erreur lors de la mise à jour de l'utilisateur : $e");
|
||||
}
|
||||
final response = await _performRequest('PUT', uri, headers: headers, body: body);
|
||||
final jsonResponse = _parseJsonResponse(response, [200]) as Map<String, dynamic>;
|
||||
return UserModel.fromJson(jsonResponse);
|
||||
}
|
||||
|
||||
/// Supprime un utilisateur par son identifiant.
|
||||
/// Les erreurs et succès sont logués pour garantir un suivi complet.
|
||||
///
|
||||
/// [id] : L'identifiant unique de l'utilisateur à supprimer.
|
||||
///
|
||||
/// Ne retourne rien en cas de succès.
|
||||
/// Lève une [ServerException] pour d'autres erreurs serveur.
|
||||
Future<void> deleteUser(String id) async {
|
||||
print("[LOG] Tentative de suppression de l'utilisateur avec l'ID : $id");
|
||||
final uri = Uri.parse(Urls.deleteUserWithId(id));
|
||||
final response = await _performRequest('DELETE', uri);
|
||||
_parseJsonResponse(response, [204]); // 204 No Content
|
||||
}
|
||||
|
||||
try {
|
||||
// Envoi de la requête DELETE pour supprimer un utilisateur
|
||||
final response = await client.delete(Uri.parse('${Urls.baseUrl}/users/$id'));
|
||||
print("[LOG] Réponse du serveur pour deleteUser : ${response.statusCode} - ${response.body}");
|
||||
/// Demande la réinitialisation du mot de passe.
|
||||
///
|
||||
/// [email] : L'email de l'utilisateur qui souhaite réinitialiser son mot de passe.
|
||||
///
|
||||
/// Ne retourne rien en cas de succès.
|
||||
/// Lève une [UserNotFoundException] si l'utilisateur n'existe pas.
|
||||
/// Lève une [ServerException] pour d'autres erreurs serveur.
|
||||
///
|
||||
/// **Note:** Le backend actuel ne supporte pas encore cette fonctionnalité.
|
||||
/// Cette méthode est préparée pour une future implémentation.
|
||||
Future<void> requestPasswordReset(String email) async {
|
||||
// TODO: Implémenter quand l'endpoint sera disponible dans le backend
|
||||
// Le backend actuel a seulement /users/{id}/reset-password qui nécessite l'ID
|
||||
throw const ServerException(
|
||||
'La réinitialisation du mot de passe par email n\'est pas encore disponible. '
|
||||
'Contactez l\'administrateur.',
|
||||
);
|
||||
}
|
||||
|
||||
// Vérification du succès de la suppression
|
||||
if (response.statusCode == 204) {
|
||||
print("[LOG] Utilisateur supprimé avec succès.");
|
||||
}
|
||||
// Gestion des autres erreurs serveur
|
||||
else {
|
||||
print("[ERROR] Erreur du serveur lors de la suppression de l'utilisateur.");
|
||||
throw ServerException();
|
||||
}
|
||||
} catch (e) {
|
||||
print("[ERROR] Erreur lors de la suppression de l'utilisateur : $e");
|
||||
throw Exception("Erreur lors de la suppression de l'utilisateur : $e");
|
||||
}
|
||||
/// Réinitialise le mot de passe d'un utilisateur par son ID.
|
||||
///
|
||||
/// [userId] : L'ID de l'utilisateur.
|
||||
/// [newPassword] : Le nouveau mot de passe.
|
||||
///
|
||||
/// Ne retourne rien en cas de succès.
|
||||
/// Lève une [UserNotFoundException] si l'utilisateur n'existe pas.
|
||||
/// Lève une [ServerException] pour d'autres erreurs serveur.
|
||||
Future<void> resetPasswordById(String userId, String newPassword) async {
|
||||
final uri = Uri.parse('${Urls.getUserByIdWithId(userId)}/reset-password?newPassword=${Uri.encodeComponent(newPassword)}');
|
||||
final response = await _performRequest('PATCH', uri);
|
||||
_parseJsonResponse(response, [200, 204]);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user