@sellout/models 0.0.188 → 0.0.192

package/src/proto/email.proto

@@ -108,6 +108,8 @@ message QueueOrderReceiptEmailRequest {
   repeated dayIdsTimeObj dayIdsTimeCalendar = 34;
   string ticketDeliveryType = 35;
   string physicalDeliveryInstructions = 36;
+  string promoterFee = 37;
+  string processingFee = 38;
 }
 
 message QueueOrderQRCodeEmailRequest {
@@ -147,6 +149,8 @@ message QueueOrderQRCodeEmailRequest {
   repeated dayIdsTimeObj dayIdsTimeCalendar = 33;
   string ticketDeliveryType = 34;
   string physicalDeliveryInstructions = 35;
+  string promoterFee = 36;
+  string processingFee = 37;
 }
 
 message QueueSeasonOrderReceiptEmailRequest {
@@ -185,6 +189,8 @@ message QueueSeasonOrderReceiptEmailRequest {
   repeated dayIdsTimeObj  dayIdsTime = 32;
   repeated dayIdsTimeObj dayIdsTimeCalendar = 33;
   repeated Event events = 34;
+  string promoterFee = 35;
+  string processingFee = 36;
 }
 
 message QueueOrderRefundEmailRequest {
@@ -218,6 +224,10 @@ message QueueOrderRefundEmailRequest {
   string refundReason = 27;
   repeated dayIdsTimeObj  dayIdsTime = 28;
   repeated dayIdsTimeObj dayIdsTimeCalendar = 29;
+  string timezone = 30;
+  string promoterFee = 31;
+  string processingFee = 32;
+  string tax = 33;
   // string ticketDeliveryType = 30;
   // string physicalDeliveryInstructions = 31;
 }
@@ -253,6 +263,7 @@ message QueueOrderCanceledEmailRequest {
   string refundReason = 27;
   repeated dayIdsTimeObj  dayIdsTime = 28;
   repeated dayIdsTimeObj dayIdsTimeCalendar = 29;
+  string timezone = 30;
 }
 
 

package/src/proto/event.proto

@@ -402,6 +402,7 @@ message CancelTicketRequest {
   repeated string ticketTypeId = 3;
   repeated string upgradesTypeId = 4;
   string promotionCode = 5;
+  repeated string upgradeId = 6;
 }
 
 message CancelTicketResponse {

package/src/proto/order.proto

@@ -40,6 +40,7 @@ message Order {
   bool printed = 29;
   string parentSeasonOrderId = 30;
   repeated orderFees fees = 31;
+  ProcessingFees promoterFee = 32;
 }
 message ProcessingFees {
   Refund refund = 0;
@@ -304,6 +305,8 @@ message RefundOrderRequest {
   string refundReason = 7;
   bool processingFee = 8;
   string eventType = 9;
+  bool promoterFee = 10;
+
 }
 
 message RefundOrderResponse {
@@ -404,6 +407,7 @@ message SendOrderRefundEmailRequest {
   repeated string ticketIds = 2;
   repeated string upgradeIds = 3;
   bool processingFee = 4;
+  bool promoterFee = 5;
 }
 
 message SendOrderRefundEmailResponse {

package/src/schemas/Order.ts

@@ -414,6 +414,9 @@ export default {
   processingFee: {
     refund: Refund
   },
+  promoterFee: {
+    refund: Refund
+  },
   refundReason: {
     type: String,
     required: false,

package/src/utils/AnalyticsUtil.ts

@@ -33,10 +33,10 @@ const makeCoordinates = (
 ) => {
   const { startDate, intervalLength, intervalNum, interval } = intervalInfo;
 
-  const coordinates =  makeArray(intervalNum).map((_, index) => {
+  const coordinates = makeArray(intervalNum).map((_, index) => {
     // set x to beginning second of interval
     let x: number;
-    switch(interval) {
+    switch (interval) {
       case AnalyticsIntervalEnum.Hour:
         x = Time.getStartOfHour(index * intervalLength + startDate);
         break;
@@ -57,11 +57,13 @@ const makeCoordinates = (
         break;
     }
 
-    const y = sumFn(orders
+    const filteredOrder = orders
       .filter((order) => {
         const createdAt = order.createdAt as number;
         return x <= createdAt && createdAt < x + intervalLength;
-      }));
+      })
+
+    const y = sumFn(filteredOrder);
 
     return {
       x,
@@ -155,13 +157,13 @@ const getIntervalFromDuration = (duration: number): AnalyticsIntervalEnum => {
   const maxWeek = maxDuration(AnalyticsIntervalEnum.Week);
   const maxMonth = maxDuration(AnalyticsIntervalEnum.Month);
 
-  if(duration <= maxHour) {
+  if (duration <= maxHour) {
     return AnalyticsIntervalEnum.Hour;
-  } else if(duration <= maxDay) {
+  } else if (duration <= maxDay) {
     return AnalyticsIntervalEnum.Day;
-  } else if(duration <= maxWeek) {
+  } else if (duration <= maxWeek) {
     return AnalyticsIntervalEnum.Week
-  } else if(duration <= maxMonth) {
+  } else if (duration <= maxMonth) {
     return AnalyticsIntervalEnum.Month;
   } else {
     return AnalyticsIntervalEnum.Year;
@@ -187,18 +189,18 @@ const getIntervalInfo = (
   startDate = startDate || orders[orders.length - 1]?.createdAt as number || Time.getStartOfCurrentDay();
   endDate = endDate || orders[0]?.createdAt as number || Time.getEndOfCurrentDay();
 
-  if(startDate === endDate) {
+  if (startDate === endDate) {
     endDate = Time.getEndOfCurrentDay();
   }
 
   const duration = endDate - startDate; // duration in seconds
   const intervalFromDuration = getIntervalFromDuration(duration);
   const intervalOptions = intervalsMap[intervalFromDuration];
-  if(!interval) {
+  if (!interval) {
     interval = getIntervalFromDuration(duration);
   }
 
-  if(!intervalOptions.includes(interval)) {
+  if (!intervalOptions.includes(interval)) {
     interval = intervalOptions[0];
   }
 
@@ -271,7 +273,7 @@ export default {
           label: type,
           interval: interval,
           intervalOptions: [],
-          coordinates: [{ x: 0, y: 0}],
+          coordinates: [{ x: 0, y: 0 }],
           segments: [],
           type: AnalyticsValueTypeEnum.Quantity,
         } as IAnalytics;
@@ -283,20 +285,31 @@ export default {
     orders: IOrder[],
     intervalInfo: IntervalInfo,
   ): IAnalytics {
-    const coordinatesSumFn = (orders: IOrder[]) =>
-      orders
-        // .filter(order => order.type === OrderTypeEnum.Paid)
-        .reduce((cur, order) => cur + sum(order.tickets.map(ticket => ticket.price)) + sum(order.upgrades.map(upgrade => upgrade.price)), 0);
-    
+
+    const coordinatesSumFn = (orders: IOrder[]) => orders.reduce((cur, order) => {
+      let total = 0
+      if (order.type == OrderTypeEnum.RSVP) {
+        total = sum(order.tickets.map(ticket => Number(ticket?.values) || 0)) + sum(order.upgrades.map(upgrade => Number(upgrade?.price) || 0))
+      } else {
+        total = sum(order.tickets.map(ticket => ticket.price)) + sum(order.upgrades.map(upgrade => upgrade.price))
+      }
+      return cur + total
+    }, 0);
+
+    // const coordinatesSumFn = (orders: IOrder[]) =>
+    //   orders
+    //     // .filter(order => order.type === OrderTypeEnum.Paid)
+    //     .reduce((cur, order) => cur + sum(order.tickets.map(ticket => ticket.price)) + sum(order.upgrades.map(upgrade => upgrade.price)), 0);
+
     const coordinates = makeCoordinates(orders, intervalInfo, coordinatesSumFn);
     const { interval, intervalOptions } = intervalInfo;
 
 
     let segments: IAnalytics[] = [];
     const coordinatesSumFn2 = (orders: IOrder[]) =>
-    orders
-      // .filter(order => order.type === OrderTypeEnum.Paid)
-      .reduce((cur, order) => cur + order.tickets.length, 0);
+      orders
+        // .filter(order => order.type === OrderTypeEnum.Paid)
+        .reduce((cur, order) => cur + order.tickets.length, 0);
     const segmentCoordinates = makeCoordinates(orders, intervalInfo, coordinatesSumFn2);
     let segment: IAnalytics = {
       label: 'Tickets Sold',
@@ -308,8 +321,8 @@ export default {
     };
     segments.push(segment);
     const coordinatesSumFn3 = (orders: IOrder[]) => orders.length//sum(orders.map(order => { return order.state != OrderStateEnum.Refunded ? 1 : 0} ))
-      // .reduce((cur,order) => cur + sum(order.tickets.map(ticket => { return ticket.refund.refunded == false ? 1 : 0})),0)
-    
+    // .reduce((cur,order) => cur + sum(order.tickets.map(ticket => { return ticket.refund.refunded == false ? 1 : 0})),0)
+
     // const coordinatesSumFn3 = (orders: IOrder[]) => orders.length;
     const segmentCoordinates2 = makeCoordinates(orders, intervalInfo, coordinatesSumFn3);
     segment = {
@@ -340,10 +353,23 @@ export default {
     intervalInfo: IntervalInfo,
     showSegments: boolean,
   ): IAnalytics {
-    const coordinatesSumFn = (orders: IOrder[]) =>
-      orders
-        // .filter(order => order.type === OrderTypeEnum.Paid)
-        .reduce((cur, order) => cur + sum(order.tickets.map(ticket => ticket.price )) + sum(order.upgrades.map(upgrade => upgrade.price)), 0);
+
+    const coordinatesSumFn = (orders: IOrder[]) => orders.reduce((cur, order) => {
+      let total = 0
+      if (order.type == OrderTypeEnum.RSVP) {
+        total = sum(order.tickets.map(ticket => Number(ticket?.values) || 0)) + sum(order.upgrades.map(upgrade => Number(upgrade?.price) || 0))
+      } else {
+        total = sum(order.tickets.map(ticket => ticket.price)) + sum(order.upgrades.map(upgrade => upgrade.price))
+      }
+      return cur + total
+    }, 0);
+
+    // const coordinatesSumFn = (orders: IOrder[]) =>
+    //   orders
+    //     // .filter(order => order.type === OrderTypeEnum.Paid)
+    //     .reduce((cur, order) => cur + sum(order.tickets.map(ticket => ticket.price)) + sum(order.upgrades.map(upgrade => upgrade.price)), 0);
+
+
     let segmentTypes;
     let segmentCoordinatesHOSumFn;
     // if (showSegments) {
@@ -385,10 +411,22 @@ export default {
     intervalInfo: IntervalInfo,
     showSegments: boolean,
   ): IAnalytics {
-    const coordinatesSumFn = (orders: IOrder[]) =>
-      orders
-        // .filter(order => order.type === OrderTypeEnum.Paid)
-        .reduce((cur, order) => cur + sum(order.tickets.map(ticket => ticket.price)), 0);
+    const coordinatesSumFn = (orders: IOrder[]) => orders.reduce((cur, order) => {
+      let total = 0
+      if (order.type == OrderTypeEnum.RSVP) {
+        total = sum(order.tickets.map(ticket => Number(ticket?.values) || 0)) || 0
+        // total = sum(order.tickets.map(ticket => Number(ticket?.values)|| 0)) + sum(order.upgrades.map(upgrade => Number(upgrade?.price) || 0))
+      } else {
+        total = sum(order.tickets.map(ticket => ticket.price))
+      }
+      return cur + total
+    }, 0);
+
+
+    // const coordinatesSumFn = (orders: IOrder[]) =>
+    //   orders
+    //     // .filter(order => order.type === OrderTypeEnum.Paid)
+    //     .reduce((cur, order) => cur + sum(order.tickets.map(ticket => ticket.price)), 0);
 
     let segmentTypes;
     let segmentCoordinatesHOSumFn;
@@ -404,13 +442,29 @@ export default {
           }, {})
       );
 
-      segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
-        orders
-          // .filter(order => order.type === OrderTypeEnum.Paid)
-          .reduce((cur, order) => cur + sum(
-            order.tickets
-              .filter((ticket) => ticket.name === segmentType)
-              .map((ticket) => ticket.price)), 0);
+      segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) => {
+        //   const ordersData = orders
+        //     // .filter(order => order.type === OrderTypeEnum.Paid)
+        //     .reduce((cur, order) => cur + sum(
+        //       order.tickets
+        //         .filter((ticket) => ticket.name === segmentType)
+        //         .map((ticket) => ticket.price)), 0);
+
+        //   return ordersData
+        // }
+        
+        const ordersData = orders.reduce((cur, order) => {
+          let total;
+          if (order.type == OrderTypeEnum.RSVP) {
+            total = sum(order.tickets.filter((ticket) => ticket.name === segmentType).map(ticket => Number(ticket?.values) || 0))
+          } else {
+            total = sum(order.tickets.filter((ticket) => ticket.name === segmentType).map(ticket => Number(ticket?.price) || 0))
+          }
+          return cur + total
+        }, 0);
+        return ordersData
+      }
+
     }
 
     return makeAnalytics(
@@ -581,12 +635,12 @@ export default {
             return cur;
           }, {})
       );
-  
+
       segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
         orders
           // .filter(order => order.type === OrderTypeEnum.Paid)
           .reduce((cur, order) =>
-            cur + order.upgrades.filter((upgrade) => upgrade.name === segmentType ).length, 0);
+            cur + order.upgrades.filter((upgrade) => upgrade.name === segmentType).length, 0);
     }
 
     return makeAnalytics(
@@ -606,11 +660,25 @@ export default {
     intervalInfo: IntervalInfo,
     showSegments: boolean,
   ): IAnalytics {
-    const coordinatesSumFn = (orders: IOrder[]) =>
-      orders
-        .reduce((cur, order) =>
-          cur + order.upgrades.filter(upgrade => upgrade.price === 0).length,
-          0);
+
+    const coordinatesSumFn = (orders: IOrder[]) => orders.reduce((cur, order) => {
+      let total = 0
+      if (order.type == OrderTypeEnum.RSVP) {
+        total = sum(order.upgrades.map(upgrade => Number(upgrade?.price) || 0))
+        // total = sum(order.tickets.map(ticket => Number(ticket?.values)|| 0)) + sum(order.upgrades.map(upgrade => Number(upgrade?.price) || 0))
+      } else {
+        total = sum(order.upgrades.map(upgrade => upgrade.price))
+        // total = sum(order.tickets.map(ticket => ticket.price)) + sum(order.upgrades.map(upgrade => upgrade.price))
+      }
+      return cur + total
+    }, 0);
+
+
+    // const coordinatesSumFn = (orders: IOrder[]) =>
+    //   orders
+    //     .reduce((cur, order) =>
+    //       cur + order.upgrades.filter(upgrade => upgrade.price === 0).length,
+    //       0);
 
     let segmentTypes;
     let segmentCoordinatesHOSumFn;
@@ -625,7 +693,7 @@ export default {
             return cur;
           }, {})
       );
-  
+
       segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
         orders
           .reduce((cur, order) =>
@@ -710,16 +778,30 @@ export default {
       segmentTypes = [EventAnalyticsEnum.SoldOutPercentage, EventAnalyticsEnum.TotalSales];
 
       segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) => {
-        switch(segmentType) {
+        switch (segmentType) {
           case EventAnalyticsEnum.SoldOutPercentage:
             return 0;
           case EventAnalyticsEnum.TotalSales:
-            return orders.reduce((cur: number, next: IOrder) => cur + next?.payments?.[0]?.transferAmount ?? 0, 0);
+            return calculateTotalSale(orders)
+
+          // orders.reduce((cur: number, next: IOrder) => cur + next?.payments?.[0]?.transferAmount ?? 0, 0)
         }
       }
     }
 
-    return makeAnalytics(
+
+    const calculateTotalSale = (orders) => orders
+      .reduce((cur, order) => {
+        let total = 0
+        if (order.type == OrderTypeEnum.RSVP) {
+          total = sum(order.tickets.map(ticket => Number(ticket?.values) || 0)) + sum(order.upgrades.map(upgrade => Number(upgrade?.price) || 0))
+        } else {
+          total = sum(order.tickets.map(ticket => ticket.price)) + sum(order.upgrades.map(upgrade => upgrade.price))
+        }
+        return cur + total
+      }, 0);
+
+    const data = makeAnalytics(
       type,
       orders,
       intervalInfo,
@@ -728,6 +810,7 @@ export default {
       segmentTypes,
       segmentCoordinatesHOSumFn
     );
+    return data
   },
   userAnalytics(
     type: AnalyticsTypeEnum,
@@ -744,8 +827,8 @@ export default {
     let segmentCoordinatesHOSumFn;
     if (showSegments) {
       segmentTypes = [
-        UserAnalyticsEnum.EventsAttendedCount, 
-        UserAnalyticsEnum.TicketsPurchasedCount, 
+        UserAnalyticsEnum.EventsAttendedCount,
+        UserAnalyticsEnum.TicketsPurchasedCount,
         UserAnalyticsEnum.LifeTimeValue
       ];
 
@@ -757,7 +840,7 @@ export default {
             return orders.reduce((cur: number, next: IOrder) => cur + next.tickets.length ?? 0, 0);
           case UserAnalyticsEnum.LifeTimeValue:
             return orders.reduce((cur: number, next: IOrder) => cur + next.payments?.[0]?.transferAmount ?? 0, 0);
-            
+
         }
       }
     }
@@ -880,19 +963,19 @@ export default {
   },
 
   getDateFormat(time: any, interval: AnalyticsIntervalEnum, timezone: string = 'America/Denver') {
-    switch(interval) {
+    switch (interval) {
       case AnalyticsIntervalEnum.Hour:
-        return Time.format(time, 'h:mma',timezone);
+        return Time.format(time, 'h:mma', timezone);
       case AnalyticsIntervalEnum.Day:
-        return Time.format(time, 'MMM DD',timezone);
+        return Time.format(time, 'MMM DD', timezone);
       case AnalyticsIntervalEnum.Week:
-        return `${Time.format(time, 'MMM DD',timezone)} - ${Time.format(time + (Time.DAY * 7), 'MMM DD',timezone)}`;
+        return `${Time.format(time, 'MMM DD', timezone)} - ${Time.format(time + (Time.DAY * 7), 'MMM DD', timezone)}`;
       case AnalyticsIntervalEnum.Month:
-        return Time.format(time, 'MMM YYYY',timezone);
+        return Time.format(time, 'MMM YYYY', timezone);
       case AnalyticsIntervalEnum.Year:
-        return Time.format(time, 'YYYY',timezone);
+        return Time.format(time, 'YYYY', timezone);
       default:
-        return Time.format(time, 'MMM DD',timezone);
+        return Time.format(time, 'MMM DD', timezone);
     }
   },
 

package/src/utils/PaymentUtil.ts

@@ -252,11 +252,7 @@ class PaymentUtil {
     const totalTicketAndUpgrades = ticketTotal + upgradeTotal
 
     const promoterFeeFlatPerOrderTotal = promoterOrderFees.reduce((acc, fee: any) => {
-      if (fee.type == FeeTypeEnum.Flat) {
-
-        return acc + getFeeAmount(fee)
-      }
-      return acc
+        return fee.type == FeeTypeEnum.Flat ? (acc + getFeeAmount(fee)) : acc
     }, 0)
 
     const promoterFeeFlatPerTicketTotal = tickets.reduce((cur, ticket) => {
@@ -391,10 +387,10 @@ class PaymentUtil {
       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
@@ -452,20 +448,6 @@ class PaymentUtil {
       return 0;
     }
 
-    // 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) {
@@ -475,79 +457,22 @@ class PaymentUtil {
         return amt * (fee.value / 100);
       }
     }
-
-    // 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
+    
+    
+      let total = {
+      salesTax: Math.round(salesTaxAmount || 0),
+      total: Math.round((preStripeTotal + stripeFeeAmt) || 0),
+      promoterFees: Math.round((promoterFeeAmount) || 0),
+      stripeFees: Math.round(stripeFeeAmt || 0),
+      selloutFees: Math.round(selloutFeesTotal || 0),
+      orderSubtotal: Math.round(orderSubtotal || 0),
+      subTotal: Math.round(totalTicketAndUpgrades || 0),
+      totalFees: Math.round((promoterFeeAmount + stripeFeeAmt + selloutFeesTotal + salesTaxAmount) || 0),
+      totalWithoutTaxFees: Math.round((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 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 promoterFeeFlatPerOrder = promoterOrderFees.reduce((cur, fee) => {
-    //   return applyOrderFee(cur, fee);
-    // }, ticketTotal + upgradeTotal);
-
-    // console.log(promoterOrderTotal)
-
-
-    // Applying sellout fees
-
-
-    //  applying sales tax fees
-
-
-    // return Math.round(orderTotal);
   }
 
 
@@ -600,10 +525,11 @@ class PaymentUtil {
     return Math.round(total - subtotal);
   }
 
-  calculateFeeWithoutTax(params: IPaymentCalculatorParams): number {
-    const total = this.calculatePaymentTotal(params).total;
-    let subtotal = this.calculatePaymentSubtotal(params);
-    return Math.round(total - subtotal);
+  calculateFeeWithoutTax(params: IPaymentCalculatorParams): any {
+    const total = this.calculatePaymentTotal(params);
+    // let subtotal = this.calculatePaymentSubtotal(params);
+    // return Math.round(total - subtotal);
+    return total
   }
   calculateOrganizationFee(params: IPaymentCalculatorParams): number {
     let { tickets = [], upgrades = [], fees = [], paymentMethodType } = params;