@sumaris-net/ngx-components 18.13.0 → 18.14.0

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

@@ -0,0 +1,425 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { gql } from 'apollo-angular';
+import { Configuration } from './model/config.model';
+import { Storage } from '@ionic/storage-angular';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { ErrorCodes } from './errors';
+import { GraphqlService } from '../graphql/graphql.service';
+import { FormFieldDefinition, FormFieldDefinitionMap } from '../../shared/form/field.model';
+import { isNotEmptyArray, isNotNil } from '../../shared/functions';
+import { FileService } from '../../shared/file/file.service';
+import { NetworkService } from './network.service';
+import { CORE_CONFIG_OPTIONS } from './config/core.config';
+import { Platform, ToastController } from '@ionic/angular';
+import { ShowToastOptions, Toasts } from '../../shared/toast/toasts';
+import { TranslateService } from '@ngx-translate/core';
+import { filter } from 'rxjs/operators';
+import { EntityServiceLoadOptions, IEntityService } from '../../shared/services/entity-service.class';
+import { Environment, ENVIRONMENT } from '../../../environments/environment.class';
+import { BaseGraphqlService } from './base-graphql-service.class';
+import { IStartableService } from '../../shared/services/startable-service.class';
+import { AccountService } from './account.service';
+import { isMobile } from '../../shared/platforms';
+import { BaseEntityGraphqlMutations } from './base-entity-service.class';
+
+import { ImagesUtils } from '../../shared/file/images.utils';
+
+const CONFIGURATION_STORAGE_KEY = 'configuration';
+
+/* ------------------------------------
+ * GraphQL queries
+ * ------------------------------------*/
+export const ConfigFragments = {
+  config: gql`
+    fragment ConfigFragment on ConfigurationVO {
+      id
+      label
+      name
+      description
+      comments
+      properties
+      smallLogo
+      largeLogo
+      backgroundImages
+      partners {
+        id
+        label
+        name
+        logo
+        siteUrl
+        __typename
+      }
+      updateDate
+      creationDate
+      statusId
+      __typename
+    }
+  `,
+};
+
+const ConfigQueries: { load: any } = {
+  load: gql`
+    query Configuration {
+      data: configuration {
+        ...ConfigFragment
+      }
+    }
+    ${ConfigFragments.config}
+  `,
+};
+
+// Save (create or update) account mutation
+const ConfigMutations: BaseEntityGraphqlMutations = {
+  save: gql`
+    mutation SaveConfiguration($data: ConfigurationVOInput) {
+      data: saveConfiguration(config: $data) {
+        ...ConfigFragment
+      }
+    }
+    ${ConfigFragments.config}
+  `,
+};
+
+const ClearCache: any = gql`
+  query ClearCache($name: String) {
+    clearCache(name: $name)
+  }
+`;
+
+const CacheStatistics: any = gql`
+  query CacheStatistics {
+    cacheStatistics
+  }
+`;
+
+export const APP_CONFIG_OPTIONS = new InjectionToken<FormFieldDefinitionMap>('defaultOptions');
+
+@Injectable({
+  providedIn: 'root',
+  deps: [APP_CONFIG_OPTIONS],
+})
+export class ConfigService
+  extends BaseGraphqlService<Configuration, any, number, Configuration>
+  implements IEntityService<Configuration>, IStartableService<Configuration>
+{
+  private _optionDefs: FormFieldDefinition[];
+  private $data = new BehaviorSubject<Configuration>(null);
+
+  get config(): Observable<Configuration> {
+    // If first call: start loading
+    if (!this.started) this.start();
+    return this.$data.pipe(filter(isNotNil));
+  }
+
+  constructor(
+    protected platform: Platform,
+    protected graphql: GraphqlService,
+    protected storage: Storage,
+    protected network: NetworkService,
+    protected file: FileService,
+    protected toastController: ToastController,
+    protected translate: TranslateService,
+    protected accountService: AccountService,
+    @Inject(ENVIRONMENT) protected environment: Environment,
+    @Optional() @Inject(APP_CONFIG_OPTIONS) defaultOptionsMap: FormFieldDefinitionMap
+  ) {
+    super(graphql, environment);
+
+    this._debug = !environment.production;
+    if (this._debug) console.debug('[config] Creating service');
+
+    this._optionDefs = Object.values({ ...CORE_CONFIG_OPTIONS, ...defaultOptionsMap });
+  }
+
+  protected async ngOnStart(): Promise<Configuration> {
+    console.info('[config] Starting configuration...');
+
+    const data = await this.loadOrRestoreLocally();
+    this.$data.next(data);
+
+    // Restart if graphql service restart
+    this.registerSubscription(this.graphql.stopSubject.subscribe(() => this.restart()));
+
+    return data;
+  }
+
+  async loadDefault(opts?: EntityServiceLoadOptions): Promise<Configuration> {
+    const now = Date.now();
+    console.debug('[config] Loading Pod configuration...');
+
+    const query = (opts && opts.query) || ConfigQueries.load;
+    const variables = (opts && opts.variables) || undefined;
+    const res = await this.graphql.query<{ data: any }>({
+      query,
+      variables,
+      error: { code: ErrorCodes.LOAD_CONFIG_ERROR, message: 'ERROR.LOAD_CONFIG_ERROR' },
+      fetchPolicy: (opts && opts.fetchPolicy) || undefined /*default*/,
+    });
+
+    const data = res?.data && opts?.toEntity !== false ? Configuration.fromObject(res.data) : res?.data;
+    console.info(`[config] Pod configuration loaded in ${Date.now() - now}ms:`, data);
+    return data;
+  }
+
+  async load(id: number, opts?: EntityServiceLoadOptions & { query?: any; variables?: any }): Promise<Configuration> {
+    console.warn('[config] Invalid call of configService.load(id). Please use loadDefault() instead');
+
+    return this.loadDefault(opts);
+  }
+
+  canUserWrite(data: Configuration): boolean {
+    return this.accountService.isAdmin();
+  }
+
+  /**
+   * Save a configuration
+   *
+   * @param config
+   */
+  async save(config: Configuration): Promise<Configuration> {
+    console.debug('[config] Saving Pod configuration...', config);
+
+    const json = config.asObject();
+
+    // Execute mutation
+    const res = await this.graphql.mutate<{ data: any }>({
+      mutation: ConfigMutations.save,
+      variables: {
+        data: json,
+      },
+      error: {
+        code: ErrorCodes.SAVE_CONFIG_ERROR,
+        message: 'ERROR.SAVE_CONFIG_ERROR',
+      },
+    });
+
+    // Copy update properties
+    const savedConfig = res?.data;
+    this.copyIdAndUpdateDate(savedConfig, config);
+
+    console.debug('[config] Pod configuration saved!');
+
+    // Full reload, to let pod recomputing some fields
+    const reloadedConfig = await this.loadDefault({ fetchPolicy: 'network-only' });
+
+    // Update computed properties, from reloaded item
+    config.smallLogo = reloadedConfig?.smallLogo;
+    config.largeLogo = reloadedConfig?.largeLogo;
+    config.backgroundImages = reloadedConfig?.backgroundImages;
+    config.partners = reloadedConfig?.partners;
+
+    // If this is the default config
+    const defaultConfig = this.$data.value;
+    if (isNotNil(defaultConfig) && reloadedConfig?.label === defaultConfig.label) {
+      // Emit update event when is default config
+      this.$data.next(reloadedConfig);
+    }
+
+    // return the original entity
+    return config;
+  }
+
+  async getCacheStatistics(): Promise<string> {
+    const now = Date.now();
+    console.debug('[config] Loading server cache statistics...');
+
+    const res = await this.graphql.query<{ cacheStatistics: any }>({
+      query: CacheStatistics,
+      variables: null,
+      error: { code: ErrorCodes.LOAD_CONFIG_ERROR, message: 'ERROR.LOAD_CONFIG_ERROR' },
+      fetchPolicy: 'network-only',
+    });
+
+    const data = (res && res.cacheStatistics) || undefined;
+    console.info(`[config] Server cache statistics loaded in ${Date.now() - now}ms:`, data);
+    return data;
+  }
+
+  async clearCache(opts?: { cacheName?: string }) {
+    const now = Date.now();
+    console.debug('[config] Clear server cache...');
+
+    const variables = (opts && opts.cacheName && { name: opts.cacheName }) || undefined;
+
+    const res = await this.graphql.query<{ clearCache: boolean }>({
+      query: ClearCache,
+      variables,
+      error: { code: ErrorCodes.LOAD_CONFIG_ERROR, message: 'ERROR.LOAD_CONFIG_ERROR' },
+      fetchPolicy: 'no-cache',
+    });
+
+    const data = (res && res.clearCache) || undefined;
+    console.info(`[config] Clear server cache in ${Date.now() - now}ms:`, data);
+    return data;
+  }
+
+  delete(data: Configuration): Promise<any> {
+    throw new Error('Not implemented yet!');
+  }
+
+  listenChanges(id: number): Observable<Configuration | undefined> {
+    return new Subject(); // TODO
+  }
+
+  get optionDefs(): FormFieldDefinition[] {
+    return this._optionDefs;
+  }
+
+  /* -- protected method -- */
+
+  protected copyIdAndUpdateDate(source: Configuration | undefined, target: Configuration) {
+    if (!source) return;
+
+    target.id = source.id || target.id;
+    target.updateDate = source.updateDate || target.updateDate;
+  }
+
+  private async loadOrRestoreLocally(): Promise<Configuration> {
+    let data: Configuration;
+    let wasJustLoaded = false;
+    if (this.network.online) {
+      try {
+        data = await this.loadDefault({ fetchPolicy: 'network-only' });
+        wasJustLoaded = true;
+      } catch (err) {
+        // Log, then continue
+        console.error((err && err.message) || err, err);
+      }
+    }
+
+    // Save it into local storage, for next startup
+    if (data) {
+      setTimeout(() => this.storeLocally(data), 2000);
+    }
+
+    // If not loaded remotely: try to restore it
+    else {
+      data = await this.restoreLocally();
+    }
+
+    // Make sure label has been filled
+    data.label = data.label || this.environment.name;
+
+    // Reset name (if same as label)
+    data.name = data.name !== data.label ? data.name : undefined;
+
+    // Check compatible version
+    if (wasJustLoaded) {
+      // TODO
+    }
+
+    return data;
+  }
+
+  private async restoreLocally(): Promise<Configuration> {
+    let data: Configuration;
+
+    // Try to load from local storage
+    const value: any = await this.storage.get(CONFIGURATION_STORAGE_KEY);
+    if (value) {
+      console.debug('[config] Restoring configuration from local storage...');
+      if (typeof value === 'string') {
+        try {
+          data = Configuration.fromObject(JSON.parse(value));
+        } catch (err) {
+          console.error(`Failed to parse config found in local storage: ${(err && err.message) || err}`, err);
+        }
+      } else if (typeof value === 'object') {
+        data = Configuration.fromObject(value);
+      }
+
+      console.debug('[config] Restoring configuration [OK]');
+    }
+
+    // Or load default value, from the environment
+    if (!data) {
+      console.debug('[config] No configuration found. Using environment...');
+      data = Configuration.fromObject(this.environment as any);
+    }
+
+    return data;
+  }
+
+  private async storeLocally(data?: Configuration) {
+    // Nothing to store : reset
+    if (!data) {
+      await this.storage.remove(CONFIGURATION_STORAGE_KEY);
+    }
+    // Config exists: store it in the local storage
+    else {
+      let now = this._debug && Date.now();
+
+      // Convert images, for offline usage
+      if (this.network.online && isMobile(window)) {
+        const jobs = [];
+
+        // Download logos
+        if (data.largeLogo && data.largeLogo.startsWith('http')) {
+          const largeLogo = ImagesUtils.getImageAndCredit(data.largeLogo)?.image; // Remove credit
+          jobs.push(this.file.getImage(largeLogo).then((imgUrl) => (data.largeLogo = imgUrl)));
+        }
+        if (data.smallLogo && data.smallLogo.startsWith('http')) {
+          const smallLogo = ImagesUtils.getImageAndCredit(data.smallLogo)?.image; // Remove credit
+          jobs.push(this.file.getImage(smallLogo).then((imgUrl) => (data.smallLogo = imgUrl)));
+        }
+
+        // Background images
+        if (isNotEmptyArray(data.backgroundImages)) {
+          const options = {
+            maxWidth: this.platform.width(),
+            maxHeight: this.platform.height(),
+          };
+
+          // Convert the FIRST image found
+          // WARN: it's NOT necessary to convert ALL image, but only one, for smaller memory footprint
+          const index = data.backgroundImages.findIndex((img) => img?.startsWith('http'));
+          if (index !== -1) {
+            const image = ImagesUtils.getImageAndCredit(data.backgroundImages[index])?.image; // Remove credit
+            jobs.push(this.file.getImage(image, options).then((dataUrl) => (data.backgroundImages = [dataUrl])));
+          }
+        }
+
+        // Partners
+        if (isNotEmptyArray(data.partners)) {
+          data.partners.forEach((dep) => {
+            if (dep?.logo && dep.logo.startsWith('http')) {
+              jobs.push(
+                this.file
+                  .getImage(dep.logo, {
+                    maxHeight: 50 /*see home page CSS */,
+                  })
+                  .then((img) => (dep.logo = img))
+                  .catch((err) => {
+                    console.error((err && err.message) || err);
+                    delete dep.logo;
+                  })
+              );
+            }
+          });
+        }
+
+        if (jobs.length) {
+          if (this._debug) console.debug(`[config] Fetching ${jobs.length} images...`);
+          try {
+            await Promise.all(jobs);
+            if (this._debug) console.debug(`[config] Fetching ${jobs.length} images [OK] in ${Date.now() - now}ms`);
+          } catch (err) {
+            console.error(`[config] Failed to fetch image(s): ${(err && err.message) || err}`, err);
+          }
+        }
+      }
+
+      // Saving config to storage
+      {
+        now = this._debug && Date.now();
+        if (this._debug) console.debug('[config] Saving config into local storage...');
+        await this.storage.set(CONFIGURATION_STORAGE_KEY, data.asObject());
+        if (this._debug) console.debug(`[config] Saving config into local storage [OK] in ${Date.now() - now}ms`);
+      }
+    }
+  }
+
+  protected async showToast(opts: ShowToastOptions) {
+    await Toasts.show(this.toastController, this.translate, opts);
+  }
+}

