@sumaris-net/ngx-components 18.10.29 → 18.12.0

package/src/app/core/services/storage/entity-store.class.ts

@@ -0,0 +1,589 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { map, mergeMap } from 'rxjs/operators';
+import { Entity, EntityUtils, IEntity } from '../model/entity.model';
+import { isEmptyArray, isNil, isNotEmptyArray, isNotNil } from '../../../shared/functions';
+import { LoadResult } from '../../../shared/services/entity-service.class';
+import { chainPromises } from '../../../shared/observables';
+import { ErrorCodes } from '../errors';
+import { IStorage } from '../../../shared/storage/storage.utils';
+import { SortDirection } from '@angular/material/sort';
+
+export const ENTITIES_STORAGE_KEY_PREFIX = 'entities';
+
+export type EntityStoreTypePolicyMode = 'default' | 'by-id';
+
+export declare interface EntityStoreTypePolicy<T extends Entity<T, any> = Entity<any, any>, K = keyof T> {
+  mode?: EntityStoreTypePolicyMode; // 'default' by default
+  skipNonLocalEntities?: boolean; // False by default
+  lightFieldsExcludes?: K[]; // none by default
+}
+
+export declare interface EntityStorageLoadOptions {
+  fullLoad?: boolean;
+}
+
+declare interface EntityStatus {
+  index: number;
+  dirty?: boolean;
+}
+
+export class EntityStore<T extends IEntity<T, ID>, ID = number, O extends EntityStorageLoadOptions = EntityStorageLoadOptions> {
+  private readonly _storageKey: string;
+  private readonly _onChange = new BehaviorSubject(true);
+  private readonly _mapToLightEntity: (T) => T;
+  private _cache: T[];
+  private _statusById: Map<ID, EntityStatus>;
+  private _sequence: number;
+  private _dirty = false;
+  private _loaded: boolean;
+
+  readonly policy: EntityStoreTypePolicy<T>;
+
+  get length(): number {
+    return this._cache?.length || 0;
+  }
+
+  get cache(): T[] {
+    return this._cache;
+  }
+
+  get dirty(): boolean {
+    return this._dirty;
+  }
+
+  protected get isByIdMode(): boolean {
+    return this.policy.mode === 'by-id';
+  }
+
+  protected get storageKeyById(): string {
+    return this._storageKey + '#ids';
+  }
+
+  constructor(
+    protected readonly name: string,
+    protected readonly storage: IStorage,
+    policy?: EntityStoreTypePolicy<T>
+  ) {
+    this.policy = policy || {};
+    this.reset({ emitEvent: false });
+    this._dirty = false;
+    this._loaded = false;
+    this._storageKey = ENTITIES_STORAGE_KEY_PREFIX + '#' + name;
+    this._mapToLightEntity = this.createLightEntityMapFn(this.policy);
+  }
+
+  nextValue(): ID {
+    this._sequence = this._sequence - 1;
+    this._dirty = true;
+    return this._sequence as unknown as ID;
+  }
+
+  currentValue(): number {
+    return this._sequence;
+  }
+
+  async load(id: ID, opts?: EntityStorageLoadOptions): Promise<T> {
+    if (this._mapToLightEntity && (!opts || opts.fullLoad !== false)) {
+      return await this.loadFullEntity(id, opts);
+    }
+    return this.loadCachedEntity(id, opts);
+  }
+
+  /**
+   * Watch a set of entities
+   *
+   * @param variables
+   * @param opts
+   */
+  watchAll(
+    variables: {
+      offset?: number;
+      size?: number;
+      sortBy?: keyof T | string;
+      sortDirection?: string;
+      filter?: (data: T) => boolean;
+    },
+    opts?: O
+  ): Observable<LoadResult<T>> {
+    // If need full entities, but use light entities in the entities array
+    if (this._mapToLightEntity && opts && opts.fullLoad === true) {
+      console.warn(
+        '[entity-store] WARN: Watching full entities, splited by id in entity store. This can be long! Please make sure you need full entities here.'
+      );
+      return this._onChange.pipe(
+        // Apply filter on cache
+        map((_) => this.reduceAndSort(this._cache, variables)),
+
+        // Then convert into full entities (using parallel jobs - /!\ can use lot of memory)
+        mergeMap((res) =>
+          Promise.all((res.data || []).map((e) => this.loadFullEntity(e.id, opts))).then((data) => ({
+            data,
+            total: res.total,
+          }))
+        )
+      );
+    }
+
+    // Load using entities array
+    return this._onChange.pipe(map((_) => this.reduceAndSort(this._cache, variables)));
+  }
+
+  /**
+   * WIll apply a filter, then a sort, then a page slice
+   *
+   * @param variables
+   * @param opts
+   */
+  async loadAll(
+    variables: {
+      offset?: number;
+      size?: number;
+      sortBy?: keyof T | string;
+      sortDirection?: string;
+      filter?: (data: T) => boolean;
+    },
+    opts?: O
+  ): Promise<LoadResult<T>> {
+    const res = this.reduceAndSort(this._cache, variables);
+
+    // If store by ID: make sure to full the full entities
+    if (this._mapToLightEntity && isNotEmptyArray(res.data) && opts && opts.fullLoad === true) {
+      // Load full entities, one by one
+      res.data = await chainPromises((res.data || []).map((e) => () => this.load(e.id)));
+    }
+
+    return res;
+  }
+
+  save(entity: T, opts?: { emitEvent?: boolean }): T {
+    const status = (isNotNil(entity.id) && this._statusById.get(entity.id)) || { index: undefined };
+    const isNew = isNil(status.index);
+    if (isNew) {
+      if (isNil(entity.id)) {
+        entity.id = this.nextValue();
+      } else if (+entity.id < 0 && +entity.id > this._sequence) {
+        console.warn('Trying to save a local entity with an id > sequence. Will replace id by sequence next value');
+        entity.id = this.nextValue();
+      } else {
+        // OK: use a valid id :
+        // - id >= 0 (should be a remote id)
+        // - OR < sequence, and not exists in the index map
+      }
+
+      this._statusById.set(entity.id, status);
+      status.index = this._cache.push(entity) - 1;
+    } else {
+      this._cache[status.index] = entity;
+    }
+
+    // Mark entity as dirty
+    status.dirty = true;
+
+    // Mark storage as dirty
+    this._dirty = true;
+
+    // Emit update event
+    if (!opts || opts.emitEvent !== false) {
+      this.emitEvent();
+    }
+
+    return entity;
+  }
+
+  saveAll(entities: T[], opts?: { emitEvent?: boolean; reset?: boolean }): T[] {
+    if (isEmptyArray(entities) && (!opts || opts.reset !== true)) return entities; // Skip (Nothing to save)
+
+    let result: T[];
+
+    console.info(`[entity-storage] Saving ${entities.length} ${this.name}(s)`);
+
+    // First save, or reset using given entities
+    if (isEmptyArray(this._cache) || (opts && opts.reset)) {
+      this.setEntities(entities, { emitEvent: false, dirty: this.isByIdMode });
+    } else {
+      result = entities.map((entity) => this.save(entity, { emitEvent: false }));
+    }
+
+    // Mark as dirty
+    this._dirty = true;
+
+    // Emit update event
+    if (!opts || opts.emitEvent !== false) {
+      this.emitEvent();
+    }
+
+    return result || this._cache.slice();
+  }
+
+  delete(id: ID, opts?: { emitEvent?: boolean }): T | undefined {
+    const status = isNotNil(id) ? this._statusById.get(id) : undefined;
+    const index = status ? status.index : undefined;
+    if (isNil(index)) return undefined;
+
+    const entity = this._cache[index];
+    if (!entity) return undefined;
+
+    // Remove from cache
+    this._cache[index] = undefined;
+    this._statusById.delete(entity.id);
+
+    // Remove full entity, by id
+    if (this.isByIdMode) {
+      this.storage.remove(this._storageKey + '#' + id);
+    }
+
+    // Mark as dirty
+    this._dirty = true;
+
+    // Emit update event
+    if (!opts || opts.emitEvent !== false) {
+      this.emitEvent();
+    }
+
+    return entity as T;
+  }
+
+  deleteMany(ids: ID[], opts?: { emitEvent?: boolean }): T[] {
+    // Delete by id, but NOT emit event on each deletion
+    const deletedEntities = (ids || []).map((id) => this.delete(id, { emitEvent: false })).filter(isNotNil);
+
+    // No changes: exit
+    if (!deletedEntities.length) return [];
+
+    // Emit update event
+    if (!opts || opts.emitEvent !== false) {
+      this.emitEvent();
+    }
+
+    return deletedEntities;
+  }
+
+  reset(opts?: { emitEvent?: boolean }) {
+    this._cache = [];
+    this._sequence = 0;
+    this._statusById = new Map<ID, any>();
+
+    this._dirty = true;
+    this._loaded = true;
+
+    // Emit update event
+    if (!opts || opts.emitEvent !== false) {
+      this.emitEvent();
+    }
+  }
+
+  /**
+   *
+   * @param opts
+   *  opts.skipIfPristine = false persist all entities, even if not dirty
+   */
+  async persist(opts = { skipIfPristine: true }): Promise<number> {
+    // Skip is not dirty
+    if (opts.skipIfPristine && !this._dirty) {
+      console.debug(`[entity-storage] Persisting ${this.name} not need. Skip`);
+      return this._cache.length;
+    }
+
+    // Copy some data, BEFORE to call markAsPristine() to allow parallel changes
+    const dirtyIndexes =
+      this.isByIdMode &&
+      Array.from(this._statusById.values())
+        .filter((s) => !opts.skipIfPristine || (s && s.dirty))
+        .map((s) => s.index);
+    const entities = this._cache.slice(); // Copy cached entities
+
+    // Mark all (entities and status) as pristine
+    this.markAsPristine({ emitEvent: false });
+
+    // Convert dirty entities into light entities (/!\ AFTER the previous copy)
+    // and update the cache (but NOT the 'entities' variable)
+    if (dirtyIndexes && this._mapToLightEntity) {
+      dirtyIndexes.forEach((index) => (this._cache[index] = this._mapToLightEntity(entities[index])));
+    }
+
+    // If no entity found
+    if (isEmptyArray(entities)) {
+      // Clean the local storage
+      await this.storage.remove(this._storageKey);
+    } else {
+      // Save each entity into a unique key (advanced mode)
+      if (this.isByIdMode) {
+        // Save ids
+        await this.storage.set(
+          this.storageKeyById,
+          entities.filter(isNotNil).map((e) => e.id)
+        );
+
+        // Saved dirty entities
+        await Promise.all(
+          dirtyIndexes.map((index) => {
+            const entity = entities[index];
+            console.debug(`[entity-storage] Persisting ${this.name}#${entity.id}...`);
+            return this.storage.set(this._storageKey + '#' + entity.id, entity);
+          })
+        );
+
+        console.info(`[entity-storage] Persisting ${dirtyIndexes.length}/${entities.length} ${this.name}(s)...`);
+      }
+
+      // Save all entities in a single key (default)
+      else {
+        console.info(`[entity-storage] Persisting ${entities.length} ${this.name}(s)...`);
+        await this.storage.set(this._storageKey, entities);
+      }
+    }
+
+    return entities.length;
+  }
+
+  async restore(opts?: { emitEvent?: boolean }): Promise<number> {
+    let entities: T[];
+
+    const res = await Promise.all([this.storage.get(this._storageKey), this.storage.get(this.storageKeyById)]);
+    const values = res[0] && Array.isArray(res[0]) ? res[0] : null;
+    const ids = res[1] && Array.isArray(res[1]) ? res[1] : null;
+    let migration = false;
+    let oldKeysToClean: string[];
+
+    // "Split by id" mode
+    if (this.isByIdMode) {
+      if (isNotNil(ids)) {
+        // Load entity by id (one by one)
+        const storageKeys = ids.map((id) => this._storageKey + '#' + id);
+        entities = await chainPromises<T>(storageKeys.map((key) => () => this.storage.get(key)));
+      }
+      // Migrate from the standard mode
+      else if (isNotNil(values)) {
+        entities = values.filter((e) => e && isNotNil(e.id));
+        migration = true;
+        oldKeysToClean = [this._storageKey];
+      }
+    }
+
+    // Else (default mode)
+    else {
+      if (isNotNil(values)) {
+        entities = values.filter((e) => e && isNotNil(e.id));
+      } else if (isNotNil(ids)) {
+        const storageKeys = ids.map((id) => this._storageKey + '#' + id);
+        // Load entity by id (one by one)
+        entities = await chainPromises<T>(storageKeys.map((key) => () => this.storage.get(key)));
+        migration = true;
+        oldKeysToClean = [...storageKeys, this.storageKeyById];
+      }
+    }
+
+    // OK, there is something in storage...
+    if (isNotEmptyArray(entities)) {
+      if (entities.length >= 1000) {
+        console.warn(`[entity-storage] - Restoring ${entities.length} ${this.name}. Check if not too many elements?!`);
+      }
+
+      // Map entities into light element (if if not need to persist, because of migration
+      if (this._mapToLightEntity && !migration) {
+        entities = entities.map(this._mapToLightEntity);
+      }
+    }
+
+    this.setEntities(entities || [], { ...opts, emitEvent: false, dirty: false });
+    this._dirty = false;
+
+    // Finish the migration
+    if (migration) {
+      try {
+        console.warn(`[entity-storage] - Migrate ${this.name} into {mode: '${this.policy.mode}'}...`);
+
+        // Force to persist, using the new mode
+        await this.persist({ skipIfPristine: false /* force persist using the new mode */ });
+
+        // Clean old storage keys (one by one)
+        if (isNotEmptyArray(oldKeysToClean)) await chainPromises(oldKeysToClean.map((key) => () => this.storage.remove(key)));
+      } catch (err) {
+        console.error(err);
+        throw { code: ErrorCodes.ENTITY_STORAGE_MIGRATION_FAILED, message: 'ERROR.ENTITY_STORAGE_MIGRATION_FAILED', details: err };
+      }
+    }
+
+    // Emit update event
+    if (!opts || opts.emitEvent !== false) {
+      this.emitEvent();
+    }
+
+    return this._cache.length;
+  }
+
+  markAsDirty(opts?: { emitEvent?: boolean }) {
+    this._dirty = true;
+
+    // Emit update event
+    if (!opts || opts.emitEvent !== false) {
+      this.emitEvent();
+    }
+  }
+
+  markAsPristine(opts?: { emitEvent?: boolean }) {
+    for (const s of this._statusById.values()) {
+      if (isNotNil(s)) {
+        s.dirty = false;
+      }
+    }
+    this._dirty = false;
+
+    // Emit update event
+    if (!opts || opts.emitEvent !== false) {
+      this.emitEvent();
+    }
+  }
+
+  /* -- protected methods -- */
+
+  private loadCachedEntity(id: ID, opts?: EntityStorageLoadOptions): T {
+    const status = this._statusById.get(id);
+    const index = status && status.index;
+    if (isNil(index)) return undefined; // not exists
+    return Object.freeze(this._cache[index]);
+  }
+
+  private async loadFullEntity(id: ID, opts?: EntityStorageLoadOptions): Promise<T> {
+    const status = this._statusById.get(id);
+    const index = status && status.index;
+    if (isNil(index)) return undefined; // not exists
+
+    // Reload from storage, if need (e.g. some attributes has been excluded in light elements)
+    if (status.dirty === false) {
+      console.debug(`[entity-storage] Full reloading ${this.name}#${id}...`);
+      const fullData = await this.storage.get(this._storageKey + '#' + id);
+      if (fullData) return Object.freeze(fullData);
+      // Not found by id, continue from cache (version prior to 1.5.3)
+    }
+
+    // Load from the cache, if dirty OR if storage is not splitted by id
+    return Object.freeze(this._cache[index]);
+  }
+
+  private setEntities(entities: T[], opts?: { emitEvent?: boolean; dirty?: boolean }) {
+    // Filter non nil (and if need non local) entities
+    entities = (entities || []).filter((item) => isNotNil(item) && (!this.policy.skipNonLocalEntities || +item.id < 0));
+
+    this._cache = entities;
+
+    // Update the sequence with min(id) of all temporary ids
+    this._sequence = this._cache.reduce((res, item) => (+item.id < 0 ? Math.min(res, +item.id) : res), 0);
+
+    this._statusById.clear();
+
+    const dirty = opts?.dirty ?? false;
+    this._cache.forEach((item, index) => {
+      this._statusById.set(item.id, <EntityStatus>{
+        index,
+        dirty,
+      });
+    });
+
+    this._loaded = true;
+
+    // Emit update event
+    if (!opts || opts.emitEvent !== false) {
+      this.emitEvent();
+    }
+  }
+
+  /**
+   * WIll apply a filter, then a sort, then a page slice
+   *
+   * @param data
+   * @param variables
+   */
+  private reduceAndSort(
+    data: T[],
+    variables: {
+      offset?: number;
+      size?: number;
+      sortBy?: keyof T | string;
+      sortDirection?: string;
+      filter?: (data: T) => boolean;
+    }
+  ): LoadResult<T> {
+    if (isEmptyArray(data)) {
+      return { data: [], total: 0 };
+    }
+
+    // Remove nil values
+    data = data.filter(isNotNil);
+
+    if (!variables) {
+      // Return all (but array has been filtered, and copied)
+      return { data, total: data.length };
+    }
+
+    // Apply the filter, if any
+    if (variables.filter) {
+      data = data.filter(variables.filter);
+    }
+
+    // Compute the total length
+    const total = data.length;
+
+    // If page size=0 (e.g. only need total)
+    if (variables.size === 0) return { data: [], total };
+
+    // Sort by
+    if (variables.sortBy) {
+      EntityUtils.sort(data, variables.sortBy, (variables.sortDirection?.toLowerCase() as SortDirection) || 'asc');
+    }
+
+    // Slice in a page (using offset and size)
+    if (variables.offset > 0) {
+      // Offset after the end: no result
+      if (variables.offset >= data.length || variables.size === 0) {
+        data = [];
+      } else {
+        data =
+          variables.size > 0 && variables.offset + variables.size < data.length
+            ? // Slice using limit to size
+              data.slice(variables.offset, variables.offset + variables.size)
+            : // Slice without limit
+              data.slice(variables.offset);
+      }
+    }
+
+    // Apply a limit
+    else if (variables.size > 0) {
+      data = data.slice(0, variables.size);
+    }
+    // No limit:
+    else if (variables.size === -1) {
+      // Keep all data
+    }
+
+    return { data, total };
+  }
+
+  private createLightEntityMapFn(policy: EntityStoreTypePolicy<T>): (T) => T {
+    if (policy.mode !== 'by-id') return undefined; // Only need for the 'by-id' mode
+    if (isEmptyArray(policy.lightFieldsExcludes)) return undefined; // skip
+
+    // Create a immutable mask object, use to clean some properties
+    const excludeAttributesMask = Object.freeze(
+      this.policy.lightFieldsExcludes.reduce(
+        (res, attr) => {
+          res[attr] = undefined;
+          return res;
+        },
+        <T>{}
+      )
+    );
+
+    return (entity) => (entity ? Object.assign(<T>{}, entity, excludeAttributesMask) : undefined);
+  }
+
+  /**
+   * Update the entitiesSubject.
+   *
+   * Before wending items, a filter is apply, to remove null value.
+   * This filter will create a array copy.
+   */
+  private emitEvent() {
+    this._onChange.next(true);
+  }
+}

