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

package/src/app/core/services/model/config.model.ts

@@ -0,0 +1,122 @@
+import {Moment} from 'moment';
+import {FormFieldDefinition} from '../../../shared/form/field.model';
+import {Entity, EntityAsObjectOptions, EntityUtils, IEntity} from './entity.model';
+import {Department} from './department.model';
+import {PropertiesMap} from '../../../shared/types';
+import {fromDateISOString, toDateISOString} from '../../../shared/dates';
+import {isNotNil, undefinedIfNull} from '../../../shared/functions';
+import {EntityClass} from './entity.decorators';
+
+// @dynamic
+@EntityClass({typename: 'SoftwareVO'})
+export class Software<
+  T extends Software<any> = Software<any>
+  >
+  extends Entity<T, number>
+  implements IEntity<T, number> {
+
+ static fromObject: (source: any, opts?: any) => Software;
+
+  label: string;
+  name: string;
+  description: string;
+  comments: string;
+  creationDate: Date | Moment;
+  statusId: number;
+  properties: PropertiesMap;
+
+  constructor(__typename?: string) {
+    super(__typename || Software.TYPENAME);
+  }
+
+  asObject(options?: EntityAsObjectOptions): any {
+    const target: any = super.asObject(options);
+    target.creationDate = toDateISOString(this.creationDate);
+    target.properties = this.properties;
+    return target;
+  }
+
+  fromObject(source: any) {
+    super.fromObject(source);
+    this.label = source.label;
+    this.name = source.name;
+    this.description = source.description;
+    this.comments = source.comments;
+    this.creationDate = fromDateISOString(source.creationDate);
+    this.statusId = source.statusId;
+
+    if (source.properties && Array.isArray(source.properties)) {
+      this.properties = EntityUtils.getPropertyArrayAsObject(source.properties);
+    } else {
+      this.properties = {...source.properties};
+    }
+  }
+}
+
+// @dynamic
+@EntityClass({typename: 'ConfigurationVO'})
+export class Configuration extends Software<Configuration> {
+
+  static fromObject: (source: any, opts?: any) => Configuration;
+
+  smallLogo: string;
+  largeLogo: string;
+  backgroundImages: string[];
+  partners: Department[];
+
+  constructor() {
+    super(Configuration.TYPENAME);
+  }
+
+  clone(): Configuration {
+    return this.copy(new Configuration());
+  }
+
+  copy(target: Configuration): Configuration {
+    target.fromObject(this);
+    return target;
+  }
+
+  asObject(options?: EntityAsObjectOptions): any {
+    const target: any = super.asObject(options);
+    target.partners = this.partners && this.partners.map(p => p.asObject(options)) || undefined;
+    return target;
+  }
+
+  fromObject(source: any) {
+    super.fromObject(source);
+    this.smallLogo = source.smallLogo;
+    this.largeLogo = source.largeLogo;
+    this.backgroundImages = source.backgroundImages;
+    this.partners = source.partners && source.partners.map(Department.fromObject) || undefined;
+  }
+
+  getPropertyAsBoolean(definition: FormFieldDefinition): boolean {
+    const value = this.getProperty(definition);
+    return isNotNil(value) ? (value && value !== 'false') : undefined;
+  }
+
+  getPropertyAsInt(definition: FormFieldDefinition): number {
+    const value = this.getProperty(definition);
+    return isNotNil(value) ? parseInt(value) : undefined;
+  }
+
+  getPropertyAsNumbers(definition: FormFieldDefinition): number[] {
+    const value = this.getProperty(definition);
+    if (typeof value === 'string') return value.split(',').map(parseFloat) || undefined;
+    return isNotNil(value) ? [parseFloat(value)] : undefined;
+  }
+
+  getPropertyAsStrings(definition: FormFieldDefinition): string[] {
+    const value = this.getProperty(definition);
+    return value && value.split(',') || undefined;
+  }
+
+  getProperty<T = string>(definition: FormFieldDefinition): T {
+    return isNotNil(this.properties[definition.key]) ? this.properties[definition.key] : undefinedIfNull(definition.defaultValue);
+  }
+
+  hasProperty<T = string>(definition: FormFieldDefinition): boolean {
+    return isNotNil(this.properties[definition.key]);
+  }
+}

package/src/app/core/services/model/department.model.ts

