first commit

unionflow-mobile-apps/lib/core/auth/bloc/auth_bloc.dart

@@ -0,0 +1,203 @@
+import 'dart:async';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:injectable/injectable.dart';
+import '../models/auth_state.dart';
+import '../services/auth_service.dart';
+import '../services/auth_api_service.dart';
+import 'auth_event.dart';
+
+/// BLoC pour gérer l'authentification
+@singleton
+class AuthBloc extends Bloc<AuthEvent, AuthState> {
+  final AuthService _authService;
+  late StreamSubscription<AuthState> _authStateSubscription;
+
+  AuthBloc(this._authService) : super(const AuthState.unknown()) {
+    // Écouter les changements d'état du service
+    _authStateSubscription = _authService.authStateStream.listen(
+      (authState) => add(AuthStateChanged(authState)),
+    );
+
+    // Gestionnaires d'événements
+    on<AuthInitializeRequested>(_onInitializeRequested);
+    on<AuthLoginRequested>(_onLoginRequested);
+    on<AuthLogoutRequested>(_onLogoutRequested);
+    on<AuthTokenRefreshRequested>(_onTokenRefreshRequested);
+    on<AuthSessionExpired>(_onSessionExpired);
+    on<AuthStatusCheckRequested>(_onStatusCheckRequested);
+    on<AuthErrorCleared>(_onErrorCleared);
+    on<AuthStateChanged>(_onStateChanged);
+  }
+
+  /// Initialisation de l'authentification
+  Future<void> _onInitializeRequested(
+    AuthInitializeRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    emit(const AuthState.checking());
+    
+    try {
+      await _authService.initialize();
+    } catch (e) {
+      emit(AuthState.error('Erreur d\'initialisation: $e'));
+    }
+  }
+
+  /// Gestion de la connexion
+  Future<void> _onLoginRequested(
+    AuthLoginRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    emit(state.copyWith(isLoading: true, errorMessage: null));
+
+    try {
+      await _authService.login(event.loginRequest);
+      // L'état sera mis à jour par le stream du service
+    } on AuthApiException catch (e) {
+      emit(state.copyWith(
+        isLoading: false,
+        errorMessage: e.message,
+      ));
+    } catch (e) {
+      emit(state.copyWith(
+        isLoading: false,
+        errorMessage: 'Erreur de connexion: $e',
+      ));
+    }
+  }
+
+  /// Gestion de la déconnexion
+  Future<void> _onLogoutRequested(
+    AuthLogoutRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    emit(state.copyWith(isLoading: true));
+
+    try {
+      await _authService.logout();
+      // L'état sera mis à jour par le stream du service
+    } catch (e) {
+      // Même en cas d'erreur, on considère que la déconnexion locale a réussi
+      emit(const AuthState.unauthenticated());
+    }
+  }
+
+  /// Gestion du rafraîchissement de token
+  Future<void> _onTokenRefreshRequested(
+    AuthTokenRefreshRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    // Le rafraîchissement est géré automatiquement par le service
+    // Cet événement peut être utilisé pour forcer un rafraîchissement manuel
+    try {
+      // Le service gère déjà le rafraîchissement automatique
+      // On peut ajouter ici une logique spécifique si nécessaire
+    } catch (e) {
+      emit(AuthState.error('Erreur lors du rafraîchissement: $e'));
+    }
+  }
+
+  /// Gestion de l'expiration de session
+  Future<void> _onSessionExpired(
+    AuthSessionExpired event,
+    Emitter<AuthState> emit,
+  ) async {
+    emit(const AuthState.expired());
+    
+    // Optionnel: essayer un rafraîchissement automatique
+    try {
+      await _authService.logout();
+    } catch (e) {
+      // Ignorer les erreurs de déconnexion lors de l'expiration
+    }
+  }
+
+  /// Vérification du statut d'authentification
+  Future<void> _onStatusCheckRequested(
+    AuthStatusCheckRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    // Utiliser l'état actuel du service
+    final currentServiceState = _authService.currentState;
+    if (currentServiceState != state) {
+      emit(currentServiceState);
+    }
+  }
+
+  /// Nettoyage des erreurs
+  void _onErrorCleared(
+    AuthErrorCleared event,
+    Emitter<AuthState> emit,
+  ) {
+    if (state.errorMessage != null) {
+      emit(state.copyWith(errorMessage: null));
+    }
+  }
+
+  /// Mise à jour depuis le service d'authentification
+  void _onStateChanged(
+    AuthStateChanged event,
+    Emitter<AuthState> emit,
+  ) {
+    final newState = event.authState as AuthState;
+    
+    // Émettre le nouvel état seulement s'il a changé
+    if (newState != state) {
+      emit(newState);
+    }
+  }
+
+  /// Vérifie si l'utilisateur est connecté
+  bool get isAuthenticated => state.isAuthenticated;
+
+  /// Récupère l'utilisateur actuel
+  get currentUser => state.user;
+
+  /// Vérifie si l'utilisateur a un rôle spécifique
+  bool hasRole(String role) {
+    return _authService.hasRole(role);
+  }
+
+  /// Vérifie si l'utilisateur a un des rôles spécifiés
+  bool hasAnyRole(List<String> roles) {
+    return _authService.hasAnyRole(roles);
+  }
+
+  /// Vérifie si la session expire bientôt
+  bool get isSessionExpiringSoon => state.isExpiringSoon;
+
+  /// Récupère le message d'erreur formaté
+  String? get errorMessage {
+    final error = state.errorMessage;
+    if (error == null) return null;
+
+    // Formatage des messages d'erreur pour l'utilisateur
+    if (error.contains('network') || error.contains('connexion')) {
+      return 'Problème de connexion. Vérifiez votre réseau.';
+    }
+    
+    if (error.contains('401') || error.contains('Identifiants')) {
+      return 'Email ou mot de passe incorrect.';
+    }
+    
+    if (error.contains('403')) {
+      return 'Accès non autorisé.';
+    }
+    
+    if (error.contains('timeout')) {
+      return 'Délai d\'attente dépassé. Réessayez.';
+    }
+    
+    if (error.contains('server') || error.contains('500')) {
+      return 'Erreur serveur temporaire. Réessayez plus tard.';
+    }
+
+    return error;
+  }
+
+  @override
+  Future<void> close() {
+    _authStateSubscription.cancel();
+    return super.close();
+  }
+}

