openecomp-ui/src/sdc-app/onboarding/licenseModel/LicenseModelActionHelper.js

/*
 * Copyright © 2016-2018 European Support Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import RestAPIUtil from 'nfvo-utils/RestAPIUtil.js';
import Configuration from 'sdc-app/config/Configuration.js';
import {actionTypes} from './LicenseModelConstants.js';
import {actionTypes as modalActionTypes} from 'nfvo-components/modal/GlobalModalConstants.js';
import {actionsEnum as vcActionsEnum} from 'nfvo-components/panel/versionController/VersionControllerConstants.js';
import i18n from 'nfvo-utils/i18n/i18n.js';
import LicenseAgreementActionHelper from './licenseAgreement/LicenseAgreementActionHelper.js';
import FeatureGroupsActionHelper from './featureGroups/FeatureGroupsActionHelper.js';
import EntitlementPoolsActionHelper from './entitlementPools/EntitlementPoolsActionHelper.js';
import LicenseKeyGroupsActionHelper from './licenseKeyGroups/LicenseKeyGroupsActionHelper.js';
import {default as ItemsHelper} from 'sdc-app/common/helpers/ItemsHelper.js';
import MergeEditorActionHelper from 'sdc-app/common/merge/MergeEditorActionHelper.js';
import {modalContentMapper} from 'sdc-app/common/modal/ModalContentMapper.js';
import {CommitModalType} from 'nfvo-components/panel/versionController/components/CommitCommentModal.jsx';
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 {actionsEnum as VersionControllerActionsEnum} from 'nfvo-components/panel/versionController/VersionControllerConstants.js';

function baseUrl() {
	const restPrefix = Configuration.get('restPrefix');
	return `${restPrefix}/v1.0/vendor-license-models/`;
}

function fetchLicenseModels() {
	return RestAPIUtil.fetch(`${baseUrl()}?versionFilter=${catalogItemStatuses.DRAFT}`);
}

function fetchFinalizedLicenseModels() {
	return RestAPIUtil.fetch(`${baseUrl()}?versionFilter=${catalogItemStatuses.CERTIFIED}`);
}
function fetchArchivedLicenseModels() {
	return RestAPIUtil.fetch(`${baseUrl()}?Status=${catalogItemStatuses.ARCHIVED}`);
}
function fetchLicenseModelById(licenseModelId, version) {
	const {id: versionId} = version;
	return RestAPIUtil.fetch(`${baseUrl()}${licenseModelId}/versions/${versionId}`);
}

function putLicenseModel(licenseModel) {
	let {id, vendorName, description, iconRef, version: {id: versionId}} = licenseModel;
	return RestAPIUtil.put(`${baseUrl()}${id}/versions/${versionId}`, {
		vendorName,
		description,
		iconRef
	});
}

function putLicenseModelAction({itemId, action, version}) {
	const {id: versionId} = version;
	return RestAPIUtil.put(`${baseUrl()}${itemId}/versions/${versionId}/actions`, {action: action});
}

const LicenseModelActionHelper = {

	fetchLicenseModels(dispatch) {
		return fetchLicenseModels().then(response => {
			dispatch({
				type: actionTypes.LICENSE_MODELS_LIST_LOADED,
				response
			});
		});
	},

	fetchFinalizedLicenseModels(dispatch) {
		return fetchFinalizedLicenseModels().then(response => dispatch({
			type: actionTypes.FINALIZED_LICENSE_MODELS_LIST_LOADED,
			response
		}));

	},

	fetchArchivedLicenseModels(dispatch) {
		return fetchArchivedLicenseModels().then(response => dispatch({
			type: actionTypes.ARCHIVED_LICENSE_MODELS_LIST_LOADED,
			response
		}));

	},

	fetchLicenseModelById(dispatch, {licenseModelId, version}) {

		return fetchLicenseModelById(licenseModelId, version).then(response => {
			dispatch({
				type: actionTypes.LICENSE_MODEL_LOADED,
				response: {...response, version}
			});
		});
	},

	fetchLicenseModelItems(dispatch, {licenseModelId, version}) {
		return Promise.all([
			LicenseAgreementActionHelper.fetchLicenseAgreementList(dispatch, {licenseModelId, version}),
			FeatureGroupsActionHelper.fetchFeatureGroupsList(dispatch, {licenseModelId, version}),
			EntitlementPoolsActionHelper.fetchEntitlementPoolsList(dispatch, {licenseModelId, version}),
			LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(dispatch, {licenseModelId, version})
		]);
	},

	manageSubmitAction(dispatch, {licenseModelId, version, isDirty}) {
		if(isDirty) {
			const onCommit = comment => {
				return this.performVCAction(dispatch, {licenseModelId, action: vcActionsEnum.COMMIT, version, comment}).then(() => {
					return this.performSubmitAction(dispatch, {licenseModelId, version});
				});
			};
			dispatch({
				type: modalActionTypes.GLOBAL_MODAL_SHOW,
				data: {
					modalComponentName: modalContentMapper.COMMIT_COMMENT,
					modalComponentProps: {
						onCommit,
						type: CommitModalType.COMMIT_SUBMIT
					},
					title: i18n('Commit & Submit')
				}
			});
			return Promise.reject();
		}
		return this.performSubmitAction(dispatch, {licenseModelId, version});
	},

	performSubmitAction(dispatch, {licenseModelId, version}) {
		return putLicenseModelAction({itemId: licenseModelId, action: vcActionsEnum.SUBMIT, version}).then(() => {
			return ItemsHelper.checkItemStatus(dispatch, {itemId: licenseModelId, versionId: version.id}).then(updatedVersion => {
				dispatch({
					type: modalActionTypes.GLOBAL_MODAL_SUCCESS,
					data: {
						title: i18n('Submit Succeeded'),
						msg: i18n('This license model successfully submitted'),
						cancelButtonText: i18n('OK'),
						timeout: 2000
					}
				});
				versionPageActionHelper.fetchVersions(dispatch, {itemType: itemTypes.LICENSE_MODEL, itemId: licenseModelId});
				return Promise.resolve(updatedVersion);
			});
		});
	},

	performVCAction(dispatch, {licenseModelId, action, version, comment}) {
		return MergeEditorActionHelper.analyzeSyncResult(dispatch, {itemId: licenseModelId, 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.LICENSE_MODEL, itemId: licenseModelId});
				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 === vcActionsEnum.SUBMIT) {
					return this.manageSubmitAction(dispatch, {licenseModelId, version, isDirty});
				}
				else {
					return ItemsHelper.performVCAction({itemId: licenseModelId, action, version, comment}).then(() => {
						versionPageActionHelper.fetchVersions(dispatch, {itemType: itemTypes.LICENSE_MODEL, itemId: licenseModelId});
						if (action === vcActionsEnum.SYNC) {
							return MergeEditorActionHelper.analyzeSyncResult(dispatch, {itemId: licenseModelId, version}).then(({updatedVersion}) => {
								return Promise.resolve(updatedVersion);
							});
						} else {
							return ItemsHelper.checkItemStatus(dispatch, {itemId: licenseModelId, versionId: version.id});
						}
					});
				}
			}
		});
	},

	saveLicenseModel(dispatch, {licenseModel}) {
		return putLicenseModel(licenseModel).then(() => {
			dispatch({
				type: actionTypes.LICENSE_MODEL_LOADED,
				response: licenseModel
			});
			const {id, version: {id: versionId}} = licenseModel;
			return ItemsHelper.checkItemStatus(dispatch, {itemId: id, versionId}).then(updatedVersion => {
				if (updatedVersion.status !== licenseModel.version.status) {
					versionPageActionHelper.fetchVersions(dispatch, {itemType: itemTypes.LICENSE_MODEL, itemId: licenseModel.id});
				}
			});
		});
	}

};

export default LicenseModelActionHelper;