hazza/dspace-angular
1
0
Fork 1
mirror of https://github.com/DSpace/dspace-angular.git synced 2025-10-18 07:23:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Final commit detect duplicate

Browse Source
This commit is contained in:
Giuseppe
2018-10-03 10:33:54 +02:00
parent 25bb5fddf6
commit 6f4b9fc818
16 changed files with 461 additions and 506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
src/app/submission/objects/submission-objects.actions.ts
View File

@@ -52,12 +52,9 @@ export const SubmissionObjectActionTypes = {
DISCARD_SUBMISSION: type('dspace/submission/DISCARD_SUBMISSION'),
DISCARD_SUBMISSION_SUCCESS: type('dspace/submission/DISCARD_SUBMISSION_SUCCESS'),
DISCARD_SUBMISSION_ERROR: type('dspace/submission/DISCARD_SUBMISSION_ERROR'),
SET_WORKSPACE_DUPLICATION: type('/sections/deduplication/SET_WORKSPACE_DUPLICATION'),
SET_WORKSPACE_DUPLICATION_SUCCESS: type('/sections/deduplication/SET_WORKSPACE_DUPLICATION_SUCCESS'),
SET_WORKSPACE_DUPLICATION_ERROR: type('/sections/deduplication/SET_WORKSPACE_DUPLICATION_ERROR'),
SET_WORKFLOW_DUPLICATION: type('/sections/deduplication/SET_WORKFLOW_DUPLICATION'),
SET_WORKFLOW_DUPLICATION_SUCCESS: type('/sections/deduplication/SET_WORKFLOW_DUPLICATION_SUCCESS'),
SET_WORKFLOW_DUPLICATION_ERROR: type('/sections/deduplication/SET_WORKFLOW_DUPLICATION_ERROR'),
SET_DUPLICATE_DECISION: type('dspace/submission/SET_DUPLICATE_DECISION'),
SET_DUPLICATE_DECISION_SUCCESS: type('dspace/submission/SET_DUPLICATE_DECISION_SUCCESS'),
SET_DUPLICATE_DECISION_ERROR: type('dspace/submission/SET_DUPLICATE_DECISION_ERROR'),
// Upload file types
NEW_FILE: type('dspace/submission/NEW_FILE'),
@@ -763,129 +760,63 @@ export class DeleteUploadedFileAction implements Action {
}
}
export class SetWorkspaceDuplicatedAction implements Action {
type = SubmissionObjectActionTypes.SET_WORKSPACE_DUPLICATION;
export class SetDuplicateDecisionAction implements Action {
type = SubmissionObjectActionTypes.SET_DUPLICATE_DECISION;
payload: {
index: number;
decision: string;
note?: string
submissionId: string;
sectionId: string;
};
/**
* Create a new SetWorkspaceDuplicatedAction
* Create a new SetDuplicateDecisionAction
*
* @param index
* the index in matches array
* @param decision
* the submitter's decision ('verify'|'reject'|null)
* @param note
* the submitter's note, for 'verify' decision only
* @param submissionId
* the submission's ID
* @param sectionId
* the section's ID
*/
constructor(payload: any) {
this.payload = payload;
constructor(submissionId: string, sectionId: string) {
this.payload = { submissionId, sectionId };
}
}
export class SetWorkspaceDuplicatedSuccessAction implements Action {
type = SubmissionObjectActionTypes.SET_WORKSPACE_DUPLICATION_SUCCESS;
export class SetDuplicateDecisionSuccessAction implements Action {
type = SubmissionObjectActionTypes.SET_DUPLICATE_DECISION_SUCCESS;
payload: {
index: number;
decision: string;
note?: string
submissionId: string;
sectionId: string;
submissionObject: SubmissionObject[];
};
/**
* Create a new SetWorkspaceDuplicatedSuccessAction
* Create a new SetDuplicateDecisionSuccessAction
*
* @param index
* the index in matches array
* @param decision
* the submitter's decision ('verify'|'reject'|null)
* @param note
* the submitter's note, for 'verify' decision only
* @param submissionId
* the submission's ID
* @param sectionId
* the section's ID
* @param submissionObjects
* the submission's Object
*/
constructor(payload: any) {
this.payload = payload;
constructor(submissionId: string, sectionId: string, submissionObject: SubmissionObject[]) {
this.payload = { submissionId, sectionId, submissionObject };
}
}
export class SetWorkspaceDuplicatedErrorAction implements Action {
type = SubmissionObjectActionTypes.SET_WORKSPACE_DUPLICATION_ERROR;
export class SetDuplicateDecisionErrorAction implements Action {
type = SubmissionObjectActionTypes.SET_DUPLICATE_DECISION_ERROR;
payload: {
index: number;
submissionId: string;
};
/**
* Create a new SetWorkspaceDuplicatedErrorAction
* Create a new SetDuplicateDecisionErrorAction
*
* @param index
* the index in matches array
* @param submissionId
* the submission's ID
*/
constructor(index: number) {
this.payload = { index };
}
}
export class SetWorkflowDuplicatedAction implements Action {
type = SubmissionObjectActionTypes.SET_WORKFLOW_DUPLICATION;
payload: {
index: number;
decision: string;
note?: string
};
/**
* Create a new SetWorkflowDuplicatedAction
*
* @param index
* the index in matches array
* @param decision
* the controller's decision ('verify'|'reject'|null)
* @param note
* the controller's note, for 'verify' decision only
*/
constructor(payload: any) {
this.payload = payload;
}
}
export class SetWorkflowDuplicatedSuccessAction implements Action {
type = SubmissionObjectActionTypes.SET_WORKFLOW_DUPLICATION_SUCCESS;
payload: {
index: number;
decision: string;
note?: string
};
/**
* Create a new SetWorkflowDuplicatedSuccessAction
*
* @param index
* the index in matches array
* @param decision
* the controller's decision ('verify'|'reject'|null)
* @param note
* the controller's note, for 'verify' decision only
*/
constructor(payload: any) {
this.payload = payload;
}
}
export class SetWorkflowDuplicatedErrorAction implements Action {
type = SubmissionObjectActionTypes.SET_WORKFLOW_DUPLICATION_ERROR;
payload: {
index: number;
};
/**
* Create a new SetWorkflowDuplicatedErrorAction
*
* @param index
* the index in matches array
*/
constructor(index: number) {
this.payload = { index };
constructor(submissionId: string) {
this.payload = { submissionId };
}
}
@@ -928,9 +859,6 @@ export type SubmissionObjectAction = DisableSectionAction
| SaveSubmissionSectionFormSuccessAction
| SaveSubmissionSectionFormErrorAction
| SetActiveSectionAction
| SetWorkspaceDuplicatedAction
| SetWorkspaceDuplicatedSuccessAction
| SetWorkspaceDuplicatedErrorAction
| SetWorkflowDuplicatedAction
| SetWorkflowDuplicatedSuccessAction
| SetWorkflowDuplicatedErrorAction;
| SetDuplicateDecisionAction
| SetDuplicateDecisionSuccessAction
| SetDuplicateDecisionErrorAction;

127
src/app/submission/objects/submission-objects.effects.ts
View File

@@ -22,12 +22,7 @@ import {
SaveSubmissionSectionFormAction,
SaveSubmissionSectionFormErrorAction,
SaveSubmissionSectionFormSuccessAction,
SetWorkflowDuplicatedAction,
SetWorkflowDuplicatedErrorAction,
SetWorkflowDuplicatedSuccessAction,
SetWorkspaceDuplicatedAction,
SetWorkspaceDuplicatedErrorAction,
SetWorkspaceDuplicatedSuccessAction,
SetDuplicateDecisionAction, SetDuplicateDecisionErrorAction, SetDuplicateDecisionSuccessAction,
SubmissionObjectActionTypes,
UpdateSectionDataAction
} from './submission-objects.actions';
@@ -43,11 +38,13 @@ 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 { DetectDuplicateService } from '../sections/detect-duplicate/detect-duplicate.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';
import { SectionsType } from '../sections/sections-type';
import { WorkspaceitemSectionsObject } from '../../core/submission/models/workspaceitem-sections.model';
@Injectable()
export class SubmissionObjectEffects {
@@ -60,7 +57,7 @@ export class SubmissionObjectEffects {
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 enabled = (sectionDefinition.mandatory && sectionDefinition.sectionType !== SectionsType.DetectDuplicate) || (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(
@@ -127,9 +124,7 @@ export class SubmissionObjectEffects {
.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);
});
.mergeMap((actions) => Observable.from(actions));
@Effect() saveSection$ = this.actions$
.ofType(SubmissionObjectActionTypes.SAVE_SUBMISSION_SECTION_FORM)
@@ -143,6 +138,31 @@ export class SubmissionObjectEffects {
.catch(() => Observable.of(new SaveSubmissionSectionFormErrorAction(action.payload.submissionId)));
});
@Effect() saveDuplicateDecision$ = this.actions$
.ofType(SubmissionObjectActionTypes.SET_DUPLICATE_DECISION)
.switchMap((action: SetDuplicateDecisionAction) => {
return this.operationsService.jsonPatchByResourceID(
this.submissionService.getSubmissionObjectLinkName(),
action.payload.submissionId,
'sections',
action.payload.sectionId)
.map((response: SubmissionObject[]) => new SetDuplicateDecisionSuccessAction(action.payload.submissionId, action.payload.sectionId, response))
.catch(() => Observable.of(new SetDuplicateDecisionErrorAction(action.payload.submissionId)));
});
@Effect({dispatch: false}) setDuplicateDecisionSuccess$ = this.actions$
.ofType(SubmissionObjectActionTypes.SET_DUPLICATE_DECISION_SUCCESS)
.do(() => this.notificationsService.success(null, this.translate.get('submission.sections.detect-duplicate.decision-success-notice')));
/* @Effect() setDuplicateDecisionSuccess$ = this.actions$
.ofType(SubmissionObjectActionTypes.SET_DUPLICATE_DECISION_SUCCESS)
.withLatestFrom(this.store$)
.map(([action, currentState]: [SetDuplicateDecisionSuccessAction, any]) => {
this.notificationsService.success(null, this.translate.get('submission.sections.detect-duplicate.decision-success-notice'));
return this.parseSaveResponse((currentState.submission as SubmissionState).objects[action.payload.submissionId], action.payload.submissionObject, action.payload.submissionId, false);
})
.mergeMap((actions) => Observable.from(actions));*/
@Effect() saveAndDepositSection$ = this.actions$
.ofType(SubmissionObjectActionTypes.SAVE_AND_DEPOSIT_SUBMISSION)
.withLatestFrom(this.store$)
@@ -202,79 +222,13 @@ export class SubmissionObjectEffects {
.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 deduplicationService: DetectDuplicateService,
private translate: TranslateService) {
}
@@ -293,11 +247,13 @@ export class SubmissionObjectEffects {
return canDeposit;
}
protected parseSaveResponse(currentState: SubmissionObjectEntry, response: SubmissionObject[], submissionId: string) {
protected parseSaveResponse(currentState: SubmissionObjectEntry, response: SubmissionObject[], submissionId: string, notify: boolean = true) {
const mappedActions = [];
if (isNotEmpty(response)) {
this.notificationsService.success(null, this.translate.get('submission.sections.general.save_success_notice'));
if (notify) {
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) => {
@@ -307,19 +263,20 @@ export class SubmissionObjectEffects {
if (errors && !isEmpty(errors)) {
errorsList = parseSectionErrors(errors);
this.notificationsService.warning(null, this.translate.get('submission.sections.general.sections_not_valid'));
if (notify) {
this.notificationsService.warning(null, this.translate.get('submission.sections.general.sections_not_valid'));
}
}
const sections = (item.sections && isNotEmpty(item.sections)) ? item.sections : {};
const sections: WorkspaceitemSectionsObject = (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.submissionService.notifyNewSection(sectionId);
if (notify && !currentState.sections[sectionId].enabled) {
this.submissionService.notifyNewSection(submissionId, sectionId, currentState.sections[sectionId].sectionType);
}
mappedActions.push(new UpdateSectionDataAction(submissionId, sectionId, sectionData, sectionErrors));
});

111
src/app/submission/objects/submission-objects.reducer.ts
View File

@@ -27,16 +27,18 @@ import {
SaveSubmissionFormErrorAction,
SaveSubmissionSectionFormSuccessAction,
SaveSubmissionSectionFormErrorAction,
SetWorkspaceDuplicatedAction,
SetWorkflowDuplicatedAction,
InitSectionAction,
RemoveSectionErrorsAction,
SaveForLaterSubmissionFormAction,
SaveAndDepositSubmissionAction, SaveForLaterSubmissionFormSuccessAction, SaveForLaterSubmissionFormErrorAction
SaveAndDepositSubmissionAction,
SaveForLaterSubmissionFormSuccessAction,
SaveForLaterSubmissionFormErrorAction,
SetDuplicateDecisionAction, SetDuplicateDecisionSuccessAction, SetDuplicateDecisionErrorAction
} from './submission-objects.actions';
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';
import { WorkspaceitemSectionDetectDuplicateObject } from '../../core/submission/models/workspaceitem-section-deduplication.model';
export interface SectionVisibility {
main: any;
@@ -74,6 +76,7 @@ export interface SubmissionObjectEntry {
sections?: SubmissionSectionEntry;
isLoading?: boolean;
savePending?: boolean;
saveDecisionPending?: boolean;
depositPending?: boolean;
}
@@ -192,15 +195,6 @@ export function submissionObjectReducer(state = initialState, action: Submission
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.ADD_SECTION_ERROR: {
return addError(state, action as InertSectionErrorsAction);
@@ -214,6 +208,19 @@ export function submissionObjectReducer(state = initialState, action: Submission
return removeSectionErrors(state, action as RemoveSectionErrorsAction);
}
// detect duplicate
case SubmissionObjectActionTypes.SET_DUPLICATE_DECISION: {
return startSaveDecision(state, action as SetDuplicateDecisionAction);
}
case SubmissionObjectActionTypes.SET_DUPLICATE_DECISION_SUCCESS: {
return setDuplicateMatches(state, action as SetDuplicateDecisionSuccessAction);
}
case SubmissionObjectActionTypes.SET_DUPLICATE_DECISION: {
return endSaveDecision(state, action as SetDuplicateDecisionErrorAction);
}
default: {
return state;
}
@@ -319,6 +326,7 @@ function initSubmission(state: SubmissionObjectState, action: InitSubmissionForm
sections: Object.create(null),
isLoading: true,
savePending: false,
saveDecisionPending: false,
depositPending: false,
};
return newState;
@@ -740,7 +748,7 @@ function deleteFile(state: SubmissionObjectState, action: DeleteUploadedFileActi
[ 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 ], {
[ 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: newData
})
@@ -754,25 +762,74 @@ function deleteFile(state: SubmissionObjectState, action: DeleteUploadedFileActi
return state;
}
// ------ Detect duplicate functions ------ //
/**
* Update a Workspace deduplication match.
* Set decision flag to true
*
* @param state
* the current state
* @param action
* a SetWorkspaceDuplicatedAction or SetWorkflowDuplicatedAction
* an SetDuplicateDecisionAction
* @return SubmissionObjectState
* the new state, with the match parameter changed.
* the new state, with the decision flag 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}}}}});
function startSaveDecision(state: SubmissionObjectState, action: SetDuplicateDecisionAction): SubmissionObjectState {
if (hasValue(state[ action.payload.submissionId ])) {
return Object.assign({}, state, {
[ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
saveDecisionPending: true,
})
});
} else {
return state;
}
}
function setDuplicateMatches(state: SubmissionObjectState, action: SetDuplicateDecisionSuccessAction) {
const index: any = findKey(
action.payload.submissionObject,
{id: parseInt(action.payload.submissionId, 10)});
const sectionData = action.payload.submissionObject[index].sections[ action.payload.sectionId ] as WorkspaceitemSectionDetectDuplicateObject;
const newData = (sectionData && sectionData.matches) ? sectionData : Object.create({});
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 ], {
enabled: true,
data: newData
})
})
),
saveDecisionPending: false
})
});
} else {
return state;
}
}
/**
* Set decision flag to false
*
* @param state
* the current state
* @param action
* an SetDuplicateDecisionSuccessAction or SetDuplicateDecisionErrorAction
* @return SubmissionObjectState
* the new state, with the decision flag changed.
*/
function endSaveDecision(state: SubmissionObjectState, action: SetDuplicateDecisionSuccessAction | SetDuplicateDecisionErrorAction): SubmissionObjectState {
if (hasValue(state[ action.payload.submissionId ])) {
return Object.assign({}, state, {
[ action.payload.submissionId ]: Object.assign({}, state[ action.payload.submissionId ], {
saveDecisionPending: false,
})
});
} else {
return state;
}
}