package/src/app/core/services/testing/local-settings.config.ts

@@ -0,0 +1,35 @@
+// Add dynamic option
+import { FormFieldDefinition } from '../../../shared/form/field.model';
+import { PersonFilter } from '../../../admin/services/filter/person.filter';
+import { StatusIds } from '../model/model.enum';
+
+// This test options should be visible in the settings page
+export const TEST_LOCAL_SETTINGS_OPTIONS = {
+  DUMMY_OPTION_ENTITY: <FormFieldDefinition>{
+    key: 'sumaris.option.dummyEntity',
+    label: 'ACCOUNT.SETTINGS.DUMMY_ENTITY',
+    type: 'entity',
+    minProfile: 'USER', // Should be login
+    autocomplete: {
+      showAllOnFocus: true,
+      attributes: ['firstName', 'lastName', 'id'],
+      filter: <PersonFilter>{
+        statusIds: [StatusIds.ENABLE, StatusIds.TEMPORARY],
+      },
+    },
+  },
+
+  DUMMY_OPTION_ENTITIES: <FormFieldDefinition>{
+    key: 'sumaris.option.dummyEntities',
+    label: 'ACCOUNT.SETTINGS.DUMMY_ENTITIES',
+    type: 'entities',
+    minProfile: 'USER', // Should be login
+    autocomplete: {
+      showAllOnFocus: true,
+      attributes: ['firstName', 'lastName', 'id'],
+      filter: <PersonFilter>{
+        statusIds: [StatusIds.ENABLE, StatusIds.TEMPORARY],
+      },
+    },
+  },
+};

