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

package/esm2020/lib/enlighten-lib/report/graphical-report/bar-chart/bar-chart.component.mjs

@@ -0,0 +1,1002 @@
+import { Component, ViewEncapsulation, ViewChild, Input, Output, EventEmitter, HostListener } from '@angular/core';
+import { ChartComponent } from 'ng-apexcharts';
+import { Subject } from 'rxjs';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { Router } from '@angular/router';
+import { ChartProperty } from '../chart/chart-property';
+import { AttributeData } from '../../../fields/attribute-data';
+import { ElementsDto } from '../../../../common-dto/elements-dto';
+import { FieldsListService } from '../../../../field-list-lib/fields-list.service';
+import { Dimension } from '../chart/dimension';
+import { Matrix } from '../chart/matrix';
+import { BarChart, BarChartOrientation } from './bar-chart';
+import { ReportBuilderMasterService } from '../../report-builder-master.service';
+import { SendToDashboardService } from '../../../../dashboard-lib/send-to-dashboard.service';
+import { ElementService } from '../../element.service';
+import { CommonService } from '../../../../common.service';
+import { takeUntil } from 'rxjs/operators';
+import { AxFilter } from '../../../filters/ax-filter';
+import { AxExpression } from '../../../ax-expression/ax-expression';
+import { SearchNode } from '../../../filters/search-node';
+import { Attribute } from '../../../data-model/attribute';
+import { AxExpTextList } from '../../../ax-expression/ax-exp-text-list';
+import { ScopeType, ScreenType } from '../../../filters/condition-type';
+import { DrillThroughService } from '../../../../drill-through/drill-through.service';
+import { DashboardBuilderService } from '../../../../dashboard-lib/dashboard-builder.service';
+import { GhostLoaderType } from '../../../../ghost-loader/ghost-loader.component';
+import { FiltersService } from '../../../../filters/filters.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../field-list-lib/fields-list.service";
+import * as i2 from "../../report-builder-master.service";
+import * as i3 from "../../../../dashboard-lib/send-to-dashboard.service";
+import * as i4 from "../../element.service";
+import * as i5 from "../../../../common.service";
+import * as i6 from "../../../../drill-through/drill-through.service";
+import * as i7 from "../../../../dashboard-lib/dashboard-builder.service";
+import * as i8 from "@angular/router";
+import * as i9 from "../../../../filters/filters.service";
+const _c0 = ["barChartContainer"];
+function BarChartComponent_ng_container_1_ng_container_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelement(1, "app-ghost-loader", 14);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r8 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("elementType", ctx_r8.GhostLoaderType.BarChartLoaderHorizontal);
+} }
+function BarChartComponent_ng_container_1_ng_container_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelement(1, "app-ghost-loader", 14);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r9 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("elementType", ctx_r9.GhostLoaderType.BarChartLoaderVertical);
+} }
+function BarChartComponent_ng_container_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, BarChartComponent_ng_container_1_ng_container_1_Template, 2, 1, "ng-container", 1);
+    i0.ɵɵtemplate(2, BarChartComponent_ng_container_1_ng_container_2_Template, 2, 1, "ng-container", 1);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r0.reportData.orientation == ctx_r0.BarChartOrientation.horizontal);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r0.reportData.orientation != ctx_r0.BarChartOrientation.horizontal);
+} }
+const _c1 = function (a0, a1) { return { "local-body": a0, "hidden": a1 }; };
+function BarChartComponent_div_4_Template(rf, ctx) { if (rf & 1) {
+    const _r12 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 15);
+    i0.ɵɵlistener("click", function BarChartComponent_div_4_Template_div_click_0_listener($event) { return $event.stopPropagation(); });
+    i0.ɵɵelementStart(1, "lib-report-filter", 16);
+    i0.ɵɵlistener("dirtyFlowCheckEvent", function BarChartComponent_div_4_Template_lib_report_filter_dirtyFlowCheckEvent_1_listener() { i0.ɵɵrestoreView(_r12); const ctx_r11 = i0.ɵɵnextContext(); return ctx_r11.dirtyFlowCheckEvent(); })("applyFilterEvent", function BarChartComponent_div_4_Template_lib_report_filter_applyFilterEvent_1_listener() { i0.ɵɵrestoreView(_r12); const ctx_r13 = i0.ɵɵnextContext(); return ctx_r13.applyLocalFilter(); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction2(8, _c1, !ctx_r1.isEditable, ctx_r1.screenType != ctx_r1.ScreenType.reportBuilder && !ctx_r1.ShowFilters));
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("filters", ctx_r1.reportData.filters)("categories", ctx_r1.reportData.categories)("reportId", ctx_r1.reportId)("dataModel", ctx_r1.dataModel)("screenType", ctx_r1.screenType)("isEditable", ctx_r1.isEditable)("appVersion", ctx_r1.appVersionId);
+} }
+function BarChartComponent_ng_template_13_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    const _r19 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "button", 19);
+    i0.ɵɵlistener("click", function BarChartComponent_ng_template_13_ng_container_0_Template_button_click_1_listener($event) { i0.ɵɵrestoreView(_r19); const ctx_r18 = i0.ɵɵnextContext(2); return ctx_r18.sendToDashboard($event); });
+    i0.ɵɵtext(2, "Pin to Dashboard");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(3, "button", 19);
+    i0.ɵɵlistener("click", function BarChartComponent_ng_template_13_ng_container_0_Template_button_click_3_listener($event) { i0.ɵɵrestoreView(_r19); const ctx_r20 = i0.ɵɵnextContext(2); return ctx_r20.openOptionPopUp($event); });
+    i0.ɵɵtext(4, "Delete");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} }
+function BarChartComponent_ng_template_13_button_1_Template(rf, ctx) { if (rf & 1) {
+    const _r22 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 19);
+    i0.ɵɵlistener("click", function BarChartComponent_ng_template_13_button_1_Template_button_click_0_listener($event) { i0.ɵɵrestoreView(_r22); const ctx_r21 = i0.ɵɵnextContext(2); return ctx_r21.onDeleteClick($event); });
+    i0.ɵɵtext(1, "Remove From Dashboard");
+    i0.ɵɵelementEnd();
+} }
+function BarChartComponent_ng_template_13_button_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "button", 20);
+    i0.ɵɵtext(1, "Drill Through");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵnextContext(2);
+    const _r5 = i0.ɵɵreference(15);
+    i0.ɵɵproperty("matMenuTriggerFor", _r5);
+} }
+function BarChartComponent_ng_template_13_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, BarChartComponent_ng_template_13_ng_container_0_Template, 5, 0, "ng-container", 1);
+    i0.ɵɵtemplate(1, BarChartComponent_ng_template_13_button_1_Template, 2, 0, "button", 17);
+    i0.ɵɵtemplate(2, BarChartComponent_ng_template_13_button_2_Template, 2, 1, "button", 18);
+} if (rf & 2) {
+    const ctx_r4 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngIf", ctx_r4.isEditable);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r4.screenTypes.dashboardBuilder === ctx_r4.screenType);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r4.isDrillThrough && ctx_r4.pages.length > 0);
+} }
+function BarChartComponent_ng_container_17_Template(rf, ctx) { if (rf & 1) {
+    const _r25 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "button", 19);
+    i0.ɵɵlistener("click", function BarChartComponent_ng_container_17_Template_button_click_1_listener() { const restoredCtx = i0.ɵɵrestoreView(_r25); const page_r23 = restoredCtx.$implicit; const ctx_r24 = i0.ɵɵnextContext(); return ctx_r24.pageClick(page_r23); });
+    i0.ɵɵtext(2);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const page_r23 = ctx.$implicit;
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", page_r23.name, "");
+} }
+const _c2 = function () { return { top: true }; };
+const _c3 = function () { return { left: true }; };
+const _c4 = function () { return { right: true }; };
+const _c5 = function () { return { bottom: true }; };
+function BarChartComponent_ng_container_18_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelement(1, "div", 21);
+    i0.ɵɵelement(2, "div", 22);
+    i0.ɵɵelement(3, "div", 23);
+    i0.ɵɵelement(4, "div", 24);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r7 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵclassProp("hide", ctx_r7.handle);
+    i0.ɵɵproperty("resizeEdges", i0.ɵɵpureFunction0(12, _c2));
+    i0.ɵɵadvance(1);
+    i0.ɵɵclassProp("hide", ctx_r7.handle);
+    i0.ɵɵproperty("resizeEdges", i0.ɵɵpureFunction0(13, _c3));
+    i0.ɵɵadvance(1);
+    i0.ɵɵclassProp("hide", ctx_r7.handle);
+    i0.ɵɵproperty("resizeEdges", i0.ɵɵpureFunction0(14, _c4));
+    i0.ɵɵadvance(1);
+    i0.ɵɵclassProp("hide", ctx_r7.handle);
+    i0.ɵɵproperty("resizeEdges", i0.ɵɵpureFunction0(15, _c5));
+} }
+const _c6 = function (a0, a1, a2) { return { "full-body": a0, "selected-resize": a1, "resize-class": a2 }; };
+const _c7 = function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { return { "selected": a0, "full-body": a1, "hidden": a2, "bold-title": a3, "normal-title": a4, "underline-title": a5, "italic-title": a6, "bold-legend": a7, "normal-legend": a8, "underline-legend": a9, "italic-legend": a10 }; };
+const _c8 = function (a0) { return { "full-body": a0 }; };
+const _c9 = function (a0, a1, a2) { return { "dashboard-chart-full-body": a0, "pt-2": a1, "pb-2": a2 }; };
+export class BarChartComponent {
+    /*** Constructor
+     *
+     */
+    constructor(_fieldsListService, // Used for get matrix data
+    _reportBuilderMasterService, _sendToDashboardService, _elementService, _commonService, _drillThroughService, _dashboardService, _router, _filterService) {
+        this._fieldsListService = _fieldsListService;
+        this._reportBuilderMasterService = _reportBuilderMasterService;
+        this._sendToDashboardService = _sendToDashboardService;
+        this._elementService = _elementService;
+        this._commonService = _commonService;
+        this._drillThroughService = _drillThroughService;
+        this._dashboardService = _dashboardService;
+        this._router = _router;
+        this._filterService = _filterService;
+        this.onchartClickedEvent = new EventEmitter();
+        this.onchartRightClickDeleteEvent = new EventEmitter();
+        this.chartRendered = new EventEmitter();
+        this.ScreenType = ScreenType;
+        this.ShowFilters = false;
+        this.titleText = '';
+        this.handle = false;
+        this.dataEvent = 'dataEvent';
+        this.isDataPointSelected = false;
+        this.selectedDataPoints = []; // Holds the all selected points.
+        this.selectedSeriesIndexes = [];
+        this.contextMenuPosition = { x: '0px', y: '0px' };
+        this.pages = [];
+        this.highlightedByOtherChart = false;
+        /****
+         * Resize  chart  styles
+         */
+        this.reportId = 0;
+        /*
+         * Subject object which helps unsubscribe all the subscribed objects in the component
+         */
+        this._unsubscribeAll = new Subject();
+        this.showGhostLoader = true;
+        this.GhostLoaderType = GhostLoaderType;
+        this.BarChartOrientation = BarChartOrientation;
+        this.property = new ChartProperty();
+    }
+    get screenTypes() {
+        return ScreenType;
+    }
+    click(event) {
+        if (event.which === 3 && this.contextMenu.menuOpened) {
+            this.contextMenu.closeMenu();
+        }
+    }
+    // -----------------------------------------------------------------------------------------------------
+    // @ Lifecycle hooks start
+    // 0
+    /**
+     * This will get called after the UI render.
+     */
+    ngAfterViewInit() {
+        setTimeout(() => {
+            this.property.apexChart = new ApexCharts(document.getElementById(this.reportData.guid.toString()), this.barChartOptions);
+            this.property.apexChart.render();
+            this.getChartData();
+        });
+    }
+    /**
+     * NgOnInit LifeCycle hook.
+     * This will get called on component initialization.
+     */
+    ngOnInit() {
+        this.xPosition = this.reportData.xPosition;
+        this.yPosition = this.reportData.yPosition;
+        this.componentRef = this;
+        this.ShowFilters = this._filterService.setVisibilityOfFilterComponent(this.reportData.filters, this.reportData.categories);
+        this.report = this._reportBuilderMasterService.report;
+        this.reportId = this.report?.id;
+        this.property.element = this.reportData;
+        // ApexChart Configurations
+        this.initializeBarChartOptions();
+        //Subscribers for barChart
+        this.subscribers();
+    }
+    /**
+     * This will initialize bar-chart options.basically did apexChart configuration here.
+     */
+    initializeBarChartOptions() {
+        const _reportData = this.reportData;
+        this.barChartOptions = {
+            title: {
+                text: this.reportData.title.text,
+                align: this.reportData.title.position,
+                style: {
+                    color: this.reportData.title.textColor,
+                    fontFamily: this.reportData.title.textStyle,
+                    fontSize: this.reportData.title.textSize
+                }
+            },
+            noData: {
+                text: 'No data to display',
+                align: 'center'
+            },
+            chart: {
+                id: 'apx-' + this.reportData.guid,
+                type: 'bar',
+                height: '100%',
+                width: '100%',
+                stacked: this.reportData.showStack,
+                background: this.reportData.backgroundColor,
+                events: {
+                    dataPointSelection: (crossFilterEvent, chart, opts) => {
+                        this.isDrillThrough = false;
+                        if (crossFilterEvent && crossFilterEvent.button === 2 && opts.dataPointIndex >= 0) {
+                            this.isDrillThrough = true;
+                            this.createDrillThroughFilter(this.reportData.dimension.attribute.series[opts.dataPointIndex]);
+                        }
+                    },
+                    // for deselecting the matrix
+                    click: (crossFilterEvent, chart, opts) => {
+                        this.chartSelect();
+                        if (opts.dataPointIndex >= 0) {
+                            if (this.highlightedByOtherChart) {
+                                this.selectedSeriesIndexes = [];
+                            }
+                            this.saveSelectDataPoints(opts.globals.selectedDataPoints);
+                            this.dataPointSelection(opts);
+                        }
+                        else {
+                            this.resetCrossFilter();
+                        }
+                        this.highlightedByOtherChart = false;
+                        // deselect all selected points.
+                        this.clearSelectedDataPoint();
+                    },
+                },
+                toolbar: {
+                    show: false
+                },
+                animations: {
+                    enabled: false
+                }
+            },
+            plotOptions: {
+                bar: {
+                    horizontal: this.reportData.orientation === BarChartOrientation.horizontal
+                }
+            },
+            dataLabels: {
+                enabled: this.reportData.showDataLabels,
+                style: {
+                    colors: [this.reportData.dataLabelColor]
+                }
+            },
+            yaxis: {
+                axisBorder: {
+                    color: this.reportData.borderColor
+                },
+                labels: {
+                    show: this.reportData.showAxis,
+                    maxWidth: 95,
+                    align: 'left',
+                    style: {
+                        colors: this.reportData.legend.textColor,
+                        fontFamily: this.reportData.legend.textStyle,
+                        fontSize: this.reportData.legend.textSize
+                    }
+                },
+                tooltip: {
+                    enabled: true,
+                    offsetX: 0
+                }
+            },
+            grid: {
+                xaxis: {
+                    lines: {
+                        show: false
+                    }
+                }
+            },
+            legend: {
+                position: this.reportData.legend.position,
+                show: this.reportData.legend.enable,
+                fontSize: this.reportData.legend.textSize,
+                fontFamily: this.reportData.legend.textStyle,
+                horizontalAlign: 'left',
+                labels: {
+                    colors: this.reportData.legend.textColor
+                },
+                markers: {
+                    fillColors: this.getSeriesColors(),
+                }
+            },
+            series: [],
+            xaxis: {
+                labels: {
+                    show: this.reportData.showAxis,
+                    trim: true,
+                    rotate: -60,
+                    maxHeight: 85,
+                },
+                axisBorder: {
+                    color: this.reportData.borderColor
+                },
+                tickAmount: 40,
+                tickPlacement: 'between',
+            },
+            states: {
+                active: {
+                    allowMultipleDataPointsSelection: true,
+                },
+            },
+            fill: {
+                colors: [function ({ seriesIndex }) {
+                        return _reportData.matrix.attributes[seriesIndex].color;
+                    }]
+            }
+        };
+    }
+    /**
+     * This will return series color.
+     */
+    getSeriesColors() {
+        const seriesColors = [];
+        this.reportData?.matrix?.attributes.forEach((atrribute) => {
+            seriesColors.push(atrribute.color);
+        });
+        return seriesColors;
+    }
+    /**
+     * Subscribers for barChart..
+     */
+    subscribers() {
+        /*whenever we change the global filters we got call back from this subscriber*/
+        this._elementService.refreshDataEvent$
+            .pipe(takeUntil(this._unsubscribeAll))
+            .subscribe((val) => {
+            if (val) {
+                this.getChartData();
+            }
+        });
+        /*when we click on bar chart event will be emitted from this subscriber*/
+        this._elementService.crossFilterEvent.subscribe((crossFilter) => {
+            if (crossFilter.resetFilter || crossFilter.values.length == 0) {
+                this.deselectDataPoints(crossFilter);
+            }
+            else {
+                this.createCrossFilter(crossFilter);
+                this.highlightedByOtherChart = true;
+            }
+        });
+        // Get pageslist
+        this._commonService.pageList$.subscribe((page) => {
+            this.pages = [];
+            this.reportData.matrix.attributes?.forEach((attribute) => {
+                page?.forEach((_page) => {
+                    _page?.drillData?.forEach((drillData) => {
+                        if ((drillData.columnName === attribute.columnName && drillData.tableName === attribute.tableName)
+                            || (this.reportData.dimension.attribute && this.reportData.dimension.attribute.columnName === drillData.columnName && this.reportData.dimension.attribute.tableName === drillData.tableName)) {
+                            this.pages.push(_page);
+                        }
+                    });
+                });
+            });
+            this.pages = this.pages.filter(p => p.id !== this.currentPageId);
+        });
+    }
+    /**
+     * Clone selected data points
+     *
+     * @param dataPoints
+     */
+    saveSelectDataPoints(dataPoints) {
+        this.selectedDataPoints = [];
+        dataPoints.forEach((matrixs, ind) => {
+            const points = [];
+            matrixs.forEach((matrix) => {
+                points.push(matrix);
+            });
+            this.selectedDataPoints.push(points);
+        });
+    }
+    /**
+     * Created filter object for cross filtering.
+     *
+     *  @param CrossFilterDto
+     */
+    createCrossFilter(crossFilterData) {
+        const axExpression = new AxExpression();
+        axExpression.comparisonOperator.text = 'In';
+        axExpression.comparisonOperator.value = 'IN';
+        axExpression.valueType = 2;
+        axExpression.field = new Attribute(crossFilterData.attributeData);
+        const axExpTextList = new AxExpTextList();
+        crossFilterData.values.forEach((value) => {
+            axExpTextList.value.push(value);
+        });
+        axExpression.value = axExpTextList;
+        const _searchNodes = new SearchNode();
+        _searchNodes.expression = axExpression;
+        const _filter = new AxFilter();
+        _filter.searchNodes.push(_searchNodes);
+        _filter.appVersionId = 0;
+        this.getCrossFilterData(_filter, crossFilterData);
+    }
+    /**
+     * pushed the filter object into basic filter and applied the filter on the data
+     *
+     *  @param CrossFilterDto
+     *  @param AxFilter
+     */
+    getCrossFilterData(_filter, crossFilterData) {
+        if (this.reportData.matrix.attributes.length && this.reportData.dimension.attribute) {
+            const elementDto = new ElementsDto(this.reportData);
+            elementDto.filters.localFilters.basic = this._elementService.getValidFilter(this.reportData.filters);
+            elementDto.filters.localFilters.basic.push(_filter);
+            elementDto.filters.localFilters.category = this._elementService.getValidFilterCategory(this.reportData.categories);
+            elementDto.filters.globalFilters.basic = this._elementService.getValidFilter(this._elementService.filtersDto.basic);
+            elementDto.filters.globalFilters.category = this._elementService.getValidFilterCategory(this._elementService.filtersDto.category);
+            elementDto.reportId = this.reportId;
+            if (crossFilterData.selectedIndexLength === 0) {
+                elementDto.filters.localFilters.basic = [];
+                this.deselectDataPoints(crossFilterData);
+            }
+            this._fieldsListService
+                .getMatrixData(elementDto)
+                .then((entitiesAttribute) => {
+                const selectedDataPointArray = [];
+                entitiesAttribute.dimension.attribute.series.forEach((_elementDto) => {
+                    const seriesIndex = (this.reportData.dimension.attribute.series.indexOf(_elementDto));
+                    selectedDataPointArray.push(seriesIndex);
+                });
+                //if matrix is not same then crossfilter should not apply
+                if (entitiesAttribute != null) {
+                    this.highlightSeriesData(selectedDataPointArray);
+                }
+            });
+        }
+    }
+    /**
+     * set data to chart if entitiesAttribute is not equal to null then this method will call and will highlight the matrix
+     */
+    highlightSeriesData(indexList) {
+        const _reportData = this.reportData;
+        this.property.apexChart.updateOptions({
+            fill: {
+                colors: [function ({ seriesIndex, dataPointIndex }) {
+                        if (indexList.includes(dataPointIndex)) {
+                            return _reportData.matrix.attributes[seriesIndex].color;
+                        }
+                        else {
+                            return _reportData.matrix.attributes[seriesIndex].color + '60';
+                        }
+                    }]
+            }
+        });
+    }
+    /**
+     * Clear the selected data points.
+     */
+    clearSelectedDataPoint() {
+        this.selectedDataPoints.forEach((matrixs, ind) => {
+            matrixs.forEach((matrix, matInd) => {
+                this.property.apexChart.toggleDataPointSelection(ind, matrix);
+            });
+        });
+        this.selectedDataPoints = [];
+    }
+    /**
+     *
+     * Called when we select a bar by a click event
+     *
+     * @param opts
+     */
+    dataPointSelection(opts) {
+        let crossFilterDto;
+        if (opts.dataPointIndex >= 0) {
+            crossFilterDto = {
+                values: [],
+                attributeData: this.reportData.dimension.attribute,
+                chartType: this.reportData.type,
+                elementGuid: this.reportData.guid,
+                resetFilter: false,
+                selectedIndexLength: 1
+            };
+            if (this.selectedSeriesIndexes.includes(opts.dataPointIndex)) {
+                const ind = this.selectedSeriesIndexes.indexOf(opts.dataPointIndex);
+                this.selectedSeriesIndexes.splice(ind, 1);
+            }
+            else {
+                this.selectedSeriesIndexes.push(opts.dataPointIndex);
+            }
+            //if index is already present in selectedDataPoints array then pop the specific index
+            this.selectedSeriesIndexes.forEach((index) => {
+                if (crossFilterDto.values.includes(this.reportData.dimension.attribute.series[index])) {
+                    crossFilterDto.values.splice(crossFilterDto.values.indexOf(this.reportData.dimension.attribute.series[index]), 1);
+                }
+                else {
+                    crossFilterDto.values.push(this.reportData.dimension.attribute.series[index]);
+                }
+            });
+        }
+        this._elementService.triggerCrossFilter(crossFilterDto);
+    }
+    /**
+     * Reset cross filter and emit reset cross filter event.
+     */
+    resetCrossFilter() {
+        let crossFilterDto;
+        crossFilterDto = {
+            values: null,
+            attributeData: null,
+            chartType: this.reportData.type,
+            elementGuid: this.reportData.guid,
+            resetFilter: true,
+            selectedIndexLength: 0
+        };
+        this.selectedSeriesIndexes = [];
+        this._elementService.triggerCrossFilter(crossFilterDto);
+    }
+    /**
+     * On destroy
+     */
+    ngOnDestroy() {
+        // Unsubscribe from all subscriptions
+        this._unsubscribeAll.next();
+        this._unsubscribeAll.complete();
+    }
+    // -----------------------------------------------------------------------------------------------------
+    // @ Lifecycle hooks end
+    // -----------------------------------------------------------------------------------------------------
+    /**
+     * Get data
+     */
+    getChartData() {
+        if (this.reportData.matrix.attributes.length && this.reportData.dimension.attribute) {
+            if (this.drillThroughParentType == ScreenType.dashboardBuilder || this.drillThroughParentType == ScreenType.containerDashboard) {
+                this.reportData.apiType = 'dashboard';
+            }
+            const data = new ElementsDto(this.reportData);
+            if (this.screenType === this.screenTypes.drillThrough) {
+                data.filters.globalFilters.basic.push(this.drillThroughFilterInput);
+            }
+            else {
+                data.filters.globalFilters.basic = this._elementService.getValidFilter(this._elementService.filtersDto.basic, ScopeType.global);
+                data.filters.globalFilters.category = this._elementService.getValidFilterCategory(this._elementService.filtersDto.category, ScopeType.global);
+            }
+            data.filters.localFilters.basic = this._elementService.getValidFilter(this.reportData.filters);
+            data.filters.localFilters.category = this._elementService.getValidFilterCategory(this.reportData.categories);
+            data.reportId = this.reportId;
+            this._fieldsListService.getMatrixData(data).then((entitiesAttribute) => {
+                if (entitiesAttribute != null) {
+                    this.chartRendered.emit();
+                    this.setDataToChart(entitiesAttribute);
+                    this.showGhostLoader = false;
+                }
+            });
+        }
+        else {
+            this.chartRendered.emit();
+            this.showGhostLoader = false;
+        }
+    }
+    /**
+     * set data to chart if entitiesAttribute is not equal to null then this method will call
+     */
+    setDataToChart(entitiesAttribute) {
+        const matrixData = [];
+        this.reportData.matrix.attributes = entitiesAttribute.matrix.attributes;
+        this.reportData.dimension.attribute = entitiesAttribute.dimension.attribute;
+        this.reportData.sqlQuery = entitiesAttribute.sqlQuery;
+        for (const attribute of this.reportData.matrix.attributes) {
+            matrixData.push({
+                data: attribute.series,
+                name: attribute.label,
+            });
+        }
+        this.property.apexChart.updateOptions({
+            xaxis: { categories: this.reportData.dimension.attribute.series }
+        });
+        this.property.apexChart.updateSeries(matrixData);
+    }
+    /**
+     * attributeDropped
+     * Called when attribute is dragged from left side fields list and dropped on the bar chart
+     *
+     * @param $event
+     */
+    attributeDropped($event) {
+        $event.item.data.aggregateFn = 'count';
+        if (this.reportData.matrix.attributes.length === 0 &&
+            this.reportData.dimension.attribute == null) {
+            this.reportData.matrix = new Matrix();
+            this.reportData.matrix.attributes.push(new AttributeData($event.item.data));
+            this.reportData.dimension = new Dimension();
+            this.reportData.dimension.attribute = new AttributeData($event.item.data);
+            this.reportData.dimension.attribute.aggregateFn = 'none';
+        }
+        else if (this.reportData.matrix.attributes.length > 0 &&
+            $event.item.data.enlightenType instanceof Text &&
+            this.reportData.dimension.attribute == null) {
+            this.reportData.dimension.attribute = new AttributeData($event.item.data);
+        }
+        else {
+            this.reportData.matrix.attributes.push(new AttributeData($event.item.data));
+            const seriesData = [];
+            this.reportData.matrix.attributes.forEach((attr) => {
+                seriesData.push({
+                    name: attr.label,
+                    data: attr.series,
+                    color: attr.color
+                });
+            });
+            this.barChartOptions.series = seriesData;
+        }
+        this._commonService.isReportBuilderDirty = true;
+        this.getChartData();
+    }
+    chartSelect() {
+        this.onchartClickedEvent.emit(this.property);
+    }
+    /**
+     * Created filter object for cross filtering.
+     *
+     *  @param CrossFilterDto
+     */
+    createDrillThroughFilter(series) {
+        const axExpression = new AxExpression();
+        axExpression.comparisonOperator.text = 'In';
+        axExpression.comparisonOperator.value = 'IN';
+        axExpression.valueType = 2;
+        axExpression.field = new Attribute(this.reportData.dimension.attribute);
+        const axExpTextList = new AxExpTextList();
+        axExpTextList.value.push(series);
+        axExpTextList.isSearchable = true;
+        axExpression.value = axExpTextList;
+        const _searchNodes = new SearchNode();
+        _searchNodes.expression = axExpression;
+        this.drillThroughFilter = new AxFilter();
+        this.drillThroughFilter.searchNodes.push(_searchNodes);
+        this.drillThroughFilter.appVersionId = 0;
+    }
+    /***
+     * On chart context  click Function
+     */
+    onContextMenu(event, chart) {
+        if (!this.isEditable &&
+            ([this.screenTypes.containerDashboard, this.screenTypes.drillThrough].includes(this.screenType))
+            && !this.pages.length) {
+            event.preventDefault();
+            return;
+        }
+        if (!this.isEditable && (this.screenType !== ScreenType.drillThrough)) {
+            const centralPage = document.getElementById(this.guid);
+            const centralPageBounds = centralPage.getBoundingClientRect();
+            event.preventDefault();
+            this.contextMenuPosition.x = (event.clientX - centralPageBounds.x) + 'px';
+            this.contextMenuPosition.y = (event.clientY - centralPageBounds.y) + 'px';
+            this.contextMenu.menuData = { chart: chart };
+            this.contextMenu.menu.focusFirstItem('mouse');
+            this.contextMenu.openMenu();
+        }
+        else {
+            event.preventDefault();
+            this.contextMenuPosition.x = event.clientX + 'px';
+            this.contextMenuPosition.y = event.clientY + 'px';
+            this.contextMenu.menuData = { chart: chart };
+            this.contextMenu.menu.focusFirstItem('mouse');
+            this.contextMenu.openMenu();
+        }
+    }
+    /***
+     * Delete chart Function
+     */
+    openOptionPopUp() {
+        this.onchartRightClickDeleteEvent.emit(this.uniquekey);
+    }
+    onDeleteClick(event) {
+        this._commonService.isDashboardBuilderDirty = true;
+        event.preventDefault();
+        event.stopPropagation();
+        // item.isDeleted = true_d
+        this._dashboardService.deleteDashboardElement(this.reportData);
+        this.contextMenu.closeMenu();
+    }
+    /***
+     * Pin to Dashboard Function
+     */
+    sendToDashboard() {
+        const sendToDashboardData = {
+            filter: null,
+            filterCategory: null,
+            appVersionId: this.report.appVersionId,
+            type: 'element',
+            element: this.reportData
+        };
+        this._sendToDashboardService.sendToDashboard(sendToDashboardData);
+    }
+    /****
+     * chartResizeMinDimensions =   this function use  Resize min dimensions validation
+     */
+    chartResizeMinDimensions(event) {
+        const MIN_DIMENSIONS_PX = 50;
+        this._commonService.isReportBuilderDirty = true;
+        if (event.rectangle.width &&
+            event.rectangle.height &&
+            (event.rectangle.width < MIN_DIMENSIONS_PX ||
+                event.rectangle.height < MIN_DIMENSIONS_PX)) {
+            return false;
+        }
+        return true;
+    }
+    /****
+     * onResizing = this function use for resize the  chart
+     */
+    onResizing(event) {
+        const centralPage = document.getElementById('central-page');
+        const centralPageBounds = centralPage.getBoundingClientRect();
+        if (event.rectangle.right >= centralPageBounds.right && event.edges.right) {
+            event.rectangle.right = centralPageBounds.right;
+        }
+        else if (event.rectangle.left < centralPageBounds.left) {
+            event.rectangle.left = centralPageBounds.left;
+        }
+        else if (event.rectangle.bottom > centralPageBounds.bottom) {
+            event.rectangle.bottom = centralPageBounds.bottom;
+        }
+        else if (event.rectangle.top < centralPageBounds.top) {
+            event.rectangle.top = centralPageBounds.top;
+        }
+        event.rectangle.width = event.rectangle.right - event.rectangle.left;
+        event.rectangle.height = event.rectangle.bottom - event.rectangle.top;
+        if (event.edges.bottom !== 0 &&
+            event.edges.top !== 0 &&
+            event.edges.left !== 0 &&
+            event.edges.right !== 0) {
+            event.edges.top = this.yPosition + Number(event.edges.top);
+            event.edges.left = this.xPosition + Number(event.edges.left);
+            this.reportData.resizeChart(event, this.property.apexChart);
+        }
+    }
+    /**
+     * Called when resizing ends
+     */
+    resizeEnd() {
+        this.xPosition = this.reportData.xPosition;
+        this.yPosition = this.reportData.yPosition;
+    }
+    /**
+     * to set isDirty after changes in bar-chart filter
+     *
+     */
+    dirtyFlowCheckEvent() {
+        this._commonService.isReportBuilderDirty = true;
+    }
+    /**
+     * call cdk drag start event
+     *
+     * @param $event
+     */
+    dragStart($event) {
+        this.handle = true;
+    }
+    /**
+     * call cdk drag end event
+     *
+     * @param $event
+     */
+    dragEnd($event) {
+        this.handle = false;
+        this.xPosition = this.reportData.xPosition;
+        this.yPosition = this.reportData.yPosition;
+    }
+    /**
+     * Deselecting the selected matrix
+     *
+     */
+    deselectDataPoints(crossFilterData) {
+        const _reportData = this.reportData;
+        this.selectedDataPoints.forEach((dataPointIndexs, ind) => {
+            // if(this.reportData.guid != crossFilterData.elementGuid){
+            dataPointIndexs.forEach((attributeInd) => {
+                this.property.apexChart.toggleDataPointSelection(ind, attributeInd);
+            });
+            // }
+        });
+        this.property.apexChart.updateOptions({
+            fill: {
+                colors: [function ({ value, seriesIndex }) {
+                        return _reportData.matrix.attributes[seriesIndex].color;
+                    }]
+            }
+        });
+        this.selectedDataPoints = [];
+    }
+    /**
+     * Called on page name clicked on dropdown options of drill through pages
+     *
+     * @param page
+     */
+    pageClick(page) {
+        if (this.screenType !== ScreenType.drillThrough) {
+            if (this.drillThroughParentType ? this.drillThroughParentType == ScreenType.reportBuilder : this.isEditable) {
+                this._drillThroughService.setParentData(this.reportId, this._reportBuilderMasterService.report.name, this._router.url);
+                this.navigateToDrillThrough(page);
+            }
+            else {
+                this._dashboardService.dashboard$.pipe(takeUntil(this._unsubscribeAll)).subscribe((dashboard) => {
+                    this._drillThroughService.setParentData(this.reportId, dashboard.name, this._router.url);
+                    this.navigateToDrillThrough(page);
+                });
+            }
+        }
+        else {
+            this.navigateToDrillThrough(page);
+        }
+    }
+    /**
+     * Navigate to drill through component with page id as route params
+     * Checks the parent URL if it is already exists or not
+     *
+     * @param page
+     */
+    navigateToDrillThrough(page) {
+        const parentUrl = this._drillThroughService.getParentData().url;
+        this._drillThroughService.drillPage(page, this.drillThroughFilter);
+        if (!parentUrl) {
+            this._router.navigate([this._router.url + '/drill-through/' + page.id]);
+        }
+        else {
+            this._router.navigate([parentUrl, 'drill-through', page.id]);
+        }
+    }
+    /**
+     * Apply local filter.
+     */
+    applyLocalFilter() {
+        this.getChartData();
+    }
+}
+BarChartComponent.ɵfac = function BarChartComponent_Factory(t) { return new (t || BarChartComponent)(i0.ɵɵdirectiveInject(i1.FieldsListService), i0.ɵɵdirectiveInject(i2.ReportBuilderMasterService), i0.ɵɵdirectiveInject(i3.SendToDashboardService), i0.ɵɵdirectiveInject(i4.ElementService), i0.ɵɵdirectiveInject(i5.CommonService), i0.ɵɵdirectiveInject(i6.DrillThroughService), i0.ɵɵdirectiveInject(i7.DashboardBuilderService), i0.ɵɵdirectiveInject(i8.Router), i0.ɵɵdirectiveInject(i9.FiltersService)); };
+BarChartComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: BarChartComponent, selectors: [["bar-chart"]], viewQuery: function BarChartComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5);
+        i0.ɵɵviewQuery(MatMenuTrigger, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.barChartContainer = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.contextMenu = _t.first);
+    } }, hostBindings: function BarChartComponent_HostBindings(rf, ctx) { if (rf & 1) {
+        i0.ɵɵlistener("mousedown", function BarChartComponent_mousedown_HostBindingHandler($event) { return ctx.click($event); }, false, i0.ɵɵresolveWindow);
+    } }, inputs: { currentPageId: "currentPageId", reportData: "reportData", isEditable: "isEditable", guid: "guid", screenType: "screenType", drillThroughFilterInput: "drillThroughFilterInput", drillThroughParentType: "drillThroughParentType", appVersionId: "appVersionId" }, outputs: { onchartClickedEvent: "onchartClickedEvent", onchartRightClickDeleteEvent: "onchartRightClickDeleteEvent", chartRendered: "chartRendered" }, decls: 19, vars: 51, consts: [["id", "bar-chart-container", "mwlResizable", "", 1, "chart-resize", 2, "width", "fit-content", "height", "fit-content", 3, "ngClass", "validateResize", "resizing", "resizeEnd"], [4, "ngIf"], ["cdkDrag", "", "cdkDragBoundary", ".page", "cdkDropList", "", 1, "bar-chart-box", "chart-padding", 2, "max-width", "100%", "max-width", "100%", 3, "ngClass", "id", "cdkDragData", "cdkDragDisabled", "cdkDragStarted", "cdkDragEnded", "click", "cdkDropListDropped", "contextmenu"], [1, "chart-inner-container", 3, "ngClass"], ["class", "filter-body pl-3", 3, "ngClass", "click", 4, "ngIf"], [1, "bar-chart-body", 3, "ngClass"], [1, "chart", "h-full", "w-full", 3, "id"], ["chart", ""], [2, "visibility", "hidden", "position", "fixed", 3, "matMenuTriggerFor"], ["contextMenu", "matMenu"], [1, "chart-menu"], ["matMenuContent", ""], ["drillThrough", "matMenu"], [4, "ngFor", "ngForOf"], [3, "elementType"], [1, "filter-body", "pl-3", 3, "ngClass", "click"], [3, "filters", "categories", "reportId", "dataModel", "screenType", "isEditable", "appVersion", "dirtyFlowCheckEvent", "applyFilterEvent"], ["mat-menu-item", "", 3, "click", 4, "ngIf"], ["mat-menu-item", "", 3, "matMenuTriggerFor", 4, "ngIf"], ["mat-menu-item", "", 3, "click"], ["mat-menu-item", "", 3, "matMenuTriggerFor"], ["mwlResizeHandle", "", 1, "resize-handle-top", 3, "resizeEdges"], ["mwlResizeHandle", "", 1, "resize-handle-left", 3, "resizeEdges"], ["mwlResizeHandle", "", 1, "resize-handle-right", 3, "resizeEdges"], ["mwlResizeHandle", "", 1, "resize-handle-bottom", 3, "resizeEdges"]], template: function BarChartComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵlistener("validateResize", function BarChartComponent_Template_div_validateResize_0_listener($event) { return ctx.chartResizeMinDimensions($event); })("resizing", function BarChartComponent_Template_div_resizing_0_listener($event) { return ctx.onResizing($event); })("resizeEnd", function BarChartComponent_Template_div_resizeEnd_0_listener() { return ctx.resizeEnd(); });
+        i0.ɵɵtemplate(1, BarChartComponent_ng_container_1_Template, 3, 2, "ng-container", 1);
+        i0.ɵɵelementStart(2, "div", 2);
+        i0.ɵɵlistener("cdkDragStarted", function BarChartComponent_Template_div_cdkDragStarted_2_listener($event) { return ctx.dragStart($event); })("cdkDragEnded", function BarChartComponent_Template_div_cdkDragEnded_2_listener($event) { return ctx.dragEnd($event); })("click", function BarChartComponent_Template_div_click_2_listener($event) { ctx.chartSelect(); return $event.stopPropagation(); })("cdkDropListDropped", function BarChartComponent_Template_div_cdkDropListDropped_2_listener($event) { return ctx.attributeDropped($event); })("contextmenu", function BarChartComponent_Template_div_contextmenu_2_listener($event) { return ctx.onContextMenu($event, ctx.reportData); });
+        i0.ɵɵelementStart(3, "div", 3);
+        i0.ɵɵtemplate(4, BarChartComponent_div_4_Template, 2, 11, "div", 4);
+        i0.ɵɵelementStart(5, "div", 5);
+        i0.ɵɵelement(6, "div", 6, 7);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementContainerStart(8);
+        i0.ɵɵelement(9, "div", 8);
+        i0.ɵɵelementStart(10, "mat-menu", null, 9);
+        i0.ɵɵelementStart(12, "div", 10);
+        i0.ɵɵtemplate(13, BarChartComponent_ng_template_13_Template, 3, 3, "ng-template", 11);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementContainerEnd();
+        i0.ɵɵelementStart(14, "mat-menu", null, 12);
+        i0.ɵɵelementStart(16, "div", 10);
+        i0.ɵɵtemplate(17, BarChartComponent_ng_container_17_Template, 3, 1, "ng-container", 13);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(18, BarChartComponent_ng_container_18_Template, 5, 16, "ng-container", 1);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        const _r3 = i0.ɵɵreference(11);
+        i0.ɵɵstyleProp("top", ctx.reportData.yPosition, "px")("left", ctx.reportData.xPosition, "px")("width", ctx.reportData.width, "px")("height", ctx.reportData.height, "px");
+        i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction3(29, _c6, !ctx.isEditable && ctx.screenType !== ctx.screenTypes.drillThrough, ctx.reportData.isSelected && !ctx.handle, !ctx.handle));
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.showGhostLoader);
+        i0.ɵɵadvance(1);
+        i0.ɵɵstyleProp("width", ctx.reportData.width, "px")("height", ctx.reportData.height, "px");
+        i0.ɵɵproperty("ngClass", i0.ɵɵpureFunctionV(33, _c7, [ctx.reportData.isSelected, !ctx.isEditable, ctx.showGhostLoader, ctx.reportData.title.fontStyle.fontWeight == "bold", ctx.reportData.title.fontStyle.fontWeight == "normal", ctx.reportData.title.fontStyle.textDecoration == "underline", ctx.reportData.title.fontStyle.isItalicFont, ctx.reportData.legend.fontStyle.fontWeight == "bold", ctx.reportData.legend.fontStyle.fontWeight == "normal", ctx.reportData.legend.fontStyle.textDecoration == "underline", ctx.reportData.legend.fontStyle.isItalicFont]))("id", "cdk-drop-" + ctx.reportData.guid)("cdkDragData", ctx.reportData)("cdkDragDisabled", !ctx.isEditable || ctx.screenType === ctx.screenTypes.drillThrough);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(45, _c8, !ctx.isEditable));
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.isEditable || ctx.reportData.filters.length > 0 || ctx.reportData.categories.length > 0);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction3(47, _c9, !ctx.isEditable && !ctx.reportData.filters.length && !ctx.reportData.categories.length, ctx.isEditable || ctx.reportData.filters.length > 0 || ctx.reportData.categories.length > 0, ctx.isEditable));
+        i0.ɵɵadvance(1);
+        i0.ɵɵpropertyInterpolate("id", ctx.reportData.guid);
+        i0.ɵɵadvance(3);
+        i0.ɵɵstyleProp("left", ctx.contextMenuPosition.x)("top", ctx.contextMenuPosition.y);
+        i0.ɵɵproperty("matMenuTriggerFor", _r3);
+        i0.ɵɵadvance(8);
+        i0.ɵɵproperty("ngForOf", ctx.pages);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.isEditable && !ctx.showGhostLoader);
+    } }, styles: ["bar-chart mwlResizable{box-sizing:border-box}bar-chart .chart-resize{position:absolute;display:flex;align-items:center;justify-content:center;cursor:pointer;margin:auto;resize:both;overflow:visible;z-index:1}bar-chart .resize-handle-top,bar-chart .resize-handle-bottom{position:absolute;height:5px;width:24px;background-color:#3699ff;cursor:row-resize;z-index:11;display:none}bar-chart .resize-handle-top{top:-2px;z-index:11}bar-chart .resize-handle-bottom{bottom:-2px}bar-chart .resize-handle-right-img{position:absolute;bottom:5px;right:5px;cursor:se-resize;height:10px;width:10px}bar-chart .resize-handle-left,bar-chart .resize-handle-right{position:absolute;background-color:#3699ff;cursor:col-resize;height:24px;width:5px;z-index:11;display:none}bar-chart .resize-handle-left{left:-2px;z-index:11}bar-chart .resize-handle-right{right:-2px;z-index:11}bar-chart .full-body{width:100%!important;height:100%!important}bar-chart .selected{border:1px solid #3699FF;z-index:11}bar-chart .selected-resize{z-index:11}bar-chart .selected-resize .resize-handle-top,bar-chart .selected-resize .resize-handle-bottom,bar-chart .selected-resize .resize-handle-left,bar-chart .selected-resize .resize-handle-right{display:inline}bar-chart .filter-body{padding-left:.625rem;height:3.7rem}bar-chart .dashboard-chart-full-body{height:100%!important;padding:17px .8rem 10px!important}.bar-chart-box{width:100%;height:100%;border:1px solid #EDEDED;cursor:move;text-align:center;background:#fff;position:relative;overflow:visible;transition:box-shadow .2s cubic-bezier(0,0,.2,1);border-radius:10px}.bar-chart-box:hover{border:1.5px solid #3699FF}.bar-chart-box .chart-box:active{box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f}.bar-chart-box .chart-inner-container{height:100%}.bar-chart-box path,.bar-chart-box .apexcharts-legend{cursor:pointer}.bar-chart-body{height:calc(100% - 4rem);padding:0 .8rem .2rem}.bar-chart-body .inner-chart{min-height:unset!important}.hide{display:none}.chart-resize .cdk-drag-placeholder{display:none!important}.apexcharts-legend-series{display:inline-block!important;white-space:nowrap;padding:.2rem;overflow:hidden;text-overflow:ellipsis!important;text-align:left}.apexcharts-legend-series span.apexcharts-legend-marker{height:10px;min-height:10px;max-height:10px;max-width:10px;min-width:10px;width:10px}.position-right,.position-left{max-width:33%;border-bottom:1rem solid transparent}.position-right .apexcharts-legend-series,.position-left .apexcharts-legend-series{width:calc(100% - 1rem)!important}.position-right .apexcharts-legend-series .apexcharts-legend-text,.position-left .apexcharts-legend-series .apexcharts-legend-text{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;text-align:left}.apexcharts-canvas svg{border-radius:10px}\n"], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BarChartComponent, [{
+        type: Component,
+        args: [{ selector: 'bar-chart', encapsulation: ViewEncapsulation.None, template: "\n  <!-- Resizable div -->\n  <div id=\"bar-chart-container\" class=\"chart-resize \" mwlResizable (validateResize)=\"chartResizeMinDimensions($event)\"  [ngClass]=\"{'full-body' : !isEditable && (screenType !== screenTypes.drillThrough),'selected-resize':reportData.isSelected && !handle, 'resize-class': !handle}\" (resizing)=\"onResizing($event)\" [style.top.px]=\"reportData.yPosition\" style=\"width: fit-content;height: fit-content;\" [style.left.px]=\"reportData.xPosition\" [style.width.px]=\"reportData.width\" [style.height.px]=\"reportData.height\" (resizeEnd)=\"resizeEnd()\">\n    <!-- Chart bodt -->\n    <ng-container *ngIf=\"showGhostLoader\">\n      <ng-container *ngIf=\"reportData.orientation == BarChartOrientation.horizontal\">\n        <app-ghost-loader [elementType]=\"GhostLoaderType.BarChartLoaderHorizontal\" ></app-ghost-loader>\n      </ng-container>\n      <ng-container *ngIf=\"reportData.orientation != BarChartOrientation.horizontal\">\n        <app-ghost-loader [elementType]=\"GhostLoaderType.BarChartLoaderVertical\"></app-ghost-loader>\n      </ng-container>\n\n    </ng-container>\n    <div\n    class=\"bar-chart-box chart-padding\"\n    [style.width.px]=\"reportData.width\" [style.height.px]=\"reportData.height\"\n    style=\"max-width: 100%; max-width: 100%;\"\n        (cdkDragStarted)=\"dragStart($event)\"\n        (cdkDragEnded)=\"dragEnd($event)\"\n        [ngClass]=\"{\n            'selected':reportData.isSelected,\n            'full-body' : !isEditable,\n            'hidden': showGhostLoader ,\n            'bold-title':reportData.title.fontStyle.fontWeight == 'bold',\n            'normal-title':reportData.title.fontStyle.fontWeight == 'normal',\n            'underline-title':reportData.title.fontStyle.textDecoration == 'underline',\n            'italic-title':reportData.title.fontStyle.isItalicFont,\n            'bold-legend':reportData.legend.fontStyle.fontWeight == 'bold',\n            'normal-legend':reportData.legend.fontStyle.fontWeight == 'normal',\n            'underline-legend':reportData.legend.fontStyle.textDecoration == 'underline',\n            'italic-legend':reportData.legend.fontStyle.isItalicFont\n        }\"\n        cdkDrag   [id]=\"'cdk-drop-'+reportData.guid\"\n    (click)=\"chartSelect(); $event.stopPropagation();\" (cdkDropListDropped)=\"attributeDropped($event)\"\n      [cdkDragData]=\"reportData\" cdkDragBoundary=\".page\" cdkDropList (contextmenu)=\"onContextMenu($event, reportData)\" [cdkDragDisabled]=\"!isEditable || (screenType === screenTypes.drillThrough)\">\n      <div [ngClass]=\"{'full-body' : !isEditable }\"  class=\"chart-inner-container\">\n        <!-- Filter Container -->\n        <!-- for future use-->\n        <div class=\"filter-body pl-3\" [ngClass]=\"{'local-body' : !isEditable, 'hidden': screenType != ScreenType.reportBuilder && !ShowFilters }\" *ngIf=\"isEditable || reportData.filters.length>0 || reportData.categories.length>0\" (click) = \"$event.stopPropagation();\">\n            <lib-report-filter\n                [filters]=\"reportData.filters\"\n                [categories]=\"reportData.categories\"\n                [reportId]=\"reportId\"\n                [dataModel]=\"dataModel\"\n                [screenType]=\"screenType\"\n                [isEditable]=\"isEditable\"\n                [appVersion]=\"appVersionId\"\n                (dirtyFlowCheckEvent)=\"dirtyFlowCheckEvent()\"\n                (applyFilterEvent)=\"applyLocalFilter()\"\n            >\n            </lib-report-filter>\n        </div>\n        <!-- Chart Container -->\n        <div class=\"bar-chart-body\" [ngClass]=\"{'dashboard-chart-full-body': !isEditable && !reportData.filters.length && !reportData.categories.length, 'pt-2': isEditable || reportData.filters.length>0 || reportData.categories.length>0, 'pb-2':isEditable }\">\n            <div id=\"{{reportData.guid}}\" class=\"chart h-full\tw-full\" #chart></div>\n        </div>\n\n        <!---------------------------------------- Mat Menu trigger For Menu Options ----------------------------->\n        <ng-container>\n          <div style=\"visibility: hidden; position: fixed\" [style.left]=\"contextMenuPosition.x\"\n          [style.top]=\"contextMenuPosition.y\" [matMenuTriggerFor]=\"contextMenu\">\n          </div>\n\n          <!-- Mat Menu PopUp -->\n          <mat-menu #contextMenu=\"matMenu\">\n            <div class=\"chart-menu\">\n              <ng-template matMenuContent let-item=\"reportData\">\n                <ng-container *ngIf='isEditable'>\n                  <button mat-menu-item (click)=\"sendToDashboard($event)\">Pin to Dashboard</button>\n                  <button mat-menu-item (click)=\"openOptionPopUp($event)\">Delete</button>\n                </ng-container>\n                <button mat-menu-item *ngIf=\"screenTypes.dashboardBuilder === screenType\" (click)=\"onDeleteClick($event)\" >Remove From Dashboard</button>\n                <button mat-menu-item *ngIf=\"isDrillThrough && pages.length > 0\" [matMenuTriggerFor]=\"drillThrough\">Drill Through</button>\n              </ng-template>\n            </div>\n          </mat-menu>\n        </ng-container>\n        <mat-menu #drillThrough=\"matMenu\">\n          <div class=\"chart-menu\">\n            <ng-container *ngFor=\" let page of pages\">\n                <button mat-menu-item (click)='pageClick(page)'> {{page.name}}</button>\n            </ng-container>\n          </div>\n        </mat-menu>\n        <!-- --------------------------------------------------------------------------- -->\n      </div>\n    </div>\n    <ng-container *ngIf='isEditable && !showGhostLoader'>\n        <!-- Resize handles  -->\n      <div  class=\"resize-handle-top\"  [class.hide] = \"handle\"  mwlResizeHandle [resizeEdges]=\"{ top: true }\"></div>\n      <div class=\"resize-handle-left\"  [class.hide] = \"handle\"  mwlResizeHandle [resizeEdges]=\"{ left: true }\"></div>\n      <div class=\"resize-handle-right\"  [class.hide] = \"handle\"  mwlResizeHandle [resizeEdges]=\"{ right: true }\"></div>\n      <div class=\"resize-handle-bottom\"  [class.hide] = \"handle\"  mwlResizeHandle [resizeEdges]=\"{ bottom: true }\"></div>\n    </ng-container>\n  </div>\n", styles: ["bar-chart mwlResizable{box-sizing:border-box}bar-chart .chart-resize{position:absolute;display:flex;align-items:center;justify-content:center;cursor:pointer;margin:auto;resize:both;overflow:visible;z-index:1}bar-chart .resize-handle-top,bar-chart .resize-handle-bottom{position:absolute;height:5px;width:24px;background-color:#3699ff;cursor:row-resize;z-index:11;display:none}bar-chart .resize-handle-top{top:-2px;z-index:11}bar-chart .resize-handle-bottom{bottom:-2px}bar-chart .resize-handle-right-img{position:absolute;bottom:5px;right:5px;cursor:se-resize;height:10px;width:10px}bar-chart .resize-handle-left,bar-chart .resize-handle-right{position:absolute;background-color:#3699ff;cursor:col-resize;height:24px;width:5px;z-index:11;display:none}bar-chart .resize-handle-left{left:-2px;z-index:11}bar-chart .resize-handle-right{right:-2px;z-index:11}bar-chart .full-body{width:100%!important;height:100%!important}bar-chart .selected{border:1px solid #3699FF;z-index:11}bar-chart .selected-resize{z-index:11}bar-chart .selected-resize .resize-handle-top,bar-chart .selected-resize .resize-handle-bottom,bar-chart .selected-resize .resize-handle-left,bar-chart .selected-resize .resize-handle-right{display:inline}bar-chart .filter-body{padding-left:.625rem;height:3.7rem}bar-chart .dashboard-chart-full-body{height:100%!important;padding:17px .8rem 10px!important}.bar-chart-box{width:100%;height:100%;border:1px solid #EDEDED;cursor:move;text-align:center;background:#fff;position:relative;overflow:visible;transition:box-shadow .2s cubic-bezier(0,0,.2,1);border-radius:10px}.bar-chart-box:hover{border:1.5px solid #3699FF}.bar-chart-box .chart-box:active{box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f}.bar-chart-box .chart-inner-container{height:100%}.bar-chart-box path,.bar-chart-box .apexcharts-legend{cursor:pointer}.bar-chart-body{height:calc(100% - 4rem);padding:0 .8rem .2rem}.bar-chart-body .inner-chart{min-height:unset!important}.hide{display:none}.chart-resize .cdk-drag-placeholder{display:none!important}.apexcharts-legend-series{display:inline-block!important;white-space:nowrap;padding:.2rem;overflow:hidden;text-overflow:ellipsis!important;text-align:left}.apexcharts-legend-series span.apexcharts-legend-marker{height:10px;min-height:10px;max-height:10px;max-width:10px;min-width:10px;width:10px}.position-right,.position-left{max-width:33%;border-bottom:1rem solid transparent}.position-right .apexcharts-legend-series,.position-left .apexcharts-legend-series{width:calc(100% - 1rem)!important}.position-right .apexcharts-legend-series .apexcharts-legend-text,.position-left .apexcharts-legend-series .apexcharts-legend-text{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;text-align:left}.apexcharts-canvas svg{border-radius:10px}\n"] }]
+    }], function () { return [{ type: i1.FieldsListService }, { type: i2.ReportBuilderMasterService }, { type: i3.SendToDashboardService }, { type: i4.ElementService }, { type: i5.CommonService }, { type: i6.DrillThroughService }, { type: i7.DashboardBuilderService }, { type: i8.Router }, { type: i9.FiltersService }]; }, { onchartClickedEvent: [{
+            type: Output
+        }], onchartRightClickDeleteEvent: [{
+            type: Output
+        }], chartRendered: [{
+            type: Output
+        }], currentPageId: [{
+            type: Input
+        }], barChartContainer: [{
+            type: ViewChild,
+            args: ['barChartContainer']
+        }], contextMenu: [{
+            type: ViewChild,
+            args: [MatMenuTrigger]
+        }], reportData: [{
+            type: Input
+        }], isEditable: [{
+            type: Input
+        }], guid: [{
+            type: Input
+        }], screenType: [{
+            type: Input
+        }], drillThroughFilterInput: [{
+            type: Input
+        }], drillThroughParentType: [{
+            type: Input
+        }], appVersionId: [{
+            type: Input
+        }], click: [{
+            type: HostListener,
+            args: ['window:mousedown', ['$event']]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bar-chart.component.js","sourceRoot":"","sources":["../../../../../../../../src/ax-common-ui-lib/src/lib/enlighten-lib/report/graphical-report/bar-chart/bar-chart.component.ts","../../../../../../../../src/ax-common-ui-lib/src/lib/enlighten-lib/report/graphical-report/bar-chart/bar-chart.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    OnInit,\n    ViewEncapsulation,\n    ViewChild,\n    Input,\n    Output,\n    EventEmitter,\n    AfterViewInit,\n    OnDestroy,\n    HostListener\n} from '@angular/core';\nimport {\n    ApexAxisChartSeries,\n    ApexChart,\n    ChartComponent,\n    ApexDataLabels,\n    ApexXAxis,\n    ApexPlotOptions,\n    ApexYAxis,\n    ApexLegend,\n    ApexTitleSubtitle,\n    ApexGrid,\n    ApexNoData\n} from 'ng-apexcharts';\nimport { CdkDragDrop } from '@angular/cdk/drag-drop';\nimport { Subject } from 'rxjs';\nimport { MatMenuTrigger } from '@angular/material/menu';\nimport { ResizeEvent } from 'angular-resizable-element';\nimport { Router } from '@angular/router';\nimport { ChartProperty } from '../chart/chart-property';\nimport { AttributeData } from '../../../fields/attribute-data';\nimport { CrossFilterDto, ElementsDto } from '../../../../common-dto/elements-dto';\nimport { FieldsListService } from '../../../../field-list-lib/fields-list.service';\nimport { Dimension } from '../chart/dimension';\nimport { Matrix } from '../chart/matrix';\nimport { IGraphicalReportComponent } from '../igraphical-report.component';\nimport { BarChart, BarChartOrientation } from './bar-chart';\nimport { Report } from '../../../../common-utils/report';\nimport { ReportBuilderMasterService } from '../../report-builder-master.service';\nimport { ISendToDashboardData } from '../../../../dashboard-lib/show-dashboards/show-dashboards.component';\nimport { SendToDashboardService } from '../../../../dashboard-lib/send-to-dashboard.service';\nimport { ElementService } from '../../element.service';\nimport { IChartComponent } from '../ichart-component';\nimport { CommonService } from '../../../../common.service';\nimport { takeUntil } from 'rxjs/operators';\nimport { AxFilter } from'../../../filters/ax-filter';\nimport { AxExpression } from '../../../ax-expression/ax-expression';\nimport { SearchNode } from '../../../filters/search-node';\nimport { Attribute } from '../../../data-model/attribute';\nimport { AxExpTextList } from '../../../ax-expression/ax-exp-text-list';\nimport { ScopeType, ScreenType } from '../../../filters/condition-type';\nimport { Page } from '../page/page';\nimport { DrillThroughService } from '../../../../drill-through/drill-through.service';\nimport { DashboardBuilderService } from '../../../../dashboard-lib/dashboard-builder.service';\nimport { GhostLoaderType } from '../../../../ghost-loader/ghost-loader.component';\nimport { FiltersService } from '../../../../filters/filters.service';\n\n// Creating custom type for bar chart options that are going to be consumed by apex chart\nexport type BarChartOptions = {\n    series: ApexAxisChartSeries;\n    chart: ApexChart;\n    dataLabels: ApexDataLabels;\n    plotOptions: ApexPlotOptions;\n    xaxis: ApexXAxis;\n    yaxis: ApexYAxis;\n    legend: ApexLegend;\n    grid: ApexGrid;\n    title: ApexTitleSubtitle;\n    noData: ApexNoData;\n    tooltip: ApexTooltip;\n    fill: ApexFill;\n    states: ApexStates;\n};\n\n@Component({\n    // eslint-disable-next-line @angular-eslint/component-selector\n    selector: 'bar-chart',\n    templateUrl: './bar-chart.component.html',\n    styleUrls: ['./bar-chart.component.scss'],\n    encapsulation: ViewEncapsulation.None\n})\nexport class BarChartComponent\n    implements\n        IGraphicalReportComponent,\n        OnInit,\n        AfterViewInit,\n        OnDestroy,\n        IChartComponent\n{\n    @Output() onchartClickedEvent = new EventEmitter<any>();\n    @Output() onchartRightClickDeleteEvent = new EventEmitter<any>();\n    @Output() chartRendered = new EventEmitter();\n    @Input() currentPageId: number;\n\n    // Binding element of bar chart to the apex chart component\n    @ViewChild('barChartContainer') barChartContainer: ChartComponent;\n\n    /***\n     * MatMenuTrigger Use for right click on the chart action\n     */\n\n    @ViewChild(MatMenuTrigger)\n    contextMenu: MatMenuTrigger;\n\n    // Accepting reportData having axis and values.\n    @Input() reportData: BarChart;\n    @Input() isEditable: boolean;\n    @Input() guid: string;\n    @Input() screenType: ScreenType;\n    @Input() drillThroughFilterInput: AxFilter;\n    @Input() drillThroughParentType: ScreenType;\n    @Input() appVersionId: number;\n    ScreenType = ScreenType;\n    ShowFilters: Boolean =  false;\n\n    titleText: string = '';\n    report: Report;\n    // uniquekey of chart\n    public uniquekey: number;\n    property: ChartProperty;\n    public isDirty: boolean;\n    handle: boolean = false;\n    dataEvent: string = 'dataEvent';\n    componentRef: IChartComponent;\n    isDataPointSelected: boolean=false;\n    selectedDataPoints: Array<Array<number>> = []; // Holds the all selected points.\n    selectedSeriesIndexes: Array<number> =[];\n    contextMenuPosition = { x: '0px', y: '0px' };\n    pages: Array<Page> = [];\n    chart: ApexCharts;\n    chartId;\n    highlightedByOtherChart = false;\n    isDrillThrough: boolean;\n\n    yPosition: number;\n    xPosition: number;\n    /****\n     * Resize  chart  styles\n     */\n\n    reportId: number = 0;\n\n    // Object for bar chart options. This is of custom type.\n    public barChartOptions: Partial<BarChartOptions>;\n\n    /*\n     * Subject object which helps unsubscribe all the subscribed objects in the component\n     */\n    private _unsubscribeAll: Subject<any> = new Subject<any>();\n    // eslint-disable-next-line @typescript-eslint/member-ordering\n\n    private drillThroughFilter: AxFilter;\n    showGhostLoader: boolean = true;\n    GhostLoaderType = GhostLoaderType;\n    BarChartOrientation = BarChartOrientation;\n    /*** Constructor\n     *\n     */\n    constructor(\n        private _fieldsListService: FieldsListService, // Used for get matrix data\n        private _reportBuilderMasterService: ReportBuilderMasterService,\n        private _sendToDashboardService: SendToDashboardService,\n        private _elementService: ElementService,\n        private _commonService: CommonService,\n        private _drillThroughService: DrillThroughService,\n        private _dashboardService: DashboardBuilderService,\n        private _router: Router,\n        private _filterService: FiltersService\n    ) {\n        this.property = new ChartProperty();\n    }\n\n    public get screenTypes(): typeof ScreenType {\n        return ScreenType;\n    }\n\n    @HostListener('window:mousedown', ['$event'])\n    click(event): void {\n        if (event.which === 3 && this.contextMenu.menuOpened) {\n            this.contextMenu.closeMenu();\n        }\n    }\n\n    // -----------------------------------------------------------------------------------------------------\n    // @ Lifecycle hooks start\n    // 0\n\n    /**\n     * This will get called after the UI render.\n     */\n    ngAfterViewInit(): void {\n        setTimeout(() => {\n            this.property.apexChart = new ApexCharts(\n                document.getElementById(this.reportData.guid.toString()),\n                this.barChartOptions\n            );\n            this.property.apexChart.render();\n            this.getChartData();\n        });\n    }\n\n    /**\n     * NgOnInit LifeCycle hook.\n     * This will get called on component initialization.\n     */\n    ngOnInit(): void {\n        this.xPosition = this.reportData.xPosition;\n        this.yPosition = this.reportData.yPosition;\n        this.componentRef = this;\n        this.ShowFilters = this._filterService.setVisibilityOfFilterComponent(this.reportData.filters,this.reportData.categories);\n        this.report = this._reportBuilderMasterService.report;\n        this.reportId = this.report?.id;\n        this.property.element = this.reportData;\n        // ApexChart Configurations\n        this.initializeBarChartOptions();\n\n        //Subscribers for barChart\n        this.subscribers();\n    }\n\n    /**\n     * This will initialize bar-chart options.basically did apexChart configuration here.\n     */\n    initializeBarChartOptions(): void{\n        const _reportData = this.reportData;\n        this.barChartOptions = {\n            title: {\n                text: this.reportData.title.text,\n                align: this.reportData.title.position,\n                style: {\n                    color: this.reportData.title.textColor,\n                    fontFamily: this.reportData.title.textStyle,\n                    fontSize: this.reportData.title.textSize\n                }\n            },\n            noData: {\n                text: 'No data to display',\n                align: 'center'\n            },\n            chart: {\n                id: 'apx-' + this.reportData.guid,\n                type: 'bar',\n                height: '100%',\n                width: '100%',\n                stacked: this.reportData.showStack,\n                background: this.reportData.backgroundColor,\n                events: {\n                    dataPointSelection: (crossFilterEvent, chart, opts): void => {\n                        this.isDrillThrough=false;\n                        if (crossFilterEvent && crossFilterEvent.button === 2 && opts.dataPointIndex >=0)\n                        {\n                            this.isDrillThrough=true;\n                            this.createDrillThroughFilter(this.reportData.dimension.attribute.series[opts.dataPointIndex]);\n                        }\n                    },\n                    // for deselecting the matrix\n                    click: (crossFilterEvent, chart, opts): void=> {\n                        this.chartSelect();\n                        if(opts.dataPointIndex >=0){\n                            if(this.highlightedByOtherChart){\n                                this.selectedSeriesIndexes = [];\n                            }\n                            this.saveSelectDataPoints(opts.globals.selectedDataPoints);\n                            this.dataPointSelection(opts);\n                        }else{\n                            this.resetCrossFilter();\n                        }\n                        this.highlightedByOtherChart = false;\n                        // deselect all selected points.\n                        this.clearSelectedDataPoint();\n                    },\n                  },\n                toolbar: {\n                    show: false\n                },\n                animations: {\n                    enabled: false\n                }\n\n            },\n            plotOptions: {\n                bar: {\n                    horizontal:\n                        this.reportData.orientation === BarChartOrientation.horizontal\n                }\n            },\n            dataLabels: {\n                enabled: this.reportData.showDataLabels,\n                style: {\n                    colors: [this.reportData.dataLabelColor]\n                }\n            },\n            yaxis: {\n                axisBorder: {\n                    color: this.reportData.borderColor\n                },\n                labels: {\n                    show: this.reportData.showAxis,\n                    maxWidth: 95,\n                    align: 'left',\n                    style: {\n                        colors: this.reportData.legend.textColor,\n                        fontFamily: this.reportData.legend.textStyle,\n                        fontSize: this.reportData.legend.textSize\n                    }\n                },\n                tooltip: {\n                    enabled: true,\n                    offsetX: 0\n                }\n            },\n            grid:{\n                xaxis: {\n                    lines: {\n                        show: false\n                    }\n                  }\n            },\n            legend: {\n                position: this.reportData.legend.position,\n                show: this.reportData.legend.enable,\n                fontSize: this.reportData.legend.textSize,\n                fontFamily: this.reportData.legend.textStyle,\n                horizontalAlign: 'left',\n                labels: {\n                    colors: this.reportData.legend.textColor\n                },\n                markers: {\n                    fillColors:this.getSeriesColors(),\n                }\n            },\n            series: [],\n            xaxis: {\n                labels: {\n                    show: this.reportData.showAxis,\n                    trim: true,\n                    rotate: -60,\n                    maxHeight: 85,\n                },\n                axisBorder: {\n                    color: this.reportData.borderColor\n                },\n                tickAmount: 40,\n                tickPlacement: 'between',\n            },\n            states: {\n                active: {\n                    allowMultipleDataPointsSelection: true,\n                },\n            },\n             fill: {\n               colors: [function({ seriesIndex }) {\n                 return  _reportData.matrix.attributes[seriesIndex].color;\n               }]\n             }\n\n        };\n    }\n\n    /**\n     * This will return series color.\n     */\n    getSeriesColors(): Array<string>{\n        const seriesColors = [];\n        this.reportData?.matrix?.attributes.forEach((atrribute: AttributeData)=>{\n            seriesColors.push(atrribute.color);\n        });\n        return seriesColors;\n    }\n\n    /**\n     * Subscribers for barChart..\n     */\n    subscribers(): void{\n\n        /*whenever we change the global filters we got call back from this subscriber*/\n        this._elementService.refreshDataEvent$\n            .pipe(takeUntil(this._unsubscribeAll))\n            .subscribe((val: boolean) => {\n                if (val) {\n                    this.getChartData();\n                }\n            });\n\n        /*when we click on bar chart event will be emitted from this subscriber*/\n        this._elementService.crossFilterEvent.subscribe((crossFilter: CrossFilterDto) => {\n            if(crossFilter.resetFilter || crossFilter.values.length == 0)\n            {\n                this.deselectDataPoints(crossFilter);\n            }else{\n\n                this.createCrossFilter(crossFilter);\n                this.highlightedByOtherChart = true;\n            }\n\n        });\n        // Get pageslist\n        this._commonService.pageList$.subscribe((page) => {\n        this.pages=[];\n        this.reportData.matrix.attributes?.forEach((attribute) => {\n                page?.forEach((_page) => {\n                        _page?.drillData?.forEach((drillData) => {\n                            if((drillData.columnName===attribute.columnName && drillData.tableName===attribute.tableName)\n                                || (this.reportData.dimension.attribute && this.reportData.dimension.attribute.columnName === drillData.columnName && this.reportData.dimension.attribute.tableName === drillData.tableName)){\n                                this.pages.push(_page);\n                            }\n                        });\n                });\n            });\n        this.pages = this.pages.filter(p => p.id !== this.currentPageId);\n        });\n    }\n\n    /**\n     * Clone selected data points\n     *\n     * @param dataPoints\n     */\n    saveSelectDataPoints(dataPoints: Array<Array<number>>){\n        this.selectedDataPoints = [];\n        dataPoints.forEach((matrixs,ind) => {\n            const points = [];\n            matrixs.forEach((matrix)=>{\n                points.push(matrix);\n            });\n            this.selectedDataPoints.push(points);\n        });\n    }\n\n    /**\n     * Created filter object for cross filtering.\n     *\n     *  @param CrossFilterDto\n     */\n    createCrossFilter(crossFilterData: CrossFilterDto): void{\n        const axExpression= new AxExpression();\n        axExpression.comparisonOperator.text = 'In';\n        axExpression.comparisonOperator.value = 'IN';\n        axExpression.valueType = 2;\n        axExpression.field= new Attribute(crossFilterData.attributeData as unknown as Attribute);\n        const axExpTextList = new AxExpTextList();\n        crossFilterData.values.forEach((value)=>{\n            axExpTextList.value.push(value);\n        });\n        axExpression.value= axExpTextList;\n        const _searchNodes= new SearchNode();\n        _searchNodes.expression= axExpression;\n        const _filter = new AxFilter();\n        _filter.searchNodes.push(_searchNodes);\n        _filter.appVersionId=0;\n        this.getCrossFilterData(_filter,crossFilterData);\n    }\n\n     /**\n      * pushed the filter object into basic filter and applied the filter on the data\n      *\n      *  @param CrossFilterDto\n      *  @param AxFilter\n      */\n     getCrossFilterData(_filter: AxFilter, crossFilterData: CrossFilterDto): void{\n        if (this.reportData.matrix.attributes.length && this.reportData.dimension.attribute) {\n            const elementDto = new ElementsDto(this.reportData);\n            elementDto.filters.localFilters.basic = this._elementService.getValidFilter(this.reportData.filters);\n            elementDto.filters.localFilters.basic.push(_filter);\n            elementDto.filters.localFilters.category =this._elementService.getValidFilterCategory(this.reportData.categories);\n            elementDto.filters.globalFilters.basic = this._elementService.getValidFilter(this._elementService.filtersDto.basic);\n            elementDto.filters.globalFilters.category =this._elementService.getValidFilterCategory(this._elementService.filtersDto.category);\n            elementDto.reportId = this.reportId;\n            if(crossFilterData.selectedIndexLength === 0){\n                elementDto.filters.localFilters.basic=[];\n                this.deselectDataPoints(crossFilterData);\n            }\n            this._fieldsListService\n            .getMatrixData(elementDto)\n            .then((entitiesAttribute: ElementsDto) => {\n                const selectedDataPointArray =[];\n                entitiesAttribute.dimension.attribute.series.forEach((_elementDto) => {\n                    const seriesIndex=(this.reportData.dimension.attribute.series.indexOf(_elementDto));\n                    selectedDataPointArray.push(seriesIndex);\n                 });\n                //if matrix is not same then crossfilter should not apply\n                if (entitiesAttribute != null) {\n                    this.highlightSeriesData(selectedDataPointArray);\n                }\n            });\n        }\n    }\n\n    /**\n     * set data to chart if entitiesAttribute is not equal to null then this method will call and will highlight the matrix\n     */\n    highlightSeriesData(indexList: Array<number>): void {\n        const  _reportData = this.reportData;\n\n        this.property.apexChart.updateOptions({\n           fill: {\n               colors: [function({ seriesIndex,dataPointIndex }) {\n                 if(indexList.includes(dataPointIndex) ) {\n                   return  _reportData.matrix.attributes[seriesIndex].color;\n               } else {\n                    return  _reportData.matrix.attributes[seriesIndex].color+  '60';\n                 }\n               }]\n             }\n       });\n    }\n\n    /**\n     * Clear the selected data points.\n     */\n    clearSelectedDataPoint(): void{\n        this.selectedDataPoints.forEach((matrixs,ind) => {\n            matrixs.forEach((matrix,matInd)=>{\n                this.property.apexChart.toggleDataPointSelection(ind,matrix);\n            });\n        });\n        this.selectedDataPoints = [];\n    }\n\n    /**\n     *\n     * Called when we select a bar by a click event\n     *\n     * @param opts\n     */\n     dataPointSelection(opts: any): void{\n        let crossFilterDto: CrossFilterDto;\n        if(opts.dataPointIndex >=0){\n            crossFilterDto = {\n                values: [],\n                attributeData: this.reportData.dimension.attribute,\n                chartType: this.reportData.type,\n                elementGuid: this.reportData.guid,\n                resetFilter:false,\n                selectedIndexLength: 1\n            };\n            if(this.selectedSeriesIndexes.includes(opts.dataPointIndex)){\n                const ind = this.selectedSeriesIndexes.indexOf(opts.dataPointIndex);\n                this.selectedSeriesIndexes.splice(ind,1);\n            }else{\n                this.selectedSeriesIndexes.push(opts.dataPointIndex);\n            }\n\n            //if index is already present in selectedDataPoints array then pop the specific index\n              this.selectedSeriesIndexes.forEach((index) => {\n                if(crossFilterDto.values.includes(this.reportData.dimension.attribute.series[index])){\n                    crossFilterDto.values.splice(crossFilterDto.values.indexOf(this.reportData.dimension.attribute.series[index]),1);\n                }\n                else{\n                crossFilterDto.values.push(this.reportData.dimension.attribute.series[index]);\n                }\n            });\n        }\n        this._elementService.triggerCrossFilter(crossFilterDto);\n\n    }\n\n    /**\n     * Reset cross filter and emit reset cross filter event.\n     */\n    resetCrossFilter(): void{\n        let crossFilterDto: CrossFilterDto;\n        crossFilterDto = {\n            values: null,\n            attributeData:null,\n            chartType: this.reportData.type,\n            elementGuid: this.reportData.guid,\n            resetFilter:true,\n            selectedIndexLength: 0\n\n        };\n        this.selectedSeriesIndexes= [];\n        this._elementService.triggerCrossFilter(crossFilterDto);\n\n    }\n\n\n    /**\n     * On destroy\n     */\n    ngOnDestroy(): void {\n        // Unsubscribe from all subscriptions\n        this._unsubscribeAll.next();\n        this._unsubscribeAll.complete();\n    }\n\n    // -----------------------------------------------------------------------------------------------------\n    // @ Lifecycle hooks end\n    // -----------------------------------------------------------------------------------------------------\n\n\n  /**\n   * Get data\n   */\n   getChartData(): void {\n    if (this.reportData.matrix.attributes.length && this.reportData.dimension.attribute) {\n        if(this.drillThroughParentType == ScreenType.dashboardBuilder || this.drillThroughParentType == ScreenType.containerDashboard)\n            {this.reportData.apiType = 'dashboard';}\n        const data = new ElementsDto(this.reportData);\n        if(this.screenType === this.screenTypes.drillThrough){\n            data.filters.globalFilters.basic.push(this.drillThroughFilterInput);\n        } else {\n            data.filters.globalFilters.basic = this._elementService.getValidFilter(this._elementService.filtersDto.basic, ScopeType.global);\n            data.filters.globalFilters.category = this._elementService.getValidFilterCategory(this._elementService.filtersDto.category, ScopeType.global);\n        }\n        data.filters.localFilters.basic = this._elementService.getValidFilter(this.reportData.filters);\n        data.filters.localFilters.category = this._elementService.getValidFilterCategory(this.reportData.categories);\n        data.reportId = this.reportId;\n        this._fieldsListService.getMatrixData(data).then((entitiesAttribute: ElementsDto) => {\n            if (entitiesAttribute != null) {\n            this.chartRendered.emit();\n            this.setDataToChart(entitiesAttribute);\n            this.showGhostLoader = false;\n            }\n        });\n    }\n    else{\n      this.chartRendered.emit();\n      this.showGhostLoader = false;\n    }\n  }\n    /**\n     * set data to chart if entitiesAttribute is not equal to null then this method will call\n     */\n    setDataToChart(entitiesAttribute: ElementsDto): void {\n        const matrixData = [];\n        this.reportData.matrix.attributes = entitiesAttribute.matrix.attributes;\n        this.reportData.dimension.attribute = entitiesAttribute.dimension.attribute;\n        this.reportData.sqlQuery = entitiesAttribute.sqlQuery;\n        for (const attribute of this.reportData.matrix.attributes) {\n            matrixData.push({\n                data: attribute.series,\n                name: attribute.label,\n            });\n        }\n        this.property.apexChart.updateOptions({\n            xaxis: { categories: this.reportData.dimension.attribute.series }\n        });\n        this.property.apexChart.updateSeries(matrixData);\n    }\n\n    /**\n     * attributeDropped\n     * Called when attribute is dragged from left side fields list and dropped on the bar chart\n     *\n     * @param $event\n     */\n    attributeDropped($event: CdkDragDrop<any>): void {\n        $event.item.data.aggregateFn = 'count';\n        if (\n            this.reportData.matrix.attributes.length === 0 &&\n            this.reportData.dimension.attribute == null\n        ) {\n            this.reportData.matrix = new Matrix();\n            this.reportData.matrix.attributes.push(new AttributeData($event.item.data));\n            this.reportData.dimension = new Dimension();\n            this.reportData.dimension.attribute = new AttributeData($event.item.data);\n            this.reportData.dimension.attribute.aggregateFn = 'none';\n        } else if (\n            this.reportData.matrix.attributes.length > 0 &&\n            $event.item.data.enlightenType instanceof Text &&\n            this.reportData.dimension.attribute == null\n        ) {\n            this.reportData.dimension.attribute = new AttributeData($event.item.data);\n        } else {\n            this.reportData.matrix.attributes.push(new AttributeData($event.item.data));\n            const seriesData = [];\n            this.reportData.matrix.attributes.forEach((attr) => {\n                seriesData.push({\n                    name: attr.label,\n                    data: attr.series,\n                    color: attr.color\n                });\n            });\n            this.barChartOptions.series = seriesData;\n        }\n        this._commonService.isReportBuilderDirty = true;\n        this.getChartData();\n    }\n\n    chartSelect(): void {\n        this.onchartClickedEvent.emit(this.property);\n    }\n    /**\n     * Created filter object for cross filtering.\n     *\n     *  @param CrossFilterDto\n     */\n     createDrillThroughFilter(series: any): void{\n        const axExpression= new AxExpression();\n        axExpression.comparisonOperator.text = 'In';\n        axExpression.comparisonOperator.value = 'IN';\n        axExpression.valueType = 2;\n        axExpression.field= new Attribute(this.reportData.dimension.attribute as unknown as Attribute);\n        const axExpTextList = new AxExpTextList();\n        axExpTextList.value.push(series);\n        axExpTextList.isSearchable = true;\n        axExpression.value= axExpTextList;\n        const _searchNodes= new SearchNode();\n        _searchNodes.expression= axExpression;\n        this.drillThroughFilter = new AxFilter();\n        this.drillThroughFilter.searchNodes.push(_searchNodes);\n        this.drillThroughFilter.appVersionId=0;\n    }\n\n\n    /***\n     * On chart context  click Function\n     */\n    onContextMenu(event: MouseEvent, chart: BarChart): void {\n        if(!this.isEditable &&\n            ([this.screenTypes.containerDashboard, this.screenTypes.drillThrough].includes(this.screenType))\n            && !this.pages.length){\n            event.preventDefault();\n            return;\n        }\n\n        if (!this.isEditable && (this.screenType !== ScreenType.drillThrough)) {\n            const centralPage: HTMLElement = document.getElementById(this.guid);\n            const centralPageBounds: DOMRect = centralPage.getBoundingClientRect();\n            event.preventDefault();\n            this.contextMenuPosition.x = ( event.clientX -centralPageBounds.x ) + 'px';\n            this.contextMenuPosition.y = (event.clientY-centralPageBounds.y) + 'px';\n            this.contextMenu.menuData = { chart: chart };\n            this.contextMenu.menu.focusFirstItem('mouse');\n            this.contextMenu.openMenu();\n        }\n        else{\n            event.preventDefault();\n            this.contextMenuPosition.x = event.clientX + 'px';\n            this.contextMenuPosition.y = event.clientY + 'px';\n            this.contextMenu.menuData = { chart: chart };\n            this.contextMenu.menu.focusFirstItem('mouse');\n            this.contextMenu.openMenu();\n        }\n    }\n    /***\n     * Delete chart Function\n     */\n    openOptionPopUp(): void {\n        this.onchartRightClickDeleteEvent.emit(this.uniquekey);\n    }\n\n    onDeleteClick(event: MouseEvent): void {\n        this._commonService.isDashboardBuilderDirty = true;\n        event.preventDefault();\n        event.stopPropagation();\n        // item.isDeleted = true_d\n        this._dashboardService.deleteDashboardElement(this.reportData);\n        this.contextMenu.closeMenu();\n    }\n\n\n    /***\n     * Pin to Dashboard Function\n     */\n    sendToDashboard(): void {\n        const sendToDashboardData: ISendToDashboardData = {\n            filter: null,\n            filterCategory: null,\n            appVersionId: this.report.appVersionId,\n            type: 'element',\n            element: this.reportData\n        };\n        this._sendToDashboardService.sendToDashboard(sendToDashboardData);\n    }\n\n    /****\n     * chartResizeMinDimensions =   this function use  Resize min dimensions validation\n     */\n\n    chartResizeMinDimensions(event: ResizeEvent): boolean {\n        const MIN_DIMENSIONS_PX: number = 50;\n        this._commonService.isReportBuilderDirty = true;\n        if (\n            event.rectangle.width &&\n            event.rectangle.height &&\n            (event.rectangle.width < MIN_DIMENSIONS_PX ||\n                event.rectangle.height < MIN_DIMENSIONS_PX)\n        ) {\n            return false;\n        }\n        return true;\n    }\n\n    /****\n     * onResizing = this function use for resize the  chart\n     */\n    onResizing(event: ResizeEvent): void {\n        const centralPage: HTMLElement = document.getElementById('central-page');\n        const centralPageBounds: DOMRect = centralPage.getBoundingClientRect();\n        if (event.rectangle.right >= centralPageBounds.right && event.edges.right) {\n            event.rectangle.right = centralPageBounds.right;\n        } else if (event.rectangle.left < centralPageBounds.left) {\n            event.rectangle.left = centralPageBounds.left;\n        } else if (event.rectangle.bottom > centralPageBounds.bottom) {\n            event.rectangle.bottom = centralPageBounds.bottom;\n        } else if (event.rectangle.top < centralPageBounds.top) {\n            event.rectangle.top = centralPageBounds.top;\n        }\n        event.rectangle.width = event.rectangle.right - event.rectangle.left;\n        event.rectangle.height = event.rectangle.bottom - event.rectangle.top;\n        if (\n            event.edges.bottom !== 0 &&\n            event.edges.top !== 0 &&\n            event.edges.left !== 0 &&\n            event.edges.right !== 0\n        ) {\n            event.edges.top = this.yPosition + Number(event.edges.top);\n            event.edges.left = this.xPosition + Number(event.edges.left);\n            this.reportData.resizeChart(event, this.property.apexChart);\n        }\n    }\n\n    /**\n     * Called when resizing ends\n     */\n    resizeEnd(){\n       this.xPosition = this.reportData.xPosition;\n       this.yPosition = this.reportData.yPosition;\n    }\n\n    /**\n     * to set isDirty after changes in bar-chart filter\n     *\n     */\n    dirtyFlowCheckEvent(): void {\n        this._commonService.isReportBuilderDirty = true;\n    }\n\n    /**\n     * call cdk drag start event\n     *\n     * @param $event\n     */\n    dragStart($event: DragEvent): void {\n        this.handle = true;\n    }\n    /**\n     * call cdk drag end event\n     *\n     * @param $event\n     */\n    dragEnd($event: DragEvent): void {\n        this.handle = false;\n        this.xPosition = this.reportData.xPosition;\n        this.yPosition = this.reportData.yPosition;\n    }\n    /**\n     * Deselecting the selected matrix\n     *\n     */\n      deselectDataPoints(crossFilterData: CrossFilterDto): void{\n        const _reportData= this.reportData;\n        this.selectedDataPoints.forEach((dataPointIndexs,ind)=>{\n            // if(this.reportData.guid != crossFilterData.elementGuid){\n                dataPointIndexs.forEach((attributeInd)=>{\n                    this.property.apexChart.toggleDataPointSelection(ind,attributeInd);\n                });\n            // }\n        }); this.property.apexChart.updateOptions({\n            fill: {\n                colors: [function({ value,seriesIndex }) {\n                  return  _reportData.matrix.attributes[seriesIndex].color;\n                }]\n            }\n      });\n        this.selectedDataPoints = [];\n  }\n\n    /**\n     * Called on page name clicked on dropdown options of drill through pages\n     *\n     * @param page\n     */\n    pageClick(page: Page): void{\n        if(this.screenType !== ScreenType.drillThrough){\n            if(this.drillThroughParentType ? this.drillThroughParentType == ScreenType.reportBuilder : this.isEditable){\n                this._drillThroughService.setParentData(this.reportId, this._reportBuilderMasterService.report.name, this._router.url);\n                this.navigateToDrillThrough(page);\n            }\n            else{\n                this._dashboardService.dashboard$.pipe(takeUntil(this._unsubscribeAll)).subscribe((dashboard) => {\n                    this._drillThroughService.setParentData(this.reportId, dashboard.name, this._router.url);\n                    this.navigateToDrillThrough(page);\n                });\n            }\n        } else {\n            this.navigateToDrillThrough(page);\n        }\n    }\n\n    /**\n     * Navigate to drill through component with page id as route params\n     * Checks the parent URL if it is already exists or not\n     *\n     * @param page\n     */\n    navigateToDrillThrough(page: Page){\n        const parentUrl: string = this._drillThroughService.getParentData().url;\n        this._drillThroughService.drillPage(page,this.drillThroughFilter);\n        if(!parentUrl){\n            this._router.navigate([this._router.url +'/drill-through/' + page.id]);\n        } else {\n            this._router.navigate([parentUrl,'drill-through',page.id]);\n        }\n    }\n\n    /**\n     * Apply local filter.\n     */\n    applyLocalFilter(): void{\n        this.getChartData();\n    }\n}\n","\n  <!-- Resizable div -->\n  <div id=\"bar-chart-container\" class=\"chart-resize \" mwlResizable (validateResize)=\"chartResizeMinDimensions($event)\"  [ngClass]=\"{'full-body' : !isEditable && (screenType !== screenTypes.drillThrough),'selected-resize':reportData.isSelected && !handle, 'resize-class': !handle}\" (resizing)=\"onResizing($event)\" [style.top.px]=\"reportData.yPosition\" style=\"width: fit-content;height: fit-content;\" [style.left.px]=\"reportData.xPosition\" [style.width.px]=\"reportData.width\" [style.height.px]=\"reportData.height\" (resizeEnd)=\"resizeEnd()\">\n    <!-- Chart bodt -->\n    <ng-container *ngIf=\"showGhostLoader\">\n      <ng-container *ngIf=\"reportData.orientation == BarChartOrientation.horizontal\">\n        <app-ghost-loader [elementType]=\"GhostLoaderType.BarChartLoaderHorizontal\" ></app-ghost-loader>\n      </ng-container>\n      <ng-container *ngIf=\"reportData.orientation != BarChartOrientation.horizontal\">\n        <app-ghost-loader [elementType]=\"GhostLoaderType.BarChartLoaderVertical\"></app-ghost-loader>\n      </ng-container>\n\n    </ng-container>\n    <div\n    class=\"bar-chart-box chart-padding\"\n    [style.width.px]=\"reportData.width\" [style.height.px]=\"reportData.height\"\n    style=\"max-width: 100%; max-width: 100%;\"\n        (cdkDragStarted)=\"dragStart($event)\"\n        (cdkDragEnded)=\"dragEnd($event)\"\n        [ngClass]=\"{\n            'selected':reportData.isSelected,\n            'full-body' : !isEditable,\n            'hidden': showGhostLoader ,\n            'bold-title':reportData.title.fontStyle.fontWeight == 'bold',\n            'normal-title':reportData.title.fontStyle.fontWeight == 'normal',\n            'underline-title':reportData.title.fontStyle.textDecoration == 'underline',\n            'italic-title':reportData.title.fontStyle.isItalicFont,\n            'bold-legend':reportData.legend.fontStyle.fontWeight == 'bold',\n            'normal-legend':reportData.legend.fontStyle.fontWeight == 'normal',\n            'underline-legend':reportData.legend.fontStyle.textDecoration == 'underline',\n            'italic-legend':reportData.legend.fontStyle.isItalicFont\n        }\"\n        cdkDrag   [id]=\"'cdk-drop-'+reportData.guid\"\n    (click)=\"chartSelect(); $event.stopPropagation();\" (cdkDropListDropped)=\"attributeDropped($event)\"\n      [cdkDragData]=\"reportData\" cdkDragBoundary=\".page\" cdkDropList (contextmenu)=\"onContextMenu($event, reportData)\" [cdkDragDisabled]=\"!isEditable || (screenType === screenTypes.drillThrough)\">\n      <div [ngClass]=\"{'full-body' : !isEditable }\"  class=\"chart-inner-container\">\n        <!-- Filter Container -->\n        <!-- for future use-->\n        <div class=\"filter-body pl-3\" [ngClass]=\"{'local-body' : !isEditable, 'hidden': screenType != ScreenType.reportBuilder && !ShowFilters }\" *ngIf=\"isEditable || reportData.filters.length>0 || reportData.categories.length>0\" (click) = \"$event.stopPropagation();\">\n            <lib-report-filter\n                [filters]=\"reportData.filters\"\n                [categories]=\"reportData.categories\"\n                [reportId]=\"reportId\"\n                [dataModel]=\"dataModel\"\n                [screenType]=\"screenType\"\n                [isEditable]=\"isEditable\"\n                [appVersion]=\"appVersionId\"\n                (dirtyFlowCheckEvent)=\"dirtyFlowCheckEvent()\"\n                (applyFilterEvent)=\"applyLocalFilter()\"\n            >\n            </lib-report-filter>\n        </div>\n        <!-- Chart Container -->\n        <div class=\"bar-chart-body\" [ngClass]=\"{'dashboard-chart-full-body': !isEditable && !reportData.filters.length && !reportData.categories.length, 'pt-2': isEditable || reportData.filters.length>0 || reportData.categories.length>0, 'pb-2':isEditable }\">\n            <div id=\"{{reportData.guid}}\" class=\"chart h-full\tw-full\" #chart></div>\n        </div>\n\n        <!---------------------------------------- Mat Menu trigger For Menu Options ----------------------------->\n        <ng-container>\n          <div style=\"visibility: hidden; position: fixed\" [style.left]=\"contextMenuPosition.x\"\n          [style.top]=\"contextMenuPosition.y\" [matMenuTriggerFor]=\"contextMenu\">\n          </div>\n\n          <!-- Mat Menu PopUp -->\n          <mat-menu #contextMenu=\"matMenu\">\n            <div class=\"chart-menu\">\n              <ng-template matMenuContent let-item=\"reportData\">\n                <ng-container *ngIf='isEditable'>\n                  <button mat-menu-item (click)=\"sendToDashboard($event)\">Pin to Dashboard</button>\n                  <button mat-menu-item (click)=\"openOptionPopUp($event)\">Delete</button>\n                </ng-container>\n                <button mat-menu-item *ngIf=\"screenTypes.dashboardBuilder === screenType\" (click)=\"onDeleteClick($event)\" >Remove From Dashboard</button>\n                <button mat-menu-item *ngIf=\"isDrillThrough && pages.length > 0\" [matMenuTriggerFor]=\"drillThrough\">Drill Through</button>\n              </ng-template>\n            </div>\n          </mat-menu>\n        </ng-container>\n        <mat-menu #drillThrough=\"matMenu\">\n          <div class=\"chart-menu\">\n            <ng-container *ngFor=\" let page of pages\">\n                <button mat-menu-item (click)='pageClick(page)'> {{page.name}}</button>\n            </ng-container>\n          </div>\n        </mat-menu>\n        <!-- --------------------------------------------------------------------------- -->\n      </div>\n    </div>\n    <ng-container *ngIf='isEditable && !showGhostLoader'>\n        <!-- Resize handles  -->\n      <div  class=\"resize-handle-top\"  [class.hide] = \"handle\"  mwlResizeHandle [resizeEdges]=\"{ top: true }\"></div>\n      <div class=\"resize-handle-left\"  [class.hide] = \"handle\"  mwlResizeHandle [resizeEdges]=\"{ left: true }\"></div>\n      <div class=\"resize-handle-right\"  [class.hide] = \"handle\"  mwlResizeHandle [resizeEdges]=\"{ right: true }\"></div>\n      <div class=\"resize-handle-bottom\"  [class.hide] = \"handle\"  mwlResizeHandle [resizeEdges]=\"{ bottom: true }\"></div>\n    </ng-container>\n  </div>\n"]}