first commit

unionflow-mobile-apps/lib/core/auth/services/auth_api_service.dart

@@ -0,0 +1,306 @@
+import 'dart:convert';
+import 'package:dio/dio.dart';
+import 'package:injectable/injectable.dart';
+import '../../../core/network/dio_client.dart';
+import '../models/login_request.dart';
+import '../models/login_response.dart';
+
+/// Service API pour l'authentification
+@singleton
+class AuthApiService {
+  final DioClient _dioClient;
+  late final Dio _dio;
+
+  AuthApiService(this._dioClient) {
+    _dio = _dioClient.dio;
+  }
+
+  /// Effectue la connexion utilisateur
+  Future<LoginResponse> login(LoginRequest request) async {
+    try {
+      final response = await _dio.post(
+        '/api/auth/login',
+        data: request.toJson(),
+        options: Options(
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          // Désactiver l'interceptor d'auth pour cette requête
+          extra: {'skipAuth': true},
+        ),
+      );
+
+      if (response.statusCode == 200) {
+        return LoginResponse.fromJson(response.data);
+      } else {
+        throw AuthApiException(
+          'Erreur de connexion',
+          statusCode: response.statusCode,
+          response: response.data,
+        );
+      }
+    } on DioException catch (e) {
+      throw _handleDioException(e);
+    } catch (e) {
+      throw AuthApiException('Erreur inattendue lors de la connexion: $e');
+    }
+  }
+
+  /// Rafraîchit le token d'accès
+  Future<LoginResponse> refreshToken(String refreshToken) async {
+    try {
+      final response = await _dio.post(
+        '/api/auth/refresh',
+        data: {'refreshToken': refreshToken},
+        options: Options(
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          extra: {'skipAuth': true},
+        ),
+      );
+
+      if (response.statusCode == 200) {
+        return LoginResponse.fromJson(response.data);
+      } else {
+        throw AuthApiException(
+          'Erreur lors du rafraîchissement du token',
+          statusCode: response.statusCode,
+          response: response.data,
+        );
+      }
+    } on DioException catch (e) {
+      throw _handleDioException(e);
+    } catch (e) {
+      throw AuthApiException('Erreur inattendue lors du rafraîchissement: $e');
+    }
+  }
+
+  /// Effectue la déconnexion
+  Future<void> logout(String? refreshToken) async {
+    try {
+      await _dio.post(
+        '/api/auth/logout',
+        data: refreshToken != null ? {'refreshToken': refreshToken} : {},
+        options: Options(
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          extra: {'skipAuth': true},
+        ),
+      );
+    } on DioException catch (e) {
+      // Ignorer les erreurs de déconnexion côté serveur
+      // La déconnexion locale est plus importante
+      print('Erreur lors de la déconnexion serveur: ${e.message}');
+    } catch (e) {
+      print('Erreur inattendue lors de la déconnexion: $e');
+    }
+  }
+
+  /// Valide un token côté serveur
+  Future<bool> validateToken(String accessToken) async {
+    try {
+      final response = await _dio.get(
+        '/api/auth/validate',
+        options: Options(
+          headers: {
+            'Authorization': 'Bearer $accessToken',
+            'Content-Type': 'application/json',
+          },
+          extra: {'skipAuth': true},
+        ),
+      );
+
+      return response.statusCode == 200;
+    } on DioException catch (e) {
+      if (e.response?.statusCode == 401) {
+        return false;
+      }
+      throw _handleDioException(e);
+    } catch (e) {
+      throw AuthApiException('Erreur lors de la validation du token: $e');
+    }
+  }
+
+  /// Récupère les informations de l'API d'authentification
+  Future<Map<String, dynamic>> getAuthInfo() async {
+    try {
+      final response = await _dio.get(
+        '/api/auth/info',
+        options: Options(
+          extra: {'skipAuth': true},
+        ),
+      );
+
+      if (response.statusCode == 200) {
+        return response.data as Map<String, dynamic>;
+      } else {
+        throw AuthApiException(
+          'Erreur lors de la récupération des informations',
+          statusCode: response.statusCode,
+        );
+      }
+    } on DioException catch (e) {
+      throw _handleDioException(e);
+    } catch (e) {
+      throw AuthApiException('Erreur inattendue: $e');
+    }
+  }
+
+  /// Gestion centralisée des erreurs Dio
+  AuthApiException _handleDioException(DioException e) {
+    switch (e.type) {
+      case DioExceptionType.connectionTimeout:
+      case DioExceptionType.sendTimeout:
+      case DioExceptionType.receiveTimeout:
+        return AuthApiException(
+          'Délai d\'attente dépassé. Vérifiez votre connexion internet.',
+          type: AuthErrorType.timeout,
+        );
+
+      case DioExceptionType.connectionError:
+        return AuthApiException(
+          'Impossible de se connecter au serveur. Vérifiez votre connexion internet.',
+          type: AuthErrorType.network,
+        );
+
+      case DioExceptionType.badResponse:
+        final statusCode = e.response?.statusCode;
+        final data = e.response?.data;
+
+        switch (statusCode) {
+          case 400:
+            return AuthApiException(
+              _extractErrorMessage(data) ?? 'Données de requête invalides',
+              statusCode: statusCode,
+              type: AuthErrorType.validation,
+              response: data,
+            );
+
+          case 401:
+            return AuthApiException(
+              _extractErrorMessage(data) ?? 'Identifiants invalides',
+              statusCode: statusCode,
+              type: AuthErrorType.unauthorized,
+              response: data,
+            );
+
+          case 403:
+            return AuthApiException(
+              _extractErrorMessage(data) ?? 'Accès interdit',
+              statusCode: statusCode,
+              type: AuthErrorType.forbidden,
+              response: data,
+            );
+
+          case 429:
+            return AuthApiException(
+              'Trop de tentatives. Veuillez réessayer plus tard.',
+              statusCode: statusCode,
+              type: AuthErrorType.rateLimited,
+              response: data,
+            );
+
+          case 500:
+          case 502:
+          case 503:
+          case 504:
+            return AuthApiException(
+              'Erreur serveur temporaire. Veuillez réessayer.',
+              statusCode: statusCode,
+              type: AuthErrorType.server,
+              response: data,
+            );
+
+          default:
+            return AuthApiException(
+              _extractErrorMessage(data) ?? 'Erreur serveur inconnue',
+              statusCode: statusCode,
+              response: data,
+            );
+        }
+
+      case DioExceptionType.cancel:
+        return AuthApiException(
+          'Requête annulée',
+          type: AuthErrorType.cancelled,
+        );
+
+      default:
+        return AuthApiException(
+          'Erreur réseau: ${e.message}',
+          type: AuthErrorType.unknown,
+        );
+    }
+  }
+
+  /// Extrait le message d'erreur de la réponse
+  String? _extractErrorMessage(dynamic data) {
+    if (data == null) return null;
+
+    if (data is Map<String, dynamic>) {
+      return data['message'] ?? data['error'] ?? data['detail'];
+    }
+
+    if (data is String) {
+      try {
+        final json = jsonDecode(data) as Map<String, dynamic>;
+        return json['message'] ?? json['error'] ?? json['detail'];
+      } catch (_) {
+        return data;
+      }
+    }
+
+    return null;
+  }
+}
+
+/// Types d'erreurs d'authentification
+enum AuthErrorType {
+  validation,
+  unauthorized,
+  forbidden,
+  timeout,
+  network,
+  server,
+  rateLimited,
+  cancelled,
+  unknown,
+}
+
+/// Exception spécifique à l'API d'authentification
+class AuthApiException implements Exception {
+  final String message;
+  final int? statusCode;
+  final AuthErrorType type;
+  final dynamic response;
+
+  const AuthApiException(
+    this.message, {
+    this.statusCode,
+    this.type = AuthErrorType.unknown,
+    this.response,
+  });
+
+  bool get isNetworkError => 
+      type == AuthErrorType.network || 
+      type == AuthErrorType.timeout;
+
+  bool get isServerError => type == AuthErrorType.server;
+
+  bool get isClientError => 
+      type == AuthErrorType.validation ||
+      type == AuthErrorType.unauthorized ||
+      type == AuthErrorType.forbidden;
+
+  bool get isRetryable => 
+      isNetworkError || 
+      isServerError || 
+      type == AuthErrorType.rateLimited;
+
+  @override
+  String toString() {
+    return 'AuthApiException: $message ${statusCode != null ? '(Status: $statusCode)' : ''}';
+  }
+}

