@sumaris-net/ngx-components 2.6.4-alpha3 → 2.6.4-alpha5

package/src/app/shared/services/memory-entity-service.class.ts

@@ -0,0 +1,447 @@
+import {BehaviorSubject, merge, Observable} from 'rxjs';
+import {filter, map, mergeMap, takeUntil, tap} from 'rxjs/operators';
+import {isEmptyArray, isNil, isNotEmptyArray, isNotNil} from '../functions';
+import {EntitiesServiceLoadOptions, EntitiesServiceWatchOptions, FilterFn, FilterFnFactory, IEntitiesService, LoadResult} from './entity-service.class';
+import {SortDirection} from '@angular/material/sort';
+import {Directive, OnDestroy} from '@angular/core';
+import {EntityUtils, IEntity} from '../../core/services/model/entity.model';
+import {EntityFilter, EntityFilterUtils} from '../../core/services/model/filter.model';
+import {firstFalsePromise, firstNotNil, WaitForOptions} from '../observables';
+import {StartableService} from './startable-service.class';
+import {StartableObservableService} from './startable-observable-service.class';
+
+export interface InMemoryEntitiesServiceOptions<T, F> {
+  onSort?: (data: T[], sortBy?: string, sortDirection?: SortDirection) => T[];
+  onLoad?: (data: T[]) => T[] | Promise<T[]>;
+  onSave?: (data: T[]) => T[] | Promise<T[]>;
+  equals?: (d1: T, d2: T) => boolean;
+
+  filterFnFactory?: FilterFnFactory<T, F>;
+  filterFn?: FilterFn<T>;
+
+  sortByReplacement?: { [key: string]: string };
+}
+
+// @dynamic
+@Directive()
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class InMemoryEntitiesService<
+  T extends IEntity<T, ID>,
+  F = any,
+  ID = number,
+  O extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions>
+  extends StartableObservableService<T[], T[]>
+  implements IEntitiesService<T, F, O>, OnDestroy {
+
+  debug = false;
+
+  private _hiddenData: T[] = null;
+
+  readonly dirtySubject = new BehaviorSubject<boolean>(false);
+
+  private readonly savingSubject = new BehaviorSubject<boolean>(false);
+  private readonly _sortFn: (data: T[], sortBy?: string, sortDirection?: SortDirection) => T[];
+  private readonly _onLoad: (data: T[]) => T[] | Promise<T[]>;
+  private readonly _onSaveFn: (data: T[]) => T[] | Promise<T[]>;
+  private readonly _equalsFn: (d1: T, d2: T) => boolean;
+  private readonly _filterFnFactory: FilterFnFactory<T, F>;
+  private readonly _sortByReplacement: { [key: string]: string };
+
+
+  set value(data: T[]) {
+    this.setValue(data);
+  }
+
+  get value(): T[] {
+    return this.dataSubject.getValue();
+  }
+
+  get saving(): boolean{
+    return this.savingSubject.value;
+  }
+
+  get dirty(): boolean {
+    return this.dirtySubject.value;
+  }
+
+  constructor(
+    protected dataType: new() => T,
+    protected filterType: new() => F,
+    options?: InMemoryEntitiesServiceOptions<T, F>
+  ) {
+    super(null);
+    options = {
+      onSort: this.sort,
+      ...options
+    };
+
+    this._sortFn = options.onSort;
+    this._onLoad = options.onLoad;
+    this._onSaveFn = options.onSave;
+    this._equalsFn = options.equals;
+    this._filterFnFactory = options.filterFnFactory || ((f) => {
+      const filter = this.asFilter(f) as F;
+      if (filter instanceof EntityFilter) {
+        return filter.asFilterFn();
+      }
+      return undefined;
+    });
+    this._startByReadyFunction = false; // Need setValue() to be called, to start the service
+
+    this._sortByReplacement = {
+      ...options.sortByReplacement
+    };
+  }
+
+  protected async ngOnStart(data?: T[]): Promise<T[]> {
+    if (!data) throw new Error('Missing required data, to start this service');
+    if (this.debug) console.debug('[memory-data-service] Starting...');
+    this._hiddenData = [];
+    this.markAsSaved();
+    this.markAsPristine();
+    return data;
+  }
+
+  protected async ngOnStop(): Promise<void> {
+    if (this.debug) console.debug('[memory-data-service] Stopping...');
+    this._hiddenData = null;
+    this.markAsSaved();
+    this.markAsPristine();
+  }
+
+  ngOnDestroy() {
+    this.stop();
+  }
+
+  setValue(data: T[]) {
+    // If service already started
+    if (this.started) {
+      // Update the data, if changed
+      if (this.dataSubject.value !== data) {
+        this._hiddenData = [];
+        this.dataSubject.next(data);
+      }
+
+      // Reset dirty and saving state
+      // (Fix ObsBio issue on samples table : still dirty after setting the same value again)
+      this.markAsSaved();
+      this.markAsPristine();
+    }
+    // If service not started yet, then start it, using given data
+    else {
+      this.start(data);
+    }
+  }
+
+  async loadAll(
+    offset: number,
+    size: number,
+    sortBy?: string,
+    sortDirection?: SortDirection,
+    filter?: F,
+    opts?: EntitiesServiceLoadOptions
+  ): Promise<LoadResult<T>> {
+
+    offset = offset >= 0 ? offset : 0;
+    size = size >= 0 ? size : -1;
+
+    const originalData = this.dataSubject.value;
+    if (isNil(originalData)) {
+      console.warn('[memory-data-service] Cannot load all: no value set. Will return empty result');
+    }
+
+    try {
+      // Wait service is ready
+      await this.ready();
+
+      // Wait while busy (e.g. when saving, or deleting)
+      await this.waitIdle({stopError: false /*avoid error when stopped*/});
+    }
+    catch (err) {
+      // Should be a stop error: log and continue
+      if (!this.stopped) console.error('Unexpected error, while waiting :', err);
+    }
+
+    // Make sure service is not stopped
+    if (this.stopped) return undefined;
+
+    const excludedDataByFilter: T[] = [];
+    let excludedDataByPagination: T[];
+
+    try {
+      if (isEmptyArray(originalData)) {
+        return {data: [], total: 0};
+      }
+
+      // Apply sort
+      let data = this._sortFn(originalData, sortBy, sortDirection) ;
+
+      if (this._onLoad) {
+        data = await this._onLoad(data);
+      }
+
+      // Apply filter (will update hiddenData)
+      data = this.filter(data, filter, excludedDataByFilter);
+
+      // Compute the total length
+      const total = data.length;
+
+      // If page size=0 (e.g. only need total)
+      if (size === 0) {
+        excludedDataByPagination = data;
+        return {data: [], total};
+      }
+
+      // Slice in a page (using offset and size)
+      if (offset > 0) {
+
+        // Offset after the end: no result
+        if (offset >= data.length) {
+          excludedDataByPagination = data;
+          data = [];
+        }
+        else {
+          excludedDataByPagination = (size > 0 && ((offset + size) < data.length))
+            // Slice using limit to size
+            ? data.slice(0, offset -1).concat(data.slice(offset + size))
+            // Slice without limit
+            : data.slice(0, offset-1);
+
+          data = (size > 0 && ((offset + size) < data.length))
+            // Slice using limit to size
+            ? data.slice(offset, offset + size)
+            // Slice without limit
+            : data.slice(offset);
+        }
+      }
+
+      // Apply a limit
+      else if (size > 0){
+        excludedDataByPagination = data.slice(size);
+        data = data.slice(0, size);
+      }
+
+      // No limit:
+      else if (size === -1){
+        // Keep all data
+      }
+
+      // /!\ If already observed, then always create a copy of the original array
+      // Because datasource will only update if the array changed
+      if (data === originalData) {
+        data = data.slice();
+      }
+
+      const res: LoadResult<T> = {data, total};
+
+      const nextOffset = size > 0 ? (offset || 0) + size : total;
+      if (nextOffset < total) {
+        res.fetchMore = () => this.loadAll(nextOffset, size, sortBy, sortDirection, filter, opts)
+          .then(res => {
+            // Update hidden data (remove new fetched item)
+            if (res.data?.length) {
+              this._hiddenData = this._hiddenData?.filter(item => !res.data.includes(item))
+            }
+            return res;
+          });
+      }
+
+      return res;
+    }
+    finally {
+      // Remember hidden data
+      if (offset === 0) {
+        this._hiddenData = !excludedDataByPagination ? excludedDataByFilter : excludedDataByFilter.concat(...excludedDataByPagination);
+      }
+    }
+  }
+
+  watchAll(
+    offset: number,
+    size: number,
+    sortBy?: string,
+    sortDirection?: SortDirection,
+    filterData?: F,
+    options?: any
+  ): Observable<LoadResult<T>> {
+
+    offset = offset >= 0 ? offset : 0;
+    size = size >= 0 ? size : -1;
+
+    return this.dataSubject
+      .pipe(
+        // Warn if waiting value to be set
+        tap((data) => this.debug && !data && console.debug('[memory-data-service] Waiting value to be set...')),
+        filter(isNotNil),
+        mergeMap(_ => this.loadAll(offset, size, sortBy, sortDirection, filterData, options)),
+        filter(isNotNil), // Skip no result (e.g. when stopped)
+        takeUntil(this.stopSubject)
+      );
+  }
+
+  async saveAll(data: T[], options?: any): Promise<T[]> {
+    if (!this.dataSubject.value) throw new Error('[memory-service] Could not save, because value not set');
+
+    this.markAsSaving();
+
+    try {
+
+      // Restore hidden data
+      if (isNotEmptyArray(this._hiddenData))
+        data = data.concat(...this._hiddenData);
+
+      if (this._onSaveFn) {
+        const res = this._onSaveFn(data);
+        data = ((res instanceof Promise)) ? await res : res;
+      }
+
+      this.dataSubject.next(data);
+      this.markAsDirty();
+      return data;
+    }
+    finally {
+      this.markAsSaved();
+    }
+  }
+
+  async deleteAll(dataToRemove: T[], options?: any): Promise<any> {
+    let data = this.dataSubject.value;
+    if (!data) throw new Error('[memory-service] Could not delete, because value not set');
+
+    this.markAsSaving();
+
+    try {
+      // Remove deleted item, from data
+      const updatedData = data.filter(entity => {
+        const removed = dataToRemove.findIndex(entityToRemove => this.equals(entityToRemove, entity)) !== -1;
+        return !removed;
+      });
+      const deleteCount = data.length - updatedData.length;
+      if (deleteCount > 0) {
+        data = updatedData;
+        this.dataSubject.next(data);
+        this.markAsDirty();
+      }
+    }
+    finally {
+      this.markAsSaved();
+    }
+  }
+
+  sort(data: T[], sortBy?: string, sortDirection?: SortDirection): T[] {
+    // Make sure to fill sortBy BEFORE checking in the replacement map
+    sortBy = sortBy || 'id';
+    // Replace sortBy, using the replacement map
+    sortBy = this._sortByReplacement[sortBy] || sortBy;
+
+    // Execute the sort
+    return EntityUtils.sort(data, sortBy, sortDirection);
+  }
+
+  asFilter(source: Partial<F>): F {
+    return EntityFilterUtils.fromObject(source, this.filterType);
+  }
+
+  addSortByReplacement(source: string, target: string) {
+    this._sortByReplacement[source] = target;
+  }
+
+  equals(d1: T, d2: T): boolean {
+    if (this._equalsFn) return this._equalsFn(d1, d2);
+    return d1 && d1.equals ? d1.equals(d2) : EntityUtils.equals(d1, d2, 'id');
+  }
+
+  /**
+   * Count data stored by the service (without hidden data).
+   * @param opts
+   */
+  // get visibleCount(): number {
+  //   return (this.dataSubject.value?.length || 0);
+  // }
+
+  /**
+   * Count data stored by the service (without hidden data).
+   * @param opts
+   * @deprecated TODO Please rename this getter into visibleCount (and create count = hiddenCount + visibleCount)
+   */
+  get count(): number {
+    return (this.dataSubject.value?.length || 0);
+  }
+
+  get hiddenCount(): number {
+    return this._hiddenData?.length || 0;
+  }
+
+  async waitIdle(opts?: WaitForOptions) {
+    await this.waitWhileSaving(opts);
+  }
+
+  markAsDirty() {
+    if (!this.dirtySubject.value) {
+      this.dirtySubject.next(true);
+    }
+  }
+
+  markAsPristine() {
+    if (this.dirtySubject.value) {
+      this.dirtySubject.next(false);
+    }
+  }
+
+  /* -- protected methods -- */
+
+  protected filter(data: T[], _filter: F, hiddenData: T[]): T[] {
+
+    // if filter is DataFilter instance, use its test function
+    const filterFn = this._filterFnFactory && this._filterFnFactory(_filter);
+    if (filterFn) {
+      const filteredData = [];
+
+      data.forEach(value => {
+        if (filterFn(value))
+          filteredData.push(value);
+        else
+          hiddenData.push(value);
+      });
+
+      return filteredData;
+    }
+
+    // default, no filter
+    return data;
+  }
+
+  protected connect(): Observable<LoadResult<T>> {
+    return this.dataSubject.pipe(
+      map((data) => {
+        data = data || [];
+        const total = data.length;
+        return {data, total};
+      })
+    );
+  }
+
+  protected async waitWhileSaving(opts?: WaitForOptions): Promise<void> {
+    if (this.saving)  {
+      return firstFalsePromise(this.savingSubject, {
+        stop: opts?.stop || merge(this.stopSubject, this.dataSubject), // Stop if destroyed or new data Received
+        stopError: false, // Avoid error when stopped
+        ...opts
+      });
+    }
+  }
+
+  protected markAsSaving() {
+    if (!this.savingSubject.value) {
+      this.savingSubject.next(true);
+    }
+  }
+
+  protected markAsSaved() {
+    if (this.savingSubject.value) {
+      this.savingSubject.next(false);
+    }
+  }
+
+
+}

