Adding Prettier and fixing up eslint version

Issue-ID: SDC-1094
Change-Id: Ie83ad95a03899345dd90235daf0323cbe3bc6afd
Signed-off-by: Einav Weiss Keidar <einavw@amdocs.com>

1 files changed, 695 insertions, 479 deletions

diff --git a/openecomp-ui/src/sdc-app/onboarding/softwareProduct/SoftwareProductActionHelper.js b/openecomp-ui/src/sdc-app/onboarding/softwareProduct/SoftwareProductActionHelper.js
index 42786bf752..4a2d7a2ece 100644
--- a/openecomp-ui/src/sdc-app/onboarding/softwareProduct/SoftwareProductActionHelper.js
+++ b/openecomp-ui/src/sdc-app/onboarding/softwareProduct/SoftwareProductActionHelper.js
@@ -21,553 +21,769 @@ import LicenseModelActionHelper from 'sdc-app/onboarding/licenseModel/LicenseMod
 import LicenseAgreementActionHelper from 'sdc-app/onboarding/licenseModel/licenseAgreement/LicenseAgreementActionHelper.js';
 import FeatureGroupsActionHelper from 'sdc-app/onboarding/licenseModel/featureGroups/FeatureGroupsActionHelper.js';
 
-import {actionTypes, onboardingOriginTypes, PRODUCT_QUESTIONNAIRE, forms} from 'sdc-app/onboarding/softwareProduct/SoftwareProductConstants.js';
+import {
+    actionTypes,
+    onboardingOriginTypes,
+    PRODUCT_QUESTIONNAIRE,
+    forms
+} from 'sdc-app/onboarding/softwareProduct/SoftwareProductConstants.js';
 import OnboardingActionHelper from 'sdc-app/onboarding/OnboardingActionHelper.js';
 import SoftwareProductComponentsActionHelper from './components/SoftwareProductComponentsActionHelper.js';
-import {actionsEnum as VersionControllerActionsEnum} from 'nfvo-components/panel/versionController/VersionControllerConstants.js';
-import {actionTypes as HeatSetupActions} from 'sdc-app/onboarding/softwareProduct/attachments/setup/HeatSetupConstants.js';
-import {actionTypes as featureGroupsActionConstants} from 'sdc-app/onboarding/licenseModel/featureGroups/FeatureGroupsConstants.js';
-import {actionTypes as licenseAgreementActionTypes} from 'sdc-app/onboarding/licenseModel/licenseAgreement/LicenseAgreementConstants.js';
-import {actionTypes as componentActionTypes} from './components/SoftwareProductComponentsConstants.js';
+import { actionsEnum as VersionControllerActionsEnum } from 'nfvo-components/panel/versionController/VersionControllerConstants.js';
+import { actionTypes as HeatSetupActions } from 'sdc-app/onboarding/softwareProduct/attachments/setup/HeatSetupConstants.js';
+import { actionTypes as featureGroupsActionConstants } from 'sdc-app/onboarding/licenseModel/featureGroups/FeatureGroupsConstants.js';
+import { actionTypes as licenseAgreementActionTypes } from 'sdc-app/onboarding/licenseModel/licenseAgreement/LicenseAgreementConstants.js';
+import { actionTypes as componentActionTypes } from './components/SoftwareProductComponentsConstants.js';
 import ValidationHelper from 'sdc-app/common/helpers/ValidationHelper.js';
-import {actionTypes as modalActionTypes} from 'nfvo-components/modal/GlobalModalConstants.js';
-import {modalContentMapper} from 'sdc-app/common/modal/ModalContentMapper.js';
-import {default as ItemsHelper} from 'sdc-app/common/helpers/ItemsHelper.js';
+import { actionTypes as modalActionTypes } from 'nfvo-components/modal/GlobalModalConstants.js';
+import { modalContentMapper } from 'sdc-app/common/modal/ModalContentMapper.js';
+import { default as ItemsHelper } from 'sdc-app/common/helpers/ItemsHelper.js';
 import ScreensHelper from 'sdc-app/common/helpers/ScreensHelper.js';
-import {enums, screenTypes} from 'sdc-app/onboarding/OnboardingConstants.js';
+import { enums, screenTypes } from 'sdc-app/onboarding/OnboardingConstants.js';
 import MergeEditorActionHelper from 'sdc-app/common/merge/MergeEditorActionHelper.js';
-import {CommitModalType} from 'nfvo-components/panel/versionController/components/CommitCommentModal.jsx';
-import {actionTypes as commonActionTypes} from 'sdc-app/common/reducers/PlainDataReducerConstants.js';
+import { CommitModalType } from 'nfvo-components/panel/versionController/components/CommitCommentModal.jsx';
+import { actionTypes as commonActionTypes } from 'sdc-app/common/reducers/PlainDataReducerConstants.js';
 import versionPageActionHelper from 'sdc-app/onboarding/versionsPage/VersionsPageActionHelper.js';
-import {itemTypes} from 'sdc-app/onboarding/versionsPage/VersionsPageConstants.js';
-import {catalogItemStatuses} from 'sdc-app/onboarding/onboard/onboardingCatalog/OnboardingCatalogConstants.js';
+import { itemTypes } from 'sdc-app/onboarding/versionsPage/VersionsPageConstants.js';
+import { catalogItemStatuses } from 'sdc-app/onboarding/onboard/onboardingCatalog/OnboardingCatalogConstants.js';
 import getValue from 'nfvo-utils/getValue.js';
 
 function getLicensingData(licensingData = {}) {
-	const {licenseAgreement, featureGroups} = licensingData;
-	const newlicenseAgreement = getValue(licenseAgreement);
-	const newfeatureGroups = getValue(featureGroups);
-	return newlicenseAgreement ? {
-		licenseAgreement: newlicenseAgreement,
-		featureGroups: newfeatureGroups
-	} : undefined;
-};
+    const { licenseAgreement, featureGroups } = licensingData;
+    const newlicenseAgreement = getValue(licenseAgreement);
+    const newfeatureGroups = getValue(featureGroups);
+    return newlicenseAgreement
+        ? {
+              licenseAgreement: newlicenseAgreement,
+              featureGroups: newfeatureGroups
+          }
+        : undefined;
+}
 
 function baseUrl() {
-	const restPrefix = Configuration.get('restPrefix');
-	return `${restPrefix}/v1.0/vendor-software-products/`;
+    const restPrefix = Configuration.get('restPrefix');
+    return `${restPrefix}/v1.0/vendor-software-products/`;
 }
 function softwareProductCategoriesUrl() {
-	const restCatalogPrefix = Configuration.get('restCatalogPrefix');
-	return `${restCatalogPrefix}/v1/categories/resources/`;
+    const restCatalogPrefix = Configuration.get('restCatalogPrefix');
+    return `${restCatalogPrefix}/v1/categories/resources/`;
 }
 
 function uploadFile(vspId, formData, version) {
-	return RestAPIUtil.post(`${baseUrl()}${vspId}/versions/${version.id}/orchestration-template-candidate`, formData);
-
+    return RestAPIUtil.post(
+        `${baseUrl()}${vspId}/versions/${
+            version.id
+        }/orchestration-template-candidate`,
+        formData
+    );
 }
 