package/src/app/core/services/crypto.service.ts

@@ -0,0 +1,126 @@
+import { Injectable } from '@angular/core';
+
+import { scryptEncode } from '@polkadot/util-crypto/scrypt/encode';
+import { ScryptParams } from '@polkadot/util-crypto/scrypt/types';
+import {
+  base58Decode,
+  base64Decode,
+  base64Encode,
+  cryptoWaitReady,
+  ed25519PairFromSeed,
+  ed25519Sign,
+  ed25519Verify,
+  sha256AsU8a,
+  sha512AsU8a,
+} from '@polkadot/util-crypto';
+
+import { bytesToHex as toHex } from '@noble/hashes/utils';
+import { Keypair } from '@polkadot/util-crypto/types';
+import { stringToU8a } from '@polkadot/util';
+
+export const ED25519_SEED_LENGTH = 32; // Length of a ED25519 seed
+
+export const SCRYPT_PARAMS = {
+  SIMPLE: <ScryptParams>{
+    N: 2048,
+    r: 8,
+    p: 1,
+  },
+  DEFAULT: <ScryptParams>{
+    N: 4096,
+    r: 16,
+    p: 1,
+  },
+  SECURE: <ScryptParams>{
+    N: 16384,
+    r: 32,
+    p: 2,
+  },
+  HARDEST: <ScryptParams>{
+    N: 65536,
+    r: 32,
+    p: 4,
+  },
+  EXTREME: <ScryptParams>{
+    N: 262144,
+    r: 64,
+    p: 8,
+  },
+};
+
+export { Keypair };
+
+@Injectable({ providedIn: 'root' })
+export class CryptoService {
+  private static _ready = false;
+
+  private static get started() {
+    return this._ready;
+  }
+
+  private static async ready(): Promise<void> {
+    if (this._ready) return; // OK
+
+    await cryptoWaitReady();
+    this._ready = true;
+  }
+
+  /**
+   * Generate a sign keypair, using scrypt, from a salt and a password
+   *
+   * @param salt
+   * @param password
+   * @param scryptParams
+   */
+  static async scryptKeypair(salt: string, password: string, scryptParams?: ScryptParams): Promise<Keypair> {
+    if (!this.started) await this.ready();
+    const saltU8a = stringToU8a(salt);
+    const result = scryptEncode(password, saltU8a, scryptParams || SCRYPT_PARAMS.DEFAULT);
+    const seed = result.password.slice(0, ED25519_SEED_LENGTH);
+    return ed25519PairFromSeed(seed);
+  }
+
+  /**
+   * Sign a message, from a key pair
+   */
+  static async sign(message: string, keypair: Keypair): Promise<string> {
+    if (!this.started) await this.ready();
+
+    const m = stringToU8a(message);
+    const sig = ed25519Sign(m, keypair);
+    return base64Encode(sig);
+  }
+
+  /**
+   * Sign a message, from a key pair
+   */
+  static async verify(message: string, signature: string, publicKey: string): Promise<boolean> {
+    if (!this.started) await this.ready();
+
+    const m = stringToU8a(message);
+    const sig = base64Decode(signature);
+    const pub = base58Decode(publicKey);
+    return ed25519Verify(m, sig, pub);
+  }
+
+  /**
+   * Hash (using SHA256) a message, as Hex
+   */
+  static sha256(message: string): string {
+    const bytes = sha256AsU8a(message);
+    return toHex(bytes);
+  }
+
+  /**
+   * Hash (using SHA512) a message, as Hex
+   */
+  static sha512(message: string): string {
+    const bytes = sha512AsU8a(message);
+    return toHex(bytes);
+  }
+
+  static encodeBase64(message: string): string {
+    const m = stringToU8a(message);
+    return base64Encode(m);
+  }
+}

