@pmcretail/mapper-library 0.0.39 → 0.0.43

package/fesm2022/pmcretail-mapper-library.mjs

@@ -0,0 +1,3482 @@
+import * as i0 from '@angular/core';
+import { Component, NgModule, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i1 from '@angular/common';
+
+class MapperLibraryComponent {
+    constructor() { }
+    ngOnInit() {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MapperLibraryComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.4", type: MapperLibraryComponent, selector: "lib-mapper-library", ngImport: i0, template: `
+    <p>
+      mapper-library works!
+    </p>
+  `, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MapperLibraryComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-mapper-library', template: `
+    <p>
+      mapper-library works!
+    </p>
+  ` }]
+        }], ctorParameters: () => [] });
+
+class MapperLibraryModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MapperLibraryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.4", ngImport: i0, type: MapperLibraryModule, declarations: [MapperLibraryComponent], exports: [MapperLibraryComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MapperLibraryModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MapperLibraryModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        MapperLibraryComponent
+                    ],
+                    imports: [],
+                    exports: [
+                        MapperLibraryComponent
+                    ]
+                }]
+        }] });
+
+var TRANSACTION_TYPE;
+(function (TRANSACTION_TYPE) {
+    TRANSACTION_TYPE["SALE"] = "SALE";
+    TRANSACTION_TYPE["REFUND"] = "REFUND";
+    TRANSACTION_TYPE["SALE_REFUND"] = "SALE_REFUND";
+    TRANSACTION_TYPE["SALE_EXCHANGE"] = "SALE_EXCHANGE";
+    TRANSACTION_TYPE["VOID"] = "VOID";
+    TRANSACTION_TYPE["WEB_RETURNS"] = "WEB_RETURNS";
+})(TRANSACTION_TYPE || (TRANSACTION_TYPE = {}));
+var DELIVERY_METHODS;
+(function (DELIVERY_METHODS) {
+    DELIVERY_METHODS[DELIVERY_METHODS["DELIVERY"] = 1] = "DELIVERY";
+    DELIVERY_METHODS[DELIVERY_METHODS["DROP_SHIP"] = 2] = "DROP_SHIP";
+    DELIVERY_METHODS[DELIVERY_METHODS["COLLECT_FROM_STORE"] = 3] = "COLLECT_FROM_STORE";
+    DELIVERY_METHODS[DELIVERY_METHODS["SHIP_TO_STORE"] = 4] = "SHIP_TO_STORE";
+})(DELIVERY_METHODS || (DELIVERY_METHODS = {}));
+var DISCOUNTTYPE;
+(function (DISCOUNTTYPE) {
+    DISCOUNTTYPE["PERCENT"] = "Percent";
+    DISCOUNTTYPE["AMOUNT"] = "AMOUNT";
+})(DISCOUNTTYPE || (DISCOUNTTYPE = {}));
+var INITIATING_MODULE;
+(function (INITIATING_MODULE) {
+    INITIATING_MODULE["EBASKET"] = "eBasket";
+})(INITIATING_MODULE || (INITIATING_MODULE = {}));
+var PROVIDERS;
+(function (PROVIDERS) {
+    PROVIDERS["SALESFORCE"] = "Salesforce";
+})(PROVIDERS || (PROVIDERS = {}));
+var PROMOTION_LEVEL;
+(function (PROMOTION_LEVEL) {
+    PROMOTION_LEVEL["LINE"] = "LINE";
+    PROMOTION_LEVEL["TRANSACTION"] = "TRANSACTION";
+})(PROMOTION_LEVEL || (PROMOTION_LEVEL = {}));
+var PROMOTION_TYPE;
+(function (PROMOTION_TYPE) {
+    PROMOTION_TYPE["COUPON"] = "COUPON";
+})(PROMOTION_TYPE || (PROMOTION_TYPE = {}));
+
+class BasketService {
+    get isMixedBasketSales() {
+        return this._isMixedBasketSales;
+    }
+    set isMixedBasketSales(v) {
+        this._isMixedBasketSales = v;
+    }
+    constructor(numberUtilService) {
+        this.numberUtilService = numberUtilService;
+        this.currentBasket = {
+            products: [],
+            transactionDiscount: [],
+            quantity: 0,
+            total: 0,
+            saleTotal: 0,
+            baseCurrency: ''
+        };
+        this.basketSource = new BehaviorSubject(null);
+        this.basket = this.basketSource.asObservable();
+        this.productSource = new BehaviorSubject(null);
+        this.product = this.productSource.asObservable();
+        this.peerSource = new BehaviorSubject(false);
+        this.peerSync = this.peerSource.asObservable();
+        this.scanSource = new BehaviorSubject(false);
+        this.scanner = this.scanSource.asObservable();
+    }
+    updateBasket(basket) {
+        this.currentBasket = basket;
+        this.isMixedBasketSales = this.filterProductListWithWebOrder(true).length > 0;
+        this.basketSource.next(basket);
+    }
+    /**
+     * calculates the total basket value and quantity
+     * @param  null
+     * @returns void
+     */
+    updateBasketTotal(basketDetails, basketState) {
+        basketDetails.quantity = 0;
+        basketDetails.total = 0;
+        for (const p of basketDetails.products) {
+            basketDetails.quantity = basketDetails.quantity + p.quantity;
+            basketDetails.total =
+                this.numberUtilService.trimTo2Decimal(basketDetails.total) +
+                    this.numberUtilService.trimTo2Decimal(p.total);
+        }
+        console.log("e:basket :basket service : basketDetails updated values for transaction id", basketDetails.transactionId, JSON.stringify(basketDetails));
+        basketDetails.basketTotal = basketDetails.total;
+        basketState.updateBasket(basketDetails);
+    }
+    /**
+     * add Line promotion
+     * @param  null
+     * @returns basketDetails
+     */
+    addlinePromotion(promotionList, basketDetails) {
+        console.log("e:basket :basket Service : promotionList and basketDetails for linePromotions", JSON.stringify(promotionList), JSON.stringify(basketDetails));
+        if (promotionList &&
+            promotionList.result &&
+            promotionList.result.linePromotions &&
+            promotionList.result.linePromotions.length > 0) {
+            for (var element of basketDetails.products) {
+                for (var promotionelement of promotionList.result.linePromotions) {
+                    if (element.itemLineId.toString() ===
+                        promotionelement.itemLineId.toString()) {
+                        element.linePromotions = promotionelement;
+                    }
+                }
+            }
+        }
+        return basketDetails;
+    }
+    /**
+     * add Transaction promotion
+     * @param  null
+     * @returns basketDetails
+     */
+    addTransactionPromotion(promotionList, basketdetails) {
+        console.log("e:basket :basket Service : promotionList and basketDetails for transactionPromotion", JSON.stringify(promotionList), JSON.stringify(basketdetails), JSON.stringify(basketdetails.transactionPromotion));
+        if (promotionList &&
+            promotionList.result &&
+            promotionList.result.transactionPromotion &&
+            promotionList.result.transactionPromotion.length > 0) {
+            promotionList.result.transactionPromotion.forEach((tPromotion) => {
+                let transactionPromotionEntryUpdated = Object.assign({}, tPromotion);
+                transactionPromotionEntryUpdated.itemLineIds = basketdetails.products.map((product) => {
+                    return product.itemLineId;
+                });
+                if (!basketdetails.transactionPromotion) {
+                    basketdetails.transactionPromotion = [];
+                }
+                basketdetails.transactionPromotion.push(transactionPromotionEntryUpdated);
+                basketdetails = this.transactionPromotionProductPortionCalc(basketdetails, transactionPromotionEntryUpdated);
+            });
+        }
+        console.log("basket details in refund calculation file", JSON.stringify(basketdetails));
+        return basketdetails;
+    }
+    updateProductTotalForSummary(basketDetails) {
+        /*sale-            product refundedQuantity = undefined
+        partial refund -   product refundedQuantity is > 0
+        total refund -     proudct refundedQuantity is > 0
+        exchange -         exchange product refundedQuantity is > 0
+                           new product refundedQuantity = undefined
+                           old product without exchange refundedQuantity = 0
+        unreference refund-product refundedQuantity is > 0 */
+        basketDetails.total = 0;
+        basketDetails.quantity = 0;
+        for (var product of basketDetails.products) {
+            if (product.linePromotions) {
+                product.total = product.linePromotions.promotionLinePrice;
+            }
+            else if (product.lineDiscount && !product.linePromotions) {
+                product.total = product.lineDiscount.discountedLinePrice;
+            }
+            else {
+                product.total = product.totalLinePrice;
+            }
+            product.total =
+                product.total -
+                    Math.abs(product.refundedTotal ? product.refundedTotal : 0);
+            basketDetails.total += product.total;
+            basketDetails.quantity =
+                basketDetails.quantity +
+                    (product.quantity -
+                        (product.refundedQuantity ? product.refundedQuantity : 0));
+            console.log("e-basket:ExchangeSummaryScreen:update basketdetails total :" +
+                basketDetails.total +
+                " Product line ID : " +
+                product.itemLineId +
+                " product total : " +
+                product.total, "quantity  : " + basketDetails.quantity);
+        }
+        return this.updateBasketTotalForSummary(basketDetails);
+    }
+    updateBasketTotalForSummary(basketDetails) {
+        basketDetails.basketTotal = basketDetails.total;
+        console.info("ebasket : basket Service : update Basket Total for transaction transactionDiscount  ", JSON.stringify(basketDetails.transactionDiscount));
+        console.info("ebasket : basket Service : update Basket Total for transaction transactionPromotion  ", JSON.stringify(basketDetails.transactionPromotion));
+        basketDetails = this.updateTransactionPromotion(basketDetails);
+        basketDetails = this.updateTransactionDiscount(basketDetails);
+        basketDetails.basketTotal = Number(basketDetails.basketTotal.toFixed(2));
+        console.info("ebasket : basket Service : update Basket Total: basketTotal after promotion applied  for basketTotal", basketDetails.basketTotal);
+        return basketDetails;
+    }
+    updateTransactionDiscount(basketDetails) {
+        if (basketDetails.transactionDiscount &&
+            basketDetails.transactionDiscount.length > 0) {
+            const discountTotal = basketDetails.transactionDiscount.reduce((n, { discountAmount }) => n + discountAmount, 0);
+            console.log("ebasket : basket Service :  discountTotal ", discountTotal);
+            basketDetails.basketTotal =
+                basketDetails.basketTotal - Math.abs(discountTotal);
+        }
+        return basketDetails;
+    }
+    updateTransactionPromotion(basketDetails) {
+        if (basketDetails.transactionPromotion &&
+            basketDetails.transactionPromotion.length > 0) {
+            const discountTotal = basketDetails.transactionPromotion.reduce((n, { promotionAmount }) => n + promotionAmount, 0);
+            basketDetails.basketTotal =
+                basketDetails.basketTotal - Math.abs(discountTotal);
+        }
+        return basketDetails;
+    }
+    updateBasketTotalWithoutDiscount(basket) {
+        basket.total = 0;
+        basket.quantity = 0;
+        for (var product of basket.products) {
+            if (product.linePromotions) {
+                product.total = product.linePromotions.promotionLinePrice;
+            }
+            else if (product.lineDiscount && !product.linePromotions) {
+                product.total = product.lineDiscount.discountedLinePrice || 0;
+            }
+            else {
+                product.total = product.totalLinePrice;
+            }
+            product.total =
+                product.total -
+                    Math.abs(product.refundedTotal ? product.refundedTotal : 0);
+            basket.total += product.total;
+            basket.quantity =
+                basket.quantity +
+                    (product.quantity -
+                        (product.refundedQuantity ? product.refundedQuantity : 0));
+            console.log("e-basket:basket service:update basketdetails total :" +
+                JSON.stringify(basket) +
+                basket.total +
+                " Product line ID : " +
+                product.itemLineId +
+                " product total : " +
+                product.total);
+        }
+        basket.basketTotal = basket.total;
+        return basket;
+    }
+    updateBasketTotalWithDiscounts(basket) {
+        console.log("e:basket :RefundBasketScreen : this.basketDetails new values", basket, JSON.stringify(basket.basketTotal));
+        if (basket.transactionPromotion && basket.transactionPromotion.length > 0) {
+            const discountTotal = basket.transactionPromotion.reduce((n, { promotionAmount }) => n + promotionAmount, 0);
+            basket.basketTotal = basket.basketTotal - discountTotal;
+        }
+        if (basket.transactionDiscount && basket.transactionDiscount.length > 0) {
+            const discountTotal = basket.transactionDiscount.reduce((n, { discountAmount }) => n + discountAmount, 0);
+            basket.basketTotal = basket.basketTotal - discountTotal;
+        }
+        console.log("e:basket :RefundBasketScreen : basket new values", JSON.stringify(basket));
+        return basket;
+    }
+    transactionDiscountAndPromotionProductortionCalculation(basket) {
+        if (basket.transactionDiscount && basket.transactionDiscount.length > 0) {
+            basket.transactionDiscount.forEach((discount) => (basket = this.transactionDiscountProductPortionCalc(basket, discount)));
+        }
+        if (basket.transactionPromotion && basket.transactionPromotion.length > 0) {
+            basket.transactionPromotion.forEach((promotion) => {
+                basket = this.transactionPromotionProductPortionCalc(basket, promotion);
+            });
+        }
+        console.log("ebasket: basket item discount protion calculation", basket, basket.products);
+        return basket;
+    }
+    transactionPromotionProductPortionCalc(basket, promotion) {
+        let total = 0;
+        let percentage = 0;
+        {
+            basket.products.forEach((p) => {
+                if (promotion.itemLineIds.includes(p.itemLineId)) {
+                    p = this.validateProductItemDiscount(p);
+                    const productContributionInTotal = this.numberUtilService.trimTo2Decimal2(p.itemDiscounts.trnDiscountsPortion) +
+                        this.numberUtilService.trimTo2Decimal2(p.itemDiscounts.trnPromotionsPortion) -
+                        this.numberUtilService.trimTo2Decimal2(p.itemDiscounts.refundPortion);
+                    total += (p.total - this.numberUtilService.trimTo2Decimal2(productContributionInTotal));
+                }
+            });
+            console.log(`ebasket: trnsactionPromotion: ${JSON.stringify(promotion)}, selected products total: ${total}`);
+            basket.products.forEach((product) => {
+                product = this.validateProductItemDiscount(product);
+                const productContributionInTotal = this.numberUtilService.trimTo2Decimal2(product.itemDiscounts.trnDiscountsPortion) +
+                    this.numberUtilService.trimTo2Decimal2(product.itemDiscounts.trnPromotionsPortion) -
+                    this.numberUtilService.trimTo2Decimal2(product.itemDiscounts.refundPortion);
+                if (promotion.itemLineIds.includes(product.itemLineId)) {
+                    percentage = ((product.total - this.numberUtilService.trimTo2Decimal2(productContributionInTotal)) / total) * 100;
+                    product.itemDiscounts.trnPromotionsPortion +=
+                        (promotion.promotionAmount * percentage) / 100;
+                    product.itemDiscounts.trnPromotionsPortion = this.numberUtilService.trimTo2Decimal2(product.itemDiscounts.trnPromotionsPortion);
+                }
+            });
+        }
+        return basket;
+    }
+    transactionDiscountProductPortionCalc(basket, discount) {
+        let total = 0;
+        let percentage = 0;
+        basket.products.forEach((p) => {
+            if (discount.itemLineIds.includes(p.itemLineId)) {
+                p = this.validateProductItemDiscount(p);
+                const productContributionInTotal = this.numberUtilService.trimTo2Decimal2(p.itemDiscounts.trnDiscountsPortion) +
+                    this.numberUtilService.trimTo2Decimal2(p.itemDiscounts.trnPromotionsPortion) -
+                    this.numberUtilService.trimTo2Decimal2(p.itemDiscounts.refundPortion);
+                total += (p.total - this.numberUtilService.trimTo2Decimal2(productContributionInTotal));
+            }
+        });
+        console.log(`ebasket: trnsactionDiscount: ${JSON.stringify(discount)}, selected products total: ${total}`);
+        basket.products.forEach((product) => {
+            product = this.validateProductItemDiscount(product);
+            console.log(product.discountable, "ebasket : basket service : discountable in basket service");
+            const productContributionInTotal = this.numberUtilService.trimTo2Decimal2(product.itemDiscounts.trnDiscountsPortion) +
+                this.numberUtilService.trimTo2Decimal2(product.itemDiscounts.trnPromotionsPortion) -
+                this.numberUtilService.trimTo2Decimal2(product.itemDiscounts.refundPortion);
+            if (discount.itemLineIds.includes(product.itemLineId) && product.discountable == true) {
+                percentage = ((product.total - this.numberUtilService.trimTo2Decimal2(productContributionInTotal)) / total) * 100;
+                product.itemDiscounts.trnDiscountsPortion +=
+                    (discount.discountAmount * percentage) / 100;
+                product.itemDiscounts.trnDiscountsPortion = this.numberUtilService.trimTo2Decimal2(product.itemDiscounts.trnDiscountsPortion);
+            }
+        });
+        return basket;
+    }
+    validateProductItemDiscount(product) {
+        if (!product.itemDiscounts) {
+            product.itemDiscounts = {
+                trnDiscountsPortion: 0,
+                trnPromotionsPortion: 0,
+                refundPortion: 0,
+            };
+        }
+        return product;
+    }
+    markProduct(product) {
+        this.productSource.next(product);
+    }
+    stopPeerSyncProcess(peerSync) {
+        this.peerSource.next(peerSync);
+    }
+    scanStart(isScanning) {
+        this.scanSource.next(isScanning);
+    }
+    promotionRemainingCalculation(promotion) {
+        var promotionValue = 0;
+        promotion.forEach((element) => {
+            promotionValue += element.promotionAmount;
+        });
+        return promotionValue;
+    }
+    discountRemainingCalculation(discount) {
+        var discountValue = 0;
+        discount.forEach((element) => {
+            discountValue += element.discountAmount;
+        });
+        return discountValue;
+    }
+    discountRefundedCalculation(discount) {
+        var discountValue = 0;
+        discount.forEach((element) => {
+            if (element.discountAmount < 0) {
+                discountValue += element.discountAmount;
+            }
+        });
+        return discountValue;
+    }
+    generateNewItemLineId(products) {
+        let largestNumber = 0;
+        if (products.length > 0) {
+            let itemLineIdArray = products.map((product) => {
+                return product.itemLineId;
+            });
+            largestNumber = itemLineIdArray.reduce((a, b) => Math.max(a, b));
+        }
+        return largestNumber + 1;
+    }
+    updateBasketProductDataAsPerQuantity(product, quantity) {
+        console.log(`ebasket: updateBasketProductDataAsPerQuantity : ${quantity} product: ${JSON.stringify(product)}`);
+        product.quantity = quantity;
+        if (product.hasOwnProperty("lineDiscount")) {
+            // && this.product.quantity !== this.productDetailForm.controls.quantity.value
+            product.lineDiscount.discountedLinePrice = Number(this.numberUtilService.getFlooredFixed(product.lineDiscount.unitPrice * quantity, 2));
+            product.lineDiscount.discountAmount =
+                product.totalLinePrice - product.lineDiscount.discountedLinePrice;
+        }
+        else {
+            product.totalLinePrice =
+                quantity * this.numberUtilService.trimTo2Decimal(product.selectedPrice);
+        }
+        if (product.lineDiscount) {
+            product.total = product.lineDiscount.discountedLinePrice;
+        }
+        else {
+            product.total = product.totalLinePrice;
+        }
+        console.log(`ebasket: updateBasketProductDataAsPerQuantity : ${quantity} product: ${JSON.stringify(product)}`);
+        return product;
+    }
+    filterProductListWithWebOrder(isWebOrder) {
+        console.log("ebasket: filterProductListWithWebOrder hit", JSON.stringify(this.currentBasket.products));
+        if (isWebOrder)
+            return this.currentBasket.products.filter((x) => x.isWebOrder);
+        else {
+            return this.currentBasket.products.filter((x) => !x.isWebOrder);
+        }
+    }
+    filterProductListWithDelivery() {
+        console.log("ebasket: filterProductListWithDelivery hit", JSON.stringify(this.currentBasket.products));
+        return this.currentBasket.products.filter((x) => x.deliveryMethod === DELIVERY_METHODS.DELIVERY.toString());
+    }
+    filterProductListWithDeliveryGroup(group, products) {
+        console.log("ebasket: filterProductListWithDeliveryGroup hit", JSON.stringify(products));
+        return products.filter((x) => x.deliveryGroup === group);
+    }
+    generateNewDeliveryGroupNumber(products) {
+        let largestNumber = 0;
+        if (products.length > 0) {
+            let deliveryGroupArr = products.map((product) => {
+                if (product.deliveryGroup) {
+                    return parseInt(product.deliveryGroup);
+                }
+                return 0;
+            });
+            largestNumber = deliveryGroupArr.reduce((a, b) => Math.max(a, b));
+        }
+        return (largestNumber + 1).toString();
+    }
+    getDeliveryGroupNumbers(products) {
+        console.log("getDeliveryGroupNumbers initiating : ", JSON.stringify(products));
+        let uniqueAndsortedResult = [];
+        if (products.length > 0) {
+            let deliveryGroupArr = products.map((product) => {
+                if (product.deliveryGroup) {
+                    return parseInt(product.deliveryGroup);
+                }
+                else if (product.deliveryMethod === "1") {
+                    return 1;
+                }
+                return 0;
+            });
+            uniqueAndsortedResult = Array.from(new Set(deliveryGroupArr)).sort((a, b) => a - b);
+            console.log("getDeliveryGroupNumbers : ", JSON.stringify(uniqueAndsortedResult));
+        }
+        return uniqueAndsortedResult;
+    }
+    updateProductsWithNewDeliveryGroupNumber(products) {
+        console.log("updateProductsWithNewDeliveryGroupNumber initiating : ", JSON.stringify(products));
+        let newGroupNumber = this.generateNewDeliveryGroupNumber(this.currentBasket.products);
+        if (products.length > 0) {
+            this.currentBasket.products.forEach(cBProducts => {
+                products.forEach(element => {
+                    if (cBProducts.itemLineId === element.itemLineId) {
+                        cBProducts.deliveryGroup = newGroupNumber;
+                    }
+                });
+            });
+        }
+        this.updateBasket(this.currentBasket);
+        return;
+    }
+    calculateEstimatedTime(products) {
+        try {
+            let time;
+            let estmatedTime = 0;
+            let estimatedDays = "Hours";
+            products.forEach((element) => {
+                if (element.leadTime.type.toLocaleLowerCase() === "weeks") {
+                    time = Number(element.leadTime.value) * 24 * 7;
+                    estmatedTime = Math.max(estmatedTime, time);
+                    estimatedDays = (estmatedTime === time) ? element.leadTime.type : estimatedDays;
+                    console.log("week", estmatedTime, estimatedDays);
+                }
+                else if (element.leadTime.type.toLocaleLowerCase() === "days") {
+                    time = Number(element.leadTime.value) * 24;
+                    estmatedTime = Math.max(estmatedTime, time);
+                    estimatedDays = (estmatedTime === time) ? element.leadTime.type : estimatedDays;
+                    console.log("days", estmatedTime, estimatedDays);
+                }
+                else if (element.leadTime.type.toLocaleLowerCase() === "months") {
+                    time = Number(element.leadTime.value) * 24 * 30;
+                    estmatedTime = Math.max(estmatedTime, time);
+                    estimatedDays = (estmatedTime === time) ? element.leadTime.type : estimatedDays;
+                    console.log("months", estmatedTime, estimatedDays);
+                }
+                else if (element.leadTime.type.toLocaleLowerCase() === "years") {
+                    time = Number(element.leadTime.value) * 24 * 365;
+                    estmatedTime = Math.max(estmatedTime, time);
+                    estimatedDays = (estmatedTime === time) ? element.leadTime.type : estimatedDays;
+                    console.log("years", estmatedTime, estimatedDays);
+                }
+                else {
+                    time = Number(element.leadTime.value);
+                    estmatedTime = Math.max(estmatedTime, time);
+                    estimatedDays = (estmatedTime === time) ? element.leadTime.type : estimatedDays;
+                    console.log("hours", estmatedTime, estimatedDays);
+                }
+            });
+            if (estimatedDays.toLocaleLowerCase() === "days") {
+                estmatedTime = estmatedTime / 24;
+            }
+            else if (estimatedDays.toLocaleLowerCase() === "weeks") {
+                estmatedTime = estmatedTime / (24 * 7);
+            }
+            else if (estimatedDays.toLocaleLowerCase() === "months") {
+                estmatedTime = estmatedTime / (24 * 30);
+            }
+            else if (estimatedDays.toLocaleLowerCase() === "years") {
+                estmatedTime = estmatedTime / (24 * 365);
+            }
+            let estimate = {
+                value: estmatedTime.toString(),
+                type: estimatedDays
+            };
+            return estimate;
+        }
+        catch (error) {
+            console.log("error in calculateEstimatedTime", error);
+        }
+        return 0;
+    }
+    updateProductsWithDeliveryGroupNumber(oldGroup, newGroup) {
+        console.log("updateProductsWithDeliveryGroupNumber initiating");
+        this.currentBasket.products.forEach(cBProducts => {
+            if (cBProducts.deliveryGroup === oldGroup) {
+                cBProducts.deliveryGroup = newGroup;
+            }
+        });
+        this.updateBasket(this.currentBasket);
+        return;
+    }
+    getDeliveryInfo() {
+        console.log("getDeliveryGroupInfor initiating");
+        try {
+            let groupInfo = {
+                groups: []
+            };
+            this.getDeliveryGroupNumbers(this.currentBasket.products).forEach((groupNumber) => {
+                let group = {
+                    groupNumber: groupNumber,
+                    items: [],
+                    estimate: {
+                        type: "Hours",
+                        value: "0"
+                    }
+                };
+                this.currentBasket.products.forEach(cBProducts => {
+                    if (cBProducts.deliveryGroup === groupNumber.toString()) {
+                        group.items.push(cBProducts);
+                    }
+                });
+                group.estimate = this.calculateEstimatedTime(group.items);
+                groupInfo.groups.push(group);
+            });
+            return groupInfo;
+        }
+        catch (error) {
+            console.log("error", error);
+        }
+    }
+}
+
+class NumberUtilService {
+    constructor(cp) {
+        this.cp = cp;
+    }
+    trimTo2Decimal(no) {
+        //return Math.floor(no * 100) / 100;
+        return no;
+    }
+    trimTo2Decimal2(no) {
+        // SEAM-11411 - Had to change 2nd param to 3 to fix rounding issue (FIXME - Needs a new story for refactoring)
+        return Number(this.getFlooredFixed(no, 3));
+    }
+    getFlooredFixed(v, d) {
+        return (Math.floor(v * Math.pow(10, d)) / Math.pow(10, d)).toFixed(d);
+    }
+    AppendWithCurrencySymbol(numValue, currencyCode) {
+        let returnValue = "";
+        if (numValue) {
+            const numb = parseFloat(numValue.toString().replace(',', ''));
+            returnValue = this.cp.transform(Number(numValue).toFixed(2), currencyCode.toLocaleUpperCase(), "symbol");
+            console.log("AppendWithCurrencySymbol :" + returnValue);
+        }
+        else {
+            returnValue = this.cp.transform("0.00", currencyCode.toLocaleUpperCase(), "symbol");
+        }
+        return returnValue;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NumberUtilService, deps: [{ token: i1.CurrencyPipe }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NumberUtilService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NumberUtilService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: () => [{ type: i1.CurrencyPipe }] });
+
+/**
+ * Transaction document builder
+ */
+class TransactionDocumentBuilder {
+    constructor(transactionDoc, currencyPipe, basketService) {
+        this.currencyPipe = currencyPipe;
+        this.basketService = basketService;
+        this.numberUtilService = new NumberUtilService(currencyPipe);
+        this.basketService = new BasketService(this.numberUtilService);
+        this.storeInfo = JSON.parse(localStorage.getItem('storeInfo') || '{}');
+        if (transactionDoc) {
+            this.transactionDocument = transactionDoc;
+        }
+        else {
+            this.transactionDocument = {
+                transactionId: "",
+                offlineTransactionId: "",
+                transactionRef: "",
+                dateTime: "",
+                orgCode: "",
+                storeId: "",
+                storeNodeId: "",
+                storeNodeStructure: "",
+                deviceId: "",
+                terminalId: "",
+                userId: "",
+                initiatingModule: "eBasket",
+                export: false,
+                basket: {},
+                basketSummary: {},
+                baseCurrency: "",
+                type: "",
+                operationStatus: "",
+                createdAt: "",
+                updatedAt: "",
+                id: "",
+                currentTransactionDetails: {},
+                saleTotal: 0,
+            };
+        }
+    }
+    /**
+     * Transactions ref
+     * @returns ref
+     */
+    transactionRef() {
+        const storeDetails = JSON.parse(localStorage.getItem('storeInfo') || '{}');
+        const date = new Date();
+        const random = (((1 + Math.random()) * 0x10000) | 0)
+            .toString(16)
+            .substring(1);
+        this.transactionDocument.transactionRef =
+            storeDetails.orgCode + storeDetails.storeId + date.toISOString() + random;
+        console.log("ebasket: transaction ref created", this.transactionDocument.transactionRef);
+        return this;
+    }
+    /**
+     * Transactions id
+     * @param transactionID
+     * @returns id
+     */
+    transactionId(transactionID, isOnline = true) {
+        if (isOnline) {
+            this.transactionDocument.transactionId = transactionID;
+        }
+        return this;
+    }
+    /**
+     * Transactions id
+     * @param transactionID
+     * @returns id
+     */
+    offlineTransactionId(transactionID, isOnline) {
+        if (!isOnline) {
+            this.transactionDocument.offlineTransactionId = transactionID;
+        }
+        return this;
+    }
+    /**
+    * storeNode Id
+    * @param storeNodeId
+    * @returns id
+    */
+    storeNodeId(storeNodeId) {
+        this.transactionDocument.storeNodeId = storeNodeId;
+        return this;
+    }
+    /**
+  * storeNode structure
+  * @param storeNodeStructure
+  * @returns id
+  */
+    storeNodeStructure(storeNodeStructure) {
+        this.transactionDocument.storeNodeStructure = storeNodeStructure;
+        return this;
+    }
+    /**
+     * Orgs code
+     * @param orgCode
+     * @returns code
+     */
+    orgCode(orgCode) {
+        this.transactionDocument.orgCode = orgCode;
+        return this;
+    }
+    /**
+     * Stores id
+     * @param storeId
+     * @returns id
+     */
+    storeId(storeId) {
+        this.transactionDocument.storeId = storeId;
+        return this;
+    }
+    /**
+     * Dates time
+     * @returns time
+     */
+    dateTime() {
+        const date = new Date();
+        this.transactionDocument.dateTime = date.toISOString();
+        return this;
+    }
+    /**
+     * Devices id
+     * @param deviceId
+     * @returns id
+     */
+    deviceId(deviceId) {
+        this.transactionDocument.deviceId = deviceId;
+        return this;
+    }
+    /**
+       * terminal id
+       * @param terminalId
+       * @returns id
+       */
+    terminalId(terminalId) {
+        this.transactionDocument.terminalId = terminalId;
+        return this;
+    }
+    /**
+      * saleExport
+      * @param saleExport
+      * @returns id
+      */
+    export(saleExport) {
+        this.transactionDocument.export = saleExport;
+        return this;
+    }
+    /*  customer(): TransactionDocumentBuilder {
+      const user = JSON.parse(localStorage.getItem('userDetails'));
+      this.transactionDocument.customer = user;
+      return this;
+    } */
+    /**
+     * Baskets transaction document builder
+     * @param basketDetails
+     * @returns basket
+     */
+    basket(basketDetails) {
+        console.log("ebasket: basket details update in transaction document", JSON.stringify(basketDetails));
+        this.transactionDocument.subsidiaryId = basketDetails.subsidiaryId || (localStorage.getItem('subsidiaryId') || '');
+        this.transactionDocument.basket.products = [];
+        this.transactionDocument.basket.lineDiscount = [];
+        this.transactionDocument.basket.linePromotion = [];
+        this.transactionDocument.basket.transactionPromotion = [];
+        basketDetails.products.forEach((product, index) => {
+            const p = {};
+            p.itemDiscounts = {};
+            p.SKU = product.SKU;
+            p.excludePromotion = product.excludePromotion;
+            p.barCode = product.barcode;
+            p.barcodes = product.barcodes;
+            p.description = product.description;
+            p.itemLineId = product.itemLineId ? product.itemLineId.toString() : "" + (index + 1);
+            p.price = product.selectedPrice;
+            p.quantity = product.quantity;
+            p.totalLinePrice = product.quantity * product.selectedPrice;
+            p.imageUrls = product.imageUrls;
+            p.selectedRRPPrice = product.selectedRRPPrice;
+            //inventory fields
+            p.fullfilmentId = product.fullfilmentId ? product.fullfilmentId : this.storeInfo.storeId;
+            p.fullfilmentLocationName = product.fullfilmentLocationName;
+            p.deliveryGroup = product.deliveryGroup;
+            p.leadTime = product.leadTime;
+            p.deliveryMethod = product.deliveryMethod;
+            p.giftCard = product.giftCard;
+            p.giftCardExpiryDate = product.giftCardExpiryDate;
+            p.giftCardNumberIssued = product.giftCardNumberIssued;
+            p.giftCardRecipientEmail = product.giftCardRecipientEmail;
+            p.giftCardRecipientName = product.giftCardRecipientName;
+            if (product.refundedQuantity > 0) {
+                p.refundedQuantity = product.refundedQuantity;
+                p.refundedPromotionalQuantity = product.refundPromotionalQuantity;
+                p.refunded = product.refunded;
+                p.refundedReasonDescription = product.refundedReasonDescription;
+                p.refundedReason = product.refundedReason;
+                if (!p.refundedReasonDescription) {
+                    p.refundedReasonDescription = p.refundedReason;
+                }
+                p.refundedTotal = product.refundedTotal;
+                p.isLastExchanged = product.isLastExchanged;
+            }
+            if (product.exchange) {
+                p.exchange = product.exchange;
+            }
+            if (product.lineDiscount) {
+                p.lineDiscount = product.lineDiscount;
+            }
+            p.itemDiscounts = product.itemDiscounts;
+            this.transactionDocument.basket.products.push(p);
+            this.lineDiscount(basketDetails);
+        });
+        console.info("ebasket: transactiondocument basket details updated", JSON.stringify(this.transactionDocument.basket));
+        return this;
+    }
+    /**
+       * current transaction Details Total(New Products)
+       * @returns currentTransactionDetails
+       */
+    currentTransactionDetails(basket) {
+        console.log("ebasket: current transaction details for exchanges", basket);
+        this.transactionDocument.currentTransactionDetails.products = [];
+        this.transactionDocument.currentTransactionDetails.linePromotion = [];
+        this.transactionDocument.currentTransactionDetails.lineDiscount = [];
+        this.transactionDocument.currentTransactionDetails.transactionDiscount = [];
+        this.transactionDocument.currentTransactionDetails.products = basket.products;
+        this.transactionDocument.currentTransactionDetails.products = this.transactionDocument.currentTransactionDetails.products.filter((proj) => proj.refundedQuantity != 0);
+        this.transactionDocument.currentTransactionDetails.products.forEach((product) => {
+            if (product.refundedQuantity) {
+                product.quantity = product.refundedQuantity;
+                // updating total line price with actual price to be refunded including the refunding qty
+                product.totalLinePrice = Math.abs(product.refundedTotal);
+                product.total = product.totalLinePrice;
+                if (product.quantity === product.refundedQuantity) {
+                    product.refunded = true;
+                }
+            }
+            //Updating line promotions and line discounts      
+            if (product.linePromotions && !product.refundedQuantity) {
+                this.transactionDocument.currentTransactionDetails.linePromotion.push(product.linePromotions);
+            }
+            if (product.lineDiscount && !product.refundedQuantity) {
+                this.transactionDocument.currentTransactionDetails.lineDiscount.push(product.lineDiscount);
+            }
+        });
+        console.log("ebasket: current transaction details after removing old products", this.transactionDocument.currentTransactionDetails.products);
+        if (basket.transactionDiscount && basket.transactionDiscount.length > 0) {
+            this.transactionDocument.currentTransactionDetails.transactionDiscount.push(...basket.transactionDiscount);
+        }
+        this.transactionDocument.currentTransactionDetails.basketSummary = {};
+        this.transactionDocument.currentTransactionDetails.basketSummary.saleTotal = this.numberUtilService.trimTo2Decimal2(this.updateSaleTotal(this.transactionDocument.currentTransactionDetails));
+        this.transactionDocument.currentTransactionDetails.basketSummary.totalItems = basket.quantity;
+        this.transactionDocument.currentTransactionDetails.basketSummary.basketTotal = basket.basketTotal;
+        this.transactionDocument.currentTransactionDetails.basketSummary.refundTotal = this.updateCurrentTransactionDetailsRefundTotal();
+        // For partial refund discount is updatied in total line price so discountTotal will always be zero & in case of exchange discount total is calculated
+        if (this.transactionDocument.type === TRANSACTION_TYPE.SALE_EXCHANGE) {
+            this.transactionDocument.currentTransactionDetails.basketSummary.discountTotal = this.numberUtilService.trimTo2Decimal2(this.updateCurrentTransactionDetailsDiscountTotal());
+        }
+        else {
+            if (this.transactionDocument.currentTransactionDetails.transactionDiscount && this.transactionDocument.currentTransactionDetails.transactionDiscount.length > 0) {
+                let discountTotal = 0;
+                this.transactionDocument.currentTransactionDetails.transactionDiscount.forEach((discount) => {
+                    discountTotal += discount.discountAmount;
+                });
+                this.transactionDocument.currentTransactionDetails.basketSummary.discountTotal = Math.abs(discountTotal);
+            }
+            else {
+                this.transactionDocument.currentTransactionDetails.basketSummary.discountTotal = 0;
+            }
+        }
+        console.log("ebasket:this.transactionDocument.currentTransactionDetails", JSON.stringify(this.transactionDocument.currentTransactionDetails));
+        return this;
+    }
+    /**
+   * current transaction Tax Total
+   * @returns Tax Total
+   */
+    updateCurrentTransactionDetailsTaxBreakdown(basketDetails) {
+        let transactionDiscountTotal = 0;
+        let taxBreakdown = {
+            taxLines: [],
+            totalTaxableAmount: 0,
+        };
+        if (this.transactionDocument.currentTransactionDetails.transactionDiscount && this.transactionDocument.currentTransactionDetails.transactionDiscount.length > 0) {
+            this.transactionDocument.currentTransactionDetails.transactionDiscount.forEach((discount) => {
+                transactionDiscountTotal += discount.discountAmount;
+            });
+        }
+        if (this.transactionDocument.currentTransactionDetails.products && this.transactionDocument.currentTransactionDetails.products.length > 0) {
+            this.transactionDocument.currentTransactionDetails.products.forEach((product) => {
+                let taxLine = {
+                    itemLineId: product.itemLineId,
+                    VAT: product.selectedVAT ? product.selectedVAT : 0,
+                    VATCode: product.selectedVATCode,
+                    taxLineTotal: 0,
+                    taxableAmount: product.total,
+                    PreTax: 0
+                };
+                console.info("Product contribution : item line ID :current transaction Details", product.itemLineId, "tax line :", JSON.stringify(taxLine), JSON.stringify(basketDetails.basketTotal));
+                //step 1
+                // if Transaction Discount and/or promotion applied, find net selling price of each product as taxableamount
+                //If transaction discount/promotion is applied taxable amount should be deducting transaction promotion and transaction disacount portion
+                if (product.refundedQuantity && product.refundedQuantity > 0) {
+                    taxLine.taxableAmount = -Math.abs(taxLine.taxableAmount - product.itemDiscounts.currentRefundPortion);
+                }
+                else {
+                    taxLine.taxableAmount = taxLine.taxableAmount - product.itemDiscounts.trnDiscountsPortion - product.itemDiscounts.trnPromotionsPortion;
+                }
+                //step 2 - find pre tax
+                taxLine.PreTax = this.numberUtilService.trimTo2Decimal2((taxLine.taxableAmount * 100) / (100 + taxLine.VAT));
+                //step 3 - Update taxbreakdown
+                taxBreakdown.totalTaxableAmount += taxLine.taxableAmount;
+                taxLine.taxableAmount = this.numberUtilService.trimTo2Decimal2(taxLine.taxableAmount);
+                // step 4 - update tax Line total
+                taxLine.taxLineTotal = this.numberUtilService.trimTo2Decimal2(taxLine.taxableAmount - taxLine.PreTax);
+                taxBreakdown.taxLines.push(taxLine);
+            });
+        }
+        taxBreakdown.totalTaxableAmount = this.numberUtilService.trimTo2Decimal2(taxBreakdown.totalTaxableAmount);
+        this.transactionDocument.currentTransactionDetails.taxBreakdown = taxBreakdown;
+        if (this.transactionDocument.currentTransactionDetails.taxBreakdown && this.transactionDocument.currentTransactionDetails.taxBreakdown.taxLines && this.transactionDocument.currentTransactionDetails.taxBreakdown.taxLines.length > 0) {
+            this.transactionDocument.currentTransactionDetails.basketSummary.VATTotal = this.numberUtilService.trimTo2Decimal2(this.transactionDocument.currentTransactionDetails.taxBreakdown.taxLines.reduce((n, { taxLineTotal }) => n + taxLineTotal, 0));
+        }
+        else {
+            this.transactionDocument.currentTransactionDetails.basketSummary.VATTotal = 0.00;
+        }
+        console.log("eBasket:after calculating tax currenttransactionDetails", this.transactionDocument.currentTransactionDetails);
+        return this;
+    }
+    updateCurrentTransactionDetailsTotalTaxSummary() {
+        console.log("Total Tax Summery Request :", JSON.stringify(this.transactionDocument.currentTransactionDetails.taxBreakdown));
+        let totalTaxSummaryArray = [];
+        let totalTaxSummaryGroup = [];
+        console.log("Tax Lines for Total Tax Summery :", JSON.stringify(this.transactionDocument.currentTransactionDetails.taxBreakdown.taxLines));
+        this.transactionDocument.currentTransactionDetails.taxBreakdown.taxLines.forEach((element) => {
+            let TaxSummary = {
+                VATCode: "",
+                VAT: -12345,
+                PreTaxSum: 0,
+                TaxSum: 0,
+                TXrateSum: 0
+            };
+            TaxSummary.VATCode = element.VATCode;
+            TaxSummary.VAT = element.VAT;
+            TaxSummary.PreTaxSum = this.numberUtilService.trimTo2Decimal2(element.PreTax);
+            TaxSummary.TaxSum = this.numberUtilService.trimTo2Decimal2(element.taxLineTotal);
+            TaxSummary.TXrateSum = this.numberUtilService.trimTo2Decimal2(TaxSummary.PreTaxSum + TaxSummary.TaxSum);
+            totalTaxSummaryArray.push(TaxSummary);
+        });
+        console.log("Total Tax Summery  Without Grouped : ", JSON.stringify(totalTaxSummaryArray));
+        totalTaxSummaryGroup = totalTaxSummaryArray.reduce((preparedArray, currentObj) => {
+            let ind = preparedArray.findIndex((x) => x.VAT === currentObj.VAT);
+            if (ind === -1) {
+                preparedArray.push(currentObj);
+            }
+            else {
+                preparedArray[ind].VATCode = currentObj.VATCode;
+                preparedArray[ind].VAT = currentObj.VAT;
+                preparedArray[ind].PreTaxSum += currentObj.PreTaxSum;
+                preparedArray[ind].TaxSum += currentObj.TaxSum;
+                preparedArray[ind].TXrateSum += currentObj.TXrateSum;
+            }
+            return preparedArray;
+        }, []);
+        // listOfTags.map(x => unique.filter(a => a.label == x.label && a.color == x.color).length > 0 ? null : unique.push(x));
+        console.log("Total  Tax Summer Group :", JSON.stringify(totalTaxSummaryGroup));
+        this.transactionDocument.currentTransactionDetails.totalTaxSummary = totalTaxSummaryGroup;
+        return this;
+    }
+    /**
+     * current transaction Disocunt Total
+     * @returns Discount Total
+     */
+    updateCurrentTransactionDetailsDiscountTotal() {
+        let refundTotal = this.transactionDocument.currentTransactionDetails.basketSummary.refundTotal ? this.transactionDocument.currentTransactionDetails.basketSummary.refundTotal : 0;
+        console.log("e-basket: transaction builder updateCurrentTransactionDetailsDiscountTotal: discountTotal", refundTotal, this.transactionDocument.currentTransactionDetails.basketSummary.basketTotal, this.transactionDocument.currentTransactionDetails.basketSummary.saleTotal);
+        const discountTotal = Math.abs(Math.abs(this.transactionDocument.currentTransactionDetails.basketSummary.saleTotal) -
+            (Math.abs(this.transactionDocument.currentTransactionDetails.basketSummary.basketTotal) + Math.abs(refundTotal)));
+        console.log("e-basket: transaction builder updateCurrentTransactionDetailsDiscountTotal: discountTotal", discountTotal);
+        return Number(discountTotal.toFixed(2));
+    }
+    /**
+    * current transaction Refund Total
+    * @returns Refund Total
+    */
+    updateCurrentTransactionDetailsRefundTotal() {
+        let totalRefund = 0;
+        for (let index = 0; index < this.transactionDocument.currentTransactionDetails.products.length; index++) {
+            const product = this.transactionDocument.currentTransactionDetails.products[index];
+            if (product.refundedTotal) {
+                totalRefund = totalRefund + product.refundedTotal;
+            }
+            console.log("ebasket : transaction Service: totalRefund for Current TransactionDetails" + totalRefund);
+        }
+        return totalRefund;
+    }
+    /**
+     * Baskets summary
+     * @param basketDetails
+     * @returns summary
+     */
+    basketSummary(basketDetails) {
+        this.transactionDocument.basketSummary.basketTotal = this.numberUtilService.trimTo2Decimal(basketDetails.basketTotal);
+        this.transactionDocument.basketSummary.saleTotal = this.numberUtilService.trimTo2Decimal2(this.updateSaleTotal(basketDetails));
+        this.transactionDocument.basketSummary.refundTotal = this.getRefundTotal();
+        if (this.transactionDocument.basket.lineDiscount ||
+            this.transactionDocument.basket.linePromotion) {
+            this.transactionDocument.basketSummary.discountTotal = this.numberUtilService.trimTo2Decimal2(this.updateDiscountTotal());
+        }
+        this.transactionDocument.basketSummary.totalItems = basketDetails.quantity;
+        if (this.transactionDocument.basket.taxBreakdown) {
+            this.transactionDocument.basketSummary.VATTotal = this.numberUtilService.trimTo2Decimal2(this.transactionDocument.basket.taxBreakdown.taxLines.reduce((n, { taxLineTotal }) => n + taxLineTotal, 0));
+        }
+        else {
+            this.transactionDocument.basketSummary.VATTotal = 0.00;
+        }
+        console.info("ebasket: basketsummary updated in transaction document: ", JSON.stringify(this.transactionDocument.basketSummary));
+        return this;
+    }
+    /**
+     * Line Discount
+     * @param basketDetails
+     * @returns line Discount
+     */
+    lineDiscount(basketDetails) {
+        this.transactionDocument.basket.lineDiscount = [];
+        for (let index = 0; index < basketDetails.products.length; index++) {
+            const element = basketDetails.products[index];
+            if (element.lineDiscount) {
+                this.transactionDocument.basket.lineDiscount.push(element.lineDiscount);
+                this.transactionDocument.basket.lineDiscount = this.transactionDocument.basket.lineDiscount.reduce((acc, val) => {
+                    if (!acc.find((el) => el.itemLineId === val.itemLineId)) {
+                        acc.push(val);
+                    }
+                    return acc;
+                }, []);
+            }
+            // console.info(
+            //   "e-basket :line discount updated in transaction document",
+            //   this.transactionDocument.basket.lineDiscount
+            // );
+        }
+        return this;
+    }
+    /**
+     * exchange
+     * @param basketDetails
+     * @returns exchange
+     */
+    exchange(basketDetails) {
+        this.transactionDocument.basket.exchange = basketDetails.exchange && basketDetails.exchange.length > 0 ? [...basketDetails.exchange] : [];
+        for (let index = 0; index < basketDetails.products.length; index++) {
+            const element = basketDetails.products[index];
+            if (element.exchange != undefined) {
+                const isPresent = this.transactionDocument.basket.exchange.some((el) => el.exchangeId === element.exchange.exchangeId);
+                if (!isPresent) {
+                    let exchangeItems = [];
+                    for (let j = 0; j < element.exchange.newItems.length; j++) {
+                        const item = element.exchange.newItems[j];
+                        let newItems = { lineItemId: item.itemLineId, Quantity: item.quantity };
+                        exchangeItems.push(newItems);
+                    }
+                    element.exchange.newItems = [...exchangeItems];
+                    this.transactionDocument.basket.exchange.push(element.exchange);
+                }
+            }
+            console.log("e-basket :TransactionDocumentBuilder: this.transactionDocument.basket exchange", JSON.stringify(this.transactionDocument.basket.exchange));
+        }
+        return this;
+    }
+    /**
+    * add previous exchange data
+    * @param originalTransactionDocument
+    * @returns line Promotions
+    */
+    addExchangeData(originalTransactionDocument) {
+        this.transactionDocument.basket.exchange = originalTransactionDocument.basket.exchange ? [...originalTransactionDocument.basket.exchange] : null;
+        return this;
+    }
+    /**
+     * line Promotions
+     * @param basketDetails
+     * @returns line Promotions
+     */
+    linePromotion(basketDetails) {
+        this.transactionDocument.basket.linePromotion = [];
+        for (let index = 0; index < basketDetails.products.length; index++) {
+            const element = basketDetails.products[index];
+            if (element.linePromotions) {
+                this.transactionDocument.basket.linePromotion.push(element.linePromotions);
+                this.transactionDocument.basket.linePromotion = this.transactionDocument.basket.linePromotion.reduce((acc, val) => {
+                    if (!acc.find((el) => el.itemLineId === val.itemLineId)) {
+                        acc.push(val);
+                    }
+                    return acc;
+                }, []);
+            }
+        }
+        return this;
+    }
+    /**
+     * transaction Promotion
+     * @param basketDetails
+     * @returns transaction Promotion
+     */
+    transactionPromotion(basketDetails) {
+        if (basketDetails.transactionPromotion) {
+            this.transactionDocument.basket.transactionPromotion =
+                basketDetails.transactionPromotion;
+            //   for (let index = 0; index < basketDetails.TransactionDiscount.length; index++) {
+            //   this.transactionDocument.basket.transactionPromotion.push(element.linePromotions)
+            //   this.transactionDocument.basket.transactionPromotion =  this.transactionDocument.basket.linePromotions.reduce((acc, val) => {
+            //     if (!acc.find(el => el.itemLineId === val.itemLineId)) {
+            //       acc.push(val);
+            //     }
+            //     return acc;
+            //   }, []);
+            // }
+            console.log("e-basket :TransactionDocumentBuilder: this.transactionDocument.basket.transactionPromotion", JSON.stringify(this.transactionDocument.basket.transactionPromotion));
+        }
+        return this;
+    }
+    transactionDiscount(basketDetails) {
+        if (basketDetails.transactionDiscount) {
+            this.transactionDocument.basket.transactionDiscount =
+                basketDetails.transactionDiscount;
+            console.log("e-basket :TransactionDocumentBuilder: transaction Discount", JSON.stringify(this.transactionDocument.basket.transactionDiscount));
+        }
+        return this;
+    }
+    /**
+     * Payments details
+     * @param paymentDetails
+     * @returns
+     */
+    paymentDetails(paymentDetails) {
+        console.info("ebasket : payment details after transaction completed", JSON.stringify(paymentDetails));
+        this.transactionDocument.paymentDetails = paymentDetails;
+        return this;
+    }
+    /**
+     * Payments details
+     * @param paymentDetails
+     * @returns
+     */
+    splitPayment(splitPayment) {
+        this.transactionDocument.splitPayment = splitPayment;
+        return this;
+    }
+    /**
+    * Payments details
+    * @param paymentDetails
+    * @returns
+    */
+    isPaymentCompleted(isPaymentCompleted) {
+        this.transactionDocument.isPaymentCompleted = isPaymentCompleted;
+        return this;
+    }
+    /**
+     * Bases currency
+     * @param currency
+     * @returns currency
+     */
+    baseCurrency(currency) {
+        this.transactionDocument.baseCurrency = currency;
+        return this;
+    }
+    /**
+    * gift option at
+    * @returns at
+    */
+    giftOption(gift) {
+        console.log("e-basket :TransactionDocumentBuilder: this.transactionDocument.giftoption", gift);
+        if (gift) {
+            this.transactionDocument.giftedReceipt = gift;
+        }
+        return this;
+    }
+    /**
+  
+  /**
+   * manual Discount
+   * @param discountData
+   * @returns
+   */
+    // manualDiscount(discountData : basketDiscount):TransactionDocumentBuilder {
+    //   let saleTotal =  this.transactionDocument.basketSummary.basketTotal;
+    //   if(discountData.discountType =='Percent'){
+    //     this.transactionDocument.basketSummary.basketTotal = saleTotal-(saleTotal*(discountData.discountAmount/100));
+    //     discountData.discountAmount = -1*(saleTotal-this.transactionDocument.basketSummary.basketTotal);
+    //   }else {
+    //     this.transactionDocument.basketSummary.basketTotal =saleTotal-discountData.discountAmount;
+    //     discountData.discountAmount = -1*discountData.discountAmount;
+    //   }
+    //   this.transactionDocument.transactionDiscount.push(discountData);
+    //   return this;
+    // }
+    /**
+     * Types transaction document builder
+     * @param t
+     * @returns type
+     */
+    type(t) {
+        this.transactionDocument.type = t;
+        return this;
+    }
+    /**
+     * Operations status
+     * @param o
+     * @returns status
+     */
+    operationStatus(o) {
+        this.transactionDocument.operationStatus = o;
+        return this;
+    }
+    /**
+     * Created at
+     * @returns at
+     */
+    createdAt() {
+        const date = new Date();
+        this.transactionDocument.createdAt = date.toISOString();
+        this.transactionDocument.updatedAt = date.toISOString();
+        return this;
+    }
+    /**
+     * Updated at
+     * @returns at
+     */
+    updatedAt() {
+        const date = new Date();
+        this.transactionDocument.updatedAt = date.toISOString();
+        return this;
+    }
+    /**
+     * transsaction completion at
+     * @returns transaction completion date
+     */
+    transactionCompletedAt() {
+        const date = new Date();
+        this.transactionDocument.transCompletedAt = date.toISOString();
+        return this;
+    }
+    /**
+     * Builds transaction document builder
+     * @returns build
+     */
+    build() {
+        return this.transactionDocument;
+    }
+    /**
+     * Sales total in refund
+     * @param saleTotal
+     * @returns total in refund
+     */
+    saleTotalInRefund(saleTotal) {
+        this.transactionDocument.saleTotal = saleTotal;
+        return this;
+    }
+    /**
+     * Gets basket details
+     * @returns basket details
+     */
+    getBasketDetails() {
+        console.info("ebasket: Getting Basket for transactionDocument", JSON.stringify(this.transactionDocument));
+        let basket = {
+            subsidiaryId: this.transactionDocument.subsidiaryId,
+            transactionDiscount: this.transactionDocument.basket.transactionDiscount,
+            transactionPromotion: this.transactionDocument.basket.transactionPromotion,
+            transactionId: this.transactionDocument.transactionId,
+            offlineTransactionId: this.transactionDocument.offlineTransactionId,
+            total: this.transactionDocument.basketSummary.basketTotal,
+            basketTotal: this.transactionDocument.basketSummary.basketTotal,
+            discountTotal: this.transactionDocument.basketSummary.discountTotal,
+            saleTotal: this.transactionDocument.basketSummary.saleTotal,
+            refundTotal: this.transactionDocument.basketSummary.refundTotal,
+            quantity: this.transactionDocument.basketSummary.totalItems,
+            products: [],
+            baseCurrency: this.transactionDocument.baseCurrency,
+            customer: this.transactionDocument.customer,
+        };
+        basket.products = [];
+        this.transactionDocument.basket.products.forEach((product, index) => {
+            console.log(JSON.stringify(product), "ebasket: basket detail update in basket");
+            const p = {};
+            p.SKU = product.SKU;
+            p.barcode = product.barCode;
+            p.barcodes = product.barcodes;
+            p.description = product.description;
+            p.imageUrls = product.imageUrls;
+            p.currency = this.transactionDocument.baseCurrency;
+            p.totalLinePrice = product.totalLinePrice;
+            p.itemLineId = Number(product.itemLineId);
+            p.excludePromotion = product.excludePromotion;
+            p.selectedPrice = product.price;
+            p.quantity = product.quantity;
+            p.total = product.totalLinePrice;
+            p.selectedRRPPrice = product.selectedRRPPrice;
+            p.fullfilmentId = product.fullfilmentId;
+            p.fullfilmentLocationName = product.fullfilmentLocationName;
+            p.deliveryGroup = product.deliveryGroup || "1";
+            p.leadTime = product.leadTime;
+            p.deliveryMethod = product.deliveryMethod || DELIVERY_METHODS.COLLECT_FROM_STORE.toString();
+            if (p.fullfilmentId != this.transactionDocument.storeId) {
+                p.isWebOrder = true;
+            }
+            p.giftCard = product.giftCard;
+            p.giftCardExpiryDate = product.giftCardExpiryDate;
+            p.giftCardNumberIssued = product.giftCardNumberIssued;
+            p.giftCardRecipientEmail = product.giftCardRecipientEmail;
+            p.giftCardRecipientName = product.giftCardRecipientName;
+            if (this.transactionDocument.basket.lineDiscount &&
+                this.transactionDocument.basket.lineDiscount.length > 0) {
+                this.transactionDocument.basket.lineDiscount.forEach((lineDiscount) => {
+                    if (product.itemLineId === lineDiscount.itemLineId.toString()) {
+                        p.lineDiscount = lineDiscount;
+                        p.total = lineDiscount.discountedLinePrice;
+                    }
+                });
+            }
+            if (this.transactionDocument.basket.linePromotion &&
+                this.transactionDocument.basket.linePromotion.length > 0) {
+                this.transactionDocument.basket.linePromotion.forEach((linePromotion) => {
+                    if (product.itemLineId === linePromotion.itemLineId.toString()) {
+                        p.linePromotions = linePromotion;
+                        p.total = linePromotion.promotionLinePrice;
+                    }
+                });
+            }
+            if (this.transactionDocument.basket.taxBreakdown &&
+                this.transactionDocument.basket.taxBreakdown.taxLines.length > 0) {
+                this.transactionDocument.basket.taxBreakdown.taxLines.forEach((taxLine) => {
+                    if (product.itemLineId && product.itemLineId === taxLine.itemLineId.toString()) {
+                        p.selectedVAT = taxLine.VAT;
+                        p.selectedVATCode = taxLine.VATCode;
+                    }
+                });
+            }
+            if (this.transactionDocument.type === TRANSACTION_TYPE.REFUND) {
+                p.total = product.refundedTotal;
+            }
+            else if ((this.transactionDocument.type === TRANSACTION_TYPE.SALE_REFUND || TRANSACTION_TYPE.SALE_EXCHANGE) && product.refundedQuantity > 0) {
+                p.refundedReasonDescription = product.refundedReasonDescription;
+                p.refundedReason = product.refundedReason;
+                if (!p.refundedReasonDescription) {
+                    p.refundedReasonDescription = p.refundedReason;
+                }
+                p.refundedQuantity = product.refundedQuantity;
+                p.refundPromotionalQuantity = product.refundedPromotionalQuantity;
+                p.refundedTotal = product.refundedTotal;
+                p.total -= Math.abs(p.refundedTotal);
+                p.isLastExchanged = product.isLastExchanged;
+            }
+            if (this.transactionDocument.type === TRANSACTION_TYPE.REFUND) {
+                if (p.total > 0) {
+                    p.total *= -1;
+                }
+            }
+            basket.products.push(p);
+        });
+        basket = this.getTransactionDiscountAndTransactionPromotionPortion(basket);
+        basket.total = (basket.basketTotal || 0) + this.getTotalDiscountWithTransactionDiscountsAndPromotions(basket);
+        if (this.transactionDocument.type === TRANSACTION_TYPE.SALE_REFUND) {
+            basket.quantity = this.getRefundedTotalWithQuantity(basket);
+        }
+        console.info("ebasket: Basket created successfully", JSON.stringify(basket));
+        return basket;
+    }
+    /**
+     * Gets basket details
+     * @returns refund basket details
+     */
+    // getRefundBasketDetails(): Basket {
+    //   let basket: Basket = {
+    //     subsidiaryId : this.transactionDocument.subsidiaryId,
+    //     transactionDiscount: this.transactionDocument.basket.transactionDiscount,
+    //     transactionPromotion: this.transactionDocument.basket.transactionPromotion,
+    //     transactionId: this.transactionDocument.transactionId,
+    //     total: this.transactionDocument.basketSummary.basketTotal,
+    //     basketTotal: this.transactionDocument.basketSummary.basketTotal,
+    //     discountTotal: this.transactionDocument.basketSummary.discountTotal,
+    //     saleTotal: this.transactionDocument.basketSummary.saleTotal,
+    //     quantity: this.transactionDocument.basketSummary.totalItems,
+    //     products: [],
+    //     baseCurrency: this.transactionDocument.baseCurrency,
+    //     customer: this.transactionDocument.customer,
+    //   };
+    //   basket.products = [] as Product[];
+    //   this.transactionDocument.basket.products.forEach((product: { SKU: any; barCode: any; barcodes: any; description: any; imageUrls: any; totalLinePrice: any; itemLineId: any; excludePromotion: any; price: number; quantity: any; selectedRRPPrice: any; fullfilmentId: any; fullfilmentLocationName: any; deliveryGroup: string; leadTime: any; deliveryMethod: any; giftCard: any; giftCardExpiryDate: any; giftCardNumberIssued: any; giftCardRecipientEmail: any; giftCardRecipientName: any; itemDiscounts: any; refundedPromotionalQuantity: any; refundedQuantity: number; refunded: any; isLastExchanged: any; exchange: any; refundedTotal: number; }, index: any) => {
+    //     const p = {} as Product;
+    //     p.SKU = product.SKU;
+    //     p.barcode = product.barCode;
+    //     p.barcodes = product.barcodes;
+    //     p.description = product.description;
+    //     p.imageUrls = product.imageUrls;
+    //     p.currency = this.transactionDocument.baseCurrency;
+    //     p.totalLinePrice = product.totalLinePrice;
+    //     p.itemLineId = Number(product.itemLineId);
+    //     p.excludePromotion = product.excludePromotion;
+    //     p.selectedPrice = product.price;
+    //     p.quantity = product.quantity;
+    //     p.total = product.totalLinePrice;
+    //     p.selectedRRPPrice = product.selectedRRPPrice;
+    //     p.fullfilmentId = product.fullfilmentId;
+    //     p.fullfilmentLocationName = product.fullfilmentLocationName;
+    //     p.deliveryGroup = product.deliveryGroup || "1";
+    //     p.leadTime = product.leadTime;
+    //     p.deliveryMethod = product.deliveryMethod || DELIVERY_METHODS.COLLECT_FROM_STORE.toString();
+    //     p.giftCard = product.giftCard;
+    //     p.giftCardExpiryDate = product.giftCardExpiryDate;
+    //     p.giftCardNumberIssued = product.giftCardNumberIssued;
+    //     p.giftCardRecipientEmail = product.giftCardRecipientEmail;
+    //     p.giftCardRecipientName = product.giftCardRecipientName;
+    //     if(p.fullfilmentId != this.transactionDocument.storeId)
+    //     {
+    //       p.isWebOrder = true;
+    //     }
+    //     if (product.itemDiscounts) {
+    //       p.itemDiscounts = product.itemDiscounts as ItemDiscount;
+    //     }
+    //     // if(!p.itemDiscounts){
+    //     //   console.log(p.itemDiscounts);
+    //     //   this.basketService.transactionDiscountAndPromotionProductortionCalculation(basket);
+    //     // }
+    //     p.refundPromotionalQuantity = product.refundedPromotionalQuantity ? product.refundedPromotionalQuantity : 0;
+    //     if (product.refundedQuantity) {
+    //       p.quantity = p.quantity - product.refundedQuantity;
+    //       p.totalLinePrice = (p.quantity * product.price);
+    //       p.total = p.totalLinePrice;
+    //       // p.refundPromotionalQuantity = product.refundedPromotionalQuantity;
+    //       p.refunded = product.refunded;
+    //       p.isLastExchanged = product.isLastExchanged;
+    //     }
+    //     if (product.exchange) {
+    //       p.exchange = product.exchange;
+    //     }
+    //     if (
+    //       this.transactionDocument.basket.lineDiscount &&
+    //       this.transactionDocument.basket.lineDiscount.length > 0
+    //     ) {
+    //       this.transactionDocument.basket.lineDiscount.forEach((lineDiscount: { itemLineId: { toString: () => any; }; discountedLinePrice: any; }) => {
+    //         if (product.itemLineId === lineDiscount.itemLineId.toString() && product.refundedQuantity > 0) {
+    //           p.lineDiscount = Object.assign({}, lineDiscount);
+    //           p.lineDiscount.discountedLinePrice = p.lineDiscount.unitPrice * p.quantity
+    //           p.lineDiscount.discountAmount = p.total - p.lineDiscount.discountedLinePrice
+    //           p.total = p.lineDiscount.discountedLinePrice;
+    //         } else if (product.itemLineId === lineDiscount.itemLineId.toString()) {
+    //           p.lineDiscount = lineDiscount;
+    //           p.total = lineDiscount.discountedLinePrice
+    //         }
+    //       });
+    //     }
+    //     if (
+    //       this.transactionDocument.basket.linePromotion &&
+    //       this.transactionDocument.basket.linePromotion.length > 0
+    //     ) {
+    //       this.transactionDocument.basket.linePromotion.forEach((linePromotion: { itemLineId: { toString: () => any; }; refunded: any; }) => {
+    //         if (product.itemLineId === linePromotion.itemLineId.toString() && !linePromotion.refunded) {
+    //           p.linePromotions = linePromotion;
+    //           p.total = p.linePromotions.promotionLinePrice;
+    //           p.total = p.total - (product.refundedTotal ? Math.abs(product.refundedTotal) : 0);
+    //         }
+    //       });
+    //     }
+    //     p.refundedQuantity = 0;
+    //     p.refundedTotal = 0;
+    //     if (
+    //       this.transactionDocument.basket.taxBreakdown &&
+    //       this.transactionDocument.basket.taxBreakdown.taxLines.length > 0
+    //     ) {
+    //       this.transactionDocument.basket.taxBreakdown.taxLines.forEach((taxLine: { itemLineId: { toString: () => any; }; VAT: any; VATCode: any; }) => {
+    //         if (product.itemLineId === taxLine.itemLineId.toString()) {
+    //           p.selectedVAT = taxLine.VAT;
+    //           p.selectedVATCode = taxLine.VATCode;
+    //         }
+    //       });
+    //     }
+    //     if (p.quantity > 0) {
+    //       basket.products.push(p);
+    //     }
+    //   });
+    //   // product.itemDiscounts
+    //   if (!basket.products[0].hasOwnProperty('itemDiscounts')) {
+    //     basket = this.getTransactionDiscountAndTransactionPromotionPortion(basket);
+    //   }
+    //   console.log("ebasket : TransactionDocumentBuilder  :new created refunded basket", JSON.stringify(basket))
+    //   basket.quantity = basket.products.reduce(
+    //     (n: any, { quantity }: any) => n + quantity,
+    //     0
+    //   );
+    //   basket.total = this.getTotalWithLineDiscountAndLinePromotionApplied(basket);
+    //   basket.basketTotal = basket.total;
+    //   basket.basketTotal = basket.basketTotal - this.getTotalDiscountWithTransactionDiscountsAndPromotions(basket);
+    //   console.log(
+    //     "ebasket : TransactionDocumentBuilder : update Basket Total: after promotion :basketTotal",
+    //     basket.basketTotal
+    //   );
+    //   console.log(
+    //     "e:basket :TransactionDocumentBuilder : basketDetails updated values",
+    //     JSON.stringify(basket)
+    //   );
+    //   return basket;
+    // }
+    getTransactionDiscountAndTransactionPromotionPortion(basket) {
+        if (basket.transactionDiscount &&
+            basket.transactionDiscount.length > 0) {
+            basket.transactionDiscount.forEach((discount) => {
+                if (!discount.itemLineIds) {
+                    discount.itemLineIds = basket.products.map((product) => {
+                        return product.itemLineId;
+                    });
+                }
+                basket = this.basketService.transactionDiscountProductPortionCalc(basket, discount);
+            });
+        }
+        if (basket.transactionPromotion &&
+            basket.transactionPromotion.length > 0) {
+            basket.transactionPromotion.forEach((tPromotion) => {
+                if (!tPromotion.itemLineIds) {
+                    const filteredData = basket.products.filter((item) => {
+                        return item.excludePromotion === false;
+                    });
+                    tPromotion.itemLineIds =
+                        filteredData.map((product) => {
+                            return product.itemLineId;
+                        });
+                }
+                basket = this.basketService.transactionPromotionProductPortionCalc(basket, tPromotion);
+            });
+        }
+        return basket;
+    }
+    getTotalDiscountWithTransactionDiscountsAndPromotions(basketDetails) {
+        let discountTotal = 0;
+        if (basketDetails.transactionPromotion &&
+            basketDetails.transactionPromotion.length > 0) {
+            discountTotal += basketDetails.transactionPromotion.reduce((n, { promotionAmount }) => n + promotionAmount, 0);
+        }
+        if (basketDetails.transactionDiscount &&
+            basketDetails.transactionDiscount.length > 0) {
+            discountTotal += basketDetails.transactionDiscount.reduce((n, { discountAmount }) => n + discountAmount, 0);
+        }
+        console.log("ebasket : TransactionDocumentBuilder : Transaction discount Total:", discountTotal);
+        return discountTotal;
+    }
+    appendCurrencySymbol(currency, value) {
+        //  value=this.decimalpipe.transform(value,'1.2');
+        if (value >= 0) {
+            const returnval = currency + value;
+            console.log(returnval, "ebasket: add currency with value");
+            return returnval;
+        }
+        else {
+            const returnval = "-" + (currency + value * -1);
+            console.log(returnval, "-(currency+(value*-1))");
+            return returnval;
+        }
+    }
+    // /**
+    //  * Updates total refund
+    //  * @returns total refund
+    //  */
+    // updateTotalRefund(): TransactionDocumentBuilder {
+    //   this.transactionDocument.basket.products.forEach((product) => {
+    //     product.refundedQuantity = product.quantity;
+    //     product.refundedTotal = product.totalLinePrice * -1;
+    //     console.log(
+    //       "ebasket: Transaction price override :",
+    //       this.transactionDocument.basket.lineDiscount
+    //     );
+    //     if (
+    //       this.transactionDocument.basket.linePromotion &&
+    //       this.transactionDocument.basket.linePromotion.length > 0
+    //     ) {
+    //       this.transactionDocument.basket.linePromotion.forEach((linePromotion) => {
+    //         console.log(
+    //           "Promotion: basket linePromotion : ",
+    //           this.transactionDocument.basket.linePromotion
+    //         );
+    //         console.log(
+    //           "linePromotion.itemLineId.toString() : ",
+    //           linePromotion.itemLineId.toString()
+    //         );
+    //         console.log(
+    //           "condition : " +
+    //           (product.itemLineId === linePromotion.itemLineId.toString())
+    //         );
+    //         if (product.itemLineId === linePromotion.itemLineId.toString()) {
+    //           product.refundedTotal =
+    //             linePromotion.promotionLinePrice * -1;
+    //         }
+    //       });
+    //     } else
+    //       if (
+    //         this.transactionDocument.basket.lineDiscount &&
+    //         this.transactionDocument.basket.lineDiscount.length > 0
+    //       ) {
+    //         this.transactionDocument.basket.lineDiscount.forEach((lineDiscount) => {
+    //           console.log(
+    //             "product.itemLineId : " +
+    //             this.transactionDocument.basket.lineDiscount
+    //           );
+    //           console.log(
+    //             "lineDiscount.itemLineId.toString() : " +
+    //             lineDiscount.itemLineId.toString()
+    //           );
+    //           console.log(
+    //             "condition : " +
+    //             (product.itemLineId === lineDiscount.itemLineId.toString())
+    //           );
+    //           if (product.itemLineId === lineDiscount.itemLineId.toString()) {
+    //             product.refundedTotal = lineDiscount.unitPrice * product.refundedQuantity * -1;
+    //           }
+    //         });
+    //       }
+    //     console.log("Product description :" + product.description);
+    //     console.log("Product total :" + product.refundedTotal);
+    //     // product.displayrefundedamount=this.appendCurrencySymbol(CURRENCY[this.transactionDocument.baseCurrency],product.refundedTotal);
+    //     // console.log(product.displayrefundedamount,"displayrefundedamount");
+    //     product.refunded = true;
+    //   });
+    //   const baskettotal = (this.transactionDocument.basketSummary.basketTotal *= -1);
+    //   // this.transactionDocument.basketSummary.displaybaskettotal=this.appendCurrencySymbol(CURRENCY[this.transactionDocument.baseCurrency], baskettotal);
+    //   const saletotal = (this.transactionDocument.basketSummary.saleTotal *= -1);
+    //   // this.transactionDocument.basketSummary.displaysaletotal = this.appendCurrencySymbol(CURRENCY[this.transactionDocument.baseCurrency], saletotal);
+    //   (this.transactionDocument.basketSummary.VATTotal *= -1);
+    //   return this;
+    // }
+    /**
+     * Sale Total
+     * @param basketDetails
+     * @returns Sale Total
+     */
+    updateSaleTotal(basketDetails) {
+        const saleTotal = basketDetails.products.reduce((n, { totalLinePrice }) => n + totalLinePrice, 0);
+        return saleTotal;
+    }
+    getTotalWithLineDiscountAndLinePromotionApplied(basketDetails) {
+        let saletotal = 0.0;
+        for (let product of basketDetails.products) {
+            // if (product.linePromotions) {
+            //   saletotal += product.linePromotions.promotionLinePrice;
+            // } else if (
+            //   product.lineDiscount &&
+            //   !product.linePromotions
+            // ) {
+            //   saletotal +=
+            //     product.quantity * Number(product.lineDiscount.unitPrice.toFixed(2));
+            // } else {
+            //   saletotal +=
+            //     product.quantity * Number(product.selectedPrice.toFixed(2));
+            // }
+            saletotal += product.total;
+            console.log("e-basket:update product Total:" + saletotal, JSON.stringify(product));
+        }
+        return saletotal;
+    }
+    getRefundedTotalWithQuantity(basketDetails) {
+        let quantity = 0;
+        for (let index = 0; index < basketDetails.products.length; index++) {
+            const product = basketDetails.products[index];
+            if (!product.refundedReasonDescription) {
+                quantity = quantity + product.quantity;
+            }
+            else {
+                quantity = quantity + (product.quantity - product.refundedQuantity);
+                // basketDetails.total = basketDetails.total + product.refundedTotal;
+            }
+        }
+        return quantity;
+    }
+    /**
+     * Discount Total
+     * @returns Discount Total
+     */
+    updateDiscountTotal() {
+        let refundTotal = this.transactionDocument.basketSummary.refundTotal ? this.transactionDocument.basketSummary.refundTotal : 0;
+        console.info("e-basket: transaction builder: refundTotal", JSON.stringify(refundTotal), JSON.stringify(this.transactionDocument.basketSummary));
+        const discountTotal = Math.abs(Math.abs(this.transactionDocument.basketSummary.saleTotal) -
+            (Math.abs(this.transactionDocument.basketSummary.basketTotal) + Math.abs(refundTotal)));
+        console.log("e-basket: transaction builder: discountTotal", JSON.stringify(discountTotal));
+        return Number(discountTotal.toFixed(2));
+    }
+    updateReasonCode(reasonCode) {
+        this.transactionDocument.reasonCode = reasonCode.code;
+        this.transactionDocument.reasonDescription = reasonCode.name;
+        return this;
+    }
+    updateManagerOverride(useroverride) {
+        this.transactionDocument.override = useroverride;
+        return this;
+    }
+    updateUserID(userID) {
+        this.transactionDocument.userId = userID;
+        return this;
+    }
+    updateUserName(name) {
+        this.transactionDocument.userName = name;
+        return this;
+    }
+    addCustomerDetails(customerDetail) {
+        this.transactionDocument.customer = customerDetail;
+        return this;
+    }
+    updateTaxBreakdown(basketDetails) {
+        // let transactionDiscountTotal = 0;
+        let taxBreakdown = {
+            taxLines: [],
+            totalTaxableAmount: 0,
+        };
+        // if (this.transactionDocument.basket.transactionDiscount && this.transactionDocument.basket.transactionDiscount.length > 0) {
+        //   this.transactionDocument.basket.transactionDiscount.forEach((discount) => {
+        //     transactionDiscountTotal += discount.discountAmount;
+        //   });
+        // }
+        // if (this.transactionDocument.basket.transactionPromotion && this.transactionDocument.basket.transactionPromotion.length > 0) {
+        //   this.transactionDocument.basket.transactionPromotion.forEach(
+        //     (promotion) => {
+        //       transactionDiscountTotal += promotion.promotionAmount;
+        //     }
+        //   );
+        // }
+        basketDetails.products.forEach((product) => {
+            let taxLine = {
+                itemLineId: product.itemLineId,
+                VAT: product.selectedVAT ? product.selectedVAT : 0,
+                VATCode: product.selectedVATCode,
+                taxLineTotal: 0,
+                taxableAmount: product.total,
+                PreTax: 0
+            };
+            console.info("Product contribution : item line ID :", product.itemLineId, "tax line :", JSON.stringify(taxLine));
+            // step 1
+            // if Transaction Discount and/or promotion applied, find net selling price of each product as taxableamount
+            // if (transactionDiscountTotal > 0) {
+            product = this.basketService.validateProductItemDiscount(product);
+            const productContributionInTotal = product.itemDiscounts.trnDiscountsPortion +
+                product.itemDiscounts.trnPromotionsPortion -
+                product.itemDiscounts.refundPortion;
+            //  tp+td-rp;
+            console.info("Product contribution : item line ID :", product.itemLineId, "contribution :", JSON.stringify(productContributionInTotal));
+            // calculate net selling price after applying transaction discount as per product contribution
+            taxLine.taxableAmount -= productContributionInTotal;
+            // }
+            //step 2 - find pre tax
+            taxLine.PreTax = this.numberUtilService.trimTo2Decimal2((taxLine.taxableAmount * 100) / (100 + taxLine.VAT));
+            //step 3 - Update taxbreakdown
+            taxBreakdown.totalTaxableAmount += taxLine.taxableAmount;
+            taxLine.taxableAmount = this.numberUtilService.trimTo2Decimal2(taxLine.taxableAmount);
+            // step 4 - update tax Line total
+            taxLine.taxLineTotal = this.numberUtilService.trimTo2Decimal2(taxLine.taxableAmount - taxLine.PreTax);
+            taxBreakdown.taxLines.push(taxLine);
+        });
+        taxBreakdown.totalTaxableAmount = this.numberUtilService.trimTo2Decimal2(taxBreakdown.totalTaxableAmount);
+        this.transactionDocument.basket.taxBreakdown = taxBreakdown;
+        return this;
+    }
+    updateTotalTaxSummary() {
+        console.log("Total Tax Summery Request :", JSON.stringify(this.transactionDocument.basket.taxBreakdown));
+        let totalTaxSummaryArray = [];
+        let totalTaxSummaryGroup = [];
+        console.log("Tax Lines for Total Tax Summery :", JSON.stringify(this.transactionDocument.basket.taxBreakdown.taxLines));
+        this.transactionDocument.basket.taxBreakdown.taxLines.forEach((element) => {
+            let TaxSummary = {
+                VATCode: "",
+                VAT: -12345,
+                PreTaxSum: 0,
+                TaxSum: 0,
+                TXrateSum: 0
+            };
+            TaxSummary.VATCode = element.VATCode;
+            TaxSummary.VAT = element.VAT;
+            TaxSummary.PreTaxSum = this.numberUtilService.trimTo2Decimal2(element.PreTax);
+            TaxSummary.TaxSum = this.numberUtilService.trimTo2Decimal2(element.taxLineTotal);
+            TaxSummary.TXrateSum = this.numberUtilService.trimTo2Decimal2(TaxSummary.PreTaxSum + TaxSummary.TaxSum);
+            totalTaxSummaryArray.push(TaxSummary);
+        });
+        console.log("Total Tax Summery  Without Grouped : ", JSON.stringify(totalTaxSummaryArray));
+        totalTaxSummaryGroup = totalTaxSummaryArray.reduce((preparedArray, currentObj) => {
+            let ind = preparedArray.findIndex((x) => x.VAT === currentObj.VAT);
+            if (ind === -1) {
+                preparedArray.push(currentObj);
+            }
+            else {
+                preparedArray[ind].VATCode = currentObj.VATCode;
+                preparedArray[ind].VAT = currentObj.VAT;
+                preparedArray[ind].PreTaxSum += currentObj.PreTaxSum;
+                preparedArray[ind].TaxSum += currentObj.TaxSum;
+                preparedArray[ind].TXrateSum += currentObj.TXrateSum;
+            }
+            return preparedArray;
+        }, []);
+        console.log("Total  Tax Summer Group :", totalTaxSummaryGroup);
+        this.transactionDocument.basket.totalTaxSummary = totalTaxSummaryGroup;
+        return this;
+    }
+    /**
+     * TransactionId
+     * @returns OriginalTransactionId
+     */
+    addOriginalTransId(tranDoc) {
+        if (this.transactionDocument.type === TRANSACTION_TYPE.REFUND || this.transactionDocument.type === TRANSACTION_TYPE.SALE_REFUND || this.transactionDocument.type === TRANSACTION_TYPE.SALE_EXCHANGE) {
+            this.transactionDocument.originalTransId = tranDoc.transactionId;
+            if (tranDoc.apiResponse && tranDoc.apiResponse.internalId) {
+                this.transactionDocument.originalExternalId = tranDoc.apiResponse.internalId.toString();
+            }
+        }
+        return this;
+    }
+    /**
+     * unreferenced Refund
+     * @returns boolean value
+     */
+    addUnreferencedRefund() {
+        this.transactionDocument.unreferencedRefund = true;
+        return this;
+    }
+    getRefundTotal() {
+        let totalRefund = 0;
+        for (let index = 0; index < this.transactionDocument.basket.products.length; index++) {
+            const product = this.transactionDocument.basket.products[index];
+            if (product.refundedTotal) {
+                totalRefund = totalRefund + product.refundedTotal;
+            }
+            console.log("ebasket : transaction Service: totalRefund" + totalRefund);
+        }
+        return totalRefund;
+    }
+    docId(docId) {
+        this.transactionDocument.id = docId;
+        return this;
+    }
+}
+
+class RJMapperBuilderClass {
+    constructor(transactionDoc) {
+        this.itemCount = 0;
+        this.largestNumber = 0;
+        this.rjObject = {};
+        if (transactionDoc) {
+            this.transactionDocument = transactionDoc;
+        }
+        else {
+            this.transactionDocument = {
+                transactionId: "",
+                offlineTransactionId: "",
+                transactionRef: "",
+                dateTime: "",
+                orgCode: "",
+                storeId: "",
+                storeNodeId: "",
+                storeNodeStructure: "",
+                deviceId: "",
+                terminalId: "",
+                userId: "",
+                initiatingModule: "eBasket",
+                export: false,
+                basket: {},
+                basketSummary: {},
+                baseCurrency: "",
+                type: "",
+                operationStatus: "",
+                createdAt: "",
+                updatedAt: "",
+                id: "",
+                currentTransactionDetails: {},
+                saleTotal: 0,
+            };
+        }
+        this.initilizeItemCount();
+        this.setLineNumberForProducts();
+        this.createdAt = this.getDate(this.transactionDocument.createdAt);
+        this.updatedAt = this.getDate(this.transactionDocument.updatedAt);
+    }
+    getPosbasketInfo() {
+        this.rjObject['Keyword'] = this.generateKeyword();
+        this.rjObject['ID'] = this.generateId(this.createdAt);
+        this.rjObject['XMLSchemaVersion'] = '2';
+        this.rjObject['LastUpdated'] = this.updatedAt;
+        this.rjObject['MajorVersion'] = this.majorVersion;
+        this.rjObject['MinorVersion'] = this.minorVersion;
+        this.rjObject['ManifestVersion'] = this.manifestVersion;
+        this.rjObject['DatabaseSchemaVersion'] = this.databaseSchemaVersion;
+        this.rjObject['BasketType'] = this.basketType;
+        this.rjObject['State'] = this.getState();
+        this.rjObject['ExternalState'] = this.externalState;
+        return this;
+    }
+    getheaderInfo() {
+        this.rjObject['Header'] = {};
+        this.rjObject['Header'].TimeZoneOffset = this.convertToString(this.generateTimezoneoffset(this.transactionDocument.createdAt));
+        this.rjObject['Header'].DateTimeCreated = this.createdAt;
+        this.rjObject['Header'].OriginatedBy = {};
+        this.rjObject['Header'].OriginatedBy.DeviceID = this.deviceId;
+        this.rjObject['Header'].OriginatedBy.CashierID = this.cashierId;
+        this.rjObject['Header'].OriginatedBy.CompanyID = this.companyId;
+        this.rjObject['Header'].OriginatedBy.StoreID = this.transactionDocument.storeId;
+        this.rjObject['Header'].OriginatedBy.BranchID = this.branchId;
+        this.rjObject['Header'].OriginatedBy.TerminalNumber = this.terminalNumber;
+        this.rjObject['Header'].OriginatedBy.TransactionNumber = this.transactionNumber;
+        this.rjObject['Header'].TaxMethodID = this.taxMethodId;
+        this.rjObject['Header'].DynamicStockLookup = this.generateDynamicStockLookUp();
+        this.rjObject['Header'].BasketLanguageID = this.basketLanguageId; //todo
+        this.rjObject['Header'].BasketCountryID = this.basketCountryId; //todo
+        this.rjObject['Header'].BasketCurrencyID = this.transactionDocument.baseCurrency;
+        this.rjObject['Header'].TradingRegionID = this.tradingRegionId;
+        this.rjObject['Header'].Eurozone = " "; //unknown
+        this.rjObject['Header'].EuroBaseExchangeRate = ""; //unknown
+        this.rjObject['Header'].PrintableName = this.transactionDocument.userName; //unknown
+        return this;
+    }
+    rjMapper() {
+        var transactionDiscount = [];
+        if (this.transactionDocument.basket.transactionDiscount && this.transactionDocument.basket.transactionDiscount.length > 0) {
+            transactionDiscount = this.transactionDocument.basket.transactionDiscount;
+        }
+        if (this.transactionDocument.type === TRANSACTION_TYPE.SALE) {
+            this.rjObject['ProductSale'] = [];
+            this.rjObject['ModifierItem'] = [];
+            this.transactionDocument.basket.products.forEach((element) => {
+                let lineDiscount = [];
+                if (this.transactionDocument.basket.lineDiscount && this.transactionDocument.basket.lineDiscount.length > 0) {
+                    lineDiscount = this.transactionDocument.basket.lineDiscount.filter((x) => x.itemLineId === element.itemLineId);
+                    if (lineDiscount.length > 0) {
+                        const index = this.transactionDocument.basket.lineDiscount.indexOf(lineDiscount[0]);
+                        if (index > -1) {
+                            this.transactionDocument.basket.lineDiscount.splice(index, 1);
+                        }
+                    }
+                }
+                let data = this.addProduct(element, (lineDiscount.length > 0 ? lineDiscount[0] : null), (transactionDiscount.length > 0 ? transactionDiscount : null));
+                this.rjObject['ProductSale'].push(data);
+                this.getModifierItem(lineDiscount.length > 0 ? lineDiscount[0] : null, element.itemLineId);
+            });
+            let transactionPromotion = [];
+            if (this.transactionDocument.basket.transactionPromotion && this.transactionDocument.basket.transactionPromotion.length > 0) {
+                transactionPromotion = this.transactionDocument.basket.transactionPromotion;
+                this.getTransactionPromotion(transactionPromotion);
+            }
+        }
+        else if (this.transactionDocument.type === TRANSACTION_TYPE.REFUND) {
+            this.rjObject['ProductReturn'] = [];
+            this.rjObject['ModifierItem'] = [];
+            this.transactionDocument.basket.products.forEach((element) => {
+                let data = this.returnProduct(element, (element.hasOwnProperty('lineDiscount') ? element.lineDiscount : null), (transactionDiscount.length > 0 ? transactionDiscount : null));
+                this.rjObject['ProductReturn'].push(data);
+                this.getModifierItem(element.lineDiscount, element.itemLineId);
+            });
+        }
+        else if (this.transactionDocument.type === TRANSACTION_TYPE.SALE_REFUND) {
+            this.rjObject['ProductReturn'] = [];
+            this.rjObject['ModifierItem'] = [];
+            let transactionDoc = new TransactionDocumentBuilder().basket(this.transactionDocument.currentTransactionDetails).build();
+            transactionDoc.basket.products.forEach((element) => {
+                let data = this.returnProduct(element, (element.hasOwnProperty('lineDiscount') ? element.lineDiscount : null), (transactionDiscount.length > 0 ? transactionDiscount : null));
+                let obj = {
+                    "OriginalReceiptSupplied": 0,
+                    "OriginalBranchID": 0,
+                    "OriginalTerminalNumber": 0,
+                    "OriginalTransactionNumber": 0,
+                    "OriginalCashierNumber": 0
+                };
+                data['Return'] = { ...data['Return'], ...obj };
+                this.rjObject['ProductReturn'].push(data);
+                this.getModifierItem(element.lineDiscount, element.itemLineId);
+            });
+        }
+        else if (this.transactionDocument.type === TRANSACTION_TYPE.SALE_EXCHANGE) {
+            this.rjObject['ProductReturn'] = [];
+            this.rjObject['ProductSale'] = [];
+            this.rjObject['ModifierItem'] = [];
+            let transactionDoc = new TransactionDocumentBuilder().basket(this.transactionDocument.currentTransactionDetails).build();
+            transactionDoc.basket.products.forEach((element) => {
+                if (element.refundedQuantity > 0) {
+                    let returnProduct = this.returnProduct(element, (element.hasOwnProperty('lineDiscount') ? element.lineDiscount : null), (transactionDiscount.length > 0 ? transactionDiscount : null));
+                    let obj = {
+                        "OriginalReceiptSupplied": 0,
+                        "OriginalBranchID": 0,
+                        "OriginalTerminalNumber": 0,
+                        "OriginalTransactionNumber": 0,
+                        "OriginalCashierNumber": 0
+                    };
+                    returnProduct['Return'] = { ...returnProduct['Return'], ...obj };
+                    this.rjObject['ProductReturn'].push(returnProduct);
+                }
+                else {
+                    let addProduct = this.addProduct(element, (element.hasOwnProperty('lineDiscount') ? element.lineDiscount : null), (transactionDiscount.length > 0 ? transactionDiscount : null));
+                    this.rjObject['ProductSale'].push(addProduct);
+                }
+                this.getModifierItem(element.lineDiscount, element.itemLineId);
+            });
+        }
+        return this;
+    }
+    getBasketDiscount() {
+        if (!this.transactionDocument.basket.transactionDiscount)
+            return this;
+        this.rjObject['BasketDiscount'] = [];
+        this.transactionDocument.basket.transactionDiscount.forEach((element) => {
+            let obj = {};
+            obj['XMLSchemaVersion'] = this.xmlSchemaVersion;
+            obj['DeviceID'] = this.deviceId;
+            obj['DateTimeCreated'] = this.updatedAt;
+            obj['NetValue'] = this.convertToString(element.discountAmount * -1);
+            obj['EffectiveNetValue'] = this.convertToString(element.discountAmount * -1);
+            obj['Description'] = element.reasonDisplayText;
+            obj['UserID'] = this.transactionDocument.userName;
+            obj['ReasonCodeID'] = element.reasonCode;
+            obj['DiscountType'] = this.convertToString(element.discountType.toUpperCase() == DISCOUNTTYPE.PERCENT.toUpperCase() ? 0 : 1);
+            obj['RoundingRule'] = this.convertToString(2);
+            obj['ModifiedLineNumber'] = element.itemLineIds;
+            obj['LineNumber'] = this.convertToString(this.generateLineNumber());
+            obj['DiscountedValue'] = this.transactionDocument.basketSummary.basketTotal + this.transactionDocument.basketSummary.discountTotal;
+            if (element.discountType.toUpperCase() == DISCOUNTTYPE.PERCENT.toUpperCase()) {
+                obj['DiscountPercentage'] = this.convertToString((element.discountAmount / this.transactionDocument.basketSummary.basketTotal).toFixed(1));
+            }
+            if (this.transactionDocument.type === 'REFUND') {
+                obj['NetValue'] = this.convertToString(element.discountAmount < 0 ? -element.discountAmount : element.discountAmount);
+                obj['EffectiveNetValue'] = this.convertToString(element.discountAmount < 0 ? -element.discountAmount : element.discountAmount);
+            }
+            this.rjObject['BasketDiscount'].push(obj);
+        });
+        return this;
+    }
+    getModifierItem(data, lineNo) {
+        if (data && lineNo) {
+            let obj = {};
+            obj.XMLSchemaVersion = 1;
+            obj.LineNumber = this.generateLineNumber();
+            obj.NetValue = 0;
+            obj.EffectiveNetValue = 0;
+            obj.Description = data.percentageDiscountReasonName ? data.percentageDiscountReasonName : data.priceOverrideReasonName;
+            obj.DeviceID = this.deviceId;
+            obj.UserID = this.transactionDocument.userName;
+            obj.DateTimeCreated = this.updatedAt;
+            obj.AuthorisingUserID = this.transactionDocument.userName;
+            obj.ReasonCodeID = data.percentageDiscountReasonCode ? data.percentageDiscountReasonCode : data.priceOverrideReasonCode;
+            obj.ModifiedLineNumber = lineNo;
+            obj.ModifiedIndex = 1;
+            this.rjObject['ModifierItem'].push(obj);
+        }
+    }
+    getTrailerInfo() {
+        this.rjObject['Trailer'] = {};
+        this.rjObject.Trailer.DateTimeCompleted = this.updatedAt;
+        this.rjObject.Trailer.CompletedBy = {};
+        this.rjObject.Trailer.CompletedBy.DeviceID = this.deviceId;
+        this.rjObject.Trailer.CompletedBy.CashierID = this.cashierId;
+        this.rjObject.Trailer.CompletedBy.StoreID = this.transactionDocument.storeId;
+        this.rjObject.Trailer.CompletedBy.BranchID = this.branchId;
+        this.rjObject.Trailer.CompletedBy.TerminalNumber = this.terminalNumber;
+        this.rjObject.Trailer.CompletedBy.TransactionNumber = this.transactionNumber;
+        this.rjObject.Trailer.Total = this.convertToString(this.transactionDocument.basketSummary.basketTotal * 100);
+        this.rjObject.Trailer.ItemCount = this.itemCount; //gives total count for product
+        this.rjObject.Trailer.ItemQuantity = this.convertToString(this.transactionDocument.basketSummary.totalItems);
+        this.rjObject.Trailer.NetItemQuantity = this.convertToString(this.transactionDocument.basketSummary.totalItems);
+        this.rjObject.Trailer.TaxTotal = this.convertToString(this.removeDecimal(this.transactionDocument.basketSummary.VATTotal));
+        this.rjObject.Trailer.SequenceDeviceID = this.deviceId;
+        this.rjObject.Trailer.SequenceNumber = 'snsn'; //static for now
+        this.rjObject['Trailer']['TaxItem'] = [];
+        this.transactionDocument.basket.taxBreakdown.taxLines.forEach((element) => {
+            let obj = {};
+            obj['XMLSchemaVersion'] = this.xmlSchemaVersion;
+            obj['TaxRate'] = this.convertToString(element.VATCode);
+            obj['TaxableTotal'] = this.convertToString(this.removeDecimal(element.taxableAmount));
+            obj['TaxTotal'] = this.convertToString(this.removeDecimal(this.removeDecimal(element.taxLineTotal)));
+            obj['TaxDescription'] = this.convertToString(element.VATCode);
+            obj['TaxIncluded'] = '1';
+            obj['TaxPercentage'] = this.addDecimal(element.VAT.toFixed(2)).toFixed(2);
+            this.rjObject['Trailer']['TaxItem'].push(obj);
+        });
+        if (this.transactionDocument.basket.linePromotion.length > 0 || this.transactionDocument.basket.linePromotion.length > 0) {
+            this.rjObject['Trailer']['PromotionItem'] = [];
+            if (this.transactionDocument.basket.linePromotion.length > 0) {
+                this.transactionDocument.basket.linePromotion.forEach((element) => {
+                    let obj = {};
+                    obj['PromotionID'] = element.promotionId;
+                    obj['PromotionSaving'] = element.promotionAmount < 0 ? element.promotionAmount : -element.promotionAmount;
+                    obj['PromotionQuantity'] = "1";
+                    obj['PromotionDescription'] = element.displayText;
+                    obj['PromotionHit'] = {};
+                    obj['PromotionHit']['XMLSchemaVersion'] = this.xmlSchemaVersion;
+                    obj['PromotionHit']['HitNumber'] = "1";
+                    obj['PromotionHit']['HitQuantity'] = "1";
+                    obj['PromotionHit']['HitSaving'] = element.promotionAmount < 0 ? element.promotionAmount : -element.promotionAmount;
+                    obj['PromotionHit']['PromotionTrigger'] = {};
+                    let product = this.transactionDocument.basket.products.find((item) => item.itemLineId == element.itemLineId);
+                    obj['PromotionHit']['PromotionTrigger']['XMLSchemaVersion'] = this.xmlSchemaVersion;
+                    obj['PromotionHit']['PromotionTrigger']['ProductID'] = product.SKU;
+                    obj['PromotionHit']['PromotionTrigger']['UnitValue'] = this.convertToString(element.promotionLinePrice / product.quantity);
+                    obj['PromotionHit']['PromotionTrigger']['LineNumber'] = this.getNumber(product.SKU);
+                    obj['PromotionHit']['PromotionTrigger']['Quantity'] = this.convertToString(product.quantity.toFixed(1));
+                    obj['PromotionHit']['PromotionTrigger']['TaxCode'] = this.transactionDocument.basket.taxBreakdown.taxLines.find((item) => item.itemLineId == element.itemLineId).VATCode;
+                    this.rjObject['Trailer']['PromotionItem'].push(obj);
+                });
+            }
+            if (this.transactionDocument.basket.transactionPromotion.length > 0) {
+                this.transactionDocument.basket.transactionPromotion.forEach((element) => {
+                    let obj = {};
+                    obj['PromotionID'] = element.promotionId;
+                    obj['PromotionSaving'] = element.promotionAmount < 0 ? element.promotionAmount : -element.promotionAmount;
+                    obj['PromotionQuantity'] = "1";
+                    obj['PromotionDescription'] = element.displayText;
+                    obj['PromotionHit'] = {};
+                    obj['PromotionHit']['XMLSchemaVersion'] = this.xmlSchemaVersion;
+                    obj['PromotionHit']['HitNumber'] = "1";
+                    obj['PromotionHit']['HitQuantity'] = "1";
+                    obj['PromotionHit']['HitSaving'] = element.promotionAmount < 0 ? element.promotionAmount : -element.promotionAmount;
+                    obj['PromotionHit']['PromotionTrigger'] = [];
+                    this.transactionDocument.basket.products.forEach((product) => {
+                        let promotionTrigger = {};
+                        element.itemLineIds.forEach((itemLineId) => {
+                            if (JSON.stringify(itemLineId) === product.itemLineId) {
+                                promotionTrigger['XMLSchemaVersion'] = this.xmlSchemaVersion;
+                                promotionTrigger['ProductID'] = product.SKU;
+                                promotionTrigger['UnitValue'] = this.convertToString(element.promotionLinePrice / product.quantity);
+                                promotionTrigger['LineNumber'] = this.getNumber(product.SKU);
+                                promotionTrigger['Quantity'] = this.convertToString(product.quantity);
+                                promotionTrigger['TaxCode'] = this.transactionDocument.basket.taxBreakdown.taxLines.find((item) => item.itemLineId == product.itemLineId).VATCode;
+                                obj['PromotionHit']['PromotionTrigger'].push(promotionTrigger);
+                            }
+                        });
+                    });
+                    this.rjObject['Trailer']['PromotionItem'].push(obj);
+                });
+            }
+        }
+        return this;
+    }
+    getTenderInfo() {
+        if (this.transactionDocument.paymentDetails && this.transactionDocument.paymentDetails.length > 0) {
+            this.transactionDocument.paymentDetails.forEach((element) => {
+                if (element.externalTenderKey) {
+                    this.rjObject[element.externalTenderKey] = [];
+                    if (element.paymentType.toUpperCase() === 'GIFT CARD') {
+                        let obj = {
+                            XMLSchemaVersion: this.xmlSchemaVersion,
+                            LineNumber: this.generateLineNumber(),
+                            NetValue: this.convertToString(-1 * this.removeDecimal((Math.round(element.amount)))),
+                            EffectiveNetValue: this.convertToString(-1 * this.removeDecimal((Math.round(element.amount)))),
+                            Description: this.getDescription(element),
+                            DeviceID: this.deviceId,
+                            UserID: this.transactionDocument.userName,
+                            DateTimeCreated: this.updatedAt,
+                            TenderType: element.externalTenderType ? element.externalTenderType : '',
+                            TenderSubType: element.externalSubTenderType ? element.externalSubTenderType : '',
+                            TenderAmount: this.convertToString(-1 * this.removeDecimal((Math.round(element.amount)))),
+                            CurrencyID: this.transactionDocument.baseCurrency,
+                            CurrencyDescription: this.transactionDocument.baseCurrency,
+                            GiftVoucherSalesAllowed: '', //todo
+                            AllowRechargeableVoucherSales: '', //todo
+                            GiftVoucherID: ''
+                        };
+                        this.rjObject[element.externalTenderKey].push(obj);
+                    }
+                    else {
+                        let obj1 = {
+                            XMLSchemaVersion: "1",
+                            LineNumber: this.generateLineNumber(), //todo
+                            NetValue: this.convertToString(-1 * this.removeDecimal(Math.round(element.amount))),
+                            EffectiveNetValue: this.convertToString(-1 * this.removeDecimal(Math.round(element.amount))),
+                            Description: this.getDescription(element),
+                            DeviceID: this.deviceId,
+                            UserID: this.transactionDocument.userName,
+                            DateTimeCreated: this.updatedAt,
+                            TenderType: element.externalTenderType ? element.externalTenderType : '',
+                            TenderSubType: element.externalSubTenderType ? element.externalSubTenderType : '',
+                            TenderAmount: this.convertToString(-1 * this.removeDecimal(Math.round(element.amount))),
+                            CurrencyID: this.transactionDocument.baseCurrency,
+                            CurrencyDescription: this.transactionDocument.baseCurrency,
+                            IncludeInTransactionTotalCheck: "1",
+                            AllowRechargeableVoucherSales: "1",
+                            OpenDrawerAtEnd: "1"
+                        };
+                        this.rjObject[element.externalTenderKey].push(obj1);
+                    }
+                }
+                else {
+                    this.rjObject['CashTender'] = [];
+                    if (element.paymentType.toUpperCase() === 'GIFT CARD') {
+                        let obj = {
+                            XMLSchemaVersion: this.xmlSchemaVersion,
+                            LineNumber: this.generateLineNumber(),
+                            NetValue: JSON.stringify(-1 * this.removeDecimal((Math.round(element.amount)))),
+                            EffectiveNetValue: JSON.stringify(-1 * this.removeDecimal((Math.round(element.amount)))),
+                            Description: this.getDescription(element),
+                            DeviceID: this.deviceId,
+                            UserID: this.transactionDocument.userName,
+                            DateTimeCreated: this.updatedAt,
+                            TenderType: element.externalTenderType ? element.externalTenderType : '',
+                            TenderSubType: element.externalSubTenderType ? element.externalSubTenderType : '',
+                            TenderAmount: JSON.stringify(-1 * this.removeDecimal((Math.round(element.amount)))),
+                            CurrencyID: this.transactionDocument.baseCurrency,
+                            CurrencyDescription: this.transactionDocument.baseCurrency,
+                            GiftVoucherSalesAllowed: '', //todo
+                            AllowRechargeableVoucherSales: '', //todo
+                            GiftVoucherID: ''
+                        };
+                        this.rjObject['CashTender'].push(obj);
+                    }
+                    else {
+                        let obj1 = {
+                            XMLSchemaVersion: "1",
+                            LineNumber: this.generateLineNumber(),
+                            NetValue: JSON.stringify(-1 * this.removeDecimal((Math.round(element.amount)))),
+                            EffectiveNetValue: JSON.stringify(-1 * this.removeDecimal((Math.round(element.amount)))),
+                            Description: this.getDescription(element),
+                            DeviceID: this.deviceId,
+                            UserID: this.transactionDocument.userName,
+                            DateTimeCreated: this.updatedAt,
+                            TenderType: element.externalTenderType ? element.externalTenderType : '',
+                            TenderSubType: element.externalSubTenderType ? element.externalSubTenderType : '',
+                            TenderAmount: JSON.stringify(-1 * this.removeDecimal((Math.round(element.amount)))),
+                            CurrencyID: this.transactionDocument.baseCurrency,
+                            CurrencyDescription: this.transactionDocument.baseCurrency,
+                            IncludeInTransactionTotalCheck: "1",
+                            AllowRechargeableVoucherSales: "1",
+                            OpenDrawerAtEnd: "1"
+                        };
+                        this.rjObject['CashTender'].push(obj1);
+                    }
+                }
+            });
+        }
+        return this;
+    }
+    getNumber(productId) {
+        let lineNumber;
+        for (let i = 0; i < this.rjObject['ProductSale'].length; i++) {
+            const element = this.rjObject['ProductSale'][i];
+            if (JSON.stringify(productId) === JSON.stringify(element.ProductID)) {
+                lineNumber = element.LineNumber;
+                break;
+            }
+        }
+        return lineNumber;
+    }
+    setLineNumberForProducts() {
+        let itemLineIdArray = [];
+        itemLineIdArray = this.transactionDocument.basket.products.map((product) => {
+            return parseInt(product.itemLineId);
+        });
+        this.largestNumber = itemLineIdArray.reduce((a, b) => Math.max(a, b));
+    }
+    generateLineNumber() {
+        this.largestNumber += 1;
+        this.itemCount += 1;
+        return this.largestNumber;
+    }
+    initilizeItemCount() {
+        this.itemCount = this.transactionDocument.basket.products.length;
+    }
+    build() {
+        return this.rjObject;
+    }
+    getDescription(element) {
+        if (element.paymentType.toUpperCase() === 'CARD') {
+            return element.cardType;
+        }
+        else {
+            return element.paymentType;
+        }
+    }
+    getMMGROUPID(attributes) {
+        if (attributes && attributes.length > 0) {
+            let filterValue = attributes.filter((attribute) => attribute.name === "MMGROUPID");
+            if (filterValue && filterValue.length > 0) {
+                return filterValue[0].value;
+            }
+        }
+    }
+    setDeviceInfo(id) {
+        this.deviceId = id;
+        return this;
+    }
+    removeDecimal(value) {
+        return value * 100;
+    }
+    addDecimal(value) {
+        return value / 100;
+    }
+    setTransactionNumber(value) {
+        this.transactionNumber = value;
+        return this;
+    }
+    setManifestVersion(value) {
+        this.manifestVersion = value;
+        return this;
+    }
+    setDatabaseSchemaVersion(value) {
+        this.databaseSchemaVersion = value;
+        return this;
+    }
+    setBasketType(value) {
+        this.basketType = value;
+        return this;
+    }
+    setTradingRegionID(value) {
+        this.tradingRegionId = value;
+        return this;
+    }
+    setCompanyID(value) {
+        this.companyId = value;
+        return this;
+    }
+    setTaxMethodID(value) {
+        this.taxMethodId = value;
+        return this;
+    }
+    setMajorVersion(value) {
+        this.majorVersion = value;
+        return this;
+    }
+    setMinorVersion(value) {
+        this.minorVersion = value;
+        return this;
+    }
+    setXMLSchemaVersion(value) {
+        this.xmlSchemaVersion = value;
+        return this;
+    }
+    setExternalState(value) {
+        this.externalState = value;
+        return this;
+    }
+    setCashierID() {
+        this.cashierId = (this.transactionDocument && this.transactionDocument.userName) ? this.transactionDocument.userName : '';
+        return this;
+    }
+    setTerminalNumber(value) {
+        this.terminalNumber = value;
+        return this;
+    }
+    setBasketLanguageID(value) {
+        this.basketLanguageId = value;
+        return this;
+    }
+    setBasketCountryID(value) {
+        this.basketCountryId = value;
+        return this;
+    }
+    setBasketCurrencyID(value) {
+        this.basketCurrencyId = value;
+        return this;
+    }
+    setBranchID(value) {
+        this.branchId = value;
+        return this;
+    }
+    setSalesPersonName(value) {
+        this.salesPersonName = value;
+        return this;
+    }
+    generateId(date) {
+        let newDateTime = date.replace(/[^0-9]/g, '');
+        let id = (this.deviceId + '|' + newDateTime + '|' + this.transactionNumber).toString();
+        return id;
+    }
+    generateTimezoneoffset(date) {
+        let x = date ? date : '';
+        return new Date(x).getTimezoneOffset();
+    }
+    generateKeyword() {
+        let x = (this.companyId + '|' + this.transactionDocument.storeId + '|' + this.terminalNumber + '|' + this.transactionNumber).toString();
+        return x;
+    }
+    getState() {
+        if (this.transactionDocument.operationStatus === 'PAY_SUCCESS') {
+            return 'Completed';
+        }
+        else {
+            return 'Cancelled';
+        }
+    }
+    returnProduct(element, lineDiscount, transactionDiscount) {
+        let obj = {};
+        let taxTotal = this.transactionDocument.basket['taxBreakdown']['taxLines'].find((item) => item.itemLineId == element['itemLineId']);
+        obj['XMLSchemaVersion'] = this.xmlSchemaVersion;
+        obj['LineNumber'] = element['itemLineId'];
+        obj['NetValue'] = this.removeDecimal(element['refundedTotal']);
+        obj['EffectiveNetValue'] = this.removeDecimal(element['refundedTotal']);
+        obj['Description'] = element['description'];
+        obj['DeviceID'] = this.transactionDocument['terminalId'];
+        obj['UserID'] = this.transactionDocument.userName;
+        obj['DateTimeCreated'] = this.createdAt;
+        obj['ExtendedValue'] = this.removeDecimal(element['totalLinePrice'] * -1);
+        obj['UnitPrice'] = this.removeDecimal(element['price']);
+        obj['Quantity'] = this.getQuantity(element);
+        obj['OriginalTaxAmountSet'] = 1;
+        obj['ProductID'] = element['SKU'];
+        obj['HandKeyed'] = 1;
+        obj['LongDescription'] = element['description'];
+        obj['Return'] = {};
+        obj['Return']['ReturnReasonID'] = element['refundedReason'];
+        obj['Return']['ReturnDescription'] = element['refundedReasonDescription'];
+        obj['Return']['ReturnToStock'] = this.getQuantity(element);
+        obj['TaxCode'] = this.transactionDocument.basket['taxBreakdown']['taxLines'].find((item) => item.itemLineId == element['itemLineId']).VATCode;
+        obj['DisplayTaxCode'] = ''; // todo
+        obj['ProductAttributes'] = ''; //todo - not required
+        obj['Perishable'] = this.getMMGROUPID(element.attributes);
+        //obj['MMGroupID'] = this.getCaregories(element);
+        obj['MMGroupID'] = this.getMMGROUPID(element.attributes);
+        obj['CustomerDetails'] = ""; // todo - blank
+        obj['TotalPromotionSaving'] = element['promotionAmount'] || -1; // TODO
+        obj['OriginalTaxAmount'] = this.convertToString((this.removeDecimal(this.getOriginalTax(element, taxTotal.VAT) * -1)).toFixed(2));
+        obj['taxAmount'] = this.removeDecimal(taxTotal.taxLineTotal < 0 ? (taxTotal.taxLineTotal) : (-taxTotal.taxLineTotal));
+        if (lineDiscount) {
+            if (lineDiscount.percentageDiscountReasonName && lineDiscount.percentageDiscountReasonCode) {
+                // line discount
+                obj['Discount'] = {};
+                obj['Discount'].ModifierValue = this.removeDecimal(lineDiscount.discountAmount) * -1;
+                obj['Discount'].ModifierDateTime = obj.DateTimeCreated;
+                obj['Discount'].ModifierReasonID = lineDiscount.percentageDiscountReasonCode;
+                obj['Discount'].ModifierDescription = lineDiscount.percentageDiscountReasonName;
+                obj['Discount'].AuthorisingUserID = this.transactionDocument.userName;
+                obj['Discount'].DiscountType = lineDiscount.discountType;
+                obj['Discount'].XMLSchemaVersion = 1;
+                obj['Discount'].OriginalPrice = this.removeDecimal(lineDiscount.discountAmount + (lineDiscount.discountedLinePrice || 0));
+                obj['Discount'].DiscountedValue = this.removeDecimal(lineDiscount.unitPrice);
+                obj['Discount'].DiscountPercentage = lineDiscount.percentageDiscountValue;
+                obj['Discount'].RoundingRule = 2;
+            }
+            if (lineDiscount.priceOverrideReasonCode && lineDiscount.priceOverrideReasonName) {
+                //price override
+                obj['PriceOverride'] = {};
+                obj['PriceOverride'].ModifierValue = this.removeDecimal(lineDiscount.discountAmount) * -1;
+                obj['PriceOverride'].ModifierDateTime = obj.DateTimeCreated;
+                obj['PriceOverride'].ModifierReasonID = lineDiscount.priceOverrideReasonCode;
+                obj['PriceOverride'].ModifierReasonDescription = lineDiscount.priceOverrideReasonName;
+                obj['PriceOverride'].AuthorisingUserID = this.transactionDocument.userName;
+                obj['PriceOverride'].XMLSchemaVersion = 1;
+                obj['PriceOverride'].NewPrice = this.removeDecimal(lineDiscount.unitPrice);
+                obj['PriceOverride'].OriginalPrice = this.removeDecimal(lineDiscount.discountedLinePrice || 0 + lineDiscount.discountAmount);
+            }
+            //update the product price
+            obj.NetValue = ((lineDiscount.discountedLinePrice || 0) + lineDiscount.discountAmount) * -1;
+            obj.EffectiveNetValue = ((lineDiscount.discountedLinePrice || 0) + lineDiscount.discountAmount) * -1;
+            obj.ExtendedValue = ((lineDiscount.discountedLinePrice || 0) + lineDiscount.discountAmount) * -1;
+            obj.UnitPrice = ((lineDiscount.discountedLinePrice || 0) + lineDiscount.discountAmount) * -1;
+        }
+        if (transactionDiscount) {
+            obj['BasketDiscountModifier'] = [];
+            this.transactionDocument.basket.transactionDiscount.forEach((e) => {
+                let discountObj = {};
+                e.itemLineIds.forEach((x) => {
+                    if (x == element.itemLineId) {
+                        var discountAmount = this.convertToString(e.discountAmount * -1);
+                        discountObj.BasketDiscountLineNumber = this.getLineNumber(e, discountAmount);
+                        discountObj.XMLSchemaVersion = this.xmlSchemaVersion;
+                        discountObj.DiscountedValue = this.getDiscountedValue(element.totalLinePrice, e.discountAmount);
+                        obj['BasketDiscountModifier'].push(discountObj);
+                    }
+                });
+            });
+            var totaltransactionDiscount = 0;
+            obj['BasketDiscountModifier'].forEach((value) => {
+                totaltransactionDiscount = totaltransactionDiscount + value.DiscountedValue;
+            });
+            //update the product price
+            obj['EffectiveNetValue'] = obj.EffectiveNetValue + totaltransactionDiscount;
+        }
+        if (this.transactionDocument.basket.transactionPromotion.length > 0) {
+            obj['PromotionSaving'] = [];
+            this.transactionDocument.basket.transactionPromotion.forEach((transactionPromo) => {
+                let promotionObj = {};
+                transactionPromo.itemLineIds.forEach((itemLineId) => {
+                    if (itemLineId == element.itemLineId) {
+                        promotionObj.ModifierValue = transactionPromo.promotionAmount;
+                        promotionObj.ModifierDateTime = this.transactionDocument.createdAt;
+                        promotionObj.ModifierDescription = transactionPromo.displayText;
+                        promotionObj.XMLSchemaVersion = this.xmlSchemaVersion;
+                        promotionObj.PromotionID = transactionPromo.promotionId;
+                        promotionObj.PromotionDescription = transactionPromo.displayText;
+                        promotionObj.HitNumber = '1';
+                        promotionObj.PromotionHitProductQuantity = this.getQuantity(element);
+                        promotionObj.PromotionHitQuantity = this.getQuantity(element) * -1;
+                        obj['PromotionSaving'].push(promotionObj);
+                    }
+                });
+            });
+        }
+        return obj;
+    }
+    addProduct(element, lineDiscount, transactionDiscount) {
+        let taxTotal = this.transactionDocument.basket['taxBreakdown']['taxLines'].find((item) => item.itemLineId == element['itemLineId']);
+        let obj = {
+            XMLSchemaVersion: this.xmlSchemaVersion,
+            LineNumber: element.itemLineId,
+            NetValue: this.removeDecimal(element.totalLinePrice),
+            EffectiveNetValue: this.removeDecimal(element.totalLinePrice),
+            Description: element.description,
+            DeviceID: this.deviceId,
+            UserID: this.transactionDocument.userName,
+            DateTimeCreated: this.createdAt,
+            ExtendedValue: this.removeDecimal(element.price),
+            UnitPrice: this.removeDecimal(element.price),
+            //MMGroupID: this.getCaregories(element),
+            Quantity: element.quantity,
+            SalespersonID: this.transactionDocument.userName,
+            SalespersonName: this.salesPersonName,
+            TaxCode: this.transactionDocument.basket['taxBreakdown']['taxLines'].find((item) => item.itemLineId == element['itemLineId']).VATCode,
+            TaxModifiable: "1", //todo
+            OriginalTaxAmount: this.convertToString((this.removeDecimal(this.getOriginalTax(element, taxTotal.VAT)).toFixed(2))),
+            TaxAmount: this.convertToString(this.removeDecimal(taxTotal.taxLineTotal)),
+            OriginalTaxAmountSet: "1", //todo
+            ProductID: element.SKU,
+            HandKeyed: "1", //todo
+            CustomerDetails: "",
+            Perishable: this.getMMGROUPID(element.attributes),
+            MMGroupID: this.getMMGROUPID(element.attributes)
+        };
+        if (lineDiscount) {
+            if (lineDiscount.percentageDiscountReasonName && lineDiscount.percentageDiscountReasonCode) {
+                // line discount
+                obj['Discount'] = {};
+                obj['Discount'].ModifierValue = this.removeDecimal(lineDiscount.discountAmount) * -1;
+                obj['Discount'].ModifierDateTime = obj.DateTimeCreated;
+                obj['Discount'].ModifierReasonID = lineDiscount.percentageDiscountReasonCode;
+                obj['Discount'].ModifierDescription = lineDiscount.percentageDiscountReasonName;
+                obj['Discount'].AuthorisingUserID = this.transactionDocument.userName;
+                obj['Discount'].DiscountType = lineDiscount.discountType;
+                obj['Discount'].XMLSchemaVersion = 1;
+                obj['Discount'].OriginalPrice = this.removeDecimal(lineDiscount.discountAmount + (lineDiscount.discountedLinePrice || 0));
+                obj['Discount'].DiscountedValue = this.removeDecimal(lineDiscount.unitPrice);
+                obj['Discount'].DiscountPercentage = lineDiscount.percentageDiscountValue;
+                obj['Discount'].RoundingRule = 2;
+            }
+            if (lineDiscount.priceOverrideReasonCode && lineDiscount.priceOverrideReasonName) {
+                //price override
+                obj['PriceOverride'] = {};
+                obj['PriceOverride'].ModifierValue = this.removeDecimal(lineDiscount.discountAmount) * -1;
+                obj['PriceOverride'].ModifierDateTime = obj.DateTimeCreated;
+                obj['PriceOverride'].ModifierReasonID = lineDiscount.priceOverrideReasonCode;
+                obj['PriceOverride'].ModifierReasonDescription = lineDiscount.priceOverrideReasonName;
+                obj['PriceOverride'].AuthorisingUserID = this.transactionDocument.userName;
+                obj['PriceOverride'].XMLSchemaVersion = this.xmlSchemaVersion;
+                obj['PriceOverride'].NewPrice = this.removeDecimal(lineDiscount.unitPrice);
+                obj['PriceOverride'].OriginalPrice = this.removeDecimal(lineDiscount.discountedLinePrice || 0 + lineDiscount.discountAmount);
+            }
+            //update the product price
+            obj['NetValue'] = ((lineDiscount.discountedLinePrice || 0) + lineDiscount.discountAmount);
+            obj['EffectiveNetValue'] = ((lineDiscount.discountedLinePrice || 0) + lineDiscount.discountAmount);
+            obj['ExtendedValue'] = ((lineDiscount.discountedLinePrice || 0) + lineDiscount.discountAmount);
+            obj['UnitPrice'] = ((lineDiscount.discountedLinePrice || 0) + lineDiscount.discountAmount);
+        }
+        if (transactionDiscount) {
+            obj['BasketDiscountModifier'] = [];
+            this.transactionDocument.basket.transactionDiscount.forEach((e) => {
+                let discountObj = {};
+                e.itemLineIds.forEach((itemLineId) => {
+                    if (itemLineId == element.itemLineId) {
+                        let discountAmount = this.convertToString(e.discountAmount * -1);
+                        discountObj.XMLSchemaVersion = this.xmlSchemaVersion;
+                        discountObj.DiscountedValue = -(this.getDiscountedValue(element.totalLinePrice, e.discountAmount));
+                        discountObj.BasketDiscountLineNumber = this.getLineNumber(e, discountAmount);
+                        obj['BasketDiscountModifier'].push(discountObj);
+                    }
+                });
+            });
+            let totaltransactionDiscount = 0;
+            obj['BasketDiscountModifier'].forEach((value) => {
+                totaltransactionDiscount = totaltransactionDiscount + value.DiscountedValue;
+            });
+            //update the product price
+            obj['EffectiveNetValue'] = obj.EffectiveNetValue + totaltransactionDiscount;
+        }
+        if (this.transactionDocument.basket.transactionPromotion.length > 0 || this.transactionDocument.basket.linePromotion.length > 0) {
+            obj['DistributedPromotionSaving'] = [];
+            if (this.transactionDocument.basket.transactionPromotion.length > 0) {
+                this.transactionDocument.basket.transactionPromotion.forEach((e) => {
+                    let promotionObj = {};
+                    e.itemLineIds.forEach((itemLineId) => {
+                        if (itemLineId == element.itemLineId) {
+                            promotionObj.PromotionID = e.promotionId;
+                            promotionObj.Hit = '1';
+                            promotionObj.Saving = this.getSaving(element.totalLinePrice, e.promotionAmount);
+                            promotionObj.ISaving = this.getSaving(element.totalLinePrice, e.promotionAmount);
+                            obj['DistributedPromotionSaving'].push(promotionObj);
+                        }
+                    });
+                });
+            }
+            if (this.transactionDocument.basket.linePromotion.length > 0) {
+                this.transactionDocument.basket.linePromotion.forEach((linePromotion) => {
+                    let promotionObj = {};
+                    if (element.itemLineId == linePromotion.itemLineId) {
+                        promotionObj.PromotionID = linePromotion.promotionId;
+                        promotionObj.Hit = "1";
+                        promotionObj.Saving = linePromotion.promotionLinePrice;
+                        promotionObj.ISaving = linePromotion.promotionLinePrice;
+                        obj['DistributedPromotionSaving'].push(promotionObj);
+                    }
+                });
+            }
+            let transactionPromotion = 0;
+            obj['DistributedPromotionSaving'].forEach((value) => {
+                transactionPromotion = transactionPromotion + value.Saving;
+            });
+            obj['EffectiveNetValue'] = obj.EffectiveNetValue + transactionPromotion;
+        }
+        return obj;
+    }
+    getSaving(price, promotionAmount) {
+        let Saving = (price * promotionAmount) / this.transactionDocument.basketSummary.saleTotal;
+        return Saving;
+    }
+    getLineNumber(value, discountAmount) {
+        let lineNumber;
+        for (let i = 0; i < this.rjObject['BasketDiscount'].length; i++) {
+            const element = this.rjObject['BasketDiscount'][i];
+            if (value.reasonCode === element.ReasonCodeID && discountAmount === element.NetValue) {
+                lineNumber = element.LineNumber;
+                break;
+            }
+        }
+        return lineNumber;
+    }
+    getDiscountedValue(price, discountAmount) {
+        let DiscountedValue = ((price * discountAmount) / this.transactionDocument.basketSummary.saleTotal) * 100;
+        return DiscountedValue;
+    }
+    getOriginalTax(element, VAT) {
+        let pricebeforetax = (element.price * 100) / (100 + VAT);
+        let originaltax = element.price - pricebeforetax;
+        return originaltax;
+    }
+    convertToString(value) {
+        try {
+            value = JSON.stringify(value);
+            return value;
+        }
+        catch (e) {
+            console.log(value, 'can not be converted in string', e);
+        }
+    }
+    generateDynamicStockLookUp() {
+        let x = '0';
+        this.transactionDocument.basket.products.forEach((element) => {
+            if (element.deliveryMethod === '1' || element.deliveryMethod === '2') {
+                x = '1';
+            }
+        });
+        return x;
+    }
+    // getAttributes(){
+    //     let name: string | any[] = []
+    //     this.transactionDocument.basket.products.forEach((element: any) => {
+    //         if (element && element.attributes && element.attributes.length > 0) {
+    //             name = element.attributes.filter((x: any) => x.name.toUpperCase() === element.name.toUpperCase());
+    //         }
+    //     });
+    //     if (name.length > 0) {
+    //         return name[0].value
+    //     }
+    //     else{
+    //         return ""
+    //     }
+    // }
+    // getCaregories(element) {
+    //     let MMGroupId = " ";
+    //     if (element.categories && element.categories.length > 0) {
+    //         let categories = element.categories.filter((x) => x.parentId != '');
+    //         let value = categories.filter((x) => x.id != x.parentId);
+    //         MMGroupId = value[0].name;
+    //     }
+    //     return MMGroupId;
+    // }
+    getDate(date) {
+        let offset = this.generateTimezoneoffset(date) * -1;
+        let offsetHours = Math.abs(Math.floor(offset / 60));
+        let offsetMinutes = Math.abs(offset) - offsetHours * 60;
+        let offsetSign = '+';
+        if (offset < 0) {
+            offsetSign = '-';
+        }
+        let newdate = date.substring(0, 19);
+        const x = (newdate + offsetSign + String(offsetHours).padStart(2, '0') + ':' + String(offsetMinutes).padStart(2, '0')).toString();
+        return x;
+    }
+    getTransactionPromotion(transactionPromotion) {
+        if (transactionPromotion && transactionPromotion.length > 0) {
+            this.rjObject['PromoVoucherItem'] = {};
+            this.rjObject['PromoVoucherItem']['XMLSchemaVersion'] = this.xmlSchemaVersion;
+            this.rjObject['PromoVoucherItem']['LineNumber'] = this.generateLineNumber();
+            this.rjObject['PromoVoucherItem']['NetValue'] = this.removeDecimal(transactionPromotion[0].promotionLinePrice) * -1;
+            this.rjObject['PromoVoucherItem']['EffectiveNetValue'] = this.removeDecimal(transactionPromotion[0].promotionLinePrice) * -1;
+            this.rjObject['PromoVoucherItem']['Description'] = transactionPromotion[0].promotionInfo;
+            this.rjObject['PromoVoucherItem']['DeviceID'] = this.deviceId;
+            this.rjObject['PromoVoucherItem']['UserID'] = this.transactionDocument.userName;
+            this.rjObject['PromoVoucherItem']['DateTimeCreated'] = this.createdAt;
+            this.rjObject['PromoVoucherItem']['ProductId'] = ""; //todo
+            this.rjObject['PromoVoucherItem']['SerialNumber'] = ""; //todo
+            this.rjObject['PromoVoucherItem']['MMGroupId'] = "";
+        }
+    }
+    getQuantity(element) {
+        let quantity;
+        if (this.transactionDocument.unreferencedRefund) {
+            quantity = element['quantity'] < 0 ? element['quantity'] : (-element['quantity']);
+        }
+        else {
+            quantity = element['refundedQuantity'] < 0 ? element['refundedQuantity'] : (-element['refundedQuantity']);
+        }
+        return quantity;
+    }
+}
+
+class WebReturnMapperBuilderClass {
+    constructor(document, currencyPipe) {
+        this.currencyPipe = currencyPipe;
+        this.webReturnObject = {
+            id: '',
+            orgCode: "",
+            storeId: "",
+            storeNodeId: "",
+            storeNodeStructure: "",
+            deviceId: "",
+            terminalId: "",
+            initiatingModule: "",
+            export: false,
+            isInStoreOrder: false,
+            basket: {},
+            basketSummary: {},
+            baseCurrency: "",
+            customer: {
+                firstName: '',
+                lastName: '',
+                email: '',
+                postCode: '',
+                id: '',
+                billingAddress: {},
+                shippingAddress: {},
+            },
+            currentTransactionDetails: {}
+        };
+        if (document) {
+            this.document = document;
+        }
+        this.numberUtilService = new NumberUtilService(currencyPipe);
+    }
+    WebReturnMapper() {
+        this.webReturnObject['type'] = 'WEB_RETURNS';
+        this.webReturnObject['datetime'] = this.getUTCDateTime(this.getText(this.document.updated_at));
+        this.webReturnObject.baseCurrency = this.getText(this.document.base_currency_code);
+        this.webReturnObject.storeId = this.getText(this.document.store_id);
+        this.webReturnObject.subsidiaryId = '1';
+        this.webReturnObject.initiatingModule = 'MAGENTO';
+        this.webReturnObject.createdAt = this.getUTCDateTime(this.getText(this.document.created_at));
+        this.webReturnObject.updatedAt = this.getUTCDateTime(this.getText(this.document.updated_at));
+        this.webReturnObject.export = true;
+        this.webReturnObject.transCompletedAt = this.getUTCDateTime(this.getText(this.document.updated_at));
+        this.webReturnObject['externalTransactionId'] = this.getText(this.document.order_id);
+        // customer
+        this.webReturnObject['customer']['firstName'] = this.getText(this.document.customer_firstname) || '';
+        this.webReturnObject['customer']['lastName'] = this.getText(this.document.customer_lastname) || '';
+        this.webReturnObject['customer']['email'] = this.getText(this.document.customer_email) || '';
+        this.webReturnObject['customer']['postCode'] = '';
+        // Billing address
+        this.webReturnObject['customer']['billingAddress']['address1'] = (this.document.billing_address && this.document.billing_address.street) ? this.getText(this.document.billing_address.street) : '';
+        this.webReturnObject['customer']['billingAddress']['city'] = (this.document.billing_address && this.document.billing_address.city) ? this.getText(this.document.billing_address.city) : '';
+        this.webReturnObject['customer']['billingAddress']['county'] = (this.document.billing_address && this.document.billing_address.region) ? this.getText(this.document.billing_address.region) : '';
+        this.webReturnObject['customer']['billingAddress']['postCode'] = (this.document.billing_address && this.document.billing_address.postcode) ? this.getText(this.document.billing_address.postcode) : '';
+        this.webReturnObject['customer']['billingAddress']['country'] = (this.document.billing_address && this.document.billing_address.country) ? this.getText(this.document.billing_address.country) : '';
+        // Shipping address
+        this.webReturnObject['customer']['shippingAddress']['address1'] = (this.document.shipping_address && this.document.shipping_address.street) ? this.getText(this.document.shipping_address.street) : '';
+        this.webReturnObject['customer']['shippingAddress']['city'] = (this.document.shipping_address && this.document.shipping_address.city) ? this.getText(this.document.shipping_address.city) : '';
+        this.webReturnObject['customer']['shippingAddress']['county'] = (this.document.shipping_address && this.document.shipping_address.region) ? this.getText(this.document.shipping_address.region) : '';
+        this.webReturnObject['customer']['shippingAddress']['postCode'] = (this.document.shipping_address && this.document.shipping_address.postcode) ? this.getText(this.document.shipping_address.postcode) : '';
+        this.webReturnObject['customer']['shippingAddress']['country'] = (this.document.shipping_address && this.document.shipping_address.country) ? this.getText(this.document.shipping_address.country) : '';
+        // basketSummary 
+        this.webReturnObject.basketSummary['discountTotal'] = Math.abs(Number(this.document.discount_amount ? this.getText(this.document.discount_amount) : 0));
+        this.webReturnObject.basketSummary['VATTotal'] = Number(this.document.base_total_paid ? this.getText(this.document.base_total_paid) : 0);
+        this.webReturnObject.basketSummary['saleTotal'] = Number(this.document.base_total_invoiced ? this.getText(this.document.base_total_invoiced) : 0);
+        this.webReturnObject.basketSummary['basketTotal'] = Number(this.document.base_total_paid ? this.getText(this.document.base_total_paid) : 0);
+        this.webReturnObject.basketSummary['totalItems'] = Number(this.document.total_qty_ordered ? this.getText(this.document.total_qty_ordered) : 0);
+        this.webReturnObject.basketSummary['refundTotal'] = Number(this.document.base_total_refunded ? this.getText(this.document.base_total_refunded) : 0);
+        // // basket line discount
+        // this.webReturnObject.basket['lineDiscount'] = [];
+        // let lineDiscount = {
+        //     itemLineId: (this.document.items && this.document.items.item && this.document.items.item.item_id) ? this.getText(this.document.items.item.item_id) : 0,
+        //     discountAmount: (this.document.items && this.document.items.item && this.document.items.item.discount_amount) ? Number(this.getText(this.document.items.item.discount_amount)) : 0
+        // }
+        // this.webReturnObject.basket['lineDiscount'].push(lineDiscount);
+        // basket transaction discount
+        // basket products 
+        this.webReturnObject.basket['products'] = [];
+        this.webReturnObject.basket['linePromotion'] = [];
+        this.webReturnObject.basket['transactionDiscount'] = [];
+        this.webReturnObject.basket['transactionPromotion'] = [];
+        // let transactionDiscount = {
+        //     discountAmount: (this.document && this.document.discount_amount) ? Number(this.getText(this.document.discount_amount)) : 0
+        // }
+        // this.webReturnObject.basket['transactionDiscount'].push(transactionDiscount);
+        let product = {};
+        if (this.document.items && this.document.items.item) {
+            if (this.document.items.item instanceof Array) {
+                this.document.items.item.forEach((element, index) => {
+                    let qty = this.getText(element.qty_ordered) ? Number(this.getText(element.qty_ordered)) : 0;
+                    let refundQty = this.getText(element.qty_refunded) ? Number(this.getText(element.qty_refunded)) : 0;
+                    let price = this.getText(element.price_incl_tax) ? Number(this.getText(element.price_incl_tax)) : 0;
+                    product = {
+                        description: (element.name) ? this.getText(element.name) : '',
+                        SKU: (element.sku) ? this.getText(element.sku) : '',
+                        quantity: (element.qty_ordered) ? Number(this.getText(element.qty_ordered)) : 0,
+                        refundedQuantity: (element.qty_refunded) ? Number(this.getText(element.qty_refunded)) : 0,
+                        //price: (element.original_price) ? Number(this.getText(element.original_price)) : 0,
+                        price: price,
+                        itemLineId: (index + 1).toString(),
+                        // totalLinePrice: (element.row_invoiced) ? Number(this.getText(element.row_invoiced)) : 0,
+                        totalLinePrice: ((qty - refundQty) * price),
+                    };
+                    let promotionAmount = this.getText(element.discount_amount) ? Number(this.getText(element.discount_amount)) : 0;
+                    let appliedIDs = this.getText(element.applied_rule_ids) ? this.getText(element.applied_rule_ids) : '';
+                    if (product && product.price != 0) {
+                        if (promotionAmount) {
+                            let trigger = {};
+                            trigger.itemLineId = product.itemLineId;
+                            trigger.quantity = product.quantity ? product.quantity : 0;
+                            let promotion = {
+                                promotionAmount: promotionAmount,
+                                promotionId: appliedIDs,
+                                itemLineId: product.itemLineId,
+                                promotionLinePrice: product.totalLinePrice - promotionAmount,
+                                trigger: trigger
+                            };
+                            this.webReturnObject.basket['linePromotion'].push(promotion);
+                        }
+                        this.webReturnObject.basket['products'].push(product);
+                    }
+                });
+            }
+            else {
+                let qty = (this.document.items && this.document.items.item && this.document.items.item.qty_ordered) ? Number(this.getText(this.document.items.item.qty_ordered)) : 0;
+                let refundQty = (this.document.items && this.document.items.item && this.document.items.item.qty_refunded) ? Number(this.getText(this.document.items.item.qty_refunded)) : 0;
+                let price = (this.document.items && this.document.items.item && this.document.items.item.price_incl_tax) ? Number(this.getText(this.document.items.item.price_incl_tax)) : 0;
+                product = {
+                    description: (this.document.items && this.document.items.item && this.document.items.item.name) ? this.getText(this.document.items.item.name) : '',
+                    SKU: (this.document.items && this.document.items.item && this.document.items.item.sku) ? this.getText(this.document.items.item.sku) : '',
+                    quantity: (this.document.items && this.document.items.item && this.document.items.item.qty_ordered) ? Number(this.getText(this.document.items.item.qty_ordered)) : 0,
+                    refundedQuantity: (this.document.items && this.document.items.item && this.document.items.item.qty_refunded) ? Number(this.getText(this.document.items.item.qty_refunded)) : 0,
+                    // price: (this.document.items && this.document.items.item && this.document.items.item.original_price) ? Number(this.getText(this.document.items.item.original_price)) : 0,
+                    price: price,
+                    itemLineId: "1",
+                    // totalLinePrice: (this.document.items && this.document.items.item && this.document.items.item.row_invoiced) ? Number(this.getText(this.document.items.item.row_invoiced)) : 0,
+                    totalLinePrice: ((qty - refundQty) * price),
+                };
+                let promotionAmount = this.getText(this.document.items.item.discount_amount) ? Number(this.getText(this.document.items.item.discount_amount)) : 0;
+                let appliedIDs = this.getText(this.document.items.item.applied_rule_ids) ? this.getText(this.document.items.item.applied_rule_ids) : '';
+                if (product && product.price != 0) {
+                    if (promotionAmount) {
+                        let trigger = {};
+                        trigger.itemLineId = product.itemLineId;
+                        trigger.quantity = product.quantity ? product.quantity : 0;
+                        let promotion = {
+                            promotionAmount: promotionAmount,
+                            promotionId: appliedIDs,
+                            itemLineId: product.itemLineId,
+                            promotionLinePrice: product.totalLinePrice - promotionAmount,
+                            trigger: trigger
+                        };
+                        this.webReturnObject.basket['linePromotion'].push(promotion);
+                    }
+                    this.webReturnObject.basket['products'].push(product);
+                }
+            }
+            let couponCode = this.getText(this.document.coupon_code) ? this.getText(this.document.coupon_code) : 0;
+            let appliedIDs = this.getText(this.document.applied_rule_ids) ? this.getText(this.document.applied_rule_ids) : '';
+            let discountDescription = this.getText(this.document.discount_description) ? this.getText(this.document.discount_description) : '';
+            let couponTriggerPromotions = [];
+            if (couponCode && appliedIDs) {
+                let transactionPromotion = {};
+                if (this.webReturnObject.basket['linePromotion'] && this.webReturnObject.basket['linePromotion'].length > 0) {
+                    this.webReturnObject.basket['linePromotion'].forEach((promotion) => {
+                        if (promotion.promotionId === appliedIDs) {
+                            let trigger = {};
+                            trigger.itemLineId = promotion.itemLineId;
+                            trigger.quantity = promotion.trigger.quantity;
+                            trigger.totalQuantity = promotion.trigger.quantity;
+                            trigger.promotionAmount = promotion.promotionAmount;
+                            trigger.refundedReason = couponCode;
+                            trigger.refundedReasonDescription = discountDescription;
+                            trigger.promotionId = promotion.promotionId;
+                            couponTriggerPromotions.push(trigger);
+                            this.webReturnObject.basket['linePromotion'] = this.webReturnObject.basket['linePromotion'].filter((x) => x.itemLineId !== promotion.itemLineId);
+                        }
+                    });
+                }
+                if (couponTriggerPromotions.length > 0) {
+                    transactionPromotion.displayText = couponTriggerPromotions[0].refundedReasonDescription;
+                    transactionPromotion.name = couponTriggerPromotions[0].refundedReason;
+                    transactionPromotion.promotionAmount = -(couponTriggerPromotions.reduce((n, { promotionAmount }) => n + promotionAmount, 0));
+                    transactionPromotion.promotionId = couponTriggerPromotions[0].promotionId;
+                    transactionPromotion.promotionInfo = couponTriggerPromotions[0].refundedReasonDescription;
+                    transactionPromotion.couponCode = couponCode;
+                    transactionPromotion.itemLineIds = [];
+                    transactionPromotion.type = PROMOTION_TYPE.COUPON;
+                    transactionPromotion.subLevelType = PROMOTION_LEVEL.LINE;
+                    transactionPromotion.trigger = couponTriggerPromotions;
+                }
+                console.log("e-basket: update LinePromotion With Coupon", JSON.stringify(transactionPromotion));
+                if (!this.webReturnObject.basket.transactionPromotion) {
+                    this.webReturnObject.basket.transactionPromotion = [];
+                }
+                if (transactionPromotion && transactionPromotion.promotionId) {
+                    this.webReturnObject.basket.transactionPromotion.push(transactionPromotion);
+                }
+            }
+            this.updateTransactionPromotionPrtionCalc();
+        }
+        return this;
+    }
+    validateProductItemDiscount(product) {
+        if (!product.itemDiscounts) {
+            product.itemDiscounts = {
+                trnDiscountsPortion: 0,
+                trnPromotionsPortion: 0,
+                refundPortion: 0,
+            };
+        }
+        return product;
+    }
+    transactionPromotionProductPortionCalc(txDoc, promotion) {
+        console.log(`ebasket: transactionPromotionProductPortionCalc: trnsactionPromotion: ${JSON.stringify(promotion)}`);
+        if (promotion.type === PROMOTION_TYPE.COUPON && promotion.subLevelType === PROMOTION_LEVEL.LINE) {
+            txDoc.basket.products.forEach((product) => {
+                product = this.validateProductItemDiscount(product);
+                if (promotion.trigger && promotion.trigger.length > 0) {
+                    promotion.trigger.forEach((t) => {
+                        if (t.itemLineId === product.itemLineId.toString()) {
+                            product.itemDiscounts.trnPromotionsPortion += t.promotionAmount;
+                        }
+                    });
+                }
+            });
+        }
+        else {
+            txDoc.basket.products.forEach((product) => {
+                product = this.validateProductItemDiscount(product);
+                if (promotion.itemLineIds.includes(+product.itemLineId)) {
+                    let discountAmount = 0;
+                    if (this.document.items.item instanceof Array) {
+                        const productItem = this.document.items.item.find(productItem => productItem.sku === product.SKU);
+                        discountAmount = productItem.discount_amount ? +productItem.discount_amount : 0;
+                    }
+                    else {
+                        discountAmount = this.document.items.item.sku === product.SKU && this.document.items.item.discount_amount ?
+                            +this.document.items.item.discount_amount : 0;
+                    }
+                    const transactionPromotionPortion = discountAmount;
+                    product.itemDiscounts.trnPromotionsPortion += this.numberUtilService.trimTo2Decimal2(transactionPromotionPortion);
+                }
+            });
+        }
+        return txDoc;
+    }
+    updateTransactionPromotionPrtionCalc() {
+        try {
+            if (this.webReturnObject.basket.transactionPromotion && this.webReturnObject.basket.transactionPromotion.length > 0) {
+                this.webReturnObject.basket.transactionPromotion.forEach(tr => {
+                    this.transactionPromotionProductPortionCalc(this.webReturnObject, tr);
+                });
+            }
+        }
+        catch (error) {
+            console.log("updateTransactionPromotionPrtionCalc => failed:", JSON.stringify(error));
+        }
+    }
+    deviceId(deviceId) {
+        this.webReturnObject.deviceId = deviceId;
+        return this;
+    }
+    terminalId(terminalId) {
+        this.webReturnObject.terminalId = terminalId;
+        return this;
+    }
+    orgCode(orgCode) {
+        this.webReturnObject.orgCode = orgCode;
+        return this;
+    }
+    storeId(storeId) {
+        this.webReturnObject.storeId = storeId;
+        return this;
+    }
+    storeNodeId(storeNodeId) {
+        this.webReturnObject.storeNodeId = storeNodeId;
+        return this;
+    }
+    storeNodeStructure(storeNodeStructure) {
+        this.webReturnObject.storeNodeStructure = storeNodeStructure;
+        return this;
+    }
+    docId(docId) {
+        this.webReturnObject.id = docId;
+        return this;
+    }
+    updateUserID(userID) {
+        this.webReturnObject.userId = userID;
+        return this;
+    }
+    updateUserName(name) {
+        this.webReturnObject.userName = name;
+        return this;
+    }
+    build() {
+        return this.webReturnObject;
+    }
+    getText(obj) {
+        if (obj && obj.text) {
+            return obj.text;
+        }
+        else {
+            return obj;
+        }
+    }
+    getUTCDateTime(date) {
+        if (date) {
+            return new Date(date).toISOString();
+        }
+    }
+    isInStoreOrder() {
+        console.log("Mapper library: WebReturnMapperBuilderClass: isInStoreOrder mapping started...");
+        if (this.document.payment && this.document.payment.method && this.document.payment.method === 'pos_order') {
+            this.webReturnObject.isInStoreOrder = true;
+        }
+        console.log("Mapper library: WebReturnMapperBuilderClass: isInStoreOrder mapping ended...");
+        return this;
+    }
+}
+
+class WebReturnSalesforceMapperBuilderClass {
+    constructor(orderDetails, currencyPipe) {
+        this.currencyPipe = currencyPipe;
+        this.webReturnObject = {
+            id: '',
+            orgCode: "",
+            storeId: "",
+            storeNodeId: "",
+            storeNodeStructure: "",
+            deviceId: "",
+            terminalId: "",
+            initiatingModule: "",
+            export: false,
+            isInStoreOrder: false,
+            basket: {},
+            basketSummary: {},
+            baseCurrency: "",
+            customer: {
+                id: '',
+                email: '',
+                firstName: '',
+                lastName: '',
+                billingAddress: [],
+                shippingAddress: [],
+                shipmentDetails: [],
+                telephone: '',
+                postCode: '',
+                noCustomerSelected: false
+            },
+            currentTransactionDetails: {}
+        };
+        if (orderDetails) {
+            this.orderDetails = orderDetails;
+        }
+        this.numberUtilService = new NumberUtilService(currencyPipe);
+    }
+    webReturnCommonMapper() {
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: webReturnCommonMapper started...");
+        this.webReturnObject['type'] = TRANSACTION_TYPE.WEB_RETURNS;
+        this.webReturnObject['datetime'] = this.getUTCDateTime(this.orderDetails.last_modified);
+        this.webReturnObject.baseCurrency = this.orderDetails.currency;
+        this.webReturnObject.subsidiaryId = '1';
+        this.webReturnObject.export = true;
+        this.webReturnObject.initiatingModule = INITIATING_MODULE.EBASKET;
+        this.webReturnObject.createdAt = this.getUTCDateTime(this.orderDetails.creation_date);
+        this.webReturnObject.updatedAt = this.getUTCDateTime(this.orderDetails.last_modified);
+        this.webReturnObject.transCompletedAt = this.getUTCDateTime(this.orderDetails.last_modified);
+        this.webReturnObject['externalTransactionId'] = this.orderDetails.order_no;
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: webReturnCommonMapper ended...");
+        return this;
+    }
+    // export(status, details) {
+    //     console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: export mapping started...");
+    //     console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: status:", status);
+    //     console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: details:", JSON.stringify(details));
+    //     if (status && details && details.providers && details.providers.length > 0) {
+    //         details.providers.forEach(
+    //             providerObj => {
+    //                 if (providerObj.provider && providerObj.provider === PROVIDERS.SALESFORCE) {
+    //                     this.webReturnObject.export = true;
+    //                 } else {
+    //                     this.webReturnObject.export = false;
+    //                 }
+    //             }
+    //         );
+    //     } else {
+    //         this.webReturnObject.export = false;
+    //     }
+    //     console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: export mapping end...")
+    //     return this;
+    // }
+    getDeliveryMethod() {
+        if (this.orderDetails.shipments && this.orderDetails.shipments.length > 0) {
+            const shipToStoreShipment = this.orderDetails.shipments.find(shipment => shipment.c_fromStoreId);
+            if (shipToStoreShipment)
+                return DELIVERY_METHODS.SHIP_TO_STORE;
+            else
+                return DELIVERY_METHODS.DELIVERY;
+        }
+        else {
+            return '';
+        }
+    }
+    product() {
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: product mapping started...");
+        this.webReturnObject.basket['products'] = [];
+        if (this.orderDetails.product_items && this.orderDetails.product_items.length > 0) {
+            this.orderDetails.product_items.forEach((product, index) => {
+                const productObj = {
+                    description: product.item_text ? product.item_text : '',
+                    SKU: product.product_id ? product.product_id : '',
+                    quantity: product.quantity ? product.quantity : 0,
+                    refundedQuantity: 0,
+                    price: product.base_price ? product.base_price : 0,
+                    itemLineId: (index + 1).toString(),
+                    deliveryMethod: this.getDeliveryMethod().toString(),
+                    totalLinePrice: product.price ? product.price : 0
+                };
+                if (product && product.price != 0) {
+                    this.webReturnObject.basket['products'].push(productObj);
+                }
+            });
+        }
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: product mapping ended...");
+        return this;
+    }
+    linePromotion() {
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: linePromotion mapping started...");
+        this.webReturnObject.basket.linePromotion = [];
+        let linePromotionArray = [];
+        if (this.orderDetails.product_items && this.orderDetails.product_items.length > 0) {
+            this.orderDetails.product_items.forEach((product, index) => {
+                product.item_id = (index + 1).toString();
+                if (product.price_adjustments && product.price_adjustments.length > 0) {
+                    product.price_adjustments.forEach((promotion) => {
+                        if (!promotion.coupon_code) {
+                            let linePromotionObj = {};
+                            let trigger = {};
+                            trigger.itemLineId = product.item_id;
+                            trigger.quantity = product.quantity ? product.quantity : 0;
+                            linePromotionObj.trigger = [];
+                            linePromotionObj.trigger.push(trigger);
+                            linePromotionObj.itemLineId = index + 1;
+                            linePromotionObj.promotionId = promotion.promotion_id ? promotion.promotion_id : '';
+                            linePromotionObj.displayText = promotion.item_text ? promotion.item_text : '';
+                            linePromotionObj.promotionType = promotion.applied_discount && promotion.applied_discount.type ? promotion.applied_discount.type : '';
+                            linePromotionObj.promotionAmount = promotion.price ? Math.abs(promotion.price) : 0;
+                            linePromotionObj.name = promotion.coupon_code ? promotion.coupon_code : (promotion.item_text ? promotion.item_text : '');
+                            linePromotionObj.promotionInfo = promotion.item_text ? promotion.item_text : '';
+                            linePromotionObj.promotionLinePrice = product.price - Math.abs(promotion.price);
+                            linePromotionArray.push(linePromotionObj);
+                        }
+                    });
+                }
+            });
+        }
+        this.webReturnObject.basket.linePromotion = linePromotionArray;
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: linePromotion mapping ended...");
+        return this;
+    }
+    transactionPromotion() {
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: transactionPromotion mapping started...");
+        let transactionPromotionArray = this.getTransactionPromotions(this.orderDetails);
+        this.webReturnObject.basket.transactionPromotion = transactionPromotionArray;
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: transactionPromotion mapping ended...");
+        return this;
+    }
+    getTransactionPromotions(basket) {
+        try {
+            let transactionPromotionArray = [];
+            if (basket.order_price_adjustments && basket.order_price_adjustments.length > 0) {
+                basket.order_price_adjustments.forEach((transactionPromotion) => {
+                    let transactionPromotionObj = {};
+                    transactionPromotionObj.displayText = transactionPromotion.item_text ? transactionPromotion.item_text : '';
+                    transactionPromotionObj.name = transactionPromotion.coupon_code ? transactionPromotion.coupon_code : (transactionPromotion.item_text ? transactionPromotion.item_text : '');
+                    transactionPromotionObj.promotionAmount = transactionPromotion.price ? Math.abs(transactionPromotion.price) : 0;
+                    transactionPromotionObj.promotionId = transactionPromotion.promotion_id ? transactionPromotion.promotion_id : '';
+                    transactionPromotionObj.promotionInfo = transactionPromotion.item_text ? transactionPromotion.item_text : '';
+                    transactionPromotionObj.promotionType = transactionPromotion.applied_discount && transactionPromotion.applied_discount.type ? transactionPromotion.applied_discount.type : '';
+                    transactionPromotionObj.itemLineIds = this.orderDetails.product_items.map((product, index) => index + 1);
+                    if (transactionPromotion.coupon_code) {
+                        transactionPromotionObj.type = PROMOTION_TYPE.COUPON;
+                        transactionPromotionObj.couponCode = transactionPromotion.coupon_code;
+                        transactionPromotionObj.subLevelType = PROMOTION_LEVEL.TRANSACTION;
+                    }
+                    transactionPromotionArray.push(transactionPromotionObj);
+                });
+            }
+            console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: getTransactionPromotions : ", JSON.stringify(transactionPromotionArray));
+            return transactionPromotionArray;
+        }
+        catch (error) {
+            console.log("Mapper library: WebReturnSalesforceMapperBuilderClass:  failed:", error);
+            console.log("Mapper library: WebReturnSalesforceMapperBuilderClass:  failed:", JSON.stringify(error));
+            throw new Error(error);
+        }
+    }
+    updateLinePromotionWithCoupon() {
+        try {
+            let transactionPromotion = {};
+            let triggerPromotion = [];
+            if (this.orderDetails.product_items && this.orderDetails.product_items.length > 0) {
+                this.orderDetails.product_items.forEach((product, index) => {
+                    product.item_id = (index + 1).toString();
+                    if (product.price_adjustments && product.price_adjustments.length > 0) {
+                        product.price_adjustments.forEach((promotion) => {
+                            if (promotion.coupon_code) {
+                                let trigger = {};
+                                trigger.itemLineId = product.item_id;
+                                trigger.quantity = product.quantity ? product.quantity : 0;
+                                trigger.totalQuantity = product.quantity ? product.quantity : 0;
+                                trigger.promotionAmount = promotion.price ? Math.abs(promotion.price) : 0;
+                                trigger.refundedReason = promotion.coupon_code ? promotion.coupon_code : '';
+                                trigger.refundedReasonDescription = promotion.item_text ? promotion.item_text : '';
+                                trigger.promotionId = promotion.promotion_id;
+                                triggerPromotion.push(trigger);
+                            }
+                        });
+                    }
+                });
+            }
+            if (triggerPromotion.length > 0) {
+                transactionPromotion.displayText = triggerPromotion[0].refundedReasonDescription;
+                transactionPromotion.name = triggerPromotion[0].refundedReason;
+                transactionPromotion.promotionAmount = -(triggerPromotion.reduce((n, { promotionAmount }) => n + promotionAmount, 0));
+                transactionPromotion.promotionId = triggerPromotion[0].promotionId;
+                transactionPromotion.promotionInfo = triggerPromotion[0].refundedReasonDescription;
+                transactionPromotion.couponCode = triggerPromotion[0].refundedReason;
+                transactionPromotion.itemLineIds = [];
+                transactionPromotion.type = PROMOTION_TYPE.COUPON;
+                transactionPromotion.subLevelType = PROMOTION_LEVEL.LINE;
+                transactionPromotion.trigger = triggerPromotion;
+            }
+            console.log("linePromotion mapping ended...");
+            console.log("e-basket: updateLinePromotionWithCoupon", JSON.stringify(transactionPromotion));
+            if (!this.webReturnObject.basket.transactionPromotion) {
+                this.webReturnObject.basket.transactionPromotion = [];
+            }
+            if (transactionPromotion && transactionPromotion.promotionId) {
+                this.webReturnObject.basket.transactionPromotion.push(transactionPromotion);
+            }
+            return this;
+        }
+        catch (error) {
+            console.log("Ebasket: Salesforce: linePromotion mapping=> failed:", error);
+            console.log("Ebasket: Salesforce: linePromotion mapping=> failed:", JSON.stringify(error));
+            throw new Error(error);
+        }
+    }
+    updateTransactionPromotionPrtionCalc() {
+        if (this.webReturnObject.basket.transactionPromotion && this.webReturnObject.basket.transactionPromotion.length > 0) {
+            this.webReturnObject.basket.transactionPromotion.forEach(tr => {
+                this.transactionPromotionProductPortionCalc(this.webReturnObject, tr);
+            });
+        }
+        return this;
+    }
+    transactionPromotionProductPortionCalc(txDoc, promotion) {
+        console.log(`ebasket: transactionPromotionProductPortionCalc: trnsactionPromotion: ${JSON.stringify(promotion)}`);
+        if (promotion.type === PROMOTION_TYPE.COUPON && promotion.subLevelType === PROMOTION_LEVEL.LINE) {
+            txDoc.basket.products.forEach((product) => {
+                product = this.validateProductItemDiscount(product);
+                if (promotion.trigger && promotion.trigger.length > 0) {
+                    promotion.trigger.forEach((t) => {
+                        if (t.itemLineId === product.itemLineId.toString()) {
+                            product.itemDiscounts.trnPromotionsPortion += t.promotionAmount;
+                        }
+                    });
+                }
+            });
+        }
+        else {
+            txDoc.basket.products.forEach((product) => {
+                product = this.validateProductItemDiscount(product);
+                if (promotion.itemLineIds.includes(+product.itemLineId)) {
+                    const productItem = this.orderDetails.product_items.find(productItem => productItem.product_id === product.SKU);
+                    const transactionPromotionPortion = (productItem && productItem.price_after_item_discount && productItem.price_after_order_discount) ?
+                        (productItem.price_after_item_discount - productItem.price_after_order_discount) : 0;
+                    product.itemDiscounts.trnPromotionsPortion += this.numberUtilService.trimTo2Decimal2(transactionPromotionPortion);
+                }
+            });
+        }
+        return txDoc;
+    }
+    validateProductItemDiscount(product) {
+        if (!product.itemDiscounts) {
+            product.itemDiscounts = {
+                trnDiscountsPortion: 0,
+                trnPromotionsPortion: 0,
+                refundPortion: 0,
+            };
+        }
+        return product;
+    }
+    customer() {
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: customer mapping started...");
+        let customerObj = {};
+        customerObj.email = this.orderDetails.customer_info && this.orderDetails.customer_info.email ? this.orderDetails.customer_info.email : '';
+        customerObj.firstName = this.orderDetails.billing_address && this.orderDetails.billing_address.first_name ? this.orderDetails.billing_address.first_name : '';
+        customerObj.lastName = this.orderDetails.billing_address && this.orderDetails.billing_address.last_name ? this.orderDetails.billing_address.last_name : '';
+        let shippingAddress = [];
+        this.orderDetails.shipments.forEach(shipment => {
+            let shippingAddressObj = {};
+            shippingAddressObj.id = shipment.shipping_address && shipment.shipping_address.id ? shipment.shipping_address.id : '';
+            shippingAddressObj.countryCode = shipment.shipping_address && shipment.shipping_address.country_code ? shipment.shipping_address.country_code : '';
+            shippingAddressObj.address1 = shipment.shipping_address && shipment.shipping_address.address1 ? shipment.shipping_address.address1 : '';
+            shippingAddressObj.city = shipment.shipping_address && shipment.shipping_address.city ? shipment.shipping_address.city : '';
+            shippingAddressObj.country = '';
+            shippingAddressObj.postCode = shipment.shipping_address && shipment.shipping_address.postal_code ? shipment.shipping_address.postal_code : '';
+            shippingAddress.push(shippingAddressObj);
+        });
+        customerObj.shippingAddress = shippingAddress;
+        let billingAddress = [];
+        let billingAddressObj = {};
+        billingAddressObj.id = this.orderDetails.billing_address && this.orderDetails.billing_address.id ? this.orderDetails.billing_address.id : '';
+        billingAddressObj.countryCode = this.orderDetails.billing_address && this.orderDetails.billing_address.country_code ? this.orderDetails.billing_address.country_code : '';
+        billingAddressObj.address1 = this.orderDetails.billing_address && this.orderDetails.billing_address.address1 ? this.orderDetails.billing_address.address1 : '';
+        billingAddressObj.city = this.orderDetails.billing_address && this.orderDetails.billing_address.city ? this.orderDetails.billing_address.city : '';
+        billingAddressObj.country = '';
+        billingAddressObj.postCode = '';
+        billingAddress.push(billingAddressObj);
+        customerObj.billingAddress = billingAddress;
+        let shipmentDetails = [];
+        this.orderDetails.shipments.forEach(shipment => {
+            let shipmentDetailsObj = {};
+            shipmentDetailsObj.id = shipment.shipment_id ? shipment.shipment_id : '';
+            shipmentDetailsObj.deliveryGroup = shipment.shipment_id ? shipment.shipment_id : '';
+            shipmentDetails.push(shipmentDetailsObj);
+        });
+        customerObj.shipmentDetails = shipmentDetails;
+        this.webReturnObject.customer = customerObj;
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: customer mapping ended...");
+        return this;
+    }
+    isInStoreOrder() {
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: isInStoreOrder mapping started...");
+        if (this.orderDetails.c_isInStoreOrder) {
+            this.webReturnObject.isInStoreOrder = true;
+        }
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: isInStoreOrder mapping ended...");
+        return this;
+    }
+    externalTransactionDetails() {
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: externalTransactionDetails mapping started...");
+        let externalTransactionDetails = [];
+        if (this.orderDetails.shipments && this.orderDetails.shipments.length > 0) {
+            this.orderDetails.shipments.forEach(shipment => {
+                let externalTransactionDetailsObj = {};
+                let transactionInfo = {};
+                externalTransactionDetailsObj.uniqueId = this.orderDetails.order_no ? this.orderDetails.order_no : '';
+                externalTransactionDetailsObj.providerType = PROVIDERS.SALESFORCE;
+                transactionInfo.shippingId = shipment.shipping_method && shipment.shipping_method.id ? shipment.shipping_method.id : '';
+                transactionInfo.externalShippingId = shipment.shipment_id ? shipment.shipment_id : '';
+                externalTransactionDetailsObj.details = transactionInfo;
+                externalTransactionDetails.push(externalTransactionDetailsObj);
+            });
+        }
+        this.webReturnObject.externalTransactionDetails = externalTransactionDetails;
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: externalTransactionDetails mapping ended...");
+        return this;
+    }
+    basketSummary() {
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: basketSummary mapping started...");
+        let basketSummary = {};
+        let basketSummaryWebOrder = {};
+        const linePromotionTotal = this.webReturnObject.basket.linePromotion.map(linePromotion => linePromotion.promotionAmount).reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+        const transactionPromotionTotal = this.webReturnObject.basket.transactionPromotion.map(transactionPromotion => transactionPromotion.promotionAmount).reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+        basketSummary.discountTotal = linePromotionTotal + transactionPromotionTotal;
+        basketSummary.VATTotal = this.orderDetails.tax_total ? this.orderDetails.tax_total : 0;
+        basketSummary.saleTotal = this.orderDetails.order_total ? this.orderDetails.order_total : 0;
+        basketSummary.basketTotal = this.orderDetails.order_total ? this.orderDetails.order_total : 0;
+        basketSummary.totalItems = this.orderDetails.product_items && this.orderDetails.product_items.length > 0 ? this.orderDetails.product_items.length : 0;
+        basketSummary.shippingTotal = this.orderDetails.shipping_total ? this.orderDetails.shipping_total : 0;
+        basketSummary.basketTotalWithShippingTotal = this.orderDetails.order_total ? this.orderDetails.order_total : 0;
+        basketSummaryWebOrder.shippingTotal = this.orderDetails.shipping_total ? this.orderDetails.shipping_total : 0;
+        basketSummaryWebOrder.basketTotalWithShippingTotal = this.orderDetails.order_total ? this.orderDetails.order_total : 0;
+        basketSummary.webOrder = basketSummaryWebOrder;
+        this.webReturnObject.basketSummary = basketSummary;
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: basketSummary mapping ended...");
+        return this;
+    }
+    deviceId(deviceId) {
+        this.webReturnObject.deviceId = deviceId;
+        return this;
+    }
+    terminalId(terminalId) {
+        this.webReturnObject.terminalId = terminalId;
+        return this;
+    }
+    orgCode(orgCode) {
+        this.webReturnObject.orgCode = orgCode;
+        return this;
+    }
+    storeId(storeId) {
+        this.webReturnObject.storeId = storeId;
+        return this;
+    }
+    storeNodeId(storeNodeId) {
+        this.webReturnObject.storeNodeId = storeNodeId;
+        return this;
+    }
+    storeNodeStructure(storeNodeStructure) {
+        this.webReturnObject.storeNodeStructure = storeNodeStructure;
+        return this;
+    }
+    docId(docId) {
+        this.webReturnObject.id = docId;
+        return this;
+    }
+    updateUserID(userID) {
+        this.webReturnObject.userId = userID;
+        return this;
+    }
+    updateUserName(name) {
+        this.webReturnObject.userName = name;
+        return this;
+    }
+    build() {
+        console.log("Mapper library: WebReturnSalesforceMapperBuilderClass: mapping done...");
+        return this.webReturnObject;
+    }
+    getUTCDateTime(date) {
+        if (date) {
+            return new Date(date).toISOString();
+        }
+    }
+}
+
+/*
+ * Public API Surface of mapper-library
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { MapperLibraryComponent, MapperLibraryModule, RJMapperBuilderClass, WebReturnMapperBuilderClass, WebReturnSalesforceMapperBuilderClass };
+//# sourceMappingURL=pmcretail-mapper-library.mjs.map