Source Code added

mobile/lib/repositories/album.repository.dart

@@ -0,0 +1,139 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/domain/models/user.model.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/infrastructure/entities/user.entity.dart' as entity;
+import 'package:immich_mobile/models/albums/album_search.model.dart';
+import 'package:immich_mobile/providers/db.provider.dart';
+import 'package:immich_mobile/repositories/database.repository.dart';
+import 'package:immich_mobile/utils/hash.dart';
+import 'package:isar/isar.dart';
+
+enum AlbumSort { remoteId, localId }
+
+final albumRepositoryProvider = Provider((ref) => AlbumRepository(ref.watch(dbProvider)));
+
+class AlbumRepository extends DatabaseRepository {
+  const AlbumRepository(super.db);
+
+  Future<int> count({bool? local}) {
+    final baseQuery = db.albums.where();
+    final QueryBuilder<Album, Album, QAfterWhereClause> query = switch (local) {
+      null => baseQuery.noOp(),
+      true => baseQuery.localIdIsNotNull(),
+      false => baseQuery.remoteIdIsNotNull(),
+    };
+    return query.count();
+  }
+
+  Future<Album> create(Album album) => txn(() => db.albums.store(album));
+
+  Future<Album?> getByName(String name, {bool? shared, bool? remote, bool? owner}) {
+    var query = db.albums.filter().nameEqualTo(name);
+    if (shared != null) {
+      query = query.sharedEqualTo(shared);
+    }
+    final isarUserId = fastHash(Store.get(StoreKey.currentUser).id);
+    if (owner == true) {
+      query = query.owner((q) => q.isarIdEqualTo(isarUserId));
+    } else if (owner == false) {
+      query = query.owner((q) => q.not().isarIdEqualTo(isarUserId));
+    }
+    if (remote == true) {
+      query = query.localIdIsNull();
+    } else if (remote == false) {
+      query = query.remoteIdIsNull();
+    }
+    return query.findFirst();
+  }
+
+  Future<Album> update(Album album) => txn(() => db.albums.store(album));
+
+  Future<void> delete(int albumId) => txn(() => db.albums.delete(albumId));
+
+  Future<List<Album>> getAll({bool? shared, bool? remote, int? ownerId, AlbumSort? sortBy}) {
+    final baseQuery = db.albums.where();
+    final QueryBuilder<Album, Album, QAfterWhereClause> afterWhere;
+    if (remote == null) {
+      afterWhere = baseQuery.noOp();
+    } else if (remote) {
+      afterWhere = baseQuery.remoteIdIsNotNull();
+    } else {
+      afterWhere = baseQuery.localIdIsNotNull();
+    }
+    QueryBuilder<Album, Album, QAfterFilterCondition> filterQuery = afterWhere.filter().noOp();
+    if (shared != null) {
+      filterQuery = filterQuery.sharedEqualTo(true);
+    }
+    if (ownerId != null) {
+      filterQuery = filterQuery.owner((q) => q.isarIdEqualTo(ownerId));
+    }
+    final QueryBuilder<Album, Album, QAfterSortBy> query = switch (sortBy) {
+      null => filterQuery.noOp(),
+      AlbumSort.remoteId => filterQuery.sortByRemoteId(),
+      AlbumSort.localId => filterQuery.sortByLocalId(),
+    };
+    return query.findAll();
+  }
+
+  Future<Album?> get(int id) => db.albums.get(id);
+
+  Future<Album?> getByRemoteId(String remoteId) {
+    return db.albums.filter().remoteIdEqualTo(remoteId).findFirst();
+  }
+
+  Future<void> removeUsers(Album album, List<UserDto> users) =>
+      txn(() => album.sharedUsers.update(unlink: users.map(entity.User.fromDto)));
+
+  Future<void> addAssets(Album album, List<Asset> assets) => txn(() => album.assets.update(link: assets));
+
+  Future<void> removeAssets(Album album, List<Asset> assets) => txn(() => album.assets.update(unlink: assets));
+
+  Future<Album> recalculateMetadata(Album album) async {
+    album.startDate = await album.assets.filter().fileCreatedAtProperty().min();
+    album.endDate = await album.assets.filter().fileCreatedAtProperty().max();
+    album.lastModifiedAssetTimestamp = await album.assets.filter().updatedAtProperty().max();
+    return album;
+  }
+
+  Future<void> addUsers(Album album, List<UserDto> users) =>
+      txn(() => album.sharedUsers.update(link: users.map(entity.User.fromDto)));
+
+  Future<void> deleteAllLocal() => txn(() => db.albums.where().localIdIsNotNull().deleteAll());
+
+  Future<List<Album>> search(String searchTerm, QuickFilterMode filterMode) async {
+    var query = db.albums.filter().nameContains(searchTerm, caseSensitive: false).remoteIdIsNotNull();
+    final isarUserId = fastHash(Store.get(StoreKey.currentUser).id);
+
+    switch (filterMode) {
+      case QuickFilterMode.sharedWithMe:
+        query = query.owner((q) => q.not().isarIdEqualTo(isarUserId));
+      case QuickFilterMode.myAlbums:
+        query = query.owner((q) => q.isarIdEqualTo(isarUserId));
+      case QuickFilterMode.all:
+        break;
+    }
+
+    return await query.findAll();
+  }
+
+  Future<void> clearTable() async {
+    await txn(() async {
+      await db.albums.clear();
+    });
+  }
+
+  Stream<List<Album>> watchRemoteAlbums() {
+    return db.albums.where().remoteIdIsNotNull().watch();
+  }
+
+  Stream<List<Album>> watchLocalAlbums() {
+    return db.albums.where().localIdIsNotNull().watch();
+  }
+
+  Stream<Album?> watchAlbum(int id) {
+    return db.albums.watchObject(id, fireImmediately: true);
+  }
+}