| import {Injectable} from "@angular/core"; |
| import {NgRedux} from "@angular-redux/store"; |
| import {AppState} from "../../../shared/store/reducers"; |
| import {PauseStatus, ServiceInstanceActions} from "../../../shared/models/serviceInstanceActions"; |
| import {MessageBoxData} from "../../../shared/components/messageBox/messageBox.data"; |
| import {MessageBoxService} from "../../../shared/components/messageBox/messageBox.service"; |
| import * as _ from "lodash"; |
| import {DrawingBoardModes} from "../drawing-board.modes"; |
| import {AuditInfoModalComponent} from "../../../shared/components/auditInfoModal/auditInfoModal.component"; |
| import {ILevelNodeInfo} from "./models/basic.model.info"; |
| import {ComponentInfoModel, ComponentInfoType} from "../component-info/component-info-model"; |
| import {ModelInformationItem} from "../../../shared/components/model-information/model-information.component"; |
| import {undoUpgradeService, upgradeService} from "../../../shared/storeUtil/utils/service/service.actions"; |
| import {VNFMethods} from "../../../shared/storeUtil/utils/vnf/vnf.actions"; |
| import {FeatureFlagsService, Features} from "../../../shared/services/featureFlag/feature-flags.service"; |
| import {Utils} from "../../../shared/utils/utils"; |
| import {Constants} from "../../../shared/utils/constants"; |
| import {NodeInstance} from "../../../shared/models/nodeInstance"; |
| |
| @Injectable() |
| export class SharedTreeService { |
| constructor(private _store: NgRedux<AppState>) { |
| } |
| |
| /*********************************************************** |
| * return if instance has missing data |
| * @param instance - vnf instance |
| * @param dynamicInputs - from the instance |
| * @param isEcompGeneratedNaming |
| ************************************************************/ |
| selectedNF: string = null; |
| |
| getSelectedNF(): string { |
| return this.selectedNF; |
| } |
| |
| setSelectedNF(node): void { |
| if (_.isNil(node) || node.data.type !== 'VF') { |
| this.selectedNF = null; |
| } else if (node.data.type === 'VF'){ |
| this.selectedNF = node.data.vnfStoreKey; |
| } else if (node.data.type === 'PNF'){ |
| this.selectedNF = node.data.pnfStoreKey; |
| } |
| |
| } |
| |
| /** |
| * Determines a consistent unique ID for a given right-tree |
| * node instance. |
| */ |
| modelUniqueId = (nodeInstance: NodeInstance): string => { |
| return _.isNil(nodeInstance.modelInfo) |
| ? null |
| : (nodeInstance.modelInfo.modelCustomizationId || nodeInstance.modelInfo.modelInvariantId); |
| }; |
| |
| modelUniqueNameOrId = (instance): string => { |
| if (_.isNil(instance)) { |
| return null; |
| } |
| |
| const innerInstance = _.find(instance) || {}; |
| |
| return instance.originalName |
| || this.modelUniqueId(instance) |
| || innerInstance.originalName |
| || this.modelUniqueId(innerInstance); |
| }; |
| |
| /** |
| * Finds a model inside a full service model |
| * @param serviceModelFromHierarchy |
| * @param modelTypeName "vnfs" | "networks" | "vfModules" | "collectionResources" | ... |
| * @param modelUniqueNameOrId Either an entry name (i.e. "originalName"), modelCustomizationId or modelInvariantId. |
| * Note that modelInvariantId will work only where model lacks a modelCustomizationId. |
| * @param modelName An optional entry name (i.e. "originalName"); will not try to use as id |
| */ |
| modelByIdentifiers = (serviceModelFromHierarchy, modelTypeName: string, modelUniqueNameOrId: string, modelName?: string): any => { |
| const logErrorAndReturnUndefined = () => |
| console.info(`modelByIdentifiers: could not find a model matching query`, { |
| modelTypeName, modelUniqueNameOrId, modelName, serviceModelFromHierarchy |
| }); |
| |
| if (_.isNil(serviceModelFromHierarchy)) return logErrorAndReturnUndefined(); |
| |
| const modelsOfType = serviceModelFromHierarchy[modelTypeName]; |
| if (_.isNil(modelsOfType)) return logErrorAndReturnUndefined(); |
| |
| const modelIfModelIdentifierIsEntryName = modelsOfType[modelUniqueNameOrId]; |
| const modelIfModeNameExists = _.isNil(modelName) ? null : modelsOfType[modelName]; |
| |
| if (!_.isNil(modelIfModelIdentifierIsEntryName)) { |
| return modelIfModelIdentifierIsEntryName; |
| } else if (!_.isNil(modelIfModeNameExists)) { |
| return modelIfModeNameExists; |
| } else { |
| // try modelUniqueNameOrId as an id |
| return _.find(modelsOfType, o => (o.customizationUuid || o.invariantUuid) === modelUniqueNameOrId) || logErrorAndReturnUndefined() |
| } |
| }; |
| |
| hasMissingData(instance, dynamicInputs: any, isEcompGeneratedNaming: boolean, requiredFields: string[]): boolean { |
| if (!isEcompGeneratedNaming && _.isEmpty(instance.instanceName)) { |
| return true; |
| } |
| |
| for (let field of requiredFields) { |
| if (_.isEmpty(instance[field])) { |
| return true; |
| } |
| } |
| |
| for (let field of dynamicInputs) { |
| if (field.isRequired && !_.isNil(instance.instanceParams) && _.isEmpty(instance.instanceParams[0][field.id])) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| |
| addingStatusProperty(node) { |
| node['statusProperties'] = []; |
| node['statusProperties'].push({key: 'Prov Status: ', value: node.provStatus, testId: 'provStatus'}); |
| node['statusProperties'].push({key: 'Orch Status: ', value: node.orchStatus, testId: 'orchStatus'}); |
| if(node.type === 'VFmodule') { |
| node['statusProperties'].push({key: 'Model Version: ', value: this.getNodeModelVersion(node), testId: 'modelVersion'}); |
| } |
| if (node.inMaint) { |
| node['statusProperties'].push({key: 'In-maintenance', value: '', testId: 'inMaint'}); |
| } |
| return node; |
| } |
| |
| getNodeModelVersion(node): string | undefined { |
| if(!_.isNil(node.instanceModelInfo) && !_.isNil(node.instanceModelInfo.modelVersion)){ |
| return node.instanceModelInfo.modelVersion; |
| } |
| return undefined; |
| } |
| |
| /********************************************** |
| * should delete or remove child instance's |
| "new" -> should remove |
| !new" -> should change action status |
| **********************************************/ |
| removeDeleteAllChild(node, serviceModelId: string, callback): void { |
| for (let nodeChild of node.children) { |
| if (nodeChild.data.action === ServiceInstanceActions.Create) { |
| if (!_.isNil(nodeChild.data) && !_.isNil(nodeChild.data.menuActions) && !_.isNil(nodeChild.data.menuActions['remove'])) { |
| nodeChild.data.menuActions['remove']['method'](nodeChild, serviceModelId); |
| } |
| } else { |
| if (!_.isNil(nodeChild.data) && !_.isNil(nodeChild.data.menuActions) && !_.isNil(nodeChild.data.menuActions['delete'])) { |
| nodeChild.data.menuActions['delete']['method'](nodeChild, serviceModelId); |
| } |
| } |
| } |
| callback(node, serviceModelId); |
| } |
| |
| |
| /********************************************** |
| * should undo delete child instance's |
| **********************************************/ |
| undoDeleteAllChild(node, serviceModelId: string, callback): void { |
| for (let nodeChild of node.children) { |
| if (!_.isNil(nodeChild.data) && !_.isNil(nodeChild.data.menuActions) && !_.isNil(nodeChild.data.menuActions['undoDelete'])) { |
| nodeChild.data.menuActions['undoDelete']['method'](nodeChild, serviceModelId); |
| } |
| } |
| callback(node, serviceModelId); |
| } |
| |
| /********************************************** |
| * should return true if can delete |
| **********************************************/ |
| shouldShowDelete(node, serviceModelId): boolean { |
| return this.shouldShowButtonGeneric(node, "delete", serviceModelId) |
| } |
| |
| /********************************************** |
| * should return true if can undo delete |
| **********************************************/ |
| shouldShowUndoDelete(node): boolean { |
| const mode = this._store.getState().global.drawingBoardStatus; |
| if (mode === DrawingBoardModes.EDIT && !_.isNil(node.data.action) && !_.isNil(node.data.menuActions['undoDelete'])) { |
| if (node.data.action === ServiceInstanceActions.Create || node.data.action === ServiceInstanceActions.Delete) { |
| return false; |
| } else if (node.data.action.split('_').pop() === 'Delete') { |
| return true |
| } |
| return false; |
| } |
| return false; |
| } |
| /********************************************** |
| * should return true if can remove or edit |
| * enabled only on edit/design mode and for new instances |
| **********************************************/ |
| shouldShowRemoveAndEdit(node): boolean { |
| const mode = this._store.getState().global.drawingBoardStatus; |
| if (!_.isNil(node) && !_.isNil(node.data) && !_.isNil(node.data.action) && node.data.action === ServiceInstanceActions.Create && |
| mode !== DrawingBoardModes.VIEW && mode !== DrawingBoardModes.RETRY) { |
| return true; |
| } |
| return false; |
| } |
| /********************************************** |
| * enabled only on edit/design |
| * enabled only if there's a newer version for VNF-M |
| **********************************************/ |
| upgradeBottomUp(node,serviceModelId: string): void { |
| this.iterateOverTreeBranchAndRunAction(node, serviceModelId, VNFMethods.UPGRADE); |
| this._store.dispatch(upgradeService(serviceModelId)); |
| } |
| |
| private iterateOverTreeBranchAndRunAction(node, serviceModelId: string, actionMethod) { |
| while (_.has(node.parent, 'data') && _.has(node.parent.data, 'menuActions') |
| && !_.isNil(node.parent.data.menuActions[actionMethod])) { |
| node = node.parent; |
| node.data.menuActions[actionMethod]['method'](node, serviceModelId); |
| } |
| } |
| |
| shouldShowRemovePause(node) : boolean { |
| if(FeatureFlagsService.getFlagState(Features.FLAG_2008_REMOVE_PAUSE_INSTANTIATION, this._store)){ |
| return node.pauseInstantiation === PauseStatus.AFTER_COMPLETION; |
| } |
| return false; |
| } |
| |
| showPauseWithOrchStatus(node): boolean { |
| if(node.orchStatus == "Active"){ |
| return false; |
| } |
| return true; |
| } |
| |
| shouldShowPauseInstantiation(node): boolean { |
| if(FeatureFlagsService.getFlagState(Features.FLAG_2008_REMOVE_PAUSE_INSTANTIATION, this._store)){ |
| return (FeatureFlagsService.getFlagState(Features.FLAG_2006_PAUSE_VFMODULE_INSTANTIATION_CREATION, this._store) && node.pauseInstantiation == null); |
| } |
| return (FeatureFlagsService.getFlagState(Features.FLAG_2006_PAUSE_VFMODULE_INSTANTIATION_CREATION, this._store)); |
| } |
| /**************************************************** |
| * should return true if customer can upgrade a VFM * |
| ****************************************************/ |
| shouldShowUpgrade(node, serviceModelId): boolean { |
| return (this.isVfMoudleCouldBeUpgraded(node, serviceModelId)) |
| && this.shouldShowButtonGeneric(node, VNFMethods.UPGRADE, serviceModelId) ; |
| } |
| |
| isVfMoudleCouldBeUpgraded(node, serviceModelId): boolean{ |
| return (FeatureFlagsService.getFlagState(Features.FLAG_FLASH_REPLACE_VF_MODULE, this._store) && |
| (this.isThereAnUpdatedLatestVersion(serviceModelId) || this.isVfModuleCustomizationIdNotExistsOnModel(node, serviceModelId)) && |
| (this.upgradeAllowedForBm(node,serviceModelId))) |
| |
| |
| } |
| |
| isVfModuleCustomizationIdNotExistsOnModel(vfModuleNode, serviceModelId) { |
| |
| // prevent undefined |
| if (_.isNil(vfModuleNode.data) || _.isNil(vfModuleNode.data.modelCustomizationId)) { |
| return false; |
| } |
| |
| let vfModulesHierarchyByGivenModelId = this._store.getState().service.serviceHierarchy[serviceModelId].vfModules; |
| return !_.some(vfModulesHierarchyByGivenModelId, vfmodel => vfmodel.customizationUuid === vfModuleNode.data.modelCustomizationId); |
| } |
| |
| |
| isVfmoduleAlmostPartOfModelOnlyCustomizationUuidDiffer(vfModuleNode, serviceModelId) : boolean { |
| /* |
| for `true`, should all: |
| 1. parent vnf found by model-mane |
| 2. vfmodule found by invariant |
| 3. vfmodule diff by customization |
| */ |
| |
| if (_.isNil(vfModuleNode.data)) { |
| return false; |
| } |
| |
| const vnfHierarchy = this.getParentVnfHierarchy(vfModuleNode, serviceModelId); |
| if (_.isNil(vnfHierarchy)) { |
| return false; |
| } |
| |
| const vfModuleHierarchyByInvariantId = this.getVfModuleHFromVnfHierarchyByInvariantId(vfModuleNode, vnfHierarchy); |
| if(_.isNil(vfModuleHierarchyByInvariantId)){ |
| return false; |
| } |
| |
| return vfModuleHierarchyByInvariantId.customizationUuid |
| && (vfModuleHierarchyByInvariantId.customizationUuid !== vfModuleNode.data.modelCustomizationId); |
| } |
| |
| getParentVnfHierarchy(vfModuleNode, serviceModelId) { |
| if (vfModuleNode.parent && vfModuleNode.parent.data) { |
| return this._store.getState().service.serviceHierarchy[serviceModelId].vnfs[vfModuleNode.parent.data.modelName]; |
| } else { |
| return null; |
| } |
| } |
| |
| getVfModuleHFromVnfHierarchyByInvariantId(vfModuleNode, parentVnfHierarchy) { |
| if(vfModuleNode.data.modelInvariantId && parentVnfHierarchy && parentVnfHierarchy.vfModules){ |
| return _.find(parentVnfHierarchy.vfModules, o => o.invariantUuid === vfModuleNode.data.modelInvariantId); |
| } |
| return null; |
| } |
| |
| |
| isThereAnUpdatedLatestVersion(serviceModelId) : boolean{ |
| let serviceInstance = this.getServiceInstance(serviceModelId); |
| return !_.isNil(serviceInstance.latestAvailableVersion) && (Number(serviceInstance.modelInfo.modelVersion) < serviceInstance.latestAvailableVersion); |
| } |
| |
| private getServiceInstance(serviceModelId): any { |
| return this._store.getState().service.serviceInstance[serviceModelId]; |
| } |
| |
| shouldShowButtonGeneric(node, method, serviceModelId) { |
| const mode = this._store.getState().global.drawingBoardStatus; |
| const isMacro = this.getServiceInstance(serviceModelId) ? !(this.getServiceInstance(serviceModelId).isALaCarte) : false; |
| // const isMacro = !(this.getServiceInstance(serviceModelId).isALaCarte); |
| if (isMacro) { //if macro action allowed only for service level |
| return false; |
| } |
| |
| if (!_.isNil(node) && !_.isNil(node.data) && !_.isNil(node.data.action) && !_.isNil(node.data.menuActions[method])) { |
| if (mode !== DrawingBoardModes.EDIT || node.data.action === ServiceInstanceActions.Create) { |
| return false; |
| } |
| else if (node.data.action === ServiceInstanceActions.None) { |
| return true |
| } |
| } |
| return false; |
| } |
| |
| /********************************************** |
| * return boolean according to |
| * current defined action of VFModule node |
| **********************************************/ |
| shouldShowUndoUpgrade(node): boolean { |
| const mode = this._store.getState().global.drawingBoardStatus; |
| if (mode === DrawingBoardModes.EDIT && !_.isNil(node.data.action) && !_.isNil(node.data.menuActions[VNFMethods.UNDO_UPGRADE])) { |
| if (node.data.action === ServiceInstanceActions.Upgrade) { |
| return false; |
| } else if (node.data.action.split('_').pop() === ServiceInstanceActions.Upgrade) { |
| return true |
| } |
| return false; |
| } |
| return false; |
| } |
| /********************************************** |
| * enabled only on edit/design |
| * enabled only if there's a newer version for VNF-M |
| **********************************************/ |
| undoUpgradeBottomUp(node,serviceModelId: string): void { |
| this.iterateOverTreeBranchAndRunAction(node, serviceModelId, VNFMethods.UNDO_UPGRADE); |
| this._store.dispatch(undoUpgradeService(serviceModelId)); |
| } |
| /********************************************** |
| * should return true if can duplicate by mode |
| **********************************************/ |
| shouldShowDuplicate(node): boolean { |
| const mode = this._store.getState().global.drawingBoardStatus; |
| return !mode.includes('RETRY'); |
| } |
| |
| /********************************************** |
| * should return true if can audit info |
| **********************************************/ |
| shouldShowAuditInfo(node): boolean { |
| return this.isRetryMode() || (!_.isNil(node.data) && !_.isNil(node.data.action) && node.data.action !== ServiceInstanceActions.Create); |
| } |
| |
| |
| isRetryMode(): boolean { |
| const mode = this._store.getState().global.drawingBoardStatus; |
| return mode.includes('RETRY'); |
| } |
| |
| |
| /********************************************** |
| * should return true if can add node instances |
| **********************************************/ |
| shouldShowAddIcon(): boolean{ |
| const mode = this._store.getState().global.drawingBoardStatus; |
| return mode === DrawingBoardModes.EDIT || mode=== DrawingBoardModes.CREATE || mode=== DrawingBoardModes.RECREATE; |
| } |
| |
| |
| isReachedToMaxInstances(properties, counter, flags): boolean{ |
| let maxInstances = Utils.getMaxFirstLevel(properties, flags); |
| if(_.isNil(maxInstances)){ |
| return false; |
| }else { |
| return !(maxInstances > counter); |
| } |
| } |
| /************************************************ |
| return number of instances with action Delete |
| @type: vnfs networks, vngGroups (not vfModule) |
| @node : node model from the left tree |
| ************************************************/ |
| getExistingInstancesWithDeleteMode(node, serviceModelId: string, type: string): number { |
| let counter = 0; |
| const existingInstances = this.getServiceInstance(serviceModelId)[type]; |
| const modelUniqueId = node.data.modelUniqueId; |
| if (!_.isNil(existingInstances)) { |
| for (let instanceKey in existingInstances) { |
| if (!_.isNil(existingInstances[instanceKey].action)) { |
| if (existingInstances[instanceKey].modelInfo.modelUniqueId === modelUniqueId && existingInstances[instanceKey].action.split('_').pop() === 'Delete') { |
| counter++; |
| } |
| } |
| } |
| } |
| return counter; |
| } |
| |
| |
| isServiceOnDeleteMode(serviceId: string): boolean { |
| return this._store.getState().service.serviceInstance[serviceId].action === ServiceInstanceActions.Delete; |
| } |
| |
| |
| openModal(node : any | any[] , serviceModelId : string, cb : Function) : void { |
| let type: string = _.isArray(node) ? 'Service' : node.data.typeName; |
| let messageBoxData: MessageBoxData = new MessageBoxData( |
| "Mark for Delete", |
| `You are about to mark for delete this ${type} this will also mark all its children and remove all new instances just added`, |
| <any>"warning", |
| <any>"md", |
| [ |
| { |
| text: "Mark and remove", |
| size: "large", |
| callback: cb.bind(this, node, serviceModelId), |
| closeModal: true |
| }, |
| {text: "Don’t Remove", size: "medium", closeModal: true} |
| ]); |
| |
| MessageBoxService.openModal.next(messageBoxData); |
| } |
| |
| someChildHasCreateAction(nodes: any | any[]) : boolean { |
| let nodesArr = _.isArray(nodes) ? nodes : [nodes]; |
| for(const node of nodesArr){ |
| if(node.action === ServiceInstanceActions.Create) {return true;} |
| if(node.children){ |
| for (let nodeChild of node.children) { |
| if (nodeChild.action === ServiceInstanceActions.Create) { |
| return true; |
| } |
| if(nodeChild.children && nodeChild.children.length > 0){ |
| for(let child of nodeChild.children){ |
| let hasCreateAction = this.someChildHasCreateAction(child); |
| if(hasCreateAction) { |
| return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| shouldShowDeleteInstanceWithChildrenModal(node : any | any[] , serviceModelId : string, cb : Function) : void { |
| if(this.someChildHasCreateAction(node)){ |
| this.openModal(node , serviceModelId, cb); |
| }else { |
| cb(node, serviceModelId) |
| } |
| } |
| |
| |
| isFailed(node): boolean { |
| return !_.isNil(node.data) ? node.data.isFailed : false; |
| } |
| |
| /************************************************ |
| in a case the node is failed e.g. not instantiated correctly |
| the function will call to openRetryInstanceAuditInfoModal |
| @node : node model from the left tree |
| @serviceModelId : serviceModelId |
| @instance : instance |
| @instanceType: instanceType |
| @modelInfoService : the model (vnf, vfmodule, network, vnfgroup)object that call to the function (this) |
| ************************************************/ |
| openAuditInfoModal(node, serviceModelId, instance, instanceType, modelInfoService : ILevelNodeInfo){ |
| AuditInfoModalComponent.openInstanceAuditInfoModal.next({ |
| instanceId: serviceModelId, |
| type: instanceType, |
| model: modelInfoService.getModel( |
| this.modelByIdentifiers( |
| this._store.getState().service.serviceHierarchy[serviceModelId], |
| modelInfoService.name, |
| this.modelUniqueNameOrId(instance), node.data.modelName |
| ) |
| ), |
| instance |
| }); |
| } |
| |
| getModelVersionEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined { |
| return this.getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, "modelVersion", model, "version"); |
| } |
| |
| getModelCustomizationIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined { |
| return this.getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, "modelCustomizationId", model, "customizationUuid"); |
| } |
| |
| getModelInvariantIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined { |
| return this.getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, "modelInvariantId", model, "invariantUuid"); |
| } |
| |
| getModelVersionIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined { |
| return this.getNamedFieldFromInstanceOrFromHierarchy (selectedNodeData, "modelVersionId", model, "uuid"); |
| } |
| |
| |
| |
| getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, instanceModelInfoFieldName, model, modelFieldName): string | undefined { |
| if (instanceModelInfoFieldName && selectedNodeData && selectedNodeData.instanceModelInfo |
| && selectedNodeData.instanceModelInfo[instanceModelInfoFieldName]) { |
| return selectedNodeData.instanceModelInfo[instanceModelInfoFieldName]; |
| } else if (modelFieldName && model && model[modelFieldName]) { |
| return model[modelFieldName]; |
| } |
| return undefined; |
| } |
| |
| addGeneralInfoItems(modelInfoSpecificItems: ModelInformationItem[], type: ComponentInfoType, model, selectedNodeData):ComponentInfoModel { |
| let modelInfoItems: ModelInformationItem[] = [ |
| ModelInformationItem.createInstance("Model version", this.getModelVersionEitherFromInstanceOrFromHierarchy(selectedNodeData, model)), |
| ModelInformationItem.createInstance("Model customization ID", this.getModelCustomizationIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model)), |
| ModelInformationItem.createInstance("Instance ID", selectedNodeData ? selectedNodeData.instanceId : null), |
| ModelInformationItem.createInstance("Instance type", selectedNodeData ? selectedNodeData.instanceType : null), |
| ModelInformationItem.createInstance("In maintenance", selectedNodeData? selectedNodeData.inMaint : null), |
| ]; |
| modelInfoItems = modelInfoItems.concat(modelInfoSpecificItems); |
| return this.getComponentInfoModelByModelInformationItems(modelInfoItems, type, selectedNodeData); |
| } |
| |
| getComponentInfoModelByModelInformationItems(modelInfoItems: ModelInformationItem[], type: ComponentInfoType, instance){ |
| const modelInfoItemsWithoutEmpty = _.filter(modelInfoItems, function(item){ return !item.values.every(_.isNil)}); |
| return new ComponentInfoModel(type, modelInfoItemsWithoutEmpty, [], instance != null); |
| } |
| |
| createMaximumToInstantiateModelInformationItem(model): ModelInformationItem { |
| return ModelInformationItem.createInstance( |
| "Max instances", |
| !_.isNil(model.max) ? String(model.max) : Constants.ModelInfo.UNLIMITED_DEFAULT |
| ); |
| } |
| |
| isAddPositionFlagTrue():boolean{ |
| return FeatureFlagsService.getFlagState(Features.FLAG_2008_CREATE_VFMODULE_INSTANTIATION_ORDER_NUMBER, this._store); |
| } |
| |
| upgradeAllowedForBm(node, serviceModelId):boolean { |
| |
| if(FeatureFlagsService.getFlagState(Features.FLAG_2012_UPGRADE_BASE_MODULE_FLAG, this._store)){ |
| let returnValue = false; |
| if(node.data.type == 'VFmodule') { |
| let serviceHierarchy = this._store.getState().service.serviceHierarchy[serviceModelId]; |
| let vnf = node.parent.data.modelName; |
| let baseModuleFlag= (serviceHierarchy.vnfs[vnf].vfModules[node.data.modelName].properties.baseModule) ? true: false; |
| |
| if(baseModuleFlag) { |
| if(node.parent.children.length >1) { |
| return returnValue; |
| } |
| else { |
| returnValue = true; |
| } |
| }else { |
| returnValue = true; |
| } |
| |
| } else { |
| returnValue= true |
| } |
| |
| return returnValue; |
| } else { |
| return true; |
| } |
| } |
| } |