@bash-app/bash-common 29.67.0 → 29.69.0

package/src/utils/service/serviceBookingUtils.ts

@@ -0,0 +1,391 @@
+import { ServiceAddon } from "@prisma/client";
+import { ServiceRatesAssociationExt } from "../../extendedSchemas";
+import { ServiceAttendeeOption } from "./attendeeOptionUtils";
+import {
+  getServiceRatePricingInfo,
+  serviceGetFilteredRates,
+  ServiceRatePricingInfo,
+  serviceRatesFilter,
+  serviceRatesHasRates,
+  ServiceRatesLuxon,
+} from "./serviceRateUtils";
+import {
+  dateTimeDiffHours,
+  dateTimeRangeHours,
+  LuxonDateRange,
+} from "../luxonUtils";
+
+export const SERVICE_BOOKING_PROCESSING_FEE_PERCENT = 0.15;
+
+export interface ServiceAddonInput extends ServiceAddon {
+  chosenQuantity?: number;
+}
+
+export type ServiceBookingFeeType =
+  | "addOnFees"
+  | "cleaningFee"
+  | "processingFee";
+
+export const ServiceBookingFeeType = {
+  addonFees: "addOnFees",
+  cleaningFee: "cleaningFee",
+  processingFee: "processingFee",
+} as const;
+
+export interface ServiceBookingFee {
+  name: string;
+  type: ServiceBookingFeeType;
+  fee: number;
+}
+
+export interface ServiceBookingDayInfoParams {
+  dateTimeRange: LuxonDateRange;
+  fees: ServiceBookingFee[];
+  addOns: ServiceAddonInput[];
+}
+
+export interface ServiceBookingDayInfo {
+  priceBreakdown: ServiceRatePricingInfo[];
+  discounts: ServiceRatePricingInfo[];
+
+  dateTimeRange: LuxonDateRange;
+
+  baseCostUndiscounted: number; //rate purely based on generalHourly
+  baseCostDiscounted: number;
+  baseCostDiscount: number;
+
+  fees: ServiceBookingFee[];
+  totalBeforeTaxes: number;
+
+  addOns: ServiceAddonInput[];
+}
+
+export interface ServiceGetPriceToBookResult {
+  serviceId: string;
+
+  daysToBook: ServiceBookingDayInfo[];
+
+  baseCostUndiscounted: number; //rate purely based on generalHourly
+  baseCostDiscounted: number;
+  baseCostDiscount: number;
+
+  additionalFees: ServiceBookingFee[];
+  totalBeforeTaxes: number;
+
+  minimumTimeBlockHours?: number; //only valid on generalRate
+  totalDurationHours: number;
+  durationHoursPerDay: number;
+
+  baseHourlyRate: number;
+}
+
+export interface ServiceGetBookingDayInfoParams {
+  filteredRates: ServiceRatesLuxon;
+  // overlappingBusinessHours: LuxonDateRange[] | null;
+
+  timezone: string | null | undefined;
+  daysToBookParams: ServiceBookingDayInfoParams[];
+}
+
+export function serviceGetBookingDayInfo({
+  filteredRates,
+  daysToBookParams,
+  // overlappingBusinessHours,
+  timezone,
+}: ServiceGetBookingDayInfoParams): ServiceBookingDayInfo[] {
+  const bookingDayResults: ServiceBookingDayInfo[] = daysToBookParams.map(
+    (day) => {
+      const rates = serviceRatesFilter(filteredRates, [day.dateTimeRange]);
+      const { generalRate, specialRates, dailyRates } = rates;
+
+      let priceBreakdown: ServiceRatePricingInfo[] = [];
+      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 baseCostDiscounted = 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;
+        baseCostDiscounted += pricingInfo.piTotal;
+
+        if (pricingInfo.rateType == "Special") {
+          specialRates.pop();
+        } else if (pricingInfo.rateType == "Weekday") {
+          dailyRates.pop();
+        }
+      }
+
+      const baseHourlyRate = generalRate?.hourlyRate ?? 0;
+
+      const discounts = priceBreakdown
+        .filter(
+          (pi) => !(pi.pricingType == "Hourly" && pi.rateType == "General")
+        )
+        .map((pi) => {
+          return {
+            ...pi,
+            piTotal: pi.hours * baseHourlyRate - pi.piTotal,
+          };
+        })
+        .filter((pi) => pi.piTotal > 0);
+
+      const baseCostUndiscounted = baseHourlyRate * durationHours;
+      const baseCostDiscount =
+        baseCostUndiscounted == 0
+          ? 0
+          : 1 - baseCostDiscounted / baseCostUndiscounted;
+
+      const totalBeforeTaxes =
+        baseCostDiscounted +
+        day.fees.reduce((sofar, fee) => sofar + fee.fee, 0);
+
+      return {
+        baseCostDiscount: baseCostDiscount,
+        baseCostDiscounted: baseCostDiscounted,
+        baseCostUndiscounted: baseCostUndiscounted,
+        discounts: discounts,
+        priceBreakdown: priceBreakdown,
+        dateTimeRange: day.dateTimeRange,
+        fees: day.fees,
+        addOns: day.addOns,
+        totalBeforeTaxes: totalBeforeTaxes,
+      } as ServiceBookingDayInfo;
+    }
+  );
+
+  return bookingDayResults;
+}
+
+export interface ServiceGetPriceToBookFeesParams {
+  daysToBookParams: ServiceBookingDayInfoParams[];
+
+  selectedAttendeeOption: ServiceAttendeeOption;
+
+  // overlappingBusinessHours: LuxonDateRange[] | null;
+  timezone: string | null | undefined;
+}
+
+export function serviceGetPriceToBookFees(
+  serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
+  {
+    daysToBookParams,
+    selectedAttendeeOption,
+    // overlappingBusinessHours,
+    timezone,
+  }: ServiceGetPriceToBookFeesParams
+): ServiceGetPriceToBookResult {
+  const bookingDateTimeRanges = daysToBookParams.map(
+    (daysToBookParams) => daysToBookParams.dateTimeRange
+  );
+  const filteredRates = serviceGetFilteredRates(
+    serviceRatesAssociation,
+    bookingDateTimeRanges,
+    timezone
+  );
+
+  const bookingDayResults: ServiceBookingDayInfo[] = serviceGetBookingDayInfo({
+    filteredRates: filteredRates,
+    daysToBookParams: daysToBookParams,
+    // overlappingBusinessHours: overlappingBusinessHours,
+    timezone: timezone,
+  });
+
+  const durationHours = bookingDateTimeRanges.reduce((sofar, curr) => {
+    return sofar + dateTimeRangeHours(curr);
+  }, 0);
+  const bookingsTotalBeforeTaxes = bookingDayResults.reduce((sofar, curr) => {
+    return sofar + curr.totalBeforeTaxes;
+  }, 0);
+  const baseHourlyRate =
+    serviceRatesAssociation?.serviceGeneralRates?.hourlyRate ?? 0;
+
+  const baseCostUndiscounted = baseHourlyRate * durationHours;
+  const baseCostDiscount =
+    baseCostUndiscounted == 0
+      ? 0
+      : 1 - bookingsTotalBeforeTaxes / baseCostUndiscounted;
+
+  const minimumTimeBlockHours =
+    serviceRatesAssociation?.serviceGeneralRates?.minimumTimeBlockHours;
+
+  const attendeeRate = selectedAttendeeOption.rate * durationHours;
+
+  const processingFee =
+    SERVICE_BOOKING_PROCESSING_FEE_PERCENT * bookingsTotalBeforeTaxes;
+  const additionalFees = (
+    [
+      {
+        name: "Processing Fee",
+        type: "processingFee",
+        fee: processingFee,
+      },
+    ] as ServiceBookingFee[]
+  ).filter((fee) => fee.fee > 0);
+
+  const totalBeforeTaxes =
+    bookingsTotalBeforeTaxes +
+    additionalFees.reduce((sofar, fee) => sofar + fee.fee, 0);
+
+  return {
+    serviceId: serviceRatesAssociation?.serviceId,
+    daysToBook: bookingDayResults,
+    baseCostUndiscounted: baseCostUndiscounted,
+    baseCostDiscounted: bookingsTotalBeforeTaxes,
+    baseCostDiscount: baseCostDiscount,
+    totalBeforeTaxes: totalBeforeTaxes,
+    additionalFees: additionalFees,
+    baseHourlyRate: baseHourlyRate,
+    totalDurationHours: durationHours,
+    minimumTimeBlockHours: minimumTimeBlockHours,
+    durationHoursPerDay: dateTimeRangeHours(bookingDateTimeRanges[0]),
+  } as ServiceGetPriceToBookResult;
+}
+
+export interface ServiceGetPriceToBookParams {
+  addOns: ServiceAddonInput[];
+
+  selectedAttendeeOption: ServiceAttendeeOption;
+
+  bookingDateTimeRanges: LuxonDateRange[];
+
+  // overlappingBusinessHours: LuxonDateRange[] | null;
+  timezone: string | null | undefined;
+}
+
+export function serviceGetPriceToBook(
+  serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
+  {
+    addOns,
+    selectedAttendeeOption,
+    bookingDateTimeRanges, //list of dateTime ranges to book
+    // overlappingBusinessHours,
+    timezone,
+  }: ServiceGetPriceToBookParams
+): ServiceGetPriceToBookResult {
+  const cleaningFee =
+    serviceRatesAssociation?.serviceGeneralRates?.cleaningFeePerBooking ?? 0;
+
+  const addOnTotal = addOns.reduce((sum, addOn) => {
+    return sum + (addOn.chosenQuantity || 0) * addOn.price;
+  }, 0);
+
+  const feesPerBooking = (
+    [
+      {
+        name: "AddOn Total",
+        type: "addOnFees",
+        fee: addOnTotal,
+      },
+      {
+        name: "Cleaning Fee",
+        type: "cleaningFee",
+        fee: cleaningFee,
+      },
+    ] as ServiceBookingFee[]
+  ).filter((fee) => fee.fee > 0);
+
+  const daysToBookParams = bookingDateTimeRanges.map(
+    (dtRange): ServiceBookingDayInfoParams => {
+      return {
+        dateTimeRange: dtRange,
+        fees: feesPerBooking,
+        addOns: addOns,
+      };
+    }
+  );
+
+  return serviceGetPriceToBookFees(serviceRatesAssociation, {
+    daysToBookParams: daysToBookParams,
+    selectedAttendeeOption: selectedAttendeeOption,
+    timezone: timezone,
+  });
+}
+
+export interface ServiceGetPriceToBookExtDay {
+  dateRange: LuxonDateRange;
+  addOns: ServiceAddonInput[];
+}
+
+export interface ServiceGetPriceToBookExtParams {
+  selectedAttendeeOption: ServiceAttendeeOption;
+
+  bookedDays: ServiceGetPriceToBookExtDay[];
+
+  // overlappingBusinessHours: LuxonDateRange[] | null;
+  timezone: string | null | undefined;
+}
+
+export function serviceGetPriceToBookExt(
+  serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
+  {
+    selectedAttendeeOption,
+    bookedDays, //list of dateTime ranges to book
+    // overlappingBusinessHours,
+    timezone,
+  }: ServiceGetPriceToBookExtParams
+): ServiceGetPriceToBookResult {
+  const cleaningFee =
+    serviceRatesAssociation?.serviceGeneralRates?.cleaningFeePerBooking ?? 0;
+
+  const daysToBookParams = bookedDays.map(
+    (day): ServiceBookingDayInfoParams => {
+      const addOnTotal = day.addOns.reduce((sum, addOn) => {
+        return sum + (addOn.chosenQuantity || 0) * addOn.price;
+      }, 0);
+
+      const feesPerBooking = (
+        [
+          {
+            name: "AddOn Total",
+            type: "addOnFees",
+            fee: addOnTotal,
+          },
+          {
+            name: "Cleaning Fee",
+            type: "cleaningFee",
+            fee: cleaningFee,
+          },
+        ] as ServiceBookingFee[]
+      ).filter((fee) => fee.fee > 0);
+
+      return {
+        dateTimeRange: day.dateRange,
+        fees: feesPerBooking,
+        addOns: day.addOns,
+      };
+    }
+  );
+
+  return serviceGetPriceToBookFees(serviceRatesAssociation, {
+    daysToBookParams: daysToBookParams,
+    selectedAttendeeOption: selectedAttendeeOption,
+    timezone: timezone,
+  });
+}

