@colijnit/transaction 12.1.174 → 12.1.176

package/esm2015/lib/cache/service/transaction-business-object-cache-manager.service.js

@@ -0,0 +1,157 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { CacheField } from '../cache-field';
+import { ParameterCacheField } from '../parameter-cache-field';
+import { ObjectUtils } from '@colijnit/ioneconnector/build/utils/object-utils';
+import * as i0 from "@angular/core";
+/**
+ * App-wide, top-level, 'dumb' BO cache manager service. It stores and returns simple and parameterized business object cache items.
+ *
+ * Several other services register cache items onto this manager, such as repositories or the more generic SelectMultipleSimpleCacheService.
+ *
+ * This is a dumb cache manager. It just functions as a point to add and retrieve generic cache items, but does not know how to actually
+ * LOAD these cache items from the database, or what exact types the items are.
+ *
+ * All caches are reset when the user logs out.
+ */
+export class TransactionBusinessObjectCacheManagerService {
+    constructor() {
+        // emits after this BO cache manager has been reset (e.g. after user logs out)
+        this.reset = new Subject();
+        // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items
+        this._selectMultipleCache = new Map();
+        // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items
+        this._selectMultipleParameterizedCache = new Map();
+        this._selectSingleCache = new Map();
+        this._selectSingleParameterizedCache = new Map();
+    }
+    // private _logoutSub: Subscription;
+    // constructor(private _transactionService: TransactionService) {
+    //   this._logoutSub = this._transactionService.logout.subscribe(() => {
+    //     this._reset();
+    //   });
+    // }
+    ngOnDestroy() {
+        // this._logoutSub.unsubscribe();
+    }
+    /**
+     * Creates and adds a new simple cache item for the given key with the given load function.
+     * @param key
+     * @param loadFunction e.g. () => { return this._dataService.selectMultiple(Color); }
+     * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.
+     * @returns The newly created cache item.
+     */
+    addNewSelectMultipleCacheItem(key, loadFunction, overrideOld = false) {
+        if (!overrideOld && this._selectMultipleCache.has(key)) {
+            return;
+        }
+        const newCacheItem = new CacheField();
+        newCacheItem.loadFunction = loadFunction;
+        this._selectMultipleCache.set(key, newCacheItem);
+        return newCacheItem;
+    }
+    addNewSelectSingleCacheItem(key, id = TransactionBusinessObjectCacheManagerService._NullBoId, loadFunction, overrideOld = false) {
+        const cacheId = id.toString();
+        if (!overrideOld && this.hasSingleCacheItem(key, id)) {
+            return;
+        }
+        if (!this._selectSingleCache.has(key)) {
+            this._selectSingleCache.set(key, {});
+        }
+        const newCacheItem = new CacheField();
+        newCacheItem.loadFunction = loadFunction;
+        this._selectSingleCache.get(key)[cacheId] = newCacheItem;
+        return newCacheItem;
+    }
+    addNewSelectSingleParameterizedCacheItem(key, loadFunction, overrideOld = false) {
+        if (!overrideOld && this._selectSingleParameterizedCache.has(key)) {
+            return;
+        }
+        const newCacheItem = new ParameterCacheField();
+        newCacheItem.loadFunction = loadFunction;
+        this._selectSingleParameterizedCache.set(key, newCacheItem);
+        return newCacheItem;
+    }
+    /**
+     * Creates and adds a new parameterized cache item for the given key with the given load function.
+     * @param key
+     * @param loadFunction e.g. (category: ArticleCategory) => { return this._dataService.selectMultiple(TurnoverGroupImage, category); }
+     * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.
+     */
+    addNewSelectMultipleParameterizedCacheItem(key, loadFunction, overrideOld = false) {
+        if (!overrideOld && this._selectMultipleParameterizedCache.has(key)) {
+            return;
+        }
+        const newCacheItem = new ParameterCacheField();
+        newCacheItem.loadFunction = loadFunction;
+        this._selectMultipleParameterizedCache.set(key, newCacheItem);
+        return newCacheItem;
+    }
+    hasSelectMultipleCacheItem(key) {
+        return this._selectMultipleCache.has(key);
+    }
+    hasSingleCacheItem(key, id = TransactionBusinessObjectCacheManagerService._NullBoId) {
+        const cacheId = id.toString();
+        return this._selectSingleCache.has(key) && !!this._selectSingleCache.get(key)[cacheId];
+    }
+    hasSelectMultipleParameterizedCacheItem(key) {
+        return this._selectMultipleParameterizedCache.has(key);
+    }
+    hasSelectSingleParameterizedCacheItem(key) {
+        return this._selectSingleParameterizedCache.has(key);
+    }
+    // Returns the simple cache item with the given key. T is the type of the cache value items requested, e.g. Color.
+    getSelectMultipleCacheItem(key) {
+        return this._selectMultipleCache.get(key);
+    }
+    getSingleCacheItem(key, id = TransactionBusinessObjectCacheManagerService._NullBoId) {
+        const cacheId = id.toString();
+        return this._selectSingleCache.has(key) && this._selectSingleCache.get(key)[cacheId];
+    }
+    deleteSingleCacheItem(key, id = TransactionBusinessObjectCacheManagerService._NullBoId) {
+        const cacheId = id.toString();
+        if (this._selectSingleCache.has(key)) {
+            this._selectSingleCache.delete(key);
+        }
+    }
+    // Returns the parameterized cache item with the given key. T is the type of the cache value items requested, e.g. Color.
+    getSelectMultipleParameterCacheItem(key) {
+        return this._selectMultipleParameterizedCache.get(key);
+    }
+    getSelectSingleParameterCacheItem(key) {
+        return this._selectSingleParameterizedCache.get(key);
+    }
+    _reset() {
+        this._selectMultipleCache.forEach((cacheItem) => {
+            if (cacheItem) {
+                cacheItem.reset();
+            }
+        });
+        this._selectSingleCache.forEach((cache) => {
+            if (cache) {
+                ObjectUtils.ForOwnProperty(cache, (cacheField) => {
+                    cacheField.reset();
+                });
+            }
+        });
+        this._selectSingleParameterizedCache.forEach((selSinParamCacheItem) => {
+            if (selSinParamCacheItem) {
+                selSinParamCacheItem.reset();
+            }
+        });
+        this._selectMultipleParameterizedCache.forEach((selMulParamCacheItem) => {
+            if (selMulParamCacheItem) {
+                selMulParamCacheItem.reset();
+            }
+        });
+        this.reset.next();
+    }
+}
+TransactionBusinessObjectCacheManagerService._NullBoId = -1;
+TransactionBusinessObjectCacheManagerService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TransactionBusinessObjectCacheManagerService_Factory() { return new TransactionBusinessObjectCacheManagerService(); }, token: TransactionBusinessObjectCacheManagerService, providedIn: "root" });
+TransactionBusinessObjectCacheManagerService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction-business-object-cache-manager.service.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/cache/service/transaction-business-object-cache-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Subject, Subscription} from 'rxjs';\r\nimport {CacheField} from '../cache-field';\r\nimport {ParameterCacheField} from '../parameter-cache-field';\r\nimport {BusinessObject} from '@colijnit/ioneconnector/build/model/business-object';\r\nimport {ObjectUtils} from '@colijnit/ioneconnector/build/utils/object-utils';\r\nimport {BusinessObjectIDType} from '@colijnit/ioneconnector/build/type/business-object-id-type';\r\n\r\n/**\r\n * App-wide, top-level, 'dumb' BO cache manager service. It stores and returns simple and parameterized business object cache items.\r\n *\r\n * Several other services register cache items onto this manager, such as repositories or the more generic SelectMultipleSimpleCacheService.\r\n *\r\n * This is a dumb cache manager. It just functions as a point to add and retrieve generic cache items, but does not know how to actually\r\n * LOAD these cache items from the database, or what exact types the items are.\r\n *\r\n * All caches are reset when the user logs out.\r\n */\r\n@Injectable({\r\n    providedIn: \"root\"\r\n  }\r\n)\r\nexport class TransactionBusinessObjectCacheManagerService implements OnDestroy {\r\n  // emits after this BO cache manager has been reset (e.g. after user logs out)\r\n  public readonly reset: Subject<void> = new Subject<void>();\r\n\r\n  private static _NullBoId: number = -1;\r\n\r\n  // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items\r\n  private _selectMultipleCache: Map<any, CacheField<BusinessObject[]>> = new Map();\r\n\r\n  // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items\r\n  private _selectMultipleParameterizedCache: Map<any, ParameterCacheField<BusinessObject[]>>\r\n    = new Map<any, ParameterCacheField<BusinessObject[]>>();\r\n\r\n  private _selectSingleCache: Map<{ new(): BusinessObject }, { [id: string]: CacheField<BusinessObject> }> = new Map();\r\n  private _selectSingleParameterizedCache: Map<any, ParameterCacheField<Object>>\r\n    = new Map<any, ParameterCacheField<Object>>();\r\n\r\n  // private _logoutSub: Subscription;\r\n\r\n  // constructor(private _transactionService: TransactionService) {\r\n  //   this._logoutSub = this._transactionService.logout.subscribe(() => {\r\n  //     this._reset();\r\n  //   });\r\n  // }\r\n\r\n  ngOnDestroy(): void {\r\n    // this._logoutSub.unsubscribe();\r\n  }\r\n\r\n  /**\r\n   * Creates and adds a new simple cache item for the given key with the given load function.\r\n   * @param key\r\n   * @param loadFunction e.g. () => { return this._dataService.selectMultiple(Color); }\r\n   * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.\r\n   * @returns The newly created cache item.\r\n   */\r\n  public addNewSelectMultipleCacheItem<T extends BusinessObject>(\r\n    key: any,\r\n    loadFunction: () => Promise<T[]>,\r\n    overrideOld: boolean = false\r\n  ): CacheField<T[]> {\r\n    if (!overrideOld && this._selectMultipleCache.has(key)) {\r\n      return;\r\n    }\r\n\r\n    const newCacheItem: CacheField<T[]> = new CacheField<T[]>();\r\n    newCacheItem.loadFunction = loadFunction;\r\n    this._selectMultipleCache.set(key, newCacheItem);\r\n    return newCacheItem;\r\n  }\r\n\r\n  public addNewSelectSingleCacheItem<T extends BusinessObject>(\r\n    key: { new(): T },\r\n    id: BusinessObjectIDType = TransactionBusinessObjectCacheManagerService._NullBoId,\r\n    loadFunction: () => Promise<T>,\r\n    overrideOld: boolean = false\r\n  ): CacheField<T> {\r\n    const cacheId: string = id.toString();\r\n    if (!overrideOld && this.hasSingleCacheItem(key, id)) {\r\n      return;\r\n    }\r\n    if (!this._selectSingleCache.has(key)) {\r\n      this._selectSingleCache.set(key, {});\r\n    }\r\n    const newCacheItem: CacheField<T> = new CacheField<T>();\r\n    newCacheItem.loadFunction = loadFunction;\r\n    this._selectSingleCache.get(key)[cacheId] = newCacheItem;\r\n    return newCacheItem;\r\n  }\r\n\r\n  public addNewSelectSingleParameterizedCacheItem<T extends Object>(\r\n    key: any,\r\n    loadFunction: (params?: any) => Promise<T>,\r\n    overrideOld: boolean = false\r\n  ): ParameterCacheField<T> {\r\n    if (!overrideOld && this._selectSingleParameterizedCache.has(key)) {\r\n      return;\r\n    }\r\n\r\n    const newCacheItem: ParameterCacheField<T> = new ParameterCacheField<T>();\r\n    newCacheItem.loadFunction = loadFunction;\r\n    this._selectSingleParameterizedCache.set(key, newCacheItem);\r\n    return newCacheItem;\r\n  }\r\n\r\n  /**\r\n   * Creates and adds a new parameterized cache item for the given key with the given load function.\r\n   * @param key\r\n   * @param loadFunction e.g. (category: ArticleCategory) => { return this._dataService.selectMultiple(TurnoverGroupImage, category); }\r\n   * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.\r\n   */\r\n  public addNewSelectMultipleParameterizedCacheItem<T extends BusinessObject>(\r\n    key: any,\r\n    loadFunction: (params?: any) => Promise<T[]>,\r\n    overrideOld: boolean = false\r\n  ): ParameterCacheField<T[]> {\r\n    if (!overrideOld && this._selectMultipleParameterizedCache.has(key)) {\r\n      return;\r\n    }\r\n\r\n    const newCacheItem: ParameterCacheField<T[]> = new ParameterCacheField<T[]>();\r\n    newCacheItem.loadFunction = loadFunction;\r\n    this._selectMultipleParameterizedCache.set(key, newCacheItem);\r\n    return newCacheItem;\r\n  }\r\n\r\n  public hasSelectMultipleCacheItem(key: any): boolean {\r\n    return this._selectMultipleCache.has(key);\r\n  }\r\n\r\n  public hasSingleCacheItem<T extends BusinessObject>(key: { new(): T }, id: BusinessObjectIDType = TransactionBusinessObjectCacheManagerService._NullBoId): boolean {\r\n    const cacheId: string = id.toString();\r\n    return this._selectSingleCache.has(key) && !!this._selectSingleCache.get(key)[cacheId];\r\n  }\r\n\r\n  public hasSelectMultipleParameterizedCacheItem(key: any): boolean {\r\n    return this._selectMultipleParameterizedCache.has(key);\r\n  }\r\n\r\n  public hasSelectSingleParameterizedCacheItem(key: any): boolean {\r\n    return this._selectSingleParameterizedCache.has(key);\r\n  }\r\n\r\n  // Returns the simple cache item with the given key. T is the type of the cache value items requested, e.g. Color.\r\n  public getSelectMultipleCacheItem<T extends BusinessObject>(key: any): CacheField<T[]> {\r\n    return <CacheField<T[]>>this._selectMultipleCache.get(key);\r\n  }\r\n\r\n  public getSingleCacheItem<T extends BusinessObject>(key: { new(): T }, id: BusinessObjectIDType = TransactionBusinessObjectCacheManagerService._NullBoId): CacheField<T> {\r\n    const cacheId: string = id.toString();\r\n    return this._selectSingleCache.has(key) && this._selectSingleCache.get(key)[cacheId] as CacheField<T>;\r\n  }\r\n\r\n  public deleteSingleCacheItem<T extends BusinessObject>(key: { new(): T }, id: BusinessObjectIDType = TransactionBusinessObjectCacheManagerService._NullBoId): void {\r\n    const cacheId: string = id.toString();\r\n    if (this._selectSingleCache.has(key)) {\r\n      this._selectSingleCache.delete(key);\r\n    }\r\n  }\r\n\r\n  // Returns the parameterized cache item with the given key. T is the type of the cache value items requested, e.g. Color.\r\n  public getSelectMultipleParameterCacheItem<T extends BusinessObject>(key: any): ParameterCacheField<T[]> {\r\n    return <ParameterCacheField<T[]>>this._selectMultipleParameterizedCache.get(key);\r\n  }\r\n\r\n  public getSelectSingleParameterCacheItem<T>(key: any): ParameterCacheField<T> {\r\n    return <ParameterCacheField<T>>this._selectSingleParameterizedCache.get(key);\r\n  }\r\n\r\n  private _reset(): void {\r\n    this._selectMultipleCache.forEach((cacheItem: CacheField<BusinessObject[]>) => {\r\n      if (cacheItem) {\r\n        cacheItem.reset();\r\n      }\r\n    });\r\n\r\n    this._selectSingleCache.forEach((cache: { [p: string]: CacheField<BusinessObject> }) => {\r\n      if (cache) {\r\n        ObjectUtils.ForOwnProperty(cache, (cacheField: CacheField<BusinessObject>) => {\r\n          cacheField.reset();\r\n        });\r\n      }\r\n    });\r\n\r\n    this._selectSingleParameterizedCache.forEach((selSinParamCacheItem: ParameterCacheField<BusinessObject>) => {\r\n      if (selSinParamCacheItem) {\r\n        selSinParamCacheItem.reset();\r\n      }\r\n    });\r\n\r\n    this._selectMultipleParameterizedCache.forEach((selMulParamCacheItem: ParameterCacheField<BusinessObject[]>) => {\r\n      if (selMulParamCacheItem) {\r\n        selMulParamCacheItem.reset();\r\n      }\r\n    });\r\n\r\n    this.reset.next();\r\n  }\r\n}\r\n"]}

