refactor(mobile): album api repository for album service (#12791)

* refactor(mobile): album api repository for album service

mobile/lib/services/album.service.dart

@@ -6,63 +6,61 @@ import 'package:collection/collection.dart';
 import 'package:flutter/foundation.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/interfaces/album.interface.dart';
+import 'package:immich_mobile/interfaces/album_api.interface.dart';
 import 'package:immich_mobile/interfaces/album_media.interface.dart';
 import 'package:immich_mobile/interfaces/asset.interface.dart';
 import 'package:immich_mobile/interfaces/backup.interface.dart';
-import 'package:immich_mobile/interfaces/user.interface.dart';
 import 'package:immich_mobile/models/albums/album_add_asset_response.model.dart';
 import 'package:immich_mobile/entities/backup_album.entity.dart';
 import 'package:immich_mobile/entities/album.entity.dart';
 import 'package:immich_mobile/entities/asset.entity.dart';
 import 'package:immich_mobile/entities/store.entity.dart';
 import 'package:immich_mobile/entities/user.entity.dart';
-import 'package:immich_mobile/providers/api.provider.dart';
 import 'package:immich_mobile/repositories/album.repository.dart';
+import 'package:immich_mobile/repositories/album_api.repository.dart';
 import 'package:immich_mobile/repositories/asset.repository.dart';
 import 'package:immich_mobile/repositories/backup.repository.dart';
 import 'package:immich_mobile/repositories/album_media.repository.dart';
-import 'package:immich_mobile/repositories/user.repository.dart';
-import 'package:immich_mobile/services/api.service.dart';
+import 'package:immich_mobile/services/entity.service.dart';
 import 'package:immich_mobile/services/sync.service.dart';
 import 'package:immich_mobile/services/user.service.dart';
 import 'package:logging/logging.dart';
-import 'package:openapi/api.dart';
 
 final albumServiceProvider = Provider(
   (ref) => AlbumService(
-    ref.watch(apiServiceProvider),
     ref.watch(userServiceProvider),
     ref.watch(syncServiceProvider),
+    ref.watch(entityServiceProvider),
     ref.watch(albumRepositoryProvider),
     ref.watch(assetRepositoryProvider),
-    ref.watch(userRepositoryProvider),
     ref.watch(backupRepositoryProvider),
     ref.watch(albumMediaRepositoryProvider),
+    ref.watch(albumApiRepositoryProvider),
   ),
 );
 
 class AlbumService {
-  final ApiService _apiService;
   final UserService _userService;
   final SyncService _syncService;
+  final EntityService _entityService;
   final IAlbumRepository _albumRepository;
   final IAssetRepository _assetRepository;
-  final IUserRepository _userRepository;
   final IBackupRepository _backupAlbumRepository;
   final IAlbumMediaRepository _albumMediaRepository;
+  final IAlbumApiRepository _albumApiRepository;
   final Logger _log = Logger('AlbumService');
   Completer<bool> _localCompleter = Completer()..complete(false);
   Completer<bool> _remoteCompleter = Completer()..complete(false);
 
   AlbumService(
-    this._apiService,
     this._userService,
     this._syncService,
+    this._entityService,
     this._albumRepository,
     this._assetRepository,
-    this._userRepository,
     this._backupAlbumRepository,
     this._albumMediaRepository,
+    this._albumApiRepository,
   );
 
   /// Checks all selected device albums for changes of albums and their assets
@@ -164,17 +162,11 @@ class AlbumService {
     bool changes = false;
     try {
       await _userService.refreshUsers();
-      final List<AlbumResponseDto>? serverAlbums = await _apiService.albumsApi
-          .getAllAlbums(shared: isShared ? true : null);
-      if (serverAlbums == null) {
-        return false;
-      }
+      final List<Album> serverAlbums =
+          await _albumApiRepository.getAll(shared: isShared ? true : null);
       changes = await _syncService.syncRemoteAlbumsToDb(
         serverAlbums,
         isShared: isShared,
-        loadDetails: (dto) async => dto.assetCount == dto.assets.length
-            ? dto
-            : (await _apiService.albumsApi.getAlbumInfo(dto.id)) ?? dto,
       );
     } finally {
       _remoteCompleter.complete(changes);
@@ -188,30 +180,13 @@ class AlbumService {
     Iterable<Asset> assets, [
     Iterable<User> sharedUsers = const [],
   ]) async {
-    try {
-      AlbumResponseDto? remote = await _apiService.albumsApi.createAlbum(
-        CreateAlbumDto(
-          albumName: albumName,
-          assetIds: assets.map((asset) => asset.remoteId!).toList(),
-          albumUsers: sharedUsers
-              .map(
-                (e) => AlbumUserCreateDto(
-                  userId: e.id,
-                  role: AlbumUserRole.editor,
-                ),
-              )
-              .toList(),
-        ),
-      );
-      if (remote != null) {
-        final Album album = await Album.remote(remote);
-        await _albumRepository.create(album);
-        return album;
-      }
-    } catch (e) {
-      debugPrint("Error createSharedAlbum  ${e.toString()}");
-    }
-    return null;
+    final Album album = await _albumApiRepository.create(
+      albumName,
+      assetIds: assets.map((asset) => asset.remoteId!),
+      sharedUserIds: sharedUsers.map((user) => user.id),
+    );
+    await _entityService.fillAlbumWithDatabaseEntities(album);
+    return _albumRepository.create(album);
   }
 
   /*
@@ -243,32 +218,21 @@ class AlbumService {
     Album album,
   ) async {
     try {
-      var response = await _apiService.albumsApi.addAssetsToAlbum(
+      final result = await _albumApiRepository.addAssets(
         album.remoteId!,
-        BulkIdsDto(ids: assets.map((asset) => asset.remoteId!).toList()),
+        assets.map((asset) => asset.remoteId!),
       );
 
-      if (response != null) {
-        List<Asset> successAssets = [];
-        List<String> duplicatedAssets = [];
+      final List<Asset> addedAssets = result.added
+          .map((id) => assets.firstWhere((asset) => asset.remoteId == id))
+          .toList();
 
-        for (final result in response) {
-          if (result.success) {
-            successAssets
-                .add(assets.firstWhere((asset) => asset.remoteId == result.id));
-          } else if (!result.success &&
-              result.error == BulkIdResponseDtoErrorEnum.duplicate) {
-            duplicatedAssets.add(result.id);
-          }
-        }
+      await _updateAssets(album.id, add: addedAssets);
 
-        await _updateAssets(album.id, add: successAssets);
-
-        return AlbumAddAssetsResponse(
-          alreadyInAlbum: duplicatedAssets,
-          successfullyAdded: successAssets.length,
-        );
-      }
+      return AlbumAddAssetsResponse(
+        alreadyInAlbum: result.duplicates,
+        successfullyAdded: addedAssets.length,
+      );
     } catch (e) {
       debugPrint("Error addAdditionalAssetToAlbum  ${e.toString()}");
     }
@@ -293,20 +257,11 @@ class AlbumService {
     Album album,
   ) async {
     try {
-      final List<AlbumUserAddDto> albumUsers = sharedUserIds
-          .map((userId) => AlbumUserAddDto(userId: userId))
-          .toList();
-
-      final result = await _apiService.albumsApi.addUsersToAlbum(
-        album.remoteId!,
-        AddUsersDto(albumUsers: albumUsers),
-      );
-      if (result != null) {
-        album.sharedUsers.addAll(await _userRepository.getByIds(sharedUserIds));
-        album.shared = result.shared;
-        await _albumRepository.update(album);
-        return true;
-      }
+      final updatedAlbum =
+          await _albumApiRepository.addUsers(album.remoteId!, sharedUserIds);
+      await _entityService.fillAlbumWithDatabaseEntities(updatedAlbum);
+      await _albumRepository.update(updatedAlbum);
+      return true;
     } catch (e) {
       debugPrint("Error addAdditionalUserToAlbum  ${e.toString()}");
     }
@@ -315,15 +270,13 @@ class AlbumService {
 
   Future<bool> setActivityEnabled(Album album, bool enabled) async {
     try {
-      final result = await _apiService.albumsApi.updateAlbumInfo(
+      final updatedAlbum = await _albumApiRepository.update(
         album.remoteId!,
-        UpdateAlbumDto(isActivityEnabled: enabled),
+        activityEnabled: enabled,
       );
-      if (result != null) {
-        album.activityEnabled = enabled;
-        await _albumRepository.update(album);
-        return true;
-      }
+      await _entityService.fillAlbumWithDatabaseEntities(updatedAlbum);
+      await _albumRepository.update(updatedAlbum);
+      return true;
     } catch (e) {
       debugPrint("Error setActivityEnabled  ${e.toString()}");
     }
@@ -334,7 +287,7 @@ class AlbumService {
     try {
       final user = Store.get(StoreKey.currentUser);
       if (album.owner.value?.isarId == user.isarId) {
-        await _apiService.albumsApi.deleteAlbum(album.remoteId!);
+        await _albumApiRepository.delete(album.remoteId!);
       }
       if (album.shared) {
         final foreignAssets =
@@ -365,7 +318,7 @@ class AlbumService {
 
   Future<bool> leaveAlbum(Album album) async {
     try {
-      await _apiService.albumsApi.removeUserFromAlbum(album.remoteId!, "me");
+      await _albumApiRepository.removeUser(album.remoteId!, userId: "me");
       return true;
     } catch (e) {
       debugPrint("Error leaveAlbum ${e.toString()}");
@@ -378,21 +331,14 @@ class AlbumService {
     Iterable<Asset> assets,
   ) async {
     try {
-      final response = await _apiService.albumsApi.removeAssetFromAlbum(
+      final result = await _albumApiRepository.removeAssets(
         album.remoteId!,
-        BulkIdsDto(
-          ids: assets.map((asset) => asset.remoteId!).toList(),
-        ),
+        assets.map((asset) => asset.remoteId!),
       );
-      if (response != null) {
-        final toRemove = response.every((e) => e.success)
-            ? assets
-            : response
-                .where((e) => e.success)
-                .map((e) => assets.firstWhere((a) => a.remoteId == e.id));
-        await _updateAssets(album.id, remove: toRemove.toList());
-        return true;
-      }
+      final toRemove = result.removed
+          .map((id) => assets.firstWhere((asset) => asset.remoteId == id));
+      await _updateAssets(album.id, remove: toRemove.toList());
+      return true;
     } catch (e) {
       debugPrint("Error removeAssetFromAlbum ${e.toString()}");
     }
@@ -404,9 +350,9 @@ class AlbumService {
     User user,
   ) async {
     try {
-      await _apiService.albumsApi.removeUserFromAlbum(
+      await _albumApiRepository.removeUser(
         album.remoteId!,
-        user.id,
+        userId: user.id,
       );
 
       album.sharedUsers.remove(user);
@@ -427,15 +373,12 @@ class AlbumService {
     String newAlbumTitle,
   ) async {
     try {
-      await _apiService.albumsApi.updateAlbumInfo(
+      album = await _albumApiRepository.update(
         album.remoteId!,
-        UpdateAlbumDto(
-          albumName: newAlbumTitle,
-        ),
+        name: newAlbumTitle,
       );
-      album.name = newAlbumTitle;
+      await _entityService.fillAlbumWithDatabaseEntities(album);
       await _albumRepository.update(album);
-
       return true;
     } catch (e) {
       debugPrint("Error changeTitleAlbum  ${e.toString()}");
@@ -456,12 +399,8 @@ class AlbumService {
     for (final albumName in albumNames) {
       Album? album = await getAlbumByName(albumName, true);
       album ??= await createAlbum(albumName, []);
-
       if (album != null && album.remoteId != null) {
-        await _apiService.albumsApi.addAssetsToAlbum(
-          album.remoteId!,
-          BulkIdsDto(ids: assetIds),
-        );
+        await _albumApiRepository.addAssets(album.remoteId!, assetIds);
       }
     }
   }