-function putSoftwareProduct({softwareProduct, version}) {
-	return RestAPIUtil.put(`${baseUrl()}${softwareProduct.id}/versions/${version.id}`, {
-		name: softwareProduct.name,
-		description: softwareProduct.description,
-		category: softwareProduct.category,
-		subCategory: softwareProduct.subCategory,
-		vendorId: softwareProduct.vendorId,
-		vendorName: softwareProduct.vendorName,
-		licensingVersion: softwareProduct.licensingVersion ? softwareProduct.licensingVersion : undefined,
-		icon: softwareProduct.icon,
-		licensingData: getLicensingData(softwareProduct.licensingData)
-	});
+function putSoftwareProduct({ softwareProduct, version }) {
+    return RestAPIUtil.put(
+        `${baseUrl()}${softwareProduct.id}/versions/${version.id}`,
+        {
+            name: softwareProduct.name,
+            description: softwareProduct.description,
+            category: softwareProduct.category,
+            subCategory: softwareProduct.subCategory,
+            vendorId: softwareProduct.vendorId,
+            vendorName: softwareProduct.vendorName,
+            licensingVersion: softwareProduct.licensingVersion
+                ? softwareProduct.licensingVersion
+                : undefined,
+            icon: softwareProduct.icon,
+            licensingData: getLicensingData(softwareProduct.licensingData)
+        }
+    );
 }
 
 function putSoftwareProductQuestionnaire(vspId, qdata, version) {
-	return RestAPIUtil.put(`${baseUrl()}${vspId}/versions/${version.id}/questionnaire`, qdata);
+    return RestAPIUtil.put(
+        `${baseUrl()}${vspId}/versions/${version.id}/questionnaire`,
+        qdata
+    );
 }
 
 function putSoftwareProductAction(id, action, version) {
-	return RestAPIUtil.put(`${baseUrl()}${id}/versions/${version.id}/actions`, {action: action});
+    return RestAPIUtil.put(`${baseUrl()}${id}/versions/${version.id}/actions`, {
+        action: action
+    });
 }
 
 function fetchSoftwareProductList() {
-	return RestAPIUtil.fetch(`${baseUrl()}?versionFilter=${catalogItemStatuses.DRAFT}`);
+    return RestAPIUtil.fetch(
+        `${baseUrl()}?versionFilter=${catalogItemStatuses.DRAFT}`
+    );
 }
 
 function fetchArchivedSoftwareProductList() {
-	return RestAPIUtil.fetch(`${baseUrl()}?Status=${catalogItemStatuses.ARCHIVED}`);
+    return RestAPIUtil.fetch(
+        `${baseUrl()}?Status=${catalogItemStatuses.ARCHIVED}`
+    );
 }
 
 function fetchFinalizedSoftwareProductList() {
-	return RestAPIUtil.fetch(`${baseUrl()}?versionFilter=${catalogItemStatuses.CERTIFIED}`);
+    return RestAPIUtil.fetch(
+        `${baseUrl()}?versionFilter=${catalogItemStatuses.CERTIFIED}`
+    );
 }
 
 function fetchSoftwareProduct(vspId, version) {
-	return RestAPIUtil.fetch(`${baseUrl()}${vspId}/versions/${version.id}`);
+    return RestAPIUtil.fetch(`${baseUrl()}${vspId}/versions/${version.id}`);
 }
 
 function fetchSoftwareProductQuestionnaire(vspId, version) {
-	return RestAPIUtil.fetch(`${baseUrl()}${vspId}/versions/${version.id}/questionnaire`);
+    return RestAPIUtil.fetch(
+        `${baseUrl()}${vspId}/versions/${version.id}/questionnaire`
+    );
 }
 
-function updateSoftwareProductHeatCandidate(softwareProductId, heatCandidate, version) {
-	return RestAPIUtil.put(`${baseUrl()}${softwareProductId}/versions/${version.id}/orchestration-template-candidate/manifest`, heatCandidate);
+function updateSoftwareProductHeatCandidate(
+    softwareProductId,
+    heatCandidate,
+    version
+) {
+    return RestAPIUtil.put(
+        `${baseUrl()}${softwareProductId}/versions/${
+            version.id
+        }/orchestration-template-candidate/manifest`,
+        heatCandidate
+    );
 }
 function validateHeatCandidate(softwareProductId, version) {
-	return RestAPIUtil.put(`${baseUrl()}${softwareProductId}/versions/${version.id}/orchestration-template-candidate/process`);
+    return RestAPIUtil.put(
+        `${baseUrl()}${softwareProductId}/versions/${
+            version.id
+        }/orchestration-template-candidate/process`
+    );
 }
 
-function fetchOrchestrationTemplateCandidate(softwareProductId, version, ) {
-	return RestAPIUtil.fetch(`${baseUrl()}${softwareProductId}/versions/${version.id}/orchestration-template-candidate`, {dataType: 'binary'});
+function fetchOrchestrationTemplateCandidate(softwareProductId, version) {
+    return RestAPIUtil.fetch(
+        `${baseUrl()}${softwareProductId}/versions/${
+            version.id
+        }/orchestration-template-candidate`,
+        { dataType: 'binary' }
+    );
 }
 
 function abortValidationProcess(softwareProductId, version) {
-	return RestAPIUtil.destroy(`${baseUrl()}${softwareProductId}/versions/${version.id}/orchestration-template-candidate`);
+    return RestAPIUtil.destroy(
+        `${baseUrl()}${softwareProductId}/versions/${
+            version.id
+        }/orchestration-template-candidate`
+    );
 }
 
 function objToString(obj) {
-	let str = '';
-	if (obj instanceof Array) {
-		obj.forEach((item) => {
-			str += objToString(item) + '\n';
-		});
-	}
-	else {
-		for (let p in obj) {
-			if (obj.hasOwnProperty(p)) {
-				str += obj[p] + '\n';
-			}
-		}
-	}
-	return str.replace(/\n$/, '');
+    let str = '';
+    if (obj instanceof Array) {
+        obj.forEach(item => {
+            str += objToString(item) + '\n';
+        });
+    } else {
+        for (let p in obj) {
+            if (obj.hasOwnProperty(p)) {
+                str += obj[p] + '\n';
+            }
+        }
+    }
+    return str.replace(/\n$/, '');
 }
 
 function parseUploadErrorMsg(error) {
-	let message = '';
-	for (let key in error) {
-		if (error.hasOwnProperty(key)) {
-			message += objToString(error[key]) + '\n';
-		}
-	}
-	return message.replace(/\n$/, '');
+    let message = '';
+    for (let key in error) {
+        if (error.hasOwnProperty(key)) {
+            message += objToString(error[key]) + '\n';
+        }
+    }
+    return message.replace(/\n$/, '');
 }
 
 function fetchSoftwareProductCategories(dispatch) {
-	let handleResponse = response => dispatch({
-		type: actionTypes.SOFTWARE_PRODUCT_CATEGORIES_LOADED,
-		softwareProductCategories: response
-	});
-	return RestAPIUtil.fetch(softwareProductCategoriesUrl())
-		.then(handleResponse)
-		.catch(() => handleResponse(null));
+    let handleResponse = response =>
+        dispatch({
+            type: actionTypes.SOFTWARE_PRODUCT_CATEGORIES_LOADED,
+            softwareProductCategories: response
+        });
+    return RestAPIUtil.fetch(softwareProductCategoriesUrl())
+        .then(handleResponse)
+        .catch(() => handleResponse(null));
 }
 
-function loadLicensingData(dispatch, {licenseModelId, licensingVersion}) {
-	return ItemsHelper.fetchVersion({itemId: licenseModelId, versionId: licensingVersion}).then(() => {
-		return Promise.all([
-			LicenseAgreementActionHelper.fetchLicenseAgreementList(dispatch, {licenseModelId, version: {id: licensingVersion}}),
-			FeatureGroupsActionHelper.fetchFeatureGroupsList(dispatch, {licenseModelId, version: {id: licensingVersion}})
-		]);
-	});
+function loadLicensingData(dispatch, { licenseModelId, licensingVersion }) {
+    return ItemsHelper.fetchVersion({
+        itemId: licenseModelId,
+        versionId: licensingVersion
+    }).then(() => {
+        return Promise.all([
+            LicenseAgreementActionHelper.fetchLicenseAgreementList(dispatch, {
+                licenseModelId,
+                version: { id: licensingVersion }
+            }),
+            FeatureGroupsActionHelper.fetchFeatureGroupsList(dispatch, {
+                licenseModelId,
+                version: { id: licensingVersion }
+            })
+        ]);
+    });
 }
 
 function getExpandedItemsId(items, itemIdToToggle) {
-	for (let i = 0; i < items.length; i++) {
-		if (items[i].id === itemIdToToggle) {
-			if (items[i].expanded) {
-				return {};
-			}
-			else {
-				return {[itemIdToToggle]: true};
-			}
-		}
-		else if (items[i].items && items[i].items.length > 0) {
-			let mapOfExpandedIds = getExpandedItemsId(items[i].items, itemIdToToggle);
-			if (mapOfExpandedIds !== false) {
-				mapOfExpandedIds[items[i].id] = true;
-				return mapOfExpandedIds;
-			}
-		}
-	}
-	return false;
+    for (let i = 0; i < items.length; i++) {
+        if (items[i].id === itemIdToToggle) {
+            if (items[i].expanded) {
+                return {};
+            } else {
+                return { [itemIdToToggle]: true };
+            }
+        } else if (items[i].items && items[i].items.length > 0) {
+            let mapOfExpandedIds = getExpandedItemsId(
+                items[i].items,
+                itemIdToToggle
+            );
+            if (mapOfExpandedIds !== false) {
+                mapOfExpandedIds[items[i].id] = true;
+                return mapOfExpandedIds;
+            }
+        }
+    }
+    return false;
 }
 
 function migrateSoftwareProduct(vspId, version) {
-	return RestAPIUtil.put(`${baseUrl()}${vspId}/versions/${version.id}/heal`);
+    return RestAPIUtil.put(`${baseUrl()}${vspId}/versions/${version.id}/heal`);
 }
 
-
-
 const SoftwareProductActionHelper = {
-
-	fetchFinalizedSoftwareProductList(dispatch) {
-		return fetchFinalizedSoftwareProductList().then(response => dispatch({
-			type: actionTypes.FINALIZED_SOFTWARE_PRODUCT_LIST_LOADED,
-			response
-		}));
-	},
-
-	fetchArchivedSoftwareProductList(dispatch) {
-		return fetchArchivedSoftwareProductList().then(response => dispatch({
-			type: actionTypes.ARCHIVED_SOFTWARE_PRODUCT_LIST_LOADED,
-			response
-		}));
-	},
-
-	loadSoftwareProductAssociatedData(dispatch) {
-		fetchSoftwareProductCategories(dispatch);
-		LicenseModelActionHelper.fetchFinalizedLicenseModels(dispatch);
-	},
-
-	loadSoftwareProductDetailsData(dispatch, {licenseModelId, licensingVersion}) {
-		SoftwareProductActionHelper.loadSoftwareProductAssociatedData(dispatch);
-		if (licensingVersion) {
-			return loadLicensingData(dispatch, {licenseModelId, licensingVersion});
-		}
-		return Promise.resolve();
-	},
-
-	fetchSoftwareProductList(dispatch) {
-		return fetchSoftwareProductList().then(response => dispatch({
-			type: actionTypes.SOFTWARE_PRODUCT_LIST_LOADED,
-			response
-		}));
-	},
-
-	loadSoftwareProductHeatCandidate(dispatch, {softwareProductId, version}){
-		return RestAPIUtil.fetch(`${baseUrl()}${softwareProductId}/versions/${version.id}/orchestration-template-candidate/manifest`).then(response => dispatch({
-			type: HeatSetupActions.MANIFEST_LOADED,
-			response
-		}));
-	},
-
-	loadLicensingVersionsList(dispatch, {licenseModelId}){
-		return ItemsHelper.fetchVersions({itemId: licenseModelId}).then(response => {
-			dispatch({
-				type: actionTypes.LOAD_LICENSING_VERSIONS_LIST,
-				licensingVersionsList: response.results
-			});
-		});
-	},
-	updateSoftwareProductHeatCandidate(dispatch, {softwareProductId, heatCandidate, version}){
-		return updateSoftwareProductHeatCandidate(softwareProductId, heatCandidate, version);
-	},
-
-	processAndValidateHeatCandidate(dispatch, {softwareProductId, version}){
-		return validateHeatCandidate(softwareProductId, version).then(response => {
-			if (response.status === 'Success') {
-				SoftwareProductComponentsActionHelper.fetchSoftwareProductComponents(dispatch, {softwareProductId, version});
-				SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {softwareProductId, version});
-			} else {
-				SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {softwareProductId, version});
-			}
-		});
-	},
-
-	uploadFile(dispatch, {softwareProductId, formData, failedNotificationTitle, version}) {
-		dispatch({
-			type: HeatSetupActions.FILL_HEAT_SETUP_CACHE,
-			payload: {}
-		});
-
-		Promise.resolve()
-			.then(() => uploadFile(softwareProductId, formData, version))
-			.then(response => {
-				if (response.status === 'Success') {
-					dispatch({
-						type: commonActionTypes.DATA_CHANGED,
-						deltaData: {onboardingOrigin: response.onboardingOrigin},
-						formName: forms.VENDOR_SOFTWARE_PRODUCT_DETAILS
-					});
-					switch(response.onboardingOrigin){
-						case onboardingOriginTypes.ZIP:
-							ScreensHelper.loadScreen(dispatch, {
-								screen: enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS_SETUP, screenType: screenTypes.SOFTWARE_PRODUCT,
-								props: {softwareProductId, version}
-							});
-							dispatch({
-								type: actionTypes.CANDIDATE_IN_PROCESS,
-								inProcess: true
-							});
-							break;
-						case onboardingOriginTypes.CSAR:
-							ScreensHelper.loadScreen(dispatch, {
-								screen: enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS_VALIDATION, screenType: screenTypes.SOFTWARE_PRODUCT,
-								props: {softwareProductId, version}
-							});
-							break;
-					}
-				}
-				else {
-					throw new Error(parseUploadErrorMsg(response.errors));
-				}
-			})
-			.catch(error => {
-				dispatch({
-					type: modalActionTypes.GLOBAL_MODAL_ERROR,
-					data: {
-						title: failedNotificationTitle,
-						msg: error.message || (error.responseJSON && error.responseJSON.message)
-					}
-				});
-			});
-	},
-
-	downloadHeatFile(dispatch, {softwareProductId, heatCandidate, isReadOnlyMode, version}){
-		let p = isReadOnlyMode ? Promise.resolve() : SoftwareProductActionHelper.updateSoftwareProductHeatCandidate(dispatch, {
-			softwareProductId,
-			heatCandidate,
-			version});
-		p.then(() => {
-			fetchOrchestrationTemplateCandidate(softwareProductId, version)
-				.then((response) => {
-					showFileSaveDialog({
-						blob: response.blob,
-						headers: response.headers,
-						defaultFilename: 'HEAT_file.zip',
-						addTimestamp: true
-					});
-				});
-		}, null/* do not download if data was not saved correctly*/);
-	},
-
-	hideUploadConfirm (dispatch) {
-		dispatch({
-			type: actionTypes.softwareProductEditor.UPLOAD_CONFIRMATION
-		});
-	},
-	updateSoftwareProduct(dispatch, {softwareProduct, version, qdata}) {
-		return Promise.all([
-			SoftwareProductActionHelper.updateSoftwareProductData(dispatch, {softwareProduct, version}).then(
-				() => dispatch({
-					type: actionTypes.SOFTWARE_PRODUCT_LIST_EDIT,
-					payload: {softwareProduct}
-				})
-			),
-			SoftwareProductActionHelper.updateSoftwareProductQuestionnaire(dispatch, {
-				softwareProductId: softwareProduct.id,
-				qdata,
-				version
-			})
-		]);
-	},
-
-	updateSoftwareProductData(dispatch, {softwareProduct, version}) {
-		return putSoftwareProduct({softwareProduct, version});
-	},
-
-	updateSoftwareProductQuestionnaire(dispatch, {softwareProductId, qdata, version}) {
-		return putSoftwareProductQuestionnaire(softwareProductId, qdata, version);
-	},
-
-	softwareProductEditorDataChanged(dispatch, {deltaData}) {
-		dispatch({
-			type: actionTypes.softwareProductEditor.DATA_CHANGED,
-			deltaData
-		});
-	},
-
-	softwareProductQuestionnaireUpdate(dispatch, {data}) {
-		dispatch({
-			type: actionTypes.SOFTWARE_PRODUCT_QUESTIONNAIRE_UPDATE,
-			payload: {qdata: data}
-		});
-	},
-
-	softwareProductEditorVendorChanged(dispatch, {deltaData, formName}) {
-		if (deltaData.licensingVersion){
-			return loadLicensingData(dispatch, {licenseModelId: deltaData.vendorId, licensingVersion: deltaData.licensingVersion}).then(() => {
-				ValidationHelper.dataChanged(dispatch, {deltaData, formName});
-				return Promise.resolve();
-			});
-		} else if (deltaData.vendorId) {
-			ValidationHelper.dataChanged(dispatch, {deltaData, formName});
-			return SoftwareProductActionHelper.loadLicensingVersionsList(dispatch, {
-				licenseModelId: deltaData.vendorId
-			}).then( () =>
-				OnboardingActionHelper.forceBreadCrumbsUpdate(dispatch)
-			);
-		} else {
-			ValidationHelper.dataChanged(dispatch, {deltaData, formName});
-
-			dispatch({
-				type: licenseAgreementActionTypes.LICENSE_AGREEMENT_LIST_LOADED,
-				response: {results: []}
-			});
-
-			dispatch({
-				type: featureGroupsActionConstants.FEATURE_GROUPS_LIST_LOADED,
-				response: {results: []}
-			});
-		}
-
-	},
-
-	setIsValidityData(dispatch, {isValidityData}) {
-		dispatch({
-			type: actionTypes.softwareProductEditor.IS_VALIDITY_DATA_CHANGED,
-			isValidityData
-		});
-	},
-
-	fetchSoftwareProduct(dispatch, {softwareProductId, version}) {
-		return Promise.all([
-			fetchSoftwareProduct(softwareProductId, version).then(response => {
-				dispatch({
-					type: actionTypes.SOFTWARE_PRODUCT_LOADED,
-					response
-				});
-				return response;
-			}),
-			fetchSoftwareProductQuestionnaire(softwareProductId, version).then(response => {
-				ValidationHelper.qDataLoaded(dispatch, {response: {qdata: response.data ? JSON.parse(response.data) : {},
-					qschema: JSON.parse(response.schema)}, qName: PRODUCT_QUESTIONNAIRE});
-			})
-		]);
-	},
-
-	manageSubmitAction(dispatch, {softwareProductId, version, isDirty}) {
-		if (isDirty) {
-			const onCommit = comment => {
-				return this.performVCAction(dispatch, {softwareProductId, action: VersionControllerActionsEnum.COMMIT, version, comment}).then(() => {
-					return this.performSubmitAction(dispatch, {softwareProductId, version});
-				});
-			};
-			dispatch({
-				type: modalActionTypes.GLOBAL_MODAL_SHOW,
-				data: {
-					modalComponentName: modalContentMapper.COMMIT_COMMENT,
-					modalComponentProps: {
-						onCommit,
-						type: CommitModalType.COMMIT_SUBMIT
-					},
-					title: i18n('Commit & Submit')
-				}
-			});
-			return Promise.resolve(version);
-		}
-		return this.performSubmitAction(dispatch, {softwareProductId, version});
-	},
-
-	performSubmitAction(dispatch, {softwareProductId, version}) {
-		return putSoftwareProductAction(softwareProductId, VersionControllerActionsEnum.SUBMIT, version).then(() => {
-			return putSoftwareProductAction(softwareProductId, VersionControllerActionsEnum.CREATE_PACKAGE, version).then(() => {
-				return ItemsHelper.checkItemStatus(dispatch, {itemId: softwareProductId, versionId: version.id}).then(updatedVersion => {
-					dispatch({
-						type: modalActionTypes.GLOBAL_MODAL_SUCCESS,
-						data: {
-							title: i18n('Submit Succeeded'),
-							msg: i18n('This software product successfully submitted'),
-							cancelButtonText: i18n('OK'),
-							timeout: 2000
-						}
-					});
-					versionPageActionHelper.fetchVersions(dispatch, {itemType: itemTypes.SOFTWARE_PRODUCT, itemId: softwareProductId});
-					return Promise.resolve(updatedVersion);
-				});
-			});
-		}, error =>
-		{
-			dispatch({
-				type: modalActionTypes.GLOBAL_MODAL_ERROR,
-				data: {
-					modalComponentName: modalContentMapper.SUMBIT_ERROR_RESPONSE,
-					title: i18n('Submit Failed'),
-					modalComponentProps: {
-						validationResponse: error.responseJSON
-					},
-					cancelButtonText: i18n('OK')
-				}
-			});
-			return Promise.reject(error.responseJSON);
-		});
-	},
-
-	performVCAction(dispatch, {softwareProductId, action, version, comment}) {
-		return MergeEditorActionHelper.analyzeSyncResult(dispatch, {itemId: softwareProductId, version}).then(({inMerge, isDirty, updatedVersion}) => {
-			if ((updatedVersion.status === catalogItemStatuses.CERTIFIED || updatedVersion.archivedStatus === catalogItemStatuses.ARCHIVED) &&
-					 (action === VersionControllerActionsEnum.COMMIT || action === VersionControllerActionsEnum.SYNC)) {
-				versionPageActionHelper.fetchVersions(dispatch, {itemType: itemTypes.SOFTWARE_PRODUCT, itemId: softwareProductId});
-				const msg = updatedVersion.archivedStatus === catalogItemStatuses.ARCHIVED ? i18n('Item was Archived') : i18n('Item version already Certified');
-				dispatch({
-					type: modalActionTypes.GLOBAL_MODAL_WARNING,
-					data: {
-						title: i18n('Commit error'),
-						msg,
-						cancelButtonText: i18n('Cancel')
-					}
-				});
-				return Promise.resolve(updatedVersion);
-			}
-			if (!inMerge) {
-				if (action === VersionControllerActionsEnum.SUBMIT) {
-					return this.manageSubmitAction(dispatch, {softwareProductId, version, isDirty});
-				}
-				else {
-					let isCallActionValid = action !== VersionControllerActionsEnum.COMMIT || isDirty;
-					if(isCallActionValid) {
-						return 	ItemsHelper.performVCAction({itemId: softwareProductId, action, version, comment}).then(() => {
-							versionPageActionHelper.fetchVersions(dispatch, {itemType: itemTypes.LICENSE_MODEL, itemId: softwareProductId});
-							if (action === VersionControllerActionsEnum.SYNC) {
-								return MergeEditorActionHelper.analyzeSyncResult(dispatch, {itemId: softwareProductId, version}).then(({updatedVersion}) => {
-									return Promise.resolve(updatedVersion);
-								});
-							} else {
-								return ItemsHelper.checkItemStatus(dispatch, {itemId: softwareProductId, versionId: version.id});
-							}
-						});
-					}
-					else {
-						dispatch({
-							type: modalActionTypes.GLOBAL_MODAL_ERROR,
-							data: {
-								title: i18n('Commit Failed'),
-								msg: i18n('There is nothing to commit')
-							}
-						});
-					}
-				}
-			}
-		});
-	},
-
-	toggleNavigationItems(dispatch, {items, itemIdToExpand}) {
-		let mapOfExpandedIds = getExpandedItemsId(items, itemIdToExpand);
-		dispatch({
-			type: actionTypes.TOGGLE_NAVIGATION_ITEM,
-			mapOfExpandedIds
-		});
-	},
-
-	/** for the next verision */
-	addComponent(dispatch, {softwareProductId, modalClassName, version}) {
-		SoftwareProductComponentsActionHelper.clearComponentCreationData(dispatch);
-		dispatch({
-			type: componentActionTypes.COMPONENT_CREATE_OPEN
-		});
-		dispatch({
-			type: modalActionTypes.GLOBAL_MODAL_SHOW,
-			data: {
-				modalComponentName: modalContentMapper.COMPONENT_CREATION,
-				modalComponentProps: {softwareProductId, version},
-				modalClassName,
-				title: 'Create Virtual Function Component'
-			}
-		});
-	},
-
-	migrateSoftwareProduct(dispatch, {softwareProduct}) {
-		let {id: softwareProductId, version} = softwareProduct;
-		const  newVer = version.id;
-		migrateSoftwareProduct(softwareProductId, version).then(() => ScreensHelper.loadScreen(dispatch, {
-			screen: enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE, screenType: screenTypes.SOFTWARE_PRODUCT,
-			props: {softwareProductId, version: {id: newVer, label: newVer}}
-		}));
-	},
-
-	abortCandidateValidation(dispatch, {softwareProductId, version}) {		
-		return abortValidationProcess(softwareProductId, version);
-	}
-
+    fetchFinalizedSoftwareProductList(dispatch) {
+        return fetchFinalizedSoftwareProductList().then(response =>
+            dispatch({
+                type: actionTypes.FINALIZED_SOFTWARE_PRODUCT_LIST_LOADED,
+                response
+            })
+        );
+    },
+
+    fetchArchivedSoftwareProductList(dispatch) {
+        return fetchArchivedSoftwareProductList().then(response =>
+            dispatch({
+                type: actionTypes.ARCHIVED_SOFTWARE_PRODUCT_LIST_LOADED,
+                response
+            })
+        );
+    },
+
+    loadSoftwareProductAssociatedData(dispatch) {
+        fetchSoftwareProductCategories(dispatch);
+        LicenseModelActionHelper.fetchFinalizedLicenseModels(dispatch);
+    },
+
+    loadSoftwareProductDetailsData(
+        dispatch,
+        { licenseModelId, licensingVersion }
+    ) {
+        SoftwareProductActionHelper.loadSoftwareProductAssociatedData(dispatch);
+        if (licensingVersion) {
+            return loadLicensingData(dispatch, {
+                licenseModelId,
+                licensingVersion
+            });
+        }
+        return Promise.resolve();
+    },
+
+    fetchSoftwareProductList(dispatch) {
+        return fetchSoftwareProductList().then(response =>
+            dispatch({
+                type: actionTypes.SOFTWARE_PRODUCT_LIST_LOADED,
+                response
+            })
+        );
+    },
+
+    loadSoftwareProductHeatCandidate(dispatch, { softwareProductId, version }) {
+        return RestAPIUtil.fetch(
+            `${baseUrl()}${softwareProductId}/versions/${
+                version.id
+            }/orchestration-template-candidate/manifest`
+        ).then(response =>
+            dispatch({
+                type: HeatSetupActions.MANIFEST_LOADED,
+                response
+            })
+        );
+    },
+
+    loadLicensingVersionsList(dispatch, { licenseModelId }) {
+        return ItemsHelper.fetchVersions({ itemId: licenseModelId }).then(
+            response => {
+                dispatch({
+                    type: actionTypes.LOAD_LICENSING_VERSIONS_LIST,
+                    licensingVersionsList: response.results
+                });
+            }
+        );
+    },
+    updateSoftwareProductHeatCandidate(
+        dispatch,
+        { softwareProductId, heatCandidate, version }
+    ) {
+        return updateSoftwareProductHeatCandidate(
+            softwareProductId,
+            heatCandidate,
+            version
+        );
+    },
+
+    processAndValidateHeatCandidate(dispatch, { softwareProductId, version }) {
+        return validateHeatCandidate(softwareProductId, version).then(
+            response => {
+                if (response.status === 'Success') {
+                    SoftwareProductComponentsActionHelper.fetchSoftwareProductComponents(
+                        dispatch,
+                        { softwareProductId, version }
+                    );
+                    SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {
+                        softwareProductId,
+                        version
+                    });
+                } else {
+                    SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {
+                        softwareProductId,
+                        version
+                    });
+                }
+            }
+        );
+    },
+
+    uploadFile(
+        dispatch,
+        { softwareProductId, formData, failedNotificationTitle, version }
+    ) {
+        dispatch({
+            type: HeatSetupActions.FILL_HEAT_SETUP_CACHE,
+            payload: {}
+        });
+
+        Promise.resolve()
+            .then(() => uploadFile(softwareProductId, formData, version))
+            .then(response => {
+                if (response.status === 'Success') {
+                    dispatch({
+                        type: commonActionTypes.DATA_CHANGED,
+                        deltaData: {
+                            onboardingOrigin: response.onboardingOrigin
+                        },
+                        formName: forms.VENDOR_SOFTWARE_PRODUCT_DETAILS
+                    });
+                    switch (response.onboardingOrigin) {
+                        case onboardingOriginTypes.ZIP:
+                            ScreensHelper.loadScreen(dispatch, {
+                                screen:
+                                    enums.SCREEN
+                                        .SOFTWARE_PRODUCT_ATTACHMENTS_SETUP,
+                                screenType: screenTypes.SOFTWARE_PRODUCT,
+                                props: { softwareProductId, version }
+                            });
+                            dispatch({
+                                type: actionTypes.CANDIDATE_IN_PROCESS,
+                                inProcess: true
+                            });
+                            break;
+                        case onboardingOriginTypes.CSAR:
+                            ScreensHelper.loadScreen(dispatch, {
+                                screen:
+                                    enums.SCREEN
+                                        .SOFTWARE_PRODUCT_ATTACHMENTS_VALIDATION,
+                                screenType: screenTypes.SOFTWARE_PRODUCT,
+                                props: { softwareProductId, version }
+                            });
+                            break;
+                    }
+                } else {
+                    throw new Error(parseUploadErrorMsg(response.errors));
+                }
+            })
+            .catch(error => {
+                dispatch({
+                    type: modalActionTypes.GLOBAL_MODAL_ERROR,
+                    data: {
+                        title: failedNotificationTitle,
+                        msg:
+                            error.message ||
+                            (error.responseJSON && error.responseJSON.message)
+                    }
+                });
+            });
+    },
+
+    downloadHeatFile(
+        dispatch,
+        { softwareProductId, heatCandidate, isReadOnlyMode, version }
+    ) {
+        let p = isReadOnlyMode
+            ? Promise.resolve()
+            : SoftwareProductActionHelper.updateSoftwareProductHeatCandidate(
+                  dispatch,
+                  {
+                      softwareProductId,
+                      heatCandidate,
+                      version
+                  }
+              );
+        p.then(() => {
+            fetchOrchestrationTemplateCandidate(
+                softwareProductId,
+                version
+            ).then(response => {
+                showFileSaveDialog({
+                    blob: response.blob,
+                    headers: response.headers,
+                    defaultFilename: 'HEAT_file.zip',
+                    addTimestamp: true
+                });
+            });
+        }, null /* do not download if data was not saved correctly*/);
+    },
+
+    hideUploadConfirm(dispatch) {
+        dispatch({
+            type: actionTypes.softwareProductEditor.UPLOAD_CONFIRMATION
+        });
+    },
+    updateSoftwareProduct(dispatch, { softwareProduct, version, qdata }) {
+        return Promise.all([
+            SoftwareProductActionHelper.updateSoftwareProductData(dispatch, {
+                softwareProduct,
+                version
+            }).then(() =>
+                dispatch({
+                    type: actionTypes.SOFTWARE_PRODUCT_LIST_EDIT,
+                    payload: { softwareProduct }
+                })
+            ),
+            SoftwareProductActionHelper.updateSoftwareProductQuestionnaire(
+                dispatch,
+                {
+                    softwareProductId: softwareProduct.id,
+                    qdata,
+                    version
+                }
+            )
+        ]);
+    },
+
+    updateSoftwareProductData(dispatch, { softwareProduct, version }) {
+        return putSoftwareProduct({ softwareProduct, version });
+    },
+
+    updateSoftwareProductQuestionnaire(
+        dispatch,
+        { softwareProductId, qdata, version }
+    ) {
+        return putSoftwareProductQuestionnaire(
+            softwareProductId,
+            qdata,
+            version
+        );
+    },
+
+    softwareProductEditorDataChanged(dispatch, { deltaData }) {
+        dispatch({
+            type: actionTypes.softwareProductEditor.DATA_CHANGED,
+            deltaData
+        });
+    },
+
+    softwareProductQuestionnaireUpdate(dispatch, { data }) {
+        dispatch({
+            type: actionTypes.SOFTWARE_PRODUCT_QUESTIONNAIRE_UPDATE,
+            payload: { qdata: data }
+        });
+    },
+
+    softwareProductEditorVendorChanged(dispatch, { deltaData, formName }) {
+        if (deltaData.licensingVersion) {
+            return loadLicensingData(dispatch, {
+                licenseModelId: deltaData.vendorId,
+                licensingVersion: deltaData.licensingVersion
+            }).then(() => {
+                ValidationHelper.dataChanged(dispatch, { deltaData, formName });
+                return Promise.resolve();
+            });
+        } else if (deltaData.vendorId) {
+            ValidationHelper.dataChanged(dispatch, { deltaData, formName });
+            return SoftwareProductActionHelper.loadLicensingVersionsList(
+                dispatch,
+                {
+                    licenseModelId: deltaData.vendorId
+                }
+            ).then(() =>
+                OnboardingActionHelper.forceBreadCrumbsUpdate(dispatch)
+            );
+        } else {
+            ValidationHelper.dataChanged(dispatch, { deltaData, formName });
+
+            dispatch({
+                type: licenseAgreementActionTypes.LICENSE_AGREEMENT_LIST_LOADED,
+                response: { results: [] }
+            });
+
+            dispatch({
+                type: featureGroupsActionConstants.FEATURE_GROUPS_LIST_LOADED,
+                response: { results: [] }
+            });
+        }
+    },
+
+    setIsValidityData(dispatch, { isValidityData }) {
+        dispatch({
+            type: actionTypes.softwareProductEditor.IS_VALIDITY_DATA_CHANGED,
+            isValidityData
+        });
+    },
+
+    fetchSoftwareProduct(dispatch, { softwareProductId, version }) {
+        return Promise.all([
+            fetchSoftwareProduct(softwareProductId, version).then(response => {
+                dispatch({
+                    type: actionTypes.SOFTWARE_PRODUCT_LOADED,
+                    response
+                });
+                return response;
+            }),
+            fetchSoftwareProductQuestionnaire(softwareProductId, version).then(
+                response => {
+                    ValidationHelper.qDataLoaded(dispatch, {
+                        response: {
+                            qdata: response.data
+                                ? JSON.parse(response.data)
+                                : {},
+                            qschema: JSON.parse(response.schema)
+                        },
+                        qName: PRODUCT_QUESTIONNAIRE
+                    });
+                }
+            )
+        ]);
+    },
+
+    manageSubmitAction(dispatch, { softwareProductId, version, isDirty }) {
+        if (isDirty) {
+            const onCommit = comment => {
+                return this.performVCAction(dispatch, {
+                    softwareProductId,
+                    action: VersionControllerActionsEnum.COMMIT,
+                    version,
+                    comment
+                }).then(() => {
+                    return this.performSubmitAction(dispatch, {
+                        softwareProductId,
+                        version
+                    });
+                });
+            };
+            dispatch({
+                type: modalActionTypes.GLOBAL_MODAL_SHOW,
+                data: {
+                    modalComponentName: modalContentMapper.COMMIT_COMMENT,
+                    modalComponentProps: {
+                        onCommit,
+                        type: CommitModalType.COMMIT_SUBMIT
+                    },
+                    title: i18n('Commit & Submit')
+                }
+            });
+            return Promise.resolve(version);
+        }
+        return this.performSubmitAction(dispatch, {
+            softwareProductId,
+            version
+        });
+    },
+
+    performSubmitAction(dispatch, { softwareProductId, version }) {
+        return putSoftwareProductAction(
+            softwareProductId,
+            VersionControllerActionsEnum.SUBMIT,
+            version
+        ).then(
+            () => {
+                return putSoftwareProductAction(
+                    softwareProductId,
+                    VersionControllerActionsEnum.CREATE_PACKAGE,
+                    version
+                ).then(() => {
+                    return ItemsHelper.checkItemStatus(dispatch, {
+                        itemId: softwareProductId,
+                        versionId: version.id
+                    }).then(updatedVersion => {
+                        dispatch({
+                            type: modalActionTypes.GLOBAL_MODAL_SUCCESS,
+                            data: {
+                                title: i18n('Submit Succeeded'),
+                                msg: i18n(
+                                    'This software product successfully submitted'
+                                ),
+                                cancelButtonText: i18n('OK'),
+                                timeout: 2000
+                            }
+                        });
+                        versionPageActionHelper.fetchVersions(dispatch, {
+                            itemType: itemTypes.SOFTWARE_PRODUCT,
+                            itemId: softwareProductId
+                        });
+                        return Promise.resolve(updatedVersion);
+                    });
+                });
+            },
+            error => {
+                dispatch({
+                    type: modalActionTypes.GLOBAL_MODAL_ERROR,
+                    data: {
+                        modalComponentName:
+                            modalContentMapper.SUMBIT_ERROR_RESPONSE,
+                        title: i18n('Submit Failed'),
+                        modalComponentProps: {
+                            validationResponse: error.responseJSON
+                        },
+                        cancelButtonText: i18n('OK')
+                    }
+                });
+                return Promise.reject(error.responseJSON);
+            }
+        );
+    },
+
+    performVCAction(dispatch, { softwareProductId, action, version, comment }) {
+        return MergeEditorActionHelper.analyzeSyncResult(dispatch, {
+            itemId: softwareProductId,
+            version
+        }).then(({ inMerge, isDirty, updatedVersion }) => {
+            if (
+                (updatedVersion.status === catalogItemStatuses.CERTIFIED ||
+                    updatedVersion.archivedStatus ===
+                        catalogItemStatuses.ARCHIVED) &&
+                (action === VersionControllerActionsEnum.COMMIT ||
+                    action === VersionControllerActionsEnum.SYNC)
+            ) {
+                versionPageActionHelper.fetchVersions(dispatch, {
+                    itemType: itemTypes.SOFTWARE_PRODUCT,
+                    itemId: softwareProductId
+                });
+                const msg =
+                    updatedVersion.archivedStatus ===
+                    catalogItemStatuses.ARCHIVED
+                        ? i18n('Item was Archived')
+                        : i18n('Item version already Certified');
+                dispatch({
+                    type: modalActionTypes.GLOBAL_MODAL_WARNING,
+                    data: {
+                        title: i18n('Commit error'),
+                        msg,
+                        cancelButtonText: i18n('Cancel')
+                    }
+                });
+                return Promise.resolve(updatedVersion);
+            }
+            if (!inMerge) {
+                if (action === VersionControllerActionsEnum.SUBMIT) {
+                    return this.manageSubmitAction(dispatch, {
+                        softwareProductId,
+                        version,
+                        isDirty
+                    });
+                } else {
+                    let isCallActionValid =
+                        action !== VersionControllerActionsEnum.COMMIT ||
+                        isDirty;
+                    if (isCallActionValid) {
+                        return ItemsHelper.performVCAction({
+                            itemId: softwareProductId,
+                            action,
+                            version,
+                            comment
+                        }).then(() => {
+                            versionPageActionHelper.fetchVersions(dispatch, {
+                                itemType: itemTypes.LICENSE_MODEL,
+                                itemId: softwareProductId
+                            });
+                            if (action === VersionControllerActionsEnum.SYNC) {
+                                return MergeEditorActionHelper.analyzeSyncResult(
+                                    dispatch,
+                                    { itemId: softwareProductId, version }
+                                ).then(({ updatedVersion }) => {
+                                    return Promise.resolve(updatedVersion);
+                                });
+                            } else {
+                                return ItemsHelper.checkItemStatus(dispatch, {
+                                    itemId: softwareProductId,
+                                    versionId: version.id
+                                });
+                            }
+                        });
+                    } else {
+                        dispatch({
+                            type: modalActionTypes.GLOBAL_MODAL_ERROR,
+                            data: {
+                                title: i18n('Commit Failed'),
+                                msg: i18n('There is nothing to commit')
+                            }
+                        });
+                    }
+                }
+            }
+        });
+    },
+
+    toggleNavigationItems(dispatch, { items, itemIdToExpand }) {
+        let mapOfExpandedIds = getExpandedItemsId(items, itemIdToExpand);
+        dispatch({
+            type: actionTypes.TOGGLE_NAVIGATION_ITEM,
+            mapOfExpandedIds
+        });
+    },
+
+    /** for the next verision */
+    addComponent(dispatch, { softwareProductId, modalClassName, version }) {
+        SoftwareProductComponentsActionHelper.clearComponentCreationData(
+            dispatch
+        );
+        dispatch({
+            type: componentActionTypes.COMPONENT_CREATE_OPEN
+        });
+        dispatch({
+            type: modalActionTypes.GLOBAL_MODAL_SHOW,
+            data: {
+                modalComponentName: modalContentMapper.COMPONENT_CREATION,
+                modalComponentProps: { softwareProductId, version },
+                modalClassName,
+                title: 'Create Virtual Function Component'
+            }
+        });
+    },
+
+    migrateSoftwareProduct(dispatch, { softwareProduct }) {
+        let { id: softwareProductId, version } = softwareProduct;
+        const newVer = version.id;
+        migrateSoftwareProduct(softwareProductId, version).then(() =>
+            ScreensHelper.loadScreen(dispatch, {
+                screen: enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE,
+                screenType: screenTypes.SOFTWARE_PRODUCT,
+                props: {
+                    softwareProductId,
+                    version: { id: newVer, label: newVer }
+                }
+            })
+        );
+    },
+
+    abortCandidateValidation(dispatch, { softwareProductId, version }) {
+        return abortValidationProcess(softwareProductId, version);
+    }
 };
 
 export default SoftwareProductActionHelper;