unionflow-mobile-apps/lib/core/auth/services/auth_service.dart

@@ -0,0 +1,318 @@
+import 'dart:async';
+import 'package:injectable/injectable.dart';
+import 'package:jwt_decoder/jwt_decoder.dart';
+import '../models/auth_state.dart';
+import '../models/login_request.dart';
+import '../models/login_response.dart';
+import '../models/user_info.dart';
+import '../storage/secure_token_storage.dart';
+import 'auth_api_service.dart';
+import '../../network/auth_interceptor.dart';
+import '../../network/dio_client.dart';
+
+/// Service principal d'authentification
+@singleton
+class AuthService {
+  final SecureTokenStorage _tokenStorage;
+  final AuthApiService _apiService;
+  final AuthInterceptor _authInterceptor;
+  final DioClient _dioClient;
+
+  // Stream controllers pour notifier les changements d'état
+  final _authStateController = StreamController<AuthState>.broadcast();
+  final _tokenRefreshController = StreamController<void>.broadcast();
+
+  // Timers pour la gestion automatique des tokens
+  Timer? _tokenRefreshTimer;
+  Timer? _sessionExpiryTimer;
+
+  // État actuel
+  AuthState _currentState = const AuthState.unknown();
+
+  AuthService(
+    this._tokenStorage,
+    this._apiService,
+    this._authInterceptor,
+    this._dioClient,
+  ) {
+    _initializeAuthInterceptor();
+  }
+
+  // Getters
+  Stream<AuthState> get authStateStream => _authStateController.stream;
+  AuthState get currentState => _currentState;
+  bool get isAuthenticated => _currentState.isAuthenticated;
+  UserInfo? get currentUser => _currentState.user;
+
+  /// Initialise l'interceptor d'authentification
+  void _initializeAuthInterceptor() {
+    _authInterceptor.setCallbacks(
+      onTokenRefreshNeeded: () => _refreshTokenSilently(),
+      onAuthenticationFailed: () => logout(),
+    );
+    _dioClient.addAuthInterceptor(_authInterceptor);
+  }
+
+  /// Initialise le service d'authentification
+  Future<void> initialize() async {
+    _updateState(const AuthState.checking());
+
+    try {
+      // Vérifier si des tokens existent
+      final hasTokens = await _tokenStorage.hasAuthData();
+      if (!hasTokens) {
+        _updateState(const AuthState.unauthenticated());
+        return;
+      }
+
+      // Récupérer les données d'authentification
+      final authData = await _tokenStorage.getAuthData();
+      if (authData == null) {
+        _updateState(const AuthState.unauthenticated());
+        return;
+      }
+
+      // Vérifier si les tokens sont expirés
+      if (authData.isRefreshTokenExpired) {
+        await _tokenStorage.clearAuthData();
+        _updateState(const AuthState.unauthenticated());
+        return;
+      }
+
+      // Si le token d'accès est expiré, essayer de le rafraîchir
+      if (authData.isAccessTokenExpired) {
+        await _refreshToken();
+        return;
+      }
+
+      // Valider le token côté serveur
+      final isValid = await _validateTokenWithServer(authData.accessToken);
+      if (!isValid) {
+        await _refreshToken();
+        return;
+      }
+
+      // Tout est OK, restaurer la session
+      _updateState(AuthState.authenticated(
+        user: authData.user,
+        accessToken: authData.accessToken,
+        refreshToken: authData.refreshToken,
+        expiresAt: authData.expiresAt,
+      ));
+
+      _scheduleTokenRefresh();
+      _scheduleSessionExpiry();
+
+    } catch (e) {
+      print('Erreur lors de l\'initialisation de l\'auth: $e');
+      await _tokenStorage.clearAuthData();
+      _updateState(AuthState.error('Erreur d\'initialisation: $e'));
+    }
+  }
+
+  /// Connecte un utilisateur
+  Future<void> login(LoginRequest request) async {
+    _updateState(_currentState.copyWith(isLoading: true));
+
+    try {
+      // Appel API de connexion
+      final response = await _apiService.login(request);
+
+      // Sauvegarder les tokens
+      await _tokenStorage.saveAuthData(response);
+
+      // Mettre à jour l'état
+      _updateState(AuthState.authenticated(
+        user: response.user,
+        accessToken: response.accessToken,
+        refreshToken: response.refreshToken,
+        expiresAt: response.expiresAt,
+      ));
+
+      // Programmer les rafraîchissements
+      _scheduleTokenRefresh();
+      _scheduleSessionExpiry();
+
+    } on AuthApiException catch (e) {
+      _updateState(AuthState.error(e.message));
+      rethrow;
+    } catch (e) {
+      final errorMessage = 'Erreur de connexion: $e';
+      _updateState(AuthState.error(errorMessage));
+      rethrow;
+    }
+  }
+
+  /// Déconnecte l'utilisateur
+  Future<void> logout() async {
+    try {
+      // Récupérer le refresh token pour l'invalider côté serveur
+      final refreshToken = await _tokenStorage.getRefreshToken();
+      
+      // Appel API de déconnexion (optionnel)
+      await _apiService.logout(refreshToken);
+    } catch (e) {
+      print('Erreur lors de la déconnexion serveur: $e');
+    }
+
+    // Nettoyage local (toujours fait)
+    await _tokenStorage.clearAuthData();
+    _cancelTimers();
+    _updateState(const AuthState.unauthenticated());
+  }
+
+  /// Rafraîchit le token d'accès
+  Future<void> _refreshToken() async {
+    try {
+      final refreshToken = await _tokenStorage.getRefreshToken();
+      if (refreshToken == null) {
+        throw Exception('Aucun refresh token disponible');
+      }
+
+      // Vérifier si le refresh token est expiré
+      final refreshExpiresAt = await _tokenStorage.getRefreshTokenExpirationDate();
+      if (refreshExpiresAt != null && DateTime.now().isAfter(refreshExpiresAt)) {
+        throw Exception('Refresh token expiré');
+      }
+
+      // Appel API de refresh
+      final response = await _apiService.refreshToken(refreshToken);
+
+      // Mettre à jour le stockage
+      await _tokenStorage.updateAccessToken(response.accessToken, response.expiresAt);
+
+      // Mettre à jour l'état
+      if (_currentState.isAuthenticated) {
+        _updateState(_currentState.copyWith(
+          accessToken: response.accessToken,
+          expiresAt: response.expiresAt,
+        ));
+      } else {
+        _updateState(AuthState.authenticated(
+          user: response.user,
+          accessToken: response.accessToken,
+          refreshToken: response.refreshToken,
+          expiresAt: response.expiresAt,
+        ));
+      }
+
+      // Reprogrammer les timers
+      _scheduleTokenRefresh();
+
+    } catch (e) {
+      print('Erreur lors du rafraîchissement du token: $e');
+      await logout();
+    }
+  }
+
+  /// Rafraîchit le token silencieusement (sans changer l'état de loading)
+  Future<void> _refreshTokenSilently() async {
+    try {
+      await _refreshToken();
+      _tokenRefreshController.add(null);
+    } catch (e) {
+      print('Erreur lors du rafraîchissement silencieux: $e');
+    }
+  }
+
+  /// Valide un token côté serveur
+  Future<bool> _validateTokenWithServer(String accessToken) async {
+    try {
+      return await _apiService.validateToken(accessToken);
+    } catch (e) {
+      print('Erreur lors de la validation du token: $e');
+      return false;
+    }
+  }
+
+  /// Programme le rafraîchissement automatique du token
+  void _scheduleTokenRefresh() {
+    _tokenRefreshTimer?.cancel();
+
+    if (!_currentState.isAuthenticated || _currentState.expiresAt == null) {
+      return;
+    }
+
+    // Rafraîchir 5 minutes avant l'expiration
+    final refreshTime = _currentState.expiresAt!.subtract(const Duration(minutes: 5));
+    final delay = refreshTime.difference(DateTime.now());
+
+    if (delay.isNegative) {
+      // Le token expire bientôt, rafraîchir immédiatement
+      _refreshTokenSilently();
+      return;
+    }
+
+    _tokenRefreshTimer = Timer(delay, () => _refreshTokenSilently());
+  }
+
+  /// Programme l'expiration de la session
+  void _scheduleSessionExpiry() {
+    _sessionExpiryTimer?.cancel();
+
+    if (!_currentState.isAuthenticated || _currentState.expiresAt == null) {
+      return;
+    }
+
+    final delay = _currentState.expiresAt!.difference(DateTime.now());
+    if (delay.isNegative) {
+      logout();
+      return;
+    }
+
+    _sessionExpiryTimer = Timer(delay, () {
+      _updateState(const AuthState.expired());
+    });
+  }
+
+  /// Annule tous les timers
+  void _cancelTimers() {
+    _tokenRefreshTimer?.cancel();
+    _sessionExpiryTimer?.cancel();
+    _tokenRefreshTimer = null;
+    _sessionExpiryTimer = null;
+  }
+
+  /// Met à jour l'état et notifie les listeners
+  void _updateState(AuthState newState) {
+    _currentState = newState;
+    _authStateController.add(newState);
+  }
+
+  /// Nettoie les ressources
+  void dispose() {
+    _cancelTimers();
+    _authStateController.close();
+    _tokenRefreshController.close();
+  }
+
+  /// Vérifie les permissions de l'utilisateur
+  bool hasRole(String role) {
+    return _currentState.user?.role == role;
+  }
+
+  /// Vérifie si l'utilisateur a un des rôles spécifiés
+  bool hasAnyRole(List<String> roles) {
+    final userRole = _currentState.user?.role;
+    return userRole != null && roles.contains(userRole);
+  }
+
+  /// Décode un token JWT (utilitaire)
+  Map<String, dynamic>? decodeToken(String token) {
+    try {
+      return JwtDecoder.decode(token);
+    } catch (e) {
+      print('Erreur lors du décodage du token: $e');
+      return null;
+    }
+  }
+
+  /// Vérifie si un token est expiré
+  bool isTokenExpired(String token) {
+    try {
+      return JwtDecoder.isExpired(token);
+    } catch (e) {
+      return true;
+    }
+  }
+}

