meemup-library 1.2.69 → 1.2.71

package/dist/controllers/OrderToolController.d.ts

@@ -0,0 +1,54 @@
+import EnumOrderType from "../enums/EnumOrderType";
+import IOrderItem from "../interfaces/order/IOrderItem";
+import IPointOfSaleSetting from "../interfaces/IPointOfSaleSetting";
+import IOrder from "../interfaces/order/IOrder";
+import EnumPaymentType from "../enums/EnumPaymentType";
+import IOrderDetailProduct from "../interfaces/print/IOrderDetailProduct";
+import IOrderDetailProductsExtra from "../interfaces/print/IOrderDetailProductsExtra";
+import IOrderExtraItem from "../interfaces/order/IOrderExtraItem";
+import IZone from "../interfaces/IZone";
+import IZoneCost from "../interfaces/IZoneCost";
+import ILocation from "../interfaces/ILocation";
+import ICalculateFeeResult from "../interfaces/ICalculateFeeResult";
+import EnumChannels from "../enums/EnumChannels";
+import IPointOfSaleSettingFee from "../interfaces/IPointOfSaleSettingFee";
+import IPointOfSaleOrderSummary from "../interfaces/pos/IPointOfSaleOrderSummary";
+import EnumCustomerMandatory from "../enums/EnumCustomerMandatory";
+import IPointOfSaleSettingRewardProgram from "../interfaces/pos/IPointOfSaleSettingRewardProgram";
+import ITextValue from "../interfaces/ITextValue";
+export default class OrderToolController {
+    replaceItem(item: IOrderItem, items: IOrderItem[]): IOrderItem[];
+    paymentTypeText(order?: IOrder | IPointOfSaleOrderSummary): string;
+    getPaymentTypeText(paymentType: EnumPaymentType, orderType: EnumOrderType): string;
+    getPaymentStateText(order?: IOrder | IPointOfSaleOrderSummary): string;
+    getOrderTypeText(orderType: EnumOrderType): string;
+    getOrderChannelText(channel: EnumChannels): string;
+    orderTypeText(order: IOrder | undefined, additionalPickupInstructionsTypes: ITextValue[]): string;
+    builtOrderDeliveryCost(form: IOrder, zones: IZone[], checkDeliveryCoverageArea: boolean): IOrder;
+    calculateItemsAmount(list: IOrderItem[]): number;
+    calculateTax(taxPercentage: number, subTotal: number, discount: number, deliveryCost: number): number;
+    calculateDiscount(order: IOrder, subTotal: number): number;
+    calculateTip(order: IOrder, subTotal: number): number;
+    calculateReward(totalAmount: number, rewardProgram: IPointOfSaleSettingRewardProgram): number;
+    customerOrNull(order: IOrder): any;
+    locationOrNull(order: IOrder): {
+        longitude: number;
+        latitude: number;
+    } | null;
+    convertOrderExtraItemToOrderDetailProductsExtra(item: IOrderExtraItem): IOrderDetailProductsExtra;
+    convertOrderItemToOrderDetailProduct(item: IOrderItem, currency: string): IOrderDetailProduct;
+    createExtraNames(item: IOrderItem, currency: string): string;
+    createExtraItemText(item: IOrderExtraItem, currency: string): string;
+    roundCashAmount(price: number, rounding: any): {
+        newPrice: number;
+        roundingRate: number;
+    };
+    calcDeliveryCost: (displayTotalAmount: number, zone: IZone) => IZoneCost;
+    coveragesAddress(location: ILocation, zones: IZone[], checkDeliveryCoverageArea: boolean): boolean;
+    zonesThatCoverageLocation(location: ILocation, zones: IZone[]): IZone[];
+    calculateFee(companyFee: IPointOfSaleSettingFee, order: IOrder, orderAmount: number): ICalculateFeeResult;
+    formatSetting(_setting: IPointOfSaleSetting): IPointOfSaleSetting;
+    customerText(form: IOrder): string;
+    isMandatory(orderType: EnumOrderType, value: EnumCustomerMandatory): boolean;
+    private round;
+}

