ax-common-ui-lib 1.0.0-beta.0

package/esm2020/lib/filters/multi-select-filter/multi-select-filter.component.mjs

@@ -0,0 +1,211 @@
+import { CommonFilterService } from './../common-filter/common-filter.service';
+import { Component, ViewEncapsulation, Input } from '@angular/core';
+import { AxExpTextList } from '../../enlighten-lib/ax-expression/ax-exp-text-list';
+import { AxOperator } from '../../enlighten-lib/filters/ax-operator';
+import { MAT_SELECT_CONFIG } from '@angular/material/select';
+import { CommonFilterComponent } from '../common-filter/common-filter.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./../common-filter/common-filter.service";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/select";
+import * as i4 from "@angular/material/tooltip";
+import * as i5 from "@angular/forms";
+import * as i6 from "../../axo-search-bar/axo-search-bar.component";
+import * as i7 from "@angular/common";
+import * as i8 from "@angular/material/core";
+import * as i9 from "../filter-footer/filter-footer.component";
+import * as i10 from "@angular/material/icon";
+function MultiSelectFilterComponent_div_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div");
+    i0.ɵɵelementContainerStart(1);
+    i0.ɵɵelementStart(2, "mat-option", 11, 12);
+    i0.ɵɵtext(4, " Yes ");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(5, "mat-option", 11, 12);
+    i0.ɵɵtext(7, " No ");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("value", 1);
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("value", 0);
+} }
+function MultiSelectFilterComponent_div_7_ng_container_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "mat-option", 14, 12);
+    i0.ɵɵtext(3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const series_r6 = ctx.$implicit;
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("matTooltip", series_r6)("value", series_r6);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", series_r6, " ");
+} }
+function MultiSelectFilterComponent_div_7_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div");
+    i0.ɵɵtemplate(1, MultiSelectFilterComponent_div_7_ng_container_1_Template, 4, 3, "ng-container", 13);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", ctx_r2.seriesList);
+} }
+export class MultiSelectFilterComponent extends CommonFilterComponent {
+    constructor(_commonFilterService) {
+        super(_commonFilterService);
+        this._commonFilterService = _commonFilterService;
+        //<----------< Inputs >---------------------------->
+        this.selectFirstValueDefault = false;
+    }
+    /**
+     * ngOnChanges use to change the current page object
+     */
+    // eslint-disable-next-line @angular-eslint/use-lifecycle-interface
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes); // called common life cycle hook.S
+    }
+    /**
+     * On init life cycle hook
+     */
+    ngOnInit() {
+        // Called super
+        super.ngOnInit();
+        this.setDisplayValue();
+        this.expression.comparisonOperator = new AxOperator({ text: 'In', value: 'IN' });
+        this.stringOperators = AxOperator.getStringOperator();
+        this.getSeriesList();
+    }
+    /**
+     * This will get called on data load
+     */
+    onDataLoaded() {
+        if (this.selectFirstValueDefault && this.seriesList.length) {
+            this.expressionValue.value.push(this.seriesList[0]);
+        }
+    }
+    /**
+     * Get called after view render
+     */
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        this.setDisplayValue();
+    }
+    /**
+     * Set expression value
+     *
+     * @overridden
+     */
+    setExpressionValue() {
+        this.expressionValue = this.expression.value ? this.expression.value : new AxExpTextList();
+    }
+    /**
+     * THis will reset Filter value.
+     *
+     * @overridden
+     */
+    resetFilter() {
+        this.expressionValue = new AxExpTextList(this.defaultValue);
+        this.expression.value = this.expressionValue;
+    }
+    /**
+     * This function clear the filter value.
+     *
+     * @overridden
+     */
+    clearValue() {
+        this.expressionValue = new AxExpTextList();
+        this.expression.value = this.expressionValue;
+    }
+    /**
+     * Set Default Value
+     *
+     * @overridden
+     */
+    setDefaultValue() {
+        this.defaultValue = new AxExpTextList(this.expressionValue);
+    }
+    /**
+     * Apply parent value parent value change
+     */
+    applyParentFilter() {
+        this.expressionValue.value = [];
+        this.pageIndex = 0;
+        this.seriesList = [];
+        this.getSeriesList();
+    }
+    /**
+     * Clear Values
+     *
+     */
+    clearAllValue() {
+        this.expressionValue.value = [];
+        this.filterValueChanged();
+        this.applyFilterEvent.emit();
+    }
+    /**
+   * set display value
+   */
+    setDisplayValue() {
+        this.addEllipsesToDisplayValue(this.expression.field.label);
+    }
+}
+MultiSelectFilterComponent.ɵfac = function MultiSelectFilterComponent_Factory(t) { return new (t || MultiSelectFilterComponent)(i0.ɵɵdirectiveInject(i1.CommonFilterService)); };
+MultiSelectFilterComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MultiSelectFilterComponent, selectors: [["lib-multi-select-filter"]], inputs: { selectFirstValueDefault: "selectFirstValueDefault" }, features: [i0.ɵɵProvidersFeature([
+            {
+                provide: MAT_SELECT_CONFIG,
+                useValue: { overlayPanelClass: 'custom-multi-select-overlay-panel' },
+            },
+        ]), i0.ɵɵInheritDefinitionFeature, i0.ɵɵNgOnChangesFeature], decls: 11, vars: 11, consts: [[1, "fields", "flex"], ["appearance", "none"], ["panelClass", "multi-select-panel", "multiple", "", 3, "placeholder", "matTooltip", "ngModel", "ngModelChange", "selectionChange"], ["multiSelectList", ""], [3, "searchText", "searchTextChanged"], [3, "ngSwitch"], [4, "ngSwitchCase"], [4, "ngSwitchDefault"], [1, "hidden"], [3, "isFilterValue", "clearAllValue", "applyFilter", "closeFilter"], [1, "down-arrow", 3, "svgIcon", "click"], [1, "py-2", 3, "value"], ["matOption", ""], [4, "ngFor", "ngForOf"], [1, "py-2", 3, "matTooltip", "value"]], template: function MultiSelectFilterComponent_Template(rf, ctx) { if (rf & 1) {
+        const _r8 = i0.ɵɵgetCurrentView();
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵelementStart(1, "mat-form-field", 1);
+        i0.ɵɵelementStart(2, "mat-select", 2, 3);
+        i0.ɵɵlistener("ngModelChange", function MultiSelectFilterComponent_Template_mat_select_ngModelChange_2_listener($event) { return ctx.expressionValue.value = $event; })("selectionChange", function MultiSelectFilterComponent_Template_mat_select_selectionChange_2_listener() { return ctx.filterValueChanged(); });
+        i0.ɵɵelementStart(4, "axo-search-bar", 4);
+        i0.ɵɵlistener("searchTextChanged", function MultiSelectFilterComponent_Template_axo_search_bar_searchTextChanged_4_listener($event) { return ctx.searchTextChanged($event); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementContainerStart(5, 5);
+        i0.ɵɵtemplate(6, MultiSelectFilterComponent_div_6_Template, 8, 2, "div", 6);
+        i0.ɵɵtemplate(7, MultiSelectFilterComponent_div_7_Template, 2, 1, "div", 7);
+        i0.ɵɵelementContainerEnd();
+        i0.ɵɵelement(8, "mat-option", 8);
+        i0.ɵɵelementStart(9, "lib-filter-footer", 9);
+        i0.ɵɵlistener("clearAllValue", function MultiSelectFilterComponent_Template_lib_filter_footer_clearAllValue_9_listener() { return ctx.clearAllValue(); })("applyFilter", function MultiSelectFilterComponent_Template_lib_filter_footer_applyFilter_9_listener() { return ctx.applyFilter(); })("closeFilter", function MultiSelectFilterComponent_Template_lib_filter_footer_closeFilter_9_listener() { i0.ɵɵrestoreView(_r8); const _r0 = i0.ɵɵreference(3); return _r0.close(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(10, "mat-icon", 10);
+        i0.ɵɵlistener("click", function MultiSelectFilterComponent_Template_mat_icon_click_10_listener() { i0.ɵɵrestoreView(_r8); const _r0 = i0.ɵɵreference(3); return _r0.open(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(2);
+        i0.ɵɵclassMapInterpolate1("multi-select-dropdown filter_", ctx.filter.id.toString(), "");
+        i0.ɵɵproperty("placeholder", ctx.displayValue)("matTooltip", ctx.toolTipValue)("ngModel", ctx.expressionValue.value);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("searchText", ctx.searchText);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngSwitch", ctx.expression.field.widgetSubType);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngSwitchCase", ctx.widgetSubType.toggle);
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("isFilterValue", ctx.seriesList && ctx.seriesList.length);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("svgIcon", "axo_arrow");
+    } }, directives: [i2.MatFormField, i3.MatSelect, i4.MatTooltip, i5.NgControlStatus, i5.NgModel, i6.AxoSearchBarComponent, i7.NgSwitch, i7.NgSwitchCase, i7.NgSwitchDefault, i8.MatOption, i9.FilterFooterComponent, i10.MatIcon, i7.NgForOf], styles: [""], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MultiSelectFilterComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-multi-select-filter', encapsulation: ViewEncapsulation.None, providers: [
+                    {
+                        provide: MAT_SELECT_CONFIG,
+                        useValue: { overlayPanelClass: 'custom-multi-select-overlay-panel' },
+                    },
+                ], template: "<div class=\"fields flex\">\n<mat-form-field appearance=\"none\">\n  <mat-select class=\"multi-select-dropdown filter_{{filter.id.toString()}}\"\n  [placeholder]=\"displayValue\"\n  [matTooltip]=\"toolTipValue\"\n  [(ngModel)]=\"expressionValue.value\"\n  (selectionChange)=\"filterValueChanged()\"\n  panelClass=\"multi-select-panel\"\n  multiple\n  #multiSelectList >\n\n  <!-- Search bar for filter value   -->\n  <axo-search-bar [searchText]=\"searchText\" (searchTextChanged)=\"searchTextChanged($event)\"></axo-search-bar>\n\n  <ng-container [ngSwitch]=\"expression.field.widgetSubType\">\n    <!-- If filter widget sub-type is toggle -->\n    <div  *ngSwitchCase=\"widgetSubType.toggle\">\n        <ng-container>\n        <mat-option #matOption  class=\"py-2\" [value]=\"1\">\n            Yes\n        </mat-option>\n        <mat-option #matOption  class=\"py-2\"  [value]=\"0\">\n            No\n        </mat-option>\n        </ng-container>\n    </div>\n    <!-- Default dropdown -->\n    <div *ngSwitchDefault>\n        <ng-container *ngFor=\"let series of seriesList\">\n        <mat-option #matOption  class=\"py-2\" [matTooltip]=\"series\"  [value]=series>\n            {{series}}\n        </mat-option>\n        </ng-container>\n    </div>\n  </ng-container>\n  <!-- this option is for opening the dropdown even if series is empty -->\n  <mat-option class=\"hidden\"></mat-option>\n  <!-- Filter dropdown footer -->\n  <lib-filter-footer\n    [isFilterValue]=\"(seriesList && seriesList.length)\"\n    (clearAllValue)=\"clearAllValue()\"\n    (applyFilter)=\"applyFilter()\"\n    (closeFilter)=\"multiSelectList.close()\"\n    >\n  </lib-filter-footer>\n</mat-select>\n\n</mat-form-field>\n<mat-icon class=\"down-arrow\" [svgIcon]=\"'axo_arrow'\" (click)=\"multiSelectList.open()\"></mat-icon>\n</div>\n", styles: [""] }]
+    }], function () { return [{ type: i1.CommonFilterService }]; }, { selectFirstValueDefault: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-select-filter.component.js","sourceRoot":"","sources":["../../../../../../src/ax-common-ui-lib/src/lib/filters/multi-select-filter/multi-select-filter.component.ts","../../../../../../src/ax-common-ui-lib/src/lib/filters/multi-select-filter/multi-select-filter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonFilterService } from './../common-filter/common-filter.service';\nimport { Component, OnInit, SimpleChanges, ViewEncapsulation, AfterViewInit, Input } from '@angular/core';\nimport { AxExpTextList } from '../../enlighten-lib/ax-expression/ax-exp-text-list';\nimport { AxOperator } from '../../enlighten-lib/filters/ax-operator';\nimport { MAT_SELECT_CONFIG } from '@angular/material/select';\nimport { CommonFilterComponent } from '../common-filter/common-filter.component';\n\n\n@Component({\n    selector: 'lib-multi-select-filter',\n    templateUrl: './multi-select-filter.component.html',\n    styleUrls: ['./multi-select-filter.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    providers: [\n        {\n            provide: MAT_SELECT_CONFIG,\n            useValue: { overlayPanelClass: 'custom-multi-select-overlay-panel' },\n        },\n    ],\n})\nexport class MultiSelectFilterComponent extends CommonFilterComponent implements OnInit, AfterViewInit {\n    //<----------< Inputs >---------------------------->\n    @Input() selectFirstValueDefault:boolean = false;\n    //<-----------<Outputs >--------------------------->\n\n    //<-------------(Enums )--------------------------->\n\n    //<-------------(Component Variables )------------->\n    expressionValue: AxExpTextList;\n    stringOperators: Array<AxOperator>;\n\n    constructor(public _commonFilterService: CommonFilterService) {\n        super(_commonFilterService);\n    }\n\n    /**\n     * ngOnChanges use to change the current page object\n     */\n    // eslint-disable-next-line @angular-eslint/use-lifecycle-interface\n    ngOnChanges(changes: SimpleChanges): void {\n        super.ngOnChanges(changes); // called common life cycle hook.S\n    }\n\n    /**\n     * On init life cycle hook\n     */\n    ngOnInit(): void {\n        // Called super\n        super.ngOnInit();\n        this.setDisplayValue();\n        this.expression.comparisonOperator = new AxOperator({ text: 'In', value: 'IN' });\n        this.stringOperators = AxOperator.getStringOperator();\n        this.getSeriesList();\n    }\n\n    /**\n     * This will get called on data load\n     */\n    onDataLoaded(): void {\n        if(this.selectFirstValueDefault && this.seriesList.length){\n            this.expressionValue.value.push(this.seriesList[0]);\n        }\n    }\n\n    /**\n     * Get called after view render\n     */\n    ngAfterViewInit(): void {\n        super.ngAfterViewInit();\n        this.setDisplayValue();\n    }\n    /**\n     * Set expression value\n     *\n     * @overridden\n     */\n    setExpressionValue(): void {\n        this.expressionValue = this.expression.value ? this.expression.value as AxExpTextList : new AxExpTextList();\n    }\n\n    /**\n     * THis will reset Filter value.\n     *\n     * @overridden\n     */\n    resetFilter(): void {\n        this.expressionValue = new AxExpTextList(this.defaultValue) ;\n        this.expression.value = this.expressionValue;\n    }\n\n    /**\n     * This function clear the filter value.\n     *\n     * @overridden\n     */\n    clearValue(): void {\n        this.expressionValue = new AxExpTextList();\n        this.expression.value = this.expressionValue;\n    }\n\n    /**\n     * Set Default Value\n     *\n     * @overridden\n     */\n    setDefaultValue(): void {\n        this.defaultValue =  new AxExpTextList(this.expressionValue);\n    }\n\n    /**\n     * Apply parent value parent value change\n     */\n    applyParentFilter(): void {\n        this.expressionValue.value = [];\n        this.pageIndex = 0;\n        this.seriesList = [];\n        this.getSeriesList();\n    }\n    /**\n     * Clear Values\n     *\n     */\n    clearAllValue(): void {\n        this.expressionValue.value = [];\n        this.filterValueChanged();\n        this.applyFilterEvent.emit();\n    }\n\n    /**\n   * set display value\n   */\n    setDisplayValue(){\n        this.addEllipsesToDisplayValue(this.expression.field.label);\n    }\n}\n","<div class=\"fields flex\">\n<mat-form-field appearance=\"none\">\n  <mat-select class=\"multi-select-dropdown filter_{{filter.id.toString()}}\"\n  [placeholder]=\"displayValue\"\n  [matTooltip]=\"toolTipValue\"\n  [(ngModel)]=\"expressionValue.value\"\n  (selectionChange)=\"filterValueChanged()\"\n  panelClass=\"multi-select-panel\"\n  multiple\n  #multiSelectList >\n\n  <!-- Search bar for filter value   -->\n  <axo-search-bar [searchText]=\"searchText\" (searchTextChanged)=\"searchTextChanged($event)\"></axo-search-bar>\n\n  <ng-container [ngSwitch]=\"expression.field.widgetSubType\">\n    <!-- If filter widget sub-type is toggle -->\n    <div  *ngSwitchCase=\"widgetSubType.toggle\">\n        <ng-container>\n        <mat-option #matOption  class=\"py-2\" [value]=\"1\">\n            Yes\n        </mat-option>\n        <mat-option #matOption  class=\"py-2\"  [value]=\"0\">\n            No\n        </mat-option>\n        </ng-container>\n    </div>\n    <!-- Default dropdown -->\n    <div *ngSwitchDefault>\n        <ng-container *ngFor=\"let series of seriesList\">\n        <mat-option #matOption  class=\"py-2\" [matTooltip]=\"series\"  [value]=series>\n            {{series}}\n        </mat-option>\n        </ng-container>\n    </div>\n  </ng-container>\n  <!-- this option is for opening the dropdown even if series is empty -->\n  <mat-option class=\"hidden\"></mat-option>\n  <!-- Filter dropdown footer -->\n  <lib-filter-footer\n    [isFilterValue]=\"(seriesList && seriesList.length)\"\n    (clearAllValue)=\"clearAllValue()\"\n    (applyFilter)=\"applyFilter()\"\n    (closeFilter)=\"multiSelectList.close()\"\n    >\n  </lib-filter-footer>\n</mat-select>\n\n</mat-form-field>\n<mat-icon class=\"down-arrow\" [svgIcon]=\"'axo_arrow'\" (click)=\"multiSelectList.open()\"></mat-icon>\n</div>\n"]}

package/esm2020/lib/filters/multi-select-filter/multi-select-filter.service.mjs

@@ -0,0 +1,214 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { AttributesDto } from '../../common-dto/attributes-dto';
+import { FilterProperty } from '../../enlighten-lib/property/filter-property';
+import { AxFilter } from '../../enlighten-lib/filters/ax-filter';
+import { CommonLibConfigurationService } from '../../common-lib-configuration.service';
+import { AxoUtils } from '../../axo-utils/axo-utils';
+import { WidgetSubType } from '../../forms/page/common/widget-enums';
+import { ScreenType } from '../../enlighten-lib/filters/condition-type';
+import { ElementService } from '../../enlighten-lib/report/element.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../common-lib-configuration.service";
+import * as i3 from "../../enlighten-lib/report/element.service";
+export class MultiSelectFilterService {
+    /**
+     * Constructor
+     */
+    constructor(_httpClient, _configuration, elementService) {
+        this._httpClient = _httpClient;
+        this._configuration = _configuration;
+        this.elementService = elementService;
+        this.refreshFilterPropertyEvent = new EventEmitter();
+        this.parentEventEmitterRef = new EventEmitter();
+        this.refreshChildFilterEventEmitterRef = new EventEmitter();
+        this._parentFilterList = new BehaviorSubject(null);
+    }
+    /**
+     * Getter for entities
+     */
+    get parentFilterList$() {
+        return this._parentFilterList.asObservable();
+    }
+    /**
+     * when filter click then open filter properties.
+     */
+    refreshChildFilter(parentFilterKey, parentFilter) {
+        this.refreshChildFilterEventEmitterRef.emit({ parentKey: parentFilterKey, parentValue: parentFilter });
+    }
+    /**
+     * when filter click then open filter properties.
+     */
+    refreshFilterProperty(filter) {
+        const filterProperty = new FilterProperty();
+        filterProperty.filter = filter;
+        this.refreshFilterPropertyEvent.emit(filterProperty);
+    }
+    /**
+     * when filter click then open filter properties.
+     */
+    refreshFilterListProperty(filters) {
+        this._parentFilterList.next(filters);
+    }
+    /**
+     * when parent filter add to child filter then call
+     */
+    refreshParentEventEmitter(guid) {
+        this.parentEventEmitterRef.emit(guid);
+    }
+    /**
+     * Get Category list by the app-version id
+     */
+    getAttributeSeries(data) {
+        data.filter = this.removeInvalidFilter(data);
+        return new Promise((resolve, reject) => {
+            this._httpClient.post('attributesdata', data).subscribe((response) => {
+                resolve(response);
+            }, reject);
+        });
+    }
+    /**
+     * Removed Parent Filter if parent has invalid value
+     *
+     * @param data
+     * @returns
+     */
+    removeInvalidFilter(data) {
+        const filter = new AxFilter(data.filter);
+        const filterValue = filter?.parent?.searchNodes[0]?.expression?.value;
+        if (filterValue && !this.elementService.getValidValue(filter.parent)) {
+            filter.parent = null;
+        }
+        return filter;
+    }
+    getDistinctWidgetValue(formId, widgetIdentifier, startIndex, limit, searchedTerm) {
+        const formData = new FormData();
+        formData.append('form_id', formId);
+        formData.append('widget_identifier', widgetIdentifier);
+        formData.append('page_index', startIndex.toString());
+        formData.append('page_size', limit.toString());
+        formData.append('searchText', searchedTerm);
+        return new Promise((resolve, reject) => {
+            this._httpClient.post(this._configuration.axonatorX1Url + 'getDistinctWidgetValues/', formData).subscribe((response) => {
+                resolve(response);
+            }, reject);
+        });
+    }
+    /**
+     * Register panel scroll event (this is listener for mat options scroll.)
+     */
+    registerPanelScrollEvent(componentRef) {
+        // Get options panel form select directive.
+        const panel = componentRef.selectElem.panel.nativeElement;
+        //Added Scroll event listener.
+        panel.addEventListener('scroll', (event) => {
+            // current scrolled position
+            const pos = event.srcElement.offsetHeight + event.srcElement.scrollTop;
+            //max scroll position
+            const max = event.srcElement.scrollHeight;
+            //Scrolled position and max scrolled position are same that mean scrolled reached at bottom. then load next page attribute list
+            if ((max - pos) < 2) {
+                //Saved current scroll position.
+                componentRef.attributeListScrollPos = event.srcElement.scrollTop;
+                componentRef.startIndex = componentRef.startIndex + 10;
+                //Fetch distinct values of widget values of next page as lazy load.
+                if (componentRef.screenType === ScreenType.dataList || componentRef.screenType === ScreenType.dataView || componentRef.screenType === ScreenType.dataViewBuilder) {
+                    if (componentRef.expression.field.widgetSubType === WidgetSubType.fixedList) {
+                        componentRef.seriesList = componentRef.expression.field.fixedSeries;
+                    }
+                    else {
+                        this.getDistinctWidgetValue(componentRef.formId, componentRef.expression.field.name, componentRef.startIndex, componentRef.limit, componentRef.searchedTerm).then((data) => {
+                            if (data.length > 0) {
+                                data.forEach((seriesData) => {
+                                    componentRef.seriesList = componentRef.seriesList;
+                                    if (!componentRef.seriesList.includes(seriesData)) {
+                                        componentRef.seriesList.push(seriesData);
+                                    }
+                                });
+                            }
+                        });
+                    }
+                    componentRef.isNoData = componentRef.seriesList.length ? true : false;
+                }
+                //Fetch Attribute list of next page as lazy load.
+                else {
+                    this.getAttributeList(componentRef);
+                }
+            }
+        });
+    }
+    /**
+     * Get the Attribute form object list.this
+     */
+    getAttributeList(componentRef) {
+        if (componentRef.totalAttribute > componentRef.seriesList.length) {
+            //Increase current page number.
+            componentRef.currentAttributePage++;
+            //Called attributDto object list api
+            const attributeData = new AttributesDto();
+            attributeData.reportId = componentRef.reportId;
+            attributeData.filter = componentRef.filter;
+            attributeData.currentPage = componentRef.currentAttributePage;
+            attributeData.serachText = componentRef.searchedTerm;
+            componentRef._multiSelectFilterService.getAttributeSeries(attributeData).then((attribute) => {
+                componentRef.seriesType = componentRef.filter.searchNodes[0].expression.field.widgetSubType;
+                if (componentRef.seriesType === WidgetSubType.dateTime || componentRef.seriesType === WidgetSubType.dateTimeOld) {
+                    this.setDateTimeListSeriesValue(attribute, componentRef);
+                }
+                else {
+                    this.setAttributeSeriesValue(attribute, componentRef);
+                }
+                componentRef.isNoData = componentRef.seriesList.length ? true : false;
+                componentRef.totalAttribute = attribute.totalRecords;
+            }).catch((error) => {
+                componentRef.isattributeLoaded = true;
+            });
+        }
+    }
+    /**
+     * set date time drop down list value
+     *
+     * @param attribute
+     * @param componentRef
+     */
+    setDateTimeListSeriesValue(attribute, componentRef) {
+        attribute.series.forEach((seriesValue) => {
+            componentRef.seriesList.push({
+                'localDateTime': AxoUtils.formatDateToCustomDateFormat(AxoUtils.formatDateFromUTCToLocal(seriesValue), 'YYYY-MM-DD hh:mm:ss a'),
+                'utcDateTime': seriesValue,
+            });
+        });
+        componentRef.totalAttribute = attribute.totalRecords;
+        componentRef.seriesList.forEach((value) => {
+            if (componentRef.expressionValue.value.length && !componentRef.expressionValue.value.includes(value.utcDateTime)) {
+                componentRef.seriesList.push(value);
+            }
+        });
+    }
+    /**
+     * Set attribute drop down list value
+     *
+     * @param attribute
+     * @param componentRef
+     */
+    setAttributeSeriesValue(attribute, componentRef) {
+        attribute.series.forEach((series) => {
+            if (!componentRef.seriesList.includes(series)) {
+                componentRef.seriesList.push(series);
+            }
+        });
+        componentRef.expressionValue.value.forEach((value) => {
+            if (!componentRef.seriesList.includes(value)) {
+                componentRef.seriesList.push(value);
+            }
+        });
+    }
+}
+MultiSelectFilterService.ɵfac = function MultiSelectFilterService_Factory(t) { return new (t || MultiSelectFilterService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.CommonLibConfigurationService), i0.ɵɵinject(i3.ElementService)); };
+MultiSelectFilterService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MultiSelectFilterService, factory: MultiSelectFilterService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MultiSelectFilterService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.CommonLibConfigurationService }, { type: i3.ElementService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-select-filter.service.js","sourceRoot":"","sources":["../../../../../../src/ax-common-ui-lib/src/lib/filters/multi-select-filter/multi-select-filter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, of } from 'rxjs';\nimport { HttpClient } from '@angular/common/http';\nimport { AttributesDto } from '../../common-dto/attributes-dto';\nimport { FilterProperty } from '../../enlighten-lib/property/filter-property';\nimport { AxFilter } from '../../enlighten-lib/filters/ax-filter';\nimport { CommonLibConfigurationService } from '../../common-lib-configuration.service';\nimport { AxoUtils } from '../../axo-utils/axo-utils';\nimport { WidgetSubType } from '../../forms/page/common/widget-enums';\nimport { ScreenType } from '../../enlighten-lib/filters/condition-type';\nimport { ElementService } from '../../enlighten-lib/report/element.service';\n\n@Injectable()\nexport class MultiSelectFilterService {\n  refreshFilterPropertyEvent: EventEmitter<any> = new EventEmitter();\n  parentEventEmitterRef: EventEmitter<any> = new EventEmitter();\n  refreshChildFilterEventEmitterRef: EventEmitter<any> = new EventEmitter();\n  private _parentFilterList: BehaviorSubject<any[] | null> = new BehaviorSubject(null);\n  /**\n   * Constructor\n   */\n  constructor(private _httpClient: HttpClient, private _configuration: CommonLibConfigurationService, private elementService: ElementService) { }\n  /**\n   * Getter for entities\n   */\n  get parentFilterList$(): Observable<AxFilter[]> {\n    return this._parentFilterList.asObservable();\n  }\n  /**\n   * when filter click then open filter properties.\n   */\n  refreshChildFilter(parentFilterKey: string | number, parentFilter: AxFilter): void {\n    this.refreshChildFilterEventEmitterRef.emit({ parentKey: parentFilterKey, parentValue: parentFilter });\n  }\n  /**\n   * when filter click then open filter properties.\n   */\n  refreshFilterProperty(filter: any): void {\n    const filterProperty = new FilterProperty();\n    filterProperty.filter = filter;\n    this.refreshFilterPropertyEvent.emit(filterProperty);\n  }\n\n  /**\n   * when filter click then open filter properties.\n   */\n  refreshFilterListProperty(filters: Array<AxFilter>): void {\n    this._parentFilterList.next(filters);\n  }\n  /**\n   * when parent filter add to child filter then call\n   */\n  refreshParentEventEmitter(guid: string): void {\n    this.parentEventEmitterRef.emit(guid);\n  }\n\n  /**\n   * Get Category list by the app-version id\n   */\n  getAttributeSeries(data: AttributesDto): Promise<AttributesDto> {\n    data.filter = this.removeInvalidFilter(data);\n    return new Promise((resolve, reject) => {\n      this._httpClient.post('attributesdata', data).subscribe((response: any) => {\n        resolve(response);\n      }, reject);\n    });\n  }\n\n  /**\n   * Removed Parent Filter if parent has invalid value\n   *\n   * @param data\n   * @returns\n   */\n  removeInvalidFilter(data: AttributesDto): AxFilter{\n    const filter = new AxFilter(data.filter);\n    const filterValue = filter?.parent?.searchNodes[0]?.expression?.value;\n    if(filterValue && !this.elementService.getValidValue(filter.parent)){\n      filter.parent = null;\n    }\n    return filter;\n  }\n\n  getDistinctWidgetValue(formId: string, widgetIdentifier: string, startIndex: number, limit: number,searchedTerm: string) {\n    const formData = new FormData();\n    formData.append('form_id', formId);\n    formData.append('widget_identifier', widgetIdentifier);\n    formData.append('page_index',startIndex.toString());\n    formData.append('page_size',limit.toString());\n    formData.append('searchText',searchedTerm);\n    return new Promise((resolve, reject) => {\n      this._httpClient.post(this._configuration.axonatorX1Url + 'getDistinctWidgetValues/', formData).subscribe((response: any) => {\n        resolve(response);\n      }, reject);\n    });\n  }\n\n  /**\n   * Register panel scroll event (this is listener for mat options scroll.)\n   */\n  registerPanelScrollEvent(componentRef: any): void {\n    // Get options panel form select directive.\n    const panel = componentRef.selectElem.panel.nativeElement;\n\n    //Added Scroll event listener.\n    panel.addEventListener('scroll', (event) => {\n\n      // current scrolled position\n      const pos = event.srcElement.offsetHeight + event.srcElement.scrollTop;\n\n      //max scroll position\n      const max = event.srcElement.scrollHeight;\n\n      //Scrolled position and max scrolled position are same that mean scrolled reached at bottom. then load next page attribute list\n      if ((max - pos) < 2) {\n\n        //Saved current scroll position.\n        componentRef.attributeListScrollPos = event.srcElement.scrollTop;\n\n        componentRef.startIndex=componentRef.startIndex + 10;\n        //Fetch distinct values of widget values of next page as lazy load.\n        if (componentRef.screenType === ScreenType.dataList || componentRef.screenType === ScreenType.dataView || componentRef.screenType === ScreenType.dataViewBuilder) {\n          if(componentRef.expression.field.widgetSubType === WidgetSubType.fixedList){\n            componentRef.seriesList = componentRef.expression.field.fixedSeries;\n          }\n          else{\n            this.getDistinctWidgetValue(componentRef.formId, componentRef.expression.field.name,componentRef.startIndex,componentRef.limit,componentRef.searchedTerm).then((data: Array<any>) => {\n              if(data.length>0){\n                data.forEach((seriesData) => {\n                  componentRef.seriesList=componentRef.seriesList as Array<any>;\n                  if(!componentRef.seriesList.includes(seriesData)){\n                    componentRef.seriesList.push(seriesData);\n                  }\n                });\n              }\n            });\n          }\n          componentRef.isNoData = componentRef.seriesList.length ? true : false;\n        }\n        //Fetch Attribute list of next page as lazy load.\n        else{\n            this.getAttributeList(componentRef);\n        }\n\n\n      }\n    });\n  }\n  /**\n   * Get the Attribute form object list.this\n   */\n  getAttributeList(componentRef: any): void {\n    if (componentRef.totalAttribute > componentRef.seriesList.length) {\n      //Increase current page number.\n      componentRef.currentAttributePage++;\n      //Called attributDto object list api\n      const attributeData = new AttributesDto();\n      attributeData.reportId = componentRef.reportId;\n      attributeData.filter = componentRef.filter;\n      attributeData.currentPage = componentRef.currentAttributePage;\n      attributeData.serachText = componentRef.searchedTerm;\n      componentRef._multiSelectFilterService.getAttributeSeries(attributeData).then((attribute) => {\n        componentRef.seriesType = componentRef.filter.searchNodes[0].expression.field.widgetSubType;\n        if(componentRef.seriesType === WidgetSubType.dateTime || componentRef.seriesType === WidgetSubType.dateTimeOld){\n          this.setDateTimeListSeriesValue(attribute, componentRef);\n        }else{\n          this.setAttributeSeriesValue(attribute, componentRef);\n        }\n        componentRef.isNoData = componentRef.seriesList.length ? true : false;\n        componentRef.totalAttribute = attribute.totalRecords;\n      }).catch((error) => {\n        componentRef.isattributeLoaded = true;\n      });\n    }\n  }\n  /**\n   * set date time drop down list value\n   *\n   * @param attribute\n   * @param componentRef\n   */\n  setDateTimeListSeriesValue(attribute: AttributesDto, componentRef: any): void{\n    attribute.series.forEach((seriesValue) => {\n      componentRef.seriesList.push({\n        'localDateTime': AxoUtils.formatDateToCustomDateFormat(AxoUtils.formatDateFromUTCToLocal(seriesValue), 'YYYY-MM-DD hh:mm:ss a'),\n        'utcDateTime': seriesValue,\n      });\n    });\n    componentRef.totalAttribute = attribute.totalRecords;\n    componentRef.seriesList.forEach((value) => {\n      if (componentRef.expressionValue.value.length && !componentRef.expressionValue.value.includes(value.utcDateTime)) {\n        componentRef.seriesList.push(value);\n      }\n    });\n  }\n  /**\n   * Set attribute drop down list value\n   *\n   * @param attribute\n   * @param componentRef\n   */\n  setAttributeSeriesValue(attribute: AttributesDto, componentRef: any): void{\n    attribute.series.forEach((series) => {\n      if (!componentRef.seriesList.includes(series)) {\n        componentRef.seriesList.push(series);\n      }\n    });\n    componentRef.expressionValue.value.forEach((value) => {\n      if (!componentRef.seriesList.includes(value)) {\n        componentRef.seriesList.push(value);\n      }\n    });\n  }\n\n\n}\n"]}