package/esm2015/lib/cache/service/transaction-select-multiple-cache.service.js

@@ -0,0 +1,38 @@
+import { Injectable } from "@angular/core";
+import { TransactionBusinessObjectCacheManagerService } from "./transaction-business-object-cache-manager.service";
+import { CacheField } from "../cache-field";
+import * as i0 from "@angular/core";
+import * as i1 from "./transaction-business-object-cache-manager.service";
+export class TransactionSelectMultipleCacheService {
+    constructor(_boCacheManager) {
+        this._boCacheManager = _boCacheManager;
+    }
+    /**
+     * Returns the global cache item for the select multiple of the given business object class. Creates a new cache item if not yet exists.
+     * @param clazz The BO class, e.g. CustomerFullObject
+     * @returns {CacheField<T[]>}
+     */
+    requestCache(clazz, loadFunction) {
+        if (!this._boCacheManager.hasSelectMultipleCacheItem(clazz)) {
+            this._createCacheItem(clazz, loadFunction);
+        }
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.getSelectMultipleCacheItem(clazz);
+    }
+    // Creates and returns a new select multiple cache item into the global business object cache manager for given business object class.
+    _createCacheItem(clazz, loadFunction) {
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.addNewSelectMultipleCacheItem(clazz, loadFunction);
+    }
+}
+TransactionSelectMultipleCacheService._NullCache = new CacheField();
+TransactionSelectMultipleCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TransactionSelectMultipleCacheService_Factory() { return new TransactionSelectMultipleCacheService(i0.ɵɵinject(i1.TransactionBusinessObjectCacheManagerService)); }, token: TransactionSelectMultipleCacheService, providedIn: "root" });
+TransactionSelectMultipleCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+TransactionSelectMultipleCacheService.ctorParameters = () => [
+    { type: TransactionBusinessObjectCacheManagerService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/cache/service/transaction-select-multiple-parameterized-cache.service.js

@@ -0,0 +1,47 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { TransactionBusinessObjectCacheManagerService } from "./transaction-business-object-cache-manager.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./transaction-business-object-cache-manager.service";
+// service resonsible for filling the global BO cache manager service with parameterized select multiple cache items
+export class TransactionSelectMultipleParameterizedCacheService {
+    constructor(_boCacheManager) {
+        this._boCacheManager = _boCacheManager;
+        // emits after this select multiple parameterized cache service has been reset (e.g. after user logs out)
+        this.reset = new Subject();
+        this._subs = [];
+        this._subs.push(this._boCacheManager.reset.subscribe(() => {
+            this.reset.next();
+        }));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(sub => sub.unsubscribe());
+    }
+    /**
+     * Returns the global cache item for the parameterized select multiple of the given business object class. Creates a new cache item if not yet exists.
+     * @param clazz The BO class, used for undeflying dataService.selectMultiple(clazz) call.
+     * @returns {CacheField<T[]>}
+     */
+    requestCache(clazz, loadFunction) {
+        if (!this._boCacheManager.hasSelectMultipleParameterizedCacheItem(clazz)) {
+            this._createParameterizedCacheItem(clazz, loadFunction);
+        }
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.getSelectMultipleParameterCacheItem(clazz);
+    }
+    // Creates and returns a new  parameterized select multiple cache item into the global business object cache manager for given business object class.
+    _createParameterizedCacheItem(clazz, loadFunction) {
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.addNewSelectMultipleParameterizedCacheItem(clazz, loadFunction);
+    }
+}
+TransactionSelectMultipleParameterizedCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TransactionSelectMultipleParameterizedCacheService_Factory() { return new TransactionSelectMultipleParameterizedCacheService(i0.ɵɵinject(i1.TransactionBusinessObjectCacheManagerService)); }, token: TransactionSelectMultipleParameterizedCacheService, providedIn: "root" });
+TransactionSelectMultipleParameterizedCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+TransactionSelectMultipleParameterizedCacheService.ctorParameters = () => [
+    { type: TransactionBusinessObjectCacheManagerService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/cache/service/transaction-select-single-cache.service.js

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { TransactionBusinessObjectCacheManagerService } from './transaction-business-object-cache-manager.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./transaction-business-object-cache-manager.service";
+export class TransactionSelectSingleCacheService {
+    constructor(_boCacheManager) {
+        this._boCacheManager = _boCacheManager;
+    }
+    requestCache(clazz, sourceId, loadFunction, reload = false) {
+        if (reload) {
+            this._boCacheManager.deleteSingleCacheItem(clazz, sourceId);
+        }
+        if (!this._boCacheManager.hasSingleCacheItem(clazz, sourceId)) {
+            this._createCacheItem(clazz, sourceId, loadFunction);
+        }
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.getSingleCacheItem(clazz, sourceId);
+    }
+    _createCacheItem(clazz, sourceId, loadFunction) {
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.addNewSelectSingleCacheItem(clazz, sourceId, loadFunction);
+    }
+}
+TransactionSelectSingleCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TransactionSelectSingleCacheService_Factory() { return new TransactionSelectSingleCacheService(i0.ɵɵinject(i1.TransactionBusinessObjectCacheManagerService)); }, token: TransactionSelectSingleCacheService, providedIn: "root" });
+TransactionSelectSingleCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+TransactionSelectSingleCacheService.ctorParameters = () => [
+    { type: TransactionBusinessObjectCacheManagerService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/cache/service/transaction-select-single-parameterized-cache.service.js

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { TransactionBusinessObjectCacheManagerService } from './transaction-business-object-cache-manager.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./transaction-business-object-cache-manager.service";
+// service resonsible for filling the global BO cache manager service with parameterized select single cache items
+export class TransactionSelectSingleParameterizedCacheService {
+    constructor(_boCacheManager) {
+        this._boCacheManager = _boCacheManager;
+        // emits after this select single parameterized cache service has been reset (e.g. after user logs out)
+        this.reset = new Subject();
+        this._subs = [];
+        this._subs.push(this._boCacheManager.reset.subscribe(() => {
+            this.reset.next();
+        }));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(sub => sub.unsubscribe());
+    }
+    /**
+     * Returns the global cache item for the parameterized select single of the given business object class. Creates a new cache item if not yet exists.
+     * @param clazz The BO class, used for undeflying dataService.selectSingle(clazz) call.
+     * @returns {CacheField<T>}
+     */
+    requestCache(clazz, loadFunction) {
+        if (!this._boCacheManager.hasSelectSingleParameterizedCacheItem(clazz)) {
+            this._createParameterizedCacheItem(clazz, loadFunction);
+        }
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.getSelectSingleParameterCacheItem(clazz);
+    }
+    // Creates and returns a new  parameterized select single cache item into the global business object cache manager for given business object class.
+    _createParameterizedCacheItem(clazz, loadFunction) {
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.addNewSelectSingleParameterizedCacheItem(clazz, loadFunction);
+    }
+}
+TransactionSelectSingleParameterizedCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TransactionSelectSingleParameterizedCacheService_Factory() { return new TransactionSelectSingleParameterizedCacheService(i0.ɵɵinject(i1.TransactionBusinessObjectCacheManagerService)); }, token: TransactionSelectSingleParameterizedCacheService, providedIn: "root" });
+TransactionSelectSingleParameterizedCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+TransactionSelectSingleParameterizedCacheService.ctorParameters = () => [
+    { type: TransactionBusinessObjectCacheManagerService }
+];
+//# sourceMappingURL=data:application/json;base64,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