@bizdoc/core 1.8.8 → 1.8.9

package/src/lib/cube/matrix/table.component.ts

@@ -0,0 +1,337 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { forkJoin, first } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { isArray } from '../../core/functions';
+import { CubeService, modelize, ScopeType } from '../cube.service';
+import { SessionService } from '../../core/session.service';
+import { DatasourceService } from '../../core/datasource.service';
+import { PromptService } from '../../core/prompt.service';
+import { Component, ElementRef, EventEmitter, Input, OnChanges, Output, SimpleChanges, ViewChild } from '@angular/core';
+import { AxesMap, Cube, CubeAxis, CubeIndex } from '../../core/models';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { query, stagger, style, transition, trigger } from '@angular/animations';
+
+const LOADING_DELAY = 200;
+
+const matrixAnimation = trigger('table',
+  [transition('void=>*',
+    [
+      query('.mat-row',
+        [
+          style({ opacity: 0, transform: 'translateX(10px)' }),
+          stagger(100,
+            style({ opacity: 1, transform: 'none' }))
+        ],
+        { optional: true })
+    ])]);
+/** cube matrix component*/
+@Component({
+  selector: 'bizdoc-cube-matrix-table',
+  templateUrl: './table.component.html',
+  styleUrls: ['./table.component.scss'],
+  animations: [matrixAnimation]
+})
+export class CubeMatrixTableComponent implements OnChanges {
+  readonly PRECISION = this._service.digitsInfo;
+  CURRENCY: string;
+  @ViewChild('table') tableElement: ElementRef<HTMLTableElement>;
+  @Input('cube') _cube?: string;
+  @Input('xAxis') _xAxis!: string;
+  @Input('serie') _serie!: string;
+  private _indices?: string[];
+  private _evalsum: { xAxis: string | number; serie: string | number; };
+  public get indices(): string[] | string {
+    return this._indices;
+  }
+  @Input()
+  public set indices(value: string[] | string) {
+    if (value) this._indices = isArray(value) ? value : [value];
+  }
+  @Input() scope: ScopeType;
+  @Input('sum') _sum: SumOptions;
+  @Input() axes: AxesMap;
+  private _interactive: boolean = true;
+  @Input() loading: boolean;
+  public get interactive(): boolean {
+    return this._interactive;
+  }
+  @Input()
+  public set interactive(value: boolean) {
+    this._interactive = coerceBooleanProperty(value);
+  }
+  @Output('explore') readonly onExplore = new EventEmitter<AxesMap>();
+  @Output() readonly loadingChange = new EventEmitter<boolean>();
+  rows: KeyValue[];
+  columns: KeyValue[];
+  indexes: CubeIndex[];
+  data: { [row: string]: { [column: string]: number; }; };
+  totals: { [column: string]: number };
+  cube: Cube;
+  xAxis: CubeAxis;
+  series: CubeAxis;
+  private _prepare: Promise<any>;
+  constructor(
+    private _sb: PromptService,
+    private _service: CubeService,
+    private _session: SessionService,
+    private _ds: DatasourceService) { }
+
+  ngOnChanges(changes: SimpleChanges): void {
+    if (changes['_cube']) {
+      this.cube = this.cube ? this._session.profile.cubes.find(c => c.name === this._cube) :
+        this._session.profile.cubes[0];
+      this.CURRENCY = this.cube.currencyCode /*|| this._service.currencyCode*/;
+    }
+    if (this._indices)
+      this.indexes = this.cube.indices.filter(i => this._indices.indexOf(i.name) > -1);
+    else {
+      this.indexes = this.cube.indices;
+      this._indices = this.cube.indices.map(i => i.name);
+    }
+    if (changes['_xAxia'] || changes['_serie']) {
+      this.xAxis = this.cube.axes.find(a => a.name === this._xAxis) || this.cube.axes[0];
+      this.series = this.cube.axes.find(a => a.name === this._serie) || this.cube.axes[1];
+      this._prepare = forkJoin(this._ds.all(this.series.dataType).pipe(tap(r =>
+        this.rows = r
+      )),
+        this._ds.all(this.xAxis.dataType).pipe(tap(c =>
+          this.columns = c
+        ))).toPromise().then(
+          () =>
+            this._sum &&
+            this._addsum());
+    }
+    if (changes['axes'])
+      this.refresh();
+  }
+  private _addsum() {
+    let { xAxis, serie } = this._dsum;
+    if (xAxis) {
+      const columns = [];
+      this.columns.forEach(c => {
+        columns.push(c);
+        if (xAxis.toString() === c.key)
+          columns.push({
+            key: '_sum',
+            value: this._sum.title
+          });
+      });
+      this.columns = columns;
+    }
+    if (serie) {
+      const rows = [];
+      this.rows.forEach(r => {
+        rows.push(r);
+        if (serie.toString() === r.key)
+          rows.push({
+            key: '_sum',
+            value: this._sum.title
+          });
+      });
+      this.rows = rows;
+    }
+  }
+
+  refresh() {
+    const progressTask = setTimeout(() =>
+      this.loadingChange.next(this.loading = true)
+      , LOADING_DELAY);
+    this._prepare.then(() => this._service.series(this.cube.name, this.xAxis.name, {
+      series: this.series.name,
+      indices: this.indexes.map(i => i.name),
+      filters: this.axes,
+      scope: this.scope
+    } as any).pipe(
+      modelize(), first(), tap(d => {
+        this._totals(d);
+        this._sum &&
+          this._calculatesum(d);
+      })).subscribe(d =>
+        this.data = d,
+        (e: HttpErrorResponse) => {
+          this._sb.error(e.status === 401 ? 'Unauthorized' : null);
+        }, () => {
+          clearTimeout(progressTask);
+          this.loadingChange.next(this.loading = false);
+        })
+    );
+  }
+  private _totals(data: { [key: string]: { [key: string]: number; }; }) {
+    let grand = 0;
+    this.indexes.forEach(i => {
+      const index = data[i.name];
+      if (!index) data[i.name] = {};
+      else
+      {
+        let sum = 0, x;
+        for (x in index)
+          sum += index[x];
+        index['_total'] = sum;
+        grand += sum;
+      }
+    });
+    this.rows.forEach(r => {
+      if (!data[r.key])
+        data[r.key] = {};
+      const line = data[r.key];
+      let sum = 0, x;
+      if (line)
+        for (x in line)
+          sum += line[x];
+      data[r.key]['_total'] = sum;
+      grand -= sum;
+    });
+    this.totals = {};
+    this.columns.forEach(c => {
+      let sum = 0, key;
+      for (key in data) {
+        const val = data[key][c.key];
+        if (val !== undefined)
+          sum += this._indices.indexOf(key) > -1 ? val : -val;
+      }
+      this.totals[c.key] = sum;
+    });
+    this.totals['_total'] = grand;
+  }
+
+  private _calculatesum(data) {
+    let { xAxis, serie } = this._dsum;
+    if (xAxis) {
+      let total = 0;
+      this.rows.forEach(r => {
+        const row = data[r.key];
+        if (!row)
+          return;
+        let sum = 0, i = 0;
+        while (i < this.columns.length) {
+          let key = this.columns[i].key, val = row[key];
+          if (val !== undefined)
+            sum += val;
+          if (key === xAxis.toString())
+            break;
+          i++;
+        }
+        data[r.key]['_sum'] = sum;
+        total += sum;
+      });
+      this.totals['_sum'] = total;
+    }
+    if (serie) {
+      let total = 0;
+      this.columns.forEach(c => {
+        let sum = 0, i = 0;
+        while (i < this.rows.length) {
+          let key = this.rows[i].key, row = data[key];
+          if (row) {
+            let val = row[c.key];
+            if (val !== undefined)
+              sum += val;
+            if (key === serie.toString())
+              break;
+          }
+          i++;
+        }
+        data['_sum'][c.key] = sum;
+        total += sum;
+      });
+      data['_sum']['_total'] = total;
+    }
+  }
+  private get _dsum(): { xAxis: any; serie: any; } {
+    if (this._evalsum) return this._evalsum;
+    const { xAxis, serie } = this._sum;
+    function translate(axis: string | number) {
+      switch (axis) {
+        case '$month':
+          return 'M' + ('0' + new Date().getMonth().toString()).slice(-2);
+        case '$year':
+          return new Date().getFullYear().toString();
+        case '$quarter':
+          return Math.ceil(new Date().getMonth() / 3).toString();
+        default:
+          return axis;
+      }
+    }
+    return this._evalsum = { xAxis: translate(xAxis), serie: translate(serie) };
+  }
+
+  explore(x: string | number | string[] | number[], serie: string | number | string[] | number[]) {
+    if (!this.interactive) return;
+    if (this._sum) {
+      if (x === '_sum') {
+        x = [] as string[];
+        for (let i = 0; i < this.columns.length; i++) {
+          let key = this.columns[i].key;
+          x.push(key);
+          if (key === this._sum.xAxis.toString())
+            break;
+        }
+      }
+      if (serie === '_sum') {
+        serie = [] as string[];
+        for (let i = 0; i < this.rows.length; i++) {
+          let key = this.rows[i].key;
+          serie.push(key);
+          if (key === this._sum.serie.toString())
+            break;
+        }
+      }
+    }
+    const axes = { ...this.axes } as AxesMap;
+    axes[this.xAxis.name] = x;
+    axes[this.series.name] = serie;
+    this.onExplore.emit(axes);
+  }
+  move(x, y) {
+    let rowIndex = 0;
+    for (let b = 0; b < this.tableElement.nativeElement.tBodies.length; b++) {
+      let tBody = this.tableElement.nativeElement.tBodies.item(b);
+      for (let r = 0; r < tBody.rows.length; r++) {
+        let row = tBody.rows.item(r);
+        for (let c = 0; c < row.cells.length; c++) {
+          let cell = row.cells.item(c);
+          if (c === x)
+            cell.classList.add('cell-x');
+          else
+            cell.classList.remove('cell-x');
+          if (rowIndex === y)
+            cell.classList.add('cell-y');
+          else
+            cell.classList.remove('cell-y');
+        }
+        rowIndex++;
+      }
+      let tFoot = this.tableElement.nativeElement.tFoot, row = tFoot.rows[0];
+      for (let c = 0; c < row.cells.length; c++) {
+        let cell = row.cells.item(c);
+        if (c === x)
+          cell.classList.add('cell-x');
+        else
+          cell.classList.remove('cell-x');
+      }
+    }
+  }
+}
+
+export class CubeInfoCellArgs {
+  private _value: number;
+  get value(): number { return this._value; }
+  private _summary: boolean;
+  get summary(): boolean { return this._summary; }
+  color: string;
+  backgroundColor: string;
+  data: { [row: string]: { [column: string]: number; }; };
+  row: string;
+  column: string;
+}
+
+type SumOptions = {
+  xAxis?: string | number;
+  serie?: string | number;
+  title: any;
+}
+type KeyValue = {
+  key: string;
+  value: any;
+};
+

package/src/lib/cube/pivot/pivot.component.html

@@ -0,0 +1,14 @@
+<!--<ejs-pivotview #pivotview [id]='id' showGroupingBar='false'
+               [dataSourceSettings]=dataSource [width]='width'
+               [height]='height'
+               [showTooltip]='false' [enableValueSorting]='true'
+               [allowExcelExport]='true' [allowPdfExport]='true'
+               spinnerTemplate=""
+  (excelQueryCellInfo)=excelQueryCellInfo($event)
+               [chartSettings]='chartSettings'
+  [gridSettings]='gridSettings'
+  [displayOption]='displayOption'
+               [hyperlinkSettings]='hyperlinkSettings'
+               (hyperlinkCellClick)='cellClick($event)'
+               [currencyCode]=currencyCode>
+</ejs-pivotview>-->