@bizdoc/core 1.14.8 → 1.14.9

package/src/lib/core/none.component.ts

@@ -0,0 +1,28 @@
+import { animate, style, transition, trigger } from "@angular/animations";
+import { Component, Input } from "@angular/core";
+import { isMobile } from "./functions";
+
+const noneAnimation = trigger('none', [
+  transition(':enter',
+    [
+      style({ opacity: 0, transform: 'translateX(10px)' }),
+      animate('400ms ease', style({ opacity: .2, transform: 'translateX(0)' }))
+    ])]);
+
+@Component({
+  selector: 'bizdoc-none',
+  template: `<div class="none" @none>
+  <h4 class="mat-title">{{title|translate}}</h4>
+  <mat-icon class="icon">{{icon}}</mat-icon>
+  <h5 class="mat-body-2" *ngIf='subtitle' [innerHTML]='subtitle|translate|sanitizeHtml'></h5>
+</div>`,
+  styleUrls: ['./none.component.scss'],
+  animations: [noneAnimation]
+})
+export
+  class NoneComponent {
+  readonly isMobile = isMobile();
+  @Input() title: string;
+  @Input() subtitle: string;
+  @Input() icon: string;
+}

package/src/lib/core/pipes/action.pipe.ts

@@ -0,0 +1,18 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { SessionService } from '../session.service';
+import { Action } from '../models';
+@Pipe({ name: 'action' })
+export class ActionPipe implements PipeTransform {
+  transform(value: any, ...args: any[]) {
+    const action = this.map.get(value);
+    if (action) {
+      if (args.length) return action[args[0]] || (args[1] !== false ? action.title : null);
+      return action.title;
+    }
+    return `_${value}`;
+  }
+  private map = new Map<string, Action>();
+  constructor(session: SessionService) {
+    session.profile.actions.forEach(a => this.map.set(a.name, a));
+  }
+}

package/src/lib/core/pipes/calendar.pipe.ts

@@ -0,0 +1,84 @@
+import { ChangeDetectorRef, EventEmitter, Pipe, PipeTransform, NgZone } from '@angular/core';
+import { Subscription } from 'rxjs';
+/// <reference path="./node_modules/dayjs/plugin/calendar.d.ts" />
+import dayjs from 'dayjs';
+
+@Pipe({
+  name: 'amCalendar',
+  pure: false
+})
+export class CalendarPipe implements PipeTransform {
+  private static refs = 0;
+
+  private static timer: number | null = null;
+  private static midnight: EventEmitter<Date> | null = null;
+
+  private midnightSub: Subscription;
+
+  transform(value: any, ...args: any[]) {
+    const [referenceTime, format] = args;
+    return dayjs(value).calendar(referenceTime, format as CalendarSpec);
+  }
+  constructor(private cdRef: ChangeDetectorRef, private ngZone: NgZone) {
+    CalendarPipe.initTimer(ngZone);
+
+    CalendarPipe.refs++;
+    this.midnightSub = CalendarPipe.midnight.subscribe(() => {
+      this.ngZone.run(() => this.cdRef.markForCheck());
+    });
+  }
+  private static initTimer(ngZone: NgZone) {
+    // initialize the timer
+    if (!CalendarPipe.midnight) {
+      CalendarPipe.midnight = new EventEmitter<Date>();
+      if (typeof window !== 'undefined') {
+        const timeToUpdate = getMillisecondsUntilUpdate();
+        CalendarPipe.timer = ngZone.runOutsideAngular(() => {
+          return window.setTimeout(() => {
+            // emit the current date
+            CalendarPipe.midnight.emit(new Date());
+
+            // refresh the timer
+            CalendarPipe.removeTimer();
+            CalendarPipe.initTimer(ngZone);
+          }, timeToUpdate);
+        });
+      }
+    }
+  }
+
+  private static removeTimer() {
+    if (CalendarPipe.timer) {
+      window.clearTimeout(CalendarPipe.timer);
+      CalendarPipe.timer = null;
+      CalendarPipe.midnight = null;
+    }
+  }
+
+  ngOnDestroy(): void {
+    if (CalendarPipe.refs > 0) {
+      CalendarPipe.refs--;
+    }
+
+    if (CalendarPipe.refs === 0) {
+      CalendarPipe.removeTimer();
+    }
+
+    this.midnightSub.unsubscribe();
+  }
+}
+function getMillisecondsUntilUpdate() {
+  const now = dayjs();
+  const tomorrow = dayjs().startOf('day').add(1, 'days');
+  const timeToMidnight = tomorrow.valueOf() - now.valueOf();
+  return timeToMidnight + 1000; // 1 second after midnight
+}
+type CalendarSpecVal = string;
+export interface CalendarSpec {
+  sameDay?: CalendarSpecVal;
+  nextDay?: CalendarSpecVal;
+  lastDay?: CalendarSpecVal;
+  nextWeek?: CalendarSpecVal;
+  lastWeek?: CalendarSpecVal;
+  sameElse?: CalendarSpecVal;
+}

