@sellout/models 0.0.160 → 0.0.162

package/src/schemas/Order.ts

@@ -41,12 +41,29 @@ const Scan = {
     type: String,
     required: false,
     default: '',
-  },startsAt:{
+  }, startsAt: {
     type: Number,
     required: false,
   }
 };
-
+const TeiMemberInfoInput = {
+  firstName: {
+    type: String,
+    required: false
+  },
+  lastName: {
+    type: String,
+    required: false
+  },
+  email: {
+    type: String,
+    required: false
+  },
+  phoneNumber: {
+    type: String,
+    required: false
+  }
+}
 const OrderTicket = {
   _id: {
     type: String,
@@ -95,39 +112,25 @@ const OrderTicket = {
     required: false,
     default: null,
   },
-  values:{
+  values: {
     type: String,
     required: false,
-  },description:{
+  }, description: {
     type: String,
     required: false
-  },dayIds:[
+  }, dayIds: [
     {
       type: String,
       required: false
     }
-  ],teiMemberId:{
+  ], teiMemberId: {
     type: String,
     required: false
-  },isMemberIdValid:{
+  }, isMemberIdValid: {
     type: Boolean,
     required: false
-  },  firstName :{
-    type: String,
-    required: false
   },
-   lastName:{
-    type: String,
-    required: false
-   },
-  email:{
-    type: String,
-    required: false
-  },
-  phoneNumber:{
-    type: String,
-    required: false
-  }
+  teiMemberInfo: TeiMemberInfoInput
 };
 
 const OrderUpgrade = {
@@ -195,6 +198,8 @@ const OrderCustomField = {
   },
 };
 
+
+
 const Payment = {
   _id: {
     type: String,
@@ -349,15 +354,15 @@ export default {
   address: Address,
   customFields: [OrderCustomField],
   payments: [Payment],
-  seasonId:{
+  seasonId: {
     type: String,
     required: false,
-  },hidden:{
+  }, hidden: {
     type: Boolean,
     required: false,
-  },printed:{
+  }, printed: {
     type: Boolean,
     required: false,
-    default:false
+    default: false
   }
 };

package/src/schemas/Season.ts

@@ -501,7 +501,11 @@ export default {
       type: String,
       required: false
     }
-  ]
+  ],isGuestTicketSale:{
+    type: Boolean,
+    required: false,
+    default: false
+  }
 };
 
 

package/src/utils/EventUtil.ts

@@ -14,7 +14,7 @@ import IEventPromotion from "../interfaces/IEventPromotion";
 import { EventPromotionTypeEnum } from "../interfaces/IEventPromotion";
 import { DropDownEnum } from "../enums/DropDownEnum";
 import { SendQRCodeEnum } from "../interfaces/IEvent";
-import IEventSchedule from "src/interfaces/IEventSchedule";
+import IEventSchedule from "../interfaces/IEventSchedule";
 
 export default {
   /****************************************************************************************

package/src/utils/PaymentUtil.ts

@@ -1,16 +1,20 @@
-import FeeUtil from './FeeUtil';
-import { ICreateOrderTicketParams, ICreateOrderUpgradeParams } from '../interfaces/ICreateOrderParams';
-import IFee, { FeeAppliedToEnum, FeeFiltersEnum, FeeTypeEnum } from '../interfaces/IFee';
-import { PaymentMethodTypeEnum } from '../enums/PaymentMethodTypeEnum';
-// import IPayment from 'src/interfaces/IPayment';
-// import IPayment from 'src/interfaces/IPayment';
-// import { OrderTypeEnum } from 'src/interfaces/IOrderType';
+import FeeUtil from "./FeeUtil";
+import {
+  ICreateOrderTicketParams,
+  ICreateOrderUpgradeParams,
+} from "../interfaces/ICreateOrderParams";
+import IFee, {
+  FeeAppliedToEnum,
+  FeeFiltersEnum,
+  FeeTypeEnum,
+} from "../interfaces/IFee";
+import { PaymentMethodTypeEnum } from "../enums/PaymentMethodTypeEnum";
 
 interface IPaymentCalculatorParams {
   tickets: ICreateOrderTicketParams[];
   upgrades: ICreateOrderUpgradeParams[];
   fees: IFee[];
-  paymentMethodType: PaymentMethodTypeEnum
+  paymentMethodType: PaymentMethodTypeEnum;
 }
 
 // interface IOrderItems {
@@ -23,13 +27,12 @@ class PaymentUtil {
   // calculateOrderItemPrices(params: IPaymentCalculatorParams): IOrderItems {
 
   //   let {
-  //     tickets = [], 
+  //     tickets = [],
   //     upgrades = [],
   //     fees = [],
   //     paymentMethodType,
   //   } = params;
 
-    
   //   // Filter fees
   //   fees = fees.filter((fee: IFee) => {
   //     // Ignore card reader fees for non card reader payemnts
@@ -77,7 +80,7 @@ class PaymentUtil {
   //     const maxFee = fee.maxAppliedToPrice || Infinity;
 
   //     if (minFee <= price && price <= maxFee) {
-        // console.log(fee);
+  // console.log(fee);
   //       if (fee.type === FeeTypeEnum.Flat) {
   //         return price - fee.value;
   //       } if (fee.type === FeeTypeEnum.Percent) {
@@ -85,7 +88,6 @@ class PaymentUtil {
   //       }
   //     }
 
-
   //     // if(fee.type === FeeTypeEnum.Percent) {
   //     //   return price * (1 - fee.value / 100);
   //     // }
@@ -111,15 +113,13 @@ class PaymentUtil {
 
   //   tickets = tickets.map((ticket: ICreateOrderTicketParams): ICreateOrderTicketParams => {
   //     const price = Math.floor(calculateTicketPrice(ticket));
-      // console.log(`Ticket Price: `, price);
+  // console.log(`Ticket Price: `, price);
   //     return {
   //       ...ticket,
   //       price,
   //     }
   //   });
 
-    
-
   //   // upgrades = upgrades.map((upgrade: ICreateOrderUpgradeParams): ICreateOrderUpgradeParams => {
   //   //   return {
   //   //     ...upgrade,
@@ -133,12 +133,7 @@ class PaymentUtil {
   //   };
   // },
   calculatePaymentTotal(params: IPaymentCalculatorParams): number {
-    let {
-      tickets = [],
-      upgrades = [],
-      fees = [],
-      paymentMethodType,
-    } = params;
+    let { tickets = [], upgrades = [], fees = [], paymentMethodType } = params;
 
     // No items, total is always 0
     if (!tickets.length && !upgrades.length) return 0;
@@ -146,45 +141,73 @@ class PaymentUtil {
     // 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) {
+      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) {
+      if (
+        fee.filters &&
+        fee.filters.includes(FeeFiltersEnum.CardEntry) &&
+        paymentMethodType !== PaymentMethodTypeEnum.CardEntry
+      ) {
         return false;
       }
 
       return true;
     });
 
-    const ticketFees = fees.filter(f => f.appliedTo === FeeAppliedToEnum.Ticket)
+    fees = fees.filter(
+      (fee: IFee) =>
+        fee.filters && fee.filters[0] !== FeeFiltersEnum.GuestTicket
+    );
+
+    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 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');
+    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 {
+    function applyTicketFee(
+      ticket: ICreateOrderTicketParams,
+      fee: IFee
+    ): number {
       // Ignore seated fees if not seated
-      if (fee.filters && fee.filters.includes(FeeFiltersEnum.Seated) && !ticket.seat) {
+      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);
+        }
+        if (fee.type === FeeTypeEnum.Percent) {
+          return (ticket.price * fee.value) / 100;
         }
       } else {
         return 0;
@@ -193,15 +216,19 @@ class PaymentUtil {
       return 0;
     }
 
-    function applyUpgradeFee(upgrade: ICreateOrderUpgradeParams, fee: IFee): number {
+    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);
+        }
+        if (fee.type === FeeTypeEnum.Percent) {
+          return (upgrade.price * fee.value) / 100;
         }
       } else {
         return 0;
@@ -213,36 +240,59 @@ class PaymentUtil {
     function applyOrderFee(orderSubtotal, fee) {
       if (fee.type === FeeTypeEnum.Flat) {
         return orderSubtotal + fee.value;
-      } if (fee.type === FeeTypeEnum.Percent) {
-        return (orderSubtotal / (1 - fee.value / 100));
+      }
+      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);
+      return (
+        cur +
+        salesTax.reduce((cur, fee) => {
+          const value = cur + applyTicketFee(ticket, fee);
+          return value;
+        }, 0)
+      );
     }, 0);
     const ticketFeeTotal = tickets.reduce((cur, ticket) => {
-      return cur + ticketFees.reduce((cur, fee) => {
-        const value = cur + applyTicketFee(ticket, fee);
-        return value;
-      }, 0);
+      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 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);
+      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);
+      return (
+        cur +
+        upgradeFees.reduce((cur, fee) => cur + applyUpgradeFee(upgrade, fee), 0)
+      );
     }, 0);
-    const orderSubtotal = Math.round(ticketTotal + ticketTaxFeeTotal + ticketFeeTotal + upgradeTaxFeeTotal + upgradeTotal + upgradeFeeTotal);
+    const orderSubtotal = Math.round(
+      ticketTotal +
+        ticketTaxFeeTotal +
+        ticketFeeTotal +
+        upgradeTaxFeeTotal +
+        upgradeTotal +
+        upgradeFeeTotal
+    );
 
     // console.log(`Order SubTotal:`, orderSubtotal);
 
@@ -262,37 +312,32 @@ class PaymentUtil {
       // fees
     } = params;
 
-    if(paymentMethodType === PaymentMethodTypeEnum.None) return 0;
+    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)
+    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
+    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);
     let subtotal = this.calculatePaymentSubtotal(params);
-    subtotal = subtotal + (subtotal*tax/100)
+    subtotal = subtotal + (subtotal * tax) / 100;
     return Math.round(total - subtotal);
   }
 
   calculateFeeWithoutTax(params: IPaymentCalculatorParams): number {
-
     const total = this.calculatePaymentTotal(params);
     let subtotal = this.calculatePaymentSubtotal(params);
     return Math.round(total - subtotal);
   }
   calculateOrganizationFee(params: IPaymentCalculatorParams): number {
-    let {
-      tickets = [],
-      upgrades = [],
-      fees = [],
-      paymentMethodType,
-    } = params;
+    let { tickets = [], upgrades = [], fees = [], paymentMethodType } = params;
 
     fees = FeeUtil.promoterFees(fees);
     return this.calculateFee({
@@ -303,14 +348,8 @@ class PaymentUtil {
     });
   }
 
-
   calculateTaxFee(params: IPaymentCalculatorParams): number {
-    let {
-      tickets = [],
-      upgrades = [],
-      fees = [],
-      paymentMethodType,
-    } = params;
+    let { tickets = [], upgrades = [], fees = [], paymentMethodType } = params;
 
     fees = FeeUtil.taxFees(fees);
     return this.calculateFeeWithoutTax({
@@ -321,12 +360,7 @@ class PaymentUtil {
     });
   }
   calculatePlatformFee(params: IPaymentCalculatorParams): number {
-    let {
-      tickets = [],
-      upgrades = [],
-      fees = [],
-      paymentMethodType,
-    } = params;
+    let { tickets = [], upgrades = [], fees = [], paymentMethodType } = params;
 
     fees = FeeUtil.selloutFees(fees);
 
@@ -348,7 +382,7 @@ class PaymentUtil {
     const total = this.calculatePaymentTotal(params);
     const subtotal = this.calculatePaymentSubtotal(params);
     const organizationFee = this.calculateOrganizationFee(params);
-    return total - subtotal  - organizationFee;
+    return total - subtotal - organizationFee;
   }
   // calculateTaxFee(params: IPaymentCalculatorParams): number {
   //   const organizationFee = this.calculateTaxFee(params);
@@ -356,6 +390,19 @@ class PaymentUtil {
   //   return organizationFee;
   // }
 
+  calculateGuestFee(tickets: any, event: any): number {
+    let guestTicketFees = event?.fees.filter(
+      (fee: IFee) =>
+        fee.filters && fee.filters[0] === FeeFiltersEnum.GuestTicket
+    );
+    let guestFeesValue = guestTicketFees && guestTicketFees[0]?.value;
+    let guestMembers = tickets.filter((a) => !a.isMemberIdValid).length;
+
+    let guestFees = (guestFeesValue as number) * guestMembers;
+    return guestTicketFees.length > 0 && event.organization.isTegIntegration
+      ? guestFees
+      : 0;
+  }
 }
 
 export default new PaymentUtil();

package/src/utils/SeasonUtil.ts

@@ -6,6 +6,9 @@ import * as Time from "@sellout/utils/.dist/time";
 import ISeason from "../interfaces/ISeason";
 import ITicketType from "../interfaces/ITicketType";
 import ISeasonCustomField from "../interfaces/ISeasonCustomField";
+import IOrderCustomField from "../interfaces/IOrderCustomField";
+import { CustomFieldTypeEnum } from "../enums/CustomFieldTypeEnum";
+import { DropDownEnum } from "../enums/DropDownEnum";
 
 export default {
   /****************************************************************************************
@@ -373,4 +376,85 @@ export default {
       .unknown(true);
     return customFieldSchema.validate(customField);
   },
+  customFieldsAreValid(
+    seasonCustomFields: ISeasonCustomField[],
+    orderCustomFields: IOrderCustomField[]
+  ): boolean {
+    const activeFields =
+      seasonCustomFields?.filter(
+        (seasonCustomField) => seasonCustomField.active
+      ) ?? [];
+
+    const validFields =
+      activeFields?.filter((eventCustomField) => {
+        const { _id, minLength, maxLength, minValue, maxValue, required } =
+          eventCustomField;
+
+        const orderCustomField = orderCustomFields?.find(
+          (orderCustomField) => orderCustomField.customFieldId === _id
+        );
+
+        // Field is not required and orderCustomField not empty
+        if (!required && !orderCustomField) return true;
+
+        // Field has not been filled out
+        if (!orderCustomField) return false;
+
+        let { value } = orderCustomField;
+
+        if (
+          !required &&
+          (value === undefined ||
+            value === "NaN" ||
+            value === "" ||
+            value === DropDownEnum.Select)
+        ) {
+          return true;
+        }
+
+        if (eventCustomField?.type === CustomFieldTypeEnum.Text) {
+          value = <string>value;
+          if (value) {
+            if (minLength === 0 && maxLength === 0 && value.length > 0) {
+              return true;
+            } else if (minLength === 0 && value.length <= maxLength) {
+              return true;
+            } else if (maxLength === 0 && minLength <= value.length) {
+              return true;
+            } else if (minLength <= value.length && value.length <= maxLength) {
+              return true;
+            }
+          }
+          return false;
+        } else if (eventCustomField.type === CustomFieldTypeEnum.Dropdown) {
+          value = <string>value;
+          if (value !== "" && value !== DropDownEnum.Select) {
+            return true;
+          }
+          return false;
+        } else if (eventCustomField.type === CustomFieldTypeEnum.Address) {
+          value = <string>value;
+          if (value !== "") {
+            return true;
+          }
+          return false;
+        } else {
+          value = <number>value;
+          if (value) {
+            if (minValue === 0 && maxValue === 0 && value > 0) {
+              return true;
+            } else if (minValue === 0 && value <= maxValue) {
+              return true;
+            } else if (maxValue === 0 && minValue <= value) {
+              return true;
+            } else if (minValue <= value && value <= maxValue) {
+              return true;
+            }
+          }
+          return false;
+        }
+      }) ?? [];
+
+    return validFields.length === activeFields.length;
+  },
 };