@pmcretail/mapper-library 0.0.1

package/fesm2020/pmcretail-mapper-library.mjs

@@ -0,0 +1,2521 @@
+import * as i0 from '@angular/core';
+import { Injectable, Inject, Component, NgModule } from '@angular/core';
+import * as JsonToXML from 'js2xmlparser';
+import { BehaviorSubject } from 'rxjs';
+
+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 || (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 = {}));
+var DISCOUNTTYPE;
+(function (DISCOUNTTYPE) {
+    DISCOUNTTYPE["PERCENT"] = "Percent";
+    DISCOUNTTYPE["AMOUNT"] = "AMOUNT";
+})(DISCOUNTTYPE || (DISCOUNTTYPE = {}));
+
+class NumberUtilService {
+    constructor(cp) {
+        this.cp = cp;
+    }
+    trimTo2Decimal(no) {
+        //return Math.floor(no * 100) / 100;
+        return no;
+    }
+    trimTo2Decimal2(no) {
+        return Number(this.getFlooredFixed(no, 2));
+    }
+    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;
+    }
+}
+NumberUtilService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NumberUtilService, deps: [{ token: null }], target: i0.ɵɵFactoryTarget.Injectable });
+NumberUtilService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NumberUtilService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NumberUtilService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [null]
+                }] }]; } });
+
+class BasketService {
+    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();
+    }
+    get isMixedBasketSales() {
+        return this._isMixedBasketSales;
+    }
+    set isMixedBasketSales(v) {
+        this._isMixedBasketSales = v;
+    }
+    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);
+        }
+    }
+}
+BasketService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BasketService, deps: [{ token: NumberUtilService }], target: i0.ɵɵFactoryTarget.Injectable });
+BasketService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BasketService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BasketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: NumberUtilService }]; } });
+
+/**
+ * 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.productQuantity = 0;
+        this.itemCount = 0;
+        this.largestNumber = 0;
+        this.rjObject = {};
+        this.paymentTypes = [
+            {
+                paymentType: 'Card',
+                type: 'SEPAY',
+                tenderType: '5',
+                tenderSubType: '8',
+            },
+            {
+                paymentType: 'Cash',
+                type: 'TMC_CASH',
+                tenderType: '1',
+                tenderSubType: '0'
+            },
+            {
+                paymentType: 'PDQ',
+                type: 'Unintegrated',
+                tenderType: '2',
+                tenderSubType: '8'
+            },
+            {
+                paymentType: 'Gift Card',
+                type: 'TMC_GIFTCARD',
+                tenderType: '5',
+                tenderSubType: '8'
+            }
+        ];
+        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();
+    }
+    getPosbasketInfo() {
+        this.rjObject['Keyword'] = this.generateKeyword();
+        this.rjObject['ID'] = this.generateId(this.transactionDocument.createdAt);
+        this.rjObject['XMLSchemaVersion'] = '2';
+        this.rjObject['LastUpdated'] = this.transactionDocument.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.transactionDocument.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.transactionDocument.storeId;
+        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(); //todo
+        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 = ""; //unknown
+        return this;
+    }
+    rjMapper() {
+        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));
+                this.rjObject['ProductSale'].push(data);
+                this.getModifierItem(lineDiscount.length > 0 ? lineDiscount[0] : null, element.itemLineId);
+            });
+        }
+        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));
+                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));
+                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));
+                    this.rjObject['ProductReturn'].push(returnProduct);
+                }
+                else {
+                    let addProduct = this.addProduct(element, (element.hasOwnProperty('lineDiscount') ? element.lineDiscount : null));
+                    this.rjObject['ProductSale'].push(addProduct);
+                }
+                this.getModifierItem(element.lineDiscount, element.itemLineId);
+            });
+        }
+        return this;
+    }
+    getBasketDiscount() {
+        this.rjObject['BasketDiscount'] = [];
+        if (!this.transactionDocument.basket.transactionDiscount)
+            return this;
+        this.transactionDocument.basket.transactionDiscount.forEach((element) => {
+            let obj = {};
+            obj['XMLSchemaVersion'] = 1;
+            obj['NetValue'] = element.discountAmount < 0 ? element.discountAmount : -element.discountAmount;
+            obj['EffectiveNetValue'] = element.discountAmount < 0 ? element.discountAmount : -element.discountAmount;
+            obj['Description'] = element.reasonCode;
+            obj['UserID'] = this.transactionDocument.basket.userId;
+            obj['ReasonCodeID'] = element.reasonCode;
+            obj['DiscountType'] = element.discountType.toUpperCase() == DISCOUNTTYPE.PERCENT.toUpperCase() ? 0 : 1; // todo - compare values 
+            obj['RoundingRule'] = 2;
+            obj['ModifiedLineNumber '] = [];
+            element.itemLineIds.forEach((element) => {
+                obj['ModifiedLineNumber'].push(element);
+            });
+            obj['LineNumber'] = this.generateLineNumber();
+            // obj['DiscountedValue'] = obj['discountAmount'] // todo - confirm value before discount;
+            // obj['DiscountPercentage'] = obj['discountAmount'] / 100 ; // todo - optional
+            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.userId;
+            obj.DateTimeCreated = this.transactionDocument.updatedAt;
+            obj.AuthorisingUserID = this.userId;
+            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.transactionDocument.updatedAt;
+        this.rjObject.Trailer.CompletedBy = {};
+        this.rjObject.Trailer.CompletedBy.DeviceID = this.deviceId; //todo
+        this.rjObject.Trailer.CompletedBy.CashierID = this.cashierId; //todo
+        this.rjObject.Trailer.CompletedBy.StoreID = this.transactionDocument.storeId;
+        this.rjObject.Trailer.CompletedBy.BranchID = this.transactionDocument.storeId;
+        this.rjObject.Trailer.CompletedBy.TerminalNumber = this.transactionDocument.terminalId;
+        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.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'] = element.VAT;
+            obj['TaxableTotal'] = this.convertToString(element.taxableAmount);
+            obj['TaxTotal'] = this.convertToString(element.taxLineTotal);
+            obj['TaxDescription'] = this.convertToString(element.VATCode);
+            obj['TaxIncluded'] = '1';
+            obj['TaxPercentage'] = element.VAT; // todo
+            this.rjObject['Trailer']['TaxItem'].push(obj);
+        });
+        // TODO: make Trailer object from promotion
+        this.rjObject['Trailer']['PromotionItem'] = [];
+        this.transactionDocument.basket.linePromotion.forEach((element) => {
+            let obj = {};
+            obj['PromotionID'] = element.promotionId;
+            obj['PromotionSaving'] = element.promotionAmount < 0 ? element.promotionAmount : -element.promotionAmount;
+            obj['PromotionQuantity'] = ""; // todo - not avaialble
+            obj['PromotionDescription'] = element.displayText;
+            obj['PromotionHit']['XMLSchemaVersion'] = this.transactionDocument.storeId;
+            obj['PromotionHit']['HitNumber'] = ""; // todo;
+            obj['PromotionHit']['HitQuantity'] = ""; // todo;
+            obj['PromotionHit']['HitSaving'] = ""; // todo;
+            obj['PromotionHit']['PromotionTrigger'] = [];
+            element.trigger.forEach((subElement) => {
+                let objSub = {};
+                let product = this.transactionDocument.basket.products.find((item) => item.lineItemId == subElement.itemLineId);
+                objSub['XMLSchemaVersion'] = this.xmlSchemaVersion;
+                objSub['ProductID'] = this.transactionDocument.basket.products.find((item) => item.itemLineId === subElement.itemLineId).SKU;
+                objSub['UnitValue'] = this.convertToString(element.promotionLinePrice / product.quantity);
+                objSub['LineNumber'] = this.convertToString(subElement.itemLineId);
+                objSub['Quantity'] = this.convertToString(subElement.quantity.toFixed(1));
+                objSub['TaxCode'] = this.transactionDocument.basket.taxBreakdown.taxLines.find((item) => item.itemLineId == element.itemLineId).VATCode; // todo
+                obj['PromotionHit']['PromotionTrigger'].push(objSub);
+            });
+            this.rjObject['Trailer']['PromotionItem'].push(obj);
+        });
+        //console.log(this.rjObject);
+        return this;
+    }
+    getTenderInfo() {
+        this.rjObject['CashTender'] = [];
+        if (this.transactionDocument.paymentDetails && this.transactionDocument.paymentDetails.length > 0) {
+            this.transactionDocument.paymentDetails.forEach((element) => {
+                let value = this.paymentTypes.filter(x => x.paymentType?.toUpperCase() === element.paymentType.toUpperCase());
+                if (element.paymentType.toUpperCase() === 'GIFT CARD') {
+                    let obj = {
+                        XMLSchemaVersion: this.xmlSchemaVersion,
+                        LineNumber: this.generateLineNumber(),
+                        NetValue: this.convertToString(-1 * (Math.round(element.amount))),
+                        EffectiveNetValue: this.convertToString(-1 * (Math.round(element.amount))),
+                        Description: this.getDescription(value[0].paymentType, element),
+                        DeviceID: this.deviceId,
+                        UserID: this.userId,
+                        DateTimeCreated: this.transactionDocument.updatedAt,
+                        TenderType: value[0].tenderType,
+                        TenderSubType: value[0].tenderSubType,
+                        TenderAmount: this.convertToString(-1 * (Math.round(element.amount))),
+                        CurrencyID: this.transactionDocument.baseCurrency,
+                        CurrencyDescription: this.transactionDocument.baseCurrency,
+                        GiftVoucherSalesAllowed: '',
+                        AllowRechargeableVoucherSales: '',
+                        GiftVoucherID: ''
+                    };
+                    this.rjObject['CashTender'].push(obj);
+                }
+                else {
+                    let obj1 = {
+                        XMLSchemaVersion: "1",
+                        LineNumber: this.generateLineNumber(),
+                        NetValue: JSON.stringify(-1 * (Math.round(element.amount))),
+                        EffectiveNetValue: JSON.stringify(-1 * (Math.round(element.amount))),
+                        Description: this.getDescription(value[0].paymentType, element),
+                        DeviceID: this.deviceId,
+                        UserID: this.userId,
+                        DateTimeCreated: this.transactionDocument.updatedAt,
+                        TenderType: value[0].tenderType,
+                        TenderSubType: value[0].tenderSubType,
+                        TenderAmount: JSON.stringify(-1 * (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;
+    }
+    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(paymentType, element) {
+        if (paymentType.toUpperCase() === 'CARD') {
+            return element.cardType;
+        }
+        else {
+            return paymentType;
+        }
+    }
+    setDeviceInfo(id) {
+        this.deviceId = id;
+        return this;
+    }
+    setUserInfo(id) {
+        this.userId = id;
+        return this;
+    }
+    removeDecimal(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(value) {
+        this.cashierId = value;
+        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;
+    }
+    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) {
+        let obj = {};
+        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.userId;
+        obj['DateTimeCreated'] = this.transactionDocument['createdAt'];
+        obj['ExtendedValue'] = this.removeDecimal(element['totalLinePrice']);
+        obj['UnitPrice'] = this.removeDecimal(element['price']);
+        obj['Quantity'] = element['refundedQuantity'] < 0 ? element['refundedQuantity'].toFixed(1) : -element['refundedQuantity'].toFixed(1);
+        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'] = element['refundedQuantity'] > 0 ? element['refundedQuantity'] : -1 * element['refundedQuantity'];
+        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.getAttributes();
+        obj['MMGroupID'] = this.getAttributes();
+        obj['CustomerDetails'] = ""; // todo - blank
+        obj['TotalPromotionSaving'] = element['promotionAmount'] || -1; // TODO
+        let taxTotal = this.transactionDocument.basket['taxBreakdown']['taxLines'].find((item) => item.itemLineId == element['itemLineId']);
+        obj['OriginalTaxAmount'] = taxTotal.taxLineTotal < 0 ? this.removeDecimal(taxTotal.taxLineTotal) : this.removeDecimal(-taxTotal.taxLineTotal); //todo
+        obj['taxAmount'] = taxTotal.taxLineTotal < 0 ? this.removeDecimal(taxTotal.taxLineTotal) : this.removeDecimal(-taxTotal.taxLineTotal);
+        if (lineDiscount) {
+            if (lineDiscount.percentageDiscountReasonName && lineDiscount.percentageDiscountReasonCode) {
+                // line discount
+                obj['Discount'] = {};
+                obj['Discount'].ModifierValue = this.removeDecimal(lineDiscount.unitPrice) * -1;
+                obj['Discount'].ModifierDateTime = obj.DateTimeCreated;
+                obj['Discount'].ModifierReasonID = lineDiscount.percentageDiscountReasonCode;
+                obj['Discount'].ModifierDescription = lineDiscount.percentageDiscountReasonName;
+                obj['Discount'].AuthorisingUserID = this.userId;
+                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.userId;
+                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;
+        }
+        return obj;
+    }
+    addProduct(element, lineDiscount) {
+        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.userId,
+            DateTimeCreated: this.transactionDocument.createdAt,
+            ExtendedValue: this.removeDecimal(element.price),
+            UnitPrice: this.removeDecimal(element.price),
+            MMGroupID: this.getAttributes(),
+            Quantity: element.quantity.toFixed(1),
+            SalespersonID: this.transactionDocument.userId,
+            SalespersonName: this.transactionDocument.userName,
+            TaxCode: 0,
+            TaxModifiable: 1,
+            TaxAmount: 0,
+            OriginalTaxAmount: 0,
+            OriginalTaxAmountSet: 1,
+            ProductID: element.SKU,
+            HandKeyed: 1,
+            CustomerDetails: "",
+            Perishable: this.getAttributes()
+        };
+        if (lineDiscount) {
+            if (lineDiscount.percentageDiscountReasonName && lineDiscount.percentageDiscountReasonCode) {
+                // line discount
+                obj['Discount'] = {};
+                obj['Discount'].ModifierValue = this.removeDecimal(lineDiscount.unitPrice) * -1;
+                obj['Discount'].ModifierDateTime = obj.DateTimeCreated;
+                obj['Discount'].ModifierReasonID = lineDiscount.percentageDiscountReasonCode;
+                obj['Discount'].ModifierDescription = lineDiscount.percentageDiscountReasonName;
+                obj['Discount'].AuthorisingUserID = this.userId;
+                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.userId;
+                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);
+            obj['EffectiveNetValue'] = ((lineDiscount?.discountedLinePrice || 0) + lineDiscount.discountAmount);
+            obj['ExtendedValue'] = ((lineDiscount?.discountedLinePrice || 0) + lineDiscount.discountAmount);
+            obj['UnitPrice'] = ((lineDiscount?.discountedLinePrice || 0) + lineDiscount.discountAmount);
+        }
+        return obj;
+    }
+    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 = [];
+        this.transactionDocument.basket.products.forEach((element) => {
+            if (element.attributes && element.attributes.length > 0) {
+                name = element.attributes.filter((x) => x.name.toUpperCase() === element.name?.toUpperCase());
+            }
+        });
+        if (name.length > 0) {
+            return name[0].value;
+        }
+        else {
+            return "";
+        }
+    }
+}
+
+class MapperLibraryService {
+    constructor() { }
+    saleDoc(transactionDoc) {
+        console.log('TransactionDocuments', transactionDoc);
+        let value = new RJMapperBuilderClass(transactionDoc)
+            .setTransactionNumber('tttt')
+            .setManifestVersion('mmmm')
+            .setDatabaseSchemaVersion('dddd')
+            .setTradingRegionID('trtr')
+            .setCompanyID('cccc')
+            .setTaxMethodID('tmtm')
+            .setBasketType('SALE')
+            .setMajorVersion('1')
+            .setMinorVersion('0')
+            .setXMLSchemaVersion('1')
+            .setExternalState('1')
+            .setCashierID('0009')
+            .setTerminalNumber('1')
+            .setUserInfo('123')
+            .setDeviceInfo('XYZ.ab.123')
+            .setBasketLanguageID('IT')
+            .setBasketCountryID('IT')
+            .setBasketCurrencyID('EUR')
+            .rjMapper()
+            .getBasketDiscount()
+            .getPosbasketInfo()
+            .getheaderInfo()
+            .getTrailerInfo()
+            .getTenderInfo()
+            .build();
+        console.log('JSONobject', value);
+        console.log('XML', JsonToXML.parse("POSBasket", value));
+        return JsonToXML.parse("POSBasket", value);
+    }
+    refundDoc(transactionDoc) {
+        console.log('TransactionDocument', transactionDoc);
+        let value = new RJMapperBuilderClass(transactionDoc)
+            .rjMapper()
+            .getTrailerInfo()
+            .build();
+        console.log('JSONobject', value);
+    }
+}
+MapperLibraryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapperLibraryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MapperLibraryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapperLibraryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapperLibraryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class MapperLibraryComponent {
+    constructor() { }
+    ngOnInit() {
+    }
+}
+MapperLibraryComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapperLibraryComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+MapperLibraryComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: MapperLibraryComponent, selector: "lib-mapper-library", ngImport: i0, template: `
+    <p>
+      mapper-library works!
+    </p>
+  `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapperLibraryComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-mapper-library',
+                    template: `
+    <p>
+      mapper-library works!
+    </p>
+  `,
+                    styles: []
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class MapperLibraryModule {
+}
+MapperLibraryModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapperLibraryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MapperLibraryModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapperLibraryModule, declarations: [MapperLibraryComponent], exports: [MapperLibraryComponent] });
+MapperLibraryModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapperLibraryModule, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapperLibraryModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        MapperLibraryComponent
+                    ],
+                    imports: [],
+                    exports: [
+                        MapperLibraryComponent
+                    ]
+                }]
+        }] });
+
+/*
+ * Public API Surface of mapper-library
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { MapperLibraryComponent, MapperLibraryModule, MapperLibraryService, RJMapperBuilderClass };
+//# sourceMappingURL=pmcretail-mapper-library.mjs.map