openecomp-ui/src/sdc-app/onboarding/softwareProduct/SoftwareProduct.js

   1 /*!
   2  * Copyright © 2016-2018 European Support Limited
   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 { connect } from 'react-redux';
  17
  18 import i18n from 'nfvo-utils/i18n/i18n.js';
  19 import ScreensHelper from 'sdc-app/common/helpers/ScreensHelper.js';
  20 import TabulatedEditor from 'src/nfvo-components/editor/TabulatedEditor.jsx';
  21
  22 import { enums, screenTypes } from 'sdc-app/onboarding/OnboardingConstants.js';
  23 import {
  24     onboardingMethod as onboardingMethodTypes,
  25     onboardingOriginTypes
  26 } from './SoftwareProductConstants.js';
  27 import SoftwareProductActionHelper from './SoftwareProductActionHelper.js';
  28 import SoftwareProductComponentsActionHelper from './components/SoftwareProductComponentsActionHelper.js';
  29 import PermissionsActionHelper from './../permissions/PermissionsActionHelper.js';
  30 import RevisionsActionHelper from './../revisions/RevisionsActionHelper.js';
  31 import HeatSetupActionHelper from './attachments/setup/HeatSetupActionHelper.js';
  32 import { actionsEnum as versionControllerActions } from 'nfvo-components/panel/versionController/VersionControllerConstants.js';
  33 import { actionTypes as modalActionTypes } from 'nfvo-components/modal/GlobalModalConstants.js';
  34 import { modalContentMapper } from 'sdc-app/common/modal/ModalContentMapper.js';
  35 import { CommitModalType } from 'nfvo-components/panel/versionController/components/CommitCommentModal.jsx';
  36 import { onboardingMethod as onboardingMethodType } from 'sdc-app/onboarding/softwareProduct/SoftwareProductConstants.js';
  37 import { SyncStates } from 'sdc-app/common/merge/MergeEditorConstants.js';
  38 import { catalogItemStatuses } from 'sdc-app/onboarding/onboard/onboardingCatalog/OnboardingCatalogConstants.js';
  39
  40 function getActiveNavigationId(screen, componentId) {
  41     let activeItemId = componentId ? screen + '|' + componentId : screen;
  42     return activeItemId;
  43 }
  44
  45 const buildComponentNavigationBarGroups = ({ componentId, meta }) => {
  46     const groups = [
  47         {
  48             id:
  49                 enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_GENERAL +
  50                 '|' +
  51                 componentId,
  52             name: i18n('General'),
  53             disabled: false,
  54             meta
  55         },
  56         {
  57             id:
  58                 enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_COMPUTE +
  59                 '|' +
  60                 componentId,
  61             name: i18n('Compute'),
  62             disabled: false,
  63             meta
  64         },
  65         {
  66             id:
  67                 enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_LOAD_BALANCING +
  68                 '|' +
  69                 componentId,
  70             name: i18n('High Availability & Load Balancing'),
  71             disabled: false,
  72             meta
  73         },
  74         {
  75             id:
  76                 enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_NETWORK +
  77                 '|' +
  78                 componentId,
  79             name: i18n('Networks'),
  80             disabled: false,
  81             meta
  82         },
  83         {
  84             id:
  85                 enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_STORAGE +
  86                 '|' +
  87                 componentId,
  88             name: i18n('Storage'),
  89             disabled: false,
  90             meta
  91         },
  92         {
  93             id:
  94                 enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_IMAGES +
  95                 '|' +
  96                 componentId,
  97             name: i18n('Images'),
  98             disabled: false,
  99             meta
 100         },
 101         {
 102             id:
 103                 enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_PROCESSES +
 104                 '|' +
 105                 componentId,
 106             name: i18n('Process Details'),
 107             disabled: false,
 108             meta
 109         },
 110         {
 111             id:
 112                 enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_MONITORING +
 113                 '|' +
 114                 componentId,
 115             name: i18n('Monitoring'),
 116             disabled: false,
 117             meta
 118         }
 119     ];
 120
 121     return groups;
 122 };
 123
 124 const buildNavigationBarProps = ({
 125     softwareProduct,
 126     meta,
 127     screen,
 128     componentId,
 129     componentsList,
 130     mapOfExpandedIds,
 131     isCertified
 132 }) => {
 133     const {
 134         softwareProductEditor: { data: currentSoftwareProduct = {} }
 135     } = softwareProduct;
 136     const {
 137         id,
 138         name,
 139         onboardingMethod,
 140         candidateOnboardingOrigin,
 141         onboardingOrigin
 142     } = currentSoftwareProduct;
 143     const groups = [
 144         {
 145             id: id,
 146             name: name,
 147             items: [
 148                 {
 149                     id: enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE,
 150                     name: i18n('Overview'),
 151                     disabled: false,
 152                     meta
 153                 },
 154                 {
 155                     id: enums.SCREEN.SOFTWARE_PRODUCT_DETAILS,
 156                     name: i18n('General'),
 157                     disabled: false,
 158                     meta
 159                 },
 160                 {
 161                     id: enums.SCREEN.SOFTWARE_PRODUCT_DEPLOYMENT,
 162                     name: i18n('Deployment Flavors'),
 163                     disabled: false,
 164                     hidden: onboardingMethod !== onboardingMethodTypes.MANUAL,
 165                     meta
 166                 },
 167                 {
 168                     id: enums.SCREEN.SOFTWARE_PRODUCT_PROCESSES,
 169                     name: i18n('Process Details'),
 170                     disabled: false,
 171                     meta
 172                 },
 173                 {
 174                     id: enums.SCREEN.SOFTWARE_PRODUCT_NETWORKS,
 175                     name: i18n('Networks'),
 176                     disabled: false,
 177                     meta
 178                 },
 179                 {
 180                     id: enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS,
 181                     name: i18n('Attachments'),
 182                     disabled: false,
 183                     hidden: !candidateOnboardingOrigin && !onboardingOrigin,
 184                     meta
 185                 },
 186                 {
 187                     id: enums.SCREEN.SOFTWARE_PRODUCT_ACTIVITY_LOG,
 188                     name: i18n('Activity Log'),
 189                     disabled: false,
 190                     meta
 191                 },
 192                 {
 193                     id: enums.SCREEN.SOFTWARE_PRODUCT_DEPENDENCIES,
 194                     name: i18n('Component Dependencies'),
 195                     hidden: componentsList.length <= 1,
 196                     disabled: false,
 197                     meta
 198                 },
 199                 {
 200                     id: enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS,
 201                     name: i18n('Components'),
 202                     hidden: componentsList.length <= 0,
 203                     meta,
 204                     expanded:
 205                         mapOfExpandedIds[
 206                             enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS
 207                         ] === true &&
 208                         screen !== enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE,
 209                     items: [
 210                         ...componentsList.map(({ id, displayName }) => ({
 211                             id:
 212                                 enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS +
 213                                 '|' +
 214                                 id,
 215                             name: displayName,
 216                             meta,
 217                             expanded:
 218                                 mapOfExpandedIds[
 219                                     enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS +
 220                                         '|' +
 221                                         id
 222                                 ] === true &&
 223                                 screen !==
 224                                     enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE,
 225                             items: buildComponentNavigationBarGroups({
 226                                 componentId: id,
 227                                 meta
 228                             })
 229                         }))
 230                     ]
 231                 }
 232             ]
 233         }
 234     ];
 235     let activeItemId = getActiveNavigationId(screen, componentId);
 236     return {
 237         activeItemId,
 238         groups,
 239         disabled: !!candidateOnboardingOrigin && !isCertified
 240     };
 241 };
 242
 243 const buildVersionControllerProps = ({
 244     softwareProduct,
 245     versions,
 246     currentVersion,
 247     permissions,
 248     userInfo,
 249     isArchived,
 250     usersList,
 251     itemPermission,
 252     isReadOnlyMode
 253 }) => {
 254     const { softwareProductEditor = { data: {} } } = softwareProduct;
 255     const {
 256         isValidityData = true,
 257         data: { name, onboardingMethod, candidateOnboardingOrigin }
 258     } = softwareProductEditor;
 259
 260     return {
 261         version: currentVersion,
 262         viewableVersions: versions,
 263         isFormDataValid: isValidityData,
 264         permissions,
 265         itemName: name,
 266         itemPermission,
 267         isReadOnlyMode,
 268         isArchived,
 269         userInfo,
 270         usersList,
 271         isManual: onboardingMethod === onboardingMethodType.MANUAL,
 272         candidateInProcess:
 273             !!candidateOnboardingOrigin && !itemPermission.isCertified
 274     };
 275 };
 276
 277 function buildMeta({
 278     softwareProduct,
 279     componentId,
 280     softwareProductDependencies,
 281     isReadOnlyMode
 282 }) {
 283     const {
 284         softwareProductEditor,
 285         softwareProductComponents,
 286         softwareProductQuestionnaire,
 287         softwareProductAttachments
 288     } = softwareProduct;
 289     const { data: currentSoftwareProduct = {} } = softwareProductEditor;
 290     const {
 291         version,
 292         onboardingOrigin,
 293         candidateOnboardingOrigin
 294     } = currentSoftwareProduct;
 295     const { qdata } = softwareProductQuestionnaire;
 296     const { heatSetup, heatSetupCache } = softwareProductAttachments;
 297     let currentComponentMeta = {};
 298     if (componentId) {
 299         const {
 300             componentEditor: { data: componentData = {}, qdata: componentQdata }
 301         } = softwareProductComponents;
 302         currentComponentMeta = { componentData, componentQdata };
 303     }
 304     const meta = {
 305         softwareProduct: currentSoftwareProduct,
 306         qdata,
 307         version,
 308         onboardingOrigin,
 309         candidateOnboardingOrigin,
 310         heatSetup,
 311         heatSetupCache,
 312         isReadOnlyMode,
 313         currentComponentMeta,
 314         softwareProductDependencies
 315     };
 316     return meta;
 317 }
 318
 319 const mapStateToProps = (
 320     {
 321         softwareProduct,
 322         users: { usersList, userInfo },
 323         versionsPage: { versionsList: { versions }, permissions }
 324     },
 325     {
 326         currentScreen: {
 327             screen,
 328             itemPermission,
 329             props: { version: currentVersion, componentId, isReadOnlyMode }
 330         }
 331     }
 332 ) => {
 333     const {
 334         softwareProductEditor,
 335         softwareProductComponents,
 336         softwareProductDependencies
 337     } = softwareProduct;
 338     const { mapOfExpandedIds = [] } = softwareProductEditor;
 339     const { componentsList = [] } = softwareProductComponents;
 340
 341     const meta = buildMeta({
 342         softwareProduct,
 343         componentId,
 344         softwareProductDependencies,
 345         isReadOnlyMode
 346     });
 347     return {
 348         versionControllerProps: buildVersionControllerProps({
 349             softwareProduct,
 350             versions,
 351             currentVersion,
 352             userInfo,
 353             usersList,
 354             isArchived: itemPermission.isArchived,
 355             permissions,
 356             itemPermission: { ...itemPermission, isDirty: true },
 357             isReadOnlyMode
 358         }),
 359         navigationBarProps: buildNavigationBarProps({
 360             softwareProduct,
 361             meta,
 362             screen,
 363             componentId,
 364             componentsList,
 365             mapOfExpandedIds,
 366             isCertified: itemPermission.isCertified
 367         }),
 368         meta
 369     };
 370 };
 371
 372 const autoSaveBeforeNavigate = ({
 373     dispatch,
 374     screen,
 375     softwareProductId,
 376     version,
 377     componentId,
 378     meta: {
 379         isReadOnlyMode,
 380         softwareProduct,
 381         qdata,
 382         currentComponentMeta: { componentData, componentQdata }
 383     }
 384 }) => {
 385     let promise;
 386     if (isReadOnlyMode) {
 387         promise = Promise.resolve();
 388     } else {
 389         switch (screen) {
 390             case enums.SCREEN.SOFTWARE_PRODUCT_DETAILS:
 391                 promise = SoftwareProductActionHelper.updateSoftwareProduct(
 392                     dispatch,
 393                     { softwareProduct, version, qdata }
 394                 );
 395                 break;
 396             case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_GENERAL:
 397                 promise = SoftwareProductComponentsActionHelper.updateSoftwareProductComponent(
 398                     dispatch,
 399                     {
 400                         softwareProductId,
 401                         version,
 402                         vspComponentId: componentId,
 403                         componentData,
 404                         qdata: componentQdata
 405                     }
 406                 );
 407                 break;
 408             case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_COMPUTE:
 409             case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_STORAGE:
 410             case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_NETWORK:
 411             case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_IMAGES:
 412             case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_LOAD_BALANCING:
 413                 promise = SoftwareProductComponentsActionHelper.updateSoftwareProductComponentQuestionnaire(
 414                     dispatch,
 415                     {
 416                         softwareProductId,
 417                         version,
 418                         vspComponentId: componentId,
 419                         qdata: componentQdata
 420                     }
 421                 );
 422                 break;
 423             default:
 424                 promise = Promise.resolve();
 425                 break;
 426         }
 427     }
 428     return promise;
 429 };
 430
 431 const mapActionsToProps = (
 432     dispatch,
 433     {
 434         currentScreen: {
 435             screen,
 436             props: {
 437                 softwareProductId,
 438                 licenseModelId,
 439                 version,
 440                 componentId: currentComponentId
 441             }
 442         }
 443     }
 444 ) => {
 445     const props = {
 446         onVersionSwitching: (versionToSwitch, meta) => {
 447             ScreensHelper.loadScreen(dispatch, {
 448                 screen: enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE,
 449                 screenType: screenTypes.SOFTWARE_PRODUCT,
 450                 props: {
 451                     softwareProductId: meta.softwareProduct.id,
 452                     version: versionToSwitch
 453                 }
 454             });
 455         },
 456         onOpenPermissions: ({ users }) => {
 457             return PermissionsActionHelper.fetchItemUsers(dispatch, {
 458                 itemId: softwareProductId,
 459                 allUsers: users
 460             });
 461         },
 462         onOpenRevisionsModal: () => {
 463             return RevisionsActionHelper.openRevisionsView(dispatch, {
 464                 itemId: softwareProductId,
 465                 version: version,
 466                 itemType: screenTypes.SOFTWARE_PRODUCT
 467             });
 468         },
 469         onOpenCommentCommitModal: ({ onCommit, title }) =>
 470             dispatch({
 471                 type: modalActionTypes.GLOBAL_MODAL_SHOW,
 472                 data: {
 473                     modalComponentName: modalContentMapper.COMMIT_COMMENT,
 474                     modalComponentProps: {
 475                         onCommit,
 476                         type: CommitModalType.COMMIT
 477                     },
 478                     title
 479                 }
 480             }),
 481         onMoreVersionsClick: ({ itemName, users }) => {
 482             ScreensHelper.loadScreen(dispatch, {
 483                 screen: enums.SCREEN.SOFTWARE_PRODUCT_VERSIONS_PAGE,
 484                 screenType: screenTypes.SOFTWARE_PRODUCT,
 485                 props: {
 486                     softwareProductId,
 487                     softwareProduct: {
 488                         name: itemName,
 489                         vendorId: licenseModelId
 490                     },
 491                     usersList: users
 492                 }
 493             });
 494         },
 495         onToggle: (groups, itemIdToExpand) =>
 496             groups.map(({ items }) =>
 497                 SoftwareProductActionHelper.toggleNavigationItems(dispatch, {
 498                     items,
 499                     itemIdToExpand
 500                 })
 501             ),
 502         onNavigate: ({ id, meta, newVersion }) => {
 503             let navigationVersion = newVersion || version;
 504             let {
 505                 onboardingOrigin,
 506                 candidateOnboardingOrigin,
 507                 heatSetup,
 508                 heatSetupCache
 509             } = meta;
 510             let heatSetupPopupPromise =
 511                 screen === enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS
 512                     ? HeatSetupActionHelper.heatSetupLeaveConfirmation(
 513                           dispatch,
 514                           { softwareProductId, heatSetup, heatSetupCache }
 515                       )
 516                     : Promise.resolve();
 517             let preNavigate = meta
 518                 ? autoSaveBeforeNavigate({
 519                       dispatch,
 520                       screen,
 521                       meta,
 522                       version,
 523                       softwareProductId,
 524                       componentId: currentComponentId
 525                   })
 526                 : Promise.resolve();
 527             version = version || (meta ? meta.version : undefined);
 528             Promise.all([preNavigate, heatSetupPopupPromise])
 529                 .then(() => {
 530                     let [nextScreen, nextComponentId] = id.split('|');
 531                     if (
 532                         nextScreen ===
 533                             enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS &&
 534                         nextComponentId &&
 535                         nextComponentId === currentComponentId
 536                     ) {
 537                         ScreensHelper.loadScreen(dispatch, {
 538                             screen: nextScreen,
 539                             screenType: screenTypes.SOFTWARE_PRODUCT,
 540                             props: {
 541                                 softwareProductId,
 542                                 version: navigationVersion
 543                             }
 544                         });
 545                     } else {
 546                         if (
 547                             nextScreen ===
 548                             enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS
 549                         ) {
 550                             if (
 551                                 onboardingOrigin ===
 552                                     onboardingOriginTypes.ZIP ||
 553                                 candidateOnboardingOrigin ===
 554                                     onboardingOriginTypes.ZIP
 555                             ) {
 556                                 nextScreen =
 557                                     enums.SCREEN
 558                                         .SOFTWARE_PRODUCT_ATTACHMENTS_SETUP;
 559                             } else if (
 560                                 onboardingOrigin === onboardingOriginTypes.CSAR
 561                             ) {
 562                                 nextScreen =
 563                                     enums.SCREEN
 564                                         .SOFTWARE_PRODUCT_ATTACHMENTS_VALIDATION;
 565                             }
 566                         }
 567                         ScreensHelper.loadScreen(dispatch, {
 568                             screen: nextScreen,
 569                             screenType: screenTypes.SOFTWARE_PRODUCT,
 570                             props: {
 571                                 softwareProductId,
 572                                 version: navigationVersion,
 573                                 componentId: nextComponentId
 574                             }
 575                         });
 576                     }
 577                 })
 578                 .catch(e => {
 579                     console.error(e);
 580                 });
 581         }
 582     };
 583
 584     switch (screen) {
 585         case enums.SCREEN.SOFTWARE_PRODUCT_LANDING_PAGE:
 586         case enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS:
 587         case enums.SCREEN.SOFTWARE_PRODUCT_PROCESSES:
 588         case enums.SCREEN.SOFTWARE_PRODUCT_NETWORKS:
 589         case enums.SCREEN.SOFTWARE_PRODUCT_DEPENDENCIES:
 590         case enums.SCREEN.SOFTWARE_PRODUCT_ACTIVITY_LOG:
 591         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENTS:
 592         case enums.SCREEN.SOFTWARE_PRODUCT_DEPLOYMENT:
 593         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_PROCESSES:
 594         case enums.SCREEN.SOFTWARE_PRODUCT_COMPONENT_MONITORING:
 595             props.onSave = () => Promise.resolve();
 596             break;
 597         default:
 598             props.onSave = ({ softwareProduct, qdata }) =>
 599                 SoftwareProductActionHelper.updateSoftwareProduct(dispatch, {
 600                     softwareProduct,
 601                     qdata,
 602                     version
 603                 });
 604             break;
 605     }
 606
 607     props.onVersionControllerAction = (action, version, comment, meta) => {
 608         let { heatSetup, heatSetupCache } = meta;
 609         let autoSavePromise = meta
 610             ? autoSaveBeforeNavigate({
 611                   dispatch,
 612                   screen,
 613                   meta,
 614                   version,
 615                   softwareProductId,
 616                   componentId: currentComponentId
 617               })
 618             : Promise.resolve();
 619         let heatSetupPopupPromise =
 620             screen === enums.SCREEN.SOFTWARE_PRODUCT_ATTACHMENTS &&
 621             action === versionControllerActions.COMMIT
 622                 ? HeatSetupActionHelper.heatSetupLeaveConfirmation(dispatch, {
 623                       softwareProductId,
 624                       heatSetup,
 625                       heatSetupCache
 626                   })
 627                 : Promise.resolve();
 628         Promise.all([autoSavePromise, heatSetupPopupPromise])
 629             .then(() => {
 630                 return SoftwareProductActionHelper.performVCAction(dispatch, {
 631                     softwareProductId,
 632                     action,
 633                     version,
 634                     comment,
 635                     meta
 636                 }).then(updatedVersion => {
 637                     const inMerge =
 638                         updatedVersion &&
 639                         updatedVersion.state &&
 640                         updatedVersion.state.synchronizationState ===
 641                             SyncStates.MERGE;
 642                     if (
 643                         (action === versionControllerActions.SYNC &&
 644                             !inMerge) ||
 645                         ((action === versionControllerActions.COMMIT ||
 646                             action === versionControllerActions.SYNC) &&
 647                             updatedVersion.status ===
 648                                 catalogItemStatuses.CERTIFIED)
 649                     ) {
 650                         ScreensHelper.loadLandingScreen(dispatch, {
 651                             previousScreenName: screen,
 652                             props: {
 653                                 softwareProductId,
 654                                 version: updatedVersion
 655                             }
 656                         });
 657                     } else {
 658                         ScreensHelper.loadScreen(dispatch, {
 659                             screen,
 660                             screenType: screenTypes.SOFTWARE_PRODUCT,
 661                             props: {
 662                                 softwareProductId,
 663                                 version: updatedVersion,
 664                                 componentId: currentComponentId
 665                             }
 666                         });
 667                     }
 668                 });
 669             })
 670             .catch(e => {
 671                 console.error(e);
 672             });
 673     };
 674
 675     props.onManagePermissions = () =>
 676         PermissionsActionHelper.openPermissonsManager(dispatch, {
 677             itemId: softwareProductId,
 678             askForRights: false
 679         });
 680     return props;
 681 };
 682
 683 export default connect(mapStateToProps, mapActionsToProps)(TabulatedEditor);