Merged submission module code

src/app/submission/objects/submission-objects.effects.ts

@@ -0,0 +1,338 @@
+import { Injectable } from '@angular/core';
+import { Actions, Effect } from '@ngrx/effects';
+
+import { union } from 'lodash';
+
+import {
+  CompleteInitSubmissionFormAction,
+  DepositSubmissionAction,
+  DepositSubmissionErrorAction,
+  DepositSubmissionSuccessAction,
+  DiscardSubmissionErrorAction,
+  DiscardSubmissionSuccessAction,
+  InitSectionAction,
+  LoadSubmissionFormAction,
+  ResetSubmissionFormAction,
+  SaveAndDepositSubmissionAction,
+  SaveForLaterSubmissionFormAction,
+  SaveForLaterSubmissionFormSuccessAction,
+  SaveSubmissionFormAction,
+  SaveSubmissionFormErrorAction,
+  SaveSubmissionFormSuccessAction,
+  SaveSubmissionSectionFormAction,
+  SaveSubmissionSectionFormErrorAction,
+  SaveSubmissionSectionFormSuccessAction,
+  SetWorkflowDuplicatedAction,
+  SetWorkflowDuplicatedErrorAction,
+  SetWorkflowDuplicatedSuccessAction,
+  SetWorkspaceDuplicatedAction,
+  SetWorkspaceDuplicatedErrorAction,
+  SetWorkspaceDuplicatedSuccessAction,
+  SubmissionObjectActionTypes,
+  UpdateSectionDataAction
+} from './submission-objects.actions';
+import { SectionsService } from '../sections/sections.service';
+import { isEmpty, isNotEmpty, isNotUndefined } from '../../shared/empty.util';
+import { Workspaceitem } from '../../core/submission/models/workspaceitem.model';
+import { Observable } from 'rxjs/Observable';
+import { JsonPatchOperationsService } from '../../core/json-patch/json-patch-operations.service';
+import { SubmitDataResponseDefinitionObject } from '../../core/shared/submit-data-response-definition.model';
+import { SubmissionService } from '../submission.service';
+import { Action, Store } from '@ngrx/store';
+import { Workflowitem } from '../../core/submission/models/workflowitem.model';
+import { NotificationsService } from '../../shared/notifications/notifications.service';
+import { SubmissionObject } from '../../core/submission/models/submission-object.model';
+import { TranslateService } from '@ngx-translate/core';
+import { DeduplicationService } from '../sections/deduplication/deduplication.service';
+import { SubmissionState } from '../submission.reducers';
+import { SubmissionObjectEntry } from './submission-objects.reducer';
+import { SubmissionSectionModel } from '../../core/shared/config/config-submission-section.model';
+import parseSectionErrors from '../utils/parseSectionErrors';
+
+@Injectable()
+export class SubmissionObjectEffects {
+
+  @Effect() loadForm$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.LOAD_SUBMISSION_FORM)
+    .map((action: LoadSubmissionFormAction) => {
+      const definition = action.payload.submissionDefinition;
+      const mappedActions = [];
+      definition.sections.forEach((sectionDefinition: SubmissionSectionModel, index: number) => {
+        const sectionId = sectionDefinition._links.self.substr(sectionDefinition._links.self.lastIndexOf('/') + 1);
+        const config = sectionDefinition._links.config || '';
+        const enabled = sectionDefinition.mandatory || (isNotEmpty(action.payload.sections) && action.payload.sections.hasOwnProperty(sectionId));
+        const sectionData = (isNotUndefined(action.payload.sections) && isNotUndefined(action.payload.sections[sectionId])) ? action.payload.sections[sectionId] : Object.create(null);
+        const sectionErrors = null;
+        mappedActions.push(
+          new InitSectionAction(
+            action.payload.submissionId,
+            sectionId,
+            sectionDefinition.header,
+            config,
+            sectionDefinition.mandatory,
+            sectionDefinition.sectionType,
+            sectionDefinition.visibility,
+            enabled,
+            sectionData,
+            sectionErrors
+          )
+        )
+      });
+      return {action: action, definition: definition, mappedActions: mappedActions};
+    })
+    .mergeMap((result) => {
+      return Observable.from(
+        result.mappedActions.concat(
+          new CompleteInitSubmissionFormAction(result.action.payload.submissionId)
+        ));
+    });
+
+  @Effect() resetForm$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.RESET_SUBMISSION_FORM)
+    .map((action: ResetSubmissionFormAction) =>
+      new LoadSubmissionFormAction(
+        action.payload.collectionId,
+        action.payload.submissionId,
+        action.payload.selfUrl,
+        action.payload.submissionDefinition,
+        action.payload.sections,
+        null
+      ));
+
+  @Effect() saveSubmission$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.SAVE_SUBMISSION_FORM)
+    .switchMap((action: SaveSubmissionFormAction) => {
+      return this.operationsService.jsonPatchByResourceType(
+        this.submissionService.getSubmissionObjectLinkName(),
+        action.payload.submissionId,
+        'sections')
+        .map((response: SubmissionObject[]) => new SaveSubmissionFormSuccessAction(action.payload.submissionId, response))
+        .catch(() => Observable.of(new SaveSubmissionFormErrorAction(action.payload.submissionId)));
+    });
+
+  @Effect() saveForLaterSubmission$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.SAVE_FOR_LATER_SUBMISSION_FORM)
+    .switchMap((action: SaveForLaterSubmissionFormAction) => {
+      return this.operationsService.jsonPatchByResourceType(
+        this.submissionService.getSubmissionObjectLinkName(),
+        action.payload.submissionId,
+        'sections')
+        .map((response: SubmissionObject[]) => new SaveForLaterSubmissionFormSuccessAction(action.payload.submissionId, response))
+        .catch(() => Observable.of(new SaveSubmissionFormErrorAction(action.payload.submissionId)));
+    });
+
+  @Effect() saveSubmissionSuccess$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.SAVE_SUBMISSION_FORM_SUCCESS, SubmissionObjectActionTypes.SAVE_SUBMISSION_SECTION_FORM_SUCCESS)
+    .withLatestFrom(this.store$)
+    .map(([action, currentState]: [SaveSubmissionFormSuccessAction | SaveSubmissionSectionFormSuccessAction, any]) => {
+      return this.parseSaveResponse((currentState.submission as SubmissionState).objects[action.payload.submissionId], action.payload.submissionObject, action.payload.submissionId);
+    })
+    .mergeMap((actions) => {
+      return Observable.from(actions);
+    });
+
+  @Effect() saveSection$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.SAVE_SUBMISSION_SECTION_FORM)
+    .switchMap((action: SaveSubmissionSectionFormAction) => {
+      return this.operationsService.jsonPatchByResourceID(
+        this.submissionService.getSubmissionObjectLinkName(),
+        action.payload.submissionId,
+        'sections',
+        action.payload.sectionId)
+        .map((response: SubmissionObject[]) => new SaveSubmissionSectionFormSuccessAction(action.payload.submissionId, response))
+        .catch(() => Observable.of(new SaveSubmissionSectionFormErrorAction(action.payload.submissionId)));
+    });
+
+  @Effect() saveAndDepositSection$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.SAVE_AND_DEPOSIT_SUBMISSION)
+    .withLatestFrom(this.store$)
+    .switchMap(([action, currentState]: [SaveAndDepositSubmissionAction, any]) => {
+      return this.operationsService.jsonPatchByResourceType(
+        this.submissionService.getSubmissionObjectLinkName(),
+        action.payload.submissionId,
+        'sections')
+        .map((response: SubmissionObject[]) => {
+          if (this.canDeposit(response)) {
+            return new DepositSubmissionAction(action.payload.submissionId);
+          } else {
+            this.notificationsService.warning(null, this.translate.get('submission.sections.general.sections_not_valid'));
+            return this.parseSaveResponse((currentState.submission as SubmissionState).objects[action.payload.submissionId], response, action.payload.submissionId);
+          }
+        })
+        .catch(() => Observable.of(new SaveSubmissionSectionFormErrorAction(action.payload.submissionId)));
+    });
+
+  @Effect() depositSubmission$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.DEPOSIT_SUBMISSION)
+    .withLatestFrom(this.store$)
+    .switchMap(([action, state]: [DepositSubmissionAction, any]) => {
+      return this.submissionService.depositSubmission(state.submission.objects[action.payload.submissionId].selfUrl)
+        .map(() => new DepositSubmissionSuccessAction(action.payload.submissionId))
+        .catch((e) => Observable.of(new DepositSubmissionErrorAction(action.payload.submissionId)));
+    });
+
+  @Effect({dispatch: false}) SaveForLaterSubmissionSuccess$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.SAVE_FOR_LATER_SUBMISSION_FORM_SUCCESS)
+    .do(() => this.notificationsService.success(null, this.translate.get('submission.sections.general.save_success_notice')))
+    .do(() => this.submissionService.redirectToMyDSpace());
+
+  @Effect({dispatch: false}) depositSubmissionSuccess$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.DEPOSIT_SUBMISSION_SUCCESS)
+    .do(() => this.notificationsService.success(null, this.translate.get('submission.sections.general.deposit_success_notice')))
+    .do(() => this.submissionService.redirectToMyDSpace());
+
+  @Effect({dispatch: false}) depositSubmissionError$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.DEPOSIT_SUBMISSION_ERROR)
+    .do(() => this.notificationsService.error(null, this.translate.get('submission.sections.general.deposit_error_notice')));
+
+  @Effect() discardSubmission$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.DISCARD_SUBMISSION)
+    .switchMap((action: DepositSubmissionAction) => {
+      return this.submissionService.discardSubmission(action.payload.submissionId)
+        .map(() => new DiscardSubmissionSuccessAction(action.payload.submissionId))
+        .catch((e) => Observable.of(new DiscardSubmissionErrorAction(action.payload.submissionId)));
+    });
+
+  @Effect({dispatch: false}) discardSubmissionSuccess$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.DISCARD_SUBMISSION_SUCCESS)
+    .do(() => this.notificationsService.success(null, this.translate.get('submission.sections.general.discard_success_notice')))
+    .do(() => this.submissionService.redirectToMyDSpace());
+
+  @Effect({dispatch: false}) discardSubmissionError$ = this.actions$
+    .ofType(SubmissionObjectActionTypes.DISCARD_SUBMISSION_ERROR)
+    .do(() => this.notificationsService.error(null, this.translate.get('submission.sections.general.discard_error_notice')));
+
+  @Effect()
+  public wsDuplication: Observable<Action> = this.actions$
+    .ofType(SubmissionObjectActionTypes.SET_WORKSPACE_DUPLICATION)
+    .map((action: SetWorkspaceDuplicatedAction) => {
+      // return this.deduplicationService.setWorkspaceDuplicated(action.payload)
+      //   .first()
+      //   .map((response) => {
+      console.log('Effect of SET_WORKSPACE_DUPLICATION');
+      // TODO JSON PATCH
+      // const pathCombiner = new JsonPatchOperationPathCombiner('sections', 'deduplication');
+      // const path = ''; // `metadata/${metadataKey}`; // TODO
+      // this.operationsBuilder.add(pathCombiner.getPath(path), action.payload, true);
+      return new SetWorkspaceDuplicatedSuccessAction(action.payload);
+    })
+    .catch((error) => Observable.of(new SetWorkspaceDuplicatedErrorAction(error)));
+
+  @Effect({dispatch: false})
+  public wsDuplicationSuccess: Observable<Action> = this.actions$
+    .ofType(SubmissionObjectActionTypes.SET_WORKSPACE_DUPLICATION_SUCCESS)
+    // TODO
+    .do((action: SetWorkspaceDuplicatedAction) => {
+      console.log('Effect of SET_WORKSPACE_DUPLICATION_SUCCESS');
+      this.deduplicationService.setWorkspaceDuplicationSuccess(action.payload);
+    });
+
+  @Effect({dispatch: false})
+  public wsDuplicationError: Observable<Action> = this.actions$
+    .ofType(SubmissionObjectActionTypes.SET_WORKSPACE_DUPLICATION_ERROR)
+    .do((action: SetWorkspaceDuplicatedAction) => {
+      console.log('Effect of SET_WORKSPACE_DUPLICATION_ERROR');
+      this.deduplicationService.setWorkspaceDuplicationError(action.payload);
+    });
+
+  @Effect()
+  public wfDuplication: Observable<Action> = this.actions$
+    .ofType(SubmissionObjectActionTypes.SET_WORKFLOW_DUPLICATION)
+    .map((action: SetWorkflowDuplicatedAction) => {
+      // return this.deduplicationService.setWorkflowDuplicated(action.payload)
+      //   .first()
+      //   .map((response) => {
+      console.log('Effect of SET_WORKFLOW_DUPLICATION');
+      // TODO JSON PATCH
+      // const pathCombiner = new JsonPatchOperationPathCombiner('sections', 'deduplication');
+      // const path = ''; // `metadata/${metadataKey}`; // TODO
+      // this.operationsBuilder.add(pathCombiner.getPath(path), action.payload, true);
+      return new SetWorkflowDuplicatedSuccessAction(action.payload);
+    })
+    .catch((error) => Observable.of(new SetWorkflowDuplicatedErrorAction(error)));
+
+  @Effect({dispatch: false})
+  public wfDuplicationSuccess: Observable<Action> = this.actions$
+    .ofType(SubmissionObjectActionTypes.SET_WORKFLOW_DUPLICATION_SUCCESS)
+    // TODO
+    .do((action: SetWorkflowDuplicatedAction) => {
+      console.log('Effect of SET_WORKFLOW_DUPLICATION_SUCCESS');
+      this.deduplicationService.setWorkflowDuplicationSuccess(action.payload);
+    });
+
+  @Effect({dispatch: false})
+  public wfDuplicationError: Observable<Action> = this.actions$
+    .ofType(SubmissionObjectActionTypes.SET_WORKFLOW_DUPLICATION_ERROR)
+    .do((action: SetWorkflowDuplicatedAction) => {
+      console.log('Effect of SET_WORKFLOW_DUPLICATION_ERROR');
+      this.deduplicationService.setWorkflowDuplicationError(action.payload);
+    });
+
+  constructor(private actions$: Actions,
+              private notificationsService: NotificationsService,
+              private operationsService: JsonPatchOperationsService<SubmitDataResponseDefinitionObject>,
+              private sectionService: SectionsService,
+              private store$: Store<any>,
+              private submissionService: SubmissionService,
+              private deduplicationService: DeduplicationService,
+              private translate: TranslateService) {
+  }
+
+  protected canDeposit(response: SubmissionObject[]) {
+    let canDeposit = true;
+
+    if (isNotEmpty(response)) {
+      response.forEach((item: Workspaceitem | Workflowitem) => {
+        const {errors} = item;
+
+        if (errors && !isEmpty(errors)) {
+          canDeposit = false;
+        }
+      });
+    }
+    return canDeposit;
+  }
+
+  protected parseSaveResponse(currentState: SubmissionObjectEntry, response: SubmissionObject[], submissionId: string) {
+    const mappedActions = [];
+
+    if (isNotEmpty(response)) {
+      this.notificationsService.success(null, this.translate.get('submission.sections.general.save_success_notice'));
+
+      // to avoid dispatching an action for every error, create an array of errors per section
+      response.forEach((item: Workspaceitem | Workflowitem) => {
+
+        let errorsList = Object.create({});
+        const {errors} = item;
+
+        if (errors && !isEmpty(errors)) {
+          errorsList = parseSectionErrors(errors);
+          this.notificationsService.warning(null, this.translate.get('submission.sections.general.sections_not_valid'));
+        }
+
+        const sections = (item.sections && isNotEmpty(item.sections)) ? item.sections : {};
+
+        const sectionsKeys: string[] = union(Object.keys(sections), Object.keys(errorsList));
+
+        sectionsKeys
+          .forEach((sectionId) => {
+            const sectionErrors = errorsList[sectionId] || [];
+            const sectionData = sections[sectionId] || {};
+            if (!currentState.sections[sectionId].enabled) {
+              this.translate.get('submission.sections.general.metadata-extracted-new-section', {sectionId})
+                .take(1)
+                .subscribe((m) => {
+                  this.notificationsService.info(null, m, null, true);
+                });
+            }
+            mappedActions.push(new UpdateSectionDataAction(submissionId, sectionId, sectionData, sectionErrors));
+          });
+
+      });
+
+    }
+    // mappedActions.push(new CompleteSaveSubmissionFormAction(submissionId));
+    return mappedActions;
+  }
+
+}

