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