@sellout/models 0.0.182 → 0.0.184

package/src/schemas/Event.ts

@@ -362,6 +362,21 @@ const TicketTier = {
   },
 };
 
+const Subscription = {
+  _id: {
+    type: String,
+    default: shortid.generate,
+  },
+  email: {
+    type: String,
+    required: true,
+  },
+  frequency: {
+    type: String,
+    required: true,
+  }
+};
+
 const TicketType = {
   _id: {
     type: String,
@@ -542,5 +557,6 @@ export default {
   }, guestTicketPerMember: {
     type: String,
     required: false
-  }
+  },
+  subscription: [Subscription]
 };

package/src/schemas/Order.ts

@@ -131,10 +131,10 @@ const OrderTicket = {
     required: false
   },
   teiMemberInfo: TeiMemberInfoInput,
-   guestTicket:{
+  guestTicket: {
     type: Boolean,
     required: false
-   }
+  }
 };
 
 const OrderUpgrade = {
@@ -368,8 +368,11 @@ export default {
     type: Boolean,
     required: false,
     default: false
-  },parentSeasonOrderId:{
+  }, parentSeasonOrderId: {
     type: String,
     required: false,
+  }, cancelReason: {
+    type: String,
+    required: false
   }
 };

package/src/utils/EventUtil.ts

@@ -138,8 +138,9 @@ export default {
       return startsAt - TWO_WEEKS;
     } */
 
-    const TEN_HOURS = 10 * 60 * 60;
-    return doorsAt - TEN_HOURS;
+    // return doorsAt - 600;
+
+    return doorsAt - 28800
   },
   shouldSendOrderReceipt(event): boolean {
     const now = Time.now();

package/src/utils/FeeUtil.ts

@@ -26,6 +26,14 @@ export default {
       return true;
     });
   },