unionflow-mobile-apps/lib/core/auth/bloc/auth_event.dart

@@ -0,0 +1,60 @@
+import 'package:equatable/equatable.dart';
+import '../models/login_request.dart';
+
+/// Événements d'authentification
+abstract class AuthEvent extends Equatable {
+  const AuthEvent();
+
+  @override
+  List<Object?> get props => [];
+}
+
+/// Initialiser l'authentification
+class AuthInitializeRequested extends AuthEvent {
+  const AuthInitializeRequested();
+}
+
+/// Demande de connexion
+class AuthLoginRequested extends AuthEvent {
+  final LoginRequest loginRequest;
+
+  const AuthLoginRequested(this.loginRequest);
+
+  @override
+  List<Object> get props => [loginRequest];
+}
+
+/// Demande de déconnexion
+class AuthLogoutRequested extends AuthEvent {
+  const AuthLogoutRequested();
+}
+
+/// Demande de rafraîchissement de token
+class AuthTokenRefreshRequested extends AuthEvent {
+  const AuthTokenRefreshRequested();
+}
+
+/// Session expirée
+class AuthSessionExpired extends AuthEvent {
+  const AuthSessionExpired();
+}
+
+/// Vérification de l'état d'authentification
+class AuthStatusCheckRequested extends AuthEvent {
+  const AuthStatusCheckRequested();
+}
+
+/// Réinitialisation de l'erreur
+class AuthErrorCleared extends AuthEvent {
+  const AuthErrorCleared();
+}
+
+/// Changement d'état depuis le service
+class AuthStateChanged extends AuthEvent {
+  final dynamic authState;
+
+  const AuthStateChanged(this.authState);
+
+  @override
+  List<Object?> get props => [authState];
+}

unionflow-mobile-apps/lib/core/auth/bloc/temp_auth_bloc.dart

