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

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

@@ -0,0 +1,139 @@
+import {isEmptyArray} from '../../../shared/functions';
+import {MINIFY_ENTITY_FOR_POD, ReferentialUtils} from './referential.model';
+import {Entity, EntityAsObjectOptions, IEntity, isInstanceOf} from './entity.model';
+import {FilterFn} from '../../../shared/services/entity-service.class';
+import {Person} from './person.model';
+import {Department} from './department.model';
+
+
+export interface IEntityFilter<F extends IEntityFilter<F, T, ID, AO, FO>,
+  T extends IEntity<T, any>,
+  ID = number,
+  AO extends EntityAsObjectOptions = EntityAsObjectOptions,
+  FO = any> extends IEntity<F, ID, AO, FO> {
+
+  filterName: string;
+  filterType: string;
+  filterRecorderPersonId: number;
+  filterRecorderDepartmentId: number;
+
+  asPodObject(): any;
+
+  asFilterFn(): FilterFn<T>;
+
+  isEmpty(): boolean;
+
+  countNotEmptyCriteria(): number;
+}
+
+export abstract class EntityFilter<F extends EntityFilter<F, T, ID, AO, FO>,
+  T extends IEntity<T, any>,
+  ID = number,
+  AO extends EntityAsObjectOptions = EntityAsObjectOptions,
+  FO = any>
+  extends Entity<F, ID, AO, FO>
+  implements IEntityFilter<F, T, ID, AO, FO> {
+
+  filterName: string;
+  filterType: string;
+  filterRecorderPersonId: number;
+  filterRecorderDepartmentId: number;
+
+  /**
+   * Compose some filter functions: all should return true
+   * @param filterFns
+   */
+  static composeFilters<T extends IEntity<T, any>>(filterFns: FilterFn<T>[]): FilterFn<T> {
+    if (isEmptyArray(filterFns)) return undefined;
+    return (entity) => (filterFns || []).every(fn => fn(entity))
+  }
+
+  static compose<F extends EntityFilter<F, T>, T extends IEntity<T>>(filters: F[]): FilterFn<T> {
+    const filterFns = (filters || []).reduce((res, f) => {
+      const fns = f.buildFilter();
+      if (!fns) return res;
+      return res.concat(fns);
+    }, []);
+    return this.composeFilters(filterFns);
+  }
+
+  /**
+   * Compose some filter functions: all should return true
+   * @param filterFns
+   */
+  static composeFns<T extends IEntity<T, any>>(filterFns: FilterFn<T>[]): FilterFn<T> {
+      if (isEmptyArray(filterFns)) return undefined;
+    return (entity) => (filterFns || []).every(fn => fn(entity))
+  }
+
+  constructor(__typename?: string) {
+    super(__typename);
+  }
+
+  /**
+   * Clean a filter, before sending to the pod (e.g convert dates, remove internal properties, etc.)
+   */
+  asPodObject(): any {
+    return this.asObject(MINIFY_ENTITY_FOR_POD as AO);
+  }
+
+  isEmpty(): boolean {
+    return this.countNotEmptyCriteria() === 0;
+  }
+
+  countNotEmptyCriteria(): number {
+    const json = this.asPodObject();
+    return Object.keys(json)
+      .filter(key => this.isCriteriaNotEmpty(key, json[key]))
+      .length;
+  }
+
+  asFilterFn(): FilterFn<T> {
+    const filterFns = this.buildFilter();
+    return EntityFilter.composeFns(filterFns);
+  }
+
+  protected buildFilter(): FilterFn<T>[] {
+    // Can be completed by subclasses
+    return [];
+  }
+
+  protected isCriteriaNotEmpty(key: string, value: any): boolean {
+    // Can be overridden by subclasses
+    return value !== undefined
+      && value !== null
+      && (
+        // not empty string
+        (typeof value === 'string' && value.trim() !== '')
+        // valid number
+        || (typeof value === 'number' && !isNaN(value))
+        // valid boolean
+        || (typeof value === 'boolean')
+        // not empty array
+        || (Array.isArray(value) && value.length > 0)
+        // entity with an id
+        || ReferentialUtils.isNotEmpty(value)
+      );
+  }
+}
+
+export abstract class EntityFilterUtils {
+
+  static isEntityFilter<F extends EntityFilter<F, any>>(obj: Partial<F>): obj is F {
+    return obj && obj.asPodObject && obj.asFilterFn && true || false;
+  }
+
+  static fromObject<F>(source: any, filterType: new () => F): F {
+    if (!source) return source;
+    if (isInstanceOf(source, filterType)) return source as F;
+    const target = new filterType();
+    if (EntityFilterUtils.isEntityFilter(target)) {
+      target.fromObject(source);
+    } else {
+      Object.assign(target, source);
+    }
+    return target;
+  }
+
+
+}

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

