@bizdoc/core 1.13.12 → 1.13.13

package/src/lib/cube/cube.service.ts

@@ -1,483 +0,0 @@
-import { Injectable, Inject } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { Observable, forkJoin, of } from 'rxjs';
-import { shareReplay, tap, map } from 'rxjs/operators';
-import { setCurrencyCode } from '@syncfusion/ej2-base';
-import { isArray, isString } from '../core/functions';
-import { BizDocConfig, BIZDOC_CONFIG, ParamMap, ScopeType } from '../core/configuration';
-import { FieldInfo, AxisType, AxesMap } from '../core/models';
-import { SessionService } from '../core/session.service';
-import { DatasourceService } from '../core/datasource.service';
-import { getCurrencySymbol, getLocaleNumberFormat, NumberFormatStyle } from '@angular/common';
-
-export const ACCOUNT_DELIMITER = '.', DEFAULT_CURRENCY = 'USD';
-
-/** in case xAxis or series is given more than one axis,
- * the value returned is combined of values seperated by this character. */
-export const AXES_CODE_DIVIDER = '__';
-
-export const AXES_LABEL_DIVIDER = '-';
-/** represents a place in pattern to be replaced by base axis. */
-export const AXIS_MAP_CHAR = '#', AXIS_MAP_AS_IS = '*';
-
-export const AXIS_SPECIAL_CHARS = /[\.;#\-,\!]/;
-
-/** allowed characters for axis value / collection / range / pattern. */
-//\pL
-export const AXIS_VALUE_PATTERN = /^((!?\w+(\,\w+)*)|(!?\w+\-\w+)|(!?[\w\.\*\#]+))([;]((!?\w+(\,\w+)*)|(!?\w+\-\w+)|(!?[\w\.\*\#]+)))*$/;
-
-export const CLDR_FILES = ['cldr-data/main/{0}/currencies.json', 'cldr-data/main/{0}/ca-gregorian.json', 'cldr-data/main/{0}/numbers.json', 'cldr-data/main/{0}/timeZoneNames.json', 'cldr-data/supplemental/numberingSystems.json'];
-
-/** query cube */
-@Injectable({ providedIn: 'root' })
-export class CubeService {
-  private readonly _cache: { [name: string]: Observable<any> } = {};
-  // ctor
-  constructor(@Inject(BIZDOC_CONFIG) private _config: BizDocConfig,
-    private _http: HttpClient,
-    private _type: DatasourceService,
-    private _session: SessionService) {
-    _config && _config.currencyCode && setCurrencyCode(_config.currencyCode);
-  }
-  private _cacheOr = <T>(name: string, fn: () => Observable<T>): Observable<T> =>
-    this._cache[name] || (this._cache[name] = fn().pipe(shareReplay()));
-  /** system currency */
-  get numberFormat(): string {
-    return this.currencyCode ?
-      getLocaleNumberFormat(this._session.language, NumberFormatStyle.Currency).
-        replace('¤', getCurrencySymbol(this.currencyCode, 'narrow')) :
-      getLocaleNumberFormat(this._session.language, NumberFormatStyle.Decimal);
-  }
-  get currencyCode(): string {
-    const { currencyCode } = this._config || {};
-    return currencyCode || DEFAULT_CURRENCY;
-  }
-  get digitsInfo(): string {
-    const { fractionDigits } = this;
-    return `1.${fractionDigits}-${fractionDigits}`;
-  }
-  get fractionDigits(): number {
-    const { formats } = this._config, { fractionDigits } = formats || {};
-    return fractionDigits !== undefined ? fractionDigits : 2;
-  }
-  /**
-   * query cube by axes, series and indices
-   * @param cube name
-   * @param xAxis group by one or more axis
-   * @param options
-   */
-  series(cube: string, xAxis: string | string[],
-    options?: {
-      /** group series by one or more axis */
-      series?: string | string[];
-      /** include one or more index serie */
-      indices?: string | string[];
-      groupIndices?: boolean,
-      //indexBy?: 'group' | 'inverse',
-      inverseIndices?: boolean,
-      /** axes */
-      filters?: { [axis: string]: AxisType };
-      scope?: ScopeType,
-      /** replace base */
-      base?: { [axis: string]: (string | number) } | Array<string | number>;
-    }): Observable<Series[]> {
-    if (!options) options = {};
-    const { filters: axes, series, indices, base, scope, groupIndices, inverseIndices } = options, filters = { ...axes };
-    // normalize args
-    base && this.base(cube, filters, base);
-    return this._http.put<Series[]>(`/api/cube/${cube}`, {
-      xAxis,
-      series,
-      indices,
-      filters,
-      scope,
-      groupIndices,
-      inverseIndices
-    }).pipe(this._decorate(cube, isArray(xAxis) ? xAxis : [xAxis],
-      series ? isArray(series) ? series : [series] : null));
-  }
-  /**
-   * aggregate cube to flat collection of columns and value(s)
-   * @param cube name
-   * @param columns
-   * @param options
-   */
-  table(cube: string, columns: string[], options?: {
-    /** axes */
-    filters?: AxesMap;
-    /** include one or more index values */
-    indices?: string | string[];
-    scope?: ScopeType,
-  }): Observable<{ value: number }[]> {
-    if (!options) options = {};
-    const { filters, indices, scope } = options;
-    return this._http.put<{ value: number }[]>(`/api/cube/table/${cube}`, {
-      columns,
-      indices,
-      filters,
-      scope
-    }).pipe(this._decorateTable(cube, columns));
-  }
-  /**
-   * information on expected explore type
-   * @param cube name
-   * @param axes filters
-   * @param options
-   */
-  resolve(cube: string, axes: { [key: string]: AxisType }, options?: {
-    /** replace base */
-    base?: { [axis: string]: (string | number) } | Array<string | number>;
-  }): Observable<ExploreType> {
-    const params = { ...axes } as any;
-    if (options) {
-      const { base } = options;
-      base && this.base(cube, params, base);
-    }
-    return this._http.get<ExploreType>(`/api/cube/exploretype/${cube}`, { params });
-  }
-  /**
-   * information on expected explore type
-   * @param cube name
-   * @param index name
-   */
-  resolveIndex(cube: string, index: string): Observable<ExploreType> {
-    return this._http.get<ExploreType>(`/api/cube/exploreindextype/${cube}/${index}`);
-  }
-  /**
-   * explore items by axis
-   * @param cube name
-   * @param axes filters
-   * @param options
-   */
-  explore(cube: string, axes: { [key: string]: AxisType }, options?: {
-    /** restrict results to user patterns or positions */
-    scope?: ScopeType,
-    /** replace base */
-    base?: { [axis: string]: (string | number) } | Array<string | number>;
-  }): Observable<any[]> {
-    const params = { ...axes } as any;
-    if (options) {
-      const { base, scope } = options;
-      base && this.base(cube, params, base);
-      if (scope) params.scope = scope;
-    }
-    return this._http.get<any[]>(
-      `/api/cube/explore/${cube}`,
-      { params });
-  }
-  /**
-   * 
-   * @param axes
-   * @param cube
-   */
-  nameOf(axes: AxesMap, cube: string) {
-    const options = this._session.profile.cubes.find(c => c.name === cube);
-    const observables = options.axes.filter(a => isString(axes[a.name]) &&
-      // value
-      !AXIS_SPECIAL_CHARS.test(axes[a.name] as string)).map(a =>
-        this._type.get(a.dataType, axes[a.name] as string) || '');
-    return (observables.length ? forkJoin(observables).pipe(map(o => o.join(' '))) : of(''));
-  } 
-  /**
-   * explore indices by axis
-   * @param cube name
-   * @param index name
-   * @param axes filters
-   * @param options
-   */
-  indices(cube: string, index: string, axes: { [axis: string]: AxisType },
-    options?: {
-      /** restrict results to user patterns or positions */
-      scope?: ScopeType
-      base?: { [axis: string]: (string | number) } | Array<string | number>;
-    }): Observable<any[]> {
-    const params = { ...axes } as any;
-    if (options) {
-      const { base, scope } = options;
-      base && this.base(cube, params, base);
-      if (scope) params.scope = scope;
-    }
-    return this._http.get<any[]>(
-      `/api/cube/exploreindex/${cube}/${index}`, { params }).
-      pipe(this._decorateTable(cube));
-  }
-  /**
-   * get explore item by axis and key(s)
-   * @param cube
-   * @param axes
-   * @param keys
-   * @param options
-   */
-  item(cube: string, axes: { [axis: string]: AxisType }, keys: (string | number)[] | string | number, options?: {
-    /** replace base */
-    base?: { [axis: string]: (string | number) } | Array<string | number>;
-  }): Observable<any> {
-    const params = { ...axes } as any;
-    params['key'] = isArray(keys) ? keys[0] : keys;
-    if (options) {
-      const { base } = options;
-      base && this.base(cube, params, base);
-    }
-    return this._http.get(`/api/cube/exploreitem/${cube}`, { params });
-  }
-  /**
-   * 
-   * @param cube name
-   * @param axes condition
-   */
-  constraints(cube: string, axes?: { [key: string]: AxisType }, options?: { source: 'constraints' | 'combinations' }): Observable<{ [dataType: string]: { [key: string]: any } }> {
-    return this._http.get<{ [dataType: string]: { [key: string]: any } }>(
-      !options || options.source === 'constraints' ?
-        `/api/cube/constraints/${cube}` : `/api/cube/combinationsconstraints/${cube}`, {
-      params: { ...axes } as any
-    });
-  }
-  /**
-   * 
-   * @param cube name
-   * @param axis name
-   */
-  values(cube: string, axis: string, dependencies?: ParamMap): Observable<{ [key: string]: any }> {
-    let cacheId = cube + axis;
-    dependencies && Object.keys(dependencies).forEach(k => cacheId += k);
-    return this._cacheOr(cacheId, () => this._http.get<{ [dataType: string]: { [key: string]: any } }>(
-      `/api/cube/segmentvalues/${cube}/${axis}`, { params: dependencies }));
-  }
-  /**
-   * get axis combinations
-   * @param cube name
-   * @param axes filters
-   * @param options
-   */
-  combinations(cube: string, axes?: { [key: string]: AxisType }, options?: {
-    /** top */
-    take?: number;
-    /** process in background */
-    progress?: boolean;
-  }): Observable<string[][]> {
-    if (!options) options = {};
-    const { take, progress } = options;
-    return this._http.get<string[][]>(`/api/cube/combinations/${cube}`, {
-      params: { ...axes, take } as any,
-      headers: progress === false ? { 'no-progress': 'true' } : {}
-    });
-  }
-  /**
-   * 
-   * @param value
-   * @param options
-   */
-  search(value: string, options: { take?: number }) {
-    return this._http.get<{ cube: string, axis: string, key: any, value: any }[]>('/api/cube/search', {
-      params: { value, ...options } as any,
-      headers: { 'no-progress': 'true' }
-    });
-  }
-  /**
-   * get segments
-   * @param cube
-   */
-  segments(cube: string, name: string): Observable<SegmentMap> {
-    return this._cacheOr(`${name}-segments`, () => this._http.get<SegmentMap>(`/api/cube/segments/${cube}/${name}`));
-  }
-  /**
-   * get user patterns
-   * @param cube
-   */
-  patterns(cube: string): Observable<Pattern[]> {
-    return this._cacheOr(`${cube}-patterns`, () => this._http.get<Pattern[]>(`/api/cube/patterns/${cube}`));
-  }
-  /** get currencies */
-  currencies(): Observable<Currency[]> {
-    return this._cacheOr('currencies', () => this._http.get<Currency[]>('api/cube/currencies'));
-  }
-  /**
-   * get exchange rate
-   * @param currencyCode
-   * @param date
-   */
-  exchangeRate(currencyCode: string, date?: Date): Observable<number> {
-    if (this.currencyCode === currencyCode)
-      return of(1);
-    let key = currencyCode;
-    if (date) key += date.toJSON();
-    return this._cacheOr(key, () => this._http.get<number>(`api/cube/exchangeRate/${currencyCode}`, {
-      params: date ? { date: date.toJSON() } : null,
-      headers: { 'no-progress': 'true' }
-    }));
-  }
-  /**
-  * replaces * or # with origin axis at char place
-  * @param cube name
-  * @param axes map
-  * @param base origin
-  */
-  public base(cube: string, axes: AxesMap,
-    base: Array<string | number> | AxesMap): void {
-    const ccube = this._session.profile.cubes.find(c => c.name === cube);
-    ccube.axes.forEach((a, i) => {
-      const val = axes[a.name];
-      if (val && isString(val)) {
-        const axisbase = isArray(base) ? base[i] : base[a.name];
-        if (val === AXIS_MAP_AS_IS)
-          axes[a.name] = axisbase;
-        else if (val.indexOf(AXIS_MAP_CHAR) > -1) {
-          let axis = '';
-          for (let j = 0; j < val.length; j++) {
-            let char = val.charAt(j);
-            axis += char === AXIS_MAP_CHAR && (axisbase as string).length > j ?
-              (axisbase as string).charAt(j) : char;
-          }
-          axes[a.name] = axis;
-        }
-      }
-    });
-  }
-  /**
-   * adds values to source keys
-   * @param cube
-   * @param xAxis
-   * @param series
-   */
-  private _decorate(cube: string,
-    xAxis: string[],
-    series: string[]): (source: Observable<Series[]>) => Observable<Series[]> {
-    return (source: Observable<Series[]>) => new Observable(observe => {
-      source.subscribe(r => {
-        const observables: Observable<any>[] = [];
-        const options = this._session.profile.cubes.find(c => c.name === cube);
-        const axisTypeMap = {};
-        options.axes.forEach(x => axisTypeMap[x.name] = x.dataType);
-        if (!r.length) {
-          observe.next(r);
-          observe.complete();
-          return;
-        }
-        const base = r[0].points;
-        r.forEach((s, i) => {
-          s.points.forEach(p => {
-            if (!p.x) return;
-            const pobservable = forkJoin(p.x.split(AXES_CODE_DIVIDER).map((k, j) =>
-              this._type.get(axisTypeMap[xAxis[j]], k))).
-              pipe(tap(o => p.name = o.join(AXES_LABEL_DIVIDER)));
-            observables.push(pobservable);
-            if (i > 0) {
-              let j = 0, missing = true;
-              while (j < base.length) {
-                let x = base[j].x;
-                if (p.x === x) {
-                  missing = false;
-                  break;
-                }
-                if (p.x < x)
-                  break;
-                j++;
-              }
-              if (missing) {
-                const clone = { x: p.x, y: 0 } as Point;
-                base.splice(j, 0, clone);
-                const cobservable = forkJoin(p.x.split(AXES_CODE_DIVIDER).map((k, j) =>
-                  this._type.get(axisTypeMap[xAxis[j]], k))).
-                  pipe(tap(o => clone.name = o.join(AXES_LABEL_DIVIDER)));
-                observables.push(cobservable);
-              }
-            }
-          });
-          if (s.index) {
-            const index = options.indices.find(i => i.name === s.index);
-            s.title = index.title;
-          }
-          else if (s.name) {
-            const sobservable = forkJoin(s.name.split(AXES_CODE_DIVIDER).map((k, i) =>
-              this._type.get(axisTypeMap[series[i]], k)
-            )).pipe(tap(v => s.title = v.join(AXES_LABEL_DIVIDER)));
-            observables.push(sobservable);
-          }
-        });
-        if (observables.length)
-          forkJoin(observables).subscribe(() => {
-            observe.next(r);
-            observe.complete();
-          }, e => observe.error(e));
-        else {
-          observe.next(r);
-          observe.complete();
-        }
-      }, e => observe.error(e));
-    });
-  }
-  /**
-   * adds values to source keys
-   * @param cube
-   */
-  private _decorateTable<T>(cube: string, columns?: string[]): (source: Observable<T[]>) => Observable<T[]> {
-    const ccube = this._session.profile.cubes.find(c => c.name === cube),
-      axes = ccube.axes.filter(a => !columns || columns.indexOf(a.name) > -1);
-    return (source) => new Observable(observe => {
-      source.subscribe(r => {
-        const observables: Observable<any>[] = [];
-        r.forEach(row =>
-          axes.forEach(a => {
-            const { name, dataType } = a, value = row[name];
-            if (value !== undefined) {
-              // keep key
-              row['_' + name] = value;
-              const observable = this._type.get(dataType, value).pipe(tap(v =>
-                row[name] = v || value));
-              observables.push(observable);
-            }
-          }));
-        if (observables.length)
-          forkJoin(observables).subscribe(() => {
-            observe.next(r);
-            observe.complete();
-          }, e => observe.error(e));
-        else {
-          observe.next([]);
-          observe.complete();
-        }
-      }, e => observe.error(e));
-    });
-  }
-}
-
-export function progress(time = 200): (source: Observable<any>) => Observable<boolean> {
-  return source => source.pipe(
-    tap(),
-    map(() => false))
-}
-/** modelize cube results as nested maps */
-export function modelize(): (source: Observable<Series[]>) => Observable<{
-  [key: string]: { [key: string]: number };
-}> {
-  const data = {};
-  return (source: Observable<Series[]>) => source.pipe(map(r => {
-    r.forEach(s => {
-      const row = data[s.index || s.name] = {};
-      s.points.forEach(p => row[p.x] = p.y);
-    });
-    return data;
-  }));
-}
-
-export interface ExploreType {
-  columns: FieldInfo[];
-  template?: string;
-  fields?: FieldInfo[];
-}
-export interface Series {
-  points: Point[];
-  name?: string;
-  index?: string;
-  title?: string;
-}
-export interface Point {
-  x: string;
-  y: number;
-  name?: string;
-}
-export interface Currency { code: string; name: string; symbol: string }
-
-export type SegmentMap = { [code: string]: string };
-
-export interface Pattern { title: string; axes: AxesMap }

package/src/lib/cube/declarations.ts

@@ -1,24 +0,0 @@
-import { EventEmitter, OnChanges } from '@angular/core';
-import { AxesMap } from '../core/models';
-
-export interface AxisClickEvent {
-  axes: AxesMap;
-  /** index name */
-  index?: string;
-}
-/** */
-export interface CubeViewerComponent extends OnChanges {
-  exportToExcel(title: string);
-  execute();
-  resize();
-  explore?: EventEmitter<AxisClickEvent>;
-  loading: boolean;
-  loadingChange: EventEmitter<boolean>;
-  height: string | number;
-  width?: string | number;
-  cube: string;
-  xAxis: string[] | string;
-  series?: string[] | string;
-  indices?: string[] | string;
-  filters?: AxesMap;
-}

package/src/lib/cube/explore/document-item.component.ts

@@ -1,28 +0,0 @@
-import { Component } from '@angular/core';
-import { DocumentModel } from '../../core/models';
-import { ExploreItemComponent } from '../../core/base';
-import { BizDoc } from '../../core/decorators';
-import { Optional } from '@angular/core';
-import { PaneRef } from '../../core/slots/pane-ref';
-import { ExploreItemPaneComponent } from './item.pane.component';
-import { SessionService } from '../../core/session.service';
-/** preview of cube explore item for form */
-@Component({
-  template: `<bizdoc-document [model]=model></bizdoc-document>`
-})
-@BizDoc({ selector: 'bizdoc-document-info' })
-export
-  class ExploreDocumentComponent implements ExploreItemComponent<DocumentModel<any>> {
-  model: DocumentModel<any>;
-  constructor(@Optional() private _pane: PaneRef<ExploreItemPaneComponent>,
-    private _session: SessionService) {
-  }
-  onBind(data: DocumentModel<any>): void {
-    if (this._pane) {
-      this._pane.title =`#${data.number}`;
-      const form = this._session.profile.forms.find(f => f.name === data.formId);
-      this._pane.icon = form.icon;
-    }
-    this.model = data;
-  }
-}

package/src/lib/cube/explore/explore-item.component.scss

@@ -1,4 +0,0 @@
-:host {
-    padding: 8px;
-    display: block;
-  }

package/src/lib/cube/explore/explore-item.component.ts

@@ -1,23 +0,0 @@
-import { Component, ViewContainerRef, AfterViewInit, Input } from '@angular/core';
-import { ExploreItemComponent } from '../../core/base';
-import { BizDocComponentFactoryResolver } from '../../core/component-factory-resolver';
-
-/** shows an item on explore. */
-@Component({
-  selector: 'bizdoc-cube-item',
-  template: '',
-  styleUrls: ['explore-item.component.scss']
-})
-export class ExploreItemImplComponent implements AfterViewInit {
-  @Input() template: string;
-  @Input() model: any;
-  constructor(private _vc: ViewContainerRef,
-    private _resolver: BizDocComponentFactoryResolver) {
-  }
-  ngAfterViewInit(): void {
-      const factory = this._resolver.resolve(this.template);
-      const cRef = this._vc.createComponent(factory);
-      const view = cRef.instance as ExploreItemComponent<any>;
-      view.onBind(this.model);
-  }
-}

package/src/lib/cube/explore/explore-items.component.html

@@ -1,25 +0,0 @@
-<mat-table matSort [dataSource]="dataSource" @list>
-  <ng-container [matColumnDef]="c.name" *ngFor="let c of columns">
-    <mat-header-cell *matHeaderCellDef mat-sort-header>{{c.label || c.name}}</mat-header-cell>
-    <mat-cell *matCellDef="let element" [class.figure]="c.type === 'Currency'">
-      <ng-container [ngSwitch]="c.type">
-        <ng-container *ngSwitchCase="'Date'">
-          {{element[c.name] | amDateFormat: 'll'}}
-        </ng-container>
-        <ng-container *ngSwitchCase="'Number'">
-          {{element[c.name] | number }}
-        </ng-container>
-        <ng-container *ngSwitchCase="'Currency'">
-          {{element[c.name] | currency : (element.currencyCode || currencyCode) : 'symbol' : CURRENCY_FORMAT }}
-        </ng-container>
-        <mat-checkbox [checked]="element.model[c.name]" disabled="true" *ngSwitchCase="'Boolean'"></mat-checkbox>
-        <ng-container *ngSwitchDefault>
-          {{element[c.name] }}
-        </ng-container>
-      </ng-container>
-    </mat-cell>
-  </ng-container>
-  <mat-header-row *matHeaderRowDef="displayedColumns; sticky: true"></mat-header-row>
-  <mat-row *matRowDef="let element; columns: displayedColumns;" (click)="expand(element)" [class.selectable]="selectable" @item></mat-row>
-</mat-table>
-<mat-paginator #paginator [pageSize]="pageSize" hidePageSize style="display: none"></mat-paginator>

package/src/lib/cube/explore/explore-items.component.scss

@@ -1,7 +0,0 @@
-.selectable {
-  cursor: pointer;
-}
-
-.figure {
-  justify-content: right;
-}