@bash-app/bash-common 29.67.0 → 29.68.0

package/src/utils/service/serviceRateUtils.ts

@@ -0,0 +1,350 @@
+import { ServiceRate, ServiceRateType } from "@prisma/client";
+import {
+  ServiceDailyRatesExt,
+  ServiceRateExt,
+  ServiceRatesAssociationExt,
+  ServiceSpecialRatesExt,
+} from "../../extendedSchemas";
+import {
+  LuxonDateRange,
+  dateTimeFromDate,
+  dateRangeWithinDateRange,
+  dateRangeDurationMatch,
+  dateTimeRangeToInterval,
+  dateRangeNormalizeToMWY,
+  dateTimeRangeIntersection,
+  dateTimeRangeHours,
+} from "../luxonUtils";
+import { DateTime } from "luxon";
+
+export const SERVICE_DAILY_RATE_HOURS_MIN = 8;
+
+export type ServiceRatePricingType = "Hourly" | "Daily";
+
+export type ServiceDailyRatesExtLuxon = Exclude<
+  ServiceDailyRatesExt,
+  "startDate" | "endDate"
+> & {
+  dateTimeRange: LuxonDateRange;
+};
+
+export type ServiceSpecialRatesExtLuxon = Exclude<
+  ServiceSpecialRatesExt,
+  "startDate" | "endDate"
+> & {
+  dateTimeRange: LuxonDateRange;
+};
+
+export function serviceRateToLuxonRate(
+  rate: ServiceDailyRatesExt | ServiceSpecialRatesExt,
+  timezone: string | undefined | null
+): ServiceDailyRatesExtLuxon | ServiceSpecialRatesExtLuxon {
+  const { startDate, endDate, ...rest } = rate;
+
+  return {
+    ...rest,
+    dateTimeRange: {
+      start: dateTimeFromDate(startDate, undefined, timezone ?? undefined),
+      end: dateTimeFromDate(endDate, undefined, timezone ?? undefined),
+    },
+  } as ServiceDailyRatesExtLuxon | ServiceSpecialRatesExtLuxon;
+}
+
+export const ServiceRatePricingType = {
+  Hourly: "Hourly" as ServiceRatePricingType,
+  Daily: "Daily" as ServiceRatePricingType,
+} as const;
+
+export interface ServiceRatePricingInfo {
+  rateType: ServiceRateType;
+  pricingType: ServiceRatePricingType;
+
+  dateTimeRange: LuxonDateRange;
+
+  hours: number; //number of hours removed from total
+  unitCount: number; // number of days (8 hour blocks)/hours used unitCount * rate = piTotal
+  rate: number;
+  piTotal: number;
+
+  // cleaningFee: number; //only aplicable to generalRate,
+  // minimumTimeBlockHours: number; //only aplicable to generalRate
+}
+
+export function serviceRatePricingInfoGetTypeText(
+  pricingInfo: ServiceRatePricingInfo
+) {
+  return `${pricingInfo.rateType} ${pricingInfo.pricingType}`;
+}
+
+export function serviceRatesToPricingInfo(
+  dateTimeRange: LuxonDateRange,
+  serviceRates: (ServiceRate | null | undefined)[],
+  isFullDay: boolean,
+  hoursRemaining: number
+): ServiceRatePricingInfo {
+  let pricingInfo: ServiceRatePricingInfo = {
+    rateType: "General",
+    pricingType: "Hourly",
+    hours: 0,
+    piTotal: 0,
+    rate: 0,
+    unitCount: 0,
+    dateTimeRange: dateTimeRange,
+    // cleaningFee: 0,
+    // minimumTimeBlockHours: 0,
+  };
+
+  // Find the first serviceRate where dailyRate or hourlyRate is not null based on isFullDay
+  const validServiceRate = serviceRates.find(
+    (rate) =>
+      rate != null &&
+      ((isFullDay && rate.dailyRate != null) ||
+        (!isFullDay && rate.hourlyRate != null))
+  );
+
+  if (isFullDay && !validServiceRate) {
+    return serviceRatesToPricingInfo(
+      //default to non-daily rate if it is null
+      dateTimeRange,
+      serviceRates,
+      false,
+      hoursRemaining
+    );
+  }
+
+  if (!validServiceRate) {
+    return pricingInfo; // Return default if no valid serviceRate is found
+  }
+
+  // Set values based on the found serviceRate
+  // pricingInfo.cleaningFee = validServiceRate.cleaningFeePerBooking ?? 0;
+  // pricingInfo.minimumTimeBlockHours =
+  //   validServiceRate.minimumTimeBlockHours ?? 0;
+  pricingInfo.rateType = validServiceRate.rateType ?? ServiceRateType.General;
+
+  if (isFullDay) {
+    pricingInfo.pricingType = ServiceRatePricingType.Daily;
+    const days = Math.floor(hoursRemaining / SERVICE_DAILY_RATE_HOURS_MIN);
+    pricingInfo.unitCount = days;
+    pricingInfo.hours = pricingInfo.unitCount * SERVICE_DAILY_RATE_HOURS_MIN;
+    pricingInfo.rate = validServiceRate.dailyRate ?? 0;
+  } else {
+    pricingInfo.pricingType = ServiceRatePricingType.Hourly;
+    pricingInfo.unitCount = hoursRemaining;
+    pricingInfo.hours = pricingInfo.unitCount;
+    pricingInfo.rate = validServiceRate.hourlyRate ?? 0;
+  }
+
+  pricingInfo.piTotal = pricingInfo.unitCount * pricingInfo.rate;
+
+  pricingInfo.dateTimeRange = {
+    start: dateTimeRange.start,
+    end: dateTimeRange.start.plus({ hours: pricingInfo.hours }),
+  };
+
+  return pricingInfo;
+}
+
+export function getServiceRatePricingInfo(
+  dateTimeRange: LuxonDateRange,
+  generalRate: ServiceRate | null | undefined,
+  dailyRates: ServiceDailyRatesExtLuxon[], //filtered to remove unavailable dates
+  specialRates: ServiceSpecialRatesExtLuxon[], //filtered to remove unavailable dates
+  // overlappingBusinessHours: LuxonDateRange[] | null,
+  timezone: string | null | undefined,
+  hoursRemaining: number
+): ServiceRatePricingInfo {
+  const specialRate = specialRates?.at(-1); //last element
+  const dailyRate = dailyRates?.at(-1); //last element
+  // const specialRate = findRateByDate(specialRates, dateTimeRange, timezone) as
+  //   | ServiceSpecialRatesExt
+  //   | undefined;
+  // const dailyRate = findRateByDate(dailyRates, dateTimeRange, timezone) as
+  //   | ServiceDailyRatesExt
+  //   | undefined;
+
+  // const isFullDay =
+  //   dateTimeRange != null &&
+  //   overlappingBusinessHours != null &&
+  //   overlappingBusinessHours.length == 1
+  //     ? dateRangeDurationMatch(dateTimeRange, overlappingBusinessHours[0])
+  //     : false;
+
+  // const isFullDay =
+  //   dateTimeRangeHours(dateTimeRange) >= SERVICE_DAILY_RATE_HOURS_MIN;
+  const isFullDay = hoursRemaining >= SERVICE_DAILY_RATE_HOURS_MIN;
+
+  //prefer specialRate over daily, and aily over general, etc...
+  const rates = [
+    specialRate?.serviceRate,
+    dailyRate?.serviceRate,
+    generalRate,
+  ].filter((rate) => !!rate);
+
+  return serviceRatesToPricingInfo(
+    dateTimeRange,
+    rates,
+    isFullDay,
+    hoursRemaining
+  );
+}
+
+export interface ServiceRatesLuxon {
+  generalRate: ServiceRate | null | undefined;
+  specialRates: ServiceSpecialRatesExtLuxon[];
+  dailyRates: ServiceDailyRatesExtLuxon[];
+}
+
+export function serviceGetFilteredRates(
+  serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
+  dateTimeRanges: LuxonDateRange[],
+  timezone: string | null | undefined
+): ServiceRatesLuxon {
+  return serviceRatesFilter(
+    serviceRatesToLuxonRates(serviceRatesAssociation, dateTimeRanges, timezone),
+    dateTimeRanges
+  );
+}
+
+export function serviceRatesFilter(
+  rates: ServiceRatesLuxon,
+  dateTimeRanges: LuxonDateRange[]
+): ServiceRatesLuxon {
+  const generalRate = rates.generalRate;
+
+  const intersectsWithAnyRange = (rateRange: LuxonDateRange) =>
+    dateTimeRanges.some(
+      (range) => dateTimeRangeIntersection(rateRange, range) != null
+    );
+
+  const specialRatesLuxon =
+    rates.specialRates
+      .filter(
+        (rate) => rate.isAvailable && intersectsWithAnyRange(rate.dateTimeRange)
+      )
+      .sort(
+        (a, b) =>
+          b.dateTimeRange.start.toMillis() - a.dateTimeRange.start.toMillis()
+      ) ?? [];
+
+  const dailyRatesLuxon =
+    rates.dailyRates
+      .filter((rate) => intersectsWithAnyRange(rate.dateTimeRange))
+      .sort(
+        (a, b) =>
+          b.dateTimeRange.start.toMillis() - a.dateTimeRange.start.toMillis()
+      ) ?? [];
+
+  return {
+    generalRate: generalRate,
+    specialRates: specialRatesLuxon,
+    dailyRates: dailyRatesLuxon,
+  };
+}
+
+export function serviceRatesHasRates(rates: ServiceRatesLuxon) {
+  const { generalRate, specialRates, dailyRates } = rates;
+
+  const isValidSpecialOrDailyRate = (
+    rate: ServiceSpecialRatesExt | ServiceDailyRatesExt
+  ) =>
+    rate?.serviceRate &&
+    ((rate.serviceRate?.dailyRate ?? 0) > 0 ||
+      (rate.serviceRate?.hourlyRate ?? 0) > 0);
+
+  const isValidGeneralRate = (rate: ServiceRate | undefined | null) =>
+    rate && ((rate.dailyRate ?? 0) > 0 || (rate.hourlyRate ?? 0) > 0);
+
+  const hasValidSpecialOrDailyRate = [...specialRates, ...dailyRates].some(
+    isValidSpecialOrDailyRate
+  );
+  const hasValidGeneralRate = isValidGeneralRate(generalRate);
+
+  const hasRates = hasValidSpecialOrDailyRate || hasValidGeneralRate;
+  return hasRates;
+}
+
+export function serviceRatesToLuxonRates(
+  serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
+  dateTimeRanges: LuxonDateRange[],
+  timezone: string | null | undefined
+): ServiceRatesLuxon {
+  const generalRate = serviceRatesAssociation?.serviceGeneralRates;
+
+  const specialRatesLuxon =
+    serviceRatesAssociation?.serviceSpecialRates
+      ?.filter((specialRate) => specialRate.isAvailable)
+      ?.map(
+        (rate) =>
+          serviceRateToLuxonRate(rate, timezone) as ServiceSpecialRatesExtLuxon
+      ) ?? [];
+
+  const dailyRatesLuxon =
+    serviceRatesAssociation?.serviceDailyRates?.map((rate) => {
+      const newRate = serviceRateToLuxonRate(
+        rate,
+        timezone
+      ) as ServiceDailyRatesExtLuxon;
+
+      dateTimeRanges.forEach((range) => {
+        newRate.dateTimeRange = dateRangeNormalizeToMWY(
+          newRate.dateTimeRange,
+          range
+        );
+      });
+
+      return newRate;
+    }) ?? [];
+
+  return {
+    generalRate: generalRate,
+    specialRates: specialRatesLuxon,
+    dailyRates: dailyRatesLuxon,
+  };
+}
+
+export function serviceRatesAssociationGetBlockedDates(
+  serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
+  timezone: string | undefined | null
+) {
+  return (
+    serviceRatesAssociation?.serviceSpecialRates
+      ?.filter((rate) => !rate.isAvailable)
+      .map((rate) => {
+        const rateRange = {
+          start: dateTimeFromDate(
+            rate.startDate,
+            undefined,
+            timezone ?? undefined
+          ),
+          end: dateTimeFromDate(rate.endDate, undefined, timezone ?? undefined),
+        } as LuxonDateRange;
+
+        return rateRange;
+        // return dateRangeNormalizeToMWY(rateRange, referenceRange);
+      }) ?? []
+  );
+}
+
+export function serviceRatesAssociationGetSpecialRates(
+  serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
+  timezone: string | undefined | null
+) {
+  return (
+    serviceRatesAssociation?.serviceSpecialRates
+      ?.filter((rate) => rate.isAvailable)
+      .map((rate) => {
+        const rateRange = {
+          start: dateTimeFromDate(
+            rate.startDate,
+            undefined,
+            timezone ?? undefined
+          ),
+          end: dateTimeFromDate(rate.endDate, undefined, timezone ?? undefined),
+        } as LuxonDateRange;
+
+        return rateRange;
+        // return dateRangeNormalizeToMWY(rateRange, referenceRange);
+      }) ?? []
+  );
+}