@@ -0,0 +1,34 @@
+import {BaseReferential} from './referential.model';
+import {EntityClass} from './entity.decorators';
+
+// @dynamic
+@EntityClass({typename: 'DepartmentVO'})
+export class Department extends BaseReferential<Department> {
+
+  static ENTITY_NAME = 'Department';
+  static fromObject: (source: any, opts?: any) => Department;
+
+  logo: string;
+  siteUrl: string;
+
+  constructor() {
+    super(Department.TYPENAME);
+    this.entityName = Department.ENTITY_NAME;
+  }
+
+  fromObject(source: any) {
+    super.fromObject(source);
+    this.entityName = source.entityName || Department.ENTITY_NAME;
+    this.logo = source.logo;
+    this.siteUrl = source.siteUrl;
+    delete this.entityName; // not need
+  }
+}
+
+export function departmentToString(obj: Department): string {
+  return obj && obj.id && (obj.name) || undefined;
+}
+
+export function departmentsToString(data: Department[], separator?: string): string {
+  return (data || []).map(departmentToString).join(separator || ', ');
+}

package/src/app/core/services/model/entity.decorators.ts

@@ -0,0 +1,112 @@
+import { environment } from '../../../../environments/environment';
+import { Entity } from './entity.model';
+import { removeEnd } from '../../../shared/functions';
+
+declare type Constructor = new(...args: any[]) => any;
+
+export class EntityClasses {
+  static CLASSES_BY_NAME = new Map<string, Constructor>();
+
+  static register(typename: string, entityClass: Constructor) {
+    // Convert to extract entityName
+    const entityName = removeEnd(typename, 'VO');
+    // DEBUG
+    //console.debug('[entity-classes] Detected entity class ' + entityName);
+
+    // Add to map
+    EntityClasses.CLASSES_BY_NAME.set(entityName, entityClass);
+  }
+
+  static get<T extends Entity<T>>(entityName: string): Constructor {
+    const entityClass = EntityClasses.CLASSES_BY_NAME.get(entityName);
+    if (!entityClass) {
+      throw new Error('Cannot found entity class \'' + entityName + '\'. Make sure it exists and has the @EntityClass decorator.');
+    }
+    return entityClass;
+  }
+
+  static fromObject<T extends Entity<T>>(value: any, opts?: {
+    [key: string]: any;
+    typename?: string;
+    entityName?: string;
+  }): T {
+    if (!value) return value;
+    const entityName = (opts && opts.entityName) || removeEnd(value.__typename || opts?.typename, 'VO');
+    if (!entityName) throw new Error('Missing one of \'value.__typename\', \'opts.entityName\', or \'opts.typename\'.');
+    const entityClass = EntityClasses.get(entityName) as any;
+    if (typeof entityClass.fromObject !== 'function') {
+      throw new Error('Cannot found the static function \'' + entityName + '.fromObject()\'. Make sure this function has been declared and the entity class has the @EntityClass decorator');
+    }
+    return entityClass.fromObject(value, opts) as T;
+  }
+}
+
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+export function EntityClass(opts: {
+  typename: string;
+  fromObjectReuseStrategy?: 'default' | 'clone';
+}) {
+
+  // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+  return function <T extends Constructor>(constructor: T) {
+
+    // Make sure the class extends Entity
+    if (!environment.production) {
+      const obj = new constructor();
+      if (!(obj instanceof Entity)) {
+        throw new Error(`Class ${constructor.name} must extends <<Entity>> to be able to use @FromObject!`);
+      }
+    }
+
+    const clazz = (constructor as any)
+    const typename = opts.typename || `${constructor.name}VO`;
+
+    // Define static field TYPENAME
+    clazz.TYPENAME = typename;
+
+    // Define static fromObject()
+    if (opts.fromObjectReuseStrategy === 'clone') {
+
+      clazz.fromObject = function(source: any, opts?: any): T {
+        if (!source) return undefined;
+        if (source instanceof constructor) return (source as any).clone(opts) as T;
+        const target: any = new constructor();
+        target.fromObject(source, opts);
+        return target as T;
+      };
+      clazz.asObject = function(source: any, opts?: any): any {
+        if (!source) return undefined;
+        if (source instanceof constructor) return source.asObject(opts);
+        return Object.assign({}, source);
+      };
+    }
+    else {
+      clazz.fromObject = function(source: any, opts?: any): T {
+        if (!source) return undefined;
+        if (source instanceof constructor) {
+          // DEBUG
+          //console.debug('@EntityClass() fromObject() => will recycle existing object: ', source);
+          return source as T;
+        }
+        const target: any = new constructor();
+        target.fromObject(source, opts);
+        return target as T;
+      };
+
+      clazz.asObject = function(source: any, opts?: any): any {
+        if (!source) return undefined;
+        if (source instanceof constructor) {
+          return source.asObject(opts);
+        }
+        // DEBUG
+        //console.debug('@EntityClass() asObject() => will recycle existing object: ', source);
+        return source;
+      };
+    }
+
+    // Register the entity class
+    EntityClasses.register(typename, constructor);
+
+    return constructor;
+  };
+}