package/src/lib/core/pipes/date-format.pipe.ts

@@ -0,0 +1,12 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import dayjs from 'dayjs';
+import localizedFormat from 'dayjs/plugin/localizedFormat';
+@Pipe({ name: 'amDateFormat' })
+export class DateFormatPipe implements PipeTransform {
+    transform(value: any, ...args: any[]) {
+        return dayjs(value).format(args[0]);
+  }
+  constructor() {
+    dayjs.extend(localizedFormat);
+  }
+}

package/src/lib/core/pipes/daterange.pipe.ts

@@ -0,0 +1,45 @@
+import { Pipe, PipeTransform } from "@angular/core";
+import { TranslateService } from "../translate.service";
+import dayjs from 'dayjs';
+
+@Pipe({ name: 'amMiniAgo' })
+export class AgoPipe implements PipeTransform {
+  transform(value: any, ...args: any[]) {
+    const date = dayjs(value), now = new Date(), seconds = date.diff(now, 's');
+    if (seconds < 60) return this._translate.get('JustNow');
+    if (seconds < 3600) return this._translate.get('MinutesAgo', Math.floor(seconds / 60));
+    if (seconds < 86400) return this._translate.get('HoursAgo', Math.floor(seconds) / 3600);
+    const months = date.diff(now, 'months', true);
+    if (months < 12) return this._translate.get('MonthsAgo', Math.round(months));
+    return this._translate.get('YearsAgo', Math.round(months / 12));
+  }
+  constructor(private _translate: TranslateService) { }
+}
+@Pipe({ name: 'dateRange' })
+export class DateRangePipe implements PipeTransform {
+  transform(value: any, ...args: any[]) {
+    const options = Object.assign({
+      w: 'dddd, ',
+      m: 'MMMM',
+      d: 'Do',
+      y: 'YYYY'
+    }, args[1]),
+      date1 = new Date(value), date2 = new Date(args[0]);
+    if (isNaN(date1.valueOf())) return '';
+    const { w, m, d, y } = options;
+    if (date1.getFullYear() === date2.getFullYear()) {
+      if (date1.getMonth() === date2.getMonth()) {
+        if (date1.getDate() === date2.getDate())
+          return dayjs(date1).format(`${w || ''} ${m} ${d}, ${y}`);
+        else
+          return `${dayjs(date1).format(`${w || ''} ${m} ${d}`)} - ${dayjs(date2).format(`${d}, ${y}`)}`;
+      }
+      else {
+        return `${dayjs(date1).format(`${w || ''} ${m} ${d}`)} - ${dayjs(date2).format(`${m} ${d}, ${y}`)}`;
+      }
+    }
+    else {
+      return `${dayjs(date1).format(`${m} ${d}, ${y}`)} - ${dayjs(date2).format(`${m} ${d}, ${y}`)}`;
+    }
+  }
+}

package/src/lib/core/pipes/difference.pipe.ts

@@ -0,0 +1,9 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import dayjs from 'dayjs';
+
+@Pipe({ name: 'amDifference' })
+export class DifferencePipe implements PipeTransform {
+    transform(value: any, ...args: any[]) {
+        return dayjs(value).diff(args[0], args[1]);
+    }
+}

package/src/lib/core/pipes/duration-format.pipe.ts

@@ -0,0 +1,42 @@
+import { Pipe, PipeTransform } from '@angular/core';
+/// <reference path="./node_modules/dayjs/plugin/duration.d.ts" />
+import dayjs from 'dayjs';
+import duration from 'dayjs/plugin/duration';
+import { TranslateService } from '../translate.service';
+
+@Pipe({ name: 'amDurationFormat' }) export
+    class DurationFormatPipe implements PipeTransform {
+    transform(value: any, ...args: any[]) {
+        const duration = dayjs.duration(value, args[0] || 's');
+        return this._format(duration);
+    }
+    private _format(duration: duration.Duration): string {
+        const parts: string[] = [];
+        let o = duration.months(), d = duration.days(), h = duration.hours(), m = duration.minutes();
+        //if (d && d >= dayjs.relativeTimeThreshold('d')) {
+        //  o++;
+        //  d = 0;
+        //}
+        //if (h && h >= dayjs.relativeTimeThreshold('h')) {
+        //  d++;
+        //  h = 0;
+        //}
+        //if (m && m >= dayjs.relativeTimeThreshold('m')) {
+        //  h++;
+        //  m = 0;
+        //}
+        if (o > 0)
+            parts.push(dayjs.duration({ months: o }).humanize());
+        if (d > 0)
+            parts.push(dayjs.duration({ days: d }).humanize());
+        if (h > 0)
+            parts.push(dayjs.duration({ hours: h }).humanize());
+        if (m > 0)
+            parts.push(dayjs.duration({ minutes: m }).humanize());
+        else if (!h && !d)
+            parts.push(duration.humanize());
+        return this._translate.join(parts, 'NumericJoinAnd');
+    }
+  constructor(private _translate: TranslateService) {
+  }
+}

