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

package/esm2020/lib/data-view-lib/data-view-lib.module.mjs

@@ -0,0 +1,88 @@
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DataViewHeaderComponent } from './data-view-header/data-view-header.component';
+import { DataViewFiltersComponent } from './data-view-filters/data-view-filters.component';
+import { MatIconModule } from '@angular/material/icon';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatListModule } from '@angular/material/list';
+import { AxoUtilsModule } from '../axo-utils/axo-utils.module';
+import { FiltersModule } from '../filters/filters.module';
+import { DataViewFiltersService } from './data-view-filters/data-view-filters.service';
+import { MatSelectModule } from '@angular/material/select';
+import { DataViewService } from './data-view.service';
+import { AxoFiltersModule } from '../axo-filters/axo-filters.module';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/tooltip";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/material/select";
+import * as i5 from "@angular/material/core";
+export class DataViewLibModule {
+}
+DataViewLibModule.ɵfac = function DataViewLibModule_Factory(t) { return new (t || DataViewLibModule)(); };
+DataViewLibModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: DataViewLibModule });
+DataViewLibModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+        DataViewFiltersService,
+        DataViewService
+    ], imports: [[
+            CommonModule,
+            MatIconModule,
+            MatMenuModule,
+            MatListModule,
+            AxoUtilsModule,
+            FiltersModule,
+            MatSelectModule,
+            AxoFiltersModule,
+            ReactiveFormsModule,
+            MatTooltipModule,
+            MatSlideToggleModule,
+            FormsModule
+        ]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DataViewLibModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [
+                    DataViewHeaderComponent,
+                    DataViewFiltersComponent
+                ],
+                imports: [
+                    CommonModule,
+                    MatIconModule,
+                    MatMenuModule,
+                    MatListModule,
+                    AxoUtilsModule,
+                    FiltersModule,
+                    MatSelectModule,
+                    AxoFiltersModule,
+                    ReactiveFormsModule,
+                    MatTooltipModule,
+                    MatSlideToggleModule,
+                    FormsModule
+                ],
+                providers: [
+                    DataViewFiltersService,
+                    DataViewService
+                ],
+                exports: [
+                    DataViewHeaderComponent
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DataViewLibModule, { declarations: [DataViewHeaderComponent,
+        DataViewFiltersComponent], imports: [CommonModule,
+        MatIconModule,
+        MatMenuModule,
+        MatListModule,
+        AxoUtilsModule,
+        FiltersModule,
+        MatSelectModule,
+        AxoFiltersModule,
+        ReactiveFormsModule,
+        MatTooltipModule,
+        MatSlideToggleModule,
+        FormsModule], exports: [DataViewHeaderComponent] }); })();
+i0.ɵɵsetComponentScope(DataViewHeaderComponent, [i1.NgClass, i1.NgIf, i2.MatTooltip, i3.MatIcon, i4.MatSelect, i1.NgForOf, i5.MatOption, DataViewFiltersComponent], []);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/data-view-lib/data-view.service.mjs