package/src/app/core/services/model/entity.model.ts

@@ -0,0 +1,326 @@
+import { Moment } from 'moment';
+import {getPropertyByPath, isEmptyArray, isNil, isNilOrBlank, isNotNil, joinPropertiesPath} from '../../../shared/functions';
+import { FilterFn } from '../../../shared/services/entity-service.class';
+import { ObjectMap, ObjectMapEntry, PropertiesArray, PropertiesMap } from '../../../shared/types';
+import { StoreObject } from '@apollo/client/core';
+import { fromDateISOString, toDateISOString } from '../../../shared/dates';
+
+
+export declare interface Cloneable<T> {
+  clone(): T;
+}
+
+export function entityToString(obj: Entity<any> | any, properties?: string[]): string | undefined {
+  return obj && obj.id && joinPropertiesPath(obj, properties || ['name']) || undefined;
+}
+
+export interface EntityAsObjectOptions {
+  minify?: boolean;
+  keepTypename?: boolean; // true by default
+  keepLocalId?: boolean; // true by default
+}
+
+export interface IEntity<T,
+  ID = number,
+  AO extends EntityAsObjectOptions = EntityAsObjectOptions,
+  FO = any
+  >
+  extends Cloneable<T> {
+  id: ID;
+  updateDate: Moment;
+  __typename: string;
+  equals(other: T): boolean;
+  clone(opts?: AO & FO): T;
+  copy(target: T, opts?: AO & FO);
+  asObject(opts?: AO): any;
+  fromObject(source: any, opts?: FO);
+}
+
+export declare interface ITreeItemEntity<
+  T extends IEntity<T, ID>,
+  ID = number
+  > {
+  parentId: ID;
+  parent: T;
+  children: T[];
+}
+
+//@dynamic
+export abstract class Entity<
+  T extends Entity<T, ID, AO, FO>,
+  ID = number,
+  AO extends EntityAsObjectOptions = EntityAsObjectOptions,
+  FO = any>
+  implements IEntity<T, ID, AO, FO> {
+
+  // The GraphQL typename (injected by @EntityClass())
+  static TYPENAME: string;
+
+  id: ID = null;
+  updateDate: Moment = null;
+  __typename: string;
+
+  constructor(__typename?: string) {
+    this.__typename = __typename || null;
+  }
+
+  clone(opts?: AO & FO): T {
+    const target = new (this.constructor as any)() as T;
+    this.copy(target, opts);
+    return target;
+  }
+
+  copy(target: T, opts?: AO & FO) {
+    target.fromObject(this.asObject(opts), opts);
+  }
+
+  asObject(opts?: AO): StoreObject {
+    const target: any = Object.assign({}, this); //= {...this};
+    if (!opts || opts.keepTypename !== true) delete target.__typename;
+    target.updateDate = toDateISOString(this.updateDate);
+    if (target.id == null || (opts && opts.keepLocalId === false && target.id < 0)) {
+      delete target.id;
+      delete target.updateDate; // Make to sens to keep updateDate of a local entity to save
+    }
+    return target;
+  }
+
+  fromObject(source: any, opts?: FO) {
+    this.id = (source.id || source.id === 0) ? source.id : undefined;
+    this.updateDate = fromDateISOString(source.updateDate);
+    this.__typename = source.__typename || this.__typename; // Keep original type (can be set in constructor)
+  }
+
+  equals(other: T): boolean {
+    return other && this.id === other.id;
+  }
+}
+
+/**
+ * @deprecated use standard instanceof instead
+ * @param obj
+ * @param constructor
+ */
+export function isInstanceOf<T>(obj: any, constructor: new (...args: any[]) => T): obj is T {
+  if (!obj) return false;
+
+  return obj instanceof constructor;
+}
+
+// @dynamic
+export abstract class EntityUtils {
+
+  // Check that the object has a NOT nil attribute (ID by default)
+  static isEntity<T extends IEntity<any>>(obj: T|any): obj is T {
+    return isNotNil(obj?.__typename) && (typeof obj.fromObject === 'function') && (typeof obj.asObject === 'function');
+  }
+
+  // Check that the object has a NOT nil attribute (ID by default)
+  static isNotEmpty<T extends IEntity<any> | any>(obj: T, checkedAttribute: keyof T): boolean {4
+    return !!obj && obj[checkedAttribute] !== null && obj[checkedAttribute] !== undefined;
+  }
+
+  static isEmpty<T extends IEntity<any> | any>(obj: T, checkedAttribute: keyof T): boolean {
+    return !obj || obj[checkedAttribute] === null || obj[checkedAttribute] === undefined;
+  }
+
+  static equals<T extends IEntity<any> | any>(o1: T, o2: T, checkAttribute?: keyof T): boolean {
+    checkAttribute = checkAttribute || 'id' as keyof T;
+    return (o1 === o2) || (isNil(o1) && isNil(o2))  || (o1 && o2 && o1[checkAttribute] === o2[checkAttribute]);
+  }
+
+  static getPropertyByPath = getPropertyByPath;
+
+  static getArrayAsMap<T = any>(source?: ObjectMapEntry<T>[]): ObjectMap<T> {
+    return (source || []).reduce((res, item) => {
+      res[item.key] = item.value;
+      return res;
+    }, {});
+  }
+
+  static getMapAsArray<T = any>(source?: ObjectMap<T>): ObjectMapEntry<T>[] {
+    if (Array.isArray(source)) return source;
+    return Object.getOwnPropertyNames(source || {})
+      .map(key => ({
+          key,
+          value: source[key]
+        }));
+  }
+
+  static getPropertyArrayAsObject(source?: PropertiesArray): PropertiesMap {
+    return (source || []).reduce((res, item) => {
+      res[item.key] = item.value;
+      return res;
+    }, {});
+  }
+
+  static copyIdAndUpdateDate<T extends Entity<any, any, any>>(source: T, target: T) {
+    if (!source) return;
+
+    // Update (id and updateDate)
+    target.id = isNotNil(source.id) ? source.id : target.id;
+    target.updateDate = fromDateISOString(source.updateDate) || target.updateDate;
+
+    // Update creation Date, if exists
+    if (source['creationDate']) {
+      target['creationDate'] = fromDateISOString(source['creationDate']);
+    }
+  }
+
+
+  static async fillLocalIds<T extends IEntity<T>>(items: T[], sequenceFactory: (firstEntity: T, incrementSize: number) => Promise<number>) {
+    const newItems = (items || []).filter(item => isNil(item.id) || item.id === 0);
+    if (isEmptyArray(newItems)) return;
+    // Get the sequence
+    let currentId = await sequenceFactory(newItems[0], newItems.length) + 1;
+    // Take the min (sequence, id), in case the sequence is corrupted
+    currentId = items.filter(item => isNotNil(item.id) && item.id < 0).reduce((res, item) => Math.min(res, item.id), currentId);
+    newItems.forEach(item => item.id = --currentId);
+  }
+
+  static cleanIdAndUpdateDate<T extends IEntity<T>>(source: T) {
+    if (!source) return; // Skip
+    source.id = null;
+    source.updateDate = null;
+  }
+
+  static cleanIdsAndUpdateDates<T extends IEntity<T>>(items: T[]) {
+    (items || []).forEach(EntityUtils.cleanIdAndUpdateDate);
+  }
+
+  static sort<T extends IEntity<T> | any>(data: T[], sortBy?: string, sortDirection?: string): T[] {
+    if (!data || data.length <= 1 || !sortBy) return data;
+    return data.sort(this.sortComparator(sortBy, sortDirection));
+  }
+
+  static sortComparator<T extends IEntity<T> | any>(sortBy?: string, sortDirection?: string): (a: T, b: T) => number {
+    const after = (!sortDirection || sortDirection === 'asc') ? 1 : -1;
+    const property = sortBy || 'id';
+    return (a, b) => {
+      const valueA = EntityUtils.getPropertyByPath(a, property);
+      const valueB = EntityUtils.getPropertyByPath(b, property);
+      return EntityUtils.compare(valueA, valueB, after);
+    };
+  }
+
+  static compare<T extends IEntity<any>>(value1: T, value2: T, direction: 1 | -1, checkAttribute?: keyof T): number {
+    checkAttribute = checkAttribute || 'id';
+    if (EntityUtils.isNotEmpty(value1, checkAttribute) && EntityUtils.isNotEmpty(value2, checkAttribute)) {
+      return EntityUtils.equals(value1, value2, checkAttribute) ? 0 : (value1[checkAttribute] > value2[checkAttribute] ? direction : (-1 * direction));
+    }
+    return value1 === value2 ? 0 : (value1 > value2 ? direction : (-1 * direction));
+  }
+
+  static compareValue<T>(value1: T, value2: T, direction: 1 | -1): number {
+    return value1 === value2 ? 0 : (value1 > value2 ? direction : (-1 * direction));
+  }
+
+  static filter<T extends IEntity<T> | any>(data: T[],
+                                           searchAttribute: string,
+                                           searchText: string): T[] {
+    const filterFn = this.searchTextFilter(searchAttribute, searchText);
+    return data.filter(filterFn);
+  }
+
+  static searchTextFilter<T extends IEntity<T> | any>(searchAttribute: string | string[],
+                                                     searchText: string): FilterFn<T> {
+    if (isNilOrBlank(searchAttribute) || isNilOrBlank(searchText)) return undefined; // filter not need
+
+    const searchRegexp = searchText
+      // Escape special characters
+      .replace(/[-\/\\^$+.()|[\]{}]/g, '\\$&')
+      // Interpret * as any text
+      .replace(/[*]+/g, '.*')
+      // Interpret ? as one character
+      .replace(/[?]/g, '.');
+    if (searchRegexp === '.*') return undefined; // filter not need
+
+    const flags = 'i'; // don't use global regex search
+    const asPrefixPattern = '^' + searchRegexp;
+    const anyMatchPattern = '^.*' + searchRegexp;
+
+    // Only one search attributes
+    if (typeof searchAttribute === 'string') {
+      const isSimplePath = !searchAttribute || searchAttribute.indexOf('.') === -1;
+      const searchAsPrefix =  searchAttribute.toLowerCase().endsWith('label') || searchAttribute.toLowerCase().endsWith('code');
+      const regexp = new RegExp(searchAsPrefix && asPrefixPattern || anyMatchPattern, flags);
+      if (isSimplePath) {
+        return a => regexp.test( a[searchAttribute]);
+      }
+      else {
+        return a => regexp.test(EntityUtils.getPropertyByPath(a, searchAttribute));
+      }
+    }
+
+    // many search attributes
+    else {
+      const regexps = searchAttribute.map(path => {
+        const searchAsPrefix =  path.toLowerCase().endsWith('label') || path.toLowerCase().endsWith('code');
+        return new RegExp( searchAsPrefix && asPrefixPattern || anyMatchPattern, flags);
+      });
+      return a => searchAttribute.findIndex((path, index) => regexps[index].test(EntityUtils.getPropertyByPath(a, path))) !== -1;
+    }
+  }
+
+  /**
+   * Transform a batch entity tree into a array list. This method keep links parent/children.
+   *
+   * Method used to find batch without id (e.g. before local storage)
+   *
+   * @param source
+   */
+  static treeToArray<T extends ITreeItemEntity<any>>(source: T): T[] {
+    if (!source) return null;
+    return (source.children || []).reduce((res, batch) => {
+      batch.parent = source;
+      return res.concat(this.treeToArray(batch)); // recursive call
+    }, [source]);
+  }
+
+  static listOfTreeToArray<T extends ITreeItemEntity<any>>(sources: T[]): T[] {
+    if (!sources || !sources.length) return null;
+    return sources.reduce((res, source) => res.concat(this.treeToArray<T>(source)), []);
+  }
+
+  /**
+   * Fill parent attribute, of all children found in the tree
+   *
+   * @param source
+   */
+  static treeFillParent<T extends ITreeItemEntity<any>>(source: T): T[] {
+    if (!source) return null;
+    (source.children || []).forEach(child => {
+      child.parent = source;
+      this.treeFillParent(child); // Loop
+    });
+  }
+
+  static isLocal(entity: IEntity<any, any> | Entity<any, any>): boolean {
+    return entity && (isNotNil(entity.id) && +entity.id < 0);
+  }
+
+  static isRemote(entity: IEntity<any, any> | Entity<any, any>): boolean {
+    return entity && !EntityUtils.isLocal(entity);
+  }
+
+  static isLocalId(id: number): boolean {
+    return isNotNil(id) && +id < 0;
+  }
+
+  static isRemoteId(id: number): boolean {
+    return isNotNil(id) && +id >= 0;
+  }
+
+  static getId<T extends IEntity<T, ID> = IEntity<any, any>, ID = any>(entity: T): ID {
+    return entity.id
+  }
+
+  static collectById<T extends IEntity<T, ID>, ID = any>(entities: T[]): ID[] {
+    return (entities || []).map(e => e.id);
+  }
+
+  static arrayDistinctFilterFn<E extends IEntity<any, any>>(item: E, index: number, values: E[]): boolean {
+    return values.findIndex(e => e.id === item.id) === index;
+  }
+
+}