package/src/app/core/services/testing/referential-filter.model.ts

@@ -0,0 +1,28 @@
+import { EntityClass } from '../model/entity.decorators';
+import { EntityFilter } from '../model/filter.model';
+import { Referential } from '../model/referential.model';
+import { EntityUtils } from '../model/entity.model';
+
+import { FilterFn } from '../../../shared/types';
+
+// @dynamic
+@EntityClass({ typename: 'ReferentialFilterVO' })
+export class ReferentialFilter extends EntityFilter<ReferentialFilter, Referential> {
+  static fromObject: (source: any, opts?: any) => ReferentialFilter;
+
+  searchText: string;
+
+  fromObject(source: any, opts?: any) {
+    super.fromObject(source, opts);
+    this.searchText = source.searchText;
+  }
+
+  protected buildFilter(): FilterFn<Referential>[] {
+    const target = super.buildFilter();
+
+    const searchTextFn = EntityUtils.searchTextFilter(['label', 'name'], this.searchText);
+    if (searchTextFn) target.push(searchTextFn);
+
+    return target;
+  }
+}

package/src/app/core/services/testing/referential.validator.ts

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { AbstractControlOptions, UntypedFormBuilder, UntypedFormGroup, Validators } from '@angular/forms';
+import { Referential } from '../model/referential.model';
+import { AppValidatorService } from '../validator/base.validator.class';
+import { StatusIds } from '../model/model.enum';
+
+@Injectable()
+export class ReferentialValidatorService<T extends Referential = Referential> extends AppValidatorService<T> {
+  constructor(protected formBuilder: UntypedFormBuilder) {
+    super(formBuilder);
+  }
+
+  getRowValidator(): UntypedFormGroup {
+    return this.getFormGroup();
+  }
+
+  getFormGroup(
+    data?: T,
+    opts?: {
+      withDescription?: boolean;
+      withComments?: boolean;
+    }
+  ): UntypedFormGroup {
+    return this.formBuilder.group(this.getFormGroupConfig(data, opts), this.getFormGroupOptions(data, opts));
+  }
+
+  getFormGroupConfig(
+    data?: T,
+    opts?: {
+      withDescription?: boolean;
+      withComments?: boolean;
+    }
+  ): { [key: string]: any } {
+    const controlsConfig: { [key: string]: any } = {
+      id: [(data && data.id) || null],
+      updateDate: [(data && data.updateDate) || null],
+      creationDate: [(data && data.creationDate) || null],
+      statusId: [(data && data.statusId) || null, Validators.required],
+      levelId: [(data && data.levelId) || null],
+      label: [(data && data.label) || null, Validators.required],
+      name: [(data && data.name) || null, Validators.required],
+      entityName: [(data && data.entityName) || null, Validators.required],
+    };
+
+    if (!opts || opts.withDescription !== false) {
+      controlsConfig.description = [(data && data.description) || null, Validators.maxLength(255)];
+    }
+    if (!opts || opts.withComments !== false) {
+      controlsConfig.comments = [(data && data.comments) || null, Validators.maxLength(2000)];
+    }
+
+    return controlsConfig;
+  }
+
+  getFormGroupOptions(data?: T, opts?: any): AbstractControlOptions | null {
+    return null;
+  }
+}