@@ -0,0 +1,25 @@
+import {Moment} from 'moment';
+
+export declare interface SynchronizationHistory {
+  name: string;
+  filter?: any;
+  execDate: string;
+  execDurationMs: number;
+  lastUpdateDate?: string;
+  children?: SynchronizationHistory[];
+}
+
+export interface HistoryPageReference {
+  title: string;
+  subtitle?: string;
+  path: string;
+  time?: Moment | string;
+  icon?: string;
+  matIcon?: string;
+
+  children?: HistoryPageReference[];
+
+  // Manage visibility and data access
+  offline?: boolean;
+  onlinePeer?: string;
+}

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

@@ -0,0 +1,11 @@
+
+// TODO: rename to STATUS_ID_MAP
+// then declare a type like this :
+// > export declare type StatusIds = keyof typeof STATUS_ID_MAP;
+export const StatusIds = {
+  DISABLE: 0,
+  ENABLE: 1,
+  TEMPORARY: 2,
+  DELETED: 3,
+  ALL: 99
+};

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

@@ -0,0 +1,86 @@
+/* -- Network -- */
+
+import {isNilOrBlank, isNotNil, isNotNilOrBlank, noTrailingSlash} from '../../../shared/functions';
+import {Cloneable, Entity, EntityAsObjectOptions} from './entity.model';
+import {EntityClass} from './entity.decorators';
+
+// @dynamic
+@EntityClass({typename: 'PeerVO'})
+export class Peer extends Entity<Peer> implements Cloneable<Peer> {
+
+  static fromObject: (source: any, opts?: any) => Peer;
+
+  static parseUrl(peerUrl: string) {
+    const url = new URL(peerUrl);
+    return this.fromObject({
+      dns: url.hostname,
+      port: isNilOrBlank(url.port) ? undefined : url.port,
+      useSsl: url.protocol && (url.protocol.startsWith('https') || url.protocol.startsWith('wss')),
+      path: noTrailingSlash(url.pathname)
+    });
+  }
+  static path(peer: Peer, ...paths: string[]): string {
+    if (!peer) throw new Error('Missing required argument \'peer\'!');
+    // Remove starting slashes
+    paths = (paths || []).map(path => {
+      if (path.startsWith('./')) return path.substring(2);
+      if (path.startsWith('/')) return path.substring(1);
+      return path;
+    }).filter(isNotNilOrBlank);
+    return [noTrailingSlash(this.fromObject(peer).url)].concat(...paths).join('/');
+  }
+
+  dns: string;
+  ipv4: string;
+  ipv6: string;
+  port: number;
+  useSsl: boolean;
+  pubkey: string;
+  path?: string;
+
+  favicon: string;
+  status: 'UP' | 'DOWN';
+  softwareName: string;
+  softwareVersion: string;
+  label: string;
+  name: string;
+
+  constructor() {
+    super(Peer.TYPENAME);
+  }
+
+  asObject(options?: EntityAsObjectOptions): any {
+    return super.asObject(options);
+  }
+
+  fromObject(source: any) {
+    super.fromObject(source);
+    this.dns = source.dns || source.host;
+    this.ipv4 = source.ipv4;
+    this.ipv6 = source.ipv6;
+    this.port = isNotNil(source.port) ? +source.port : undefined;
+    this.pubkey = source.pubkey;
+    this.useSsl = source.useSsl || (this.port === 443);
+    this.path = source.path || '';
+  }
+
+  equals(other: Peer): boolean {
+    return super.equals(other) && this.pubkey === other.pubkey && this.url === other.url;
+  }
+
+  /**
+   * Return the peer URL (without trailing slash)
+   */
+  get url(): string {
+    return (this.useSsl ? 'https://' : 'http://') + this.hostAndPort + (this.path || '');
+  }
+
+  get hostAndPort(): string {
+    return (this.dns || this.ipv4 || this.ipv6) +
+      ((this.port && this.port !== 80 && this.port !== 443) ? ':' + this.port : '');
+  }
+
+  get reachable(): boolean {
+    return this.status && this.status === 'UP';
+  }
+}

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