unionflow-mobile-apps/lib/core/auth/services/temp_auth_service.dart

@@ -0,0 +1,70 @@
+import 'dart:async';
+import 'package:flutter/foundation.dart';
+import '../models/auth_state.dart';
+import '../models/login_request.dart';
+import '../models/user_info.dart';
+
+/// Service d'authentification temporaire pour test sans dépendances
+class TempAuthService {
+  final _authStateController = StreamController<AuthState>.broadcast();
+  AuthState _currentState = const AuthState.unknown();
+
+  Stream<AuthState> get authStateStream => _authStateController.stream;
+  AuthState get currentState => _currentState;
+  bool get isAuthenticated => _currentState.isAuthenticated;
+  UserInfo? get currentUser => _currentState.user;
+
+  Future<void> initialize() async {
+    _updateState(const AuthState.checking());
+    
+    // Simuler une vérification
+    await Future.delayed(const Duration(seconds: 2));
+    
+    _updateState(const AuthState.unauthenticated());
+  }
+
+  Future<void> login(LoginRequest request) async {
+    _updateState(_currentState.copyWith(isLoading: true));
+
+    try {
+      // Simulation d'appel API
+      await Future.delayed(const Duration(seconds: 1));
+
+      // Vérification simple pour la démo
+      if (request.email == 'admin@unionflow.dev' && request.password == 'admin123') {
+        final user = UserInfo(
+          id: '1',
+          email: request.email,
+          firstName: 'Admin',
+          lastName: 'UnionFlow',
+          role: 'admin',
+          isActive: true,
+        );
+
+        _updateState(AuthState.authenticated(
+          user: user,
+          accessToken: 'fake_access_token',
+          refreshToken: 'fake_refresh_token',
+          expiresAt: DateTime.now().add(const Duration(hours: 1)),
+        ));
+      } else {
+        throw Exception('Identifiants invalides');
+      }
+    } catch (e) {
+      _updateState(AuthState.error(e.toString()));
+    }
+  }
+
+  Future<void> logout() async {
+    _updateState(const AuthState.unauthenticated());
+  }
+
+  void _updateState(AuthState newState) {
+    _currentState = newState;
+    _authStateController.add(newState);
+  }
+
+  void dispose() {
+    _authStateController.close();
+  }
+}