package/src/app/core/services/errors.ts

@@ -0,0 +1,80 @@
+import { FormErrors } from '../../shared/forms';
+
+export interface AppError {
+  code?: number;
+  message?: string;
+}
+
+export interface AppErrorWithDetails extends AppError {
+  details: AppError & { errors?: FormErrors };
+}
+
+export declare interface ServiceError {
+  code: number;
+  message: string;
+  reject?: (err) => void;
+}
+
+export const ErrorCodes = {
+  UNKNOWN_ERROR: 0,
+
+  LOAD_ACCOUNT_ERROR: 1,
+  BAD_PASSWORD: 2,
+  UNKNOWN_ACCOUNT_EMAIL: 3,
+  EMAIL_ALREADY_REGISTERED: 4,
+  UNREACHABLE_NETWORK_ERROR: 4,
+  UNKNOWN_NETWORK_ERROR: 5,
+  SENT_CONFIRMATION_EMAIL_FAILED: 6,
+  CONFIRM_EMAIL_FAILED: 7,
+  SAVE_ACCOUNT_ERROR: 8,
+  ACCOUNT_NOT_EXISTS: 9,
+  SAVE_SETTINGS_ERROR: 8,
+  SUBSCRIBE_ACCOUNT_ERROR: 10,
+  ENTITY_STORAGE_MIGRATION_FAILED: 11,
+
+  LOAD_DATA_ERROR: 12,
+  SAVE_DATA_ERROR: 13,
+  DELETE_DATA_ERROR: 14,
+  SUBSCRIBE_DATA_ERROR: 15,
+
+  // DATA errors (load error)
+  LOAD_PERSONS_ERROR: 100,
+  DATA_NOT_FOUND_ERROR: 104,
+
+  TABLE_INVALID_ROW_ERROR: 350,
+  TABLE_READ_ONLY: 351,
+
+  UNAUTHORIZED: 401,
+  INTERNAL_SERVER_ERROR: 500,
+  AUTH_CHALLENGE_ERROR: 601,
+  AUTH_SERVER_ERROR: 602,
+  AUTH_SEND_RESET_PASSWORD_EMAIL_ERROR: 603,
+  AUTH_RESET_PUBKEY_ERROR: 604,
+  AUTH_UPDATE_PUBKEY_ERROR: 605,
+
+  LOAD_CONFIG_ERROR: 700,
+  SAVE_CONFIG_ERROR: 701,
+
+  LOAD_TRASH_ENTITY_ERROR: 800,
+  DELETE_TRASH_ENTITY_ERROR: 801,
+};
+
+export const ServerErrorCodes = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401, // not authenticated
+  FORBIDDEN: 403, // authenticated but no access right
+  NOT_FOUND: 404,
+
+  // sumaris-core-shared errors
+  INTERNAL_SERVER_ERROR: 500,
+  DATA_LOCKED: 520,
+  BAD_UPDATE_DATE: 521,
+  DENY_DELETION: 522,
+  DATA_NOT_UNIQUE: 523,
+
+  // sumaris-server errors
+  INVALID_EMAIL_CONFIRMATION: 550,
+  INVALID_QUERY_VARIABLES: 551,
+  ACCOUNT_ALREADY_EXISTS: 552,
+  BAD_APP_VERSION: 553,
+};

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