@@ -0,0 +1,112 @@
+import {Moment} from 'moment';
+import {ReferentialAsObjectOptions} from './referential.model';
+import {Entity} from './entity.model';
+import {Department} from './department.model';
+import {fromDateISOString, toDateISOString} from '../../../shared/dates';
+import {EntityClass} from './entity.decorators';
+import {isEmptyArray} from '../../../shared/functions';
+
+
+export type UserProfileLabel = 'ADMIN' | 'USER' | 'SUPERVISOR' | 'GUEST';
+export const PRIORITIZED_AUTHORITIES: Readonly<UserProfileLabel[]> = Object.freeze(['ADMIN', 'SUPERVISOR', 'USER', 'GUEST']);
+
+// @dynamic
+@EntityClass({typename: 'PersonVO'})
+export class Person<
+  T extends Person<any> = Person<any>
+  > extends Entity<T, number, ReferentialAsObjectOptions> {
+
+  static fromObject: (source: any, opts?: any) =>  Person;
+
+  firstName: string;
+  lastName: string;
+  email: string;
+  pubkey: string;
+  avatar: string;
+  creationDate: Date | Moment;
+  statusId: number;
+  department: Department = null;
+  username: string;
+  usernameExtranet: string;
+  profiles: string[];
+  mainProfile: string;
+
+  constructor(__typename?: string) {
+    super(__typename || Person.TYPENAME);
+  }
+
+  asObject(opts?: ReferentialAsObjectOptions): any {
+    if (opts && opts.minify)  {
+      return {
+        id: this.id,
+        __typename: opts.keepTypename && this.__typename || undefined,
+        firstName: this.firstName,
+        lastName: this.lastName
+      };
+    }
+    const target: any = super.asObject(opts);
+    target.department = this.department && this.department.asObject(opts) || undefined;
+    target.profiles = this.profiles && this.profiles.slice(0) || [];
+    // Set profile list from the main profile
+    target.profiles = this.mainProfile && [this.mainProfile] || target.profiles;
+    target.creationDate = toDateISOString(this.creationDate);
+
+    if (!opts || opts.minify !== true) target.mainProfile = PersonUtils.getMainProfile(target.profiles);
+    return target;
+  }
+
+  fromObject(source: any) {
+    super.fromObject(source);
+    this.firstName = source.firstName;
+    this.lastName = source.lastName;
+    this.email = source.email;
+    this.creationDate = fromDateISOString(source.creationDate);
+    this.pubkey = source.pubkey;
+    this.username = source.username;
+    this.usernameExtranet = source.usernameExtranet;
+    this.avatar = source.avatar;
+    this.statusId = source.statusId;
+    this.department = source.department && Department.fromObject(source.department) || undefined;
+    this.profiles = source.profiles && source.profiles.slice(0) || [];
+    // Add main profile to the list, if need
+    if (source.mainProfile && !this.profiles.find(p => p === source.mainProfile)) {
+      this.profiles = this.profiles.concat(source.mainProfile);
+    }
+    this.mainProfile = PersonUtils.getMainProfile(this.profiles);
+  }
+}
+
+export class PersonUtils {
+  static getMainProfile(profiles?: string[]): UserProfileLabel {
+    if (isEmptyArray(profiles)) return 'GUEST';
+    return PRIORITIZED_AUTHORITIES.find(label => profiles.includes(label)) || 'GUEST';
+  }
+
+  static getMainProfileIndex(profiles?: string[]): number {
+    if (isEmptyArray(profiles)) return PRIORITIZED_AUTHORITIES.length - 1; // return last (lower) profile
+    const index = PRIORITIZED_AUTHORITIES.findIndex(label => profiles.includes(label));
+    return (index !== -1) ? index : (PRIORITIZED_AUTHORITIES.length - 1);
+  }
+
+  static hasUpperOrEqualsProfile(actualProfiles: string[], expectedProfile: UserProfileLabel): boolean {
+    const expectedProfileIndex = PRIORITIZED_AUTHORITIES.indexOf(expectedProfile);
+    return expectedProfileIndex !== -1 && PersonUtils.getMainProfileIndex(actualProfiles) <= expectedProfileIndex;
+  }
+
+  static personToString(obj: Person): string {
+    if (!obj || !obj.id) return undefined;
+    return obj.lastName + ' ' + obj.firstName;
+  }
+
+  static personsToString(data: Person[], separator?: string): string {
+    return (data || []).map(PersonUtils.personToString).join(separator || ', ');
+  }
+
+}
+
+
+
+
+
+
+

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

