TF-2177 Fix download attachment not working on web

Signed-off-by: dab246 <tdvu@linagora.com>
(cherry picked from commit 09cbfe5245c206670aa2191c151fd8f2ea48df3a)

lib/features/email/domain/state/download_attachment_for_web_state.dart

@@ -55,9 +55,11 @@ class DownloadAttachmentForWebSuccess extends UIState {
 
 class DownloadAttachmentForWebFailure extends FeatureFailure {
 
-  final DownloadTaskId taskId;
+  final DownloadTaskId? taskId;
 
-  DownloadAttachmentForWebFailure(this.taskId, dynamic exception) : super(exception: exception);
+  DownloadAttachmentForWebFailure({
+    this.taskId, dynamic exception
+  }) : super(exception: exception);
 
   @override
   List<Object?> get props => [taskId, ...super.props];

lib/features/email/domain/usecases/download_attachment_for_web_interactor.dart

@@ -45,39 +45,38 @@ class DownloadAttachmentForWebInteractor {
 
       if (currentAccount.authenticationType == AuthenticationType.oidc) {
         final tokenOidc = await _authenticationOIDCRepository.getStoredTokenOIDC(currentAccount.id);
-        accountRequest = AccountRequest(
+        accountRequest = AccountRequest.withOidc(token: tokenOidc.toToken());
-            token: tokenOidc.toToken(),
-            authenticationType: AuthenticationType.oidc);
       } else {
         final authenticationInfoCache = await credentialRepository.getAuthenticationInfoStored();
-        if (authenticationInfoCache != null) {
+        accountRequest = AccountRequest.withBasic(
-          accountRequest = AccountRequest(
+          userName: UserName(authenticationInfoCache.username),
-              userName: UserName(authenticationInfoCache.username),
+          password: Password(authenticationInfoCache.password),
-              password: Password(authenticationInfoCache.password),
+        );
-              authenticationType: AuthenticationType.basic);
-        }
       }
 
-      if (accountRequest != null) {
+      final bytesDownloaded = await emailRepository.downloadAttachmentForWeb(
-        final bytesDownloaded = await emailRepository.downloadAttachmentForWeb(
+        taskId,
-            taskId,
+        attachment,
-            attachment,
+        accountId,
-            accountId,
+        baseDownloadUrl,
-            baseDownloadUrl,
+        accountRequest,
-            accountRequest,
+        onReceiveController
-            onReceiveController);
+      );
 
-        yield Right<Failure, Success>(DownloadAttachmentForWebSuccess(
+      yield Right<Failure, Success>(
-            taskId,
+        DownloadAttachmentForWebSuccess(
-            attachment,
-            bytesDownloaded));
-      } else {
-        yield Left<Failure, Success>(DownloadAttachmentForWebFailure(taskId, null));
-      }
-    } catch (exception) {
-      yield Left<Failure, Success>(DownloadAttachmentForWebFailure(
           taskId,
-          exception));
+          attachment,
+          bytesDownloaded
+        )
+      );
+    } catch (exception) {
+      yield Left<Failure, Success>(
+        DownloadAttachmentForWebFailure(
+          taskId: taskId,
+          exception: exception
+        )
+      );
     }
   }
 }

lib/features/email/domain/usecases/download_attachments_interactor.dart

