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

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

@@ -1,729 +0,0 @@
-import {EventEmitter, Inject, Injectable, Optional} from '@angular/core';
-import {CryptoService} from './crypto.service';
-import {TranslateService} from '@ngx-translate/core';
-import {Storage} from '@ionic/storage-angular';
-import {Peer} from './model/peer.model';
-import {LocalSettings} from './model/settings.model';
-import {ModalController, Platform, ToastController} from '@ionic/angular';
-import {ISelectPeerModalOptions, SelectPeerModal} from '../peer/select-peer.modal';
-import {BehaviorSubject, Subscription, timer} from 'rxjs';
-import {LocalSettingsService, SETTINGS_STORAGE_KEY} from './local-settings.service';
-import {SplashScreen} from '@capacitor/splash-screen';
-import {HttpClient, HttpHeaders} from '@angular/common/http';
-import {isNotEmptyArray, isNotNilOrBlank, sleep, toBoolean} from '../../shared/functions';
-import {Network} from '@awesome-cordova-plugins/network/ngx';
-import {DOCUMENT} from '@angular/common';
-import {CacheService} from 'ionic-cache';
-import {ShowToastOptions, Toasts} from '../../shared/toast/toasts';
-import {distinctUntilChanged, filter, first, map, mergeMap, takeUntil, tap} from 'rxjs/operators';
-import {OverlayEventDetail} from '@ionic/core';
-import {AppManifest, NodeInfo} from './network.utils';
-import {HttpUtils} from '../../shared/http/http.utils';
-import {VersionUtils} from '../../shared/version/versions';
-import {ENVIRONMENT} from '../../../environments/environment.class';
-import {StartableObservableService} from '../../shared/services/startable-observable-service.class';
-import {ConnectionType, getConnectionType, NetworkEventType} from './network.types';
-import {APP_LOGGING_SERVICE} from '../../shared/logging/logging-service.class';
-import {ILogger, ILoggingService} from '../../shared/logging/logger.model';
-
-const NetworkRefreshTimerPeriod = {
-    MOBILE:  1000 * 60 * 10 /* every 10 min */,
-    DESKTOP: 1000 * 60 * 5 /* every 5 min */
-};
-
-export const PEER_URL_REGEXP = /^(http|https):\/\/[^ "?#@]+$/;
-
-/* -- DEV only (to debug refresh timer)
-const NetworkRefreshTimerPeriod = {
-    MOBILE:  1000,
-    DESKTOP: 1000
-}*/
-
-@Injectable({providedIn: 'root'})
-export class NetworkService extends StartableObservableService<Peer, Peer> {
-
-  onPeerChanges = this.startSubject.pipe(
-    map(peer => peer?.url),
-    filter(isNotNilOrBlank),
-    distinctUntilChanged<string>()
-  );
-  onNetworkStatusChanges = new BehaviorSubject<ConnectionType>(null);
-  onResetNetworkCache = new EventEmitter(true);
-
-  private readonly _mobile: boolean;
-  private readonly _logger: ILogger;
-  private _timerSubscription: Subscription;
-  private readonly _timerRefreshPeriod: number;
-  private readonly _timerRefreshCondition: () => boolean;
-  private _deviceConnectionType: ConnectionType;
-  private _forceOffline: boolean;
-  private _listeners: {
-   [key: string]: ((data?: any) => Promise<void>)[];
-  } = {};
-
-  get online(): boolean {
-    return this.connectionType !== 'none';
-  }
-
-  get offline(): boolean {
-    return this.connectionType === 'none';
-  }
-
-  get connectionType(): ConnectionType{
-    // If force offline: return 'none'
-    return this._forceOffline && 'none'
-      // Else, return device connection type (or unknown)
-      || (this.started && this._deviceConnectionType || 'unknown');
-  }
-
-  get peer(): Peer {
-    return this.dataSubject.value?.clone();
-  }
-
-  set peer(peer: Peer) {
-    this.restart(peer);
-  }
-
-  constructor(
-    @Inject(DOCUMENT) private _document: any,
-    private platform: Platform,
-    private modalCtrl: ModalController,
-    private cryptoService: CryptoService,
-    private storage: Storage,
-    private settings: LocalSettingsService,
-    private cache: CacheService,
-    private http: HttpClient,
-    @Inject(ENVIRONMENT) protected environment,
-    @Optional() @Inject(APP_LOGGING_SERVICE) private loggingService: ILoggingService,
-    @Optional() private network: Network,
-    @Optional() private translate: TranslateService,
-    @Optional() private toastController: ToastController
-  ) {
-    super(platform);
-    this._mobile = this.settings.mobile;
-    this._logger = this.loggingService?.getLogger('network');
-
-    if (this._mobile) {
-      this._timerRefreshPeriod = NetworkRefreshTimerPeriod.MOBILE;
-      this._timerRefreshCondition = () => this.online; // Check only when online, and stop when offline
-    }
-    else {
-      this._timerRefreshPeriod = NetworkRefreshTimerPeriod.DESKTOP;
-      this._timerRefreshCondition = () => true; // Always check
-    }
-
-    this.startSubject.subscribe(peer => this.ngOnAfterStart(peer));
-
-    // For DEV only
-    this._debug = !environment.production;
-
-  }
-
-  /**
-   * Register to network event
-   *
-   * @param eventType
-   * @param callback
-   */
-  on<T= any>(eventType: NetworkEventType, callback: (data?: T) => Promise<any>): Subscription {
-    switch (eventType) {
-      case 'start':
-        return this.startSubject.subscribe(() => callback());
-
-      case 'peerChanged':
-        return this.onPeerChanges.subscribe(() => callback());
-
-      case 'statusChanged':
-        return this.onNetworkStatusChanges.subscribe((type) => callback(type as unknown as T));
-
-      case 'resetCache':
-        return this.onResetNetworkCache.subscribe(() => callback());
-
-      default:
-        return this.addListener(eventType, callback);
-    }
-  }
-
-  async tryOnline(opts?: {
-    showOfflineToast?: boolean;
-    showOnlineToast?: boolean;
-    showLoadingToast?: boolean;
-    afterRetryDelay?: number;
-    afterRetryPromise?: () => Promise<any>;
-  }): Promise<boolean> {
-    // If offline mode not forced, and device says there is no connection: skip
-    if (!this._forceOffline || this._deviceConnectionType === 'none') return false;
-
-    // SHow loading toast
-    const now = Date.now();
-    const showLoadingToast = !opts || opts.showLoadingToast !== false;
-    let loadingToast: HTMLIonToastElement;
-    if (showLoadingToast) {
-      await this.showToast({message: 'NETWORK.INFO.RETRY_TO_CONNECT',
-        duration: 10000,
-        onWillPresent: t => loadingToast = t});
-    }
-
-    try {
-      console.info('[network] Checking connection to pod...');
-      const settings: LocalSettings = await this.settings.ready();
-
-      if (!settings.peerUrl) return false; // No peer define. Skip
-
-      const peer = Peer.parseUrl(settings.peerUrl);
-      const peerInfo = await this.checkPeerAlive(peer);
-      const peerAliveAndCompatible = peerInfo && await this.checkPeerCompatible(peerInfo);
-      if (peerAliveAndCompatible) {
-
-        // Disable the offline mode
-        this.setForceOffline(false);
-
-        // Restart
-        await this.restart(peer);
-
-        // Wait a promise, before recheck
-        await this.emit('beforeTryOnlineFinish', this.online);
-
-      }
-    }
-    catch (err) {
-      console.error(err && err.message || err);
-      // Continue
-    }
-
-    // Close loading toast (with a minimal display duration of 2s)
-    if (showLoadingToast) {
-      await sleep(2000 - (Date.now() - now));
-      if (loadingToast) await loadingToast.dismiss();
-    }
-
-    // Recheck network status
-    const online = this.online;
-
-    // Display a toast to user
-    if (online) {
-      if (!opts || opts.showOnlineToast !== false) {
-        // Display toast (without await, because not need to wait toast close event)
-        this.showToast({message: 'NETWORK.INFO.ONLINE', type: 'info'});
-      }
-    }
-    else if (opts && opts.showOfflineToast === true) {
-      // Display toast (without await, because not need to wait toast close event)
-      return this.showOfflineToast({showRetryButton: false});
-    }
-
-    return this.started && online;
-  }
-
-  async showOfflineToast(opts?: {
-    message?: string;
-    showCloseButton?: boolean;
-    showRetryButton?: boolean;
-    showRetrySuccessToast?: boolean;
-    showRetryLoadingToast?: boolean;
-    onRetrySuccess?: () => void;
-  }): Promise<boolean> {
-    if (this.online) return; // Skip if online
-
-    // Toast with a retry button
-    if (!opts || opts.showRetryButton !== false) {
-
-      const toastResult = await this.showToast({
-        message: (opts && opts.message || 'ERROR.NETWORK_REQUIRED'),
-        type: 'warning',
-        showCloseButton: true,
-        duration: 100000,
-        buttons: [
-          // reconnect button
-          {
-            role: 'refresh',
-            text: this.translate.instant('NETWORK.BTN_CHECK_ALIVE')
-          }
-        ]
-      });
-
-      // User don't click reconnect: return
-      if (!toastResult || toastResult.role !== 'refresh') return false;
-
-      // if network state changed to online: exit here
-      if (this.online) return true;
-
-      // Try to reconnect
-      const online = await this.tryOnline({
-        showOfflineToast: false,
-        showOnlineToast: toBoolean(opts && opts.showRetrySuccessToast, true),
-        showLoadingToast: toBoolean(opts && opts.showRetryLoadingToast, true)
-      });
-      if (online) {
-        // Call success callback (async)
-        if (opts && opts.onRetrySuccess) {
-          setTimeout(opts.onRetrySuccess);
-        }
-        return true;
-      }
-
-      opts = {
-        ...opts,
-        showRetryButton: false,
-        showCloseButton: true
-      };
-    }
-
-    // Simple toast, without 'await', because not need to wait toast's dismiss
-    this.showToast({
-      message: 'ERROR.NETWORK_REQUIRED',
-      type: 'error',
-      ...opts
-    });
-
-    return false;
-  }
-
-
-  /**
-   * Check if the peer is alive
-   *
-   * @param peer
-   * @param opts
-   */
-  async checkPeerAlive(peer?: string | Peer, opts?: { checkCompatible?: boolean; displayToast?: boolean } ): Promise<NodeInfo> {
-    peer = peer || this.peer;
-    if (!peer) {
-      const settings: LocalSettings = await this.settings.ready();
-      if (!settings.peerUrl) return undefined; // No peer define. Skip
-      peer = Peer.parseUrl(settings.peerUrl);
-    }
-
-    return this.getNodeInfo(peer);
-  }
-
-  async checkPeerCompatible(peerInfo: NodeInfo, opts?: { showToast?: boolean }): Promise<boolean> {
-    if (!this.environment.peerMinVersion) return true; // Skip compatibility check
-
-    // Check the min pod version, defined by the app
-    const isCompatible = peerInfo && peerInfo.softwareVersion && VersionUtils.isCompatible(this.environment.peerMinVersion, peerInfo.softwareVersion);
-
-    // Display toast, if not compatible
-    if (!isCompatible && (!opts || opts.showToast !== false)) {
-      await this.showToast({
-        type: 'error',
-        message: 'NETWORK.ERROR.NOT_COMPATIBLE_PEER',
-        messageParams: {
-          version: this.environment.peerMinVersion
-        },
-        showCloseButton: true
-      });
-    }
-    return isCompatible;
-  }
-
-  async getNodeInfo(peer?: string | Peer): Promise<NodeInfo> {
-
-    const path = this.computePeerPath(peer, '/api/node/info');
-    this._logger?.debug('checkPeerAlive', `Getting '${path}' ...`);
-
-    try {
-      const data:NodeInfo = await this.get(path);
-      this._logger?.debug('checkPeerAlive', `Response of '${path}':\n${JSON.stringify(data)}`);
-      return data;
-    } catch (err) {
-      console.debug(`[network] Error while getting '${path}': ${err && err.message || err}`, err);
-      this._logger?.error('checkPeerAlive', `Error while getting '${path}': ${err?.message || ''}`);
-      return undefined;
-    }
-  }
-
-  async getAppManifest(peer?: string | Peer, opts?: {nocache?: boolean}): Promise<AppManifest|undefined> {
-    try {
-      let path = this.computePeerPath(peer, 'manifest.json');
-      if (opts?.nocache) {
-        path += '?t=' + Date.now();
-      }
-      return await this.get(path, opts);
-    }
-    catch (err) {
-      if (this.environment.production) console.error('[network] Cannot load file \'manifest.json\'. Please make sure webserver config allow CORS access', err);
-      else console.error('[network] Cannot load file \'manifest.json\'.', err);
-      // Continue
-    }
-  }
-
-  async getAppVersion(peer?: string | Peer, opts = {nocache: true}): Promise<string|undefined> {
-    try {
-      let path = this.computePeerPath(peer, 'version.appup');
-      if (opts.nocache) {
-        path += '?t=' + Date.now();
-      }
-      const appVersion: string = await this.getText(path, opts);
-      if (isNotNilOrBlank(appVersion)) return appVersion;
-    }
-    catch (err) {
-      if (this.environment.production) console.error('[network] Cannot load file \'version.appup\'. Please make sure webserver config allow CORS access');
-      else console.error('[network] Cannot load file \'version.appup\'.', err);
-      // Continue
-    }
-
-    // Try loading manifest.json
-    const manifest = await this.getAppManifest(peer, opts);
-    return manifest?.version;
-  }
-
-  computePeerPath(peer: string | Peer | undefined, path: string): string | undefined {
-    peer = peer || this.peer;
-    if (!peer) return undefined;
-
-    let peerUrl = (peer instanceof Peer) ? peer.url : (peer as string);
-
-    // Remove trailing slash
-    if (peerUrl.endsWith('/')) {
-      peerUrl = peerUrl.substr(0, peerUrl.length - 1);
-    }
-
-    // Add first path
-    if (!path.startsWith('/')) {
-      path = '/' + path;
-    }
-
-    // Concat peer URL and path
-    return peerUrl + path;
-  }
-
-
-  /**
-   * Allow to force offline mode
-   */
-  setForceOffline(value?: boolean, opts?: {
-    showToast?: boolean; // Display a toast, when offline ?
-  }) {
-    value = toBoolean(value, true);
-    if (this._forceOffline !== value) {
-      const previousConnectionType = this.connectionType;
-      this._forceOffline = value;
-      const currentConnectionType = this.connectionType;
-
-      if (previousConnectionType !== currentConnectionType) {
-        console.info(`[network] Connection changed to {${currentConnectionType}}`);
-        this.onNetworkStatusChanges.next(currentConnectionType);
-
-        // Offline mode: alert the user
-        if (currentConnectionType === 'none' && (!opts || opts.showToast !== false)) {
-          this.showToast({message: 'NETWORK.INFO.OFFLINE_HELP', type: 'warning'});
-        }
-      }
-    }
-  }
-
-  async showSelectPeerModal(opts?: Partial<ISelectPeerModalOptions>): Promise<Peer | undefined> {
-
-    opts = opts || {};
-
-    const $onRefresh = new EventEmitter<Event>();
-    const peers$ = $onRefresh.pipe(
-      mergeMap((_) => this.getDefaultPeers()),
-      map(peers => peers || [])
-    );
-
-    const modal = await this.modalCtrl.create({
-      component: SelectPeerModal,
-      componentProps: <ISelectPeerModalOptions>{
-        onRefresh: $onRefresh,
-        peers: peers$,
-        ...opts
-      },
-      keyboardClose: true,
-      showBackdrop: true
-    });
-    await modal.present();
-    $onRefresh.emit();
-
-    const { data } = await modal.onWillDismiss();
-    $onRefresh.complete();
-
-    return data && (data as Peer) || undefined;
-  }
-
-  async clearCache(opts?: { emitEvent?: boolean }): Promise<void> {
-
-    const now = this._debug && Date.now();
-
-    console.info('[network] Clearing all caches...');
-    return this.cache.clearAll()
-      .then(() => {
-        // Emit event
-        if (!opts || opts.emitEvent !== false && this.onResetNetworkCache.observers.length > 0) {
-          this.onResetNetworkCache.emit();
-
-          // Wait observers clean their caches, if need
-          return sleep(500);
-        }
-      })
-      .then(() => {
-        if (this._debug) console.debug(`[network] All cache cleared, in ${Date.now() - now}ms`);
-      });
-  }
-
-  /* -- protected functions -- */
-
-  protected async ngOnStart(peer?: Peer): Promise<Peer> {
-
-    console.info('[network] Starting network...');
-
-    // Restoring local settings
-    peer = peer || (await this.restoreLocally());
-
-    // Make sure to hide the splashscreen, before open the modal
-    if (!peer) await SplashScreen.hide();
-
-    // No peer in settings: ask user to choose
-    while (!peer) {
-      console.debug('[network] No peer defined. Asking user to choose a peer.');
-      peer = await this.showSelectPeerModal({allowSelectDownPeer: false});
-    }
-
-    console.info(`[network] Starting service [OK] {peer: '${peer.url}', online: ${this.online}}`);
-
-    return peer;
-  }
-
-  protected async ngOnAfterStart(peer: Peer) {
-
-    // Wait settings starts, then save peer in settings
-    await this.settings.apply({peerUrl: peer.url});
-
-    this.onDeviceConnectionChanged(this.network?.type || 'unknown');
-
-    // Start the refresh timer
-    this.startRefreshTimer();
-
-    // Listen for device network changes
-    if (this.network) {
-      this.registerSubscription(this.network.onDisconnect().subscribe(() => this.onDeviceConnectionChanged('none')));
-      this.registerSubscription(this.network.onConnect().subscribe(() => this.onDeviceConnectionChanged(this.network.type)));
-    }
-  }
-
-  protected ngOnStop() {
-    // Stop timer, if cannot refresh anymore
-    if (this._timerRefreshCondition() === false) {
-      this.stopRefreshTimer();
-    }
-  }
-
-  /**
-   * Try to restore peer from the local storage
-   */
-  protected async restoreLocally(): Promise<Peer | undefined> {
-
-    // Restore from storage
-    let settings = await this.storage.get(SETTINGS_STORAGE_KEY);
-    settings = (typeof settings === 'string') ? JSON.parse(settings) : settings;
-    if (settings && settings.peerUrl) {
-      console.debug(`[network] Use peer {${settings.peerUrl}} (found in the local storage)`);
-      return Peer.parseUrl(settings.peerUrl);
-    }
-
-    // Else, use default peer in env, if exists
-    if (this.environment.defaultPeer) {
-      return Peer.fromObject(this.environment.defaultPeer);
-    }
-
-    // Else, if App is hosted, try the web site as a peer
-    const location = this._document && this._document.location;
-    if (location && location.protocol && location.protocol.startsWith('http')) {
-      const hostname = this._document.location.host;
-      const detectedPeer = Peer.parseUrl(`${this._document.location.protocol}${hostname}${this.environment.baseUrl}`);
-
-      if (await this.checkPeerAlive(detectedPeer)) {
-        return detectedPeer;
-      }
-
-      // Peer not alive, but should be at the same URL, retrying each 1s
-      if (this.environment.sameUrlPeer) {
-        return await timer(1000, 1000)
-          .pipe(
-            takeUntil(this.stopSubject),
-            tap(() => console.warn(`[network-service] Waiting peer be be alive, at {${detectedPeer.url}} ...`)),
-            mergeMap(() => this.checkPeerAlive(detectedPeer)),
-            filter(alive => !!alive),
-            map(() => detectedPeer),
-            first()
-          ).toPromise();
-      }
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Stop to network state
-   *
-   * @protected
-   */
-  protected stopRefreshTimer() {
-    if (this._timerSubscription) {
-      this._timerSubscription.unsubscribe();
-      this._timerSubscription = undefined;
-    }
-  }
-
-  /**
-   * Refresh the network state
-   *
-   * @protected
-   */
-  protected startRefreshTimer(){
-    if (this._timerSubscription) return; // Already running: skip
-
-    console.info(`[network] Starting refresh timer, every ${this._timerRefreshPeriod}ms...`);
-
-    let lastInfo: NodeInfo;
-    this._timerSubscription = timer(this._timerRefreshPeriod, this._timerRefreshPeriod)
-      .pipe(
-        // Skip some timer event (see constructor)
-        filter(this._timerRefreshCondition),
-
-        // Checkin if peer alive
-        tap(() =>  console.debug('[network] Checking connection to pod...')),
-        mergeMap(() => this.checkPeerAlive(this.peer)),
-
-        // Filter to keep only changes
-        filter(info => !!info !== !!lastInfo),
-        tap(info => lastInfo = info),
-
-        // Check compatibility
-        mergeMap((info) => this.checkPeerCompatible(info, {showToast: true})),
-      )
-      .subscribe(alive => {
-          if (alive && this.offline) {
-            this.setForceOffline(false);
-
-            // Restart the service (to force re auth)
-            this.restart();
-          }
-          else if (!alive && this.online){
-            this.setForceOffline(true);
-
-            // Stop the service
-            this.stop();
-          }
-        });
-
-    this._timerSubscription.add(() => console.debug('[network] Refresh timer stopped'));
-  }
-
-
-  protected async getText(path: string, opts?: {
-    headers?: HttpHeaders | {
-      [header: string]: string | string[];
-    };
-    responseType?: 'text';
-    nocache?: boolean;
-  }): Promise<string> {
-
-    return HttpUtils.getText(this.http, this.getUri(path), opts);
-  }
-
-  protected get<T>(path: string, opts?: {
-    headers?: HttpHeaders | {
-      [header: string]: string | string[];
-    };
-    responseType?: 'json';
-    nocache?: boolean;
-  }): Promise<T> {
-
-    return HttpUtils.getJson<T>(this.http, this.getUri(path), opts);
-  }
-
-  /* -- Protected methods -- */
-
-  protected getUri(path: string): string {
-    let uri = path;
-
-    // If path is not an URI: prepend with peer URL
-    if (!uri.startsWith('http://') && !uri.startsWith('https://')) {
-      let peerUrl = (this.peer && this.peer.url);
-
-      // Remove trailing slash
-      if (peerUrl.endsWith('/')) {
-        peerUrl = peerUrl.substr(0, peerUrl.length - 1 );
-      }
-
-      // Add first path
-      if (!path.startsWith('/')) {
-        path = '/' + path;
-      }
-
-      // Create the URI: concat peer URL and path
-      uri = peerUrl + path;
-    }
-    return uri;
-  }
-  protected onDeviceConnectionChanged(connectionType?: string) {
-    connectionType = getConnectionType(connectionType);
-    if (connectionType !== this._deviceConnectionType) {
-      this._deviceConnectionType = connectionType as ConnectionType;
-
-      // If NOT  already forced as offline, emit event
-      if (!this._forceOffline) {
-        console.info(`[network] Connection changed to {${this._deviceConnectionType}}`);
-        this.onNetworkStatusChanges.next(this._deviceConnectionType);
-
-        // Change to offline
-        if (this._deviceConnectionType === 'none') {
-          if (this._mobile) {
-            // Force offline mode
-            this._forceOffline = true;
-
-            // Alert the user
-            this.showToast({message: 'NETWORK.INFO.OFFLINE_HELP', type: 'warning'});
-          }
-          else {
-            // Alert the user
-            this.showToast({message: 'NETWORK.INFO.OFFLINE', type: 'warning'});
-          }
-
-          // Stop the network service
-          this.stop();
-        }
-      }
-    }
-  }
-
-  /**
-   * Get default peers, from environment
-   */
-  protected async getDefaultPeers(): Promise<Peer[]> {
-    const peers = (this.environment.defaultPeers || []).map(Peer.fromObject);
-    return Promise.resolve(peers);
-  }
-
-  protected showToast<T = any>(opts: ShowToastOptions): Promise<OverlayEventDetail<T>> {
-    return Toasts.show(this.toastController, this.translate, opts);
-  }
-
-  protected addListener<T= any>(name: NetworkEventType, callback: (data?: T) => Promise<void>): Subscription {
-    this._listeners[name] = this._listeners[name] || [];
-    this._listeners[name].push(callback);
-
-    // When unsubscribe, remove from the listener
-    return new Subscription(() => {
-      const index = this._listeners[name].indexOf(callback);
-      if (index !== -1) {
-        this._listeners[name].splice(index, 1);
-      }
-    });
-  }
-
-  protected async emit<T= any>(name: NetworkEventType, data?: T) {
-    const hooks = this._listeners[name];
-    if (isNotEmptyArray(hooks)) {
-      console.info(`[network-service] Trigger ${name} hook: Executing ${hooks.length} callbacks...`);
-
-      return Promise.all(hooks.map(callback => {
-        const promise = callback(data);
-        if (!promise) return;
-        return promise.catch(err => console.error('Error while executing hook ' + name, err));
-      }));
-    }
-  }
-}