@@ -0,0 +1,244 @@
+import {Moment} from 'moment';
+import { joinPropertiesPath, splitById, toNumber } from '../../../shared/functions';
+import {Entity, EntityAsObjectOptions, EntityUtils, IEntity} from './entity.model';
+import {StatusIds} from './model.enum';
+import {fromDateISOString, toDateISOString} from '../../../shared/dates';
+import {EntityClass} from './entity.decorators';
+import {IconRef} from '../../../shared/types';
+
+export function referentialToString(obj: Referential | any, properties?: string[]): string | undefined {
+  return obj && obj.id && joinPropertiesPath(obj, properties || ['label', 'name']) || undefined;
+}
+export function referentialsToString(values: Referential[], properties?: string[], separator?: string): string {
+  return (values || []).map(v => referentialToString(v, properties)).join(separator || ', ');
+}
+
+export declare interface IStatus {
+  id: number;
+  icon?: string;
+  label: string;
+}
+
+export const StatusList: Readonly<IStatus[]> = Object.freeze([
+  {
+    id: StatusIds.ENABLE,
+    icon: 'checkmark',
+    label: 'REFERENTIAL.STATUS_ENUM.ENABLE'
+  },
+  {
+    id: StatusIds.DISABLE,
+    icon: 'close',
+    label: 'REFERENTIAL.STATUS_ENUM.DISABLE'
+  },
+  {
+    id: StatusIds.TEMPORARY,
+    icon: 'help',
+    label: 'REFERENTIAL.STATUS_ENUM.TEMPORARY'
+  }
+]);
+
+export const StatusById = Object.freeze(splitById(StatusList));
+
+export declare interface IReferentialRef<
+  T extends IEntity<T, ID> = IEntity<any, any>,
+  ID = number
+  >
+  extends IEntity<T, ID> {
+  label: string;
+  name: string;
+  description?: string;
+  levelId?: number;
+  statusId: number;
+  entityName: string;
+  icon?: IconRef;
+}
+
+//@dynamic
+export abstract class BaseReferential<
+  T extends BaseReferential<T, ID, AO>,
+  ID = number,
+  AO extends ReferentialAsObjectOptions = ReferentialAsObjectOptions,
+  FO = any
+  >
+  extends Entity<T, ID, AO, FO>
+  implements IReferentialRef<T, ID> {
+
+  label: string;
+  name: string;
+  description: string;
+  comments: string;
+  creationDate: Date | Moment;
+  statusId: number;
+  validityStatusId: number;
+  levelId: number;
+  parentId: number;
+  entityName: string;
+  icon?: IconRef;
+
+  constructor(__typename?: string) {
+    super(__typename);
+  }
+
+  asObject(opts?: AO): any {
+    if (opts && opts.minify) {
+      return {
+        id: this.id,
+        entityName: opts.keepEntityName && this.entityName || undefined, // Don't keep by default
+        __typename: opts.keepTypename && this.__typename || undefined
+      };
+    }
+    const target: any = super.asObject(opts);
+    target.creationDate = toDateISOString(this.creationDate);
+    if (opts && opts.keepTypename === false) delete target.entityName;
+    if (opts && opts.keepIcon === false) delete target.icon;
+    return target;
+  }
+
+  fromObject(source: any, opts?: FO) {
+    super.fromObject(source, opts);
+    this.label = source.label;
+    this.name = source.name;
+    this.description = source.description;
+    this.comments = source.comments;
+    this.statusId = source.statusId;
+    this.validityStatusId  = source.validityStatusId;
+    this.levelId = source.levelId && source.levelId !== 0 ? source.levelId : undefined; // Do not set as null (need for account.department, when register)
+    this.parentId = source.parentId;
+    this.creationDate = fromDateISOString(source.creationDate);
+    this.entityName = source.entityName;
+    this.icon = source.icon;
+  }
+
+  equals(other: T): boolean {
+    return super.equals(other) && this.entityName === other.entityName;
+  }
+}
+
+// @dynamic
+@EntityClass({typename: 'ReferentialVO'})
+export class Referential<
+  T extends Referential<T, any> = Referential<any>,
+  ID = number
+  >
+  extends BaseReferential<T, ID> {
+
+  properties?: {[key: string]: any};
+
+  static fromObject: (source: any, opts?: any) => Referential;
+
+  fromObject(source: any, opts?: any) {
+    super.fromObject(source, opts);
+    this.properties = source.properties && {...source.properties} || undefined;
+  }
+
+  asObject(opts?: ReferentialAsObjectOptions): any {
+    const target = super.asObject(opts);
+    if (opts?.minify) {
+      delete target.properties;
+    }
+    return target;
+  }
+}
+
+export class ReferentialUtils {
+  // FIXME: remove this
+  static fromObject(source: any, opts?: any): Referential {
+    if (!source || source instanceof Referential) return source;
+    const res = new Referential();
+    res.fromObject(source, opts);
+    return res as Referential;
+  }
+
+  static isNotEmpty<T extends IReferentialRef<T>>(obj: T|any): boolean {
+    // A referential entity should always have a 'id' filled (can be negative is local and temporary)
+    return EntityUtils.isNotEmpty(obj, 'id');
+  }
+
+  static isEmpty<T extends IReferentialRef<T>>(obj: T|any): boolean {
+    return EntityUtils.isEmpty(obj, 'id');
+  }
+
+  static equals<T extends IReferentialRef<T>>(o1: T|any, o2: T|any): boolean {
+    return EntityUtils.equals(o1, o2, 'id');
+  }
+}
+
+
+export interface ReferentialAsObjectOptions extends EntityAsObjectOptions {
+  keepEntityName?: boolean;
+  keepIcon?: boolean;
+}
+
+/**
+ * Used to store an entity locally
+ */
+export const MINIFY_ENTITY_FOR_LOCAL_STORAGE: ReferentialAsObjectOptions = Object.freeze({
+  minify: true,
+  keepTypename: true,
+  keepEntityName: true,
+  keepLocalId: true,
+  keepIcon: true
+});
+
+/**
+ * Used to send an entity to a pod
+ */
+export const MINIFY_ENTITY_FOR_POD: ReferentialAsObjectOptions = Object.freeze({
+  minify: true,
+  keepTypename: false,
+  keepEntityName: false,
+  keepLocalId: false,
+  keepIcon: false
+});
+
+// @dynamic
+@EntityClass({typename: 'ReferentialVO'})
+export class ReferentialRef<
+  T extends ReferentialRef<any, ID> = ReferentialRef<any, any>,
+  ID = number,
+  O extends ReferentialAsObjectOptions = ReferentialAsObjectOptions,
+  FO = any
+  >
+  extends Entity<T, ID, O, FO>
+  implements IReferentialRef<T, ID> {
+
+  static fromObject: (source: any, opts?: any) => ReferentialRef;
+
+  label: string;
+  name: string;
+  description: string;
+  statusId: number;
+  levelId: number;
+  entityName: string;
+  icon?: IconRef;
+
+  constructor() {
+    super(ReferentialRef.TYPENAME);
+  }
+
+  asObject(opts?: O): any {
+    if (opts && opts.minify) {
+      return {
+        id: this.id,
+        entityName: opts.keepEntityName && this.entityName || undefined, // Don't keep by default
+        __typename: opts.keepTypename && this.__typename || undefined
+      };
+    }
+    const target: any = super.asObject(opts);
+    if (opts && opts.keepEntityName === false) delete target.entityName;
+    if (opts && opts.keepIcon === false) delete target.icon;
+
+    return target;
+  }
+
+  fromObject(source: any, opts?: FO) {
+    super.fromObject(source);
+    this.entityName = source.entityName || this.entityName;
+    this.label = source.label;
+    this.name = source.name;
+    this.description = source.description;
+    this.statusId = source.statusId;
+    this.levelId = source.levelId;
+    this.icon = source.icon;
+  }
+}

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

