@colijnit/transaction 12.1.32 → 12.1.34

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

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

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

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

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

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

@@ -0,0 +1,30 @@
+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) {
+        if (!this._boCacheManager.hasSingleCacheItem(clazz, sourceId)) {
+            this._createCacheItem(clazz, sourceId, loadFunction);
+        }
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.getSingleCacheItem(clazz, sourceId);
+    }
+    _createCacheItem(clazz, sourceId, loadFunction) {
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.addNewSelectSingleCacheItem(clazz, sourceId, loadFunction);
+    }
+}
+SelectSingleCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SelectSingleCacheService_Factory() { return new SelectSingleCacheService(i0.ɵɵinject(i1.BusinessObjectCacheManagerService)); }, token: SelectSingleCacheService, providedIn: "root" });
+SelectSingleCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+SelectSingleCacheService.ctorParameters = () => [
+    { type: BusinessObjectCacheManagerService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/checkout/checkout-overview-delivery-edit/checkout-overview-delivery-edit.component.js

@@ -220,7 +220,7 @@ CheckoutOverviewDeliveryEditComponent.decorators = [
             </div>
             <div class="checkout-data-column">
               <div class="checkout-data-row">
-                <co-transaction-header-branch [transactionInfo]="transaction.transactionInfo"></co-transaction-header-branch>
+                <co-transaction-header-branch [simple]="true" [transactionInfo]="transaction.transactionInfo"></co-transaction-header-branch>
                 <co-transaction-header-administrative-relation [transactionInfo]="transaction.transactionInfo"></co-transaction-header-administrative-relation>
               </div>
               <div class="checkout-data-row">
@@ -268,4 +268,4 @@ CheckoutOverviewDeliveryEditComponent.propDecorators = {
     invalidSubmit: [{ type: Output }],
     showClass: [{ type: HostBinding, args: ["class.co-checkout-overview-delivery-edit",] }]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout-overview-delivery-edit.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/checkout/checkout-overview-delivery-edit/checkout-overview-delivery-edit.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from \"@angular/core\";\nimport {FormMasterService} from \"@colijnit/corecomponents_v12\";\nimport {Address} from \"@colijnit/transactionapi/build/model/address.bo\";\nimport {GenderType} from \"@colijnit/transactionapi/build/enum/gender-type.enum\";\nimport {Marketing} from \"@colijnit/transactionapi/build/model/marketing.bo\";\nimport {DeliveryMethod} from \"@colijnit/transactionapi/build/model/delivery-method.bo\";\nimport {DeliveryOption} from \"@colijnit/transactionapi/build/model/delivery-option.bo\";\nimport {TransactionService} from \"../../../service/transaction.service\";\nimport {TextValueContainer} from \"../../../model/text-value-container\";\nimport {DictionaryService} from \"../../../service/dictionary.service\";\nimport {TransactionInfoResponse} from \"@colijnit/transactionapi/build/model/transaction-info-response.bo\";\nimport {Icon} from \"../../../enum/icon.enum\";\nimport {animate, state, style, transition, trigger} from \"@angular/animations\";\nimport {BusinessObjectFactory} from \"../../../factory/business-object-factory\";\nimport {IconCacheService} from \"../../../service/icon-cache.service\";\n\n@Component({\n  selector: \"co-checkout-overview-delivery-edit\",\n  template: `\n    <div class=\"delivery-edit-content\">\n      <co-form>\n        <div class=\"checkout-form-wrapper\">\n          <div class=\"checkout-section-wrapper\">\n            <div class=\"checkout-label-column\">\n              <span>01</span>\n              <span class=\"label\" [textContent]=\"'DELIVERY_DATA' | localize\"></span>\n            </div>\n            <div class=\"checkout-data-column\">\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-delivery-method\n                  [transactionInfo]=\"transaction.transactionInfo\"\n                  (deliveryMethodChange)=\"currentDeliveryMethod = $event\"\n                ></co-transaction-header-delivery-method>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-delivery-date class=\"header-delivery-deliverydate\"\n                                                     [transactionInfo]=\"transaction.transactionInfo\"\n                ></co-transaction-header-delivery-date>\n                <co-transaction-header-preferred-delivery-date class=\"header-delivery-deliverydate\"\n                                                     [transactionInfo]=\"transaction.transactionInfo\"\n                ></co-transaction-header-preferred-delivery-date>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-partial-delivery [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-partial-delivery>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-collapsible [headerTitle]=\"'ADD_DELIVERY_OPTION' | localize\" [iconData]=\"iconService.getIcon(icons.TriangleDown)\">\n                  <div class=\"checkout-data-row\">\n                    <co-transaction-header-delivery-options\n                      [transactionInfo]=\"transaction.transactionInfo\"\n                      [deliveryMethod]=\"currentDeliveryMethod\"\n                    ></co-transaction-header-delivery-options>\n                  </div>\n                </co-collapsible>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-collapsible [headerTitle]=\"'ADD_REMARK' | localize\" [iconData]=\"iconService.getIcon(icons.TriangleDown)\">\n                  <div class=\"checkout-data-row\">\n                    <co-transaction-header-remarks [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-remarks>\n                  </div>\n                </co-collapsible>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-collapsible [headerTitle]=\"'ADD_REFERENCE' | localize\" [iconData]=\"iconService.getIcon(icons.TriangleDown)\">\n                  <div class=\"checkout-data-row\">\n                    <co-transaction-header-reference [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-reference>\n                  </div>\n                  <div class=\"checkout-data-row\">\n                    <co-transaction-header-relation-reference [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-relation-reference>\n                  </div>\n                </co-collapsible>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-input-date [model]=\"'NOG_NIET_GEIMPLEMENTEERD'\" [placeholder]=\"'ASSEMBLY_DATE' | localize\"></co-input-date>\n              </div>\n            </div>\n          </div>\n          <div class=\"checkout-section-wrapper\">\n            <div class=\"checkout-label-column\">\n              <span>02</span>\n              <span class=\"label\" [textContent]=\"'DOWNPAYMENT' | localize\"></span>\n            </div>\n            <div class=\"checkout-data-column\">\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-downpayment-percentage [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-downpayment-percentage>\n                <co-transaction-header-downpayment-amount [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-downpayment-amount>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-input-text [model]=\"'NOG_NIET_GEIMPLEMENTEERD'\" [placeholder]=\"'DOWNPAYMENT_BY_BR' | localize\"></co-input-text>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-input-text [model]=\"'NOG_NIET_GEIMPLEMENTEERD'\" [placeholder]=\"'DOWNPAYMENT_ON_DELIVERY' | localize\"></co-input-text>\n              </div>\n            </div>\n          </div>\n          <div class=\"checkout-section-wrapper\">\n            <div class=\"checkout-label-column\">\n              <span>03</span>\n              <span class=\"label\" [textContent]=\"'ORDER_DATA' | localize\"></span>\n            </div>\n            <div class=\"checkout-data-column\">\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-branch [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-branch>\n                <co-transaction-header-administrative-relation [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-administrative-relation>\n              </div>\n              <div class=\"checkout-data-row\">\n                <span class=\"label\" [textContent]=\"'MARKETING_CODE' | localize\"></span>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-marketing [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-marketing>\n              </div>\n              <div class=\"checkout-data-row\">\n                <span class=\"label\" [textContent]=\"'ORDER_PARAMETERS' | localize\"></span>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-definitive [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-definitive>\n              </div>\n            </div>\n          </div>\n        </div>\n      </co-form>\n    </div>\n  `,\n  providers: [\n    FormMasterService\n  ],\n  animations: [\n    trigger(\"showHideInvoiceAddress\", [\n      state(\"void\", style({height: 0, opacity: 0})),\n      state(\"*\", style({height: \"*\", opacity: 1})),\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\n      transition(\"* => void\", animate(\"200ms ease-out\"))\n    ])\n  ],\n  encapsulation: ViewEncapsulation.None\n})\nexport class CheckoutOverviewDeliveryEditComponent implements OnInit {\n  public readonly icons: typeof Icon = Icon;\n\n  // @Input()\n  // public deliveryOptionsRequest: SetTransactionDeliveryOptionsRequest;\n\n  @Input()\n  public transaction: TransactionInfoResponse;\n\n  @Output()\n  public validSubmit: EventEmitter<void> = new EventEmitter<void>();\n\n  @Output()\n  public invalidSubmit: EventEmitter<void> = new EventEmitter<void>();\n\n  @HostBinding(\"class.co-checkout-overview-delivery-edit\")\n  public showClass(): boolean {\n    return true;\n  }\n\n  // public deliveryTypes: DeliveryType[] = [\n  //   {code: '1', description: 'Bezorgen', icon: this.icons.DeliveryTruck, price: 89},\n  //   {code: '2', description: 'Bezorgen & monteren', icon: this.icons.CalendarDay, price: 119},\n  //   {code: '3', description: 'Meenemen', icon: this.icons.Truck},\n  // ];\n  public deliveryOptionList: DeliveryOption[] = [];\n  public deliveryOptions: DeliveryOption[] = [];\n  public deliveryOptionFields: TextValueContainer = {text: \"description\", value: \"code\"};\n  public deliveryMethods: DeliveryMethod[] = [];\n  public deliveryMethodFields: TextValueContainer = {text: \"description\", value: \"code\"};\n  public deliveryTypeIdx: number = 0;\n\n  public currentDeliveryMethod: DeliveryMethod;\n\n  public changeLocationPopup: boolean = false;\n  public transactionDefinitive: boolean = false;\n\n  public newAddress: Address;\n  public preferredDateOptions: TextValueContainer[] = [\n    {text: \"NOT_AFTER\", value: \">\"},\n    {text: \"NOT_BEFORE\", value: \"<\"},\n    {text: \"ON_DATE\", value: \"=\"},\n  ];\n  public addressToEdit: Address;\n  public preferredDate: Date = new Date();\n  public gender: GenderType;\n  public marketing: Marketing[] = [];\n  public marketingFields: Object = {text: \"description\", value: \"code\"};\n  public marketingCode: string;\n  public assemblyCosts: number;\n  public deliveryCosts: number;\n\n  // TODO: Deze velden nog opnemen in Transaction!!\n  public deliveryDateFinal: boolean = false;\n  public assemblyDate: Date = new Date();\n  public totalAssemblyTime: string = \"\";\n  public dropshipment: boolean = false;\n\n  public get deliveryDate(): Date {\n    if (this.transaction.transactionInfo.deliveryDate === undefined) {\n      this.transaction.transactionInfo.deliveryDate = new Date();\n    }\n    return this.transaction.transactionInfo.deliveryDate;\n  }\n\n  public set deliveryDate(value: Date) {\n    this.transaction.transactionInfo.deliveryDate = value;\n  }\n\n  public get preferredDeliveryDate(): Date {\n    if (this.transaction.transactionInfo.preferredDeliveryDate === undefined) {\n      this.transaction.transactionInfo.preferredDeliveryDate = new Date();\n    }\n    return this.transaction.transactionInfo.preferredDeliveryDate;\n  }\n\n  public set preferredDeliveryDate(value: Date) {\n    this.transaction.transactionInfo.preferredDeliveryDate = value;\n  }\n\n  constructor(\n    private _dictionaryService: DictionaryService,\n    private _formMasterService: FormMasterService,\n    private _boFactory: BusinessObjectFactory,\n    public service: TransactionService,\n    public iconService: IconCacheService\n  ) {\n  }\n\n  public async ngOnInit(): Promise<void> {\n    this.deliveryCosts = this.calculateDeliveryCosts();\n    this.assemblyCosts = this.calculateAssemblyCosts();\n    this.service.getDeliveryMethods().then((methods: DeliveryMethod[]) => {\n      this.deliveryMethods = methods.filter(m => m.webshop);\n    });\n    this.service.getDeliveryOptions().then((options: DeliveryOption[]) => {\n      this.deliveryOptionList = options;\n    });\n    this.service.getMarketingCodes().then((marketingCodes: Marketing[]) => {\n      this.marketing = marketingCodes;\n    });\n  }\n\n  public submit(): boolean {\n    return this._formMasterService.submitSlaves();\n  }\n\n  public async handleDeliveryMethodChange(deliveryMethod: DeliveryMethod): Promise<void> {\n    this.service.updateHeaderTransactionDeliveryMethod(this.service.currentTransaction.transactionInfo.uuid, deliveryMethod.code).then(() => {\n      this.deliveryOptions = this.selectDeliveryOptionsByDeliveryMethod(deliveryMethod);\n    });\n    // this.transaction.transactionLines.forEach((tl: TransactionLineInfo) => {\n    //   tl.deliveryMethodCode = deliveryMethod.code;\n    // })\n    // if (deliveryMethod) {\n    //   this.deliveryOptions = this.selectDeliveryOptionsByDeliveryMethod(deliveryMethod);\n    // }\n  }\n\n  public setIndexDeliveryType(idx: number): void {\n    this.deliveryTypeIdx = idx;\n    // this.selectAddress(this.relation.addresses[idx]);\n  }\n\n  public selectDeliveryOptionsByDeliveryMethod(deliveryMethod: DeliveryMethod): DeliveryOption[] {\n    return this.deliveryOptionList.filter(deliveryOption => deliveryMethod.deliveryOptions.indexOf(deliveryOption.code) !== -1);\n  }\n\n  public selectDeliveryMethodById(deliveryMethodId: string): DeliveryMethod {\n    return this.deliveryMethods.find(delivery => delivery.code === deliveryMethodId);\n  }\n\n  public isDeliveryOptionChecked(deliveryOptionItem: DeliveryOption): boolean {\n    return (this.transaction.transactionInfo.deliveryOptions.indexOf(deliveryOptionItem.code, 0) === 0);\n  }\n\n  public changePreferredDeliveryDate2(preferredDateOption: string): void {\n    this.transaction.transactionInfo.preferredDeliveryDate2 = preferredDateOption;\n  }\n\n  public onMarketingCodeChange(marketingCode: string): void {\n    this.transaction.transactionInfo.marketingCode = marketingCode;\n  }\n\n  public onChangeLocationCancelClick(): void {\n    this.changeLocationPopup = false;\n  }\n\n  public async handleTransactionDefinitive(definitive: boolean): Promise<void> {\n    const success: boolean = await this.service.updateHeaderTransactionDefinitive(this.transaction.transactionInfo.uuid, definitive);\n    if (!success) {\n      this.transactionDefinitive = !definitive;\n    }\n  }\n\n  private calculateDeliveryCosts(): number {\n    return 0;\n  }\n\n  private calculateAssemblyCosts(): number {\n    return 0;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout-overview-delivery-edit.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/checkout/checkout-overview-delivery-edit/checkout-overview-delivery-edit.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from \"@angular/core\";\nimport {FormMasterService} from \"@colijnit/corecomponents_v12\";\nimport {Address} from \"@colijnit/transactionapi/build/model/address.bo\";\nimport {GenderType} from \"@colijnit/transactionapi/build/enum/gender-type.enum\";\nimport {Marketing} from \"@colijnit/transactionapi/build/model/marketing.bo\";\nimport {DeliveryMethod} from \"@colijnit/transactionapi/build/model/delivery-method.bo\";\nimport {DeliveryOption} from \"@colijnit/transactionapi/build/model/delivery-option.bo\";\nimport {TransactionService} from \"../../../service/transaction.service\";\nimport {TextValueContainer} from \"../../../model/text-value-container\";\nimport {DictionaryService} from \"../../../service/dictionary.service\";\nimport {TransactionInfoResponse} from \"@colijnit/transactionapi/build/model/transaction-info-response.bo\";\nimport {Icon} from \"../../../enum/icon.enum\";\nimport {animate, state, style, transition, trigger} from \"@angular/animations\";\nimport {BusinessObjectFactory} from \"../../../factory/business-object-factory\";\nimport {IconCacheService} from \"../../../service/icon-cache.service\";\n\n@Component({\n  selector: \"co-checkout-overview-delivery-edit\",\n  template: `\n    <div class=\"delivery-edit-content\">\n      <co-form>\n        <div class=\"checkout-form-wrapper\">\n          <div class=\"checkout-section-wrapper\">\n            <div class=\"checkout-label-column\">\n              <span>01</span>\n              <span class=\"label\" [textContent]=\"'DELIVERY_DATA' | localize\"></span>\n            </div>\n            <div class=\"checkout-data-column\">\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-delivery-method\n                  [transactionInfo]=\"transaction.transactionInfo\"\n                  (deliveryMethodChange)=\"currentDeliveryMethod = $event\"\n                ></co-transaction-header-delivery-method>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-delivery-date class=\"header-delivery-deliverydate\"\n                                                     [transactionInfo]=\"transaction.transactionInfo\"\n                ></co-transaction-header-delivery-date>\n                <co-transaction-header-preferred-delivery-date class=\"header-delivery-deliverydate\"\n                                                     [transactionInfo]=\"transaction.transactionInfo\"\n                ></co-transaction-header-preferred-delivery-date>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-partial-delivery [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-partial-delivery>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-collapsible [headerTitle]=\"'ADD_DELIVERY_OPTION' | localize\" [iconData]=\"iconService.getIcon(icons.TriangleDown)\">\n                  <div class=\"checkout-data-row\">\n                    <co-transaction-header-delivery-options\n                      [transactionInfo]=\"transaction.transactionInfo\"\n                      [deliveryMethod]=\"currentDeliveryMethod\"\n                    ></co-transaction-header-delivery-options>\n                  </div>\n                </co-collapsible>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-collapsible [headerTitle]=\"'ADD_REMARK' | localize\" [iconData]=\"iconService.getIcon(icons.TriangleDown)\">\n                  <div class=\"checkout-data-row\">\n                    <co-transaction-header-remarks [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-remarks>\n                  </div>\n                </co-collapsible>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-collapsible [headerTitle]=\"'ADD_REFERENCE' | localize\" [iconData]=\"iconService.getIcon(icons.TriangleDown)\">\n                  <div class=\"checkout-data-row\">\n                    <co-transaction-header-reference [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-reference>\n                  </div>\n                  <div class=\"checkout-data-row\">\n                    <co-transaction-header-relation-reference [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-relation-reference>\n                  </div>\n                </co-collapsible>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-input-date [model]=\"'NOG_NIET_GEIMPLEMENTEERD'\" [placeholder]=\"'ASSEMBLY_DATE' | localize\"></co-input-date>\n              </div>\n            </div>\n          </div>\n          <div class=\"checkout-section-wrapper\">\n            <div class=\"checkout-label-column\">\n              <span>02</span>\n              <span class=\"label\" [textContent]=\"'DOWNPAYMENT' | localize\"></span>\n            </div>\n            <div class=\"checkout-data-column\">\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-downpayment-percentage [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-downpayment-percentage>\n                <co-transaction-header-downpayment-amount [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-downpayment-amount>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-input-text [model]=\"'NOG_NIET_GEIMPLEMENTEERD'\" [placeholder]=\"'DOWNPAYMENT_BY_BR' | localize\"></co-input-text>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-input-text [model]=\"'NOG_NIET_GEIMPLEMENTEERD'\" [placeholder]=\"'DOWNPAYMENT_ON_DELIVERY' | localize\"></co-input-text>\n              </div>\n            </div>\n          </div>\n          <div class=\"checkout-section-wrapper\">\n            <div class=\"checkout-label-column\">\n              <span>03</span>\n              <span class=\"label\" [textContent]=\"'ORDER_DATA' | localize\"></span>\n            </div>\n            <div class=\"checkout-data-column\">\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-branch [simple]=\"true\" [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-branch>\n                <co-transaction-header-administrative-relation [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-administrative-relation>\n              </div>\n              <div class=\"checkout-data-row\">\n                <span class=\"label\" [textContent]=\"'MARKETING_CODE' | localize\"></span>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-marketing [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-marketing>\n              </div>\n              <div class=\"checkout-data-row\">\n                <span class=\"label\" [textContent]=\"'ORDER_PARAMETERS' | localize\"></span>\n              </div>\n              <div class=\"checkout-data-row\">\n                <co-transaction-header-definitive [transactionInfo]=\"transaction.transactionInfo\"></co-transaction-header-definitive>\n              </div>\n            </div>\n          </div>\n        </div>\n      </co-form>\n    </div>\n  `,\n  providers: [\n    FormMasterService\n  ],\n  animations: [\n    trigger(\"showHideInvoiceAddress\", [\n      state(\"void\", style({height: 0, opacity: 0})),\n      state(\"*\", style({height: \"*\", opacity: 1})),\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\n      transition(\"* => void\", animate(\"200ms ease-out\"))\n    ])\n  ],\n  encapsulation: ViewEncapsulation.None\n})\nexport class CheckoutOverviewDeliveryEditComponent implements OnInit {\n  public readonly icons: typeof Icon = Icon;\n\n  // @Input()\n  // public deliveryOptionsRequest: SetTransactionDeliveryOptionsRequest;\n\n  @Input()\n  public transaction: TransactionInfoResponse;\n\n  @Output()\n  public validSubmit: EventEmitter<void> = new EventEmitter<void>();\n\n  @Output()\n  public invalidSubmit: EventEmitter<void> = new EventEmitter<void>();\n\n  @HostBinding(\"class.co-checkout-overview-delivery-edit\")\n  public showClass(): boolean {\n    return true;\n  }\n\n  // public deliveryTypes: DeliveryType[] = [\n  //   {code: '1', description: 'Bezorgen', icon: this.icons.DeliveryTruck, price: 89},\n  //   {code: '2', description: 'Bezorgen & monteren', icon: this.icons.CalendarDay, price: 119},\n  //   {code: '3', description: 'Meenemen', icon: this.icons.Truck},\n  // ];\n  public deliveryOptionList: DeliveryOption[] = [];\n  public deliveryOptions: DeliveryOption[] = [];\n  public deliveryOptionFields: TextValueContainer = {text: \"description\", value: \"code\"};\n  public deliveryMethods: DeliveryMethod[] = [];\n  public deliveryMethodFields: TextValueContainer = {text: \"description\", value: \"code\"};\n  public deliveryTypeIdx: number = 0;\n\n  public currentDeliveryMethod: DeliveryMethod;\n\n  public changeLocationPopup: boolean = false;\n  public transactionDefinitive: boolean = false;\n\n  public newAddress: Address;\n  public preferredDateOptions: TextValueContainer[] = [\n    {text: \"NOT_AFTER\", value: \">\"},\n    {text: \"NOT_BEFORE\", value: \"<\"},\n    {text: \"ON_DATE\", value: \"=\"},\n  ];\n  public addressToEdit: Address;\n  public preferredDate: Date = new Date();\n  public gender: GenderType;\n  public marketing: Marketing[] = [];\n  public marketingFields: Object = {text: \"description\", value: \"code\"};\n  public marketingCode: string;\n  public assemblyCosts: number;\n  public deliveryCosts: number;\n\n  // TODO: Deze velden nog opnemen in Transaction!!\n  public deliveryDateFinal: boolean = false;\n  public assemblyDate: Date = new Date();\n  public totalAssemblyTime: string = \"\";\n  public dropshipment: boolean = false;\n\n  public get deliveryDate(): Date {\n    if (this.transaction.transactionInfo.deliveryDate === undefined) {\n      this.transaction.transactionInfo.deliveryDate = new Date();\n    }\n    return this.transaction.transactionInfo.deliveryDate;\n  }\n\n  public set deliveryDate(value: Date) {\n    this.transaction.transactionInfo.deliveryDate = value;\n  }\n\n  public get preferredDeliveryDate(): Date {\n    if (this.transaction.transactionInfo.preferredDeliveryDate === undefined) {\n      this.transaction.transactionInfo.preferredDeliveryDate = new Date();\n    }\n    return this.transaction.transactionInfo.preferredDeliveryDate;\n  }\n\n  public set preferredDeliveryDate(value: Date) {\n    this.transaction.transactionInfo.preferredDeliveryDate = value;\n  }\n\n  constructor(\n    private _dictionaryService: DictionaryService,\n    private _formMasterService: FormMasterService,\n    private _boFactory: BusinessObjectFactory,\n    public service: TransactionService,\n    public iconService: IconCacheService\n  ) {\n  }\n\n  public async ngOnInit(): Promise<void> {\n    this.deliveryCosts = this.calculateDeliveryCosts();\n    this.assemblyCosts = this.calculateAssemblyCosts();\n    this.service.getDeliveryMethods().then((methods: DeliveryMethod[]) => {\n      this.deliveryMethods = methods.filter(m => m.webshop);\n    });\n    this.service.getDeliveryOptions().then((options: DeliveryOption[]) => {\n      this.deliveryOptionList = options;\n    });\n    this.service.getMarketingCodes().then((marketingCodes: Marketing[]) => {\n      this.marketing = marketingCodes;\n    });\n  }\n\n  public submit(): boolean {\n    return this._formMasterService.submitSlaves();\n  }\n\n  public async handleDeliveryMethodChange(deliveryMethod: DeliveryMethod): Promise<void> {\n    this.service.updateHeaderTransactionDeliveryMethod(this.service.currentTransaction.transactionInfo.uuid, deliveryMethod.code).then(() => {\n      this.deliveryOptions = this.selectDeliveryOptionsByDeliveryMethod(deliveryMethod);\n    });\n    // this.transaction.transactionLines.forEach((tl: TransactionLineInfo) => {\n    //   tl.deliveryMethodCode = deliveryMethod.code;\n    // })\n    // if (deliveryMethod) {\n    //   this.deliveryOptions = this.selectDeliveryOptionsByDeliveryMethod(deliveryMethod);\n    // }\n  }\n\n  public setIndexDeliveryType(idx: number): void {\n    this.deliveryTypeIdx = idx;\n    // this.selectAddress(this.relation.addresses[idx]);\n  }\n\n  public selectDeliveryOptionsByDeliveryMethod(deliveryMethod: DeliveryMethod): DeliveryOption[] {\n    return this.deliveryOptionList.filter(deliveryOption => deliveryMethod.deliveryOptions.indexOf(deliveryOption.code) !== -1);\n  }\n\n  public selectDeliveryMethodById(deliveryMethodId: string): DeliveryMethod {\n    return this.deliveryMethods.find(delivery => delivery.code === deliveryMethodId);\n  }\n\n  public isDeliveryOptionChecked(deliveryOptionItem: DeliveryOption): boolean {\n    return (this.transaction.transactionInfo.deliveryOptions.indexOf(deliveryOptionItem.code, 0) === 0);\n  }\n\n  public changePreferredDeliveryDate2(preferredDateOption: string): void {\n    this.transaction.transactionInfo.preferredDeliveryDate2 = preferredDateOption;\n  }\n\n  public onMarketingCodeChange(marketingCode: string): void {\n    this.transaction.transactionInfo.marketingCode = marketingCode;\n  }\n\n  public onChangeLocationCancelClick(): void {\n    this.changeLocationPopup = false;\n  }\n\n  public async handleTransactionDefinitive(definitive: boolean): Promise<void> {\n    const success: boolean = await this.service.updateHeaderTransactionDefinitive(this.transaction.transactionInfo.uuid, definitive);\n    if (!success) {\n      this.transactionDefinitive = !definitive;\n    }\n  }\n\n  private calculateDeliveryCosts(): number {\n    return 0;\n  }\n\n  private calculateAssemblyCosts(): number {\n    return 0;\n  }\n}\n"]}

package/esm2015/lib/component/checkout/checkout-overview-payment/checkout-overview-payment.component.js

@@ -1,8 +1,10 @@
 import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
 import { Icon } from "../../../enum/icon.enum";
 import { Address } from "@colijnit/transactionapi/build/model/address.bo";
+import { TransactionService } from "../../../service/transaction.service";
 export class CheckoutOverviewPaymentComponent {
-    constructor() {
+    constructor(_transactionService) {
+        this._transactionService = _transactionService;
         this.icons = Icon;
         this.changeYourDataClick = new EventEmitter();
         this.changeDeliveryClick = new EventEmitter();
@@ -25,6 +27,11 @@ export class CheckoutOverviewPaymentComponent {
             }
         }
     }
+    handlePayed() {
+        const id = this._transactionService.currentTransaction.transactionInfo.id;
+        this._transactionService.currentTransaction = undefined;
+        this.payed.emit(id);
+    }
 }
 CheckoutOverviewPaymentComponent.decorators = [
     { type: Component, args: [{
@@ -75,12 +82,15 @@ CheckoutOverviewPaymentComponent.decorators = [
       [transactionUuid]="transaction.transactionInfo.uuid"
       [amount]="transaction.transactionTotal.netAmount"
       [currencyId]="transaction.transactionInfo.currencyId"
-      (payed)="payed.emit()"
+      (payed)="handlePayed()"
     ></co-payment>
   `,
                 encapsulation: ViewEncapsulation.None
             },] }
 ];
+CheckoutOverviewPaymentComponent.ctorParameters = () => [
+    { type: TransactionService }
+];
 CheckoutOverviewPaymentComponent.propDecorators = {
     transaction: [{ type: Input }],
     relation: [{ type: Input }],
@@ -89,4 +99,4 @@ CheckoutOverviewPaymentComponent.propDecorators = {
     payed: [{ type: Output }],
     showClass: [{ type: HostBinding, args: ["class.co-checkout-overview-payment",] }]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout-overview-payment.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/checkout/checkout-overview-payment/checkout-overview-payment.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAU,MAAM,EAAE,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAE7G,OAAO,EAAC,IAAI,EAAC,MAAM,yBAAyB,CAAC;AAE7C,OAAO,EAAC,OAAO,EAAC,MAAM,iDAAiD,CAAC;AAuDxE,MAAM,OAAO,gCAAgC;IArD7C;QAsDkB,UAAK,GAAgB,IAAI,CAAC;QASnC,wBAAmB,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAGnE,wBAAmB,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAGnE,UAAK,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAOrD,oBAAe,GAAY,IAAI,OAAO,EAAE,CAAC;QACzC,mBAAc,GAAY,IAAI,OAAO,EAAE,CAAC;IAcjD,CAAC;IAnBQ,SAAS;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAKD,QAAQ;QACN,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,MAAM,UAAU,GAAY,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC;YAC/H,IAAI,UAAU,EAAE;gBACd,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC;aACnC;YACD,MAAM,UAAU,GAAY,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;YAC3H,IAAI,UAAU,EAAE;gBACd,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC;aAClC;SACF;IACH,CAAC;;;YA1FF,SAAS,SAAC;gBACT,QAAQ,EAAE,8BAA8B;gBACxC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDT;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;aACtC;;;0BAIE,KAAK;uBAGL,KAAK;kCAGL,MAAM;kCAGN,MAAM;oBAGN,MAAM;wBAGN,WAAW,SAAC,oCAAoC","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from \"@angular/core\";\r\nimport {TransactionInfoResponse} from \"@colijnit/transactionapi/build/model/transaction-info-response.bo\";\r\nimport {Icon} from \"../../../enum/icon.enum\";\r\nimport {RelationAnyType} from \"@colijnit/transactionapi/build/model/relation-any-type\";\r\nimport {Address} from \"@colijnit/transactionapi/build/model/address.bo\";\r\n\r\n@Component({\r\n  selector: \"co-checkout-overview-payment\",\r\n  template: `\r\n    <div class=\"checkout-overview-section\">\r\n      <span class=\"overview-section-title\" [textContent]=\"'YOUR_DATA' | localize\"></span>\r\n      <div class=\"two-column-grid\">\r\n        <div class=\"overview-address\">\r\n            <span class=\"overview-address-title\" [textContent]=\"'DELIVERY_ADDRESS' | localize\"></span>\r\n            <span [textContent]=\"relation.displayName\"></span>\r\n            <span [textContent]=\"deliveryAddress.displayAddress\"></span>\r\n            <span [textContent]=\"deliveryAddress.displayPostal\"></span>\r\n        </div>\r\n        <div class=\"overview-address\">\r\n          <span class=\"overview-address-title\" [textContent]=\"'INVOICE_ADDRESS' | localize\"></span>\r\n          <span [textContent]=\"relation.displayName\"></span>\r\n          <span [textContent]=\"invoiceAddress.displayAddress\"></span>\r\n          <span [textContent]=\"invoiceAddress.displayPostal\"></span>\r\n        </div>\r\n      </div>\r\n      <div class=\"overview-address\">\r\n        <span class=\"overview-address-title\" [textContent]=\"'CONTACT_DETAILS' | localize\"></span>\r\n        <span [textContent]=\"relation.primaryEmail\"></span>\r\n        <span [textContent]=\"relation.primaryPhoneNumber\"></span>\r\n      </div>\r\n      <div class=\"overview-section-change-link\">\r\n        <icon class=\"overview-section-change-icon\" [icon]=\"icons.ArrowPointRight\"></icon>\r\n        <div [textContent]=\"'CHANGE_DATA' | localize\" (click)=\"changeYourDataClick.emit()\"></div>\r\n      </div>\r\n    </div>\r\n    <div class=\"checkout-overview-section\">\r\n      <span class=\"overview-section-title\" [textContent]=\"'DELIVERY' | localize\"></span>\r\n      <div class=\"overview-address\">\r\n        <div class=\"overview-row\">\r\n            <span [textContent]=\"'EXPECTED_DELIVERY_DATE' | localize | append:':'\"></span><span [textContent]=\"transaction.transactionInfo.deliveryDate | date:'dd MMM yyyy'\"></span>\r\n        </div>\r\n        <div class=\"overview-row\">\r\n            <span [textContent]=\"'DELIVERY_METHOD' | localize | append:':'\"></span><span [textContent]=\"transaction.transactionInfo.deliveryMethod\"></span>\r\n        </div>\r\n      </div>\r\n      <div class=\"overview-section-change-link\">\r\n        <icon class=\"overview-section-change-icon\" [icon]=\"icons.ArrowPointRight\"></icon>\r\n        <div [textContent]=\"'CHANGE_DATA' | localize\" (click)=\"changeDeliveryClick.emit()\"></div>\r\n      </div>\r\n    </div>\r\n    <co-payment\r\n      [transactionUuid]=\"transaction.transactionInfo.uuid\"\r\n      [amount]=\"transaction.transactionTotal.netAmount\"\r\n      [currencyId]=\"transaction.transactionInfo.currencyId\"\r\n      (payed)=\"payed.emit()\"\r\n    ></co-payment>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class CheckoutOverviewPaymentComponent implements OnInit {\r\n  public readonly icons: typeof Icon = Icon;\r\n\r\n  @Input()\r\n  public transaction: TransactionInfoResponse;\r\n\r\n  @Input()\r\n  public relation: RelationAnyType;\r\n\r\n  @Output()\r\n  public changeYourDataClick: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @Output()\r\n  public changeDeliveryClick: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @Output()\r\n  public payed: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @HostBinding(\"class.co-checkout-overview-payment\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public deliveryAddress: Address = new Address();\r\n  public invoiceAddress: Address = new Address();\r\n\r\n  ngOnInit(): void {\r\n    if (this.relation) {\r\n      const delAddress: Address = this.relation.addresses.find(a => a.nawNr === this.transaction.transactionInfo.transactionAddress);\r\n      if (delAddress) {\r\n        this.deliveryAddress = delAddress;\r\n      }\r\n      const invAddress: Address = this.relation.addresses.find(a => a.nawNr === this.transaction.transactionInfo.invoiceAddress);\r\n      if (invAddress) {\r\n        this.invoiceAddress = invAddress;\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout-overview-payment.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/checkout/checkout-overview-payment/checkout-overview-payment.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAU,MAAM,EAAE,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAE7G,OAAO,EAAC,IAAI,EAAC,MAAM,yBAAyB,CAAC;AAE7C,OAAO,EAAC,OAAO,EAAC,MAAM,iDAAiD,CAAC;AACxE,OAAO,EAAC,kBAAkB,EAAC,MAAM,sCAAsC,CAAC;AAuDxE,MAAM,OAAO,gCAAgC;IA0B3C,YAAoB,mBAAuC;QAAvC,wBAAmB,GAAnB,mBAAmB,CAAoB;QAzB3C,UAAK,GAAgB,IAAI,CAAC;QASnC,wBAAmB,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAGnE,wBAAmB,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAGnE,UAAK,GAAyB,IAAI,YAAY,EAAU,CAAC;QAOzD,oBAAe,GAAY,IAAI,OAAO,EAAE,CAAC;QACzC,mBAAc,GAAY,IAAI,OAAO,EAAE,CAAC;IAG/C,CAAC;IARM,SAAS;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAQD,QAAQ;QACN,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,MAAM,UAAU,GAAY,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC;YAC/H,IAAI,UAAU,EAAE;gBACd,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC;aACnC;YACD,MAAM,UAAU,GAAY,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;YAC3H,IAAI,UAAU,EAAE;gBACd,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC;aAClC;SACF;IACH,CAAC;IAEM,WAAW;QAChB,MAAM,EAAE,GAAW,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,eAAe,CAAC,EAAE,CAAC;QAClF,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,GAAG,SAAS,CAAC;QACxD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACtB,CAAC;;;YAnGF,SAAS,SAAC;gBACT,QAAQ,EAAE,8BAA8B;gBACxC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDT;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;aACtC;;;YAtDO,kBAAkB;;;0BA0DvB,KAAK;uBAGL,KAAK;kCAGL,MAAM;kCAGN,MAAM;oBAGN,MAAM;wBAGN,WAAW,SAAC,oCAAoC","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from \"@angular/core\";\r\nimport {TransactionInfoResponse} from \"@colijnit/transactionapi/build/model/transaction-info-response.bo\";\r\nimport {Icon} from \"../../../enum/icon.enum\";\r\nimport {RelationAnyType} from \"@colijnit/transactionapi/build/model/relation-any-type\";\r\nimport {Address} from \"@colijnit/transactionapi/build/model/address.bo\";\r\nimport {TransactionService} from \"../../../service/transaction.service\";\r\n\r\n@Component({\r\n  selector: \"co-checkout-overview-payment\",\r\n  template: `\r\n    <div class=\"checkout-overview-section\">\r\n      <span class=\"overview-section-title\" [textContent]=\"'YOUR_DATA' | localize\"></span>\r\n      <div class=\"two-column-grid\">\r\n        <div class=\"overview-address\">\r\n            <span class=\"overview-address-title\" [textContent]=\"'DELIVERY_ADDRESS' | localize\"></span>\r\n            <span [textContent]=\"relation.displayName\"></span>\r\n            <span [textContent]=\"deliveryAddress.displayAddress\"></span>\r\n            <span [textContent]=\"deliveryAddress.displayPostal\"></span>\r\n        </div>\r\n        <div class=\"overview-address\">\r\n          <span class=\"overview-address-title\" [textContent]=\"'INVOICE_ADDRESS' | localize\"></span>\r\n          <span [textContent]=\"relation.displayName\"></span>\r\n          <span [textContent]=\"invoiceAddress.displayAddress\"></span>\r\n          <span [textContent]=\"invoiceAddress.displayPostal\"></span>\r\n        </div>\r\n      </div>\r\n      <div class=\"overview-address\">\r\n        <span class=\"overview-address-title\" [textContent]=\"'CONTACT_DETAILS' | localize\"></span>\r\n        <span [textContent]=\"relation.primaryEmail\"></span>\r\n        <span [textContent]=\"relation.primaryPhoneNumber\"></span>\r\n      </div>\r\n      <div class=\"overview-section-change-link\">\r\n        <icon class=\"overview-section-change-icon\" [icon]=\"icons.ArrowPointRight\"></icon>\r\n        <div [textContent]=\"'CHANGE_DATA' | localize\" (click)=\"changeYourDataClick.emit()\"></div>\r\n      </div>\r\n    </div>\r\n    <div class=\"checkout-overview-section\">\r\n      <span class=\"overview-section-title\" [textContent]=\"'DELIVERY' | localize\"></span>\r\n      <div class=\"overview-address\">\r\n        <div class=\"overview-row\">\r\n            <span [textContent]=\"'EXPECTED_DELIVERY_DATE' | localize | append:':'\"></span><span [textContent]=\"transaction.transactionInfo.deliveryDate | date:'dd MMM yyyy'\"></span>\r\n        </div>\r\n        <div class=\"overview-row\">\r\n            <span [textContent]=\"'DELIVERY_METHOD' | localize | append:':'\"></span><span [textContent]=\"transaction.transactionInfo.deliveryMethod\"></span>\r\n        </div>\r\n      </div>\r\n      <div class=\"overview-section-change-link\">\r\n        <icon class=\"overview-section-change-icon\" [icon]=\"icons.ArrowPointRight\"></icon>\r\n        <div [textContent]=\"'CHANGE_DATA' | localize\" (click)=\"changeDeliveryClick.emit()\"></div>\r\n      </div>\r\n    </div>\r\n    <co-payment\r\n      [transactionUuid]=\"transaction.transactionInfo.uuid\"\r\n      [amount]=\"transaction.transactionTotal.netAmount\"\r\n      [currencyId]=\"transaction.transactionInfo.currencyId\"\r\n      (payed)=\"handlePayed()\"\r\n    ></co-payment>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class CheckoutOverviewPaymentComponent implements OnInit {\r\n  public readonly icons: typeof Icon = Icon;\r\n\r\n  @Input()\r\n  public transaction: TransactionInfoResponse;\r\n\r\n  @Input()\r\n  public relation: RelationAnyType;\r\n\r\n  @Output()\r\n  public changeYourDataClick: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @Output()\r\n  public changeDeliveryClick: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @Output()\r\n  public payed: EventEmitter<number> = new EventEmitter<number>();\r\n\r\n  @HostBinding(\"class.co-checkout-overview-payment\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public deliveryAddress: Address = new Address();\r\n  public invoiceAddress: Address = new Address();\r\n\r\n  constructor(private _transactionService: TransactionService) {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    if (this.relation) {\r\n      const delAddress: Address = this.relation.addresses.find(a => a.nawNr === this.transaction.transactionInfo.transactionAddress);\r\n      if (delAddress) {\r\n        this.deliveryAddress = delAddress;\r\n      }\r\n      const invAddress: Address = this.relation.addresses.find(a => a.nawNr === this.transaction.transactionInfo.invoiceAddress);\r\n      if (invAddress) {\r\n        this.invoiceAddress = invAddress;\r\n      }\r\n    }\r\n  }\r\n\r\n  public handlePayed(): void {\r\n    const id: number = this._transactionService.currentTransaction.transactionInfo.id;\r\n    this._transactionService.currentTransaction = undefined;\r\n    this.payed.emit(id);\r\n  }\r\n}\r\n"]}