@sellout/models 0.0.62 → 0.0.64

package/src/utils/PaymentUtil.ts

@@ -1,6 +1,7 @@
 import { ICreateOrderTicketParams, ICreateOrderUpgradeParams } from '../interfaces/ICreateOrderParams';
 import IFee, { FeeAppliedToEnum, FeeFiltersEnum, FeeTypeEnum } from '../interfaces/IFee';
 import { PaymentMethodTypeEnum } from '../enums/PaymentMethodTypeEnum';
+// import { OrderTypeEnum } from 'src/interfaces/IOrderType';
 
 interface IPaymentCalculatorParams {
   tickets: ICreateOrderTicketParams[];
@@ -9,50 +10,171 @@ interface IPaymentCalculatorParams {
   paymentMethodType: PaymentMethodTypeEnum
 }
 
+// interface IOrderItems {
+//   tickets: ICreateOrderTicketParams[];
+//   upgrades: ICreateOrderUpgradeParams[];
+// }
+
 export default {
+  // DOES NOT WORK! Work in Progress :)
+  // calculateOrderItemPrices(params: IPaymentCalculatorParams): IOrderItems {
+
+  //   let {
+  //     tickets = [], 
+  //     upgrades = [],
+  //     fees = [],
+  //     paymentMethodType,
+  //   } = params;
+
+    
+  //   // 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;
+  //     }
+
+  //     // Ignore card entry fees for non card entry payemnts
+  //     if (fee.filters && fee.filters.includes(FeeFiltersEnum.CardEntry) && paymentMethodType !== PaymentMethodTypeEnum.CardEntry) {
+  //       return false;
+  //     }
+
+  //     return true;
+  //   });
+
+  //   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)
+  //   .sort(({ type }) => {
+  //     if (type === FeeTypeEnum.Percent) return -1;
+  //     else return 1;
+  //   })
+  //   .map(fee => {
+  //     if(fee.type === FeeTypeEnum.Flat) {
+  //       return {
+  //         ...fee,
+  //         value: fee.value / tickets.length,
+  //       }
+  //     }
+  //     else return fee;
+  //   });
+
+  //   const reverseApplyFee = (price: number, ticket: ICreateOrderTicketParams, fee: IFee): number => {
+  //     // Ignore seated fees
+  //     if (fee.filters && fee.filters.includes(FeeFiltersEnum.Seated) && !ticket.seat) {
+  //       return price;
+  //     }
+
+  //     const minFee = fee.minAppliedToPrice || 0;
+  //     const maxFee = fee.maxAppliedToPrice || Infinity;
+
+  //     if (minFee <= price && price <= maxFee) {
+        // console.log(fee);
+  //       if (fee.type === FeeTypeEnum.Flat) {
+  //         return price - fee.value;
+  //       } if (fee.type === FeeTypeEnum.Percent) {
+  //         return price * (1 - fee.value / 100);
+  //       }
+  //     }
+
+
+  //     // if(fee.type === FeeTypeEnum.Percent) {
+  //     //   return price * (1 - fee.value / 100);
+  //     // }
+
+  //     // if(fee.type === FeeTypeEnum.Flat) {
+  //     //   return price - fee.value;
+  //     // }
+
+  //     return price;
+  //   }
+
+  //   function calculateTicketPrice(ticket: ICreateOrderTicketParams): number {
+  //     if(!ticket.rollFees) return ticket.price;
+
+  //     const allFees = [...orderFees, ...ticketFees];
+
+  //     return allFees.reduce((cur, fee) => {
+  //       const next = reverseApplyFee(cur, ticket, fee);
+  //       return next;
+  //     }, ticket.price);
+
+  //   }
+
+  //   tickets = tickets.map((ticket: ICreateOrderTicketParams): ICreateOrderTicketParams => {
+  //     const price = Math.floor(calculateTicketPrice(ticket));
+      // console.log(`Ticket Price: `, price);
+  //     return {
+  //       ...ticket,
+  //       price,
+  //     }
+  //   });
+
+    
+
+  //   // upgrades = upgrades.map((upgrade: ICreateOrderUpgradeParams): ICreateOrderUpgradeParams => {
+  //   //   return {
+  //   //     ...upgrade,
+  //   //     price: calculateUpgradePrice(upgrade),
+  //   //   }
+  //   // });
+
+  //   return {
+  //     tickets,
+  //     upgrades,
+  //   };
+  // },
   calculateTotal(params: IPaymentCalculatorParams): number {
 
-    const {
-      tickets = [], 
+    let {
+      tickets = [],
       upgrades = [],
       fees = [],
       paymentMethodType,
     } = params;
 
-    console.log(fees);
-
     // No items, total is always 0
-    if(!tickets.length && !upgrades.length) return 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 ticketFees = fees.filter(f => f.appliedTo === FeeAppliedToEnum.Ticket);
+      // Ignore card entry fees for non card entry payemnts
+      if (fee.filters && fee.filters.includes(FeeFiltersEnum.CardEntry) && paymentMethodType !== PaymentMethodTypeEnum.CardEntry) {
+        return false;
+      }
+
+      return true;
+    });
+
+    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).sort(({ type }) => {
       if (type === 'Flat') return -1;
-      return 1;
+      else return 1;
     });
+    
 
     function applyTicketFee(ticket: ICreateOrderTicketParams, fee: IFee): number {
-      // // Ignore rolled fees
-      // if (ticket.rollFees) {
-      //   return 0;
-      // }
-
-      // Ignore seated fees
+      // Ignore seated fees if not seated
       if (fee.filters && fee.filters.includes(FeeFiltersEnum.Seated) && !ticket.seat) {
         return 0;
       }
-
-      // Ignore card reader fees for non card reader payemnts
-      if (fee.filters && fee.filters.includes(FeeFiltersEnum.CardReader) && paymentMethodType !== PaymentMethodTypeEnum.CardReader) {
-        return 0;
-      }
-
-      // Ignore card entry fees for non card entry payemnts
-      if (fee.filters && fee.filters.includes(FeeFiltersEnum.CardEntry) && paymentMethodType !== PaymentMethodTypeEnum.CardEntry) {
-        return 0;
-      }
-
+      
       const minFee = fee.minAppliedToPrice || 0;
       const maxFee = fee.maxAppliedToPrice || Infinity;
 
@@ -70,19 +192,14 @@ export default {
     }
 
     function applyUpgradeFee(upgrade: ICreateOrderUpgradeParams, fee: IFee): number {
-      // // Ignore rolled fees
-      // if (upgrade.rollFees) {
-      //   return 0;
-      // }
-      
       const minFee = fee.minAppliedToPrice || 0;
       const maxFee = fee.maxAppliedToPrice || Infinity;
 
       if (minFee <= upgrade.price && upgrade.price <= maxFee) {
         if (fee.type === FeeTypeEnum.Flat) {
-          return fee.value;
+          return upgrade.price + fee.value;
         } if (fee.type === FeeTypeEnum.Percent) {
-          return (upgrade.price * fee.value / 100);
+          return (upgrade.price / (1 - fee.value / 100));
         }
       } else {
         return 0;
@@ -102,7 +219,11 @@ export default {
     const ticketTotal = tickets.reduce((cur, ticket) => cur + ticket.price, 0);
 
     const ticketFeeTotal = tickets.reduce((cur, ticket) => {
-      return cur + ticketFees.reduce((cur, fee) => cur + applyTicketFee(ticket, fee), 0);
+      return cur + ticketFees.reduce((cur, fee) => {
+        const value = cur + applyTicketFee(ticket, fee);
+        // console.log(`${fee.name}: ${value}`);
+        return value;
+      }, 0);
     }, 0);
 
     const upgradeTotal = upgrades.reduce((cur, upgrade) => cur + upgrade.price, 0);
@@ -111,12 +232,16 @@ export default {
       return cur + upgradeFees.reduce((cur, fee) => cur + applyUpgradeFee(upgrade, fee), 0);
     }, 0);
 
-    const orderSubtotal = ticketTotal + ticketFeeTotal + upgradeTotal + upgradeFeeTotal;
+    const orderSubtotal = Math.round(ticketTotal + ticketFeeTotal + upgradeTotal + upgradeFeeTotal);
+
+    // console.log(`Order SubTotal:`, orderSubtotal);
 
     const orderTotal = orderFees.reduce((cur, fee) => {
       return applyOrderFee(cur, fee);
     }, orderSubtotal);
 
-    return Math.round(orderTotal);
+    // console.log(`Order Total`, orderTotal);
+
+    return orderTotal;
   }
 }

package/src/enums/OrderDeliveryMethodEnum.ts

@@ -1,5 +0,0 @@
-export enum OrderDeliveryMethodEnum {
-  Email = 'Email',
-  TextMessage = 'Text Message',
-  Printed = 'Printed',
-};