@bash-app/bash-common 30.3.0 → 30.5.0

package/src/utils/service/apiServiceBookingApiUtils.ts

@@ -0,0 +1,222 @@
+import {
+  ApiBookingParamsLuxon,
+  ApiServiceBookingParams,
+  ApiServiceBookedDayParamsLuxon,
+  ApiServiceAddonParams,
+  ApiServiceBookedDayParams,
+  ApiServicePriceToBookResult,
+} from "../../definitions";
+import {
+  ServiceAddonExt,
+  ServiceBookingAddOnExt,
+  ServiceBookingDayExt,
+  ServiceBookingExt,
+  ServiceBookingFeeExt,
+  ServiceBookingPriceBreakdownExt,
+  ServiceExt,
+} from "../../extendedSchemas";
+import { dateTimeFromString, dateTimeRangeFromDates } from "../luxonUtils";
+import { serviceAttendeeOptions } from "./attendeeOptionUtils";
+import { ServiceBookingPriceBreakdownBaseT } from "./serviceBookingTypes";
+import {
+  ServiceAddonInput,
+  FrontendServiceGetPriceToBookResult,
+  FrontendServiceBookingDayInfo,
+} from "./frontendServiceBookingUtils";
+
+export type ApiServiceCantBookReason = {
+  type: string;
+  msg: string;
+};
+
+export const ApiServiceCantBookReasons = {
+  notInBusinessHours: {
+    msg: "Time not within normal Business Hours",
+  } as ApiServiceCantBookReason,
+  minimumTimeBlock: {
+    msg: "Minimum time block not satisfied",
+  } as ApiServiceCantBookReason,
+  dateBlocked: {
+    msg: "The selected date is blocked.",
+  } as ApiServiceCantBookReason,
+  alreadyBooked: {
+    msg: "This service has already been booked.",
+  } as ApiServiceCantBookReason,
+  requestDeclined: {
+    msg: "The booking request has been declined.",
+  } as ApiServiceCantBookReason,
+} as const;
+
+export type ApiServiceCantBookReasons = keyof typeof ApiServiceCantBookReasons;
+
+export function apiTransformAddOnsToAddonInputs<
+  AddonParams_t extends ApiServiceAddonParams
+>(
+  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 apiTransformBookedDays(
+  priceToBook: ApiServicePriceToBookResult
+): 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.addOnId,
+        addOn: addOn.addOn,
+        chosenQuantity: addOn.chosenQuantity,
+        costPQCents: addOn.costPQCents,
+      })
+    );
+
+    const priceBreakdown = day.priceBreakdown.map(
+      (pb): Partial<ServiceBookingPriceBreakdownExt> => {
+        const { dateTimeRange, ...pbData } = pb;
+        return {
+          ...pbData,
+          startDate: pb.dateTimeRange.start.toJSDate(),
+          endDate: pb.dateTimeRange.end.toJSDate(),
+        };
+      }
+    );
+
+    return {
+      startDate: day.dateTimeRange.start.toJSDate(),
+      endDate: day.dateTimeRange.end.toJSDate(),
+      addOns: addOns,
+      packages: [],
+      fees: day.fees as ServiceBookingFeeExt[],
+      priceBreakdown: priceBreakdown,
+      totalBeforeTaxesCents: day.totalBeforeTaxesCents,
+    } as Partial<ServiceBookingDayExt>;
+  });
+}
+
+export function serviceGetPriceToBookFromBooking(
+  service: ServiceExt,
+  booking: ServiceBookingExt
+): FrontendServiceGetPriceToBookResult {
+  const daysToBook = booking.bookedDays
+    .map((day) => {
+      const priceBreakdown = day.priceBreakdown.map(
+        (pb): ServiceBookingPriceBreakdownBaseT => ({
+          ...pb,
+          dateTimeRange: dateTimeRangeFromDates(
+            pb.startDate,
+            pb.endDate,
+            "UTC",
+            booking.timezone
+          ),
+        })
+      );
+
+      return {
+        dateTimeRange: dateTimeRangeFromDates(
+          day.startDate,
+          day.endDate,
+          "UTC",
+          booking.timezone
+        ),
+        addOns: day.addOns,
+        priceBreakdown: priceBreakdown,
+        fees: day.fees,
+        totalBeforeTaxesCents: day.totalBeforeTaxesCents,
+        timezone: booking.timezone,
+      } as FrontendServiceBookingDayInfo;
+    })
+    .sort(
+      (lhs, rhs) =>
+        lhs.dateTimeRange.start.toMillis() - rhs.dateTimeRange.start.toMillis()
+    );
+
+  return {
+    serviceId: service.id,
+    daysToBook: daysToBook,
+    selectedAttendeeOption: serviceAttendeeOptions[0],
+    additionalFees: booking.additionalFees,
+    timezone: booking.timezone,
+    daysTotalBeforeTaxesCents: booking.daysTotalATBCents,
+    totalBeforeTaxesCents: booking.totalATBCents,
+  } as FrontendServiceGetPriceToBookResult;
+}
+
+export function serviceBookingParamsToLuxon(
+  params: ApiServiceBookingParams
+): ApiBookingParamsLuxon {
+  const bookedDays = params.bookedDays.reduce(
+    (sofar, day): ApiServiceBookedDayParamsLuxon[] => {
+      sofar.push({
+        ...day,
+        dateTimeRange: {
+          start: dateTimeFromString(day.startDate),
+          end: dateTimeFromString(day.endDate),
+        },
+      });
+
+      return sofar;
+    },
+    [] as ApiServiceBookedDayParamsLuxon[]
+  );
+
+  return {
+    ...params,
+    bookedDays,
+  };
+}
+
+export function servicePriceToBookToApiDays(
+  serviceId: string,
+  userId: string,
+  priceToBook: FrontendServiceGetPriceToBookResult
+): ApiServiceBookedDayParams[] {
+  const bookedDays: ApiServiceBookedDayParams[] =
+    priceToBook.daysToBook
+      .map((day): ApiServiceBookedDayParams | null => {
+        const addOns: ApiServiceAddonParams[] = day.addOns.map(
+          (addOn): ApiServiceAddonParams => ({
+            addonId: addOn.addOnId,
+            chosenQuantity: addOn.chosenQuantity,
+          })
+        );
+        const startDate = day.dateTimeRange.start.toISO();
+        const endDate = day.dateTimeRange.end.toISO();
+
+        if (!startDate || !endDate) {
+          console.log(`Invalid startDate/endDate: ${startDate}/${endDate}`);
+          return null;
+        }
+
+        return {
+          serviceId: serviceId,
+          forUserId: userId,
+          startDate,
+          endDate,
+          addOns,
+          allowPromiseToPay: false,
+          isFreeGuest: false,
+        };
+      })
+      .filter(
+        (dayParams): dayParams is ApiServiceBookedDayParams =>
+          dayParams !== null
+      ) ?? [];
+
+  return bookedDays;
+}

