xevion/paperless-mobile
1
0
Fork 0
mirror of https://github.com/Xevion/paperless-mobile.git synced 2025-12-09 10:08:00 -06:00
Code Issues Packages Projects Releases Wiki Activity

Updated onboarding, reformatted files, improved referenced documents view, updated error handling

Browse Source
This commit is contained in:
Anton Stubenbord
2022-11-03 22:15:36 +01:00
parent 2f2312d5f3
commit 40133b6e0e
117 changed files with 1788 additions and 1021 deletions
Download Patch File Download Diff File Expand all files Collapse all files

220
lib/features/documents/bloc/documents_cubit.dart
View File

@@ -1,6 +1,8 @@
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';
import 'package:paperless_mobile/features/documents/model/document_filter.dart';
@@ -11,8 +13,10 @@ import 'package:injectable/injectable.dart';
@singleton
class DocumentsCubit extends Cubit<DocumentsState> {
final DocumentRepository documentRepository;
final GlobalErrorCubit errorCubit;
DocumentsCubit(this.documentRepository) : super(DocumentsState.initial);
DocumentsCubit(this.documentRepository, this.errorCubit)
: super(DocumentsState.initial);
Future<void> addDocument(
Uint8List bytes,
@@ -23,101 +27,217 @@ class DocumentsCubit extends Cubit<DocumentsState> {
int? correspondent,
List<int>? tags,
DateTime? createdAt,
bool propagateEventOnError = true,
}) async {
await documentRepository.create(
bytes,
fileName,
title: title,
documentType: documentType,
correspondent: correspondent,
tags: tags,
createdAt: createdAt,
);
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;
}
}
// documentRepository
// .waitForConsumptionFinished(fileName, title)
// .then((value) => onConsumptionFinished(value));
}
Future<void> removeDocument(DocumentModel document) async {
await documentRepository.delete(document);
return await reloadDocuments();
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> bulkRemoveDocuments(List<DocumentModel> documents) async {
await documentRepository.bulkDelete(documents);
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> updateDocument(DocumentModel document) async {
await documentRepository.update(document);
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> loadDocuments() async {
final result = await documentRepository.find(state.filter);
emit(DocumentsState(
isLoaded: true,
value: [...state.value, result],
filter: state.filter,
));
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> reloadDocuments() async {
Future<void> reloadDocuments({
bool propagateEventOnError = true,
}) async {
if (state.currentPageNumber >= 5) {
return _bulkReloadDocuments();
}
var newPages = <PagedSearchResult>[];
for (final page in state.value) {
final result = await documentRepository.find(state.filter.copyWith(page: page.pageKey));
newPages.add(result);
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;
}
}
emit(DocumentsState(isLoaded: true, value: newPages, filter: state.filter));
}
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> _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> loadMore() async {
Future<void> loadMore({
bool propagateEventOnError = true,
}) async {
if (state.isLastPageLoaded) {
return;
}
final newFilter = state.filter.copyWith(page: state.filter.page + 1);
final result = await documentRepository.find(newFilter);
emit(DocumentsState(isLoaded: true, value: [...state.value, result], filter: newFilter));
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;
}
}
}
Future<void> assignAsn(DocumentModel document) async {
if (document.archiveSerialNumber == null) {
final int asn = await documentRepository.findNextAsn();
updateDocument(document.copyWith(archiveSerialNumber: asn));
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;
}
}
}
///
/// 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,
}) async {
final result = await documentRepository.find(filter.copyWith(page: 1));
emit(DocumentsState(filter: filter, value: [result], isLoaded: true));
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;
}
}
}
///
/// Convenience method which allows to directly use [DocumentFilter.copyWith] on the current filter.
///
Future<void> updateCurrentFilter(final DocumentFilter Function(DocumentFilter) transformFn) {
return updateFilter(filter: transformFn(state.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;
}
}
}
void toggleDocumentSelection(DocumentModel model) {
if (state.selection.contains(model)) {
emit(
state.copyWith(
selection: state.selection.where((element) => element.id != model.id).toList(),
selection: state.selection
.where((element) => element.id != model.id)
.toList(),
),
);
} else {