1 import {Injectable} from '@angular/core';
2 import * as _ from 'lodash';
3 import {NgRedux} from '@angular-redux/store';
4 import {AppState} from '../../store/reducers';
5 import {VnfTreeNode} from "../../models/vnfTreeNode";
6 import {VfModuleInstance} from "../../models/vfModuleInstance";
7 import {VfModule} from "../../models/vfModule";
8 import {VfModuleTreeNode} from "../../models/vfModuleTreeNode";
9 import {InputType} from "../../models/inputTypes";
10 import {ServiceNodeTypes} from "../../models/ServiceNodeTypes";
11 import {Constants} from "../../utils/constants";
12 import {Utils} from "../../utils/utils";
13 import {NetworkTreeNode} from "../../models/networkTreeNode";
14 import {createVNFInstance} from "../../storeUtil/utils/vnf/vnf.actions";
15 import {changeInstanceCounter} from "../../storeUtil/utils/general/general.actions";
16 import {createNetworkInstance} from "../../storeUtil/utils/network/network.actions";
17 import {createVFModuleInstance, updateVFModulePosition} from "../../storeUtil/utils/vfModule/vfModule.actions";
18 import {createVnfGroupInstance} from "../../storeUtil/utils/vnfGroup/vnfGroup.actions";
19 import {VnfGroupTreeNode} from "../../models/vnfGroupTreeNode";
20 import {ModelInfo} from "../../models/modelInfo";
21 import {ServiceInstanceActions} from "../../models/serviceInstanceActions";
22 import Parameter = Constants.Parameter;
23 import {createPNFInstance} from "../../storeUtil/utils/pnf/pnf.actions";
24 import {FeatureFlagsService, Features} from "../featureFlag/feature-flags.service";
27 export class DefaultDataGeneratorService {
28 static controlsFieldsStatus = {};
29 public requiredFields = {
30 VF: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
31 PNF: [InputType.PLATFORM],
32 Network: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
33 VL: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
38 constructor(private store: NgRedux<AppState>) {
41 public getArbitraryInputs(inputs) {
43 let parameterList = [];
44 for (let key in inputs) {
47 type: Parameter.STRING,
49 value: inputs[key][Parameter.DEFAULT],
50 isRequired: inputs[key][Parameter.REQUIRED],
51 description: inputs[key][Parameter.DESCRIPTION]
53 switch (inputs[key][Parameter.TYPE]) {
54 case Parameter.INTEGER:
55 parameter.type = Parameter.NUMBER;
57 case Parameter.BOOLEAN:
58 parameter.type = Parameter.BOOLEAN;
63 parameter.type = Parameter.LIST;
66 parameter.type = Parameter.MAP;
69 if (Utils.hasContents(inputs[key][Parameter.CONSTRAINTS])
70 && (inputs[key][Parameter.CONSTRAINTS].length > 0)) {
71 let constraintsArray = inputs[key][Parameter.CONSTRAINTS];
72 this.addConstraintParameters(parameterList, constraintsArray, key, inputs, parameter);
75 parameterList.push(parameter);
81 private addConstraintParameters(parameterList, constraintsArray, key, inputs, parameter) {
82 // If there are constraints and the operator is "valid_values",
83 // use a select parameter type.
84 let i: number = constraintsArray.length;
85 let parameterPushed: boolean = false;
87 while ((i--) && (!parameterPushed)) {
88 let keys = Object.keys(constraintsArray[i]);
89 for (let operator in keys) {
90 switch (keys[operator]) {
91 case Parameter.VALID_VALUES:
92 let j: number = constraintsArray[i][Parameter.VALID_VALUES].length;
98 name: constraintsArray[i][Parameter.VALID_VALUES][j],
101 if ((Utils.hasContents(inputs[key][Parameter.DEFAULT]))
102 && (inputs[key][Parameter.DEFAULT] === constraintsArray[i][Parameter.VALID_VALUES][j])) {
104 name: constraintsArray[i][Parameter.VALID_VALUES][j],
110 parameter.type = Parameter.SELECT;
111 parameter.optionList = oList;
112 parameterList.push(parameter);
113 parameterPushed = true;
117 case Parameter.EQUAL:
118 if (constraintsArray[i][Parameter.EQUAL] != null) {
119 parameter.type = Parameter.STRING;
120 parameter.isReadOnly = true;
121 parameter.value = constraintsArray[i][Parameter.EQUAL];
122 parameterList.push(parameter);
123 parameterPushed = true;
127 case Parameter.LENGTH:
128 if (constraintsArray[i][Parameter.LENGTH] != null) {
129 parameter.minLength = constraintsArray[i][Parameter.LENGTH];
130 parameter.maxLength = constraintsArray[i][Parameter.LENGTH];
131 parameterList.push(parameter);
132 parameterPushed = true;
135 case Parameter.MAX_LENGTH:
136 if (constraintsArray[i][Parameter.MAX_LENGTH] != null) {
137 parameter.maxLength = constraintsArray[i][Parameter.MAX_LENGTH];
138 parameterList.push(parameter);
139 parameterPushed = true;
142 case Parameter.MIN_LENGTH:
143 if (constraintsArray[i][Parameter.MIN_LENGTH] != null) {
144 parameter.minLength = constraintsArray[i][Parameter.MIN_LENGTH];
145 parameterList.push(parameter);
146 parameterPushed = true;
149 case Parameter.IN_RANGE:
150 if (constraintsArray[i][Parameter.IN_RANGE] != null) {
151 if (constraintsArray[i][Parameter.IN_RANGE].length > 1) {
152 parameter.min = constraintsArray[i][Parameter.IN_RANGE][0];
153 parameter.max = constraintsArray[i][Parameter.IN_RANGE][1];
154 parameter.type = Parameter.NUMBER;
155 parameter.value = inputs[key][Parameter.DEFAULT];
156 parameterList.push(parameter);
157 parameterPushed = true;
161 case Parameter.GREATER_THAN:
162 if (constraintsArray[i][Parameter.GREATER_THAN] != null) {
163 parameter.type = Parameter.NUMBER;
164 parameter.min = constraintsArray[i][Parameter.GREATER_THAN];
165 parameter.value = inputs[key][Parameter.DEFAULT];
166 parameterList.push(parameter);
167 parameterPushed = true;
176 updateDynamicInputsVnfDataFromModel(modelType: string, model: any): any[] {
178 if (modelType === ServiceNodeTypes.VFmodule) {
179 displayInputs = model.inputs;
181 return _.isEmpty(displayInputs) ? [] : this.getArbitraryInputs(displayInputs);
184 updateNetworksOnFirstSet(serviceId: string, formServiceValues: any) {
185 const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceId];
186 if (serviceHierarchy && !_.isEmpty(serviceHierarchy.networks)) {
187 for (let networkUUID in serviceHierarchy.networks) {
188 const isEcompGeneratedNaming = this.getIsEcompGeneratedNaming(serviceHierarchy.networks[networkUUID]);
189 let min_vnf_instances_greater_than_0 = serviceHierarchy.networks[networkUUID].properties['min_instances'] && serviceHierarchy.networks[networkUUID].properties['min_instances'] > 0;
190 if (min_vnf_instances_greater_than_0) {
191 this.createNetworkInstanceReduxIfNotExist(
193 this.generateNetworkData(serviceHierarchy, networkUUID, formServiceValues, isEcompGeneratedNaming)
200 updateVnfGroupsOnFirstSet(serviceId: string, formServiceValues: any) {
201 const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceId];
202 if (serviceHierarchy && !_.isEmpty(serviceHierarchy.vnfGroups)) {
203 for (let vnfGroupUUID in serviceHierarchy.vnfGroups) {
204 const isEcompGeneratedNaming = this.getIsEcompGeneratedNaming(serviceHierarchy.vnfGroups[vnfGroupUUID]);
205 let min_vnf_group_instances_greater_than_0 = serviceHierarchy.vnfGroups[vnfGroupUUID].properties['min_instances'] && serviceHierarchy.vnfGroups[vnfGroupUUID].properties['min_instances'] > 0;
206 if (min_vnf_group_instances_greater_than_0) {
207 this.createVnfGroupInstanceReduxIfNotExist(
209 this.generateVnfGroupData(serviceHierarchy, vnfGroupUUID, formServiceValues, isEcompGeneratedNaming)
216 updatePnfsOnFirstSet(serviceId: string, formServiceValues: any) {
217 const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceId];
218 if (serviceHierarchy && !_.isEmpty(serviceHierarchy.pnfs)) {
219 for (let pnfUUID in serviceHierarchy.pnfs) {
220 if (this.isMinInstancesGreaterThanZero(serviceHierarchy, pnfUUID) && this.isExtendedMacroPnfConfigOn()) {
221 this.createPNFInstanceReduxIfNotExist(
223 this.generatePNFData(
227 this.getIsEcompGeneratedNaming(serviceHierarchy.pnfs[pnfUUID])
235 isExtendedMacroPnfConfigOn(): boolean {
236 return FeatureFlagsService.getFlagState(Features.FLAG_EXTENDED_MACRO_PNF_CONFIG, this.store)
239 isMinInstancesGreaterThanZero(serviceHierarchy, pnfUUID): boolean {
240 return serviceHierarchy.pnfs[pnfUUID].properties['min_instances']
241 && serviceHierarchy.pnfs[pnfUUID].properties['min_instances'] > 0;
244 updateReduxOnFirstSet(serviceId: string, formServiceValues: any): void {
245 this.updateNetworksOnFirstSet(serviceId, formServiceValues);
246 this.updateVnfGroupsOnFirstSet(serviceId, formServiceValues);
247 this.updatePnfsOnFirstSet(serviceId, formServiceValues);
248 const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceId];
249 if (serviceHierarchy && !_.isEmpty(serviceHierarchy.vnfs)) {
250 for (let vnfUUID in serviceHierarchy.vnfs) {
251 const isEcompGeneratedNaming = this.getIsEcompGeneratedNaming(serviceHierarchy.vnfs[vnfUUID]);
252 for (let vnfModuleUUID in serviceHierarchy.vnfs[vnfUUID].vfModules) {
253 const vfModuleModel = serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID];
254 if (vfModuleModel.properties.minCountInstances > 0) {
255 let vfModule = this.generateVFModule(vfModuleModel, this.updateDynamicInputsVnfDataFromModel(ServiceNodeTypes.VFmodule, vfModuleModel), isEcompGeneratedNaming, formServiceValues.isALaCarte);
256 if (vfModuleModel.properties.initialCount > 0) {
257 this.createVNFInstanceReduxIfNotExist(
259 this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
262 this.addDefaultVfModulesInRedux(
264 vfModuleModel.properties.initialCount,
265 vfModuleModel.properties.baseModule,
275 let min_vnf_instances_greater_than_0 = serviceHierarchy.vnfs[vnfUUID].properties['min_instances'] && serviceHierarchy.vnfs[vnfUUID].properties['min_instances'] > 0;
276 if (min_vnf_instances_greater_than_0) {
277 this.createVNFInstanceReduxIfNotExist(
279 this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
286 private getIsEcompGeneratedNaming(vnfJson) {
287 const ecompGeneratedNaming = vnfJson.properties.ecomp_generated_naming;
288 return ecompGeneratedNaming === "true";
291 createVNFInstanceReduxIfNotExist(serviceId: string, vnfData: any): void {
292 if(!this.store.getState().service.serviceInstance[serviceId].vnfs[vnfData.modelInfo.modelCustomizationName]){
293 this.store.dispatch(createVNFInstance(vnfData, vnfData.modelInfo.modelCustomizationName, serviceId));
294 this.store.dispatch(changeInstanceCounter(vnfData.modelInfo.modelUniqueId, serviceId, 1, <any> {data : {type : 'VF'}}));
298 createPNFInstanceReduxIfNotExist(serviceId: string, pnfData: any): void {
299 if(!this.store.getState().service.serviceInstance[serviceId].pnfs[pnfData.modelInfo.modelCustomizationName]){
300 this.store.dispatch(createPNFInstance(pnfData, pnfData.modelInfo.modelCustomizationName, serviceId));
301 this.store.dispatch(changeInstanceCounter(pnfData.modelInfo.modelUniqueId, serviceId, 1, <any> {data : {type : 'PNF'}}));
305 createNetworkInstanceReduxIfNotExist(serviceId: string, networkData: any): void {
306 if(!this.store.getState().service.serviceInstance[serviceId].vnfs[networkData.modelInfo.modelCustomizationName]){
307 this.store.dispatch(createNetworkInstance(networkData, networkData.modelInfo.modelCustomizationName, serviceId));
308 this.store.dispatch(changeInstanceCounter(networkData.modelInfo.modelUniqueId, serviceId, 1, <any> {data : {type : 'VL'}}));
312 createVnfGroupInstanceReduxIfNotExist(serviceId: string, vnfGroupData: any): void {
313 if(!this.store.getState().service.serviceInstance[serviceId].vnfGroups[vnfGroupData.modelInfo.modelCustomizationName]){
314 this.store.dispatch(createVnfGroupInstance(vnfGroupData, vnfGroupData.modelInfo.modelCustomizationName, serviceId));
315 this.store.dispatch(changeInstanceCounter(vnfGroupData.modelInfo.modelUniqueId , serviceId, 1, <any> {data : {type : 'VnfGroup'}}));
319 addDefaultVfModulesInRedux(serviceId: string, numberOfVfModules: number,baseModule:boolean, vfModuleData: any, vfModuleName: string, vnfUUID : string){
320 for (let i = 0; i < numberOfVfModules; i++) {
322 this.store.dispatch(createVFModuleInstance(vfModuleData, vfModuleName, serviceId, 1, vnfUUID));
324 this.store.dispatch(createVFModuleInstance(vfModuleData, vfModuleName, serviceId, i+1, vnfUUID));
330 generateVnfGroupInstance(vnfGroupModel: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean, instanceName: string) {
331 let modelInfo = new ModelInfo(vnfGroupModel);
332 let instanceParams = {};
334 'uuid' : modelInfo.uuid,
335 'action': ServiceInstanceActions.Create,
336 'instanceName': (!isEcompGeneratedNaming) ? instanceName : null,
337 'isMissingData' : false,
338 'modelInfo': modelInfo,
339 'rollbackOnFailure' : "true",
343 'trackById': DefaultDataGeneratorService.createRandomTrackById()
348 generateVFModule(vfModule: any, dynamicInputs: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean) {
349 let instanceParams = {};
350 dynamicInputs.forEach(field => {
351 instanceParams[field.id] = field.value;
354 'isMissingData' : this.setIsMissingData(ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNaming, isALaCarte),
355 'sdncPreReload': null,
357 'modelType': 'VFmodule',
358 'modelInvariantId': vfModule.invariantUuid,
359 'modelVersionId': vfModule.uuid,
360 'modelName': vfModule.name,
361 'modelVersion': vfModule.version,
362 'modelCustomizationId': vfModule.customizationUuid,
363 'modelCustomizationName': vfModule.modelCustomizationName,
364 'modelUniqueId' : vfModule.customizationUuid || vfModule.uuid
369 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
370 'rollbackOnFailure' : isALaCarte ? true : null,
371 'position': vfModule.position
376 setIsMissingData(type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean, isAlaCarte?: boolean): boolean {
377 if (isAlaCarte || !isEcompGeneratedNaming || this.requiredFields[type].length > 0) {
382 for(let input of dynamicInputs) {
383 if (input.isRequired && _.isEmpty(input.value)) {
391 generateVNFData(serviceHierarchy: any, vnfName: string, formValues: any, isEcompGeneratedNaming) {
393 'uuid' : serviceHierarchy.vnfs[vnfName].uuid,
394 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VF, [], isEcompGeneratedNaming),
395 'productFamilyId': formValues.productFamilyId,
396 'lcpCloudRegionId': null,
398 'lineOfBusiness': null,
399 'platformName': null,
402 'modelInvariantId': serviceHierarchy.vnfs[vnfName].invariantUuid,
403 'modelVersionId': serviceHierarchy.vnfs[vnfName].uuid,
404 'modelName': serviceHierarchy.vnfs[vnfName].name,
405 'modelVersion': serviceHierarchy.vnfs[vnfName].version,
406 'modelCustomizationId': serviceHierarchy.vnfs[vnfName].customizationUuid,
407 'modelCustomizationName': serviceHierarchy.vnfs[vnfName].modelCustomizationName,
408 'modelUniqueId' : serviceHierarchy.vnfs[vnfName].customizationUuid || serviceHierarchy.vnfs[vnfName].uuid,
410 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
414 generatePNFData(serviceHierarchy: any, pnfName: string, formValues: any, isEcompGeneratedNaming) {
416 'uuid' : serviceHierarchy.pnfs[pnfName].uuid,
417 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.PNF, [], isEcompGeneratedNaming),
418 'productFamilyId': formValues.productFamilyId,
419 'lcpCloudRegionId': null,
421 'lineOfBusiness': null,
422 'platformName': null,
425 'modelInvariantId': serviceHierarchy.pnfs[pnfName].invariantUuid,
426 'modelVersionId': serviceHierarchy.pnfs[pnfName].uuid,
427 'modelName': serviceHierarchy.pnfs[pnfName].name,
428 'modelVersion': serviceHierarchy.pnfs[pnfName].version,
429 'modelCustomizationId': serviceHierarchy.pnfs[pnfName].customizationUuid,
430 'modelCustomizationName': serviceHierarchy.pnfs[pnfName].modelCustomizationName,
431 'modelUniqueId' : serviceHierarchy.pnfs[pnfName].customizationUuid || serviceHierarchy.pnfs[pnfName].uuid,
433 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
437 generateNetworkData(serviceHierarchy: any, networkName: string, formValues: any, isEcompGeneratedNaming) {
439 'uuid' : serviceHierarchy.network[networkName].uuid,
440 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VL, [], isEcompGeneratedNaming),
441 'productFamilyId': formValues.productFamilyId,
442 'lcpCloudRegionId': null,
444 'lineOfBusiness': null,
445 'platformName': null,
448 'modelInvariantId': serviceHierarchy.network[networkName].invariantUuid,
449 'modelVersionId': serviceHierarchy.network[networkName].uuid,
450 'modelName': serviceHierarchy.network[networkName].name,
451 'modelVersion': serviceHierarchy.network[networkName].version,
452 'modelCustomizationId': serviceHierarchy.network[networkName].modelCustomizationId,
453 'modelCustomizationName': serviceHierarchy.network[networkName].modelCustomizationName,
454 'modelUniqueId' : serviceHierarchy.network[networkName].modelCustomizationId || serviceHierarchy.network[networkName].uuid,
456 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
460 generateVnfGroupData(serviceHierarchy: any, vnfGroupName: string, formValues: any, isEcompGeneratedNaming) {
462 'uuid' : serviceHierarchy.vnfGroups[vnfGroupName].uuid,
463 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VnfGroup, [], isEcompGeneratedNaming),
464 'platformName': null,
466 'modelType': 'VnfGroup',
467 'modelInvariantId': serviceHierarchy.vnfGroups[vnfGroupName].invariantUuid,
468 'modelVersionId': serviceHierarchy.vnfGroups[vnfGroupName].uuid,
469 'modelName': serviceHierarchy.vnfGroups[vnfGroupName].name,
470 'modelVersion': serviceHierarchy.vnfGroups[vnfGroupName].version,
471 'modelCustomizationId': serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationId,
472 'modelCustomizationName': serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationName,
473 'modelUniqueId' : serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationId || serviceHierarchy.vnfGroups[vnfGroupName].uuid,
476 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
481 static createRandomTrackById() {
482 return Math.random().toString(36).slice(2);
485 private checkMissingData(instance, type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean): boolean {
486 if (!isEcompGeneratedNaming && _.isEmpty(instance.instanceName)) {
490 for (let field of this.requiredFields[type]) {
491 if (_.isEmpty(instance[field])) {
496 for (let field of dynamicInputs) {
497 if (field.isRequired && !_.isNil(instance.instanceParams) && _.isEmpty(instance.instanceParams[0][field.id])) {
505 createNewTreeNode(instance: any, model: any, storeKey : string, type : string): VnfTreeNode {
507 if(type === 'vnfs') {
508 tmp = new VnfTreeNode(instance, model, storeKey);
509 }else if (type === 'vnfGroups') {
510 tmp = new VnfGroupTreeNode(instance, model, storeKey);
512 tmp = new NetworkTreeNode(instance, model, storeKey);
514 tmp.missingData = this.checkMissingData(instance, ServiceNodeTypes.VF, [], model.isEcompGeneratedNaming);
519 createNewVfModuleTreeNode(instance: VfModuleInstance, vfModuleModel: VfModule, vfModuleModelName: string, isEcompGeneratedNamig: boolean, dynamicInputs, dynamicModelName :string): VfModuleTreeNode {
520 let newVfModule: VfModuleTreeNode = new VfModuleTreeNode(instance, vfModuleModel, vfModuleModelName, dynamicInputs, isEcompGeneratedNamig, dynamicModelName);
521 newVfModule.missingData = this.checkMissingData(instance, ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNamig);
525 calculatePositionOfVfmodule(serviceModelId:string) {
526 const serviceInstance = this.store.getState().service.serviceInstance[serviceModelId];
527 const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceModelId];
529 const vnfList = serviceInstance.vnfs;
530 let totalSecondListLength =1;
531 if (!_.isEmpty(vnfList)) {
532 for (let vnfStoreKey in vnfList) {
533 const firstVfModuleInstanceList = vnfList[vnfStoreKey].vfModules;
534 if (!_.isEmpty(firstVfModuleInstanceList)) {
535 for (let vfModuleInstanceKey in firstVfModuleInstanceList) {
536 let secondVfModuleInstanceList = firstVfModuleInstanceList[vfModuleInstanceKey];
537 let numSecondVfModuleInstanceList = Object.keys(secondVfModuleInstanceList).length;
538 totalSecondListLength = totalSecondListLength + numSecondVfModuleInstanceList;
542 //No instances added yet , hence start from 1
543 totalSecondListLength = 1;
549 return totalSecondListLength;
553 updatePositionForRemainingVfModules(serviceModelId: string) {
555 const serviceInstance = this.store.getState().service.serviceInstance[serviceModelId];
556 const vnfList = serviceInstance.vnfs;
557 if (!_.isEmpty(vnfList)) {
558 for (let vnfStoreKey in vnfList) {
559 const firstVfModuleInstanceList = vnfList[vnfStoreKey].vfModules;
560 if (!_.isEmpty(firstVfModuleInstanceList)) {
561 for (let vfModuleInstanceKey in firstVfModuleInstanceList) {
562 let secondVfModuleInstanceList = firstVfModuleInstanceList[vfModuleInstanceKey];
563 for(let secondVfModuleInstanceKey in secondVfModuleInstanceList) {
564 let secondVfModuleObj = secondVfModuleInstanceList[secondVfModuleInstanceKey];
565 if(!_.isNil(secondVfModuleObj.position)) {
566 this.store.dispatch(updateVFModulePosition(vfModuleInstanceKey,secondVfModuleInstanceKey, secondVfModuleObj.position+1,serviceModelId, vnfStoreKey));