vid-webpack-master/src/app/drawingBoard/service-planning/objectsToTree/shared.tree.service.ts

   1 import {Injectable} from "@angular/core";
   2 import {NgRedux} from "@angular-redux/store";
   3 import {AppState} from "../../../shared/store/reducers";
   4 import {PauseStatus, ServiceInstanceActions} from "../../../shared/models/serviceInstanceActions";
   5 import {MessageBoxData} from "../../../shared/components/messageBox/messageBox.data";
   6 import {MessageBoxService} from "../../../shared/components/messageBox/messageBox.service";
   7 import * as _ from "lodash";
   8 import {DrawingBoardModes} from "../drawing-board.modes";
   9 import {AuditInfoModalComponent} from "../../../shared/components/auditInfoModal/auditInfoModal.component";
  10 import {ILevelNodeInfo} from "./models/basic.model.info";
  11 import {ComponentInfoModel, ComponentInfoType} from "../component-info/component-info-model";
  12 import {ModelInformationItem} from "../../../shared/components/model-information/model-information.component";
  13 import {undoUpgradeService, upgradeService} from "../../../shared/storeUtil/utils/service/service.actions";
  14 import {VNFMethods} from "../../../shared/storeUtil/utils/vnf/vnf.actions";
  15 import {FeatureFlagsService, Features} from "../../../shared/services/featureFlag/feature-flags.service";
  16 import {Utils} from "../../../shared/utils/utils";
  17 import {Constants} from "../../../shared/utils/constants";
  18 import {NodeInstance} from "../../../shared/models/nodeInstance";
  19
  20 @Injectable()
  21 export class SharedTreeService {
  22   constructor(private _store: NgRedux<AppState>) {
  23   }
  24
  25   /***********************************************************
  26    * return if instance has missing data
  27    * @param instance - vnf instance
  28    * @param dynamicInputs - from the instance
  29    * @param isEcompGeneratedNaming
  30    ************************************************************/
  31   selectedNF: string = null;
  32
  33   getSelectedNF(): string {
  34     return this.selectedNF;
  35   }
  36
  37   setSelectedNF(node): void {
  38     if (_.isNil(node) || node.data.type !== 'VF') {
  39       this.selectedNF = null;
  40     } else if (node.data.type === 'VF'){
  41       this.selectedNF = node.data.vnfStoreKey;
  42     } else if (node.data.type === 'PNF'){
  43       this.selectedNF = node.data.pnfStoreKey;
  44     }
  45
  46   }
  47
  48   /**
  49    * Determines a consistent unique ID for a given right-tree
  50    * node instance.
  51    */
  52   modelUniqueId = (nodeInstance: NodeInstance): string => {
  53     return _.isNil(nodeInstance.modelInfo)
  54       ? null
  55       : (nodeInstance.modelInfo.modelCustomizationId || nodeInstance.modelInfo.modelInvariantId);
  56   };
  57
  58   modelUniqueNameOrId = (instance): string => {
  59     if (_.isNil(instance)) {
  60       return null;
  61     }
  62
  63     const innerInstance = _.find(instance) || {};
  64
  65     return instance.originalName
  66       || this.modelUniqueId(instance)
  67       || innerInstance.originalName
  68       || this.modelUniqueId(innerInstance);
  69   };
  70
  71   /**
  72    * Finds a model inside a full service model
  73    * @param serviceModelFromHierarchy
  74    * @param modelTypeName "vnfs" | "networks" | "vfModules" | "collectionResources" | ...
  75    * @param modelUniqueNameOrId Either an entry name (i.e. "originalName"), modelCustomizationId or modelInvariantId.
  76    *                      Note that modelInvariantId will work only where model lacks a modelCustomizationId.
  77    * @param modelName An optional entry name (i.e. "originalName"); will not try to use as id
  78    */
  79   modelByIdentifiers = (serviceModelFromHierarchy, modelTypeName: string, modelUniqueNameOrId: string, modelName?: string): any => {
  80     const logErrorAndReturnUndefined = () =>
  81       console.info(`modelByIdentifiers: could not find a model matching query`, {
  82         modelTypeName, modelUniqueNameOrId, modelName, serviceModelFromHierarchy
  83       });
  84
  85     if (_.isNil(serviceModelFromHierarchy)) return logErrorAndReturnUndefined();
  86
  87     const modelsOfType = serviceModelFromHierarchy[modelTypeName];
  88     if (_.isNil(modelsOfType)) return logErrorAndReturnUndefined();
  89
  90     const modelIfModelIdentifierIsEntryName = modelsOfType[modelUniqueNameOrId];
  91     const modelIfModeNameExists = _.isNil(modelName) ? null : modelsOfType[modelName];
  92
  93     if (!_.isNil(modelIfModelIdentifierIsEntryName)) {
  94       return modelIfModelIdentifierIsEntryName;
  95     } else if (!_.isNil(modelIfModeNameExists)) {
  96       return modelIfModeNameExists;
  97     } else {
  98       // try modelUniqueNameOrId as an id
  99       return _.find(modelsOfType, o => (o.customizationUuid || o.invariantUuid) === modelUniqueNameOrId) || logErrorAndReturnUndefined()
 100     }
 101   };
 102
 103   hasMissingData(instance, dynamicInputs: any, isEcompGeneratedNaming: boolean, requiredFields: string[]): boolean {
 104     if (!isEcompGeneratedNaming && _.isEmpty(instance.instanceName)) {
 105       return true;
 106     }
 107
 108     for (let field of requiredFields) {
 109       if (_.isEmpty(instance[field])) {
 110         return true;
 111       }
 112     }
 113
 114     for (let field of dynamicInputs) {
 115       if (field.isRequired && !_.isNil(instance.instanceParams) && _.isEmpty(instance.instanceParams[0][field.id])) {
 116         return true;
 117       }
 118     }
 119     return false;
 120   }
 121
 122
 123   addingStatusProperty(node) {
 124     node['statusProperties'] = [];
 125     node['statusProperties'].push({key: 'Prov Status: ', value: node.provStatus, testId: 'provStatus'});
 126     node['statusProperties'].push({key: 'Orch Status: ', value: node.orchStatus, testId: 'orchStatus'});
 127     if(node.type === 'VFmodule') {
 128       node['statusProperties'].push({key: 'Model Version: ', value: this.getNodeModelVersion(node), testId: 'modelVersion'});
 129     }
 130     if (node.inMaint) {
 131       node['statusProperties'].push({key: 'In-maintenance', value: '', testId: 'inMaint'});
 132     }
 133     return node;
 134   }
 135
 136    getNodeModelVersion(node): string | undefined {
 137     if(!_.isNil(node.instanceModelInfo) && !_.isNil(node.instanceModelInfo.modelVersion)){
 138       return node.instanceModelInfo.modelVersion;
 139     }
 140     return undefined;
 141   }
 142
 143   /**********************************************
 144    * should delete or remove child instance's
 145    "new" -> should remove
 146    !new" -> should change action status
 147    **********************************************/
 148   removeDeleteAllChild(node, serviceModelId: string, callback): void {
 149     for (let nodeChild of node.children) {
 150       if (nodeChild.data.action === ServiceInstanceActions.Create) {
 151         if (!_.isNil(nodeChild.data) && !_.isNil(nodeChild.data.menuActions) && !_.isNil(nodeChild.data.menuActions['remove'])) {
 152           nodeChild.data.menuActions['remove']['method'](nodeChild, serviceModelId);
 153         }
 154       } else {
 155         if (!_.isNil(nodeChild.data) && !_.isNil(nodeChild.data.menuActions) && !_.isNil(nodeChild.data.menuActions['delete'])) {
 156           nodeChild.data.menuActions['delete']['method'](nodeChild, serviceModelId);
 157         }
 158       }
 159     }
 160     callback(node, serviceModelId);
 161   }
 162
 163
 164   /**********************************************
 165    * should undo delete child instance's
 166    **********************************************/
 167   undoDeleteAllChild(node, serviceModelId: string, callback): void {
 168     for (let nodeChild of node.children) {
 169       if (!_.isNil(nodeChild.data) && !_.isNil(nodeChild.data.menuActions) && !_.isNil(nodeChild.data.menuActions['undoDelete'])) {
 170         nodeChild.data.menuActions['undoDelete']['method'](nodeChild, serviceModelId);
 171       }
 172     }
 173     callback(node, serviceModelId);
 174   }
 175
 176   /**********************************************
 177    * should return true if can delete
 178    **********************************************/
 179   shouldShowDelete(node, serviceModelId): boolean {
 180     return this.shouldShowButtonGeneric(node, "delete", serviceModelId)
 181   }
 182
 183   /**********************************************
 184    * should return true if can undo delete
 185    **********************************************/
 186   shouldShowUndoDelete(node): boolean {
 187     const mode = this._store.getState().global.drawingBoardStatus;
 188     if (mode === DrawingBoardModes.EDIT && !_.isNil(node.data.action) && !_.isNil(node.data.menuActions['undoDelete'])) {
 189       if (node.data.action === ServiceInstanceActions.Create || node.data.action === ServiceInstanceActions.Delete) {
 190         return false;
 191       } else if (node.data.action.split('_').pop() === 'Delete') {
 192         return true
 193       }
 194       return false;
 195     }
 196     return false;
 197   }
 198   /**********************************************
 199    * should return true if can remove or edit
 200    * enabled only on edit/design mode and for new instances
 201    **********************************************/
 202   shouldShowRemoveAndEdit(node): boolean {
 203     const mode = this._store.getState().global.drawingBoardStatus;
 204     if (!_.isNil(node) && !_.isNil(node.data) && !_.isNil(node.data.action) && node.data.action === ServiceInstanceActions.Create &&
 205       mode !== DrawingBoardModes.VIEW && mode !== DrawingBoardModes.RETRY) {
 206       return true;
 207     }
 208     return false;
 209   }
 210   /**********************************************
 211    * enabled only on edit/design
 212    * enabled only if there's a newer version for VNF-M
 213    **********************************************/
 214   upgradeBottomUp(node,serviceModelId: string): void {
 215     this.iterateOverTreeBranchAndRunAction(node, serviceModelId, VNFMethods.UPGRADE);
 216     this._store.dispatch(upgradeService(serviceModelId));
 217   }
 218
 219   private iterateOverTreeBranchAndRunAction(node, serviceModelId: string, actionMethod) {
 220     while (_.has(node.parent, 'data') && _.has(node.parent.data, 'menuActions')
 221     && !_.isNil(node.parent.data.menuActions[actionMethod])) {
 222       node = node.parent;
 223       node.data.menuActions[actionMethod]['method'](node, serviceModelId);
 224     }
 225   }
 226
 227   shouldShowRemovePause(node) : boolean {
 228     if(FeatureFlagsService.getFlagState(Features.FLAG_2008_REMOVE_PAUSE_INSTANTIATION, this._store)){
 229       return node.pauseInstantiation === PauseStatus.AFTER_COMPLETION;
 230     }
 231     return false;
 232   }
 233
 234   showPauseWithOrchStatus(node): boolean {
 235     if(node.orchStatus == "Active"){
 236       return false;
 237     }
 238     return true;
 239   }
 240
 241   shouldShowPauseInstantiation(node): boolean {
 242     if(FeatureFlagsService.getFlagState(Features.FLAG_2008_REMOVE_PAUSE_INSTANTIATION, this._store)){
 243       return (FeatureFlagsService.getFlagState(Features.FLAG_2006_PAUSE_VFMODULE_INSTANTIATION_CREATION, this._store) && node.pauseInstantiation == null);
 244     }
 245     return (FeatureFlagsService.getFlagState(Features.FLAG_2006_PAUSE_VFMODULE_INSTANTIATION_CREATION, this._store));
 246   }
 247   /****************************************************
 248    * should return true if customer can upgrade a VFM *
 249    ****************************************************/
 250   shouldShowUpgrade(node, serviceModelId): boolean {
 251       return (this.isVfMoudleCouldBeUpgraded(node, serviceModelId))
 252         && this.shouldShowButtonGeneric(node, VNFMethods.UPGRADE, serviceModelId) ;
 253     }
 254
 255   isVfMoudleCouldBeUpgraded(node, serviceModelId): boolean{
 256     return (FeatureFlagsService.getFlagState(Features.FLAG_FLASH_REPLACE_VF_MODULE, this._store) &&
 257     (this.isThereAnUpdatedLatestVersion(serviceModelId) || this.isVfModuleCustomizationIdNotExistsOnModel(node, serviceModelId)) &&
 258     (this.upgradeAllowedForBm(node,serviceModelId)))
 259
 260
 261   }
 262
 263   isVfModuleCustomizationIdNotExistsOnModel(vfModuleNode, serviceModelId) {
 264
 265     // prevent undefined
 266     if (_.isNil(vfModuleNode.data) || _.isNil(vfModuleNode.data.modelCustomizationId)) {
 267       return false;
 268     }
 269
 270     let vfModulesHierarchyByGivenModelId = this._store.getState().service.serviceHierarchy[serviceModelId].vfModules;
 271     return  !_.some(vfModulesHierarchyByGivenModelId, vfmodel => vfmodel.customizationUuid === vfModuleNode.data.modelCustomizationId);
 272   }
 273
 274
 275   isVfmoduleAlmostPartOfModelOnlyCustomizationUuidDiffer(vfModuleNode, serviceModelId) : boolean {
 276     /*
 277     for `true`, should all:
 278     1. parent vnf found by model-mane
 279     2. vfmodule found by invariant
 280     3. vfmodule diff by customization
 281      */
 282
 283     if (_.isNil(vfModuleNode.data)) {
 284       return false;
 285     }
 286
 287     const vnfHierarchy = this.getParentVnfHierarchy(vfModuleNode, serviceModelId);
 288     if (_.isNil(vnfHierarchy)) {
 289       return false;
 290     }
 291
 292     const vfModuleHierarchyByInvariantId =  this.getVfModuleHFromVnfHierarchyByInvariantId(vfModuleNode, vnfHierarchy);
 293     if(_.isNil(vfModuleHierarchyByInvariantId)){
 294       return false;
 295     }
 296
 297     return vfModuleHierarchyByInvariantId.customizationUuid
 298       && (vfModuleHierarchyByInvariantId.customizationUuid !== vfModuleNode.data.modelCustomizationId);
 299   }
 300
 301   getParentVnfHierarchy(vfModuleNode, serviceModelId) {
 302     if (vfModuleNode.parent && vfModuleNode.parent.data) {
 303       return this._store.getState().service.serviceHierarchy[serviceModelId].vnfs[vfModuleNode.parent.data.modelName];
 304     } else {
 305       return null;
 306     }
 307   }
 308
 309   getVfModuleHFromVnfHierarchyByInvariantId(vfModuleNode, parentVnfHierarchy) {
 310     if(vfModuleNode.data.modelInvariantId && parentVnfHierarchy && parentVnfHierarchy.vfModules){
 311       return _.find(parentVnfHierarchy.vfModules, o => o.invariantUuid === vfModuleNode.data.modelInvariantId);
 312     }
 313     return null;
 314   }
 315
 316
 317   isThereAnUpdatedLatestVersion(serviceModelId) : boolean{
 318     let serviceInstance = this.getServiceInstance(serviceModelId);
 319     return !_.isNil(serviceInstance.latestAvailableVersion) && (Number(serviceInstance.modelInfo.modelVersion) < serviceInstance.latestAvailableVersion);
 320   }
 321
 322   private getServiceInstance(serviceModelId): any {
 323     return this._store.getState().service.serviceInstance[serviceModelId];
 324   }
 325
 326   shouldShowButtonGeneric(node, method, serviceModelId) {
 327     const mode = this._store.getState().global.drawingBoardStatus;
 328         const isMacro = this.getServiceInstance(serviceModelId) ? !(this.getServiceInstance(serviceModelId).isALaCarte) : false;
 329         //  const isMacro = !(this.getServiceInstance(serviceModelId).isALaCarte);
 330     if (isMacro) { //if macro action allowed only for service level
 331       return false;
 332     }
 333
 334     if (!_.isNil(node) && !_.isNil(node.data) && !_.isNil(node.data.action) && !_.isNil(node.data.menuActions[method])) {
 335       if (mode !== DrawingBoardModes.EDIT || node.data.action === ServiceInstanceActions.Create) {
 336         return false;
 337       }
 338       else if (node.data.action === ServiceInstanceActions.None) {
 339         return true
 340       }
 341     }
 342     return false;
 343   }
 344
 345   /**********************************************
 346    * return boolean according to
 347    * current defined action of VFModule node
 348    **********************************************/
 349   shouldShowUndoUpgrade(node): boolean {
 350     const mode = this._store.getState().global.drawingBoardStatus;
 351     if (mode === DrawingBoardModes.EDIT && !_.isNil(node.data.action) && !_.isNil(node.data.menuActions[VNFMethods.UNDO_UPGRADE])) {
 352       if (node.data.action === ServiceInstanceActions.Upgrade) {
 353         return false;
 354       } else if (node.data.action.split('_').pop() === ServiceInstanceActions.Upgrade) {
 355         return true
 356       }
 357       return false;
 358     }
 359     return false;
 360   }
 361   /**********************************************
 362    * enabled only on edit/design
 363    * enabled only if there's a newer version for VNF-M
 364    **********************************************/
 365   undoUpgradeBottomUp(node,serviceModelId: string): void {
 366     this.iterateOverTreeBranchAndRunAction(node, serviceModelId, VNFMethods.UNDO_UPGRADE);
 367     this._store.dispatch(undoUpgradeService(serviceModelId));
 368   }
 369   /**********************************************
 370    * should return true if can duplicate by mode
 371    **********************************************/
 372   shouldShowDuplicate(node): boolean {
 373     const mode = this._store.getState().global.drawingBoardStatus;
 374     return !mode.includes('RETRY');
 375   }
 376
 377   /**********************************************
 378    * should return true if can audit info
 379    **********************************************/
 380   shouldShowAuditInfo(node): boolean {
 381     return this.isRetryMode() || (!_.isNil(node.data) && !_.isNil(node.data.action) && node.data.action !== ServiceInstanceActions.Create);
 382   }
 383
 384
 385   isRetryMode(): boolean {
 386     const mode = this._store.getState().global.drawingBoardStatus;
 387     return mode.includes('RETRY');
 388   }
 389
 390
 391   /**********************************************
 392    * should return true if can add node instances
 393    **********************************************/
 394   shouldShowAddIcon(): boolean{
 395     const mode = this._store.getState().global.drawingBoardStatus;
 396     return mode === DrawingBoardModes.EDIT || mode=== DrawingBoardModes.CREATE || mode=== DrawingBoardModes.RECREATE;
 397   }
 398
 399
 400   isReachedToMaxInstances(properties, counter, flags): boolean{
 401     let maxInstances  = Utils.getMaxFirstLevel(properties, flags);
 402     if(_.isNil(maxInstances)){
 403       return false;
 404     }else {
 405       return !(maxInstances > counter);
 406     }
 407   }
 408   /************************************************
 409    return number of instances with action Delete
 410    @type: vnfs networks, vngGroups (not vfModule)
 411    @node : node model from the left tree
 412    ************************************************/
 413   getExistingInstancesWithDeleteMode(node, serviceModelId: string, type: string): number {
 414     let counter = 0;
 415     const existingInstances = this.getServiceInstance(serviceModelId)[type];
 416     const modelUniqueId = node.data.modelUniqueId;
 417     if (!_.isNil(existingInstances)) {
 418       for (let instanceKey in existingInstances) {
 419         if (!_.isNil(existingInstances[instanceKey].action)) {
 420           if (existingInstances[instanceKey].modelInfo.modelUniqueId === modelUniqueId && existingInstances[instanceKey].action.split('_').pop() === 'Delete') {
 421             counter++;
 422           }
 423         }
 424       }
 425     }
 426     return counter;
 427   }
 428
 429
 430   isServiceOnDeleteMode(serviceId: string): boolean {
 431     return this._store.getState().service.serviceInstance[serviceId].action === ServiceInstanceActions.Delete;
 432   }
 433
 434
 435   openModal(node : any | any[] , serviceModelId : string, cb : Function) : void {
 436     let type: string = _.isArray(node) ? 'Service' : node.data.typeName;
 437     let messageBoxData: MessageBoxData = new MessageBoxData(
 438       "Mark for Delete",
 439       `You are about to mark for delete this ${type} this will also mark all its children and remove all new instances just added`,
 440       <any>"warning",
 441       <any>"md",
 442       [
 443         {
 444           text: "Mark and remove",
 445           size: "large",
 446           callback: cb.bind(this, node, serviceModelId),
 447           closeModal: true
 448         },
 449         {text: "Don’t Remove", size: "medium", closeModal: true}
 450       ]);
 451
 452     MessageBoxService.openModal.next(messageBoxData);
 453   }
 454
 455   someChildHasCreateAction(nodes: any | any[]) : boolean {
 456     let nodesArr = _.isArray(nodes) ? nodes : [nodes];
 457     for(const node of nodesArr){
 458       if(node.action === ServiceInstanceActions.Create) {return true;}
 459       if(node.children){
 460         for (let nodeChild of node.children) {
 461           if (nodeChild.action === ServiceInstanceActions.Create) {
 462             return true;
 463           }
 464           if(nodeChild.children && nodeChild.children.length > 0){
 465             for(let child of nodeChild.children){
 466               let hasCreateAction = this.someChildHasCreateAction(child);
 467               if(hasCreateAction) {
 468                 return true;
 469               }
 470             }
 471           }
 472         }
 473       }
 474     }
 475     return false;
 476   }
 477
 478   shouldShowDeleteInstanceWithChildrenModal(node : any | any[] , serviceModelId : string, cb : Function) : void {
 479     if(this.someChildHasCreateAction(node)){
 480       this.openModal(node , serviceModelId, cb);
 481     }else {
 482       cb(node, serviceModelId)
 483     }
 484   }
 485
 486
 487   isFailed(node): boolean {
 488     return !_.isNil(node.data) ? node.data.isFailed : false;
 489   }
 490
 491   /************************************************
 492    in a case the node is failed e.g. not instantiated correctly
 493    the function will call to openRetryInstanceAuditInfoModal
 494    @node : node model from the left tree
 495    @serviceModelId : serviceModelId
 496    @instance : instance
 497    @instanceType: instanceType
 498    @modelInfoService : the model (vnf, vfmodule, network, vnfgroup)object that call to the function (this)
 499    ************************************************/
 500   openAuditInfoModal(node, serviceModelId, instance, instanceType, modelInfoService : ILevelNodeInfo){
 501     AuditInfoModalComponent.openInstanceAuditInfoModal.next({
 502       instanceId: serviceModelId,
 503       type: instanceType,
 504       model: modelInfoService.getModel(
 505         this.modelByIdentifiers(
 506           this._store.getState().service.serviceHierarchy[serviceModelId],
 507           modelInfoService.name,
 508           this.modelUniqueNameOrId(instance), node.data.modelName
 509         )
 510       ),
 511       instance
 512     });
 513   }
 514
 515   getModelVersionEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined {
 516     return this.getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, "modelVersion", model, "version");
 517   }
 518
 519   getModelCustomizationIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined {
 520     return this.getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, "modelCustomizationId", model, "customizationUuid");
 521   }
 522
 523   getModelInvariantIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined {
 524     return this.getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, "modelInvariantId", model, "invariantUuid");
 525   }
 526
 527   getModelVersionIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined {
 528     return this.getNamedFieldFromInstanceOrFromHierarchy (selectedNodeData, "modelVersionId", model, "uuid");
 529   }
 530
 531
 532
 533   getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, instanceModelInfoFieldName, model, modelFieldName): string | undefined {
 534     if (instanceModelInfoFieldName && selectedNodeData && selectedNodeData.instanceModelInfo
 535       && selectedNodeData.instanceModelInfo[instanceModelInfoFieldName]) {
 536       return selectedNodeData.instanceModelInfo[instanceModelInfoFieldName];
 537     } else if (modelFieldName && model && model[modelFieldName]) {
 538       return model[modelFieldName];
 539     }
 540     return undefined;
 541   }
 542
 543   addGeneralInfoItems(modelInfoSpecificItems: ModelInformationItem[], type: ComponentInfoType, model, selectedNodeData):ComponentInfoModel {
 544     let modelInfoItems: ModelInformationItem[] = [
 545       ModelInformationItem.createInstance("Model version", this.getModelVersionEitherFromInstanceOrFromHierarchy(selectedNodeData, model)),
 546       ModelInformationItem.createInstance("Model customization ID", this.getModelCustomizationIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model)),
 547       ModelInformationItem.createInstance("Instance ID", selectedNodeData ? selectedNodeData.instanceId : null),
 548       ModelInformationItem.createInstance("Instance type", selectedNodeData ? selectedNodeData.instanceType : null),
 549       ModelInformationItem.createInstance("In maintenance", selectedNodeData? selectedNodeData.inMaint : null),
 550     ];
 551     modelInfoItems = modelInfoItems.concat(modelInfoSpecificItems);
 552     return this.getComponentInfoModelByModelInformationItems(modelInfoItems, type, selectedNodeData);
 553   }
 554
 555   getComponentInfoModelByModelInformationItems(modelInfoItems: ModelInformationItem[], type: ComponentInfoType, instance){
 556     const modelInfoItemsWithoutEmpty = _.filter(modelInfoItems, function(item){ return !item.values.every(_.isNil)});
 557     return new ComponentInfoModel(type, modelInfoItemsWithoutEmpty, [], instance != null);
 558   }
 559
 560   createMaximumToInstantiateModelInformationItem(model): ModelInformationItem {
 561     return ModelInformationItem.createInstance(
 562       "Max instances",
 563       !_.isNil(model.max) ? String(model.max) : Constants.ModelInfo.UNLIMITED_DEFAULT
 564     );
 565   }
 566
 567   isAddPositionFlagTrue():boolean{
 568     return FeatureFlagsService.getFlagState(Features.FLAG_2008_CREATE_VFMODULE_INSTANTIATION_ORDER_NUMBER, this._store);
 569   }
 570
 571   upgradeAllowedForBm(node, serviceModelId):boolean {
 572
 573     if(FeatureFlagsService.getFlagState(Features.FLAG_2012_UPGRADE_BASE_MODULE_FLAG, this._store)){
 574       let returnValue = false;
 575       if(node.data.type == 'VFmodule') {
 576         let serviceHierarchy = this._store.getState().service.serviceHierarchy[serviceModelId];
 577         let vnf :any;
 578         let baseModuleFlag: any;
 579
 580         if(node.parent) {
 581             vnf= node.parent.data.modelName;
 582         }
 583
 584         if(vnf) {
 585             baseModuleFlag=(serviceHierarchy.vnfs[vnf].vfModules[node.data.modelName].properties.baseModule) ? true: false;
 586         }
 587
 588
 589         if(baseModuleFlag) {
 590           if(node.parent.children.length >1) {
 591             return returnValue;
 592           }
 593           else {
 594             returnValue = true;
 595           }
 596         }else {
 597           returnValue = true;
 598         }
 599
 600       } else {
 601         returnValue= true
 602       }
 603
 604       return returnValue;
 605     } else {
 606       return true;
 607     }
 608   }
 609 }