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