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

package/esm2020/lib/drill-through/drill-through.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DrillThroughComponent } from './drill-through.component';
+import { MatIconModule } from '@angular/material/icon';
+import { EnlightenLibModule } from '../enlighten-lib/enlighten-lib.module';
+import * as i0 from "@angular/core";
+export class DrillThroughModule {
+}
+DrillThroughModule.ɵfac = function DrillThroughModule_Factory(t) { return new (t || DrillThroughModule)(); };
+DrillThroughModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: DrillThroughModule });
+DrillThroughModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [[
+            CommonModule,
+            MatIconModule,
+            EnlightenLibModule
+        ]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrillThroughModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [
+                    DrillThroughComponent
+                ],
+                imports: [
+                    CommonModule,
+                    MatIconModule,
+                    EnlightenLibModule
+                ],
+                exports: [DrillThroughComponent]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DrillThroughModule, { declarations: [DrillThroughComponent], imports: [CommonModule,
+        MatIconModule,
+        EnlightenLibModule], exports: [DrillThroughComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJpbGwtdGhyb3VnaC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXgtYXBwLWNvbW1vbi1saWIvc3JjL2xpYi9kcmlsbC10aHJvdWdoL2RyaWxsLXRocm91Z2gubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQzs7QUFlM0UsTUFBTSxPQUFPLGtCQUFrQjs7b0ZBQWxCLGtCQUFrQjtvRUFBbEIsa0JBQWtCO3dFQVBwQjtZQUNQLFlBQVk7WUFDWixhQUFhO1lBQ2Isa0JBQWtCO1NBQ25CO3VGQUdVLGtCQUFrQjtjQVg5QixRQUFRO2VBQUM7Z0JBQ1IsWUFBWSxFQUFFO29CQUNaLHFCQUFxQjtpQkFDdEI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLFlBQVk7b0JBQ1osYUFBYTtvQkFDYixrQkFBa0I7aUJBQ25CO2dCQUNELE9BQU8sRUFBQyxDQUFDLHFCQUFxQixDQUFDO2FBQ2hDOzt3RkFDWSxrQkFBa0IsbUJBVDNCLHFCQUFxQixhQUdyQixZQUFZO1FBQ1osYUFBYTtRQUNiLGtCQUFrQixhQUVYLHFCQUFxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgRHJpbGxUaHJvdWdoQ29tcG9uZW50IH0gZnJvbSAnLi9kcmlsbC10aHJvdWdoLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBNYXRJY29uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaWNvbic7XG5pbXBvcnQgeyBFbmxpZ2h0ZW5MaWJNb2R1bGUgfSBmcm9tICcuLi9lbmxpZ2h0ZW4tbGliL2VubGlnaHRlbi1saWIubW9kdWxlJztcblxuXG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1xuICAgIERyaWxsVGhyb3VnaENvbXBvbmVudFxuICBdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIE1hdEljb25Nb2R1bGUsXG4gICAgRW5saWdodGVuTGliTW9kdWxlXG4gIF0sXG4gIGV4cG9ydHM6W0RyaWxsVGhyb3VnaENvbXBvbmVudF1cbn0pXG5leHBvcnQgY2xhc3MgRHJpbGxUaHJvdWdoTW9kdWxlIHsgfVxuIl19

package/esm2020/lib/drill-through/drill-through.resolver.mjs

@@ -0,0 +1,80 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Page } from '../enlighten-lib/report/graphical-report/page/page';
+import { DrillThroughService } from './drill-through.service';
+import { BreadCrumbsService } from '../bread-crumbs/bread-crumbs.service';
+import { ScreenType } from '../enlighten-lib/filters/condition-type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./drill-through.service";
+import * as i3 from "../bread-crumbs/bread-crumbs.service";
+export class DrillThroughResolver {
+    /**
+     * Constructor
+     */
+    constructor(_httpClient, _drillThroughService, _breadCrumbService) {
+        this._httpClient = _httpClient;
+        this._drillThroughService = _drillThroughService;
+        this._breadCrumbService = _breadCrumbService;
+        this._drillThroughService.restoreStates();
+    }
+    // -----------------------------------------------------------------------------------------------------
+    // @ Public methods
+    // -----------------------------------------------------------------------------------------------------
+    /**
+     * Use this resolver to resolve initial api for the module
+     *
+     * @param route
+     * @param state
+     */
+    resolve(route, state) {
+        const pageId = route.params.pageId;
+        return new Promise((resolve, reject) => {
+            Promise.all([
+                this.getPageData(pageId)
+            ]).then((response) => {
+                this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.reportBuilder);
+                this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.dashboardBuilder);
+                this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.containerDashboard);
+                resolve(response);
+            }).catch((error) => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Get page data by page id
+     *
+     * @param pageId
+     * @returns
+     */
+    getPageData(pageId) {
+        let httpParams = new HttpParams();
+        httpParams = httpParams.append('pageId', pageId.toString());
+        return new Promise((resolve, reject) => {
+            const currentState = this._drillThroughService.GetCurrentDrillThroughState();
+            if (currentState && currentState.isLoaded) {
+                const isPageExists = this._drillThroughService.checkLoadedPageExists(Number(pageId));
+                if (isPageExists) {
+                    this._drillThroughService.onPageChanged.emit('page_changed');
+                }
+                resolve(true);
+            }
+            else {
+                this._httpClient.get('drillthrough/getdrilledpage', { params: httpParams })
+                    .subscribe((response) => {
+                    this._drillThroughService.GetCurrentDrillThroughState().page = new Page(response);
+                    this._drillThroughService.GetCurrentDrillThroughState().isLoaded = true;
+                    this._drillThroughService.onPageChanged.emit('page_changed');
+                    resolve(response);
+                }, reject);
+            }
+        });
+    }
+}
+DrillThroughResolver.ɵfac = function DrillThroughResolver_Factory(t) { return new (t || DrillThroughResolver)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.DrillThroughService), i0.ɵɵinject(i3.BreadCrumbsService)); };
+DrillThroughResolver.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DrillThroughResolver, factory: DrillThroughResolver.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrillThroughResolver, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.DrillThroughService }, { type: i3.BreadCrumbsService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/drill-through/drill-through.service.mjs

@@ -0,0 +1,218 @@
+import { Injectable, EventEmitter } from '@angular/core';
+import { Page } from '../enlighten-lib/report/graphical-report/page/page';
+import { ScreenType } from '../enlighten-lib/filters/condition-type';
+import { BreadCrumbsService, BreadCrumb } from '../bread-crumbs/bread-crumbs.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../bread-crumbs/bread-crumbs.service";
+/**
+ * @class DrillPageState :- hold the state of drilled page
+ */
+export class DrillPageState {
+    constructor(page, filter) {
+        this.page = page;
+        this.filter = filter;
+        this.isLoaded = false;
+    }
+}
+export class ParentData {
+}
+export class DrillThroughService {
+    constructor(_breadCrumbService) {
+        this._breadCrumbService = _breadCrumbService;
+        /* Drilled page saved here. this array will help to going back to previous drill page  */
+        this._drillThroughStates = [];
+        this._drillThroughStatesRedo = [];
+        this._parentData = new ParentData();
+        this.onPageChanged = new EventEmitter();
+    }
+    /**
+     * This will save page and filter in array for preserving routing state.
+     *
+     * @param page
+     * @param filter
+     */
+    drillPage(page, filter) {
+        this._drillThroughStates.push(new DrillPageState(page, filter));
+    }
+    /**
+     * Remove preserved drill page from array on back button click
+     */
+    PageBack() {
+        const poppedState = this._drillThroughStates.pop();
+        this._drillThroughStatesRedo.push(poppedState);
+        if (!this._drillThroughStates.length) {
+            return null;
+        }
+        const currentState = this._drillThroughStates[this._drillThroughStates.length - 1];
+        this._breadCrumbService.changeCurrentBreadCrumb(currentState.page.id);
+        this._breadCrumbService.update();
+        return currentState;
+    }
+    PageNext() {
+        const drillPageState = this._drillThroughStatesRedo.pop();
+        if (drillPageState) {
+            this.drillPage(drillPageState.page, drillPageState.filter);
+        }
+        return drillPageState;
+    }
+    /**
+     *  This function return the current drill through state.
+     */
+    GetCurrentDrillThroughState() {
+        if (this._drillThroughStates.length < 1) {
+            return null;
+        }
+        return this._drillThroughStates[this._drillThroughStates.length - 1];
+    }
+    /**
+     * This function removes the pages from Drill Through States on change of bread crumbs state
+     */
+    changeDrillThroughStates(index) {
+        if (index < this._drillThroughStates.length) {
+            const states = this._drillThroughStates.splice(index).reverse();
+            states.forEach((state) => {
+                this._drillThroughStatesRedo.push(state);
+            });
+            const currentState = this.GetCurrentDrillThroughState();
+            const breadCrumbIndex = this._breadCrumbService.breadCrumbs.map(b => b.itemId).lastIndexOf(currentState.page.id);
+            this._breadCrumbService.changeCurrentBreadCrumb(breadCrumbIndex);
+            this._breadCrumbService.update();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * check loaded page already exists if it is then change the drill through states accordingly
+     */
+    checkLoadedPageExists(pageId) {
+        const index = this._drillThroughStates.findIndex(d => d.page.id === pageId);
+        if (index != -1) {
+            this.changeDrillThroughStates(index + 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Destroy drill through data
+     */
+    destroy() {
+        this._drillThroughStates = [];
+        this._drillThroughStatesRedo = [];
+        this._parentData = new ParentData();
+        this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.drillThrough);
+        localStorage.removeItem('drill_states');
+        localStorage.removeItem('drill_redo_states');
+        localStorage.removeItem('paranet_data');
+    }
+    /**
+     * Save states in localstorage on reload
+     */
+    saveStates() {
+        localStorage.setItem('drill_states', JSON.stringify(this._drillThroughStates));
+        localStorage.setItem('drill_redo_states', JSON.stringify(this._drillThroughStatesRedo));
+        localStorage.setItem('paranet_data', JSON.stringify(this._parentData));
+    }
+    /**
+     * Set the parent data of the drill through
+     *
+     * @param id
+     * @param name
+     * @param url
+     */
+    setParentData(id, name, url) {
+        if (!this._parentData.id) {
+            this._parentData = new ParentData();
+            this._parentData.id = id;
+            this._parentData.name = name;
+            this._parentData.screenType = ScreenType.drillThrough;
+            this._parentData.url = url;
+        }
+    }
+    /**
+     * Get parent data of drill through
+     *
+     * @returns
+     */
+    getParentData() {
+        return this._parentData;
+    }
+    /**
+     * Restore states when reload of page finishes
+     */
+    restoreStates() {
+        const drillThroughStates = JSON.parse(localStorage.getItem('drill_states'));
+        const drillThroughStatesRedo = JSON.parse(localStorage.getItem('drill_states_redo'));
+        const parentData = JSON.parse(localStorage.getItem('paranet_data'));
+        if (drillThroughStates && drillThroughStates.length) {
+            this.setParentData(parentData.id, parentData.name, parentData.url);
+            this.setParentBreadCrumb();
+            this._drillThroughStates = drillThroughStates;
+            this._drillThroughStates.forEach((state) => {
+                state.page = new Page(state.page);
+                state.filter = state.filter;
+            });
+            if (drillThroughStatesRedo && drillThroughStatesRedo.length) {
+                this._drillThroughStatesRedo = drillThroughStatesRedo;
+            }
+            this._drillThroughStates.forEach((state, index) => {
+                if (index < this._drillThroughStates.length - 1) {
+                    this.setPageBreadCrumb(state.page);
+                }
+            });
+        }
+    }
+    /**
+     * Set drill thorugh parent bread crumb
+     */
+    setParentBreadCrumb() {
+        const breadCrumb = new BreadCrumb();
+        breadCrumb.itemId = this._parentData.id;
+        breadCrumb.title = this._parentData.name;
+        breadCrumb.url = this._parentData.url;
+        breadCrumb.screenType = ScreenType.drillThrough;
+        this._breadCrumbService.addBreadCrumb(breadCrumb);
+        this._breadCrumbService.update();
+    }
+    /**
+     * Set bread crumbs for all states/pages of drill through
+     */
+    setBreadCrumbs() {
+        this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.drillThrough);
+        this.setParentBreadCrumb();
+        this._drillThroughStates.forEach((state, index) => {
+            this.setPageBreadCrumb(state.page);
+        });
+    }
+    /**
+     * Set page bread crumb
+     *
+     * @param page
+     */
+    setPageBreadCrumb(page) {
+        const breadCrumb = new BreadCrumb();
+        breadCrumb.itemId = page.id;
+        breadCrumb.title = page.name;
+        breadCrumb.url = this._parentData.url + '/drill-through/' + page.id;
+        breadCrumb.parentId = this._parentData.id;
+        breadCrumb.screenType = ScreenType.drillThrough;
+        this._breadCrumbService.addBreadCrumb(breadCrumb);
+        this._breadCrumbService.update();
+    }
+    /**
+     * returns true if there next page to show
+     *
+     * @returns boolean
+     */
+    hasNextPage() {
+        return (this._drillThroughStatesRedo.length > 0);
+    }
+}
+DrillThroughService.ɵfac = function DrillThroughService_Factory(t) { return new (t || DrillThroughService)(i0.ɵɵinject(i1.BreadCrumbsService)); };
+DrillThroughService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DrillThroughService, factory: DrillThroughService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrillThroughService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.BreadCrumbsService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drill-through.service.js","sourceRoot":"","sources":["../../../../../src/ax-app-common-lib/src/lib/drill-through/drill-through.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, EventEmitter } from '@angular/core';\nimport { AxFilter } from '../enlighten-lib/filters/ax-filter';\nimport { Page } from '../enlighten-lib/report/graphical-report/page/page';\nimport { ScreenType } from '../enlighten-lib/filters/condition-type';\nimport { BreadCrumbsService, BreadCrumb } from '../bread-crumbs/bread-crumbs.service';\n\n/**\n * @class DrillPageState :- hold the state of drilled page\n */\nexport class DrillPageState\n{\n  page: Page;\n  filter: AxFilter;\n  isLoaded: boolean;\n  constructor(page: Page,filter: AxFilter){\n    this.page = page;\n    this.filter = filter;\n    this.isLoaded= false;\n  }\n}\n\nexport class ParentData {\n  name: string;\n  id: number;\n  screenType: number;\n  url: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DrillThroughService {\n\n  onPageChanged: EventEmitter<string>;\n  /* Drilled page saved here. this array will help to going back to previous drill page  */\n  private _drillThroughStates: Array<DrillPageState> = [];\n  private _drillThroughStatesRedo: Array<DrillPageState> = [];\n  private _parentData: ParentData = new ParentData();\n\n  constructor(private _breadCrumbService: BreadCrumbsService) {\n    this.onPageChanged = new EventEmitter();\n  }\n  /**\n   * This will save page and filter in array for preserving routing state.\n   *\n   * @param page\n   * @param filter\n   */\n  public drillPage(page: Page,filter: AxFilter): void{\n    this._drillThroughStates.push(new DrillPageState(page,filter));\n  }\n\n  /**\n   * Remove preserved drill page from array on back button click\n   */\n  public PageBack(): DrillPageState{\n    const poppedState: DrillPageState = this._drillThroughStates.pop();\n    this._drillThroughStatesRedo.push(poppedState);\n    if(!this._drillThroughStates.length){\n      return null;\n    }\n    const currentState: DrillPageState = this._drillThroughStates[this._drillThroughStates.length-1];\n    this._breadCrumbService.changeCurrentBreadCrumb(currentState.page.id);\n    this._breadCrumbService.update();\n    return currentState;\n  }\n\n  public PageNext(): DrillPageState {\n    const drillPageState: DrillPageState = this._drillThroughStatesRedo.pop();\n    if(drillPageState)\n      {this.drillPage(drillPageState.page, drillPageState.filter);}\n    return drillPageState;\n  }\n\n/**\n *  This function return the current drill through state.\n */\n  public GetCurrentDrillThroughState(): DrillPageState{\n    if(this._drillThroughStates.length < 1){\n      return null;\n    }\n    return this._drillThroughStates[this._drillThroughStates.length-1];\n  }\n\n  /**\n   * This function removes the pages from Drill Through States on change of bread crumbs state\n   */\n  public changeDrillThroughStates(index: number): boolean{\n    if(index < this._drillThroughStates.length){\n      const states: Array<DrillPageState> = this._drillThroughStates.splice(index).reverse();\n      states.forEach((state) => {\n        this._drillThroughStatesRedo.push(state);\n      });\n      const currentState: DrillPageState = this.GetCurrentDrillThroughState();\n      const breadCrumbIndex = this._breadCrumbService.breadCrumbs.map(b => b.itemId).lastIndexOf(currentState.page.id);\n      this._breadCrumbService.changeCurrentBreadCrumb(breadCrumbIndex);\n      this._breadCrumbService.update();\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * check loaded page already exists if it is then change the drill through states accordingly\n   */\n  public checkLoadedPageExists(pageId: number): boolean {\n    const index: number = this._drillThroughStates.findIndex(d => d.page.id === pageId);\n    if(index != -1){\n      this.changeDrillThroughStates(index+1);\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Destroy drill through data\n   */\n  public destroy(): void {\n    this._drillThroughStates = [];\n    this._drillThroughStatesRedo = [];\n    this._parentData = new ParentData();\n    this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.drillThrough);\n    localStorage.removeItem('drill_states');\n    localStorage.removeItem('drill_redo_states');\n    localStorage.removeItem('paranet_data');\n  }\n\n  /**\n   * Save states in localstorage on reload\n   */\n  public saveStates(): void {\n    localStorage.setItem('drill_states', JSON.stringify(this._drillThroughStates));\n    localStorage.setItem('drill_redo_states', JSON.stringify(this._drillThroughStatesRedo));\n    localStorage.setItem('paranet_data', JSON.stringify(this._parentData));\n  }\n\n  /**\n   * Set the parent data of the drill through\n   *\n   * @param id\n   * @param name\n   * @param url\n   */\n  setParentData(id: number, name: string, url: string): void {\n    if(!this._parentData.id){\n      this._parentData = new ParentData();\n      this._parentData.id = id;\n      this._parentData.name = name;\n      this._parentData.screenType = ScreenType.drillThrough;\n      this._parentData.url = url;\n    }\n  }\n\n  /**\n   * Get parent data of drill through\n   *\n   * @returns\n   */\n  getParentData(): ParentData {\n    return this._parentData;\n  }\n\n  /**\n   * Restore states when reload of page finishes\n   */\n  public restoreStates(): void {\n    const drillThroughStates = JSON.parse(localStorage.getItem('drill_states'));\n    const drillThroughStatesRedo = JSON.parse(localStorage.getItem('drill_states_redo'));\n    const parentData = JSON.parse(localStorage.getItem('paranet_data')) as ParentData;\n    if(drillThroughStates && drillThroughStates.length){\n      this.setParentData(parentData.id, parentData.name, parentData.url);\n      this.setParentBreadCrumb();\n      this._drillThroughStates = drillThroughStates;\n      this._drillThroughStates.forEach((state) => {\n        state.page = new Page(state.page);\n        state.filter = state.filter as AxFilter;\n      });\n      if(drillThroughStatesRedo && drillThroughStatesRedo.length)\n        {this._drillThroughStatesRedo = drillThroughStatesRedo;}\n\n      this._drillThroughStates.forEach((state, index) => {\n        if(index < this._drillThroughStates.length-1){\n          this.setPageBreadCrumb(state.page);\n        }\n      });\n    }\n  }\n\n  /**\n   * Set drill thorugh parent bread crumb\n   */\n  setParentBreadCrumb(): void{\n    const breadCrumb = new BreadCrumb();\n    breadCrumb.itemId = this._parentData.id;\n    breadCrumb.title = this._parentData.name;\n    breadCrumb.url = this._parentData.url;\n    breadCrumb.screenType = ScreenType.drillThrough;\n    this._breadCrumbService.addBreadCrumb(breadCrumb);\n    this._breadCrumbService.update();\n  }\n\n  /**\n   * Set bread crumbs for all states/pages of drill through\n   */\n  setBreadCrumbs(): void{\n    this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.drillThrough);\n    this.setParentBreadCrumb();\n    this._drillThroughStates.forEach((state, index) => {\n      this.setPageBreadCrumb(state.page);\n    });\n  }\n\n  /**\n   * Set page bread crumb\n   *\n   * @param page\n   */\n  setPageBreadCrumb(page: Page): void {\n    const breadCrumb = new BreadCrumb();\n    breadCrumb.itemId = page.id;\n    breadCrumb.title = page.name;\n    breadCrumb.url = this._parentData.url + '/drill-through/' + page.id;\n    breadCrumb.parentId = this._parentData.id;\n    breadCrumb.screenType = ScreenType.drillThrough;\n    this._breadCrumbService.addBreadCrumb(breadCrumb);\n    this._breadCrumbService.update();\n  }\n\n  /**\n   * returns true if there next page to show\n   *\n   * @returns boolean\n   */\n  hasNextPage(): boolean {\n    return (this._drillThroughStatesRedo.length > 0);\n  }\n}\n"]}

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-column.mjs

@@ -0,0 +1,37 @@
+import { Attribute } from '../data-model/attribute';
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpColumn extends AxExpressionValue {
+    constructor(axExpColumn) {
+        super(axExpColumn);
+        this.subType = ExpressionValueSubType.column;
+        if (axExpColumn) {
+            this.axExpColumn(axExpColumn);
+        }
+        else {
+            this.newAxExpColumn();
+        }
+    }
+    /**
+     * Create Object of Ex-column by default value
+     */
+    newAxExpColumn() {
+        this.value = new Attribute();
+    }
+    /**
+     * Create Object of Ex-column existing  value
+     *
+     * @param axExpColumn
+     */
+    axExpColumn(axExpColumn) {
+        this.value = axExpColumn.value;
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value) {
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-list.mjs

@@ -0,0 +1,37 @@
+import { AxoUtils } from '../../axo-utils/axo-utils';
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpDateList extends AxExpressionValue {
+    constructor(axExpDateList) {
+        super(axExpDateList);
+        this.subType = ExpressionValueSubType.dateList;
+        if (axExpDateList) {
+            this.axExpDateList(axExpDateList);
+        }
+        else {
+            this.newAxExpDateList();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxExpDateList() {
+        this.value = [];
+    }
+    /**
+     * Pass actual date value
+     *
+     * @param axExpDateList
+     */
+    axExpDateList(axExpDateList) {
+        this.value = AxoUtils.convertUTCDateToDateFromat(axExpDateList.value);
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value?.length) {
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-range-value.mjs

@@ -0,0 +1,37 @@
+import { AxDateRange } from './ax-exp-date-range';
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpDateRangeValue extends AxExpressionValue {
+    constructor(axExpDateRangeValue) {
+        super(axExpDateRangeValue);
+        this.subType = ExpressionValueSubType.dateRange;
+        if (axExpDateRangeValue) {
+            this.axExpDateRangeValue(axExpDateRangeValue);
+        }
+        else {
+            this.newAxExpDateRangeValue();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxExpDateRangeValue() {
+        this.value = new AxDateRange();
+    }
+    /**
+     * Pass actual Text value
+     *
+     * @param axExpDateRangeValue
+     */
+    axExpDateRangeValue(axExpDateRangeValue) {
+        this.value = new AxDateRange(axExpDateRangeValue.value);
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value) {
+            return this.value?.searchable();
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-range.mjs

@@ -0,0 +1,34 @@
+export class AxDateRange {
+    constructor(axDateRange) {
+        if (axDateRange) {
+            this.axDateRange(axDateRange);
+        }
+        else {
+            this.newAxDateRange();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxDateRange() {
+        this.from = new Date();
+        this.to = new Date();
+    }
+    /**
+     * Pass actual date value
+     *
+     * @param axDateRange
+     */
+    axDateRange(axDateRange) {
+        this.from = axDateRange.from;
+        this.to = axDateRange.to;
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.from && this.to) {
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-time-list.mjs

@@ -0,0 +1,36 @@
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpDateTimeList extends AxExpressionValue {
+    constructor(axExpDateList) {
+        super(axExpDateList);
+        this.subType = ExpressionValueSubType.dateTimeList;
+        if (axExpDateList) {
+            this.axExpDateList(axExpDateList);
+        }
+        else {
+            this.newAxExpDateList();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxExpDateList() {
+        this.value = [];
+    }
+    /**
+     * Pass actual date value
+     *
+     * @param axExpDateList
+     */
+    axExpDateList(axExpDateList) {
+        this.value = axExpDateList.value;
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value?.length) {
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-time-range-value.mjs

@@ -0,0 +1,37 @@
+import { AxExpDateTimeRange } from './ax-exp-date-time-range';
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpDateTimeRangeValue extends AxExpressionValue {
+    constructor(axExpDateTimeRangeValue) {
+        super(axExpDateTimeRangeValue);
+        this.subType = ExpressionValueSubType.dateTimeRange;
+        if (axExpDateTimeRangeValue) {
+            this.axExpDateRangeValue(axExpDateTimeRangeValue);
+        }
+        else {
+            this.newAxExpDateRangeValue();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxExpDateRangeValue() {
+        this.value = new AxExpDateTimeRange();
+    }
+    /**
+     * Pass actual value
+     *
+     * @param axExpDateTimeRangeValue
+     */
+    axExpDateRangeValue(axExpDateTimeRangeValue) {
+        this.value = new AxExpDateTimeRange(axExpDateTimeRangeValue.value);
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value) {
+            return this.value.searchable();
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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