@@ -0,0 +1,74 @@
+import 'dart:async';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import '../models/auth_state.dart';
+import '../services/temp_auth_service.dart';
+import 'auth_event.dart';
+
+/// BLoC temporaire pour test sans injection de dépendances
+class TempAuthBloc extends Bloc<AuthEvent, AuthState> {
+  final TempAuthService _authService;
+  late StreamSubscription<AuthState> _authStateSubscription;
+
+  TempAuthBloc(this._authService) : super(const AuthState.unknown()) {
+    _authStateSubscription = _authService.authStateStream.listen(
+      (authState) => add(AuthStateChanged(authState)),
+    );
+
+    on<AuthInitializeRequested>(_onInitializeRequested);
+    on<AuthLoginRequested>(_onLoginRequested);
+    on<AuthLogoutRequested>(_onLogoutRequested);
+    on<AuthErrorCleared>(_onErrorCleared);
+    on<AuthStateChanged>(_onStateChanged);
+  }
+
+  Future<void> _onInitializeRequested(
+    AuthInitializeRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    await _authService.initialize();
+  }
+
+  Future<void> _onLoginRequested(
+    AuthLoginRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    try {
+      await _authService.login(event.loginRequest);
+    } catch (e) {
+      emit(AuthState.error(e.toString()));
+    }
+  }
+
+  Future<void> _onLogoutRequested(
+    AuthLogoutRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    await _authService.logout();
+  }
+
+  void _onErrorCleared(
+    AuthErrorCleared event,
+    Emitter<AuthState> emit,
+  ) {
+    if (state.errorMessage != null) {
+      emit(state.copyWith(errorMessage: null));
+    }
+  }
+
+  void _onStateChanged(
+    AuthStateChanged event,
+    Emitter<AuthState> emit,
+  ) {
+    final newState = event.authState as AuthState;
+    if (newState != state) {
+      emit(newState);
+    }
+  }
+
+  @override
+  Future<void> close() {
+    _authStateSubscription.cancel();
+    _authService.dispose();
+    return super.close();
+  }
+}

unionflow-mobile-apps/lib/core/auth/models/auth_state.dart

@@ -0,0 +1,140 @@
+import 'package:equatable/equatable.dart';
+import 'user_info.dart';
+
+/// États d'authentification possibles
+enum AuthStatus {
+  unknown,      // État initial
+  checking,     // Vérification en cours
+  authenticated,// Utilisateur connecté
+  unauthenticated, // Utilisateur non connecté
+  expired,      // Session expirée
+  error,        // Erreur d'authentification
+}
+
+/// État d'authentification de l'application
+class AuthState extends Equatable {
+  final AuthStatus status;
+  final UserInfo? user;
+  final String? accessToken;
+  final String? refreshToken;
+  final DateTime? expiresAt;
+  final String? errorMessage;
+  final bool isLoading;
+
+  const AuthState({
+    this.status = AuthStatus.unknown,
+    this.user,
+    this.accessToken,
+    this.refreshToken,
+    this.expiresAt,
+    this.errorMessage,
+    this.isLoading = false,
+  });
+
+  /// État initial inconnu
+  const AuthState.unknown() : this(status: AuthStatus.unknown);
+
+  /// État de vérification
+  const AuthState.checking() : this(
+    status: AuthStatus.checking,
+    isLoading: true,
+  );
+
+  /// État authentifié
+  const AuthState.authenticated({
+    required UserInfo user,
+    required String accessToken,
+    required String refreshToken,
+    required DateTime expiresAt,
+  }) : this(
+    status: AuthStatus.authenticated,
+    user: user,
+    accessToken: accessToken,
+    refreshToken: refreshToken,
+    expiresAt: expiresAt,
+    isLoading: false,
+  );
+
+  /// État non authentifié
+  const AuthState.unauthenticated({String? errorMessage}) : this(
+    status: AuthStatus.unauthenticated,
+    errorMessage: errorMessage,
+    isLoading: false,
+  );
+
+  /// État de session expirée
+  const AuthState.expired() : this(
+    status: AuthStatus.expired,
+    isLoading: false,
+  );
+
+  /// État d'erreur
+  const AuthState.error(String errorMessage) : this(
+    status: AuthStatus.error,
+    errorMessage: errorMessage,
+    isLoading: false,
+  );
+
+  /// Vérifie si l'utilisateur est connecté
+  bool get isAuthenticated => status == AuthStatus.authenticated;
+
+  /// Vérifie si la session est valide
+  bool get isSessionValid {
+    if (!isAuthenticated || expiresAt == null) return false;
+    return DateTime.now().isBefore(expiresAt!);
+  }
+
+  /// Vérifie si la session expire bientôt
+  bool get isExpiringSoon {
+    if (!isAuthenticated || expiresAt == null) return false;
+    final threshold = DateTime.now().add(const Duration(minutes: 5));
+    return expiresAt!.isBefore(threshold);
+  }
+
+  /// Crée une copie avec des modifications
+  AuthState copyWith({
+    AuthStatus? status,
+    UserInfo? user,
+    String? accessToken,
+    String? refreshToken,
+    DateTime? expiresAt,
+    String? errorMessage,
+    bool? isLoading,
+  }) {
+    return AuthState(
+      status: status ?? this.status,
+      user: user ?? this.user,
+      accessToken: accessToken ?? this.accessToken,
+      refreshToken: refreshToken ?? this.refreshToken,
+      expiresAt: expiresAt ?? this.expiresAt,
+      errorMessage: errorMessage ?? this.errorMessage,
+      isLoading: isLoading ?? this.isLoading,
+    );
+  }
+
+  /// Crée une copie en effaçant les données sensibles
+  AuthState clearSensitiveData() {
+    return AuthState(
+      status: status,
+      user: user,
+      errorMessage: errorMessage,
+      isLoading: isLoading,
+    );
+  }
+
+  @override
+  List<Object?> get props => [
+        status,
+        user,
+        accessToken,
+        refreshToken,
+        expiresAt,
+        errorMessage,
+        isLoading,
+      ];
+
+  @override
+  String toString() {
+    return 'AuthState(status: $status, user: ${user?.email}, isLoading: $isLoading, error: $errorMessage)';
+  }
+}