src/app/submission/objects/submission-objects.reducer.ts

@@ -0,0 +1,844 @@
+import { hasValue, isNotEmpty, isNotNull, isNotUndefined } from '../../shared/empty.util';
+import { findKey, uniqWith, isEqual, differenceWith } from 'lodash';
+
+import {
+  CompleteInitSubmissionFormAction,
+  DeleteUploadedFileAction,
+  DisableSectionAction, EditFileDataAction,
+  EnableSectionAction, NewUploadedFileAction,
+  LoadSubmissionFormAction, SectionStatusChangeAction,
+  SubmissionObjectAction,
+  SubmissionObjectActionTypes, ClearSectionErrorsAction, InertSectionErrorsAction,
+  DeleteSectionErrorsAction, ResetSubmissionFormAction, UpdateSectionDataAction, SaveSubmissionFormAction,
+  CompleteSaveSubmissionFormAction, SetActiveSectionAction, SaveSubmissionSectionFormAction,
+  DepositSubmissionAction, DepositSubmissionSuccessAction, DepositSubmissionErrorAction,
+  ChangeSubmissionCollectionAction, SaveSubmissionFormSuccessAction, SaveSubmissionFormErrorAction,
+  SaveSubmissionSectionFormSuccessAction, SaveSubmissionSectionFormErrorAction, SetWorkspaceDuplicatedAction,
+  SetWorkflowDuplicatedAction, InitSectionAction, RemoveSectionErrorsAction
+} from './submission-objects.actions';
+import { deleteProperty } from '../../shared/object.util';
+import { WorkspaceitemSectionDataType } from '../../core/submission/models/workspaceitem-sections.model';
+import { WorkspaceitemSectionUploadObject } from '../../core/submission/models/workspaceitem-section-upload.model';
+import { SectionsType } from '../sections/sections-type';
+
+export interface SectionVisibility {
+  main: any;
+  other: any;
+}
+
+export interface SubmissionSectionObject {
+  header: string;
+  config: string;
+  mandatory: boolean;
+  sectionType: SectionsType;
+  visibility: SectionVisibility;
+  collapsed: boolean,
+  enabled: boolean;
+  data: WorkspaceitemSectionDataType;
+  errors: SubmissionSectionError[];
+  isLoading: boolean;
+  isValid: boolean;
+}
+
+export interface SubmissionSectionError {
+  path: string;
+  message: string;
+}
+
+export interface SubmissionSectionEntry {
+  [sectionId: string]: SubmissionSectionObject;
+}
+
+export interface SubmissionObjectEntry {
+  collection?: string,
+  definition?: string,
+  selfUrl?: string;
+  activeSection?: string;
+  sections?: SubmissionSectionEntry;
+  isLoading?: boolean;
+  savePending?: boolean;
+  depositPending?: boolean;
+}
+
+/**
+ * The Submission State
+ *
+ * Consists of a map with submission's ID as key,
+ * and SubmissionObjectEntries as values
+ */
+export interface SubmissionObjectState {
+  [submissionId: string]: SubmissionObjectEntry;
+}
+
+const initialState: SubmissionObjectState = Object.create({});
+
+export function submissionObjectReducer(state = initialState, action: SubmissionObjectAction): SubmissionObjectState {
+  switch (action.type) {
+
+    // submission form actions
+    case SubmissionObjectActionTypes.INIT_SUBMISSION_FORM: {
+      return state;
+    }
+
+    case SubmissionObjectActionTypes.COMPLETE_INIT_SUBMISSION_FORM: {
+      return completeInit(state, action as CompleteInitSubmissionFormAction);
+    }
+
+    case SubmissionObjectActionTypes.LOAD_SUBMISSION_FORM: {
+      return initSubmission(state, action as LoadSubmissionFormAction);
+    }
+
+    case SubmissionObjectActionTypes.RESET_SUBMISSION_FORM: {
+      return resetSubmission(state, action as ResetSubmissionFormAction);
+    }
+
+    case SubmissionObjectActionTypes.CANCEL_SUBMISSION_FORM: {
+      return initialState;
+    }
+
+    case SubmissionObjectActionTypes.SAVE_SUBMISSION_FORM:
+    case SubmissionObjectActionTypes.SAVE_FOR_LATER_SUBMISSION_FORM:
+    case SubmissionObjectActionTypes.SAVE_AND_DEPOSIT_SUBMISSION: {
+      return saveSubmission(state, action as SaveSubmissionFormAction);
+    }
+
+    case SubmissionObjectActionTypes.SAVE_SUBMISSION_FORM_SUCCESS:
+    case SubmissionObjectActionTypes.SAVE_FOR_LATER_SUBMISSION_FORM_SUCCESS: {
+      return completeSave(state, action as SaveSubmissionFormSuccessAction);
+    }
+
+    case SubmissionObjectActionTypes.SAVE_SUBMISSION_FORM_ERROR:
+    case SubmissionObjectActionTypes.SAVE_FOR_LATER_SUBMISSION_FORM_ERROR: {
+      return completeSave(state, action as SaveSubmissionFormErrorAction);
+    }
+
+    case SubmissionObjectActionTypes.SAVE_SUBMISSION_SECTION_FORM: {
+      return saveSubmission(state, action as SaveSubmissionSectionFormAction);
+    }
+
+    case SubmissionObjectActionTypes.SAVE_SUBMISSION_SECTION_FORM_SUCCESS: {
+      return completeSave(state, action as SaveSubmissionSectionFormSuccessAction);
+    }
+
+    case SubmissionObjectActionTypes.SAVE_SUBMISSION_SECTION_FORM_ERROR: {
+      return completeSave(state, action as SaveSubmissionSectionFormErrorAction);
+    }
+
+    case SubmissionObjectActionTypes.CHANGE_SUBMISSION_COLLECTION: {
+      return changeCollection(state, action as ChangeSubmissionCollectionAction);
+    }
+
+    case SubmissionObjectActionTypes.COMPLETE_SAVE_SUBMISSION_FORM: {
+      return completeSave(state, action as CompleteSaveSubmissionFormAction);
+    }
+
+    case SubmissionObjectActionTypes.DEPOSIT_SUBMISSION: {
+      return startDeposit(state, action as DepositSubmissionAction);
+    }
+
+    case SubmissionObjectActionTypes.DEPOSIT_SUBMISSION_SUCCESS: {
+      return initialState;
+    }
+
+    case SubmissionObjectActionTypes.DEPOSIT_SUBMISSION_ERROR: {
+      return endDeposit(state, action as DepositSubmissionAction);
+    }
+
+    case SubmissionObjectActionTypes.DISCARD_SUBMISSION: {
+      return state;
+    }
+
+    case SubmissionObjectActionTypes.DISCARD_SUBMISSION_SUCCESS: {
+      return initialState;
+    }
+
+    case SubmissionObjectActionTypes.DISCARD_SUBMISSION_ERROR: {
+      return state;
+    }
+
+    case SubmissionObjectActionTypes.SET_ACTIVE_SECTION: {
+      return setActiveSection(state, action as SetActiveSectionAction);
+    }
+
+    // Section actions
+
+    case SubmissionObjectActionTypes.INIT_SECTION: {
+      return initSection(state, action as InitSectionAction);
+    }
+
+    case SubmissionObjectActionTypes.ENABLE_SECTION: {
+      return changeSectionState(state, action as EnableSectionAction, true);
+    }
+
+    case SubmissionObjectActionTypes.UPLOAD_SECTION_DATA: {
+      return updateSectionData(state, action as UpdateSectionDataAction);
+    }
+
+    case SubmissionObjectActionTypes.REMOVE_SECTION_ERRORS: {
+      return removeSectionErrors(state, action as RemoveSectionErrorsAction);
+    }
+
+    case SubmissionObjectActionTypes.DISABLE_SECTION: {
+      return changeSectionState(state, action as DisableSectionAction, false);
+    }
+
+    case SubmissionObjectActionTypes.SECTION_STATUS_CHANGE: {
+      return setIsValid(state, action as SectionStatusChangeAction);
+    }
+
+    // Files actions
+    case SubmissionObjectActionTypes.NEW_FILE: {
+      return newFile(state, action as NewUploadedFileAction);
+    }
+
+    case SubmissionObjectActionTypes.EDIT_FILE_DATA: {
+      return editFileData(state, action as EditFileDataAction);
+    }
+
+    case SubmissionObjectActionTypes.DELETE_FILE: {
+      return deleteFile(state, action as DeleteUploadedFileAction);
+    }
+
+    // deduplication
+    case SubmissionObjectActionTypes.SET_WORKSPACE_DUPLICATION: {
+      return updateDeduplication(state, action as SetWorkspaceDuplicatedAction);
+    }
+
+    case SubmissionObjectActionTypes.SET_WORKFLOW_DUPLICATION: {
+      return updateDeduplication(state, action as SetWorkflowDuplicatedAction);
+    }
+
+    // errors actions
+    case SubmissionObjectActionTypes.INSERT_ERRORS: {
+      return insertError(state, action as InertSectionErrorsAction);
+    }
+
+    case SubmissionObjectActionTypes.DELETE_ERRORS: {
+      return removeError(state, action as DeleteSectionErrorsAction);
+    }
+
+    case SubmissionObjectActionTypes.CLEAR_ERRORS: {
+      return clearErrorsFromSection(state, action as ClearSectionErrorsAction);
+    }
+
+    default: {
+      return state;
+    }
+  }
+}
+
+// ------ Submission error functions ------ //
+
+const removeError = (state: SubmissionObjectState, action: DeleteSectionErrorsAction): SubmissionObjectState => {
+  const { submissionId, sectionId, error } = action.payload;
+
+  if (hasValue(state[ submissionId ].sections[ sectionId ])) {
+    let errors = state[ submissionId ].sections[ sectionId ].errors.filter((currentError) => {
+      return currentError.message !== error && !isEqual(currentError, error);
+    });
+
+    if (action.payload.error instanceof Array) {
+      errors = differenceWith(errors, action.payload.error, isEqual);
+    }
+
+    return Object.assign({}, state, {
+      [ submissionId ]: Object.assign({}, state[ submissionId ], {
+        sections: Object.assign({}, state[ submissionId ].sections, {
+          [ sectionId ]: Object.assign({}, state[ action.payload.submissionId ].sections [ action.payload.sectionId ], {
+            errors
+          })
+        }),
+      })
+    });
+  } else {
+    return state;
+  }
+};
+
+const insertError = (state: SubmissionObjectState, action: InertSectionErrorsAction): SubmissionObjectState => {
+  const { submissionId, sectionId, error } = action.payload;
+
+  if (hasValue(state[ submissionId ].sections[ sectionId ])) {
+    const errors = uniqWith(state[ submissionId ].sections[ sectionId ].errors.concat(error), isEqual);
+
+    return Object.assign({}, state, {
+      [ submissionId ]: Object.assign({}, state[ submissionId ], {
+        activeSection: state[ action.payload.submissionId ].activeSection,        sections: Object.assign({}, state[ submissionId ].sections, {
+          [ sectionId ]: Object.assign({}, state[ action.payload.submissionId ].sections [ action.payload.sectionId ], {
+            errors
+          })
+        }),
+      })
+    });
+  } else {
+    return state;
+  }
+};
+
+const clearErrorsFromSection = (state: SubmissionObjectState, action: ClearSectionErrorsAction): SubmissionObjectState => {
+  const { submissionId, sectionId } = action.payload;
+
+  if (hasValue(state[ submissionId ].sections[ sectionId ])) {
+    const errors = []; // clear the errors
+
+    return Object.assign({}, state, {
+      [ submissionId ]: Object.assign({}, state[ submissionId ], {
+        sections: Object.assign({}, state[ submissionId ].sections, {
+          [ sectionId ]: Object.assign({}, state[ action.payload.submissionId ].sections [ action.payload.sectionId ], {
+            errors
+          })
+        }),
+      })
+    });
+  } else {
+    return state;
+  }
+};
+
+// ------ Submission functions ------ //
+
+/**
+ * Init a SubmissionObjectState.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an LoadSubmissionFormAction
+ * @return SubmissionObjectState
+ *    the new state, with the section removed.
+ */
+function initSubmission(state: SubmissionObjectState, action: LoadSubmissionFormAction | ResetSubmissionFormAction): SubmissionObjectState {
+
+  const newState = Object.assign({}, state);
+  newState[ action.payload.submissionId ] = {
+    collection: action.payload.collectionId,
+    definition: action.payload.submissionDefinition.name,
+    selfUrl: action.payload.selfUrl,
+    activeSection: null,
+    sections: Object.create(null),
+    isLoading: true,
+    savePending: false,
+    depositPending: false,
+  };
+  return newState;
+}
+
+/**
+ * Reset submission.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an ResetSubmissionFormAction
+ * @return SubmissionObjectState
+ *    the new state, with the section removed.
+ */
+function resetSubmission(state: SubmissionObjectState, action: ResetSubmissionFormAction): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        sections: Object.create(null),
+        isLoading: true
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Set submission loading to false.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an CompleteInitSubmissionFormAction
+ * @return SubmissionObjectState
+ *    the new state, with the section removed.
+ */
+function completeInit(state: SubmissionObjectState, action: CompleteInitSubmissionFormAction): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        isLoading: false
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Set submission save flag to true
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an SaveSubmissionFormAction
+ * @return SubmissionObjectState
+ *    the new state, with the flag set to true.
+ */
+function saveSubmission(state: SubmissionObjectState, action: SaveSubmissionFormAction): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        activeSection: state[ action.payload.submissionId ].activeSection,
+        sections: state[ action.payload.submissionId ].sections,
+        isLoading: state[ action.payload.submissionId ].isLoading,
+        savePending: true,
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Set submission save flag to false.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an CompleteSaveSubmissionFormAction | SaveSubmissionFormSuccessAction | SaveSubmissionFormErrorAction
+ * @return SubmissionObjectState
+ *    the new state, with the flag set to false.
+ */
+function completeSave(state: SubmissionObjectState,
+                      action: CompleteSaveSubmissionFormAction
+                        | SaveSubmissionFormSuccessAction
+                        | SaveSubmissionFormErrorAction
+                        | SaveSubmissionSectionFormSuccessAction
+                        | SaveSubmissionSectionFormErrorAction): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        savePending: false,
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Set deposit flag to true
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an DepositSubmissionAction
+ * @return SubmissionObjectState
+ *    the new state, with the deposit flag changed.
+ */
+function startDeposit(state: SubmissionObjectState, action: DepositSubmissionAction): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        savePending: false,
+        depositPending: true,
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Set deposit flag to false
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an DepositSubmissionSuccessAction or DepositSubmissionErrorAction
+ * @return SubmissionObjectState
+ *    the new state, with the deposit flag changed.
+ */
+function endDeposit(state: SubmissionObjectState, action: DepositSubmissionSuccessAction | DepositSubmissionErrorAction): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        depositPending: false,
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Init a SubmissionObjectState.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an LoadSubmissionFormAction
+ * @return SubmissionObjectState
+ *    the new state, with the section removed.
+ */
+function changeCollection(state: SubmissionObjectState, action: ChangeSubmissionCollectionAction): SubmissionObjectState {
+  return Object.assign({}, state, {
+    [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+      collection: action.payload.collectionId
+    })
+  });
+}
+
+// ------ Section functions ------ //
+
+/**
+ * Set submission active section.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an SetActiveSectionAction
+ * @return SubmissionObjectState
+ *    the new state, with the active section.
+ */
+function setActiveSection(state: SubmissionObjectState, action: SetActiveSectionAction): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        activeSection: action.payload.sectionId,
+        sections: state[ action.payload.submissionId ].sections,
+        isLoading: state[ action.payload.submissionId ].isLoading,
+        savePending: state[ action.payload.submissionId ].savePending,
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Set a section enabled.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an InitSectionAction
+ * @return SubmissionObjectState
+ *    the new state, with the section removed.
+ */
+function initSection(state: SubmissionObjectState, action: InitSectionAction): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        sections: Object.assign({}, state[ action.payload.submissionId ].sections, {
+          [ action.payload.sectionId ]: {
+            header: action.payload.header,
+            config: action.payload.config,
+            mandatory: action.payload.mandatory,
+            sectionType: action.payload.sectionType,
+            visibility: action.payload.visibility,
+            collapsed: false,
+            enabled: action.payload.enabled,
+            data: action.payload.data,
+            errors: action.payload.errors || [],
+            isLoading: false,
+            isValid: false
+          }
+        })
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Update section's data.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an UpdateSectionDataAction
+ * @return SubmissionObjectState
+ *    the new state, with the section's data updated.
+ */
+function updateSectionData(state: SubmissionObjectState, action: UpdateSectionDataAction): SubmissionObjectState {
+  if (isNotEmpty(state[ action.payload.submissionId ])
+      && isNotEmpty(state[ action.payload.submissionId ].sections[ action.payload.sectionId])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        sections: Object.assign({}, state[ action.payload.submissionId ].sections, {
+          [ action.payload.sectionId ]: Object.assign({}, state[ action.payload.submissionId ].sections [ action.payload.sectionId ], {
+            enabled: true,
+            data: action.payload.data,
+            errors: action.payload.errors
+          })
+        })
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Remove section's errors.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an RemoveSectionErrorsAction
+ * @return SubmissionObjectState
+ *    the new state, with the section's errors updated.
+ */
+function removeSectionErrors(state: SubmissionObjectState, action: RemoveSectionErrorsAction): SubmissionObjectState {
+  if (isNotEmpty(state[ action.payload.submissionId ])
+      && isNotEmpty(state[ action.payload.submissionId ].sections[ action.payload.sectionId])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        sections: Object.assign({}, state[ action.payload.submissionId ].sections, {
+          [ action.payload.sectionId ]: Object.assign({}, state[ action.payload.submissionId ].sections [ action.payload.sectionId ], {
+            errors: []
+          })
+        })
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Set a section state.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an DisableSectionAction
+ * @param enabled
+ *    enabled or disabled section.
+ * @return SubmissionObjectState
+ *    the new state, with the section removed.
+ */
+function changeSectionState(state: SubmissionObjectState, action: EnableSectionAction | DisableSectionAction, enabled: boolean): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ].sections[ action.payload.sectionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        // sections: deleteProperty(state[ action.payload.submissionId ].sections, action.payload.sectionId),
+        sections: Object.assign({}, state[ action.payload.submissionId ].sections, {
+          [ action.payload.sectionId ]: Object.assign({}, state[ action.payload.submissionId ].sections [ action.payload.sectionId ], {
+            enabled
+          })
+        })
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+/**
+ * Set the section validity.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    an LoadSubmissionFormAction
+ * @return SubmissionObjectState
+ *    the new state, with the section new validity status.
+ */
+function setIsValid(state: SubmissionObjectState, action: SectionStatusChangeAction): SubmissionObjectState {
+  if (hasValue(state[ action.payload.submissionId ].sections[ action.payload.sectionId ])) {
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        sections: Object.assign({}, state[ action.payload.submissionId ].sections,
+          Object.assign({}, {
+            [ action.payload.sectionId ]: Object.assign({}, state[ action.payload.submissionId ].sections [ action.payload.sectionId ], {
+              isValid: action.payload.status
+            })
+          })
+        )
+      })
+    });
+  } else {
+    return state;
+  }
+}
+
+// ------ Upload file functions ------ //
+
+/**
+ * Set a new bitstream.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    a NewUploadedFileAction action
+ * @return SubmissionObjectState
+ *    the new state, with the new bitstream.
+ */
+function newFile(state: SubmissionObjectState, action: NewUploadedFileAction): SubmissionObjectState {
+  const filesData = state[ action.payload.submissionId ].sections[ action.payload.sectionId ].data as WorkspaceitemSectionUploadObject;
+  if (isNotUndefined(filesData.files)
+    && !hasValue(filesData.files[ action.payload.fileId ])) {
+    const newData = [];
+    newData[ action.payload.fileId ] = action.payload.data;
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        activeSection: state[ action.payload.submissionId ].activeSection,
+        sections: Object.assign({}, state[ action.payload.submissionId ].sections,
+          Object.assign({}, {
+              [ action.payload.sectionId ]: {
+                data: Object.assign({}, state[ action.payload.submissionId ].sections[ action.payload.sectionId ].data, {
+                  files: Object.assign({},
+                    filesData.files,
+                    newData)
+                }),
+                isValid: state[ action.payload.submissionId ].sections[ action.payload.sectionId ].isValid,
+                errors: state[ action.payload.submissionId ].sections[ action.payload.sectionId ].errors
+              }
+            }
+          )
+        ),
+        isLoading: state[ action.payload.submissionId ].isLoading,
+        savePending: state[ action.payload.submissionId ].savePending,
+      })
+    });
+  } else {
+    const newData = [];
+    newData[ action.payload.fileId ] = action.payload.data;
+    return Object.assign({}, state, {
+      [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+        activeSection: state[ action.payload.submissionId ].activeSection,
+        sections: Object.assign({}, state[ action.payload.submissionId ].sections,
+          Object.assign({}, {
+            [ action.payload.sectionId ]: {
+              data: Object.assign({}, state[ action.payload.submissionId ].sections[ action.payload.sectionId ].data, {
+                files: newData
+              }),
+              isValid: state[ action.payload.submissionId ].sections[ action.payload.sectionId ].isValid,
+              errors: state[ action.payload.submissionId ].sections[ action.payload.sectionId ].errors
+            }
+          })
+        ),
+        isLoading: state[ action.payload.submissionId ].isLoading,
+        savePending: state[ action.payload.submissionId ].savePending,
+      })
+    });
+  }
+}
+
+/**
+ * Edit a bitstream.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    a EditFileDataAction action
+ * @return SubmissionObjectState
+ *    the new state, with the edited bitstream.
+ */
+function editFileData(state: SubmissionObjectState, action: EditFileDataAction): SubmissionObjectState {
+  const filesData = state[ action.payload.submissionId ].sections[ action.payload.sectionId ].data as WorkspaceitemSectionUploadObject;
+  if (hasValue(filesData.files)) {
+    const fileIndex = findKey(
+      filesData.files,
+      { uuid: action.payload.fileId });
+    if (isNotNull(fileIndex)) {
+      return Object.assign({}, state, {
+        [ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
+          activeSection: state[ action.payload.submissionId ].activeSection,
+          sections: Object.assign({}, state[ action.payload.submissionId ].sections,
+            Object.assign({}, {
+              [ action.payload.sectionId ]: Object.assign({}, state[ action.payload.submissionId ].sections [ action.payload.sectionId ], {
+                data: Object.assign({}, state[ action.payload.submissionId ].sections[ action.payload.sectionId ].data, {
+                  files: Object.assign({},
+                    filesData.files, {
+                      [ fileIndex ]: action.payload.data
+                    })
+                })
+              })
+            })
+            // Object.assign({}, state[action.payload.submissionId].sections[action.payload.sectionId],{
+            //     [ action.payload.sectionId ]: {
+            //       data: Object.assign({}, state[ action.payload.submissionId ].sections[ action.payload.sectionId ].data, {
+            //         files: Object.assign({},
+            //           filesData.files, {
+            //             [ fileIndex ]: action.payload.data
+            //           })
+            //       })
+            //     }
+            //   }
+            // )
+          ),
+          isLoading: state[ action.payload.submissionId ].isLoading,
+          savePending: state[ action.payload.submissionId ].savePending,
+        })
+      });
+    }
+  }
+  return state;
+}
+
+/**
+ * Delete a bitstream.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    a DeleteUploadedFileAction action
+ * @return SubmissionObjectState
+ *    the new state, with the bitstream removed.
+ */
+function deleteFile(state: SubmissionObjectState, action: DeleteUploadedFileAction): SubmissionObjectState {
+  const filesData = state[ action.payload.submissionId ].sections[ action.payload.sectionId ].data as WorkspaceitemSectionUploadObject;
+  if (hasValue(filesData.files)) {
+    const fileIndex = findKey(
+      filesData.files,
+      {uuid: action.payload.fileId});
+    if (isNotNull(fileIndex)) {
+      return Object.assign({}, state, {
+        [ action.payload.submissionId ]: Object.assign({}, state[action.payload.submissionId], {
+          activeSection: state[ action.payload.submissionId ].activeSection,
+          sections: Object.assign({}, state[action.payload.submissionId].sections,
+            Object.assign({}, {
+              [ action.payload.sectionId ]: Object.assign({}, state[ action.payload.submissionId ].sections [ action.payload.sectionId ], {
+                data: Object.assign({}, state[ action.payload.submissionId ].sections[ action.payload.sectionId ].data, {
+                  files: deleteProperty(filesData.files, fileIndex)
+                })
+              })
+            })
+            // Object.assign({}, state[action.payload.submissionId].sections[action.payload.sectionId], {
+            //     [ action.payload.sectionId ]: {
+            //       data: Object.assign({}, state[action.payload.submissionId].sections[action.payload.sectionId].data, {
+            //         files: deleteProperty(filesData.files, fileIndex)
+            //       })
+            //     }
+            //   }
+            // )
+          ),
+          isLoading: state[action.payload.submissionId].isLoading,
+          savePending: state[action.payload.submissionId].savePending,
+        })
+      });
+    }
+  }
+  return state;
+}
+
+/**
+ * Update a Workspace deduplication match.
+ *
+ * @param state
+ *    the current state
+ * @param action
+ *    a SetWorkspaceDuplicatedAction or SetWorkflowDuplicatedAction
+ * @return SubmissionObjectState
+ *    the new state, with the match parameter changed.
+ */
+function updateDeduplication(state: SubmissionObjectState, action: SetWorkspaceDuplicatedAction|SetWorkflowDuplicatedAction): SubmissionObjectState {
+  const matches = Object.assign([], (state[(action.payload as any).submissionId].sections.deduplication.data as any).matches);
+  const newMatch = (action.payload as any).data;
+  matches.forEach( (match, i) => {
+    if (i === action.payload.index) {
+      matches.splice(i, 1, Object.assign({}, match, newMatch));
+      return;
+    }
+  });
+  // const updatedMatches = Object.assign({}, matches, newMatch);
+  return Object.assign({}, state, {[(action.payload as any).submissionId]: {sections: {deduplication: {data: {matches}}}}});
+}