@bash-app/bash-common 29.67.0 → 29.69.0

package/src/utils/mathUtils.ts

@@ -0,0 +1,3 @@
+export function roundToNearestDivisor(num: number, div: number): number {
+  return Math.round(num * div) / div;
+}

package/src/utils/paymentUtils.ts

@@ -1,33 +1,44 @@
-import {BashEventPromoCode, TicketTier} from "@prisma/client";
-import {BASH_FEE_PERCENTAGE, NumberOfTicketsForDate, PRICE_DOLLARS_AND_CENTS_RATIO} from "../definitions";
-
+import { BashEventPromoCode, TicketTier } from "@prisma/client";
+import {
+  BASH_FEE_PERCENTAGE,
+  NumberOfTicketsForDate,
+  PRICE_DOLLARS_AND_CENTS_RATIO,
+} from "../definitions";
 
 /**
  * Returns the amount of discount in dollars
  * @param totalInDollars
  * @param promoCode
  */
-export function calculateDiscountFromPromoCode(totalInDollars: number, promoCode: BashEventPromoCode | undefined): number {
+export function calculateDiscountFromPromoCode(
+  totalInDollars: number,
+  promoCode: BashEventPromoCode | undefined
+): number {
   if (promoCode) {
     if (promoCode.discountAmountInCents) {
-      const discountInDollars = convertCentsToDollars(promoCode.discountAmountInCents);
+      const discountInDollars = convertCentsToDollars(
+        promoCode.discountAmountInCents
+      );
       return Math.max(0, discountInDollars); // Ensure we don't discount more than 100%
     }
     if (promoCode.discountAmountPercentage) {
-      const discountInDollars = totalInDollars * (promoCode.discountAmountPercentage / 100);
+      const discountInDollars =
+        totalInDollars * (promoCode.discountAmountPercentage / 100);
       return Math.min(totalInDollars, discountInDollars); // Ensure we don't discount more than 100%
     }
   }
   return 0;
 }
 
-
 /**
  * Returns the total price based on a map where the keys are the ticketTierIds
  * @param ticketTiers
  * @param ticketList
  */
-export function calculateTotalPriceWithoutTax(ticketTiers: TicketTier[], ticketList: Map<string, NumberOfTicketsForDate[]>): number {
+export function calculateTotalPriceWithoutTax(
+  ticketTiers: TicketTier[],
+  ticketList: Map<string, NumberOfTicketsForDate[]>
+): number {
   let total = 0;
   ticketTiers.forEach((tier: TicketTier) => {
     const ticketListNumAndDate = ticketList.get(tier.id);
@@ -38,13 +49,17 @@ export function calculateTotalPriceWithoutTax(ticketTiers: TicketTier[], ticketL
   return total;
 }
 
-export function convertCentsToDollars(price: number | undefined | null): number {
+export function convertCentsToDollars(
+  price: number | undefined | null
+): number {
   if (!price) {
     return 0;
   }
   return price / PRICE_DOLLARS_AND_CENTS_RATIO;
 }
-export function convertDollarsToCents(price: number | undefined | null): number {
+export function convertDollarsToCents(
+  price: number | undefined | null
+): number {
   if (!price) {
     return 0;
   }

package/src/utils/service/attendeeOptionUtils.ts

@@ -0,0 +1,19 @@
+export interface ServiceAttendeeOptionRange {
+  start: number;
+  end: number;
+}
+
+export interface ServiceAttendeeOption {
+  label: string;
+  rate: number;
+  personRange: ServiceAttendeeOptionRange;
+}
+
+export const serviceAttendeeOptions = [
+  { label: "1 - 5 people", personRange: { start: 1, end: 5 }, rate: 0 },
+  { label: "6 - 15 people", personRange: { start: 6, end: 15 }, rate: 50 },
+  { label: "16 - 30 people", personRange: { start: 16, end: 30 }, rate: 100 },
+  { label: "31 - 45 people", personRange: { start: 31, end: 45 }, rate: 200 },
+  { label: "46 - 60 people", personRange: { start: 46, end: 60 }, rate: 400 },
+  { label: "61 - 75 people", personRange: { start: 61, end: 75 }, rate: 500 },
+] as ServiceAttendeeOption[];

package/src/utils/service/serviceBookingApiUtils.ts

@@ -0,0 +1,259 @@
+import {
+  ServiceBookingApiParamsLuxon,
+  ServiceBookingApiParams,
+  ServiceBookedDayApiParamsLuxon,
+  ServiceAddonApiParams,
+  ServiceBookedDayApiParams,
+  ServicePriceToBookApiResult,
+} from "../../definitions";
+import {
+  ServiceAddonExt,
+  ServiceBookingAddOnExt,
+  ServiceBookingDayExt,
+  ServiceBookingExt,
+  ServiceExt,
+} from "../../extendedSchemas";
+import {
+  dateTimeFromDate,
+  dateTimeFromString,
+  dateTimeRangeFromDates,
+} from "../luxonUtils";
+import { convertDollarsToCents } from "../paymentUtils";
+import {
+  ServiceAttendeeOption,
+  serviceAttendeeOptions,
+} from "./attendeeOptionUtils";
+import {
+  ServiceGetPriceToBookFeesParams,
+  ServiceBookingDayInfoParams,
+  ServiceBookingFee,
+  ServiceAddonInput,
+  ServiceGetPriceToBookResult,
+  serviceGetPriceToBookFees,
+  serviceGetPriceToBookExt,
+  ServiceGetPriceToBookExtDay,
+} from "./serviceBookingUtils";
+
+export type ServiceCantBookReason = {
+  type: string;
+  msg: string;
+};
+
+export const ServiceCantBookReasons = {
+  notInBusinessHours: {
+    type: "notInBusinessHours",
+    msg: "Time not within normal Business Hours",
+  } as ServiceCantBookReason,
+  minimumTimeBlock: {
+    type: "minimumTimeBlock",
+    msg: "Minimum time block not satisfied",
+  } as ServiceCantBookReason,
+  dateBlocked: {
+    type: "dateBlocked",
+    msg: "The selected date is blocked.",
+  } as ServiceCantBookReason,
+  alreadyBooked: {
+    type: "alreadyBooked",
+    msg: "This service has already been booked.",
+  } as ServiceCantBookReason,
+  requestDeclined: {
+    type: "requestDeclined",
+    msg: "The booking request has been declined.",
+  } as ServiceCantBookReason,
+} as const;
+
+export type ServiceCantBookReasons = keyof typeof ServiceCantBookReasons;
+
+export function apiTransformAddOnsToAddonInputs<
+  AddonParams_t extends ServiceAddonApiParams
+>(
+  addOnsApi: AddonParams_t[],
+  serviceAddons: ServiceAddonExt[]
+): ServiceAddonInput[] {
+  // Create a Map for faster lookup by addonId
+  const addonMap = new Map<string, ServiceAddonExt>(
+    serviceAddons.map((addon) => [addon.id, addon])
+  );
+
+  return addOnsApi.map((addOnApi) => {
+    const matchedAddon = addonMap.get(addOnApi.addonId);
+    if (!matchedAddon) {
+      throw new Error(`Failed to match addon with id: ${addOnApi.addonId}`);
+    }
+    return {
+      ...matchedAddon,
+      ...addOnApi,
+    } as ServiceAddonInput;
+  });
+}
+
+// export function serviceAddonInputAddOnsToAddonInputs<
+//   AddonParams_t extends ServiceAddonInput
+// >(
+//   addOnsApi: AddonParams_t[],
+//   serviceAddons: ServiceAddonExt[]
+// ): ServiceAddonInput[] {
+//   // Create a Map for faster lookup by addonId
+//   const addonMap = new Map<string, ServiceAddonExt>(
+//     serviceAddons.map((addon) => [addon.id, addon])
+//   );
+
+//   return addOnsApi.map((addOnApi) => {
+//     const matchedAddon = addonMap.get(addOnApi.id);
+//     if (!matchedAddon) {
+//       throw new Error(`Failed to match addon with id: ${addOnApi.id}`);
+//     }
+//     return {
+//       ...matchedAddon,
+//       ...addOnApi,
+//     } as ServiceAddonInput;
+//   });
+// }
+
+// export function apiTransformBookedDays(
+//   bookedDays: ServiceBookedDayApiParams[],
+//   bookingId: string,
+//   serviceAddons: ServiceAddonExt[]
+// ): ServiceBookingDayExt[] {
+//   return bookedDays.map((day) => {
+//     // Transform the addOns using the helper function and then map to the expected output
+//     const addOns = apiTransformAddOnsToAddonInputs(
+//       day.addOns,
+//       serviceAddons
+//     ).map(
+//       (addOn) =>
+//         ({
+//           addOnId: addOn.id,
+//           chosenQuantity: addOn.chosenQuantity,
+//           serviceBookingDayId: bookingId,
+//           costATBCents: convertDollarsToCents(addOn.price),
+//         } as ServiceBookingAddOnExt)
+//     );
+
+//     return {
+//       id: "",
+//       startDate: dateTimeFromString(day.startDate).toJSDate(),
+//       endDate: dateTimeFromString(day.endDate).toJSDate(),
+//       serviceBookingRequestId: bookingId,
+//       addOns: addOns,
+//       packages: [],
+//     } as ServiceBookingDayExt;
+//   });
+// }
+
+export function apiTransformBookedDays(
+  priceToBook: ServicePriceToBookApiResult
+): Partial<ServiceBookingDayExt>[] {
+  return priceToBook.daysToBook.map((day): Partial<ServiceBookingDayExt> => {
+    // Transform addOns using the helper function, then map to the expected output.
+    const addOns = day.addOns.map(
+      (addOn): Partial<ServiceBookingAddOnExt> => ({
+        addOnId: addOn.id,
+        chosenQuantity: addOn.chosenQuantity ?? 0,
+        addOn: addOn,
+        // costATBCents: convertDollarsToCents(addOn.price),
+      })
+    );
+
+    return {
+      startDate: day.dateTimeRange.start.toJSDate(),
+      endDate: day.dateTimeRange.end.toJSDate(),
+      addOns: addOns,
+      packages: [],
+      // costATBCents: convertDollarsToCents(day.totalBeforeTaxes),
+    } as Partial<ServiceBookingDayExt>;
+  });
+}
+
+export function serviceGetPriceToBookFromBooking(
+  service: ServiceExt,
+  booking: ServiceBookingExt
+): ServiceGetPriceToBookResult {
+  const daysToBook = booking.bookedDays.map((day) => {
+    // Transform addOns back to the original format
+    const addOns =
+      day.addOns?.map(
+        (addOn): ServiceAddonInput => ({
+          ...addOn.addOn,
+          id: addOn.addOnId!,
+          chosenQuantity: addOn.chosenQuantity,
+          // Reconstruct other addOn properties from the stored addOn object
+        })
+      ) ?? [];
+
+    return {
+      dateRange: dateTimeRangeFromDates(
+        day.startDate,
+        day.endDate,
+        "UTC",
+        booking.timezone
+      ),
+      addOns: addOns,
+      // totalBeforeTaxes: day.costATBCents ? convertCentsToDollars(day.costATBCents) : 0,
+    } as ServiceGetPriceToBookExtDay;
+  });
+
+  return serviceGetPriceToBookExt(service.serviceRatesAssociation, {
+    bookedDays: daysToBook,
+    selectedAttendeeOption: serviceAttendeeOptions[0],
+    timezone: booking.timezone,
+  });
+}
+
+// Main function that transforms service booking parameters to price-to-book parameters
+export function serviceBookingParamsToPriceToBookParams(
+  params: ServiceBookingApiParamsLuxon,
+  serviceAddons: ServiceAddonExt[]
+): ServiceGetPriceToBookFeesParams {
+  // Map each booked day to the required parameters
+  const daysToBookParams: ServiceBookingDayInfoParams[] = params.bookedDays.map(
+    (day) => {
+      // Use the helper function to transform the day's addOns
+      const addOnsWithDetails = apiTransformAddOnsToAddonInputs(
+        day.addOns,
+        serviceAddons
+      );
+
+      return {
+        dateTimeRange: day.dateTimeRange,
+        fees: addOnsWithDetails.map(
+          (addon): ServiceBookingFee => ({
+            name: `${addon.name} Fee`,
+            type: "addOnFees",
+            fee: (addon.chosenQuantity || 0) * (addon.price || 0),
+          })
+        ),
+      } as ServiceBookingDayInfoParams;
+    }
+  );
+
+  return {
+    daysToBookParams: daysToBookParams,
+    selectedAttendeeOption: {} as ServiceAttendeeOption, // Placeholder: update with actual business logic
+    timezone: params.timezone,
+  };
+}
+
+export function serviceBookingParamsToLuxon(
+  params: ServiceBookingApiParams
+): ServiceBookingApiParamsLuxon {
+  const bookedDays = params.bookedDays.reduce(
+    (sofar, day): ServiceBookedDayApiParamsLuxon[] => {
+      sofar.push({
+        ...day,
+        dateTimeRange: {
+          start: dateTimeFromString(day.startDate),
+          end: dateTimeFromString(day.endDate),
+        },
+      });
+
+      return sofar;
+    },
+    [] as ServiceBookedDayApiParamsLuxon[]
+  );
+
+  return {
+    ...params,
+    bookedDays,
+  };
+}

package/src/utils/service/serviceBookingStatusUtils.ts

@@ -0,0 +1,106 @@
+import { ServiceBookingExt, ServiceExt } from "../../extendedSchemas";
+
+export interface ValidationResult {
+  valid: boolean;
+  errorMessage?: string;
+}
+
+export function serviceBookingIsValid(
+  service: ServiceExt,
+  booking: ServiceBookingExt | null | undefined
+) {
+  if (booking == null) {
+    return {
+      valid: false,
+      errorMessage: "This booking has already been canceled.",
+    };
+  }
+}
+
+export function serviceBookingCanBePaid(
+  service: ServiceExt,
+  booking: ServiceBookingExt
+): ValidationResult {
+  if (booking.status === "Canceled") {
+    return {
+      valid: false,
+      errorMessage: "This booking has already been canceled.",
+    };
+  }
+  if (booking.status === "Rejected") {
+    return {
+      valid: false,
+      errorMessage: "You cannot pay for a rejected booking request.",
+    };
+  }
+  if (booking.status === "Pending" && booking.bookingType === "Request") {
+    return {
+      valid: false,
+      errorMessage: "You cannot pay for a pending booking request.",
+    };
+  }
+  return { valid: true };
+}
+
+export function serviceBookingCanHaveApprovalDecision(
+  service: ServiceExt,
+  booking: ServiceBookingExt
+): ValidationResult {
+  if (booking.bookingType !== "Request") {
+    return {
+      valid: false,
+      errorMessage: "Approval decisions can only be made on booking requests.",
+    };
+  }
+  if (booking.status !== "Pending") {
+    return {
+      valid: false,
+      errorMessage:
+        "Approval decisions can only be made for pending booking requests.",
+    };
+  }
+
+  return { valid: true };
+}
+
+export function serviceBookingHasDecision(
+  service: ServiceExt,
+  booking: ServiceBookingExt
+): ValidationResult {
+  if (booking.bookingType !== "Request") {
+    return {
+      valid: false,
+      errorMessage: "Only booking requests can have a decision.",
+    };
+  }
+  if (booking.status !== "Approved" && booking.status !== "Rejected") {
+    return {
+      valid: false,
+      errorMessage: "The booking request does not have a decision yet.",
+    };
+  }
+  return { valid: true };
+}
+
+export function serviceBookingCanBeCanceled(
+  service: ServiceExt,
+  booking: ServiceBookingExt
+): ValidationResult {
+  if (booking.status !== "Confirmed") {
+    return {
+      valid: false,
+      errorMessage: "Only confirmed bookings can be canceled.",
+    };
+  }
+  return { valid: true };
+}
+
+export function serviceBookingCanBeConfirmed(
+  service: ServiceExt,
+  booking: ServiceBookingExt
+): ValidationResult {
+  if (booking.status !== "Canceled") {
+    return { valid: false, errorMessage: "The booking is not canceled." };
+  }
+  return { valid: true };
+}