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

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

@@ -1,598 +0,0 @@
-import {BehaviorSubject, Observable} from 'rxjs';
-import {filter, 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';
-
-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?: string;
-            sortDirection?: string;
-            filter?: (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?: string;
-    sortDirection?: string;
-    filter?: (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});
-    }
-    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 });
-    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 }) {
-    // 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();
-    this._cache.forEach((item, index) => {
-      this._statusById.set(item.id, <EntityStatus>{
-        index,
-        dirty: false
-      });
-    });
-
-    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?: string;
-                          sortDirection?: string;
-                          filter?: (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);
-    }
-
-    // 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/referential-filter.model.ts

@@ -1,28 +0,0 @@
-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/services/entity-service.class';
-
-// @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

@@ -1,57 +0,0 @@
-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;
-  }
-}