@@ -46,32 +46,25 @@ class DownloadAttachmentsInteractor {
 
       if (currentAccount.authenticationType == AuthenticationType.oidc) {
         final tokenOidc = await _authenticationOIDCRepository.getStoredTokenOIDC(currentAccount.id);
-        accountRequest = AccountRequest(
+        accountRequest = AccountRequest.withOidc(token: tokenOidc.toToken());
-            token: tokenOidc.toToken(),
-            authenticationType: AuthenticationType.oidc);
       } else {
         final authenticationInfoCache = await credentialRepository.getAuthenticationInfoStored();
-        if (authenticationInfoCache != null) {
+        accountRequest = AccountRequest.withBasic(
-          accountRequest = AccountRequest(
+          userName: UserName(authenticationInfoCache.username),
-              userName: UserName(authenticationInfoCache.username),
+          password: Password(authenticationInfoCache.password),
-              password: Password(authenticationInfoCache.password),
+        );
-              authenticationType: AuthenticationType.basic);
-        }
       }
 
-      if (accountRequest != null) {
+      final taskIds = await emailRepository.downloadAttachments(
-        final taskIds = await emailRepository.downloadAttachments(
+        attachments,
-            attachments,
+        accountId,
-            accountId,
+        baseDownloadUrl,
-            baseDownloadUrl,
+        accountRequest
-            accountRequest);
+      );
 
-        yield Right<Failure, Success>(DownloadAttachmentsSuccess(taskIds));
+      yield Right<Failure, Success>(DownloadAttachmentsSuccess(taskIds));
-      } else {
-        yield Left<Failure, Success>(DownloadAttachmentsFailure(null));
-      }
     } catch (exception) {
-      log('DownloadAttachmentsInteractor::execute(): $exception');
+      logError('DownloadAttachmentsInteractor::execute(): $exception');
       if (exception is DownloadAttachmentHasTokenExpiredException &&
           exception.refreshToken.isNotEmpty) {
         yield* _retryDownloadAttachments(
@@ -101,9 +94,10 @@ class DownloadAttachmentsInteractor {
           oidcConfig.scopes,
           refreshToken);
 
+      await _accountRepository.deleteCurrentAccount(accountCurrent.id);
+
       await Future.wait([
         _authenticationOIDCRepository.persistTokenOIDC(newTokenOIDC),
-        _accountRepository.deleteCurrentAccount(accountCurrent.id),
         _accountRepository.setCurrentAccount(PersonalAccount(
           newTokenOIDC.tokenIdHash,
           AuthenticationType.oidc,
@@ -117,9 +111,7 @@ class DownloadAttachmentsInteractor {
           newToken: newTokenOIDC.toToken(),
           newConfig: oidcConfig);
 
-      final accountRequest = AccountRequest(
+      final accountRequest = AccountRequest.withOidc(token: newTokenOIDC.toToken());
-          token: newTokenOIDC.toToken(),
-          authenticationType: AuthenticationType.oidc);
 
       final taskIds = await emailRepository.downloadAttachments(
           attachments,

lib/features/email/domain/usecases/export_attachment_interactor.dart

@@ -38,31 +38,24 @@ class ExportAttachmentInteractor {
 
       if (currentAccount.authenticationType == AuthenticationType.oidc) {
         final tokenOidc = await _authenticationOIDCRepository.getStoredTokenOIDC(currentAccount.id);
-        accountRequest = AccountRequest(
+        accountRequest = AccountRequest.withOidc(token: tokenOidc.toToken());
-            token: tokenOidc.toToken(),
-            authenticationType: AuthenticationType.oidc);
       } else {
         final authenticationInfoCache = await credentialRepository.getAuthenticationInfoStored();
-        if (authenticationInfoCache != null) {
+        accountRequest = AccountRequest.withBasic(
-          accountRequest = AccountRequest(
+          userName: UserName(authenticationInfoCache.username),
-              userName: UserName(authenticationInfoCache.username),
+          password: Password(authenticationInfoCache.password),
-              password: Password(authenticationInfoCache.password),
+        );
-              authenticationType: AuthenticationType.basic);
-        }
       }
 
-      if (accountRequest != null) {
+      final downloadedResponse = await emailRepository.exportAttachment(
-        final downloadedResponse = await emailRepository.exportAttachment(
+        attachment,
-            attachment,
+        accountId,
-            accountId,
+        baseDownloadUrl,
-            baseDownloadUrl,
+        accountRequest,
-            accountRequest,
+        cancelToken
-            cancelToken);
+      );
 
-        yield Right<Failure, Success>(ExportAttachmentSuccess(downloadedResponse));
+      yield Right<Failure, Success>(ExportAttachmentSuccess(downloadedResponse));
-      } else {
-        yield Left<Failure, Success>(ExportAttachmentFailure(null));
-      }
     } catch (exception) {
       log('ExportAttachmentInteractor::execute(): exception: $exception');
       yield Left<Failure, Success>(ExportAttachmentFailure(exception));

lib/features/email/presentation/controller/single_email_controller.dart

@@ -74,6 +74,7 @@ import 'package:tmail_ui_user/features/manage_account/domain/usecases/create_new
 import 'package:tmail_ui_user/features/manage_account/domain/usecases/get_all_identities_interactor.dart';
 import 'package:tmail_ui_user/features/manage_account/presentation/extensions/datetime_extension.dart';
 import 'package:tmail_ui_user/features/rules_filter_creator/presentation/model/rules_filter_creator_arguments.dart';
+import 'package:tmail_ui_user/features/session/data/exceptions/session_exceptions.dart';
 import 'package:tmail_ui_user/features/thread/domain/constants/thread_constants.dart';
 import 'package:tmail_ui_user/features/thread/presentation/model/delete_action_type.dart';
 import 'package:tmail_ui_user/main/error/capability_validator.dart';
@@ -698,8 +699,9 @@ class SingleEmailController extends BaseController with AppLoaderMixin {
 
   void _downloadAttachmentForWebAction(BuildContext context, Attachment attachment) async {
     final accountId = mailboxDashBoardController.accountId.value;
-    if (accountId != null && mailboxDashBoardController.sessionCurrent != null) {
+    final session = mailboxDashBoardController.sessionCurrent;
-      final baseDownloadUrl = mailboxDashBoardController.sessionCurrent!.getDownloadUrl(jmapUrl: _dynamicUrlInterceptors.jmapUrl);
+    if (accountId != null && session != null) {
+      final baseDownloadUrl = session.getDownloadUrl(jmapUrl: _dynamicUrlInterceptors.jmapUrl);
       final generateTaskId = DownloadTaskId(_uuid.v4());
       consumeState(_downloadAttachmentForWebInteractor.execute(
           generateTaskId,
@@ -707,6 +709,10 @@ class SingleEmailController extends BaseController with AppLoaderMixin {
           accountId,
           baseDownloadUrl,
           _downloadProgressStateController));
+    } else {
+      consumeState(Stream.value(
+        Left(DownloadAttachmentForWebFailure(exception: NotFoundSessionException()))
+      ));
     }
   }
 
@@ -721,7 +727,9 @@ class SingleEmailController extends BaseController with AppLoaderMixin {
 
   void _downloadAttachmentForWebFailureAction(DownloadAttachmentForWebFailure failure) {
     log('SingleEmailController::_downloadAttachmentForWebFailureAction(): $failure');
-    mailboxDashBoardController.deleteDownloadTask(failure.taskId);
+    if (failure.taskId != null) {
+      mailboxDashBoardController.deleteDownloadTask(failure.taskId!);
+    }
 
     if (currentOverlayContext != null && currentContext != null) {
       _appToast.showToastErrorMessage(

lib/features/login/data/datasource_impl/hive_account_datasource_impl.dart

@@ -13,21 +13,21 @@ class HiveAccountDatasourceImpl extends AccountDatasource {
   @override
   Future<PersonalAccount> getCurrentAccount() {
     return Future.sync(() async {
-      return await _accountCacheManager.getSelectedAccount();
+      return await _accountCacheManager.getCurrentAccount();
     }).catchError(_exceptionThrower.throwException);
   }
 
   @override
   Future<void> setCurrentAccount(PersonalAccount newCurrentAccount) {
     return Future.sync(() async {
-      return await _accountCacheManager.setSelectedAccount(newCurrentAccount);
+      return await _accountCacheManager.setCurrentAccount(newCurrentAccount);
     }).catchError(_exceptionThrower.throwException);
   }
 
   @override
   Future<void> deleteCurrentAccount(String accountId) {
     return Future.sync(() async {
-      return await _accountCacheManager.deleteSelectedAccount(accountId);
+      return await _accountCacheManager.deleteCurrentAccount(accountId);
     }).catchError(_exceptionThrower.throwException);
   }
 }

lib/features/login/data/local/account_cache_manager.dart

@@ -1,3 +1,4 @@
+import 'package:collection/collection.dart';
 import 'package:core/utils/app_logger.dart';
 import 'package:model/account/personal_account.dart';
 import 'package:tmail_ui_user/features/caching/clients/account_cache_client.dart';
@@ -10,24 +11,29 @@ class AccountCacheManager {
 
   AccountCacheManager(this._accountCacheClient);
 
-  Future<PersonalAccount> getSelectedAccount() async {
+  Future<PersonalAccount> getCurrentAccount() async {
-    try {
+    final allAccounts = await _accountCacheClient.getAll();
-      final allAccounts = await _accountCacheClient.getAll();
+    log('AccountCacheManager::getCurrentAccount::allAccounts(): $allAccounts');
-      return allAccounts.firstWhere((account) => account.isSelected)
+    final accountCache = allAccounts.firstWhereOrNull((account) => account.isSelected);
-          .toAccount();
+    log('AccountCacheManager::getCurrentAccount::accountCache(): $accountCache');
-    } catch (e) {
+    if (accountCache != null) {
-      logError('AccountCacheManager::getSelectedAccount(): $e');
+      return accountCache.toAccount();
+    } else {
       throw NotFoundAuthenticatedAccountException();
     }
   }
 
-  Future<void> setSelectedAccount(PersonalAccount account) {
+  Future<void> setCurrentAccount(PersonalAccount account) async {
-    log('AccountCacheManager::setSelectedAccount(): $_accountCacheClient');
+    log('AccountCacheManager::setCurrentAccount(): $account');
+    final accountCacheExist = await _accountCacheClient.isExistTable();
+    if (accountCacheExist) {
+      await _accountCacheClient.clearAllData();
+    }
     return _accountCacheClient.insertItem(account.id, account.toCache());
   }
 
-  Future<void> deleteSelectedAccount(String accountId) {
+  Future<void> deleteCurrentAccount(String hashId) {
-    log('AccountCacheManager::deleteSelectedAccount(): $accountId');
+    log('AccountCacheManager::deleteCurrentAccount(): $hashId');
-    return _accountCacheClient.deleteItem(accountId);
+    return _accountCacheClient.deleteItem(hashId);
   }
 }

lib/features/login/data/local/authentication_info_cache_manager.dart

@@ -1,5 +1,6 @@
 import 'package:tmail_ui_user/features/caching/clients/authentication_info_cache_client.dart';
 import 'package:tmail_ui_user/features/login/data/model/authentication_info_cache.dart';
+import 'package:tmail_ui_user/features/login/domain/exceptions/authentication_exception.dart';
 
 class AuthenticationInfoCacheManager {
   final AuthenticationInfoCacheClient _authenticationInfoCacheClient;
@@ -12,8 +13,13 @@ class AuthenticationInfoCacheManager {
         authenticationInfoCache);
   }
 
-  Future<AuthenticationInfoCache?> getAuthenticationInfoStored() {
+  Future<AuthenticationInfoCache> getAuthenticationInfoStored() async {
-    return _authenticationInfoCacheClient.getItem(AuthenticationInfoCache.keyCacheValue);
+    final authenticationInfoCache = await _authenticationInfoCacheClient.getItem(AuthenticationInfoCache.keyCacheValue);
+    if (authenticationInfoCache != null) {
+      return authenticationInfoCache;
+    } else {
+      throw NotFoundAuthenticationInfoCache();
+    }
   }
 
   Future<void> removeAuthenticationInfo() {

lib/features/login/data/network/config/authorization_interceptors.dart

@@ -56,8 +56,7 @@ class AuthorizationInterceptors extends QueuedInterceptorsWrapper {
 
   @override
   void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
-    log('AuthorizationInterceptors::onRequest():DATA: ${options.data}');
+    log('AuthorizationInterceptors::onRequest():data: ${options.data} | header: ${options.headers}');
-    log('AuthorizationInterceptors::onRequest():TOKEN_HASHCODE_CURRENT: ${_token?.token.hashCode}');
     switch(_authenticationType) {
       case AuthenticationType.basic:
         if (_authorization != null) {
@@ -78,8 +77,6 @@ class AuthorizationInterceptors extends QueuedInterceptorsWrapper {
   @override
   void onError(DioError err, ErrorInterceptorHandler handler) async {
     logError('AuthorizationInterceptors::onError(): $err');
-    logError('AuthorizationInterceptors::onError():TOKEN_HASHCODE_CURRENT: ${_token?.token.hashCode}');
-
     final requestOptions = err.requestOptions;
     final extraInRequest = requestOptions.extra;
     var retries = extraInRequest[RETRY_KEY] ?? 0;
@@ -94,20 +91,20 @@ class AuthorizationInterceptors extends QueuedInterceptorsWrapper {
         _token!.refreshToken
       );
 
-      final accountCurrent = await _accountCacheManager.getSelectedAccount();
+      final currentAccount = await _accountCacheManager.getCurrentAccount();
 
-      await _accountCacheManager.deleteSelectedAccount(_token!.tokenIdHash);
+      await _accountCacheManager.deleteCurrentAccount(currentAccount.id);
 
       await Future.wait([
         _tokenOidcCacheManager.persistOneTokenOidc(newToken),
-        _accountCacheManager.setSelectedAccount(
+        _accountCacheManager.setCurrentAccount(
           PersonalAccount(
             newToken.tokenIdHash,
             AuthenticationType.oidc,
             isSelected: true,
-            accountId: accountCurrent.accountId,
+            accountId: currentAccount.accountId,
-            apiUrl: accountCurrent.apiUrl,
+            apiUrl: currentAccount.apiUrl,
-            userName: accountCurrent.userName
+            userName: currentAccount.userName
           )
         )
       ]);

lib/features/login/data/repository/account_repository_impl.dart

@@ -1,4 +1,3 @@
-import 'package:core/utils/app_logger.dart';
 import 'package:model/account/personal_account.dart';
 import 'package:tmail_ui_user/features/login/data/datasource/account_datasource.dart';
 import 'package:tmail_ui_user/features/login/domain/repository/account_repository.dart';
@@ -16,12 +15,11 @@ class AccountRepositoryImpl extends AccountRepository {
 
   @override
   Future<void> setCurrentAccount(PersonalAccount newCurrentAccount) {
-    log('AccountRepositoryImpl::setCurrentAccount(): $newCurrentAccount');
     return _accountDatasource.setCurrentAccount(newCurrentAccount);
   }
 
   @override
-  Future<void> deleteCurrentAccount(String accountId) {
+  Future<void> deleteCurrentAccount(String hashId) {
-    return _accountDatasource.deleteCurrentAccount(accountId);
+    return _accountDatasource.deleteCurrentAccount(hashId);
   }
 }

lib/features/login/data/repository/credential_repository_impl.dart

@@ -36,7 +36,7 @@ class CredentialRepositoryImpl extends CredentialRepository {
   }
 
   @override
-  Future<AuthenticationInfoCache?> getAuthenticationInfoStored() {
+  Future<AuthenticationInfoCache> getAuthenticationInfoStored() {
     return _authenticationInfoCacheManager.getAuthenticationInfoStored();
   }
 

lib/features/login/domain/exceptions/authentication_exception.dart

@@ -52,3 +52,5 @@ class CanNotFoundUserName implements Exception {}
 class CanNotFoundPassword implements Exception {}
 
 class CanNotAuthenticationInfoOnWeb implements Exception {}
+
+class NotFoundAuthenticationInfoCache implements Exception {}

lib/features/login/domain/repository/account_repository.dart

@@ -6,5 +6,5 @@ abstract class AccountRepository {
 
   Future<void> setCurrentAccount(PersonalAccount newCurrentAccount);
 
-  Future<void> deleteCurrentAccount(String accountId);
+  Future<void> deleteCurrentAccount(String hashId);
 }

lib/features/login/domain/repository/credential_repository.dart

@@ -9,7 +9,7 @@ abstract class CredentialRepository {
 
   Future<void> storeAuthenticationInfo(AuthenticationInfoCache authenticationInfoCache);
 
-  Future<AuthenticationInfoCache?> getAuthenticationInfoStored();
+  Future<AuthenticationInfoCache> getAuthenticationInfoStored();
 
   Future<void> removeAuthenticationInfo();
 }

lib/features/session/data/datasource_impl/hive_session_datasource_impl.dart

@@ -33,7 +33,7 @@ class HiveSessionDataSourceImpl extends SessionDataSource {
       if (sessionHiveObj != null) {
         return sessionHiveObj.toSession();
       } else {
-        throw NotFoundSessionHiveObject();
+        throw NotFoundSessionException();
       }
     }).catchError(_exceptionThrower.throwException);
   }

lib/features/session/data/exceptions/session_exceptions.dart

@@ -1,2 +1,2 @@
 
-class NotFoundSessionHiveObject implements Exception {}
+class NotFoundSessionException implements Exception {}

model/lib/account/account_request.dart

@@ -19,6 +19,24 @@ class AccountRequest with EquatableMixin {
     this.authenticationType = AuthenticationType.none,
   });
 
+  factory AccountRequest.withOidc({required Token token}) {
+    return AccountRequest(
+      token: token,
+      authenticationType: AuthenticationType.oidc
+    );
+  }
+
+  factory AccountRequest.withBasic({
+    required UserName userName,
+    required Password password
+  }) {
+    return AccountRequest(
+      userName: userName,
+      password: password,
+      authenticationType: AuthenticationType.basic
+    );
+  }
+
   String get basicAuth => 'Basic ${base64Encode(utf8.encode('${userName?.value}:${password?.value}'))}';
 
   String get bearerToken => 'Bearer ${token?.token}';