@bash-app/bash-common 30.113.0 → 30.115.0

package/src/utils/discountEngine/eligibilityValidator.ts

@@ -0,0 +1,256 @@
+import { BashEventPromoCode, SpecialOffer, SpecialOfferType } from "@prisma/client";
+
+export interface EligibilityResult {
+  eligible: boolean;
+  reason?: string;
+}
+
+/**
+ * Validate if a user is eligible to use a promo code
+ */
+export const validatePromoCodeEligibility = (
+  promoCode: BashEventPromoCode,
+  userId: string,
+  usersWhoUsedCode: string[] = []
+): EligibilityResult => {
+  // Check if expired
+  if (promoCode.redeemBy && new Date() > promoCode.redeemBy) {
+    return {
+      eligible: false,
+      reason: `This promo code expired on ${promoCode.redeemBy.toLocaleDateString()}`,
+    };
+  }
+
+  // Check max redemptions
+  if (promoCode.maxRedemptions && usersWhoUsedCode.length >= promoCode.maxRedemptions) {
+    return {
+      eligible: false,
+      reason: "This promo code has reached its maximum number of uses",
+    };
+  }
+
+  // Check if user already used this code
+  if (usersWhoUsedCode.includes(userId)) {
+    return {
+      eligible: false,
+      reason: "You have already used this promo code",
+    };
+  }
+
+  return { eligible: true };
+};
+
+/**
+ * Validate if a user is eligible for a special offer
+ */
+export const validateOfferEligibility = (
+  offer: SpecialOffer,
+  userId: string,
+  quantity: number,
+  currentDate: Date,
+  userRedemptionCount: number = 0
+): EligibilityResult => {
+  // Check if offer is active
+  if (!offer.isActive) {
+    return {
+      eligible: false,
+      reason: "This offer is no longer active",
+    };
+  }
+
+  // Check start date
+  if (offer.startDate && currentDate < offer.startDate) {
+    return {
+      eligible: false,
+      reason: `This offer starts on ${offer.startDate.toLocaleDateString()}`,
+    };
+  }
+
+  // Check end date
+  if (offer.endDate && currentDate > offer.endDate) {
+    return {
+      eligible: false,
+      reason: `This offer ended on ${offer.endDate.toLocaleDateString()}`,
+    };
+  }
+
+  // Check early bird cutoff
+  if (offer.availableUntil && currentDate > offer.availableUntil) {
+    return {
+      eligible: false,
+      reason: "The early bird period has ended",
+    };
+  }
+
+  // Check price increase countdown
+  if (offer.priceIncreasesAt && currentDate > offer.priceIncreasesAt) {
+    return {
+      eligible: false,
+      reason: "This special pricing is no longer available",
+    };
+  }
+
+  // Check max redemptions (total)
+  if (offer.maxRedemptions && offer.currentRedemptions >= offer.maxRedemptions) {
+    return {
+      eligible: false,
+      reason: "This offer has reached its maximum number of uses",
+    };
+  }
+
+  // Check max redemptions per user
+  if (offer.maxPerUser && userRedemptionCount >= offer.maxPerUser) {
+    return {
+      eligible: false,
+      reason: "You have reached the maximum number of times you can use this offer",
+    };
+  }
+
+  // Check limited quantity
+  if (offer.limitedQuantity && offer.currentRedemptions >= offer.limitedQuantity) {
+    return {
+      eligible: false,
+      reason: "This offer is sold out",
+    };
+  }
+
+  // Check quantity requirements for specific offer types
+  if (offer.offerType === SpecialOfferType.GROUP_DISCOUNT) {
+    if (offer.minGroupSize && quantity < offer.minGroupSize) {
+      return {
+        eligible: false,
+        reason: `You must purchase at least ${offer.minGroupSize} tickets to qualify for this group discount`,
+      };
+    }
+    if (offer.maxGroupSize && quantity > offer.maxGroupSize) {
+      return {
+        eligible: false,
+        reason: `This group discount only applies to groups of ${offer.maxGroupSize} or fewer`,
+      };
+    }
+  }
+
+  if (offer.offerType === SpecialOfferType.BOGO) {
+    const buyQuantity = offer.buyQuantity || 1;
+    const getQuantity = offer.getQuantity || 1;
+    const minQuantity = buyQuantity + getQuantity;
+
+    if (quantity < minQuantity) {
+      return {
+        eligible: false,
+        reason: `You must purchase at least ${minQuantity} tickets for this Buy ${buyQuantity} Get ${getQuantity} offer`,
+      };
+    }
+  }
+
+  // All checks passed
+  return { eligible: true };
+};
+
+/**
+ * Validate if an offer can stack with promo codes
+ */
+export const validateOfferStacking = (
+  offer: SpecialOffer,
+  hasPromoCode: boolean,
+  hasOtherOffer: boolean
+): EligibilityResult => {
+  if (hasPromoCode && !offer.canStackWithPromoCodes) {
+    return {
+      eligible: false,
+      reason: "This offer cannot be combined with promo codes",
+    };
+  }
+
+  if (hasOtherOffer && !offer.canStackWithOtherOffers) {
+    return {
+      eligible: false,
+      reason: "This offer cannot be combined with other offers",
+    };
+  }
+
+  return { eligible: true };
+};
+
+/**
+ * Validate loyalty offer requirements
+ */
+export const validateLoyaltyRequirements = (
+  offer: SpecialOffer,
+  userEventAttendanceCount: number,
+  isHostEvent: boolean
+): EligibilityResult => {
+  if (offer.offerType !== SpecialOfferType.LOYALTY) {
+    return { eligible: true };
+  }
+
+  // Check event attendance requirement
+  if (offer.requiresEventAttendance && userEventAttendanceCount < offer.requiresEventAttendance) {
+    return {
+      eligible: false,
+      reason: `You must have attended at least ${offer.requiresEventAttendance} events to qualify for this loyalty offer`,
+    };
+  }
+
+  // Check if it's host-specific loyalty
+  if (offer.hostSpecificLoyalty && !isHostEvent) {
+    return {
+      eligible: false,
+      reason: "This loyalty offer only applies to events by this host",
+    };
+  }
+
+  return { eligible: true };
+};
+
+/**
+ * Batch validate multiple offers for a user
+ */
+export const validateMultipleOffers = (
+  offers: SpecialOffer[],
+  userId: string,
+  quantity: number,
+  currentDate: Date,
+  userRedemptions: Map<string, number>
+): Map<string, EligibilityResult> => {
+  const results = new Map<string, EligibilityResult>();
+
+  offers.forEach(offer => {
+    const userCount = userRedemptions.get(offer.id) || 0;
+    const result = validateOfferEligibility(offer, userId, quantity, currentDate, userCount);
+    results.set(offer.id, result);
+  });
+
+  return results;
+};
+
+/**
+ * Get time remaining until offer expires (for countdown timers)
+ */
+export const getTimeRemaining = (offer: SpecialOffer, currentDate: Date): {
+  expired: boolean;
+  days: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+} => {
+  const expiryDate = offer.endDate || offer.priceIncreasesAt || offer.availableUntil;
+
+  if (!expiryDate) {
+    return { expired: false, days: 999, hours: 0, minutes: 0, seconds: 0 };
+  }
+
+  const diff = expiryDate.getTime() - currentDate.getTime();
+
+  if (diff <= 0) {
+    return { expired: true, days: 0, hours: 0, minutes: 0, seconds: 0 };
+  }
+
+  const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+  const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
+  const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
+  const seconds = Math.floor((diff % (1000 * 60)) / 1000);
+
+  return { expired: false, days, hours, minutes, seconds };
+};
+

