@bizdoc/core 1.8.5 → 1.8.9

package/src/lib/views/cube/sum.component.ts

@@ -0,0 +1,433 @@
+import { Component } from "@angular/core";
+import { DocumentViewComponent } from "../../core/base";
+import { BizDoc } from "../../core/decorators";
+import { SessionService } from "../../core/session.service";
+import { RouterImpl } from "../../core/router";
+import { CubeService, Point, ScopeType, Series } from "../../cube/cube.service";
+import { DocumentViewRef } from "../document-view-ref";
+import { CubeBase } from "./cube-base";
+import { DatasourceService } from "../../core/datasource.service";
+import { AxesMap, AxisType, CubeAxis, DocumentModel, Form } from "../../core/models";
+import { isArray } from "../../core/functions";
+import { animate, style, transition, trigger } from "@angular/animations";
+
+@Component({
+  templateUrl: 'sum.component.html',
+  styleUrls: ['sum.component.scss'],
+  host: { class: 'view' },
+  animations: [trigger('bar', [
+    transition('*<=>*', [style({
+      flexBasis: '{{startWidth}}%'
+    }), animate('500ms ease')], { params: { startWidth: 100 } }),
+  ])]
+})
+@BizDoc({
+  selector: 'bizdoc-cube-sum'
+})
+export class CubeDocumentSumComponent extends CubeBase<Options> implements DocumentViewComponent {
+  next: Level;
+  current: Level;
+  prev: Level;
+  help: string;
+  readonly Math = Math;
+  currencyCode: string;
+  digitsInfo: string;
+  indices: string[];
+  primaryAxis: CubeAxis;
+  parentAxis: CubeAxis;
+  form: Form;
+  selectedAxis: string | number;
+  back = true;
+  forward = false;
+  private _results: Series[];
+  private _scoperesults: Series[];
+  private _scope: string;
+  constructor(
+    viewRef: DocumentViewRef<Options>,
+    private _router: RouterImpl,
+    private _ds: DatasourceService,
+    service: CubeService,
+    session: SessionService) {
+    super(viewRef, service, session);
+  }
+  async onViewBind() {
+    const { xAxis, indices, parentAxis, periodPolicy } = this._viewRef.options;
+    if (!xAxis) throw 'sum view reqires xAxis';
+    this.primaryAxis = this.cube.axes.find(a => a.name === xAxis);
+    //this.form = this._session.profile.forms.find(f => f.name === this.model.formId);
+    if (parentAxis) this.parentAxis = this.cube.axes.find(a => a.name === parentAxis);
+    this.indices = indices ? isArray(indices) ? indices : [indices] : this.cube.indices.map(i => i.name);
+    this.currencyCode = this.cube.currencyCode;
+    this.digitsInfo = this._service.digitsInfo;
+    const originalValue = this.originalAxes[xAxis];
+    if (isArray(originalValue))
+      this.selectedAxis = originalValue[0];
+    const axis = isArray(originalValue) ? originalValue[0] : originalValue;
+    if (periodPolicy && periodPolicy.toLowerCase() === 'strict')
+      await this._strict(axis);
+    else
+      await this._fish(axis);
+  }
+  private async _strict(axis: AxisType) {
+    const keys = await this._ds.keys(this.primaryAxis.dataType).toPromise(),
+      keyIndex = keys.indexOf(axis as string);
+
+    const filters = { ...this.axes };
+    const axes = [axis];
+    if (keyIndex > 0) axes.push(keys[keyIndex - 1]);
+    if (keyIndex === keys.length - 1) axes.push(keys[keyIndex + 1]);
+    filters[this.primaryAxis.name] = axis;
+    const results = await this._service.series(this.cube.name, this.primaryAxis.name, {
+      indices: this.indices,
+      filters
+    }).toPromise();
+    function fill(serie: Series, point: Point) {
+      if (serie.index)
+        this.current.indices.push({ name: serie.index, title: serie.title, value: point.y });
+      else
+        this.current = { axis: point.x, name: axis, value: point.y, indices: [] } as any;
+    }
+    for (var i = 0; i < results.length; i++) {
+      const { index, title, points } = results[i];
+      for (var j = 0; j < points.length; j++) {
+        let point = points[j], { x, y, name: axis } = point;
+        if (x === axis) {
+          if (index)
+            this.current.indices.push({ name: index, title, value: y });
+          else
+            this.current = { axis: x, name: axis, value: y, indices: [] } as any;
+        }
+        else if (x === keys[keyIndex - 1]) {
+          if (!this.prev) this.prev = { axis: x, name: axis, value: 0, indices: [] } as any;
+          if (index)
+            this.prev.indices.push({ name: index, title, value: y });
+          else
+            this.prev.value = y;
+        }
+        else if (x === keys[keyIndex + 1]) {
+          if (!this.next) this.next = { axis: x, name: axis, value: 0, indices: [] } as any;
+          if (index)
+            this.next.indices.push({ name: index, title, value: y });
+          else
+            this.next.value = y;
+        }
+      }
+    }
+    const parallel = async (direction: 1 | -1) => {
+      const parentKey = this.originalAxes[this.parentAxis.name];
+      const parentKeys = await this._ds.keys(this.parentAxis.dataType).toPromise();
+      const index = parentKeys.indexOf((isArray(parentKey) ? parentKey[0] : parentKey) as string),
+        scope = parentKeys[index + direction];
+      if (!scope) return;
+      filters[this.parentAxis.name] = scope;
+      const axis = keys[keys.length + direction];
+      filters[this.primaryAxis.name] = axis;
+      const results = await this._service.series(this.cube.name, this.primaryAxis.name, {
+        indices: this.indices,
+        filters
+      }).toPromise();
+
+      const level: Level = { axis, indices: [], scope } as any;
+      for (var i = 0; i < results.length; i++) {
+        const { index, title, points } = results[i];
+        if (!points.length) continue;
+        const [point] = points;
+        if (index === 'Index')
+          level.indices.push({ name: index, title, value: point.y });
+        else
+          level.title = point.name, level.value = point.y;
+      }
+      return level;
+    };
+    if (keyIndex === 0 && this.parentAxis)
+      this.prev = await parallel(-1);
+    else if (keyIndex === keys.length - 1)
+      this.next = await parallel(1);
+  }
+  private async _fish(axis: AxisType) {
+    this.loading = true;
+    try {
+      const { xAxis, parentAxis } = this._viewRef.options;
+      const filters = { ...this.axes };
+      delete filters[xAxis];
+      const results = this._results = await this._service.series(this.cube.name, xAxis, {
+        indices: this.indices, filters
+      }).
+        toPromise();
+      this.current = {
+        axis,
+        value: 0,
+        indices: []
+      } as Level;
+      for (var j = 0; j < results.length; j++) {
+        let { points, index, name, title } = results[j];
+        for (let i = 0; i < points.length; i++) {
+          let point = points[i];
+          if (point.x === axis) {
+            if (index)
+              this.current.indices.push({ name: index, title, value: point.y });
+            else
+              this.current.title = point.name,
+                this.current.value = point.y;
+            if (i > 0) {
+              point = points[i - 1];
+              if (!this.prev)
+                this.prev = {
+                  axis: point.x,
+                  title: point.name,
+                  value: point.y,
+                  indices: []
+                } as Level;
+              if (index) {
+                let q = i;
+                while (q > 0 && point.x !== this.prev.axis)
+                  point = points[q--];
+
+                q > 0 &&
+                  this.prev.indices.push({
+                    name: index, title, value: point.y
+                  });
+              }
+            }
+            if (i < points.length - 1) {
+              point = points[i + 1];
+              if (!this.next)
+                this.next = {
+                  axis: point.x,
+                  title: point.name,
+                  value: 0,
+                  indices: []
+                } as Level;
+              if (index) {
+                let q = i;
+                while (q < points.length - 1 && point.x !== this.next.axis)
+                  point = points[q++];
+                q < points.length - 1 && this.next.indices.push({
+                  name: index, title, value: point.y
+                });
+              }
+              else
+                this.current.value = point.y;
+            }
+            break;
+          }
+          else if (this.next && point.x == this.next.axis)
+            this.next.indices.push({ name, title, value: point.y });
+          else if (this.prev && point.x == this.prev.axis)
+            this.prev.indices.push({ name, title, value: point.y });
+        }
+      }
+      this._calculate(this.current);
+      this.current.chain = this.prev;
+      this.help = await super.getAggregateLabel();
+      if (!this.prev)
+        this.prev = await this._parallel(-1, this.originalAxes[parentAxis]);
+      if (!this.next)
+        this.next = await this._parallel(1, this.originalAxes[parentAxis]);
+      this.next && this._calculate(this.next);
+      this.prev && this._calculate(this.prev);
+    } catch (e) {
+      throw e;
+    }
+    finally {
+      this.loading = false;
+    }
+  }
+  private _calculate(level: Level) {
+    const indices = level.indices
+      .filter(i => this.cube.indices.find(m => m.name === i.name && m.accumulate !== false))
+      .sum(i => i.value);
+    const percent = indices !== 0 ?
+      Math.round(level.value / indices * 100) : 0;
+    level.percent = percent;
+    level.animation = {
+      value: percent,
+      params: {
+        startWidth:
+          percent < 100 ?
+            100 :
+            100
+      }
+    }
+  }
+  async goprev() {
+    let alternate: Level;
+    if (!this.prev.scope)
+      alternate = this._seek(this.prev.axis, this._results, -1);
+    if (!alternate) {
+      if (this._scope === this.prev.scope)
+        alternate = this._seek(this.prev.axis, this._scoperesults, -1);
+      if (!alternate)
+        alternate = await this._parallel(-1, this.prev.scope);
+    }
+    if (alternate) {
+      this._calculate(alternate);
+      alternate.animation.params.startWidth = this.prev.percent;
+      this.prev = alternate;
+      this.forward = true;
+    }
+    else
+      this.back = false;
+  }
+  private _seek(axis: string, results: Series[], direction: 1 | -1) {
+    let level: Level;
+    for (var i = 0; i < results.length; i++) {
+      let { index, points, title } = results[i],
+        j = 0;
+      while (j < points.length - 1) {
+        let point = points[j];
+        if (point.x === axis) {
+          if ((direction > 0 && j === points.length - 1) || (direction < 0 && j === 0))
+            break;
+          point = points[j + direction];
+          if (!level) level = {
+            axis: point.x,
+            title: point.name,
+            indices: []
+          } as Level;
+          if (index) {
+            let q = j;
+            while (point && point.x !== level.axis)
+              point = points[q += direction];
+            point && level.indices.push({ name: index, title, value: point.y });
+            if (level.value === undefined) level.value = 0;
+          }
+          else
+            level.value = point.y;
+          if (direction > 0 && j < points.length - 2 && points[j + 2].x !== this.current.axis)
+            this.forward = true;
+          break;
+        }
+        else if (index && level && level.axis === point.x)
+          level.indices.push({ name: index, title, value: point.y });
+        j++;
+      }
+    }
+    return level;
+  }
+  async gonext() {
+    let alternate: Level;
+    this.forward = false;
+    if (this.prev.scope)
+      alternate = this._seek(this.prev.axis, this._scoperesults, 1);
+    if (!alternate)
+      alternate = this._seek(this.prev.axis, this._results, 1);
+    if (alternate) {
+      this._calculate(alternate);
+      alternate.animation.params.startWidth = this.prev.percent;
+      this.prev = alternate;
+      this.back = true;
+    }
+    else
+      this.forward = false;
+  }
+  async switchAxis(value: string | number) {
+    const axes = {};
+    axes[this.primaryAxis.name] = value;
+    super.switchAxes(axes);
+    await this._fish(value);
+    this.selectedAxis = value;
+  }
+  /**
+   * 
+   * @param level
+   * @param index
+   */
+  explore(level: Level, index?: string) {
+    if ((!index && level.value === 0) ||
+      (index && level.indices.find(i => i.name === index).value === 0)) return;
+    const { xAxis, parentAxis } = this._viewRef.options;
+    const queryParams = { ...this.axes };
+    queryParams[xAxis] = level.axis;
+    if (level.scope)
+      queryParams[parentAxis] = level.scope;
+
+    this._router.navigate(['cube', this.cube.name, 'explore'], {
+      group: `#${this.model.number}`,
+      queryParams,
+      state: {
+        index
+      }
+    })
+  }
+  private async _parallel(direction: 1 | -1, parentKey: AxisType) {
+    const { xAxis, parentAxis } = this._viewRef.options;
+    if (!parentAxis) return;
+    const parentKeys = await this._ds.keys(this.parentAxis.dataType).toPromise();
+    const
+      keyIndex = parentKeys.indexOf((isArray(parentKey) ? parentKey[0] : parentKey) as string),
+      scope = parentKeys[keyIndex + direction];
+    if (!scope)
+      return;
+    const filters = { ...this.axes } as AxesMap;
+    filters[parentAxis] = scope;
+    delete filters[xAxis];
+    const results = this._scoperesults = await this._service.series(this.cube.name, xAxis, {
+      indices: this.indices, filters
+    }).toPromise();
+    this._scope = scope;
+    if (!results.some(s => s.points.length)) return;
+    const level: Level = {
+      scope,
+      indices: []
+    } as any;
+    const parentTitle = await this._ds.get(this.parentAxis.dataType, scope).toPromise();
+    for (var j = 0; j < results.length; j++) {
+      let { index, title, points, name } = results[j],
+        q = direction > 0 ? 0 : points.length - 1,
+        point = points[q];
+      if (index) {
+        if (level.value === undefined) {
+          level.value = 0,
+            level.title = `${point.name} ${parentTitle}`;
+          level.indices.push({ name: index, title, value: point.y });
+        }
+        else {
+          if (direction > 0) {
+            while (q > 0 && point.x !== level.axis)
+              point = points[q--];
+            q > 0 && level.indices.push({ name, title, value: point.y });
+          }
+          else {
+            while (q < points.length - 1 && point.x !== level.axis)
+              point = points[q++];
+            q < points.length - 1 && level.indices.push({ name, title, value: point.y });
+          }
+        }
+      }
+      else
+        level.axis = point.x,
+          level.value = point.y,
+          level.title = `${point.name} ${parentTitle}`;
+    }
+    return level;
+  }
+}
+declare type Level = {
+  indices: {
+    name: string;
+    title: string;
+    value: number;
+  }[],
+  value: number,
+  title: string,
+  axis: string
+  /** parent axis */
+  scope?: string,
+  animation: {
+    value: number,
+    params: {
+      startWidth: number
+    }
+  };
+  chain?: Level;
+  percent: number;
+};
+export interface Options {
+  indices: string[] | string;
+  aggregate: string[];
+  xAxis: string;
+  parentAxis?: string;
+  periodPolicy?: 'strict' | null;
+  scope?: ScopeType;
+}

