TF-1897 Implement delete multiple sending email

(cherry picked from commit fecdb2cedba62820b0639d4aff495e2f93fa8c58)

lib/features/email/data/datasource/email_datasource.dart

@@ -97,4 +97,8 @@ abstract class EmailDataSource {
   Future<List<SendingEmail>> getAllSendingEmails(AccountId accountId, UserName userName);
 
   Future<void> deleteSendingEmail(AccountId accountId, UserName userName, String sendingId);
+
+  Future<void> deleteMultipleSendingEmail(AccountId accountId, UserName userName, List<String> sendingIds);
+
+  Future<List<SendingEmail>> updateMultipleSendingEmail(AccountId accountId, UserName userName, List<SendingEmail> newSendingEmails);
 }

lib/features/email/data/datasource_impl/email_datasource_impl.dart

@@ -195,7 +195,7 @@ class EmailDataSourceImpl extends EmailDataSource {
   }
 
   @override
-  Future<List<SendingEmail>> getAllSendingEmails(AccountId accountId, UserName userName, {bool needToReopen = false}) {
+  Future<List<SendingEmail>> getAllSendingEmails(AccountId accountId, UserName userName) {
     throw UnimplementedError();
   }
 
@@ -208,4 +208,14 @@ class EmailDataSourceImpl extends EmailDataSource {
   Future<SendingEmail> updateSendingEmail(AccountId accountId, UserName userName, SendingEmail newSendingEmail) {
     throw UnimplementedError();
   }
+
+  @override
+  Future<List<SendingEmail>> updateMultipleSendingEmail(AccountId accountId, UserName userName, List<SendingEmail> newSendingEmails) {
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<List<SendingEmail>> deleteMultipleSendingEmail(AccountId accountId, UserName userName, List<String> sendingIds) {
+    throw UnimplementedError();
+  }
 }

lib/features/email/data/datasource_impl/email_hive_cache_datasource_impl.dart

@@ -35,6 +35,7 @@ import 'package:tmail_ui_user/features/offline_mode/manager/detailed_email_cache
 import 'package:tmail_ui_user/features/offline_mode/manager/detailed_email_cache_worker_queue.dart';
 import 'package:tmail_ui_user/features/offline_mode/manager/opened_email_cache_manager.dart';
 import 'package:tmail_ui_user/features/offline_mode/manager/opened_email_cache_worker_queue.dart';
+import 'package:tmail_ui_user/features/sending_queue/domain/extensions/list_sending_email_extension.dart';
 import 'package:tmail_ui_user/features/sending_queue/domain/extensions/sending_email_extension.dart';
 import 'package:tmail_ui_user/features/sending_queue/domain/model/sending_email.dart';
 import 'package:tmail_ui_user/features/thread/data/extensions/email_cache_extension.dart';
@@ -256,25 +257,40 @@ class EmailHiveCacheDataSourceImpl extends EmailDataSource {
   }
 
   @override
-  Future<List<SendingEmail>> getAllSendingEmails(AccountId accountId, UserName userName, {bool needToReopen = false}) {
+  Future<List<SendingEmail>> getAllSendingEmails(AccountId accountId, UserName userName) {
     return Future.sync(() async {
-      final sendingEmailsCache = await _sendingEmailCacheManager.getAllSendingEmailsByTupleKey(accountId, userName, needToReopen: needToReopen);
+      final sendingEmailsCache = await _sendingEmailCacheManager.getAllSendingEmailsByTupleKey(accountId, userName);
       return sendingEmailsCache.toSendingEmails();
     }).catchError(_exceptionThrower.throwException);
   }
 
   @override
-  Future<void> deleteSendingEmail(AccountId accountId, UserName userName, String sendingId, {bool needToReopen = false}) {
+  Future<void> deleteSendingEmail(AccountId accountId, UserName userName, String sendingId) {
     return Future.sync(() async {
-      return await _sendingEmailCacheManager.deleteSendingEmail(accountId, userName, sendingId, needToReopen: needToReopen);
+      return await _sendingEmailCacheManager.deleteSendingEmail(accountId, userName, sendingId);
     }).catchError(_exceptionThrower.throwException);
   }
 
   @override
-  Future<SendingEmail> updateSendingEmail(AccountId accountId, UserName userName, SendingEmail newSendingEmail, {bool needToReopen = false}) {
+  Future<SendingEmail> updateSendingEmail(AccountId accountId, UserName userName, SendingEmail newSendingEmail) {
     return Future.sync(() async {
-      final sendingEmailsCache = await _sendingEmailCacheManager.updateSendingEmail(accountId, userName, newSendingEmail.toHiveCache(), needToReopen: needToReopen);
+      final sendingEmailsCache = await _sendingEmailCacheManager.updateSendingEmail(accountId, userName, newSendingEmail.toHiveCache());
       return sendingEmailsCache.toSendingEmail();
     }).catchError(_exceptionThrower.throwException);
   }
+
+  @override
+  Future<List<SendingEmail>> updateMultipleSendingEmail(AccountId accountId, UserName userName, List<SendingEmail> newSendingEmails) {
+    return Future.sync(() async {
+      final listSendingEmailsCache = await _sendingEmailCacheManager.updateMultipleSendingEmail(accountId, userName, newSendingEmails.toHiveCache());
+      return listSendingEmailsCache.toSendingEmails();
+    }).catchError(_exceptionThrower.throwException);
+  }
+
+  @override
+  Future<void> deleteMultipleSendingEmail(AccountId accountId, UserName userName, List<String> sendingIds) {
+    return Future.sync(() async {
+      return await _sendingEmailCacheManager.deleteMultipleSendingEmail(accountId, userName, sendingIds);
+    }).catchError(_exceptionThrower.throwException);
+  }
 }

lib/features/sending_queue/data/repository/sending_queue_repository_impl.dart

@@ -11,22 +11,32 @@ class SendingQueueRepositoryImpl extends SendingQueueRepository {
   SendingQueueRepositoryImpl(this._emailHiveCacheDataSourceImpl);
 
   @override
-  Future<List<SendingEmail>> getAllSendingEmails(AccountId accountId, UserName userName, {bool needToReopen = false}) {
-    return _emailHiveCacheDataSourceImpl.getAllSendingEmails(accountId, userName, needToReopen: needToReopen);
+  Future<List<SendingEmail>> getAllSendingEmails(AccountId accountId, UserName userName) {
+    return _emailHiveCacheDataSourceImpl.getAllSendingEmails(accountId, userName);
   }
 
   @override
-  Future<void> deleteSendingEmail(AccountId accountId, UserName userName, String sendingId, {bool needToReopen = false}) {
-    return _emailHiveCacheDataSourceImpl.deleteSendingEmail(accountId, userName, sendingId, needToReopen: needToReopen);
+  Future<void> deleteSendingEmail(AccountId accountId, UserName userName, String sendingId) {
+    return _emailHiveCacheDataSourceImpl.deleteSendingEmail(accountId, userName, sendingId);
   }
 
   @override
-  Future<SendingEmail> updateSendingEmail(AccountId accountId, UserName userName, SendingEmail newSendingEmail, {bool needToReopen = false}) {
-    return _emailHiveCacheDataSourceImpl.updateSendingEmail(accountId, userName, newSendingEmail, needToReopen: needToReopen);
+  Future<SendingEmail> updateSendingEmail(AccountId accountId, UserName userName, SendingEmail newSendingEmail) {
+    return _emailHiveCacheDataSourceImpl.updateSendingEmail(accountId, userName, newSendingEmail);
   }
 
   @override
   Future<SendingEmail> storeSendingEmail(AccountId accountId, UserName userName, SendingEmail sendingEmail) {
     return _emailHiveCacheDataSourceImpl.storeSendingEmail(accountId, userName, sendingEmail);
   }
+
+  @override
+  Future<List<SendingEmail>> updateMultipleSendingEmail(AccountId accountId, UserName userName, List<SendingEmail> newSendingEmails) {
+    return _emailHiveCacheDataSourceImpl.updateMultipleSendingEmail(accountId, userName, newSendingEmails);
+  }
+
+  @override
+  Future<void> deleteMultipleSendingEmail(AccountId accountId, UserName userName, List<String> sendingIds) {
+    return _emailHiveCacheDataSourceImpl.deleteMultipleSendingEmail(accountId, userName, sendingIds);
+  }
 }

lib/features/sending_queue/domain/repository/sending_queue_repository.dart

@@ -4,11 +4,15 @@ import 'package:jmap_dart_client/jmap/core/user_name.dart';
 import 'package:tmail_ui_user/features/sending_queue/domain/model/sending_email.dart';
 
 abstract class SendingQueueRepository {
-  Future<List<SendingEmail>> getAllSendingEmails(AccountId accountId, UserName userName, {bool needToReopen = false});
+  Future<List<SendingEmail>> getAllSendingEmails(AccountId accountId, UserName userName);
 
   Future<SendingEmail> storeSendingEmail(AccountId accountId, UserName userName, SendingEmail sendingEmail);
 
-  Future<void> deleteSendingEmail(AccountId accountId, UserName userName, String sendingId, {bool needToReopen = false});
+  Future<void> deleteSendingEmail(AccountId accountId, UserName userName, String sendingId);
 
-  Future<SendingEmail> updateSendingEmail(AccountId accountId, UserName userName, SendingEmail newSendingEmail, {bool needToReopen = false});
+  Future<void> deleteMultipleSendingEmail(AccountId accountId, UserName userName, List<String> sendingIds);
+
+  Future<SendingEmail> updateSendingEmail(AccountId accountId, UserName userName, SendingEmail newSendingEmail);
+
+  Future<List<SendingEmail>> updateMultipleSendingEmail(AccountId accountId, UserName userName, List<SendingEmail> newSendingEmails);
 }

lib/features/sending_queue/domain/state/delete_multiple_sending_email_state.dart

@@ -4,16 +4,13 @@ import 'package:core/presentation/state/success.dart';
 
 class DeleteMultipleSendingEmailLoading extends UIState {}
 
-class DeleteMultipleSendingEmailAllSuccess extends UIState {}
+class DeleteMultipleSendingEmailSuccess extends UIState {
+  final List<String> sendingIds;
 
-class DeleteMultipleSendingEmailHasSomeSuccess extends UIState {}
-
-class DeleteMultipleSendingEmailAllFailure extends FeatureFailure {
-
-  DeleteMultipleSendingEmailAllFailure(dynamic exception) : super(exception: exception);
+  DeleteMultipleSendingEmailSuccess(this.sendingIds);
 
   @override
-  List<Object?> get props => [exception];
+  List<Object?> get props => [sendingIds];
 }
 
 class DeleteMultipleSendingEmailFailure extends FeatureFailure {

lib/features/sending_queue/domain/usecases/delete_multiple_sending_email_interactor.dart

@@ -3,32 +3,19 @@ import 'package:core/presentation/state/success.dart';
 import 'package:dartz/dartz.dart';
 import 'package:jmap_dart_client/jmap/account_id.dart';
 import 'package:jmap_dart_client/jmap/core/user_name.dart';
+import 'package:tmail_ui_user/features/sending_queue/domain/repository/sending_queue_repository.dart';
 import 'package:tmail_ui_user/features/sending_queue/domain/state/delete_multiple_sending_email_state.dart';
-import 'package:tmail_ui_user/features/sending_queue/domain/usecases/delete_single_sending_email_interactor.dart';
 
 class DeleteMultipleSendingEmailInteractor {
-  final DeleteSingleSendingEmailInteractor _deleteSingleSendingEmailInteractor;
+  final SendingQueueRepository _sendingQueueRepository;
 
-  DeleteMultipleSendingEmailInteractor(this._deleteSingleSendingEmailInteractor);
+  DeleteMultipleSendingEmailInteractor(this._sendingQueueRepository);
 
   Stream<Either<Failure, Success>> execute(AccountId accountId, UserName userName, List<String> sendingIds) async* {
     try {
       yield Right<Failure, Success>(DeleteMultipleSendingEmailLoading());
-      final listResult = await Future.wait(
-        sendingIds.map((sendingId) => _deleteSingleSendingEmailInteractor.execute(accountId, userName, sendingId)),
-        eagerError: true
-      );
-
-      bool isAllSuccess = listResult.every((either) => either.isRight());
-      bool isAllFailure = listResult.every((either) => either.isLeft());
-
-      if (isAllSuccess) {
-        yield Right<Failure, Success>(DeleteMultipleSendingEmailAllSuccess());
-      } else if (isAllFailure) {
-        yield Left<Failure, Success>(DeleteMultipleSendingEmailAllFailure(null));
-      } else {
-        yield Right<Failure, Success>(DeleteMultipleSendingEmailHasSomeSuccess());
-      }
+      await _sendingQueueRepository.deleteMultipleSendingEmail(accountId, userName, sendingIds);
+      yield Right<Failure, Success>(DeleteMultipleSendingEmailSuccess(sendingIds));
     } catch (e) {
       yield Left<Failure, Success>(DeleteMultipleSendingEmailFailure(e));
     }

lib/features/sending_queue/domain/usecases/delete_sending_email_interactor.dart

@@ -11,10 +11,10 @@ class DeleteSendingEmailInteractor {
 
   DeleteSendingEmailInteractor(this._sendingQueueRepository);
 
-  Stream<Either<Failure, Success>> execute(AccountId accountId, UserName userName, String sendingId, {bool needToReopen = false}) async* {
+  Stream<Either<Failure, Success>> execute(AccountId accountId, UserName userName, String sendingId) async* {
     try {
       yield Right<Failure, Success>(DeleteSendingEmailLoading());
-      await _sendingQueueRepository.deleteSendingEmail(accountId, userName, sendingId, needToReopen: needToReopen);
+      await _sendingQueueRepository.deleteSendingEmail(accountId, userName, sendingId);
       yield Right<Failure, Success>(DeleteSendingEmailSuccess());
     } catch (e) {
       yield Left<Failure, Success>(DeleteSendingEmailFailure(e));

lib/features/sending_queue/domain/usecases/delete_single_sending_email_interactor.dart

@@ -1,22 +0,0 @@
-import 'package:core/presentation/state/failure.dart';
-import 'package:core/presentation/state/success.dart';
-import 'package:dartz/dartz.dart';
-import 'package:jmap_dart_client/jmap/account_id.dart';
-import 'package:jmap_dart_client/jmap/core/user_name.dart';
-import 'package:tmail_ui_user/features/email/domain/state/delete_sending_email_state.dart';
-import 'package:tmail_ui_user/features/sending_queue/domain/repository/sending_queue_repository.dart';
-
-class DeleteSingleSendingEmailInteractor {
-  final SendingQueueRepository _sendingQueueRepository;
-
-  DeleteSingleSendingEmailInteractor(this._sendingQueueRepository);
-
-  Future<Either<Failure, Success>> execute(AccountId accountId, UserName userName, String sendingId) async {
-    try {
-      await _sendingQueueRepository.deleteSendingEmail(accountId, userName, sendingId);
-      return Right<Failure, Success>(DeleteSendingEmailSuccess());
-    } catch (e) {
-      return Left<Failure, Success>(DeleteSendingEmailFailure(e));
-    }
-  }
-}

lib/features/sending_queue/domain/usecases/get_all_sending_email_interactor.dart

@@ -11,10 +11,10 @@ class GetAllSendingEmailInteractor {
 
   GetAllSendingEmailInteractor(this._sendingQueueRepository);
 
-  Stream<Either<Failure, Success>> execute(AccountId accountId, UserName userName, {bool needToReopen = false}) async* {
+  Stream<Either<Failure, Success>> execute(AccountId accountId, UserName userName) async* {
     try {
       yield Right<Failure, Success>(GetAllSendingEmailLoading());
-      final sendingEmails = await _sendingQueueRepository.getAllSendingEmails(accountId, userName, needToReopen: needToReopen);
+      final sendingEmails = await _sendingQueueRepository.getAllSendingEmails(accountId, userName);
       yield Right<Failure, Success>(GetAllSendingEmailSuccess(sendingEmails));
     } catch (e) {
       yield Left<Failure, Success>(GetAllSendingEmailFailure(e));