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 SoftwareProductNetworksActionHelper from './softwareProduct/networks/SoftwareProductNetworksActionHelper.js';
  24 import SoftwareProductComponentsActionHelper from './softwareProduct/components/SoftwareProductComponentsActionHelper.js';
  25 import SoftwareProductComponentProcessesActionHelper from './softwareProduct/components/processes/SoftwareProductComponentProcessesActionHelper.js';
  26 import SoftwareProductComponentsNetworkActionHelper from './softwareProduct/components/network/SoftwareProductComponentsNetworkActionHelper.js';
  27 import SoftwareProductDependenciesActionHelper from './softwareProduct/dependencies/SoftwareProductDependenciesActionHelper.js';
  28 import OnboardActionHelper from './onboard/OnboardActionHelper.js';
  29 import SoftwareProductComponentsMonitoringAction from './softwareProduct/components/monitoring/SoftwareProductComponentsMonitoringActionHelper.js';
  30 import {actionTypes, enums} from './OnboardingConstants.js';
  31 import {navigationItems as SoftwareProductNavigationItems, actionTypes as SoftwareProductActionTypes} from 'sdc-app/onboarding/softwareProduct/SoftwareProductConstants.js';
  32 import ActivityLogActionHelper from 'nfvo-components/activity-log/ActivityLogActionHelper.js';
  33 import licenseModelOverviewActionHelper from 'sdc-app/onboarding/licenseModel/overview/licenseModelOverviewActionHelper.js';
  34 import store from 'sdc-app/AppStore.js';
  35 import {selectedButton as licenseModelOverviewSelectedButton} from 'sdc-app/onboarding/licenseModel/overview/LicenseModelOverviewConstants.js';
  36
  37 function setCurrentScreen(dispatch, screen, props = {}) {
  38         dispatch({
  39                 type: actionTypes.SET_CURRENT_SCREEN,
  40                 currentScreen: {
  41                         screen,
  42                         props,
  43                         forceBreadCrumbsUpdate: true
  44                 }
  45         });
  46 }
  47
  48 function  getCurrentLicenseModelVersion(licenseModelId) {
  49         return store.getState().licenseModelList.find(({id}) => id === licenseModelId).version;
  50 }
  51
  52 function getCurrentSoftwareProductVersion(softwareProductId) {
  53         return store.getState().softwareProductList.find(({id}) => id === softwareProductId).version;
  54 }
  55
  56 export default {
  57
  58         navigateToOnboardingCatalog(dispatch) {
  59                 LicenseModelActionHelper.fetchLicenseModels(dispatch);
  60                 LicenseModelActionHelper.fetchFinalizedLicenseModels(dispatch);
  61                 SoftwareProductActionHelper.fetchSoftwareProductList(dispatch);
  62                 SoftwareProductActionHelper.fetchFinalizedSoftwareProductList(dispatch);
  63                 OnboardActionHelper.resetOnboardStore(dispatch);
  64                 setCurrentScreen(dispatch, enums.SCREEN.ONBOARDING_CATALOG);
  65         },
  66
  67         autoSaveBeforeNavigate(dispatch, {softwareProductId, version, vspComponentId, dataToSave}) {
  68                 if(softwareProductId) {
  69                         if(vspComponentId) {
  70                                 return SoftwareProductComponentsActionHelper.updateSoftwareProductComponent(dispatch, {
  71                                         softwareProductId, version, vspComponentId,
  72                                         componentData: dataToSave.componentData,
  73                                         qdata: dataToSave.qdata
  74                                 });
  75                         }
  76                         return SoftwareProductActionHelper.updateSoftwareProduct(dispatch, {
  77                                 softwareProduct: dataToSave.softwareProduct,
  78                                 qdata: dataToSave.qdata
  79                         });
  80                 }
  81                 return Promise.resolve();
  82         },
  83
  84         navigateToLicenseModelOverview(dispatch, {licenseModelId, version}) {
  85                 if (!version) {
  86                         version = getCurrentLicenseModelVersion(licenseModelId);
  87                 }
  88
  89                 /**
  90                  * TODO change to specific rest
  91                  */
  92
  93                 LicenseModelActionHelper.fetchLicenseModelById(dispatch, {licenseModelId, version}).then(() => {
  94                         LicenseModelActionHelper.fetchLicenseModelItems(dispatch, {licenseModelId, version}).then(() =>{
  95                                 setCurrentScreen(dispatch, enums.SCREEN.LICENSE_MODEL_OVERVIEW, {licenseModelId, version});
  96                         });
  97                         licenseModelOverviewActionHelper.selectVLMListView(dispatch, {buttonTab: licenseModelOverviewSelectedButton.VLM_LIST_VIEW});
  98                 });
  99         },
 100         navigateToLicenseAgreements(dispatch, {licenseModelId, version}) {
 101                 if(!version) {
 102                         version = getCurrentLicenseModelVersion(licenseModelId);
 103                 }
 104                 LicenseAgreementActionHelper.fetchLicenseAgreementList(dispatch, {licenseModelId, version});
 105                 LicenseModelActionHelper.fetchLicenseModelById(dispatch, {licenseModelId, version}).then(() => {
 106                         setCurrentScreen(dispatch, enums.SCREEN.LICENSE_AGREEMENTS, {licenseModelId, version});
 107                 });
 108         },
 109
 110         navigateToFeatureGroups(dispatch, {licenseModelId, version}) {
 111                 if(!version) {
 112                         version = getCurrentLicenseModelVersion(licenseModelId);
 113                 }
 114                 FeatureGroupsActionHelper.fetchFeatureGroupsList(dispatch, {licenseModelId, version});
 115                 setCurrentScreen(dispatch, enums.SCREEN.FEATURE_GROUPS, {licenseModelId, version});
 116         },
 117
 118         navigateToEntitlementPools(dispatch, {licenseModelId, version}) {
 119                 if(!version) {
 120                         version = getCurrentLicenseModelVersion(licenseModelId);
 121                 }
 122                 EntitlementPoolsActionHelper.fetchEntitlementPoolsList(dispatch, {licenseModelId, version});
 123                 setCurrentScreen(dispatch, enums.SCREEN.ENTITLEMENT_POOLS, {licenseModelId, version});
 124         },
 125
 126         navigateToLicenseKeyGroups(dispatch, {licenseModelId, version}) {
 127                 if(!version) {
 128                         version = getCurrentLicenseModelVersion(licenseModelId);
 129                 }
 130                 LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(dispatch, {licenseModelId, version});
 131                 setCurrentScreen(dispatch, enums.SCREEN.LICENSE_KEY_GROUPS, {licenseModelId, version});
 132         },
 133
 134         navigateToLicenseModelActivityLog(dispatch, {licenseModelId, version}){
 135                 if(!version) {
 136                         version = getCurrentLicenseModelVersion(licenseModelId);
 137                 }
 138                 ActivityLogActionHelper.fetchActivityLog(dispatch, {itemId: licenseModelId, versionId: version.id});
 139                 setCurrentScreen(dispatch, enums.SCREEN.ACTIVITY_LOG, {licenseModelId, version});
 140         },
 141
 142         navigateToSoftwareProductLandingPage(dispatch, {softwareProductId, licenseModelId, version, licensingVersion}) {
 143
 144                 if (!version) {
 145                         version = getCurrentSoftwareProductVersion(softwareProductId);
 146                 }
 147
 148                 SoftwareProductComponentsActionHelper.clearComponentsStore(dispatch);
 149                 SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {softwareProductId, version}).then(response => {
 150                         if(!licensingVersion) {
 151                                 licensingVersion = response[0].licensingVersion;
 152                                 if (!licensingVersion) {
 153                                         licensingVersion = {id: '1.0', label: '1.0'};
 154                                 }
 155                         }
 156                         if (!licenseModelId) {
 157                                 licenseModelId = response[0].vendorId;
 158                         }
 159
 160                         const newVersion = response[0].version ? response[0].version : version;
 161
 162                         SoftwareProductActionHelper.loadSoftwareProductDetailsData(dispatch, {licenseModelId, licensingVersion});
 163                         SoftwareProductComponentsActionHelper.fetchSoftwareProductComponents(dispatch, {softwareProductId, version: newVersion});
 164                         SoftwareProductActionHelper.loadSoftwareProductHeatCandidate(dispatch, {softwareProductId, version: newVersion});
 165                         setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE, {softwareProductId, licenseModelId, version: newVersion});
 166                 });
 167         },
 168
 169         navigateToSoftwareProductDetails(dispatch, {softwareProductId, version}) {
 170                 SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {softwareProductId, version});
 171                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_DETAILS, {softwareProductId, version});
 172         },
 173
 174         navigateToSoftwareProductAttachments(dispatch, {softwareProductId, version}) {
 175                 SoftwareProductActionHelper.loadSoftwareProductHeatCandidate(dispatch, {softwareProductId, version});
 176                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS, {softwareProductId, version});
 177         },
 178
 179         navigateToSoftwareProductProcesses(dispatch, {softwareProductId, version}) {
 180                 if (softwareProductId) {
 181                         SoftwareProductProcessesActionHelper.fetchProcessesList(dispatch, {softwareProductId, version});
 182                 }
 183                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_PROCESSES, {softwareProductId, version});
 184         },
 185
 186         navigateToSoftwareProductNetworks(dispatch, {softwareProductId, version}) {
 187                 if (softwareProductId) {
 188                         SoftwareProductNetworksActionHelper.fetchNetworksList(dispatch, {softwareProductId, version});
 189                 }
 190                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_NETWORKS, {softwareProductId, version});
 191         },
 192
 193         navigateToSoftwareProductDependencies(dispatch, {softwareProductId, version}) {
 194                 SoftwareProductDependenciesActionHelper.fetchDependencies(dispatch, {softwareProductId, version});
 195                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_DEPENDENCIES, {softwareProductId, version});
 196         },
 197
 198         navigateToSoftwareProductComponents(dispatch, {softwareProductId, version}) {
 199                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponents(dispatch, {softwareProductId, version});
 200                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS, {softwareProductId, version});
 201         },
 202
 203         navigateToSoftwareProductActivityLog(dispatch, {softwareProductId, version}){
 204                 ActivityLogActionHelper.fetchActivityLog(dispatch, {itemId: softwareProductId, versionId: version.id});
 205                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_ACTIVITY_LOG, {softwareProductId, version});
 206         },
 207
 208         navigateToSoftwareProductComponentProcesses(dispatch, {softwareProductId, componentId, version}) {
 209                 if (componentId && softwareProductId) {
 210                         SoftwareProductComponentProcessesActionHelper.fetchProcessesList(dispatch, {componentId, softwareProductId, version});
 211                 }
 212                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_PROCESSES, {softwareProductId, componentId, version});
 213         },
 214
 215         navigateToSoftwareProductComponentMonitoring(dispatch, {softwareProductId, version, componentId}){
 216                 if (componentId && softwareProductId && version) {
 217                         SoftwareProductComponentsMonitoringAction.fetchExistingFiles(dispatch, {componentId, softwareProductId, version});
 218                 }
 219                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_MONITORING, {softwareProductId, componentId, version});
 220         },
 221
 222         navigateToComponentStorage(dispatch, {softwareProductId, componentId, version}) {
 223                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 224                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_STORAGE, {softwareProductId, version, componentId});
 225         },
 226
 227         navigateToComponentCompute(dispatch, {softwareProductId, componentId, version}) {
 228                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 229                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_COMPUTE, {softwareProductId, version, componentId});
 230         },
 231
 232         navigateToComponentNetwork(dispatch, {softwareProductId, componentId, version}) {
 233                 SoftwareProductComponentsNetworkActionHelper.fetchNICsList(dispatch, {softwareProductId, componentId, version});
 234                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_NETWORK, {softwareProductId, version, componentId});
 235         },
 236
 237         navigateToSoftwareProductComponentGeneral(dispatch, {softwareProductId, componentId, version}) {
 238                 if (componentId && softwareProductId) {
 239                         SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 240                 }
 241                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_GENERAL, {softwareProductId, version, componentId});
 242         },
 243
 244         navigateToSoftwareProductComponentGeneralAndUpdateLeftPanel(dispatch, {softwareProductId, componentId, version}) {
 245                 this.navigateToSoftwareProductComponentGeneral(dispatch, {softwareProductId, componentId, version});
 246                 dispatch({
 247                         type: SoftwareProductActionTypes.TOGGLE_NAVIGATION_ITEM,
 248                         mapOfExpandedIds: {
 249                                 [SoftwareProductNavigationItems.COMPONENTS]: true,
 250                                 [SoftwareProductNavigationItems.COMPONENTS + '|' + componentId]: true
 251                         }
 252                 });
 253         },
 254
 255         navigateToComponentLoadBalancing(dispatch, {softwareProductId, componentId, version}) {
 256                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 257                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_LOAD_BALANCING, {softwareProductId, version, componentId});
 258         }
 259
 260 };