@@ -0,0 +1,211 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { EventEmitter, Injectable } from '@angular/core';
+import { JsonConvert } from 'json2typescript';
+import { BehaviorSubject } from 'rxjs';
+import { CommonLibConfigurationService } from '../common-lib-configuration.service';
+import { Utils } from '../enlighten-lib/utils/utils';
+import { AxForm } from '../forms/ax-form';
+import { DataView } from './data-view/data-view';
+import { DataViewType } from './data-view/data-view-enums';
+import { AxoUser } from '../core/user/axo-user';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../common-lib-configuration.service";
+export class DataViewService {
+    constructor(_httpClient, commonLibConfig) {
+        this._httpClient = _httpClient;
+        this.commonLibConfig = commonLibConfig;
+        this.applyFilterEmit = new EventEmitter();
+        this.resetFilterEmit = new EventEmitter();
+        this._dataViews = new BehaviorSubject(null);
+        this._form = new BehaviorSubject(null);
+        this.users = new BehaviorSubject(null);
+        this.usersMap = new BehaviorSubject(null);
+    }
+    /**
+     * Getter for data view.
+     */
+    get dataView$() {
+        return this._dataViews.asObservable();
+    }
+    /**
+     * Getter for form details
+     */
+    get formDetails$() {
+        return this._form.asObservable();
+    }
+    /*
+    * Getter for form appUserList
+    */
+    get appUserList$() {
+        return this.users.asObservable();
+    }
+    /*
+   * Getter for form details
+   */
+    get getUserMap$() {
+        return this.usersMap.asObservable();
+    }
+    /**
+     * function to emit emitter for apply filter.
+     */
+    applyDataListFilter() {
+        this.applyFilterEmit.emit();
+    }
+    /**
+     * function to emit emitter for reset filter.
+     */
+    resetDataListFilter() {
+        this.resetFilterEmit.emit();
+    }
+    /**
+     * Get Data view
+     *
+     * @param dataViewId
+     * @returns
+     */
+    getDataView(dataViewId) {
+        return new Promise((resolve, reject) => {
+            this._httpClient.get('dataviews/' + dataViewId).subscribe((response) => {
+                const dataView = new DataView(response);
+                if (dataView.taskViews.length > 0) {
+                    dataView.type = dataView.form ? DataViewType.dedicatedTaskView : DataViewType.genericTaskView;
+                }
+                else {
+                    dataView.type = DataViewType.formDataView;
+                }
+                resolve(dataView);
+            }, reject);
+        });
+    }
+    /**
+     * Get Form and Data view
+     *
+     * @param dataViewId
+     * @returns
+     */
+    getFormAndDataView(dataViewId) {
+        return new Promise(async (resolve, reject) => {
+            const dataView = await this.getDataView(dataViewId);
+            if (dataView.type !== DataViewType.genericTaskView) {
+                const form = await this.getFormDetails(dataView.form.id);
+                this._form.next(form);
+            }
+            this._dataViews.next(dataView);
+            resolve(true);
+        });
+    }
+    /**
+     * Update Data View API
+     *
+     * @param dataView
+     * @returns
+     */
+    saveDataView(dataView) {
+        return new Promise((resolve, reject) => {
+            this._httpClient.put('dataviews', dataView).subscribe((response) => {
+                const _dataView = new DataView(response);
+                resolve(_dataView);
+            }, reject);
+        });
+    }
+    /**
+     * Get  form-details from x1
+     */
+    getFormDetails(fid) {
+        const jsonConvert = new JsonConvert();
+        const formData = new FormData();
+        const form = { 'fid': fid };
+        formData.append('form', JSON.stringify(form));
+        return new Promise((resolve, reject) => {
+            this._httpClient.post(this.commonLibConfig.axonatorX1Url + 'getFormDetails/', formData).subscribe((response) => {
+                let _form;
+                if (response?.fd?.form) {
+                    _form = jsonConvert.deserializeObject(response?.fd?.form, AxForm);
+                }
+                this._widgetMap = Utils.createWidgetMap(_form.widgets);
+                resolve(_form);
+            }, reject);
+        });
+    }
+    /**
+     * Create Board Cache
+     *
+     * @returns
+     */
+    createBoardViewCache(boardViewId) {
+        return new Promise((resolve, reject) => {
+            this._httpClient.post('boardview/createcache', { boardViewId: boardViewId }).subscribe((response) => {
+                resolve(response);
+            }, reject);
+        });
+    }
+    /**
+     * Create Map Cache
+     *
+     * @returns
+     */
+    createMapViewCache(mapViewId) {
+        return new Promise((resolve, reject) => {
+            this._httpClient.post('mapview/createcache', { mapViewId: mapViewId }).subscribe((response) => {
+                resolve(response);
+            }, reject);
+        });
+    }
+    /**
+     * Get  data-list data
+     */
+    getDataList(dataListId) {
+        let params = new HttpParams();
+        params = params.append('id', dataListId);
+        return new Promise((resolve, reject) => {
+            this._httpClient.get('datalist', { params: params })
+                .subscribe((response) => {
+                resolve(response);
+            }, reject);
+        });
+    }
+    /**
+     * Get App Users.
+     *
+     * @param appVersionId
+     * @param currentPage
+     * @param pageSize
+     * @returns
+     */
+    getAppUsers(appVersionId, currentPage = 1, pageSize = 500) {
+        return new Promise((resolve, reject) => {
+            const data = {
+                appVersionId: appVersionId,
+                currentPage: currentPage,
+                pagesize: pageSize
+            };
+            const formData = new FormData();
+            formData.append('app', JSON.stringify(data));
+            this._httpClient.post(this.commonLibConfig.axonatorX1Url + 'getAppUsers/', formData).subscribe((response) => {
+                console.log(response);
+                const jsonConvert = new JsonConvert();
+                const users = jsonConvert.deserializeArray(response['appuser'].AppUser.appusers, AxoUser);
+                this.usersMap.next(this.cerateUsersMap(users));
+                this.users.next(users);
+                resolve(users);
+            }, reject);
+        });
+    }
+    /**
+     * Create User Map.
+     */
+    cerateUsersMap(users) {
+        const userMap = new Map();
+        users.forEach((user) => {
+            userMap.set(user.userId, user);
+        });
+        return userMap;
+    }
+}
+DataViewService.ɵfac = function DataViewService_Factory(t) { return new (t || DataViewService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.CommonLibConfigurationService)); };
+DataViewService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DataViewService, factory: DataViewService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DataViewService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.CommonLibConfigurationService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-view.service.js","sourceRoot":"","sources":["../../../../../src/ax-common-ui-lib/src/lib/data-view-lib/data-view.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { TaskView } from './data-view/task-view';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { EventEmitter, Injectable, Output } from '@angular/core';\nimport { JsonConvert } from 'json2typescript';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { CommonLibConfigurationService } from '../common-lib-configuration.service';\nimport { Utils } from '../enlighten-lib/utils/utils';\nimport { AxForm } from '../forms/ax-form';\nimport { Widget } from '../forms/page/widgets/widget';\nimport { DataView } from './data-view/data-view';\nimport { DataViewType } from './data-view/data-view-enums';\nimport { AxoUser } from '../core/user/axo-user';\n\n@Injectable()\nexport class DataViewService {\n\n  public applyFilterEmit = new EventEmitter<any>();\n  public resetFilterEmit = new EventEmitter<any>();\n\n  private _dataViews: BehaviorSubject<DataView | null> = new BehaviorSubject(null);\n  private _form: BehaviorSubject<AxForm | null> = new BehaviorSubject(null);\n  private users: BehaviorSubject<Array<AxoUser> | null> = new BehaviorSubject(null);\n  private usersMap: BehaviorSubject<Map<number,AxoUser> | null> = new BehaviorSubject(null);\n\n  private _widgetMap: Map<string,Widget>;\n  constructor(\n    private _httpClient: HttpClient,\n    private commonLibConfig: CommonLibConfigurationService\n  ) { }\n\n  /**\n   * Getter for data view.\n   */\n  get dataView$(): Observable<DataView> {\n    return this._dataViews.asObservable();\n  }\n\n  /**\n   * Getter for form details\n   */\n  get formDetails$(): Observable<AxForm> {\n    return this._form.asObservable();\n  }\n\n\n  /*\n  * Getter for form appUserList\n  */\n  get appUserList$(): Observable<Array<AxoUser>> {\n    return this.users.asObservable();\n   }\n   /*\n  * Getter for form details\n  */\n  get getUserMap$(): Observable<Map<number,AxoUser>> {\n    return this.usersMap.asObservable();\n   }\n\n  /**\n   * function to emit emitter for apply filter.\n   */\n  applyDataListFilter(): void {\n    this.applyFilterEmit.emit();\n  }\n\n  /**\n   * function to emit emitter for reset filter.\n   */\n  resetDataListFilter(): void {\n    this.resetFilterEmit.emit();\n  }\n\n  /**\n   * Get Data view\n   *\n   * @param dataViewId\n   * @returns\n   */\n  getDataView(dataViewId: number): Promise<DataView> {\n    return new Promise((resolve, reject) => {\n      this._httpClient.get<DataView>('dataviews/' + dataViewId).subscribe((response) => {\n        const dataView = new DataView(response);\n        if(dataView.taskViews.length > 0){\n            dataView.type = dataView.form?DataViewType.dedicatedTaskView:DataViewType.genericTaskView;\n        }else{\n            dataView.type = DataViewType.formDataView;\n        }\n        resolve(dataView);\n      }, reject);\n    });\n\n  }\n  /**\n   * Get Form and Data view\n   *\n   * @param dataViewId\n   * @returns\n   */\n  getFormAndDataView(dataViewId: number): Promise<any> {\n    return new Promise(async (resolve, reject) => {\n      const dataView = await this.getDataView(dataViewId);\n      if(dataView.type !== DataViewType.genericTaskView){\n        const form = await this.getFormDetails(dataView.form.id);\n        this._form.next(form);\n      }\n      this._dataViews.next(dataView);\n      resolve(true);\n    });\n  }\n\n  /**\n   * Update Data View API\n   *\n   * @param dataView\n   * @returns\n   */\n  saveDataView(dataView: DataView): Promise<any> {\n    return new Promise((resolve, reject) => {\n      this._httpClient.put('dataviews', dataView).subscribe((response: DataView) => {\n        const _dataView = new DataView(response);\n        resolve(_dataView);\n      }, reject);\n    });\n  }\n\n  /**\n   * Get  form-details from x1\n   */\n\n  getFormDetails(fid: string | number): Promise<AxForm> {\n    const jsonConvert: JsonConvert = new JsonConvert();\n    const formData = new FormData();\n    const form = { 'fid': fid };\n    formData.append('form', JSON.stringify(form));\n    return new Promise((resolve, reject) => {\n      this._httpClient.post(this.commonLibConfig.axonatorX1Url + 'getFormDetails/', formData).subscribe((response: any) => {\n        let _form;\n        if (response?.fd?.form) {\n          _form = jsonConvert.deserializeObject(response?.fd?.form, AxForm);\n        }\n        this._widgetMap = Utils.createWidgetMap(_form.widgets);\n        resolve(_form);\n      }, reject);\n    });\n  }\n  /**\n   * Create Board Cache\n   *\n   * @returns\n   */\n  createBoardViewCache(boardViewId: number): Promise<boolean>{\n    return new Promise((resolve,reject)=>{\n        this._httpClient.post<boolean>('boardview/createcache',{boardViewId:boardViewId}).subscribe((response)=>{\n            resolve(response);\n        },reject);\n    });\n  }\n  /**\n   * Create Map Cache\n   *\n   * @returns\n   */\n   createMapViewCache(mapViewId): Promise<boolean>{\n    return new Promise((resolve,reject)=>{\n        this._httpClient.post<boolean>('mapview/createcache',{mapViewId:mapViewId}).subscribe((response)=>{\n            resolve(response);\n        },reject);\n    });\n  }\n\n   /**\n    * Get  data-list data\n    */\n    getDataList(dataListId: number): Promise<any> {\n        let params = new HttpParams();\n        params = params.append('id', dataListId);\n        return new Promise((resolve, reject) => {\n          this._httpClient.get<TaskView>('datalist', { params: params })\n            .subscribe((response) => {\n              resolve(response);\n            }, reject);\n        });\n    }\n  /**\n   * Get App Users.\n   *\n   * @param appVersionId\n   * @param currentPage\n   * @param pageSize\n   * @returns\n   */\n  getAppUsers(appVersionId: number,currentPage: number=1,pageSize: number=500): Promise<Array<any>>{\n    return new Promise((resolve,reject)=>{\n        const data = {\n            appVersionId:appVersionId,\n            currentPage:currentPage,\n            pagesize:pageSize\n        };\n        const formData = new FormData();\n        formData.append('app', JSON.stringify(data));\n        this._httpClient.post(this.commonLibConfig.axonatorX1Url+'getAppUsers/',formData).subscribe((response)=>{\n                console.log(response);\n                const jsonConvert: JsonConvert = new JsonConvert();\n                const users = jsonConvert.deserializeArray(response['appuser'].AppUser.appusers, AxoUser);\n                this.usersMap.next(this.cerateUsersMap(users));\n                this.users.next(users);\n                resolve(users);\n        },reject);\n    });\n  }\n\n  /**\n   * Create User Map.\n   */\n  cerateUsersMap(users: Array<AxoUser>):  Map<number,AxoUser>{\n    const userMap: Map<number,AxoUser> = new Map<number,AxoUser>();\n    users.forEach((user)=>{\n        userMap.set(user.userId,user);\n    });\n    return userMap;\n  }\n}\n"]}