unionflow-mobile-apps/lib/core/auth/models/login_request.dart

@@ -0,0 +1,50 @@
+import 'package:equatable/equatable.dart';
+
+/// Modèle de requête de connexion
+class LoginRequest extends Equatable {
+  final String email;
+  final String password;
+  final bool rememberMe;
+
+  const LoginRequest({
+    required this.email,
+    required this.password,
+    this.rememberMe = false,
+  });
+
+  Map<String, dynamic> toJson() {
+    return {
+      'email': email,
+      'password': password,
+      'rememberMe': rememberMe,
+    };
+  }
+
+  factory LoginRequest.fromJson(Map<String, dynamic> json) {
+    return LoginRequest(
+      email: json['email'] ?? '',
+      password: json['password'] ?? '',
+      rememberMe: json['rememberMe'] ?? false,
+    );
+  }
+
+  LoginRequest copyWith({
+    String? email,
+    String? password,
+    bool? rememberMe,
+  }) {
+    return LoginRequest(
+      email: email ?? this.email,
+      password: password ?? this.password,
+      rememberMe: rememberMe ?? this.rememberMe,
+    );
+  }
+
+  @override
+  List<Object?> get props => [email, password, rememberMe];
+
+  @override
+  String toString() {
+    return 'LoginRequest(email: $email, rememberMe: $rememberMe)';
+  }
+}

unionflow-mobile-apps/lib/core/auth/models/login_response.dart