package/src/utils/service/serviceDBUtils.ts

@@ -0,0 +1,51 @@
+import { ServiceRate } from "@prisma/client";
+import { ServiceExt, ServiceSpecialRatesExt } from "../../extendedSchemas";
+import {
+  specialRateConvertToDb,
+  generalRatesConvertRatesToDB,
+  specialRateConvertFromDb,
+  generalRatesConvertRatesFromDB,
+} from "./serviceRateDBUtils";
+
+export function serviceToDb(service: Partial<ServiceExt>): Partial<ServiceExt> {
+  if (service.serviceRatesAssociation) {
+    service.serviceRatesAssociation.serviceSpecialRates =
+      service.serviceRatesAssociation.serviceSpecialRates?.map(
+        (
+          serviceSpecialRate: Partial<ServiceSpecialRatesExt>
+        ): ServiceSpecialRatesExt => {
+          return specialRateConvertToDb(
+            serviceSpecialRate
+          ) as ServiceSpecialRatesExt;
+        }
+      );
+    if (service.serviceRatesAssociation.serviceGeneralRates) {
+      service.serviceRatesAssociation.serviceGeneralRates =
+        generalRatesConvertRatesToDB(
+          service.serviceRatesAssociation.serviceGeneralRates
+        ) as ServiceRate;
+    }
+  }
+  return service;
+}
+
+export function serviceFromDb(service: ServiceExt): ServiceExt {
+  if (service.serviceRatesAssociation) {
+    service.serviceRatesAssociation.serviceSpecialRates =
+      service.serviceRatesAssociation.serviceSpecialRates?.map(
+        (
+          serviceSpecialRate: ServiceSpecialRatesExt
+        ): ServiceSpecialRatesExt => {
+          return specialRateConvertFromDb(serviceSpecialRate);
+        }
+      );
+    if (service.serviceRatesAssociation.serviceGeneralRates) {
+      console.log("updating general rates from db");
+      service.serviceRatesAssociation.serviceGeneralRates =
+        generalRatesConvertRatesFromDB(
+          service.serviceRatesAssociation.serviceGeneralRates
+        );
+    }
+  }
+  return service;
+}

