WIP - More decoupling of data layer from ui layer

lib/core/repository/impl/correspondent_repository_impl.dart

@@ -0,0 +1,67 @@
+import 'dart:async';
+
+import 'package:paperless_api/paperless_api.dart';
+import 'package:paperless_mobile/core/repository/label_repository.dart';
+import 'package:rxdart/rxdart.dart' show BehaviorSubject;
+
+class CorrespondentRepositoryImpl implements LabelRepository<Correspondent> {
+  final PaperlessLabelsApi _api;
+
+  final _subject = BehaviorSubject<Map<int, Correspondent>>.seeded(const {});
+
+  CorrespondentRepositoryImpl(this._api);
+  @override
+  Stream<Map<int, Correspondent>> get labels =>
+      _subject.stream.asBroadcastStream();
+
+  @override
+  Future<Correspondent> create(Correspondent correspondent) async {
+    final created = await _api.saveCorrespondent(correspondent);
+    final updatedState = {..._subject.value}
+      ..putIfAbsent(created.id!, () => created);
+    _subject.add(updatedState);
+    return created;
+  }
+
+  @override
+  Future<void> delete(Correspondent correspondent) async {
+    await _api.deleteCorrespondent(correspondent);
+    final updatedState = {..._subject.value}
+      ..removeWhere((k, v) => k == correspondent.id);
+    _subject.add(updatedState);
+  }
+
+  @override
+  Future<Correspondent?> find(int id) async {
+    final correspondent = await _api.getCorrespondent(id);
+    if (correspondent != null) {
+      final updatedState = {..._subject.value}..[id] = correspondent;
+      _subject.add(updatedState);
+      return correspondent;
+    }
+    return null;
+  }
+
+  @override
+  Future<Iterable<Correspondent>> findAll([Iterable<int>? ids]) async {
+    final correspondents = await _api.getCorrespondents(ids);
+    final updatedState = {..._subject.value}
+      ..addEntries(correspondents.map((e) => MapEntry(e.id!, e)));
+    _subject.add(updatedState);
+    return correspondents;
+  }
+
+  @override
+  Future<Correspondent> update(Correspondent correspondent) async {
+    final updated = await _api.updateCorrespondent(correspondent);
+    final updatedState = {..._subject.value}
+      ..update(updated.id!, (_) => updated);
+    _subject.add(updatedState);
+    return updated;
+  }
+
+  @override
+  void clear() {
+    _subject.add(const {});
+  }
+}

lib/core/repository/impl/document_type_repository_impl.dart

@@ -0,0 +1,66 @@
+import 'package:paperless_api/paperless_api.dart';
+import 'package:paperless_mobile/core/repository/label_repository.dart';
+import 'package:rxdart/rxdart.dart' show BehaviorSubject;
+
+class DocumentTypeRepositoryImpl implements LabelRepository<DocumentType> {
+  final PaperlessLabelsApi _api;
+
+  final _subject = BehaviorSubject<Map<int, DocumentType>>.seeded(const {});
+
+  DocumentTypeRepositoryImpl(this._api);
+
+  @override
+  Stream<Map<int, DocumentType>> get labels =>
+      _subject.stream.asBroadcastStream();
+
+  @override
+  Future<DocumentType> create(DocumentType documentType) async {
+    final created = await _api.saveDocumentType(documentType);
+    final updatedState = {..._subject.value}
+      ..putIfAbsent(created.id!, () => created);
+    _subject.add(updatedState);
+    return created;
+  }
+
+  @override
+  Future<void> delete(DocumentType documentType) async {
+    await _api.deleteDocumentType(documentType);
+    final updatedState = {..._subject.value}
+      ..removeWhere((k, v) => k == documentType.id);
+    _subject.add(updatedState);
+  }
+
+  @override
+  Future<DocumentType?> find(int id) async {
+    final documentType = await _api.getDocumentType(id);
+    if (documentType != null) {
+      final updatedState = {..._subject.value}..[id] = documentType;
+      _subject.add(updatedState);
+      return documentType;
+    }
+    return null;
+  }
+
+  @override
+  Future<Iterable<DocumentType>> findAll([Iterable<int>? ids]) async {
+    final documentTypes = await _api.getDocumentTypes(ids);
+    final updatedState = {..._subject.value}
+      ..addEntries(documentTypes.map((e) => MapEntry(e.id!, e)));
+    _subject.add(updatedState);
+    return documentTypes;
+  }
+
+  @override
+  Future<DocumentType> update(DocumentType documentType) async {
+    final updated = await _api.updateDocumentType(documentType);
+    final updatedState = {..._subject.value}
+      ..update(updated.id!, (_) => updated);
+    _subject.add(updatedState);
+    return updated;
+  }
+
+  @override
+  void clear() {
+    _subject.add(const {});
+  }
+}

lib/core/repository/impl/saved_view_repository_impl.dart