+  organizationFees(fees: any[] = []) {
+    return fees.filter((fee) => {
+      if (fee.appliedBy === "Organization") {
+        return false;
+      }
+      return true;
+    });
+  },
   promoterFees(fees: any[] = []) {
     return fees?.filter((fee) => {
       if (fee.appliedBy === "Sellout" || fee.appliedBy === "Stripe") {

package/src/utils/OrderUtil.ts

@@ -6,6 +6,7 @@ import ICreateOrderParams from '../interfaces/ICreateOrderParams';
 import IPayment from '../interfaces/IPayment';
 import PaymentUtil from './PaymentUtil';
 // import IFee from '../interfaces/IFee';
+import IFee, { FeeAppliedByEnum, FeeTypeEnum, FeeFiltersEnum } from "../interfaces/IFee";
 
 export default {
   isComp(order) {
@@ -112,7 +113,6 @@ export default {
           upgradeFees.reduce((cur, fee) => cur + applyUpgradeFee(upgrade, fee), 0)
         );
       }, 0);
-
       const orderSubtotal =
         ticketTotal + ticketFeeTotal + upgradeTotal + upgradeFeeTotal;
 
@@ -130,9 +130,170 @@ export default {
       return Math.round(orderTotal);
     }
   },
+
+  // orderTotalExport(order: IOrder, fees: any[]): number {
+  //   if (order?.payments && order?.payments.length > 0) {
+  //     return order.payments.reduce((cur: number, payment: IPayment): number => {
+  //       const paymentTickets = order.tickets.filter(ticket => ticket.paymentId === payment._id)
+  //       const paymentUpgrades = order.upgrades.filter(upgrade => upgrade.paymentId === payment._id)
+  //       const total = PaymentUtil.calculatePaymentTotalDublicate({
+  //         tickets: paymentTickets,
+  //         upgrades: paymentUpgrades,
+  //         fees: fees,
+  //         paymentMethodType: payment.paymentMethodType,
+  //       })
+  //       return cur + total
+  //     }, 0);
+  //   } else {
+  //     if (
+  //       (!order.tickets || !order.tickets.length) &&
+  //       (!order.upgrades || !order.upgrades.length)
+  //     )
+  //       return 0;
+
+  //     if (!order.tickets) order.tickets = [];
+  //     if (!order.upgrades) order.upgrades = [];
+
+  //     const ticketFees = fees.filter(f => f.appliedTo === "Ticket");
+  //     const upgradeFees = fees.filter(f => f.appliedTo === "Upgrade");
+  //     let orderFees = fees.filter(f => f.appliedTo === "Order");
+
+  //     function applyTicketFee(ticket, fee) {
+  //       if (fee.filters.includes("Seated") && !ticket.seat) return 0;
+  //       const noMax = fee.maxAppliedToPrice === 0;
+  //       if (
+  //         (fee.minAppliedToPrice <= ticket.price &&
+  //           ticket.price <= fee.maxAppliedToPrice) ||
+  //         noMax
+  //       ) {
+  //         if (fee.type === "Flat") {
+  //           return fee.value;
+  //         }
+  //         if (fee.type === "Percent") {
+  //           return (ticket.price * fee.value) / 100;
+  //         }
+  //       } else {
+  //         return 0;
+  //       }
+  //     }
+
+  //     function applyUpgradeFee(upgrade, fee) {
+  //       const noMax = fee.maxAppliedToPrice === 0;
+  //       if (
+  //         (fee.minAppliedToPrice <= upgrade.price &&
+  //           upgrade.price <= fee.minAppliedToPrice) ||
+  //         noMax
+  //       ) {
+  //         if (fee.type === "Flat") {
+  //           return fee.value;
+  //         }
+  //         if (fee.type === "Percent") {
+  //           return (upgrade.price * fee.value) / 100;
+  //         }
+  //       } else {
+  //         return 0;
+  //       }
+  //     }
+
+  //     function applyOrderFee(orderSubtotal, fee) {
+  //       if (fee.type === "Flat") {
+  //         return orderSubtotal + fee.value;
+  //       }
+  //       if (fee.type === "Percent") {
+  //         return orderSubtotal / (1 - fee.value / 100);
+  //       }
+  //     }
+
+  //     const ticketTotal = order.tickets.reduce(
+  //       (cur, ticket) => cur + ticket.price,
+  //       0
+  //     );
+
+  //     const ticketFeeTotal = order.tickets.reduce((cur, ticket) => {
+  //       return (
+  //         cur +
+  //         ticketFees.reduce((cur, fee) => cur + applyTicketFee(ticket, fee), 0)
+  //       );
+  //     }, 0);
+
+  //     const upgradeTotal = order.upgrades.reduce(
+  //       (cur, upgrade) => cur + upgrade.price,
+  //       0
+  //     );
+
+  //     const upgradeFeeTotal = order.upgrades.reduce((cur, upgrade) => {
+  //       return (
+  //         cur +
+  //         upgradeFees.reduce((cur, fee) => cur + applyUpgradeFee(upgrade, fee), 0)
+  //       );
+  //     }, 0);
+  //     const orderSubtotal =
+  //       ticketTotal + ticketFeeTotal + upgradeTotal + upgradeFeeTotal;
+
+  //     // Order matters here. Flat type fees must be
+  //     // applied before Percent type fees
+  //     orderFees = orderFees.sort(({ type }) => {
+  //       if (type === "Flat") return -1;
+  //       return 1;
+  //     });
+
+  //     const orderTotal = orderFees.reduce((cur, fee) => {
+  //       return applyOrderFee(cur, fee);
+  //     }, orderSubtotal);
+
+  //     return Math.round(orderTotal);
+  //   }
+  // },
+
+
+
+  guestFees(order: IOrder, fees: IFee[]): any {
+    let guestTicketFees = fees.find(
+      (fee: IFee) => {
+        const filter: any = fee?.filters
+        return filter.includes(FeeFiltersEnum.GuestTicket)
+      }
+    );
+
+    let guestFeesValue = guestTicketFees?.value || 0;
+    // const ticketTotal = order.tickets.reduce((cur, ticket) => cur + ticket.price - ticket.refund.refundedAmount, 0);
+    const ticketTotal = order.tickets.reduce((cur, ticket) => cur + ticket.price - ticket.refund.refundedAmount, 0);
+    let guestMembers = order.tickets.filter((a) => a.guestTicket).length;
+    // let guestMembers = order.tickets.filter((a) => a.guestTicket && a.refund.refunded == false).length;
+    let guestMembersRefunded = order.tickets.filter((a) => a.guestTicket && a.refund.refunded == true).length;
+    const stripeFees: any = fees.find(
+      (fee: IFee) => fee.appliedBy === FeeAppliedByEnum.Stripe && fee.type === FeeTypeEnum.Percent
+    );
+    let guestFees;
+    let guestFeesRefunded;
+
+    if (guestTicketFees?.type === "Flat") {
+      guestFees = (guestFeesValue as number) * guestMembers
+      guestFeesRefunded = (guestFeesValue as number) * guestMembersRefunded
+    } else if (guestTicketFees?.type === "Percent") {
+      guestFees = (ticketTotal * guestFeesValue) / 100
+      guestFeesRefunded = (ticketTotal * guestMembersRefunded) / 100
+    }
+    let stripeFeeAmount = 0;
+    if (stripeFees?.value) {
+      stripeFeeAmount = Math.round(guestFees * stripeFees?.value / 100)
+    }
+
+    return {
+      guestFees: guestFees || 0,
+      guestFeesRefunded: guestFeesRefunded || 0,
+      stripeFeeAmount: stripeFeeAmount || 0
+    }
+
+  },
   orderTotalWithRefund(order, fees) {
-    return this.orderTotal(order, fees) - (order.refundedAmount || 0);
+    const orderTotal = this.orderTotal(order, fees);
+    return orderTotal - (order.refundedAmount || 0);
   },
+  // orderExportTotalWithRefund(order, fees) {
+  //   const orderTotal = this.orderTotalExport(order, fees);
+  //   return orderTotal - (order.refundedAmount || 0);
+  // },
   orderTransferAmountWithRefund(order, fees) {
     const promoterFees = FeeUtil.promoterFees(fees);
     return this.orderTotalWithRefund(order, promoterFees);
@@ -195,6 +356,13 @@ export default {
     fees = FeeUtil.selloutFees(fees);
     return this.orderTotal(order, fees) - this.orderSubtotal(order);
   },
+
+  // selloutExortFees(order, fees) {
+  //   if (!order.tickets) order.tickets = [];
+  //   if (!order.upgrades) order.upgrades = [];
+  //   fees = FeeUtil.selloutFees(fees);
+  //   return this.orderTotalExport(order, fees) - this.orderSubtotal(order);
+  // },
   // This one is special because stripe fees
   // can be applied as a percentage
   stripeFees(order, fees) {
@@ -208,6 +376,18 @@ export default {
     let stripeFeeT = stripeFee < 0 ? 0 : stripeFee;
     return stripeFeeT;
   },
+
+  // stripeFeesExport(order, fees) {
+  //   if (!order.tickets) order.tickets = [];
+  //   if (!order.upgrades) order.upgrades = [];
+  //   const total = this.orderTotalExport(order, fees);
+  //   const subtotal = this.orderSubtotal(order);
+  //   const selloutFees = this.selloutExortFees(order, fees);
+  //   const promoterFees = this.promoterFees(order, fees);
+  //   let stripeFee = total - subtotal - selloutFees - promoterFees;
+  //   let stripeFeeT = stripeFee < 0 ? 0 : stripeFee;
+  //   return stripeFeeT;
+  // },
   promoterFees(order, fees) {
     if (!order.tickets) order.tickets = [];
     if (!order.upgrades) order.upgrades = [];

package/src/utils/PaymentUtil.ts

@@ -163,11 +163,61 @@ class PaymentUtil {
       return true;
     });
 
+    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
     );
 
+    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;
+      }
+
+      if(!ticket.guestTicket){
+        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;
+    }
+    
+    const ticketGuestFeeTotal = tickets.reduce((cur, ticket) => {
+      return (
+        cur +
+        guestFees.reduce((cur, fee) => {
+          const value = cur + applyGuestTicketFee(ticket, fee);
+          return value;
+        }, 0)
+      );
+    }, 0);
+
+  
     const ticketFees = fees
       .filter((f) => f.appliedTo === FeeAppliedToEnum.Ticket)
       .sort(({ type }) => {
@@ -270,6 +320,9 @@ class PaymentUtil {
       );
     }, 0);
 
+    
+
+
     const upgradeTotal = upgrades.reduce(
       (cur, upgrade) => cur + upgrade.price,
       0
@@ -291,22 +344,261 @@ class PaymentUtil {
     const orderSubtotal = Math.round(
       ticketTotal +
         ticketTaxFeeTotal +
+        // ticketFeeTotal +
         ticketFeeTotal +
-        upgradeTaxFeeTotal +
+        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;
+      }
+
+      // Ignore card entry fees for non card entry payemnts
+      if (
+        fee.filters &&
+        fee.filters.includes(FeeFiltersEnum.CardEntry) &&
+        paymentMethodType !== PaymentMethodTypeEnum.CardEntry
+      ) {
+        return false;
+      }
+
+      return true;
+    });
+
+    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
+    );
+
+    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;
+      }
+
+      if(!ticket.guestTicket){
+        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;
+    }
+    
+    const ticketGuestFeeTotal = tickets.reduce((cur, ticket) => {
+      return (
+        cur +
+        guestFees.reduce((cur, fee) => {
+          const value = cur + applyGuestTicketFee(ticket, fee);
+          return value;
+        }, 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"
+    )
+      .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;
+      }
+
+      return 0;
+    }
+
+    function applyOrderFee(orderSubtotal, fee) {
+      if (fee.type === FeeTypeEnum.Flat) {
+        return orderSubtotal + fee.value;
+      }
+      if (fee.type === FeeTypeEnum.Percent) {
+        return orderSubtotal / (1 - fee.value / 100);
+      }
+    }
+
+    const ticketTotal = tickets.reduce((cur, ticket) => cur + ticket.price, 0);
+    
+
+    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) => {
+    //   return (
+    //     cur +
+    //     ticketFees.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 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
     );
 
-    // console.log(`Order SubTotal:`, orderSubtotal);
 
     const orderTotal = orderFees.reduce((cur, fee) => {
       return applyOrderFee(cur, fee);
     }, orderSubtotal);
 
-     console.log(`Order Total`, orderTotal);
 
     return Math.round(orderTotal);
   }
+
+
+
   calculatePaymentSubtotal(params: IPaymentCalculatorParams): number {
     let {
       tickets = [],
@@ -404,15 +696,16 @@ class PaymentUtil {
       (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 + Math.round(guestFees * stripeFeesValue/100)
+      ? guestFees + guestFees * stripeFeesValue/100
       : 0;
   }
+  
 }
 
 export default new PaymentUtil();