@@ -0,0 +1,39 @@
+import { TestBed } from '@angular/core/testing';
+import { LocalSettingsService } from './local-settings.service';
+import { TranslateModule } from '@ngx-translate/core';
+import { IonicStorageModule } from '@ionic/storage-angular';
+import { ENVIRONMENT } from '../../../environments/environment.class';
+import { environment } from '../../../environments/environment.test';
+import { StorageService } from '../../shared/storage/storage.service';
+import { IonicModule } from '@ionic/angular';
+
+describe('LocalSettingsService', () => {
+  let service: LocalSettingsService;
+  let storage: StorageService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [TranslateModule.forRoot(), IonicModule, IonicStorageModule.forRoot()],
+      providers: [
+        StorageService,
+        LocalSettingsService,
+        {
+          provide: ENVIRONMENT,
+          useValue: environment,
+        },
+      ],
+      teardown: { destroyAfterEach: false },
+    });
+    service = TestBed.inject(LocalSettingsService);
+    storage = TestBed.inject(StorageService);
+  });
+
+  it('should be created', async () => {
+    expect(service).toBeTruthy();
+    await storage.ready();
+    const settings = await service.ready();
+    expect(settings).toBeDefined();
+    expect(settings.locale).toBeUndefined();
+    expect(settings.latLongFormat).toBe('DDMM');
+  });
+});