refactor(bookings): delivers per-member round-robin limit overrides end-to-end

apps/web/modules/event-types/components/AddMembersWithSwitch.tsx

@@ -89,6 +89,17 @@ const CheckedHostField = ({
                   userId: parseInt(option.value, 10),
                   priority: option.priority ?? 2,
                   weight: option.weight ?? 100,
+                  overrideMinimumBookingNotice: option.overrideMinimumBookingNotice,
+                  overrideBeforeEventBuffer: option.overrideBeforeEventBuffer,
+                  overrideAfterEventBuffer: option.overrideAfterEventBuffer,
+                  overrideSlotInterval: option.overrideSlotInterval,
+                  overrideBookingLimits: option.overrideBookingLimits,
+                  overrideDurationLimits: option.overrideDurationLimits,
+                  overridePeriodType: option.overridePeriodType,
+                  overridePeriodStartDate: option.overridePeriodStartDate,
+                  overridePeriodEndDate: option.overridePeriodEndDate,
+                  overridePeriodDays: option.overridePeriodDays,
+                  overridePeriodCountCalendarDays: option.overridePeriodCountCalendarDays,
                   scheduleId: option.defaultScheduleId,
                   groupId: option.groupId,
                 }))
@@ -106,6 +117,17 @@ const CheckedHostField = ({
                 isFixed,
                 weight: host.weight ?? 100,
                 groupId: host.groupId,
+                overrideMinimumBookingNotice: host.overrideMinimumBookingNotice,
+                overrideBeforeEventBuffer: host.overrideBeforeEventBuffer,
+                overrideAfterEventBuffer: host.overrideAfterEventBuffer,
+                overrideSlotInterval: host.overrideSlotInterval,
+                overrideBookingLimits: host.overrideBookingLimits,
+                overrideDurationLimits: host.overrideDurationLimits,
+                overridePeriodType: host.overridePeriodType,
+                overridePeriodStartDate: host.overridePeriodStartDate,
+                overridePeriodEndDate: host.overridePeriodEndDate,
+                overridePeriodDays: host.overridePeriodDays,
+                overridePeriodCountCalendarDays: host.overridePeriodCountCalendarDays,
               });
 
               return acc;

apps/web/modules/event-types/components/EventType.tsx

@@ -26,6 +26,17 @@ export type Host = {
   weight: number;
   scheduleId?: number | null;
   groupId: string | null;
+  overrideMinimumBookingNotice?: number | null;
+  overrideBeforeEventBuffer?: number | null;
+  overrideAfterEventBuffer?: number | null;
+  overrideSlotInterval?: number | null;
+  overrideBookingLimits?: Record<string, number> | null;
+  overrideDurationLimits?: Record<string, number> | null;
+  overridePeriodType?: "UNLIMITED" | "ROLLING" | "ROLLING_WINDOW" | "RANGE" | null;
+  overridePeriodStartDate?: Date | null;
+  overridePeriodEndDate?: Date | null;
+  overridePeriodDays?: number | null;
+  overridePeriodCountCalendarDays?: boolean | null;
 };
 
 export type CustomInputParsed = typeof customInputSchema._output;

apps/web/modules/event-types/components/tabs/assignment/EventTeamAssignmentTab.tsx

@@ -174,9 +174,21 @@ const FixedHosts = ({
           userId: parseInt(teamMember.value, 10),
           priority: host?.priority ?? 2,
           weight: host?.weight ?? 100,
+          overrideMinimumBookingNotice: host?.overrideMinimumBookingNotice,
+          overrideBeforeEventBuffer: host?.overrideBeforeEventBuffer,
+          overrideAfterEventBuffer: host?.overrideAfterEventBuffer,
+          overrideSlotInterval: host?.overrideSlotInterval,
+          overrideBookingLimits: host?.overrideBookingLimits,
+          overrideDurationLimits: host?.overrideDurationLimits,
+          overridePeriodType: host?.overridePeriodType,
+          overridePeriodStartDate: host?.overridePeriodStartDate,
+          overridePeriodEndDate: host?.overridePeriodEndDate,
+          overridePeriodDays: host?.overridePeriodDays,
+          overridePeriodCountCalendarDays: host?.overridePeriodCountCalendarDays,
           // if host was already added, retain scheduleId and groupId
           scheduleId: host?.scheduleId || teamMember.defaultScheduleId,
           groupId: host?.groupId || null,
+          location: host?.location ?? null,
         };
       }),
       { shouldDirty: true }
