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

package/esm2020/lib/dashboard-lib/dashboard-filter/dashboard-filter.component.mjs

@@ -0,0 +1,107 @@
+import { Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { CrossFilterDto } from '../../common-dto/elements-dto';
+import { ScopeType, ScreenType } from '../../enlighten-lib/filters/condition-type';
+import { ElementService } from '../../enlighten-lib/report/element.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../enlighten-lib/report/element.service";
+import * as i2 from "@angular/router";
+import * as i3 from "../../filters/filters.component";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/material/tooltip";
+import * as i6 from "@angular/material/icon";
+function DashboardFilterComponent_button_2_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 3);
+    i0.ɵɵlistener("click", function DashboardFilterComponent_button_2_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r2); const ctx_r1 = i0.ɵɵnextContext(); return ctx_r1.resetCrossFilter(); });
+    i0.ɵɵelement(1, "mat-icon", 4);
+    i0.ɵɵelementEnd();
+} }
+const _c0 = function (a0) { return { "widthWithCrossFilter": a0 }; };
+export class DashboardFilterComponent {
+    constructor(_elementService, activatedRoute) {
+        this._elementService = _elementService;
+        this.activatedRoute = activatedRoute;
+        this.commonFilterArray = [];
+        this.dirtyFlowCheckEvent = new EventEmitter();
+        this.scopeType = ScopeType.global;
+        this.showHeader = true;
+    }
+    ngOnInit() {
+        this.activatedRoute.paramMap.subscribe((params) => {
+            const showHeader = params.get('header');
+            if (showHeader && showHeader === 'hideHeader') {
+                this.showHeader = false;
+            }
+        });
+    }
+    /**
+     * Reset cross filter
+     */
+    resetCrossFilter() {
+        const crossfilterDto = new CrossFilterDto();
+        crossfilterDto.resetFilter = true;
+        this._elementService.triggerCrossFilter(crossfilterDto);
+    }
+    ngOnChanges() {
+        this.commonFilterArray = [];
+        this.allFilter();
+    }
+    /**
+     * Call dirty flow event emit
+     */
+    dirtyFlowCheck() {
+        this.dirtyFlowCheckEvent.emit();
+    }
+    /**
+     * call when the global filters fields values are selected.
+     */
+    refreshElementData() {
+        this._elementService.refreshElementData();
+    }
+    allFilter() {
+        this.filters.forEach((filter) => {
+            //   filter.generalFilterType = 1;
+            if (!this.commonFilterArray.includes(filter)) {
+                this.commonFilterArray.push(filter);
+            }
+        });
+        this.categories.forEach((category) => {
+            category.generalFilterType = 2;
+            if (!this.commonFilterArray.includes(category)) {
+                this.commonFilterArray.push(category);
+            }
+        });
+    }
+}
+DashboardFilterComponent.ɵfac = function DashboardFilterComponent_Factory(t) { return new (t || DashboardFilterComponent)(i0.ɵɵdirectiveInject(i1.ElementService), i0.ɵɵdirectiveInject(i2.ActivatedRoute)); };
+DashboardFilterComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: DashboardFilterComponent, selectors: [["lib-dashboard-filter"]], inputs: { filters: "filters", categories: "categories", screenType: "screenType", commonFilterArray: "commonFilterArray", crossFilterEnabled: "crossFilterEnabled" }, outputs: { dirtyFlowCheckEvent: "dirtyFlowCheckEvent" }, features: [i0.ɵɵNgOnChangesFeature], decls: 3, vars: 7, consts: [[1, "filter-component", "global-filter"], [1, "flex", "gap-x-2", 3, "commonFilterArray", "screenType", "scopeType", "ngClass", "dirtyFlowCheckEvent", "filterChangeEmit"], ["matTooltip", "Remove cross filter", "mat-icon-button", "", "class", "flex items-center", 3, "click", 4, "ngIf"], ["matTooltip", "Remove cross filter", "mat-icon-button", "", 1, "flex", "items-center", 3, "click"], ["svgIcon", "axo_filter_remove", 1, "filter-icon"]], template: function DashboardFilterComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵelementStart(1, "filters", 1);
+        i0.ɵɵlistener("dirtyFlowCheckEvent", function DashboardFilterComponent_Template_filters_dirtyFlowCheckEvent_1_listener() { return ctx.dirtyFlowCheck(); })("filterChangeEmit", function DashboardFilterComponent_Template_filters_filterChangeEmit_1_listener() { return ctx.refreshElementData(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(2, DashboardFilterComponent_button_2_Template, 2, 0, "button", 2);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("commonFilterArray", ctx.commonFilterArray)("screenType", ctx.screenType)("scopeType", ctx.scopeType)("ngClass", i0.ɵɵpureFunction1(5, _c0, !ctx.showHeader && ctx.crossFilterEnabled));
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", !ctx.showHeader && ctx.crossFilterEnabled);
+    } }, directives: [i3.FiltersComponent, i4.NgClass, i4.NgIf, i5.MatTooltip, i6.MatIcon], styles: ["lib-dashboard-filter{max-width:100%;width:100%;height:3.7rem;display:flex;align-items:start}lib-dashboard-filter .widthWithCrossFilter{width:calc(100% - 2.563rem);min-width:calc(100% - 2.563rem);max-width:calc(100% - 2.563rem);display:flex;align-items:center}lib-dashboard-filter .global-filter{height:100%;display:flex;align-items:center;max-width:100%}lib-dashboard-filter .global-filter .dash-reset,lib-dashboard-filter .global-filter .reset-section,lib-dashboard-filter .global-filter .reset-btn{border-left:1px solid #c9c9c9c9;white-space:nowrap;width:144px;display:flex;height:2rem;align-items:start;padding-left:.4rem}lib-dashboard-filter .global-filter .dash-reset .reset,lib-dashboard-filter .global-filter .reset-section .reset,lib-dashboard-filter .global-filter .reset-btn .reset{margin:0;font-size:11px}lib-dashboard-filter .global-filter .filter-wrapper{position:inherit;display:inline-block;gap:25px;max-width:calc(100% - 154px);height:2.7rem;line-height:2.7rem;align-items:start!important;overflow-y:hidden;align-self:center}lib-dashboard-filter .global-filter .filter-wrapper .reset{margin:0!important}\n"], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DashboardFilterComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-dashboard-filter', encapsulation: ViewEncapsulation.None, template: "<div class=\"filter-component global-filter\">\n <filters\n    class=\"flex gap-x-2\"\n    [commonFilterArray]=\"commonFilterArray\"\n    [screenType]=\"screenType\"\n    (dirtyFlowCheckEvent)=\"dirtyFlowCheck()\"\n    (filterChangeEmit)= \"refreshElementData()\"\n    [scopeType]=\"scopeType\"\n    [ngClass]=\"{'widthWithCrossFilter': !showHeader && crossFilterEnabled}\"\n    >\n </filters>\n <button *ngIf=\"!showHeader && crossFilterEnabled\" (click)=\"resetCrossFilter()\" matTooltip=\"Remove cross filter\"  mat-icon-button class=\"flex items-center\">\n   <mat-icon class=\"filter-icon\"svgIcon=\"axo_filter_remove\"></mat-icon>\n </button>\n</div>\n", styles: ["lib-dashboard-filter{max-width:100%;width:100%;height:3.7rem;display:flex;align-items:start}lib-dashboard-filter .widthWithCrossFilter{width:calc(100% - 2.563rem);min-width:calc(100% - 2.563rem);max-width:calc(100% - 2.563rem);display:flex;align-items:center}lib-dashboard-filter .global-filter{height:100%;display:flex;align-items:center;max-width:100%}lib-dashboard-filter .global-filter .dash-reset,lib-dashboard-filter .global-filter .reset-section,lib-dashboard-filter .global-filter .reset-btn{border-left:1px solid #c9c9c9c9;white-space:nowrap;width:144px;display:flex;height:2rem;align-items:start;padding-left:.4rem}lib-dashboard-filter .global-filter .dash-reset .reset,lib-dashboard-filter .global-filter .reset-section .reset,lib-dashboard-filter .global-filter .reset-btn .reset{margin:0;font-size:11px}lib-dashboard-filter .global-filter .filter-wrapper{position:inherit;display:inline-block;gap:25px;max-width:calc(100% - 154px);height:2.7rem;line-height:2.7rem;align-items:start!important;overflow-y:hidden;align-self:center}lib-dashboard-filter .global-filter .filter-wrapper .reset{margin:0!important}\n"] }]
+    }], function () { return [{ type: i1.ElementService }, { type: i2.ActivatedRoute }]; }, { filters: [{
+            type: Input
+        }], categories: [{
+            type: Input
+        }], screenType: [{
+            type: Input
+        }], commonFilterArray: [{
+            type: Input
+        }], crossFilterEnabled: [{
+            type: Input
+        }], dirtyFlowCheckEvent: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/dashboard-lib/dashboard-lib.module.mjs

@@ -0,0 +1,111 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DashboardControlService } from './dashboard-control.service';
+import { MatMomentDateModule, MAT_MOMENT_DATE_ADAPTER_OPTIONS } from '@angular/material-moment-adapter';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatNativeDateModule } from '@angular/material/core';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatInputModule } from '@angular/material/input';
+import { MatListModule } from '@angular/material/list';
+import { MatSortModule } from '@angular/material/sort';
+import { MatTableModule } from '@angular/material/table';
+import { MatButtonModule } from '@angular/material/button';
+import { SelectDashboardsDialogComponent } from './show-dashboards/show-dashboards.component';
+import { MatSelectModule } from '@angular/material/select';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatGridListModule } from '@angular/material/grid-list';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatIconModule } from '@angular/material/icon';
+import * as i0 from "@angular/core";
+export class DashboardLibModule {
+}
+DashboardLibModule.ɵfac = function DashboardLibModule_Factory(t) { return new (t || DashboardLibModule)(); };
+DashboardLibModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: DashboardLibModule });
+DashboardLibModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+        DashboardControlService,
+        { provide: MAT_MOMENT_DATE_ADAPTER_OPTIONS, useValue: { useUtc: true } }
+    ], imports: [[
+            CommonModule,
+            MatInputModule,
+            MatButtonModule,
+            MatDatepickerModule,
+            MatNativeDateModule,
+            MatMomentDateModule,
+            MatListModule,
+            MatCheckboxModule,
+            MatTableModule,
+            MatSortModule,
+            MatSelectModule,
+            MatSlideToggleModule,
+            MatDialogModule,
+            MatMenuModule,
+            MatGridListModule,
+            MatFormFieldModule,
+            ReactiveFormsModule,
+            MatSnackBarModule,
+            MatIconModule,
+            FormsModule,
+            ReactiveFormsModule
+        ]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DashboardLibModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [
+                    SelectDashboardsDialogComponent
+                ],
+                imports: [
+                    CommonModule,
+                    MatInputModule,
+                    MatButtonModule,
+                    MatDatepickerModule,
+                    MatNativeDateModule,
+                    MatMomentDateModule,
+                    MatListModule,
+                    MatCheckboxModule,
+                    MatTableModule,
+                    MatSortModule,
+                    MatSelectModule,
+                    MatSlideToggleModule,
+                    MatDialogModule,
+                    MatMenuModule,
+                    MatGridListModule,
+                    MatFormFieldModule,
+                    ReactiveFormsModule,
+                    MatSnackBarModule,
+                    MatIconModule,
+                    FormsModule,
+                    ReactiveFormsModule
+                ],
+                exports: [],
+                providers: [
+                    DashboardControlService,
+                    { provide: MAT_MOMENT_DATE_ADAPTER_OPTIONS, useValue: { useUtc: true } }
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DashboardLibModule, { declarations: [SelectDashboardsDialogComponent], imports: [CommonModule,
+        MatInputModule,
+        MatButtonModule,
+        MatDatepickerModule,
+        MatNativeDateModule,
+        MatMomentDateModule,
+        MatListModule,
+        MatCheckboxModule,
+        MatTableModule,
+        MatSortModule,
+        MatSelectModule,
+        MatSlideToggleModule,
+        MatDialogModule,
+        MatMenuModule,
+        MatGridListModule,
+        MatFormFieldModule,
+        ReactiveFormsModule,
+        MatSnackBarModule,
+        MatIconModule,
+        FormsModule,
+        ReactiveFormsModule] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/dashboard-lib/dashboard-list.service.mjs

@@ -0,0 +1,73 @@
+// External libs
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class DashboardListService {
+    // flatten: IFlatten;
+    /**
+     * Constructor
+     */
+    constructor(_httpClient) {
+        this._httpClient = _httpClient;
+        this.dashboardList = new BehaviorSubject(null);
+        this._dashboardId = new BehaviorSubject(null);
+    }
+    // -----------------------------------------------------------------------------------------------------
+    // @ Accessors
+    // -----------------------------------------------------------------------------------------------------
+    /**
+     * Getter for dashboards
+     */
+    get dashboardsList$() {
+        return this.dashboardList.asObservable();
+    }
+    // -----------------------------------------------------------------------------------------------------
+    // @ Public methods
+    // -----------------------------------------------------------------------------------------------------
+    // Get dashboard list by the appversion id provided in route
+    getDashboardList(appVersionId) {
+        let params = new HttpParams();
+        params = params.append('appVersionId', appVersionId);
+        return this._httpClient.get('dashboards', { params: params }).pipe(tap((response) => {
+            this.dashboardList.next(response);
+        }));
+    }
+    // Get dashboard by the id provided in route
+    getDashboardData(appVersionId) {
+        let params = new HttpParams();
+        params = params.append('appVersionId', appVersionId);
+        return new Promise((resolve, reject) => {
+            this._httpClient.get('dashboards', { params: params })
+                .subscribe((response) => {
+                this.dashboardList.next(response);
+                resolve(response);
+            }, reject);
+        });
+    }
+    //create dashboard
+    createDashboard(dashboard) {
+        return new Promise((resolve, reject) => {
+            this._httpClient.post('dashboards', dashboard).subscribe((response) => {
+                this._dashboardId.next(response);
+                resolve(response);
+            }, reject);
+        });
+    }
+    deleteDashboard(dashboardId) {
+        return new Promise((resolve, reject) => {
+            this._httpClient.delete('dashboards?id=' + dashboardId).subscribe((response) => {
+                this._dashboardId.next(response);
+                resolve(response);
+            }, reject);
+        });
+    }
+}
+DashboardListService.ɵfac = function DashboardListService_Factory(t) { return new (t || DashboardListService)(i0.ɵɵinject(i1.HttpClient)); };
+DashboardListService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DashboardListService, factory: DashboardListService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DashboardListService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/dashboard-lib/dashboard.mjs

@@ -0,0 +1,15 @@
+import { EntityBase } from '../common-utils/entity-base';
+import { AxFilter } from '../enlighten-lib/filters/ax-filter';
+import { FilterCategory } from '../enlighten-lib/filters/filter-category';
+export class Dashboard extends EntityBase {
+    constructor(dashboard) {
+        super(dashboard);
+        this.name = dashboard.name;
+        this.appVersionId = dashboard.appVersionId;
+        this.dashboardElements = dashboard && dashboard.dashboardElements || [];
+        this.filters = dashboard && AxFilter.createFilters(dashboard.filters) || [];
+        this.categories = dashboard && FilterCategory.createCategories(dashboard.categories) || [];
+        this.isDirty = dashboard && dashboard.isDirty || false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/dashboard-lib/send-to-dashboard.service.mjs

@@ -0,0 +1,96 @@
+import { Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { SelectDashboardsDialogComponent } from '../dashboard-lib/show-dashboards/show-dashboards.component';
+import { ConfirmationModalComponent } from '../shared/comfirmation-modal/confirmation-modal.component';
+import { ReportBuilderMasterService } from '../enlighten-lib/report/report-builder-master.service';
+import { CommonService } from '../common.service';
+import { AxoSnackBarService, AxoSnackBarType } from '../axo-snack-bar/axo-snack-bar.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../enlighten-lib/report/report-builder-master.service";
+import * as i3 from "../common.service";
+import * as i4 from "../axo-snack-bar/axo-snack-bar.service";
+export class SendToDashboardService {
+    constructor(dialog, _reportBuilderMasterService, _commonService, _axoSnackBar) {
+        this.dialog = dialog;
+        this._reportBuilderMasterService = _reportBuilderMasterService;
+        this._commonService = _commonService;
+        this._axoSnackBar = _axoSnackBar;
+    }
+    /**
+     * Send element/filter to dashboard
+     *
+     * @param filters
+     * @param elements
+     *
+     */
+    sendToDashboard(sendToDashboardData) {
+        this.report = this._reportBuilderMasterService.report;
+        if (this._commonService.isReportBuilderDirty) {
+            this.openConfirmationPopup(sendToDashboardData);
+        }
+        else {
+            const dialogRef = this.dialog.open(SelectDashboardsDialogComponent, {
+                width: '430px',
+                data: sendToDashboardData
+            });
+        }
+    }
+    /**
+     * Open Confirmation dialog if report is not saved. when we try to send chart on dashboard
+     *
+     * @param data
+     *
+     */
+    async openConfirmationPopup(element) {
+        const dialogRef = this.dialog.open(ConfirmationModalComponent, {
+            width: '30%',
+            data: {
+                title: 'Unsaved Changes',
+                message: 'The report has unsaved changes. Before pin to dashboard, you must save your progress.',
+                confirmButtonText: 'Save and Pin',
+                cancelButtonText: 'Cancel'
+            },
+            panelClass: 'confirm-modal-container'
+        });
+        dialogRef.afterClosed().subscribe((result) => {
+            if (result) {
+                this.saveAndSendToDashboard(element);
+            }
+        });
+    }
+    /**
+     *
+     *to save report and pin element to dashboard
+     *
+     * @param data
+     */
+    async saveAndSendToDashboard(element) {
+        this._commonService.isReportBuilderDirty = false;
+        this._reportBuilderMasterService.saveReport(this.report).then((reportresp) => {
+            reportresp.filters.forEach((filter, filterIndex) => {
+                this.report.filters[filterIndex].id = filter.id;
+            });
+            reportresp.pages.forEach((page, pageIndex) => {
+                this.report.pages[pageIndex].id = page.id;
+                page.elements.forEach((value, elmentIndex) => {
+                    this.report.pages[pageIndex].elements[elmentIndex].id = value.id;
+                    value.filters.forEach((filter, filterIndex) => {
+                        this.report.pages[pageIndex].elements[elmentIndex].filters[filterIndex].id = filter.id;
+                    });
+                    value.categories.forEach((category, categoryIndex) => {
+                        this.report.pages[pageIndex].elements[elmentIndex].categories[categoryIndex].id = category.id;
+                    });
+                });
+            });
+            this._axoSnackBar.openSnackBar('Report Saved.', AxoSnackBarType.success);
+        });
+        this.sendToDashboard(element);
+    }
+}
+SendToDashboardService.ɵfac = function SendToDashboardService_Factory(t) { return new (t || SendToDashboardService)(i0.ɵɵinject(i1.MatDialog), i0.ɵɵinject(i2.ReportBuilderMasterService), i0.ɵɵinject(i3.CommonService), i0.ɵɵinject(i4.AxoSnackBarService)); };
+SendToDashboardService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SendToDashboardService, factory: SendToDashboardService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SendToDashboardService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.MatDialog }, { type: i2.ReportBuilderMasterService }, { type: i3.CommonService }, { type: i4.AxoSnackBarService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send-to-dashboard.service.js","sourceRoot":"","sources":["../../../../../src/ax-app-common-lib/src/lib/dashboard-lib/send-to-dashboard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnInit } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { Report } from '../common-utils/report';\nimport { ISendToDashboardData, SelectDashboardsDialogComponent } from '../dashboard-lib/show-dashboards/show-dashboards.component';\nimport { MatSnackBar } from '@angular/material/snack-bar';\nimport { ConfirmationModalComponent } from '../shared/comfirmation-modal/confirmation-modal.component';\nimport { ReportBuilderMasterService } from '../enlighten-lib/report/report-builder-master.service';\nimport { CommonService } from '../common.service';\nimport { AxoSnackBarService, AxoSnackBarType } from '../axo-snack-bar/axo-snack-bar.service';\n\n\n\n@Injectable()\nexport class SendToDashboardService{\n  report: Report;\n  constructor(\n    public dialog: MatDialog,\n    private _reportBuilderMasterService: ReportBuilderMasterService,\n    private _commonService: CommonService,\n    private _axoSnackBar: AxoSnackBarService,\n\n  ) {\n  }\n\n\n  /**\n   * Send element/filter to dashboard\n   *\n   * @param filters\n   * @param elements\n   *\n   */\n  sendToDashboard(sendToDashboardData: ISendToDashboardData): void {\n    this.report=this._reportBuilderMasterService.report;\n    if(this._commonService.isReportBuilderDirty){\n      this.openConfirmationPopup(sendToDashboardData);\n    }\n    else{\n      const dialogRef = this.dialog.open(SelectDashboardsDialogComponent, {\n        width: '430px',\n        data: sendToDashboardData\n      });\n    }\n  }\n\n\n  /**\n   * Open Confirmation dialog if report is not saved. when we try to send chart on dashboard\n   *\n   * @param data\n   *\n   */\n  async openConfirmationPopup(element: ISendToDashboardData): Promise<void> {\n    const dialogRef = this.dialog.open(ConfirmationModalComponent, {\n    width: '30%',\n    data: {\n        title: 'Unsaved Changes',\n        message: 'The report has unsaved changes. Before pin to dashboard, you must save your progress.',\n        confirmButtonText: 'Save and Pin',\n        cancelButtonText: 'Cancel'\n      },\n      panelClass: 'confirm-modal-container'\n    });\n\n    dialogRef.afterClosed().subscribe((result) => {\n    if (result) {\n        this.saveAndSendToDashboard(element);\n      }\n    });\n  }\n  /**\n   *\n   *to save report and pin element to dashboard\n   *\n   * @param data\n   */\n    async saveAndSendToDashboard(element: ISendToDashboardData): Promise<void> {\n      this._commonService.isReportBuilderDirty = false;\n      this._reportBuilderMasterService.saveReport(this.report).then((reportresp) => {\n          reportresp.filters.forEach((filter, filterIndex) => {\n            this.report.filters[filterIndex].id = filter.id;\n          });\n          reportresp.pages.forEach((page, pageIndex) => {\n            this.report.pages[pageIndex].id = page.id;\n              page.elements.forEach((value, elmentIndex) => {\n                  this.report.pages[pageIndex].elements[elmentIndex].id = value.id;\n                  value.filters.forEach((filter,filterIndex)=>{\n                    this.report.pages[pageIndex].elements[elmentIndex].filters[filterIndex].id =  filter.id;\n                 });\n                 value.categories.forEach((category,categoryIndex)=>{\n                  this.report.pages[pageIndex].elements[elmentIndex].categories[categoryIndex].id =  category.id;\n                 });\n              });\n          });\n          this._axoSnackBar.openSnackBar('Report Saved.',AxoSnackBarType.success);\n      });\n    this.sendToDashboard(element);\n  }\n\n  /**\n   * Open the snackbar and dispay message.\n   *\n   * @param message\n   *\n   */\n\n}\n"]}