vid-webpack-master/src/app/shared/services/defaultDataServiceGenerator/default.data.generator.service.ts

   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";
  25
  26 @Injectable()
  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],
  34     VFmodule: [],
  35     VnfGroup: []
  36   };
  37
  38   constructor(private store: NgRedux<AppState>) {
  39   }
  40
  41   public getArbitraryInputs(inputs) {
  42     let parameter;
  43     let parameterList = [];
  44     for (let key in inputs) {
  45       parameter = {
  46         id: key,
  47         type: Parameter.STRING,
  48         name: key,
  49         value: inputs[key][Parameter.DEFAULT],
  50         isRequired: inputs[key][Parameter.REQUIRED],
  51         description: inputs[key][Parameter.DESCRIPTION]
  52       };
  53       switch (inputs[key][Parameter.TYPE]) {
  54         case Parameter.INTEGER:
  55           parameter.type = Parameter.NUMBER;
  56           break;
  57         case Parameter.BOOLEAN:
  58           parameter.type = Parameter.BOOLEAN;
  59           break;
  60         case Parameter.RANGE:
  61           break;
  62         case Parameter.LIST:
  63           parameter.type = Parameter.LIST;
  64           break;
  65         case Parameter.MAP:
  66           parameter.type = Parameter.MAP;
  67           break;
  68       }
  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);
  73       } else {
  74
  75         parameterList.push(parameter);
  76       }
  77     }
  78     return parameterList;
  79   }
  80
  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;
  86     if (i > 0) {
  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;
  93               if (j > 0) {
  94                 let oList = [];
  95                 let option;
  96                 while (j--) {
  97                   option = {
  98                     name: constraintsArray[i][Parameter.VALID_VALUES][j],
  99                     isDefault: false
 100                   };
 101                   if ((Utils.hasContents(inputs[key][Parameter.DEFAULT]))
 102                     && (inputs[key][Parameter.DEFAULT] === constraintsArray[i][Parameter.VALID_VALUES][j])) {
 103                     option = {
 104                       name: constraintsArray[i][Parameter.VALID_VALUES][j],
 105                       isDefault: true
 106                     }
 107                   }
 108                   oList.push(option);
 109                 }
 110                 parameter.type = Parameter.SELECT;
 111                 parameter.optionList = oList;
 112                 parameterList.push(parameter);
 113                 parameterPushed = true;
 114               }
 115               break;
 116
 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;
 124               }
 125               break;
 126
 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;
 133               }
 134               break;
 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;
 140               }
 141               break;
 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;
 147               }
 148               break;
 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;
 158                 }
 159               }
 160               break;
 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;
 168               }
 169               break;
 170           }
 171         }
 172       }
 173     }
 174   };
 175
 176   updateDynamicInputsVnfDataFromModel(modelType: string, model: any): any[] {
 177     let displayInputs;
 178     if (modelType === ServiceNodeTypes.VFmodule) {
 179       displayInputs = model.inputs;
 180     }
 181     return _.isEmpty(displayInputs) ? [] : this.getArbitraryInputs(displayInputs);
 182   }
 183
 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(
 192             serviceId,
 193             this.generateNetworkData(serviceHierarchy, networkUUID, formServiceValues, isEcompGeneratedNaming)
 194           );
 195         }
 196       }
 197     }
 198   }
 199
 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(
 208             serviceId,
 209             this.generateVnfGroupData(serviceHierarchy, vnfGroupUUID, formServiceValues, isEcompGeneratedNaming)
 210           );
 211         }
 212       }
 213     }
 214   }
 215
 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(
 222             serviceId,
 223             this.generatePNFData(
 224               serviceHierarchy,
 225               pnfUUID,
 226               formServiceValues,
 227               this.getIsEcompGeneratedNaming(serviceHierarchy.pnfs[pnfUUID])
 228             )
 229           );
 230         }
 231       }
 232     }
 233   }
 234
 235   isExtendedMacroPnfConfigOn(): boolean {
 236     return FeatureFlagsService.getFlagState(Features.FLAG_EXTENDED_MACRO_PNF_CONFIG, this.store)
 237   }
 238
 239   isMinInstancesGreaterThanZero(serviceHierarchy, pnfUUID): boolean {
 240     return serviceHierarchy.pnfs[pnfUUID].properties['min_instances']
 241       && serviceHierarchy.pnfs[pnfUUID].properties['min_instances'] > 0;
 242   }
 243
 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(
 258                 serviceId,
 259                 this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
 260               );
 261
 262               this.addDefaultVfModulesInRedux(
 263                 serviceId,
 264                 vfModuleModel.properties.initialCount,
 265                 vfModuleModel.properties.baseModule,
 266                 vfModule,
 267                 vnfModuleUUID,
 268                 vnfUUID
 269               )
 270
 271             }
 272           }
 273         }
 274
 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(
 278             serviceId,
 279             this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
 280           );
 281         }
 282       }
 283     }
 284   }
 285
 286   private getIsEcompGeneratedNaming(vnfJson) {
 287     const ecompGeneratedNaming = vnfJson.properties.ecomp_generated_naming;
 288     return ecompGeneratedNaming === "true";
 289   };
 290
 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'}}));
 295     }
 296   }
 297
 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'}}));
 302     }
 303   }
 304
 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'}}));
 309     }
 310   }
 311
 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'}}));
 316     }
 317   }
 318
 319   addDefaultVfModulesInRedux(serviceId: string, numberOfVfModules: number,baseModule:boolean, vfModuleData: any, vfModuleName: string, vnfUUID : string){
 320     for (let i = 0; i < numberOfVfModules; i++) {
 321       if(baseModule) {
 322         this.store.dispatch(createVFModuleInstance(vfModuleData, vfModuleName, serviceId, 1, vnfUUID));
 323       } else {
 324         this.store.dispatch(createVFModuleInstance(vfModuleData, vfModuleName, serviceId, i+1, vnfUUID));
 325       }
 326
 327     }
 328   }
 329
 330   generateVnfGroupInstance(vnfGroupModel: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean, instanceName: string) {
 331     let modelInfo = new ModelInfo(vnfGroupModel);
 332     let instanceParams = {};
 333     return {
 334       'uuid' : modelInfo.uuid,
 335       'action': ServiceInstanceActions.Create,
 336       'instanceName': (!isEcompGeneratedNaming) ? instanceName : null,
 337       'isMissingData' : false,
 338       'modelInfo': modelInfo,
 339       'rollbackOnFailure' : "true",
 340       'instanceParams': [
 341         instanceParams
 342       ],
 343       'trackById': DefaultDataGeneratorService.createRandomTrackById()
 344     };
 345   }
 346
 347
 348   generateVFModule(vfModule: any, dynamicInputs: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean) {
 349     let instanceParams = {};
 350     dynamicInputs.forEach(field => {
 351       instanceParams[field.id] = field.value;
 352     });
 353     return {
 354       'isMissingData' : this.setIsMissingData(ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNaming, isALaCarte),
 355       'sdncPreReload': null,
 356       'modelInfo': {
 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
 365       },
 366       'instanceParams': [
 367         instanceParams
 368       ],
 369       'trackById': DefaultDataGeneratorService.createRandomTrackById(),
 370       'rollbackOnFailure' : isALaCarte ? true : null,
 371       'position': vfModule.position
 372
 373     };
 374   }
 375
 376   setIsMissingData(type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean, isAlaCarte?: boolean): boolean {
 377     if (isAlaCarte || !isEcompGeneratedNaming || this.requiredFields[type].length > 0) {
 378       return true;
 379     }
 380
 381     if (dynamicInputs) {
 382       for(let input of dynamicInputs) {
 383         if (input.isRequired && _.isEmpty(input.value)) {
 384           return true;
 385         }
 386       }
 387     }
 388     return false;
 389   }
 390
 391   generateVNFData(serviceHierarchy: any, vnfName: string, formValues: any, isEcompGeneratedNaming) {
 392     return {
 393       'uuid' : serviceHierarchy.vnfs[vnfName].uuid,
 394       'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VF, [], isEcompGeneratedNaming),
 395       'productFamilyId': formValues.productFamilyId,
 396       'lcpCloudRegionId': null,
 397       'tenantId': null,
 398       'lineOfBusiness': null,
 399       'platformName': null,
 400       'modelInfo': {
 401         'modelType': 'VF',
 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,
 409       },
 410       'trackById': DefaultDataGeneratorService.createRandomTrackById(),
 411     }
 412   }
 413
 414   generatePNFData(serviceHierarchy: any, pnfName: string, formValues: any, isEcompGeneratedNaming) {
 415     return {
 416       'uuid' : serviceHierarchy.pnfs[pnfName].uuid,
 417       'isMissingData' :this.setIsMissingData(ServiceNodeTypes.PNF, [], isEcompGeneratedNaming),
 418       'productFamilyId': formValues.productFamilyId,
 419       'lcpCloudRegionId': null,
 420       'tenantId': null,
 421       'lineOfBusiness': null,
 422       'platformName': null,
 423       'modelInfo': {
 424         'modelType': 'PNF',
 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,
 432       },
 433       'trackById': DefaultDataGeneratorService.createRandomTrackById(),
 434     }
 435   }
 436
 437   generateNetworkData(serviceHierarchy: any, networkName: string, formValues: any, isEcompGeneratedNaming) {
 438       return {
 439         'uuid' : serviceHierarchy.network[networkName].uuid,
 440         'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VL, [], isEcompGeneratedNaming),
 441         'productFamilyId': formValues.productFamilyId,
 442         'lcpCloudRegionId': null,
 443         'tenantId': null,
 444         'lineOfBusiness': null,
 445         'platformName': null,
 446         'modelInfo': {
 447           'modelType': 'VF',
 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,
 455         },
 456         'trackById': DefaultDataGeneratorService.createRandomTrackById(),
 457       }
 458     }
 459
 460   generateVnfGroupData(serviceHierarchy: any, vnfGroupName: string, formValues: any, isEcompGeneratedNaming) {
 461     return {
 462       'uuid' : serviceHierarchy.vnfGroups[vnfGroupName].uuid,
 463       'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VnfGroup, [], isEcompGeneratedNaming),
 464       'platformName': null,
 465       'modelInfo': {
 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,
 474
 475       },
 476       'trackById': DefaultDataGeneratorService.createRandomTrackById(),
 477     }
 478   }
 479
 480
 481   static createRandomTrackById() {
 482     return Math.random().toString(36).slice(2);
 483   }
 484
 485   private checkMissingData(instance, type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean): boolean {
 486     if (!isEcompGeneratedNaming && _.isEmpty(instance.instanceName)) {
 487       return true;
 488     }
 489
 490     for (let field of this.requiredFields[type]) {
 491       if (_.isEmpty(instance[field])) {
 492         return true;
 493       }
 494     }
 495
 496     for (let field of dynamicInputs) {
 497       if (field.isRequired && !_.isNil(instance.instanceParams) && _.isEmpty(instance.instanceParams[0][field.id])) {
 498         return true;
 499       }
 500     }
 501
 502     return false;
 503   }
 504
 505   createNewTreeNode(instance: any, model: any, storeKey : string, type : string): VnfTreeNode {
 506     let tmp  = null;
 507     if(type === 'vnfs') {
 508       tmp = new VnfTreeNode(instance, model, storeKey);
 509     }else if (type === 'vnfGroups') {
 510       tmp = new VnfGroupTreeNode(instance, model, storeKey);
 511     }else {
 512       tmp = new NetworkTreeNode(instance, model, storeKey);
 513     }
 514     tmp.missingData = this.checkMissingData(instance, ServiceNodeTypes.VF, [], model.isEcompGeneratedNaming);
 515
 516     return tmp;
 517   }
 518
 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);
 522     return newVfModule;
 523   }
 524
 525   calculatePositionOfVfmodule(serviceModelId:string) {
 526     const serviceInstance = this.store.getState().service.serviceInstance[serviceModelId];
 527     const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceModelId];
 528
 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;
 539
 540           }
 541         } else {
 542           //No instances added yet , hence start from 1
 543           totalSecondListLength = 1;
 544         }
 545
 546       }
 547     }
 548
 549     return totalSecondListLength;
 550   }
 551
 552
 553   updatePositionForRemainingVfModules(serviceModelId: string) {
 554
 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));
 567               }
 568             }
 569
 570           }
 571         }
 572
 573       }
 574     }
 575   }
 576 }