@@ -0,0 +1,32 @@
+import {PropertiesMap, Property} from '../../../shared/types';
+import {InjectionToken} from '@angular/core';
+import {HistoryPageReference} from './history.model';
+
+export type UsageMode = 'DESK' | 'FIELD';
+
+export declare interface LocaleConfig extends Property {
+  country?: string;
+}
+
+export const APP_LOCALES = new InjectionToken<LocaleConfig[]>('locales');
+
+export declare interface OfflineFeature {
+  name: string;
+  lastSyncDate?: string;
+  filter?: any;
+}
+
+export declare interface LocalSettings {
+  pages?: any;
+  peerUrl?: string;
+  latLongFormat: 'DDMMSS' | 'DDMM' | 'DD';
+  accountInheritance?: boolean;
+  locale: string;
+  usageMode?: UsageMode;
+  mobile?: boolean;
+  properties?: PropertiesMap;
+  pageHistory?: HistoryPageReference[];
+  offlineFeatures?: (string | OfflineFeature)[];
+  pageHistoryMaxSize: number;
+}
+

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

@@ -0,0 +1,54 @@
+import {EntityClass} from './entity.decorators';
+import {Entity, EntityAsObjectOptions} from './entity.model';
+import {Moment} from 'moment/moment';
+import {fromDateISOString, toDateISOString} from '../../../shared/dates';
+import {toNumber} from '../../../shared/functions';
+import {isPresentationRole} from '@angular-eslint/eslint-plugin-template/dist/eslint-plugin-template/src/utils/is-presentation-role';
+
+export class TokenScope {
+  id: string;
+  flag: number;
+  name: string;
+}
+
+// @dynamic
+@EntityClass({typename: 'UserTokenVO'})
+export class UserToken extends Entity<UserToken> {
+  static fromObject: (source: any, opts?: any) => UserToken;
+
+  pubkey: string = null;
+  token: string = null;
+  name: string = null;
+  flags: number = null;
+  scopes: TokenScope[] = null;
+  expirationDate: Moment = null;
+  lastUsedDate: Moment = null;
+  creationDate: Moment = null;
+
+  constructor() {
+    super(UserToken.TYPENAME);
+  }
+
+  asObject(opts?: EntityAsObjectOptions): any {
+    const target = super.asObject(opts);
+    target.expirationDate = toDateISOString(this.expirationDate);
+    target.lastUsedDate = toDateISOString(this.lastUsedDate);
+    target.creationDate = toDateISOString(this.creationDate);
+    if (opts?.minify) {
+      delete target.scopes;
+    }
+    return target;
+  }
+
+  fromObject(source: any, opts?: any) {
+    super.fromObject(source);
+    this.pubkey = source.pubkey;
+    this.token = source.token;
+    this.name = source.name;
+    this.flags = toNumber(source.flags);
+    this.scopes = source.scopes;
+    this.expirationDate = fromDateISOString(source.expirationDate);
+    this.lastUsedDate = fromDateISOString(source.lastUsedDate);
+    this.creationDate = fromDateISOString(source.creationDate);
+  }
+}