openecomp-ui/src/sdc-app/onboarding/OnboardingActionHelper.js

   1 /*!
   2  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  13  * or implied. See the License for the specific language governing
  14  * permissions and limitations under the License.
  15  */
  16 import LicenseModelActionHelper from './licenseModel/LicenseModelActionHelper.js';
  17 import LicenseAgreementActionHelper from './licenseModel/licenseAgreement/LicenseAgreementActionHelper.js';
  18 import FeatureGroupsActionHelper from './licenseModel/featureGroups/FeatureGroupsActionHelper.js';
  19 import LicenseKeyGroupsActionHelper from './licenseModel/licenseKeyGroups/LicenseKeyGroupsActionHelper.js';
  20 import EntitlementPoolsActionHelper from './licenseModel/entitlementPools/EntitlementPoolsActionHelper.js';
  21 import SoftwareProductActionHelper from './softwareProduct/SoftwareProductActionHelper.js';
  22 import SoftwareProductProcessesActionHelper from './softwareProduct/processes/SoftwareProductProcessesActionHelper.js';
  23 import SoftwareProductDeploymentActionHelper from './softwareProduct/deployment/SoftwareProductDeploymentActionHelper.js';
  24 import SoftwareProductNetworksActionHelper from './softwareProduct/networks/SoftwareProductNetworksActionHelper.js';
  25 import SoftwareProductComponentsActionHelper from './softwareProduct/components/SoftwareProductComponentsActionHelper.js';
  26 import SoftwareProductComponentProcessesActionHelper from './softwareProduct/components/processes/SoftwareProductComponentProcessesActionHelper.js';
  27 import SoftwareProductComponentsNetworkActionHelper from './softwareProduct/components/network/SoftwareProductComponentsNetworkActionHelper.js';
  28 import SoftwareProductDependenciesActionHelper from './softwareProduct/dependencies/SoftwareProductDependenciesActionHelper.js';
  29 import ComputeFlavorActionHelper from './softwareProduct/components/compute/ComputeFlavorActionHelper.js';
  30 import OnboardActionHelper from './onboard/OnboardActionHelper.js';
  31 import SoftwareProductComponentsMonitoringAction from './softwareProduct/components/monitoring/SoftwareProductComponentsMonitoringActionHelper.js';
  32 import {actionTypes, enums} from './OnboardingConstants.js';
  33 import SoftwareProductComponentsImageActionHelper from './softwareProduct/components/images/SoftwareProductComponentsImageActionHelper.js';
  34 import {navigationItems as SoftwareProductNavigationItems, actionTypes as SoftwareProductActionTypes, onboardingOriginTypes} from 'sdc-app/onboarding/softwareProduct/SoftwareProductConstants.js';
  35 import ActivityLogActionHelper from 'sdc-app/common/activity-log/ActivityLogActionHelper.js';
  36 import licenseModelOverviewActionHelper from 'sdc-app/onboarding/licenseModel/overview/licenseModelOverviewActionHelper.js';
  37 import store from 'sdc-app/AppStore.js';
  38 import {selectedButton as licenseModelOverviewSelectedButton} from 'sdc-app/onboarding/licenseModel/overview/LicenseModelOverviewConstants.js';
  39 import {tabsMapping as attachmentsTabsMapping} from 'sdc-app/onboarding/softwareProduct/attachments/SoftwareProductAttachmentsConstants.js';
  40 import SoftwareProductAttachmentsActionHelper from 'sdc-app/onboarding/softwareProduct/attachments/SoftwareProductAttachmentsActionHelper.js';
  41
  42 function setCurrentScreen(dispatch, screen, props = {}) {
  43         dispatch({
  44                 type: actionTypes.SET_CURRENT_SCREEN,
  45                 currentScreen: {
  46                         screen,
  47                         props,
  48                         forceBreadCrumbsUpdate: true
  49                 }
  50         });
  51 }
  52
  53 function  getCurrentLicenseModelVersion(licenseModelId) {
  54         return store.getState().licenseModelList.find(({id}) => id === licenseModelId).version;
  55 }
  56
  57 function getCurrentSoftwareProductVersion(softwareProductId) {
  58         return store.getState().softwareProductList.find(({id}) => id === softwareProductId).version;
  59 }
  60
  61 export default {
  62
  63         navigateToOnboardingCatalog(dispatch) {
  64                 LicenseModelActionHelper.fetchLicenseModels(dispatch);
  65                 LicenseModelActionHelper.fetchFinalizedLicenseModels(dispatch);
  66                 SoftwareProductActionHelper.fetchSoftwareProductList(dispatch);
  67                 SoftwareProductActionHelper.fetchFinalizedSoftwareProductList(dispatch);
  68                 OnboardActionHelper.resetOnboardStore(dispatch);
  69                 setCurrentScreen(dispatch, enums.SCREEN.ONBOARDING_CATALOG);
  70         },
  71
  72         autoSaveBeforeNavigate(dispatch, {softwareProductId, version, vspComponentId, dataToSave}) {
  73                 if(softwareProductId) {
  74                         if(vspComponentId) {
  75                                 return SoftwareProductComponentsActionHelper.updateSoftwareProductComponent(dispatch, {
  76                                         softwareProductId, version, vspComponentId,
  77                                         componentData: dataToSave.componentData,
  78                                         qdata: dataToSave.qdata
  79                                 });
  80                         }
  81                         return SoftwareProductActionHelper.updateSoftwareProduct(dispatch, {
  82                                 softwareProduct: dataToSave.softwareProduct,
  83                                 qdata: dataToSave.qdata
  84                         });
  85                 }
  86                 return Promise.resolve();
  87         },
  88
  89         navigateToLicenseModelOverview(dispatch, {licenseModelId, version}) {
  90                 if (!version) {
  91                         version = getCurrentLicenseModelVersion(licenseModelId);
  92                 }
  93
  94                 /**
  95                  * TODO change to specific rest
  96                  */
  97
  98                 LicenseModelActionHelper.fetchLicenseModelById(dispatch, {licenseModelId, version}).then(() => {
  99                         LicenseModelActionHelper.fetchLicenseModelItems(dispatch, {licenseModelId, version}).then(() =>{
 100                                 setCurrentScreen(dispatch, enums.SCREEN.LICENSE_MODEL_OVERVIEW, {licenseModelId, version});
 101                         });
 102                         licenseModelOverviewActionHelper.selectVLMListView(dispatch, {buttonTab: licenseModelOverviewSelectedButton.VLM_LIST_VIEW});
 103                 });
 104         },
 105         navigateToLicenseAgreements(dispatch, {licenseModelId, version}) {
 106                 if(!version) {
 107                         version = getCurrentLicenseModelVersion(licenseModelId);
 108                 }
 109                 LicenseAgreementActionHelper.fetchLicenseAgreementList(dispatch, {licenseModelId, version});
 110                 LicenseModelActionHelper.fetchLicenseModelById(dispatch, {licenseModelId, version}).then(() => {
 111                         setCurrentScreen(dispatch, enums.SCREEN.LICENSE_AGREEMENTS, {licenseModelId, version});
 112                 });
 113         },
 114
 115         navigateToFeatureGroups(dispatch, {licenseModelId, version}) {
 116                 if(!version) {
 117                         version = getCurrentLicenseModelVersion(licenseModelId);
 118                 }
 119                 FeatureGroupsActionHelper.fetchFeatureGroupsList(dispatch, {licenseModelId, version});
 120                 setCurrentScreen(dispatch, enums.SCREEN.FEATURE_GROUPS, {licenseModelId, version});
 121         },
 122
 123         navigateToEntitlementPools(dispatch, {licenseModelId, version}) {
 124                 if(!version) {
 125                         version = getCurrentLicenseModelVersion(licenseModelId);
 126                 }
 127                 EntitlementPoolsActionHelper.fetchEntitlementPoolsList(dispatch, {licenseModelId, version});
 128                 setCurrentScreen(dispatch, enums.SCREEN.ENTITLEMENT_POOLS, {licenseModelId, version});
 129         },
 130
 131         navigateToLicenseKeyGroups(dispatch, {licenseModelId, version}) {
 132                 if(!version) {
 133                         version = getCurrentLicenseModelVersion(licenseModelId);
 134                 }
 135                 LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(dispatch, {licenseModelId, version});
 136                 setCurrentScreen(dispatch, enums.SCREEN.LICENSE_KEY_GROUPS, {licenseModelId, version});
 137         },
 138
 139         navigateToLicenseModelActivityLog(dispatch, {licenseModelId, version}){
 140                 if(!version) {
 141                         version = getCurrentLicenseModelVersion(licenseModelId);
 142                 }
 143                 ActivityLogActionHelper.fetchActivityLog(dispatch, {itemId: licenseModelId, versionId: version.id});
 144                 setCurrentScreen(dispatch, enums.SCREEN.ACTIVITY_LOG, {licenseModelId, version});
 145         },
 146
 147         navigateToSoftwareProductLandingPage(dispatch, {softwareProductId, licenseModelId, version, licensingVersion}) {
 148
 149                 if (!version) {
 150                         version = getCurrentSoftwareProductVersion(softwareProductId);
 151                 }
 152
 153                 SoftwareProductComponentsActionHelper.clearComponentsStore(dispatch);
 154                 SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {softwareProductId, version}).then(response => {
 155                         if(!licensingVersion) {
 156                                 licensingVersion = response[0].licensingVersion;
 157                                 if (!licensingVersion) {
 158                                         licensingVersion = {id: '1.0', label: '1.0'};
 159                                 }
 160                         }
 161                         if (!licenseModelId) {
 162                                 licenseModelId = response[0].vendorId;
 163                         }
 164
 165                         const newVersion = response[0].version ? response[0].version : version;
 166
 167                         SoftwareProductActionHelper.loadSoftwareProductDetailsData(dispatch, {licenseModelId, licensingVersion});
 168
 169                         SoftwareProductComponentsActionHelper.fetchSoftwareProductComponents(dispatch, {softwareProductId, version: newVersion});
 170                         if(response[0].onboardingOrigin === onboardingOriginTypes.ZIP) {
 171                                 SoftwareProductActionHelper.loadSoftwareProductHeatCandidate(dispatch, {softwareProductId, version: newVersion});
 172                         }
 173                         setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE, {softwareProductId, licenseModelId, version: newVersion});
 174                 });
 175         },
 176
 177         navigateToSoftwareProductDetails(dispatch, {softwareProductId, version}) {
 178                 SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {softwareProductId, version});
 179                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_DETAILS, {softwareProductId, version});
 180         },
 181
 182         navigateToSoftwareProductAttachmentsSetupTab(dispatch, {softwareProductId, version}) {
 183                 SoftwareProductActionHelper.loadSoftwareProductHeatCandidate(dispatch, {softwareProductId, version});
 184                 SoftwareProductAttachmentsActionHelper.setActiveTab(dispatch, {activeTab: attachmentsTabsMapping.SETUP});
 185                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS, {softwareProductId, version});
 186         },
 187
 188         navigateToSoftwareProductAttachmentsValidationTab(dispatch, {softwareProductId, version}) {
 189                 SoftwareProductActionHelper.processAndValidateHeatCandidate(dispatch, {softwareProductId, version}).then(() => {
 190                         SoftwareProductAttachmentsActionHelper.setActiveTab(dispatch, {activeTab: attachmentsTabsMapping.VALIDATION});
 191                         setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS, {softwareProductId, version});
 192                 });
 193         },
 194
 195         navigateToSoftwareProductProcesses(dispatch, {softwareProductId, version}) {
 196                 if (softwareProductId) {
 197                         SoftwareProductProcessesActionHelper.fetchProcessesList(dispatch, {softwareProductId, version});
 198                 }
 199                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_PROCESSES, {softwareProductId, version});
 200         },
 201
 202         navigateToSoftwareProductNetworks(dispatch, {softwareProductId, version}) {
 203                 if (softwareProductId) {
 204                         SoftwareProductNetworksActionHelper.fetchNetworksList(dispatch, {softwareProductId, version});
 205                 }
 206                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_NETWORKS, {softwareProductId, version});
 207         },
 208
 209         navigateToSoftwareProductDependencies(dispatch, {softwareProductId, version}) {
 210                 SoftwareProductDependenciesActionHelper.fetchDependencies(dispatch, {softwareProductId, version});
 211                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_DEPENDENCIES, {softwareProductId, version});
 212         },
 213
 214         navigateToSoftwareProductComponents(dispatch, {softwareProductId, version}) {
 215                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponents(dispatch, {softwareProductId, version});
 216                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS, {softwareProductId, version});
 217         },
 218         navigateToSoftwareProductDeployment(dispatch, {softwareProductId, version}) {
 219                 SoftwareProductDeploymentActionHelper.fetchDeploymentFlavorsList(dispatch, {softwareProductId, version});
 220                 ComputeFlavorActionHelper.fetchComputesListForVSP(dispatch, {softwareProductId, version});
 221                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_DEPLOYMENT, {softwareProductId, version});
 222         },
 223         navigateToSoftwareProductActivityLog(dispatch, {softwareProductId, version}){
 224                 ActivityLogActionHelper.fetchActivityLog(dispatch, {itemId: softwareProductId, versionId: version.id});
 225                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_ACTIVITY_LOG, {softwareProductId, version});
 226         },
 227
 228         navigateToSoftwareProductComponentProcesses(dispatch, {softwareProductId, componentId, version}) {
 229                 if (componentId && softwareProductId) {
 230                         SoftwareProductComponentProcessesActionHelper.fetchProcessesList(dispatch, {componentId, softwareProductId, version});
 231                 }
 232                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_PROCESSES, {softwareProductId, componentId, version});
 233         },
 234
 235         navigateToSoftwareProductComponentMonitoring(dispatch, {softwareProductId, version, componentId}){
 236                 if (componentId && softwareProductId && version) {
 237                         SoftwareProductComponentsMonitoringAction.fetchExistingFiles(dispatch, {componentId, softwareProductId, version});
 238                 }
 239                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_MONITORING, {softwareProductId, componentId, version});
 240         },
 241
 242         navigateToComponentStorage(dispatch, {softwareProductId, componentId, version}) {
 243                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 244                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_STORAGE, {softwareProductId, version, componentId});
 245         },
 246
 247         navigateToComponentCompute(dispatch, {softwareProductId, componentId, version}) {
 248                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 249                 if (componentId && softwareProductId) {
 250                         ComputeFlavorActionHelper.fetchComputesList(dispatch, {softwareProductId, componentId, version});
 251                 }
 252                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_COMPUTE, {softwareProductId, version, componentId});
 253         },
 254
 255         navigateToComponentNetwork(dispatch, {softwareProductId, componentId, version}) {
 256                 SoftwareProductComponentsNetworkActionHelper.fetchNICsList(dispatch, {softwareProductId, componentId, version});
 257                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_NETWORK, {softwareProductId, version, componentId});
 258         },
 259
 260         navigateToSoftwareProductComponentGeneral(dispatch, {softwareProductId, componentId, version}) {
 261                 if (componentId && softwareProductId) {
 262                         SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 263                 }
 264                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_GENERAL, {softwareProductId, version, componentId});
 265         },
 266
 267         navigateToSoftwareProductComponentGeneralAndUpdateLeftPanel(dispatch, {softwareProductId, componentId, version}) {
 268                 this.navigateToSoftwareProductComponentGeneral(dispatch, {softwareProductId, componentId, version});
 269                 dispatch({
 270                         type: SoftwareProductActionTypes.TOGGLE_NAVIGATION_ITEM,
 271                         mapOfExpandedIds: {
 272                                 [SoftwareProductNavigationItems.COMPONENTS]: true,
 273                                 [SoftwareProductNavigationItems.COMPONENTS + '|' + componentId]: true
 274                         }
 275                 });
 276         },
 277
 278         navigateToComponentLoadBalancing(dispatch, {softwareProductId, componentId, version}) {
 279                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 280                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_LOAD_BALANCING, {softwareProductId, version, componentId});
 281         },
 282
 283         navigateToComponentImages(dispatch, {softwareProductId, componentId, version}) {
 284                 SoftwareProductComponentsImageActionHelper.fetchImagesList(dispatch, {
 285                         softwareProductId,
 286                         componentId,
 287                         version
 288                 });
 289                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_IMAGES, {softwareProductId, version, componentId});
 290         },
 291
 292         updateCurrentScreenVersion(dispatch, version) {
 293                 dispatch({
 294                         type: actionTypes.SET_CURRENT_SCREEN_VERSION,
 295                         version
 296                 });
 297         }
 298
 299 };