@@ -0,0 +1,96 @@
+import 'package:equatable/equatable.dart';
+import 'user_info.dart';
+
+/// Modèle de réponse de connexion
+class LoginResponse extends Equatable {
+  final String accessToken;
+  final String refreshToken;
+  final String tokenType;
+  final DateTime expiresAt;
+  final DateTime refreshExpiresAt;
+  final UserInfo user;
+
+  const LoginResponse({
+    required this.accessToken,
+    required this.refreshToken,
+    required this.tokenType,
+    required this.expiresAt,
+    required this.refreshExpiresAt,
+    required this.user,
+  });
+
+  /// Vérifie si le token d'accès est expiré
+  bool get isAccessTokenExpired {
+    return DateTime.now().isAfter(expiresAt);
+  }
+
+  /// Vérifie si le refresh token est expiré
+  bool get isRefreshTokenExpired {
+    return DateTime.now().isAfter(refreshExpiresAt);
+  }
+
+  /// Vérifie si le token expire dans les prochaines minutes
+  bool isExpiringSoon({int minutes = 5}) {
+    final threshold = DateTime.now().add(Duration(minutes: minutes));
+    return expiresAt.isBefore(threshold);
+  }
+
+  factory LoginResponse.fromJson(Map<String, dynamic> json) {
+    return LoginResponse(
+      accessToken: json['accessToken'] ?? '',
+      refreshToken: json['refreshToken'] ?? '',
+      tokenType: json['tokenType'] ?? 'Bearer',
+      expiresAt: json['expiresAt'] != null
+          ? DateTime.parse(json['expiresAt'])
+          : DateTime.now().add(const Duration(minutes: 15)),
+      refreshExpiresAt: json['refreshExpiresAt'] != null
+          ? DateTime.parse(json['refreshExpiresAt'])
+          : DateTime.now().add(const Duration(days: 7)),
+      user: UserInfo.fromJson(json['user'] ?? {}),
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'accessToken': accessToken,
+      'refreshToken': refreshToken,
+      'tokenType': tokenType,
+      'expiresAt': expiresAt.toIso8601String(),
+      'refreshExpiresAt': refreshExpiresAt.toIso8601String(),
+      'user': user.toJson(),
+    };
+  }
+
+  LoginResponse copyWith({
+    String? accessToken,
+    String? refreshToken,
+    String? tokenType,
+    DateTime? expiresAt,
+    DateTime? refreshExpiresAt,
+    UserInfo? user,
+  }) {
+    return LoginResponse(
+      accessToken: accessToken ?? this.accessToken,
+      refreshToken: refreshToken ?? this.refreshToken,
+      tokenType: tokenType ?? this.tokenType,
+      expiresAt: expiresAt ?? this.expiresAt,
+      refreshExpiresAt: refreshExpiresAt ?? this.refreshExpiresAt,
+      user: user ?? this.user,
+    );
+  }
+
+  @override
+  List<Object?> get props => [
+        accessToken,
+        refreshToken,
+        tokenType,
+        expiresAt,
+        refreshExpiresAt,
+        user,
+      ];
+
+  @override
+  String toString() {
+    return 'LoginResponse(tokenType: $tokenType, user: ${user.email}, expiresAt: $expiresAt)';
+  }
+}

unionflow-mobile-apps/lib/core/auth/models/models.dart

@@ -0,0 +1,5 @@
+// Export all auth models
+export 'auth_state.dart';
+export 'login_request.dart';
+export 'login_response.dart';
+export 'user_info.dart';

unionflow-mobile-apps/lib/core/auth/models/user_info.dart

@@ -0,0 +1,90 @@
+import 'package:equatable/equatable.dart';
+
+/// Modèle des informations utilisateur
+class UserInfo extends Equatable {
+  final String id;
+  final String email;
+  final String firstName;
+  final String lastName;
+  final String role;
+  final String? profilePicture;
+  final bool isActive;
+
+  const UserInfo({
+    required this.id,
+    required this.email,
+    required this.firstName,
+    required this.lastName,
+    required this.role,
+    this.profilePicture,
+    required this.isActive,
+  });
+
+  String get fullName => '$firstName $lastName';
+
+  String get initials {
+    final f = firstName.isNotEmpty ? firstName[0] : '';
+    final l = lastName.isNotEmpty ? lastName[0] : '';
+    return '$f$l'.toUpperCase();
+  }
+
+  factory UserInfo.fromJson(Map<String, dynamic> json) {
+    return UserInfo(
+      id: json['id'] ?? '',
+      email: json['email'] ?? '',
+      firstName: json['firstName'] ?? '',
+      lastName: json['lastName'] ?? '',
+      role: json['role'] ?? 'membre',
+      profilePicture: json['profilePicture'],
+      isActive: json['isActive'] ?? true,
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'id': id,
+      'email': email,
+      'firstName': firstName,
+      'lastName': lastName,
+      'role': role,
+      'profilePicture': profilePicture,
+      'isActive': isActive,
+    };
+  }
+
+  UserInfo copyWith({
+    String? id,
+    String? email,
+    String? firstName,
+    String? lastName,
+    String? role,
+    String? profilePicture,
+    bool? isActive,
+  }) {
+    return UserInfo(
+      id: id ?? this.id,
+      email: email ?? this.email,
+      firstName: firstName ?? this.firstName,
+      lastName: lastName ?? this.lastName,
+      role: role ?? this.role,
+      profilePicture: profilePicture ?? this.profilePicture,
+      isActive: isActive ?? this.isActive,
+    );
+  }
+
+  @override
+  List<Object?> get props => [
+        id,
+        email,
+        firstName,
+        lastName,
+        role,
+        profilePicture,
+        isActive,
+      ];
+
+  @override
+  String toString() {
+    return 'UserInfo(id: $id, email: $email, fullName: $fullName, role: $role, isActive: $isActive)';
+  }
+}

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