unionflow-mobile-apps/lib/core/auth/services/ultra_simple_auth_service.dart

@@ -0,0 +1,86 @@
+import 'dart:async';
+import 'package:flutter/foundation.dart';
+import '../models/auth_state.dart';
+import '../models/login_request.dart';
+import '../models/user_info.dart';
+
+/// Service d'authentification ultra-simple sans aucune dépendance externe
+class UltraSimpleAuthService {
+  final _authStateController = StreamController<AuthState>.broadcast();
+  AuthState _currentState = const AuthState.unknown();
+
+  Stream<AuthState> get authStateStream => _authStateController.stream;
+  AuthState get currentState => _currentState;
+  bool get isAuthenticated => _currentState.isAuthenticated;
+  UserInfo? get currentUser => _currentState.user;
+
+  Future<void> initialize() async {
+    _updateState(const AuthState.checking());
+    
+    // Simuler une vérification
+    await Future.delayed(const Duration(seconds: 2));
+    
+    _updateState(const AuthState.unauthenticated());
+  }
+
+  Future<void> login(LoginRequest request) async {
+    _updateState(_currentState.copyWith(isLoading: true));
+
+    try {
+      // Simulation d'appel API
+      await Future.delayed(const Duration(seconds: 1));
+
+      // Vérification simple pour la démo
+      if (request.email == 'admin@unionflow.dev' && request.password == 'admin123') {
+        final user = UserInfo(
+          id: '1',
+          email: request.email,
+          firstName: 'Admin',
+          lastName: 'UnionFlow',
+          role: 'admin',
+          isActive: true,
+        );
+
+        _updateState(AuthState.authenticated(
+          user: user,
+          accessToken: 'fake_access_token_${DateTime.now().millisecondsSinceEpoch}',
+          refreshToken: 'fake_refresh_token_${DateTime.now().millisecondsSinceEpoch}',
+          expiresAt: DateTime.now().add(const Duration(hours: 1)),
+        ));
+      } else if (request.email == 'president@lions.org' && request.password == 'admin123') {
+        final user = UserInfo(
+          id: '2',
+          email: request.email,
+          firstName: 'Jean',
+          lastName: 'Dupont',
+          role: 'président',
+          isActive: true,
+        );
+
+        _updateState(AuthState.authenticated(
+          user: user,
+          accessToken: 'fake_access_token_${DateTime.now().millisecondsSinceEpoch}',
+          refreshToken: 'fake_refresh_token_${DateTime.now().millisecondsSinceEpoch}',
+          expiresAt: DateTime.now().add(const Duration(hours: 1)),
+        ));
+      } else {
+        throw Exception('Identifiants invalides');
+      }
+    } catch (e) {
+      _updateState(AuthState.error(e.toString()));
+    }
+  }
+
+  Future<void> logout() async {
+    _updateState(const AuthState.unauthenticated());
+  }
+
+  void _updateState(AuthState newState) {
+    _currentState = newState;
+    _authStateController.add(newState);
+  }
+
+  void dispose() {
+    _authStateController.close();
+  }
+}