ax-common-ui-lib 1.0.0-qa.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS12aWV3LWxpYi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXgtYXBwLWNvbW1vbi1saWIvc3JjL2xpYi9kYXRhLXZpZXctbGliL2RhdGEtdmlldy1saWIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLCtDQUErQyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBQzNGLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUMvRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDMUQsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sK0NBQStDLENBQUM7QUFDdkYsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzNELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNyRSxPQUFPLEVBQUUsV0FBVyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDbEUsT0FBTyxFQUFDLGdCQUFnQixFQUFDLE1BQU0sMkJBQTJCLENBQUM7Ozs7Ozs7QUFpQzNELE1BQU0sT0FBTyxpQkFBaUI7O2tGQUFqQixpQkFBaUI7bUVBQWpCLGlCQUFpQjt3RUFUbEI7UUFDUixzQkFBc0I7UUFDdEIsZUFBZTtLQUNoQixZQWxCUTtZQUNQLFlBQVk7WUFDWixhQUFhO1lBQ2IsYUFBYTtZQUNiLGFBQWE7WUFDYixjQUFjO1lBQ2QsYUFBYTtZQUNiLGVBQWU7WUFDZixnQkFBZ0I7WUFDaEIsbUJBQW1CO1lBQ25CLGdCQUFnQjtZQUNoQixvQkFBb0I7WUFDcEIsV0FBVztTQUVaO3VGQVVVLGlCQUFpQjtjQTdCN0IsUUFBUTtlQUFDO2dCQUNSLFlBQVksRUFBRTtvQkFDWix1QkFBdUI7b0JBQ3ZCLHdCQUF3QjtpQkFDekI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLFlBQVk7b0JBQ1osYUFBYTtvQkFDYixhQUFhO29CQUNiLGFBQWE7b0JBQ2IsY0FBYztvQkFDZCxhQUFhO29CQUNiLGVBQWU7b0JBQ2YsZ0JBQWdCO29CQUNoQixtQkFBbUI7b0JBQ25CLGdCQUFnQjtvQkFDaEIsb0JBQW9CO29CQUNwQixXQUFXO2lCQUVaO2dCQUNELFNBQVMsRUFBQztvQkFDUixzQkFBc0I7b0JBQ3RCLGVBQWU7aUJBQ2hCO2dCQUVELE9BQU8sRUFBQztvQkFDTix1QkFBdUI7aUJBQ3hCO2FBQ0Y7O3dGQUNZLGlCQUFpQixtQkEzQjFCLHVCQUF1QjtRQUN2Qix3QkFBd0IsYUFHeEIsWUFBWTtRQUNaLGFBQWE7UUFDYixhQUFhO1FBQ2IsYUFBYTtRQUNiLGNBQWM7UUFDZCxhQUFhO1FBQ2IsZUFBZTtRQUNmLGdCQUFnQjtRQUNoQixtQkFBbUI7UUFDbkIsZ0JBQWdCO1FBQ2hCLG9CQUFvQjtRQUNwQixXQUFXLGFBU1gsdUJBQXVCO3VCQXhCdkIsdUJBQXVCLDJGQUN2Qix3QkFBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNYXRTbGlkZVRvZ2dsZU1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL3NsaWRlLXRvZ2dsZSc7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IERhdGFWaWV3SGVhZGVyQ29tcG9uZW50IH0gZnJvbSAnLi9kYXRhLXZpZXctaGVhZGVyL2RhdGEtdmlldy1oZWFkZXIuY29tcG9uZW50JztcbmltcG9ydCB7IERhdGFWaWV3RmlsdGVyc0NvbXBvbmVudCB9IGZyb20gJy4vZGF0YS12aWV3LWZpbHRlcnMvZGF0YS12aWV3LWZpbHRlcnMuY29tcG9uZW50JztcbmltcG9ydCB7IE1hdEljb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9pY29uJztcbmltcG9ydCB7IE1hdE1lbnVNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9tZW51JztcbmltcG9ydCB7IE1hdExpc3RNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9saXN0JztcbmltcG9ydCB7IEF4b1V0aWxzTW9kdWxlIH0gZnJvbSAnLi4vYXhvLXV0aWxzL2F4by11dGlscy5tb2R1bGUnO1xuaW1wb3J0IHsgRmlsdGVyc01vZHVsZSB9IGZyb20gJy4uL2ZpbHRlcnMvZmlsdGVycy5tb2R1bGUnO1xuaW1wb3J0IHsgRGF0YVZpZXdGaWx0ZXJzU2VydmljZSB9IGZyb20gJy4vZGF0YS12aWV3LWZpbHRlcnMvZGF0YS12aWV3LWZpbHRlcnMuc2VydmljZSc7XG5pbXBvcnQgeyBNYXRTZWxlY3RNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9zZWxlY3QnO1xuaW1wb3J0IHsgRGF0YVZpZXdTZXJ2aWNlIH0gZnJvbSAnLi9kYXRhLXZpZXcuc2VydmljZSc7XG5pbXBvcnQgeyBBeG9GaWx0ZXJzTW9kdWxlIH0gZnJvbSAnLi4vYXhvLWZpbHRlcnMvYXhvLWZpbHRlcnMubW9kdWxlJztcbmltcG9ydCB7IEZvcm1zTW9kdWxlLCBSZWFjdGl2ZUZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHtNYXRUb29sdGlwTW9kdWxlfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC90b29sdGlwJztcblxuXG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1xuICAgIERhdGFWaWV3SGVhZGVyQ29tcG9uZW50LFxuICAgIERhdGFWaWV3RmlsdGVyc0NvbXBvbmVudFxuICBdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIE1hdEljb25Nb2R1bGUsXG4gICAgTWF0TWVudU1vZHVsZSxcbiAgICBNYXRMaXN0TW9kdWxlLFxuICAgIEF4b1V0aWxzTW9kdWxlLFxuICAgIEZpbHRlcnNNb2R1bGUsXG4gICAgTWF0U2VsZWN0TW9kdWxlLFxuICAgIEF4b0ZpbHRlcnNNb2R1bGUsXG4gICAgUmVhY3RpdmVGb3Jtc01vZHVsZSxcbiAgICBNYXRUb29sdGlwTW9kdWxlLFxuICAgIE1hdFNsaWRlVG9nZ2xlTW9kdWxlLFxuICAgIEZvcm1zTW9kdWxlXG5cbiAgXSxcbiAgcHJvdmlkZXJzOltcbiAgICBEYXRhVmlld0ZpbHRlcnNTZXJ2aWNlLFxuICAgIERhdGFWaWV3U2VydmljZVxuICBdLFxuXG4gIGV4cG9ydHM6W1xuICAgIERhdGFWaWV3SGVhZGVyQ29tcG9uZW50XG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgRGF0YVZpZXdMaWJNb2R1bGUgeyB9XG4iXX0=

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-app-common-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-app-common-lib/src/lib/drill-through/drill-through.component.ts","../../../../../src/ax-app-common-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"]}