@sumaris-net/ngx-components 1.2.7 → 1.2.14

package/esm2020/src/app/core/services/model/config.model.mjs

@@ -0,0 +1,92 @@
+var Software_1, Configuration_1;
+import { __decorate } from "tslib";
+import { Entity, EntityUtils } from './entity.model';
+import { Department } from './department.model';
+import { fromDateISOString, toDateISOString } from '../../../shared/dates';
+import { isNotNil } from '../../../shared/functions';
+import { EntityClass } from './entity.decorators';
+// @dynamic
+let Software = Software_1 = class Software extends Entity {
+    constructor(__typename) {
+        super(__typename || Software_1.TYPENAME);
+    }
+    asObject(options) {
+        const target = super.asObject(options);
+        target.creationDate = toDateISOString(this.creationDate);
+        target.properties = this.properties;
+        return target;
+    }
+    fromObject(source) {
+        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 };
+        }
+    }
+};
+Software = Software_1 = __decorate([
+    EntityClass({ typename: 'SoftwareVO' })
+], Software);
+export { Software };
+// @dynamic
+let Configuration = Configuration_1 = class Configuration extends Software {
+    constructor() {
+        super(Configuration_1.TYPENAME);
+    }
+    clone() {
+        return this.copy(new Configuration_1());
+    }
+    copy(target) {
+        target.fromObject(this);
+        return target;
+    }
+    asObject(options) {
+        const target = super.asObject(options);
+        target.partners = this.partners && this.partners.map(p => p.asObject(options)) || undefined;
+        return target;
+    }
+    fromObject(source) {
+        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) {
+        const value = this.getProperty(definition);
+        return isNotNil(value) ? (value && value !== 'false') : undefined;
+    }
+    getPropertyAsInt(definition) {
+        const value = this.getProperty(definition);
+        return isNotNil(value) ? parseInt(value) : undefined;
+    }
+    getPropertyAsNumbers(definition) {
+        const value = this.getProperty(definition);
+        if (typeof value === 'string')
+            return value.split(',').map(parseFloat) || undefined;
+        return isNotNil(value) ? [parseFloat(value)] : undefined;
+    }
+    getPropertyAsStrings(definition) {
+        const value = this.getProperty(definition);
+        return value && value.split(',') || undefined;
+    }
+    getProperty(definition) {
+        return isNotNil(this.properties[definition.key]) ? this.properties[definition.key] : (definition.defaultValue || undefined);
+    }
+    hasProperty(definition) {
+        return isNotNil(this.properties[definition.key]);
+    }
+};
+Configuration = Configuration_1 = __decorate([
+    EntityClass({ typename: 'ConfigurationVO' })
+], Configuration);
+export { Configuration };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.model.js","sourceRoot":"","sources":["../../../../../../../src/app/core/services/model/config.model.ts"],"names":[],"mappings":"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","sourcesContent":["import {Moment} from 'moment';\nimport {FormFieldDefinition} from '../../../shared/form/field.model';\nimport {Entity, EntityAsObjectOptions, EntityUtils, IEntity} from './entity.model';\nimport {Department} from './department.model';\nimport {PropertiesMap} from '../../../shared/types';\nimport {fromDateISOString, toDateISOString} from '../../../shared/dates';\nimport {isNotNil} from '../../../shared/functions';\nimport {EntityClass} from './entity.decorators';\n\n// @dynamic\n@EntityClass({typename: 'SoftwareVO'})\nexport class Software<\n  T extends Software<any> = Software<any>\n  >\n  extends Entity<T, number>\n  implements IEntity<T, number> {\n\n static fromObject: (source: any, opts?: any) => Software;\n\n  label: string;\n  name: string;\n  description: string;\n  comments: string;\n  creationDate: Date | Moment;\n  statusId: number;\n  properties: PropertiesMap;\n\n  constructor(__typename?: string) {\n    super(__typename || Software.TYPENAME);\n  }\n\n  asObject(options?: EntityAsObjectOptions): any {\n    const target: any = super.asObject(options);\n    target.creationDate = toDateISOString(this.creationDate);\n    target.properties = this.properties;\n    return target;\n  }\n\n  fromObject(source: any) {\n    super.fromObject(source);\n    this.label = source.label;\n    this.name = source.name;\n    this.description = source.description;\n    this.comments = source.comments;\n    this.creationDate = fromDateISOString(source.creationDate);\n    this.statusId = source.statusId;\n\n    if (source.properties && Array.isArray(source.properties)) {\n      this.properties = EntityUtils.getPropertyArrayAsObject(source.properties);\n    } else {\n      this.properties = {...source.properties};\n    }\n  }\n}\n\n// @dynamic\n@EntityClass({typename: 'ConfigurationVO'})\nexport class Configuration extends Software<Configuration> {\n\n  static fromObject: (source: any, opts?: any) => Configuration;\n\n  smallLogo: string;\n  largeLogo: string;\n  backgroundImages: string[];\n  partners: Department[];\n\n  constructor() {\n    super(Configuration.TYPENAME);\n  }\n\n  clone(): Configuration {\n    return this.copy(new Configuration());\n  }\n\n  copy(target: Configuration): Configuration {\n    target.fromObject(this);\n    return target;\n  }\n\n  asObject(options?: EntityAsObjectOptions): any {\n    const target: any = super.asObject(options);\n    target.partners = this.partners && this.partners.map(p => p.asObject(options)) || undefined;\n    return target;\n  }\n\n  fromObject(source: any) {\n    super.fromObject(source);\n    this.smallLogo = source.smallLogo;\n    this.largeLogo = source.largeLogo;\n    this.backgroundImages = source.backgroundImages;\n    this.partners = source.partners && source.partners.map(Department.fromObject) || undefined;\n  }\n\n  getPropertyAsBoolean(definition: FormFieldDefinition): boolean {\n    const value = this.getProperty(definition);\n    return isNotNil(value) ? (value && value !== 'false') : undefined;\n  }\n\n  getPropertyAsInt(definition: FormFieldDefinition): number {\n    const value = this.getProperty(definition);\n    return isNotNil(value) ? parseInt(value) : undefined;\n  }\n\n  getPropertyAsNumbers(definition: FormFieldDefinition): number[] {\n    const value = this.getProperty(definition);\n    if (typeof value === 'string') return value.split(',').map(parseFloat) || undefined;\n    return isNotNil(value) ? [parseFloat(value)] : undefined;\n  }\n\n  getPropertyAsStrings(definition: FormFieldDefinition): string[] {\n    const value = this.getProperty(definition);\n    return value && value.split(',') || undefined;\n  }\n\n  getProperty<T = string>(definition: FormFieldDefinition): T {\n    return isNotNil(this.properties[definition.key]) ? this.properties[definition.key] : (definition.defaultValue || undefined);\n  }\n\n  hasProperty<T = string>(definition: FormFieldDefinition): boolean {\n    return isNotNil(this.properties[definition.key]);\n  }\n}\n"]}