package/src/app/shared/services/progress-bar.service.ts

@@ -0,0 +1,42 @@
+import { EventEmitter, Injectable, InjectionToken } from '@angular/core';
+import { ProgressBarMode } from '@angular/material/progress-bar';
+
+export const APP_PROGRESS_BAR_SERVICE = new InjectionToken<IProgressBarService>('ProgressBarService');
+
+export declare type ProgressMode = ProgressBarMode;
+
+export interface IProgressBarService {
+  onProgressChanged: EventEmitter<ProgressBarMode>;
+  list(): number;
+  increase();
+  decrease();
+}
+
+@Injectable({providedIn: 'root'})
+export class ProgressBarService implements IProgressBarService {
+  private _requestsRunning = 0;
+
+  onProgressChanged = new EventEmitter<ProgressBarMode>();
+
+  list(): number {
+      return this._requestsRunning;
+  }
+
+  increase(): void {
+    this._requestsRunning++;
+    if (this._requestsRunning === 1) {
+        this.onProgressChanged.emit('query');
+    }
+  }
+
+  decrease(): void {
+    if (this._requestsRunning > 0) {
+        this._requestsRunning--;
+    }
+    if (this._requestsRunning === 0) {
+      this.onProgressChanged.emit(null);
+    }
+  }
+
+
+}

