1 import {Injectable} from '@angular/core';
2 import * as _ from 'lodash';
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, updateVFModulePosition} 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;
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],
36 constructor(private store: NgRedux<AppState>) {
39 public getArbitraryInputs(inputs) {
41 let parameterList = [];
42 for (let key in inputs) {
45 type: Parameter.STRING,
47 value: inputs[key][Parameter.DEFAULT],
48 isRequired: inputs[key][Parameter.REQUIRED],
49 description: inputs[key][Parameter.DESCRIPTION]
51 switch (inputs[key][Parameter.TYPE]) {
52 case Parameter.INTEGER:
53 parameter.type = Parameter.NUMBER;
55 case Parameter.BOOLEAN:
56 parameter.type = Parameter.BOOLEAN;
61 parameter.type = Parameter.LIST;
64 parameter.type = Parameter.MAP;
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);
74 parameterList.push(parameter);
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;
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;
97 name: constraintsArray[i][Parameter.VALID_VALUES][j],
100 if ((Utils.hasContents(inputs[key][Parameter.DEFAULT]) )
101 && (inputs[key][Parameter.DEFAULT] === constraintsArray[i][Parameter.VALID_VALUES][j] )) {
103 name: constraintsArray[i][Parameter.VALID_VALUES][j],
109 parameter.type = Parameter.SELECT;
110 parameter.optionList = oList;
111 parameterList.push(parameter);
112 parameterPushed = true;
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;
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;
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;
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;
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;
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;
175 updateDynamicInputsVnfDataFromModel(modelType: string, model: any): any[] {
177 if (modelType === ServiceNodeTypes.VFmodule) {
178 displayInputs = model.inputs;
180 return _.isEmpty(displayInputs) ? [] : this.getArbitraryInputs(displayInputs);
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)
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)
208 this.createVnfGroupInstanceReduxIfNotExist(
210 this.generateVnfGroupData(serviceHierarchy, vnfGroupUUID, formServiceValues, isEcompGeneratedNaming)
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(
231 this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
234 this.addDefaultVfModulesInRedux(
236 vfModuleModel.properties.initialCount,
237 vfModuleModel.properties.baseModule,
247 let min_vnf_instances_greater_than_0 = serviceHierarchy.vnfs[vnfUUID].properties['min_instances'] && serviceHierarchy.vnfs[vnfUUID].properties['min_instances'] > 0;
248 if(min_vnf_instances_greater_than_0)
250 this.createVNFInstanceReduxIfNotExist(
252 this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
260 private getIsEcompGeneratedNaming(vnfJson) {
261 const ecompGeneratedNaming = vnfJson.properties.ecomp_generated_naming;
262 return ecompGeneratedNaming === "true";
265 createVNFInstanceReduxIfNotExist(serviceId: string, vnfData: any): void {
266 if(!this.store.getState().service.serviceInstance[serviceId].vnfs[vnfData.modelInfo.modelCustomizationName]){
267 this.store.dispatch(createVNFInstance(vnfData, vnfData.modelInfo.modelCustomizationName, serviceId));
268 this.store.dispatch(changeInstanceCounter(vnfData.modelInfo.modelUniqueId, serviceId, 1, <any> {data : {type : 'VF'}}));
272 createNetworkInstanceReduxIfNotExist(serviceId: string, networkData: any): void {
273 if(!this.store.getState().service.serviceInstance[serviceId].vnfs[networkData.modelInfo.modelCustomizationName]){
274 this.store.dispatch(createNetworkInstance(networkData, networkData.modelInfo.modelCustomizationName, serviceId));
275 this.store.dispatch(changeInstanceCounter(networkData.modelInfo.modelUniqueId, serviceId, 1, <any> {data : {type : 'VL'}}));
279 createVnfGroupInstanceReduxIfNotExist(serviceId: string, vnfGroupData: any): void {
280 if(!this.store.getState().service.serviceInstance[serviceId].vnfGroups[vnfGroupData.modelInfo.modelCustomizationName]){
281 this.store.dispatch(createVnfGroupInstance(vnfGroupData, vnfGroupData.modelInfo.modelCustomizationName, serviceId));
282 this.store.dispatch(changeInstanceCounter(vnfGroupData.modelInfo.modelUniqueId , serviceId, 1, <any> {data : {type : 'VnfGroup'}}));
286 addDefaultVfModulesInRedux(serviceId: string, numberOfVfModules: number,baseModule:boolean, vfModuleData: any, vfModuleName: string, vnfUUID : string){
287 for (let i = 0; i < numberOfVfModules; i++) {
289 this.store.dispatch(createVFModuleInstance(vfModuleData, vfModuleName, serviceId, 1, vnfUUID));
291 this.store.dispatch(createVFModuleInstance(vfModuleData, vfModuleName, serviceId, i+1, vnfUUID));
297 generateVnfGroupInstance(vnfGroupModel: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean, instanceName: string) {
298 let modelInfo = new ModelInfo(vnfGroupModel);
299 let instanceParams = {};
301 'uuid' : modelInfo.uuid,
302 'action': ServiceInstanceActions.Create,
303 'instanceName': (!isEcompGeneratedNaming) ? instanceName : null,
304 'isMissingData' : false,
305 'modelInfo': modelInfo,
306 'rollbackOnFailure' : "true",
310 'trackById': DefaultDataGeneratorService.createRandomTrackById()
315 generateVFModule(vfModule: any, dynamicInputs: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean) {
316 let instanceParams = {};
317 dynamicInputs.forEach(field => {
318 instanceParams[field.id] = field.value;
321 'isMissingData' : this.setIsMissingData(ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNaming, isALaCarte),
322 'sdncPreReload': null,
324 'modelType': 'VFmodule',
325 'modelInvariantId': vfModule.invariantUuid,
326 'modelVersionId': vfModule.uuid,
327 'modelName': vfModule.name,
328 'modelVersion': vfModule.version,
329 'modelCustomizationId': vfModule.customizationUuid,
330 'modelCustomizationName': vfModule.modelCustomizationName,
331 'modelUniqueId' : vfModule.customizationUuid || vfModule.uuid
336 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
337 'rollbackOnFailure' : isALaCarte ? true : null,
338 'position': vfModule.position
343 setIsMissingData(type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean, isAlaCarte?: boolean): boolean {
344 if (isAlaCarte || !isEcompGeneratedNaming || this.requiredFields[type].length > 0) {
349 for(let input of dynamicInputs) {
350 if (input.isRequired && _.isEmpty(input.value)) {
358 generateVNFData(serviceHierarchy: any, vnfName: string, formValues: any, isEcompGeneratedNaming) {
360 'uuid' : serviceHierarchy.vnfs[vnfName].uuid,
361 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VF, [], isEcompGeneratedNaming),
362 'productFamilyId': formValues.productFamilyId,
363 'lcpCloudRegionId': null,
365 'lineOfBusiness': null,
366 'platformName': null,
369 'modelInvariantId': serviceHierarchy.vnfs[vnfName].invariantUuid,
370 'modelVersionId': serviceHierarchy.vnfs[vnfName].uuid,
371 'modelName': serviceHierarchy.vnfs[vnfName].name,
372 'modelVersion': serviceHierarchy.vnfs[vnfName].version,
373 'modelCustomizationId': serviceHierarchy.vnfs[vnfName].customizationUuid,
374 'modelCustomizationName': serviceHierarchy.vnfs[vnfName].modelCustomizationName,
375 'modelUniqueId' : serviceHierarchy.vnfs[vnfName].customizationUuid || serviceHierarchy.vnfs[vnfName].uuid,
377 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
381 generateNetworkData(serviceHierarchy: any, networkName: string, formValues: any, isEcompGeneratedNaming) {
383 'uuid' : serviceHierarchy.network[networkName].uuid,
384 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VL, [], isEcompGeneratedNaming),
385 'productFamilyId': formValues.productFamilyId,
386 'lcpCloudRegionId': null,
388 'lineOfBusiness': null,
389 'platformName': null,
392 'modelInvariantId': serviceHierarchy.network[networkName].invariantUuid,
393 'modelVersionId': serviceHierarchy.network[networkName].uuid,
394 'modelName': serviceHierarchy.network[networkName].name,
395 'modelVersion': serviceHierarchy.network[networkName].version,
396 'modelCustomizationId': serviceHierarchy.network[networkName].modelCustomizationId,
397 'modelCustomizationName': serviceHierarchy.network[networkName].modelCustomizationName,
398 'modelUniqueId' : serviceHierarchy.network[networkName].modelCustomizationId || serviceHierarchy.network[networkName].uuid,
400 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
404 generateVnfGroupData(serviceHierarchy: any, vnfGroupName: string, formValues: any, isEcompGeneratedNaming) {
406 'uuid' : serviceHierarchy.vnfGroups[vnfGroupName].uuid,
407 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VnfGroup, [], isEcompGeneratedNaming),
408 'platformName': null,
410 'modelType': 'VnfGroup',
411 'modelInvariantId': serviceHierarchy.vnfGroups[vnfGroupName].invariantUuid,
412 'modelVersionId': serviceHierarchy.vnfGroups[vnfGroupName].uuid,
413 'modelName': serviceHierarchy.vnfGroups[vnfGroupName].name,
414 'modelVersion': serviceHierarchy.vnfGroups[vnfGroupName].version,
415 'modelCustomizationId': serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationId,
416 'modelCustomizationName': serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationName,
417 'modelUniqueId' : serviceHierarchy.vnfGroups[vnfGroupName].modelCustomizationId || serviceHierarchy.vnfGroups[vnfGroupName].uuid,
420 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
425 static createRandomTrackById() {
426 return Math.random().toString(36).slice(2);
429 private checkMissingData(instance, type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean): boolean {
430 if (!isEcompGeneratedNaming && _.isEmpty(instance.instanceName)) {
434 for (let field of this.requiredFields[type]) {
435 if (_.isEmpty(instance[field])) {
440 for (let field of dynamicInputs) {
441 if (field.isRequired && !_.isNil(instance.instanceParams) && _.isEmpty(instance.instanceParams[0][field.id])) {
449 createNewTreeNode(instance: any, model: any, storeKey : string, type : string): VnfTreeNode {
451 if(type === 'vnfs') {
452 tmp = new VnfTreeNode(instance, model, storeKey);
453 }else if (type === 'vnfGroups') {
454 tmp = new VnfGroupTreeNode(instance, model, storeKey);
456 tmp = new NetworkTreeNode(instance, model, storeKey);
458 tmp.missingData = this.checkMissingData(instance, ServiceNodeTypes.VF, [], model.isEcompGeneratedNaming);
463 createNewVfModuleTreeNode(instance: VfModuleInstance, vfModuleModel: VfModule, vfModuleModelName: string, isEcompGeneratedNamig: boolean, dynamicInputs, dynamicModelName :string): VfModuleTreeNode {
464 let newVfModule: VfModuleTreeNode = new VfModuleTreeNode(instance, vfModuleModel, vfModuleModelName, dynamicInputs, isEcompGeneratedNamig, dynamicModelName);
465 newVfModule.missingData = this.checkMissingData(instance, ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNamig);
469 calculatePositionOfVfmodule(serviceModelId:string) {
470 const serviceInstance = this.store.getState().service.serviceInstance[serviceModelId];
471 const serviceHierarchy = this.store.getState().service.serviceHierarchy[serviceModelId];
473 const vnfList = serviceInstance.vnfs;
474 let totalSecondListLength =1;
475 if (!_.isEmpty(vnfList)) {
476 for (let vnfStoreKey in vnfList) {
477 const firstVfModuleInstanceList = vnfList[vnfStoreKey].vfModules;
478 if (!_.isEmpty(firstVfModuleInstanceList)) {
479 for (let vfModuleInstanceKey in firstVfModuleInstanceList) {
480 let secondVfModuleInstanceList = firstVfModuleInstanceList[vfModuleInstanceKey];
481 let numSecondVfModuleInstanceList = Object.keys(secondVfModuleInstanceList).length;
482 totalSecondListLength = totalSecondListLength + numSecondVfModuleInstanceList;
486 //No instances added yet , hence start from 1
487 totalSecondListLength = 1;
493 return totalSecondListLength;
497 updatePositionForRemainingVfModules(serviceModelId: string) {
499 const serviceInstance = this.store.getState().service.serviceInstance[serviceModelId];
500 const vnfList = serviceInstance.vnfs;
501 if (!_.isEmpty(vnfList)) {
502 for (let vnfStoreKey in vnfList) {
503 const firstVfModuleInstanceList = vnfList[vnfStoreKey].vfModules;
504 if (!_.isEmpty(firstVfModuleInstanceList)) {
505 for (let vfModuleInstanceKey in firstVfModuleInstanceList) {
506 let secondVfModuleInstanceList = firstVfModuleInstanceList[vfModuleInstanceKey];
507 for(let secondVfModuleInstanceKey in secondVfModuleInstanceList) {
508 let secondVfModuleObj = secondVfModuleInstanceList[secondVfModuleInstanceKey];
509 if(!_.isNil(secondVfModuleObj.position)) {
510 this.store.dispatch(updateVFModulePosition(vfModuleInstanceKey,secondVfModuleInstanceKey, secondVfModuleObj.position+1,serviceModelId, vnfStoreKey));