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