@bizdoc/core 1.14.9 → 1.14.12

package/esm2020/lib/core/window-title.service.mjs

@@ -0,0 +1,53 @@
+import { Injectable, Inject } from '@angular/core';
+import { BIZDOC_CONFIG } from '../core/configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "./account.service";
+import * as i2 from "./translate.service";
+import * as i3 from "./hub.service";
+const TIME = 1000;
+export class WindowTitleService {
+    constructor(config, users, translate, hub) {
+        this.config = config;
+        this._inFocus = true;
+        this._isActive = false;
+        this._mode = false;
+        this._appTitle = this.config.appTitle || 'BizDoc';
+        document.addEventListener('blur', () => this._inFocus = false);
+        document.addEventListener('focus', () => {
+            this._isActive &&
+                this._clear();
+            this._inFocus = true;
+        });
+        hub.new$.subscribe(i => users.get(i.model.senderId).subscribe(u => !this._inFocus && this._show(translate.get('NewFrom', i.model.number, u.name))));
+        hub.notify$.subscribe(n => !this._inFocus && this._show(n.model.title));
+        this._title = document.title;
+    }
+    set(value) {
+        document.title = this._title = value ? `${this._appTitle} - ${value}` : this._appTitle;
+    }
+    _show(message) {
+        this._message = message;
+        this._isActive = true;
+        this._task && clearInterval(this._task);
+        this._task = setInterval(() => {
+            this._mode = !this._mode;
+            document.title = this._mode ? this._title : this._message;
+        }, TIME);
+    }
+    _clear() {
+        clearInterval(this._task);
+        this._task = null;
+        document.title = this._title;
+        this._isActive = false;
+    }
+}
+WindowTitleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: WindowTitleService, deps: [{ token: BIZDOC_CONFIG }, { token: i1.AccountService }, { token: i2.TranslateService }, { token: i3.HubService }], target: i0.ɵɵFactoryTarget.Injectable });
+WindowTitleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: WindowTitleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: WindowTitleService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BIZDOC_CONFIG]
+                }] }, { type: i1.AccountService }, { type: i2.TranslateService }, { type: i3.HubService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/cube/accum/accum.component.mjs

@@ -0,0 +1,259 @@
+import { Component, Output, EventEmitter, HostBinding, Input } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { AccumulationChart } from '@syncfusion/ej2-angular-charts';
+import { Internationalization } from '@syncfusion/ej2-base';
+import { Workbook } from '@syncfusion/ej2-excel-export';
+import { FONT_FAMILY } from '../../core/colors';
+import { AXES_CODE_DIVIDER, AXES_LABEL_DIVIDER, errResource } from '../cube.service';
+import { isArray } from '../../core/functions';
+import * as i0 from "@angular/core";
+import * as i1 from "../cube.service";
+import * as i2 from "../../core/prompt.service";
+import * as i3 from "../../core/translate.service";
+import * as i4 from "../../core/session.service";
+/** chart component*/
+export class CubeAccumulationChartComponent {
+    /** chart ctor */
+    constructor(_service, _sb, _translate, _elementRef, _session) {
+        this._service = _service;
+        this._sb = _sb;
+        this._translate = _translate;
+        this._elementRef = _elementRef;
+        this._session = _session;
+        this.id = `cube-accum-chart-${CubeAccumulationChartComponent.nextId++}`;
+        this.theme = this._session.theme.dark ? 'MaterialDark' : 'Material';
+        this.dataLabel = {
+            visible: true,
+            name: 'text',
+            position: 'Outside',
+            font: {
+                fontFamily: FONT_FAMILY
+            }
+        };
+        this.legendSettings = {
+            visible: true,
+            //position: this._session.inverse ? 'Left' : 'Right',
+            isInversed: this._session.inverse,
+            textStyle: {
+                fontFamily: FONT_FAMILY
+            }
+        };
+        this.tooltip = {
+            enable: true,
+            enableAnimation: true,
+            textStyle: {
+                fontFamily: FONT_FAMILY
+            }
+        };
+        this._palettes = this._session.accentPalette;
+        this.loadingChange = new EventEmitter();
+        this.explore = new EventEmitter();
+        this._intl = new Internationalization();
+        this._destroy = new Subject();
+        _session.themeChange.pipe(takeUntil(this._destroy)).
+            subscribe(t => {
+            this.theme = t.dark ? 'MaterialDark' : 'Material';
+            this.palettes = _session.accentPalette;
+        });
+    }
+    get palettes() {
+        return this._palettes;
+    }
+    set palettes(value) {
+        this._palettes = value;
+    }
+    set xAxis(val) {
+        this._xAxis = isArray(val) ? val : [val];
+    }
+    ngOnInit() {
+        this._cube = this._session.profile.cubes.find(c => c.name === this.cube) || this._session.profile.cubes[0];
+        this.currencyCode = this._cube.currencyCode;
+        switch (this.chartType) {
+            case 'Doughnut':
+                this.innerRadius = '10%';
+                break;
+            case 'HalfDoughnut':
+                this.startAngle = 270;
+                this.endAngle = 90;
+                this.innerRadius = '10%';
+                break;
+            case 'Funnel':
+                break;
+            default:
+                this.startAngle = 0;
+                this.endAngle = 360;
+                this.innerRadius = '0';
+        }
+        this.execute();
+    }
+    textRender(e) {
+        e.text = e.point.x;
+    }
+    tooltipRender(e) {
+        e.text = this._intl.formatNumber(e.point.y, {
+            currency: this.currencyCode,
+            format: this.currencyCode ? 'c' : 'n',
+            maximumFractionDigits: this._service.fractionDigits
+        });
+    }
+    pointClick(evt) {
+        const axes = {};
+        const x = evt.series.dataSource[evt.pointIndex].x.split(AXES_CODE_DIVIDER);
+        for (let i = 0; i < this._xAxis.length; i++)
+            axes[this._xAxis[i]] = x[i];
+        this.explore.emit({ axes });
+    }
+    /**
+     *
+     */
+    ngOnChanges(changes) {
+        if (changes['filters'] && !changes['filters'].firstChange)
+            this.execute();
+        else if (changes['height'])
+            this.resize();
+    }
+    resize() {
+        this.accumchart && this.accumchart.accumulationResize();
+    }
+    execute() {
+        this.loadingChange.emit(true);
+        this._service.series(this.cube, this._xAxis, {
+            filters: this.filters,
+            scope: this.scope
+        }).subscribe(r => {
+            this.dataSource = r[0].points;
+            this._draw();
+            this.loadingChange.emit(false);
+        }, (e) => {
+            this._sb.error(errResource(e));
+            this.loadingChange.emit(false);
+        });
+    }
+    _draw() {
+        this.accumchart && this.accumchart.destroy();
+        this.accumchart = new AccumulationChart({
+            legendSettings: this.legendSettings,
+            tooltip: this.tooltip,
+            pointClick: this.pointClick.bind(this),
+            theme: this.theme,
+            textRender: this.textRender.bind(this),
+            tooltipRender: this.tooltipRender.bind(this),
+            enableAnimation: true,
+            background: 'transparent',
+            height: this.height,
+            currencyCode: this.currencyCode,
+            series: [{
+                    dataSource: this.dataSource,
+                    xName: 'name',
+                    yName: 'y',
+                    startAngle: this.startAngle,
+                    endAngle: this.endAngle,
+                    radius: "70%",
+                    dataLabel: this.dataLabel,
+                    explode: true,
+                    explodeOffset: '10%',
+                    explodeIndex: 0,
+                    innerRadius: this.innerRadius,
+                    palettes: this.palettes
+                }]
+        }, this._elementRef.nativeElement);
+    }
+    exportToExcel(title) {
+        const numberFormat = this._service.numberFormat, rows = [{
+                index: 1,
+                cells: this._xAxis.map((x, i) => ({
+                    index: i + 1,
+                    value: this._cube.axes.find(a => a.name === x).title,
+                    style: {
+                        bold: true
+                    }
+                }))
+            }];
+        rows[0].cells.push({
+            index: this._xAxis.length + 1,
+            value: this._translate.get('Value'),
+            style: {
+                bold: true
+            }
+        });
+        this.dataSource.forEach((p, i) => {
+            const cells = this._xAxis.map((_, j) => {
+                return {
+                    index: j + 1,
+                    value: p.name.split(AXES_LABEL_DIVIDER)[j]
+                };
+            });
+            cells.push({
+                type: 'number',
+                index: this._xAxis.length + 1,
+                style: {
+                    numberFormat,
+                    hAlign: 'right'
+                },
+                value: p.y
+            });
+            rows.push({
+                index: i + 2,
+                cells
+            });
+        });
+        const book = new Workbook({
+            worksheets: [
+                {
+                    enableRtl: this._session.inverse,
+                    name: this._translate.get('SheetN', 1),
+                    columns: [...this._xAxis.map((_, i) => ({ index: i + 1, width: 250 })),
+                        { index: this._xAxis.length + 1 },],
+                    rows
+                }
+            ],
+        }, 'xlsx');
+        book.save(`${title}.xlsx`);
+    }
+    ngOnDestroy() {
+        this.accumchart && this.accumchart.destroy();
+        this._destroy.next();
+        this._destroy.complete();
+    }
+}
+CubeAccumulationChartComponent.nextId = 0;
+CubeAccumulationChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeAccumulationChartComponent, deps: [{ token: i1.CubeService }, { token: i2.PromptService }, { token: i3.TranslateService }, { token: i0.ElementRef }, { token: i4.SessionService }], target: i0.ɵɵFactoryTarget.Component });
+CubeAccumulationChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: CubeAccumulationChartComponent, selector: "bizdoc-cube-accum", inputs: { palettes: "palettes", height: "height", width: "width", cube: "cube", xAxis: "xAxis", filters: "filters", chartType: "chartType", scope: "scope", loading: "loading" }, outputs: { loadingChange: "loadingChange", explore: "explore" }, host: { properties: { "id": "this.id" }, classAttribute: "cube-view" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeAccumulationChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-cube-accum',
+                    template: '',
+                    host: {
+                        class: 'cube-view'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CubeService }, { type: i2.PromptService }, { type: i3.TranslateService }, { type: i0.ElementRef }, { type: i4.SessionService }]; }, propDecorators: { id: [{
+                type: HostBinding
+            }], palettes: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], cube: [{
+                type: Input
+            }], xAxis: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], chartType: [{
+                type: Input
+            }], scope: [{
+                type: Input
+            }, {
+                type: Input
+            }], loading: [{
+                type: Input
+            }], loadingChange: [{
+                type: Output
+            }], explore: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accum.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/cube/accum/accum.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Output, EventEmitter, OnDestroy, OnInit, ElementRef, HostBinding, Input, SimpleChanges, OnChanges } from '@angular/core';\r\nimport { HttpErrorResponse } from '@angular/common/http';\r\nimport { Subject } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport { AccumulationDataLabelSettingsModel, TooltipSettingsModel, LegendSettingsModel, AccumulationChart, IPointEventArgs, IAccTextRenderEventArgs, IAccTooltipRenderEventArgs } from '@syncfusion/ej2-angular-charts';\r\nimport { Internationalization } from '@syncfusion/ej2-base';\r\nimport { Workbook, Worksheet, Row, Column } from '@syncfusion/ej2-excel-export';\r\nimport { AxisClickEvent, CubeViewerComponent } from \"../declarations\";\r\nimport { AxesMap, ChartType, Cube } from '../../core/models';\r\nimport { FONT_FAMILY } from '../../core/colors';\r\nimport { AXES_CODE_DIVIDER, AXES_LABEL_DIVIDER, CubeService, errResource, Point } from '../cube.service';\r\nimport { SessionService } from '../../core/session.service';\r\nimport { TranslateService } from '../../core/translate.service';\r\nimport { PromptService } from '../../core/prompt.service';\r\nimport { isArray } from '../../core/functions';\r\nimport { ScopeType } from '../../core/configuration';\r\n\r\n@Component({\r\n  selector: 'bizdoc-cube-accum',\r\n  template: '',\r\n  host: {\r\n    class: 'cube-view'\r\n  }\r\n})\r\n/** chart component*/\r\nexport class CubeAccumulationChartComponent implements OnInit, OnChanges, OnDestroy, CubeViewerComponent {\r\n  static nextId = 0;\r\n  @HostBinding()\r\n  readonly id = `cube-accum-chart-${CubeAccumulationChartComponent.nextId++}`;\r\n  theme: 'Material' | 'MaterialDark' = this._session.theme.dark ? 'MaterialDark' : 'Material';\r\n  accumchart: AccumulationChart;\r\n  startAngle: number;\r\n  endAngle: number;\r\n  innerRadius: string;\r\n  dataSource: Point[];\r\n  readonly dataLabel: AccumulationDataLabelSettingsModel = {\r\n    visible: true,\r\n    name: 'text',\r\n    position: 'Outside',\r\n    font: {\r\n      fontFamily: FONT_FAMILY\r\n    }\r\n  };\r\n  readonly legendSettings: LegendSettingsModel = {\r\n    visible: true,\r\n    //position: this._session.inverse ? 'Left' : 'Right',\r\n    isInversed: this._session.inverse,\r\n    textStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    }\r\n  };\r\n  readonly tooltip: TooltipSettingsModel = {\r\n    enable: true,\r\n    enableAnimation: true,\r\n    textStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    }\r\n  };\r\n  private _palettes = this._session.accentPalette;\r\n  public get palettes() {\r\n    return this._palettes;\r\n  }\r\n  @Input()\r\n  public set palettes(value) {\r\n    this._palettes = value;\r\n  }\r\n  @Input()\r\n  height: string | number;\r\n  @Input()\r\n  width: string | number;\r\n  @Input()\r\n  cube!: string;\r\n  private _xAxis!: string[];\r\n  @Input()\r\n  set xAxis(val: string | string[]) {\r\n    this._xAxis = isArray(val) ? val : [val];\r\n  }\r\n  @Input()\r\n  filters?: AxesMap;\r\n  @Input()\r\n  chartType?: ChartType;\r\n  @Input()\r\n  @Input() scope: ScopeType;\r\n  currencyCode: string;\r\n  @Input() loading: boolean;\r\n  @Output() readonly loadingChange = new EventEmitter<boolean>();\r\n  @Output() readonly explore: EventEmitter<AxisClickEvent> = new EventEmitter();\r\n  private _cube: Cube;\r\n  private readonly _intl: Internationalization = new Internationalization();\r\n  private readonly _destroy = new Subject<void>();\r\n  /** chart ctor */\r\n  constructor(private _service: CubeService,\r\n    private _sb: PromptService,\r\n    private _translate: TranslateService,\r\n    private _elementRef: ElementRef,\r\n    private _session: SessionService) {\r\n    _session.themeChange.pipe(takeUntil(this._destroy)).\r\n      subscribe(t => {\r\n        this.theme = t.dark ? 'MaterialDark' : 'Material';\r\n        this.palettes = _session.accentPalette;\r\n      });\r\n  }\r\n  ngOnInit() {\r\n    this._cube = this._session.profile.cubes.find(c => c.name === this.cube) || this._session.profile.cubes[0];\r\n    this.currencyCode = this._cube.currencyCode;\r\n    switch (this.chartType) {\r\n      case 'Doughnut':\r\n        this.innerRadius = '10%';\r\n        break;\r\n      case 'HalfDoughnut':\r\n        this.startAngle = 270;\r\n        this.endAngle = 90;\r\n        this.innerRadius = '10%';\r\n        break;\r\n      case 'Funnel':\r\n        break;\r\n      default:\r\n        this.startAngle = 0;\r\n        this.endAngle = 360;\r\n        this.innerRadius = '0';\r\n    }\r\n    this.execute();\r\n  }\r\n  textRender(e: IAccTextRenderEventArgs) {\r\n    e.text = e.point.x as string;\r\n  }\r\n  tooltipRender(e: IAccTooltipRenderEventArgs): void {\r\n    (e as any).text = this._intl.formatNumber(e.point.y, {\r\n      currency: this.currencyCode,\r\n      format: this.currencyCode ? 'c' : 'n',\r\n      maximumFractionDigits: this._service.fractionDigits\r\n    });\r\n  }\r\n  pointClick(evt: IPointEventArgs) {\r\n    const axes: AxesMap = {};\r\n    const x = (evt.series.dataSource[evt.pointIndex].x as string).split(AXES_CODE_DIVIDER);\r\n    for (let i = 0; i < this._xAxis.length; i++)\r\n      axes[this._xAxis[i]] = x[i];\r\n    this.explore.emit({ axes });\r\n  }\r\n  /**\r\n   * \r\n   */\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['filters'] && !changes['filters'].firstChange)\r\n      this.execute();\r\n    else\r\n      if (changes['height'])\r\n        this.resize();\r\n  }\r\n  resize() {\r\n    this.accumchart && this.accumchart.accumulationResize();\r\n  }\r\n\r\n  execute() {\r\n    this.loadingChange.emit(true);\r\n    this._service.series(this.cube, this._xAxis, {\r\n      filters: this.filters,\r\n      scope: this.scope\r\n    }).subscribe(r => {\r\n      this.dataSource = r[0].points;\r\n      this._draw();\r\n      this.loadingChange.emit(false);\r\n    }, (e: HttpErrorResponse) => {\r\n      this._sb.error(errResource(e));\r\n      this.loadingChange.emit(false);\r\n    });\r\n  }\r\n\r\n  private _draw() {\r\n    this.accumchart && this.accumchart.destroy();\r\n    this.accumchart = new AccumulationChart({\r\n      legendSettings: this.legendSettings,\r\n      tooltip: this.tooltip,\r\n      pointClick: this.pointClick.bind(this),\r\n      theme: this.theme,\r\n      textRender: this.textRender.bind(this),\r\n      tooltipRender: this.tooltipRender.bind(this),\r\n      enableAnimation: true,\r\n      background: 'transparent',\r\n      height: this.height as string,\r\n      currencyCode: this.currencyCode,\r\n      series: [{\r\n        dataSource: this.dataSource,\r\n        xName: 'name',\r\n        yName: 'y',\r\n        startAngle: this.startAngle,\r\n        endAngle: this.endAngle,\r\n        radius: \"70%\",\r\n        dataLabel: this.dataLabel,\r\n        explode: true,\r\n        explodeOffset: '10%',\r\n        explodeIndex: 0,\r\n        innerRadius: this.innerRadius,\r\n        palettes: this.palettes\r\n      }]\r\n    }, this._elementRef.nativeElement);\r\n  }\r\n  exportToExcel(title: string) {\r\n    const numberFormat = this._service.numberFormat,\r\n      rows = [{\r\n        index: 1,\r\n        cells: this._xAxis.map((x, i) => ({\r\n          index: i + 1,\r\n          value: this._cube.axes.find(a => a.name === x).title,\r\n          style: {\r\n            bold: true\r\n          }\r\n        } as Cell))\r\n      }] as Row[];\r\n    rows[0].cells.push({\r\n      index: this._xAxis.length + 1,\r\n      value: this._translate.get('Value'),\r\n      style: {\r\n        bold: true\r\n      }\r\n    });\r\n    this.dataSource.forEach((p, i) => {\r\n      const cells = this._xAxis.map((_, j) => {\r\n        return {\r\n          index: j + 1,\r\n          value: p.name.split(AXES_LABEL_DIVIDER)[j]\r\n        } as Cell;\r\n      }\r\n      );\r\n      cells.push({\r\n        type: 'number',\r\n        index: this._xAxis.length + 1,\r\n        style: {\r\n          numberFormat,\r\n          hAlign: 'right'\r\n        },\r\n        value: p.y\r\n      } as Cell);\r\n      rows.push(\r\n        {\r\n          index: i + 2,\r\n          cells\r\n        } as Row)\r\n    });\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._xAxis.map((_, i) => ({ index: i + 1, width: 250 } as Column))\r\n              , { index: this._xAxis.length + 1 },\r\n            ],\r\n            rows\r\n          } as Worksheet\r\n        ],\r\n      },\r\n      'xlsx'\r\n    );\r\n    book.save(`${title}.xlsx`);\r\n  }\r\n  ngOnDestroy(): void {\r\n    this.accumchart && this.accumchart.destroy();\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n  }\r\n}\r\ninterface Cell { }\r\n"]}