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
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user