package/src/app/shared/services/startable-observable-service.class.ts

@@ -0,0 +1,137 @@
+import {Optional} from '@angular/core';
+import {BehaviorSubject, Subject, Subscription} from 'rxjs';
+import {filter, takeUntil} from 'rxjs/operators';
+import {IStartableService} from './startable-service.class';
+
+/**
+ * Same as StartableService, bu with a dataSubject instead of a simple 'data' property
+ */
+export abstract class StartableObservableService<T = any, O = any> implements IStartableService<T> {
+
+  readonly dataSubject = new BehaviorSubject<T>(null);
+  readonly startSubject = new Subject<T>();
+  readonly stopSubject = new Subject<void>();
+
+  protected _debug = false;
+  protected _startByReadyFunction = true; // should start when calling ready() ?
+
+  private _started = false;
+  private _startPromise: Promise<T> = null;
+  private _startPrerequisite: () => Promise<any> = null;
+  private _subscription: Subscription = null;
+
+  protected constructor(
+    @Optional() prerequisiteService?: { ready: () => Promise<any> }
+  ) {
+    this._startPrerequisite = prerequisiteService
+      ? () => prerequisiteService.ready()
+      : () => Promise.resolve();
+  }
+
+  start(opts?: O): Promise<T> {
+    if (this._startPromise) return this._startPromise;
+    if (this._started) return Promise.resolve(this.dataSubject.value);
+
+    this._startPromise = this._startPrerequisite()
+      .then(() => this.ngOnStart(opts))
+      .then(data => {
+
+        this._started = true;
+        this._startPromise = undefined;
+
+        // Should be done AFTER 'this._started = true', because of the 'filter' operator, inside ready() function
+        this.dataSubject.next(data);
+        this.startSubject.next(data);
+
+        return data;
+      })
+      .catch(err => {
+        if (!this.stopped) {
+          console.error('Failed to start a service: ' + (err && err.message || err), err);
+          this._started = false;
+          this._startPromise = null;
+        }
+        return null;
+      });
+    return this._startPromise;
+  }
+
+  ready(): Promise<T> {
+    if (this._started) return Promise.resolve(this.dataSubject.value);
+    if (this._startPromise) return this._startPromise;
+    if (this._startByReadyFunction) return this.start();
+
+    return this.dataSubject
+      .pipe(
+        takeUntil(this.stopSubject),
+        // Wait start() to be called, to exclude the initial 'null' value
+        filter(_ => this._started)
+      )
+      .toPromise();
+  }
+
+  async stop() {
+
+    try {
+      this.unsubscribe();
+      await this.ngOnStop();
+    }
+    catch (err) {
+      console.error('Failed to stop a service: ' + (err && err.message || err), err);
+    }
+    finally {
+      this._started = false;
+      this._startPromise = undefined;
+      this.stopSubject.next(); // Stop all running observables
+      this.dataSubject.next(null); // Reset data
+    }
+  }
+
+  async restart(opts?: O): Promise<T> {
+    if (this._startPromise) await this._startPromise; // Wait end of previous loading
+    if (this._started) await this.stop(); // Then stop if started
+    return this.start(opts); // Then start again
+  }
+
+  get started(): boolean {
+    return this._started;
+  }
+
+  get starting(): boolean {
+    return !!this._startPromise;
+  }
+
+  get stopped(): boolean {
+    return !this._started && !this._startPromise;
+  }
+
+  protected get data(): T {
+    return this.dataSubject.value;
+  }
+
+  protected set data(value: T) {
+    if (this.dataSubject.value !== value) {
+      this.dataSubject.next(value);
+    }
+  }
+
+  protected registerSubscription(sub: Subscription) {
+    this._subscription = this._subscription || new Subscription();
+    this._subscription.add(sub);
+  }
+
+  protected unregisterSubscription(sub: Subscription): void {
+    this._subscription?.remove(sub);
+  }
+
+  protected unsubscribe() {
+    this._subscription?.unsubscribe();
+    this._subscription = null;
+  }
+
+  protected ngOnStop(): Promise<void> | void {
+    // Can be overwritten by subclasses
+  }
+
+  protected abstract ngOnStart(opts?: O): Promise<T>;
+}