aboutsummaryrefslogtreecommitdiffstats
path: root/vid-webpack-master/src/app/shared/services/defaultDataServiceGenerator/default.data.generator.service.ts
diff options
context:
space:
mode:
Diffstat (limited to 'vid-webpack-master/src/app/shared/services/defaultDataServiceGenerator/default.data.generator.service.ts')
-rw-r--r--vid-webpack-master/src/app/shared/services/defaultDataServiceGenerator/default.data.generator.service.ts448
1 files changed, 413 insertions, 35 deletions
diff --git a/vid-webpack-master/src/app/shared/services/defaultDataServiceGenerator/default.data.generator.service.ts b/vid-webpack-master/src/app/shared/services/defaultDataServiceGenerator/default.data.generator.service.ts
index b1e676fc5..b0baa82ec 100644
--- a/vid-webpack-master/src/app/shared/services/defaultDataServiceGenerator/default.data.generator.service.ts
+++ b/vid-webpack-master/src/app/shared/services/defaultDataServiceGenerator/default.data.generator.service.ts
@@ -1,67 +1,355 @@
-import { Injectable } from '@angular/core';
+import {Injectable} from '@angular/core';
import * as _ from 'lodash';
-import { createVFModuleInstance, updateVNFInstance } from '../../../service.actions';
-import { NgRedux } from '@angular-redux/store';
-import { AppState } from '../../../store/reducers';
+
+import {NgRedux} from '@angular-redux/store';
+import {AppState} from '../../store/reducers';
+import {VnfTreeNode} from "../../models/vnfTreeNode";
+import {VfModuleInstance} from "../../models/vfModuleInstance";
+import {VfModule} from "../../models/vfModule";
+import {VfModuleTreeNode} from "../../models/vfModuleTreeNode";
+import {InputType} from "../../models/inputTypes";
+import {ServiceNodeTypes} from "../../models/ServiceNodeTypes";
+import {Constants} from "../../utils/constants";
+import {Utils} from "../../utils/utils";
+import {NetworkTreeNode} from "../../models/networkTreeNode";
+import {createVNFInstance} from "../../storeUtil/utils/vnf/vnf.actions";
+import {changeInstanceCounter} from "../../storeUtil/utils/general/general.actions";
+import {createNetworkInstance} from "../../storeUtil/utils/network/network.actions";
+import {createVFModuleInstance} from "../../storeUtil/utils/vfModule/vfModule.actions";
+import {createVnfGroupInstance} from "../../storeUtil/utils/vnfGroup/vnfGroup.actions";
+import {VnfGroupTreeNode} from "../../models/vnfGroupTreeNode";
+import {ModelInfo} from "../../models/modelInfo";
+import {ServiceInstanceActions} from "../../models/serviceInstanceActions";
+import Parameter = Constants.Parameter;
@Injectable()
export class DefaultDataGeneratorService {
static controlsFieldsStatus = {};
+ public requiredFields = {
+ VF: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
+ Network: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
+ VL: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
+ VFmodule: [],
+ VnfGroup: []
+ };
+
+ constructor(private store: NgRedux<AppState>) {
+ }
+
+ 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) {
+ 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;
+ }
+ }
+ }
+ }
+ };
+
+ updateDynamicInputsVnfDataFromModel(modelType: string, model: any): any[] {
+ let displayInputs;
+ if (modelType === ServiceNodeTypes.VFmodule) {
+ displayInputs = model.inputs;
+ }
+ return _.isEmpty(displayInputs) ? [] : this.getArbitraryInputs(displayInputs);
+ }
+
+ updateNetworksOnFirstSet(serviceId: string, formServiceValues: any){
+ const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceId];
+ if (serviceHierarchy && !_.isEmpty(serviceHierarchy.networks)) {
+ for (let networkUUID in serviceHierarchy.networks) {
+ const isEcompGeneratedNaming = this.getIsEcompGeneratedNaming(serviceHierarchy.networks[networkUUID]);
+ let min_vnf_instances_greater_than_0 = serviceHierarchy.networks[networkUUID].properties['min_instances'] && serviceHierarchy.networks[networkUUID].properties['min_instances'] > 0;
+ if(this.store.getState().global.flags['FLAG_DEFAULT_VNF'] && min_vnf_instances_greater_than_0)
+ {
+ this.createNetworkInstanceReduxIfNotExist(
+ serviceId,
+ this.generateNetworkData(serviceHierarchy, networkUUID, formServiceValues, isEcompGeneratedNaming)
+ );
+ }
+ }
+ }
+ }
- constructor(private store: NgRedux<AppState>) { }
+ updateVnfGroupsOnFirstSet(serviceId: string, formServiceValues: any){
+ const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceId];
+ if (serviceHierarchy && !_.isEmpty(serviceHierarchy.vnfGroups)) {
+ for (let vnfGroupUUID in serviceHierarchy.vnfGroups) {
+ const isEcompGeneratedNaming = this.getIsEcompGeneratedNaming(serviceHierarchy.vnfGroups[vnfGroupUUID]);
+ let min_vnf_group_instances_greater_than_0 = serviceHierarchy.vnfGroups[vnfGroupUUID].properties['min_instances'] && serviceHierarchy.vnfGroups[vnfGroupUUID].properties['min_instances'] > 0;
+ if(this.store.getState().global.flags['FLAG_DEFAULT_VNF'] && min_vnf_group_instances_greater_than_0)
+ {
+ this.createVnfGroupInstanceReduxIfNotExist(
+ serviceId,
+ this.generateVnfGroupData(serviceHierarchy, vnfGroupUUID, formServiceValues, isEcompGeneratedNaming)
+ );
+ }
+ }
+ }
+ }
updateReduxOnFirstSet(serviceId: string, formServiceValues: any): void {
+ this.updateNetworksOnFirstSet(serviceId, formServiceValues);
+ this.updateVnfGroupsOnFirstSet(serviceId, formServiceValues);
const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceId];
if (serviceHierarchy && !_.isEmpty(serviceHierarchy.vnfs)) {
for (let vnfUUID in serviceHierarchy.vnfs) {
+ const isEcompGeneratedNaming = this.getIsEcompGeneratedNaming(serviceHierarchy.vnfs[vnfUUID]);
for (let vnfModuleUUID in serviceHierarchy.vnfs[vnfUUID].vfModules) {
- if (serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID].properties.minCountInstances > 0) {
-
- let vfModule = this.generateVFModule(serviceHierarchy, vnfUUID, vnfModuleUUID);
- this.updateVNFInstanceRedux(
- serviceHierarchy.vnfs[vnfUUID].modelName,
- serviceId,
- serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID].properties.initialCount,
- vfModule,
- this.generateVNFData(serviceHierarchy, vnfUUID, vnfModuleUUID, formServiceValues),
- vnfModuleUUID
- );
+ const vfModuleModel = serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID];
+ if (vfModuleModel.properties.minCountInstances > 0) {
+ let vfModule = this.generateVFModule(vfModuleModel, this.updateDynamicInputsVnfDataFromModel(ServiceNodeTypes.VFmodule, vfModuleModel), isEcompGeneratedNaming, formServiceValues.isALaCarte);
+ if (vfModuleModel.properties.initialCount > 0) {
+ this.createVNFInstanceReduxIfNotExist(
+ serviceId,
+ this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
+ );
+
+ this.addDefaultVfModulesInRedux(
+ serviceId,
+ vfModuleModel.properties.initialCount,
+ vfModule,
+ vnfModuleUUID,
+ vnfUUID
+ )
+
+ }
}
}
+
+ let min_vnf_instances_greater_than_0 = serviceHierarchy.vnfs[vnfUUID].properties['min_instances'] && serviceHierarchy.vnfs[vnfUUID].properties['min_instances'] > 0;
+ if(this.store.getState().global.flags['FLAG_DEFAULT_VNF'] && min_vnf_instances_greater_than_0)
+ {
+ this.createVNFInstanceReduxIfNotExist(
+ serviceId,
+ this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
+ );
+ }
}
}
}
- updateVNFInstanceRedux(vnfModelName: string, serviceId: string, numberOfVfModules: number, vfModuleData: any, vnfData: any, vfModuleName : string): void {
- if (numberOfVfModules > 0) {
- this.store.dispatch(updateVNFInstance(vnfData, vnfData.modelInfo.modelCustomizationName, serviceId));
- for (let i = 0; i < numberOfVfModules; i++) {
- this.store.dispatch(createVFModuleInstance(vfModuleData, vfModuleName, serviceId));
- }
+
+ private getIsEcompGeneratedNaming(vnfJson) {
+ const ecompGeneratedNaming = vnfJson.properties.ecomp_generated_naming;
+ return ecompGeneratedNaming === "true";
+ };
+
+ createVNFInstanceReduxIfNotExist(serviceId: string, vnfData: any): void {
+ if(!this.store.getState().service.serviceInstance[serviceId].vnfs[vnfData.modelInfo.modelCustomizationName]){
+ this.store.dispatch(createVNFInstance(vnfData, vnfData.modelInfo.modelCustomizationName, serviceId));
+ this.store.dispatch(changeInstanceCounter(vnfData.modelInfo.modelUniqueId, serviceId, 1, <any> {data : {type : 'VF'}}));
+ }
+ }
+
+ createNetworkInstanceReduxIfNotExist(serviceId: string, networkData: any): void {
+ if(!this.store.getState().service.serviceInstance[serviceId].vnfs[networkData.modelInfo.modelCustomizationName]){
+ this.store.dispatch(createNetworkInstance(networkData, networkData.modelInfo.modelCustomizationName, serviceId));
+ this.store.dispatch(changeInstanceCounter(networkData.modelInfo.modelUniqueId, serviceId, 1, <any> {data : {type : 'VL'}}));
}
}
+ createVnfGroupInstanceReduxIfNotExist(serviceId: string, vnfGroupData: any): void {
+ if(!this.store.getState().service.serviceInstance[serviceId].vnfGroups[vnfGroupData.modelInfo.modelCustomizationName]){
+ this.store.dispatch(createVnfGroupInstance(vnfGroupData, vnfGroupData.modelInfo.modelCustomizationName, serviceId));
+ this.store.dispatch(changeInstanceCounter(vnfGroupData.modelInfo.modelUniqueId , serviceId, 1, <any> {data : {type : 'VnfGroup'}}));
+ }
+ }
+
+ addDefaultVfModulesInRedux(serviceId: string, numberOfVfModules: number, vfModuleData: any, vfModuleName: string, vnfUUID : string){
+ for (let i = 0; i < numberOfVfModules; i++) {
+ this.store.dispatch(createVFModuleInstance(vfModuleData, vfModuleName, serviceId, null, vnfUUID));
+ }
+ }
- generateVFModule(serviceHierarchy: any, vnfUUID: string, vnfModuleUUID: string) {
+ generateVnfGroupInstance(vnfGroupModel: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean, instanceName: string) {
+ let modelInfo = new ModelInfo(vnfGroupModel);
+ let instanceParams = {};
return {
+ 'uuid' : modelInfo.uuid,
+ 'action': ServiceInstanceActions.Create,
+ 'instanceName': (!isEcompGeneratedNaming) ? instanceName : null,
+ 'isMissingData' : false,
+ 'modelInfo': modelInfo,
+ 'rollbackOnFailure' : "true",
+ 'instanceParams': [
+ instanceParams
+ ],
+ 'trackById': DefaultDataGeneratorService.createRandomTrackById()
+ };
+ }
+
+
+ generateVFModule(vfModule: any, dynamicInputs: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean) {
+ let instanceParams = {};
+ dynamicInputs.forEach(field => {
+ instanceParams[field.id] = field.value;
+ });
+ return {
+ 'isMissingData' : this.setIsMissingData(ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNaming, isALaCarte),
'sdncPreReload': null,
'modelInfo': {
'modelType': 'VFmodule',
- 'modelInvariantId': serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID].invariantUuid,
- 'modelVersionId': serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID].uuid,
- 'modelName': serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID].name,
- 'modelVersion': serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID].version,
- 'modelCustomizationId': serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID].customizationUuid,
- 'modelCustomizationName': serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID].modelCustomizationName
+ 'modelInvariantId': vfModule.invariantUuid,
+ 'modelVersionId': vfModule.uuid,
+ 'modelName': vfModule.name,
+ 'modelVersion': vfModule.version,
+ 'modelCustomizationId': vfModule.customizationUuid,
+ 'modelCustomizationName': vfModule.modelCustomizationName,
+ 'modelUniqueId' : vfModule.customizationUuid || vfModule.uuid
},
'instanceParams': [
- {}
- ]
+ instanceParams
+ ],
+ 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
};
}
- generateVNFData(serviceHierarchy: any, vnfName: string, vnfUUID: string, formValues: any) {
+ setIsMissingData(type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean, isAlaCarte?: boolean): boolean {
+ if (isAlaCarte || !isEcompGeneratedNaming || this.requiredFields[type].length > 0) {
+ return true;
+ }
+
+ if (dynamicInputs) {
+ for(let input of dynamicInputs) {
+ if (input.isRequired && _.isEmpty(input.value)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ generateVNFData(serviceHierarchy: any, vnfName: string, formValues: any, isEcompGeneratedNaming) {
return {
+ 'uuid' : serviceHierarchy.vnfs[vnfName].uuid,
+ 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VF, [], isEcompGeneratedNaming),
'productFamilyId': formValues.productFamilyId,
'lcpCloudRegionId': null,
'tenantId': null,
@@ -73,10 +361,100 @@ export class DefaultDataGeneratorService {
'modelVersionId': formValues.modelInfo.modelVersionId,
'modelName': serviceHierarchy.vnfs[vnfName].name,
'modelVersion': serviceHierarchy.vnfs[vnfName].version,
- 'modelCustomizationId': serviceHierarchy.vnfs[vnfName].modelCustomizationId,
- 'modelCustomizationName': serviceHierarchy.vnfs[vnfName].modelCustomizationName
+ 'modelCustomizationId': serviceHierarchy.vnfs[vnfName].customizationUuid,
+ 'modelCustomizationName': serviceHierarchy.vnfs[vnfName].modelCustomizationName,
+ 'modelUniqueId' : serviceHierarchy.vnfs[vnfName].customizationUuid || serviceHierarchy.vnfs[vnfName].uuid,
},
- 'isUserProvidedNaming': null
+ 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
}
}
+
+ generateNetworkData(serviceHierarchy: any, networkName: string, formValues: any, isEcompGeneratedNaming) {
+ return {
+ 'uuid' : serviceHierarchy.network[networkName].uuid,
+ 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VL, [], isEcompGeneratedNaming),
+ 'productFamilyId': formValues.productFamilyId,
+ 'lcpCloudRegionId': null,
+ 'tenantId': null,
+ 'lineOfBusiness': null,
+ 'platformName': null,
+ 'modelInfo': {
+ 'modelType': 'VF',
+ 'modelInvariantId': serviceHierarchy.network[networkName].invariantUuid,
+ 'modelVersionId': formValues.modelInfo.modelVersionId,
+ 'modelName': serviceHierarchy.network[networkName].name,
+ 'modelVersion': serviceHierarchy.network[networkName].version,
+ 'modelCustomizationId': serviceHierarchy.network[networkName].modelCustomizationId,
+ 'modelCustomizationName': serviceHierarchy.network[networkName].modelCustomizationName,
+ 'modelUniqueId' : serviceHierarchy.network[networkName].modelCustomizationId || serviceHierarchy.network[networkName].uuid,
+ },
+ 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
+ }
+ }
+
+ generateVnfGroupData(serviceHierarchy: any, vnfGroupName: string, formValues: any, isEcompGeneratedNaming) {
+ return {
+ 'uuid' : serviceHierarchy.vnfGroups[vnfGroupName].uuid,
+ 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VnfGroup, [], isEcompGeneratedNaming),
+ 'platformName': null,
+ 'modelInfo': {
+ 'modelType': 'VnfGroup',
+ 'modelInvariantId': serviceHierarchy.vnfGroups[vnfGroupName].invariantUuid,
+ 'modelVersionId': formValues.modelInfo.modelVersionId,
+ 'modelName': serviceHierarchy.vnfGroups[vnfGroupName].name,
+ 'modelVersion': serviceHierarchy.vnfGroups[vnfGroupName].version,
+ 'modelCustomizationId': serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationId,
+ 'modelCustomizationName': serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationName,
+ 'modelUniqueId' : serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationId || serviceHierarchy.vnfGroups[vnfGroupName].uuid,
+
+ },
+ 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
+ }
+ }
+
+
+ static createRandomTrackById() {
+ return Math.random().toString(36).slice(2);
+ }
+
+ private checkMissingData(instance, type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean): boolean {
+ if (!isEcompGeneratedNaming && _.isEmpty(instance.instanceName)) {
+ return true;
+ }
+
+ for (let field of this.requiredFields[type]) {
+ 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;
+ }
+
+ createNewTreeNode(instance: any, model: any, storeKey : string, type : string): VnfTreeNode {
+ let tmp = null;
+ if(type === 'vnfs') {
+ tmp = new VnfTreeNode(instance, model, storeKey);
+ }else if (type === 'vnfGroups') {
+ tmp = new VnfGroupTreeNode(instance, model, storeKey);
+ }else {
+ tmp = new NetworkTreeNode(instance, model, storeKey);
+ }
+ tmp.missingData = this.checkMissingData(instance, ServiceNodeTypes.VF, [], model.isEcompGeneratedNaming);
+
+ return tmp;
+ }
+
+ createNewVfModuleTreeNode(instance: VfModuleInstance, vfModuleModel: VfModule, vfModuleModelName: string, isEcompGeneratedNamig: boolean, dynamicInputs, dynamicModelName :string): VfModuleTreeNode {
+ let newVfModule: VfModuleTreeNode = new VfModuleTreeNode(instance, vfModuleModel, vfModuleModelName, dynamicInputs, isEcompGeneratedNamig, dynamicModelName);
+ newVfModule.missingData = this.checkMissingData(instance, ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNamig);
+ return newVfModule;
+ }
+
}