@@ -0,0 +1,57 @@
+import 'package:paperless_api/paperless_api.dart';
+import 'package:paperless_api/src/models/saved_view_model.dart';
+import 'package:paperless_mobile/core/repository/saved_view_repository.dart';
+import 'package:rxdart/rxdart.dart';
+
+class SavedViewRepositoryImpl implements SavedViewRepository {
+  final PaperlessSavedViewsApi _api;
+
+  SavedViewRepositoryImpl(this._api);
+
+  final BehaviorSubject<Map<int, SavedView>> _subject =
+      BehaviorSubject.seeded({});
+
+  @override
+  Stream<Map<int, SavedView>> get savedViews =>
+      _subject.stream.asBroadcastStream();
+
+  @override
+  void clear() {}
+
+  @override
+  Future<SavedView> create(SavedView view) async {
+    final created = await _api.save(view);
+    final updatedState = {..._subject.value}
+      ..putIfAbsent(created.id!, () => created);
+    _subject.add(updatedState);
+    return created;
+  }
+
+  @override
+  Future<int> delete(SavedView view) async {
+    await _api.delete(view);
+    final updatedState = {..._subject.value}..remove(view.id);
+    _subject.add(updatedState);
+    return view.id!;
+  }
+
+  @override
+  Future<SavedView?> find(int id) async {
+    final found = await _api.find(id);
+    final updatedState = {..._subject.value}
+      ..update(id, (_) => found, ifAbsent: () => found);
+    _subject.add(updatedState);
+    return found;
+  }
+
+  @override
+  Future<Iterable<SavedView>> findAll([Iterable<int>? ids]) async {
+    final found = await _api.findAll(ids);
+    final updatedState = {
+      ..._subject.value,
+      ...{for (final view in found) view.id!: view},
+    };
+    _subject.add(updatedState);
+    return found;
+  }
+}

lib/core/repository/impl/storage_path_repository_impl.dart

@@ -0,0 +1,66 @@
+import 'package:paperless_api/paperless_api.dart';
+import 'package:paperless_mobile/core/repository/label_repository.dart';
+import 'package:rxdart/rxdart.dart' show BehaviorSubject;
+
+class StoragePathRepositoryImpl implements LabelRepository<StoragePath> {
+  final PaperlessLabelsApi _api;
+
+  final _subject = BehaviorSubject<Map<int, StoragePath>>.seeded(const {});
+
+  StoragePathRepositoryImpl(this._api);
+
+  @override
+  Stream<Map<int, StoragePath>> get labels =>
+      _subject.stream.asBroadcastStream();
+
+  @override
+  Future<StoragePath> create(StoragePath storagePath) async {
+    final created = await _api.saveStoragePath(storagePath);
+    final updatedState = {..._subject.value}
+      ..putIfAbsent(created.id!, () => created);
+    _subject.add(updatedState);
+    return created;
+  }
+
+  @override
+  Future<void> delete(StoragePath storagePath) async {
+    await _api.deleteStoragePath(storagePath);
+    final updatedState = {..._subject.value}
+      ..removeWhere((k, v) => k == storagePath.id);
+    _subject.add(updatedState);
+  }
+
+  @override
+  Future<StoragePath?> find(int id) async {
+    final storagePath = await _api.getStoragePath(id);
+    if (storagePath != null) {
+      final updatedState = {..._subject.value}..[id] = storagePath;
+      _subject.add(updatedState);
+      return storagePath;
+    }
+    return null;
+  }
+
+  @override
+  Future<Iterable<StoragePath>> findAll([Iterable<int>? ids]) async {
+    final storagePaths = await _api.getStoragePaths(ids);
+    final updatedState = {..._subject.value}
+      ..addEntries(storagePaths.map((e) => MapEntry(e.id!, e)));
+    _subject.add(updatedState);
+    return storagePaths;
+  }
+
+  @override
+  Future<StoragePath> update(StoragePath storagePath) async {
+    final updated = await _api.updateStoragePath(storagePath);
+    final updatedState = {..._subject.value}
+      ..update(updated.id!, (_) => updated);
+    _subject.add(updatedState);
+    return updated;
+  }
+
+  @override
+  void clear() {
+    _subject.add(const {});
+  }
+}

lib/core/repository/impl/tag_repository_impl.dart

@@ -0,0 +1,65 @@
+import 'package:paperless_api/paperless_api.dart';
+import 'package:paperless_mobile/core/repository/label_repository.dart';
+import 'package:rxdart/rxdart.dart' show BehaviorSubject;
+
+class TagRepositoryImpl implements LabelRepository<Tag> {
+  final PaperlessLabelsApi _api;
+
+  final _subject = BehaviorSubject<Map<int, Tag>>.seeded(const {});
+
+  TagRepositoryImpl(this._api);
+
+  @override
+  Stream<Map<int, Tag>> get labels => _subject.stream.asBroadcastStream();
+
+  @override
+  Future<Tag> create(Tag tag) async {
+    final created = await _api.saveTag(tag);
+    final updatedState = {..._subject.value}
+      ..putIfAbsent(created.id!, () => created);
+    _subject.add(updatedState);
+    return created;
+  }
+
+  @override
+  Future<void> delete(Tag tag) async {
+    await _api.deleteTag(tag);
+    final updatedState = {..._subject.value}
+      ..removeWhere((k, v) => k == tag.id);
+    _subject.add(updatedState);
+  }
+
+  @override
+  Future<Tag?> find(int id) async {
+    final tag = await _api.getTag(id);
+    if (tag != null) {
+      final updatedState = {..._subject.value}..[id] = tag;
+      _subject.add(updatedState);
+      return tag;
+    }
+    return null;
+  }
+
+  @override
+  Future<Iterable<Tag>> findAll([Iterable<int>? ids]) async {
+    final tags = await _api.getTags(ids);
+    final updatedState = {..._subject.value}
+      ..addEntries(tags.map((e) => MapEntry(e.id!, e)));
+    _subject.add(updatedState);
+    return tags;
+  }
+
+  @override
+  Future<Tag> update(Tag tag) async {
+    final updated = await _api.updateTag(tag);
+    final updatedState = {..._subject.value}
+      ..update(updated.id!, (_) => updated);
+    _subject.add(updatedState);
+    return updated;
+  }
+
+  @override
+  void clear() {
+    _subject.add(const {});
+  }
+}