@sumaris-net/ngx-components 18.10.29 → 18.12.0

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

@@ -0,0 +1,119 @@
+/* -- Network -- */
+
+import { isNilOrBlank, isNotNil, isNotNilOrBlank, noTrailingSlash } from '../../../shared/functions';
+import { Cloneable, Entity, EntityAsObjectOptions } from './entity.model';
+import { EntityClass } from './entity.decorators';
+import { NodeFeature } from './node-feature.model';
+
+// @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('/');
+  }
+
+  static equals(p1: Peer, p2: Peer) {
+    return p1 && p2 && Peer.fromObject(p1).equals(p2);
+  }
+  static countAllFeatures(peers: Peer[]): number {
+    return (peers || []).reduce((res, peer) => {
+      return res + (peer?.features?.length || 0);
+    }, 0);
+  }
+
+  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;
+  registrationUri?: string;
+  registrationManager?: string;
+  features?: NodeFeature[];
+
+  constructor() {
+    super(Peer.TYPENAME);
+  }
+
+  asObject(options?: EntityAsObjectOptions): any {
+    const target = super.asObject(options);
+    target.features = this.features?.map((feature) => feature.asObject(options));
+    return target;
+  }
+
+  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.useSsl = source.useSsl || this.port === 443;
+    this.pubkey = source.pubkey;
+    this.path = source.path || '';
+
+    this.favicon = source.favicon;
+    this.status = source.status;
+    this.softwareName = source.softwareName;
+    this.softwareVersion = source.softwareVersion;
+    this.label = source.label || '';
+    this.name = source.name || '';
+    this.registrationUri = source.registrationUri || '';
+    this.registrationManager = source.registrationManager;
+
+    this.features = source.features?.map(NodeFeature.fromObject);
+  }
+
+  equals(other: Peer): boolean {
+    return (
+      // Same entity (by id)
+      (isNotNil(this.id) && isNotNil(other.id) && this.id === other.id) ||
+      // Same pubkey (if defined)
+      ((!this.pubkey || !other.pubkey || this.pubkey === other.pubkey) &&
+        // Same url
+        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,122 @@
+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, isNil, isNotNil } 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);
+  }
+
+  equals(other: T): boolean {
+    return (
+      other &&
+      ((isNotNil(this.id) && this.id === other.id) ||
+        // Functional test
+        // Pubkey should be unique
+        (this.pubkey &&
+          this.pubkey === other.pubkey &&
+          // Email should be unique
+          this.email &&
+          this.email === other.email))
+    );
+  }
+}
+
+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, opts?: { withDepartment?: boolean }): string {
+    if (!obj || isNil(obj.id)) return undefined;
+    if (opts?.withDepartment && obj.department?.label) {
+      return obj.lastName + ' ' + obj.firstName + ' (' + obj.department.label + ')';
+    }
+    return obj.lastName + ' ' + obj.firstName;
+  }
+
+  static personsToString(data: Person[], separator?: string, opts?: { withDepartment?: boolean }): string {
+    return (data || []).map((p) => PersonUtils.personToString(p, opts)).join(separator || ', ');
+  }
+
+  static roleToProfile(role: string, defaultProfile?: UserProfileLabel): UserProfileLabel {
+    const label = role?.replace(/^ROLE_/, '') as UserProfileLabel;
+    return label || defaultProfile;
+  }
+}

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

@@ -0,0 +1,253 @@
+import { Moment } from 'moment';
+import { isNil, isNotNil, joinPropertiesPath, splitById } 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[], separator?: string): string | undefined {
+  return (obj && isNotNil(obj.id) && joinPropertiesPath(obj, properties || ['label', 'name'], separator)) || undefined;
+}
+export function referentialsToString(values: Referential[], properties?: string[], valueSeparator?: string, propertySeparator?: string): string {
+  return (values || []).map((v) => referentialToString(v, properties, propertySeparator)).join(valueSeparator || ', ');
+}
+
+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;
+
+  protected constructor(__typename?: string) {
+    super(__typename);
+  }
+
+  asObject(opts?: AO): any {
+    if (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?.keepEntityName === false) delete target.entityName;
+    if (opts?.keepIcon === false) delete target.icon;
+    if (opts?.keepProperties === false) delete target.properties;
+    if (isNil(target.validityStatusId)) delete target.validityStatusId;
+    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> {
+  static fromObject: (source: any, opts?: any) => Referential;
+
+  properties?: { [key: string]: any };
+
+  constructor() {
+    super();
+  }
+
+  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');
+  }
+
+  static isNotDisabled<T extends IReferentialRef<T>>(obj: T | any): boolean {
+    return obj && obj.statusId !== StatusIds.DISABLE;
+  }
+}
+
+export interface ReferentialAsObjectOptions extends EntityAsObjectOptions {
+  keepEntityName?: boolean;
+  keepIcon?: boolean;
+  keepProperties?: 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,
+  keepProperties: 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,
+  keepProperties: 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;
+  static clone(source: any): ReferentialRef {
+    return ReferentialRef.fromObject(source)?.clone();
+  }
+
+  label: string;
+  name: string;
+  description: string;
+  statusId: number;
+  levelId: number;
+  entityName: string;
+  icon?: IconRef;
+  properties?: { [key: string]: any };
+
+  constructor() {
+    super(ReferentialRef.TYPENAME);
+  }
+
+  asObject(opts?: O): any {
+    if (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?.keepEntityName === false) delete target.entityName;
+    if (opts?.keepIcon === false) delete target.icon;
+    if (opts?.keepProperties === false) delete target.properties;
+
+    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;
+    this.properties = (source.properties && { ...source.properties }) || undefined;
+  }
+}

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

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

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

@@ -0,0 +1,60 @@
+import { EntityClass } from './entity.decorators';
+import { Entity, EntityAsObjectOptions } from './entity.model';
+import { Moment } from 'moment/moment';
+import { DateUtils, fromDateISOString, toDateISOString } from '../../../shared/dates';
+import { isNotNil, toNumber } from '../../../shared/functions';
+
+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;
+
+  static equals(t1: UserToken, t2: UserToken): boolean {
+    return (
+      (isNotNil(t1.id) && t1.id === t2?.id) ||
+      (t1 && t1.pubkey && t1.pubkey === t2?.pubkey && t1.name === t2?.name && DateUtils.equals(t1.expirationDate, t2?.expirationDate))
+    );
+  }
+
+  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);
+  }
+}