@elderbyte/ngx-starter 14.11.0 → 14.11.1

package/src/lib/common/http/transfer/http-data-transfer.ts

@@ -0,0 +1,276 @@
+import {BehaviorSubject, Observable, of, Subject} from 'rxjs';
+import {HttpEvent, HttpEventType, HttpProgressEvent, HttpResponse, HttpSentEvent} from '@angular/common/http';
+import {catchError, filter, first, map, takeUntil, tap} from 'rxjs/operators';
+import {DataTransferProgress} from './data-transfer-progress';
+import {DataTransferState} from './data-transfer-state';
+import {LoggerFactory} from '@elderbyte/ts-logger';
+
+
+
+/**
+ * Represents a Http data transfer, either a download or upload.
+ */
+export class HttpDataTransfer {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private logger = LoggerFactory.getLogger('HttpDataTransfer');
+
+  private readonly _state: BehaviorSubject<DataTransferState>;
+
+  private readonly _httpRequest: Observable<HttpEvent<any>>;
+  private readonly abort$ = new Subject<void>();
+
+  private readonly _name: string;
+
+  private _startTimeMs: number;
+  private _endTimeMs: number;
+  private _currTimeMs: number;
+  private _prevTimeMs: number;
+  private _oldBytes = 0;
+
+
+  /***************************************************************************
+   *                                                                         *
+   * Static Builder                                                          *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Creates a new HttpDataTransfer from a HttpClient HttpRequest.
+   * @param httpRequest
+   * @param name Name of this transfer
+   * @param totalBytes The total expected bytes
+   */
+  public static fromRequest(
+    httpRequest: Observable<HttpEvent<any>>,
+    name?: string,
+    totalBytes?: number
+  ): HttpDataTransfer {
+    return new HttpDataTransfer(httpRequest, name, totalBytes);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Creates a new HttpDataTransfer
+   * @param httpRequest The http request.
+   * @param name The name of this transfer (usually the file name)
+   * @param totalBytes The total bytes of the transfer. (If not set, will be auto discovered if possible)
+   */
+  private constructor(
+    httpRequest: Observable<HttpEvent<any>>,
+    name?: string,
+    totalBytes?: number
+  ) {
+    this._name = name;
+    this._httpRequest = httpRequest;
+    this._state = new BehaviorSubject(DataTransferState.pending(totalBytes));
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Starts the data transfer
+   */
+  public start(): Observable<HttpEvent<any>> {
+    return this._httpRequest.pipe(
+      takeUntil(this.abort$),
+      tap(event => {
+
+          switch (event.type) {
+
+            case HttpEventType.Sent:
+              this.onStart(event);
+              break;
+            case HttpEventType.UploadProgress:
+            case HttpEventType.DownloadProgress:
+              this.onProgress(event);
+              break;
+            case HttpEventType.Response:
+              this.onComplete(event);
+              break;
+          }
+        },
+        err => this.onError(err),
+        () => this.finally()
+      ),
+      catchError(err => {
+        return of(err);
+      })
+    );
+  }
+
+  /**
+   * Aborts the data transfer
+   */
+  public abort(): void {
+    this.abort$.next();
+    this.emitState(
+      DataTransferState.aborted(this.stateSnapshot.progress)
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Awaits until this transfer is done and closes the observable.
+   *
+   * If successful, emits true. Observable is closed.
+   * If aborted, emits false. Observable is closed.
+   * If failed, throws error. Observable is closed.
+   */
+  public get done$(): Observable<boolean> {
+    return this.state$.pipe(
+      filter(state => state.isDone),
+      map(state => {
+        if (state.isCompleted) { return true; }
+        if (state.isAborted) { return false; }
+
+        if (state.hasFailed) {
+          throw state.error ? state.error : 'Completion Failed due unknown error!';
+        }
+      }),
+      first()
+    );
+  }
+
+  /**
+   * Get the state of this data transfer over time.
+   * Unsubscribe after use.
+   */
+  public get state$(): Observable<DataTransferState> {
+    return this._state.asObservable();
+  }
+
+  /**
+   * Get a snapshot of the current state of this data transfer
+   */
+  public get stateSnapshot(): DataTransferState {
+    return this._state.getValue();
+  }
+
+  public get name(): string {
+    return this._name;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private onStart(event: HttpSentEvent): void {
+    this.emitState(
+      DataTransferState.started(this.stateSnapshot.progress.totalBytes)
+    );
+  }
+
+  private onProgress(event: HttpProgressEvent): void {
+    const progress = this.transferProgress(event);
+    this.emitState(
+      DataTransferState.transferring(progress)
+    );
+  }
+
+  private onComplete(event: HttpResponse<any>): void {
+    this.emitState(
+      DataTransferState.completed(
+        this.transferProgressFromResponse(event, this.stateSnapshot.progress)
+      )
+    );
+  }
+
+  private onError(error: any): void {
+    this.emitState(
+      DataTransferState.failed(error, this.stateSnapshot.progress)
+    );
+  }
+
+  private finally(): void {
+    this._endTimeMs = new Date().getTime();
+    if (!this.stateSnapshot.isDone) {
+      this.logger.warn('DataTransfer did not reach done-state! Completing Transfer now...');
+      this.emitState(
+        DataTransferState.completed(this.stateSnapshot.progress)
+      );
+    }
+  }
+
+  private emitState(newState: DataTransferState): void {
+    this._state.next(newState);
+  }
+
+
+  private transferProgressFromResponse(
+    event: HttpResponse<any>,
+    previous?: DataTransferProgress
+  ): DataTransferProgress {
+
+    return new DataTransferProgress(
+      previous ? previous.totalBytes : 0,
+      previous ? previous.bytesPerSec : 0,
+      previous ? previous.avgBytesPerSec : 0,
+      previous ? previous.totalBytes : 0,
+      100
+    );
+  }
+
+  private transferProgress(event: HttpProgressEvent): DataTransferProgress {
+
+    this._currTimeMs = new Date().getTime();
+
+    // setting start time
+    if (!this._startTimeMs) {
+      this._startTimeMs = new Date().getTime();
+      this._prevTimeMs = this._startTimeMs;
+    }
+
+    // tracking how much data is received and
+    const bytesReceivedTotal = event.loaded;
+    const bytesReceived = bytesReceivedTotal - this._oldBytes;
+
+    const durationMs = (this._currTimeMs - this._prevTimeMs);
+    const durationSec = durationMs / 1000;
+
+    // Calc transfer speed per percent data received
+    const bytesPerSec = bytesReceived / durationSec;
+
+    // updating previous values
+    this._prevTimeMs = this._currTimeMs;
+    this._oldBytes = bytesReceivedTotal;
+
+    // Calc avg speed
+    const durationSinceStartMs = (this._currTimeMs - this._startTimeMs);
+    const durationSinceStartSec = durationSinceStartMs / 1000;
+    const avgBytesPerSec = event.loaded / durationSinceStartSec;
+
+    // Calc progress if possible
+    const percentDone = event.total ? Math.round(100 * event.loaded / event.total) : undefined;
+
+    return new DataTransferProgress(
+      event.loaded,
+      bytesPerSec,
+      avgBytesPerSec,
+      event.total,
+      percentDone
+    );
+  }
+
+}

package/src/lib/common/http/transfer/public_api.ts

@@ -0,0 +1,9 @@
+export * from './data-transfer-status';
+export * from './data-transfer-state';
+export * from './data-transfer-progress';
+export * from './data-transfer-progress-aggregate';
+export * from './data-transfer-factory';
+export * from './http-data-transfer';
+
+
+

package/src/lib/common/http/upload/file-upload-client.ts

@@ -0,0 +1,74 @@
+import {HttpClient} from '@angular/common/http';
+import {HttpDataTransfer} from '../transfer/http-data-transfer';
+import {DataTransferFactory} from '../transfer/data-transfer-factory';
+import {ElderDataTransferService} from '../../../components/data-transfer/elder-data-transfer.service';
+
+
+export interface IFileUploadClient {
+  uploadFiles(files: Set<File>): Map<File, HttpDataTransfer>;
+  uploadFile(file: File): HttpDataTransfer;
+}
+
+export class FileUploadClient implements IFileUploadClient {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly dataTransferFactory: DataTransferFactory;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    private http: HttpClient,
+    private transferManager: ElderDataTransferService,
+    protected readonly endpointUrl: string,
+    private requestMethod: 'POST' | 'PUT' | 'PATCH'
+  ) {
+    this.dataTransferFactory = new DataTransferFactory(http);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public uploadFiles(files: Set<File>): Map<File, HttpDataTransfer> {
+
+    const allProgress = new Map<File, HttpDataTransfer>();
+
+    files.forEach(file => {
+      // create a new upload job for every file
+      allProgress.set(file, this.createUploadTransfer(file));
+    });
+
+    const transfers = Array.from(allProgress.values());
+
+    this.transferManager.enqueueAll(transfers);
+
+    return allProgress;
+  }
+
+  public uploadFile(file: File): HttpDataTransfer {
+    return this.transferManager.enqueue(
+      this.createUploadTransfer(file)
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private createUploadTransfer(file: File): HttpDataTransfer {
+    return this.dataTransferFactory.buildFileFormDataUpload(this.requestMethod, this.endpointUrl, file);
+  }
+}

package/src/lib/common/i18n/entity/impl/i18n-base.ts

@@ -0,0 +1,9 @@
+import {Localized} from '../localized';
+import {LanguageTag} from '../language-tag';
+
+export abstract class I18nBase implements Localized {
+  protected constructor(
+    public locale: LanguageTag
+  ) { }
+}
+

package/src/lib/common/i18n/entity/impl/i18n-text.ts

@@ -0,0 +1,25 @@
+import {LanguageTag} from '../language-tag';
+import {I18nBase} from './i18n-base';
+import {SimpleLocalisationPicker} from '../localisation-picker';
+
+/**
+ * Represents a text in a specific locale.
+ */
+export class I18nText extends I18nBase {
+
+  private static readonly localisationPicker = SimpleLocalisationPicker.Instance;
+
+  public static findBestText(
+    choices: I18nText[],
+    desired: LanguageTag
+  ): string | undefined {
+    return I18nText.localisationPicker.findBest(choices, desired)?.text;
+  }
+
+  constructor(
+    locale: LanguageTag,
+    public text: string
+  ) {
+    super(locale);
+  }
+}

package/src/lib/common/i18n/entity/language-tag.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents IETF Language Tags, consisting of
+ * ISO Language Codes (639-1 and 693-2) and IETF language types.
+ * https://datahub.io/core/language-codes#resource-ietf-language-tags
+ */
+export type LanguageTag = string;
+
+export class KnownLocaleType {
+
+  public readonly ENGLISH: LanguageTag = 'en';
+  public readonly en_US: LanguageTag = 'en-US';
+
+  public readonly FRENCH: LanguageTag = 'fr';
+  public readonly fr_FR: LanguageTag = 'fr-FR';
+
+  public readonly GERMAN: LanguageTag = 'de';
+  public readonly de_DE: LanguageTag = 'de-DE';
+  public readonly de_CH: LanguageTag = 'de-CH';
+}

package/src/lib/common/i18n/entity/locale.ts

@@ -0,0 +1,20 @@
+import {LanguageTag} from './language-tag';
+
+
+export class Locale {
+
+  public static parse(tag: LanguageTag): Locale {
+    const parts = tag.split('-');
+    return new Locale(
+      parts[0],
+      parts[1],
+      parts[2],
+    );
+  }
+
+  constructor(
+    public readonly language: string,
+    public readonly country?: string,
+    public readonly variant?: string
+  ) { }
+}

package/src/lib/common/i18n/entity/localisation-picker.ts

@@ -0,0 +1,51 @@
+import {LanguageTag} from './language-tag';
+import {Localized} from './localized';
+import {Locale} from './locale';
+
+export interface LocalisationPicker {
+
+  /**
+   * Returns the best match of the given choices for the given desired language tag.
+   * @param choices
+   * @param desired
+   */
+  findBest<T extends Localized>(
+    choices: T[],
+    desired: LanguageTag
+  ): T | undefined;
+
+}
+
+
+export class SimpleLocalisationPicker implements LocalisationPicker {
+
+  public static readonly Instance: LocalisationPicker = new SimpleLocalisationPicker();
+
+  public findBest<T extends Localized>(
+    choices: T[],
+    desiredTag: LanguageTag
+  ): T | undefined {
+
+    if (!choices || choices.length === 0) { return undefined; }
+
+    // 1. Attempt exact / full match
+    let match = choices.find(c => c.locale === desiredTag);
+    if (match) { return match; }
+
+    const desired = Locale.parse(desiredTag);
+
+    // 2. Attempt language match
+    match = choices.find(c => Locale.parse(c.locale).language === desired.language);
+    if (match) { return match; }
+
+    // 2. Attempt country match
+    if (desired.country) {
+      match = choices.find(c => Locale.parse(c.locale).country === desired.country);
+      if (match) { return match; }
+    }
+
+    // Otherwise, return the first available choice
+    return choices[0];
+  }
+
+}

package/src/lib/common/i18n/entity/localized.ts

@@ -0,0 +1,11 @@
+import {LanguageTag} from './language-tag';
+
+/**
+ * Represents a localized item.
+ */
+export interface Localized {
+  /**
+   * The locale type code of this localized item.
+   */
+  readonly locale: LanguageTag;
+}

package/src/lib/common/i18n/entity/public_api.ts

@@ -0,0 +1,7 @@
+
+export * from './language-tag';
+export * from './localized';
+export * from './localisation-picker';
+export * from './impl/i18n-base';
+export * from './impl/i18n-text';
+

package/src/lib/common/i18n/public_api.ts

@@ -0,0 +1,3 @@
+
+export * from './entity/public_api';
+

package/src/lib/common/json-map.ts

@@ -0,0 +1,26 @@
+export type JsonMap<T> = {
+  [name in string | number]: T;
+};
+
+export class JsonMapUtil {
+
+  public static toJsonMap<T>(esMap: Map<string | number, T>): JsonMap<T> {
+    const entries = Array.from(esMap.entries());
+    const jsonMap = <JsonMap<T>>{};
+    entries.reduce((o, [key, value]) => {
+      o[key] = value;
+      return o;
+    }, jsonMap);
+    return jsonMap;
+  }
+
+  public static toMap<T, ID = string | number>(
+    jsonMap: JsonMap<T>,
+    toIdFn: ((key: string | number) => ID) = key => <any>key
+  ): Map<ID, T> {
+    const map = new Map<ID, T>();
+    Object.keys(jsonMap)
+      .forEach(k => map.set(toIdFn(k), jsonMap[k]));
+    return map;
+  }
+}

package/src/lib/common/objects.ts

@@ -0,0 +1,46 @@
+/**
+ * Provides common used object utils
+ */
+import {LoggerFactory} from '@elderbyte/ts-logger';
+
+export class Objects {
+
+    private static readonly logger = LoggerFactory.getLogger('Objects');
+
+    /**
+     * Checks if the given value is non null / nun undefined
+     */
+    public static nonNull(value: any): boolean {
+        return value !== null && value !== undefined;
+    }
+
+    /**
+     * Checks if the given value is null or undefined
+     */
+    public static isNull(value: any): boolean {
+        return value === null || value === undefined;
+    }
+
+    /**
+     * Creates a copy of the object data.
+     */
+    public static cloneData<T>(src: T): T {
+
+        if (!src) { return src; }
+
+        try {
+            const json = JSON.stringify(src);
+            return JSON.parse(json) as T;
+        } catch (err) {
+            throw new Error('Failed to clone object! ' + err.message);
+        }
+
+    }
+
+    /**
+     * Checks if the two given objects have the same data
+     */
+    public static dataEquals<T>(a: T, b: T): boolean {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+}

package/src/lib/common/public_api.ts

@@ -0,0 +1,20 @@
+
+export * from './format/public_api';
+export * from './time/public_api';
+export * from './data/public_api';
+export * from './forms/public_api';
+export * from './utils/public_api';
+export * from './selection/public_api';
+export * from './http/public_api';
+export * from './i18n/public_api';
+export * from './enums/public_api';
+export * from './errors/public_api';
+export * from './csv/public_api';
+export * from './async/public_api';
+export * from './url/public_api';
+
+export * from './json-map';
+export * from './objects';
+export * from './sets';
+export * from './suggestion-provider';
+export * from './reactive-map';