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 UsersActionHelper from './users/UsersActionHelper.js';
  17 import VersionsPageActionHelper from './versionsPage/VersionsPageActionHelper.js';
  18 import PermissionsActionHelper from './permissions/PermissionsActionHelper.js';
  19 import LicenseModelActionHelper from './licenseModel/LicenseModelActionHelper.js';
  20 import LicenseAgreementActionHelper from './licenseModel/licenseAgreement/LicenseAgreementActionHelper.js';
  21 import FeatureGroupsActionHelper from './licenseModel/featureGroups/FeatureGroupsActionHelper.js';
  22 import LicenseKeyGroupsActionHelper from './licenseModel/licenseKeyGroups/LicenseKeyGroupsActionHelper.js';
  23 import EntitlementPoolsActionHelper from './licenseModel/entitlementPools/EntitlementPoolsActionHelper.js';
  24 import SoftwareProductActionHelper from './softwareProduct/SoftwareProductActionHelper.js';
  25 import SoftwareProductProcessesActionHelper from './softwareProduct/processes/SoftwareProductProcessesActionHelper.js';
  26 import SoftwareProductDeploymentActionHelper from './softwareProduct/deployment/SoftwareProductDeploymentActionHelper.js';
  27 import SoftwareProductNetworksActionHelper from './softwareProduct/networks/SoftwareProductNetworksActionHelper.js';
  28 import SoftwareProductComponentsActionHelper from './softwareProduct/components/SoftwareProductComponentsActionHelper.js';
  29 import SoftwareProductComponentProcessesActionHelper from './softwareProduct/components/processes/SoftwareProductComponentProcessesActionHelper.js';
  30 import SoftwareProductComponentsNetworkActionHelper from './softwareProduct/components/network/SoftwareProductComponentsNetworkActionHelper.js';
  31 import SoftwareProductDependenciesActionHelper from './softwareProduct/dependencies/SoftwareProductDependenciesActionHelper.js';
  32 import ComputeFlavorActionHelper from './softwareProduct/components/compute/ComputeFlavorActionHelper.js';
  33 import OnboardActionHelper from './onboard/OnboardActionHelper.js';
  34 import MergeEditorActionHelper from 'sdc-app/common/merge/MergeEditorActionHelper.js';
  35 // import {SyncStates} from 'sdc-app/common/merge/MergeEditorConstants.js';
  36 import SoftwareProductComponentsMonitoringAction from './softwareProduct/components/monitoring/SoftwareProductComponentsMonitoringActionHelper.js';
  37 import {actionTypes, enums} from './OnboardingConstants.js';
  38 import {actionTypes as SoftwareProductActionTypes, onboardingOriginTypes} from 'sdc-app/onboarding/softwareProduct/SoftwareProductConstants.js';
  39 import ActivityLogActionHelper from 'sdc-app/common/activity-log/ActivityLogActionHelper.js';
  40 import ItemsHelper from 'sdc-app/common/helpers/ItemsHelper.js';
  41 import SoftwareProductComponentsImageActionHelper from './softwareProduct/components/images/SoftwareProductComponentsImageActionHelper.js';
  42 import licenseModelOverviewActionHelper from 'sdc-app/onboarding/licenseModel/overview/licenseModelOverviewActionHelper.js';
  43 import {tabsMapping as attachmentsTabsMapping} from 'sdc-app/onboarding/softwareProduct/attachments/SoftwareProductAttachmentsConstants.js';
  44 import SoftwareProductAttachmentsActionHelper from 'sdc-app/onboarding/softwareProduct/attachments/SoftwareProductAttachmentsActionHelper.js';
  45
  46 function setCurrentScreen(dispatch, screen, props = {}) {
  47         dispatch({
  48                 type: actionTypes.SET_CURRENT_SCREEN,
  49                 currentScreen: {
  50                         screen,
  51                         props,
  52                         forceBreadCrumbsUpdate: true
  53                 }
  54         });
  55 }
  56
  57 export function updateCurrentScreenProps(dispatch, props = {}) {
  58         dispatch({
  59                 type: actionTypes.UPDATE_CURRENT_SCREEN_PROPS,
  60                 props
  61         });
  62 }
  63
  64 const OnboardingActionHelper = {
  65
  66         loadItemsLists(dispatch) {
  67                 LicenseModelActionHelper.fetchLicenseModels(dispatch);
  68                 LicenseModelActionHelper.fetchFinalizedLicenseModels(dispatch);
  69                 SoftwareProductActionHelper.fetchSoftwareProductList(dispatch);
  70                 SoftwareProductActionHelper.fetchFinalizedSoftwareProductList(dispatch);
  71         },
  72
  73         navigateToOnboardingCatalog(dispatch) {
  74                 UsersActionHelper.fetchUsersList(dispatch);
  75                 this.loadItemsLists(dispatch);
  76                 OnboardActionHelper.resetOnboardStore(dispatch);
  77                 setCurrentScreen(dispatch, enums.SCREEN.ONBOARDING_CATALOG);
  78         },
  79
  80         autoSaveBeforeNavigate(dispatch, {softwareProductId, version, vspComponentId, dataToSave}) {
  81                 if(softwareProductId) {
  82                         if(vspComponentId) {
  83                                 return SoftwareProductComponentsActionHelper.updateSoftwareProductComponent(dispatch, {
  84                                         softwareProductId, version, vspComponentId,
  85                                         componentData: dataToSave.componentData,
  86                                         qdata: dataToSave.qdata
  87                                 });
  88                         }
  89                         return SoftwareProductActionHelper.updateSoftwareProduct(dispatch, {
  90                                 softwareProduct: dataToSave.softwareProduct,
  91                                 version,
  92                                 qdata: dataToSave.qdata
  93                         });
  94                 }
  95                 return Promise.resolve();
  96         },
  97
  98         navigateToLicenseModelOverview(dispatch, {licenseModelId, version}) {
  99
 100                 /**
 101                  * TODO change to specific rest
 102                  */
 103
 104                 LicenseModelActionHelper.fetchLicenseModelById(dispatch, {licenseModelId, version}).then(() => {
 105                         LicenseModelActionHelper.fetchLicenseModelItems(dispatch, {licenseModelId, version}).then(() => {
 106                                 setCurrentScreen(dispatch, enums.SCREEN.LICENSE_MODEL_OVERVIEW, {licenseModelId, version});
 107                         });
 108                         licenseModelOverviewActionHelper.selectVLMListView(dispatch, {buttonTab: null});
 109                 });
 110         },
 111         navigateToLicenseAgreements(dispatch, {licenseModelId, version}) {
 112                 LicenseAgreementActionHelper.fetchLicenseAgreementList(dispatch, {licenseModelId, version});
 113                 LicenseModelActionHelper.fetchLicenseModelById(dispatch, {licenseModelId, version}).then(() => {
 114                         setCurrentScreen(dispatch, enums.SCREEN.LICENSE_AGREEMENTS, {licenseModelId, version});
 115                 });
 116         },
 117
 118         navigateToFeatureGroups(dispatch, {licenseModelId, version}) {
 119                 FeatureGroupsActionHelper.fetchFeatureGroupsList(dispatch, {licenseModelId, version});
 120                 setCurrentScreen(dispatch, enums.SCREEN.FEATURE_GROUPS, {licenseModelId, version});
 121         },
 122
 123         navigateToEntitlementPools(dispatch, {licenseModelId, version}) {
 124                 EntitlementPoolsActionHelper.fetchEntitlementPoolsList(dispatch, {licenseModelId, version});
 125                 setCurrentScreen(dispatch, enums.SCREEN.ENTITLEMENT_POOLS, {licenseModelId, version});
 126         },
 127
 128         navigateToLicenseKeyGroups(dispatch, {licenseModelId, version}) {
 129                 LicenseKeyGroupsActionHelper.fetchLicenseKeyGroupsList(dispatch, {licenseModelId, version});
 130                 setCurrentScreen(dispatch, enums.SCREEN.LICENSE_KEY_GROUPS, {licenseModelId, version});
 131         },
 132
 133         navigateToLicenseModelActivityLog(dispatch, {licenseModelId, version}){
 134                 ActivityLogActionHelper.fetchActivityLog(dispatch, {itemId: licenseModelId, versionId: version.id});
 135                 setCurrentScreen(dispatch, enums.SCREEN.ACTIVITY_LOG, {licenseModelId, version});
 136         },
 137
 138         navigateToSoftwareProductLandingPage(dispatch, {softwareProductId, version}) {
 139                 SoftwareProductComponentsActionHelper.clearComponentsStore(dispatch);
 140                 SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {softwareProductId, version}).then(response => {
 141                         let {vendorId: licenseModelId, licensingVersion} = response[0];
 142                         SoftwareProductActionHelper.loadSoftwareProductDetailsData(dispatch, {licenseModelId, licensingVersion});
 143                         SoftwareProductComponentsActionHelper.fetchSoftwareProductComponents(dispatch, {softwareProductId, version: version});
 144                         if(response[0].onboardingOrigin === onboardingOriginTypes.ZIP) {
 145                                 SoftwareProductActionHelper.loadSoftwareProductHeatCandidate(dispatch, {softwareProductId, version: version});
 146                         }
 147                         setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE, {softwareProductId, licenseModelId, version});
 148                 });
 149         },
 150
 151         navigateToSoftwareProductDetails(dispatch, {softwareProductId, version}) {
 152                 SoftwareProductActionHelper.fetchSoftwareProduct(dispatch, {softwareProductId, version}).then(response => {
 153                         let {vendorId: licenseModelId, licensingVersion} = response[0];
 154                         SoftwareProductActionHelper.loadLicensingVersionsList(dispatch, {licenseModelId});
 155                         SoftwareProductActionHelper.loadSoftwareProductDetailsData(dispatch, {licenseModelId, licensingVersion});
 156                         setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_DETAILS, {softwareProductId, version});
 157                 });
 158         },
 159
 160         navigateToSoftwareProductAttachmentsSetupTab(dispatch, {softwareProductId, version}) {
 161                 SoftwareProductActionHelper.loadSoftwareProductHeatCandidate(dispatch, {softwareProductId, version});
 162                 SoftwareProductAttachmentsActionHelper.setActiveTab(dispatch, {activeTab: attachmentsTabsMapping.SETUP});
 163                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS, {softwareProductId, version});
 164         },
 165         navigateToSoftwareProductAttachmentsValidationTab(dispatch, {softwareProductId, version}) {
 166                 SoftwareProductActionHelper.processAndValidateHeatCandidate(dispatch, {softwareProductId, version}).then(() => {
 167                         SoftwareProductAttachmentsActionHelper.setActiveTab(dispatch, {activeTab: attachmentsTabsMapping.VALIDATION});
 168                         setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS, {softwareProductId, version});
 169                 });
 170         },
 171
 172         navigateToSoftwareProductProcesses(dispatch, {softwareProductId, version}) {
 173                 if (softwareProductId) {
 174                         SoftwareProductProcessesActionHelper.fetchProcessesList(dispatch, {softwareProductId, version});
 175                 }
 176                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_PROCESSES, {softwareProductId, version});
 177         },
 178
 179         navigateToSoftwareProductNetworks(dispatch, {softwareProductId, version}) {
 180                 if (softwareProductId) {
 181                         SoftwareProductNetworksActionHelper.fetchNetworksList(dispatch, {softwareProductId, version});
 182                 }
 183                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_NETWORKS, {softwareProductId, version});
 184         },
 185
 186         navigateToSoftwareProductDependencies(dispatch, {softwareProductId, version}) {
 187                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponents(dispatch, {softwareProductId, version}).then(result => {
 188                         if(result.listCount >= 2) {
 189                                 SoftwareProductDependenciesActionHelper.fetchDependencies(dispatch, {softwareProductId, version});
 190                                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_DEPENDENCIES, {softwareProductId, version});
 191                         }
 192                         else {
 193                                 this.navigateToSoftwareProductLandingPage(dispatch, {softwareProductId, version});
 194                         }
 195                 });
 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         navigateToSoftwareProductDeployment(dispatch, {softwareProductId, version}) {
 203                 SoftwareProductDeploymentActionHelper.fetchDeploymentFlavorsList(dispatch, {softwareProductId, version});
 204                 ComputeFlavorActionHelper.fetchComputesListForVSP(dispatch, {softwareProductId, version});
 205                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_DEPLOYMENT, {softwareProductId, version});
 206         },
 207         navigateToSoftwareProductActivityLog(dispatch, {softwareProductId, version}){
 208                 ActivityLogActionHelper.fetchActivityLog(dispatch, {itemId: softwareProductId, versionId: version.id});
 209                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_ACTIVITY_LOG, {softwareProductId, version});
 210         },
 211
 212         navigateToSoftwareProductComponentProcesses(dispatch, {softwareProductId, componentId, version}) {
 213                 if (componentId && softwareProductId) {
 214                         SoftwareProductComponentProcessesActionHelper.fetchProcessesList(dispatch, {componentId, softwareProductId, version});
 215                 }
 216                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_PROCESSES, {softwareProductId, componentId, version});
 217         },
 218
 219         navigateToSoftwareProductComponentMonitoring(dispatch, {softwareProductId, version, componentId}){
 220                 if (componentId && softwareProductId && version) {
 221                         SoftwareProductComponentsMonitoringAction.fetchExistingFiles(dispatch, {componentId, softwareProductId, version});
 222                 }
 223                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_MONITORING, {softwareProductId, componentId, version});
 224         },
 225
 226         navigateToComponentStorage(dispatch, {softwareProductId, componentId, version}) {
 227                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 228                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_STORAGE, {softwareProductId, version, componentId});
 229         },
 230
 231         navigateToComponentCompute(dispatch, {softwareProductId, componentId, version}) {
 232                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 233                 if (componentId && softwareProductId) {
 234                         ComputeFlavorActionHelper.fetchComputesList(dispatch, {softwareProductId, componentId, version});
 235                 }
 236                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_COMPUTE, {softwareProductId, version, componentId});
 237         },
 238
 239         navigateToComponentNetwork(dispatch, {softwareProductId, componentId, version}) {
 240                 SoftwareProductComponentsNetworkActionHelper.fetchNICsList(dispatch, {softwareProductId, componentId, version});
 241                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_NETWORK, {softwareProductId, version, componentId});
 242         },
 243
 244         navigateToSoftwareProductComponentGeneral(dispatch, {softwareProductId, componentId, version}) {
 245                 if (componentId && softwareProductId) {
 246                         SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 247                 }
 248                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_GENERAL, {softwareProductId, version, componentId});
 249         },
 250
 251         navigateToSoftwareProductComponentGeneralAndUpdateLeftPanel(dispatch, {softwareProductId, componentId, version}) {
 252                 this.navigateToSoftwareProductComponentGeneral(dispatch, {softwareProductId, componentId, version});
 253                 dispatch({
 254                         type: SoftwareProductActionTypes.TOGGLE_NAVIGATION_ITEM,
 255                         mapOfExpandedIds: {
 256                                 [enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS]: true,
 257                                 [enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS + '|' + componentId]: true
 258                         }
 259                 });
 260         },
 261
 262         navigateToComponentLoadBalancing(dispatch, {softwareProductId, componentId, version}) {
 263                 SoftwareProductComponentsActionHelper.fetchSoftwareProductComponent(dispatch, {softwareProductId, vspComponentId: componentId, version});
 264                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_LOAD_BALANCING, {softwareProductId, version, componentId});
 265         },
 266
 267         navigateToComponentImages(dispatch, {softwareProductId, componentId, version}) {
 268                 SoftwareProductComponentsImageActionHelper.fetchImagesList(dispatch, {
 269                         softwareProductId,
 270                         componentId,
 271                         version
 272                 });
 273                 setCurrentScreen(dispatch, enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_IMAGES, {softwareProductId, version, componentId});
 274         },
 275
 276         navigateToVersionsPage(dispatch, {itemType, itemId, itemName, additionalProps, users}) {
 277                 PermissionsActionHelper.fetchItemUsers(dispatch, {itemId, allUsers: users});
 278                 VersionsPageActionHelper.selectNone(dispatch);
 279                 VersionsPageActionHelper.fetchVersions(dispatch, {itemType, itemId}).then(() => {
 280                         setCurrentScreen(dispatch, enums.SCREEN.VERSIONS_PAGE, {itemType, itemId, itemName, additionalProps});
 281                 });
 282         },
 283
 284         checkMergeStatus(dispatch, {itemId, versionId, version}) {
 285                 return ItemsHelper.fetchVersion({itemId, versionId}).then(response => {
 286                         let state = response && response.state || {};
 287                         let {synchronizationState} = state;
 288                         // let inMerge = synchronizationState === SyncStates.MERGE;
 289                         MergeEditorActionHelper.fetchConflicts(dispatch, {itemId, version}).then(data => {
 290                                 dispatch({
 291                                         type: actionTypes.CHECK_MERGE_STATUS,
 292                                         synchronizationState,
 293                                         conflictInfoList: data.conflictInfoList
 294                                 });
 295                         });
 296                 });
 297         },
 298
 299         forceBreadCrumbsUpdate(dispatch) {
 300                 dispatch({
 301                         type: actionTypes.SET_CURRENT_SCREEN,
 302                         currentScreen: {
 303                                 forceBreadCrumbsUpdate: true
 304                         }
 305                 });
 306         },
 307
 308         updateCurrentScreenVersion(dispatch, version) {
 309                 dispatch({
 310                         type: actionTypes.SET_CURRENT_SCREEN_VERSION,
 311                         version
 312                 });
 313         }
 314 };
 315
 316 export default OnboardingActionHelper;