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} 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,
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)
249 this.createVNFInstanceReduxIfNotExist(
251 this.generateVNFData(serviceHierarchy, vnfUUID, formServiceValues, isEcompGeneratedNaming)
259 private getIsEcompGeneratedNaming(vnfJson) {
260 const ecompGeneratedNaming = vnfJson.properties.ecomp_generated_naming;
261 return ecompGeneratedNaming === "true";
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'}}));
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'}}));
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'}}));
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));
291 generateVnfGroupInstance(vnfGroupModel: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean, instanceName: string) {
292 let modelInfo = new ModelInfo(vnfGroupModel);
293 let instanceParams = {};
295 'uuid' : modelInfo.uuid,
296 'action': ServiceInstanceActions.Create,
297 'instanceName': (!isEcompGeneratedNaming) ? instanceName : null,
298 'isMissingData' : false,
299 'modelInfo': modelInfo,
300 'rollbackOnFailure' : "true",
304 'trackById': DefaultDataGeneratorService.createRandomTrackById()
309 generateVFModule(vfModule: any, dynamicInputs: any, isEcompGeneratedNaming : boolean, isALaCarte: boolean) {
310 let instanceParams = {};
311 dynamicInputs.forEach(field => {
312 instanceParams[field.id] = field.value;
315 'isMissingData' : this.setIsMissingData(ServiceNodeTypes.VFmodule, dynamicInputs, isEcompGeneratedNaming, isALaCarte),
316 'sdncPreReload': null,
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
330 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
331 'rollbackOnFailure' : isALaCarte ? true : null,
335 setIsMissingData(type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean, isAlaCarte?: boolean): boolean {
336 if (isAlaCarte || !isEcompGeneratedNaming || this.requiredFields[type].length > 0) {
341 for(let input of dynamicInputs) {
342 if (input.isRequired && _.isEmpty(input.value)) {
350 generateVNFData(serviceHierarchy: any, vnfName: string, formValues: any, isEcompGeneratedNaming) {
352 'uuid' : serviceHierarchy.vnfs[vnfName].uuid,
353 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VF, [], isEcompGeneratedNaming),
354 'productFamilyId': formValues.productFamilyId,
355 'lcpCloudRegionId': null,
357 'lineOfBusiness': null,
358 'platformName': null,
361 'modelInvariantId': serviceHierarchy.vnfs[vnfName].invariantUuid,
362 'modelVersionId': formValues.modelInfo.modelVersionId,
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,
369 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
373 generateNetworkData(serviceHierarchy: any, networkName: string, formValues: any, isEcompGeneratedNaming) {
375 'uuid' : serviceHierarchy.network[networkName].uuid,
376 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VL, [], isEcompGeneratedNaming),
377 'productFamilyId': formValues.productFamilyId,
378 'lcpCloudRegionId': null,
380 'lineOfBusiness': null,
381 'platformName': null,
384 'modelInvariantId': serviceHierarchy.network[networkName].invariantUuid,
385 'modelVersionId': formValues.modelInfo.modelVersionId,
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,
392 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
396 generateVnfGroupData(serviceHierarchy: any, vnfGroupName: string, formValues: any, isEcompGeneratedNaming) {
398 'uuid' : serviceHierarchy.vnfGroups[vnfGroupName].uuid,
399 'isMissingData' :this.setIsMissingData(ServiceNodeTypes.VnfGroup, [], isEcompGeneratedNaming),
400 'platformName': null,
402 'modelType': 'VnfGroup',
403 'modelInvariantId': serviceHierarchy.vnfGroups[vnfGroupName].invariantUuid,
404 'modelVersionId': formValues.modelInfo.modelVersionId,
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,
412 'trackById': DefaultDataGeneratorService.createRandomTrackById(),
417 static createRandomTrackById() {
418 return Math.random().toString(36).slice(2);
421 private checkMissingData(instance, type: string, dynamicInputs: any, isEcompGeneratedNaming: boolean): boolean {
422 if (!isEcompGeneratedNaming && _.isEmpty(instance.instanceName)) {
426 for (let field of this.requiredFields[type]) {
427 if (_.isEmpty(instance[field])) {
432 for (let field of dynamicInputs) {
433 if (field.isRequired && !_.isNil(instance.instanceParams) && _.isEmpty(instance.instanceParams[0][field.id])) {
441 createNewTreeNode(instance: any, model: any, storeKey : string, type : string): VnfTreeNode {
443 if(type === 'vnfs') {
444 tmp = new VnfTreeNode(instance, model, storeKey);
445 }else if (type === 'vnfGroups') {
446 tmp = new VnfGroupTreeNode(instance, model, storeKey);
448 tmp = new NetworkTreeNode(instance, model, storeKey);
450 tmp.missingData = this.checkMissingData(instance, ServiceNodeTypes.VF, [], model.isEcompGeneratedNaming);
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);