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

package/esm2020/lib/filters/common-filter/common-filter.component.mjs

@@ -0,0 +1,310 @@
+import { CommonFilterService } from './common-filter.service';
+import { takeUntil } from 'rxjs/operators';
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { MatSelect } from '@angular/material/select';
+import { AxFilter } from '../../enlighten-lib/filters/ax-filter';
+import { ScreenType } from '../../enlighten-lib/filters/condition-type';
+import { Subject } from 'rxjs';
+import { AttributesDto } from '../../common-dto/attributes-dto';
+import { DataSourceTypes } from '../../axo-utils/data-source-types';
+import { WidgetSubType } from '../../forms/page/common/widget-enums';
+import * as i0 from "@angular/core";
+import * as i1 from "./common-filter.service";
+const _c0 = ["multiSelectList"];
+export class CommonFilterComponent {
+    /**
+     * Constructor
+     */
+    constructor(_commonFilterService) {
+        this._commonFilterService = _commonFilterService;
+        this.resetFilterEvent = new EventEmitter();
+        this.parentFilterValueChange = new EventEmitter();
+        //<---------------(Outputs)-------------------->
+        this.filterValueChange = new EventEmitter();
+        this.parentFilterEvent = new EventEmitter();
+        this.applyFilterEvent = new EventEmitter();
+        // @Output() filterClickEvent: EventEmitter<AxFilter> = new EventEmitter<AxFilter>(); Don't need this in common filter we will handled this from filters component
+        this.clearValueEvent = new EventEmitter();
+        this._unsubscribeAll = new Subject();
+        this.pageIndex = 0; // Current page index
+        this.pageSize = 10; // Page size series
+        this.totalSeriesLength = null; // Available series length
+        this.dataSource = DataSourceTypes.flattenDB; // default data view
+        this.showSearchBox = false; // show search box on filter dropdown by default it's hidden
+        this.searchText = '';
+        this.seriesList = [];
+        this.isDataLoaded = false;
+        // <--------------------(Enums)-------------------------->
+        this.widgetSubType = WidgetSubType;
+        this.screenTypes = ScreenType;
+    }
+    /**
+     * This will get called after view init
+     * means get called after html render.
+     * for lazy loading we need scroll element.
+     */
+    ngAfterViewInit() {
+        // lazy loading for filter series
+        // Mat select open/close subscriber need only for attribute list
+        this.selectElem?.openedChange?.subscribe((isOpen) => {
+            // mat select dropdown is opened then registered panel scroll event for attribute list  lazy loading
+            if (isOpen) {
+                this.registerPanelScrollEvent();
+            }
+        });
+    }
+    /**
+     * On Change Life cycle hook
+     *
+     * @param changes
+     */
+    ngOnChanges(changes) {
+    }
+    /**
+     * On Init Life cycle hook
+     */
+    ngOnInit() {
+        // set data source for filter series.
+        this.setDataSourceType();
+        this.subscribers();
+        // set expression in local variable.
+        this.expression = this.filter?.searchNodes[0]?.expression;
+        this.setExpressionValue();
+        // Don't clear default filter.
+        if (!this.filter.isDefault) {
+            this.clearValue(); // this will create expression value object
+        }
+        else {
+            this.setDefaultValue(); // Set Default Value.
+        }
+        this.setDisplayValue();
+    }
+    /**
+     * On Destroy life cycle hook
+     */
+    ngOnDestroy() {
+        // Unsubscribe from all subscriptions
+        this._unsubscribeAll.next();
+        this._unsubscribeAll.complete();
+    }
+    /**
+     * All Subscribers should be implemented here
+     */
+    subscribers() {
+        // Subscriber for reset Filter
+        this.resetFilterEvent.pipe(takeUntil(this._unsubscribeAll)).subscribe(() => {
+            this.resetFilter();
+            // Reset child filter on filter reset.
+            if (this.filter.parent) {
+                this.applyParentFilter();
+            }
+        });
+        //Subscriber for parent filter value change. this will get called on parent filter value change.
+        this._commonFilterService.filterValueChange.pipe(takeUntil(this._unsubscribeAll)).subscribe((filter) => {
+            if (filter.id === this.filter?.parent?.id || filter.guid === this.filter.parent?.guid) {
+                this.filter.parent = filter;
+                this.applyParentFilter();
+            }
+        });
+        // Subscriber for updated the display value of filter on update of filter label
+        this._commonFilterService.filterLabelChanged.subscribe((filter) => {
+            if (filter && filter.id == this.filter.id) {
+                this.setDisplayValue();
+            }
+        });
+    }
+    /**
+     * Set filter series  data source.
+     */
+    setDataSourceType() {
+        // For Data View We fetch series form x1 API.
+        if (this.screenType === ScreenType.dataView || this.screenType === ScreenType.dataViewBuilder) {
+            this.dataSource = DataSourceTypes.x1API;
+        }
+    }
+    /**
+     * update the value of filter label in displayed value
+     */
+    setDisplayValue() {
+        // overridden on child class.
+    }
+    /**
+     * Get Called on Filter Value change
+     */
+    filterValueChanged() {
+        this.filterValueChange.emit(this.filter);
+        this._commonFilterService.filterValueChange.emit(this.filter);
+        this.setDisplayValue();
+    }
+    /**
+     * Set Expression value in component variable;
+     *  This will be overridden in child component.
+     */
+    setExpressionValue() {
+    }
+    /**
+     * Reset Filter
+     * this will be overridden in child component.
+     */
+    resetFilter() {
+    }
+    /**
+     * Clear value
+     * This will be overridden in child component.
+     */
+    clearValue() {
+    }
+    /**
+     * Apply filter
+     */
+    applyFilter() {
+        this.applyFilterEvent.emit();
+    }
+    /**
+     * Set Default value
+     *  This will be overridden in child component.
+     */
+    setDefaultValue() {
+    }
+    /**
+     * This will get called on parent filter value change.
+     * This will be overridden in child component.
+     */
+    applyParentFilter() {
+        // overridden in child component
+    }
+    /**
+     * Get series list from backend.
+     * we need this in common component for common lazy loading api calls.
+     */
+    getSeriesList(clearSeries) {
+        // Created dto
+        const attributeData = new AttributesDto();
+        attributeData.reportId = this.reportId;
+        attributeData.filter = this.filter;
+        attributeData.searchText = this.searchText;
+        attributeData.formId = this.formId;
+        attributeData.currentPage = this.pageIndex;
+        attributeData.pagesize = this.pageSize;
+        this._commonFilterService.getFilterSeries(attributeData, this.dataSource).then((attributeDto) => {
+            if (clearSeries) {
+                this.seriesList = [];
+            }
+            this.seriesList.push(...attributeDto.series);
+            this.totalSeriesLength = attributeDto.totalRecords;
+            // Set data loaded true;
+            if (!this.isDataLoaded) {
+                this.isDataLoaded = true;
+                this.onDataLoaded();
+            }
+        }).catch((err) => {
+            console.error('Filter attribute series api get failed.');
+            console.error(this.filter);
+        });
+    }
+    /**
+     * This will get called on data loaded.
+     * Get Called only first time.
+     *
+     */
+    onDataLoaded() {
+    }
+    /**
+     * Register panel scroll event (this is listener for mat options scroll.)
+     * We used this scroll for filter series lazy loading
+     */
+    registerPanelScrollEvent() {
+        // Get options panel form select directive.
+        const panel = this.selectElem.panel.nativeElement;
+        //Added Scroll event listener.
+        panel.addEventListener('scroll', (event) => {
+            if (this.seriesList.length < this.totalSeriesLength || !this.totalSeriesLength) {
+                // 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) {
+                    this.pageIndex = this.pageIndex + 1;
+                    this.getSeriesList();
+                }
+            }
+        });
+    }
+    /**
+     * Search filter value
+     *
+     * @param searchText
+     */
+    searchTextChanged(searchText) {
+        this.pageIndex = 0;
+        this.searchText = searchText;
+        this.getSeriesList(true);
+    }
+    addEllipsesToDisplayValue(displayValue) {
+        this.toolTipValue = displayValue;
+        this.displayValue = displayValue;
+        var words = this.expression.field.label.split(" ");
+        if (words.length > 2) {
+            if (words.length > 3) {
+                this.displayValue = words.slice(0, 3).join(' ') + '...';
+                const valueWidth = document.querySelector('.filter_' + this.filter.id + ' .mat-select-value');
+                const valueSpanWidth = valueWidth.querySelector('span');
+                // if(valueWidth.clientWidth > valueSpanWidth.clientWidth){
+                //     if(words.length > 4){
+                //         this.displayValue = words.slice(0, 4).join(' ') + '...';
+                //     }
+                //     else{
+                //         this.displayValue = words.slice(0, 4).join(' ');
+                //     }
+                // }
+            }
+            else {
+                this.displayValue = words.slice(0, 3).join(' ');
+            }
+        }
+    }
+}
+CommonFilterComponent.ɵfac = function CommonFilterComponent_Factory(t) { return new (t || CommonFilterComponent)(i0.ɵɵdirectiveInject(i1.CommonFilterService)); };
+CommonFilterComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: CommonFilterComponent, selectors: [["lib-common-filter"]], viewQuery: function CommonFilterComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.selectElem = _t.first);
+    } }, inputs: { filter: "filter", screenType: "screenType", appVersionId: "appVersionId", appId: "appId", formId: "formId", reportId: "reportId", resetFilterEvent: "resetFilterEvent", parentFilterValueChange: "parentFilterValueChange" }, outputs: { filterValueChange: "filterValueChange", parentFilterEvent: "parentFilterEvent", applyFilterEvent: "applyFilterEvent", clearValueEvent: "clearValueEvent" }, features: [i0.ɵɵNgOnChangesFeature], decls: 2, vars: 0, template: function CommonFilterComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "p");
+        i0.ɵɵtext(1, "common-filter works!");
+        i0.ɵɵelementEnd();
+    } }, styles: [""] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CommonFilterComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-common-filter', template: "<p>common-filter works!</p>\n", styles: [""] }]
+    }], function () { return [{ type: i1.CommonFilterService }]; }, { selectElem: [{
+            type: ViewChild,
+            args: ['multiSelectList']
+        }], filter: [{
+            type: Input
+        }], screenType: [{
+            type: Input
+        }], appVersionId: [{
+            type: Input
+        }], appId: [{
+            type: Input
+        }], formId: [{
+            type: Input
+        }], reportId: [{
+            type: Input
+        }], resetFilterEvent: [{
+            type: Input
+        }], parentFilterValueChange: [{
+            type: Input
+        }], filterValueChange: [{
+            type: Output
+        }], parentFilterEvent: [{
+            type: Output
+        }], applyFilterEvent: [{
+            type: Output
+        }], clearValueEvent: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-filter.component.js","sourceRoot":"","sources":["../../../../../../src/ax-common-ui-lib/src/lib/filters/common-filter/common-filter.component.ts","../../../../../../src/ax-common-ui-lib/src/lib/filters/common-filter/common-filter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonFilterService } from './common-filter.service';\nimport { takeUntil } from 'rxjs/operators';\nimport { Component, EventEmitter, Input, OnInit, Output, OnDestroy, SimpleChanges, OnChanges, ViewChild, AfterViewInit } from '@angular/core';\nimport { MatSelect } from '@angular/material/select';\nimport { AxExpression } from '../../enlighten-lib/ax-expression/ax-expression';\nimport { AxFilter } from '../../enlighten-lib/filters/ax-filter';\nimport { ScreenType } from '../../enlighten-lib/filters/condition-type';\nimport { Subject } from 'rxjs';\nimport { AttributesDto } from '../../common-dto/attributes-dto';\nimport { DataSourceTypes } from '../../axo-utils/data-source-types';\nimport { WidgetSubType } from '../../forms/page/common/widget-enums';\n\n@Component({\n    selector: 'lib-common-filter',\n    templateUrl: './common-filter.component.html',\n    styleUrls: ['./common-filter.component.scss']\n})\nexport class  CommonFilterComponent implements OnInit,OnDestroy,OnChanges,AfterViewInit {\n    //<--------------<View Child> ------------------->\n    @ViewChild('multiSelectList') selectElem: MatSelect;\n    //<--------------(Inputs)--------------------->\n    @Input() filter: AxFilter; // Filter\n    @Input() screenType: ScreenType;  // filter screen type .\n    @Input() appVersionId: number;\n    @Input() appId: number;\n    @Input() formId?: number;\n    @Input() reportId: number;\n    @Input() resetFilterEvent: EventEmitter<any> = new EventEmitter();\n    @Input() parentFilterValueChange: EventEmitter<AxFilter> = new EventEmitter();\n    //<---------------(Outputs)-------------------->\n    @Output() filterValueChange: EventEmitter<any> = new EventEmitter<AxFilter>();\n    @Output() parentFilterEvent: EventEmitter<any> =  new EventEmitter<AxFilter>();\n    @Output() applyFilterEvent: EventEmitter<any> =  new EventEmitter<any>();\n    // @Output() filterClickEvent: EventEmitter<AxFilter> = new EventEmitter<AxFilter>(); Don't need this in common filter we will handled this from filters component\n    @Output() clearValueEvent: EventEmitter<any> =  new EventEmitter<AxFilter>();\n\n    //<------(Common component Variables)---------->\n    expression: AxExpression;\n    _unsubscribeAll: Subject<any> = new Subject<any>();\n    pageIndex: number = 0; // Current page index\n    pageSize: number = 10; // Page size series\n    totalSeriesLength = null; // Available series length\n    defaultValue: any; // this will store default value of filter on reset we user default\n    dataSource: DataSourceTypes = DataSourceTypes.flattenDB; // default data view\n    showSearchBox: boolean = false; // show search box on filter dropdown by default it's hidden\n    searchText: string = '';\n    seriesList: Array<any> = [];\n    isDataLoaded:boolean = false;\n    displayValue: string;\n    toolTipValue: string;\n    // <--------------------(Enums)-------------------------->\n    widgetSubType = WidgetSubType;\n    screenTypes = ScreenType;\n\n    /**\n     * Constructor\n     */\n    constructor(\n        public _commonFilterService: CommonFilterService\n    ) { }\n\n    /**\n     * This will get called after view init\n     * means get called after html render.\n     * for lazy loading we need scroll element.\n     */\n    ngAfterViewInit(): void {\n        // lazy loading for filter series\n        // Mat select open/close subscriber need only for attribute list\n    this.selectElem?.openedChange?.subscribe((isOpen) => {\n        // mat select dropdown is opened then registered panel scroll event for attribute list  lazy loading\n        if(isOpen){\n          this.registerPanelScrollEvent();\n        }\n      });\n\n    }\n\n    /**\n     * On Change Life cycle hook\n     *\n     * @param changes\n     */\n    ngOnChanges(changes: SimpleChanges): void {\n\n    }\n    /**\n     * On Init Life cycle hook\n     */\n    ngOnInit(): void {\n        // set data source for filter series.\n        this.setDataSourceType();\n\n        this.subscribers();\n        // set expression in local variable.\n        this.expression = this.filter?.searchNodes[0]?.expression;\n        this.setExpressionValue();\n        // Don't clear default filter.\n        if(!this.filter.isDefault){\n            this.clearValue(); // this will create expression value object\n        }else{\n            this.setDefaultValue();  // Set Default Value.\n        }\n        this.setDisplayValue();\n    }\n    /**\n     * On Destroy life cycle hook\n     */\n    ngOnDestroy(): void {\n        // Unsubscribe from all subscriptions\n        this._unsubscribeAll.next();\n        this._unsubscribeAll.complete();\n    }\n\n    /**\n     * All Subscribers should be implemented here\n     */\n    subscribers(): void{\n        // Subscriber for reset Filter\n        this.resetFilterEvent.pipe(takeUntil(this._unsubscribeAll)).subscribe(()=>{\n            this.resetFilter();\n            // Reset child filter on filter reset.\n            if(this.filter.parent){\n                this.applyParentFilter();\n            }\n        });\n\n        //Subscriber for parent filter value change. this will get called on parent filter value change.\n        this._commonFilterService.filterValueChange.pipe(takeUntil(this._unsubscribeAll)).subscribe((filter: AxFilter)=>{\n            if(filter.id === this.filter?.parent?.id || filter.guid === this.filter.parent?.guid){\n                this.filter.parent =filter;\n                this.applyParentFilter();\n            }\n        });\n\n        // Subscriber for updated the display value of filter on update of filter label\n        this._commonFilterService.filterLabelChanged.subscribe((filter: AxFilter) => {\n            if(filter && filter.id == this.filter.id){\n                this.setDisplayValue();\n            }\n        })\n\n    }\n    /**\n     * Set filter series  data source.\n     */\n    setDataSourceType(): void{\n        // For Data View We fetch series form x1 API.\n        if(this.screenType === ScreenType.dataView || this.screenType === ScreenType.dataViewBuilder){\n            this.dataSource = DataSourceTypes.x1API;\n        }\n    }\n\n    /**\n     * update the value of filter label in displayed value\n     */\n    setDisplayValue(): void{\n        // overridden on child class.\n    }\n\n    /**\n     * Get Called on Filter Value change\n     */\n    filterValueChanged(): void{\n        this.filterValueChange.emit(this.filter);\n        this._commonFilterService.filterValueChange.emit(this.filter);\n        this.setDisplayValue();\n    }\n    /**\n     * Set Expression value in component variable;\n     *  This will be overridden in child component.\n     */\n    setExpressionValue(): void{\n\n    }\n    /**\n     * Reset Filter\n     * this will be overridden in child component.\n     */\n    resetFilter(): void{\n\n    }\n\n    /**\n     * Clear value\n     * This will be overridden in child component.\n     */\n    clearValue(): void{\n\n    }\n    /**\n     * Apply filter\n     */\n    applyFilter(): void{\n        this.applyFilterEvent.emit();\n    }\n    /**\n     * Set Default value\n     *  This will be overridden in child component.\n     */\n    setDefaultValue(): void{\n\n    }\n\n\n    /**\n     * This will get called on parent filter value change.\n     * This will be overridden in child component.\n     */\n    applyParentFilter(): void{\n        // overridden in child component\n    }\n\n\n    /**\n     * Get series list from backend.\n     * we need this in common component for common lazy loading api calls.\n     */\n  getSeriesList(clearSeries?: boolean): void{\n    // Created dto\n    const attributeData = new AttributesDto();\n    attributeData.reportId = this.reportId;\n    attributeData.filter = this.filter;\n    attributeData.searchText = this.searchText;\n    attributeData.formId = this.formId;\n    attributeData.currentPage = this.pageIndex;\n    attributeData.pagesize = this.pageSize;\n\n    this._commonFilterService.getFilterSeries(attributeData,this.dataSource).then((attributeDto: AttributesDto)=>{\n        if(clearSeries){\n            this.seriesList = [];\n        }\n        this.seriesList.push(...attributeDto.series);\n        this.totalSeriesLength = attributeDto.totalRecords;\n        // Set data loaded true;\n        if(!this.isDataLoaded){\n            this.isDataLoaded = true;\n            this.onDataLoaded();\n        }\n    }).catch((err) =>{\n        console.error('Filter attribute series api get failed.');\n        console.error(this.filter);\n\n    });\n\n  }\n\n  /**\n   * This will get called on data loaded.\n   * Get Called only first time.\n   *\n   */\n  onDataLoaded(): void{\n\n  }\n\n  /**\n   * Register panel scroll event (this is listener for mat options scroll.)\n   * We used this scroll for filter series lazy loading\n   */\n   registerPanelScrollEvent(): void {\n    // Get options panel form select directive.\n    const panel = this.selectElem.panel.nativeElement;\n\n    //Added Scroll event listener.\n    panel.addEventListener('scroll', (event) => {\n        if(this.seriesList.length < this.totalSeriesLength || !this.totalSeriesLength ){\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                this.pageIndex= this.pageIndex+ 1;\n                this.getSeriesList();\n            }\n        }\n    });\n  }\n\n  /**\n   * Search filter value\n   *\n   * @param searchText\n   */\n  searchTextChanged(searchText: string): void{\n    this.pageIndex = 0;\n    this.searchText = searchText;\n    this.getSeriesList(true);\n  }\n\n  addEllipsesToDisplayValue(displayValue){\n    this.toolTipValue = displayValue;\n    this.displayValue = displayValue;\n    var words = this.expression.field.label.split(\" \");\n    \n    if(words.length > 2){\n        if(words.length > 3){\n            this.displayValue = words.slice(0, 3).join(' ') + '...';\n            const valueWidth = document.querySelector('.filter_'+this.filter.id+' .mat-select-value') as Element;\n            const valueSpanWidth = valueWidth.querySelector('span') as Element;\n            // if(valueWidth.clientWidth > valueSpanWidth.clientWidth){\n            //     if(words.length > 4){\n            //         this.displayValue = words.slice(0, 4).join(' ') + '...';\n            //     }\n            //     else{\n            //         this.displayValue = words.slice(0, 4).join(' ');\n            //     }\n            // }\n        }\n        else{\n            this.displayValue = words.slice(0, 3).join(' ');\n        }\n    }\n  }\n\n\n}\n","<p>common-filter works!</p>\n"]}

package/esm2020/lib/filters/common-filter/common-filter.service.mjs

@@ -0,0 +1,106 @@
+import { DataSourceTypes } from './../../axo-utils/data-source-types';
+import { HttpClient } from '@angular/common/http';
+import { EventEmitter, Injectable } from '@angular/core';
+import { CommonLibConfigurationService } from '../../common-lib-configuration.service';
+import { AxFilter } from '../../enlighten-lib/filters/ax-filter';
+import { WidgetSubType } from '../../forms/page/common/widget-enums';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../common-lib-configuration.service";
+export class CommonFilterService {
+    constructor(_httpClient, _configuration) {
+        this._httpClient = _httpClient;
+        this._configuration = _configuration;
+        // filter selection change emitter.
+        this.filterLabelChanged = new EventEmitter(); // this emitter is used for emit on update of filter label
+        this.filterValueChange = new EventEmitter();
+    }
+    getFilterSeries(attributeDto, dataSource) {
+        if (dataSource === DataSourceTypes.flattenDB) {
+            return this.getAttributeSeries(attributeDto);
+        }
+        else if (attributeDto.filter.searchNodes[0].expression.field.widgetSubType === WidgetSubType.referenceList) {
+            return this.gtReferenceFilterSeries(attributeDto);
+        }
+        else {
+            return this.getAttributeSeriesFromX1(attributeDto);
+        }
+    }
+    /**
+     * Get Filter series from flatten database;
+     *
+     * @param data
+     * @returns
+     */
+    getAttributeSeries(attributeDto) {
+        attributeDto.filter = this.cloneFilter(attributeDto.filter);
+        return new Promise((resolve, reject) => {
+            this._httpClient.post('attributesdata', attributeDto).subscribe((response) => {
+                resolve(response);
+            }, reject);
+        });
+    }
+    /**
+     * Get Filter Series  from x1 API
+     */
+    getAttributeSeriesFromX1(attributeDto) {
+        const pageIndex = attributeDto.currentPage * attributeDto.pagesize;
+        const formData = new FormData();
+        formData.append('form_id', attributeDto.formId.toString());
+        formData.append('widget_identifier', attributeDto.filter.searchNodes[0].expression.field.identifier);
+        formData.append('page_index', pageIndex.toString());
+        formData.append('page_size', attributeDto.pagesize.toString());
+        formData.append('searchText', attributeDto.searchText);
+        return new Promise((resolve, reject) => {
+            this._httpClient.post(this._configuration.axonatorX1Url + 'getDistinctWidgetValues/', formData).subscribe((response) => {
+                attributeDto.series = response;
+                resolve(attributeDto);
+            }, reject);
+        });
+    }
+    /**
+   * to get reference widget values
+   *
+   * @param searchObject
+   * @returns
+   */
+    gtReferenceFilterSeries(attributeDto) {
+        const limit = (attributeDto.currentPage + 1) * attributeDto.pagesize;
+        const searchObject = { 'srct': 'A', 'sc': 'f', 'afid': attributeDto.filter.searchNodes[0].expression.field.formId,
+            'folnt': 78.534454, 'folat': 17.4508872, 'kw': attributeDto.searchText, 'offset': 0, 'limit': limit,
+            'search_in_all_fields': false };
+        const formData = new FormData();
+        formData.append('search', JSON.stringify(searchObject));
+        return new Promise((resolve, reject) => {
+            this._httpClient.post(this._configuration.axonatorX1Url + 'search/', formData).subscribe((response) => {
+                attributeDto.series = response['wfis_resp']?.wfis?.form_objects ? response['wfis_resp']?.wfis?.form_objects : [];
+                attributeDto.totalRecords = response['wfis_resp']?.wfis?.total_form_objects ? response['wfis_resp']?.wfis?.total_form_objects : null;
+                resolve(attributeDto);
+            }, reject);
+        });
+    }
+    /**
+     * Check Valid Parent Filter
+     *
+     * @param _filter
+     * @returns
+     */
+    cloneFilter(_filter) {
+        // clone filter object
+        const filter = new AxFilter(_filter);
+        // Check filter Parent
+        if (filter.parent) {
+            // If parent is not searchable then set parent null for get filter series.
+            if (!filter.parent?.searchNodes[0].expression.value?.searchable()) {
+                filter.parent = null;
+            }
+        }
+        return filter;
+    }
+}
+CommonFilterService.ɵfac = function CommonFilterService_Factory(t) { return new (t || CommonFilterService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.CommonLibConfigurationService)); };
+CommonFilterService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CommonFilterService, factory: CommonFilterService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CommonFilterService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.CommonLibConfigurationService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-filter.service.js","sourceRoot":"","sources":["../../../../../../src/ax-common-ui-lib/src/lib/filters/common-filter/common-filter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSourceTypes } from './../../axo-utils/data-source-types';\nimport { HttpClient } from '@angular/common/http';\nimport { EventEmitter, Injectable } from '@angular/core';\nimport { AttributesDto } from '../../common-dto/attributes-dto';\nimport { CommonLibConfigurationService } from '../../common-lib-configuration.service';\nimport { AxFilter } from '../../enlighten-lib/filters/ax-filter';\nimport { WidgetSubType } from '../../forms/page/common/widget-enums';\n\n@Injectable()\nexport class CommonFilterService {\n    // filter selection change emitter.\n    filterLabelChanged: EventEmitter<any> = new EventEmitter<AxFilter>(); // this emitter is used for emit on update of filter label\n    filterValueChange: EventEmitter<AxFilter> = new EventEmitter();\n\n    constructor(\n        private _httpClient: HttpClient,\n        private _configuration: CommonLibConfigurationService,\n        ) { }\n\n\n\n    getFilterSeries(attributeDto: AttributesDto,dataSource: DataSourceTypes): Promise<AttributesDto>{\n        if(dataSource === DataSourceTypes.flattenDB){\n            return this.getAttributeSeries(attributeDto);\n        }else if(attributeDto.filter.searchNodes[0].expression.field.widgetSubType === WidgetSubType.referenceList){\n            return this.gtReferenceFilterSeries(attributeDto);\n        }else{\n            return this.getAttributeSeriesFromX1(attributeDto);\n        }\n    }\n    /**\n     * Get Filter series from flatten database;\n     *\n     * @param data\n     * @returns\n     */\n    getAttributeSeries(attributeDto: AttributesDto): Promise<AttributesDto> {\n\n        attributeDto.filter =this.cloneFilter(attributeDto.filter);\n        return new Promise((resolve, reject) => {\n          this._httpClient.post('attributesdata', attributeDto).subscribe((response: any) => {\n            resolve(response);\n          }, reject);\n        });\n    }\n\n\n    /**\n     * Get Filter Series  from x1 API\n     */\n\n    getAttributeSeriesFromX1(attributeDto: AttributesDto): Promise<AttributesDto>{\n        const pageIndex = attributeDto.currentPage * attributeDto.pagesize;\n        const formData = new FormData();\n        formData.append('form_id', attributeDto.formId.toString());\n        formData.append('widget_identifier', attributeDto.filter.searchNodes[0].expression.field.identifier);\n        formData.append('page_index',pageIndex.toString());\n        formData.append('page_size',attributeDto.pagesize.toString());\n        formData.append('searchText',attributeDto.searchText);\n        return new Promise((resolve, reject) => {\n        this._httpClient.post(this._configuration.axonatorX1Url + 'getDistinctWidgetValues/', formData).subscribe((response: any) => {\n            attributeDto.series = response;\n            resolve(attributeDto);\n        }, reject);\n        });\n    }\n\n    /**\n   * to get reference widget values\n   *\n   * @param searchObject\n   * @returns\n   */\n  gtReferenceFilterSeries(attributeDto: AttributesDto): Promise<AttributesDto>{\n    const limit = (attributeDto.currentPage+1) * attributeDto.pagesize;\n    const searchObject = { 'srct': 'A', 'sc': 'f', 'afid': attributeDto.filter.searchNodes[0].expression.field.formId,\n    'folnt': 78.534454, 'folat': 17.4508872, 'kw':attributeDto.searchText,'offset': 0, 'limit': limit,\n    'search_in_all_fields':false };\n    const formData = new FormData();\n    formData.append('search', JSON.stringify(searchObject));\n    return new Promise((resolve, reject) => {\n      this._httpClient.post(this._configuration.axonatorX1Url + 'search/', formData).subscribe((response: any) => {\n        attributeDto.series = response['wfis_resp']?.wfis?.form_objects?response['wfis_resp']?.wfis?.form_objects:[];\n        attributeDto.totalRecords = response['wfis_resp']?.wfis?.total_form_objects?response['wfis_resp']?.wfis?.total_form_objects:null;\n        resolve(attributeDto);\n      }, reject);\n    });\n  }\n\n\n    /**\n     * Check Valid Parent Filter\n     *\n     * @param _filter\n     * @returns\n     */\n    cloneFilter(_filter: AxFilter): AxFilter{\n        // clone filter object\n        const filter = new AxFilter(_filter);\n        // Check filter Parent\n        if(filter.parent){\n            // If parent is not searchable then set parent null for get filter series.\n            if(!filter.parent?.searchNodes[0].expression.value?.searchable()){\n                filter.parent = null;\n            }\n        }\n        return filter;\n    }\n}\n"]}

package/esm2020/lib/filters/custom-scroll-directives.mjs

@@ -0,0 +1,45 @@
+import { Directive, HostListener, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+// this directive is used for handling the disabled properties previous and next button of scroll
+export class CustomScrollDirective {
+    constructor(eleRef) {
+        this.eleRef = eleRef;
+        this.disableLeftBtn = true; // previous button which scrolls to left
+        this.disableRightBtn = false; // next button which scrolls to right
+    }
+    onScrollEvent(event) {
+        this.left = this.eleRef.nativeElement.scrollLeft;
+        this.offSetWidth = this.eleRef.nativeElement.offsetWidth;
+        this.scrollWidth = this.eleRef.nativeElement.scrollWidth;
+        // if scroll is at the left corner than the previous button is disabled and the next button is enabled
+        if (this.left === 0) {
+            this.disableLeftBtn = true;
+            this.disableRightBtn = false;
+        }
+        // if scroll is not at the left or right corner than the previous button and next button is enabled
+        if (this.left > 0) {
+            this.disableLeftBtn = false;
+            this.disableRightBtn = false;
+        }
+        // if scroll is at the right corner than the next button is disabled and the previous button is enabled
+        if (this.left > this.scrollWidth - this.offSetWidth - 3) {
+            this.disableRightBtn = true;
+            this.disableLeftBtn = false;
+        }
+    }
+}
+CustomScrollDirective.ɵfac = function CustomScrollDirective_Factory(t) { return new (t || CustomScrollDirective)(i0.ɵɵdirectiveInject(i0.ElementRef)); };
+CustomScrollDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: CustomScrollDirective, selectors: [["", "appCustomScroll", ""]], hostBindings: function CustomScrollDirective_HostBindings(rf, ctx) { if (rf & 1) {
+        i0.ɵɵlistener("scroll", function CustomScrollDirective_scroll_HostBindingHandler() { return ctx.onScrollEvent(); });
+    } }, exportAs: ["appCustomScroll"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CustomScrollDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[appCustomScroll]',
+                exportAs: 'appCustomScroll'
+            }]
+    }], function () { return [{ type: i0.ElementRef }]; }, { onScrollEvent: [{
+            type: HostListener,
+            args: ['scroll']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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