@sellout/models 0.0.233 → 0.0.237

package/src/utils/PaymentUtil.ts

@@ -11,6 +11,11 @@ import IFee, {
   // FeePaymentMethodEnum
 } from "../interfaces/IFee";
 import { PaymentMethodTypeEnum } from "../enums/PaymentMethodTypeEnum";
+import IEventPromotion, {
+  EventPromotionAppliesToEnum,
+  EventPromotionDiscountTypeEnum,
+} from "../interfaces/IEventPromotion";
+// import EventPromotionDiscountTypeEnum from '../interfaces/I'
 // import Fee from "src/schemas/Fee";
 
 interface IPaymentCalculatorParams {
@@ -18,6 +23,7 @@ interface IPaymentCalculatorParams {
   upgrades: ICreateOrderUpgradeParams[];
   fees: IFee[];
   paymentMethodType: PaymentMethodTypeEnum;
+  promotions?: IEventPromotion[];
 }
 
 // interface IOrderItems {
@@ -137,32 +143,101 @@ class PaymentUtil {
   // },
 
   calculatePaymentTotal(params: IPaymentCalculatorParams): any {
-    let { tickets = [], upgrades = [], fees = [], paymentMethodType } = params;
+    let {
+      tickets = [],
+      upgrades = [],
+      fees = [],
+      paymentMethodType,
+      promotions = [],
+    } = params;
 
     // No items, total is always 0
     if (!tickets.length && !upgrades.length) return 0;
 
-    // Filter fees
+    const ticketFeesPromoCodePercent = promotions?.filter(
+      (f) =>
+        f.appliesTo === EventPromotionAppliesToEnum.PerTicket &&
+        f.discountType === EventPromotionDiscountTypeEnum.Percent
+    );
+
+    const discountFeePercentPerTicketTotal = tickets?.reduce((cur, ticket) => {
+      return (
+        cur +
+        ticketFeesPromoCodePercent?.reduce((cur, promotion) => {
+          const value = cur + applyTicketDiscount(ticket, promotion);
+          return value;
+        }, 0)
+      );
+    }, 0);
+
+    // console.log(
+    //   "++++++++++++eee+>>>>>>>>>>>>",
+    //   discountFeePercentPerTicketTotal
+    // );
+
+
+  if(promotions?.length){
+    tickets = tickets.map(ticket => {
+        if(promotions && promotions[0].discountType === "Flat"){
+          if (promotions[0]?.ticketTypeIds.includes(ticket?.ticketTypeId)){
+            const discountValue = Number(promotions[0].discountValue);
+            const originalPrice = tickets[0].price;
+            const discountedPrice = originalPrice - discountValue;
+            return {
+              ...ticket,
+              price : discountedPrice
+            };
+          }
+          else { 
+            const originalPrice = tickets[0].price;
+            return {
+              ...ticket,
+              price : originalPrice
+            };}
+        }
+        if(promotions && promotions[0].discountType === "Percent"){
+          if (promotions[0]?.ticketTypeIds.includes(ticket?.ticketTypeId)){
+            const discountValue = Number(promotions[0].discountValue);
+            const percentTicketValue = (ticket.origionalPrice * discountValue) / 100 
+            const originalPrice = tickets[0].price;
+            const discountPercentPrice = originalPrice - percentTicketValue
+            // const discountedPrice = originalPrice
+            console.log("percentTicketValue",percentTicketValue);
+            
+            return {
+              ...ticket,
+              price : discountPercentPrice
+            };
+          }
+          else { 
+            const originalPrice = tickets[0].price;
+            return {
+              ...ticket,
+              price : originalPrice
+            };}
+        }
+      
+        return ticket;
+      })
+     }
 
+    // Filter fees
     fees = fees.filter((fee: IFee) => {
       if (!fee?.paymentMethods || fee?.paymentMethods?.length == 0) {
-        return true
+        return true;
       } else if (fee?.paymentMethods?.includes(paymentMethodType as any)) {
-        return true
+        return true;
       } else {
-        return false
+        return false;
       }
 
       // fee.paymentMethods.includes(paymentMethodType)
       // fee?.paymentMethods?.includes(paymentMethodType)
 
-
-
       // let isPayment = paymentMethodType !==  fee?.paymentMethods?.includes(paymentMethodType) || PaymentMethodTypeEnum.Check || PaymentMethodTypeEnum.None ||  PaymentMethodTypeEnum.CardReader ? true: false;
 
       // console.log("isPayment ++++>>",isPayment)
 
-
       // if (
       //   fee.paymentMethods &&
       //   fee.paymentMethods.includes(FeePaymentMethodEnum.CardReader) &&
@@ -221,8 +296,7 @@ class PaymentUtil {
     });
 
     let guestFees = fees.filter(
-      (fee: IFee) =>
-        fee.filters && fee.filters[0] == FeeFiltersEnum.GuestTicket
+      (fee: IFee) => fee.filters && fee.filters[0] == FeeFiltersEnum.GuestTicket
     );
 
     fees = fees.filter(
@@ -230,7 +304,6 @@ class PaymentUtil {
         fee.filters && fee.filters[0] !== FeeFiltersEnum.GuestTicket
     );
 
-
     function applyGuestTicketFee(
       ticket: ICreateOrderTicketParams,
       fee: IFee
@@ -264,20 +337,63 @@ class PaymentUtil {
 
       return 0;
     }
+
+    // Discount codes apply
+
+    const isDiscount = promotions?.filter((f) => f.discountValue);
+    console.log(isDiscount,"isDiscount");
+    
+
+    const ticketFeesPromoCodeFlat = promotions?.filter(
+      (f) =>
+        f.appliesTo === EventPromotionAppliesToEnum.PerTicket &&
+        f.discountType === EventPromotionDiscountTypeEnum.Flat
+    );
+
+
+    // const ticketFeesPromoCodePercent = promotions?.filter(
+    //   (f) =>
+    //     f.appliesTo === EventPromotionAppliesToEnum.PerTicket &&
+    //     f.discountType === EventPromotionDiscountTypeEnum.Percent
+    // );
+
+    // const ticketFeesPromoCodeFlatPerOrder = promotions?.filter(
+    //   (f) =>
+    //     f.appliesTo === EventPromotionAppliesToEnum.PerOrder &&
+    //     f.discountType === EventPromotionDiscountTypeEnum.Flat
+    // );
+
+    // const ticketFeesPromoCodePercentPerOrder = promotions?.filter(
+    //   (f) =>
+    //     f.appliesTo === EventPromotionAppliesToEnum.PerOrder &&
+    //     f.discountType === EventPromotionDiscountTypeEnum.Percent
+    // );
+
+
     // 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 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
+      (f) =>
+        f.appliedTo === FeeAppliedToEnum.Upgrade &&
+        f.appliedBy == FeeAppliedByEnum.Organization
     );
 
     const upgradeFeesSelloutFees = fees.filter(
-      (f) => f.appliedTo === FeeAppliedToEnum.Upgrade && f.appliedBy == FeeAppliedByEnum.Sellout
+      (f) =>
+        f.appliedTo === FeeAppliedToEnum.Upgrade &&
+        f.appliedBy == FeeAppliedByEnum.Sellout
     );
 
     const selloutFees: any = fees.filter(
@@ -292,20 +408,136 @@ class PaymentUtil {
     // Orders mattes here. Flat type fees must be applied before Percent type fees
     const promoterOrderFees = fees
       .filter(
-        (f) => f.appliedTo === FeeAppliedToEnum.Order && f.name != "Sales tax" && f.appliedBy == FeeAppliedByEnum.Organization
+        (f) =>
+          f.appliedTo === FeeAppliedToEnum.Order &&
+          f.name != "Sales tax" &&
+          f.appliedBy == FeeAppliedByEnum.Organization
       )
       .sort(({ type }) => {
         if (type === "Flat") return -1;
         else return 1;
       });
-    // Caclualtions 
+    // 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
+    const upgradeTotal = upgrades.reduce(
+      (cur, upgrade) => cur + upgrade.price,
+      0
+    );
+
+    const totalTicketUpgrade = ticketTotal + upgradeTotal;
+
+    const discountFeeFlatPerTicketTotal = tickets?.reduce((cur, ticket) => {
+      return (
+        cur +
+        ticketFeesPromoCodeFlat?.reduce((cur, promotion) => {
+          const value = cur + applyTicketDiscount(ticket, promotion);
+          return value;
+        }, 0)
+      );
+    }, 0);
 
-    const promoterFeeFlatPerOrderTotal = promoterOrderFees.reduce((acc, fee: any) => {
-      return fee.type == FeeTypeEnum.Flat ? (acc + getFeeAmount(fee)) : acc
-    }, 0)
+    // console.log("+++++++++++++>>>>>>>>>>>>", discountFeeFlatPerTicketTotal);
+
+    // const discountFeePercentPerTicketTotal = tickets?.reduce((cur, ticket) => {
+    //   return (
+    //     cur +
+    //     ticketFeesPromoCodePercent?.reduce((cur, promotion) => {
+    //       const value = cur + applyTicketDiscount(ticket, promotion);
+    //       return value;
+    //     }, 0)
+    //   );
+    // }, 0);
+
+    // console.log(
+    //   "++++++++++++eee+>>>>>>>>>>>>",
+    //   discountFeePercentPerTicketTotal
+    // );
+
+    // const discountFeeFlatPerOrderTotal = tickets?.reduce((cur, ticket) => {
+    //   return (
+    //     cur +
+    //     ticketFeesPromoCodeFlatPerOrder?.reduce((cur, promotion) => {
+    //       const value = cur + applyTicketDiscount(ticket, promotion);
+    //       return value;
+    //     }, 0)
+    //   );
+    // }, 0);
+
+    // console.log("+++++++++++++>>>>>>>>>>>>", discountFeeFlatPerOrderTotal);
+
+    // const discountFeePercentPerOrderTotal = tickets?.reduce((cur, ticket) => {
+    //   return (
+    //     cur +
+    //     ticketFeesPromoCodePercentPerOrder?.reduce((cur, promotion) => {
+    //       const value = cur + applyTicketDiscount(ticket, promotion);
+    //       return value;
+    //     }, 0)
+    //   );
+    // }, 0);
+
+    // console.log("+++++++++++++>>>>>>>>>>>>", discountFeePercentPerOrderTotal);
+
+    // const promoterFeeFlatPerOrderTotal = promoterOrderFees.reduce(
+    //   (acc, fee: any) => {
+    //     return fee.type == FeeTypeEnum.Flat ? acc + getFeeAmount(fee) : acc;
+    //   },
+    //   0
+    // );
+
+    const discountFeeFlatPerOrderAmt = promotions?.reduce(
+      (cur: number,promotion: IEventPromotion) => {
+        if (
+          promotion.discountType == EventPromotionDiscountTypeEnum.Flat &&
+          promotion.appliesTo === EventPromotionAppliesToEnum.PerOrder
+        ) {
+          const value = cur + promotion.discountValue;
+          return value;
+        }
+        return cur;
+      },
+      0
+    );
+
+    // console.log("Amt flat per order",discountFeeFlatPerOrderAmt)
+
+
+    const discountFeePercentPerOrderAmt = promotions?.reduce(
+      (cur: number,promotion: IEventPromotion) => {
+        if (
+          promotion.discountType == EventPromotionDiscountTypeEnum.Percent &&
+          promotion.appliesTo === EventPromotionAppliesToEnum.PerOrder
+        ) {
+          const value = cur + (totalTicketUpgrade * promotion.discountValue)/100;
+          return value;
+        }
+        return cur;
+      },
+      0
+    );
+
+    // console.log("Amt percent per order",discountFeePercentPerOrderAmt)
+
+    const discount =
+    Math.round(
+      discountFeeFlatPerTicketTotal || 0 + discountFeePercentPerTicketTotal || 0) || 0;
+      console.log(discount);
+      const discountOrder =
+      Math.round(
+        discountFeeFlatPerOrderAmt || 0 + discountFeePercentPerOrderAmt || 0) || 0;
+        console.log(discountOrder);
+
+    const totalTicketAndUpgrades = Math.round(ticketTotal - discountOrder|| 0 ) + Math.round(upgradeTotal);
+
+
+
+    const promoterFeeFlatPerOrderTotal = promoterOrderFees.reduce(
+      (acc, fee: any) => {
+        return fee.type == FeeTypeEnum.Flat ? acc + getFeeAmount(fee) : acc;
+      },
+      0
+    );
+
+    //
 
     const promoterFeeFlatPerTicketTotal = tickets.reduce((cur, ticket) => {
       return (
@@ -317,6 +549,100 @@ class PaymentUtil {
       );
     }, 0);
 
+    // discount
+
+    // const discountTickets = tickets.filter(
+    //   (obj, index) =>
+    //     tickets.findIndex((item) => item.ticketTypeId === obj.ticketTypeId) ===
+    //     index
+    // );
+    // console.log(discountTickets, "discountTickets");
+
+    // const discountFeeFlatPerTicketTotal = tickets?.reduce((cur, ticket) => {
+    //   return (
+    //     cur +
+    //     ticketFeesPromoCodeFlat?.reduce((cur, promotion) => {
+    //       const value = cur + applyTicketDiscount(ticket, promotion);
+    //       return value;
+    //     }, 0)
+    //   );
+    // }, 0);
+
+    // console.log("+++++++++++++>>>>>>>>>>>>", discountFeeFlatPerTicketTotal);
+
+    // const discountFeePercentPerTicketTotal = tickets?.reduce((cur, ticket) => {
+    //   return (
+    //     cur +
+    //     ticketFeesPromoCodePercent?.reduce((cur, promotion) => {
+    //       const value = cur + applyTicketDiscount(ticket, promotion);
+    //       return value;
+    //     }, 0)
+    //   );
+    // }, 0);
+
+    // console.log(
+    //   "++++++++++++eee+>>>>>>>>>>>>",
+    //   discountFeePercentPerTicketTotal
+    // );
+
+    // // const discountFeeFlatPerOrderTotal = tickets?.reduce((cur, ticket) => {
+    // //   return (
+    // //     cur +
+    // //     ticketFeesPromoCodeFlatPerOrder?.reduce((cur, promotion) => {
+    // //       const value = cur + applyTicketDiscount(ticket, promotion);
+    // //       return value;
+    // //     }, 0)
+    // //   );
+    // // }, 0);
+
+    // // console.log("+++++++++++++>>>>>>>>>>>>", discountFeeFlatPerOrderTotal);
+
+    // const discountFeePercentPerOrderTotal = tickets?.reduce((cur, ticket) => {
+    //   return (
+    //     cur +
+    //     ticketFeesPromoCodePercentPerOrder?.reduce((cur, promotion) => {
+    //       const value = cur + applyTicketDiscount(ticket, promotion);
+    //       return value;
+    //     }, 0)
+    //   );
+    // }, 0);
+
+    // console.log("+++++++++++++>>>>>>>>>>>>", discountFeePercentPerOrderTotal);
+
+    // // const promoterFeeFlatPerOrderTotal = promoterOrderFees.reduce(
+    // //   (acc, fee: any) => {
+    // //     return fee.type == FeeTypeEnum.Flat ? acc + getFeeAmount(fee) : acc;
+    // //   },
+    // //   0
+    // // );
+
+    // const discountFeeFlatPerOrderAmt = promotions?.reduce(
+    //   (cur: number,promotion: IEventPromotion) => {
+    //     if (
+    //       promotion.discountType == EventPromotionDiscountTypeEnum.Flat &&
+    //       promotion.appliesTo === EventPromotionAppliesToEnum.PerOrder
+    //     ) {
+    //       const value = cur + promotion.discountValue;
+    //       return value;
+    //     }
+    //     return cur;
+    //   },
+    //   0
+    // );
+
+    // console.log("Amt flat per order",discountFeeFlatPerOrderAmt)
+
+    // const discountPercentFeesAmt  = promotions.reduce((acc, promotion) => {
+    //   if (promotion.discountType == EventPromotionDiscountTypeEnum.Percent && 
+    //     promotion.appliesTo === EventPromotionAppliesToEnum.PerOrder
+    //     ) {
+    //     return acc + getFeeAmount(promotion, promoterTotal);
+    //   }
+    //   return acc;
+    // }, 0);
+
+    // console.log("order amt percent",discountPercentFeesAmt)
+
     const promoterFeeFlatPerUpgradeTotal = upgrades.reduce((cur, upgrade) => {
       return (
         cur +
@@ -349,16 +675,19 @@ class PaymentUtil {
 
     const promoterFeePercentPerOrder = promoterOrderFees.reduce((acc, fee) => {
       if (fee.type == FeeTypeEnum.Percent) {
-        return acc + getFeeAmount(fee, totalTicketAndUpgrades)
+        return acc + getFeeAmount(fee, totalTicketAndUpgrades);
       }
-      return acc
-    }, 0)
+      return acc;
+    }, 0);
 
     const ticketGuestFeeTotalForPromoter = tickets.reduce((cur, ticket) => {
       return (
         cur +
         guestFees.reduce((cur, fee) => {
-          const value = fee.appliedBy == FeeAppliedByEnum.Organization ? cur + applyGuestTicketFee(ticket, fee) : 0;
+          const value =
+            fee.appliedBy == FeeAppliedByEnum.Organization
+              ? cur + applyGuestTicketFee(ticket, fee)
+              : 0;
           return value;
         }, 0)
       );
@@ -368,86 +697,160 @@ class PaymentUtil {
       return (
         cur +
         guestFees.reduce((cur, fee) => {
-          const value = fee.appliedBy == FeeAppliedByEnum.Sellout ? cur + applyGuestTicketFee(ticket, fee) : 0;
+          const value =
+            fee.appliedBy == FeeAppliedByEnum.Sellout
+              ? cur + applyGuestTicketFee(ticket, fee)
+              : 0;
           return value;
         }, 0)
       );
     }, 0);
 
+    // const discount =
+    //   Math.round(
+    //     discountFeeFlatPerTicketTotal ||
+    //       0 + discountFeePercentPerTicketTotal ||
+    //       0 + discountFeeFlatPerOrderAmt ||
+    //       0 + discountFeePercentPerOrderTotal ||
+    //       0
+    //   ) || 0;
+    // console.log(discount);
+
     const orderSubtotal = Math.round(
-      ticketTotal +
-      upgradeTotal +
-      promoterFeeFlatPerTicketTotal +
-      promoterFeeFlatPerOrderTotal +
-      promoterFeePercentPerTicketTotal +
-      promoterFeePercentPerOrder +
-      ticketGuestFeeTotalForPromoter + promoterFeeFlatPerUpgradeTotal
-    )
-    const salesTaxAmount = salesTaxFees ? (orderSubtotal * salesTaxFees.value) / 100 : 0;
+      totalTicketAndUpgrades+
+        // upgradeTotal +
+        promoterFeeFlatPerTicketTotal +
+        promoterFeeFlatPerOrderTotal +
+        promoterFeePercentPerTicketTotal +
+        Math.round(promoterFeePercentPerOrder) +
+        ticketGuestFeeTotalForPromoter +
+        promoterFeeFlatPerUpgradeTotal
+    );
+  
+
+
+    const discountValue = Math.round(orderSubtotal);
+    console.log(discountValue, "discountValue");
 
-    const promoterTotal = orderSubtotal + salesTaxAmount;
+    const salesTaxAmount = salesTaxFees
+      ? (orderSubtotal * salesTaxFees.value) / 100
+      : 0;
+
+    const promoterTotal = orderSubtotal + Math.round(salesTaxAmount);
 
     const selloutPercentFeesAmt = selloutFees.reduce((acc, fee) => {
       if (fee.type == FeeTypeEnum.Percent) {
-        return acc + getFeeAmount(fee, promoterTotal)
+        return acc + getFeeAmount(fee, promoterTotal);
       }
-      return acc
-    }, 0)
-
-    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)
-      );
+      return acc;
     }, 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 cur
-    }, 0)
+    //
+
+    // const discountPercentFeesAmt  = promotions.reduce((acc, promotion) => {
+    //   if (promotion.discountType == EventPromotionDiscountTypeEnum.Percent) {
+    //     return acc + getFeeAmount(promotion, promoterTotal);
+    //   }
+    //   return acc;
+    // }, 0);
+
+    // console.log(discountPercentFeesAmt)
+
+    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
+    );
+
+    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 cur;
+      },
+      0
+    );
+
+    // if (fee.type === FeeTypeEnum.Percent) {
+    //   return amt * (fee.value / 100);
+    // }
+    // const discountFeeFlatPerOrderAmt = promotions?.reduce(
+    //   (cur: number,promotion: IEventPromotion) => {
+    //     if (
+    //       promotion.discountType == EventPromotionDiscountTypeEnum.Percent &&
+    //       promotion.appliesTo === EventPromotionAppliesToEnum.PerOrder
+    //     ) {
+    //       // const value = cur + promotion.discountValue;
+    //       // return value;
+    //       return amt * (promotion.discountType / 100);
+
+
+    //     }
+    //     return cur;
+    //   },
+    //   0
+    // );
+
+    // console.log(discountFeeFlatPerOrderAmt)
+    
+
     const selloutSeatedFeeAmt = tickets.reduce((cur: number, ticket: any) => {
       return (
         cur +
         selloutFees.reduce((cur: number, fee: IFee) => {
-          if (fee.type == FeeTypeEnum.Flat && fee.appliedTo === FeeAppliedToEnum.Ticket &&
+          if (
+            fee.type == FeeTypeEnum.Flat &&
+            fee.appliedTo === FeeAppliedToEnum.Ticket &&
             fee?.filters?.includes(FeeFiltersEnum.Seated)
           ) {
             const value = cur + applyTicketFee(ticket, fee);
             return value;
           }
 
-          return cur
-
+          return cur;
         }, 0)
       );
     }, 0);
 
     const selloutFeesTotal = Math.round(
       selloutPercentFeesAmt +
-      selloutFeeFlatPerTicketAmt +
-      selloutFeeFlatPerOrderAmt +
-      selloutSeatedFeeAmt + ticketGuestFeeTotalForSellout + SelloutFeeFlatPerUpgradeTotal
-    )
-    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
-
+        selloutFeeFlatPerTicketAmt +
+        selloutFeeFlatPerOrderAmt +
+        selloutSeatedFeeAmt +
+        ticketGuestFeeTotalForSellout +
+        SelloutFeeFlatPerUpgradeTotal
+    );
+    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;
+  
     function applyTicketFee(
       ticket: ICreateOrderTicketParams,
       fee: IFee
@@ -477,6 +880,25 @@ class PaymentUtil {
 
       return 0;
     }
+    //
+    function applyTicketDiscount(
+      ticket: ICreateOrderTicketParams,
+      promotion: IEventPromotion
+    ): any {
+      if (
+        promotion.ticketTypeIds.includes(ticket?.ticketTypeId) ||
+        promotion.ticketTypeIds.length == 0
+      ) {
+        if (promotion?.discountType === EventPromotionDiscountTypeEnum.Flat) {
+          return promotion.discountValue;
+        }
+        if (promotion.discountType === EventPromotionDiscountTypeEnum.Percent) {
+          return (ticket.origionalPrice * promotion.discountValue )/100;
+        }
+      } else {
+        return 0;
+      }
+    }
 
     function applyUpgradeFee(
       upgrade: ICreateOrderUpgradeParams,
@@ -500,6 +922,17 @@ class PaymentUtil {
       return 0;
     }
 
+    // function getDiscount(promotion: IEventPromotion, amt = 0) {
+    //   if (promotion?.discountType === EventPromotionDiscountTypeEnum.Flat) {
+    //     return (amt -);
+    //   }
+    //   if (promotion?.discountType === EventPromotionDiscountTypeEnum.Percent) {
+    //     return amt * (promotion.discountValue/ 100);
+    //   }
+    // }
+
+    // console.log(getDiscount)
+
     // return Calculated fees amount based on type
     function getFeeAmount(fee, amt = 0) {
       if (fee.type === FeeTypeEnum.Flat) {
@@ -509,9 +942,47 @@ class PaymentUtil {
         return amt * (fee.value / 100);
       }
     }
-    let promoterFeeAmount = promoterFeeFlatPerTicketTotal + promoterFeeFlatPerOrderTotal + promoterFeePercentPerTicketTotal +
-      promoterFeePercentPerOrder + ticketGuestFeeTotalForPromoter + promoterFeeFlatPerUpgradeTotal;
-
+    let promoterFeeAmount =
+      promoterFeeFlatPerTicketTotal +
+      promoterFeeFlatPerOrderTotal +
+      promoterFeePercentPerTicketTotal +
+      promoterFeePercentPerOrder +
+      ticketGuestFeeTotalForPromoter +
+      promoterFeeFlatPerUpgradeTotal;
+
+    // let total = {
+    //   salesTax: Math.round(salesTaxAmount || 0),
+    //   total: isDiscount && discount > 0
+    //     ? Math.round(orderSubtotal - discount) +
+    //       Math.round(
+    //         promoterFeeAmount +
+    //           (isDiscount && discount > 0 ? stripeDiscountFeeAmt : stripeFeeAmt) +
+    //           selloutFeesTotal +
+    //           salesTaxAmount || 0
+    //       )
+    //     : Math.round(preStripeTotal) + Math.round(isDiscount ? stripeDiscountFeeAmt : stripeFeeAmt) || 0,
+    //   promoterFees: Math.round(promoterFeeAmount || 0),
+    //   stripeFees: Math.round(isDiscount ? stripeDiscountFeeAmt : stripeFeeAmt || 0),
+    //   selloutFees: Math.round(selloutFeesTotal || 0),
+    //   orderSubtotal: Math.round(orderSubtotal || 0),
+    //   subTotal: isDiscount && discount > 0
+    //     ? Math.round(orderSubtotal - discount || 0)
+    //     : Math.round(totalTicketAndUpgrades || 0),
+    //   // subTotal: Math.round(totalTicketAndUpgrades || 0),
+
+    //   totalFees: Math.round(
+    //     promoterFeeAmount +
+    //       stripeDiscountFeeAmt +
+    //       selloutFeesTotal +
+    //       salesTaxAmount || 0
+    //   ),
+    //   totalWithoutTaxFees: Math.round(
+    //     promoterFeeAmount + stripeFeeAmt + selloutFeesTotal || 0
+    //   ),
+    //   guestFeeForPromoter: Math.round(ticketGuestFeeTotalForPromoter || 0),
+    //   guestFeeForSellout: Math.round(ticketGuestFeeTotalForSellout || 0),
+    //   discountAmount: Math.round(discount) || 0,
+    // };
 
     let total = {
       salesTax: Math.round(salesTaxAmount || 0),
@@ -525,17 +996,20 @@ class PaymentUtil {
       totalWithoutTaxFees: Math.round((promoterFeeAmount + stripeFeeAmt + selloutFeesTotal) || 0),
       guestFeeForPromoter: Math.round(ticketGuestFeeTotalForPromoter || 0),
       guestFeeForSellout: Math.round(ticketGuestFeeTotalForSellout || 0),
+      discountAmount: Math.round(discount || discountOrder) || 0,
+
     }
-    return total
+    // console.log(total, "total");
+    return total;
   }
 
-
   calculatePaymentSubtotal(params: IPaymentCalculatorParams): number {
     let {
       tickets = [],
       upgrades = [],
       paymentMethodType,
       // fees
+      // promotions
     } = params;
 
     if (paymentMethodType === PaymentMethodTypeEnum.None) return 0;
@@ -545,10 +1019,38 @@ class PaymentUtil {
       (cur, upgrade) => cur + upgrade.price,
       0
     ); // +  (upgrade.price * tax/100)
-    return ticketTotal + upgradeTotal;
+    // const discountFeeFlatPerOrderAmt = promotions?.reduce(
+    //   (cur: number,promotion: IEventPromotion) => {
+    //     if (
+    //       promotion.discountType == EventPromotionDiscountTypeEnum.Flat &&
+    //       promotion.appliesTo === EventPromotionAppliesToEnum.PerOrder
+    //     ) {
+    //       const value = cur + promotion.discountValue;
+    //       return value;
+    //     }
+    //     return cur;
+    //   },
+    //   0
+    // );
+
+    // const totalTicketUpgrade = ticketTotal + upgradeTotal 
+
+    
+
+
+
+    
+
+
+
+
+
+    return ticketTotal + upgradeTotal 
   }
 
 
+ 
+
   calculatePaymentSubtotalValue(params: any): number {
     let {
       tickets = [],
@@ -564,11 +1066,9 @@ class PaymentUtil {
       (cur, upgrade) => cur + upgrade.price,
       0
     ); // +  (upgrade.price * tax/100)
-    return ticketTotal + upgradeTotal;
+    return ticketTotal + upgradeTotal ;
   }
 
-
-
   calculateFee(params: IPaymentCalculatorParams): number {
     let { fees } = params;
     const salesTax = fees.filter((f) => f.name == "Sales tax");
@@ -583,7 +1083,7 @@ class PaymentUtil {
     const total = this.calculatePaymentTotal(params);
     // let subtotal = this.calculatePaymentSubtotal(params);
     // return Math.round(total - subtotal);
-    return total
+    return total;
   }
   calculateOrganizationFee(params: IPaymentCalculatorParams): number {
     let { tickets = [], upgrades = [], fees = [], paymentMethodType } = params;
@@ -640,26 +1140,25 @@ class PaymentUtil {
   // }
 
   calculateGuestFee(tickets: any, event: any): number {
-
     let guestTicketFees = event?.fees.filter(
       (fee: IFee) =>
         fee.filters && fee.filters[0] === FeeFiltersEnum.GuestTicket
     );
 
     let stripeFees = event?.fees.filter(
-      (fee: IFee) => fee.appliedBy === FeeAppliedByEnum.Stripe && fee.type === FeeTypeEnum.Percent
+      (fee: IFee) =>
+        fee.appliedBy === FeeAppliedByEnum.Stripe &&
+        fee.type === FeeTypeEnum.Percent
     );
 
-
     let guestFeesValue = guestTicketFees && guestTicketFees[0]?.value;
     let stripeFeesValue = stripeFees && stripeFees[0]?.value;
     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();