@bizdoc/core 1.14.9 → 1.14.10

package/esm2020/lib/reports/cube/usage-pivot.component.mjs

@@ -0,0 +1,256 @@
+import { Component, ViewChild } from "@angular/core";
+import { forkJoin, of } from "rxjs";
+import { tap, takeUntil } from "rxjs/operators";
+import { PivotViewComponent } from "@syncfusion/ej2-angular-pivotview";
+import { PivotView } from "@syncfusion/ej2-angular-pivotview";
+import { Internationalization } from "@syncfusion/ej2-base";
+import { Tooltip } from '@syncfusion/ej2-popups';
+import { getWarn, isArray } from "../../core/functions";
+import { UsageReportBase } from "./usage-base";
+import * as i0 from "@angular/core";
+import * as i1 from "../report-ref";
+import * as i2 from "../../core/datasource.service";
+import * as i3 from "../../cube/cube.service";
+import * as i4 from "../../core/session.service";
+import * as i5 from "../../core/router";
+import * as i6 from "../../core/prompt.service";
+import * as i7 from "@angular/cdk/bidi";
+import * as i8 from "../../core/translate.service";
+const PIVOT_HEADER_DELIMITER = '|';
+/**
+ * cube usage
+ * */
+export class UsagePivotComponent extends UsageReportBase {
+    // ctor
+    constructor(reportRef, type, _elementRef, service, session, router, sb, dir, translate) {
+        super(reportRef, type, service, session, router, sb, dir, translate);
+        this._elementRef = _elementRef;
+        this.gridSettings = {
+            rowHeight: 36
+        };
+        this.conditionalFormatSettings = [{
+                conditions: 'LessThan',
+                value1: 0,
+                measure: 'value',
+                applyGrandTotals: true,
+                style: {
+                    color: getWarn()
+                }
+            }];
+        this.groupingBarSettings = {
+            showRemoveIcon: false,
+            showFilterIcon: false,
+            showValueTypeIcon: false
+        };
+        this._intl = new Internationalization();
+        this._session.themeChange.pipe(takeUntil(this._destroy)).subscribe(() => {
+            this.conditionalFormatSettings[0].style.color = getWarn();
+            this.pivot.refresh();
+        });
+        this._defaults();
+    }
+    /** set defaults */
+    _defaults() {
+        const { xAxis } = this._options;
+        this._xAxis = xAxis ? this._cube.axes.filter(a => isArray(xAxis) ? xAxis.indexOf(a.name) > -1 : a.name === xAxis) : this._cube.axes.filter(a => !a.hidden).slice(0, 2);
+        this._emptyCellsTextContent = this._intl.formatNumber(0, {
+            format: this.currencyCode ? 'C' : 'N',
+            currency: this.currencyCode,
+            maximumFractionDigits: this._fractionDigits
+        });
+        const formatSettings = [{
+                name: 'usage',
+                format: this.currencyCode ? 'C' : 'N',
+                maximumFractionDigits: this._fractionDigits
+            }];
+        const values = [
+            {
+                name: 'usage',
+                caption: this._yTitle,
+                showNoDataItems: true
+            }
+        ];
+        const conditionalSettings = [{
+                conditions: 'NotEquals',
+                value1: 0,
+                measure: 'usage'
+            }];
+        this._indices &&
+            this._indices.forEach(i => {
+                values.push({
+                    name: i.name,
+                    caption: i.title,
+                    showNoDataItems: true
+                });
+                conditionalSettings.push({
+                    conditions: 'NotEquals',
+                    value1: 0,
+                    measure: i.name
+                });
+                formatSettings.push({
+                    name: i.name,
+                    format: this.currencyCode ? 'C' : 'N',
+                    maximumFractionDigits: this._fractionDigits
+                });
+            });
+        this.hyperlinkSettings = {
+            conditionalSettings: conditionalSettings
+        };
+        const columns = this._xAxis.map(a => {
+            return {
+                name: a.name,
+                caption: a.title,
+                showNoDataItems: true
+            };
+        });
+        const rows = this._series.map(a => {
+            return {
+                name: a.name,
+                caption: a.title,
+                showNoDataItems: true
+            };
+        });
+        this.dataSourceSettings = {
+            columns,
+            rows,
+            values,
+            conditionalFormatSettings: this.conditionalFormatSettings,
+            emptyCellsTextContent: this._emptyCellsTextContent,
+            expandAll: this._expandAll,
+            showColumnGrandTotals: true,
+            alwaysShowValueHeader: false,
+            formatSettings,
+            dataSource: [],
+            valueSortSettings: { headerDelimiter: PIVOT_HEADER_DELIMITER },
+            enableSorting: false
+        };
+    }
+    /**
+     *
+     * @param result
+     */
+    onData(result) {
+        this._decorate(result).subscribe(() => {
+            this._data = this.dataSourceSettings.dataSource = result;
+            this._draw();
+        }, () => this._sb.error());
+    }
+    enginePopulated() {
+        this.pivot.grid.excelQueryCellInfo = this.excelQueryCellInfo.bind(this);
+    }
+    excelQueryCellInfo(evt) {
+        if (evt.value === this._emptyCellsTextContent)
+            evt.value = 0;
+    }
+    onResize() {
+        if (this.pivot) {
+            this.pivot.width = this.width;
+            this.pivot.onWindowResize();
+        }
+    }
+    onExport(name) {
+        this.pivot.excelExport({
+            fileName: `${name}.xlsx`
+        });
+    }
+    /**
+     * adds data source description to item keys.
+     * @param result
+     */
+    _decorate(result) {
+        const observables = [];
+        result.forEach(row => {
+            this._xAxis.concat(this._series).forEach(a => {
+                const axis = row[a.name];
+                row[`_${a.name}`] = axis;
+                const observable = this._type.get(a.dataType, axis).pipe(tap(v => row[a.name] = v || axis));
+                observables.push(observable);
+            });
+        });
+        return observables.length ? forkJoin(observables) : of([]);
+    }
+    _draw() {
+        this.pivot && this.pivot.destroy();
+        this.pivot = new PivotView({
+            spinnerTemplate: '',
+            dataSourceSettings: this.dataSourceSettings,
+            width: this.width,
+            height: this.height,
+            enableValueSorting: true,
+            enableRtl: this.enableRtl,
+            showTooltip: false,
+            allowConditionalFormatting: true,
+            allowNumberFormatting: true,
+            groupingBarSettings: this.groupingBarSettings,
+            allowCalculatedField: true,
+            showGroupingBar: true,
+            allowExcelExport: true,
+            hyperlinkSettings: this.hyperlinkSettings,
+            gridSettings: this.gridSettings,
+            cellClick: this.cellClick.bind(this),
+            currencyCode: this.currencyCode,
+            dataBound: this.dataBound.bind(this)
+        }, this._elementRef.nativeElement);
+    }
+    dataBound(_) {
+        this.tooltip = new Tooltip({
+            target: '.e-icons',
+            cssClass: 'e-custom-tooltip',
+            position: 'BottomCenter',
+            offsetY: 15,
+            enableRtl: this.pivot.enableRtl,
+            locale: this.pivot.locale,
+        });
+        this.tooltip.appendTo(this._elementRef.nativeElement);
+    }
+    /**
+     *
+     * @param evt
+     */
+    cellClick(evt) {
+        const { columnHeaders, rowHeaders, actualText } = evt.data;
+        const axes = this._pivotAxes(columnHeaders, rowHeaders);
+        super.browse(axes, actualText === 'usage' ? null : actualText);
+    }
+    /**
+     * reverse engineer axes from headers
+     * @param columnHeaders
+     * @param rowHeaders
+     */
+    _pivotAxes(columnHeaders, rowHeaders) {
+        const axes = {};
+        if (columnHeaders !== '')
+            columnHeaders.split(PIVOT_HEADER_DELIMITER).forEach((c, i) => {
+                const column = this.dataSourceSettings.columns[i].name, 
+                // find any row with header
+                element = this._data.find(e => e[column].toString() === c);
+                // translate back to key
+                axes[column] = element ? element[`_${column}`] : c;
+            });
+        if (rowHeaders !== '')
+            rowHeaders.split(PIVOT_HEADER_DELIMITER).forEach((r, i) => {
+                const column = this.dataSourceSettings.rows[i].name, element = this._data.find(e => e[column] === r);
+                axes[column] = element ? element[`_${column}`] : r;
+            });
+        return axes;
+    }
+    ngOnDestroy() {
+        this.tooltip && this.tooltip.destroy();
+        this.pivot && this.pivot.destroy();
+        super.ngOnDestroy();
+    }
+}
+UsagePivotComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: UsagePivotComponent, deps: [{ token: i1.ReportRef }, { token: i2.DatasourceService }, { token: i0.ElementRef }, { token: i3.CubeService }, { token: i4.SessionService }, { token: i5.RouterImpl }, { token: i6.PromptService }, { token: i7.Directionality }, { token: i8.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+UsagePivotComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: UsagePivotComponent, selector: "ng-component", host: { properties: { "id": "id" } }, viewQueries: [{ propertyName: "pivot", first: true, predicate: PivotViewComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: UsagePivotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                    //templateUrl: 'usage-pivot.component.html',
+                    host: { '[id]': 'id' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ReportRef }, { type: i2.DatasourceService }, { type: i0.ElementRef }, { type: i3.CubeService }, { type: i4.SessionService }, { type: i5.RouterImpl }, { type: i6.PromptService }, { type: i7.Directionality }, { type: i8.TranslateService }]; }, propDecorators: { pivot: [{
+                type: ViewChild,
+                args: [PivotViewComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"usage-pivot.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/reports/cube/usage-pivot.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, ViewChild } from \"@angular/core\";\r\nimport { Directionality } from \"@angular/cdk/bidi\";\r\nimport { Observable, forkJoin, of } from \"rxjs\";\r\nimport { tap, takeUntil } from \"rxjs/operators\";\r\nimport { PivotViewComponent } from \"@syncfusion/ej2-angular-pivotview\";\r\nimport { PivotView, GroupingBarSettingsModel, HyperCellClickEventArgs, ConditionalSettingsModel, HyperlinkSettingsModel } from \"@syncfusion/ej2-angular-pivotview\";\r\nimport { ExcelQueryCellInfoEventArgs } from \"@syncfusion/ej2-grids\";\r\nimport { ConditionalFormatSettingsModel } from \"@syncfusion/ej2-pivotview/src/pivotview/model/datasourcesettings-model\";\r\nimport { DataSourceSettingsModel, FieldOptionsModel, FormatSettingsModel } from \"@syncfusion/ej2-pivotview/src/pivotview/model/datasourcesettings-model\";\r\nimport { GridSettingsModel } from \"@syncfusion/ej2-pivotview/src/pivotview/model/gridsettings-model\";\r\nimport { Internationalization } from \"@syncfusion/ej2-base\";\r\nimport { Tooltip } from '@syncfusion/ej2-popups';\r\nimport { CubeAxis } from \"../../core/models\";\r\nimport { getWarn, isArray } from \"../../core/functions\";\r\nimport { SessionService } from \"../../core/session.service\";\r\nimport { TranslateService } from \"../../core/translate.service\";\r\nimport { DatasourceService } from \"../../core/datasource.service\";\r\nimport { CubeService } from \"../../cube/cube.service\";\r\nimport { PromptService } from \"../../core/prompt.service\";\r\nimport { RouterImpl } from \"../../core/router\";\r\nimport { Item, Options, UsageReportBase } from \"./usage-base\";\r\nimport { ReportRef } from \"../report-ref\";\r\n\r\nconst PIVOT_HEADER_DELIMITER = '|';\r\n/**\r\n * cube usage\r\n * */\r\n@Component({\r\n  template: '',\r\n  //templateUrl: 'usage-pivot.component.html',\r\n  host: { '[id]': 'id' }\r\n})\r\nexport\r\n  class UsagePivotComponent extends UsageReportBase {\r\n  @ViewChild(PivotViewComponent) pivot: PivotView;\r\n  private _emptyCellsTextContent: string;\r\n  private _xAxis: CubeAxis[];\r\n  dataSourceSettings: DataSourceSettingsModel;\r\n  hyperlinkSettings: HyperlinkSettingsModel;\r\n  tooltip: Tooltip;\r\n  readonly gridSettings: GridSettingsModel = {\r\n    rowHeight: 36\r\n  };\r\n  readonly conditionalFormatSettings: ConditionalFormatSettingsModel[] = [{\r\n    conditions: 'LessThan',\r\n    value1: 0,\r\n    measure: 'value',\r\n    applyGrandTotals: true,\r\n    style: {\r\n      color: getWarn()\r\n    }\r\n  }];\r\n  readonly groupingBarSettings: GroupingBarSettingsModel = {\r\n    showRemoveIcon: false,\r\n    showFilterIcon: false,\r\n    showValueTypeIcon: false\r\n  };\r\n  private readonly _intl: Internationalization = new Internationalization();\r\n  // ctor\r\n  constructor(reportRef: ReportRef<Options>,\r\n    type: DatasourceService,\r\n    private _elementRef: ElementRef,\r\n    service: CubeService, session: SessionService,\r\n    router: RouterImpl,\r\n    sb: PromptService,\r\n    dir: Directionality,\r\n    translate: TranslateService) {\r\n    super(reportRef, type, service, session, router, sb, dir, translate);\r\n    this._session.themeChange.pipe(takeUntil(this._destroy)).subscribe(() => {\r\n      this.conditionalFormatSettings[0].style.color = getWarn();\r\n      this.pivot.refresh();\r\n    });\r\n    this._defaults();\r\n  }\r\n  /** set defaults */\r\n  private _defaults() {\r\n    const { xAxis } = this._options;\r\n    this._xAxis = xAxis ? this._cube.axes.filter(a => isArray(xAxis) ? xAxis.indexOf(a.name) > -1 : a.name === xAxis) : this._cube.axes.filter(a => !a.hidden).slice(0, 2);\r\n    this._emptyCellsTextContent = this._intl.formatNumber(0, {\r\n      format: this.currencyCode ? 'C' : 'N',\r\n      currency: this.currencyCode,\r\n      maximumFractionDigits: this._fractionDigits\r\n    });\r\n    const formatSettings: FormatSettingsModel[] = [{\r\n      name: 'usage',\r\n      format: this.currencyCode ? 'C' : 'N',\r\n      maximumFractionDigits: this._fractionDigits\r\n    }];\r\n    const values: FieldOptionsModel[] = [\r\n      {\r\n        name: 'usage',\r\n        caption: this._yTitle,\r\n        showNoDataItems: true\r\n      }\r\n    ];\r\n    const conditionalSettings: ConditionalSettingsModel[] = [{\r\n      conditions: 'NotEquals',\r\n      value1: 0,\r\n      measure: 'usage'\r\n    }];\r\n    this._indices &&\r\n      this._indices.forEach(i => {\r\n        values.push({\r\n          name: i.name,\r\n          caption: i.title,\r\n          showNoDataItems: true\r\n        });\r\n        conditionalSettings.push({\r\n          conditions: 'NotEquals',\r\n          value1: 0,\r\n          measure: i.name\r\n        });\r\n        formatSettings.push({\r\n          name: i.name,\r\n          format: this.currencyCode ? 'C' : 'N',\r\n          maximumFractionDigits: this._fractionDigits\r\n        });\r\n      });\r\n    this.hyperlinkSettings = {\r\n      conditionalSettings: conditionalSettings\r\n    }\r\n    const columns = this._xAxis.map(a => {\r\n      return {\r\n        name: a.name,\r\n        caption: a.title,\r\n        showNoDataItems: true\r\n      } as FieldOptionsModel;\r\n    });\r\n    const rows = this._series.map(a => {\r\n      return {\r\n        name: a.name,\r\n        caption: a.title,\r\n        showNoDataItems: true\r\n      } as FieldOptionsModel;\r\n    });\r\n    this.dataSourceSettings = {\r\n      columns,\r\n      rows,\r\n      values,\r\n      conditionalFormatSettings: this.conditionalFormatSettings,\r\n      emptyCellsTextContent: this._emptyCellsTextContent,\r\n      expandAll: this._expandAll,\r\n      showColumnGrandTotals: true,\r\n      alwaysShowValueHeader: false,\r\n      formatSettings,\r\n      dataSource: [],\r\n      valueSortSettings: { headerDelimiter: PIVOT_HEADER_DELIMITER },\r\n      enableSorting: false\r\n    };\r\n  }\r\n  /**\r\n   * \r\n   * @param result\r\n   */\r\n  onData(result: Item[]) {\r\n    this._decorate(result).subscribe(() => {\r\n      this._data = this.dataSourceSettings.dataSource = result as any;\r\n      this._draw();\r\n    }, () => this._sb.error());\r\n  }\r\n  enginePopulated() {\r\n    this.pivot.grid.excelQueryCellInfo = this.excelQueryCellInfo.bind(this);\r\n  }\r\n  excelQueryCellInfo(evt: ExcelQueryCellInfoEventArgs) {\r\n    if (evt.value === this._emptyCellsTextContent) evt.value = 0;\r\n  }\r\n  onResize() {\r\n    if (this.pivot) {\r\n      this.pivot.width = this.width;\r\n      this.pivot.onWindowResize();\r\n    }\r\n  }\r\n  onExport(name: string) {\r\n    this.pivot.excelExport({\r\n      fileName: `${name}.xlsx`\r\n    });\r\n  }\r\n\r\n  /**\r\n   * adds data source description to item keys.\r\n   * @param result\r\n   */\r\n  private _decorate(result: Item[]): Observable<any> {\r\n    const observables: Observable<any>[] = [];\r\n    result.forEach(row => {\r\n      this._xAxis.concat(this._series).forEach(a => {\r\n        const axis = row[a.name] as string;\r\n        row[`_${a.name}`] = axis;\r\n        const observable = this._type.get(a.dataType, axis).pipe(tap(v => row[a.name] = v || axis));\r\n        observables.push(observable);\r\n      });\r\n    });\r\n    return observables.length ? forkJoin(observables) : of([]);\r\n  }\r\n  private _draw() {\r\n    this.pivot && this.pivot.destroy();\r\n    this.pivot = new PivotView({\r\n      spinnerTemplate: '',\r\n      dataSourceSettings: this.dataSourceSettings,\r\n      width: this.width,\r\n      height: this.height,\r\n      enableValueSorting: true,\r\n      enableRtl: this.enableRtl,\r\n      showTooltip: false,\r\n      allowConditionalFormatting: true,\r\n      allowNumberFormatting: true,\r\n      groupingBarSettings: this.groupingBarSettings,\r\n      allowCalculatedField: true,\r\n      showGroupingBar: true,\r\n      allowExcelExport: true,\r\n      hyperlinkSettings: this.hyperlinkSettings,\r\n      gridSettings: this.gridSettings,\r\n      cellClick: this.cellClick.bind(this),\r\n      currencyCode: this.currencyCode,\r\n      dataBound: this.dataBound.bind(this)\r\n    }, this._elementRef.nativeElement);\r\n  }\r\n  dataBound(_) {\r\n    this.tooltip = new Tooltip({\r\n      target: '.e-icons',\r\n      cssClass: 'e-custom-tooltip',\r\n      position: 'BottomCenter',\r\n      offsetY: 15,\r\n      enableRtl: this.pivot.enableRtl,\r\n      locale: this.pivot.locale,\r\n    });\r\n    this.tooltip.appendTo(this._elementRef.nativeElement);\r\n  }\r\n  /**\r\n   * \r\n   * @param evt\r\n   */\r\n  cellClick(evt: HyperCellClickEventArgs) {\r\n    const { columnHeaders, rowHeaders, actualText } = evt.data as any;\r\n    const axes = this._pivotAxes(columnHeaders, rowHeaders);\r\n    super.browse(axes, actualText === 'usage' ? null : actualText);\r\n  }\r\n  /**\r\n   * reverse engineer axes from headers\r\n   * @param columnHeaders\r\n   * @param rowHeaders\r\n   */\r\n  private _pivotAxes(columnHeaders: string, rowHeaders: string): { [axis: string]: string; } {\r\n    const axes: { [axis: string]: string } = {};\r\n    if (columnHeaders !== '')\r\n      columnHeaders.split(PIVOT_HEADER_DELIMITER).forEach((c, i) => {\r\n        const column = this.dataSourceSettings.columns[i].name,\r\n          // find any row with header\r\n          element = this._data.find(e => e[column].toString() === c);\r\n        // translate back to key\r\n        axes[column] = element ? element[`_${column}`] : c;\r\n      });\r\n    if (rowHeaders !== '')\r\n      rowHeaders.split(PIVOT_HEADER_DELIMITER).forEach((r, i) => {\r\n        const column = this.dataSourceSettings.rows[i].name,\r\n          element = this._data.find(e => e[column] === r);\r\n        axes[column] = element ? element[`_${column}`] : r;\r\n      });\r\n    return axes;\r\n  }\r\n  ngOnDestroy() {\r\n    this.tooltip && this.tooltip.destroy();\r\n    this.pivot && this.pivot.destroy();\r\n    super.ngOnDestroy();\r\n  }\r\n}\r\n"]}

package/esm2020/lib/reports/cube/usage.component.mjs

@@ -0,0 +1,40 @@
+import { __decorate } from "tslib";
+import { Component } from "@angular/core";
+import { BizDoc } from "../../core/decorators";
+import { UsagePivotComponent } from "./usage-pivot.component";
+import { UsageChartComponent } from "./usage-chart.component";
+import * as i0 from "@angular/core";
+import * as i1 from "../report-ref";
+let CubeUsageComponent = class CubeUsageComponent {
+    constructor(_injector, _ref, _vc) {
+        this._injector = _injector;
+        this._ref = _ref;
+        this._vc = _vc;
+    }
+    onBind(data, args) {
+        this._instance.onBind(data, args);
+    }
+    ngOnInit() {
+        let comp;
+        if (this._ref.options.chartType)
+            comp = UsageChartComponent;
+        else
+            comp = UsagePivotComponent;
+        this._instance = this._vc.createComponent(comp).instance;
+    }
+};
+CubeUsageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeUsageComponent, deps: [{ token: i0.Injector }, { token: i1.ReportRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component });
+CubeUsageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: CubeUsageComponent, selector: "ng-component", ngImport: i0, template: '', isInline: true });
+CubeUsageComponent = __decorate([
+    BizDoc({
+        selector: 'bizdoc-cube-usage'
+    })
+], CubeUsageComponent);
+export { CubeUsageComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeUsageComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.ReportRef }, { type: i0.ViewContainerRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/reports/report-ref.mjs

@@ -0,0 +1,31 @@
+import { filter, map } from 'rxjs/operators';
+import { BehaviorSubject, Subject } from 'rxjs';
+/** */
+export class ReportRef {
+    constructor(_configuration, _hub, dim) {
+        this._configuration = _configuration;
+        this._hub = _hub;
+        this._exporting = new Subject();
+        this._resize = new BehaviorSubject(dim);
+    }
+    /** intercept user export */
+    exporting() {
+        return this._exporting.asObservable();
+    }
+    get resize() { return this._resize.asObservable(); }
+    /** listen to progress events reported by backend code */
+    get progress() {
+        return this._hub.reportProgress$.
+            pipe(filter(e => e.name === this._configuration.name), map(e => e.progress));
+    }
+    /** configuration options */
+    get options() {
+        return this._configuration.options || {};
+    }
+    /** configuration name */
+    get name() { return this._configuration.name; }
+    _destroy() {
+        this._resize.unsubscribe();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/reports/report-viewer.component.mjs

@@ -0,0 +1,151 @@
+import { Component, ViewChild, ViewContainerRef, Injector, HostListener, Input } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { debounceTime, takeUntil, filter, tap } from 'rxjs/operators';
+import { Workbook } from '@syncfusion/ej2-excel-export';
+import { ReportRef } from './report-ref';
+import { TableViewComponent } from './table/table-view.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../core/prompt.service";
+import * as i3 from "../core/hub.service";
+import * as i4 from "../core/translate.service";
+import * as i5 from "../core/session.service";
+import * as i6 from "../core/component-factory-resolver";
+import * as i7 from "@angular/material/progress-bar";
+/** reportviewer component*/
+export class ReportViewerComponent {
+    /** reportviewer ctor */
+    constructor(_http, _sb, _injector, _hub, _translate, _session, _factoryResolver) {
+        this._http = _http;
+        this._sb = _sb;
+        this._injector = _injector;
+        this._hub = _hub;
+        this._translate = _translate;
+        this._session = _session;
+        this._factoryResolver = _factoryResolver;
+        this.progress = -1;
+        this._resizing = new BehaviorSubject({});
+        this._destroy = new Subject();
+    }
+    get reportRef() {
+        return this._reportRef;
+    }
+    ngOnChanges(changes) {
+        if (changes['report']) {
+            this._destroy.next();
+            this._reportRef && this._reportRef._destroy();
+            this._reportRef = new ReportRef(this.report, this._hub, this._dim());
+            if (this.report.template)
+                this._createView();
+            else
+                this._instance = this.table;
+            // listen to progress
+            this._hub.reportProgress$.
+                pipe(filter(e => e.name === this.report.name), takeUntil(this._destroy), debounceTime(50)).
+                subscribe(i => {
+                if (this.progress > 0)
+                    this.progress = i.progress;
+            });
+            this._resizing.pipe(debounceTime(150)).subscribe(() => this._reportRef._resize.next(this._dim()));
+        }
+    }
+    /** */
+    _createView() {
+        const componentFactory = this._factoryResolver.resolve(this.report.template);
+        this.viewContainer.clear();
+        const injector = Injector.create([{ provide: ReportRef, useValue: this._reportRef }], this._injector);
+        const componentRef = this.viewContainer.createComponent(componentFactory, 0, injector);
+        this._instance = componentRef.instance;
+    }
+    resize() {
+        this._resizing.next({});
+    }
+    _dim() {
+        const { width, height } = this.viewContainer.element.nativeElement.parentElement.getBoundingClientRect();
+        return { width: Math.floor(width - 2), height: Math.floor(height) };
+    }
+    /** */
+    execute() {
+        this.progress = 0;
+        return this._http.post(`/api/report/${this.report.name}`, this.args).
+            pipe(tap(r => {
+            this._instance.onBind(r, this.args);
+            this._data = r;
+            this.progress = -1;
+        }, () => {
+            this._sb.error();
+            this.progress = -1;
+        })).toPromise();
+    }
+    explore(item) {
+        const args = {};
+        const keys = this.report.fields.filter(f => f.key);
+        if (keys.length === 0)
+            throw `report ${this.report.name} item model missing key attribute`;
+        keys.forEach(f => args[f.name] = item[f.name]);
+        return this._http.put(`/api/report/${this.report.name}`, args).toPromise();
+    }
+    /** */
+    exportExcel() {
+        const args = { data: this._data.map(r => { return { ...r }; }) };
+        this._reportRef._exporting.next(args);
+        if (args.cancel)
+            return;
+        const rows = [{
+                index: 1,
+                cells: this.report.columns.map((c, j) => ({
+                    index: j + 1, value: c.label || c.name,
+                    style: {
+                        bold: true,
+                        hAlign: c.type === 'Number' || c.type === 'Currency' ? 'right' : 'general'
+                    }
+                }))
+            }];
+        args.data.forEach((r, i) => rows.push({
+            index: i + 2,
+            cells: this.report.columns.map((c, j) => ({
+                index: j + 1, value: r[c.name],
+                style: {
+                    hAlign: c.type === 'Number' || c.type === 'Currency' ? 'right' : 'general'
+                }
+            }))
+        }));
+        const book = new Workbook({
+            worksheets: [
+                {
+                    enableRtl: this._session.inverse,
+                    name: this._translate.get('SheetN', 1),
+                    columns: this.report.columns.map((_, i) => ({ index: i + 1, width: 250 })),
+                    rows
+                }
+            ],
+        }, 'xlsx');
+        book.save(`${this.report.title}.xlsx`);
+    }
+    ngOnDestroy() {
+        this._reportRef._destroy();
+        this._resizing.complete();
+        this._destroy.next();
+        this._destroy.complete();
+    }
+}
+ReportViewerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: ReportViewerComponent, deps: [{ token: i1.HttpClient }, { token: i2.PromptService }, { token: i0.Injector }, { token: i3.HubService }, { token: i4.TranslateService }, { token: i5.SessionService }, { token: i6.BizDocComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Component });
+ReportViewerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: ReportViewerComponent, selector: "bizdoc-report-viewer", inputs: { report: "report", args: "args" }, host: { listeners: { "window:resize": "resize()" } }, viewQueries: [{ propertyName: "viewContainer", first: true, predicate: ["vc"], descendants: true, read: ViewContainerRef, static: true }, { propertyName: "table", first: true, predicate: TableViewComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<mat-progress-bar [mode]=\"progress === 0 ? 'query' : 'buffer'\" [value]=progress [bufferValue]=0 [style.visibility]=\"progress > -1 ? 'visible':'hidden'\"></mat-progress-bar>\r\n<ng-container #vc></ng-container>\r\n", styles: [":host{display:flex;flex-direction:column}:host :last-child{flex:1 auto}\n"], components: [{ type: i7.MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "value", "bufferValue", "mode"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: ReportViewerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bizdoc-report-viewer', template: "<mat-progress-bar [mode]=\"progress === 0 ? 'query' : 'buffer'\" [value]=progress [bufferValue]=0 [style.visibility]=\"progress > -1 ? 'visible':'hidden'\"></mat-progress-bar>\r\n<ng-container #vc></ng-container>\r\n", styles: [":host{display:flex;flex-direction:column}:host :last-child{flex:1 auto}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.PromptService }, { type: i0.Injector }, { type: i3.HubService }, { type: i4.TranslateService }, { type: i5.SessionService }, { type: i6.BizDocComponentFactoryResolver }]; }, propDecorators: { report: [{
+                type: Input
+            }], args: [{
+                type: Input
+            }], viewContainer: [{
+                type: ViewChild,
+                args: ['vc', { static: true, read: ViewContainerRef }]
+            }], table: [{
+                type: ViewChild,
+                args: [TableViewComponent]
+            }], resize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-viewer.component.js","sourceRoot":"","sources":["../../../../../libraries/core/src/lib/reports/report-viewer.component.ts","../../../../../libraries/core/src/lib/reports/report-viewer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ViewChild, OnDestroy, ViewContainerRef, Injector, HostListener, Input, OnChanges, SimpleChanges } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { BehaviorSubject, Subject } from 'rxjs';\r\nimport { debounceTime, takeUntil, filter, tap } from 'rxjs/operators';\r\nimport { Workbook } from '@syncfusion/ej2-excel-export';\r\nimport { Worksheet } from '@syncfusion/ej2-excel-export/src/worksheet';\r\nimport { Row } from '@syncfusion/ej2-excel-export/src/row';\r\nimport { Column } from '@syncfusion/ej2-excel-export/src/column';\r\nimport { ReportComponent } from '../core/base';\r\nimport { Report } from '../core/models';\r\nimport { ParamMap } from '../core/configuration';\r\nimport { ReportRef, ExportEventArgs } from './report-ref';\r\nimport { HubService } from '../core/hub.service';\r\nimport { PromptService } from '../core/prompt.service';\r\nimport { TranslateService } from '../core/translate.service';\r\nimport { BizDocComponentFactoryResolver } from '../core/component-factory-resolver';\r\nimport { TableViewComponent } from './table/table-view.component';\r\nimport { SessionService } from '../core/session.service';\r\n\r\n@Component({\r\n  selector: 'bizdoc-report-viewer',\r\n  templateUrl: './report-viewer.component.html',\r\n  styleUrls: ['./report-viewer.component.scss']\r\n})\r\n/** reportviewer component*/\r\nexport class ReportViewerComponent implements OnChanges, OnDestroy {\r\n  @Input() report!: Report;\r\n  @Input() args: ParamMap;\r\n  progress = -1;\r\n  public get reportRef(): ReportRef {\r\n    return this._reportRef;\r\n  }\r\n  @ViewChild('vc', { static: true, read: ViewContainerRef }) viewContainer: ViewContainerRef;\r\n  @ViewChild(TableViewComponent) table: TableViewComponent;\r\n  private _data: any[];\r\n  private _instance: ReportComponent<any, any>;\r\n  private _reportRef: ReportRef;\r\n  private readonly _resizing = new BehaviorSubject({});\r\n  private readonly _destroy = new Subject<void>();\r\n  /** reportviewer ctor */\r\n  constructor(\r\n    private _http: HttpClient,\r\n    private _sb: PromptService,\r\n    private _injector: Injector,\r\n    private _hub: HubService,\r\n    private _translate: TranslateService,\r\n    private _session: SessionService,\r\n    private _factoryResolver: BizDocComponentFactoryResolver) {\r\n  }\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['report']) {\r\n      this._destroy.next();\r\n      this._reportRef && this._reportRef._destroy();\r\n      this._reportRef = new ReportRef(this.report, this._hub, this._dim());\r\n      if (this.report.template)\r\n        this._createView();\r\n      else\r\n        this._instance = this.table;\r\n      // listen to progress\r\n      this._hub.reportProgress$.\r\n        pipe(filter(e =>\r\n          e.name === this.report.name),\r\n          takeUntil(this._destroy),\r\n          debounceTime(50)).\r\n        subscribe(i => {\r\n          if (this.progress > 0) this.progress = i.progress;\r\n        });\r\n      this._resizing.pipe(debounceTime(150)).subscribe(() => this._reportRef._resize.next(this._dim()));\r\n    }\r\n  }\r\n  /** */\r\n  private _createView() {\r\n    const componentFactory = this._factoryResolver.resolve(this.report.template);\r\n    this.viewContainer.clear();\r\n    const injector = Injector.create([{ provide: ReportRef, useValue: this._reportRef }], this._injector);\r\n    const componentRef = this.viewContainer.createComponent(componentFactory, 0, injector);\r\n\r\n    this._instance = componentRef.instance as ReportComponent<any, any>;\r\n  }\r\n  @HostListener('window:resize')\r\n  resize() {\r\n    this._resizing.next({}); \r\n  }\r\n  private _dim(): { height: number; width: number } {\r\n    const { width, height } = (this.viewContainer.element.nativeElement as HTMLDivElement).parentElement.getBoundingClientRect();\r\n    return { width: Math.floor(width - 2), height: Math.floor(height) };\r\n  }\r\n  /** */\r\n  execute() {\r\n    this.progress = 0;\r\n    return this._http.post<any[]>(`/api/report/${this.report.name}`, this.args).\r\n      pipe(tap(r => {\r\n        this._instance.onBind(r, this.args);\r\n        this._data = r;\r\n        this.progress = -1;\r\n      }, () => {\r\n        this._sb.error();\r\n        this.progress = -1;\r\n      })).toPromise()\r\n  }\r\n\r\n  explore(item: any) {\r\n    const args = {};\r\n    const keys = this.report.fields.filter(f => f.key);\r\n    if (keys.length === 0)\r\n      throw `report ${this.report.name} item model missing key attribute`;\r\n    keys.forEach(f => args[f.name] = item[f.name]);\r\n    return this._http.put<any[]>(`/api/report/${this.report.name}`, args).toPromise();\r\n  }\r\n\r\n  /** */\r\n  exportExcel() {\r\n    const args = { data: this._data.map(r => { return { ...r } }) } as ExportEventArgs;\r\n    this._reportRef._exporting.next(args);\r\n    if (args.cancel) return;\r\n    const rows = [{\r\n      index: 1,\r\n      cells: this.report.columns.map((c, j) => ({\r\n        index: j + 1, value: c.label || c.name,\r\n        style: {\r\n          bold: true,\r\n          hAlign: c.type === 'Number' || c.type === 'Currency' ? 'right' : 'general'\r\n        }\r\n      } as Cell))\r\n    }] as Row[];\r\n    args.data.forEach((r, i) => rows.push(\r\n      {\r\n        index: i + 2,\r\n        cells: this.report.columns.map((c, j) => ({\r\n          index: j + 1, value: r[c.name],\r\n          style: {\r\n            hAlign: c.type === 'Number' || c.type === 'Currency' ? 'right' : 'general'\r\n          }\r\n        }))\r\n      } as Row));\r\n    const book = new Workbook(\r\n      {\r\n        worksheets: [\r\n          {\r\n          enableRtl: this._session.inverse,\r\n            name: this._translate.get('SheetN', 1),\r\n            columns: this.report.columns.map((_, i) => ({ index: i + 1, width: 250 } as Column)),\r\n            rows\r\n          } as Worksheet\r\n        ],\r\n      },\r\n      'xlsx'\r\n    );\r\n    book.save(`${this.report.title}.xlsx`);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._reportRef._destroy();\r\n    this._resizing.complete();\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n  }\r\n}\r\ninterface Cell { }\r\n","<mat-progress-bar [mode]=\"progress === 0 ? 'query' : 'buffer'\" [value]=progress [bufferValue]=0 [style.visibility]=\"progress > -1 ? 'visible':'hidden'\"></mat-progress-bar>\r\n<ng-container #vc></ng-container>\r\n"]}