@bash-app/bash-common 29.66.0 → 29.68.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/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,116 @@
+import {
+  ServiceBookingApiParamsLuxon,
+  ServiceBookingApiParams,
+  ServiceBookedDayApiParamsLuxon,
+} from "../../definitions";
+import { ServiceAddonExt } from "../../extendedSchemas";
+import { dateTimeFromString } from "../luxonUtils";
+import { ServiceAttendeeOption } from "./attendeeOptionUtils";
+import {
+  ServiceGetPriceToBookFeesParams,
+  ServiceBookingDayInfoParams,
+  ServiceBookingFee,
+} 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 serviceBookingParamsToPriceToBookParams(
+  params: ServiceBookingApiParamsLuxon,
+  serviceAddons: ServiceAddonExt[]
+): ServiceGetPriceToBookFeesParams {
+  // Create a HashMap (Map) for faster lookup by addonId
+  const addonMap = new Map<string, ServiceAddonExt>(
+    serviceAddons.map((addon) => [addon.id, addon])
+  );
+
+  // Map the addOns from the params to the format expected by ServiceGetPriceToBookFeesParams
+  const daysToBookParams: ServiceBookingDayInfoParams[] = params.bookedDays.map(
+    (day) => {
+      // Map over each day's addOns and match with the addonMap to get additional data
+      const addOnsWithDetails = day.addOns.map((addonInput) => {
+        const matchedAddon = addonMap.get(addonInput.addonId);
+
+        if (!matchedAddon) {
+          throw new Error(
+            `Failed to match addon with id: ${addonInput.addonId}`
+          );
+        }
+
+        return {
+          ...matchedAddon,
+          addonId: addonInput.addonId,
+          chosenQuantity: addonInput.chosenQuantity,
+        };
+      });
+
+      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, should be determined based on 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/serviceBookingUtils.ts

@@ -0,0 +1,321 @@
+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 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[];
+}
+
+export interface ServiceBookingDayInfo {
+  priceBreakdown: ServiceRatePricingInfo[];
+  discounts: ServiceRatePricingInfo[];
+
+  dateTimeRange: LuxonDateRange;
+
+  baseCostUndiscounted: number; //rate purely based on generalHourly
+  baseCostDiscounted: number;
+  baseCostDiscount: number;
+
+  fees: ServiceBookingFee[];
+  totalBeforeTaxes: number;
+}
+
+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,
+        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 processingFee = 53.08;
+  const additionalFees = (
+    [
+      {
+        name: "Processing Fee",
+        type: "processingFee",
+        fee: processingFee,
+      },
+    ] as ServiceBookingFee[]
+  ).filter((fee) => fee.fee > 0);
+
+  const bookingDayResults: ServiceBookingDayInfo[] = serviceGetBookingDayInfo({
+    filteredRates: filteredRates,
+    daysToBookParams: daysToBookParams,
+    // overlappingBusinessHours: overlappingBusinessHours,
+    timezone: timezone,
+  });
+
+  const durationHours = bookingDateTimeRanges.reduce((sofar, curr) => {
+    return sofar + dateTimeRangeHours(curr);
+  }, 0);
+  const baseCostDiscounted = bookingDayResults.reduce((sofar, curr) => {
+    return sofar + curr.baseCostDiscounted;
+  }, 0);
+  const baseHourlyRate =
+    serviceRatesAssociation?.serviceGeneralRates?.hourlyRate ?? 0;
+
+  const baseCostUndiscounted = baseHourlyRate * durationHours;
+  const baseCostDiscount =
+    baseCostUndiscounted == 0
+      ? 0
+      : 1 - baseCostDiscounted / baseCostUndiscounted;
+
+  const minimumTimeBlockHours =
+    serviceRatesAssociation?.serviceGeneralRates?.minimumTimeBlockHours;
+
+  const attendeeRate = selectedAttendeeOption.rate * durationHours;
+
+  const totalBeforeTaxes =
+    baseCostDiscounted +
+    additionalFees.reduce((sofar, fee) => sofar + fee.fee, 0);
+
+  return {
+    serviceId: serviceRatesAssociation?.serviceId,
+    daysToBook: bookingDayResults,
+    baseCostUndiscounted: baseCostUndiscounted,
+    baseCostDiscounted: baseCostDiscounted,
+    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,
+      };
+    }
+  );
+
+  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;
+}