Improved error handling, added multithreading for fromJson calls, made receive sharing intent more robust

lib/features/documents/bloc/documents_cubit.dart

@@ -1,7 +1,6 @@
 import 'dart:typed_data';
 
 import 'package:flutter_bloc/flutter_bloc.dart';
-import 'package:paperless_mobile/core/bloc/global_error_cubit.dart';
 import 'package:paperless_mobile/core/model/error_message.dart';
 import 'package:paperless_mobile/features/documents/bloc/documents_state.dart';
 import 'package:paperless_mobile/features/documents/model/document.model.dart';
@@ -13,10 +12,8 @@ import 'package:injectable/injectable.dart';
 @singleton
 class DocumentsCubit extends Cubit<DocumentsState> {
   final DocumentRepository documentRepository;
-  final GlobalErrorCubit errorCubit;
 
-  DocumentsCubit(this.documentRepository, this.errorCubit)
-      : super(DocumentsState.initial);
+  DocumentsCubit(this.documentRepository) : super(DocumentsState.initial);
 
   Future<void> addDocument(
     Uint8List bytes,
@@ -27,209 +24,99 @@ class DocumentsCubit extends Cubit<DocumentsState> {
     int? correspondent,
     List<int>? tags,
     DateTime? createdAt,
-    bool propagateEventOnError = true,
   }) async {
-    try {
-      await documentRepository.create(
-        bytes,
-        fileName,
-        title: title,
-        documentType: documentType,
-        correspondent: correspondent,
-        tags: tags,
-        createdAt: createdAt,
-      );
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
-    }
+    await documentRepository.create(
+      bytes,
+      fileName,
+      title: title,
+      documentType: documentType,
+      correspondent: correspondent,
+      tags: tags,
+      createdAt: createdAt,
+    );
+
     // documentRepository
     //     .waitForConsumptionFinished(fileName, title)
     //     .then((value) => onConsumptionFinished(value));
   }
 
-  Future<void> removeDocument(
-    DocumentModel document, {
-    bool propagateEventOnError = true,
-  }) async {
-    try {
-      await documentRepository.delete(document);
-      return await reloadDocuments();
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
-    }
+  Future<void> removeDocument(DocumentModel document) async {
+    await documentRepository.delete(document);
+    return await reloadDocuments();
   }
 
-  Future<void> bulkRemoveDocuments(List<DocumentModel> documents,
-      {bool propagateEventOnError = true}) async {
-    try {
-      await documentRepository.bulkDelete(documents);
-      return await reloadDocuments();
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
-    }
+  Future<void> bulkRemoveDocuments(List<DocumentModel> documents) async {
+    await documentRepository.bulkDelete(documents);
+    return await reloadDocuments();
   }
 
-  Future<void> updateDocument(
-    DocumentModel document, {
-    bool propagateEventOnError = true,
-  }) async {
-    try {
-      await documentRepository.update(document);
-      await reloadDocuments();
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
-    }
+  Future<void> updateDocument(DocumentModel document) async {
+    await documentRepository.update(document);
+    await reloadDocuments();
   }
 
-  Future<void> loadDocuments({
-    bool propagateEventOnError = true,
-  }) async {
-    try {
-      final result = await documentRepository.find(state.filter);
-      emit(DocumentsState(
-        isLoaded: true,
-        value: [...state.value, result],
-        filter: state.filter,
-      ));
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
-    }
+  Future<void> loadDocuments() async {
+    final result = await documentRepository.find(state.filter);
+    emit(DocumentsState(
+      isLoaded: true,
+      value: [...state.value, result],
+      filter: state.filter,
+    ));
   }
 
-  Future<void> reloadDocuments({
-    bool propagateEventOnError = true,
-  }) async {
+  Future<void> reloadDocuments() async {
     if (state.currentPageNumber >= 5) {
       return _bulkReloadDocuments();
     }
     var newPages = <PagedSearchResult>[];
-    try {
-      for (final page in state.value) {
-        final result = await documentRepository
-            .find(state.filter.copyWith(page: page.pageKey));
-        newPages.add(result);
-      }
-      emit(DocumentsState(
-          isLoaded: true, value: newPages, filter: state.filter));
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
+    for (final page in state.value) {
+      final result = await documentRepository
+          .find(state.filter.copyWith(page: page.pageKey));
+      newPages.add(result);
     }
+    emit(DocumentsState(isLoaded: true, value: newPages, filter: state.filter));
   }
 
-  Future<void> _bulkReloadDocuments({
-    bool propagateEventOnError = true,
-  }) async {
-    try {
-      final result = await documentRepository.find(
-          state.filter.copyWith(page: 1, pageSize: state.documents.length));
-      emit(DocumentsState(
-          isLoaded: true, value: [result], filter: state.filter));
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
-    }
+  Future<void> _bulkReloadDocuments() async {
+    final result = await documentRepository
+        .find(state.filter.copyWith(page: 1, pageSize: state.documents.length));
+    emit(DocumentsState(isLoaded: true, value: [result], filter: state.filter));
   }
 
-  Future<void> loadMore({
-    bool propagateEventOnError = true,
-  }) async {
+  Future<void> loadMore() async {
     if (state.isLastPageLoaded) {
       return;
     }
     final newFilter = state.filter.copyWith(page: state.filter.page + 1);
-    try {
-      final result = await documentRepository.find(newFilter);
-      emit(DocumentsState(
-          isLoaded: true, value: [...state.value, result], filter: newFilter));
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
-    }
+    final result = await documentRepository.find(newFilter);
+    emit(DocumentsState(
+        isLoaded: true, value: [...state.value, result], filter: newFilter));
   }
 
-  Future<void> assignAsn(
-    DocumentModel document, {
-    bool propagateEventOnError = true,
-  }) async {
-    try {
-      if (document.archiveSerialNumber == null) {
-        final int asn = await documentRepository.findNextAsn();
-        updateDocument(document.copyWith(archiveSerialNumber: asn));
-      }
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
+  Future<void> assignAsn(DocumentModel document) async {
+    if (document.archiveSerialNumber == null) {
+      final int asn = await documentRepository.findNextAsn();
+      updateDocument(document.copyWith(archiveSerialNumber: asn));
     }
   }
 
   ///
   /// Update filter state and automatically reload documents. Always resets page to 1.
   /// Use [DocumentsCubit.loadMore] to load more data.
-  Future<void> updateFilter(
-      {final DocumentFilter filter = DocumentFilter.initial,
-      bool propagateEventOnError = true}) async {
-    try {
-      final result = await documentRepository.find(filter.copyWith(page: 1));
-      emit(DocumentsState(filter: filter, value: [result], isLoaded: true));
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      } else {
-        rethrow;
-      }
-    }
+  Future<void> updateFilter({
+    final DocumentFilter filter = DocumentFilter.initial,
+  }) async {
+    final result = await documentRepository.find(filter.copyWith(page: 1));
+    emit(DocumentsState(filter: filter, value: [result], isLoaded: true));
   }
 
   ///
   /// Convenience method which allows to directly use [DocumentFilter.copyWith] on the current filter.
   ///
   Future<void> updateCurrentFilter(
-    final DocumentFilter Function(DocumentFilter) transformFn, {
-    bool propagateEventOnError = true,
-  }) async {
-    try {
-      return updateFilter(filter: transformFn(state.filter));
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        return errorCubit.add(error);
-      } else {
-        rethrow;
-      }
-    }
-  }
+    final DocumentFilter Function(DocumentFilter) transformFn,
+  ) async =>
+      updateFilter(filter: transformFn(state.filter));
 
   void toggleDocumentSelection(DocumentModel model) {
     if (state.selection.contains(model)) {

lib/features/documents/bloc/saved_view_cubit.dart

@@ -1,5 +1,4 @@
 import 'package:flutter_bloc/flutter_bloc.dart';
-import 'package:paperless_mobile/core/bloc/global_error_cubit.dart';
 import 'package:paperless_mobile/core/model/error_message.dart';
 import 'package:paperless_mobile/di_initializer.dart';
 import 'package:paperless_mobile/features/documents/bloc/saved_view_state.dart';
@@ -9,79 +8,42 @@ import 'package:injectable/injectable.dart';
 
 @singleton
 class SavedViewCubit extends Cubit<SavedViewState> {
-  final GlobalErrorCubit errorCubit;
-  SavedViewCubit(this.errorCubit) : super(SavedViewState(value: {}));
+  SavedViewCubit() : super(SavedViewState(value: {}));
 
-  void selectView(SavedView? view, {bool propagateEventOnError = true}) {
-    try {
-      emit(SavedViewState(value: state.value, selectedSavedViewId: view?.id));
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      }
-      rethrow;
-    }
+  void selectView(SavedView? view) {
+    emit(SavedViewState(value: state.value, selectedSavedViewId: view?.id));
   }
 
-  Future<SavedView> add(
-    SavedView view, {
-    bool propagateEventOnError = true,
-  }) async {
-    try {
-      final savedView = await getIt<SavedViewsRepository>().save(view);
-      emit(
-        SavedViewState(
-          value: {...state.value, savedView.id!: savedView},
-          selectedSavedViewId: state.selectedSavedViewId,
-        ),
-      );
-      return savedView;
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      }
-      rethrow;
-    }
+  Future<SavedView> add(SavedView view) async {
+    final savedView = await getIt<SavedViewsRepository>().save(view);
+    emit(
+      SavedViewState(
+        value: {...state.value, savedView.id!: savedView},
+        selectedSavedViewId: state.selectedSavedViewId,
+      ),
+    );
+    return savedView;
   }
 
-  Future<int> remove(
-    SavedView view, {
-    bool propagateEventOnError = true,
-  }) async {
-    try {
-      final id = await getIt<SavedViewsRepository>().delete(view);
-      final newValue = {...state.value};
-      newValue.removeWhere((key, value) => key == id);
-      emit(
-        SavedViewState(
-          value: newValue,
-          selectedSavedViewId: view.id == state.selectedSavedViewId
-              ? null
-              : state.selectedSavedViewId,
-        ),
-      );
-      return id;
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      }
-      rethrow;
-    }
+  Future<int> remove(SavedView view) async {
+    final id = await getIt<SavedViewsRepository>().delete(view);
+    final newValue = {...state.value};
+    newValue.removeWhere((key, value) => key == id);
+    emit(
+      SavedViewState(
+        value: newValue,
+        selectedSavedViewId: view.id == state.selectedSavedViewId
+            ? null
+            : state.selectedSavedViewId,
+      ),
+    );
+    return id;
   }
 
-  Future<void> initialize({
-    bool propagateEventOnError = true,
-  }) async {
-    try {
-      final views = await getIt<SavedViewsRepository>().getAll();
-      final values = {for (var element in views) element.id!: element};
-      emit(SavedViewState(value: values));
-    } on ErrorMessage catch (error) {
-      if (propagateEventOnError) {
-        errorCubit.add(error);
-      }
-      rethrow;
-    }
+  Future<void> initialize() async {
+    final views = await getIt<SavedViewsRepository>().getAll();
+    final values = {for (var element in views) element.id!: element};
+    emit(SavedViewState(value: values));
   }
 
   void resetSelection() {