gerrit.onap Code Review - vid.git/blob

   1 import {Injectable} from "@angular/core";
   2 import {DropdownFormControl} from "../../../../models/formControlModels/dropdownFormControl.model";
   3 import {FormControlType} from "../../../../models/formControlModels/formControlTypes.enum";
   4 import {
   5   FormControlModel,
   6   ValidatorModel,
   7   ValidatorOptions
   8 } from "../../../../models/formControlModels/formControl.model";
   9 import {NgRedux} from "@angular-redux/store";
  10 import {AppState} from "../../../../store/reducers";
  11 import {AaiService} from "../../../../services/aaiService/aai.service";
  12 import {ControlGeneratorUtil, SDN_C_PRE_LOAD} from "../control.generator.util.service";
  13 import * as _ from "lodash";
  14 import {FormGroup} from "@angular/forms";
  15 import {Constants} from "../../../../utils/constants";
  16 import {CheckboxFormControl} from "../../../../models/formControlModels/checkboxFormControl.model";
  17 import {InputFormControl} from "../../../../models/formControlModels/inputFormControl.model";
  18 import {NodeModel} from "../../../../models/nodeModel";
  19 import {LcpRegion} from "../../../../models/lcpRegion";
  20 import {Tenant} from "../../../../models/tenant";
  21 import {MultiselectFormControl} from "../../../../models/formControlModels/multiselectFormControl.model";
  22 import {MultiSelectItem} from "../../../formControls/component/multiselect/multiselect.model";
  23
  24 @Injectable()
  25 export class SharedControllersService {
  26   constructor(private _store : NgRedux<AppState>,
  27               private _aaiService : AaiService,
  28               private _basicControlGenerator : ControlGeneratorUtil){}
  29
  30
  31   getLineOfBusinessControl = (instance?: any): DropdownFormControl => {
  32     return this.getLineOfBusinessControlInternal(undefined, instance);
  33   };
  34
  35   getLineOfBusinessByOwningEntityControl = (instance?: any, serviceId?: string, controls?: FormControlModel[]): DropdownFormControl => {
  36     const service = this._store.getState().service.serviceInstance[serviceId];
  37     const owningEntityName: string = service.owningEntityName;
  38
  39     const changeLcpRegionOptionsOnChange = (lineOfBusinessNameParam: string, form: FormGroup) => {
  40       form.controls['lcpCloudRegionId'].enable();
  41       form.controls['lcpCloudRegionId'].reset();
  42       this._basicControlGenerator.getSubscribeInitResult(
  43         this._aaiService.getLcpRegionsByOwningEntityAndLineOfBusiness.bind(this, owningEntityName, lineOfBusinessNameParam),
  44         controls.find(item => item.controlName === 'lcpCloudRegionId') as DropdownFormControl, form
  45       ).subscribe()
  46     };
  47
  48     return this.getLineOfBusinessControlInternal(changeLcpRegionOptionsOnChange, instance);
  49   };
  50
  51   private getLineOfBusinessControlInternal = (onChange: Function, instance?: any): DropdownFormControl => {
  52     return new DropdownFormControl({
  53       type: FormControlType.DROPDOWN,
  54       controlName: 'lineOfBusiness',
  55       displayName: 'Line of business',
  56       dataTestId: 'lineOfBusiness',
  57       placeHolder: 'Select Line Of Business',
  58       isDisabled: false,
  59       name: "lineOfBusiness",
  60       value: instance ? instance.lineOfBusiness : null,
  61       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
  62       onInitSelectedField: ['lineOfBusinessList'],
  63       onChange,
  64       onInit: this._basicControlGenerator.getSubscribeInitResult.bind(null, this._aaiService.getCategoryParameters)
  65     })
  66   };
  67
  68   getTenantControl = (serviceId: string, instance?: any): DropdownFormControl => {
  69     const service = this._store.getState().service.serviceInstance[serviceId];
  70     const globalCustomerId: string = service.globalSubscriberId;
  71     const serviceType: string = service.subscriptionServiceType;
  72
  73     const onInit = instance
  74       ? this._basicControlGenerator.getSubscribeInitResult.bind(
  75           this._aaiService,
  76           this._aaiService.getLcpRegionsAndTenants.bind(this, globalCustomerId, serviceType))
  77       : () => {};
  78     return this.getTenantControlInternal(onInit, instance);
  79   };
  80
  81   getTenantByLcpRegionControl = (serviceId: string, instance?: any): DropdownFormControl => {
  82     return this.getTenantControlInternal(() => {}, instance);
  83   };
  84
  85   private getTenantControlInternal = (onInit: Function, instance?: any): DropdownFormControl => {
  86     return new DropdownFormControl({
  87       type: FormControlType.DROPDOWN,
  88       controlName: 'tenantId',
  89       displayName: 'Tenant',
  90       dataTestId: 'tenant',
  91       placeHolder: 'Select Tenant',
  92       name: 'tenant',
  93       isDisabled: _.isNil(instance) || _.isNil(instance.lcpCloudRegionId),
  94       onInitSelectedField: instance ? ['lcpRegionsTenantsMap', instance.lcpCloudRegionId] : null,
  95       value: instance ? instance.tenantId : null,
  96       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
  97       onInit,
  98     })
  99   };
 100
 101   getRollbackOnFailureControl = (instance?: any): DropdownFormControl => {
 102     return new DropdownFormControl({
 103       type: FormControlType.DROPDOWN,
 104       controlName: 'rollbackOnFailure',
 105       displayName: 'Rollback on failure',
 106       dataTestId: 'rollback',
 107       placeHolder: 'Rollback on failure',
 108       isDisabled: false,
 109       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
 110       value: instance ? instance.rollbackOnFailure : 'true',
 111       onInit: this._basicControlGenerator.getSubscribeInitResult.bind(null, this._basicControlGenerator.getRollBackOnFailureOptions)
 112     })
 113   };
 114
 115   getLegacyRegion(instance: any): FormControlModel {
 116     return new InputFormControl({
 117       controlName: 'legacyRegion',
 118       displayName: 'Legacy Region',
 119       dataTestId: 'lcpRegionText',
 120       placeHolder: 'Type Legacy Region',
 121       validations: [],
 122       isVisible: this._basicControlGenerator.isLegacyRegionShouldBeVisible(instance),
 123       isDisabled : _.isNil(instance) ? true : Constants.LegacyRegion.MEGA_REGION.indexOf(instance.lcpCloudRegionId),
 124       value: instance ? instance.legacyRegion : null
 125     });
 126   }
 127
 128   getLcpRegionControl = (serviceId: string, instance: any, controls: FormControlModel[]): DropdownFormControl => {
 129     const service = this._store.getState().service.serviceInstance[serviceId];
 130     const globalCustomerId: string = service.globalSubscriberId;
 131     const serviceType: string = service.subscriptionServiceType;
 132
 133     const onInit = this._basicControlGenerator.getSubscribeInitResult.bind(
 134       this._aaiService,
 135       this._aaiService.getLcpRegionsAndTenants.bind(this, globalCustomerId, serviceType)
 136     );
 137
 138     const changeTenantsOptionsByServiceTypeOnChange = (
 139       (globalCustomerId, serviceType, lcpCloudRegionIdParam) => {
 140         if (!_.isNil(globalCustomerId) && !_.isNil(serviceType)) {
 141           this._basicControlGenerator.getSubscribeResult.bind(this,
 142             this._aaiService.getLcpRegionsAndTenants(globalCustomerId, serviceType)
 143             .subscribe(res => this.setTenantsOptions(controls, res.lcpRegionsTenantsMap[lcpCloudRegionIdParam])));
 144         }
 145
 146       }
 147     ).bind(this, globalCustomerId, serviceType);
 148
 149     return this.getLcpRegionControlInternal(instance, controls,
 150       false, onInit, ['lcpRegionList'], changeTenantsOptionsByServiceTypeOnChange)
 151   };
 152
 153   getLcpRegionByLineOfBusinessControl = (serviceId: string, instance: any, controls: FormControlModel[]): DropdownFormControl => {
 154     const service = this._store.getState().service.serviceInstance[serviceId];
 155     const owningEntityName: string = service.owningEntityName;
 156
 157     const changeTenantsOptions = (controls: FormControlModel[], cloudRegionId, lcpRegionList: LcpRegion[]) => {
 158       const lcpRegionOption = (_.isNil(lcpRegionList) || _.isNil(cloudRegionId))
 159         ? null : lcpRegionList.find(({id}) => id === cloudRegionId);
 160
 161       if (!_.isNil(lcpRegionOption)) {
 162         this._aaiService.getTenantsByCloudOwnerAndCloudRegionId(lcpRegionOption.cloudOwner, lcpRegionOption.id)
 163           .subscribe(res => this.setTenantsOptions(controls, res));
 164       }
 165     };
 166
 167     const lcpRegionOptionsList = (controls: FormControlModel[]): LcpRegion[] => {
 168       const lcpCloudRegionIdControl = _.isNil(controls)
 169         ? null : controls.find(({controlName}) => controlName === 'lcpCloudRegionId');
 170
 171       return _.isNil(lcpCloudRegionIdControl) ? null : lcpCloudRegionIdControl['options$'];
 172     };
 173
 174     const loadLcpRegionOptionsOnInit = (_.isNil(instance) || _.isNil(instance.lineOfBusiness))
 175       ? () => {}
 176       : this._basicControlGenerator.getSubscribeInitResult.bind(
 177         this, () => {
 178           return this._aaiService.getLcpRegionsByOwningEntityAndLineOfBusiness(owningEntityName, instance.lineOfBusiness)
 179           .do(res => changeTenantsOptions(controls, instance.lcpCloudRegionId, res));
 180         }
 181       );
 182
 183     const changeTenantsOptionsByCloudRegionIdOnChange = (
 184       (controls, lcpCloudRegionIdParam) => changeTenantsOptions(controls, lcpCloudRegionIdParam, lcpRegionOptionsList(controls))
 185     ).bind(this, controls);
 186
 187     return this.getLcpRegionControlInternal(instance, controls,
 188       _.isNil(instance) || _.isNil(instance.lineOfBusiness),
 189       loadLcpRegionOptionsOnInit, null, changeTenantsOptionsByCloudRegionIdOnChange
 190       )
 191   };
 192
 193   private getLcpRegionControlInternal = (instance: any, controls: FormControlModel[], isDisabled: boolean,
 194                                          onInit: Function, onInitSelectedField: string[], changeTenantsOptionsOnChange: Function
 195   ): DropdownFormControl => {
 196     return new DropdownFormControl({
 197       type: FormControlType.DROPDOWN,
 198       controlName: 'lcpCloudRegionId',
 199       displayName: 'LCP region',
 200       dataTestId: 'lcpRegion',
 201       placeHolder: 'Select LCP Region',
 202       name: "lcpRegion",
 203       isDisabled,
 204       value: instance ? instance.lcpCloudRegionId : null,
 205       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
 206       onInitSelectedField,
 207       onInit,
 208
 209       onChange: (lcpCloudRegionIdParam: string, form: FormGroup) => {
 210         form.controls['tenantId'].enable();
 211         form.controls['tenantId'].reset();
 212
 213         changeTenantsOptionsOnChange(lcpCloudRegionIdParam);
 214
 215         if (Constants.LegacyRegion.MEGA_REGION.indexOf(lcpCloudRegionIdParam) !== -1) {
 216           form.controls['legacyRegion'].enable();
 217           controls.find(item => item.controlName === 'legacyRegion').isVisible = true;
 218
 219         } else {
 220           controls.find(item => item.controlName === 'legacyRegion').isVisible = false;
 221           form.controls['legacyRegion'].setValue(null);
 222           form.controls['legacyRegion'].reset();
 223           form.controls['legacyRegion'].disable();
 224         }
 225       }
 226     })
 227   };
 228
 229   private setTenantsOptions = (controls: FormControlModel[], tenants: Tenant[]) => {
 230     const tenantsControl = controls.find(item => item.controlName === 'tenantId');
 231     tenantsControl['options$'] = tenants;
 232     tenantsControl['hasEmptyOptions'] = tenants && tenants.length === 0;
 233   };
 234
 235   getSDNCControl = (instance: any, extraContents? : object[]): FormControlModel => {
 236     return new CheckboxFormControl({
 237       controlName: SDN_C_PRE_LOAD,
 238       displayName: 'SDN-C pre-load',
 239       dataTestId: 'sdncPreLoad',
 240       value: instance ? instance.sdncPreLoad : false,
 241       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
 242       extraContents
 243     })
 244   };
 245
 246   getProductFamilyControl = (instance : any, controls : FormControlModel[], isMandatory?: boolean) : DropdownFormControl => {
 247     return new DropdownFormControl({
 248       type : FormControlType.DROPDOWN,
 249       controlName : 'productFamilyId',
 250       displayName : 'Product family',
 251       dataTestId : 'productFamily',
 252       placeHolder : 'Select Product Family',
 253       isDisabled : false,
 254       name : "product-family-select",
 255       value : instance ? instance.productFamilyId : null,
 256       validations : _.isNil(isMandatory) || isMandatory === true ? [new ValidatorModel(ValidatorOptions.required, 'is required')]: [],
 257       onInit : this._basicControlGenerator.getSubscribeResult.bind(this, this._aaiService.getProductFamilies),
 258     })
 259   };
 260
 261   getInstanceNameController(instance: any, serviceId: string, isEcompGeneratedNaming: boolean, model: NodeModel): FormControlModel {
 262     let validations: ValidatorModel[] = this._basicControlGenerator.createValidationsForInstanceName(instance, serviceId, isEcompGeneratedNaming);
 263     return new InputFormControl({
 264       controlName: 'instanceName',
 265       displayName: 'Instance name',
 266       dataTestId: 'instanceName',
 267       placeHolder: (!isEcompGeneratedNaming) ? 'Instance name' : 'Automatically generated when not provided',
 268       validations: validations,
 269       isVisible : true,
 270       value : (!isEcompGeneratedNaming || (!_.isNil(instance) && !_.isNil(instance.instanceName) && instance.instanceName !== ""))
 271         ? this._basicControlGenerator.getDefaultInstanceName(instance, model) : null,
 272       onKeypress : (event) => {
 273         const pattern:RegExp = ControlGeneratorUtil.INSTANCE_NAME_REG_EX;
 274         if(pattern){
 275           if(!pattern.test(event['key'])){
 276             event.preventDefault();
 277           }
 278         }
 279         return event;
 280       }
 281     });
 282   }
 283
 284   getInstanceName(instance : any, serviceId : string, isEcompGeneratedNaming: boolean): FormControlModel {
 285     let formControlModel:FormControlModel = this.getInstanceNameController(instance, serviceId, isEcompGeneratedNaming, new NodeModel());
 286     formControlModel.value = instance ? instance.instanceName : null;
 287     return formControlModel;
 288   }
 289
 290   getPlatformMultiselectControl = (instance: any, controls: FormControlModel[], isMultiSelected: boolean) : MultiselectFormControl => {
 291     return new MultiselectFormControl({
 292       type: FormControlType.MULTI_SELECT,
 293       controlName: 'platformName',
 294       displayName: 'Platform',
 295       dataTestId: 'multi-selectPlatform',
 296       selectedFieldName: 'name',
 297       ngValue: 'name',
 298       placeHolder: 'Select Platform',
 299       isDisabled: false,
 300       name: "platform",
 301       value: instance ? instance.platformName : '',
 302       limitSelection: isMultiSelected ? 1000 : 1,
 303       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
 304       onInitSelectedField: ['platformList'],
 305       onInit: this._basicControlGenerator.getSubscribeInitResult.bind(null, this._aaiService.getCategoryParameters),
 306       onChange: (param: MultiSelectItem[], form: FormGroup) => {
 307         form.controls['platformName'].setValue(param.map((multiSelectItem: MultiSelectItem) => {
 308           return multiSelectItem.itemName
 309         }).join(','));
 310       },
 311       convertOriginalDataToArray: (value?: string) => {
 312         if (_.isNil(value)) return [];
 313         return value.split(',');
 314       }
 315     });
 316   }
 317 }