vid-webpack-master/src/app/shared/components/genericForm/formControlsServices/sharedControlles/shared.controllers.service.ts

   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 {MultiselectFormControl} from "../../../../models/formControlModels/multiselectFormControl.model";
  20 import {MultiSelectItem} from "../../../formControls/component/multiselect/multiselect.model";
  21
  22 @Injectable()
  23 export class SharedControllersService {
  24   constructor(private _store : NgRedux<AppState>,
  25               private _aaiService : AaiService,
  26               private _basicControlGenerator : ControlGeneratorUtil){}
  27
  28   getTenantControl = (serviceId: string, instance?: any): DropdownFormControl => {
  29     const service = this._store.getState().service.serviceInstance[serviceId];
  30     const globalCustomerId: string = service.globalSubscriberId;
  31     const serviceType: string = service.subscriptionServiceType;
  32     return new DropdownFormControl({
  33       type: FormControlType.DROPDOWN,
  34       controlName: 'tenantId',
  35       displayName: 'Tenant',
  36       dataTestId: 'tenant',
  37       placeHolder: 'Select Tenant',
  38       name: 'tenant',
  39       isDisabled: _.isNil(instance) || _.isNil(instance.lcpCloudRegionId),
  40       onInitSelectedField: instance ? ['lcpRegionsTenantsMap', instance.lcpCloudRegionId] : null,
  41       value: instance ? instance.tenantId : null,
  42       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
  43       onInit: instance ? this._basicControlGenerator.getSubscribeInitResult.bind(
  44         this._aaiService,
  45         this._aaiService.getLcpRegionsAndTenants.bind(this, globalCustomerId, serviceType)) : () => {
  46       }
  47     })
  48   };
  49
  50   getRollbackOnFailureControl = (instance?: any): DropdownFormControl => {
  51     return new DropdownFormControl({
  52       type: FormControlType.DROPDOWN,
  53       controlName: 'rollbackOnFailure',
  54       displayName: 'Rollback on failure',
  55       dataTestId: 'rollback',
  56       placeHolder: 'Rollback on failure',
  57       isDisabled: false,
  58       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
  59       value: instance ? instance.rollbackOnFailure : 'true',
  60       onInit: this._basicControlGenerator.getSubscribeInitResult.bind(null, this._basicControlGenerator.getRollBackOnFailureOptions)
  61     })
  62   };
  63
  64   getLegacyRegion(instance: any): FormControlModel {
  65     return new InputFormControl({
  66       controlName: 'legacyRegion',
  67       displayName: 'Legacy Region',
  68       dataTestId: 'lcpRegionText',
  69       placeHolder: 'Type Legacy Region',
  70       validations: [],
  71       isVisible: this._basicControlGenerator.isLegacyRegionShouldBeVisible(instance),
  72       isDisabled : _.isNil(instance) ? true : Constants.LegacyRegion.MEGA_REGION.indexOf(instance.lcpCloudRegionId),
  73       value: instance ? instance.legacyRegion : null
  74     });
  75   }
  76
  77   getLcpRegionControl = (serviceId: string, instance: any, controls: FormControlModel[]): DropdownFormControl => {
  78     const service = this._store.getState().service.serviceInstance[serviceId];
  79     const globalCustomerId: string = service.globalSubscriberId;
  80     const serviceType: string = service.subscriptionServiceType;
  81     return new DropdownFormControl({
  82       type: FormControlType.DROPDOWN,
  83       controlName: 'lcpCloudRegionId',
  84       displayName: 'LCP region',
  85       dataTestId: 'lcpRegion',
  86       placeHolder: 'Select LCP Region',
  87       name: "lcpRegion",
  88       isDisabled: false,
  89       value: instance ? instance.lcpCloudRegionId : null,
  90       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
  91       onInitSelectedField: ['lcpRegionList'],
  92       onInit: this._basicControlGenerator.getSubscribeInitResult.bind(
  93         this._aaiService,
  94         this._aaiService.getLcpRegionsAndTenants.bind(this, globalCustomerId, serviceType)),
  95       onChange: (param: string, form: FormGroup) => {
  96         form.controls['tenantId'].enable();
  97         form.controls['tenantId'].reset();
  98         if (!_.isNil(globalCustomerId) && !_.isNil(serviceType)) {
  99           this._basicControlGenerator.getSubscribeResult.bind(this, this._aaiService.getLcpRegionsAndTenants(globalCustomerId, serviceType).subscribe(res => {
 100             controls.find(item => item.controlName === 'tenantId')['options$'] = res.lcpRegionsTenantsMap[param];
 101             if (res.lcpRegionsTenantsMap[param]) {
 102               controls.find(item => item.controlName === 'tenantId')['hasEmptyOptions'] = res.lcpRegionsTenantsMap[param].length === 0;
 103             }
 104           }));
 105         }
 106
 107         if (Constants.LegacyRegion.MEGA_REGION.indexOf(param) !== -1) {
 108           form.controls['legacyRegion'].enable();
 109           controls.find(item => item.controlName === 'legacyRegion').isVisible = true;
 110
 111         } else {
 112           controls.find(item => item.controlName === 'legacyRegion').isVisible = false;
 113           form.controls['legacyRegion'].setValue(null);
 114           form.controls['legacyRegion'].reset();
 115           form.controls['legacyRegion'].disable();
 116         }
 117       }
 118     })
 119   };
 120
 121
 122
 123
 124   getSDNCControl = (instance: any, checkedByDefault: boolean, extraContents? : object[]): FormControlModel => {
 125     return new CheckboxFormControl({
 126       controlName: SDN_C_PRE_LOAD,
 127       displayName: 'SDN-C pre-load',
 128       dataTestId: 'sdncPreLoad',
 129       value: instance ? instance.sdncPreLoad : checkedByDefault,
 130       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
 131       extraContents
 132     })
 133   };
 134
 135   getProductFamilyControl = (instance : any, controls : FormControlModel[], isMandatory?: boolean) : DropdownFormControl => {
 136     return new DropdownFormControl({
 137       type : FormControlType.DROPDOWN,
 138       controlName : 'productFamilyId',
 139       displayName : 'Product family',
 140       dataTestId : 'productFamily',
 141       placeHolder : 'Select Product Family',
 142       isDisabled : false,
 143       name : "product-family-select",
 144       value : instance ? instance.productFamilyId : null,
 145       validations : _.isNil(isMandatory) || isMandatory === true ? [new ValidatorModel(ValidatorOptions.required, 'is required')]: [],
 146       onInit : this._basicControlGenerator.getSubscribeResult.bind(this, this._aaiService.getProductFamilies),
 147     })
 148   };
 149
 150   getInstanceNameController(instance: any, serviceId: string, isEcompGeneratedNaming: boolean, model: NodeModel): FormControlModel {
 151     let validations: ValidatorModel[] = this._basicControlGenerator.createValidationsForInstanceName(instance, serviceId, isEcompGeneratedNaming);
 152     return new InputFormControl({
 153       controlName: 'instanceName',
 154       displayName: 'Instance name',
 155       dataTestId: 'instanceName',
 156       placeHolder: (!isEcompGeneratedNaming) ? 'Instance name' : 'Automatically generated when not provided',
 157       validations: validations,
 158       isVisible : true,
 159       value : (!isEcompGeneratedNaming || (!_.isNil(instance) && !_.isNil(instance.instanceName) && instance.instanceName !== ""))
 160         ? this._basicControlGenerator.getDefaultInstanceName(instance, model) : null,
 161       onKeypress : (event) => {
 162         const pattern:RegExp = ControlGeneratorUtil.INSTANCE_NAME_REG_EX;
 163         if(pattern){
 164           if(!pattern.test(event['key'])){
 165             event.preventDefault();
 166           }
 167         }
 168         return event;
 169       }
 170     });
 171   }
 172
 173   getInstanceName(instance : any, serviceId : string, isEcompGeneratedNaming: boolean): FormControlModel {
 174     let formControlModel:FormControlModel = this.getInstanceNameController(instance, serviceId, isEcompGeneratedNaming, new NodeModel());
 175     formControlModel.value = instance ? instance.instanceName : null;
 176     return formControlModel;
 177   }
 178
 179   getPlatformMultiselectControl = (instance: any, controls: FormControlModel[], isMultiSelected: boolean) : MultiselectFormControl => {
 180     return this.getMultiSelectFormControl(
 181       'platformName',
 182       'Platform',
 183       'multi-selectPlatform',
 184       'Select Platform',
 185       "platform",
 186       instance,
 187       instance ? instance.platformName : null,
 188       isMultiSelected,
 189       'platformList'
 190     );
 191   };
 192
 193   getLobMultiselectControl = (instance: any, isMultiSelected: boolean) : MultiselectFormControl => {
 194     return this.getMultiSelectFormControl(
 195       'lineOfBusiness',
 196       'Line of business',
 197       'multi-lineOfBusiness',
 198       'Select Line Of Business',
 199       "lineOfBusiness",
 200       instance,
 201       instance ? instance.lineOfBusiness : null,
 202       isMultiSelected,
 203       'lineOfBusinessList');
 204   };
 205
 206   private getMultiSelectFormControl(controlName: string, displayName: string, dataTestId: string, placeholder: string,
 207                                     name: string, instance: any, defaultValue, isMultiSelected: boolean, catagoryParamResponseFieldName: string) {
 208     return new MultiselectFormControl({
 209       type: FormControlType.MULTI_SELECT,
 210       controlName,
 211       displayName,
 212       dataTestId,
 213       selectedFieldName: 'name',
 214       ngValue: 'name',
 215       placeHolder: placeholder,
 216       isDisabled: false,
 217       name: name,
 218       value: instance ? defaultValue : '',
 219       limitSelection: isMultiSelected ? 1000 : 1,
 220       validations: [new ValidatorModel(ValidatorOptions.required, 'is required')],
 221       onInitSelectedField: [catagoryParamResponseFieldName],
 222       onInit: this._basicControlGenerator.getSubscribeInitResult.bind(null, this._aaiService.getCategoryParameters),
 223       onChange: (param: MultiSelectItem[], form: FormGroup) => {
 224         form.controls[controlName].setValue(param.map((multiSelectItem: MultiSelectItem) => {
 225           return multiSelectItem.itemName
 226         }).join(','));
 227       },
 228       convertOriginalDataToArray: (value?: string) => {
 229         if (_.isNil(value)) return [];
 230         return value.split(',');
 231       }
 232     });
 233   }
 234 }