@sellout/models 0.0.188-alpha.0 → 0.0.188

package/src/utils/PaymentUtil.ts

@@ -10,6 +10,7 @@ import IFee, {
   FeeAppliedByEnum
 } from "../interfaces/IFee";
 import { PaymentMethodTypeEnum } from "../enums/PaymentMethodTypeEnum";
+// import Fee from "src/schemas/Fee";
 
 interface IPaymentCalculatorParams {
   tickets: ICreateOrderTicketParams[];
@@ -134,7 +135,7 @@ class PaymentUtil {
   //   };
   // },
 
-  calculatePaymentTotal(params: IPaymentCalculatorParams): number {
+  calculatePaymentTotal(params: IPaymentCalculatorParams): any {
     let { tickets = [], upgrades = [], fees = [], paymentMethodType } = params;
 
     // No items, total is always 0
@@ -151,6 +152,10 @@ class PaymentUtil {
         return false;
       }
 
+      if (fee.appliedBy == FeeAppliedByEnum.Stripe && paymentMethodType == PaymentMethodTypeEnum.Cash) {
+        return false;
+      }
+
       // Ignore card entry fees for non card entry payemnts
       if (
         fee.filters &&
@@ -167,12 +172,13 @@ class PaymentUtil {
       (fee: IFee) =>
         fee.filters && fee.filters[0] == FeeFiltersEnum.GuestTicket
     );
-    
+
     fees = fees.filter(
       (fee: IFee) =>
         fee.filters && fee.filters[0] !== FeeFiltersEnum.GuestTicket
     );
 
+
     function applyGuestTicketFee(
       ticket: ICreateOrderTicketParams,
       fee: IFee
@@ -181,12 +187,12 @@ class PaymentUtil {
       if (
         fee.filters &&
         fee.filters.includes(FeeFiltersEnum.Seated) &&
-        !ticket.seat 
+        !ticket.seat
       ) {
         return 0;
       }
 
-      if(!ticket.guestTicket){
+      if (!ticket.guestTicket) {
         return 0;
       }
 
@@ -206,262 +212,193 @@ class PaymentUtil {
 
       return 0;
     }
-    
-    const ticketGuestFeeTotal = tickets.reduce((cur, ticket) => {
-      return (
-        cur +
-        guestFees.reduce((cur, fee) => {
-          const value = cur + applyGuestTicketFee(ticket, fee);
-          return value;
-        }, 0)
-      );
-    }, 0);
+    // Fees applied
+    const ticketFeesPromotersFlat = fees
+      .filter((f) => f.appliedTo === FeeAppliedToEnum.Ticket &&
+        f.appliedBy == FeeAppliedByEnum.Organization && f.type === FeeTypeEnum.Flat)
+    const ticketFeesPromotersPercent = fees
+      .filter((f) => f.appliedTo === FeeAppliedToEnum.Ticket &&
+        f.appliedBy == FeeAppliedByEnum.Organization && f.type === FeeTypeEnum.Percent);
+
+    const upgradeFeesPromotersFees = fees.filter(
+      (f) => f.appliedTo === FeeAppliedToEnum.Upgrade && f.appliedBy == FeeAppliedByEnum.Organization
+    );
 
-  
-    const ticketFees = fees
-      .filter((f) => f.appliedTo === FeeAppliedToEnum.Ticket)
-      .sort(({ type }) => {
-        if (type === FeeTypeEnum.Flat) return -1;
-        else return 1;
-      });
-    const upgradeFees = fees.filter(
-      (f) => f.appliedTo === FeeAppliedToEnum.Upgrade
+    const upgradeFeesSelloutFees = fees.filter(
+      (f) => f.appliedTo === FeeAppliedToEnum.Upgrade && f.appliedBy == FeeAppliedByEnum.Sellout
+    );
+
+    const selloutFees: any = fees.filter(
+      (f) => f.appliedBy == FeeAppliedByEnum.Sellout
+      // (f) => f.appliedTo === FeeAppliedToEnum.Upgrade && f.appliedBy == FeeAppliedByEnum.Sellout
+    );
+    // sales tax fee
+    const salesTaxFees = fees.find((f) => f.name == "Sales tax");
+    const stripeFees = fees.filter(
+      (f) => f.appliedBy == FeeAppliedByEnum.Stripe
     );
     // Orders mattes here. Flat type fees must be applied before Percent type fees
-    const orderFees = fees
+    const promoterOrderFees = fees
       .filter(
-        (f) => f.appliedTo === FeeAppliedToEnum.Order && f.name != "Sales tax"
+        (f) => f.appliedTo === FeeAppliedToEnum.Order && f.name != "Sales tax" && f.appliedBy == FeeAppliedByEnum.Organization
       )
       .sort(({ type }) => {
         if (type === "Flat") return -1;
         else return 1;
       });
-    const salesTax = fees.filter((f) => f.name == "Sales tax");
-
-    function applyTicketFee(
-      ticket: ICreateOrderTicketParams,
-      fee: IFee
-    ): number {
-      // Ignore seated fees if not seated
-      if (
-        fee.filters &&
-        fee.filters.includes(FeeFiltersEnum.Seated) &&
-        !ticket.seat
-      ) {
-        return 0;
-      }
-
-      const minFee = fee.minAppliedToPrice || 0;
-      const maxFee = fee.maxAppliedToPrice || Infinity;
-
-      if (minFee <= ticket.price && ticket.price <= maxFee) {
-        if (fee.type === FeeTypeEnum.Flat) {
-          return fee.value;
-        }
-        if (fee.type === FeeTypeEnum.Percent) {
-          return (ticket.price * fee.value) / 100;
-        }
-      } else {
-        return 0;
-      }
-
-      return 0;
-    }
-
-    function applyUpgradeFee(
-      upgrade: ICreateOrderUpgradeParams,
-      fee: IFee
-    ): number {
-      const minFee = fee.minAppliedToPrice || 0;
-      const maxFee = fee.maxAppliedToPrice || Infinity;
-
-      if (minFee <= upgrade.price && upgrade.price <= maxFee) {
-        if (fee.type === FeeTypeEnum.Flat) {
-          return upgrade.price + fee.value;
-        }
-        if (fee.type === FeeTypeEnum.Percent) {
-          return (upgrade.price * fee.value) / 100;
-        }
-      } else {
-        return 0;
-      }
+    // Caclualtions 
+    const ticketTotal = tickets.reduce((cur, ticket) => cur + ticket.price, 0);
+    const upgradeTotal = upgrades.reduce((cur, upgrade) => cur + upgrade.price, 0);
+    const totalTicketAndUpgrades = ticketTotal + upgradeTotal
 
-      return 0;
-    }
+    const promoterFeeFlatPerOrderTotal = promoterOrderFees.reduce((acc, fee: any) => {
+      if (fee.type == FeeTypeEnum.Flat) {
 
-    function applyOrderFee(orderSubtotal, fee) {
-      if (fee.type === FeeTypeEnum.Flat) {
-        return orderSubtotal + fee.value;
+        return acc + getFeeAmount(fee)
       }
-      if (fee.type === FeeTypeEnum.Percent) {
-        return orderSubtotal / (1 - fee.value / 100);
-      }
-    }
+      return acc
+    }, 0)
 
-    const ticketTotal = tickets.reduce((cur, ticket) => cur + ticket.price, 0);
-    
-
-    const ticketTaxFeeTotal = tickets.reduce((cur, ticket) => {
+    const promoterFeeFlatPerTicketTotal = tickets.reduce((cur, ticket) => {
       return (
         cur +
-        salesTax.reduce((cur, fee) => {
+        ticketFeesPromotersFlat.reduce((cur, fee) => {
           const value = cur + applyTicketFee(ticket, fee);
           return value;
         }, 0)
       );
     }, 0);
-    const ticketFeeTotal = tickets.reduce((cur, ticket) => {
+
+    const promoterFeeFlatPerUpgradeTotal = upgrades.reduce((cur, upgrade) => {
       return (
         cur +
-        ticketFees.reduce((cur, fee) => {
-          const value = cur + applyTicketFee(ticket, fee);
+        upgradeFeesPromotersFees.reduce((cur, fee) => {
+          const value = cur + applyUpgradeFee(upgrade, fee);
           return value;
         }, 0)
       );
     }, 0);
 
-    
-
-
-    const upgradeTotal = upgrades.reduce(
-      (cur, upgrade) => cur + upgrade.price,
-      0
-    );
-
-    const upgradeTaxFeeTotal = upgrades.reduce((cur, upgrade) => {
+    const SelloutFeeFlatPerUpgradeTotal = upgrades.reduce((cur, upgrade) => {
       return (
         cur +
-        salesTax.reduce((curr, fee) => curr + applyUpgradeFee(upgrade, fee), 0)
+        upgradeFeesSelloutFees.reduce((cur, fee) => {
+          const value = cur + applyUpgradeFee(upgrade, fee);
+          return value;
+        }, 0)
       );
     }, 0);
 
-    const upgradeFeeTotal = upgrades.reduce((cur, upgrade) => {
+    const promoterFeePercentPerTicketTotal = tickets.reduce((cur, ticket) => {
       return (
         cur +
-        upgradeFees.reduce((cur, fee) => cur + applyUpgradeFee(upgrade, fee), 0)
+        ticketFeesPromotersPercent.reduce((cur, fee) => {
+          const value = cur + applyTicketFee(ticket, fee);
+          return value;
+        }, 0)
       );
     }, 0);
-    const orderSubtotal = Math.round(
-      ticketTotal +
-        ticketTaxFeeTotal +
-        // ticketFeeTotal +
-        ticketFeeTotal +
-        upgradeTaxFeeTotal + ticketGuestFeeTotal +
-        upgradeTotal +
-        upgradeFeeTotal
-    );
-
-
-    const orderTotal = orderFees.reduce((cur, fee) => {
-      return applyOrderFee(cur, fee);
-    }, orderSubtotal);
-
-    return Math.round(orderTotal);
-  }
-
-
-  calculatePaymentTotalDublicate(params: IPaymentCalculatorParams): number {
-    let { tickets = [], upgrades = [], fees = [], paymentMethodType } = params;
 
-    // No items, total is always 0
-    if (!tickets.length && !upgrades.length) return 0;
-
-    // Filter fees
-    fees = fees.filter((fee: IFee) => {
-      // Ignore card reader fees for non card reader payemnts
-      if (
-        fee.filters &&
-        fee.filters.includes(FeeFiltersEnum.CardReader) &&
-        paymentMethodType !== PaymentMethodTypeEnum.CardReader
-      ) {
-        return false;
+    const promoterFeePercentPerOrder = promoterOrderFees.reduce((acc, fee) => {
+      if (fee.type == FeeTypeEnum.Percent) {
+        return acc + getFeeAmount(fee, totalTicketAndUpgrades)
       }
+      return acc
+    }, 0)
 
-      // Ignore card entry fees for non card entry payemnts
-      if (
-        fee.filters &&
-        fee.filters.includes(FeeFiltersEnum.CardEntry) &&
-        paymentMethodType !== PaymentMethodTypeEnum.CardEntry
-      ) {
-        return false;
-      }
+    const ticketGuestFeeTotalForPromoter = tickets.reduce((cur, ticket) => {
+      return (
+        cur +
+        guestFees.reduce((cur, fee) => {
+          const value = fee.appliedBy == FeeAppliedByEnum.Organization ? cur + applyGuestTicketFee(ticket, fee) : 0;
+          return value;
+        }, 0)
+      );
+    }, 0);
 
-      return true;
-    });
+    const ticketGuestFeeTotalForSellout = tickets.reduce((cur, ticket) => {
+      return (
+        cur +
+        guestFees.reduce((cur, fee) => {
+          const value = fee.appliedBy == FeeAppliedByEnum.Sellout ? cur + applyGuestTicketFee(ticket, fee) : 0;
+          return value;
+        }, 0)
+      );
+    }, 0);
 
-    let guestFees = fees.filter(
-      (fee: IFee) =>
-        fee.filters && fee.filters[0] == FeeFiltersEnum.GuestTicket
-    );
-    
-    fees = fees.filter(
-      (fee: IFee) =>
-        fee.filters && fee.filters[0] !== FeeFiltersEnum.GuestTicket
-    );
+    const orderSubtotal = Math.round(
+      ticketTotal +
+      upgradeTotal +
+      promoterFeeFlatPerTicketTotal +
+      promoterFeeFlatPerOrderTotal +
+      promoterFeePercentPerTicketTotal +
+      promoterFeePercentPerOrder +
+      ticketGuestFeeTotalForPromoter + promoterFeeFlatPerUpgradeTotal
+    )
+    const salesTaxAmount = salesTaxFees ? (orderSubtotal * salesTaxFees.value) / 100 : 0;
 
-    function applyGuestTicketFee(
-      ticket: ICreateOrderTicketParams,
-      fee: IFee
-    ): number {
-      // Ignore seated fees if not seated
-      if (
-        fee.filters &&
-        fee.filters.includes(FeeFiltersEnum.Seated) &&
-        !ticket.seat 
-      ) {
-        return 0;
-      }
+    const promoterTotal = orderSubtotal + salesTaxAmount;
 
-      if(!ticket.guestTicket){
-        return 0;
+    const selloutPercentFeesAmt = selloutFees.reduce((acc, fee) => {
+      if (fee.type == FeeTypeEnum.Percent) {
+        return acc + getFeeAmount(fee, promoterTotal)
       }
+      return acc
+    }, 0)
 
-      const minFee = fee.minAppliedToPrice || 0;
-      const maxFee = fee.maxAppliedToPrice || Infinity;
+    const selloutFeeFlatPerTicketAmt = tickets.reduce((cur: number, ticket: any) => {
+      return (
+        cur +
+        selloutFees.reduce((cur: number, fee: IFee) => {
+          if (fee.type == FeeTypeEnum.Flat && fee.appliedTo === FeeAppliedToEnum.Ticket &&
+            !fee?.filters?.includes(FeeFiltersEnum.Seated)
+          ) {
+            const value = cur + applyTicketFee(ticket, fee);
+            return value;
+          }
+          return cur
+        }, 0)
+      );
+    }, 0);
 
-      if (minFee <= ticket.price && ticket.price <= maxFee) {
-        if (fee.type === FeeTypeEnum.Flat) {
-          return fee.value;
-        }
-        if (fee.type === FeeTypeEnum.Percent) {
-          return (ticket.price * fee.value) / 100;
-        }
-      } else {
-        return 0;
+    const selloutFeeFlatPerOrderAmt = selloutFees.reduce((cur: number, fee: IFee) => {
+      if (fee.type === FeeTypeEnum.Flat && fee.appliedTo === FeeAppliedToEnum.Order) {
+        const value = cur + fee.value;
+        return value;
       }
-
-      return 0;
-    }
-    
-    const ticketGuestFeeTotal = tickets.reduce((cur, ticket) => {
+      return cur
+    }, 0)
+    const selloutSeatedFeeAmt = tickets.reduce((cur: number, ticket: any) => {
       return (
         cur +
-        guestFees.reduce((cur, fee) => {
-          const value = cur + applyGuestTicketFee(ticket, fee);
-          return value;
+        selloutFees.reduce((cur: number, fee: IFee) => {
+          if (fee.type == FeeTypeEnum.Flat && fee.appliedTo === FeeAppliedToEnum.Ticket &&
+            fee?.filters?.includes(FeeFiltersEnum.Seated)
+          ) {
+            const value = cur + applyTicketFee(ticket, fee);
+            return value;
+          }
+
+          return cur
+
         }, 0)
       );
     }, 0);
 
-    const ticketFees = fees
-      .filter((f) => f.appliedTo === FeeAppliedToEnum.Ticket)
-      .sort(({ type }) => {
-        if (type === FeeTypeEnum.Flat) return -1;
-        else return 1;
-      });
-    const upgradeFees = fees.filter(
-      (f) => f.appliedTo === FeeAppliedToEnum.Upgrade
-    );
-    // Orders mattes here. Flat type fees must be applied before Percent type fees
-    const orderFees = fees
-      .filter(
-        (f) => f.appliedTo === FeeAppliedToEnum.Order && f.name != "Sales tax"
+    const selloutFeesTotal = Math.round(
+      selloutPercentFeesAmt +
+      selloutFeeFlatPerTicketAmt +
+      selloutFeeFlatPerOrderAmt +
+      selloutSeatedFeeAmt + ticketGuestFeeTotalForSellout + SelloutFeeFlatPerUpgradeTotal
     )
-      .sort(({ type }) => {
-        if (type === "Flat") return -1;
-        else return 1;
-      });
-    const salesTax = fees.filter((f) => f.name == "Sales tax");
+
+    const preStripeTotal = promoterTotal + selloutFeesTotal
+
+    let stripeFeeAmt = 0
+    const stripeFeePercentage = stripeFees.find(fee => fee.type == FeeTypeEnum.Percent)?.value || 0
+    const stripeFeeFlat = stripeFees.find(fee => fee.type == FeeTypeEnum.Flat)?.value || 0
+    stripeFeeAmt = (preStripeTotal + (stripeFeeFlat)) / (1 - (stripeFeePercentage / 100)) - preStripeTotal
+    // stripeFeeAmt = ((preStripeTotal + (stripeFeeFlat)) * (stripeFeePercentage / 100)) - preStripeTotal
 
     function applyTicketFee(
       ticket: ICreateOrderTicketParams,
@@ -502,7 +439,8 @@ class PaymentUtil {
 
       if (minFee <= upgrade.price && upgrade.price <= maxFee) {
         if (fee.type === FeeTypeEnum.Flat) {
-          return upgrade.price + fee.value;
+          // return upgrade.price + fee.value;
+          return fee.value;
         }
         if (fee.type === FeeTypeEnum.Percent) {
           return (upgrade.price * fee.value) / 100;
@@ -514,89 +452,103 @@ class PaymentUtil {
       return 0;
     }
 
-    function applyOrderFee(orderSubtotal, fee) {
+    // depricated 
+
+    // function applyOrderFee(orderSubtotal, fee) {
+    //   if (fee.type === FeeTypeEnum.Flat) {
+    //     return fee.value
+    //     // return orderSubtotal + fee.value;
+    //   }
+    //   if (fee.type === FeeTypeEnum.Percent) {
+    //     // return orderSubtotal / (1 - fee.value / 100);
+    //     return orderSubtotal * (fee.value / 100);
+
+    //   }
+    // }
+
+    // return Calculated fees amount based on type
+    function getFeeAmount(fee, amt = 0) {
       if (fee.type === FeeTypeEnum.Flat) {
-        return orderSubtotal + fee.value;
+        return fee.value;
       }
       if (fee.type === FeeTypeEnum.Percent) {
-        return orderSubtotal / (1 - fee.value / 100);
+        return amt * (fee.value / 100);
       }
     }
 
-    const ticketTotal = tickets.reduce((cur, ticket) => cur + ticket.price, 0);
-    
+    // function applySelloutFee(amt, fee) {
+    //   if (fee.type === FeeTypeEnum.Flat) {
+    //     return amt + fee.value;
+    //   }
+    //   if (fee.type === FeeTypeEnum.Percent) {
+    //     // return amt / (1 - fee.value / 100);
+    //     return amt * (fee.value / 100);
+    //   }
+    // }
+    // let totconsole.log(toto)o = preStripeTotal + stripeFeeAmt;
+
+    // return Math.round(preStripeTotal + stripeFeeAmt);
+    let promoterFeeAmount = promoterFeeFlatPerTicketTotal + promoterFeeFlatPerOrderTotal + promoterFeePercentPerTicketTotal +
+      promoterFeePercentPerOrder + ticketGuestFeeTotalForPromoter + promoterFeeFlatPerUpgradeTotal;
+    let total = {
+      salesTax: salesTaxAmount || 0,
+      total: (preStripeTotal + stripeFeeAmt) || 0,
+      promoterFees: (promoterFeeAmount) || 0,
+      stripeFees: stripeFeeAmt || 0,
+      selloutFees: selloutFeesTotal || 0,
+      orderSubtotal: orderSubtotal || 0,
+      subTotal: totalTicketAndUpgrades || 0,
+      totalFees: (promoterFeeAmount + stripeFeeAmt + selloutFeesTotal + salesTaxAmount) || 0,
+      totalWithoutTaxFees: (promoterFeeAmount + stripeFeeAmt + selloutFeesTotal) || 0
+    }
+    return total
 
-    const ticketTaxFeeTotal = tickets.reduce((cur, ticket) => {
-      return (
-        cur +
-        salesTax.reduce((cur, fee) => {
-          const value = cur + applyTicketFee(ticket, fee);
-          return value;
-        }, 0)
-      );
-    }, 0);
 
-    // const ticketGuestFeeTotal = tickets.reduce((cur, ticket) => {
+    // const ticketTaxFeeTotal = tickets.reduce((cur, ticket) => {
     //   return (
     //     cur +
-    //     ticketFees.reduce((cur, fee) => {
+    //     salesTax.reduce((cur, fee) => {
     //       const value = cur + applyTicketFee(ticket, fee);
     //       return value;
     //     }, 0)
     //   );
     // }, 0);
 
-    // applyGuestTicketFee
 
 
 
 
-    const ticketFeeTotal = tickets.reduce((cur, ticket) => {
-      return (
-        cur +
-        ticketFees.reduce((cur, fee) => {
-          const value = cur + applyTicketFee(ticket, fee);
-          return value;
-        }, 0)
-      );
-    }, 0);
 
-    const upgradeTotal = upgrades.reduce(
-      (cur, upgrade) => cur + upgrade.price,
-      0
-    );
 
-    const upgradeTaxFeeTotal = upgrades.reduce((cur, upgrade) => {
-      return (
-        cur +
-        salesTax.reduce((curr, fee) => curr + applyUpgradeFee(upgrade, fee), 0)
-      );
-    }, 0);
+    // const upgradeTaxFeeTotal = upgrades.reduce((cur, upgrade) => {
+    //   return (
+    //     cur +
+    //     salesTax.reduce((curr, fee) => curr + applyUpgradeFee(upgrade, fee), 0)
+    //   );
+    // }, 0);
 
-    const upgradeFeeTotal = upgrades.reduce((cur, upgrade) => {
-      return (
-        cur +
-        upgradeFees.reduce((cur, fee) => cur + applyUpgradeFee(upgrade, fee), 0)
-      );
-    }, 0);
-    const orderSubtotal = Math.round(
-      ticketTotal +
-        ticketTaxFeeTotal +
-        ticketFeeTotal +
-        upgradeTaxFeeTotal + ticketGuestFeeTotal +
-        upgradeTotal +
-        upgradeFeeTotal
-    );
+    // const upgradeFeeTotal = upgrades.reduce((cur, upgrade) => {
+    //   return (
+    //     cur +
+    //     upgradeFees.reduce((cur, fee) => cur + applyUpgradeFee(upgrade, fee), 0)
+    //   );
+    // }, 0);
 
+    // const promoterFeeFlatPerOrder = promoterOrderFees.reduce((cur, fee) => {
+    //   return applyOrderFee(cur, fee);
+    // }, ticketTotal + upgradeTotal);
 
-    const orderTotal = orderFees.reduce((cur, fee) => {
-      return applyOrderFee(cur, fee);
-    }, orderSubtotal);
+    // console.log(promoterOrderTotal)
 
 
-    return Math.round(orderTotal);
-  }
+    // Applying sellout fees
+
 
+    //  applying sales tax fees
+
+
+    // return Math.round(orderTotal);
+  }
 
 
   calculatePaymentSubtotal(params: IPaymentCalculatorParams): number {
@@ -616,18 +568,40 @@ class PaymentUtil {
     ); // +  (upgrade.price * tax/100)
     return ticketTotal + upgradeTotal;
   }
+
+
+  calculatePaymentSubtotalValue(params: any): number {
+    let {
+      tickets = [],
+      upgrades = [],
+      // paymentMethodType,
+      // fees
+    } = params;
+
+    // if (paymentMethodType === PaymentMethodTypeEnum.None) return 0;
+
+    const ticketTotal = tickets.reduce((cur, ticket) => cur + ticket.price, 0); // +  (ticket.price * tax/100)
+    const upgradeTotal = upgrades.reduce(
+      (cur, upgrade) => cur + upgrade.price,
+      0
+    ); // +  (upgrade.price * tax/100)
+    return ticketTotal + upgradeTotal;
+  }
+
+
+
   calculateFee(params: IPaymentCalculatorParams): number {
     let { fees } = params;
     const salesTax = fees.filter((f) => f.name == "Sales tax");
     const tax = salesTax.length > 0 ? salesTax[0].value : 0;
-    const total = this.calculatePaymentTotal(params);
+    const total = this.calculatePaymentTotal(params).total;
     let subtotal = this.calculatePaymentSubtotal(params);
     subtotal = subtotal + (subtotal * tax) / 100;
     return Math.round(total - subtotal);
   }
 
   calculateFeeWithoutTax(params: IPaymentCalculatorParams): number {
-    const total = this.calculatePaymentTotal(params);
+    const total = this.calculatePaymentTotal(params).total;
     let subtotal = this.calculatePaymentSubtotal(params);
     return Math.round(total - subtotal);
   }
@@ -667,14 +641,14 @@ class PaymentUtil {
     });
   }
   calculateStripeFee(params: IPaymentCalculatorParams): number {
-    const total = this.calculatePaymentTotal(params);
+    const total = this.calculatePaymentTotal(params).total;
     const subtotal = this.calculatePaymentSubtotal(params);
     const platformFees = this.calculatePlatformFee(params);
     const organizationFee = this.calculateOrganizationFee(params);
     return total - subtotal - platformFees - organizationFee;
   }
   calculateProcessingFee(params: IPaymentCalculatorParams): number {
-    const total = this.calculatePaymentTotal(params);
+    const total = this.calculatePaymentTotal(params).total;
     const subtotal = this.calculatePaymentSubtotal(params);
     const organizationFee = this.calculateOrganizationFee(params);
     return total - subtotal - organizationFee;
@@ -686,7 +660,7 @@ class PaymentUtil {
   // }
 
   calculateGuestFee(tickets: any, event: any): number {
-    
+
     let guestTicketFees = event?.fees.filter(
       (fee: IFee) =>
         fee.filters && fee.filters[0] === FeeFiltersEnum.GuestTicket
@@ -702,10 +676,10 @@ class PaymentUtil {
     let guestMembers = tickets.filter((a) => a.guestTicket).length;
     let guestFees = (guestFeesValue as number) * guestMembers;
     return guestTicketFees.length > 0 && event.organization.isTegIntegration
-      ? guestFees + guestFees * stripeFeesValue/100
+      ? guestFees + guestFees * stripeFeesValue / 100
       : 0;
   }
-  
+
 }
 
 export default new PaymentUtil();