package/src/utils/service/frontendServiceBookingUtils.ts

@@ -0,0 +1,310 @@
+import {
+  ServiceAddon,
+  ServiceBookingFee,
+  ServiceBookingFeeType,
+} from "@prisma/client";
+import {
+  ServiceBookingAddOnExt,
+  ServiceBookingDayExt,
+  ServiceBookingFeeExt,
+  ServiceBookingPriceBreakdownExt,
+  ServiceDailyRatesExt,
+  ServiceRatesAssociationExt,
+  ServiceSpecialRatesExt,
+} from "../../extendedSchemas";
+import { ServiceAttendeeOption } from "./attendeeOptionUtils";
+import {
+  getServiceRatePricingInfo,
+  SERVICE_DAILY_RATE_HOURS_MIN,
+  serviceGetFilteredRates,
+  serviceRatesFilter,
+  serviceRatesHasRates,
+  ServiceRatesLuxon,
+} from "./serviceRateUtils";
+import {
+  dateTimeDiffHours,
+  dateTimeRangeHours,
+  LuxonDateRange,
+} from "../luxonUtils";
+import {
+  ServiceBookingFeeBase,
+  ServiceBookingPriceBreakdownBaseT,
+  ServiceBookingAddOnBase,
+} from "./serviceBookingTypes";
+import { convertDollarsToCents } from "../paymentUtils";
+
+export const SERVICE_BOOKING_PROCESSING_FEE_PERCENT = 0.15;
+
+export interface ServiceAddonInput extends ServiceAddon {
+  chosenQuantity?: number;
+}
+
+export interface FrontendServiceBookingDayInfoParams {
+  dateTimeRange: LuxonDateRange;
+  fees: ServiceBookingFeeBase[];
+  addOns: ServiceAddonInput[];
+}
+
+export interface FrontendServiceBookingDayInfo {
+  priceBreakdown: ServiceBookingPriceBreakdownBaseT[];
+  addOns: ServiceBookingAddOnBase[];
+  fees: ServiceBookingFeeBase[];
+  // discounts: ServiceRatePricingInfo[];
+
+  dateTimeRange: LuxonDateRange;
+  timezone: string;
+
+  totalBeforeTaxesCents: number;
+}
+
+export interface FrontendServiceGetPriceToBookResult {
+  serviceId: string;
+
+  daysToBook: FrontendServiceBookingDayInfo[];
+  additionalFees: ServiceBookingFeeBase[];
+
+  daysTotalBeforeTaxesCents: number;
+  totalBeforeTaxesCents: number;
+
+  minimumTimeBlockHours?: number; //only valid on generalRate
+}
+
+export interface FrontendServiceGetBookingDayInfoFrontParams {
+  filteredRates: ServiceRatesLuxon;
+  // overlappingBusinessHours: LuxonDateRange[] | null;
+
+  timezone: string | null | undefined;
+  daysToBookParams: FrontendServiceBookingDayInfoParams[];
+}
+
+export function frontendServiceGetBookingDayInfo({
+  filteredRates,
+  daysToBookParams,
+  // overlappingBusinessHours,
+  timezone,
+}: FrontendServiceGetBookingDayInfoFrontParams): FrontendServiceBookingDayInfo[] {
+  const bookingDayResults: FrontendServiceBookingDayInfo[] =
+    daysToBookParams.map((day) => {
+      const rates = serviceRatesFilter(filteredRates, [day.dateTimeRange]);
+      const { generalRate, specialRates, dailyRates } = rates;
+
+      let priceBreakdown: ServiceBookingPriceBreakdownBaseT[] = [];
+      const durationHours = dateTimeDiffHours(
+        day.dateTimeRange.start,
+        day.dateTimeRange.end
+      );
+      // console.log(
+      //   `serviceGetBookingDayInfo: durationHours: ${JSON.stringify(
+      //     durationHours
+      //   )}, dtRange: ${JSON.stringify(day.dateTimeRange)}`
+      // );
+      let hoursRemaining = durationHours;
+      let currentRange = { ...day.dateTimeRange };
+      let baseCostDiscountedCents = 0;
+      while (serviceRatesHasRates(rates) && hoursRemaining > 0) {
+        const pricingInfo = getServiceRatePricingInfo(
+          currentRange,
+          generalRate,
+          dailyRates,
+          specialRates,
+          // overlappingBusinessHours,
+          timezone,
+          hoursRemaining
+        );
+
+        if (pricingInfo.hours == 0 || pricingInfo.unitCount == 0) {
+          throw new Error(`Invalid pricingInfo`);
+        }
+
+        priceBreakdown.push(pricingInfo);
+
+        // currentRange.start = currentRange.start.plus({
+        //   hours: pricingInfo.hours,
+        // });
+        currentRange.start = pricingInfo.dateTimeRange.end;
+        hoursRemaining -= pricingInfo.hours;
+        baseCostDiscountedCents += pricingInfo.piTotalCents;
+
+        if (pricingInfo.hours < SERVICE_DAILY_RATE_HOURS_MIN) {
+          if (pricingInfo.rateType == "Special") {
+            specialRates.pop();
+          } else if (pricingInfo.rateType == "Weekday") {
+            dailyRates.pop();
+          }
+        }
+      }
+
+      const addOns = day.addOns.map((addOn): ServiceBookingAddOnBase => {
+        return {
+          addOn: addOn,
+          addOnId: addOn.id,
+          chosenQuantity: addOn.chosenQuantity ?? 0,
+          costPQCents: addOn.priceCents,
+        };
+      });
+
+      const feesTotalCents = day.fees.reduce(
+        (sofar, fee) => sofar + fee.costPQCents * fee.quantity,
+        0
+      );
+
+      const addOnsTotalCents = addOns.reduce(
+        (sofar, addOn) => sofar + addOn.costPQCents * addOn.chosenQuantity,
+        0
+      );
+
+      const totalBeforeTaxesCents =
+        baseCostDiscountedCents + addOnsTotalCents + feesTotalCents;
+
+      return {
+        priceBreakdown: priceBreakdown,
+        dateTimeRange: day.dateTimeRange,
+        timezone: day.dateTimeRange.start.zoneName,
+        fees: day.fees,
+        addOns: addOns,
+        totalBeforeTaxesCents: totalBeforeTaxesCents,
+      } as FrontendServiceBookingDayInfo;
+    });
+
+  return bookingDayResults;
+}
+
+export interface FrontendServiceGetPriceToBookFeesParams {
+  daysToBookParams: FrontendServiceBookingDayInfoParams[];
+  selectedAttendeeOption: ServiceAttendeeOption;
+
+  additionalFees: ServiceBookingFeeBase[];
+
+  // overlappingBusinessHours: LuxonDateRange[] | null;
+  timezone: string | null | undefined;
+}
+
+export function frontendServiceGetPriceToBookFees(
+  serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
+  {
+    daysToBookParams,
+    selectedAttendeeOption,
+    additionalFees,
+    // overlappingBusinessHours,
+    timezone,
+  }: FrontendServiceGetPriceToBookFeesParams
+): FrontendServiceGetPriceToBookResult {
+  const bookingDateTimeRanges = daysToBookParams.map(
+    (daysToBookParams) => daysToBookParams.dateTimeRange
+  );
+  const filteredRates = serviceGetFilteredRates(
+    serviceRatesAssociation,
+    bookingDateTimeRanges,
+    timezone
+  );
+
+  const bookingDayResults: FrontendServiceBookingDayInfo[] =
+    frontendServiceGetBookingDayInfo({
+      filteredRates: filteredRates,
+      daysToBookParams: daysToBookParams,
+      // overlappingBusinessHours: overlappingBusinessHours,
+      timezone: timezone,
+    });
+
+  const daysTotalBeforeTaxesCents = bookingDayResults.reduce((sofar, curr) => {
+    return sofar + curr.totalBeforeTaxesCents;
+  }, 0);
+
+  const minimumTimeBlockHours =
+    serviceRatesAssociation?.serviceGeneralRates?.minimumTimeBlockHours;
+
+  // const attendeeRate = selectedAttendeeOption.rate * durationHours;
+
+  const processingFeeCents =
+    SERVICE_BOOKING_PROCESSING_FEE_PERCENT * daysTotalBeforeTaxesCents;
+
+  const hasCustomProcessingFee = additionalFees.some(
+    (fee) => fee.feeType == ServiceBookingFeeType.ProcessingFee
+  );
+
+  let allAdditionalFees = [...additionalFees];
+
+  if (!hasCustomProcessingFee) {
+    allAdditionalFees.push({
+      feeType: ServiceBookingFeeType.ProcessingFee,
+      name: "Processing Fee",
+      description: "Processing Fee",
+      costPQCents: processingFeeCents,
+      quantity: 1,
+    });
+  }
+
+  allAdditionalFees = allAdditionalFees.filter((fee) => fee.costPQCents > 0);
+
+  const allAdditionalFeesCents = allAdditionalFees.reduce(
+    (sofar, fee) => sofar + fee.costPQCents * fee.quantity,
+    0
+  );
+
+  const totalBeforeTaxesCents =
+    daysTotalBeforeTaxesCents + allAdditionalFeesCents;
+
+  return {
+    serviceId: serviceRatesAssociation?.serviceId,
+    daysToBook: bookingDayResults,
+    daysTotalBeforeTaxesCents: daysTotalBeforeTaxesCents,
+    totalBeforeTaxesCents: totalBeforeTaxesCents,
+    additionalFees: allAdditionalFees,
+    minimumTimeBlockHours: minimumTimeBlockHours,
+  } as FrontendServiceGetPriceToBookResult;
+}
+
+export interface FrontendServiceGetPriceToBookParams {
+  addOns: ServiceAddonInput[];
+
+  selectedAttendeeOption: ServiceAttendeeOption;
+
+  bookingDateTimeRanges: LuxonDateRange[];
+
+  // overlappingBusinessHours: LuxonDateRange[] | null;
+  timezone: string | null | undefined;
+}
+
+export function frontendServiceGetPriceToBook(
+  serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
+  {
+    addOns,
+    selectedAttendeeOption,
+    bookingDateTimeRanges, //list of dateTime ranges to book
+    // overlappingBusinessHours,
+    timezone,
+  }: FrontendServiceGetPriceToBookParams
+): FrontendServiceGetPriceToBookResult {
+  const cleaningFeePerBookingCents =
+    serviceRatesAssociation?.serviceGeneralRates?.cleaningFeePerBookingCents ??
+    0;
+
+  const feesPerBooking = (
+    [
+      {
+        feeType: ServiceBookingFeeType.CleaningFee,
+        name: "Cleaning Fee",
+        description: "Cleaning Fee",
+        costPQCents: cleaningFeePerBookingCents,
+        quantity: 1,
+      },
+    ] as ServiceBookingFeeBase[]
+  ).filter((fee) => fee.costPQCents > 0);
+
+  const daysToBookParams = bookingDateTimeRanges.map(
+    (dtRange): FrontendServiceBookingDayInfoParams => {
+      return {
+        dateTimeRange: dtRange,
+        fees: feesPerBooking,
+        addOns: addOns,
+      };
+    }
+  );
+
+  return frontendServiceGetPriceToBookFees(serviceRatesAssociation, {
+    daysToBookParams: daysToBookParams,
+    selectedAttendeeOption: selectedAttendeeOption,
+    additionalFees: [],
+    timezone: timezone,
+  });
+}