Documents

lib/data/repositories/expense_repository.dart

@@ -72,4 +72,20 @@ class ExpenseRepository {
 
     return expenseResponse.data;
   }
+
+  Future<ExpenseEntity> uploadDocument(
+      Credentials credentials, BaseEntity entity, String filePath) async {
+    final fields = <String, String>{
+      '_method': 'put',
+    };
+
+    final dynamic response = await webClient.post(
+        '${credentials.url}/expenses/${entity.id}', credentials.token,
+        data: fields, filePath: filePath, fileIndex: 'documents[]');
+
+    final ExpenseItemResponse expenseResponse =
+    serializers.deserializeWith(ExpenseItemResponse.serializer, response);
+
+    return expenseResponse.data;
+  }
 }

lib/data/repositories/project_repository.dart

@@ -72,4 +72,20 @@ class ProjectRepository {
 
     return projectResponse.data;
   }
+
+  Future<ProjectEntity> uploadDocument(
+      Credentials credentials, BaseEntity entity, String filePath) async {
+    final fields = <String, String>{
+      '_method': 'put',
+    };
+
+    final dynamic response = await webClient.post(
+        '${credentials.url}/projects/${entity.id}', credentials.token,
+        data: fields, filePath: filePath, fileIndex: 'documents[]');
+
+    final ProjectItemResponse projectResponse =
+        serializers.deserializeWith(ProjectItemResponse.serializer, response);
+
+    return projectResponse.data;
+  }
 }

lib/data/repositories/task_repository.dart

@@ -76,4 +76,20 @@ class TaskRepository {
 
     return taskResponse.data;
   }
+
+  Future<TaskEntity> uploadDocument(
+      Credentials credentials, BaseEntity entity, String filePath) async {
+    final fields = <String, String>{
+      '_method': 'put',
+    };
+
+    final dynamic response = await webClient.post(
+        '${credentials.url}/tasks/${entity.id}', credentials.token,
+        data: fields, filePath: filePath, fileIndex: 'documents[]');
+
+    final TaskItemResponse taskResponse =
+    serializers.deserializeWith(TaskItemResponse.serializer, response);
+
+    return taskResponse.data;
+  }
 }

lib/data/repositories/vendor_repository.dart

@@ -72,4 +72,20 @@ class VendorRepository {
 
     return vendorResponse.data;
   }
+
+  Future<VendorEntity> uploadDocument(
+      Credentials credentials, BaseEntity entity, String filePath) async {
+    final fields = <String, String>{
+      '_method': 'put',
+    };
+
+    final dynamic response = await webClient.post(
+        '${credentials.url}/vendors/${entity.id}', credentials.token,
+        data: fields, filePath: filePath, fileIndex: 'documents[]');
+
+    final VendorItemResponse vendorResponse =
+    serializers.deserializeWith(VendorItemResponse.serializer, response);
+
+    return vendorResponse.data;
+  }
 }

lib/redux/expense/expense_middleware.dart