@@ -400,9 +412,21 @@ const RoundRobinHosts = ({
             userId: parseInt(teamMember.value, 10),
             priority: host?.priority ?? 2,
             weight: host?.weight ?? 100,
+            overrideMinimumBookingNotice: host?.overrideMinimumBookingNotice,
+            overrideBeforeEventBuffer: host?.overrideBeforeEventBuffer,
+            overrideAfterEventBuffer: host?.overrideAfterEventBuffer,
+            overrideSlotInterval: host?.overrideSlotInterval,
+            overrideBookingLimits: host?.overrideBookingLimits,
+            overrideDurationLimits: host?.overrideDurationLimits,
+            overridePeriodType: host?.overridePeriodType,
+            overridePeriodStartDate: host?.overridePeriodStartDate,
+            overridePeriodEndDate: host?.overridePeriodEndDate,
+            overridePeriodDays: host?.overridePeriodDays,
+            overridePeriodCountCalendarDays: host?.overridePeriodCountCalendarDays,
             // if host was already added, retain scheduleId and groupId
             scheduleId: host?.scheduleId || teamMember.defaultScheduleId,
             groupId: host?.groupId || groupId,
+            location: host?.location ?? null,
           };
         }),
         { shouldDirty: true }
@@ -668,6 +692,51 @@ const Hosts = ({
             ...newValue,
             scheduleId: existingHost.scheduleId,
             groupId: existingHost.groupId,
+            location: newValue.location !== undefined ? newValue.location : existingHost.location,
+            overrideMinimumBookingNotice:
+              newValue.overrideMinimumBookingNotice !== undefined
+                ? newValue.overrideMinimumBookingNotice
+                : existingHost.overrideMinimumBookingNotice,
+            overrideBeforeEventBuffer:
+              newValue.overrideBeforeEventBuffer !== undefined
+                ? newValue.overrideBeforeEventBuffer
+                : existingHost.overrideBeforeEventBuffer,
+            overrideAfterEventBuffer:
+              newValue.overrideAfterEventBuffer !== undefined
+                ? newValue.overrideAfterEventBuffer
+                : existingHost.overrideAfterEventBuffer,
+            overrideSlotInterval:
+              newValue.overrideSlotInterval !== undefined
+                ? newValue.overrideSlotInterval
+                : existingHost.overrideSlotInterval,
+            overrideBookingLimits:
+              newValue.overrideBookingLimits !== undefined
+                ? newValue.overrideBookingLimits
+                : existingHost.overrideBookingLimits,
+            overrideDurationLimits:
+              newValue.overrideDurationLimits !== undefined
+                ? newValue.overrideDurationLimits
+                : existingHost.overrideDurationLimits,
+            overridePeriodType:
+              newValue.overridePeriodType !== undefined
+                ? newValue.overridePeriodType
+                : existingHost.overridePeriodType,
+            overridePeriodStartDate:
+              newValue.overridePeriodStartDate !== undefined
+                ? newValue.overridePeriodStartDate
+                : existingHost.overridePeriodStartDate,
+            overridePeriodEndDate:
+              newValue.overridePeriodEndDate !== undefined
+                ? newValue.overridePeriodEndDate
+                : existingHost.overridePeriodEndDate,
+            overridePeriodDays:
+              newValue.overridePeriodDays !== undefined
+                ? newValue.overridePeriodDays
+                : existingHost.overridePeriodDays,
+            overridePeriodCountCalendarDays:
+              newValue.overridePeriodCountCalendarDays !== undefined
+                ? newValue.overridePeriodCountCalendarDays
+                : existingHost.overridePeriodCountCalendarDays,
           }
         : newValue;
     });