package/src/lib/core/pipes/duration.pipe.ts

@@ -0,0 +1,13 @@
+import { Pipe, PipeTransform } from '@angular/core';
+/// <reference path="./node_modules/dayjs/plugin/duration.d.ts" />
+import dayjs from 'dayjs';
+
+@Pipe({ name: 'amDuration' }) export
+  class DurationPipe implements PipeTransform {
+  transform(value: any, ...args: any[]) {
+    const duration = dayjs.duration(value, args[0] || 's');
+    return duration.humanize();
+  }
+  constructor() {
+  }
+}

package/src/lib/core/pipes/form.pipe.ts

@@ -0,0 +1,19 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { SessionService } from '../session.service';
+import { Form } from '../models';
+@Pipe({ name: 'form' })
+export class FormPipe implements PipeTransform {
+    transform(value: any, ...args: any[]) {
+        const form = this.map.get(value);
+        if (form) {
+            if (args.length)
+                return form[args[0]] || form.title;
+            return form.title;
+        }
+        return `_${value}`;
+    }
+    private map = new Map<string, Form>();
+    constructor(session: SessionService) {
+        session.profile.forms.forEach(f => this.map.set(f.name, f));
+    }
+}

package/src/lib/core/pipes/join.pipe.ts

@@ -0,0 +1,10 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { TranslateService } from '../translate.service';
+@Pipe({ name: 'join' })
+export class JoinPipe implements PipeTransform {
+  transform(value: any, ...args: any[]) {
+    return this._translate.join(value);
+  }
+  constructor(private _translate: TranslateService) {
+  }
+}

package/src/lib/core/pipes/role.pipe.ts

@@ -0,0 +1,19 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { SessionService } from '../session.service';
+import { Action } from '../models';
+@Pipe({ name: 'role' })
+export class RolePipe implements PipeTransform {
+    transform(value: any, ...args: any[]) {
+        const role = this.map.get(value);
+        if (role) {
+            if (args.length)
+                return role[args[0]] || role.title;
+            return role.title;
+        }
+        return `_${value}`;
+    }
+    private map = new Map<string, Action>();
+    constructor(session: SessionService) {
+        session.profile.roles.forEach(a => this.map.set(a.name, a));
+    }
+}

package/src/lib/core/pipes/sanitize-html.pipe.ts

@@ -0,0 +1,10 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+@Pipe({ name: 'sanitizeHtml' })
+export class SanitizeHtmlPipe implements PipeTransform {
+  constructor(private _sanitizer: DomSanitizer) { }
+
+  transform(value: string): SafeHtml {
+    return value ? this._sanitizer.bypassSecurityTrustHtml(value) : '';
+  }
+}

package/src/lib/core/pipes/sort.pipe.ts

@@ -0,0 +1,34 @@
+import { Pipe, PipeTransform } from '@angular/core';
+@Pipe({
+  name: "sort"
+})
+export class ArraySortPipe implements PipeTransform {
+  transform(array: any, field: string, order: 'asc' | 'desc' = 'asc'): any[] {
+    if (!Array.isArray(array)) {
+      return;
+    }
+    array.sort((a: any, b: any) => {
+      if (a[field] < b[field]) {
+        return order === 'asc' ? -1 : 1;
+      } else if (a[field] > b[field]) {
+        return order === 'asc' ? 1 : -1;
+      } else {
+        return 0;
+      }
+    });
+    return array;
+  }
+}
+@Pipe({
+  name: "filter"
+})
+export class FilterPipe implements PipeTransform {
+  transform(array: any, field: string, value: string): any[] {
+    if (!Array.isArray(array)) 
+      return;
+    if (!value)
+      return array;
+    value = value.trim().toLowerCase();
+    return array.filter(i => (i[field] as string).toLowerCase().indexOf(value) > -1);
+  }
+}

package/src/lib/core/pipes/state.pipe.ts

@@ -0,0 +1,19 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { SessionService } from '../session.service';
+import { State } from '../models';
+@Pipe({ name: 'state' })
+export class StatePipe implements PipeTransform {
+    transform(value: string, ...args: any[]) {
+        const state = this._map.get(value);
+        if (state) {
+            if (args.length)
+                return state[args[0]] || state.title;
+            return state.title;
+        }
+        return `_${value}`;
+    }
+  private _map = new Map<string, State>();
+    constructor(session: SessionService) {
+        session.profile.states.forEach(s => this._map.set(s.name, s));
+    }
+}

