@elderbyte/ngx-starter 14.10.0 → 14.11.1

package/src/lib/common/data/filters/filter.ts

@@ -0,0 +1,137 @@
+
+
+import {Objects} from '../../objects';
+import {CollectionUtil} from '../../utils/collection-util';
+
+export class Filter {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * The filter key.
+   * Unique inside a FilterContext or Filter request.
+   */
+  public readonly key: string;
+
+  /**
+   * The filter value as string.
+   * Multiple string values are supported.
+   */
+  public readonly value: string | string[] | null;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+      key: string,
+      value: string | string[] | null) {
+
+    if (!key) { throw new Error('ArgumentNull: Filter.key can not be null!'); }
+
+    this.key = key;
+    this.value = value;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public static merge(
+    current: Filter,
+    forcedFilter: Filter
+  ): Filter {
+    let newFilterValue: string | string[];
+    if(Filter.isMulti(current) || Filter.isMulti(forcedFilter)){
+      // We have a list of values. We just have to ensure our forced values are in there
+      const valueSet = new Set<string>();
+      Filter.addValuesToSet(valueSet, current);
+      Filter.addValuesToSet(valueSet, forcedFilter);
+      newFilterValue = Array.from(valueSet);
+    } else {
+      newFilterValue = forcedFilter.value;
+    }
+    return new Filter(current.key, newFilterValue);
+  }
+
+  /**
+   * Checks if this filter supports multiple values.
+   * @param filter
+   */
+  public static isMulti(filter: Filter){
+    return Array.isArray(filter.value);
+  }
+
+  /**
+   * Checks if this filter has a value.
+   * This is the case when the value is non-null and
+   * in case it's an array, also non-empty.
+   */
+  public static hasValue(self: Filter): boolean {
+
+    if (!self) { return false; }
+
+    if (Objects.nonNull(self.value)) {
+       if (self.value instanceof Array) {
+         return self.value.length > 0;
+       } else {
+         return true;
+       }
+    }
+    return false;
+  }
+
+  /**
+   * Checks this filter has the same value as the other given filter.
+   * @param self
+   * @param other
+   */
+  public static equals(self: Filter, other: Filter): boolean {
+
+    if (self === other) { return true; } // Same obj reference
+
+    if (!self) { return false; }
+    if (!other) { return false; }
+    if (self.key !== other.key) { return false; }
+    if (self.value === other.value) { return true; } // Same key and same value reference
+
+    // In case the filter has a multi value array, we need to compare those by value
+
+    if (Array.isArray(self.value) || Array.isArray(other.value)) {
+      const valueArr = Array.isArray(self.value) ? self.value as string[] : [self.value];
+      const otherArr = Array.isArray(other.value) ? other.value as string[] : [other.value];
+      return CollectionUtil.equalSetDeep(
+        new Set<string>(valueArr),
+        new Set<string>(otherArr)
+      );
+    } else {
+      return false; // Otherwise, they are not equal
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private static addValuesToSet(valueSet: Set<string>, filter: Filter): void {
+    const filterValue = filter.value;
+    if(Array.isArray(filterValue)) {
+      const values = filterValue as string[];
+      values.forEach(v => valueSet.add(v));
+    } else {
+      const value = filterValue as string;
+      valueSet.add(value);
+    }
+  }
+}
+

package/src/lib/common/data/http-params-builder.ts

@@ -0,0 +1,138 @@
+import {HttpParams} from '@angular/common/http';
+import {Filter} from './filters/filter';
+import {Sort} from './sort';
+import {Pageable} from './page';
+import {Objects} from '../objects';
+import {TokenChunkRequest} from './token-chunk-request';
+
+
+export class HttpParamsBuilder {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private params: HttpParams;
+
+  /***************************************************************************
+   *                                                                         *
+   * Static Builder                                                          *
+   *                                                                         *
+   **************************************************************************/
+
+  public static start(params?: HttpParams): HttpParamsBuilder {
+    return new HttpParamsBuilder(params);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(params?: HttpParams) {
+    this.params = params ? params : new HttpParams();
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public appendFilters(filters?: Filter[]): this {
+    if (filters) {
+      for (const filter of filters) {
+        if (Filter.hasValue(filter)) {
+          // Ignore filters without a value specified
+          if (filter.value instanceof Array) {
+            filter.value
+              .forEach(
+                v => this.append(filter.key, v)
+              );
+          } else {
+            this.append(filter.key, filter.value);
+          }
+        }
+      }
+    }
+    return this;
+  }
+
+  public appendFilter(...filters: Filter[]): this {
+    return this.appendFilters(filters);
+  }
+
+  public appendSorts(sorts?: Sort[]): this {
+    if (sorts) {
+      for (const sort of sorts) {
+        if (sort && Objects.nonNull(sort.prop)) {
+          this.append('sort', sort.prop + ',' + sort.dir);
+        }
+      }
+    }
+    return this;
+  }
+
+  public appendSort(...sorts: Sort[]): this  {
+    return this.appendSorts(sorts);
+  }
+
+  public appendPageable(pageable?: Pageable): this  {
+    if (pageable) {
+      this
+        .set('page', pageable.page.toString())
+        .set('size', pageable.size.toString())
+        .appendSorts(pageable.sorts);
+    }
+    return this;
+  }
+
+  public appendContinuationRequest(tokenChunkRequest?: TokenChunkRequest): this  {
+    if (tokenChunkRequest) {
+      if (tokenChunkRequest.nextContinuationToken) {
+        this.set('continuationToken', tokenChunkRequest.nextContinuationToken);
+      }
+      this.appendFilters(tokenChunkRequest.filters);
+      this.appendSorts(tokenChunkRequest.sorts);
+    }
+    return this;
+  }
+
+  /**
+   * Turns an object into query-params.
+   *
+   * @param obj The object of which all properties should be applied to this param builder
+   */
+  public appendObject(obj: any): this {
+    if (obj) {
+      Object.keys(obj).forEach(k => {
+        const value = obj[k];
+        if (Array.isArray(value)) {
+          const arr = <any[]>value;
+          arr.forEach(v => this.append(k, v + ''));
+        } else {
+          this.append(k, value + '');
+        }
+      });
+    }
+    return this;
+  }
+
+
+  public append(key: string, value: string): this {
+    this.params = this.params.append(key, value);
+    return this;
+  }
+
+  public set(key: string, value: string): this {
+    this.params = this.params.set(key, value);
+    return this;
+  }
+
+  public build(): HttpParams {
+    return this.params;
+  }
+}

package/src/lib/common/data/page.ts

@@ -0,0 +1,92 @@
+
+import {Sort} from './sort';
+
+export class Page<T> {
+
+    public content: T[];
+    public totalElements: number;
+    public totalPages: number;
+    public last: boolean;
+    public size: number;
+    public number: number;
+    public sort: any;
+    public first: boolean;
+    public numberOfElements: number;
+
+    public static hasNext(page: Page<any>): boolean {
+        return !page.last;
+    }
+
+    public static nextPageable(page: Page<any>, sorts?: Sort[]): Pageable {
+
+        if (!Page.hasNext(page)) {
+            throw new Error('There is no next page! To avoid this error, check with hasNext() first.');
+        }
+
+        return new Pageable(
+          page.number + 1,
+          page.size,
+          sorts
+        );
+    }
+
+    public static fromPage<TS>(data: TS[], total: number, pageable: Pageable) {
+        const page = new Page<TS>();
+        page.content = data;
+        page.totalElements = total;
+        page.totalPages = Math.ceil(total / pageable.size);
+        page.last = pageable.page >= page.totalPages;
+        page.first = pageable.page === 0;
+        page.size = pageable.size;
+        page.number = pageable.page;
+        page.numberOfElements = total;
+        return page;
+    }
+
+    public static from<TS>(data: TS[]) {
+        const page = new Page<TS>();
+        page.content = data;
+        page.totalElements = data.length;
+        page.totalPages = 1;
+        page.last = true;
+        page.first = true;
+        page.size = data.length;
+        page.number = 0;
+        page.numberOfElements = data.length;
+        return page;
+    }
+
+}
+
+export class PageRequest {
+  constructor(
+
+    /**
+     * index Page number (zero based index)
+     */
+    public readonly index: number,
+
+    /**
+     * size The page size
+     */
+    public readonly size: number
+  ) { }
+}
+
+export class Pageable {
+
+    public readonly page: number;
+    public readonly size: number;
+    public readonly sorts: Sort[] = [];
+
+    constructor(
+        page: number,
+        size: number,
+        sorts?: Sort[]
+    ) {
+
+        this.page = page;
+        this.size = size;
+        this.sorts = sorts ? sorts : [];
+    }
+}

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

@@ -0,0 +1,12 @@
+
+export * from './filters/filter';
+export * from './filters/filter-context';
+export * from './sort';
+export * from './page';
+export * from './entity-set-patch';
+export * from './http-params-builder';
+export * from './field-comparator';
+export * from './continuable-listing';
+export * from './token-chunk-request';
+export * from './data-context/public_api';
+export * from './datasource/public_api';

package/src/lib/common/data/required-filter-evaluator.ts

@@ -0,0 +1,122 @@
+import {Filter} from './filters/filter';
+import {BehaviorSubject, combineLatest, Observable} from 'rxjs';
+import {distinctUntilChanged, map} from 'rxjs/operators';
+import {FilterContext} from './filters/filter-context';
+
+export class RequiredFilterContextChangedEvent {
+
+  constructor(
+    public readonly requiredFilters: Array<string[]>,
+    public readonly currentFilters: Filter[],
+    public readonly isValid: boolean
+  ) {
+  }
+
+}
+
+export class RequiredFilterEvaluator {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly _filterContext: FilterContext;
+  private readonly _requiredFilters = new BehaviorSubject<Array<string[]>>([]);
+
+  public readonly context$: Observable<RequiredFilterContextChangedEvent>;
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    filterContext: FilterContext,
+    requiredFilters?: Array<string[]>
+  ) {
+    if (filterContext == null) {
+      throw new Error('filterContext must not be null!');
+    }
+
+    this._filterContext = filterContext;
+    if (requiredFilters) {
+      this._requiredFilters.next(requiredFilters);
+    }
+
+    this.context$ = combineLatest([
+        this._requiredFilters,
+        this._filterContext.filters
+      ]).pipe(
+      map(([required, currentFilters]) => this.createEvent(requiredFilters, currentFilters))
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get filterContext(): FilterContext {
+    return this._filterContext;
+  }
+
+  public get requiredFilters$(): Observable<Array<string[]>> {
+    return this._requiredFilters.asObservable();
+  }
+
+  public get requiredFilters(): Array<string[]> {
+    return this._requiredFilters.getValue();
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private createEvent(
+    requiredFilters: Array<string[]>,
+    currentFilters: Filter[]
+  ): RequiredFilterContextChangedEvent {
+    return new RequiredFilterContextChangedEvent(
+      requiredFilters,
+      currentFilters,
+      this.allRequiredFiltersPresent(
+        requiredFilters,
+        currentFilters
+      )
+    );
+  }
+
+  private allRequiredFiltersPresent(
+    requiredFilters: Array<string[]>,
+    currentFilters: Filter[]
+  ): boolean {
+    if (requiredFilters) {
+      const validatedFilterGroups = requiredFilters.map(filterGroup => this.hasAllFilters(filterGroup, currentFilters));
+      return validatedFilterGroups.find(validGroup => !!validGroup);
+    }
+
+    return true;
+  }
+
+  private hasAllFilters(
+    requiredFilters: string[],
+    currentFilters: Filter[]
+  ): boolean {
+    const currentFilterKeys = currentFilters.map(f => f.key);
+    const currentFilterKeySet = new Set(currentFilterKeys);
+    return requiredFilters.every(required => currentFilterKeySet.has(required));
+  }
+
+}

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

@@ -0,0 +1,90 @@
+import {BehaviorSubject, Observable} from 'rxjs';
+import {Sort, SortDirection} from './sort';
+
+export class SortContext {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly _sorts = new BehaviorSubject<Sort[]>([]);
+
+  /***************************************************************************
+   *                                                                         *
+   * Read API                                                                *
+   *                                                                         *
+   **************************************************************************/
+
+  public get sorts(): Observable<Sort[]> {
+    return this._sorts.asObservable();
+  }
+
+  public get sortsSnapshot(): Sort[] {
+    return this._sorts.getValue();
+  }
+
+  public findSortDirection(prop: string): SortDirection | undefined {
+    const f = this.findSort(prop);
+    return f ? f.dir : undefined;
+  }
+
+  public findSort(prop: string): Sort | undefined {
+    return this.sortsSnapshot
+      .filter(f => f.prop === prop)
+      .find(first => true);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * This method updatees / adds the given sort, leaving
+   * existing ones untouched.
+   * @param updatedSort
+   */
+  public updateSort(updatedSort?: Sort): void {
+    if (updatedSort) {
+      this.updateSorts([updatedSort]);
+    }
+  }
+
+  /**
+   * This method updates / adds the given filters, leaving
+   * existing ones untouched.
+   * @param updatedSorts
+   */
+  public updateSorts(updatedSorts?: Sort[]): void {
+    if (updatedSorts && updatedSorts.length > 0) {
+      const sortMap = new Map<string, Sort>();
+      this.sortsSnapshot.forEach(s => sortMap.set(s.prop, s));
+      updatedSorts.forEach(s => sortMap.set(s.prop, s));
+      this.replaceSorts(
+        Array.from(updatedSorts.values())
+      );
+    }
+  }
+
+  /**
+   * Replace all existing filters with the given new ones.
+   * @param newSorts
+   */
+  public replaceSorts(newSorts?: Sort[]) {
+    this._sorts.next(newSorts || []);
+  }
+
+  public clear(): void {
+    this.replaceSorts([]);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+}

package/src/lib/common/data/sort.ts

@@ -0,0 +1,16 @@
+
+export declare type SortDirection = 'asc' | 'desc' | '';
+
+export class Sort {
+
+    public static NONE = new Sort(undefined, '');
+
+    constructor (
+        public readonly prop: string | undefined,
+        public readonly dir: SortDirection
+    ) { }
+
+    public equals(other: Sort): boolean {
+        return other && this.prop === other.prop && this.dir === other.dir;
+    }
+}

package/src/lib/common/data/token-chunk-request.ts

@@ -0,0 +1,10 @@
+import {Sort} from './sort';
+import {Filter} from './filters/filter';
+
+export class TokenChunkRequest {
+    constructor (
+        public readonly nextContinuationToken: string | null | undefined,
+        public readonly filters: Filter[],
+        public readonly sorts: Sort[]
+    ) {}
+}