summaryrefslogtreecommitdiffstats
path: root/vid-webpack-master/src/app/services/service-planning.service.ts
diff options
context:
space:
mode:
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.ts282
1 files changed, 0 insertions, 282 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
deleted file mode 100644
index 75720c8a1..000000000
--- a/vid-webpack-master/src/app/services/service-planning.service.ts
+++ /dev/null
@@ -1,282 +0,0 @@
-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";
- }
-}