package/esm2020/src/app/core/services/model/department.model.mjs

@@ -0,0 +1,30 @@
+var Department_1;
+import { __decorate } from "tslib";
+import { BaseReferential } from './referential.model';
+import { EntityClass } from './entity.decorators';
+// @dynamic
+let Department = Department_1 = class Department extends BaseReferential {
+    constructor() {
+        super(Department_1.TYPENAME);
+        this.entityName = Department_1.ENTITY_NAME;
+    }
+    fromObject(source) {
+        super.fromObject(source);
+        this.entityName = source.entityName || Department_1.ENTITY_NAME;
+        this.logo = source.logo;
+        this.siteUrl = source.siteUrl;
+        delete this.entityName; // not need
+    }
+};
+Department.ENTITY_NAME = 'Department';
+Department = Department_1 = __decorate([
+    EntityClass({ typename: 'DepartmentVO' })
+], Department);
+export { Department };
+export function departmentToString(obj) {
+    return obj && obj.id && (obj.name) || undefined;
+}
+export function departmentsToString(data, separator) {
+    return (data || []).map(departmentToString).join(separator || ', ');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/core/services/model/entity.decorators.mjs

@@ -0,0 +1,97 @@
+import { environment } from '../../../../environments/environment';
+import { Entity } from './entity.model';
+import { removeEnd } from '../../../shared/functions';
+export class EntityClasses {
+    static register(typename, entityClass) {
+        // 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(entityName) {
+        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(value, opts) {
+        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);
+        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);
+    }
+}
+EntityClasses.CLASSES_BY_NAME = new Map();
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+export function EntityClass(opts) {
+    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+    return function (constructor) {
+        // 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;
+        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, opts) {
+                if (!source)
+                    return undefined;
+                if (source instanceof constructor)
+                    return source.clone(opts);
+                const target = new constructor();
+                target.fromObject(source, opts);
+                return target;
+            };
+            clazz.asObject = function (source, opts) {
+                if (!source)
+                    return undefined;
+                if (source instanceof constructor)
+                    return source.asObject(opts);
+                return Object.assign({}, source);
+            };
+        }
+        else {
+            clazz.fromObject = function (source, opts) {
+                if (!source)
+                    return undefined;
+                if (source instanceof constructor) {
+                    // DEBUG
+                    //console.debug('@EntityClass() fromObject() => will recycle existing object: ', source);
+                    return source;
+                }
+                const target = new constructor();
+                target.fromObject(source, opts);
+                return target;
+            };
+            clazz.asObject = function (source, opts) {
+                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;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity.decorators.js","sourceRoot":"","sources":["../../../../../../../src/app/core/services/model/entity.decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { environment } from '../../../../environments/environment';\nimport { Entity } from './entity.model';\nimport { removeEnd } from '../../../shared/functions';\n\ndeclare type Constructor = new(...args: any[]) => any;\n\nexport class EntityClasses {\n  static CLASSES_BY_NAME = new Map<string, Constructor>();\n\n  static register(typename: string, entityClass: Constructor) {\n    // Convert to extract entityName\n    const entityName = removeEnd(typename, 'VO');\n    // DEBUG\n    //console.debug('[entity-classes] Detected entity class ' + entityName);\n\n    // Add to map\n    EntityClasses.CLASSES_BY_NAME.set(entityName, entityClass);\n  }\n\n  static get<T extends Entity<T>>(entityName: string): Constructor {\n    const entityClass = EntityClasses.CLASSES_BY_NAME.get(entityName);\n    if (!entityClass) {\n      throw new Error('Cannot found entity class \\'' + entityName + '\\'. Make sure it exists and has the @EntityClass decorator.');\n    }\n    return entityClass;\n  }\n\n  static fromObject<T extends Entity<T>>(value: any, opts?: {\n    [key: string]: any;\n    typename?: string;\n    entityName?: string;\n  }): T {\n    if (!value) return value;\n    const entityName = (opts && opts.entityName) || removeEnd(value.__typename || opts?.typename, 'VO');\n    if (!entityName) throw new Error('Missing one of \\'value.__typename\\', \\'opts.entityName\\', or \\'opts.typename\\'.');\n    const entityClass = EntityClasses.get(entityName) as any;\n    if (typeof entityClass.fromObject !== 'function') {\n      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');\n    }\n    return entityClass.fromObject(value, opts) as T;\n  }\n}\n\n// eslint-disable-next-line prefer-arrow/prefer-arrow-functions\nexport function EntityClass(opts: {\n  typename: string;\n  fromObjectReuseStrategy?: 'default' | 'clone';\n}) {\n\n  // eslint-disable-next-line prefer-arrow/prefer-arrow-functions\n  return function <T extends Constructor>(constructor: T) {\n\n    // Make sure the class extends Entity\n    if (!environment.production) {\n      const obj = new constructor();\n      if (!(obj instanceof Entity)) {\n        throw new Error(`Class ${constructor.name} must extends <<Entity>> to be able to use @FromObject!`);\n      }\n    }\n\n    const clazz = (constructor as any)\n    const typename = opts.typename || `${constructor.name}VO`;\n\n    // Define static field TYPENAME\n    clazz.TYPENAME = typename;\n\n    // Define static fromObject()\n    if (opts.fromObjectReuseStrategy === 'clone') {\n\n      clazz.fromObject = function(source: any, opts?: any): T {\n        if (!source) return undefined;\n        if (source instanceof constructor) return (source as any).clone(opts) as T;\n        const target: any = new constructor();\n        target.fromObject(source, opts);\n        return target as T;\n      };\n      clazz.asObject = function(source: any, opts?: any): any {\n        if (!source) return undefined;\n        if (source instanceof constructor) return source.asObject(opts);\n        return Object.assign({}, source);\n      };\n    }\n    else {\n      clazz.fromObject = function(source: any, opts?: any): T {\n        if (!source) return undefined;\n        if (source instanceof constructor) {\n          // DEBUG\n          //console.debug('@EntityClass() fromObject() => will recycle existing object: ', source);\n          return source as T;\n        }\n        const target: any = new constructor();\n        target.fromObject(source, opts);\n        return target as T;\n      };\n\n      clazz.asObject = function(source: any, opts?: any): any {\n        if (!source) return undefined;\n        if (source instanceof constructor) {\n          return source.asObject(opts);\n        }\n        // DEBUG\n        //console.debug('@EntityClass() asObject() => will recycle existing object: ', source);\n        return source;\n      };\n    }\n\n    // Register the entity class\n    EntityClasses.register(typename, constructor);\n\n    return constructor;\n  };\n}\n"]}

package/esm2020/src/app/core/services/model/entity.model.mjs

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