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

2025-12-13 18:12:20 -06:00 · 2022-11-13 14:41:42 +01:00
parent afbd4bddb4
commit 1cafd5d246
43 changed files with 644 additions and 746 deletions
--- a/lib/features/documents/bloc/documents_cubit.dart
+++ b/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)) {
--- a/lib/features/documents/bloc/saved_view_cubit.dart
+++ b/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() {
--- a/lib/features/documents/model/paged_search_result.dart
+++ b/lib/features/documents/model/paged_search_result.dart
@@ -4,6 +4,13 @@ import 'package:paperless_mobile/features/documents/model/document.model.dart';

 const pageRegex = r".*page=(\d+).*";

+class PagedSearchResultJsonSerializer<T> {
+  final JSON json;
+  final T Function(JSON) fromJson;
+
+  PagedSearchResultJsonSerializer(this.json, this.fromJson);
+}
+
 class PagedSearchResult<T> extends Equatable {
  /// Total number of available items
  final int count;
@@ -46,12 +53,14 @@ class PagedSearchResult<T> extends Equatable {
  });

  factory PagedSearchResult.fromJson(
-      Map<dynamic, dynamic> json, T Function(JSON) fromJson) {
+      PagedSearchResultJsonSerializer<T> serializer) {
    return PagedSearchResult(
-      count: json['count'],
-      next: json['next'],
-      previous: json['previous'],
-      results: List<JSON>.from(json['results']).map<T>(fromJson).toList(),
+      count: serializer.json['count'],
+      next: serializer.json['next'],
+      previous: serializer.json['previous'],
+      results: List<JSON>.from(serializer.json['results'])
+          .map<T>(serializer.fromJson)
+          .toList(),
    );
  }

--- a/lib/features/documents/repository/document_repository_impl.dart
+++ b/lib/features/documents/repository/document_repository_impl.dart
@@ -138,8 +138,10 @@ class DocumentRepositoryImpl implements DocumentRepository {
        body: json.encode(doc.toJson()),
        headers: {"Content-Type": "application/json"}).timeout(requestTimeout);
    if (response.statusCode == 200) {
-      return DocumentModel.fromJson(
-          jsonDecode(utf8.decode(response.bodyBytes)));
+      return compute(
+        DocumentModel.fromJson,
+        jsonDecode(utf8.decode(response.bodyBytes)) as JSON,
+      );
    } else {
      throw const ErrorMessage(ErrorCode.documentUpdateFailed);
    }
@@ -152,11 +154,13 @@ class DocumentRepositoryImpl implements DocumentRepository {
      Uri.parse("/api/documents/?$filterParams"),
    );
    if (response.statusCode == 200) {
-      final searchResult = PagedSearchResult.fromJson(
-        jsonDecode(utf8.decode(response.bodyBytes)),
-        DocumentModel.fromJson,
+      return compute(
+        PagedSearchResult.fromJson,
+        PagedSearchResultJsonSerializer<DocumentModel>(
+          jsonDecode(utf8.decode(response.bodyBytes)),
+          DocumentModel.fromJson,
+        ),
      );
-      return searchResult;
    } else {
      throw const ErrorMessage(ErrorCode.documentLoadFailed);
    }
@@ -261,8 +265,10 @@ class DocumentRepositoryImpl implements DocumentRepository {
  Future<DocumentMetaData> getMetaData(DocumentModel document) async {
    final response = await httpClient
        .get(Uri.parse("/api/documents/${document.id}/metadata/"));
-    return DocumentMetaData.fromJson(
-        jsonDecode(utf8.decode(response.bodyBytes)));
+    return compute(
+      DocumentMetaData.fromJson,
+      jsonDecode(utf8.decode(response.bodyBytes)) as JSON,
+    );
  }

  @override
@@ -280,10 +286,14 @@ class DocumentRepositoryImpl implements DocumentRepository {
    final response = await httpClient
        .get(Uri.parse("/api/documents/?more_like=$docId&pageSize=10"));
    if (response.statusCode == 200) {
-      return PagedSearchResult<SimilarDocumentModel>.fromJson(
-        jsonDecode(utf8.decode(response.bodyBytes)),
-        SimilarDocumentModel.fromJson,
-      ).results;
+      return (await compute(
+        PagedSearchResult<SimilarDocumentModel>.fromJson,
+        PagedSearchResultJsonSerializer(
+          jsonDecode(utf8.decode(response.bodyBytes)),
+          SimilarDocumentModel.fromJson,
+        ),
+      ))
+          .results;
    }
    throw const ErrorMessage(ErrorCode.similarQueryError);
  }
--- a/lib/features/documents/view/pages/document_details_page.dart
+++ b/lib/features/documents/view/pages/document_details_page.dart
@@ -198,10 +198,8 @@ class _DocumentDetailsPageState extends State<DocumentDetailsPage> {
                      child: Text(S
                          .of(context)
                          .documentDetailsPageAssignAsnButtonLabel),
-                      onPressed: widget.allowEdit
-                          ? () => BlocProvider.of<DocumentsCubit>(context)
-                              .assignAsn(document)
-                          : null,
+                      onPressed:
+                          widget.allowEdit ? () => _assignAsn(document) : null,
                    ),
            ),
            _separator(),
@@ -233,6 +231,14 @@ class _DocumentDetailsPageState extends State<DocumentDetailsPage> {
    );
  }

+  Future<void> _assignAsn(DocumentModel document) async {
+    try {
+      await BlocProvider.of<DocumentsCubit>(context).assignAsn(document);
+    } on ErrorMessage catch (error) {
+      showError(context, error);
+    }
+  }
+
  Widget _buildDocumentContentView(DocumentModel document, String? match) {
    return SingleChildScrollView(
      child: _DetailsItem(
@@ -392,21 +398,23 @@ class _DocumentDetailsPageState extends State<DocumentDetailsPage> {
    );
  }

-  Future<void> _onDelete(DocumentModel document) async {
-    showDialog(
-            context: context,
-            builder: (context) =>
-                DeleteDocumentConfirmationDialog(document: document))
-        .then((delete) {
-      if (delete ?? false) {
-        BlocProvider.of<DocumentsCubit>(context)
-            .removeDocument(document)
-            .then((value) {
-          Navigator.pop(context);
-          showSnackBar(context, S.of(context).documentDeleteSuccessMessage);
-        });
+  void _onDelete(DocumentModel document) async {
+    final delete = await showDialog(
+          context: context,
+          builder: (context) =>
+              DeleteDocumentConfirmationDialog(document: document),
+        ) ??
+        false;
+    if (delete) {
+      try {
+        await BlocProvider.of<DocumentsCubit>(context).removeDocument(document);
+        showSnackBar(context, S.of(context).documentDeleteSuccessMessage);
+      } on ErrorMessage catch (error) {
+        showError(context, error);
+      } finally {
+        Navigator.pop(context);
      }
-    });
+    }
  }

  Future<void> _onOpen(DocumentModel document) async {
--- a/lib/features/documents/view/pages/document_edit_page.dart
+++ b/lib/features/documents/view/pages/document_edit_page.dart
@@ -3,6 +3,7 @@ import 'dart:typed_data';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:flutter_form_builder/flutter_form_builder.dart';
+import 'package:paperless_mobile/core/model/error_message.dart';
 import 'package:paperless_mobile/di_initializer.dart';
 import 'package:paperless_mobile/extensions/flutter_extensions.dart';
 import 'package:paperless_mobile/features/documents/bloc/documents_cubit.dart';
@@ -76,10 +77,14 @@ class _DocumentEditPageState extends State<DocumentEditPage> {
            setState(() {
              _isSubmitLoading = true;
            });
-            await getIt<DocumentsCubit>().updateDocument(updatedDocument);
-            Navigator.pop(context);
-            showSnackBar(
-                context, "Document successfully updated."); //TODO: INTL
+            try {
+              await getIt<DocumentsCubit>().updateDocument(updatedDocument);
+              showSnackBar(context, S.of(context).documentUpdateErrorMessage);
+            } on ErrorMessage catch (error) {
+              showError(context, error);
+            } finally {
+              Navigator.pop(context);
+            }
          }
        },
        icon: const Icon(Icons.save),
--- a/lib/features/documents/view/pages/documents_page.dart
+++ b/lib/features/documents/view/pages/documents_page.dart
@@ -44,13 +44,20 @@ class _DocumentsPageState extends State<DocumentsPage> {
  @override
  void initState() {
    super.initState();
-    final documentsCubit = BlocProvider.of<DocumentsCubit>(context);
-    if (!documentsCubit.state.isLoaded) {
-      documentsCubit.loadDocuments();
+    if (!BlocProvider.of<DocumentsCubit>(context).state.isLoaded) {
+      _initDocuments();
    }
    _pagingController.addPageRequestListener(_loadNewPage);
  }

+  Future<void> _initDocuments() async {
+    try {
+      BlocProvider.of<DocumentsCubit>(context).loadDocuments();
+    } on ErrorMessage catch (error) {
+      showError(context, error);
+    }
+  }
+
  @override
  void dispose() {
    _pagingController.dispose();
@@ -64,17 +71,25 @@ class _DocumentsPageState extends State<DocumentsPage> {
    if (pageCount <= pageKey + 1) {
      _pagingController.nextPageKey = null;
    }
-    documentsCubit.loadMore();
+    try {
+      await documentsCubit.loadMore();
+    } on ErrorMessage catch (error) {
+      showError(context, error);
+    }
  }

  void _onSelected(DocumentModel model) {
    BlocProvider.of<DocumentsCubit>(context).toggleDocumentSelection(model);
  }

-  Future<void> _onRefresh() {
-    final documentsCubit = BlocProvider.of<DocumentsCubit>(context);
-    return documentsCubit.updateFilter(
-        filter: documentsCubit.state.filter.copyWith(page: 1));
+  Future<void> _onRefresh() async {
+    try {
+      await BlocProvider.of<DocumentsCubit>(context).updateCurrentFilter(
+        (filter) => filter.copyWith(page: 1),
+      );
+    } on ErrorMessage catch (error) {
+      showError(context, error);
+    }
  }

  @override
@@ -86,9 +101,9 @@ class _DocumentsPageState extends State<DocumentsPage> {
          _panelController.close();
          return false;
        }
-        final docBloc = BlocProvider.of<DocumentsCubit>(context);
-        if (docBloc.state.selection.isNotEmpty) {
-          docBloc.resetSelection();
+        final documentsCubit = BlocProvider.of<DocumentsCubit>(context);
+        if (documentsCubit.state.selection.isNotEmpty) {
+          documentsCubit.resetSelection();
          return false;
        }
        return true;
--- a/lib/features/documents/view/widgets/search/document_filter_panel.dart
+++ b/lib/features/documents/view/widgets/search/document_filter_panel.dart
@@ -513,7 +513,7 @@ class _DocumentFilterPanelState extends State<DocumentFilterPanel> {
    );
  }

-  void _onApplyFilter() {
+  void _onApplyFilter() async {
    if (_formKey.currentState?.saveAndValidate() ?? false) {
      final v = _formKey.currentState!.value;
      final docCubit = BlocProvider.of<DocumentsCubit>(context);
@@ -530,13 +530,15 @@ class _DocumentFilterPanelState extends State<DocumentFilterPanel> {
        addedDateAfter: (v[fkAddedAt] as DateTimeRange?)?.start,
        queryType: v[QueryTypeFormField.fkQueryType] as QueryType,
      );
-      BlocProvider.of<DocumentsCubit>(context)
-          .updateFilter(filter: newFilter)
-          .then((value) {
+      try {
+        await BlocProvider.of<DocumentsCubit>(context)
+            .updateFilter(filter: newFilter);
        BlocProvider.of<SavedViewCubit>(context).resetSelection();
        FocusScope.of(context).unfocus();
        widget.panelController.close();
-      });
+      } on ErrorMessage catch (error) {
+        showError(context, error);
+      }
    }
  }

--- a/lib/features/documents/view/widgets/selection/documents_page_app_bar.dart
+++ b/lib/features/documents/view/widgets/selection/documents_page_app_bar.dart
@@ -74,14 +74,22 @@ class _DocumentsPageAppBarState extends State<DocumentsPageAppBar> {

  void _onDelete(BuildContext context, DocumentsState documentsState) async {
    final shouldDelete = await showDialog<bool>(
-      context: context,
-      builder: (context) => BulkDeleteConfirmationDialog(state: documentsState),
-    );
-    if (shouldDelete ?? false) {
-      BlocProvider.of<DocumentsCubit>(context)
-          .bulkRemoveDocuments(documentsState.selection)
-          .then((_) => showSnackBar(
-              context, S.of(context).documentsPageBulkDeleteSuccessfulText));
+          context: context,
+          builder: (context) =>
+              BulkDeleteConfirmationDialog(state: documentsState),
+        ) ??
+        false;
+    if (shouldDelete) {
+      try {
+        await BlocProvider.of<DocumentsCubit>(context)
+            .bulkRemoveDocuments(documentsState.selection);
+        showSnackBar(
+          context,
+          S.of(context).documentsPageBulkDeleteSuccessfulText,
+        );
+      } on ErrorMessage catch (error) {
+        showError(context, error);
+      }
    }
  }

--- a/lib/features/documents/view/widgets/selection/saved_view_selection_widget.dart
+++ b/lib/features/documents/view/widgets/selection/saved_view_selection_widget.dart
@@ -78,22 +78,32 @@ class SavedViewSelectionWidget extends StatelessWidget {
    final newView = await Navigator.of(context).push<SavedView?>(
      MaterialPageRoute(
        builder: (context) => AddSavedViewPage(
-            currentFilter: getIt<DocumentsCubit>().state.filter),
+          currentFilter: getIt<DocumentsCubit>().state.filter,
+        ),
      ),
    );
    if (newView != null) {
-      BlocProvider.of<SavedViewCubit>(context).add(newView);
+      try {
+        await BlocProvider.of<SavedViewCubit>(context).add(newView);
+      } on ErrorMessage catch (error) {
+        showError(context, error);
+      }
    }
  }

-  void _onSelected(bool isSelected, BuildContext context, SavedView view) {
-    if (isSelected) {
-      BlocProvider.of<DocumentsCubit>(context)
-          .updateFilter(filter: view.toDocumentFilter());
-      BlocProvider.of<SavedViewCubit>(context).selectView(view);
-    } else {
-      BlocProvider.of<DocumentsCubit>(context).updateFilter();
-      BlocProvider.of<SavedViewCubit>(context).selectView(null);
+  void _onSelected(
+      bool isSelected, BuildContext context, SavedView view) async {
+    try {
+      if (isSelected) {
+        BlocProvider.of<DocumentsCubit>(context)
+            .updateFilter(filter: view.toDocumentFilter());
+        BlocProvider.of<SavedViewCubit>(context).selectView(view);
+      } else {
+        BlocProvider.of<DocumentsCubit>(context).updateFilter();
+        BlocProvider.of<SavedViewCubit>(context).selectView(null);
+      }
+    } on ErrorMessage catch (error) {
+      showError(context, error);
    }
  }

@@ -105,7 +115,11 @@ class SavedViewSelectionWidget extends StatelessWidget {
          ) ??
          false;
      if (delete) {
-        BlocProvider.of<SavedViewCubit>(context).remove(view);
+        try {
+          BlocProvider.of<SavedViewCubit>(context).remove(view);
+        } on ErrorMessage catch (error) {
+          showError(context, error);
+        }
      }
    }
  }
--- a/lib/features/documents/view/widgets/sort_documents_button.dart
+++ b/lib/features/documents/view/widgets/sort_documents_button.dart
@@ -43,11 +43,18 @@ class _SortDocumentsButtonState extends State<SortDocumentsButton> {
            ),
            onPressed: () async {
              setState(() => _isLoading = true);
-              BlocProvider.of<DocumentsCubit>(context)
-                  .updateFilter(
-                      filter: state.filter
-                          .copyWith(sortOrder: state.filter.sortOrder.toggle()))
-                  .whenComplete(() => setState(() => _isLoading = false));
+              try {
+                await BlocProvider.of<DocumentsCubit>(context)
+                    .updateCurrentFilter(
+                  (filter) => filter.copyWith(
+                    sortOrder: state.filter.sortOrder.toggle(),
+                  ),
+                );
+              } on ErrorMessage catch (error) {
+                showError(context, error);
+              } finally {
+                setState(() => _isLoading = false);
+              }
            },
          );
        }