package/src/lib/views/cube/view.component.html

@@ -0,0 +1,34 @@
+<ng-container *ngIf="hasdata; else none">
+  <div class="row toolbar">
+    <button mat-icon-button (click)="guide()" [matTooltip]="'Help' | translate" *ngIf="view.guide"><mat-icon>help_outline</mat-icon></button>
+    <ng-container *ngIf="alternate">
+      <button mat-button [matMenuTriggerFor]="cmenu">{{cube.title}} <mat-icon>arrow_drop_down</mat-icon></button>
+      <mat-menu #cmenu>
+        <button mat-menu-item *ngFor="let a of alternate"
+                (click)="switchTo(a)">
+          {{a.title}}
+        </button>
+      </mat-menu>
+    </ng-container>
+    <span class="divider"></span>
+    <button mat-icon-button [matMenuTriggerFor]="pmenu" [matTooltip]="'Patterns' | translate" [disabled]="!patterns?.length" data-help="pattern"><mat-icon [class.filled]="pattern">filter_alt</mat-icon></button>
+    <mat-menu #pmenu>
+      <button mat-menu-item *ngFor="let p of patterns" (click)="patternChange(p)">
+        {{p.title}}
+      </button>
+    </mat-menu>
+    <button mat-icon-button (click)="clearFilter()" [matTooltip]="'Clear' | translate" [disabled]="!anyFilters"><mat-icon>clear_all</mat-icon></button>
+    <button mat-icon-button (click)="filterToggle($event)" [matTooltip]="'Filter' | translate" [disabled]="!anyAxes" data-help="filter"><mat-icon>filter_list</mat-icon></button>
+  </div>
+  <div class="loading-view" *ngIf="loading">
+    <mat-spinner color="accent"></mat-spinner>
+  </div>
+  <bizdoc-cube-view [axes]="axes" #vp
+                    (explore)="explore($event)"
+                    [cube]="cube"
+                    [view]="view"
+                    (loading)="loading = $event"></bizdoc-cube-view>
+</ng-container>
+<ng-template #none>
+  <bizdoc-none icon="equalizer" subtitle="NothingHere"></bizdoc-none>
+</ng-template>

