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

package/src/app/core/services/local-settings.service.ts

@@ -0,0 +1,548 @@
+import { EventEmitter, Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { LocalSettings, OfflineFeature, UsageMode } from './model/settings.model';
+import { Peer } from './model/peer.model';
+import { TranslateService } from '@ngx-translate/core';
+import { Storage } from '@ionic/storage-angular';
+
+import {equals, getPropertyByPath, isEmptyArray, isNil, isNotEmptyArray, isNotNil, isNotNilOrBlank, undefinedIfNull} from '../../shared/functions';
+import { Subject } from 'rxjs';
+import { Platform } from '@ionic/angular';
+import { FormFieldDefinition, FormFieldDefinitionMap } from '../../shared/form/field.model';
+import { Moment } from 'moment';
+import { debounceTime, filter } from 'rxjs/operators';
+import { LatLongPattern } from '../../shared/material/latlong/latlong.utils';
+import { ENVIRONMENT, Environment } from '../../../environments/environment.class';
+import { environment } from '../../../environments/environment';
+import { DateUtils, fromDateISOString } from '../../shared/dates';
+import { HistoryPageReference } from './model/history.model';
+import { StartableService } from '../../shared/services/startable-service.class';
+import { isCapacitor, isMobile } from '../../shared/platforms';
+
+export const SETTINGS_STORAGE_KEY = 'settings';
+export const SETTINGS_TRANSIENT_PROPERTIES = ['mobile', 'touchUi'/*deprecated*/];
+
+// fixme: this constant points to static environment
+const DEFAULT_SETTINGS: LocalSettings = {
+  accountInheritance: true,
+  locale: environment.defaultLocale,
+  latLongFormat: environment.defaultLatLongFormat || 'DDMM',
+  pageHistoryMaxSize: 3
+};
+
+export interface LocalSettingsOptions {
+  serializeAsString?: boolean; // false by default
+  options: FormFieldDefinitionMap;
+}
+export declare interface AddToPageHistoryOptions {
+  removePathQueryParams?: boolean;
+  removeTitleSmallTag?: boolean;
+  emitEvent?: boolean;
+}
+
+export const APP_LOCAL_SETTINGS = new InjectionToken<Partial<LocalSettings>>('DefaultLocalSettings');
+export const APP_LOCAL_SETTINGS_OPTIONS = new InjectionToken<LocalSettingsOptions>('LocalSettingsOptions');
+
+
+@Injectable({
+  providedIn: 'root'
+  //deps: [APP_LOCAL_SETTINGS, APP_LOCAL_SETTINGS_OPTIONS]
+})
+export class LocalSettingsService extends StartableService<LocalSettings> {
+
+  onChange = new Subject<LocalSettings>();
+
+  private readonly _optionDefs: FormFieldDefinition[];
+  private readonly _serializeAsString: boolean;
+  private _$persist: EventEmitter<any>;
+
+  get settings(): LocalSettings {
+    return this._data || this.defaultSettings;
+  }
+
+  get locale(): string {
+    return this._data && this._data.locale || this.translate.currentLang || this.translate.defaultLang;
+  }
+
+  get latLongFormat(): LatLongPattern {
+    return this._data && this._data.latLongFormat || 'DDMM';
+  }
+
+  get usageMode(): UsageMode {
+    return isNotNil(this._data.usageMode) ? this._data.usageMode : (isCapacitor(window) || isMobile(window) ? 'FIELD' : 'DESK');
+  }
+
+  get mobile(): boolean {
+    return isNotNil(this._data.mobile) ? this._data.mobile : isMobile(window);
+  }
+
+  set mobile(value: boolean) {
+    this._data.mobile = value;
+  }
+
+  get pageHistory(): HistoryPageReference[] {
+    return (this._data && this._data.pageHistory || []);
+  }
+
+  constructor(
+    private translate: TranslateService,
+    private platform: Platform,
+    private storage: Storage,
+    @Inject(ENVIRONMENT) protected readonly environment: Environment,
+    @Optional() @Inject(APP_LOCAL_SETTINGS) private readonly defaultSettings: LocalSettings,
+    @Optional() @Inject(APP_LOCAL_SETTINGS_OPTIONS) options: LocalSettingsOptions
+  ) {
+    super(platform);
+    this.defaultSettings = {...DEFAULT_SETTINGS, ...this.defaultSettings};
+
+    this._optionDefs = Object.values(options?.options || {});
+    this._serializeAsString = options?.serializeAsString || false;
+
+    this.resetData();
+
+    this._debug = !environment.production;
+    if (this._debug) console.debug('[settings] Creating service');
+  }
+
+  ngOnStart(): Promise<LocalSettings> {
+
+    console.info('[settings] Starting service...');
+
+    // Default value
+    this._data.mobile = this.mobile;
+    this._data.usageMode = this.usageMode;
+
+    // Restoring local settings
+    return this.restoreLocally();
+  }
+
+
+  isUsageMode(mode: UsageMode): boolean {
+    return this.usageMode === mode;
+  }
+
+  isOnFieldMode(value?: UsageMode): boolean {
+    return (value || this.usageMode) === 'FIELD';
+  }
+
+  async restoreLocally(): Promise<LocalSettings | undefined> {
+    let data = this._data || <LocalSettings>{};
+
+    // Restore from storage
+    const settings = await this.storage.get(SETTINGS_STORAGE_KEY);
+
+    // Restore local settings (or keep old settings)
+    if (isNotNil(settings)) {
+      console.info('[settings] Restoring previous settings...');
+
+      const restoredData = (typeof settings === 'string') ? JSON.parse(settings) : settings;
+
+      // Avoid to override transient properties
+      SETTINGS_TRANSIENT_PROPERTIES.forEach(transientKey => {
+        delete restoredData[transientKey];
+      });
+
+      // Merge into existing data
+      data = Object.assign(data, restoredData);
+    }
+
+    // Emit event
+    this.onChange.next(data);
+
+    return data;
+  }
+
+  setProperty<T = string>(keyOrDef: string|FormFieldDefinition, value: T, opts?: {emitEvent?: boolean; immediate?: boolean}){
+    if (!this._data || !keyOrDef) return;
+    if (typeof keyOrDef === 'object') {
+      this.setProperty(keyOrDef.key, value);
+      return;
+    }
+    this._data.properties = this._data.properties || {};
+    this._data.properties[keyOrDef] = isNil(value) ? undefined : value.toString();
+
+    // Update local settings
+    if (!opts || opts.emitEvent !== false) {
+      this.persistLocally(opts?.immediate);
+    }
+  }
+
+  getProperty(keyOrDef: string|FormFieldDefinition, defaultValue?: any): any {
+    if (typeof keyOrDef === 'object') {
+      return this.getProperty(keyOrDef.key, isNotNil(defaultValue) ? defaultValue : keyOrDef.defaultValue);
+    }
+    const value = this._data && this._data.properties && this._data.properties[keyOrDef];
+    return isNotNil(value) ? value : undefinedIfNull(defaultValue);
+  }
+
+  getPropertyAsBoolean(definition: FormFieldDefinition, defaultValue?: boolean): boolean {
+    const value = this.getProperty(definition, defaultValue);
+    return isNotNil(value) ? (value && value !== 'false') : undefined;
+  }
+
+  getPropertyAsInt(definition: FormFieldDefinition, defaultValue?: number): number {
+    const value = this.getProperty(definition, defaultValue);
+    return isNotNil(value) ? parseInt(value) : undefined;
+  }
+
+  getPropertyAsNumbers(definition: FormFieldDefinition, defaultValue?: number[]): number[] {
+    const value = this.getProperty(definition, defaultValue);
+    if (typeof value === 'string') return value.split(',').map(parseFloat) || undefined;
+    return isNotNil(value) ? [parseFloat(value)] : undefined;
+  }
+
+  getPropertyAsStrings(definition: FormFieldDefinition, defaultValue?: string[]): string[] {
+    const value = this.getProperty(definition, defaultValue);
+    return value && value.split(',') || undefined;
+  }
+
+  async apply(settings: Partial<LocalSettings>, opts?: { emitEvent?: boolean; persistImmediate?: boolean }) {
+    if (!this.started) await this.ready();
+
+    const data = { ...this._data, ...settings};
+
+    if (equals(data, this._data)) return; // Skip if no changes
+
+    this._data = data;
+
+    // Save locally
+    if (opts && opts.persistImmediate) {
+      await this.persistLocally(true);
+    }
+    else {
+      this.persistLocally(); // No AWAIT
+    }
+
+    // Emit event
+    if (!opts || opts.emitEvent !== false) {
+      this.onChange.next(this._data);
+    }
+  }
+
+  async applyProperty(key: keyof LocalSettings, value: any, opts?: { emitEvent?: boolean; persistImmediate?: boolean }) {
+    const changes = {};
+    changes[key] = value;
+    await this.apply(changes, opts);
+  }
+
+  getPageSettings<T = any>(pageId: string, propertyName?: string): T {
+    if (!this._data || !this._data.pages) return undefined;
+    const key = pageId.replace(/[/]/g, '__');
+    if (isNotNilOrBlank(propertyName)) {
+      return getPropertyByPath(this._data.pages, key + '.' + propertyName);
+    }
+    return this._data.pages[key];
+  }
+
+  async savePageSetting(pageId: string, value: any, propertyName?: string) {
+    this._data = this._data || this.defaultSettings;
+    this._data.pages = this._data.pages || {};
+
+    const key = pageId.replace(/[/]/g, '__');
+    if (propertyName) {
+      this._data.pages[key] = this._data.pages[key] || {};
+      this._data.pages[key][propertyName] = value;
+    }
+    else {
+      this._data.pages[key] = value;
+    }
+
+    // Update local settings
+    this.persistLocally();
+  }
+
+
+  getOfflineFeature(featureName: string): OfflineFeature {
+    if (!this._data || !this._data.offlineFeatures || isEmptyArray(this._data.offlineFeatures))
+      return undefined;
+    if (!featureName) throw Error('Missing \'featureName\' argument');
+
+    featureName = featureName.toLowerCase();
+    const featurePrefix = featureName + '#';
+    const feature = this._data.offlineFeatures.find(f => {
+      if (typeof f === 'string') return f.toLowerCase().startsWith(featurePrefix);
+      if (f && typeof f === 'object' && f.name) return f.name === featureName;
+      return false;
+    });
+    if (!feature) return; // Not found
+    if (typeof feature === 'string') {
+      const lastSyncDate = feature.substring(featurePrefix.length);
+      console.debug(`[${featureName}] Last synchronization date: ${lastSyncDate}`);
+      return {
+        name: featureName,
+        lastSyncDate
+      };
+    }
+    return feature;
+  }
+
+  getOfflineFeatureLastSyncDate(featureName: string): Moment {
+    const feature = this.getOfflineFeature(featureName);
+    return feature && fromDateISOString(feature.lastSyncDate);
+  }
+
+  hasOfflineFeature(featureName?: string): boolean {
+    if (featureName) return isNotNil(this.getOfflineFeature(featureName));
+    return this._data && isNotEmptyArray(this._data.offlineFeatures);
+  }
+
+  saveOfflineFeature(feature: OfflineFeature) {
+    this._data = this._data || this.defaultSettings;
+    this._data.offlineFeatures = this._data.offlineFeatures || [];
+
+    feature.name = feature.name.toLowerCase();
+
+    const featurePrefix = feature.name + '#';
+    const existingIndex = this._data.offlineFeatures.findIndex(f => {
+      if (typeof f === 'string') return f.toLowerCase().startsWith(featurePrefix);
+      if (f && typeof f === 'object' && f.name) return f.name === feature.name;
+      return false;
+    });
+    if (existingIndex !== -1) {
+      this._data.offlineFeatures[existingIndex] = feature;
+    }
+    else {
+      this._data.offlineFeatures.push(feature);
+    }
+
+    // Update local settings
+    this.persistLocally();
+  }
+
+  markOfflineFeatureAsSync(featureName: string) {
+    let feature = this.getOfflineFeature(featureName);
+
+    if (!feature) {
+      feature = <OfflineFeature>{
+        name: featureName.toLowerCase(),
+        lastSyncDate: DateUtils.moment().toISOString()
+      };
+    }
+    else {
+      feature.lastSyncDate = DateUtils.moment().toISOString();
+    }
+
+    this.saveOfflineFeature(feature);
+  }
+
+  removeOfflineFeatures() {
+    if (this._data && this._data.offlineFeatures) {
+      this._data.offlineFeatures = [];
+
+      // Update local settings
+      this.persistLocally();
+    }
+  }
+
+  getFieldDisplayAttributes(fieldName: string, defaultAttributes?: string[]): string[] {
+    const value = this._data && this._data.properties &&  this._data.properties[`sumaris.field.${fieldName}.attributes`];
+    // Nothing found in settings: return defaults
+    if (!value) return defaultAttributes || ['label', 'name'];
+
+    return value.split(',');
+  }
+
+  getPageFieldDefaultValue(pageId: string, fieldName: string): any {
+    return this.getPageSettings(pageId, `field.${fieldName}.defaultValue`);
+  }
+
+  get optionDefs(): FormFieldDefinition[] {
+    return this._optionDefs;
+  }
+
+  registerOption(def: FormFieldDefinition) {
+    if (this._optionDefs.findIndex(f => f.key === def.key) !== -1) {
+      throw new Error(`Additional additional property {${def.key}} already define.`);
+    }
+    if (this._debug) console.debug(`[settings] Adding additional property {${def.key}}`, def);
+    this._optionDefs.push(def);
+  }
+
+  registerOptions(defs: FormFieldDefinition[]) {
+    (defs || []).forEach(def => this.registerOption(def));
+  }
+
+  async addToPageHistory(page: HistoryPageReference,
+                         opts?: AddToPageHistoryOptions,
+                         pageHistory?: HistoryPageReference[] // used for recursive call to children
+  ) {
+    // If not inside recursive call: fill page history defaults
+    if (!pageHistory) this.fillPageHistoryDefaults(page, opts);
+
+    pageHistory = pageHistory || this._data.pageHistory;
+
+    const index = pageHistory.findIndex(p => (
+      // same path
+      p.path === page.path
+      // or sub-path
+      || page.path.startsWith(p.path + '/'))
+    );
+
+    // New page: insert it
+    if (index === -1) {
+      //if (this._debug)
+      console.debug('[settings] Adding page to history: ', page);
+
+      // Prepend to list
+      pageHistory.splice(0, 0, page);
+    }
+
+    else {
+      const existingPage = pageHistory[index];
+
+      // Same path: replace existing page
+      if (pageHistory[index].path === page.path) {
+        //if (this._debug)
+        console.debug('[settings] Updating existing page in history: ', page);
+        pageHistory.splice(index, 1);
+
+        // Copy exiting children
+        page.children = existingPage.children || [];
+
+        // Prepend to list
+        pageHistory.splice(0, 0, page);
+      }
+
+      // Not same path (should be a parent page)
+      else {
+        // Create parent's children array, if not exists
+        existingPage.children = existingPage.children || [];
+
+        // Update the parent time
+        existingPage.time = page.time;
+
+        // Add page as parent's children (recursive call)
+        await this.addToPageHistory(page, opts, existingPage.children);
+      }
+    }
+
+    // Save locally (only if not a recursive execution)
+    if (pageHistory === this._data.pageHistory) {
+
+      // If max has been reached, remove old pages
+      if (this._data.pageHistory.length > this._data.pageHistoryMaxSize) {
+        const removedPages = pageHistory.splice(this._data.pageHistoryMaxSize, pageHistory.length - this._data.pageHistoryMaxSize);
+        console.debug('[settings] Pages removed from history: ', removedPages);
+      }
+
+      // Apply new value
+      await this.applyProperty('pageHistory', pageHistory);
+    }
+  }
+
+  async removePageHistory(path: string,
+                          opts?: {emitEvent?: boolean },
+                          pageHistory?: HistoryPageReference[] // used for recursive call to children)
+  ) {
+    pageHistory = pageHistory || this._data.pageHistory;
+
+    const index = pageHistory.findIndex(p => p.path === path);
+    let found = index !== -1;
+    if (found) {
+      console.debug('[settings] Remove page history: ', path);
+      // Remove value
+      pageHistory.splice(index, 1);
+    }
+    else {
+      // Search path on children (stop when found)
+      found = pageHistory
+        .map(p => p.children)
+        .filter(isNotEmptyArray)
+        .findIndex(children => this.removePageHistory(path, opts, children)) !== -1;
+    }
+
+    // Save locally (only if not a recursive execution)
+    if (found && pageHistory === this._data.pageHistory) {
+      // Apply changes
+      await this.applyProperty('pageHistory', this._data.pageHistory);
+    }
+
+    return found;
+  }
+
+  async clearPageHistory() {
+    // Reset all page history
+    await this.applyProperty('pageHistory', [], {persistImmediate: true});
+  }
+
+  /* -- Protected methods -- */
+
+  protected async ngOnStop(): Promise<void> {
+    this.resetData();
+  }
+
+  private resetData() {
+    this._data = {...this._data, ...this.defaultSettings};
+
+    this._data.locale = this.translate.currentLang || this.translate.defaultLang;
+    this._data.mobile = undefined;
+    this._data.usageMode = undefined;
+    this._data.pageHistory = [];
+
+    const defaultPeer = this.environment.defaultPeer && Peer.fromObject(this.environment.defaultPeer);
+    this._data.peerUrl = defaultPeer && defaultPeer.url || undefined;
+
+    if (this.started) this.onChange.next(this._data);
+  }
+
+  private persistLocally(immediate?: boolean): Promise<any> {
+
+    // Execute immediate
+    if (immediate) {
+      if (!this._data) {
+        console.debug('[settings] Removing local settings from storage');
+        return this.storage.remove(SETTINGS_STORAGE_KEY);
+      }
+      else {
+        console.debug('[settings] Store local settings', this._data);
+        if (this._serializeAsString) {
+          // Fix serialization error, in Sumaris-App
+          return this.storage.set(SETTINGS_STORAGE_KEY, JSON.stringify(this._data));
+        }
+        return this.storage.set(SETTINGS_STORAGE_KEY, this._data);
+      }
+    }
+
+    // Execute with delay
+    else {
+
+      // Create the event emitter
+      if (!this._$persist) {
+        this._$persist = new EventEmitter<any>(true);
+        this._$persist
+          .pipe(
+            debounceTime(2000), // add a delay of 2s
+            filter(() => this.started)
+          )
+          .subscribe(() => this.persistLocally(true));
+      }
+
+      this._$persist.emit();
+    }
+  }
+
+  private fillPageHistoryDefaults(page: HistoryPageReference, opts?: {
+      removePathQueryParams?: boolean;
+    removeTitleSmallTag?: boolean;
+  }): HistoryPageReference {
+    if (!page || !page.title || !page.path) throw Error('Missing required argument \'page\', \'page.path\' or \'page.title\'');
+
+    // Set time
+    page.time = page.time || DateUtils.moment();
+
+    // Clean the title (remove <small> tags)
+    if (!opts || opts.removeTitleSmallTag !== false) {
+      const tagIndex = page.title.indexOf('</small>');
+      if (tagIndex !== -1) {
+        page.title = page.title.substring(tagIndex + '</small>'.length);
+      }
+      page.title = page.title.replace(/[ ]*class='hidden-xs hidden-sm'/g, '');
+    }
+
+    // Remove query params
+    if (!opts || opts.removePathQueryParams !== false) {
+      page.path = page.path.replace(/[?].*$/, '');
+    }
+
+    return page;
+  }
+}

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

@@ -0,0 +1,141 @@
+import {LocalSettings} from './settings.model';
+import {Person} from './person.model';
+import {Entity, EntityAsObjectOptions} from './entity.model';
+import {EntityClass} from './entity.decorators';
+import {LatLongPattern} from '../../../shared/material/latlong/latlong.utils';
+import {equals, isNil} from '../../../shared/functions';
+import {UserToken} from './token.model';
+
+/**
+ * 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);
+  }
+
+}
+
+
+// @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;
+  }
+
+  merge<S = LocalSettings>(source: S, includesProperties: (keyof S)[]): boolean {
+    if (!source) return; // Skip
+
+    // Reset content
+    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 (includesProperties && includesProperties.includes(key as keyof S)){
+          if (!equals(this.content[key], source[key])) {
+            this.content[key] = Object.assign({}, source[key]);
+            hasChanges = true;
+          }
+        }
+      });
+    return hasChanges;
+  }
+
+  asLocalSettings(): Partial<LocalSettings> {
+    const target = {};
+    UserSettings.SETTINGS_PROPERTIES.forEach(key => {
+      target[key] = this[key];
+    });
+    Object.keys(this.content).forEach(key => {
+      target[key] = this.content[key];
+    });
+    return target;
+  }
+}
+
+
+export function accountToString(data: Account): string {
+  return data &&
+    ((data.firstName && (data.firstName + ' ') || '') +
+      (data.lastName || '')) || '';
+}