package/dist/controllers/OrderToolController.js

@@ -0,0 +1,588 @@
+import EnumOrderType from "../enums/EnumOrderType";
+import EnumDiscountType from "../enums/EnumDiscountType";
+import { initOrder } from "../interfaces/order/IOrder";
+import EnumTipType from "../enums/EnumTipType";
+import EnumPaymentType from "../enums/EnumPaymentType";
+import MoneyController from "../controllers/MoneyController";
+import EnumPriceMidpointRounding from "../enums/EnumPriceMidpointRounding";
+import EnumPaymentState from "../enums/EnumPaymentState";
+import { CUSTOM_DELIVERY_ZONE_ID } from "../statics";
+import ZoneController from "../controllers/ZoneController";
+import EnumFeeCalculationMode from "../enums/EnumFeeCalculationMode";
+import ToolController from "../controllers/ToolController";
+import EnumPizzaSide from "../enums/EnumPizzaSide";
+import PhoneController from "../controllers/PhoneController";
+import EnumChannels from "../enums/EnumChannels";
+import EnumCustomerMandatory from "../enums/EnumCustomerMandatory";
+import EnumRewardPointType from "../enums/EnumRewardPointType";
+export default class OrderToolController {
+    constructor() {
+        this.calcDeliveryCost = (displayTotalAmount, zone) => {
+            if (displayTotalAmount >= zone.freeFrom)
+                return {
+                    deliveryCost: 0,
+                    duration: zone.additionalDeliveryTime,
+                    zoneId: zone.id
+                };
+            return { deliveryCost: zone.deliveryCost, duration: zone.additionalDeliveryTime, zoneId: zone.id };
+        };
+    }
+    replaceItem(item, items) {
+        let index = items.findIndex(i => i.id === item.id);
+        if (index !== -1) {
+            items[index] = item;
+        }
+        return items;
+    }
+    paymentTypeText(order = initOrder) {
+        switch (order.paymentType) {
+            case EnumPaymentType.online:
+                return "Online";
+            case EnumPaymentType.cash:
+                return "Cash";
+            case EnumPaymentType.debitAt:
+                return "Debit machine";
+            case EnumPaymentType.debitMachine:
+                return "Debit machine";
+            case EnumPaymentType.terminal:
+                return "Terminal";
+            case EnumPaymentType.splitPayments:
+                return "Multi payment";
+            default:
+                return "None";
+        }
+    }
+    getPaymentTypeText(paymentType, orderType) {
+        switch (paymentType) {
+            case EnumPaymentType.online:
+                return "Online";
+            case EnumPaymentType.cash:
+                return "Cash";
+            case EnumPaymentType.debitAt:
+                return orderType === EnumOrderType.delivery ? "Credit at door" : "In-store";
+            case EnumPaymentType.debitMachine:
+                return "Debit machine";
+            case EnumPaymentType.terminal:
+                return "Terminal";
+            case EnumPaymentType.splitPayments:
+                return "Multi payment";
+            default:
+                return "None";
+        }
+    }
+    getPaymentStateText(order = initOrder) {
+        switch (order.paymentState) {
+            case EnumPaymentState.PAID:
+                return "Paid";
+            case EnumPaymentState.NOT_PAID:
+                return "Not paid";
+            case EnumPaymentState.PENDING:
+                return "Pending";
+            default:
+                return "";
+        }
+    }
+    getOrderTypeText(orderType) {
+        switch (orderType) {
+            case EnumOrderType.delivery:
+                return "Delivery";
+            case EnumOrderType.dining:
+                return "Dine-in";
+            case EnumOrderType.pickup:
+                return "Pickup";
+            default:
+                return "";
+        }
+    }
+    getOrderChannelText(channel) {
+        switch (channel) {
+            case EnumChannels.DigitalMenu:
+                return "Digital menu";
+            case EnumChannels.GoogleOrdering:
+                return "Google";
+            case EnumChannels.POS:
+                return "POS";
+            case EnumChannels.WebShop:
+                return "Online store";
+            case EnumChannels.App:
+                return "APP";
+            case EnumChannels.None:
+                return "None";
+            default:
+                return "";
+        }
+    }
+    orderTypeText(order = initOrder, additionalPickupInstructionsTypes) {
+        switch (order.orderType) {
+            case EnumOrderType.delivery:
+                return "Delivery";
+            case EnumOrderType.dining:
+                return "Dine-in";
+            case EnumOrderType.pickup:
+                let item = additionalPickupInstructionsTypes.find(i => i.value === order.pickupInstructions);
+                if (item)
+                    return item.text;
+                return "Pickup";
+            default:
+                return "";
+        }
+    }
+    builtOrderDeliveryCost(form, zones, checkDeliveryCoverageArea) {
+        let zoneInfo = {
+            zoneId: form.zoneId,
+            duration: form.duration,
+            deliveryCost: form.deliveryCost
+        };
+        // console.log("zoneInfo : ", zoneInfo);
+        if (form.orderType === EnumOrderType.delivery) {
+            // console.log("if -------------");
+            if (checkDeliveryCoverageArea) {
+                // console.log("if -------------2");
+                if (form.zoneId !== CUSTOM_DELIVERY_ZONE_ID) {
+                    let point = {
+                        latitude: +(form.latitude + ""),
+                        longitude: +(form.longitude + "")
+                    };
+                    let enabledZones = this.zonesThatCoverageLocation(point, zones);
+                    if (enabledZones.length > 0) {
+                        let basketPriceWithoutDeliveryCost = form.displayTotalAmount - form.deliveryCost;
+                        let zonesDeliveryForms = enabledZones.filter(zone => zone.deliveryFrom <= basketPriceWithoutDeliveryCost)
+                            .map(i => this.calcDeliveryCost(basketPriceWithoutDeliveryCost, i));
+                        if (zonesDeliveryForms.length > 0) {
+                            zonesDeliveryForms = zonesDeliveryForms.sort((a, b) => {
+                                return a.deliveryCost < b.deliveryCost ? -1 : 1;
+                            });
+                            zoneInfo.zoneId = zonesDeliveryForms[0].zoneId;
+                            zoneInfo.duration = zonesDeliveryForms[0].duration;
+                            zoneInfo.deliveryCost = zonesDeliveryForms[0].deliveryCost;
+                        }
+                        else {
+                            zoneInfo.zoneId = initOrder.zoneId;
+                            zoneInfo.duration = 0;
+                            zoneInfo.deliveryCost = 0;
+                        }
+                    }
+                    else {
+                        zoneInfo.zoneId = initOrder.zoneId;
+                        zoneInfo.duration = 0;
+                        zoneInfo.deliveryCost = 0;
+                    }
+                }
+                // else {
+                //  //here staff entered custom value as delivery cost and not need anything
+                // }
+            }
+            // else {
+            //
+            //   console.log("else -------------2");
+            //
+            //   zoneInfo.zoneId = initOrder.zoneId;
+            //   zoneInfo.duration = 0;
+            //   zoneInfo.deliveryCost = 0;
+            // }
+            form.zoneId = zoneInfo.zoneId;
+            form.deliveryCost = zoneInfo.deliveryCost;
+            form.duration = zoneInfo.duration;
+        }
+        else {
+            // console.log("else -------------");
+            form.zoneId = initOrder.zoneId;
+            form.deliveryCost = 0;
+            form.duration = 0;
+        }
+        // console.log("formInfo : ", {
+        //   zoneId: form.zoneId,
+        //   duration: form.duration,
+        //   deliveryCost: form.deliveryCost
+        // });
+        return form;
+    }
+    calculateItemsAmount(list) {
+        if (list.length === 0)
+            return 0;
+        return list.map(i => i.totalAmount).reduce((a, b) => this.round(a + b));
+    }
+    calculateTax(taxPercentage, subTotal, discount, deliveryCost) {
+        return (taxPercentage / 100) * ((+subTotal) + (+deliveryCost) - (+discount));
+    }
+    calculateDiscount(order, subTotal) {
+        if (order.discountType === EnumDiscountType.percent)
+            return subTotal * order.discount / 100;
+        return order.discount;
+    }
+    calculateTip(order, subTotal) {
+        if (order.tipType === EnumTipType.percent)
+            return subTotal * order.tip / 100;
+        return order.tip;
+    }
+    calculateReward(totalAmount, rewardProgram) {
+        if (!rewardProgram || !rewardProgram.state)
+            return 0;
+        let points = 0;
+        try {
+            switch (rewardProgram.rewardsPoints) {
+                case EnumRewardPointType.PerAmount:
+                    if (rewardProgram.rewardsEveryValue > 0) {
+                        points = Math.round(totalAmount / rewardProgram.rewardsEveryValue);
+                    }
+                    if (rewardProgram.rewardsMaxPointsPerOrder !== 0 && rewardProgram.rewardsMaxPointsPerOrder < points) {
+                        points = rewardProgram.rewardsMaxPointsPerOrder;
+                    }
+                    break;
+                case EnumRewardPointType.PerOrder:
+                    points = rewardProgram.rewardsNumberOfPoints;
+                    break;
+                default:
+                    break;
+            }
+        }
+        catch (e) {
+        }
+        return points;
+    }
+    customerOrNull(order) {
+        // const customer = {
+        //   email: order.email,
+        //   phoneNumber: PhoneController.unFormatPhoneNumber(PhoneController.formatPhoneNumber(order.phoneNumber)),
+        //   firstName: order.firstName,
+        //   lastName: order.lastName,
+        //   gender: order.genderType,
+        //   id: order.customerId
+        // }
+        // if (order.orderType === EnumOrderType.delivery || order.email !== "" || order.phoneNumber !== "" || order.firstName !== "" || order.lastName !== "" || order.customerId !== null) {
+        //   return {
+        //     email: order.email,
+        //     phoneNumber: PhoneController.unFormatPhoneNumber(PhoneController.formatPhoneNumber(order.phoneNumber)),
+        //     firstName: order.firstName,
+        //     lastName: order.lastName,
+        //     gender: order.genderType,
+        //     id: order.customerId
+        //   };
+        // }
+        return {
+            email: order.email,
+            phoneNumber: PhoneController.unFormatPhoneNumber(PhoneController.formatPhoneNumber(order.phoneNumber)),
+            firstName: order.firstName,
+            lastName: order.lastName,
+            gender: order.genderType,
+            id: order.customerId
+        };
+    }
+    locationOrNull(order) {
+        try {
+            if (order.latitude === null)
+                order.latitude = 0;
+            if (order.longitude === null)
+                order.longitude = 0;
+            if (!order)
+                return null;
+            if (typeof order.longitude === "string")
+                order.longitude = +order.longitude;
+            if (typeof order.latitude === "string")
+                order.latitude = +order.latitude;
+            if (isNaN(order.longitude))
+                order.longitude = 0;
+            if (isNaN(order.longitude))
+                order.latitude = 0;
+            if (order.longitude === 0 && order.latitude === 0 && order.orderType !== EnumOrderType.delivery)
+                return null;
+            return {
+                longitude: +((+(order.longitude + "")).toFixed(6)),
+                latitude: +((+(order.latitude + "")).toFixed(6)),
+            };
+        }
+        catch (e) {
+            return {
+                longitude: +(order.longitude + ""),
+                latitude: +(order.latitude + ""),
+            };
+        }
+    }
+    convertOrderExtraItemToOrderDetailProductsExtra(item) {
+        return {
+            id: item.id,
+            extraId: item.extraId,
+            extraItemId: item.extraItemId,
+            extraTitle: item.extraTitle,
+            extraItemTitle: item.extraItemTitle,
+            price: item.price,
+            quantity: item.quantity,
+            totalAmount: item.totalAmount,
+            priority: 1,
+            pizzaSide: item.pizzaSide,
+            text: item.text,
+            extraItemOptionId: item.extraItemOptionId,
+            extraItemOptionTitle: item.extraItemOptionTitle,
+        };
+    }
+    convertOrderItemToOrderDetailProduct(item, currency) {
+        return {
+            id: item.id,
+            productId: item.productId,
+            categoryId: -1,
+            categoryTitle: "",
+            title: item.title,
+            quantity: item.quantity,
+            price: item.price,
+            note: item.note,
+            extrasNames: this.createExtraNames(item, currency),
+            totalAmount: item.totalAmount,
+            text: "",
+            extras: item.extras.map(i => this.convertOrderExtraItemToOrderDetailProductsExtra(i)),
+            kitchenReceiptName: item.title,
+            additionalText: item.additionalText,
+        };
+    }
+    createExtraNames(item, currency) {
+        let list = [];
+        item.extras.forEach(i => {
+            // let part = "";
+            // if (i.quantity > 1) part += i.quantity + "x ";
+            //
+            // part += i.extraItemTitle + " ";
+            //
+            // if (i.extraItemOptionId !== -1) part += `[${i.extraItemOptionTitle}] `;
+            //
+            // if (i.totalAmount > 0) part += `(${MoneyController.format(i.totalAmount, currency)})`;
+            list.push(this.createExtraItemText(i, currency));
+        });
+        return list.join(" , ");
+    }
+    createExtraItemText(item, currency) {
+        let part = "";
+        if (item.quantity > 1)
+            part += item.quantity + "x ";
+        switch (item.pizzaSide) {
+            case EnumPizzaSide.all:
+                part += "[WHOLE] ";
+                break;
+            case EnumPizzaSide.left:
+                part += "[LEFT] ";
+                break;
+            case EnumPizzaSide.right:
+                part += "[RIGHT] ";
+                break;
+        }
+        part += item.extraItemTitle + " ";
+        if (item.extraItemOptionId !== -1)
+            part += `[${item.extraItemOptionTitle}] `;
+        if (item.totalAmount > 0)
+            part += `(${MoneyController.format(item.totalAmount, currency)})`;
+        return part;
+    }
+    roundCashAmount(price, rounding) {
+        if (price == 0 || rounding == EnumPriceMidpointRounding.None) {
+            return { newPrice: price, roundingRate: 0 };
+        }
+        let roundingRate;
+        if (price === null || price === undefined || (price + "").trim() === "" || isNaN(parseFloat(price + "")))
+            price = 0;
+        let str = price.toFixed(2);
+        let index = str.indexOf(".");
+        let number = Number.parseInt(str);
+        let tensDigit = +str.substring(index + 1, index + 2);
+        let digit = +str.substring(index + 2, index + 3);
+        switch (rounding) {
+            case EnumPriceMidpointRounding.CeilingFiveCent:
+                if (digit > 0 && digit < 5) {
+                    digit = 5;
+                }
+                else if (digit > 6 && digit <= 9) {
+                    digit = 0;
+                    tensDigit++;
+                }
+                break;
+            case EnumPriceMidpointRounding.CeilingTenCent:
+                digit = 0;
+                tensDigit++;
+                break;
+            case EnumPriceMidpointRounding.CeilingFiftyCent:
+                digit = 0;
+                if (tensDigit > 0 && tensDigit < 5) {
+                    tensDigit = 5;
+                }
+                else if (tensDigit > 5 && tensDigit <= 9) {
+                    tensDigit = 0;
+                    number++;
+                }
+                break;
+            case EnumPriceMidpointRounding.FloorFiveCent:
+                if (digit >= 1 && digit <= 4) {
+                    digit = 0;
+                }
+                else if (digit >= 6 && digit <= 9) {
+                    digit = 5;
+                }
+                break;
+            case EnumPriceMidpointRounding.FloorTenCent:
+                digit = 0;
+                break;
+            case EnumPriceMidpointRounding.FloorFiftyCent:
+                digit = 0;
+                if (tensDigit >= 1 && tensDigit <= 4) {
+                    tensDigit = 0;
+                }
+                else if (tensDigit >= 6 && tensDigit <= 9) {
+                    tensDigit = 5;
+                }
+                break;
+            case EnumPriceMidpointRounding.MediocrityFiveCent:
+                if (digit == 1 || digit == 2) {
+                    digit = 0;
+                }
+                else if (digit >= 3 && digit <= 7) {
+                    digit = 5;
+                }
+                else if (digit == 8 || digit === 9) {
+                    digit = 0;
+                    tensDigit++;
+                }
+                break;
+            case EnumPriceMidpointRounding.MediocrityTenCent:
+                if (digit >= 1 && digit <= 4) {
+                    digit = 0;
+                }
+                else if (digit >= 5 && digit <= 9) {
+                    digit = 0;
+                    tensDigit++;
+                }
+                break;
+            case EnumPriceMidpointRounding.MediocrityFiftyCent:
+                let n = (tensDigit * 10) + digit;
+                if (n < 35) {
+                    digit = 0;
+                    tensDigit = 0;
+                }
+                else if (n >= 35 && n < 70) {
+                    digit = 0;
+                    tensDigit = 5;
+                }
+                else if (n >= 70) {
+                    digit = 0;
+                    tensDigit = 0;
+                    number++;
+                }
+                break;
+        }
+        if (tensDigit >= 10) {
+            tensDigit = 0;
+            number++;
+        }
+        let newPrice = +`${number}.${tensDigit}${digit}`;
+        roundingRate = newPrice - price;
+        return { newPrice: newPrice, roundingRate: roundingRate };
+    }
+    coveragesAddress(location, zones, checkDeliveryCoverageArea) {
+        if (!checkDeliveryCoverageArea)
+            return true;
+        return zones.filter(zone => zone.enabled)
+            .find(zone => ZoneController.pointInPolygon(zone.points, {
+            latitude: +(location.latitude + ""),
+            longitude: +(location.longitude + "")
+        })) !== undefined;
+    }
+    zonesThatCoverageLocation(location, zones) {
+        return zones.filter(zone => zone.enabled).filter(zone => ZoneController.pointInPolygon(zone.points, {
+            latitude: +(location.latitude + ""),
+            longitude: +(location.longitude + "")
+        }));
+    }
+    calculateFee(companyFee, order, orderAmount) {
+        const { orderType, paymentType } = order;
+        const { enabled, calculationMode, orderTypes, type, maximumOrderAmount, amount, minimumOrderAmount, minimumFee, maximumFee, paymentTypes, text, taxable, percentage, taxPercentage } = companyFee;
+        let result = {
+            text: text,
+            amount: 0,
+            type: type,
+            tax: 0
+        };
+        if (!enabled)
+            return result;
+        if (calculationMode == EnumFeeCalculationMode.NONE)
+            return result;
+        if (Array.isArray(orderTypes) && orderTypes.length > 0 && !orderTypes.includes(orderType))
+            return result;
+        if (paymentType == EnumPaymentType.none)
+            return result;
+        let notOnOnlinePay = paymentType == EnumPaymentType.online && !ToolController.find_number_to_2(paymentTypes, 1);
+        let notOnCashPay = paymentType == EnumPaymentType.cash && !ToolController.find_number_to_2(paymentTypes, 2);
+        let notOnDebitAt = paymentType == EnumPaymentType.debitAt && !ToolController.find_number_to_2(paymentTypes, 4);
+        let notOnApplePay = paymentType == EnumPaymentType.applePay && !ToolController.find_number_to_2(paymentTypes, 8);
+        let notOnGooglePay = paymentType == EnumPaymentType.googlePay && !ToolController.find_number_to_2(paymentTypes, 16);
+        let notOnStripeTerminal = paymentType == EnumPaymentType.terminal && !ToolController.find_number_to_2(paymentTypes, 32);
+        let notOnWallet = paymentType == EnumPaymentType.wallet && !ToolController.find_number_to_2(paymentTypes, 64);
+        let notOnGiftCards = paymentType == EnumPaymentType.wallet && !ToolController.find_number_to_2(paymentTypes, 128);
+        //TODO need test and fix
+        let notOnElvanPayment = paymentType == EnumPaymentType.debitMachine && !ToolController.find_number_to_2(paymentTypes, 256);
+        let notOnSplitPayment = paymentType == EnumPaymentType.splitPayments && !ToolController.find_number_to_2(paymentTypes, 512);
+        // let notOnNone = paymentType == EnumPaymentType.terminal && !ToolController.find_number_to_2(paymentTypes, 0);
+        if (notOnOnlinePay || notOnCashPay || notOnDebitAt || notOnGooglePay || notOnApplePay || notOnWallet || notOnGiftCards || notOnStripeTerminal || notOnElvanPayment || notOnSplitPayment)
+            return result;
+        if (minimumOrderAmount != 0 && orderAmount < minimumOrderAmount)
+            return result;
+        if (maximumOrderAmount != 0 && orderAmount > maximumOrderAmount)
+            return result;
+        let fee = 0;
+        let tax = 0;
+        switch (calculationMode) {
+            case EnumFeeCalculationMode.FIXED:
+                fee = amount;
+                break;
+            case EnumFeeCalculationMode.MIXED:
+                if (percentage > 0)
+                    fee += +MoneyController.round((percentage * orderAmount) / 100); //Math.Round((((decimal)percentage) *orderAmount) /100, 2);
+                break;
+            case EnumFeeCalculationMode.BOTH:
+                fee = amount;
+                if (percentage > 0)
+                    fee += +MoneyController.round((percentage * orderAmount) / 100); //Math.Round((((decimal)percentage) *orderAmount) /100, 2);
+                break;
+            default:
+                break;
+        }
+        if (taxable) {
+            if (fee > 0 && taxPercentage > 0) {
+                tax = +MoneyController.round((taxPercentage * fee) / 100); //Math.Round((fee * (decimal)taxPercentage) /100, 2);
+                fee += tax;
+            }
+        }
+        if (calculationMode == EnumFeeCalculationMode.MIXED || calculationMode == EnumFeeCalculationMode.BOTH) {
+            if (minimumFee > 0 && fee < minimumFee)
+                fee = minimumFee;
+            if (maximumFee > 0 && fee > maximumFee)
+                fee = maximumFee;
+        }
+        result.amount = fee;
+        result.tax = tax;
+        return result;
+    }
+    formatSetting(_setting) {
+        //TODO this method after update https://core.meemup.com must be removed
+        let data = Object.assign({}, _setting);
+        if (!data.hasOwnProperty("fees")) {
+            data.fees = [];
+        }
+        return data;
+    }
+    customerText(form) {
+        const label = `${form.firstName} ${form.lastName}`;
+        if (label.trim() === "")
+            return "Guest";
+        return label;
+    }
+    isMandatory(orderType, value) {
+        switch (orderType) {
+            case EnumOrderType.dining:
+                return value === EnumCustomerMandatory.ON_DELIVERY_AND_DINING || value === EnumCustomerMandatory.ONLY_ON_DINING || value === EnumCustomerMandatory.YES || value === EnumCustomerMandatory.ON_PICKUP_AND_DINING;
+            case EnumOrderType.pickup:
+                return value === EnumCustomerMandatory.ON_PICKUP_AND_DINING || value === EnumCustomerMandatory.ONLY_ON_PICKUP || value === EnumCustomerMandatory.YES || value === EnumCustomerMandatory.ON_PICKUP_AND_DELIVERY;
+            case EnumOrderType.delivery:
+                return value === EnumCustomerMandatory.ON_PICKUP_AND_DELIVERY || value === EnumCustomerMandatory.ONLY_ON_DELIVERY || value === EnumCustomerMandatory.YES || value === EnumCustomerMandatory.ON_DELIVERY_AND_DINING;
+            default:
+                return false;
+        }
+    }
+    round(num) {
+        return Math.round(num * 100) / 100;
+    }
+}

package/dist/interfaces/ICalculateFeeResult.d.ts

@@ -2,5 +2,6 @@ interface ICalculateFeeResult {
     type: number;
     text: string;
     amount: number;
+    tax: number;
 }
 export default ICalculateFeeResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meemup-library",
-  "version": "1.2.69",
+  "version": "1.2.71",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",