@sumaris-net/ngx-components 18.10.29 → 18.12.0

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

@@ -0,0 +1,188 @@
+import { LocalSettings } from './settings.model';
+import { Person, PersonUtils, UserProfileLabel } from './person.model';
+import { Entity, EntityAsObjectOptions } from './entity.model';
+import { EntityClass } from './entity.decorators';
+import { StatusIds } from './model.enum';
+import { LatLongPattern } from '../../../shared/material/latlong/latlong.utils';
+import { equals, isNil, isNotEmptyArray } from '../../../shared/functions';
+import { UserToken } from './token.model';
+import { FormFieldDefinition } from '../../../shared/form/field.model';
+import { AppPropertiesUtils } from '../../form/properties/properties.utils';
+
+/**
+ * A user account
+ */
+// @dynamic
+@EntityClass({ typename: 'AccountVO' })
+export class Account extends Person<Account> {
+  static fromObject: (source: any, opts?: any) => Account;
+
+  settings: UserSettings = null;
+  tokens: UserToken[] = [];
+
+  constructor() {
+    super(Account.TYPENAME);
+  }
+
+  asObject(opts?: EntityAsObjectOptions): any {
+    const target: any = super.asObject({ ...opts, minify: false /*disable Person minify (too restrictive) */ });
+    target.settings = this.settings?.asObject(opts);
+    target.tokens = this.tokens?.map((value) => value.asObject(opts));
+    if (opts?.minify) {
+      delete target.mainProfile; // Not known on server
+    }
+    return target;
+  }
+
+  fromObject(source: any) {
+    super.fromObject(source);
+    this.settings = source.settings && UserSettings.fromObject(source.settings);
+    this.tokens = source.tokens?.map((value) => UserToken.fromObject(value)) || [];
+  }
+
+  /**
+   * Convert into a Person. This will fill __typename with a right value, for data cache
+   */
+  asPerson(): Person {
+    const person = Person.fromObject(
+      this.asObject({
+        keepTypename: true, // This is need for the department object
+      })
+    );
+    person.__typename = Person.TYPENAME; // Do not keep AccountVO as typename
+    return person;
+  }
+
+  get displayName(): string {
+    return accountToString(this);
+  }
+}
+
+export abstract class AccountUtils {
+  static accountToString = accountToString;
+
+  static hasMinProfile(account: Account | null, userProfile: UserProfileLabel): boolean {
+    // should be login, and status ENABLE or TEMPORARY
+    if (!account || !account.pubkey || (account.statusId !== StatusIds.ENABLE && account.statusId !== StatusIds.TEMPORARY)) {
+      return false;
+    }
+    return PersonUtils.hasUpperOrEqualsProfile(account.profiles, userProfile);
+  }
+
+  static hasExactProfile(account: Account | null, label: UserProfileLabel): boolean {
+    // should be login, and status ENABLE or TEMPORARY
+    if (!account || !account.pubkey || (account.statusId !== StatusIds.ENABLE && account.statusId !== StatusIds.TEMPORARY)) return false;
+    return account.profiles.some((profile) => profile === label);
+  }
+
+  static hasProfileAndIsEnable(account: Account | null, userProfile: UserProfileLabel): boolean {
+    // should be login, and status ENABLE
+    if (!account || !account.pubkey || account.statusId !== StatusIds.ENABLE) return false;
+    return PersonUtils.hasUpperOrEqualsProfile(account.profiles, userProfile);
+  }
+}
+
+// @dynamic
+@EntityClass({ typename: 'UserSettingsVO' })
+export class UserSettings extends Entity<UserSettings> {
+  static SETTINGS_PROPERTIES = [<keyof UserSettings>'locale', <keyof UserSettings>'latLongFormat'] as string[];
+  static fromObject: (source: any, opts?: any) => UserSettings;
+
+  locale: string;
+  latLongFormat: LatLongPattern;
+  content: any;
+  nonce: string;
+
+  constructor() {
+    super(UserSettings.TYPENAME);
+  }
+
+  asObject(opts?: EntityAsObjectOptions): any {
+    const target = super.asObject(opts);
+    if (opts?.minify) {
+      // Stringify content
+      target.content = this.content ? JSON.stringify(this.content) : undefined;
+    }
+    return target;
+  }
+
+  fromObject(source: any, opts?: any) {
+    super.fromObject(source);
+    this.locale = source.locale;
+    this.latLongFormat = source.latLongFormat as LatLongPattern;
+    if (isNil(source.content) || typeof source.content === 'object') {
+      this.content = source.content || {};
+    } else {
+      this.content = (source.content && JSON.parse(source.content)) || {};
+    }
+    this.nonce = source.nonce;
+  }
+
+  /**
+   * Merges the given source object into the current instance.
+   *
+   * @param {S} source - The source object containing properties to merge.
+   * @param {Array<keyof S | string | number>} [includedProperties] - Optional array of property keys to be merged into the content map.
+   * @param {boolean} [resetContent] - Optional flag to reset existing content. False by default
+   * @return {boolean} - Returns true if any changes were made; otherwise, false.
+   */
+  merge<S = LocalSettings>(source: S, includedProperties: (keyof S | string | number)[], resetContent?: boolean): boolean {
+    if (!source) return; // Skip
+
+    // Reset or init content
+    this.content = resetContent ? {} : this.content || {};
+    let hasChanges = false;
+
+    // For each property of source object
+    Object.keys(source).forEach((key) => {
+      // If property exists in UserSettings class: store it directly
+      if (UserSettings.SETTINGS_PROPERTIES.includes(key)) {
+        if (!equals(this[key], source[key])) {
+          this[key] = source[key];
+          hasChanges = true;
+        }
+      }
+      // Else, store property into the 'content' map
+      else if (includedProperties && includedProperties.includes(key as keyof S)) {
+        const sourceValue = source[key];
+        if (!equals(this.content[key], sourceValue)) {
+          if (typeof sourceValue === 'object' && sourceValue !== null) {
+            this.content[key] = { ...this.content[key], ...sourceValue }; // Merge object
+          } else {
+            this.content[key] = sourceValue;
+          }
+          hasChanges = true;
+        }
+      }
+    });
+    return hasChanges;
+  }
+
+  /**
+   * Transform user settings into local settings
+   * @param opts
+   */
+  asLocalSettings(opts?: { definitions?: FormFieldDefinition[] }): Partial<LocalSettings> {
+    const target = <LocalSettings>{};
+    UserSettings.SETTINGS_PROPERTIES.forEach((key) => {
+      target[key] = this[key];
+    });
+    Object.keys(this.content).forEach((key) => {
+      target[key] = this.content[key];
+    });
+    // Sanitize properties
+    const includedKeys = opts?.definitions?.map((def) => def.key) || [];
+    if (isNotEmptyArray(includedKeys)) {
+      target.properties = AppPropertiesUtils.sanitize(target.properties, { includedKeys });
+    }
+    // Clear properties if empty, to avoid to reset the existing properties - See issue sumaris-app#897
+    if (Object.keys(target.properties || {}).length === 0) {
+      delete target.properties;
+    }
+    return target;
+  }
+}
+
+export function accountToString(data: Account): string {
+  return (data && ((data.firstName && data.firstName + ' ') || '') + (data.lastName || '')) || '';
+}

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

@@ -0,0 +1,116 @@
+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 { PropertyMap } from '../../../shared/types';
+import { fromDateISOString, toDateISOString } from '../../../shared/dates';
+import { isNotNil, isNotNilOrBlank, 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: PropertyMap;
+
+  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(',').filter(isNotNilOrBlank).map(parseFloat) || undefined;
+    return isNotNil(value) ? [parseFloat(value)] : undefined;
+  }
+
+  getPropertyAsStrings(definition: FormFieldDefinition): string[] {
+    const value = this.getProperty(definition);
+    return (value && value.split(',').filter(isNotNilOrBlank)) || 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';
+import { isNotNil } from '../../../shared/functions';
+
+// @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 (isNotNil(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,110 @@
+import { environment } from '../../../../environments/environment';
+import { Entity } from './entity.model';
+import { removeEnd } from '../../../shared/functions';
+
+declare type Constructor<T = any> = new (...args: any[]) => T;
+
+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;
+  }
+}
+
+export function EntityClass(opts: { typename: string; fromObjectReuseStrategy?: 'default' | 'clone' }) {
+  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;
+  };
+}