unionflow-mobile-apps/lib/core/auth/storage/memory_token_storage.dart

@@ -0,0 +1,117 @@
+import 'dart:convert';
+import '../models/login_response.dart';
+import '../models/user_info.dart';
+
+/// Service de stockage en mémoire des tokens (temporaire pour contourner Java 21)
+class MemoryTokenStorage {
+  static final MemoryTokenStorage _instance = MemoryTokenStorage._internal();
+  factory MemoryTokenStorage() => _instance;
+  MemoryTokenStorage._internal();
+
+  // Stockage en mémoire
+  final Map<String, String> _storage = {};
+
+  static const String _accessTokenKey = 'access_token';
+  static const String _refreshTokenKey = 'refresh_token';
+  static const String _userInfoKey = 'user_info';
+  static const String _expiresAtKey = 'expires_at';
+  static const String _refreshExpiresAtKey = 'refresh_expires_at';
+
+  /// Sauvegarde les données d'authentification
+  Future<void> saveAuthData(LoginResponse loginResponse) async {
+    try {
+      _storage[_accessTokenKey] = loginResponse.accessToken;
+      _storage[_refreshTokenKey] = loginResponse.refreshToken;
+      _storage[_userInfoKey] = jsonEncode(loginResponse.user.toJson());
+      _storage[_expiresAtKey] = loginResponse.expiresAt.toIso8601String();
+      _storage[_refreshExpiresAtKey] = loginResponse.refreshExpiresAt.toIso8601String();
+    } catch (e) {
+      throw StorageException('Erreur lors de la sauvegarde des données d\'authentification: $e');
+    }
+  }
+
+  /// Récupère le token d'accès
+  Future<String?> getAccessToken() async {
+    return _storage[_accessTokenKey];
+  }
+
+  /// Récupère le refresh token
+  Future<String?> getRefreshToken() async {
+    return _storage[_refreshTokenKey];
+  }
+
+  /// Récupère les informations utilisateur
+  Future<UserInfo?> getUserInfo() async {
+    try {
+      final userJson = _storage[_userInfoKey];
+      if (userJson == null) return null;
+      
+      final userMap = jsonDecode(userJson) as Map<String, dynamic>;
+      return UserInfo.fromJson(userMap);
+    } catch (e) {
+      throw StorageException('Erreur lors de la récupération des informations utilisateur: $e');
+    }
+  }
+
+  /// Récupère la date d'expiration du token d'accès
+  Future<DateTime?> getTokenExpirationDate() async {
+    try {
+      final expiresAtString = _storage[_expiresAtKey];
+      if (expiresAtString == null) return null;
+      
+      return DateTime.parse(expiresAtString);
+    } catch (e) {
+      throw StorageException('Erreur lors de la récupération de la date d\'expiration: $e');
+    }
+  }
+
+  /// Récupère la date d'expiration du refresh token
+  Future<DateTime?> getRefreshTokenExpirationDate() async {
+    try {
+      final expiresAtString = _storage[_refreshExpiresAtKey];
+      if (expiresAtString == null) return null;
+      
+      return DateTime.parse(expiresAtString);
+    } catch (e) {
+      throw StorageException('Erreur lors de la récupération de la date d\'expiration du refresh token: $e');
+    }
+  }
+
+  /// Vérifie si l'utilisateur est authentifié
+  Future<bool> hasValidToken() async {
+    final token = await getAccessToken();
+    if (token == null) return false;
+    
+    final expirationDate = await getTokenExpirationDate();
+    if (expirationDate == null) return false;
+    
+    return DateTime.now().isBefore(expirationDate);
+  }
+
+  /// Efface toutes les données d'authentification
+  Future<void> clearAll() async {
+    _storage.clear();
+  }
+
+  /// Met à jour uniquement les tokens
+  Future<void> updateTokens({
+    required String accessToken,
+    required String refreshToken,
+    required DateTime expiresAt,
+    required DateTime refreshExpiresAt,
+  }) async {
+    _storage[_accessTokenKey] = accessToken;
+    _storage[_refreshTokenKey] = refreshToken;
+    _storage[_expiresAtKey] = expiresAt.toIso8601String();
+    _storage[_refreshExpiresAtKey] = refreshExpiresAt.toIso8601String();
+  }
+}
+
+/// Exception personnalisée pour les erreurs de stockage
+class StorageException implements Exception {
+  final String message;
+  StorageException(this.message);
+  
+  @override
+  String toString() => 'StorageException: $message';
+}