@@ -25,6 +25,7 @@ List<Middleware<AppState>> createStoreExpensesMiddleware([
   final archiveExpense = _archiveExpense(repository);
   final deleteExpense = _deleteExpense(repository);
   final restoreExpense = _restoreExpense(repository);
+  final saveDocument = _saveDocument(repository);
 
   return [
     TypedMiddleware<AppState, ViewExpenseList>(viewExpenseList),
@@ -36,6 +37,7 @@ List<Middleware<AppState>> createStoreExpensesMiddleware([
     TypedMiddleware<AppState, ArchiveExpenseRequest>(archiveExpense),
     TypedMiddleware<AppState, DeleteExpenseRequest>(deleteExpense),
     TypedMiddleware<AppState, RestoreExpenseRequest>(restoreExpense),
+    TypedMiddleware<AppState, SaveExpenseDocumentRequest>(saveDocument),
   ];
 }
 
@@ -238,3 +240,28 @@ Middleware<AppState> _loadExpenses(ExpenseRepository repository) {
     next(action);
   };
 }
+
+Middleware<AppState> _saveDocument(ExpenseRepository repository) {
+  return (Store<AppState> store, dynamic dynamicAction, NextDispatcher next) {
+    final action = dynamicAction as SaveExpenseDocumentRequest;
+    if (store.state.isEnterprisePlan) {
+      repository
+          .uploadDocument(
+          store.state.credentials, action.expense, action.filePath)
+          .then((expense) {
+        store.dispatch(SaveExpenseSuccess(expense));
+        action.completer.complete(null);
+      }).catchError((Object error) {
+        print(error);
+        store.dispatch(SaveExpenseDocumentFailure(error));
+        action.completer.completeError(error);
+      });
+    } else {
+      const error = 'Uploading documents requires an enterprise plan';
+      store.dispatch(SaveExpenseDocumentFailure(error));
+      action.completer.completeError(error);
+    }
+
+    next(action);
+  };
+}

lib/redux/project/project_middleware.dart

@@ -25,6 +25,7 @@ List<Middleware<AppState>> createStoreProjectsMiddleware([
   final archiveProject = _archiveProject(repository);
   final deleteProject = _deleteProject(repository);
   final restoreProject = _restoreProject(repository);
+  final saveDocument = _saveDocument(repository);
 
   return [
     TypedMiddleware<AppState, ViewProjectList>(viewProjectList),
@@ -36,6 +37,7 @@ List<Middleware<AppState>> createStoreProjectsMiddleware([
     TypedMiddleware<AppState, ArchiveProjectRequest>(archiveProject),
     TypedMiddleware<AppState, DeleteProjectRequest>(deleteProject),
     TypedMiddleware<AppState, RestoreProjectRequest>(restoreProject),
+    TypedMiddleware<AppState, SaveProjectDocumentRequest>(saveDocument),
   ];
 }
 
@@ -245,3 +247,28 @@ Middleware<AppState> _loadProjects(ProjectRepository repository) {
     next(action);
   };
 }
+
+Middleware<AppState> _saveDocument(ProjectRepository repository) {
+  return (Store<AppState> store, dynamic dynamicAction, NextDispatcher next) {
+    final action = dynamicAction as SaveProjectDocumentRequest;
+    if (store.state.isEnterprisePlan) {
+      repository
+          .uploadDocument(
+          store.state.credentials, action.project, action.filePath)
+          .then((project) {
+        store.dispatch(SaveProjectSuccess(project));
+        action.completer.complete(null);
+      }).catchError((Object error) {
+        print(error);
+        store.dispatch(SaveProjectDocumentFailure(error));
+        action.completer.completeError(error);
+      });
+    } else {
+      const error = 'Uploading documents requires an enterprise plan';
+      store.dispatch(SaveProjectDocumentFailure(error));
+      action.completer.completeError(error);
+    }
+
+    next(action);
+  };
+}

lib/redux/task/task_middleware.dart

@@ -25,6 +25,7 @@ List<Middleware<AppState>> createStoreTasksMiddleware([
   final archiveTask = _archiveTask(repository);
   final deleteTask = _deleteTask(repository);
   final restoreTask = _restoreTask(repository);
+  final saveDocument = _saveDocument(repository);
 
   return [
     TypedMiddleware<AppState, ViewTaskList>(viewTaskList),
@@ -36,6 +37,7 @@ List<Middleware<AppState>> createStoreTasksMiddleware([
     TypedMiddleware<AppState, ArchiveTaskRequest>(archiveTask),
     TypedMiddleware<AppState, DeleteTaskRequest>(deleteTask),
     TypedMiddleware<AppState, RestoreTaskRequest>(restoreTask),
+    TypedMiddleware<AppState, SaveTaskDocumentRequest>(saveDocument),
   ];
 }
 
@@ -234,3 +236,28 @@ Middleware<AppState> _loadTasks(TaskRepository repository) {
     next(action);
   };
 }
+
+Middleware<AppState> _saveDocument(TaskRepository repository) {
+  return (Store<AppState> store, dynamic dynamicAction, NextDispatcher next) {
+    final action = dynamicAction as SaveTaskDocumentRequest;
+    if (store.state.isEnterprisePlan) {
+      repository
+          .uploadDocument(
+          store.state.credentials, action.task, action.filePath)
+          .then((task) {
+        store.dispatch(SaveTaskSuccess(task));
+        action.completer.complete(null);
+      }).catchError((Object error) {
+        print(error);
+        store.dispatch(SaveTaskDocumentFailure(error));
+        action.completer.completeError(error);
+      });
+    } else {
+      const error = 'Uploading documents requires an enterprise plan';
+      store.dispatch(SaveTaskDocumentFailure(error));
+      action.completer.completeError(error);
+    }
+
+    next(action);
+  };
+}

lib/redux/vendor/vendor_middleware.dart

@@ -25,6 +25,7 @@ List<Middleware<AppState>> createStoreVendorsMiddleware([
   final archiveVendor = _archiveVendor(repository);
   final deleteVendor = _deleteVendor(repository);
   final restoreVendor = _restoreVendor(repository);
+  final saveDocument = _saveDocument(repository);
 
   return [
     TypedMiddleware<AppState, ViewVendorList>(viewVendorList),
@@ -36,6 +37,7 @@ List<Middleware<AppState>> createStoreVendorsMiddleware([
     TypedMiddleware<AppState, ArchiveVendorRequest>(archiveVendor),
     TypedMiddleware<AppState, DeleteVendorRequest>(deleteVendor),
     TypedMiddleware<AppState, RestoreVendorRequest>(restoreVendor),
+    TypedMiddleware<AppState, SaveVendorDocumentRequest>(saveDocument),
   ];
 }
 
@@ -242,3 +244,28 @@ Middleware<AppState> _loadVendors(VendorRepository repository) {
     next(action);
   };
 }
+
+Middleware<AppState> _saveDocument(VendorRepository repository) {
+  return (Store<AppState> store, dynamic dynamicAction, NextDispatcher next) {
+    final action = dynamicAction as SaveVendorDocumentRequest;
+    if (store.state.isEnterprisePlan) {
+      repository
+          .uploadDocument(
+          store.state.credentials, action.vendor, action.filePath)
+          .then((vendor) {
+        store.dispatch(SaveVendorSuccess(vendor));
+        action.completer.complete(null);
+      }).catchError((Object error) {
+        print(error);
+        store.dispatch(SaveVendorDocumentFailure(error));
+        action.completer.completeError(error);
+      });
+    } else {
+      const error = 'Uploading documents requires an enterprise plan';
+      store.dispatch(SaveVendorDocumentFailure(error));
+      action.completer.completeError(error);
+    }
+
+    next(action);
+  };
+}