openecomp-ui/src/sdc-app/common/helpers/ScreensHelper.js

   1 import {itemTypes} from 'sdc-app/onboarding/versionsPage/VersionsPageConstants.js';
   2 import {enums, screenTypes} from 'sdc-app/onboarding/OnboardingConstants.js';
   3 import OnboardingActionHelper from 'sdc-app/onboarding/OnboardingActionHelper.js';
   4 import {actionTypes as SoftwareProductActionTypes} from 'sdc-app/onboarding/softwareProduct/SoftwareProductConstants.js';
   5 import ItemsHelper from 'sdc-app/common/helpers/ItemsHelper.js';
   6 import versionPageActionHelper from 'sdc-app/onboarding/versionsPage/VersionsPageActionHelper.js';
   7 import i18n from 'nfvo-utils/i18n/i18n.js';
   8 import {actionTypes as modalActionTypes} from 'nfvo-components/modal/GlobalModalConstants.js';
   9
  10 const ScreensHelper = {
  11         async loadScreen(dispatch, {screen, screenType, props}) {
  12                 if(screen === enums.SCREEN.ONBOARDING_CATALOG) {
  13                         OnboardingActionHelper.navigateToOnboardingCatalog(dispatch);
  14                         return;
  15                 }
  16
  17                 screenType = !screenType ? this.getScreenType(screen) : screenType;
  18
  19                 if(screenType === screenTypes.LICENSE_MODEL) {
  20                         const {licenseModelId, version, licenseModel, usersList} = props;
  21                         const item = await ItemsHelper.fetchItem(licenseModelId);
  22                         let itemStatusPromise = version && screen ?
  23                                 ItemsHelper.checkItemStatus(dispatch, {itemId: licenseModelId, versionId: version.id}) :
  24                                 Promise.resolve();
  25                         itemStatusPromise.then((updatedVersion) => {
  26                                 if (updatedVersion && updatedVersion.status !== version.status) {
  27                                         dispatch({
  28                                                 type: modalActionTypes.GLOBAL_MODAL_WARNING,
  29                                                 data: {
  30                                                         title: i18n('Commit error'),
  31                                                         msg: i18n('Item version was certified by Owner'),
  32                                                         cancelButtonText: i18n('Cancel')
  33                                                 }
  34                                         });
  35                                         versionPageActionHelper.fetchVersions(dispatch, {itemType: itemTypes.LICENSE_MODEL, itemId: licenseModelId});
  36                                 }
  37                                 let newVersion = updatedVersion ? updatedVersion : version;
  38                                 const screenProps = {licenseModelId, version: newVersion, status: item.status};
  39                                 switch (screen) {
  40                                         case enums.SCREEN.LICENSE_MODEL_OVERVIEW:
  41                                                 OnboardingActionHelper.navigateToLicenseModelOverview(dispatch, screenProps);
  42                                                 break;
  43                                         case enums.SCREEN.LICENSE_AGREEMENTS:
  44                                                 OnboardingActionHelper.navigateToLicenseAgreements(dispatch, screenProps);
  45                                                 break;
  46                                         case enums.SCREEN.FEATURE_GROUPS:
  47                                                 OnboardingActionHelper.navigateToFeatureGroups(dispatch, screenProps);
  48                                                 break;
  49                                         case enums.SCREEN.ENTITLEMENT_POOLS:
  50                                                 OnboardingActionHelper.navigateToEntitlementPools(dispatch, screenProps);
  51                                                 break;
  52                                         case enums.SCREEN.LICENSE_KEY_GROUPS:
  53                                                 OnboardingActionHelper.navigateToLicenseKeyGroups(dispatch, screenProps);
  54                                                 break;
  55                                         case enums.SCREEN.ACTIVITY_LOG:
  56                                                 OnboardingActionHelper.navigateToLicenseModelActivityLog(dispatch, screenProps);
  57                                                 break;
  58                                         case enums.SCREEN.VERSIONS_PAGE:
  59                                         default:
  60                                                 OnboardingActionHelper.navigateToVersionsPage(dispatch, {
  61                                                         itemId: licenseModelId,
  62                                                         itemType: itemTypes.LICENSE_MODEL,
  63                                                         itemName: licenseModel.name,
  64                                                         users: usersList
  65                                                 });
  66                                                 break;
  67                                 }
  68                         });
  69                 }
  70
  71                 else if(screenType === screenTypes.SOFTWARE_PRODUCT) {
  72                         const {softwareProductId, componentId, version, softwareProduct, usersList} = props;
  73                         const item = await ItemsHelper.fetchItem(softwareProductId);
  74                         let itemStatusPromise = version && screen ?
  75                                 ItemsHelper.checkItemStatus(dispatch, {itemId: softwareProductId, versionId: version.id}) :
  76                                 Promise.resolve();
  77                         itemStatusPromise.then((updatedVersion) => {
  78                                 if (updatedVersion && updatedVersion.status !== version.status) {
  79                                         dispatch({
  80                                                 type: modalActionTypes.GLOBAL_MODAL_WARNING,
  81                                                 data: {
  82                                                         title: i18n('Commit error'),
  83                                                         msg: i18n('Item version already Certified'),
  84                                                         cancelButtonText: i18n('Cancel')
  85                                                 }
  86                                         });
  87                                         versionPageActionHelper.fetchVersions(dispatch, {itemType: itemTypes.SOFTWARE_PRODUCT, itemId: softwareProductId});
  88                                 }
  89
  90                                 let newVersion = updatedVersion ? updatedVersion : version;
  91
  92                                 const props = {
  93                                         softwareProductId,
  94                                         componentId,
  95                                         version: newVersion,
  96                                         status: item.status
  97                                 };
  98                                 if (screen === screenTypes.SOFTWARE_PRODUCT_COMPONENT_DEFAULT_GENERAL) {
  99                                         OnboardingActionHelper.navigateToSoftwareProductComponentGeneralAndUpdateLeftPanel(dispatch, props);
 100                                 }
 101
 102                                 switch (screen) {
 103                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS:
 104                                                 OnboardingActionHelper.navigateToSoftwareProductComponentGeneralAndUpdateLeftPanel(dispatch, props);
 105                                                 break;
 106                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_GENERAL:
 107                                                 OnboardingActionHelper.navigateToSoftwareProductComponentGeneral(dispatch, props);
 108                                                 break;
 109                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_COMPUTE:
 110                                                 OnboardingActionHelper.navigateToComponentCompute(dispatch, props);
 111                                                 break;
 112                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_LOAD_BALANCING:
 113                                                 OnboardingActionHelper.navigateToComponentLoadBalancing(dispatch, props);
 114                                                 break;
 115                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_NETWORK:
 116                                                 OnboardingActionHelper.navigateToComponentNetwork(dispatch, props);
 117                                                 break;
 118                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_STORAGE:
 119                                                 OnboardingActionHelper.navigateToComponentStorage(dispatch, props);
 120                                                 break;
 121                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_PROCESSES:
 122                                                 OnboardingActionHelper.navigateToSoftwareProductComponentProcesses(dispatch, props);
 123                                                 break;
 124                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_MONITORING:
 125                                                 OnboardingActionHelper.navigateToSoftwareProductComponentMonitoring(dispatch, props);
 126                                                 break;
 127                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_IMAGES:
 128                                                 OnboardingActionHelper.navigateToComponentImages(dispatch, props);
 129                                                 break;
 130                                         case enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE:
 131                                                 OnboardingActionHelper.navigateToSoftwareProductLandingPage(dispatch, props);
 132                                                 break;
 133                                         case enums.SCREEN.SOFTWARE_PRODUCT_DETAILS:
 134                                                 OnboardingActionHelper.navigateToSoftwareProductDetails(dispatch, props);
 135                                                 break;
 136                                         case enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS_SETUP:
 137                                                 OnboardingActionHelper.navigateToSoftwareProductAttachmentsSetupTab(dispatch, props);
 138                                                 break;
 139                                         case enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS_VALIDATION:
 140                                                 OnboardingActionHelper.navigateToSoftwareProductAttachmentsValidationTab(dispatch, props);
 141                                                 break;
 142                                         case enums.SCREEN.SOFTWARE_PRODUCT_PROCESSES:
 143                                                 OnboardingActionHelper.navigateToSoftwareProductProcesses(dispatch, props);
 144                                                 break;
 145                                         case enums.SCREEN.SOFTWARE_PRODUCT_DEPLOYMENT:
 146                                                 OnboardingActionHelper.navigateToSoftwareProductDeployment(dispatch, props);
 147                                                 break;
 148                                         case enums.SCREEN.SOFTWARE_PRODUCT_NETWORKS:
 149                                                 OnboardingActionHelper.navigateToSoftwareProductNetworks(dispatch, props);
 150                                                 break;
 151                                         case enums.SCREEN.SOFTWARE_PRODUCT_DEPENDENCIES:
 152                                                 OnboardingActionHelper.navigateToSoftwareProductDependencies(dispatch, props);
 153                                                 break;
 154                                         case enums.SCREEN.SOFTWARE_PRODUCT_ACTIVITY_LOG:
 155                                                 OnboardingActionHelper.navigateToSoftwareProductActivityLog(dispatch, props);
 156                                                 break;
 157                                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS:
 158                                                 OnboardingActionHelper.navigateToSoftwareProductComponents(dispatch, props);
 159                                                 dispatch({
 160                                                         type: SoftwareProductActionTypes.TOGGLE_NAVIGATION_ITEM,
 161                                                         mapOfExpandedIds: {
 162                                                                 [enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS]: true
 163                                                         }
 164                                                 });
 165                                                 break;
 166                                         case enums.SCREEN.SOFTWARE_PRODUCT_VERSIONS_PAGE:
 167                                         default:
 168                                                 OnboardingActionHelper.navigateToVersionsPage(dispatch, {
 169                                                         itemId: softwareProductId,
 170                                                         itemType: itemTypes.SOFTWARE_PRODUCT,
 171                                                         itemName: softwareProduct.name,
 172                                                         users: usersList,
 173                                                         additionalProps: {
 174                                                                 licenseModelId: softwareProduct.vendorId,
 175                                                                 licensingVersion: softwareProduct.licensingVersion
 176                                                         }
 177                                                 });
 178                                                 break;
 179                                 }
 180                         });
 181                 }
 182         },
 183
 184         getScreenType(screen) {
 185                 switch (screen) {
 186                         case enums.SCREEN.LICENSE_MODEL_OVERVIEW:
 187                         case enums.SCREEN.LICENSE_AGREEMENTS:
 188                         case enums.SCREEN.FEATURE_GROUPS:
 189                         case enums.SCREEN.ENTITLEMENT_POOLS:
 190                         case enums.SCREEN.LICENSE_KEY_GROUPS:
 191                         case enums.SCREEN.ACTIVITY_LOG:
 192                                 return screenTypes.LICENSE_MODEL;
 193                         case screenTypes.SOFTWARE_PRODUCT_COMPONENT_DEFAULT_GENERAL:
 194                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_GENERAL:
 195                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_COMPUTE:
 196                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_LOAD_BALANCING:
 197                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_NETWORK:
 198                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_STORAGE:
 199                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_PROCESSES:
 200                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_MONITORING:
 201                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_IMAGES:
 202                         case enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE:
 203                         case enums.SCREEN.SOFTWARE_PRODUCT_DETAILS:
 204                         case enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS:
 205                         case enums.SCREEN.SOFTWARE_PRODUCT_PROCESSES:
 206                         case enums.SCREEN.SOFTWARE_PRODUCT_DEPLOYMENT:
 207                         case enums.SCREEN.SOFTWARE_PRODUCT_NETWORKS:
 208                         case enums.SCREEN.SOFTWARE_PRODUCT_DEPENDENCIES:
 209                         case enums.SCREEN.SOFTWARE_PRODUCT_ACTIVITY_LOG:
 210                         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS:
 211                                 return screenTypes.SOFTWARE_PRODUCT;
 212                 }
 213         },
 214
 215         loadLandingScreen(dispatch, {previousScreenName, screenType, props: {licenseModelId, softwareProductId, version}}) {
 216                 let selectedScreenType = screenType ? screenType : this.getScreenType(previousScreenName);
 217                 let screen = selectedScreenType === screenTypes.SOFTWARE_PRODUCT ?
 218                         enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE :
 219                         enums.SCREEN.LICENSE_MODEL_OVERVIEW;
 220                 let props = {licenseModelId, softwareProductId, version};
 221                 return this.loadScreen(dispatch, {screen, screenType: selectedScreenType, props});
 222         }
 223 };
 224
 225 export default ScreensHelper;