packages/features/bookings/lib/handleNewBooking/ensureAvailableUsers.ts

@@ -3,6 +3,14 @@ import type { Logger } from "tslog";
 import dayjs from "@calcom/dayjs";
 import type { Dayjs } from "@calcom/dayjs";
 import { checkForConflicts } from "@calcom/features/bookings/lib/conflictChecker/checkForConflicts";
+import {
+  getRoundRobinHostLimitOverrides,
+  groupRoundRobinHostsByEffectiveLimits,
+} from "@calcom/features/bookings/lib/handleNewBooking/resolveRoundRobinHostEffectiveLimits";
+import {
+  buildEventTypeWithEffectiveLimits,
+  getEventLevelLimits,
+} from "@calcom/features/bookings/lib/handleNewBooking/eventTypeEffectiveLimits";
 import { getBusyTimesService } from "@calcom/features/di/containers/BusyTimes";
 import { getUserAvailabilityService } from "@calcom/features/di/containers/GetUserAvailability";
 import { buildDateRanges } from "@calcom/features/schedules/lib/date-ranges";
@@ -13,7 +21,9 @@ import { getPiiFreeUser } from "@calcom/lib/piiFreeData";
 import { safeStringify } from "@calcom/lib/safeStringify";
 import { withReporting } from "@calcom/lib/sentryWrapper";
 import prisma from "@calcom/prisma";
+import { SchedulingType } from "@calcom/prisma/enums";
 import type { CalendarFetchMode } from "@calcom/types/Calendar";
+import type { EventBusyDetails } from "@calcom/types/Calendar";
 
 import type { getEventTypeResponse } from "./getEventTypesFromDB";
 import type { BookingType } from "./originalRescheduledBookingUtils";
