@colijnit/transaction 12.1.153 → 12.1.154

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

@@ -107,6 +107,12 @@ export class BusinessObjectCacheManagerService {
         const cacheId = id.toString();
         return this._selectSingleCache.has(key) && this._selectSingleCache.get(key)[cacheId];
     }
+    deleteSingleCacheItem(key, id = BusinessObjectCacheManagerService._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);
@@ -147,4 +153,4 @@ BusinessObjectCacheManagerService.decorators = [
                 providedIn: "root"
             },] }
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"business-object-cache-manager.service.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/cache/service/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 BusinessObjectCacheManagerService 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 = BusinessObjectCacheManagerService._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 = BusinessObjectCacheManagerService._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 = BusinessObjectCacheManagerService._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  // 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"business-object-cache-manager.service.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/cache/service/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 BusinessObjectCacheManagerService 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 = BusinessObjectCacheManagerService._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 = BusinessObjectCacheManagerService._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 = BusinessObjectCacheManagerService._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 = BusinessObjectCacheManagerService._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/select-single-cache.service.js

@@ -1,12 +1,15 @@
-import { Injectable } from "@angular/core";
-import { BusinessObjectCacheManagerService } from "./business-object-cache-manager.service";
+import { Injectable } from '@angular/core';
+import { BusinessObjectCacheManagerService } from './business-object-cache-manager.service';
 import * as i0 from "@angular/core";
 import * as i1 from "./business-object-cache-manager.service";
 export class SelectSingleCacheService {
     constructor(_boCacheManager) {
         this._boCacheManager = _boCacheManager;
     }
-    requestCache(clazz, sourceId, loadFunction) {
+    requestCache(clazz, sourceId, loadFunction, reload = false) {
+        if (reload) {
+            this._boCacheManager.deleteSingleCacheItem(clazz, sourceId);
+        }
         if (!this._boCacheManager.hasSingleCacheItem(clazz, sourceId)) {
             this._createCacheItem(clazz, sourceId, loadFunction);
         }
@@ -27,4 +30,4 @@ SelectSingleCacheService.decorators = [
 SelectSingleCacheService.ctorParameters = () => [
     { type: BusinessObjectCacheManagerService }
 ];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LXNpbmdsZS1jYWNoZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHJhbnNhY3Rpb24vc3JjL2xpYi9jYWNoZS9zZXJ2aWNlL3NlbGVjdC1zaW5nbGUtY2FjaGUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBQyxpQ0FBaUMsRUFBQyxNQUFNLHlDQUF5QyxDQUFDOzs7QUFRMUYsTUFBTSxPQUFPLHdCQUF3QjtJQUVuQyxZQUFvQixlQUFrRDtRQUFsRCxvQkFBZSxHQUFmLGVBQWUsQ0FBbUM7SUFDdEUsQ0FBQztJQUVNLFlBQVksQ0FBMkIsS0FBbUIsRUFBRSxRQUE4QixFQUFFLFlBQThCO1FBQy9ILElBQUksQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLGtCQUFrQixDQUFJLEtBQUssRUFBRSxRQUFRLENBQUMsRUFBRTtZQUNoRSxJQUFJLENBQUMsZ0JBQWdCLENBQUksS0FBSyxFQUFFLFFBQVEsRUFBRSxZQUFZLENBQUMsQ0FBQztTQUN6RDtRQUVELHVDQUF1QztRQUN2QyxPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsa0JBQWtCLENBQUksS0FBSyxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ3JFLENBQUM7SUFFTyxnQkFBZ0IsQ0FBMkIsS0FBbUIsRUFBRSxRQUE4QixFQUFFLFlBQThCO1FBQ3BJLHVDQUF1QztRQUN2QyxPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsMkJBQTJCLENBQUksS0FBSyxFQUFFLFFBQVEsRUFBRSxZQUFZLENBQUMsQ0FBQztJQUM1RixDQUFDOzs7O1lBcEJGLFVBQVUsU0FBQztnQkFDVixVQUFVLEVBQUUsTUFBTTthQUNuQjs7O1lBUE8saUNBQWlDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge0J1c2luZXNzT2JqZWN0Q2FjaGVNYW5hZ2VyU2VydmljZX0gZnJvbSBcIi4vYnVzaW5lc3Mtb2JqZWN0LWNhY2hlLW1hbmFnZXIuc2VydmljZVwiO1xyXG5pbXBvcnQge0J1c2luZXNzT2JqZWN0fSBmcm9tIFwiQGNvbGlqbml0L2lvbmVjb25uZWN0b3IvYnVpbGQvbW9kZWwvYnVzaW5lc3Mtb2JqZWN0XCI7XHJcbmltcG9ydCB7Q2FjaGVGaWVsZH0gZnJvbSBcIi4uL2NhY2hlLWZpZWxkXCI7XHJcbmltcG9ydCB7QnVzaW5lc3NPYmplY3RJRFR5cGV9IGZyb20gXCJAY29saWpuaXQvaW9uZWNvbm5lY3Rvci9idWlsZC90eXBlL2J1c2luZXNzLW9iamVjdC1pZC10eXBlXCI7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogXCJyb290XCJcclxufSlcclxuZXhwb3J0IGNsYXNzIFNlbGVjdFNpbmdsZUNhY2hlU2VydmljZSB7XHJcblxyXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgX2JvQ2FjaGVNYW5hZ2VyOiBCdXNpbmVzc09iamVjdENhY2hlTWFuYWdlclNlcnZpY2UpIHtcclxuICB9XHJcblxyXG4gIHB1YmxpYyByZXF1ZXN0Q2FjaGU8VCBleHRlbmRzIEJ1c2luZXNzT2JqZWN0PihjbGF6ejogeyBuZXcoKTogVCB9LCBzb3VyY2VJZDogQnVzaW5lc3NPYmplY3RJRFR5cGUsIGxvYWRGdW5jdGlvbjogKCkgPT4gUHJvbWlzZTxUPik6IENhY2hlRmllbGQ8VD4ge1xyXG4gICAgaWYgKCF0aGlzLl9ib0NhY2hlTWFuYWdlci5oYXNTaW5nbGVDYWNoZUl0ZW08VD4oY2xhenosIHNvdXJjZUlkKSkge1xyXG4gICAgICB0aGlzLl9jcmVhdGVDYWNoZUl0ZW08VD4oY2xhenosIHNvdXJjZUlkLCBsb2FkRnVuY3Rpb24pO1xyXG4gICAgfVxyXG5cclxuICAgIC8vIG5vaW5zcGVjdGlvbiBUeXBlU2NyaXB0VmFsaWRhdGVUeXBlc1xyXG4gICAgcmV0dXJuIHRoaXMuX2JvQ2FjaGVNYW5hZ2VyLmdldFNpbmdsZUNhY2hlSXRlbTxUPihjbGF6eiwgc291cmNlSWQpO1xyXG4gIH1cclxuXHJcbiAgcHJpdmF0ZSBfY3JlYXRlQ2FjaGVJdGVtPFQgZXh0ZW5kcyBCdXNpbmVzc09iamVjdD4oY2xheno6IHsgbmV3KCk6IFQgfSwgc291cmNlSWQ6IEJ1c2luZXNzT2JqZWN0SURUeXBlLCBsb2FkRnVuY3Rpb246ICgpID0+IFByb21pc2U8VD4pOiBDYWNoZUZpZWxkPFQ+IHtcclxuICAgIC8vIG5vaW5zcGVjdGlvbiBUeXBlU2NyaXB0VmFsaWRhdGVUeXBlc1xyXG4gICAgcmV0dXJuIHRoaXMuX2JvQ2FjaGVNYW5hZ2VyLmFkZE5ld1NlbGVjdFNpbmdsZUNhY2hlSXRlbTxUPihjbGF6eiwgc291cmNlSWQsIGxvYWRGdW5jdGlvbik7XHJcbiAgfVxyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LXNpbmdsZS1jYWNoZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHJhbnNhY3Rpb24vc3JjL2xpYi9jYWNoZS9zZXJ2aWNlL3NlbGVjdC1zaW5nbGUtY2FjaGUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBQyxpQ0FBaUMsRUFBQyxNQUFNLHlDQUF5QyxDQUFDOzs7QUFRMUYsTUFBTSxPQUFPLHdCQUF3QjtJQUVuQyxZQUFvQixlQUFrRDtRQUFsRCxvQkFBZSxHQUFmLGVBQWUsQ0FBbUM7SUFDdEUsQ0FBQztJQUVNLFlBQVksQ0FBMkIsS0FBbUIsRUFBRSxRQUE4QixFQUFFLFlBQThCLEVBQUUsU0FBa0IsS0FBSztRQUN4SixJQUFJLE1BQU0sRUFBRTtZQUNWLElBQUksQ0FBQyxlQUFlLENBQUMscUJBQXFCLENBQUksS0FBSyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1NBQ2hFO1FBQ0QsSUFBSSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsa0JBQWtCLENBQUksS0FBSyxFQUFFLFFBQVEsQ0FBQyxFQUFFO1lBQ2hFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBSSxLQUFLLEVBQUUsUUFBUSxFQUFFLFlBQVksQ0FBQyxDQUFDO1NBQ3pEO1FBRUQsdUNBQXVDO1FBQ3ZDLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxrQkFBa0IsQ0FBSSxLQUFLLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDckUsQ0FBQztJQUVPLGdCQUFnQixDQUEyQixLQUFtQixFQUFFLFFBQThCLEVBQUUsWUFBOEI7UUFDcEksdUNBQXVDO1FBQ3ZDLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQywyQkFBMkIsQ0FBSSxLQUFLLEVBQUUsUUFBUSxFQUFFLFlBQVksQ0FBQyxDQUFDO0lBQzVGLENBQUM7Ozs7WUF2QkYsVUFBVSxTQUFDO2dCQUNWLFVBQVUsRUFBRSxNQUFNO2FBQ25COzs7WUFQTyxpQ0FBaUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGFibGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQge0J1c2luZXNzT2JqZWN0Q2FjaGVNYW5hZ2VyU2VydmljZX0gZnJvbSAnLi9idXNpbmVzcy1vYmplY3QtY2FjaGUtbWFuYWdlci5zZXJ2aWNlJztcclxuaW1wb3J0IHtCdXNpbmVzc09iamVjdH0gZnJvbSAnQGNvbGlqbml0L2lvbmVjb25uZWN0b3IvYnVpbGQvbW9kZWwvYnVzaW5lc3Mtb2JqZWN0JztcclxuaW1wb3J0IHtDYWNoZUZpZWxkfSBmcm9tICcuLi9jYWNoZS1maWVsZCc7XHJcbmltcG9ydCB7QnVzaW5lc3NPYmplY3RJRFR5cGV9IGZyb20gJ0Bjb2xpam5pdC9pb25lY29ubmVjdG9yL2J1aWxkL3R5cGUvYnVzaW5lc3Mtb2JqZWN0LWlkLXR5cGUnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46IFwicm9vdFwiXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBTZWxlY3RTaW5nbGVDYWNoZVNlcnZpY2Uge1xyXG5cclxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIF9ib0NhY2hlTWFuYWdlcjogQnVzaW5lc3NPYmplY3RDYWNoZU1hbmFnZXJTZXJ2aWNlKSB7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgcmVxdWVzdENhY2hlPFQgZXh0ZW5kcyBCdXNpbmVzc09iamVjdD4oY2xheno6IHsgbmV3KCk6IFQgfSwgc291cmNlSWQ6IEJ1c2luZXNzT2JqZWN0SURUeXBlLCBsb2FkRnVuY3Rpb246ICgpID0+IFByb21pc2U8VD4sIHJlbG9hZDogYm9vbGVhbiA9IGZhbHNlKTogQ2FjaGVGaWVsZDxUPiB7XHJcbiAgICBpZiAocmVsb2FkKSB7XHJcbiAgICAgIHRoaXMuX2JvQ2FjaGVNYW5hZ2VyLmRlbGV0ZVNpbmdsZUNhY2hlSXRlbTxUPihjbGF6eiwgc291cmNlSWQpO1xyXG4gICAgfVxyXG4gICAgaWYgKCF0aGlzLl9ib0NhY2hlTWFuYWdlci5oYXNTaW5nbGVDYWNoZUl0ZW08VD4oY2xhenosIHNvdXJjZUlkKSkge1xyXG4gICAgICB0aGlzLl9jcmVhdGVDYWNoZUl0ZW08VD4oY2xhenosIHNvdXJjZUlkLCBsb2FkRnVuY3Rpb24pO1xyXG4gICAgfVxyXG5cclxuICAgIC8vIG5vaW5zcGVjdGlvbiBUeXBlU2NyaXB0VmFsaWRhdGVUeXBlc1xyXG4gICAgcmV0dXJuIHRoaXMuX2JvQ2FjaGVNYW5hZ2VyLmdldFNpbmdsZUNhY2hlSXRlbTxUPihjbGF6eiwgc291cmNlSWQpO1xyXG4gIH1cclxuXHJcbiAgcHJpdmF0ZSBfY3JlYXRlQ2FjaGVJdGVtPFQgZXh0ZW5kcyBCdXNpbmVzc09iamVjdD4oY2xheno6IHsgbmV3KCk6IFQgfSwgc291cmNlSWQ6IEJ1c2luZXNzT2JqZWN0SURUeXBlLCBsb2FkRnVuY3Rpb246ICgpID0+IFByb21pc2U8VD4pOiBDYWNoZUZpZWxkPFQ+IHtcclxuICAgIC8vIG5vaW5zcGVjdGlvbiBUeXBlU2NyaXB0VmFsaWRhdGVUeXBlc1xyXG4gICAgcmV0dXJuIHRoaXMuX2JvQ2FjaGVNYW5hZ2VyLmFkZE5ld1NlbGVjdFNpbmdsZUNhY2hlSXRlbTxUPihjbGF6eiwgc291cmNlSWQsIGxvYWRGdW5jdGlvbik7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2015/lib/component/checkout/checkout.component.js

@@ -54,6 +54,9 @@ export class CheckoutComponent {
         this.service.transactionKind = this.transactionType;
         this.relationType = this.service.getRelationKindFromTransactionKind();
         this.service.createNewRelation();
+        if (this.relationNr) {
+            this.service.setRelationOnTransaction(this.relationNr, this.relationType);
+        }
     }
     ngOnDestroy() {
         this._subs.forEach(s => s.unsubscribe());
@@ -216,6 +219,7 @@ CheckoutComponent.propDecorators = {
     checkoutDelivery: [{ type: ViewChild, args: ["checkoutDelivery",] }],
     checkoutPayment: [{ type: ViewChild, args: ["checkoutPayment",] }],
     newTransaction: [{ type: Input }],
+    relationNr: [{ type: Input }],
     sellerId: [{ type: Input }],
     transactionType: [{ type: Input }],
     showCreateTransactionButton: [{ type: Input }],
@@ -223,4 +227,4 @@ CheckoutComponent.propDecorators = {
     editCartClick: [{ type: Output }],
     showClass: [{ type: HostBinding, args: ["class.co-checkout",] }]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout.component.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/component/checkout/checkout.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnDestroy, OnInit, Output, ViewChild, ViewEncapsulation} from '@angular/core';\r\nimport {TransactionService} from '../../service/transaction.service';\r\nimport {DictionaryService} from '../../service/dictionary.service';\r\nimport {TransactionInfoResponse} from '@colijnit/transactionapi/build/model/transaction-info-response.bo';\r\nimport {CheckoutOverviewRelationEditComponent} from './checkout-overview-relation-edit/checkout-overview-relation-edit.component';\r\nimport {CheckoutOverviewDeliveryEditComponent} from './checkout-overview-delivery-edit/checkout-overview-delivery-edit.component';\r\nimport {StepperStepComponent} from '../stepper/component/stepper-step.component';\r\nimport {DialogService} from '../../service/dialog.service';\r\nimport {PaymentComponent} from '../payment/payment.component';\r\nimport {StepperComponent} from '../stepper/stepper.component';\r\nimport {TransactionKind} from '@colijnit/transactionapi/build/enum/transaction-kind.enum';\r\nimport {RelationKind} from '@colijnit/relationapi/build/enum/relation-kind.enum';\r\nimport {RelationService} from '../../service/relation.service';\r\nimport {CheckoutScreenConfigurationService} from './service/checkout-screen-configuration.service';\r\nimport {Subscription} from 'rxjs';\r\nimport {BaseModuleScreenConfigService, BaseModuleService} from '@colijnit/corecomponents_v12';\r\nimport {CheckoutModuleService} from './service/checkout-module.service';\r\nimport {CheckoutCfgName} from '../../enum/checkout-cfg-name.enum';\r\n\r\n@Component({\r\n  selector: \"co-checkout\",\r\n  template: `\r\n    <ng-container *ngIf=\"configLoaded\">\r\n      <co-stepper #stepper\r\n                  [title]=\"service.titleForCheckout\"\r\n                  [showStepper]=\"transactionType !== transKind.PurchaseOrder\"\r\n                  [titleIcon]=\"service.iconForCheckout\"\r\n                  [finishButtonLabel]=\"'CHECKOUT_FINISH' | localize\"\r\n                  (createClicked)=\"handleCreateTransaction($event)\"\r\n      >\r\n        <co-stepper-step #stepRelation [index]=\"1\" [label]=\"'YOUR_DATA' | localize\" (validateStep)=\"handleRelationValidation()\" *ngIf=\"showYourData\">\r\n          <co-checkout-overview-relation-edit #checkoutRelation *ngIf=\"stepRelation.show\"\r\n                                              [(relation)]=\"service.relation\"\r\n                                              [relationKind]=\"relationType\"\r\n                                              [deliveryAddressNawNr]=\"deliveryAddressNawNr\"\r\n                                              [invoiceAddressNawNr]=\"invoiceAddressNawNr\"\r\n                                              (deliveryAddressChange)=\"handleDeliveryAddressChange($event)\"\r\n                                              (invoiceAddressChange)=\"handleInvoiceAddressChange($event)\"\r\n                                              (relationChange)=\"service.relation = $event\"\r\n          ></co-checkout-overview-relation-edit>\r\n        </co-stepper-step>\r\n        <co-stepper-step #stepDelivery [index]=\"2\" [label]=\"'DELIVERY' | localize\" (validateStep)=\"handleDeliveryValidation()\" *ngIf=\"showDelivery\">\r\n          <co-checkout-overview-delivery-edit #checkoutDelivery *ngIf=\"stepDelivery.show\"\r\n                                              [transaction]=\"service.currentTransaction\"\r\n          ></co-checkout-overview-delivery-edit>\r\n        </co-stepper-step>\r\n        <co-stepper-step #stepOverview [index]=\"3\" [label]=\"service.paymentStepTitleForCheckout | localize\" *ngIf=\"showOverview\">\r\n          <co-checkout-overview-payment *ngIf=\"stepOverview.show\"\r\n                                        [relation]=\"service.relation\"\r\n                                        [transaction]=\"service.currentTransaction\"\r\n                                        [showPayment]=\"transactionType === transKind.SalesOrder\"\r\n                                        (changeYourDataClick)=\"stepper.goto(0)\"\r\n                                        (changeDeliveryClick)=\"stepper.goto(1)\"\r\n                                        (payed)=\"handleTransactionFinished($event)\"\r\n          ></co-checkout-overview-payment>\r\n        </co-stepper-step>\r\n        <div class=\"co-checkout-right-panel\">\r\n          <div class=\"co-checkout-right-panel-relation\">\r\n            <co-avatar [relationId]=\"sellerId\"></co-avatar>\r\n          </div>\r\n          <co-shopping-cart-preview *ngIf=\"!showCreateTransactionButton\" \r\n                                    [showCheckoutButton]=\"false\" \r\n                                    [withoutBorder]=\"true\"\r\n                                    (editCartClick)=\"editCartClick.emit($event)\"\r\n          ></co-shopping-cart-preview>\r\n        </div>\r\n      </co-stepper>\r\n    </ng-container>\r\n  `,\r\n  providers: [\r\n    {provide: BaseModuleService, useExisting: CheckoutModuleService},\r\n    {provide: BaseModuleScreenConfigService, useExisting: CheckoutScreenConfigurationService},\r\n  ],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class CheckoutComponent implements OnInit, OnDestroy {\r\n  public readonly transKind: typeof TransactionKind = TransactionKind;\r\n  public readonly cfgNames: typeof CheckoutCfgName = CheckoutCfgName;\r\n\r\n  @ViewChild(\"stepper\")\r\n  public stepper: StepperComponent;\r\n\r\n  @ViewChild(\"stepRelation\")\r\n  public stepRelation: StepperStepComponent;\r\n\r\n  @ViewChild(\"stepDelivery\")\r\n  public stepDelivery: StepperStepComponent;\r\n\r\n  @ViewChild(\"stepOverview\")\r\n  public stepOverview: StepperStepComponent;\r\n\r\n  @ViewChild(\"stepPay\")\r\n  public stepPay: StepperStepComponent;\r\n\r\n  @ViewChild(\"checkoutRelation\")\r\n  public checkoutRelation: CheckoutOverviewRelationEditComponent;\r\n\r\n  @ViewChild(\"checkoutDelivery\")\r\n  public checkoutDelivery: CheckoutOverviewDeliveryEditComponent;\r\n\r\n  @ViewChild(\"checkoutPayment\")\r\n  public checkoutPayment: PaymentComponent;\r\n\r\n  @Input()\r\n  public newTransaction: boolean = false;\r\n\r\n  @Input()\r\n  public sellerId: number;\r\n\r\n  @Input()\r\n  public transactionType: TransactionKind = TransactionKind.SalesOrder;\r\n\r\n  @Input()\r\n  public showCreateTransactionButton: boolean = false;\r\n\r\n  @Output()\r\n  public transactionFinished: EventEmitter<{id: number, fromCheckout: boolean}> = new EventEmitter<{id: number, fromCheckout: boolean}>();\r\n\r\n  @Output()\r\n  public editCartClick: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @HostBinding(\"class.co-checkout\")\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  public get userIsApplicationUser(): boolean {\r\n    // TODO: return this.userService.isApplicationUser;\r\n    return true;\r\n  }\r\n\r\n  public transaction: TransactionInfoResponse;\r\n  public deliveryAddressNawNr: number = 0;\r\n  public invoiceAddressNawNr: number = 0;\r\n  public relationType: RelationKind;\r\n  public configLoaded: boolean = false;\r\n  public showYourData: boolean = false;\r\n  public showDelivery: boolean = false;\r\n  public showOverview: boolean = false;\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(\r\n    public service: TransactionService,\r\n    private _relationService: RelationService,\r\n    private _dictionary: DictionaryService,\r\n    private _dialogService: DialogService,\r\n    private _screenConfigurationService: CheckoutScreenConfigurationService\r\n  ) {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this._screenConfigurationService.loadConfig([this.transactionType]);\r\n    this._subs.push(\r\n        this._screenConfigurationService.configSet.subscribe((configObjects: string[]) => {\r\n          if (configObjects && configObjects.length > 0) {\r\n            this.showYourData = this._screenConfigurationService.getObjectConfigurationFor(this.cfgNames.YourDataHeader).immediatelyVisible();\r\n            this.showDelivery = this._screenConfigurationService.getObjectConfigurationFor(this.cfgNames.DeliveryHeader).immediatelyVisible();\r\n            this.showOverview = this._screenConfigurationService.getObjectConfigurationFor(this.cfgNames.OverviewAndPaymentHeader).immediatelyVisible();\r\n            this.configLoaded = true;\r\n          }\r\n        })\r\n    )\r\n    if (this.newTransaction) {\r\n      this.service.resetCurrentTransaction();\r\n    }\r\n    this.service.transactionKind = this.transactionType;\r\n    this.relationType = this.service.getRelationKindFromTransactionKind();\r\n    this.service.createNewRelation();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    if (this._relationService.relationLocked) {\r\n      this.service.rollback();\r\n    }\r\n  }\r\n\r\n  public async handleCreateTransaction(event: MouseEvent): Promise<void> {\r\n    let success: boolean = true;\r\n    if (this.stepper.activeStep === 0 && await this.handleRelationValidation()) {\r\n      success = await this.service.saveRelation();\r\n      if (success && this.transactionType !== this.transKind.SalesQuotation) {\r\n        await this.service.updateHeaderTransactionDefinitive(this.service.currentTransaction.transactionInfo.uuid, true, true);\r\n      }\r\n    }\r\n    if (!success) {\r\n      return;\r\n    }\r\n    const saveSuccess: boolean = await this.service.saveTransactionAndCommit();\r\n    if (saveSuccess) {\r\n      this.handleTransactionFinished(this.service.currentTransaction.transactionInfo.transactionNr);\r\n    }\r\n  }\r\n\r\n  public async handleRelationValidation(): Promise<boolean> {\r\n    if (this.checkoutRelation && this.stepRelation) {\r\n      const valid = this.checkoutRelation.submit();\r\n      if (valid) {\r\n        this.stepRelation.completed = await this.saveRelation();\r\n      }\r\n      return valid;\r\n    }\r\n  }\r\n\r\n  public async handleDeliveryValidation(): Promise<boolean> {\r\n    if (this.checkoutDelivery && this.stepDelivery) {\r\n      const valid = this.checkoutDelivery.submit();\r\n      if (valid) {\r\n        const saveSuccess: boolean = await this.service.saveTransactionAndCommit();\r\n        if (saveSuccess) {\r\n          const lockSuccess: boolean =\r\n              await this.service.tryToLockTransaction(this.service.currentTransaction.transactionInfo.id, this.service.currentTransaction.transactionInfo.version);\r\n          if (lockSuccess) {\r\n            this.stepDelivery.completed = await this.handleSaveDelivery();\r\n          }\r\n        }\r\n      }\r\n      return valid;\r\n    }\r\n  }\r\n\r\n  public async saveRelation(): Promise<boolean> {\r\n    const success: boolean = await this.service.saveRelation();\r\n    if (success) {\r\n      if (this.deliveryAddressNawNr === null || this.deliveryAddressNawNr === undefined || this.deliveryAddressNawNr === 0 && this.service.relation.addresses && this.service.relation.addresses.length === 1) {\r\n        this.deliveryAddressNawNr = this.service.relation.addresses[0].nawNr;\r\n      }\r\n      if (this.service.currentTransaction.transactionInfo.transactionAddress !== this.deliveryAddressNawNr) {\r\n        await this.service.updateHeaderDeliveryAddress(this.service.currentTransaction.transactionInfo.uuid, this.deliveryAddressNawNr);\r\n      }\r\n      const invoiceAddressNawNr: number = this.invoiceAddressNawNr ? this.invoiceAddressNawNr : this.deliveryAddressNawNr;\r\n      if (this.service.currentTransaction.transactionInfo.invoiceAddress !== invoiceAddressNawNr) {\r\n        await this.service.updateHeaderInvoiceAddress(this.service.currentTransaction.transactionInfo.uuid, invoiceAddressNawNr);\r\n      }\r\n    }\r\n    return success;\r\n  }\r\n\r\n  public async handleSaveDelivery(): Promise<boolean> {\r\n    return true;\r\n  }\r\n\r\n  public handleDeliveryAddressChange(nawNr: number): void {\r\n    this.deliveryAddressNawNr = nawNr;\r\n  }\r\n\r\n  public handleInvoiceAddressChange(nawNr: number): void {\r\n    this.invoiceAddressNawNr = nawNr;\r\n  }\r\n\r\n  public handleTransactionFinished(id: number): void {\r\n    this.service.resetCurrentTransaction();\r\n    this.transactionFinished.emit({id: id, fromCheckout: this.showCreateTransactionButton});\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout.component.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/component/checkout/checkout.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnDestroy, OnInit, Output, ViewChild, ViewEncapsulation} from '@angular/core';\r\nimport {TransactionService} from '../../service/transaction.service';\r\nimport {DictionaryService} from '../../service/dictionary.service';\r\nimport {TransactionInfoResponse} from '@colijnit/transactionapi/build/model/transaction-info-response.bo';\r\nimport {CheckoutOverviewRelationEditComponent} from './checkout-overview-relation-edit/checkout-overview-relation-edit.component';\r\nimport {CheckoutOverviewDeliveryEditComponent} from './checkout-overview-delivery-edit/checkout-overview-delivery-edit.component';\r\nimport {StepperStepComponent} from '../stepper/component/stepper-step.component';\r\nimport {DialogService} from '../../service/dialog.service';\r\nimport {PaymentComponent} from '../payment/payment.component';\r\nimport {StepperComponent} from '../stepper/stepper.component';\r\nimport {TransactionKind} from '@colijnit/transactionapi/build/enum/transaction-kind.enum';\r\nimport {RelationKind} from '@colijnit/relationapi/build/enum/relation-kind.enum';\r\nimport {RelationService} from '../../service/relation.service';\r\nimport {CheckoutScreenConfigurationService} from './service/checkout-screen-configuration.service';\r\nimport {Subscription} from 'rxjs';\r\nimport {BaseModuleScreenConfigService, BaseModuleService} from '@colijnit/corecomponents_v12';\r\nimport {CheckoutModuleService} from './service/checkout-module.service';\r\nimport {CheckoutCfgName} from '../../enum/checkout-cfg-name.enum';\r\n\r\n@Component({\r\n  selector: \"co-checkout\",\r\n  template: `\r\n    <ng-container *ngIf=\"configLoaded\">\r\n      <co-stepper #stepper\r\n                  [title]=\"service.titleForCheckout\"\r\n                  [showStepper]=\"transactionType !== transKind.PurchaseOrder\"\r\n                  [titleIcon]=\"service.iconForCheckout\"\r\n                  [finishButtonLabel]=\"'CHECKOUT_FINISH' | localize\"\r\n                  (createClicked)=\"handleCreateTransaction($event)\"\r\n      >\r\n        <co-stepper-step #stepRelation [index]=\"1\" [label]=\"'YOUR_DATA' | localize\" (validateStep)=\"handleRelationValidation()\" *ngIf=\"showYourData\">\r\n          <co-checkout-overview-relation-edit #checkoutRelation *ngIf=\"stepRelation.show\"\r\n                                              [(relation)]=\"service.relation\"\r\n                                              [relationKind]=\"relationType\"\r\n                                              [deliveryAddressNawNr]=\"deliveryAddressNawNr\"\r\n                                              [invoiceAddressNawNr]=\"invoiceAddressNawNr\"\r\n                                              (deliveryAddressChange)=\"handleDeliveryAddressChange($event)\"\r\n                                              (invoiceAddressChange)=\"handleInvoiceAddressChange($event)\"\r\n                                              (relationChange)=\"service.relation = $event\"\r\n          ></co-checkout-overview-relation-edit>\r\n        </co-stepper-step>\r\n        <co-stepper-step #stepDelivery [index]=\"2\" [label]=\"'DELIVERY' | localize\" (validateStep)=\"handleDeliveryValidation()\" *ngIf=\"showDelivery\">\r\n          <co-checkout-overview-delivery-edit #checkoutDelivery *ngIf=\"stepDelivery.show\"\r\n                                              [transaction]=\"service.currentTransaction\"\r\n          ></co-checkout-overview-delivery-edit>\r\n        </co-stepper-step>\r\n        <co-stepper-step #stepOverview [index]=\"3\" [label]=\"service.paymentStepTitleForCheckout | localize\" *ngIf=\"showOverview\">\r\n          <co-checkout-overview-payment *ngIf=\"stepOverview.show\"\r\n                                        [relation]=\"service.relation\"\r\n                                        [transaction]=\"service.currentTransaction\"\r\n                                        [showPayment]=\"transactionType === transKind.SalesOrder\"\r\n                                        (changeYourDataClick)=\"stepper.goto(0)\"\r\n                                        (changeDeliveryClick)=\"stepper.goto(1)\"\r\n                                        (payed)=\"handleTransactionFinished($event)\"\r\n          ></co-checkout-overview-payment>\r\n        </co-stepper-step>\r\n        <div class=\"co-checkout-right-panel\">\r\n          <div class=\"co-checkout-right-panel-relation\">\r\n            <co-avatar [relationId]=\"sellerId\"></co-avatar>\r\n          </div>\r\n          <co-shopping-cart-preview *ngIf=\"!showCreateTransactionButton\" \r\n                                    [showCheckoutButton]=\"false\" \r\n                                    [withoutBorder]=\"true\"\r\n                                    (editCartClick)=\"editCartClick.emit($event)\"\r\n          ></co-shopping-cart-preview>\r\n        </div>\r\n      </co-stepper>\r\n    </ng-container>\r\n  `,\r\n  providers: [\r\n    {provide: BaseModuleService, useExisting: CheckoutModuleService},\r\n    {provide: BaseModuleScreenConfigService, useExisting: CheckoutScreenConfigurationService},\r\n  ],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class CheckoutComponent implements OnInit, OnDestroy {\r\n  public readonly transKind: typeof TransactionKind = TransactionKind;\r\n  public readonly cfgNames: typeof CheckoutCfgName = CheckoutCfgName;\r\n\r\n  @ViewChild(\"stepper\")\r\n  public stepper: StepperComponent;\r\n\r\n  @ViewChild(\"stepRelation\")\r\n  public stepRelation: StepperStepComponent;\r\n\r\n  @ViewChild(\"stepDelivery\")\r\n  public stepDelivery: StepperStepComponent;\r\n\r\n  @ViewChild(\"stepOverview\")\r\n  public stepOverview: StepperStepComponent;\r\n\r\n  @ViewChild(\"stepPay\")\r\n  public stepPay: StepperStepComponent;\r\n\r\n  @ViewChild(\"checkoutRelation\")\r\n  public checkoutRelation: CheckoutOverviewRelationEditComponent;\r\n\r\n  @ViewChild(\"checkoutDelivery\")\r\n  public checkoutDelivery: CheckoutOverviewDeliveryEditComponent;\r\n\r\n  @ViewChild(\"checkoutPayment\")\r\n  public checkoutPayment: PaymentComponent;\r\n\r\n  @Input()\r\n  public newTransaction: boolean = false;\r\n\r\n  /**\r\n   * When set, this is the relation be used for the checkout\r\n   */\r\n  @Input()\r\n  public relationNr: number;\r\n\r\n  @Input()\r\n  public sellerId: number;\r\n\r\n  @Input()\r\n  public transactionType: TransactionKind = TransactionKind.SalesOrder;\r\n\r\n  @Input()\r\n  public showCreateTransactionButton: boolean = false;\r\n\r\n  @Output()\r\n  public transactionFinished: EventEmitter<{id: number, fromCheckout: boolean}> = new EventEmitter<{id: number, fromCheckout: boolean}>();\r\n\r\n  @Output()\r\n  public editCartClick: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @HostBinding(\"class.co-checkout\")\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  public get userIsApplicationUser(): boolean {\r\n    // TODO: return this.userService.isApplicationUser;\r\n    return true;\r\n  }\r\n\r\n  public transaction: TransactionInfoResponse;\r\n  public deliveryAddressNawNr: number = 0;\r\n  public invoiceAddressNawNr: number = 0;\r\n  public relationType: RelationKind;\r\n  public configLoaded: boolean = false;\r\n  public showYourData: boolean = false;\r\n  public showDelivery: boolean = false;\r\n  public showOverview: boolean = false;\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(\r\n    public service: TransactionService,\r\n    private _relationService: RelationService,\r\n    private _dictionary: DictionaryService,\r\n    private _dialogService: DialogService,\r\n    private _screenConfigurationService: CheckoutScreenConfigurationService\r\n  ) {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this._screenConfigurationService.loadConfig([this.transactionType]);\r\n    this._subs.push(\r\n        this._screenConfigurationService.configSet.subscribe((configObjects: string[]) => {\r\n          if (configObjects && configObjects.length > 0) {\r\n            this.showYourData = this._screenConfigurationService.getObjectConfigurationFor(this.cfgNames.YourDataHeader).immediatelyVisible();\r\n            this.showDelivery = this._screenConfigurationService.getObjectConfigurationFor(this.cfgNames.DeliveryHeader).immediatelyVisible();\r\n            this.showOverview = this._screenConfigurationService.getObjectConfigurationFor(this.cfgNames.OverviewAndPaymentHeader).immediatelyVisible();\r\n            this.configLoaded = true;\r\n          }\r\n        })\r\n    )\r\n    if (this.newTransaction) {\r\n      this.service.resetCurrentTransaction();\r\n    }\r\n    this.service.transactionKind = this.transactionType;\r\n    this.relationType = this.service.getRelationKindFromTransactionKind();\r\n    this.service.createNewRelation();\r\n    if (this.relationNr) {\r\n      this.service.setRelationOnTransaction(this.relationNr, this.relationType);\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    if (this._relationService.relationLocked) {\r\n      this.service.rollback();\r\n    }\r\n  }\r\n\r\n  public async handleCreateTransaction(event: MouseEvent): Promise<void> {\r\n    let success: boolean = true;\r\n    if (this.stepper.activeStep === 0 && await this.handleRelationValidation()) {\r\n      success = await this.service.saveRelation();\r\n      if (success && this.transactionType !== this.transKind.SalesQuotation) {\r\n        await this.service.updateHeaderTransactionDefinitive(this.service.currentTransaction.transactionInfo.uuid, true, true);\r\n      }\r\n    }\r\n    if (!success) {\r\n      return;\r\n    }\r\n    const saveSuccess: boolean = await this.service.saveTransactionAndCommit();\r\n    if (saveSuccess) {\r\n      this.handleTransactionFinished(this.service.currentTransaction.transactionInfo.transactionNr);\r\n    }\r\n  }\r\n\r\n  public async handleRelationValidation(): Promise<boolean> {\r\n    if (this.checkoutRelation && this.stepRelation) {\r\n      const valid = this.checkoutRelation.submit();\r\n      if (valid) {\r\n        this.stepRelation.completed = await this.saveRelation();\r\n      }\r\n      return valid;\r\n    }\r\n  }\r\n\r\n  public async handleDeliveryValidation(): Promise<boolean> {\r\n    if (this.checkoutDelivery && this.stepDelivery) {\r\n      const valid = this.checkoutDelivery.submit();\r\n      if (valid) {\r\n        const saveSuccess: boolean = await this.service.saveTransactionAndCommit();\r\n        if (saveSuccess) {\r\n          const lockSuccess: boolean =\r\n              await this.service.tryToLockTransaction(this.service.currentTransaction.transactionInfo.id, this.service.currentTransaction.transactionInfo.version);\r\n          if (lockSuccess) {\r\n            this.stepDelivery.completed = await this.handleSaveDelivery();\r\n          }\r\n        }\r\n      }\r\n      return valid;\r\n    }\r\n  }\r\n\r\n  public async saveRelation(): Promise<boolean> {\r\n    const success: boolean = await this.service.saveRelation();\r\n    if (success) {\r\n      if (this.deliveryAddressNawNr === null || this.deliveryAddressNawNr === undefined || this.deliveryAddressNawNr === 0 && this.service.relation.addresses && this.service.relation.addresses.length === 1) {\r\n        this.deliveryAddressNawNr = this.service.relation.addresses[0].nawNr;\r\n      }\r\n      if (this.service.currentTransaction.transactionInfo.transactionAddress !== this.deliveryAddressNawNr) {\r\n        await this.service.updateHeaderDeliveryAddress(this.service.currentTransaction.transactionInfo.uuid, this.deliveryAddressNawNr);\r\n      }\r\n      const invoiceAddressNawNr: number = this.invoiceAddressNawNr ? this.invoiceAddressNawNr : this.deliveryAddressNawNr;\r\n      if (this.service.currentTransaction.transactionInfo.invoiceAddress !== invoiceAddressNawNr) {\r\n        await this.service.updateHeaderInvoiceAddress(this.service.currentTransaction.transactionInfo.uuid, invoiceAddressNawNr);\r\n      }\r\n    }\r\n    return success;\r\n  }\r\n\r\n  public async handleSaveDelivery(): Promise<boolean> {\r\n    return true;\r\n  }\r\n\r\n  public handleDeliveryAddressChange(nawNr: number): void {\r\n    this.deliveryAddressNawNr = nawNr;\r\n  }\r\n\r\n  public handleInvoiceAddressChange(nawNr: number): void {\r\n    this.invoiceAddressNawNr = nawNr;\r\n  }\r\n\r\n  public handleTransactionFinished(id: number): void {\r\n    this.service.resetCurrentTransaction();\r\n    this.transactionFinished.emit({id: id, fromCheckout: this.showCreateTransactionButton});\r\n  }\r\n}\r\n"]}

package/esm2015/lib/component/deposit-payment/deposit-payment.component.js

@@ -61,9 +61,10 @@ DepositPaymentComponent.decorators = [
           [image]="payment.paymentMethod?.image"
           [description]="payment.paymentMethod?.payment.description"
         ></co-payment-tile>
-        <div class="deposit-payment-spacer"></div>
+        <div class="down-payment-date-wrapper">
+          <div class="down-payment-date" [textContent]="payment.depositPayment?.date | date:'d MMMM yyyy'"></div>
+        </div>
         <div class="down-payment-amount-wrapper">
-          <div class="down-payment-date" [textContent]="payment.depositPayment?.date | date:'d MMMM yyyy | HH:mm'"></div>
           <div class="down-payment-amount" [textContent]="payment.depositPayment?.depositPaymentAmount | coCurrency"></div>
         </div>
       </div>
@@ -83,4 +84,4 @@ DepositPaymentComponent.propDecorators = {
     transactionUuid: [{ type: Input }],
     showClass: [{ type: HostBinding, args: ["class.co-deposit-payment",] }]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deposit-payment.component.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/component/deposit-payment/deposit-payment.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, HostBinding, Input, OnDestroy, OnInit, ViewEncapsulation} from '@angular/core';\r\nimport {DepositPaymentViewModel} from '../../model/deposit-payment-view-model';\r\nimport {PaymentViewmodel} from '../../model/payment.viewmodel';\r\nimport {PaymentService} from '../../service/payment.service';\r\nimport {TransactionDepositPaymentInfo} from '@colijnit/transactionapi/build/model/transaction-deposit-payment-info.bo';\r\nimport {DepositPayment} from '@colijnit/transactionapi/build/model/deposit-payment.bo';\r\nimport {TransactionKind} from '@colijnit/transactionapi/build/enum/transaction-kind.enum';\r\nimport {Subscription} from 'rxjs';\r\nimport {TransactionEventService} from '../../service/transaction-event.service';\r\n\r\n@Component({\r\n  selector: \"co-deposit-payment\",\r\n  template: `\r\n    <div class=\"down-payment-payments-title\" [textContent]=\"'PAYMENTS_MADE' | localize\" *ngIf=\"showTitle\"></div>\r\n    <div class=\"down-payment-payments-wrapper\">\r\n      <co-loader class=\"loader\" *ngIf=\"showLoader\"></co-loader>\r\n      <div class=\"down-payment-payments\" *ngFor=\"let payment of depositPayments\">\r\n        <co-payment-tile\r\n          [image]=\"payment.paymentMethod?.image\"\r\n          [description]=\"payment.paymentMethod?.payment.description\"\r\n        ></co-payment-tile>\r\n        <div class=\"deposit-payment-spacer\"></div>\r\n        <div class=\"down-payment-amount-wrapper\">\r\n          <div class=\"down-payment-date\" [textContent]=\"payment.depositPayment?.date | date:'d MMMM yyyy | HH:mm'\"></div>\r\n          <div class=\"down-payment-amount\" [textContent]=\"payment.depositPayment?.depositPaymentAmount | coCurrency\"></div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class DepositPaymentComponent implements OnInit, OnDestroy {\r\n  public readonly transKind: typeof TransactionKind = TransactionKind;\r\n\r\n  @Input()\r\n  public branch: string;\r\n\r\n  @Input()\r\n  public transactionKind: TransactionKind;\r\n\r\n  @Input()\r\n  public showTitle: boolean = true;\r\n\r\n  @Input()\r\n  public transactionUuid: string;\r\n\r\n  @HostBinding(\"class.co-deposit-payment\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public paymentMethods: PaymentViewmodel[] = [];\r\n  public depositPayments: DepositPaymentViewModel[] = [];\r\n  public showLoader: boolean = true;\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(\r\n      private _paymentService: PaymentService,\r\n      private _transactionEventService: TransactionEventService\r\n  ) {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this._subs.push(\r\n        this._transactionEventService.transactionPaymentDone.subscribe(() => this._getDepositPaymentInfo())\r\n    )\r\n    this._prepareData();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  private _getDepositPaymentInfo(): void {\r\n    this.showLoader = true;\r\n    this._paymentService.getDepositPaymentInfo(this.transactionUuid).then((info: TransactionDepositPaymentInfo) => {\r\n      this.depositPayments.length = 0;\r\n      if (info && info.depositPayments) {\r\n        info.depositPayments.sort((a, b) => a.id > b.id ? 1 : -1);\r\n        info.depositPayments.forEach((dp: DepositPayment) => {\r\n          const paymentMethod: PaymentViewmodel = this.paymentMethods.find(pm => pm.payment.code === dp.paymentMethodCode);\r\n          this.depositPayments.push(new DepositPaymentViewModel(dp, paymentMethod));\r\n        });\r\n      }\r\n      this.showLoader = false;\r\n    });\r\n  }\r\n\r\n  private _prepareData(): void {\r\n    this.depositPayments.length = 0;\r\n    this.showLoader = true;\r\n    this.paymentMethods.length = 0;\r\n    this._paymentService.getPaymentMethodsViewModels(this.branch, this.transactionKind).then((methods: PaymentViewmodel[]) => {\r\n      this.paymentMethods = methods.slice();\r\n      this._getDepositPaymentInfo();\r\n      this.showLoader = false;\r\n    });\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deposit-payment.component.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/component/deposit-payment/deposit-payment.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, HostBinding, Input, OnDestroy, OnInit, ViewEncapsulation} from '@angular/core';\r\nimport {DepositPaymentViewModel} from '../../model/deposit-payment-view-model';\r\nimport {PaymentViewmodel} from '../../model/payment.viewmodel';\r\nimport {PaymentService} from '../../service/payment.service';\r\nimport {TransactionDepositPaymentInfo} from '@colijnit/transactionapi/build/model/transaction-deposit-payment-info.bo';\r\nimport {DepositPayment} from '@colijnit/transactionapi/build/model/deposit-payment.bo';\r\nimport {TransactionKind} from '@colijnit/transactionapi/build/enum/transaction-kind.enum';\r\nimport {Subscription} from 'rxjs';\r\nimport {TransactionEventService} from '../../service/transaction-event.service';\r\n\r\n@Component({\r\n  selector: \"co-deposit-payment\",\r\n  template: `\r\n    <div class=\"down-payment-payments-title\" [textContent]=\"'PAYMENTS_MADE' | localize\" *ngIf=\"showTitle\"></div>\r\n    <div class=\"down-payment-payments-wrapper\">\r\n      <co-loader class=\"loader\" *ngIf=\"showLoader\"></co-loader>\r\n      <div class=\"down-payment-payments\" *ngFor=\"let payment of depositPayments\">\r\n        <co-payment-tile\r\n          [image]=\"payment.paymentMethod?.image\"\r\n          [description]=\"payment.paymentMethod?.payment.description\"\r\n        ></co-payment-tile>\r\n        <div class=\"down-payment-date-wrapper\">\r\n          <div class=\"down-payment-date\" [textContent]=\"payment.depositPayment?.date | date:'d MMMM yyyy'\"></div>\r\n        </div>\r\n        <div class=\"down-payment-amount-wrapper\">\r\n          <div class=\"down-payment-amount\" [textContent]=\"payment.depositPayment?.depositPaymentAmount | coCurrency\"></div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class DepositPaymentComponent implements OnInit, OnDestroy {\r\n  public readonly transKind: typeof TransactionKind = TransactionKind;\r\n\r\n  @Input()\r\n  public branch: string;\r\n\r\n  @Input()\r\n  public transactionKind: TransactionKind;\r\n\r\n  @Input()\r\n  public showTitle: boolean = true;\r\n\r\n  @Input()\r\n  public transactionUuid: string;\r\n\r\n  @HostBinding(\"class.co-deposit-payment\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public paymentMethods: PaymentViewmodel[] = [];\r\n  public depositPayments: DepositPaymentViewModel[] = [];\r\n  public showLoader: boolean = true;\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(\r\n      private _paymentService: PaymentService,\r\n      private _transactionEventService: TransactionEventService\r\n  ) {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this._subs.push(\r\n        this._transactionEventService.transactionPaymentDone.subscribe(() => this._getDepositPaymentInfo())\r\n    )\r\n    this._prepareData();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  private _getDepositPaymentInfo(): void {\r\n    this.showLoader = true;\r\n    this._paymentService.getDepositPaymentInfo(this.transactionUuid).then((info: TransactionDepositPaymentInfo) => {\r\n      this.depositPayments.length = 0;\r\n      if (info && info.depositPayments) {\r\n        info.depositPayments.sort((a, b) => a.id > b.id ? 1 : -1);\r\n        info.depositPayments.forEach((dp: DepositPayment) => {\r\n          const paymentMethod: PaymentViewmodel = this.paymentMethods.find(pm => pm.payment.code === dp.paymentMethodCode);\r\n          this.depositPayments.push(new DepositPaymentViewModel(dp, paymentMethod));\r\n        });\r\n      }\r\n      this.showLoader = false;\r\n    });\r\n  }\r\n\r\n  private _prepareData(): void {\r\n    this.depositPayments.length = 0;\r\n    this.showLoader = true;\r\n    this.paymentMethods.length = 0;\r\n    this._paymentService.getPaymentMethodsViewModels(this.branch, this.transactionKind).then((methods: PaymentViewmodel[]) => {\r\n      this.paymentMethods = methods.slice();\r\n      this._getDepositPaymentInfo();\r\n      this.showLoader = false;\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2015/lib/component/payment/payment.component.js

@@ -7,12 +7,14 @@ import { SharedService } from '../../service/shared.service';
 import { IonePaymentStatusCode } from '@colijnit/transactionapi/build/enum/ione-payment-status-code.enum';
 import { TransactionEventService } from '../../service/transaction-event.service';
 import { DoPaymentRequest } from '@colijnit/transactionapi/build/model/do-payment-request';
+import { IconCacheService } from "../../service/icon-cache.service";
 export class PaymentComponent {
-    constructor(_transactionService, _sharedService, _paymentService, _transactionEventService) {
+    constructor(_transactionService, _sharedService, _paymentService, _transactionEventService, iconCacheService) {
         this._transactionService = _transactionService;
         this._sharedService = _sharedService;
         this._paymentService = _paymentService;
         this._transactionEventService = _transactionEventService;
+        this.iconCacheService = iconCacheService;
         this.icons = Icon;
         this.updateDepositAmount = true;
         this.payed = new EventEmitter();
@@ -25,6 +27,7 @@ export class PaymentComponent {
         this.showPspQrCode = false;
         this.showLoader = true;
         this.amountToPay = 0;
+        this.depositAmount = 0;
         this.statusMessage = "";
         this._amount = 0;
         this._paymentStatusPollIntervalMs = 5000;
@@ -119,6 +122,7 @@ export class PaymentComponent {
                 const info = yield this._paymentService.getDepositPaymentInfo(this.transactionUuid);
                 if (info) {
                     this.amountToPay = info.depositRemainderAmount;
+                    this.depositAmount = info.depositAmount;
                 }
             }
             else {
@@ -228,47 +232,59 @@ PaymentComponent.decorators = [
                 selector: "co-payment",
                 template: `
     <div class="payment-wrapper">
-      <div class="payment-methods-header">
-        <span class="payment-header-title" [textContent]="'SELECT_A' | localize"></span>
-        <span class="payment-header-title extra" [textContent]="'FREE' | localize:false"></span>
-        <span class="payment-header-title" [textContent]="'PAYMENT_METHOD' | localize:false"></span>
-      </div>
-      <div class="payment-methods">
-        <co-loader class="loader" *ngIf="showLoader"></co-loader>
-        <ng-container *ngIf="!showLoader">
-          <co-payment-tile *ngFor="let paymentMethod of paymentMethods; let index = index"
-                           [image]="paymentMethod.image"
-                           [description]="paymentMethod.payment.description"
-                           [selected]="paymentMethodIdx === index"
-                           (selectedChange)="paymentMethodSelected(paymentMethod.payment, index)"
-          ></co-payment-tile>
-        </ng-container>
-      </div>
-      <div class="payment-cash-register-wrapper" *ngIf="showCashRegisters">
-        <div class="payment-cash-register-header">
-          <span class="payment-header-title" [textContent]="'SELECT_CASH_REGISTER' | localize"></span>
+      <div class="payment-methods-register-wrapper">
+        <div class="payment-methods-wrapper">
+          <div class="payment-methods-header">
+            <span class="payment-header-title" [textContent]="'SELECT' | localize"></span>
+            <!--span class="payment-header-title extra" [textContent]="'FREE' | localize:false"></span-->
+            <span class="payment-header-title" [textContent]="'PAYMENT_METHOD' | localize:false"></span>
+          </div>
+          <div class="payment-methods co-small-scrollbar">
+            <co-loader class="loader" *ngIf="showLoader"></co-loader>
+            <ng-container *ngIf="!showLoader">
+              <co-payment-tile *ngFor="let paymentMethod of paymentMethods; let index = index"
+                               [image]="paymentMethod.image"
+                               [description]="paymentMethod.payment.description"
+                               [selected]="paymentMethodIdx === index"
+                               (selectedChange)="paymentMethodSelected(paymentMethod.payment, index)"
+              ></co-payment-tile>
+            </ng-container>
+          </div>
         </div>
-        <div class="payment-methods">
-          <co-payment-tile *ngFor="let cashRegister of cashRegisters; let index = index"
-                           [icon]="cashRegister.icon"
-                           [description]="cashRegister.description"
-                           [selected]="cashRegisterIdx === index"
-                           (selectedChange)="cashRegisterSelected(cashRegister, index)"
-          ></co-payment-tile>
+        <div class="payment-cash-register-wrapper" *ngIf="showCashRegisters">
+          <div class="payment-cash-register-header">
+            <span class="payment-header-title" [textContent]="'SELECT_CASH_REGISTER' | localize"></span>
+          </div>
+          <div class="payment-methods">
+            <co-payment-tile *ngFor="let cashRegister of cashRegisters; let index = index"
+                             [icon]="cashRegister.icon"
+                             [description]="cashRegister.description"
+                             [selected]="cashRegisterIdx === index"
+                             (selectedChange)="cashRegisterSelected(cashRegister, index)"
+            ></co-payment-tile>
+          </div>
         </div>
       </div>
       <div class="payment-to-pay-wrapper">
-        <co-payment-to-pay [amountToPay]="amountToPay"></co-payment-to-pay>
+        <div class="payment-to-pay-total">
+          <div class="payment-to-pay-header">
+            <span class="payment-header-title" [textContent]="'TOTAL_AMOUNT_TO_PAY' | localize"></span>
+            <span class="payment-total-pay" [textContent]="depositAmount === 0 ? depositAmount : (depositAmount | coCurrency)"></span>
+          </div>
+          <div class="payment-input-button-wrapper">
+            <div class="payment-input-button">
+                <co-payment-to-pay [amountToPay]="amountToPay"></co-payment-to-pay>
+                <div class="payment-to-pay-button">
+                    <co-button [iconData]="iconCacheService.getIcon(icons.CheckDuotone)" (click)="handlePayment()" [disabled]="amountToPay === 0"></co-button>
+                </div>
+            </div>
+            <div class="payment-error-message" *ngIf="statusMessage" [textContent]="statusMessage"></div>
+          </div>
+        </div>
+
         <div class="payment-deposit">
           <co-deposit-payment [branch]="branch" [transactionUuid]="transactionUuid"></co-deposit-payment>
         </div>
-        <div class="payment-to-pay-button">
-          <!--
-                    <co-loader *ngIf="statusMessage"></co-loader>
-          -->
-          <div class="payment-error-message" *ngIf="statusMessage" [textContent]="statusMessage"></div>
-          <co-button [label]="'PAY' | localize" (click)="handlePayment()" [disabled]="amountToPay === 0"></co-button>
-        </div>
         <co-key-pad class="payment-to-pay-keypad"
                     [showValue]="false"
                     [emitModelChangeOnEnter]="false"
@@ -291,7 +307,8 @@ PaymentComponent.ctorParameters = () => [
     { type: TransactionService },
     { type: SharedService },
     { type: PaymentService },
-    { type: TransactionEventService }
+    { type: TransactionEventService },
+    { type: IconCacheService }
 ];
 PaymentComponent.propDecorators = {
     transId: [{ type: Input }],
@@ -303,4 +320,4 @@ PaymentComponent.propDecorators = {
     payed: [{ type: Output }],
     showClass: [{ type: HostBinding, args: ["class.co-payment",] }]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"payment.component.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/component/payment/payment.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnDestroy, OnInit, Output, ViewEncapsulation} from '@angular/core';\r\nimport {Icon} from '../../enum/icon.enum';\r\nimport {TransactionService} from '../../service/transaction.service';\r\nimport {CashRegister} from '@colijnit/transactionapi/build/model/cash-register';\r\nimport {PaymentService} from '../../service/payment.service';\r\nimport {SharedService} from '../../service/shared.service';\r\nimport {PaymentMethod} from '@colijnit/transactionapi/build/model/payment-method.bo';\r\nimport {PaymentViewmodel} from '../../model/payment.viewmodel';\r\nimport {PaymentLinkStatus} from '@colijnit/transactionapi/build/model/payment-link-status.bo';\r\nimport {CreatePaymentLinkResult} from '@colijnit/transactionapi/build/model/create-payment-link-result.bo';\r\nimport {TransactionDepositPaymentInfo} from '@colijnit/transactionapi/build/model/transaction-deposit-payment-info.bo';\r\nimport {PspTransactionStatus} from '@colijnit/transactionapi/build/model/psp-transaction-status.bo';\r\nimport {IonePaymentStatusCode} from '@colijnit/transactionapi/build/enum/ione-payment-status-code.enum';\r\nimport {Subscription} from 'rxjs';\r\nimport {TransactionEventService} from '../../service/transaction-event.service';\r\nimport {DoPaymentRequest} from '@colijnit/transactionapi/build/model/do-payment-request';\r\n\r\n@Component({\r\n  selector: \"co-payment\",\r\n  template: `\r\n    <div class=\"payment-wrapper\">\r\n      <div class=\"payment-methods-header\">\r\n        <span class=\"payment-header-title\" [textContent]=\"'SELECT_A' | localize\"></span>\r\n        <span class=\"payment-header-title extra\" [textContent]=\"'FREE' | localize:false\"></span>\r\n        <span class=\"payment-header-title\" [textContent]=\"'PAYMENT_METHOD' | localize:false\"></span>\r\n      </div>\r\n      <div class=\"payment-methods\">\r\n        <co-loader class=\"loader\" *ngIf=\"showLoader\"></co-loader>\r\n        <ng-container *ngIf=\"!showLoader\">\r\n          <co-payment-tile *ngFor=\"let paymentMethod of paymentMethods; let index = index\"\r\n                           [image]=\"paymentMethod.image\"\r\n                           [description]=\"paymentMethod.payment.description\"\r\n                           [selected]=\"paymentMethodIdx === index\"\r\n                           (selectedChange)=\"paymentMethodSelected(paymentMethod.payment, index)\"\r\n          ></co-payment-tile>\r\n        </ng-container>\r\n      </div>\r\n      <div class=\"payment-cash-register-wrapper\" *ngIf=\"showCashRegisters\">\r\n        <div class=\"payment-cash-register-header\">\r\n          <span class=\"payment-header-title\" [textContent]=\"'SELECT_CASH_REGISTER' | localize\"></span>\r\n        </div>\r\n        <div class=\"payment-methods\">\r\n          <co-payment-tile *ngFor=\"let cashRegister of cashRegisters; let index = index\"\r\n                           [icon]=\"cashRegister.icon\"\r\n                           [description]=\"cashRegister.description\"\r\n                           [selected]=\"cashRegisterIdx === index\"\r\n                           (selectedChange)=\"cashRegisterSelected(cashRegister, index)\"\r\n          ></co-payment-tile>\r\n        </div>\r\n      </div>\r\n      <div class=\"payment-to-pay-wrapper\">\r\n        <co-payment-to-pay [amountToPay]=\"amountToPay\"></co-payment-to-pay>\r\n        <div class=\"payment-deposit\">\r\n          <co-deposit-payment [branch]=\"branch\" [transactionUuid]=\"transactionUuid\"></co-deposit-payment>\r\n        </div>\r\n        <div class=\"payment-to-pay-button\">\r\n          <!--\r\n                    <co-loader *ngIf=\"statusMessage\"></co-loader>\r\n          -->\r\n          <div class=\"payment-error-message\" *ngIf=\"statusMessage\" [textContent]=\"statusMessage\"></div>\r\n          <co-button [label]=\"'PAY' | localize\" (click)=\"handlePayment()\" [disabled]=\"amountToPay === 0\"></co-button>\r\n        </div>\r\n        <co-key-pad class=\"payment-to-pay-keypad\"\r\n                    [showValue]=\"false\"\r\n                    [emitModelChangeOnEnter]=\"false\"\r\n                    [model]=\"amountToPay\"\r\n                    (modelChange)=\"handleKeyPadModelChange($event)\"\r\n                    (enterClick)=\"handlePayment()\"\r\n        ></co-key-pad>\r\n      </div>\r\n    </div>\r\n    <co-dialog *ngIf=\"showPspQrCode\" (closeClick)=\"showPspQrCode = false\">\r\n      <co-payment-qr-code\r\n          [qrCodeImage]=\"qrCodeImage\"\r\n      ></co-payment-qr-code>\r\n    </co-dialog>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class PaymentComponent implements OnInit, OnDestroy {\r\n  public readonly icons: typeof Icon = Icon;\r\n\r\n  @Input()\r\n  public transId: number;\r\n\r\n  @Input()\r\n  public transactionUuid: string;\r\n\r\n  @Input()\r\n  public branch: string;\r\n\r\n  @Input()\r\n  public set amount(value: number) {\r\n    this._amount = value;\r\n  }\r\n\r\n  public get amount(): number {\r\n    return this._amount;\r\n  }\r\n\r\n  @Input()\r\n  public currencyId: number;\r\n\r\n  @Input()\r\n  public updateDepositAmount: boolean = true;\r\n\r\n  @Output()\r\n  public payed: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @HostBinding(\"class.co-payment\")\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  public paymentMethodIdx: number = 0;\r\n  public cashRegisterIdx: number = 0;\r\n  public paymentMethods: PaymentViewmodel[] = [];\r\n  public cashRegisters: any[] = [];\r\n  public showCashRegisters: boolean = false;\r\n  public showKeyPad: boolean = false;\r\n  public showPspQrCode: boolean = false;\r\n  public currentPaymentMethod: PaymentMethod;\r\n  public qrCodeImage: string;\r\n  public showLoader: boolean = true;\r\n  public amountToPay: number = 0;\r\n\r\n  public statusMessage: string = \"\";\r\n\r\n  private _amount: number = 0;\r\n  private _paymentStatusInterval: any;\r\n  private _paymentStatusPollIntervalMs: number = 5000;\r\n  private _paymentStatusMaxPollInterval: number = 10;\r\n  private _paymentStatusPollIntervalCount: number = 0;\r\n  private _paymentResult: CreatePaymentLinkResult;\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(\r\n      private _transactionService: TransactionService,\r\n      private _sharedService: SharedService,\r\n      private _paymentService: PaymentService,\r\n      private _transactionEventService: TransactionEventService) {\r\n  }\r\n\r\n  async ngOnInit(): Promise<void> {\r\n    // if (this.updateDepositAmount) {\r\n    //   await this._transactionService.updateHeaderTransactionDepositAmount(this.transactionUuid, this.amountToPay, true);\r\n    // }\r\n    this._getPaymentMethods().then(() => {\r\n      this.showLoader = false;\r\n      this._getDepositPaymentInfo();\r\n      this._prepareCashRegisters();\r\n    });\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    this._clearInterval();\r\n  }\r\n\r\n  public paymentMethodSelected(method: PaymentMethod, index: number): void {\r\n    this.paymentMethodIdx = index;\r\n    this._prepareCashRegisters();\r\n  }\r\n\r\n  public cashRegisterSelected(cashRegister: CashRegister, index: number): void {\r\n    this.cashRegisterIdx = index;\r\n  }\r\n\r\n  public handlePayment(): void {\r\n    this.statusMessage = \"\";\r\n    const currentPaymentViewModel = this.paymentMethods[this.paymentMethodIdx];\r\n    this.currentPaymentMethod = currentPaymentViewModel.payment;\r\n    if (this.currentPaymentMethod && this.currentPaymentMethod.externalSourceId) { // psp payment\r\n      if (this.currentPaymentMethod.pinTerminal) {\r\n        const cashRegister: CashRegister = this.cashRegisters[this.cashRegisterIdx];\r\n        this._paymentService.doPinPayment(this.transId, this.currentPaymentMethod.code, cashRegister.nr, cashRegister.group, this.amountToPay).then((pspTransactionUuid: string) => {\r\n          if (pspTransactionUuid) {\r\n            this._paymentStatusPollIntervalCount = 0;\r\n            this._waitForPinPaymentStatus(pspTransactionUuid);\r\n          }\r\n        });\r\n      } else {\r\n        this._paymentService.createIonePaymentLinkAndQRCode(this.transactionUuid, this.amountToPay, this.currentPaymentMethod.code).then((response: CreatePaymentLinkResult) => {\r\n          this._paymentResult = response;\r\n          if (this._paymentResult && this._paymentResult.imageBase64) {\r\n            this.qrCodeImage = this._dataUriToBase64(this._paymentResult.imageBase64, 'image/png');\r\n            this.showPspQrCode = true;\r\n            this._paymentStatusPollIntervalCount = 0;\r\n            this._waitForPaymentStatus();\r\n          }\r\n        });\r\n      }\r\n    } else {\r\n      const currentCashRegister: CashRegister = this.cashRegisters[this.cashRegisterIdx];\r\n      const request: DoPaymentRequest = new DoPaymentRequest();\r\n      request.transId = this.transId;\r\n      request.paymentMethodCode = this.currentPaymentMethod.code;\r\n      request.amount = this.amountToPay;\r\n      request.currencyId = this.currencyId;\r\n      request.cashRegisterNr = currentCashRegister.nr;\r\n      request.cashRegisterGroupId = currentCashRegister.group;\r\n      request.cashRegisterDrawerId = null;\r\n      this._paymentService.doPayment(request).then(async () => {\r\n        this.showKeyPad = false;\r\n        await this._getDepositPaymentInfo();\r\n        this._handlePayment(false);\r\n        if (this.amountToPay === 0) {\r\n          this._handlePayment();\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  public handleKeyPadModelChange(model: number): void {\r\n    this.amountToPay = model;\r\n  }\r\n\r\n  private async _getDepositPaymentInfo(): Promise<void> {\r\n    if (this.updateDepositAmount) {\r\n      const info: TransactionDepositPaymentInfo = await this._paymentService.getDepositPaymentInfo(this.transactionUuid);\r\n      if (info) {\r\n        this.amountToPay = info.depositRemainderAmount;\r\n      }\r\n    } else {\r\n      this.amountToPay = this._amount;\r\n    }\r\n  }\r\n\r\n  private _dataUriToBase64(uri: string, mimeType: string): string {\r\n    return uri ? \"data:\" + mimeType + \";base64,\" + uri : \"\";\r\n  }\r\n\r\n  private _waitForPaymentStatus(): void {\r\n    if (this._paymentResult && this._paymentResult.paymentLinkUUID) {\r\n      this._paymentStatusInterval = setInterval(async () => {\r\n        if (this._paymentStatusPollIntervalCount >= this._paymentStatusMaxPollInterval) {\r\n          this._clearInterval();\r\n        } else {\r\n          const status: PaymentLinkStatus = await this._paymentService.getPaymentLinkStatus(this._paymentResult.paymentLinkUUID);\r\n          if (status.payedDate) {\r\n            this._clearInterval();\r\n            this.showPspQrCode = false;\r\n            await this._getDepositPaymentInfo();\r\n            if (this.amountToPay === 0) {\r\n              this._handlePayment();\r\n            }\r\n          }\r\n          this._paymentStatusPollIntervalCount++;\r\n        }\r\n      }, this._paymentStatusPollIntervalMs);\r\n    } else {\r\n      this._clearInterval();\r\n    }\r\n  }\r\n\r\n  private _waitForPinPaymentStatus(pspTransactionUuid: string): void {\r\n    if (pspTransactionUuid) {\r\n      this._paymentStatusInterval = setInterval(async () => {\r\n        if (this._paymentStatusPollIntervalCount >= this._paymentStatusMaxPollInterval) {\r\n          this._clearInterval();\r\n        } else {\r\n          const pinStatus: PspTransactionStatus = await this._paymentService.getPspTransactionStatus(pspTransactionUuid);\r\n          if (pinStatus && pinStatus.status) {\r\n            this.statusMessage = pinStatus.status.description;\r\n          }\r\n          if (pinStatus.statusDate && pinStatus.status && pinStatus.status.endStatus) {\r\n            this._clearInterval();\r\n            if (pinStatus.status.code === IonePaymentStatusCode.PAID) {\r\n              await this._getDepositPaymentInfo();\r\n              if (this.amountToPay === 0) {\r\n                this._handlePayment();\r\n              }\r\n            }\r\n          }\r\n          this._paymentStatusPollIntervalCount++;\r\n        }\r\n      }, this._paymentStatusPollIntervalMs);\r\n    } else {\r\n      this._clearInterval();\r\n    }\r\n  }\r\n\r\n  private _clearInterval(): void {\r\n    clearInterval(this._paymentStatusInterval);\r\n    this._paymentStatusInterval = undefined;\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @private\r\n   */\r\n  private _prepareCashRegisters(): void {\r\n    const paymentMethod: PaymentMethod = this.paymentMethods[this.paymentMethodIdx].payment;\r\n    if (paymentMethod && (!paymentMethod.externalSourceId || paymentMethod.pinTerminal)) {\r\n      this.cashRegisters.length = 0;\r\n      paymentMethod.posGroups.forEach(crg => {\r\n        this._getCashRegisters(this.branch, crg.id);\r\n      });\r\n      this.showCashRegisters = true;\r\n    } else {\r\n      this.showCashRegisters = false;\r\n    }\r\n  }\r\n\r\n  private _getCashRegisters(branch?: string, group?: number): void {\r\n    this._transactionService.getCashRegisters(branch, group).then((cashRegisters: CashRegister[]) => {\r\n      this.cashRegisters.push(...cashRegisters);\r\n    });\r\n  }\r\n\r\n  private _getPaymentMethods(): Promise<void> {\r\n    return new Promise((resolve: Function) => {\r\n      this.paymentMethods.length = 0;\r\n      this._paymentService.getPaymentMethodsViewModels(this.branch).then((methods: PaymentViewmodel[]) => {\r\n        this.paymentMethods = methods.slice();\r\n        resolve();\r\n      });\r\n    });\r\n  }\r\n\r\n  private _handlePayment(emitPayed: boolean = true): void {\r\n    this._transactionEventService.transactionPaymentDone.next();\r\n    if (emitPayed) {\r\n      this.payed.emit();\r\n    }\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"payment.component.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/component/payment/payment.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnDestroy, OnInit, Output, ViewEncapsulation} from '@angular/core';\r\nimport {Icon} from '../../enum/icon.enum';\r\nimport {TransactionService} from '../../service/transaction.service';\r\nimport {CashRegister} from '@colijnit/transactionapi/build/model/cash-register';\r\nimport {PaymentService} from '../../service/payment.service';\r\nimport {SharedService} from '../../service/shared.service';\r\nimport {PaymentMethod} from '@colijnit/transactionapi/build/model/payment-method.bo';\r\nimport {PaymentViewmodel} from '../../model/payment.viewmodel';\r\nimport {PaymentLinkStatus} from '@colijnit/transactionapi/build/model/payment-link-status.bo';\r\nimport {CreatePaymentLinkResult} from '@colijnit/transactionapi/build/model/create-payment-link-result.bo';\r\nimport {TransactionDepositPaymentInfo} from '@colijnit/transactionapi/build/model/transaction-deposit-payment-info.bo';\r\nimport {PspTransactionStatus} from '@colijnit/transactionapi/build/model/psp-transaction-status.bo';\r\nimport {IonePaymentStatusCode} from '@colijnit/transactionapi/build/enum/ione-payment-status-code.enum';\r\nimport {Subscription} from 'rxjs';\r\nimport {TransactionEventService} from '../../service/transaction-event.service';\r\nimport {DoPaymentRequest} from '@colijnit/transactionapi/build/model/do-payment-request';\r\nimport {IconCacheService} from \"../../service/icon-cache.service\";\r\n\r\n@Component({\r\n  selector: \"co-payment\",\r\n  template: `\r\n    <div class=\"payment-wrapper\">\r\n      <div class=\"payment-methods-register-wrapper\">\r\n        <div class=\"payment-methods-wrapper\">\r\n          <div class=\"payment-methods-header\">\r\n            <span class=\"payment-header-title\" [textContent]=\"'SELECT' | localize\"></span>\r\n            <!--span class=\"payment-header-title extra\" [textContent]=\"'FREE' | localize:false\"></span-->\r\n            <span class=\"payment-header-title\" [textContent]=\"'PAYMENT_METHOD' | localize:false\"></span>\r\n          </div>\r\n          <div class=\"payment-methods co-small-scrollbar\">\r\n            <co-loader class=\"loader\" *ngIf=\"showLoader\"></co-loader>\r\n            <ng-container *ngIf=\"!showLoader\">\r\n              <co-payment-tile *ngFor=\"let paymentMethod of paymentMethods; let index = index\"\r\n                               [image]=\"paymentMethod.image\"\r\n                               [description]=\"paymentMethod.payment.description\"\r\n                               [selected]=\"paymentMethodIdx === index\"\r\n                               (selectedChange)=\"paymentMethodSelected(paymentMethod.payment, index)\"\r\n              ></co-payment-tile>\r\n            </ng-container>\r\n          </div>\r\n        </div>\r\n        <div class=\"payment-cash-register-wrapper\" *ngIf=\"showCashRegisters\">\r\n          <div class=\"payment-cash-register-header\">\r\n            <span class=\"payment-header-title\" [textContent]=\"'SELECT_CASH_REGISTER' | localize\"></span>\r\n          </div>\r\n          <div class=\"payment-methods\">\r\n            <co-payment-tile *ngFor=\"let cashRegister of cashRegisters; let index = index\"\r\n                             [icon]=\"cashRegister.icon\"\r\n                             [description]=\"cashRegister.description\"\r\n                             [selected]=\"cashRegisterIdx === index\"\r\n                             (selectedChange)=\"cashRegisterSelected(cashRegister, index)\"\r\n            ></co-payment-tile>\r\n          </div>\r\n        </div>\r\n      </div>\r\n      <div class=\"payment-to-pay-wrapper\">\r\n        <div class=\"payment-to-pay-total\">\r\n          <div class=\"payment-to-pay-header\">\r\n            <span class=\"payment-header-title\" [textContent]=\"'TOTAL_AMOUNT_TO_PAY' | localize\"></span>\r\n            <span class=\"payment-total-pay\" [textContent]=\"depositAmount === 0 ? depositAmount : (depositAmount | coCurrency)\"></span>\r\n          </div>\r\n          <div class=\"payment-input-button-wrapper\">\r\n            <div class=\"payment-input-button\">\r\n                <co-payment-to-pay [amountToPay]=\"amountToPay\"></co-payment-to-pay>\r\n                <div class=\"payment-to-pay-button\">\r\n                    <co-button [iconData]=\"iconCacheService.getIcon(icons.CheckDuotone)\" (click)=\"handlePayment()\" [disabled]=\"amountToPay === 0\"></co-button>\r\n                </div>\r\n            </div>\r\n            <div class=\"payment-error-message\" *ngIf=\"statusMessage\" [textContent]=\"statusMessage\"></div>\r\n          </div>\r\n        </div>\r\n\r\n        <div class=\"payment-deposit\">\r\n          <co-deposit-payment [branch]=\"branch\" [transactionUuid]=\"transactionUuid\"></co-deposit-payment>\r\n        </div>\r\n        <co-key-pad class=\"payment-to-pay-keypad\"\r\n                    [showValue]=\"false\"\r\n                    [emitModelChangeOnEnter]=\"false\"\r\n                    [model]=\"amountToPay\"\r\n                    (modelChange)=\"handleKeyPadModelChange($event)\"\r\n                    (enterClick)=\"handlePayment()\"\r\n        ></co-key-pad>\r\n      </div>\r\n    </div>\r\n    <co-dialog *ngIf=\"showPspQrCode\" (closeClick)=\"showPspQrCode = false\">\r\n      <co-payment-qr-code\r\n          [qrCodeImage]=\"qrCodeImage\"\r\n      ></co-payment-qr-code>\r\n    </co-dialog>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class PaymentComponent implements OnInit, OnDestroy {\r\n  public readonly icons: typeof Icon = Icon;\r\n\r\n  @Input()\r\n  public transId: number;\r\n\r\n  @Input()\r\n  public transactionUuid: string;\r\n\r\n  @Input()\r\n  public branch: string;\r\n\r\n  @Input()\r\n  public set amount(value: number) {\r\n    this._amount = value;\r\n  }\r\n\r\n  public get amount(): number {\r\n    return this._amount;\r\n  }\r\n\r\n  @Input()\r\n  public currencyId: number;\r\n\r\n  @Input()\r\n  public updateDepositAmount: boolean = true;\r\n\r\n  @Output()\r\n  public payed: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @HostBinding(\"class.co-payment\")\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  public paymentMethodIdx: number = 0;\r\n  public cashRegisterIdx: number = 0;\r\n  public paymentMethods: PaymentViewmodel[] = [];\r\n  public cashRegisters: any[] = [];\r\n  public showCashRegisters: boolean = false;\r\n  public showKeyPad: boolean = false;\r\n  public showPspQrCode: boolean = false;\r\n  public currentPaymentMethod: PaymentMethod;\r\n  public qrCodeImage: string;\r\n  public showLoader: boolean = true;\r\n  public amountToPay: number = 0;\r\n  public depositAmount: number = 0;\r\n\r\n  public statusMessage: string = \"\";\r\n\r\n  private _amount: number = 0;\r\n  private _paymentStatusInterval: any;\r\n  private _paymentStatusPollIntervalMs: number = 5000;\r\n  private _paymentStatusMaxPollInterval: number = 10;\r\n  private _paymentStatusPollIntervalCount: number = 0;\r\n  private _paymentResult: CreatePaymentLinkResult;\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(\r\n      private _transactionService: TransactionService,\r\n      private _sharedService: SharedService,\r\n      private _paymentService: PaymentService,\r\n      private _transactionEventService: TransactionEventService,\r\n      public iconCacheService: IconCacheService ){\r\n  }\r\n\r\n  async ngOnInit(): Promise<void> {\r\n    // if (this.updateDepositAmount) {\r\n    //   await this._transactionService.updateHeaderTransactionDepositAmount(this.transactionUuid, this.amountToPay, true);\r\n    // }\r\n    this._getPaymentMethods().then(() => {\r\n      this.showLoader = false;\r\n      this._getDepositPaymentInfo();\r\n      this._prepareCashRegisters();\r\n    });\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    this._clearInterval();\r\n  }\r\n\r\n  public paymentMethodSelected(method: PaymentMethod, index: number): void {\r\n    this.paymentMethodIdx = index;\r\n    this._prepareCashRegisters();\r\n  }\r\n\r\n  public cashRegisterSelected(cashRegister: CashRegister, index: number): void {\r\n    this.cashRegisterIdx = index;\r\n  }\r\n\r\n  public handlePayment(): void {\r\n    this.statusMessage = \"\";\r\n    const currentPaymentViewModel = this.paymentMethods[this.paymentMethodIdx];\r\n    this.currentPaymentMethod = currentPaymentViewModel.payment;\r\n    if (this.currentPaymentMethod && this.currentPaymentMethod.externalSourceId) { // psp payment\r\n      if (this.currentPaymentMethod.pinTerminal) {\r\n        const cashRegister: CashRegister = this.cashRegisters[this.cashRegisterIdx];\r\n        this._paymentService.doPinPayment(this.transId, this.currentPaymentMethod.code, cashRegister.nr, cashRegister.group, this.amountToPay).then((pspTransactionUuid: string) => {\r\n          if (pspTransactionUuid) {\r\n            this._paymentStatusPollIntervalCount = 0;\r\n            this._waitForPinPaymentStatus(pspTransactionUuid);\r\n          }\r\n        });\r\n      } else {\r\n        this._paymentService.createIonePaymentLinkAndQRCode(this.transactionUuid, this.amountToPay, this.currentPaymentMethod.code).then((response: CreatePaymentLinkResult) => {\r\n          this._paymentResult = response;\r\n          if (this._paymentResult && this._paymentResult.imageBase64) {\r\n            this.qrCodeImage = this._dataUriToBase64(this._paymentResult.imageBase64, 'image/png');\r\n            this.showPspQrCode = true;\r\n            this._paymentStatusPollIntervalCount = 0;\r\n            this._waitForPaymentStatus();\r\n          }\r\n        });\r\n      }\r\n    } else {\r\n      const currentCashRegister: CashRegister = this.cashRegisters[this.cashRegisterIdx];\r\n      const request: DoPaymentRequest = new DoPaymentRequest();\r\n      request.transId = this.transId;\r\n      request.paymentMethodCode = this.currentPaymentMethod.code;\r\n      request.amount = this.amountToPay;\r\n      request.currencyId = this.currencyId;\r\n      request.cashRegisterNr = currentCashRegister.nr;\r\n      request.cashRegisterGroupId = currentCashRegister.group;\r\n      request.cashRegisterDrawerId = null;\r\n      this._paymentService.doPayment(request).then(async () => {\r\n        this.showKeyPad = false;\r\n        await this._getDepositPaymentInfo();\r\n        this._handlePayment(false);\r\n        if (this.amountToPay === 0) {\r\n          this._handlePayment();\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  public handleKeyPadModelChange(model: number): void {\r\n    this.amountToPay = model;\r\n  }\r\n\r\n  private async _getDepositPaymentInfo(): Promise<void> {\r\n    if (this.updateDepositAmount) {\r\n      const info: TransactionDepositPaymentInfo = await this._paymentService.getDepositPaymentInfo(this.transactionUuid);\r\n      if (info) {\r\n        this.amountToPay = info.depositRemainderAmount;\r\n        this.depositAmount = info.depositAmount;\r\n      }\r\n    } else {\r\n      this.amountToPay = this._amount;\r\n    }\r\n  }\r\n\r\n  private _dataUriToBase64(uri: string, mimeType: string): string {\r\n    return uri ? \"data:\" + mimeType + \";base64,\" + uri : \"\";\r\n  }\r\n\r\n  private _waitForPaymentStatus(): void {\r\n    if (this._paymentResult && this._paymentResult.paymentLinkUUID) {\r\n      this._paymentStatusInterval = setInterval(async () => {\r\n        if (this._paymentStatusPollIntervalCount >= this._paymentStatusMaxPollInterval) {\r\n          this._clearInterval();\r\n        } else {\r\n          const status: PaymentLinkStatus = await this._paymentService.getPaymentLinkStatus(this._paymentResult.paymentLinkUUID);\r\n          if (status.payedDate) {\r\n            this._clearInterval();\r\n            this.showPspQrCode = false;\r\n            await this._getDepositPaymentInfo();\r\n            if (this.amountToPay === 0) {\r\n              this._handlePayment();\r\n            }\r\n          }\r\n          this._paymentStatusPollIntervalCount++;\r\n        }\r\n      }, this._paymentStatusPollIntervalMs);\r\n    } else {\r\n      this._clearInterval();\r\n    }\r\n  }\r\n\r\n  private _waitForPinPaymentStatus(pspTransactionUuid: string): void {\r\n    if (pspTransactionUuid) {\r\n      this._paymentStatusInterval = setInterval(async () => {\r\n        if (this._paymentStatusPollIntervalCount >= this._paymentStatusMaxPollInterval) {\r\n          this._clearInterval();\r\n        } else {\r\n          const pinStatus: PspTransactionStatus = await this._paymentService.getPspTransactionStatus(pspTransactionUuid);\r\n          if (pinStatus && pinStatus.status) {\r\n            this.statusMessage = pinStatus.status.description;\r\n          }\r\n          if (pinStatus.statusDate && pinStatus.status && pinStatus.status.endStatus) {\r\n            this._clearInterval();\r\n            if (pinStatus.status.code === IonePaymentStatusCode.PAID) {\r\n              await this._getDepositPaymentInfo();\r\n              if (this.amountToPay === 0) {\r\n                this._handlePayment();\r\n              }\r\n            }\r\n          }\r\n          this._paymentStatusPollIntervalCount++;\r\n        }\r\n      }, this._paymentStatusPollIntervalMs);\r\n    } else {\r\n      this._clearInterval();\r\n    }\r\n  }\r\n\r\n  private _clearInterval(): void {\r\n    clearInterval(this._paymentStatusInterval);\r\n    this._paymentStatusInterval = undefined;\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @private\r\n   */\r\n  private _prepareCashRegisters(): void {\r\n    const paymentMethod: PaymentMethod = this.paymentMethods[this.paymentMethodIdx].payment;\r\n    if (paymentMethod && (!paymentMethod.externalSourceId || paymentMethod.pinTerminal)) {\r\n      this.cashRegisters.length = 0;\r\n      paymentMethod.posGroups.forEach(crg => {\r\n        this._getCashRegisters(this.branch, crg.id);\r\n      });\r\n      this.showCashRegisters = true;\r\n    } else {\r\n      this.showCashRegisters = false;\r\n    }\r\n  }\r\n\r\n  private _getCashRegisters(branch?: string, group?: number): void {\r\n    this._transactionService.getCashRegisters(branch, group).then((cashRegisters: CashRegister[]) => {\r\n      this.cashRegisters.push(...cashRegisters);\r\n    });\r\n  }\r\n\r\n  private _getPaymentMethods(): Promise<void> {\r\n    return new Promise((resolve: Function) => {\r\n      this.paymentMethods.length = 0;\r\n      this._paymentService.getPaymentMethodsViewModels(this.branch).then((methods: PaymentViewmodel[]) => {\r\n        this.paymentMethods = methods.slice();\r\n        resolve();\r\n      });\r\n    });\r\n  }\r\n\r\n  private _handlePayment(emitPayed: boolean = true): void {\r\n    this._transactionEventService.transactionPaymentDone.next();\r\n    if (emitPayed) {\r\n      this.payed.emit();\r\n    }\r\n  }\r\n}\r\n"]}