package/src/utils/service/serviceRateDBUtils.ts

@@ -0,0 +1,179 @@
+import { ServiceRate } from "@prisma/client";
+import { ApiResult } from "../../definitions";
+import { ServiceSpecialRatesExt } from "../../extendedSchemas";
+import { convertDollarsToCents, convertCentsToDollars } from "../paymentUtils";
+
+export function specialRateConvertToDb(
+  specialRate: Partial<ServiceSpecialRatesExt>
+): Partial<ServiceSpecialRatesExt> {
+  return specialRateConvertRatesToDB(
+    specialRateConvertDateStringsToDb(structuredClone(specialRate))
+  );
+}
+
+export function specialRateConvertFromDb(
+  specialRate: ServiceSpecialRatesExt
+): ServiceSpecialRatesExt {
+  // console.log(`specialRateConvertFromDb`);
+  return specialRateConvertRatesFromDB(
+    specialRateConvertDateStringsFromDb(specialRate)
+  );
+}
+
+function specialRateConvertDateStringsToDb(
+  specialRate: Partial<ServiceSpecialRatesExt>
+): Partial<ServiceSpecialRatesExt> {
+  // const oldStart = new Date(specialRate.startDate!);
+  // const oldEnd = new Date(specialRate.endDate!);
+
+  // specialRate.startDate = dateTimeLocalToUTCDate(specialRate.startDate!);
+  // specialRate.endDate = dateTimeLocalToUTCDate(specialRate.endDate!);
+  // specialRate.startDate = normalizeDate(specialRate.startDate!);
+  // specialRate.endDate = normalizeDate(specialRate.endDate!);
+
+  // const localStart = dateTimeLocalFromUTCDate(new Date(specialRate.startDate!));
+  // const localEnd = dateTimeLocalFromUTCDate(new Date(specialRate.endDate!));
+
+  // console.log(
+  //   `specialRateConvertDateStringsToDb oldStart: ${oldStart?.toString()}`
+  // );
+  // console.log(
+  //   `specialRateConvertDateStringsToDb oldEnd: ${oldEnd?.toString()}`
+  // );
+  // console.log(
+  //   `specialRateConvertDateStringsToDb specialRate.startDate: ${specialRate.startDate?.toString()}`
+  // );
+  // console.log(
+  //   `specialRateConvertDateStringsToDb specialRate.endDate: ${specialRate.endDate?.toString()}`
+  // );
+  // console.log(
+  //   `specialRateConvertDateStringsToDb localStart: ${localStart?.toString()}`
+  // );
+  // console.log(
+  //   `specialRateConvertDateStringsToDb localEnd: ${localEnd?.toString()}`
+  // );
+
+  // const a = 3 + 4;
+
+  // specialRate.startDate = specialRate.startDate.toISOString();
+  // specialRate.endDate = specialRate.endDate.toISOString();
+  // return specialRate;
+  return specialRate;
+}
+
+function specialRateConvertDateStringsFromDb(
+  specialRate: ServiceSpecialRatesExt
+): ServiceSpecialRatesExt {
+  // specialRate.startDate = localDateToUTC(new Date(specialRate.startDate));
+  // specialRate.endDate = localDateToUTC(new Date(specialRate.endDate));
+
+  //this shouldnt even be necessary as javascript dates are always stored in UTC timezone (they lack timezone information)
+  // specialRate.startDate = ensureDateTimeIsLocalDateTime(
+  //   new Date(specialRate.startDate)
+  // ).toDate();
+  // specialRate.endDate = ensureDateTimeIsLocalDateTime(
+  //   new Date(specialRate.endDate)
+  // ).toDate();
+
+  specialRate.startDate = new Date(specialRate.startDate);
+  specialRate.endDate = new Date(specialRate.endDate);
+
+  // const oldStart = new Date(specialRate.startDate!);
+  // const oldEnd = new Date(specialRate.endDate!);
+
+  // specialRate.startDate = dateTimeLocalFromUTCDate(
+  //   new Date(specialRate.startDate)
+  // );
+  // specialRate.endDate = dateTimeLocalFromUTCDate(new Date(specialRate.endDate));
+
+  // // specialRate.startDate = ensureDateTimeIsLocalDateTime(
+  // //   new Date(specialRate.startDate)
+  // // ).toDate();
+  // // specialRate.endDate = ensureDateTimeIsLocalDateTime(
+  // //   new Date(specialRate.endDate)
+  // // ).toDate();
+
+  // // specialRate.startDate = localDateToUTC(new Date(specialRate.startDate));
+  // // specialRate.endDate = localDateToUTC(new Date(specialRate.endDate));
+
+  // const date2 = normalizeDate(specialRate.startDate)!;
+  // const date3 = normalizeDate(specialRate.endDate)!;
+
+  // const a = 3 + 4;
+  return specialRate;
+}
+
+function specialRateConvertRatesToDB(
+  specialRate: Partial<ServiceSpecialRatesExt>
+): Partial<ServiceSpecialRatesExt> {
+  if (specialRate.serviceRate) {
+    specialRate.serviceRate = generalRatesConvertRatesToDB(
+      specialRate.serviceRate
+    ) as ServiceRate;
+  }
+  return specialRate;
+}
+
+function specialRateConvertRatesFromDB(
+  specialRate: ServiceSpecialRatesExt
+): ServiceSpecialRatesExt {
+  if (specialRate.serviceRate) {
+    specialRate.serviceRate = generalRatesConvertRatesFromDB(
+      specialRate.serviceRate
+    );
+  }
+  return specialRate;
+}
+
+export function generalRatesConvertRatesToDB(
+  generalRate: ServiceRate
+): ServiceRate {
+  return generalRatesConvertRatesToDBHelper(structuredClone(generalRate));
+}
+
+export function generalRatesConvertRatesToDBHelper(
+  generalRate: ServiceRate
+): ServiceRate {
+  //   console.log(
+  //     `generalRatesConvertRatesToDBHelper A: ${JSON.stringify(generalRate)}`
+  //   );
+  if (generalRate?.dailyRate) {
+    generalRate.dailyRate = convertDollarsToCents(generalRate.dailyRate);
+  }
+  if (generalRate?.hourlyRate) {
+    generalRate.hourlyRate = convertDollarsToCents(generalRate.hourlyRate);
+  }
+  if (generalRate?.cleaningFeePerBooking) {
+    generalRate.cleaningFeePerBooking = convertDollarsToCents(
+      generalRate.cleaningFeePerBooking
+    );
+  }
+  //   console.log(
+  //     `generalRatesConvertRatesToDBHelper B: ${JSON.stringify(generalRate)}`
+  //   );
+  return generalRate;
+}
+
+export function generalRatesConvertRatesFromDB(
+  generalRate: ServiceRate
+): ServiceRate {
+  //   console.log(
+  //     `generalRatesConvertRatesFromDB A: ${JSON.stringify(generalRate)}`
+  //   );
+  // console.log(`specialRateConvertRatesFromDB`);
+  if (generalRate?.dailyRate) {
+    generalRate.dailyRate = convertCentsToDollars(generalRate.dailyRate);
+  }
+  if (generalRate?.hourlyRate) {
+    generalRate.hourlyRate = convertCentsToDollars(generalRate.hourlyRate);
+  }
+  if (generalRate?.cleaningFeePerBooking) {
+    generalRate.cleaningFeePerBooking = convertCentsToDollars(
+      generalRate.cleaningFeePerBooking
+    );
+  }
+  //   console.log(
+  //     `generalRatesConvertRatesFromDB B: ${JSON.stringify(generalRate)}`
+  //   );
+  return generalRate;
+}