@elderbyte/ngx-starter 14.11.0 → 14.11.1

package/src/lib/common/data/data-context/data-context-active-page.ts

@@ -0,0 +1,184 @@
+import {DataContextBase} from './data-context-base';
+import {Page, Pageable, PageRequest} from '../page';
+import {Filter} from '../filters/filter';
+import {Logger, LoggerFactory} from '@elderbyte/ts-logger';
+import {BehaviorSubject, Observable, Subject, Subscription} from 'rxjs';
+import {first} from 'rxjs/operators';
+import {IDataContextActivePage} from './data-context';
+import {Sort} from '../sort';
+import {IPagedDataSource} from '../datasource/data-source';
+
+export class DataContextActivePage<T> extends DataContextBase<T> implements IDataContextActivePage<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly actlogger: Logger = LoggerFactory.getLogger(this.constructor.name);
+
+  private readonly _page: BehaviorSubject<PageRequest>;
+
+  /**
+   * Subscription to the event when the active page has changed.
+   * This will trigger a page reload.
+   */
+  private _activePageChangedSub: Subscription;
+
+  /**
+   * Subscription of an actual page load http request.
+   * If this is closed, it will cancel the http request.
+   */
+  private _activePageLoad: Subscription;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+
+  constructor(
+    dataSource: IPagedDataSource<T>,
+    pageSize: number,
+    indexFn: ((item: T) => any),
+    localApply: ((data: T[]) => T[]),
+    localSort: ((data: T[], sorts: Sort[]) => T[])
+  ) {
+    super(dataSource, indexFn, localApply, localSort);
+    this._page = new BehaviorSubject<PageRequest>(new PageRequest(0, pageSize));
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get dataSource(): IPagedDataSource<T> {
+    return <IPagedDataSource<T>>super.dataSource;
+  }
+
+  public get page(): Observable<PageRequest> {
+    return this._page.asObservable();
+  }
+
+  public get pageSnapshot(): PageRequest {
+    return this._page.getValue();
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Set the current page index and reload.
+   * @param pageIndex
+   */
+  public setActiveIndex(pageIndex: number) {
+    this.setActivePage(new PageRequest(pageIndex, this.pageSnapshot.size));
+  }
+
+  /**
+   * Sets the current page index / size and reload.
+   */
+  public setActivePage(request: PageRequest) {
+
+    this.actlogger.trace('Setting page to ', request);
+
+    if (!request) { throw new Error('Setting page PageRequest must not be null!'); }
+
+    let hasChange = false;
+
+    const page = this.pageSnapshot;
+
+    if (page.index !== request.index) {
+      hasChange = true;
+    } else if (page.size !== request.size) {
+      hasChange = true;
+    }
+
+    if (hasChange) {
+      this._page.next(request);
+      this.reload();
+    }
+  }
+
+  public close(): void {
+    super.close();
+    if (this._activePageChangedSub) {
+      this._activePageChangedSub.unsubscribe();
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  protected clearAll(): void {
+    super.clearAll();
+    this.setActiveIndex(0);
+  }
+
+  protected reloadInternal(): Observable<any> {
+
+    if (this._activePageLoad) {
+      // Cancel previous pending request
+      this._activePageLoad.unsubscribe();
+    }
+
+    const subject = new Subject<any>();
+
+    this.onLoading();
+    const page = this.pageSnapshot;
+    const pageRequest = new Pageable(page.index, page.size, this.sort.sortsSnapshot);
+
+
+    this._activePageLoad = this.dataSource.findAllPaged(pageRequest, this.filter.filtersSnapshot)
+      .pipe(first())
+      .subscribe(
+        success => {
+          this.setTotal(success.totalElements);
+          this.setData(success.content);
+          subject.next(success);
+          this.onIdle();
+        }, err => {
+          this.setData([]);
+          this.actlogger.error('Failed to query data', err);
+          subject.error(err);
+          this.onError(err);
+        }, () => {
+          this.onIdle();
+        });
+
+    return subject.pipe(first());
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Event handlers                                                          *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Occurs when the sorts property has changed.
+   */
+  protected onSortsChanged(sorts: Sort[]): void {
+    this.setActiveIndex(0);
+    super.onSortsChanged(sorts);
+  }
+
+  /**
+   * Occurs when the filtersSnapshot property has changed.
+   */
+  protected onFiltersChanged(filters: Filter[]): void {
+    this.setActiveIndex(0);
+    super.onFiltersChanged(filters);
+  }
+}
+

package/src/lib/common/data/data-context/data-context-auto-starter.ts

@@ -0,0 +1,108 @@
+
+import {IDataContext} from './data-context';
+import {RequiredFilterEvaluator} from '../required-filter-evaluator';
+import {DataContextLifeCycleBinding} from './data-context-life-cycle-binding';
+import {Observable} from 'rxjs';
+import {filter, map} from 'rxjs/operators';
+import {LoggerFactory} from '@elderbyte/ts-logger';
+import {Sort} from '../sort';
+
+export class AutoStartSpec {
+
+  public static asap(sort?: Sort[]): AutoStartSpec {
+    return new AutoStartSpec(null, sort);
+  }
+
+  public static requireFiltersAll(filters: string[], sort?: Sort[]): AutoStartSpec {
+    return AutoStartSpec.requireFilters([filters], sort);
+  }
+
+  public static requireFiltersAny(filters: string[], sort?: Sort[]): AutoStartSpec {
+    const separateFilterArrays = filters.map(singleFilter => [singleFilter]);
+    return AutoStartSpec.requireFilters(separateFilterArrays, sort);
+  }
+
+  public static requireFilters(filters: Array<string[]>, sort?: Sort[]): AutoStartSpec {
+    return new AutoStartSpec(filters, sort);
+  }
+
+  constructor(
+    public requiredFilters?: Array<string[]>,
+    public initialSort?: Sort[]
+  ) {
+  }
+}
+
+export class DataContextAutoStarter extends DataContextLifeCycleBinding {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly logger = LoggerFactory.getLogger(this.constructor.name);
+
+  private readonly _autoStartConditionFulfilled$: Observable<boolean>;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    dataContext: IDataContext<any>,
+    private readonly _autoStartSpec: AutoStartSpec
+  ) {
+    super(dataContext);
+
+    if (_autoStartSpec == null) {
+      throw new Error('autoStartSpec must not be null!');
+    }
+
+    if (_autoStartSpec.requiredFilters) {
+      this._autoStartConditionFulfilled$ = this.buildRequiredFilterConditionObservable();
+    } else {
+      // no condition defined, try to start immediately
+      this.startDataContext();
+    }
+
+    this.subscribe();
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  protected subscribe(): void {
+    if (this._autoStartConditionFulfilled$) {
+      this._subscription = this._autoStartConditionFulfilled$.pipe(
+        filter(fulfilled => !!fulfilled)
+      ).subscribe(() => this.startDataContext());
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private buildRequiredFilterConditionObservable(): Observable<boolean> {
+    return new RequiredFilterEvaluator(
+      this._dataContext.filter,
+      this._autoStartSpec.requiredFilters
+    ).context$.pipe(
+      map(event => event.isValid)
+    );
+  }
+
+  private startDataContext() {
+    this.logger.debug('Auto starting data context...');
+    this._dataContext.start(this._autoStartSpec.initialSort);
+  }
+
+}

package/src/lib/common/data/data-context/data-context-base.ts

@@ -0,0 +1,406 @@
+import {Logger, LoggerFactory} from '@elderbyte/ts-logger';
+import {Filter} from '../filters/filter';
+import {Sort} from '../sort';
+import {CollectionViewer, DataSource} from '@angular/cdk/collections';
+import {DataContextStatus} from './data-context-status';
+import {BehaviorSubject, EMPTY, Observable, of, Subject} from 'rxjs';
+import {FilterContext} from '../filters/filter-context';
+import {DataContextSnapshot, IDataContext} from './data-context';
+import {catchError, debounceTime, filter, map, takeUntil} from 'rxjs/operators';
+import {SortContext} from '../sort-context';
+import {IDataSource} from '../datasource/data-source';
+
+export abstract class DataContextBase<T> extends DataSource<T> implements IDataContext<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly baselog: Logger = LoggerFactory.getLogger('DataContextBase');
+
+  private readonly _dataSource: IDataSource<T>;
+
+  private readonly _filter = new FilterContext();
+  private readonly _sort = new SortContext();
+
+  private readonly _loading: Observable<boolean>;
+
+  private readonly _data = new BehaviorSubject<T[]>([]);
+  private readonly _total = new BehaviorSubject<number | undefined>(undefined);
+  private readonly _status = new BehaviorSubject<DataContextStatus>(DataContextStatus.idle());
+
+  private readonly _started = new BehaviorSubject<boolean>(false);
+  private readonly _closed = new BehaviorSubject<boolean>(false);
+
+  private readonly _primaryIndex = new Map<any, T>();
+
+  private readonly _reloadQueue = new Subject<void>();
+
+  protected readonly unsubscribe$ = new Subject<void>();
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  protected constructor(
+    dataSource: IDataSource<T>,
+    private _indexFn: ((item: T) => any),
+    private _localApply: ((data: T[]) => T[]),
+    private _localSort: ((data: T[], sorts: Sort[]) => T[]),
+  ) {
+    super();
+
+    this._dataSource = dataSource;
+
+    this._loading = this._status.pipe(
+      map(status => status.loading)
+    );
+
+    this._filter.filters.pipe(
+      filter(() => this.started),
+      takeUntil(this.unsubscribe$)
+    ).subscribe(
+      filters => this.onFiltersChanged(filters)
+    );
+
+    this._sort.sorts.pipe(
+      filter(() => this.started),
+      takeUntil(this.unsubscribe$)
+    ).subscribe(
+      sorts => this.onSortsChanged(sorts)
+    );
+
+    this._reloadQueue.pipe(
+      filter(() => this.started),
+      debounceTime(50),
+      takeUntil(this.unsubscribe$),
+      catchError(err => {  // Dont die on errors
+        this.baselog.error('Reload queue detected error, bad!', err);
+        return EMPTY;
+      })
+    ).subscribe(() => this.reloadNow());
+    // Maybe skipMap the real requests for auto abort pending (except for continuation / paged)
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API Material DC                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  public connect(collectionViewer: CollectionViewer): Observable<T[]> {
+    return this.data;
+  }
+
+  public disconnect(collectionViewer: CollectionViewer): void {
+    // this.close(); Closing will destroy the DC
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get dataSource(): IDataSource<T> {
+    return this._dataSource;
+  }
+
+  public get snapshot(): DataContextSnapshot<T> {
+    return new DataContextSnapshot(
+      this.dataSnapshot,
+      this.isEmpty,
+      this.loadingSnapshot,
+      this.totalSnapshot,
+      this.statusSnapshot
+    );
+  }
+
+
+  public get total(): Observable<number | undefined> {
+    return this._total.asObservable();
+  }
+
+  public get totalSnapshot(): number | undefined {
+    return this._total.getValue();
+  }
+
+  public get sort(): SortContext {
+    return this._sort;
+  }
+
+  public get filter(): FilterContext {
+    return this._filter;
+  }
+
+  public get loading(): Observable<boolean> {
+    return this._loading;
+  }
+
+  public get loadingSnapshot(): boolean {
+    return this.statusSnapshot?.loading;
+  }
+
+  public get data(): Observable<T[]> {
+    return this._data.asObservable();
+  }
+
+  public get dataSnapshot(): T[] {
+    return this._data.getValue();
+  }
+
+  public get status(): Observable<DataContextStatus> {
+    return this._status;
+  }
+
+  public get statusSnapshot(): DataContextStatus {
+    return this._status.getValue();
+  }
+
+  public get isEmpty(): boolean {
+    return this.dataSnapshot.length === 0;
+  }
+
+  public get isStarted(): boolean {
+    return this.started;
+  }
+
+  public get isStarted$(): Observable<boolean> {
+    return this._started.asObservable();
+  }
+
+  public get isClosed(): boolean {
+    return this._closed.getValue();
+  }
+
+  protected get started(): boolean {
+    return this._started.getValue();
+  }
+
+  protected set started(started: boolean) {
+    this._started.next(started);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public start(sorts?: Sort[], filters?: Filter[]): Observable<any> {
+
+    if (this.isClosed) {
+      throw new Error('Restarting a closed DataContext is not possible!'); // See unsubscribe$
+    }
+
+    this.baselog.debug('Starting fresh dataContext ...');
+
+    this.started = false;
+
+    this._sort.replaceSorts(sorts || this.sort.sortsSnapshot);
+    this._filter.replaceFilters(filters || this.filter.filtersSnapshot);
+
+    this.started = true;
+
+    return this.reloadNow();
+  }
+
+  public reload(): void {
+    this._reloadQueue.next();
+  }
+
+  public findByIndex(key: any): T | undefined {
+    if (!this._indexFn) { throw new Error('findByIndex requires you to pass a index function!'); }
+    return this._primaryIndex.get(key);
+  }
+
+  /**
+   * Closes this DataContext and cleans up all used resources.
+   */
+  public close(): void {
+
+    this.started = false;
+    this.unsubscribe$.next();
+    this.unsubscribe$.complete();
+    this._closed.next(true);
+
+    this._data.complete();
+    this._total.complete();
+    this._status.complete();
+
+    this.clearAll();
+    this.baselog.debug('DataContext has been closed and resources cleaned up!');
+  }
+
+  public refresh(): void {
+    const current = this._data.getValue();
+    this._data.next(current);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Protected methods                                                       *
+   *                                                                         *
+   **************************************************************************/
+
+  protected reloadNow(): Observable<any> {
+    return this.reloadInternal(); // TODO This should actually return the real (http) request
+  }
+
+  /**
+   * Append the given rows to to existing ones.
+   */
+  protected appendData(additionalData: T[]): void {
+    // We had previous chunks so append to current data.
+    const newData = [...this.dataSnapshot];
+    newData.push(...additionalData);
+    this.indexAll(additionalData);
+    this.setData(newData, true);
+  }
+
+  /**
+   * Replaces the existing data with the new set.
+   * @param newData The new data set.
+   * @param alreadyIndexed The rows will be indexed unless they already have been.
+   */
+  protected setData(newData: T[], alreadyIndexed = false): void {
+
+    if (this._localApply) {
+      newData = this._localApply(newData);
+    }
+
+    if (this._localSort) {
+      newData = this._localSort(newData, this._sort.sortsSnapshot);
+    }
+
+    if (!alreadyIndexed) {
+      this.indexAll(newData);
+    }
+
+    const current = this.dataSnapshot;
+
+    if (!(current.length === 0 && newData.length === 0)) {
+      this.baselog.debug('Data has changed: ' + newData.length);
+      this._data.next(newData);
+    }
+  }
+
+  protected setTotal(total: number | undefined): void {
+    this._total.next(total);
+  }
+
+  /**
+   * Clears the current data-context cached data.
+   * State such as current sorting and filtersSnapshot are kept.
+   */
+  protected clearAll(silent = false): void {
+    this.clearIndex();
+
+    if (!silent) {
+      this.setTotal(0);
+      this.setData([]);
+    }
+
+    this.onIdle();
+  }
+
+  protected updateIndex(): void {
+    this.clearIndex();
+    this.indexAll(this.dataSnapshot);
+  }
+
+  /**
+   * Indexes the given item by key if there is an index function defined.
+   */
+  protected indexItem(item: T): void {
+    const key = this.getItemKey(item);
+    if (key) {
+      this._primaryIndex.set(key, item);
+    }
+  }
+
+  /**
+   * Indexes all the given items by key if there is an index function defined.
+   */
+  protected indexAll(items: T[]): void {
+    if (this._indexFn) {
+      items.forEach(item => this.indexItem(item));
+    }
+  }
+
+  protected getItemKey(item: T): any  {
+    if (this._indexFn) {
+      return this._indexFn(item);
+    }
+    return null;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Event handler                                                           *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Occurs when the sort has changed.
+   */
+  protected onSortsChanged(sorts: Sort[]): void {
+    if (!this._localSort) {
+      this.reload();
+    } else {
+      this.setData(this.dataSnapshot, true);
+    }
+  }
+
+  /**
+   * Occurs when the filter has changed.
+   */
+  protected onFiltersChanged(filters: Filter[]): void {
+    this.reload();
+  }
+
+  protected onError(err: any): void {
+    this.onStatus(DataContextStatus.error(err));
+  }
+
+  protected onIdle(): void {
+    this.onStatus(DataContextStatus.idle());
+  }
+
+  protected onLoading(): void {
+    this.onStatus(DataContextStatus.loading());
+  }
+
+  protected onStatus(status: DataContextStatus): void {
+    this._status.next(status);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Abstract methods                                                        *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Subclasses must implement this method and
+   * reload the currently held data.
+   * If possible, the current view state should be kept.
+   *
+   * @returns The reload job.
+   */
+  protected abstract reloadInternal(): Observable<any>;
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private clearIndex(): void {
+    this._primaryIndex.clear();
+  }
+}