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, 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";
+ }
+}