refactor(mobile): services and providers (#9232)

* refactor(mobile): services and provider * providers
2024-05-02 15:59:14 -05:00
parent ec4eb7cd19
commit c1253663b7
242 changed files with 497 additions and 503 deletions
@@ -0,0 +1,78 @@
+import 'dart:async';
+
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/services/album.service.dart';
+import 'package:immich_mobile/modules/home/ui/asset_grid/asset_grid_data_structure.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/entities/album.entity.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/entities/user.entity.dart';
+import 'package:immich_mobile/providers/db.provider.dart';
+import 'package:immich_mobile/utils/renderlist_generator.dart';
+import 'package:isar/isar.dart';
+
+class AlbumNotifier extends StateNotifier<List<Album>> {
+  AlbumNotifier(this._albumService, Isar db) : super([]) {
+    final query = db.albums
+        .filter()
+        .owner((q) => q.isarIdEqualTo(Store.get(StoreKey.currentUser).isarId));
+    query.findAll().then((value) {
+      if (mounted) {
+        state = value;
+      }
+    });
+    _streamSub = query.watch().listen((data) => state = data);
+  }
+  final AlbumService _albumService;
+  late final StreamSubscription<List<Album>> _streamSub;
+
+  Future<void> getAllAlbums() => Future.wait([
+        _albumService.refreshDeviceAlbums(),
+        _albumService.refreshRemoteAlbums(isShared: false),
+      ]);
+
+  Future<void> getDeviceAlbums() => _albumService.refreshDeviceAlbums();
+
+  Future<bool> deleteAlbum(Album album) => _albumService.deleteAlbum(album);
+
+  Future<Album?> createAlbum(
+    String albumTitle,
+    Set<Asset> assets,
+  ) =>
+      _albumService.createAlbum(albumTitle, assets, []);
+
+  @override
+  void dispose() {
+    _streamSub.cancel();
+    super.dispose();
+  }
+}
+
+final albumProvider =
+    StateNotifierProvider.autoDispose<AlbumNotifier, List<Album>>((ref) {
+  return AlbumNotifier(
+    ref.watch(albumServiceProvider),
+    ref.watch(dbProvider),
+  );
+});
+
+final albumWatcher =
+    StreamProvider.autoDispose.family<Album, int>((ref, albumId) async* {
+  final db = ref.watch(dbProvider);
+  final a = await db.albums.get(albumId);
+  if (a != null) yield a;
+  await for (final a in db.albums.watchObject(albumId, fireImmediately: true)) {
+    if (a != null) yield a;
+  }
+});
+
+final albumRenderlistProvider =
+    StreamProvider.autoDispose.family<RenderList, int>((ref, albumId) {
+  final album = ref.watch(albumWatcher(albumId)).value;
+  if (album != null) {
+    final query =
+        album.assets.filter().isTrashedEqualTo(false).sortByFileCreatedAtDesc();
+    return renderListGeneratorWithGroupBy(query, GroupAssetsBy.none);
+  }
+  return const Stream.empty();
+});
@@ -0,0 +1,131 @@
+import 'package:collection/collection.dart';
+import 'package:immich_mobile/providers/app_settings.provider.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:immich_mobile/entities/album.entity.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'album_sort_by_options.provider.g.dart';
+
+typedef AlbumSortFn = List<Album> Function(List<Album> albums, bool isReverse);
+
+class _AlbumSortHandlers {
+  const _AlbumSortHandlers._();
+
+  static const AlbumSortFn created = _sortByCreated;
+  static List<Album> _sortByCreated(List<Album> albums, bool isReverse) {
+    final sorted = albums.sortedBy((album) => album.createdAt);
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn title = _sortByTitle;
+  static List<Album> _sortByTitle(List<Album> albums, bool isReverse) {
+    final sorted = albums.sortedBy((album) => album.name);
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn lastModified = _sortByLastModified;
+  static List<Album> _sortByLastModified(List<Album> albums, bool isReverse) {
+    final sorted = albums.sortedBy((album) => album.modifiedAt);
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn assetCount = _sortByAssetCount;
+  static List<Album> _sortByAssetCount(List<Album> albums, bool isReverse) {
+    final sorted =
+        albums.sorted((a, b) => a.assetCount.compareTo(b.assetCount));
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn mostRecent = _sortByMostRecent;
+  static List<Album> _sortByMostRecent(List<Album> albums, bool isReverse) {
+    final sorted = albums.sorted((a, b) {
+      if (a.endDate != null && b.endDate != null) {
+        return a.endDate!.compareTo(b.endDate!);
+      }
+      if (a.endDate == null) return 1;
+      if (b.endDate == null) return -1;
+      return 0;
+    });
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn mostOldest = _sortByMostOldest;
+  static List<Album> _sortByMostOldest(List<Album> albums, bool isReverse) {
+    final sorted = albums.sorted((a, b) {
+      if (a.startDate != null && b.startDate != null) {
+        return a.startDate!.compareTo(b.startDate!);
+      }
+      if (a.startDate == null) return 1;
+      if (b.startDate == null) return -1;
+      return 0;
+    });
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+}
+
+// Store index allows us to re-arrange the values without affecting the saved prefs
+enum AlbumSortMode {
+  title(1, "library_page_sort_title", _AlbumSortHandlers.title),
+  assetCount(4, "library_page_sort_asset_count", _AlbumSortHandlers.assetCount),
+  lastModified(
+    3,
+    "library_page_sort_last_modified",
+    _AlbumSortHandlers.lastModified,
+  ),
+  created(0, "library_page_sort_created", _AlbumSortHandlers.created),
+  mostRecent(
+    2,
+    "library_page_sort_most_recent_photo",
+    _AlbumSortHandlers.mostRecent,
+  ),
+  mostOldest(
+    5,
+    "library_page_sort_most_oldest_photo",
+    _AlbumSortHandlers.mostOldest,
+  );
+
+  final int storeIndex;
+  final String label;
+  final AlbumSortFn sortFn;
+
+  const AlbumSortMode(this.storeIndex, this.label, this.sortFn);
+}
+
+@riverpod
+class AlbumSortByOptions extends _$AlbumSortByOptions {
+  @override
+  AlbumSortMode build() {
+    final sortOpt = ref
+        .watch(appSettingsServiceProvider)
+        .getSetting(AppSettingsEnum.selectedAlbumSortOrder);
+    return AlbumSortMode.values.firstWhere(
+      (e) => e.storeIndex == sortOpt,
+      orElse: () => AlbumSortMode.title,
+    );
+  }
+
+  void changeSortMode(AlbumSortMode sortOption) {
+    state = sortOption;
+    ref.watch(appSettingsServiceProvider).setSetting(
+          AppSettingsEnum.selectedAlbumSortOrder,
+          sortOption.storeIndex,
+        );
+  }
+}
+
+@riverpod
+class AlbumSortOrder extends _$AlbumSortOrder {
+  @override
+  bool build() {
+    return ref
+        .watch(appSettingsServiceProvider)
+        .getSetting(AppSettingsEnum.selectedAlbumSortReverse);
+  }
+
+  void changeSortDirection(bool isReverse) {
+    state = isReverse;
+    ref
+        .watch(appSettingsServiceProvider)
+        .setSetting(AppSettingsEnum.selectedAlbumSortReverse, isReverse);
+  }
+}
@@ -0,0 +1,43 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'album_sort_by_options.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$albumSortByOptionsHash() =>
+    r'dd8da5e730af555de1b86c3b157b6c93183523ac';
+
+/// See also [AlbumSortByOptions].
+@ProviderFor(AlbumSortByOptions)
+final albumSortByOptionsProvider =
+    AutoDisposeNotifierProvider<AlbumSortByOptions, AlbumSortMode>.internal(
+  AlbumSortByOptions.new,
+  name: r'albumSortByOptionsProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$albumSortByOptionsHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+typedef _$AlbumSortByOptions = AutoDisposeNotifier<AlbumSortMode>;
+String _$albumSortOrderHash() => r'573dea45b4519e69386fc7104c72522e35713440';
+
+/// See also [AlbumSortOrder].
+@ProviderFor(AlbumSortOrder)
+final albumSortOrderProvider =
+    AutoDisposeNotifierProvider<AlbumSortOrder, bool>.internal(
+  AlbumSortOrder.new,
+  name: r'albumSortOrderProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$albumSortOrderHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+typedef _$AlbumSortOrder = AutoDisposeNotifier<bool>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member
@@ -0,0 +1,17 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+class AlbumTitleNotifier extends StateNotifier<String> {
+  AlbumTitleNotifier() : super("");
+
+  setAlbumTitle(String title) {
+    state = title;
+  }
+
+  clearAlbumTitle() {
+    state = "";
+  }
+}
+
+final albumTitleProvider = StateNotifierProvider<AlbumTitleNotifier, String>(
+  (ref) => AlbumTitleNotifier(),
+);
@@ -0,0 +1,56 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/models/albums/album_viewer_page_state.model.dart';
+import 'package:immich_mobile/providers/album/shared_album.provider.dart';
+import 'package:immich_mobile/services/album.service.dart';
+import 'package:immich_mobile/entities/album.entity.dart';
+
+class AlbumViewerNotifier extends StateNotifier<AlbumViewerPageState> {
+  AlbumViewerNotifier(this.ref)
+      : super(AlbumViewerPageState(editTitleText: "", isEditAlbum: false));
+
+  final Ref ref;
+
+  void enableEditAlbum() {
+    state = state.copyWith(isEditAlbum: true);
+  }
+
+  void disableEditAlbum() {
+    state = state.copyWith(isEditAlbum: false);
+  }
+
+  void setEditTitleText(String newTitle) {
+    state = state.copyWith(editTitleText: newTitle);
+  }
+
+  void remoteEditTitleText() {
+    state = state.copyWith(editTitleText: "");
+  }
+
+  void resetState() {
+    state = state.copyWith(editTitleText: "", isEditAlbum: false);
+  }
+
+  Future<bool> changeAlbumTitle(
+    Album album,
+    String newAlbumTitle,
+  ) async {
+    AlbumService service = ref.watch(albumServiceProvider);
+
+    bool isSuccess = await service.changeTitleAlbum(album, newAlbumTitle);
+
+    if (isSuccess) {
+      state = state.copyWith(editTitleText: "", isEditAlbum: false);
+      ref.read(sharedAlbumProvider.notifier).getAllSharedAlbums();
+
+      return true;
+    }
+
+    state = state.copyWith(editTitleText: "", isEditAlbum: false);
+    return false;
+  }
+}
+
+final albumViewerProvider =
+    StateNotifierProvider<AlbumViewerNotifier, AlbumViewerPageState>((ref) {
+  return AlbumViewerNotifier(ref);
+});
@@ -0,0 +1,15 @@
+import 'package:immich_mobile/entities/album.entity.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'current_album.provider.g.dart';
+
+@riverpod
+class CurrentAlbum extends _$CurrentAlbum {
+  @override
+  Album? build() => null;
+
+  void set(Album? a) => state = a;
+}
+
+/// Mock class for testing
+abstract class CurrentAlbumInternal extends _$CurrentAlbum {}
@@ -0,0 +1,25 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'current_album.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$currentAlbumHash() => r'61f00273d6b69da45add1532cc3d3a076ee55110';
+
+/// See also [CurrentAlbum].
+@ProviderFor(CurrentAlbum)
+final currentAlbumProvider =
+    AutoDisposeNotifierProvider<CurrentAlbum, Album?>.internal(
+  CurrentAlbum.new,
+  name: r'currentAlbumProvider',
+  debugGetCreateSourceHash:
+      const bool.fromEnvironment('dart.vm.product') ? null : _$currentAlbumHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+typedef _$CurrentAlbum = AutoDisposeNotifier<Album?>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member
@@ -0,0 +1,90 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/services/album.service.dart';
+import 'package:immich_mobile/entities/album.entity.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/entities/user.entity.dart';
+import 'package:immich_mobile/providers/db.provider.dart';
+import 'package:isar/isar.dart';
+
+class SharedAlbumNotifier extends StateNotifier<List<Album>> {
+  SharedAlbumNotifier(this._albumService, Isar db) : super([]) {
+    final query = db.albums.filter().sharedEqualTo(true).sortByCreatedAtDesc();
+    query.findAll().then((value) {
+      if (mounted) {
+        state = value;
+      }
+    });
+    _streamSub = query.watch().listen((data) => state = data);
+  }
+
+  final AlbumService _albumService;
+  late final StreamSubscription<List<Album>> _streamSub;
+
+  Future<Album?> createSharedAlbum(
+    String albumName,
+    Iterable<Asset> assets,
+    Iterable<User> sharedUsers,
+  ) async {
+    try {
+      return await _albumService.createAlbum(
+        albumName,
+        assets,
+        sharedUsers,
+      );
+    } catch (e) {
+      debugPrint("Error createSharedAlbum  ${e.toString()}");
+    }
+    return null;
+  }
+
+  Future<void> getAllSharedAlbums() =>
+      _albumService.refreshRemoteAlbums(isShared: true);
+
+  Future<bool> deleteAlbum(Album album) => _albumService.deleteAlbum(album);
+
+  Future<bool> leaveAlbum(Album album) async {
+    var res = await _albumService.leaveAlbum(album);
+
+    if (res) {
+      await deleteAlbum(album);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  Future<bool> removeAssetFromAlbum(Album album, Iterable<Asset> assets) {
+    return _albumService.removeAssetFromAlbum(album, assets);
+  }
+
+  Future<bool> removeUserFromAlbum(Album album, User user) async {
+    final result = await _albumService.removeUserFromAlbum(album, user);
+
+    if (result && album.sharedUsers.isEmpty) {
+      state = state.where((element) => element.id != album.id).toList();
+    }
+
+    return result;
+  }
+
+  Future<bool> setActivityEnabled(Album album, bool activityEnabled) {
+    return _albumService.setActivityEnabled(album, activityEnabled);
+  }
+
+  @override
+  void dispose() {
+    _streamSub.cancel();
+    super.dispose();
+  }
+}
+
+final sharedAlbumProvider =
+    StateNotifierProvider.autoDispose<SharedAlbumNotifier, List<Album>>((ref) {
+  return SharedAlbumNotifier(
+    ref.watch(albumServiceProvider),
+    ref.watch(dbProvider),
+  );
+});
@@ -0,0 +1,9 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/entities/user.entity.dart';
+import 'package:immich_mobile/services/user.service.dart';
+
+final otherUsersProvider = FutureProvider.autoDispose<List<User>>((ref) {
+  UserService userService = ref.watch(userServiceProvider);
+
+  return userService.getUsersInDb();
+});