package/src/utils/service/serviceUtils.ts

@@ -1,7 +1,9 @@
 import {
   ServiceCancelationPolicy as ServiceCancelationPolicyOption,
   ServiceSubscriptionStatus,
+  ServiceTypes,
 } from "@prisma/client";
+import { ServiceExt } from "../../extendedSchemas";
 
 export type ServiceCancelationRefundPolicy = {
   days?: number;
@@ -148,3 +150,36 @@ export function serviceCheckoutUrl(
 ) {
   return `/checkout/services/${serviceId}/${serviceType}/${specificId}`;
 }
+
+// Define the keys and values in a single object
+const serviceKeysObject = {
+  eventService: true,
+  entertainmentService: true,
+  vendor: true,
+  exhibitor: true,
+  sponsor: true,
+  venue: true,
+  organization: true,
+} as const;
+
+export type ServiceSpecificName = keyof typeof serviceKeysObject;
+
+export const serviceKeysArray = Object.keys(serviceKeysObject);
+
+export type ServiceSpecificType = ServiceExt[ServiceSpecificName];
+
+export const specificServiceMap: Record<ServiceTypes, ServiceSpecificName> = {
+  EventServices: "eventService",
+  EntertainmentServices: "entertainmentService",
+  Vendors: "vendor",
+  Exhibitors: "exhibitor",
+  Sponsors: "sponsor",
+  Venues: "venue",
+  Organizations: "organization",
+} as const;
+
+export const serviceTypeToField = (
+  serviceType: ServiceTypes
+): ServiceSpecificName => {
+  return specificServiceMap[serviceType];
+};

package/src/utils/typeUtils.ts

@@ -1 +1,17 @@
 export type ValueOf<T> = T[keyof T];
+export type UnionFromArray<T extends ReadonlyArray<any>> = T[number];
+export type RemoveCommonProperties<T, U> = keyof (Omit<T, keyof U> &
+  Omit<U, keyof T>);
+
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> &
+  Partial<Pick<T, K>>;
+
+// Create the final object dynamically
+export function createAllTrueObject<T extends string>(
+  keys: T[]
+): Record<T, true> {
+  return keys.reduce((acc, key) => {
+    acc[key] = true;
+    return acc;
+  }, {} as Record<T, true>);
+}

package/tsconfig.json

@@ -12,8 +12,8 @@
     "forceConsistentCasingInFileNames": true,
     "jsx": "react-jsx",
     "noImplicitAny": true,
-    "sourceMap": true,
+    "sourceMap": true
   },
-  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/types/**/*.d.ts"],
   "exclude": ["node_modules"]
 }