unionflow-mobile-apps/lib/core/auth/storage/secure_token_storage.dart

@@ -0,0 +1,246 @@
+import 'dart:convert';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:injectable/injectable.dart';
+import '../models/login_response.dart';
+import '../models/user_info.dart';
+
+/// Service de stockage sécurisé des tokens d'authentification
+@singleton
+class SecureTokenStorage {
+  static const String _accessTokenKey = 'access_token';
+  static const String _refreshTokenKey = 'refresh_token';
+  static const String _userInfoKey = 'user_info';
+  static const String _expiresAtKey = 'expires_at';
+  static const String _refreshExpiresAtKey = 'refresh_expires_at';
+  static const String _biometricEnabledKey = 'biometric_enabled';
+
+  // Utilise SharedPreferences temporairement pour Android
+  Future<SharedPreferences> get _prefs => SharedPreferences.getInstance();
+
+  /// Sauvegarde les données d'authentification
+  Future<void> saveAuthData(LoginResponse loginResponse) async {
+    try {
+      final prefs = await _prefs;
+      await Future.wait([
+        prefs.setString(_accessTokenKey, loginResponse.accessToken),
+        prefs.setString(_refreshTokenKey, loginResponse.refreshToken),
+        prefs.setString(_userInfoKey, jsonEncode(loginResponse.user.toJson())),
+        prefs.setString(_expiresAtKey, loginResponse.expiresAt.toIso8601String()),
+        prefs.setString(_refreshExpiresAtKey, loginResponse.refreshExpiresAt.toIso8601String()),
+      ]);
+    } catch (e) {
+      throw StorageException('Erreur lors de la sauvegarde des données d\'authentification: $e');
+    }
+  }
+
+  /// Récupère le token d'accès
+  Future<String?> getAccessToken() async {
+    try {
+      final prefs = await _prefs;
+      return prefs.getString(_accessTokenKey);
+    } catch (e) {
+      throw StorageException('Erreur lors de la récupération du token d\'accès: $e');
+    }
+  }
+
+  /// Récupère le refresh token
+  Future<String?> getRefreshToken() async {
+    try {
+      final prefs = await _prefs;
+      return prefs.getString(_refreshTokenKey);
+    } catch (e) {
+      throw StorageException('Erreur lors de la récupération du refresh token: $e');
+    }
+  }
+
+  /// Récupère les informations utilisateur
+  Future<UserInfo?> getUserInfo() async {
+    try {
+      final prefs = await _prefs;
+      final userJson = prefs.getString(_userInfoKey);
+      if (userJson == null) return null;
+      
+      final userMap = jsonDecode(userJson) as Map<String, dynamic>;
+      return UserInfo.fromJson(userMap);
+    } catch (e) {
+      throw StorageException('Erreur lors de la récupération des informations utilisateur: $e');
+    }
+  }
+
+  /// Récupère la date d'expiration du token d'accès
+  Future<DateTime?> getTokenExpirationDate() async {
+    try {
+      final prefs = await _prefs;
+      final expiresAtString = prefs.getString(_expiresAtKey);
+      if (expiresAtString == null) return null;
+      
+      return DateTime.parse(expiresAtString);
+    } catch (e) {
+      throw StorageException('Erreur lors de la récupération de la date d\'expiration: $e');
+    }
+  }
+
+  /// Récupère la date d'expiration du refresh token
+  Future<DateTime?> getRefreshTokenExpirationDate() async {
+    try {
+      final expiresAtString = await _storage.read(key: _refreshExpiresAtKey);
+      if (expiresAtString == null) return null;
+      
+      return DateTime.parse(expiresAtString);
+    } catch (e) {
+      throw StorageException('Erreur lors de la récupération de la date d\'expiration du refresh token: $e');
+    }
+  }
+
+  /// Récupère toutes les données d'authentification
+  Future<LoginResponse?> getAuthData() async {
+    try {
+      final results = await Future.wait([
+        getAccessToken(),
+        getRefreshToken(),
+        getUserInfo(),
+        getTokenExpirationDate(),
+        getRefreshTokenExpirationDate(),
+      ]);
+
+      final accessToken = results[0] as String?;
+      final refreshToken = results[1] as String?;
+      final userInfo = results[2] as UserInfo?;
+      final expiresAt = results[3] as DateTime?;
+      final refreshExpiresAt = results[4] as DateTime?;
+
+      if (accessToken == null || 
+          refreshToken == null || 
+          userInfo == null || 
+          expiresAt == null || 
+          refreshExpiresAt == null) {
+        return null;
+      }
+
+      return LoginResponse(
+        accessToken: accessToken,
+        refreshToken: refreshToken,
+        tokenType: 'Bearer',
+        expiresAt: expiresAt,
+        refreshExpiresAt: refreshExpiresAt,
+        user: userInfo,
+      );
+    } catch (e) {
+      throw StorageException('Erreur lors de la récupération des données d\'authentification: $e');
+    }
+  }
+
+  /// Met à jour le token d'accès
+  Future<void> updateAccessToken(String accessToken, DateTime expiresAt) async {
+    try {
+      await Future.wait([
+        _storage.write(key: _accessTokenKey, value: accessToken),
+        _storage.write(key: _expiresAtKey, value: expiresAt.toIso8601String()),
+      ]);
+    } catch (e) {
+      throw StorageException('Erreur lors de la mise à jour du token d\'accès: $e');
+    }
+  }
+
+  /// Vérifie si les données d'authentification existent
+  Future<bool> hasAuthData() async {
+    try {
+      final accessToken = await _storage.read(key: _accessTokenKey);
+      final refreshToken = await _storage.read(key: _refreshTokenKey);
+      return accessToken != null && refreshToken != null;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /// Vérifie si les tokens sont expirés
+  Future<bool> areTokensExpired() async {
+    try {
+      final expiresAt = await getTokenExpirationDate();
+      final refreshExpiresAt = await getRefreshTokenExpirationDate();
+      
+      if (expiresAt == null || refreshExpiresAt == null) return true;
+      
+      final now = DateTime.now();
+      return refreshExpiresAt.isBefore(now);
+    } catch (e) {
+      return true;
+    }
+  }
+
+  /// Vérifie si le token d'accès expire bientôt
+  Future<bool> isAccessTokenExpiringSoon({int minutes = 5}) async {
+    try {
+      final expiresAt = await getTokenExpirationDate();
+      if (expiresAt == null) return true;
+      
+      final threshold = DateTime.now().add(Duration(minutes: minutes));
+      return expiresAt.isBefore(threshold);
+    } catch (e) {
+      return true;
+    }
+  }
+
+  /// Efface toutes les données d'authentification
+  Future<void> clearAuthData() async {
+    try {
+      await Future.wait([
+        _storage.delete(key: _accessTokenKey),
+        _storage.delete(key: _refreshTokenKey),
+        _storage.delete(key: _userInfoKey),
+        _storage.delete(key: _expiresAtKey),
+        _storage.delete(key: _refreshExpiresAtKey),
+      ]);
+    } catch (e) {
+      throw StorageException('Erreur lors de l\'effacement des données d\'authentification: $e');
+    }
+  }
+
+  /// Active/désactive l'authentification biométrique
+  Future<void> setBiometricEnabled(bool enabled) async {
+    try {
+      await _storage.write(key: _biometricEnabledKey, value: enabled.toString());
+    } catch (e) {
+      throw StorageException('Erreur lors de la configuration biométrique: $e');
+    }
+  }
+
+  /// Vérifie si l'authentification biométrique est activée
+  Future<bool> isBiometricEnabled() async {
+    try {
+      final enabled = await _storage.read(key: _biometricEnabledKey);
+      return enabled == 'true';
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /// Efface toutes les données stockées
+  Future<void> clearAll() async {
+    try {
+      await _storage.deleteAll();
+    } catch (e) {
+      throw StorageException('Erreur lors de l\'effacement de toutes les données: $e');
+    }
+  }
+
+  /// Vérifie si le stockage sécurisé est disponible
+  Future<bool> isAvailable() async {
+    try {
+      await _storage.containsKey(key: 'test');
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+}
+
+/// Exception liée au stockage
+class StorageException implements Exception {
+  final String message;
+  
+  const StorageException(this.message);
+  
+  @override
+  String toString() => 'StorageException: $message';
+}