@@ -74,12 +84,15 @@ const _ensureAvailableUsers = async (
 
   const bookingLimits = parseBookingLimit(eventType?.bookingLimits);
   const durationLimits = parseDurationLimit(eventType?.durationLimits);
+  const hasRoundRobinHostLimitOverrides =
+    eventType.schedulingType === SchedulingType.ROUND_ROBIN &&
+    eventType.users.some((user) => getRoundRobinHostLimitOverrides(user));
 
   const busyTimesService = getBusyTimesService();
   const busyTimesFromLimitsBookingsAllUsers: Awaited<
     ReturnType<typeof busyTimesService.getBusyTimesForLimitChecks>
   > =
-    eventType && (bookingLimits || durationLimits)
+    !hasRoundRobinHostLimitOverrides && eventType && (bookingLimits || durationLimits)
       ? await busyTimesService.getBusyTimesForLimitChecks({
           userIds: eventType.users.map((u) => u.id),
           eventTypeId: eventType.id,
@@ -91,27 +104,99 @@ const _ensureAvailableUsers = async (
         })
       : [];
 
-  const usersAvailability = await userAvailabilityService.getUsersAvailability({
-    users: eventType.users,
-    query: {
-      ...input,
-      eventTypeId: eventType.id,
-      duration: originalBookingDuration,
-      returnDateOverrides: false,
-      dateFrom: startDateTimeUtc.format(),
-      dateTo: endDateTimeUtc.format(),
-      beforeEventBuffer: eventType.beforeEventBuffer,
-      afterEventBuffer: eventType.afterEventBuffer,
-      bypassBusyCalendarTimes: false,
-      mode,
-      withSource: true,
-    },
-    initialData: {
-      eventType,
-      rescheduleUid: input.originalRescheduledBooking?.uid ?? null,
-      busyTimesFromLimitsBookings: busyTimesFromLimitsBookingsAllUsers,
-    },
-  });
+  const usersAvailability = hasRoundRobinHostLimitOverrides
+    ? await (async () => {
+        const eventLevelLimits = getEventLevelLimits(eventType);
+        const limitBuckets = groupRoundRobinHostsByEffectiveLimits({
+          schedulingType: eventType.schedulingType,
+          eventLimits: eventLevelLimits,
+          hosts: eventType.users,
+          getHostOverrides: getRoundRobinHostLimitOverrides,
+        });
+        const effectiveLimitsByUserId = new Map<number, typeof eventLevelLimits>();
+        const busyTimesFromLimitsByUserId = new Map<number, EventBusyDetails[]>();
+
+        for (const bucket of limitBuckets) {
+          const parsedBucketBookingLimits = parseBookingLimit(bucket.effectiveLimits.bookingLimits);
+          const parsedBucketDurationLimits = parseDurationLimit(bucket.effectiveLimits.durationLimits);
+
+          let bucketBookings: EventBusyDetails[] = [];
+          if (parsedBucketBookingLimits || parsedBucketDurationLimits) {
+            const { limitDateFrom, limitDateTo } = busyTimesService.getStartEndDateforLimitCheck(
+              startDateTimeUtc.toISOString(),
+              endDateTimeUtc.toISOString(),
+              parsedBucketBookingLimits,
+              parsedBucketDurationLimits
+            );
+
+            bucketBookings = await busyTimesService.getBusyTimesForLimitChecks({
+              userIds: bucket.hosts.map((user) => user.id),
+              eventTypeId: eventType.id,
+              startDate: limitDateFrom.format(),
+              endDate: limitDateTo.format(),
+              rescheduleUid: input.originalRescheduledBooking?.uid ?? null,
+              bookingLimits: parsedBucketBookingLimits,
+              durationLimits: parsedBucketDurationLimits,
+            });
+          }
+
+          for (const user of bucket.hosts) {
+            effectiveLimitsByUserId.set(user.id, bucket.effectiveLimits);
+            busyTimesFromLimitsByUserId.set(
+              user.id,
+              bucketBookings.filter((booking) => booking.userId === user.id)
+            );
+          }
+        }
+
+        return await Promise.all(
+          eventType.users.map(async (user) => {
+            const effectiveLimits = effectiveLimitsByUserId.get(user.id) ?? eventLevelLimits;
+            return await userAvailabilityService.getUserAvailability(
+              {
+                ...input,
+                eventTypeId: eventType.id,
+                duration: originalBookingDuration,
+                returnDateOverrides: false,
+                dateFrom: startDateTimeUtc,
+                dateTo: endDateTimeUtc,
+                beforeEventBuffer: effectiveLimits.beforeEventBuffer,
+                afterEventBuffer: effectiveLimits.afterEventBuffer,
+                bypassBusyCalendarTimes: false,
+                mode,
+                withSource: true,
+              },
+              {
+                user,
+                eventType: buildEventTypeWithEffectiveLimits({ eventType, effectiveLimits }),
+                rescheduleUid: input.originalRescheduledBooking?.uid ?? null,
+                busyTimesFromLimitsBookings: busyTimesFromLimitsByUserId.get(user.id) ?? [],
+              }
+            );
+          })
+        );
+      })()
+    : await userAvailabilityService.getUsersAvailability({
+        users: eventType.users,
+        query: {
+          ...input,
+          eventTypeId: eventType.id,
+          duration: originalBookingDuration,
+          returnDateOverrides: false,
+          dateFrom: startDateTimeUtc.format(),
+          dateTo: endDateTimeUtc.format(),
+          beforeEventBuffer: eventType.beforeEventBuffer,
+          afterEventBuffer: eventType.afterEventBuffer,
+          bypassBusyCalendarTimes: false,
+          mode,
+          withSource: true,
+        },
+        initialData: {
+          eventType,
+          rescheduleUid: input.originalRescheduledBooking?.uid ?? null,
+          busyTimesFromLimitsBookings: busyTimesFromLimitsBookingsAllUsers,
+        },
+      });
 
   const piiFreeInputDataForLogging = safeStringify({
     startDateTimeUtc,

packages/features/bookings/lib/handleNewBooking/eventTypeEffectiveLimits.ts

@@ -0,0 +1,57 @@
+import type { getEventTypeResponse } from "./getEventTypesFromDB";
+import type { IsFixedAwareUser } from "./types";
+
+export type EventLimitFields = Pick<
+  getEventTypeResponse,
+  | "minimumBookingNotice"
+  | "beforeEventBuffer"
+  | "afterEventBuffer"
+  | "slotInterval"
+  | "bookingLimits"
+  | "durationLimits"
+  | "periodType"
+  | "periodDays"
+  | "periodCountCalendarDays"
+  | "periodStartDate"
+  | "periodEndDate"
+>;
+
+export type EventTypeResponseWithIsFixedAwareUsers = Omit<getEventTypeResponse, "users"> & {
+  users: IsFixedAwareUser[];
+};
+
+export const getEventLevelLimits = <T extends EventLimitFields>(eventType: T): EventLimitFields => ({
+  minimumBookingNotice: eventType.minimumBookingNotice,
+  beforeEventBuffer: eventType.beforeEventBuffer,
+  afterEventBuffer: eventType.afterEventBuffer,
+  slotInterval: eventType.slotInterval,
+  bookingLimits: eventType.bookingLimits,
+  durationLimits: eventType.durationLimits,
+  periodType: eventType.periodType,
+  periodDays: eventType.periodDays,
+  periodCountCalendarDays: eventType.periodCountCalendarDays,
+  periodStartDate: eventType.periodStartDate,
+  periodEndDate: eventType.periodEndDate,
+});
+
+export const buildEventTypeWithEffectiveLimits = <T extends EventLimitFields>(params: {
+  eventType: T;
+  effectiveLimits: EventLimitFields;
+}): T => {
+  const { eventType, effectiveLimits } = params;
+
+  return {
+    ...eventType,
+    minimumBookingNotice: effectiveLimits.minimumBookingNotice,
+    beforeEventBuffer: effectiveLimits.beforeEventBuffer,
+    afterEventBuffer: effectiveLimits.afterEventBuffer,
+    slotInterval: effectiveLimits.slotInterval,
+    bookingLimits: effectiveLimits.bookingLimits,
+    durationLimits: effectiveLimits.durationLimits,
+    periodType: effectiveLimits.periodType,
+    periodDays: effectiveLimits.periodDays,
+    periodCountCalendarDays: effectiveLimits.periodCountCalendarDays,
+    periodStartDate: effectiveLimits.periodStartDate,
+    periodEndDate: effectiveLimits.periodEndDate,
+  };
+};

packages/features/bookings/lib/handleNewBooking/getEventTypesFromDB.ts

@@ -87,6 +87,7 @@ const getEventTypesFromDBSelect = {
   seatsShowAvailabilityCount: true,
   bookingLimits: true,
   durationLimits: true,
+  slotInterval: true,
   rescheduleWithSameRoundRobinHost: true,
   assignAllTeamMembers: true,
   isRRWeightsEnabled: true,
@@ -141,6 +142,17 @@ const getEventTypesFromDBSelect = {
       isFixed: true,
       priority: true,
       weight: true,
+      overrideMinimumBookingNotice: true,
+      overrideBeforeEventBuffer: true,
+      overrideAfterEventBuffer: true,
+      overrideSlotInterval: true,
+      overrideBookingLimits: true,
+      overrideDurationLimits: true,
+      overridePeriodType: true,
+      overridePeriodStartDate: true,
+      overridePeriodEndDate: true,
+      overridePeriodDays: true,
+      overridePeriodCountCalendarDays: true,
       createdAt: true,
       groupId: true,
       location: {