@iotize/ionic
Version:
Iotize specific building blocks on top of @ionic/angular.
140 lines • 17 kB
JavaScript
import { Injectable } from '@angular/core';
import { filter, first } from 'rxjs/operators';
import { UniqKeyQueue } from './uniq-key-queue';
import { toTapInfoKeyEquals, toTapInfoKeyObject } from './utility';
import { TapInfoCacheService } from './tap-info-cache.service';
import * as i0 from "@angular/core";
import * as i1 from "./tap-info-cache.service";
export class TapInfoRequestService {
tapInfoCacheService;
/**
* Tap info keys to load queue
*/
queue = new UniqKeyQueue(toTapInfoKeyEquals);
requestedTapInfoKeysChange = this.queue.queueChange;
constructor(tapInfoCacheService) {
this.tapInfoCacheService = tapInfoCacheService;
}
removeKeys(keys) {
this.queue.remove(...keys);
}
getValue(key) {
return this.getInfoValue(key);
}
getValues(values) {
this.loadKeysIfNotInCache(values);
return Promise.all(values.map((key) => this.tapInfoCacheService.value(key)));
}
reset() {
this.queue.reset();
}
getLoadedKeyInfoChange(info) {
this.loadKeyIfNotInCache(info);
return this.tapInfoCacheService.infoChange(info).pipe(filter((info) => {
return info.error !== undefined || info.value !== undefined;
}));
}
/**
* Refresh all keys
*/
async refreshKeys(keysToRefresh) {
return this._refreshKeys(keysToRefresh, true);
}
async _refreshKeys(keysToRefresh, clearCache) {
// Append to refresh keys list. If we show dialog before nfc tap is done, it will
// append keys to the refresh list
if (clearCache) {
const keys = keysToRefresh.map((key) => toTapInfoKeyObject(key));
this.tapInfoCacheService.clearKeys(keys);
this.queue.add(...keys);
}
else {
this.loadKeysIfNotInCache(keysToRefresh);
}
return await this.waitForKeySync(keysToRefresh);
}
/**
* Refresh a single key
* Resolve when refresh has been done (with error or success)
*/
async refreshKey(keyOrString) {
let key = toTapInfoKeyObject(keyOrString);
const nextValue = this.tapInfoCacheService
.infoChange(key)
.pipe(filter((v) => !!v.loadDate), first())
.toPromise();
this.queue.add(key);
return await nextValue;
}
/**
* @warning do not call this method inside executeTapAction or it will hang forever...
* @param allKeys
* @returns
*/
async refreshKeysIfNeeded(allKeys) {
return this._refreshKeys(allKeys, false);
}
/**
* Load key only if it's not already loaded
* @param key key to load
* @returns the info value
*/
async loadKeyIfNotInCache(key) {
const snapshot = this.tapInfoCacheService.getInfoSnapshot(key);
if (!snapshot?.loadDate) {
return this.refreshKey(key);
}
return snapshot;
}
/**
* Load key only if it's not already loaded
* @param key keys to load
*/
loadKeysIfNotInCache(infos) {
const notInCacheKeys = infos.map(toTapInfoKeyObject).filter((key) => {
return !this.tapInfoCacheService.isValueLoaded(key);
});
this.queue.add(...notInCacheKeys);
}
/**
* Load key info
* If key has not been loaded for the device yet, it will to loaded it
* @param key
* @param params
* @returns
*/
loadKeyInfoChange(key) {
key = toTapInfoKeyObject(key);
const obs = this.tapInfoCacheService.infoChange(key);
this.loadKeyIfNotInCache(key);
return obs;
}
/**
*
* @param info: TapInfo
*/
async getInfoValue(info) {
await this.loadKeyIfNotInCache(info);
return this.tapInfoCacheService.value(info);
}
async waitForKeySync(keysToWait) {
if (keysToWait.length === 0) {
return;
}
await this.queue.queueChange
.pipe(filter((currentKeysToRefresh) => {
const remainingKeyToSync = currentKeysToRefresh.find((currentKey) => keysToWait.find((key) => toTapInfoKeyEquals(currentKey, toTapInfoKeyObject(key))));
return !remainingKeyToSync;
}), first())
.toPromise();
}
/** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TapInfoRequestService, deps: [{ token: i1.TapInfoCacheService }], target: i0.ɵɵFactoryTarget.Injectable });
/** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TapInfoRequestService, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TapInfoRequestService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
}]
}], ctorParameters: () => [{ type: i1.TapInfoCacheService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tap-info-request.service.js","sourceRoot":"","sources":["../../../../../../projects/iotize-ionic/src/lib/tap-info/tap-info-request.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ProgressState } from '@iotize/common/progress/api';\nimport { Observable } from 'rxjs';\nimport { filter, first } from 'rxjs/operators';\nimport {\n  TapInfoHolder,\n  TapInfoKey,\n  TapInfoKeyObjectOrString,\n} from './definitions';\nimport { UniqKeyQueue } from './uniq-key-queue';\nimport { toTapInfoKeyEquals, toTapInfoKeyObject } from './utility';\n\nimport { TapInfoCacheService } from './tap-info-cache.service';\n\nexport type RefreshKeysProgressState = ProgressState & {};\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TapInfoRequestService {\n  /**\n   * Tap info keys to load queue\n   */\n  private readonly queue = new UniqKeyQueue<TapInfoKey>(toTapInfoKeyEquals);\n\n  readonly requestedTapInfoKeysChange = this.queue.queueChange;\n\n  constructor(private tapInfoCacheService: TapInfoCacheService) {}\n\n  removeKeys(keys: TapInfoKey[]) {\n    this.queue.remove(...keys);\n  }\n\n  getValue<T = string>(key: TapInfoKeyObjectOrString) {\n    return this.getInfoValue<T>(key);\n  }\n\n  getValues<T extends any[] = unknown[]>(\n    values: TapInfoKeyObjectOrString[]\n  ): Promise<T> {\n    this.loadKeysIfNotInCache(values);\n    return Promise.all(\n      values.map((key) => this.tapInfoCacheService.value(key))\n    ) as Promise<T>;\n  }\n\n  reset() {\n    this.queue.reset();\n  }\n\n  getLoadedKeyInfoChange<T>(\n    info: TapInfoKeyObjectOrString\n  ): Observable<TapInfoHolder<T>> {\n    this.loadKeyIfNotInCache(info);\n    return this.tapInfoCacheService.infoChange<T>(info).pipe(\n      filter((info) => {\n        return info.error !== undefined || info.value !== undefined;\n      })\n    );\n  }\n\n  /**\n   * Refresh all keys\n   */\n  async refreshKeys(keysToRefresh: TapInfoKeyObjectOrString[]) {\n    return this._refreshKeys(keysToRefresh, true);\n  }\n\n  private async _refreshKeys(\n    keysToRefresh: TapInfoKeyObjectOrString[],\n    clearCache: boolean\n  ) {\n    // Append to refresh keys list. If we show dialog before nfc tap is done, it will\n    // append keys to the refresh list\n    if (clearCache) {\n      const keys = keysToRefresh.map((key) => toTapInfoKeyObject(key));\n      this.tapInfoCacheService.clearKeys(keys);\n      this.queue.add(...keys);\n    } else {\n      this.loadKeysIfNotInCache(keysToRefresh);\n    }\n    return await this.waitForKeySync(keysToRefresh);\n  }\n  /**\n   * Refresh a single key\n   * Resolve when refresh has been done (with error or success)\n   */\n  async refreshKey<T>(\n    keyOrString: TapInfoKeyObjectOrString\n  ): Promise<TapInfoHolder<T>> {\n    let key = toTapInfoKeyObject(keyOrString);\n    const nextValue = this.tapInfoCacheService\n      .infoChange<T>(key)\n      .pipe(\n        filter((v) => !!v.loadDate),\n        first()\n      )\n      .toPromise() as Promise<TapInfoHolder<T>>;\n    this.queue.add(key);\n    return await nextValue;\n  }\n\n  /**\n   * @warning do not call this method inside executeTapAction or it will hang forever...\n   * @param allKeys\n   * @returns\n   */\n  async refreshKeysIfNeeded(allKeys: TapInfoKeyObjectOrString[]) {\n    return this._refreshKeys(allKeys, false);\n  }\n\n  /**\n   * Load key only if it's not already loaded\n   * @param key key to load\n   * @returns the info value\n   */\n  async loadKeyIfNotInCache<T>(\n    key: TapInfoKeyObjectOrString\n  ): Promise<TapInfoHolder<T>> {\n    const snapshot = this.tapInfoCacheService.getInfoSnapshot<T>(key);\n    if (!snapshot?.loadDate) {\n      return this.refreshKey<T>(key);\n    }\n    return snapshot;\n  }\n\n  /**\n   * Load key only if it's not already loaded\n   * @param key keys to load\n   */\n  loadKeysIfNotInCache(infos: TapInfoKeyObjectOrString[]) {\n    const notInCacheKeys = infos.map(toTapInfoKeyObject).filter((key) => {\n      return !this.tapInfoCacheService.isValueLoaded(key);\n    });\n    this.queue.add(...notInCacheKeys);\n  }\n\n  /**\n   * Load key info\n   * If key has not been loaded for the device yet, it will to loaded it\n   * @param key\n   * @param params\n   * @returns\n   */\n  loadKeyInfoChange<T>(\n    key: TapInfoKeyObjectOrString\n  ): Observable<TapInfoHolder<T>> {\n    key = toTapInfoKeyObject(key);\n    const obs = this.tapInfoCacheService.infoChange<T>(key);\n    this.loadKeyIfNotInCache(key);\n    return obs;\n  }\n\n  /**\n   *\n   * @param info: TapInfo\n   */\n  async getInfoValue<T = string>(info: TapInfoKeyObjectOrString): Promise<T> {\n    await this.loadKeyIfNotInCache<T>(info);\n    return this.tapInfoCacheService.value(info);\n  }\n\n  async waitForKeySync(keysToWait: TapInfoKeyObjectOrString[]) {\n    if (keysToWait.length === 0) {\n      return;\n    }\n    await this.queue.queueChange\n      .pipe(\n        filter((currentKeysToRefresh) => {\n          const remainingKeyToSync = currentKeysToRefresh.find((currentKey) =>\n            keysToWait.find((key) =>\n              toTapInfoKeyEquals(currentKey, toTapInfoKeyObject(key))\n            )\n          );\n          return !remainingKeyToSync;\n        }),\n        first()\n      )\n      .toPromise();\n  }\n}\n"]}