diff options
Diffstat (limited to 'vid-webpack-master/src/app/services/service-planning.service.ts')
| -rw-r--r-- | vid-webpack-master/src/app/services/service-planning.service.ts | 282 |
1 files changed, 282 insertions, 0 deletions
diff --git a/vid-webpack-master/src/app/services/service-planning.service.ts b/vid-webpack-master/src/app/services/service-planning.service.ts new file mode 100644 index 000000000..75720c8a1 --- /dev/null +++ b/vid-webpack-master/src/app/services/service-planning.service.ts @@ -0,0 +1,282 @@ +import {Injectable} from '@angular/core'; +import {Constants} from "../shared/utils/constants"; +import {Utils} from "../utils/utils"; +import * as _ from 'lodash'; +import Parameter = Constants.Parameter; +import {ITreeNode} from "angular-tree-component/dist/defs/api"; +import {ServiceInstance} from "../shared/models/serviceInstance"; +import {VNFModel} from "../shared/models/vnfModel"; +import {ServiceNodeTypes} from "../shared/models/ServiceNodeTypes"; +import {VfModuleMap} from "../shared/models/vfModulesMap"; +import {VnfInstance} from "../shared/models/vnfInstance"; +import {VfModuleTreeNode} from "../shared/models/vfModuleTreeNode"; +import {VfModule} from "../shared/models/vfModule"; +import {VnfTreeNode} from "../shared/models/vnfTreeNode"; +import {NgRedux} from "@angular-redux/store"; +import {AppState} from "../store/reducers"; +import {InputType} from "../shared/models/inputTypes"; + + +@Injectable() +export class ServicePlanningService { + + modelDataTree: any[] = []; + drawingDataTree: any[] = []; + service: any = {name:'My Service'} ; + public requiredFields = { + VF: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM], + VFmodule: [] + }; + + constructor(private store: NgRedux<AppState>) {} + + + public getServiceName() :string{ + return this.service.name; + } + + public getServiceInstance(serviceModelId): ServiceInstance { + return this.store.getState().service.serviceInstance[serviceModelId]; + } + + public getVnfInstance(serviceModelId, vnfModelName): VnfInstance { + return this.getServiceInstance(serviceModelId).vnfs[vnfModelName]; + } + + public getVfModuleMap(serviceModelId, vnfModelName, vfModuleModelName): VfModuleMap { + let vnfInstance = this.getVnfInstance(serviceModelId, vnfModelName); + return _.get(vnfInstance, ['vfModules', vfModuleModelName]); + } + + public convertServiceModelToTreeNodes(serviceModel) { + let _this = this; + + _.forOwn(serviceModel.vnfs, function(item, key) { + _this.addFirstLevelModel(key, item, item.type, serviceModel); + }); + + _.forOwn(serviceModel.configurations, function(item, key) { + _this.addFirstLevelModel(key, item, ServiceNodeTypes.Configuration, serviceModel); + }); + + _.forOwn(serviceModel.networks, function(network, key) { + _this.addFirstLevelModel(key, network, ServiceNodeTypes.Network, serviceModel); + }); + + return this.modelDataTree; + } + + private addFirstLevelModel(key, value, valueType, serviceModel) { + + let node = this.convertItemToTreeNode(key, value, valueType, null, false); + let vnfInstance = this.getVnfInstance(serviceModel.service.uuid, key); + if(value.vfModules) { + node.children = Object.keys(value.vfModules).map((vmKey) => + this.convertItemToTreeNode(vmKey, value.vfModules[vmKey], ServiceNodeTypes.VFmodule, value, !vnfInstance)); + } + this.modelDataTree.push(node); + } + + private convertItemToTreeNode(key, value, valueType, parentModel , disabled) { + + return { + id: value.uuid, + name: key, + tooltip: valueType, + type: valueType, + count: value.count || 0, + max: value.max || 1, + children: [], + disabled: disabled, + dynamicInputs: this.updateDynamicInputsVnfDataFromModel(valueType, value), + userProvidedNaming: this.isUserProvidedNaming(valueType, value, parentModel) + } + } + + public convertServiceInstanceToTreeData(serviceInstance: ServiceInstance, modelId: string): any { + let drawingBoardData = []; + let _this = this; + _.forOwn(serviceInstance.vnfs, (vnfInstance, vnfModelName) => { + let vnfModel: VNFModel = _this.store.getState().service.serviceHierarchy[modelId].vnfs[vnfModelName]; + let vnfNode = new VnfTreeNode(vnfInstance, vnfModel); + + let vfModuleNodes = []; + _.forOwn(vnfInstance.vfModules, (vfModuleMap, vfModuleModelName) => { + _.forOwn(vfModuleMap, (vfModuleInstance, vfModuleInstsanceName) => { + let vfModule: VfModule = _this.store.getState().service.serviceHierarchy[modelId].vnfs[vnfModelName].vfModules[vfModuleModelName]; + let vfModuleNode: VfModuleTreeNode = new VfModuleTreeNode(vfModuleInstance, vfModule, vfModuleModelName); + vfModuleNodes.push(vfModuleNode); + }); + }); + vnfNode.children = vfModuleNodes; + drawingBoardData.push(vnfNode); + }); + + return drawingBoardData; + } + + public getArbitraryInputs(inputs) { + let parameter; + let parameterList = []; + for (let key in inputs) { + parameter = { + id : key, + type : Parameter.STRING, + name : key, + value : inputs[key][Parameter.DEFAULT], + isRequired : inputs[key][Parameter.REQUIRED], + description : inputs[key][Parameter.DESCRIPTION] + }; + switch (inputs[key][Parameter.TYPE]) { + case Parameter.INTEGER: + parameter.type = Parameter.NUMBER; + break; + case Parameter.BOOLEAN: + parameter.type = Parameter.BOOLEAN; + break; + case Parameter.RANGE: + break; + case Parameter.LIST: + parameter.type = Parameter.LIST; + break; + case Parameter.MAP: + parameter.type = Parameter.MAP; + break; + } + if ( Utils.hasContents(inputs[key][Parameter.CONSTRAINTS]) + && ( inputs[key][Parameter.CONSTRAINTS].length > 0 ) ) { + let constraintsArray = inputs[key][Parameter.CONSTRAINTS]; + this.addConstraintParameters (parameterList, constraintsArray, key, inputs, parameter); + } + else { + + parameterList.push(parameter); + } + } + return parameterList; + } + + private addConstraintParameters(parameterList, constraintsArray, key, inputs, parameter) { + // If there are constraints and the operator is "valid_values", + // use a select parameter type. + let i:number = constraintsArray.length; + let parameterPushed: boolean = false; + if ( i > 0 ) { + while ( (i--) && (!parameterPushed) ) { + let keys = Object.keys(constraintsArray[i]); + for ( let operator in keys ) { + switch (keys[operator]) { + case Parameter.VALID_VALUES: + let j: number = constraintsArray[i][Parameter.VALID_VALUES].length; + if ( j > 0 ) { + let oList = []; + let option; + while (j--) { + option = { + name: constraintsArray[i][Parameter.VALID_VALUES][j], + isDefault: false + }; + if ( (Utils.hasContents (inputs[key][Parameter.DEFAULT]) ) + && (inputs[key][Parameter.DEFAULT] === constraintsArray[i][Parameter.VALID_VALUES][j] ) ) { + option = { + name: constraintsArray[i][Parameter.VALID_VALUES][j], + isDefault: true + } + } + oList.push(option); + } + parameter.type = Parameter.SELECT; + parameter.optionList = oList; + parameterList.push(parameter); + parameterPushed = true; + } + break; + + case Parameter.EQUAL: + if ( constraintsArray[i][Parameter.EQUAL] != null ) { + //override parameter type + parameter.type = Parameter.STRING; + parameter.isReadOnly = true; + parameter.value = constraintsArray[i][Parameter.EQUAL]; + parameterList.push(parameter); + parameterPushed = true; + } + break; + + case Parameter.LENGTH: + if ( constraintsArray[i][Parameter.LENGTH] != null ) { + parameter.minLength = constraintsArray[i][Parameter.LENGTH]; + parameter.maxLength = constraintsArray[i][Parameter.LENGTH]; + parameterList.push(parameter); + parameterPushed = true; + } + break; + case Parameter.MAX_LENGTH: + if ( constraintsArray[i][Parameter.MAX_LENGTH] != null ) { + parameter.maxLength = constraintsArray[i][Parameter.MAX_LENGTH]; + parameterList.push(parameter); + parameterPushed = true; + } + break; + case Parameter.MIN_LENGTH: + if ( constraintsArray[i][Parameter.MIN_LENGTH] != null ) { + parameter.minLength = constraintsArray[i][Parameter.MIN_LENGTH]; + parameterList.push(parameter); + parameterPushed = true; + } + break; + case Parameter.IN_RANGE: + if ( constraintsArray[i][Parameter.IN_RANGE] != null ) { + if (constraintsArray[i][Parameter.IN_RANGE].length > 1 ) { + parameter.min = constraintsArray[i][Parameter.IN_RANGE][0]; + parameter.max = constraintsArray[i][Parameter.IN_RANGE][1]; + parameter.type = Parameter.NUMBER; + parameter.value = inputs[key][Parameter.DEFAULT]; + parameterList.push(parameter); + parameterPushed = true; + } + } + break; + case Parameter.GREATER_THAN: + if ( constraintsArray[i][Parameter.GREATER_THAN] != null ) { + parameter.type = Parameter.NUMBER; + parameter.min = constraintsArray[i][Parameter.GREATER_THAN]; + parameter.value = inputs[key][Parameter.DEFAULT]; + parameterList.push(parameter); + parameterPushed = true; + } + break; + }//switch + }//for + }//while + }//if + }; + + public static isVfModule(node:ITreeNode): boolean { + return node.data.type=='VFmodule'; + } + + public static isVnf(node:ITreeNode): boolean { + return node.data.type == ServiceNodeTypes.VF; + } + + updateDynamicInputsVnfDataFromModel(modelType: string, model: any): Array<any> { + let displayInputs; + if (modelType === ServiceNodeTypes.VFmodule) { + displayInputs = model.inputs; + } + return _.isEmpty(displayInputs) ? [] : this.getArbitraryInputs(displayInputs); + } + + isUserProvidedNaming(type: string, nodeModel: any, parentModel: any) : boolean { + let model; + if (type === ServiceNodeTypes.VFmodule) { + model = parentModel; + } + else { + model = nodeModel; + } + const ecompGeneratedNaming = model.properties.ecomp_generated_naming; + return ecompGeneratedNaming !== undefined && ecompGeneratedNaming === "false"; + } +} |