ax-common-ui-lib 1.0.0-beta.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGFzaGJvYXJkLWxpYi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXgtY29tbW9uLXVpLWxpYi9zcmMvbGliL2Rhc2hib2FyZC1saWIvZGFzaGJvYXJkLWxpYi5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDdEUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLCtCQUErQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDeEcsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDL0QsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDN0QsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDbkUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3pELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3pELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsK0JBQStCLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQztBQUM5RixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDM0QsT0FBTyxFQUFFLFdBQVcsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUNsRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDdEUsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQXFDdkQsTUFBTSxPQUFPLGtCQUFrQjs7b0ZBQWxCLGtCQUFrQjtvRUFBbEIsa0JBQWtCO3lFQUxuQjtRQUNSLHVCQUF1QjtRQUN2QixFQUFFLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxRQUFRLEVBQUUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLEVBQUU7S0FDekUsWUE3QlE7WUFDUCxZQUFZO1lBQ1osY0FBYztZQUNkLGVBQWU7WUFDZixtQkFBbUI7WUFDbkIsbUJBQW1CO1lBQ25CLG1CQUFtQjtZQUNuQixhQUFhO1lBQ2IsaUJBQWlCO1lBQ2pCLGNBQWM7WUFDZCxhQUFhO1lBQ2IsZUFBZTtZQUNmLG9CQUFvQjtZQUNwQixlQUFlO1lBQ2YsYUFBYTtZQUNiLGlCQUFpQjtZQUNqQixrQkFBa0I7WUFDbEIsbUJBQW1CO1lBQ25CLGlCQUFpQjtZQUNqQixhQUFhO1lBQ2IsV0FBVztZQUNYLG1CQUFtQjtTQUVwQjt1RkFRVSxrQkFBa0I7Y0FuQzlCLFFBQVE7ZUFBQztnQkFDUixZQUFZLEVBQUU7b0JBQ1osK0JBQStCO2lCQUNoQztnQkFDRCxPQUFPLEVBQUU7b0JBQ1AsWUFBWTtvQkFDWixjQUFjO29CQUNkLGVBQWU7b0JBQ2YsbUJBQW1CO29CQUNuQixtQkFBbUI7b0JBQ25CLG1CQUFtQjtvQkFDbkIsYUFBYTtvQkFDYixpQkFBaUI7b0JBQ2pCLGNBQWM7b0JBQ2QsYUFBYTtvQkFDYixlQUFlO29CQUNmLG9CQUFvQjtvQkFDcEIsZUFBZTtvQkFDZixhQUFhO29CQUNiLGlCQUFpQjtvQkFDakIsa0JBQWtCO29CQUNsQixtQkFBbUI7b0JBQ25CLGlCQUFpQjtvQkFDakIsYUFBYTtvQkFDYixXQUFXO29CQUNYLG1CQUFtQjtpQkFFcEI7Z0JBQ0QsT0FBTyxFQUFDLEVBQ1A7Z0JBQ0QsU0FBUyxFQUFDO29CQUNSLHVCQUF1QjtvQkFDdkIsRUFBRSxPQUFPLEVBQUUsK0JBQStCLEVBQUUsUUFBUSxFQUFFLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxFQUFFO2lCQUN6RTthQUNGOzt3RkFDWSxrQkFBa0IsbUJBakMzQiwrQkFBK0IsYUFHL0IsWUFBWTtRQUNaLGNBQWM7UUFDZCxlQUFlO1FBQ2YsbUJBQW1CO1FBQ25CLG1CQUFtQjtRQUNuQixtQkFBbUI7UUFDbkIsYUFBYTtRQUNiLGlCQUFpQjtRQUNqQixjQUFjO1FBQ2QsYUFBYTtRQUNiLGVBQWU7UUFDZixvQkFBb0I7UUFDcEIsZUFBZTtRQUNmLGFBQWE7UUFDYixpQkFBaUI7UUFDakIsa0JBQWtCO1FBQ2xCLG1CQUFtQjtRQUNuQixpQkFBaUI7UUFDakIsYUFBYTtRQUNiLFdBQVc7UUFDWCxtQkFBbUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IERhc2hib2FyZENvbnRyb2xTZXJ2aWNlIH0gZnJvbSAnLi9kYXNoYm9hcmQtY29udHJvbC5zZXJ2aWNlJztcbmltcG9ydCB7IE1hdE1vbWVudERhdGVNb2R1bGUsIE1BVF9NT01FTlRfREFURV9BREFQVEVSX09QVElPTlMgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC1tb21lbnQtYWRhcHRlcic7XG5pbXBvcnQgeyBNYXRDaGVja2JveE1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2NoZWNrYm94JztcbmltcG9ydCB7IE1hdE5hdGl2ZURhdGVNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9jb3JlJztcbmltcG9ydCB7IE1hdERhdGVwaWNrZXJNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9kYXRlcGlja2VyJztcbmltcG9ydCB7IE1hdElucHV0TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaW5wdXQnO1xuaW1wb3J0IHsgTWF0TGlzdE1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2xpc3QnO1xuaW1wb3J0IHsgTWF0U29ydE1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL3NvcnQnO1xuaW1wb3J0IHsgTWF0VGFibGVNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC90YWJsZSc7XG5pbXBvcnQgeyBNYXRCdXR0b25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9idXR0b24nO1xuaW1wb3J0IHsgU2VsZWN0RGFzaGJvYXJkc0RpYWxvZ0NvbXBvbmVudCB9IGZyb20gJy4vc2hvdy1kYXNoYm9hcmRzL3Nob3ctZGFzaGJvYXJkcy5jb21wb25lbnQnO1xuaW1wb3J0IHsgTWF0U2VsZWN0TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvc2VsZWN0JztcbmltcG9ydCB7IEZvcm1zTW9kdWxlLCBSZWFjdGl2ZUZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgTWF0RGlhbG9nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvZGlhbG9nJztcbmltcG9ydCB7IE1hdEZvcm1GaWVsZE1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2Zvcm0tZmllbGQnO1xuaW1wb3J0IHsgTWF0R3JpZExpc3RNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9ncmlkLWxpc3QnO1xuaW1wb3J0IHsgTWF0TWVudU1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL21lbnUnO1xuaW1wb3J0IHsgTWF0U25hY2tCYXJNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9zbmFjay1iYXInO1xuaW1wb3J0IHsgTWF0U2xpZGVUb2dnbGVNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9zbGlkZS10b2dnbGUnO1xuaW1wb3J0IHsgTWF0SWNvbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2ljb24nO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBTZWxlY3REYXNoYm9hcmRzRGlhbG9nQ29tcG9uZW50XG4gIF0sXG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgTWF0SW5wdXRNb2R1bGUsXG4gICAgTWF0QnV0dG9uTW9kdWxlLFxuICAgIE1hdERhdGVwaWNrZXJNb2R1bGUsXG4gICAgTWF0TmF0aXZlRGF0ZU1vZHVsZSxcbiAgICBNYXRNb21lbnREYXRlTW9kdWxlLFxuICAgIE1hdExpc3RNb2R1bGUsXG4gICAgTWF0Q2hlY2tib3hNb2R1bGUsXG4gICAgTWF0VGFibGVNb2R1bGUsXG4gICAgTWF0U29ydE1vZHVsZSxcbiAgICBNYXRTZWxlY3RNb2R1bGUsXG4gICAgTWF0U2xpZGVUb2dnbGVNb2R1bGUsXG4gICAgTWF0RGlhbG9nTW9kdWxlLFxuICAgIE1hdE1lbnVNb2R1bGUsXG4gICAgTWF0R3JpZExpc3RNb2R1bGUsXG4gICAgTWF0Rm9ybUZpZWxkTW9kdWxlLFxuICAgIFJlYWN0aXZlRm9ybXNNb2R1bGUsXG4gICAgTWF0U25hY2tCYXJNb2R1bGUsXG4gICAgTWF0SWNvbk1vZHVsZSxcbiAgICBGb3Jtc01vZHVsZSxcbiAgICBSZWFjdGl2ZUZvcm1zTW9kdWxlXG5cbiAgXSxcbiAgZXhwb3J0czpbXG4gIF0sXG4gIHByb3ZpZGVyczpbXG4gICAgRGFzaGJvYXJkQ29udHJvbFNlcnZpY2UsXG4gICAgeyBwcm92aWRlOiBNQVRfTU9NRU5UX0RBVEVfQURBUFRFUl9PUFRJT05TLCB1c2VWYWx1ZTogeyB1c2VVdGM6IHRydWUgfSB9XG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgRGFzaGJvYXJkTGliTW9kdWxlIHsgfVxuIl19

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-common-ui-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"]}