118 lines
3.5 KiB
Dart
118 lines
3.5 KiB
Dart
import '../../api/services/auth_service.dart';
|
|
import '../../features/auth/models/auth_token.dart';
|
|
import '../../features/auth/models/auth_credentials.dart';
|
|
import '../../data/models/user.dart';
|
|
import '../../security/secure_storage.dart';
|
|
|
|
class AuthRepository {
|
|
final AuthService _authService;
|
|
final SecureStorage _secureStorage;
|
|
|
|
static const _accessTokenKey = 'access_token';
|
|
static const _refreshTokenKey = 'refresh_token';
|
|
static const _tokenExpiryKey = 'token_expiry';
|
|
static const _userKey = 'user_data';
|
|
|
|
AuthRepository(this._authService, this._secureStorage);
|
|
|
|
Future<User> login(String username, String password) async {
|
|
// Create credentials and call service
|
|
final credentials = AuthCredentials(username: username, password: password);
|
|
final authToken = await _authService.login(credentials);
|
|
|
|
// Save token securely
|
|
await _saveAuthToken(authToken);
|
|
|
|
// Get and save user profile
|
|
final user = await _authService.getUserProfile();
|
|
await _saveUserData(user);
|
|
|
|
return user;
|
|
}
|
|
|
|
Future<bool> isLoggedIn() async {
|
|
final token = await _getAuthToken();
|
|
return token != null && !token.isExpired;
|
|
}
|
|
|
|
Future<void> logout() async {
|
|
final token = await _getAuthToken();
|
|
if (token != null) {
|
|
try {
|
|
await _authService.logout(token.refreshToken);
|
|
} finally {
|
|
// Clear stored data regardless of logout API success
|
|
await _clearAuthData();
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<User?> getCurrentUser() async {
|
|
final userJson = await _secureStorage.read(_userKey);
|
|
if (userJson != null) {
|
|
return User.fromJson(userJson);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
Future<String?> getAccessToken() async {
|
|
final token = await _getAuthToken();
|
|
if (token == null) return null;
|
|
|
|
// If token expired, try to refresh it
|
|
if (token.isExpired) {
|
|
final newToken = await _refreshToken(token.refreshToken);
|
|
if (newToken != null) {
|
|
return newToken.accessToken;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
return token.accessToken;
|
|
}
|
|
|
|
// Private helper methods
|
|
Future<void> _saveAuthToken(AuthToken token) async {
|
|
await _secureStorage.write(_accessTokenKey, token.accessToken);
|
|
await _secureStorage.write(_refreshTokenKey, token.refreshToken);
|
|
await _secureStorage.write(_tokenExpiryKey, token.expiresAt.toIso8601String());
|
|
}
|
|
|
|
Future<AuthToken?> _getAuthToken() async {
|
|
final accessToken = await _secureStorage.read(_accessTokenKey);
|
|
final refreshToken = await _secureStorage.read(_refreshTokenKey);
|
|
final expiryString = await _secureStorage.read(_tokenExpiryKey);
|
|
|
|
if (accessToken != null && refreshToken != null && expiryString != null) {
|
|
return AuthToken(
|
|
accessToken: accessToken,
|
|
refreshToken: refreshToken,
|
|
expiresAt: DateTime.parse(expiryString),
|
|
);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
Future<void> _saveUserData(User user) async {
|
|
await _secureStorage.write(_userKey, user);
|
|
}
|
|
|
|
Future<void> _clearAuthData() async {
|
|
await _secureStorage.delete(_accessTokenKey);
|
|
await _secureStorage.delete(_refreshTokenKey);
|
|
await _secureStorage.delete(_tokenExpiryKey);
|
|
await _secureStorage.delete(_userKey);
|
|
}
|
|
|
|
Future<AuthToken?> _refreshToken(String refreshToken) async {
|
|
try {
|
|
final newToken = await _authService.refreshToken(refreshToken);
|
|
await _saveAuthToken(newToken);
|
|
return newToken;
|
|
} catch (e) {
|
|
// If refresh fails, clear auth data
|
|
await _clearAuthData();
|
|
return null;
|
|
}
|
|
}
|
|
} |