gerrit.onap Code Review - vid.git/blob

   1 import {Injectable} from '@angular/core';
   2 import * as _ from 'lodash';
   3
   4 import {NgRedux} from '@angular-redux/store';
   5 import {AppState} from '../../store/reducers';
   6 import {VnfTreeNode} from "../../models/vnfTreeNode";
   7 import {VfModuleInstance} from "../../models/vfModuleInstance";
   8 import {VfModule} from "../../models/vfModule";
   9 import {VfModuleTreeNode} from "../../models/vfModuleTreeNode";
  10 import {InputType} from "../../models/inputTypes";
  11 import {ServiceNodeTypes} from "../../models/ServiceNodeTypes";
  12 import {Constants} from "../../utils/constants";
  13 import {Utils} from "../../utils/utils";
  14 import {NetworkTreeNode} from "../../models/networkTreeNode";
  15 import {createVNFInstance} from "../../storeUtil/utils/vnf/vnf.actions";
  16 import {changeInstanceCounter} from "../../storeUtil/utils/general/general.actions";
  17 import {createNetworkInstance} from "../../storeUtil/utils/network/network.actions";
  18 import {createVFModuleInstance} from "../../storeUtil/utils/vfModule/vfModule.actions";
  19 import {createVnfGroupInstance} from "../../storeUtil/utils/vnfGroup/vnfGroup.actions";
  20 import {VnfGroupTreeNode} from "../../models/vnfGroupTreeNode";
  21 import {ModelInfo} from "../../models/modelInfo";
  22 import {ServiceInstanceActions} from "../../models/serviceInstanceActions";
  23 import Parameter = Constants.Parameter;
  24
  25 @Injectable()
  26 export class DefaultDataGeneratorService {
  27   static controlsFieldsStatus = {};
  28   public requiredFields = {
  29     VF: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
  30     Network: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
  31     VL: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
  32     VFmodule: [],
  33     VnfGroup: []
  34   };
  35
  36   constructor(private store: NgRedux<AppState>) {
  37   }
  38
  39   public getArbitraryInputs(inputs) {
  40     let parameter;
  41     let parameterList = [];
  42     for (let key in inputs) {
  43       parameter = {
  44         id: key,
  45         type: Parameter.STRING,
  46         name: key,
  47         value: inputs[key][Parameter.DEFAULT],
  48         isRequired: inputs[key][Parameter.REQUIRED],
  49         description: inputs[key][Parameter.DESCRIPTION]
  50       };
  51       switch (inputs[key][Parameter.TYPE]) {
  52         case Parameter.INTEGER:
  53           parameter.type = Parameter.NUMBER;
  54           break;
  55         case Parameter.BOOLEAN:
  56           parameter.type = Parameter.BOOLEAN;
  57           break;
  58         case Parameter.RANGE:
  59           break;
  60         case Parameter.LIST:
  61           parameter.type = Parameter.LIST;
  62           break;
  63         case Parameter.MAP:
  64           parameter.type = Parameter.MAP;
  65           break;
  66       }
  67       if (Utils.hasContents(inputs[key][Parameter.CONSTRAINTS])
  68         && ( inputs[key][Parameter.CONSTRAINTS].length > 0 )) {
  69         let constraintsArray = inputs[key][Parameter.CONSTRAINTS];
  70         this.addConstraintParameters(parameterList, constraintsArray, key, inputs, parameter);
  71       }
  72       else {
  73
  74         parameterList.push(parameter);
  75       }
  76     }
  77     return parameterList;
  78   }
  79
  80   private addConstraintParameters(parameterList, constraintsArray, key, inputs, parameter) {
  81     // If there are constraints and the operator is "valid_values",
  82     // use a select parameter type.
  83     let i: number = constraintsArray.length;
  84     let parameterPushed: boolean = false;
  85     if (i > 0) {
  86       while ((i--) && (!parameterPushed)) {
  87         let keys = Object.keys(constraintsArray[i]);
  88         for (let operator in keys) {
  89           switch (keys[operator]) {
  90             case Parameter.VALID_VALUES:
  91               let j: number = constraintsArray[i][Parameter.VALID_VALUES].length;
  92               if (j > 0) {
  93                 let oList = [];
  94                 let option;
  95                 while (j--) {
  96                   option = {
  97                     name: constraintsArray[i][Parameter.VALID_VALUES][j],
  98                     isDefault: false
  99                   };
 100                   if ((Utils.hasContents(inputs[key][Parameter.DEFAULT]) )
 101                     && (inputs[key][Parameter.DEFAULT] === constraintsArray[i][Parameter.VALID_VALUES][j] )) {
 102                     option = {
 103                       name: constraintsArray[i][Parameter.VALID_VALUES][j],
 104                       isDefault: true
 105                     }
 106                   }
 107                   oList.push(option);
 108                 }
 109                 parameter.type = Parameter.SELECT;
 110                 parameter.optionList = oList;
 111                 parameterList.push(parameter);
 112                 parameterPushed = true;
 113               }
 114               break;
 115
 116             case Parameter.EQUAL:
 117               if (constraintsArray[i][Parameter.EQUAL] != null) {
 118                 parameter.type = Parameter.STRING;
 119                 parameter.isReadOnly = true;
 120                 parameter.value = constraintsArray[i][Parameter.EQUAL];
 121                 parameterList.push(parameter);
 122                 parameterPushed = true;
 123               }
 124               break;
 125
 126             case Parameter.LENGTH:
 127               if (constraintsArray[i][Parameter.LENGTH] != null) {
 128                 parameter.minLength = constraintsArray[i][Parameter.LENGTH];
 129                 parameter.maxLength = constraintsArray[i][Parameter.LENGTH];
 130                 parameterList.push(parameter);
 131                 parameterPushed = true;
 132               }
 133               break;
 134             case Parameter.MAX_LENGTH:
 135               if (constraintsArray[i][Parameter.MAX_LENGTH] != null) {
 136                 parameter.maxLength = constraintsArray[i][Parameter.MAX_LENGTH];
 137                 parameterList.push(parameter);
 138                 parameterPushed = true;
 139               }
 140               break;
 141             case Parameter.MIN_LENGTH:
 142               if (constraintsArray[i][Parameter.MIN_LENGTH] != null) {
 143                 parameter.minLength = constraintsArray[i][Parameter.MIN_LENGTH];
 144                 parameterList.push(parameter);
 145                 parameterPushed = true;
 146               }
 147               break;
 148             case Parameter.IN_RANGE:
 149               if (constraintsArray[i][Parameter.IN_RANGE] != null) {
 150                 if (constraintsArray[i][Parameter.IN_RANGE].length > 1) {
 151                   parameter.min = constraintsArray[i][Parameter.IN_RANGE][0];
 152                   parameter.max = constraintsArray[i][Parameter.IN_RANGE][1];
 153                   parameter.type = Parameter.NUMBER;
 154                   parameter.value = inputs[key][Parameter.DEFAULT];
 155                   parameterList.push(parameter);
 156                   parameterPushed = true;
 157                 }
 158               }
 159               break;
 160             case Parameter.GREATER_THAN:
 161               if (constraintsArray[i][Parameter.GREATER_THAN] != null) {
 162                 parameter.type = Parameter.NUMBER;
 163                 parameter.min = constraintsArray[i][Parameter.GREATER_THAN];
 164                 parameter.value = inputs[key][Parameter.DEFAULT];
 165                 parameterList.push(parameter);
 166                 parameterPushed = true;
 167               }
 168               break;
 169           }
 170         }
 171       }
 172     }
 173   };
 174
 175   updateDynamicInputsVnfDataFromModel(modelType: string, model: any): any[] {
 176     let displayInputs;
 177     if (modelType === ServiceNodeTypes.VFmodule) {
 178       displayInputs = model.inputs;
 179     }
 180     return _.isEmpty(displayInputs) ? [] : this.getArbitraryInputs(displayInputs);
 181   }
 182
 183   updateNetworksOnFirstSet(serviceId: string, formServiceValues: any){
 184     const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceId];
 185     if (serviceHierarchy && !_.isEmpty(serviceHierarchy.networks)) {
 186       for (let networkUUID in serviceHierarchy.networks) {
 187         const isEcompGeneratedNaming = this.getIsEcompGeneratedNaming(serviceHierarchy.networks[networkUUID]);
 188         let min_vnf_instances_greater_than_0 = serviceHierarchy.networks[networkUUID].properties['min_instances'] && serviceHierarchy.networks[networkUUID].properties['min_instances'] > 0;
 189         if(min_vnf_instances_greater_than_0)
 190         {
 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         {
 208           this.createVnfGroupInstanceReduxIfNotExist(
 209             serviceId,
 210             this.generateVnfGroupData(serviceHierarchy, vnfGroupUUID, formServiceValues, isEcompGeneratedNaming)
 211           );
 212         }
 213       }
 214     }
 215   }
 216
 217   updateReduxOnFirstSet(serviceId: string, formServiceValues: any): void {
 218     this.updateNetworksOnFirstSet(serviceId, formServiceValues);
 219     this.updateVnfGroupsOnFirstSet(serviceId, formServiceValues);
 220     const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceId];
 221     if (serviceHierarchy && !_.isEmpty(serviceHierarchy.vnfs)) {
 222       for (let vnfUUID in serviceHierarchy.vnfs) {
 223         const isEcompGeneratedNaming = this.getIsEcompGeneratedNaming(serviceHierarchy.vnfs[vnfUUID]);
 224         for (let vnfModuleUUID in serviceHierarchy.vnfs[vnfUUID].vfModules) {
 225           const vfModuleModel = serviceHierarchy.vnfs[vnfUUID].vfModules[vnfModuleUUID];
 226           if (vfModuleModel.properties.minCountInstances > 0) {
 227             let vfModule = this.generateVFModule(vfModuleModel, this.updateDynamicInputsVnfDataFromModel(ServiceNodeTypes.VFmodule, vfModuleModel), isEcompGeneratedNaming, formServiceValues.isALaCarte);
 228             if (vfModuleModel.properties.initialCount > 0) {
 229               this.createVNFInstanceReduxIfNotExist(
 230                 serviceId,
 231                 this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
 232               );
 233
 234               this.addDefaultVfModulesInRedux(
 235                 serviceId,
 236                 vfModuleModel.properties.initialCount,
 237                 vfModule,
 238                 vnfModuleUUID,
 239                 vnfUUID
 240               )
 241
 242             }
 243           }
 244         }
 245
 246         let min_vnf_instances_greater_than_0 = serviceHierarchy.vnfs[vnfUUID].properties['min_instances'] && serviceHierarchy.vnfs[vnfUUID].properties['min_instances'] > 0;
 247         if(min_vnf_instances_greater_than_0)
 248         {
 249           this.createVNFInstanceReduxIfNotExist(
 250             serviceId,
 251             this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
 252           );
 253         }
 254       }
 255     }
 256   }
 257
 258
 259   private getIsEcompGeneratedNaming(vnfJson) {
 260     const ecompGeneratedNaming = vnfJson.properties.ecomp_generated_naming;
 261     return ecompGeneratedNaming === "true";
 262   };
 263
 264   createVNFInstanceReduxIfNotExist(serviceId: string, vnfData: any): void {
 265     if(!this.store.getState().service.serviceInstance[serviceId].vnfs[vnfData.modelInfo.modelCustomizationName]){
 266       this.store.dispatch(createVNFInstance(vnfData, vnfData.modelInfo.modelCustomizationName, serviceId));
 267       this.store.dispatch(changeInstanceCounter(vnfData.modelInfo.modelUniqueId, serviceId, 1, <any> {data : {type : 'VF'}}));
 268     }
 269   }
 270
 271   createNetworkInstanceReduxIfNotExist(serviceId: string, networkData: any): void {
 272     if(!this.store.getState().service.serviceInstance[serviceId].vnfs[networkData.modelInfo.modelCustomizationName]){
 273       this.store.dispatch(createNetworkInstance(networkData, networkData.modelInfo.modelCustomizationName, serviceId));
 274       this.store.dispatch(changeInstanceCounter(networkData.modelInfo.modelUniqueId, serviceId, 1, <any> {data : {type : 'VL'}}));
 275     }
 276   }
 277
 278   createVnfGroupInstanceReduxIfNotExist(serviceId: string, vnfGroupData: any): void {
 279     if(!this.store.getState().service.serviceInstance[serviceId].vnfGroups[vnfGroupData.modelInfo.modelCustomizationName]){
 280       this.store.dispatch(createVnfGroupInstance(vnfGroupData, vnfGroupData.modelInfo.modelCustomizationName, serviceId));
 281       this.store.dispatch(changeInstanceCounter(vnfGroupData.modelInfo.modelUniqueId , serviceId, 1, <any> {data : {type : 'VnfGroup'}}));
 282     }
 283   }
 284
 285   addDefaultVfModulesInRedux(serviceId: string, numberOfVfModules: number, vfModuleData: any, vfModuleName: string, vnfUUID : string){
 286     for (let i = 0; i < numberOfVfModules; i++) {
 287       this.store.dispatch(createVFModuleInstance(vfModuleData, vfModuleName, serviceId, null, vnfUUID));
 288     }
 289   }
 290
 291   generateVnfGroupInstance(vnfGroupModel: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean, instanceName: string) {
 292     let modelInfo = new ModelInfo(vnfGroupModel);
 293     let instanceParams = {};
 294     return {
 295       'uuid' : modelInfo.uuid,
 296       'action': ServiceInstanceActions.Create,
 297       'instanceName': (!isEcompGeneratedNaming) ? instanceName : null,
 298       'isMissingData' : false,
 299       'modelInfo': modelInfo,
 300       'rollbackOnFailure' : "true",
 301       'instanceParams': [
 302         instanceParams
 303       ],
 304       'trackById': DefaultDataGeneratorService.createRandomTrackById()
 305     };
 306   }
 307
 308
 309   generateVFModule(vfModule: any, dynamicInputs: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean) {
 310     let instanceParams = {};
 311     dynamicInputs.forEach(field => {
 312       instanceParams[field.id] = field.value;
 313     });
 314     return {
 315       'isMissingData' : this.setIsMissingData(ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNaming, isALaCarte),
 316       'sdncPreReload': null,
 317       'modelInfo': {
 318         'modelType': 'VFmodule',
 319         'modelInvariantId': vfModule.invariantUuid,
 320         'modelVersionId': vfModule.uuid,
 321         'modelName': vfModule.name,
 322         'modelVersion': vfModule.version,
 323         'modelCustomizationId': vfModule.customizationUuid,
 324         'modelCustomizationName': vfModule.modelCustomizationName,
 325         'modelUniqueId' : vfModule.customizationUuid || vfModule.uuid
 326       },
 327       'instanceParams': [
 328         instanceParams
 329       ],
 330       'trackById': DefaultDataGeneratorService.createRandomTrackById(),
 331       'rollbackOnFailure' : isALaCarte ? true : null,
 332     };
 333   }
 334
 335   setIsMissingData(type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean, isAlaCarte?: boolean): boolean {
 336     if (isAlaCarte || !isEcompGeneratedNaming || this.requiredFields[type].length > 0) {
 337       return true;
 338     }
 339
 340     if (dynamicInputs) {
 341       for(let input of dynamicInputs) {
 342         if (input.isRequired && _.isEmpty(input.value)) {
 343           return true;
 344         }
 345       }
 346     }
 347     return false;
 348   }
 349
 350   generateVNFData(serviceHierarchy: any, vnfName: string, formValues: any, isEcompGeneratedNaming) {
 351     return {
 352       'uuid' : serviceHierarchy.vnfs[vnfName].uuid,
 353       'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VF, [], isEcompGeneratedNaming),
 354       'productFamilyId': formValues.productFamilyId,
 355       'lcpCloudRegionId': null,
 356       'tenantId': null,
 357       'lineOfBusiness': null,
 358       'platformName': null,
 359       'modelInfo': {
 360         'modelType': 'VF',
 361         'modelInvariantId': serviceHierarchy.vnfs[vnfName].invariantUuid,
 362         'modelVersionId': serviceHierarchy.vnfs[vnfName].uuid,
 363         'modelName': serviceHierarchy.vnfs[vnfName].name,
 364         'modelVersion': serviceHierarchy.vnfs[vnfName].version,
 365         'modelCustomizationId': serviceHierarchy.vnfs[vnfName].customizationUuid,
 366         'modelCustomizationName': serviceHierarchy.vnfs[vnfName].modelCustomizationName,
 367         'modelUniqueId' : serviceHierarchy.vnfs[vnfName].customizationUuid || serviceHierarchy.vnfs[vnfName].uuid,
 368       },
 369       'trackById': DefaultDataGeneratorService.createRandomTrackById(),
 370     }
 371   }
 372
 373   generateNetworkData(serviceHierarchy: any, networkName: string, formValues: any, isEcompGeneratedNaming) {
 374       return {
 375         'uuid' : serviceHierarchy.network[networkName].uuid,
 376         'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VL, [], isEcompGeneratedNaming),
 377         'productFamilyId': formValues.productFamilyId,
 378         'lcpCloudRegionId': null,
 379         'tenantId': null,
 380         'lineOfBusiness': null,
 381         'platformName': null,
 382         'modelInfo': {
 383           'modelType': 'VF',
 384           'modelInvariantId': serviceHierarchy.network[networkName].invariantUuid,
 385           'modelVersionId': serviceHierarchy.network[networkName].uuid,
 386           'modelName': serviceHierarchy.network[networkName].name,
 387           'modelVersion': serviceHierarchy.network[networkName].version,
 388           'modelCustomizationId': serviceHierarchy.network[networkName].modelCustomizationId,
 389           'modelCustomizationName': serviceHierarchy.network[networkName].modelCustomizationName,
 390           'modelUniqueId' : serviceHierarchy.network[networkName].modelCustomizationId || serviceHierarchy.network[networkName].uuid,
 391         },
 392         'trackById': DefaultDataGeneratorService.createRandomTrackById(),
 393       }
 394     }
 395
 396   generateVnfGroupData(serviceHierarchy: any, vnfGroupName: string, formValues: any, isEcompGeneratedNaming) {
 397     return {
 398       'uuid' : serviceHierarchy.vnfGroups[vnfGroupName].uuid,
 399       'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VnfGroup, [], isEcompGeneratedNaming),
 400       'platformName': null,
 401       'modelInfo': {
 402         'modelType': 'VnfGroup',
 403         'modelInvariantId': serviceHierarchy.vnfGroups[vnfGroupName].invariantUuid,
 404         'modelVersionId': serviceHierarchy.vnfGroups[vnfGroupName].uuid,
 405         'modelName': serviceHierarchy.vnfGroups[vnfGroupName].name,
 406         'modelVersion': serviceHierarchy.vnfGroups[vnfGroupName].version,
 407         'modelCustomizationId': serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationId,
 408         'modelCustomizationName': serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationName,
 409         'modelUniqueId' : serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationId || serviceHierarchy.vnfGroups[vnfGroupName].uuid,
 410
 411       },
 412       'trackById': DefaultDataGeneratorService.createRandomTrackById(),
 413     }
 414   }
 415
 416
 417   static createRandomTrackById() {
 418     return Math.random().toString(36).slice(2);
 419   }
 420
 421   private checkMissingData(instance, type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean): boolean {
 422     if (!isEcompGeneratedNaming && _.isEmpty(instance.instanceName)) {
 423       return true;
 424     }
 425
 426     for (let field of this.requiredFields[type]) {
 427       if (_.isEmpty(instance[field])) {
 428         return true;
 429       }
 430     }
 431
 432     for (let field of dynamicInputs) {
 433       if (field.isRequired && !_.isNil(instance.instanceParams) && _.isEmpty(instance.instanceParams[0][field.id])) {
 434         return true;
 435       }
 436     }
 437
 438     return false;
 439   }
 440
 441   createNewTreeNode(instance: any, model: any, storeKey : string, type : string): VnfTreeNode {
 442     let tmp  = null;
 443     if(type === 'vnfs') {
 444       tmp = new VnfTreeNode(instance, model, storeKey);
 445     }else if (type === 'vnfGroups') {
 446       tmp = new VnfGroupTreeNode(instance, model, storeKey);
 447     }else {
 448       tmp = new NetworkTreeNode(instance, model, storeKey);
 449     }
 450     tmp.missingData = this.checkMissingData(instance, ServiceNodeTypes.VF, [], model.isEcompGeneratedNaming);
 451
 452     return tmp;
 453   }
 454
 455   createNewVfModuleTreeNode(instance: VfModuleInstance, vfModuleModel: VfModule, vfModuleModelName: string, isEcompGeneratedNamig: boolean, dynamicInputs, dynamicModelName  :string): VfModuleTreeNode {
 456     let newVfModule: VfModuleTreeNode = new VfModuleTreeNode(instance, vfModuleModel, vfModuleModelName, dynamicInputs, isEcompGeneratedNamig, dynamicModelName);
 457     newVfModule.missingData = this.checkMissingData(instance, ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNamig);
 458     return newVfModule;
 459   }
 460
 461 }