package/src/lib/core/pipes/time-ago.pipe.ts

@@ -0,0 +1,59 @@
+import { ChangeDetectorRef, NgZone, Pipe, PipeTransform } from '@angular/core';
+/// <reference path="./node_modules/dayjs/plugin/relativeTime.d.ts" />
+import dayjs from 'dayjs';
+
+@Pipe({
+  name: 'amTimeAgo',
+  pure: false
+})
+export class TimeAgoPipe implements PipeTransform {
+  private currentTimer: number;
+  lastTime: dayjs.Dayjs;
+  transform(value: any, ...args: any[]) {
+    this.lastTime = dayjs(value);
+    this.createTimer();
+    return this.lastTime.fromNow();
+  }
+  constructor(private cdRef: ChangeDetectorRef, private ngZone: NgZone) {
+  }
+  ngOnDestroy(): void {
+    this.removeTimer();
+  }
+  private createTimer() {
+    if (this.currentTimer) {
+      return;
+    }
+
+    const timeToUpdate = getSecondsUntilUpdate(this.lastTime) * 1000;
+
+    this.currentTimer = this.ngZone.runOutsideAngular(() => {
+      if (typeof window !== 'undefined') {
+        return window.setTimeout(() => {
+          this.currentTimer = null;
+          this.ngZone.run(() => this.cdRef.markForCheck());
+        }, timeToUpdate);
+      } else {
+        return null;
+      }
+    });
+  }
+
+  private removeTimer() {
+    if (this.currentTimer) {
+      window.clearTimeout(this.currentTimer);
+      this.currentTimer = null;
+    }
+  }
+}
+function getSecondsUntilUpdate(time: dayjs.Dayjs) {
+  const howOld = Math.abs(time.diff(new Date(), 'minute'));
+  if (howOld < 1) {
+    return 1;
+  } else if (howOld < 60) {
+    return 30;
+  } else if (howOld < 180) {
+    return 300;
+  } else {
+    return 3600;
+  }
+}

package/src/lib/core/pipes/translate.pipe.ts

@@ -0,0 +1,22 @@
+import { Directive, ElementRef, Input, OnInit, Pipe, PipeTransform } from '@angular/core';
+import { TranslateService } from '../translate.service';
+@Pipe({ name: 'translate' })
+export class TranslatePipe implements PipeTransform {
+  transform(value: any, ...args: any[]) {
+    let str = this.translate.get(value);
+    if (args.length)
+      for (let i = 0; i < args.length; i++) {
+        str = str.replace(`{${i}}`, args[i]);
+      }
+    return str;
+  }
+  constructor(private translate: TranslateService) { }
+}
+
+@Directive({ selector: '[i18n]' })
+export class TranslateDirective implements OnInit {
+  constructor(private _elementRef: ElementRef<HTMLElement>, private _translate: TranslateService) { }
+  ngOnInit(): void {
+    this._elementRef.nativeElement.innerHTML = this._translate.get(this._elementRef.nativeElement.innerText);
+  }
+}

package/src/lib/core/pipes/type-value.pipe.ts

@@ -0,0 +1,37 @@
+import { PipeTransform, Pipe } from '@angular/core';
+import { DatasourceService } from '../datasource.service';
+import { isArray, isObject } from '../functions';
+import { BehaviorSubject, forkJoin, map } from 'rxjs';
+import { TranslateService } from '../translate.service';
+
+@Pipe({
+  name: 'typeValue',
+})
+export class TypeValuePipe implements PipeTransform {
+  transform(value: any, ...args: any[]) {
+    const subject = new BehaviorSubject(value);
+    if (isArray(value)) {
+      forkJoin(value.map(k => this._get(args[0], k, args[1]))).subscribe(v =>
+        subject.next(v.join(this._translate.comma))
+      );
+    }
+    else
+      this._get(args[0], value, args[1]).subscribe(v => subject.next(v));
+    return subject;
+  }
+  private _get(type: string, key: any, field?: string) {
+    return this._ds.get(type, key).pipe(map(v => {
+      if (isObject(v)) {
+        if (!field) field = Object.keys(v)[0];
+        return v[field];
+      }
+      else return v;
+    }));
+  }
+  /** type-value ctor */
+  constructor(
+    private _translate: TranslateService,
+    private _ds: DatasourceService) {
+
+  }
+}

package/src/lib/core/pipes/user-name.pipe.ts

@@ -0,0 +1,14 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { AccountService } from '../account.service';
+@Pipe({ name: 'userName' })
+export class UserNamePipe implements PipeTransform {
+  transform(value: any) {
+    const subject = new BehaviorSubject(null);
+    this._accounts.get(value).subscribe(u =>
+      subject.next(u.name));
+    return subject;
+  }
+  constructor(private _accounts: AccountService) {
+  }
+}