package/src/lib/views/cube/view.component.scss

@@ -0,0 +1,12 @@
+:host {
+  display: flex;
+  -ms-flex-direction: column;
+  -webkit-flex-direction: column;
+  flex-direction: column;
+  height: 100%;
+  min-height: 220px;
+}
+
+:host ::ng-deep .cube-view {
+  flex: 1 auto;
+}

package/src/lib/views/cube/view.component.ts

@@ -0,0 +1,102 @@
+import { Component, OnInit, ViewChild } from '@angular/core';
+import { takeUntil } from 'rxjs/operators';
+import { BizDoc } from '../../core/decorators';
+import { GuideService } from '../../core/guide/guide.service';
+import { CubeView } from '../../core/models';
+import { Popup } from '../../core/popup/popup.service';
+import { RouterImpl } from '../../core/router';
+import { SessionService } from '../../core/session.service';
+import { CubeViewComponent } from '../../cube/cube-view.component';
+import { CubeService, Pattern } from '../../cube/cube.service';
+import { AxisClickEvent } from '../../cube/declarations';
+import { CubeFilterComponent } from '../../cube/filter/filter.component';
+import { DocumentViewRef } from '../document-view-ref';
+import { CubeBase } from './cube-base';
+
+@Component({
+  templateUrl: './view.component.html',
+  styleUrls: ['./view.component.scss']
+})
+@BizDoc({
+  selector: 'bizdoc-cube-view'
+})
+export
+  class CubeDocumentViewComponent extends CubeBase<Options> implements OnInit {
+  @ViewChild(CubeViewComponent) viewPane: CubeViewComponent;
+  view: CubeView;
+  anyAxes: boolean;
+  constructor(session: SessionService,
+    viewRef: DocumentViewRef<Options>,
+    service: CubeService,
+    private _popup: Popup,
+    private _router: RouterImpl,
+    private _guide: GuideService) {
+    super(viewRef, service, session, true);
+  }
+  onViewBind() {
+    const { view } = this._viewRef.options;
+
+    this.view = this.cube.views.find(v => v.name === view) || this.cube.views[0];
+
+    this._service.patterns(this.cube.name).subscribe(p => this.patterns = p);
+
+    const keys = Object.keys(this.axes);
+
+    this.anyAxes = this.cube.axes.some(a => keys.indexOf(a.name) < 0 && !a.hidden && a.selectionMode !== 'None');
+  }
+  ngOnInit(): void {
+    this._viewRef.resize.subscribe(() => this.viewPane && this.viewPane.resize());
+  }
+  filterToggle(evt: Event) {
+    const popupRef = this._popup.open(CubeFilterComponent, evt.currentTarget as HTMLElement);
+    popupRef.opened.
+      subscribe(e => {
+        e.cube = this.cube.name;
+        e.axes = this.axes;
+        e.exclude = [...this.view.xAxis, ...this.view.series];
+        e.include = this._viewRef.options.filters;
+        e.axesChange.pipe(takeUntil(popupRef.closed)).subscribe(axes => {
+          this.axes = axes
+          this.anyFilters = true;
+        });
+      });
+  }
+  /**
+   *
+   * @param evt
+   */
+  explore(evt: AxisClickEvent) {
+    const { axes, index } = evt;
+    this._router.navigate(['cube', this.cube.name, 'explore'],
+      {
+        queryParams: axes,
+        state: { index }
+      });
+  }
+  patternChange(pattern: Pattern) {
+    this.pattern = pattern;
+    const axes = {
+      ...pattern.axes
+    };
+    this._service.base(this.cube.name, axes, this.originalAxes);
+    this.anyFilters = true;
+    this.axes = axes;
+  }
+  clearFilter() {
+    this.axes = this.aggregate(this.originalAxes);
+    this.anyFilters = false;
+    this.pattern = null;
+  }
+  guide(evt?: Event) {
+    if (this.view.guide) {
+      this._guide.start(this.view.guide);
+      evt && evt.preventDefault();
+    }
+  }
+}
+
+interface Options {
+  view: string;
+  aggregate?: string[];
+  filters?: string[];
+}

package/src/lib/views/document-view-ref.ts

@@ -0,0 +1,34 @@
+import { HttpClient } from "@angular/common/http";
+import { BehaviorSubject, Observable } from "rxjs";
+import { Dimentions, DocumentModel, View } from "../core/models";
+
+export class DocumentViewRef<O = any, A = any, R = any> {
+  hidden: boolean;
+  public get model(): DocumentModel {
+    return this._model;
+  }
+
+  _resize: BehaviorSubject<Dimentions>;
+  constructor(
+    private _http: HttpClient,
+    private _model: DocumentModel,
+    private _view: View,
+    dim: Dimentions) {
+    this._resize = new BehaviorSubject(dim);
+  }
+  populate(params: A) {
+    return this._http.get<R>('/api/view/' + this._view.name, { params: params as any });
+  }
+  get options(): O {
+    return this._view.options || {};
+  }
+  get name(): string {
+    return this._view.name;
+  }
+  get resize(): Observable<Dimentions> { return this._resize.asObservable(); }
+  get dimentions(): Dimentions { return this._resize.value; }
+  _destroy() {
+    this._resize.complete();
+  }
+
+}