package/src/utils/discountEngine/index.ts

@@ -0,0 +1,5 @@
+// Unified Discount Engine - All discount calculation and validation logic
+export * from './discountCalculator';
+export * from './bestPriceResolver';
+export * from './eligibilityValidator';
+

package/src/utils/recurrenceUtils.ts

@@ -74,6 +74,11 @@ function getRecurringBashEventPossibleDatesTimesInternal(
       console.error(`Unsupported frequency: ${recurrence.frequency}`);
   }
 
+  // If repeatCount is specified, limit to that many occurrences
+  if (recurrence.repeatCount && recurrence.repeatCount > 0) {
+    recurrenceDates = recurrenceDates.slice(0, recurrence.repeatCount);
+  }
+
   return recurrenceDates
     .map((date: DateTime): string =>
       date.toFormat(LUXON_DATETIME_FORMAT_ISO_LIKE)
@@ -108,7 +113,12 @@ function getDailyRecurringDates(
   }
 
   const interval = recurrence.interval ?? 1;
-  const recurrenceEnds = dateTimeFromDate(recurrence.ends).endOf("day");
+  
+  // Default to 1 year from now if no end date specified
+  const recurrenceEnds = recurrence.ends 
+    ? dateTimeFromDate(recurrence.ends).endOf("day")
+    : DateTime.local().plus({ years: 1 }).endOf("day");
+    
   const numberOfDays = recurrenceEnds.diff(beginningDateTime, "days").days;
   const numberOfOccurrences = Math.ceil(numberOfDays / interval);
 
@@ -141,7 +151,9 @@ function getWeeklyRecurringDates(
   }
 
   const interval = recurrence.interval ?? 1;
-  const recurrenceEnds = dateTimeFromDate(recurrence.ends).endOf("day"); // Get the end of the day to not miss the last day
+  const recurrenceEnds = recurrence.ends 
+    ? dateTimeFromDate(recurrence.ends).endOf("day")
+    : DateTime.local().plus({ years: 1 }).endOf("day");
   const numberOfDays = recurrenceEnds.diff(beginningDateTime, "days").days;
   const numberOfWeeks = Math.ceil(numberOfDays / 7 / interval); // Get the number of days and then round up so that we include the ending date
 
@@ -203,7 +215,9 @@ function getMonthlyRecurringDates(
   }
 
   const interval = recurrence.interval ?? 1;
-  const recurrenceEnds = dateTimeFromDate(recurrence.ends).endOf("day");
+  const recurrenceEnds = recurrence.ends 
+    ? dateTimeFromDate(recurrence.ends).endOf("day")
+    : DateTime.local().plus({ years: 1 }).endOf("day");
   const dayOfMonth = recurrence.repeatOnDayOfMonth ?? beginningDateTime.day;
 
   const recurrenceDates: DateTime[] = [];
@@ -248,7 +262,9 @@ function getYearlyRecurringDates(
   }
 
   const interval = recurrence.interval ?? 1;
-  const recurrenceEnds = dateTimeFromDate(recurrence.ends).endOf("day");
+  const recurrenceEnds = recurrence.ends 
+    ? dateTimeFromDate(recurrence.ends).endOf("day")
+    : DateTime.local().plus({ years: 20 }).endOf("day");
   
   // Use the repeatYearlyDate if provided, otherwise use the beginning date
   const baseDate = recurrence.repeatYearlyDate