package/esm2020/lib/data-view-lib/public-api.mjs

@@ -0,0 +1,28 @@
+/**
+ * We will export all dataview modules and classes from here.
+ */
+export * from './data-view/data-view';
+export * from './data-view/data-view-enums';
+export * from './data-view/axo-card';
+export * from './data-view/axo-tag';
+export * from './data-view/board-column';
+export * from './data-view/board-view';
+export * from './data-view/cardConfig';
+export * from './data-view/conditional-formatting';
+export * from './data-view/coordinate';
+export * from './data-view/idata-view';
+export * from './data-view/info-window';
+export * from './data-view/location';
+export * from './data-view/map-view';
+export * from './data-view/tag-style';
+export * from './data-view/tagConfig';
+export * from './data-view-lib.module';
+export * from './data-view-header/data-view-header.component';
+export * from './data-view/tag-style';
+export * from './data-view/data-view-filter';
+export * from './data-view.service';
+export * from './data-view/task-view';
+export * from './data-view/task';
+export * from './data-view/task-asset-form-object-dto';
+export * from './data-view/task-column-value';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directive/adjust-font-size.mjs

@@ -0,0 +1,49 @@
+import { Directive, ElementRef, Input } from '@angular/core';
+import { ScreenType } from '../enlighten-lib/filters/condition-type';
+import * as i0 from "@angular/core";
+export class AdjustFontSize {
+    constructor(element) {
+        this.element = element;
+    }
+    adjustFontSize() {
+        let fitted = false;
+        while (!fitted) {
+            if (this.isOverflow()) {
+                const style = window.getComputedStyle(this.element.nativeElement, null).getPropertyValue('font-size');
+                const fontSize = parseFloat(style);
+                this.element.nativeElement.style.fontSize = (fontSize - 1) + 'px';
+                fitted = true;
+            }
+            else {
+                const style = window.getComputedStyle(this.element.nativeElement, null).getPropertyValue('font-size');
+                const fontSize = parseFloat(style);
+                this.element.nativeElement.style.fontSize = (fontSize + 1) + 'px';
+                if (!this.isOverflow()) {
+                    fitted = true;
+                }
+            }
+        }
+    }
+    ngOnInit() {
+        if (this.screenType === ScreenType.containerDashboard || this.screenType === ScreenType.dashboardBuilder)
+            setInterval(() => this.adjustFontSize(), 10);
+    }
+    isOverflow() {
+        if ((this.element.nativeElement.clientWidth < this.element.nativeElement.scrollWidth) ||
+            (this.element.nativeElement.clientHeight < this.element.nativeElement.scrollHeight)) {
+            return true;
+        }
+        return false;
+    }
+}
+AdjustFontSize.ɵfac = function AdjustFontSize_Factory(t) { return new (t || AdjustFontSize)(i0.ɵɵdirectiveInject(i0.ElementRef)); };
+AdjustFontSize.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: AdjustFontSize, selectors: [["", "adjustFontSize", ""]], inputs: { screenType: "screenType" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AdjustFontSize, [{
+        type: Directive,
+        args: [{
+                selector: '[adjustFontSize]'
+            }]
+    }], function () { return [{ type: i0.ElementRef }]; }, { screenType: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,153 @@
+/**** Import should have relative path in common lib ****/
+import { Component, HostListener, Input, ViewEncapsulation } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { ScreenType } from '../enlighten-lib/filters/condition-type';
+import { DrillThroughService } from './drill-through.service';
+import { EnlightenReportType } from '../enlighten-lib/report/ireport';
+import * as i0 from "@angular/core";
+import * as i1 from "./drill-through.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/common";
+import * as i4 from "../enlighten-lib/report/graphical-report/graphical-report.component";
+import * as i5 from "../enlighten-lib/report/tabular-report/tabular-report.component";
+function DrillThroughComponent_graphical_report_2_Template(rf, ctx) { if (rf & 1) {
+    const _r3 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "graphical-report", 4);
+    i0.ɵɵlistener("nextPageClicked", function DrillThroughComponent_graphical_report_2_Template_graphical_report_nextPageClicked_0_listener() { i0.ɵɵrestoreView(_r3); const ctx_r2 = i0.ɵɵnextContext(); return ctx_r2.nextPage(); })("previousPageClicked", function DrillThroughComponent_graphical_report_2_Template_graphical_report_previousPageClicked_0_listener() { i0.ɵɵrestoreView(_r3); const ctx_r4 = i0.ɵɵnextContext(); return ctx_r4.previousPage(); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("page", ctx_r0.page)("drillThroughFilterInput", ctx_r0.filter)("screenType", ctx_r0.screenTypes.drillThrough)("drillThroughParentType", ctx_r0.drillThroughParentType)("hasNextPage", ctx_r0.hasNextPage)("appVersionId", ctx_r0.appVersionId);
+} }
+function DrillThroughComponent_tabular_report_3_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "tabular-report", 5);
+    i0.ɵɵlistener("nextPageClicked", function DrillThroughComponent_tabular_report_3_Template_tabular_report_nextPageClicked_0_listener() { i0.ɵɵrestoreView(_r6); const ctx_r5 = i0.ɵɵnextContext(); return ctx_r5.nextPage(); })("previousPageClicked", function DrillThroughComponent_tabular_report_3_Template_tabular_report_previousPageClicked_0_listener() { i0.ɵɵrestoreView(_r6); const ctx_r7 = i0.ɵɵnextContext(); return ctx_r7.previousPage(); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("page", ctx_r1.page)("drillThroughFilterInput", ctx_r1.filter)("screenType", ctx_r1.screenTypes.drillThrough)("drillThroughParentType", ctx_r1.drillThroughParentType)("hasNextPage", ctx_r1.hasNextPage)("appVersionId", ctx_r1.appVersionId);
+} }
+const _c0 = function (a0, a1) { return { "graphical-drill-parent": a0, "h-full": a1 }; };
+export class DrillThroughComponent {
+    /**
+     * Constructor
+     * Inject all required services here.
+     */
+    constructor(_drillThroughService, _router) {
+        this._drillThroughService = _drillThroughService;
+        this._router = _router;
+        /*
+        * Subject object which helps unsubscribe all the subscribed objects in the component
+        */
+        this._unsubscribeAll = new Subject();
+    }
+    get screenTypes() {
+        return ScreenType;
+    }
+    get enlightenReportTypes() {
+        return EnlightenReportType;
+    }
+    beforeUnload(event) {
+        this._drillThroughService.saveStates();
+    }
+    /**
+     * OnInit life cycle hook ..
+     */
+    ngOnInit() {
+        this.setDrillThrough();
+        this.subscribers();
+    }
+    ngOnDestroy() {
+        this._drillThroughService.destroy();
+    }
+    /**
+     * Subscribers should be written here.
+     */
+    subscribers() {
+        this._drillThroughService.onPageChanged
+            .pipe(takeUntil(this._unsubscribeAll))
+            .subscribe((event) => {
+            if (event) {
+                this.setDrillThrough();
+            }
+        });
+        this._router.events
+            .pipe(filter((rs) => rs instanceof NavigationEnd))
+            .subscribe((event) => {
+            if (event.id === 1 && event.url === event.urlAfterRedirects) {
+                this._drillThroughService.restoreStates();
+            }
+        });
+    }
+    /**
+     * Set drill through initial data
+     */
+    setDrillThrough() {
+        const drillPageState = this._drillThroughService.GetCurrentDrillThroughState();
+        if (this.enlightenReportTypes[drillPageState.page.elements[0].type] === this.enlightenReportTypes.tabular) {
+            this.reportType = this.enlightenReportTypes[drillPageState.page.elements[0].type];
+        }
+        else {
+            this.reportType = this.enlightenReportTypes.graphical;
+        }
+        this.page = drillPageState.page;
+        this.filter = drillPageState.filter;
+        this._drillThroughService.setBreadCrumbs();
+        this.hasNextPage = this._drillThroughService.hasNextPage();
+    }
+    /**
+     * called on click of next arrow on drill through page
+     */
+    nextPage() {
+        const drillPageState = this._drillThroughService.PageNext();
+        if (drillPageState) {
+            this._router.navigate([this._drillThroughService.getParentData().url + '/drill-through/' + drillPageState.page.id]);
+        }
+    }
+    /**
+     * called on click of next arrow on drill through page
+     */
+    previousPage() {
+        const drillPageState = this._drillThroughService.PageBack();
+        if (drillPageState) {
+            this._router.navigate([this._drillThroughService.getParentData().url + '/drill-through/' + drillPageState.page.id]);
+        }
+        else {
+            this._router.navigate([this._drillThroughService.getParentData().url]);
+        }
+    }
+}
+DrillThroughComponent.ɵfac = function DrillThroughComponent_Factory(t) { return new (t || DrillThroughComponent)(i0.ɵɵdirectiveInject(i1.DrillThroughService), i0.ɵɵdirectiveInject(i2.Router)); };
+DrillThroughComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: DrillThroughComponent, selectors: [["drill-through"]], hostBindings: function DrillThroughComponent_HostBindings(rf, ctx) { if (rf & 1) {
+        i0.ɵɵlistener("beforeunload", function DrillThroughComponent_beforeunload_HostBindingHandler($event) { return ctx.beforeUnload($event); }, false, i0.ɵɵresolveWindow);
+    } }, inputs: { drillThroughParentType: "drillThroughParentType", appVersionId: "appVersionId" }, decls: 4, vars: 7, consts: [[3, "ngClass"], [3, "ngSwitch"], ["class", "report-page graphical-report-page customscroll", 3, "page", "drillThroughFilterInput", "screenType", "drillThroughParentType", "hasNextPage", "appVersionId", "nextPageClicked", "previousPageClicked", 4, "ngSwitchCase"], ["class", "report-page tabular-report-page h-full", 3, "page", "drillThroughFilterInput", "screenType", "drillThroughParentType", "hasNextPage", "appVersionId", "nextPageClicked", "previousPageClicked", 4, "ngSwitchCase"], [1, "report-page", "graphical-report-page", "customscroll", 3, "page", "drillThroughFilterInput", "screenType", "drillThroughParentType", "hasNextPage", "appVersionId", "nextPageClicked", "previousPageClicked"], [1, "report-page", "tabular-report-page", "h-full", 3, "page", "drillThroughFilterInput", "screenType", "drillThroughParentType", "hasNextPage", "appVersionId", "nextPageClicked", "previousPageClicked"]], template: function DrillThroughComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵelementContainerStart(1, 1);
+        i0.ɵɵtemplate(2, DrillThroughComponent_graphical_report_2_Template, 1, 6, "graphical-report", 2);
+        i0.ɵɵtemplate(3, DrillThroughComponent_tabular_report_3_Template, 1, 6, "tabular-report", 3);
+        i0.ɵɵelementContainerEnd();
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction2(4, _c0, ctx.reportType === ctx.enlightenReportTypes.graphical, ctx.reportType === ctx.enlightenReportTypes.tabular));
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngSwitch", ctx.reportType);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngSwitchCase", ctx.enlightenReportTypes.graphical);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngSwitchCase", ctx.enlightenReportTypes.tabular);
+    } }, directives: [i3.NgClass, i3.NgSwitch, i3.NgSwitchCase, i4.GraphicalReportComponent, i5.TabularReportComponent], styles: ["drill-through .graphical-drill-parent{width:100%;display:flex;justify-content:center;max-height:calc(100vh - 92px)}drill-through #central-page{padding:1rem;min-height:100%;border:none!important;box-shadow:none!important;height:100%;max-height:100%}drill-through #central-page .back-btn{min-width:1.5rem!important;max-width:1.5rem!important;cursor:pointer}drill-through #central-page .next-btn{min-width:1.5rem!important;max-width:1.5rem!important;cursor:pointer;transform:rotate(180deg);float:right}drill-through graphical-report{width:100%}drill-through tabular-report{min-height:100%!important;height:100%!important;max-height:100%!important;box-shadow:none!important}drill-through tabular-report .tableContainer{max-width:100%;min-width:100%;height:calc(100% - .5rem)!important;max-height:calc(100% - .5rem)!important;min-height:calc(100% - .5rem)!important}drill-through tabular-report .tableContainer table{width:auto!important}drill-through .tabular-report{min-height:400px!important;height:100%!important;max-height:calc(100% - 2rem)!important;min-width:400px!important;width:100%!important;max-width:100%;border:1px solid #80808033!important}drill-through h1:has(+ p){margin-bottom:0}drill-through .tabular-report:has(.loader-spinner){width:100%!important}\n"], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrillThroughComponent, [{
+        type: Component,
+        args: [{ selector: 'drill-through', encapsulation: ViewEncapsulation.None, template: "<div [ngClass]=\"{'graphical-drill-parent': reportType === enlightenReportTypes.graphical, 'h-full': reportType === enlightenReportTypes.tabular}\">\n    <ng-container [ngSwitch]=\"reportType\">\n        <graphical-report\n            *ngSwitchCase=\"enlightenReportTypes.graphical\"\n            class=\"report-page graphical-report-page customscroll\"\n            [page]=\"page\"\n            [drillThroughFilterInput]=\"filter\"\n            [screenType]=\"screenTypes.drillThrough\"\n            (nextPageClicked)=\"nextPage()\"\n            (previousPageClicked)=\"previousPage()\"\n            [drillThroughParentType]=\"drillThroughParentType\"\n            [hasNextPage]=\"hasNextPage\"\n            [appVersionId]=\"appVersionId\">\n        </graphical-report>\n        <tabular-report\n            *ngSwitchCase=\"enlightenReportTypes.tabular\"\n            class=\"report-page tabular-report-page h-full\"\n            [page]=\"page\"\n            [drillThroughFilterInput]=\"filter\"\n            [screenType]=\"screenTypes.drillThrough\"\n            (nextPageClicked)=\"nextPage()\"\n            (previousPageClicked)=\"previousPage()\"\n            [drillThroughParentType]=\"drillThroughParentType\"\n            [hasNextPage]=\"hasNextPage\"\n            [appVersionId]=\"appVersionId\">\n        </tabular-report>\n    </ng-container>\n</div>\n\t\n", styles: ["drill-through .graphical-drill-parent{width:100%;display:flex;justify-content:center;max-height:calc(100vh - 92px)}drill-through #central-page{padding:1rem;min-height:100%;border:none!important;box-shadow:none!important;height:100%;max-height:100%}drill-through #central-page .back-btn{min-width:1.5rem!important;max-width:1.5rem!important;cursor:pointer}drill-through #central-page .next-btn{min-width:1.5rem!important;max-width:1.5rem!important;cursor:pointer;transform:rotate(180deg);float:right}drill-through graphical-report{width:100%}drill-through tabular-report{min-height:100%!important;height:100%!important;max-height:100%!important;box-shadow:none!important}drill-through tabular-report .tableContainer{max-width:100%;min-width:100%;height:calc(100% - .5rem)!important;max-height:calc(100% - .5rem)!important;min-height:calc(100% - .5rem)!important}drill-through tabular-report .tableContainer table{width:auto!important}drill-through .tabular-report{min-height:400px!important;height:100%!important;max-height:calc(100% - 2rem)!important;min-width:400px!important;width:100%!important;max-width:100%;border:1px solid #80808033!important}drill-through h1:has(+ p){margin-bottom:0}drill-through .tabular-report:has(.loader-spinner){width:100%!important}\n"] }]
+    }], function () { return [{ type: i1.DrillThroughService }, { type: i2.Router }]; }, { drillThroughParentType: [{
+            type: Input
+        }], appVersionId: [{
+            type: Input
+        }], beforeUnload: [{
+            type: HostListener,
+            args: ['window:beforeunload', ['$event']]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drill-through.component.js","sourceRoot":"","sources":["../../../../../src/ax-common-ui-lib/src/lib/drill-through/drill-through.component.ts","../../../../../src/ax-common-ui-lib/src/lib/drill-through/drill-through.component.html"],"names":[],"mappings":"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","sourcesContent":["/**** Import should have relative path in common lib ****/\nimport { Component, HostListener, Input, OnDestroy, OnInit, ViewEncapsulation } from '@angular/core';\nimport { NavigationEnd, Router } from '@angular/router';\nimport { Subject } from 'rxjs';\nimport { filter, takeUntil } from 'rxjs/operators';\nimport { AxFilter } from '../enlighten-lib/filters/ax-filter';\nimport { ScreenType } from '../enlighten-lib/filters/condition-type';\nimport { TabularReport } from '../enlighten-lib/report/tabular-report/tabular-report';\nimport { DrillPageState, DrillThroughService } from './drill-through.service';\nimport { EnlightenReportType } from '../enlighten-lib/report/ireport';\n\n@Component({\n  selector: 'drill-through',\n  templateUrl: './drill-through.component.html',\n  styleUrls: ['./drill-through.component.scss'],\n  encapsulation: ViewEncapsulation.None\n\n})\nexport class DrillThroughComponent implements OnInit, OnDestroy {\n  @Input() drillThroughParentType: ScreenType;\n  @Input() appVersionId: number;\n  page: any;\n  tabularReport: TabularReport;\n  reportId: number;\n  filter: AxFilter;\n  reportType: EnlightenReportType;\n  hasNextPage: boolean;\n  /*\n  * Subject object which helps unsubscribe all the subscribed objects in the component\n  */\n  private _unsubscribeAll: Subject<any> = new Subject<any>();\n\n  /**\n   * Constructor\n   * Inject all required services here.\n   */\n  constructor(\n    private _drillThroughService: DrillThroughService,\n    private _router: Router\n    ) { }\n\n  public get screenTypes(): typeof ScreenType {\n    return ScreenType;\n  }\n\n  public get enlightenReportTypes(): typeof EnlightenReportType {\n    return EnlightenReportType;\n  }\n\n  @HostListener('window:beforeunload',['$event'])\n  beforeUnload(event: BeforeUnloadEvent): void {\n    this._drillThroughService.saveStates();\n  }\n\n  /**\n   * OnInit life cycle hook ..\n   */\n  ngOnInit(): void {\n    this.setDrillThrough();\n    this.subscribers();\n\n  }\n\n  ngOnDestroy(): void{\n    this._drillThroughService.destroy();\n  }\n\n  /**\n   * Subscribers should be written here.\n   */\n  subscribers(): void{\n    this._drillThroughService.onPageChanged\n      .pipe(takeUntil(this._unsubscribeAll))\n      .subscribe((event) => {\n        if(event)\n          {\n            this.setDrillThrough();\n          }\n      });\n    this._router.events\n      .pipe(filter((rs): rs is NavigationEnd => rs instanceof NavigationEnd))\n      .subscribe((event: NavigationEnd) => {\n        if(event.id === 1 && event.url === event.urlAfterRedirects){\n          this._drillThroughService.restoreStates();\n        }\n      });\n  }\n\n  /**\n   * Set drill through initial data\n   */\n  setDrillThrough(): void{\n    const drillPageState: DrillPageState = this._drillThroughService.GetCurrentDrillThroughState();\n    if(this.enlightenReportTypes[drillPageState.page.elements[0].type] === this.enlightenReportTypes.tabular){\n      this.reportType = this.enlightenReportTypes[drillPageState.page.elements[0].type];\n    } else {\n      this.reportType = this.enlightenReportTypes.graphical;\n    }\n    this.page = drillPageState.page;\n    this.filter = drillPageState.filter;\n    this._drillThroughService.setBreadCrumbs();\n    this.hasNextPage = this._drillThroughService.hasNextPage();\n  }\n\n  /**\n   * called on click of next arrow on drill through page\n   */\n  nextPage(): void{\n    const drillPageState: DrillPageState = this._drillThroughService.PageNext();\n    if(drillPageState)\n      {this._router.navigate([this._drillThroughService.getParentData().url +'/drill-through/' + drillPageState.page.id]);}\n  }\n\n  /**\n   * called on click of next arrow on drill through page\n   */\n  previousPage(): void {\n    const drillPageState: DrillPageState = this._drillThroughService.PageBack();\n    if(drillPageState)\n      {this._router.navigate([this._drillThroughService.getParentData().url +'/drill-through/' + drillPageState.page.id]);}\n    else\n      {this._router.navigate([this._drillThroughService.getParentData().url]);}\n  }\n\n}\n","<div [ngClass]=\"{'graphical-drill-parent': reportType === enlightenReportTypes.graphical, 'h-full': reportType === enlightenReportTypes.tabular}\">\n    <ng-container [ngSwitch]=\"reportType\">\n        <graphical-report\n            *ngSwitchCase=\"enlightenReportTypes.graphical\"\n            class=\"report-page graphical-report-page customscroll\"\n            [page]=\"page\"\n            [drillThroughFilterInput]=\"filter\"\n            [screenType]=\"screenTypes.drillThrough\"\n            (nextPageClicked)=\"nextPage()\"\n            (previousPageClicked)=\"previousPage()\"\n            [drillThroughParentType]=\"drillThroughParentType\"\n            [hasNextPage]=\"hasNextPage\"\n            [appVersionId]=\"appVersionId\">\n        </graphical-report>\n        <tabular-report\n            *ngSwitchCase=\"enlightenReportTypes.tabular\"\n            class=\"report-page tabular-report-page h-full\"\n            [page]=\"page\"\n            [drillThroughFilterInput]=\"filter\"\n            [screenType]=\"screenTypes.drillThrough\"\n            (nextPageClicked)=\"nextPage()\"\n            (previousPageClicked)=\"previousPage()\"\n            [drillThroughParentType]=\"drillThroughParentType\"\n            [hasNextPage]=\"hasNextPage\"\n            [appVersionId]=\"appVersionId\">\n        </tabular-report>\n    </ng-container>\n</div>\n\t\n"]}