Scheduling infrastructure for absolutely everyone.
perf: Optimize team bookings query by fetching data for multiple users at once (#21137)
devin-ai-integration[bot]d770cfc65ecb
diff --git a/packages/lib/getUserAvailability.ts b/packages/lib/getUserAvailability.tsindex f24d1ec1b5e..c50ed5feebc 100644--- a/packages/lib/getUserAvailability.ts+++ b/packages/lib/getUserAvailability.ts@@ -182,6 +182,18 @@ export type GetUserAvailabilityInitialData = {reason: Pick<OutOfOfficeReason, "id" | "emoji" | "reason"> | null;})[];busyTimesFromLimitsBookings: EventBusyDetails[];+ busyTimesFromLimits?: Map<number, EventBusyDetails[]>;+ eventTypeForLimits?: {+ id: number;+ bookingLimits?: unknown;+ durationLimits?: unknown;+ } | null;+ teamBookingLimits?: Map<number, EventBusyDetails[]>;+ teamForBookingLimits?: {+ id: number;+ bookingLimits?: unknown;+ includeManagedEventsInLimits: boolean;+ } | null;};export type GetAvailabilityUser = NonNullable<GetUserAvailabilityInitialData["user"]>;@@ -352,40 +364,49 @@ const _getUserAvailability = async function getUsersWorkingHoursLifeTheUniverseAconst bookingLimits = parseBookingLimit(eventType?.bookingLimits);const durationLimits = parseDurationLimit(eventType?.durationLimits);- const busyTimesFromLimits =- eventType && (bookingLimits || durationLimits)- ? await getBusyTimesFromLimits(- bookingLimits,- durationLimits,- dateFrom.tz(timeZone),- dateTo.tz(timeZone),- duration,- eventType,- initialData?.busyTimesFromLimitsBookings ?? [],- timeZone,- initialData?.rescheduleUid ?? undefined- )- : [];+ let busyTimesFromLimits: EventBusyDetails[] = [];++ if (initialData?.busyTimesFromLimits && initialData?.eventTypeForLimits) {+ busyTimesFromLimits = initialData.busyTimesFromLimits.get(user.id) || [];+ } else if (eventType && (bookingLimits || durationLimits)) {+ // Fall back to individual query if not available in initialData+ busyTimesFromLimits = await getBusyTimesFromLimits(+ bookingLimits,+ durationLimits,+ dateFrom.tz(timeZone),+ dateTo.tz(timeZone),+ duration,+ eventType,+ initialData?.busyTimesFromLimitsBookings ?? [],+ timeZone,+ initialData?.rescheduleUid ?? undefined+ );+ }const teamForBookingLimits =+ initialData?.teamForBookingLimits ??eventType?.team ??(eventType?.parent?.team?.includeManagedEventsInLimits ? eventType?.parent?.team : null);const teamBookingLimits = parseBookingLimit(teamForBookingLimits?.bookingLimits);- const busyTimesFromTeamLimits =- teamForBookingLimits && teamBookingLimits- ? await getBusyTimesFromTeamLimits(- user,- teamBookingLimits,- dateFrom.tz(timeZone),- dateTo.tz(timeZone),- teamForBookingLimits.id,- teamForBookingLimits.includeManagedEventsInLimits,- timeZone,- initialData?.rescheduleUid ?? undefined- )- : [];+ let busyTimesFromTeamLimits: EventBusyDetails[] = [];++ if (initialData?.teamBookingLimits && teamForBookingLimits) {+ busyTimesFromTeamLimits = initialData.teamBookingLimits.get(user.id) || [];+ } else if (teamForBookingLimits && teamBookingLimits) {+ // Fall back to individual query if not available in initialData+ busyTimesFromTeamLimits = await getBusyTimesFromTeamLimits(+ user,+ teamBookingLimits,+ dateFrom.tz(timeZone),+ dateTo.tz(timeZone),+ teamForBookingLimits.id,+ teamForBookingLimits.includeManagedEventsInLimits,+ timeZone,+ initialData?.rescheduleUid ?? undefined+ );+ }// TODO: only query what we need after applying limits (shrink date range)const getBusyTimesStart = dateFrom.toISOString();@@ -598,10 +619,15 @@ export const getPeriodStartDatesBetween = (return monitorCallbackSync(_getPeriodStartDatesBetween, ...args);};-const _getPeriodStartDatesBetween = (dateFrom: Dayjs, dateTo: Dayjs, period: IntervalLimitUnit) => {+const _getPeriodStartDatesBetween = (+ dateFrom: Dayjs,+ dateTo: Dayjs,+ period: IntervalLimitUnit,+ timeZone?: string+) => {const dates = [];- let startDate = dayjs(dateFrom).startOf(period);- const endDate = dayjs(dateTo).endOf(period);+ let startDate = timeZone ? dayjs(dateFrom).tz(timeZone).startOf(period) : dayjs(dateFrom).startOf(period);+ const endDate = timeZone ? dayjs(dateTo).tz(timeZone).endOf(period) : dayjs(dateTo).endOf(period);while (startDate.isBefore(endDate)) {dates.push(startDate);diff --git a/packages/lib/intervalLimits/limitManager.ts b/packages/lib/intervalLimits/limitManager.tsindex bbff888d2bb..e659b3c404c 100644--- a/packages/lib/intervalLimits/limitManager.ts+++ b/packages/lib/intervalLimits/limitManager.ts@@ -14,31 +14,32 @@ export default class LimitManager {/*** Creates a busy map key*/- private static createKey(start: Dayjs, unit: IntervalLimitUnit): BusyMapKey {- return `${unit}-${start.startOf(unit).toISOString()}`;+ private static createKey(start: Dayjs, unit: IntervalLimitUnit, timeZone?: string): BusyMapKey {+ const tzStart = timeZone ? start.tz(timeZone) : start;+ return `${unit}-${tzStart.startOf(unit).toISOString()}`;}/*** Checks if already marked busy by ancestors or siblings*/- isAlreadyBusy(start: Dayjs, unit: IntervalLimitUnit) {- if (this.busyMap.has(LimitManager.createKey(start, "year"))) return true;+ isAlreadyBusy(start: Dayjs, unit: IntervalLimitUnit, timeZone?: string) {+ if (this.busyMap.has(LimitManager.createKey(start, "year", timeZone))) return true;- if (unit === "month" && this.busyMap.has(LimitManager.createKey(start, "month"))) {+ if (unit === "month" && this.busyMap.has(LimitManager.createKey(start, "month", timeZone))) {return true;} else if (unit === "week" &&// weeks can be part of two months- ((this.busyMap.has(LimitManager.createKey(start, "month")) &&- this.busyMap.has(LimitManager.createKey(start.endOf("week"), "month"))) ||- this.busyMap.has(LimitManager.createKey(start, "week")))+ ((this.busyMap.has(LimitManager.createKey(start, "month", timeZone)) &&+ this.busyMap.has(LimitManager.createKey(start.endOf("week"), "month", timeZone))) ||+ this.busyMap.has(LimitManager.createKey(start, "week", timeZone)))) {return true;} else if (unit === "day" &&- (this.busyMap.has(LimitManager.createKey(start, "month")) ||- this.busyMap.has(LimitManager.createKey(start, "week")) ||- this.busyMap.has(LimitManager.createKey(start, "day")))+ (this.busyMap.has(LimitManager.createKey(start, "month", timeZone)) ||+ this.busyMap.has(LimitManager.createKey(start, "week", timeZone)) ||+ this.busyMap.has(LimitManager.createKey(start, "day", timeZone)))) {return true;} else {@@ -49,10 +50,11 @@ export default class LimitManager {/*** Adds a new busy time*/- addBusyTime(start: Dayjs, unit: IntervalLimitUnit) {- this.busyMap.set(`${unit}-${start.toISOString()}`, {- start: start.toISOString(),- end: start.endOf(unit).toISOString(),+ addBusyTime(start: Dayjs, unit: IntervalLimitUnit, timeZone?: string) {+ const tzStart = timeZone ? start.tz(timeZone) : start;+ this.busyMap.set(`${unit}-${tzStart.toISOString()}`, {+ start: tzStart.toISOString(),+ end: tzStart.endOf(unit).toISOString(),});}diff --git a/packages/lib/server/repository/booking.ts b/packages/lib/server/repository/booking.tsindex b02d77729f3..0f6e1fe95c5 100644--- a/packages/lib/server/repository/booking.ts+++ b/packages/lib/server/repository/booking.ts@@ -17,6 +17,22 @@ type TeamBookingsParamsBase = {shouldReturnCount?: boolean;};+type TeamBookingsMultipleUsersParamsBase = {+ users: { id: number; email: string }[];+ teamId: number;+ startDate: Date;+ endDate: Date;+ excludedUid?: string | null;+ includeManagedEvents: boolean;+ shouldReturnCount?: boolean;+};++type TeamBookingsMultipleUsersParamsWithCount = TeamBookingsMultipleUsersParamsBase & {+ shouldReturnCount: true;+};++type TeamBookingsMultipleUsersParamsWithoutCount = TeamBookingsMultipleUsersParamsBase;+type TeamBookingsParamsWithCount = TeamBookingsParamsBase & {shouldReturnCount: true;};@@ -666,4 +682,116 @@ export class BookingRepository {},});}++ static async getAllAcceptedTeamBookingsOfUsers(+ params: TeamBookingsMultipleUsersParamsWithCount+ ): Promise<number>;++ static async getAllAcceptedTeamBookingsOfUsers(+ params: TeamBookingsMultipleUsersParamsWithoutCount+ ): Promise<Array<Booking>>;++ static async getAllAcceptedTeamBookingsOfUsers(params: TeamBookingsMultipleUsersParamsBase) {+ const { users, teamId, startDate, endDate, excludedUid, shouldReturnCount, includeManagedEvents } =+ params;++ const baseWhere: Prisma.BookingWhereInput = {+ status: BookingStatus.ACCEPTED,+ startTime: {+ gte: startDate,+ },+ endTime: {+ lte: endDate,+ },+ ...(excludedUid && {+ uid: {+ not: excludedUid,+ },+ }),+ };++ const userIds = users.map((user) => user.id);+ const userEmails = users.map((user) => user.email);++ const whereCollectiveRoundRobinOwner: Prisma.BookingWhereInput = {+ ...baseWhere,+ userId: {+ in: userIds,+ },+ eventType: {+ teamId,+ },+ };++ const whereCollectiveRoundRobinBookingsAttendee: Prisma.BookingWhereInput = {+ ...baseWhere,+ attendees: {+ some: {+ email: {+ in: userEmails,+ },+ },+ },+ eventType: {+ teamId,+ },+ };++ const whereManagedBookings: Prisma.BookingWhereInput = {+ ...baseWhere,+ userId: {+ in: userIds,+ },+ eventType: {+ parent: {+ teamId,+ },+ },+ };++ if (shouldReturnCount) {+ const collectiveRoundRobinBookingsOwner = await prisma.booking.count({+ where: whereCollectiveRoundRobinOwner,+ });++ const collectiveRoundRobinBookingsAttendee = await prisma.booking.count({+ where: whereCollectiveRoundRobinBookingsAttendee,+ });++ let managedBookings = 0;++ if (includeManagedEvents) {+ managedBookings = await prisma.booking.count({+ where: whereManagedBookings,+ });+ }++ const totalNrOfBooking =+ collectiveRoundRobinBookingsOwner + collectiveRoundRobinBookingsAttendee + managedBookings;++ return totalNrOfBooking;+ }++ const collectiveRoundRobinBookingsOwner = await prisma.booking.findMany({+ where: whereCollectiveRoundRobinOwner,+ });++ const collectiveRoundRobinBookingsAttendee = await prisma.booking.findMany({+ where: whereCollectiveRoundRobinBookingsAttendee,+ });++ let managedBookings: typeof collectiveRoundRobinBookingsAttendee = [];++ if (includeManagedEvents) {+ managedBookings = await prisma.booking.findMany({+ where: whereManagedBookings,+ });+ }++ return [+ ...collectiveRoundRobinBookingsOwner,+ ...collectiveRoundRobinBookingsAttendee,+ ...managedBookings,+ ];+ }}diff --git a/packages/trpc/server/routers/viewer/slots/util.ts b/packages/trpc/server/routers/viewer/slots/util.tsindex 356747dbaba..285964f2ef5 100644--- a/packages/trpc/server/routers/viewer/slots/util.ts+++ b/packages/trpc/server/routers/viewer/slots/util.ts@@ -15,11 +15,21 @@ import { RESERVED_SUBDOMAINS } from "@calcom/lib/constants";import { getUTCOffsetByTimezone } from "@calcom/lib/dayjs";import { getDefaultEvent } from "@calcom/lib/defaultEvents";import { getAggregatedAvailability } from "@calcom/lib/getAggregatedAvailability";-import { getBusyTimesForLimitChecks } from "@calcom/lib/getBusyTimes";-import type { CurrentSeats, GetAvailabilityUser, IFromUser, IToUser } from "@calcom/lib/getUserAvailability";-import { getUsersAvailability } from "@calcom/lib/getUserAvailability";+import { getBusyTimesForLimitChecks, getStartEndDateforLimitCheck } from "@calcom/lib/getBusyTimes";+import type {+ CurrentSeats,+ GetAvailabilityUser,+ IFromUser,+ IToUser,+ EventType,+} from "@calcom/lib/getUserAvailability";+import { getUsersAvailability, getPeriodStartDatesBetween } from "@calcom/lib/getUserAvailability";+import { descendingLimitKeys, intervalLimitKeyToUnit } from "@calcom/lib/intervalLimits/intervalLimit";+import type { IntervalLimit } from "@calcom/lib/intervalLimits/intervalLimitSchema";import { parseBookingLimit } from "@calcom/lib/intervalLimits/isBookingLimits";import { parseDurationLimit } from "@calcom/lib/intervalLimits/isDurationLimits";+import LimitManager from "@calcom/lib/intervalLimits/limitManager";+import { checkBookingLimit } from "@calcom/lib/intervalLimits/server/checkBookingLimits";import {calculatePeriodLimits,isTimeOutOfBounds,@@ -28,6 +38,7 @@ import {import logger from "@calcom/lib/logger";import { safeStringify } from "@calcom/lib/safeStringify";import monitorCallbackAsync, { monitorCallbackSync } from "@calcom/lib/sentryWrapper";+import { getTotalBookingDuration } from "@calcom/lib/server/queries";import { BookingRepository as BookingRepo } from "@calcom/lib/server/repository/booking";import { EventTypeRepository } from "@calcom/lib/server/repository/eventType";import { UserRepository, withSelectedCalendars } from "@calcom/lib/server/repository/user";@@ -36,7 +47,7 @@ import prisma, { availabilityUserSelect } from "@calcom/prisma";import { PeriodType, Prisma } from "@calcom/prisma/client";import { SchedulingType } from "@calcom/prisma/enums";import { credentialForCalendarServiceSelect } from "@calcom/prisma/selects/credential";-import type { EventBusyDate } from "@calcom/types/Calendar";+import type { EventBusyDate, EventBusyDetails } from "@calcom/types/Calendar";import type { CredentialPayload, CredentialForCalendarService } from "@calcom/types/Credential";import { TRPCError } from "@trpc/server";@@ -834,6 +845,395 @@ export function getAllDatesWithBookabilityStatus(availableDates: string[]) {return allDates;}+/**+ * Gets busy times from limits for multiple users+ */+const getBusyTimesFromLimitsForUsers = async (+ users: { id: number; email: string }[],+ bookingLimits: IntervalLimit | null,+ durationLimits: IntervalLimit | null,+ dateFrom: Dayjs,+ dateTo: Dayjs,+ duration: number | undefined,+ eventType: NonNullable<EventType>,+ timeZone: string,+ rescheduleUid?: string+) => {+ const userBusyTimesMap = new Map<number, EventBusyDetails[]>();++ if (!bookingLimits && !durationLimits) {+ return userBusyTimesMap;+ }++ const { limitDateFrom, limitDateTo } = getStartEndDateforLimitCheck(+ dateFrom.toISOString(),+ dateTo.toISOString(),+ bookingLimits || durationLimits+ );++ const busyTimesFromLimitsBookings = await getBusyTimesForLimitChecks({+ userIds: users.map((user) => user.id),+ eventTypeId: eventType.id,+ startDate: limitDateFrom.format(),+ endDate: limitDateTo.format(),+ rescheduleUid,+ bookingLimits,+ durationLimits,+ });++ const globalLimitManager = new LimitManager();++ if (bookingLimits) {+ for (const key of descendingLimitKeys) {+ const limit = bookingLimits?.[key];+ if (!limit) continue;++ const unit = intervalLimitKeyToUnit(key);+ const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);++ for (const periodStart of periodStartDates) {+ if (globalLimitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;++ const periodEnd = periodStart.endOf(unit);+ let totalBookings = 0;++ for (const booking of busyTimesFromLimitsBookings) {+ const bookingStart = dayjs(booking.start).tz(timeZone);+ const bookingDay = bookingStart.format("YYYY-MM-DD");+ const periodStartDay = periodStart.format("YYYY-MM-DD");+ const periodEndDay = periodEnd.format("YYYY-MM-DD");++ if (bookingDay < periodStartDay || bookingDay > periodEndDay) {+ continue;+ }++ totalBookings++;+ if (totalBookings >= limit) {+ globalLimitManager.addBusyTime(periodStart, unit, timeZone);+ break;+ }+ }+ }+ }+ }++ for (const user of users) {+ const userBookings = busyTimesFromLimitsBookings.filter((booking) => booking.userId === user.id);+ const limitManager = new LimitManager();++ for (const busyTime of globalLimitManager.getBusyTimes()) {+ const start = dayjs(busyTime.start);+ const end = dayjs(busyTime.end);++ let unit: "year" | "month" | "week" | "day";++ if (end.diff(start, "year") >= 1) {+ unit = "year";+ } else if (end.diff(start, "month") >= 1) {+ unit = "month";+ } else if (end.diff(start, "week") >= 1) {+ unit = "week";+ } else {+ unit = "day";+ }++ limitManager.addBusyTime(start, unit, timeZone);+ }++ await monitorCallbackAsync(async () => {+ if (bookingLimits) {+ for (const key of descendingLimitKeys) {+ const limit = bookingLimits?.[key];+ if (!limit) continue;++ const unit = intervalLimitKeyToUnit(key);+ const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);++ for (const periodStart of periodStartDates) {+ if (limitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;++ if (unit === "year") {+ try {+ await checkBookingLimit({+ eventStartDate: periodStart.toDate(),+ limitingNumber: limit,+ eventId: eventType.id,+ key,+ user,+ rescheduleUid,+ timeZone,+ });+ } catch (_) {+ limitManager.addBusyTime(periodStart, unit, timeZone);+ if (+ periodStartDates.every((start: Dayjs) => limitManager.isAlreadyBusy(start, unit, timeZone))+ ) {+ break;+ }+ }+ continue;+ }++ const periodEnd = periodStart.endOf(unit);+ let totalBookings = 0;++ for (const booking of userBookings) {+ const bookingStart = dayjs(booking.start).tz(timeZone);+ const bookingDay = bookingStart.format("YYYY-MM-DD");+ const periodStartDay = periodStart.format("YYYY-MM-DD");+ const periodEndDay = periodEnd.format("YYYY-MM-DD");++ if (bookingDay < periodStartDay || bookingDay > periodEndDay) {+ continue;+ }++ totalBookings++;+ if (totalBookings >= limit) {+ limitManager.addBusyTime(periodStart, unit, timeZone);+ break;+ }+ }+ }+ }+ }++ if (durationLimits) {+ for (const key of descendingLimitKeys) {+ const limit = durationLimits?.[key];+ if (!limit) continue;++ const unit = intervalLimitKeyToUnit(key);+ const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);++ for (const periodStart of periodStartDates) {+ if (limitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;++ const selectedDuration = (duration || eventType.length) ?? 0;++ if (selectedDuration > limit) {+ limitManager.addBusyTime(periodStart, unit, timeZone);+ continue;+ }++ if (unit === "year") {+ const totalYearlyDuration = await getTotalBookingDuration({+ eventId: eventType.id,+ startDate: periodStart.toDate(),+ endDate: periodStart.endOf(unit).toDate(),+ rescheduleUid,+ });+ if (totalYearlyDuration + selectedDuration > limit) {+ limitManager.addBusyTime(periodStart, unit, timeZone);+ if (+ periodStartDates.every((start: Dayjs) => limitManager.isAlreadyBusy(start, unit, timeZone))+ ) {+ break;+ }+ }+ continue;+ }++ const periodEnd = periodStart.endOf(unit);+ let totalDuration = selectedDuration;++ for (const booking of userBookings) {+ const bookingStart = dayjs(booking.start).tz(timeZone);+ const bookingDay = bookingStart.format("YYYY-MM-DD");+ const periodStartDay = periodStart.format("YYYY-MM-DD");+ const periodEndDay = periodEnd.format("YYYY-MM-DD");++ if (bookingDay < periodStartDay || bookingDay > periodEndDay) {+ continue;+ }++ totalDuration += dayjs(booking.end).diff(dayjs(booking.start), "minute");+ if (totalDuration > limit) {+ limitManager.addBusyTime(periodStart, unit, timeZone);+ break;+ }+ }+ }+ }+ }+ });++ userBusyTimesMap.set(user.id, limitManager.getBusyTimes());+ }++ return userBusyTimesMap;+};++/**+ * Gets busy times from team booking limits for multiple users+ */+const getBusyTimesFromTeamLimitsForUsers = async (+ users: { id: number; email: string }[],+ bookingLimits: IntervalLimit,+ dateFrom: Dayjs,+ dateTo: Dayjs,+ teamId: number,+ includeManagedEvents: boolean,+ timeZone: string,+ rescheduleUid?: string+) => {+ const { limitDateFrom, limitDateTo } = getStartEndDateforLimitCheck(+ dateFrom.toISOString(),+ dateTo.toISOString(),+ bookingLimits+ );++ const bookings = await BookingRepo.getAllAcceptedTeamBookingsOfUsers({+ users,+ teamId,+ startDate: limitDateFrom.toDate(),+ endDate: limitDateTo.toDate(),+ excludedUid: rescheduleUid,+ includeManagedEvents,+ });++ const busyTimes = bookings.map(({ id, startTime, endTime, eventTypeId, title, userId }) => ({+ start: dayjs(startTime).toDate(),+ end: dayjs(endTime).toDate(),+ title,+ source: `eventType-${eventTypeId}-booking-${id}`,+ userId,+ }));++ const globalLimitManager = new LimitManager();++ for (const key of descendingLimitKeys) {+ const limit = bookingLimits?.[key];+ if (!limit) continue;++ const unit = intervalLimitKeyToUnit(key);+ const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);++ for (const periodStart of periodStartDates) {+ if (globalLimitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;++ const periodEnd = periodStart.endOf(unit);+ let totalBookings = 0;++ for (const booking of busyTimes) {+ const bookingStart = dayjs(booking.start).tz(timeZone);+ const bookingDay = bookingStart.format("YYYY-MM-DD");+ const periodStartDay = periodStart.format("YYYY-MM-DD");+ const periodEndDay = periodEnd.format("YYYY-MM-DD");++ if (bookingDay < periodStartDay || bookingDay > periodEndDay) {+ continue;+ }++ totalBookings++;+ if (totalBookings >= limit) {+ globalLimitManager.addBusyTime(periodStart, unit, timeZone);+ break;+ }+ }+ }+ }++ const userBusyTimesMap = new Map();++ for (const user of users) {+ const userBusyTimes = busyTimes.filter((busyTime) => busyTime.userId === user.id);+ const limitManager = new LimitManager();++ for (const busyTime of globalLimitManager.getBusyTimes()) {+ const start = dayjs(busyTime.start);+ const end = dayjs(busyTime.end);++ let unit: "year" | "month" | "week" | "day";++ if (end.diff(start, "year") >= 1) {+ unit = "year";+ } else if (end.diff(start, "month") >= 1) {+ unit = "month";+ } else if (end.diff(start, "week") >= 1) {+ unit = "week";+ } else {+ unit = "day";+ }++ limitManager.addBusyTime(start, unit, timeZone);+ }++ await monitorCallbackAsync(async () => {+ const bookingLimitsParams = {+ bookings: userBusyTimes,+ bookingLimits,+ dateFrom,+ dateTo,+ limitManager,+ rescheduleUid,+ teamId,+ user,+ includeManagedEvents,+ timeZone,+ };++ for (const key of descendingLimitKeys) {+ const limit = bookingLimits?.[key];+ if (!limit) continue;++ const unit = intervalLimitKeyToUnit(key);+ const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);++ for (const periodStart of periodStartDates) {+ if (limitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;++ if (unit === "year") {+ try {+ await checkBookingLimit({+ eventStartDate: periodStart.toDate(),+ limitingNumber: limit,+ key,+ teamId,+ user,+ rescheduleUid,+ includeManagedEvents,+ timeZone,+ });+ } catch (_) {+ limitManager.addBusyTime(periodStart, unit, timeZone);+ if (+ periodStartDates.every((start: Dayjs) => limitManager.isAlreadyBusy(start, unit, timeZone))+ ) {+ return;+ }+ }+ continue;+ }++ const periodEnd = periodStart.endOf(unit);+ let totalBookings = 0;++ for (const booking of userBusyTimes) {+ const bookingStart = dayjs(booking.start).tz(timeZone);+ const bookingDay = bookingStart.format("YYYY-MM-DD");+ const periodStartDay = periodStart.format("YYYY-MM-DD");+ const periodEndDay = periodEnd.format("YYYY-MM-DD");++ if (bookingDay < periodStartDay || bookingDay > periodEndDay) {+ continue;+ }++ totalBookings++;+ if (totalBookings >= limit) {+ limitManager.addBusyTime(periodStart, unit, timeZone);+ break;+ }+ }+ }+ }+ });++ userBusyTimesMap.set(user.id, limitManager.getBusyTimes());+ }++ return userBusyTimesMap;+};+const calculateHostsAndAvailabilities = async ({input,eventType,@@ -905,6 +1305,43 @@ const calculateHostsAndAvailabilities = async ({});}+ let busyTimesFromLimitsMap: Map<number, EventBusyDetails[]> | undefined = undefined;+ if (eventType && (bookingLimits || durationLimits)) {+ const usersForLimits = usersWithCredentials.map((user) => ({ id: user.id, email: user.email }));+ busyTimesFromLimitsMap = await getBusyTimesFromLimitsForUsers(+ usersForLimits,+ bookingLimits,+ durationLimits,+ startTime,+ endTime,+ typeof input.duration === "number" ? input.duration : undefined,+ eventType,+ usersWithCredentials[0]?.timeZone || "UTC",+ input.rescheduleUid || undefined+ );+ }++ const teamForBookingLimits =+ eventType?.team ??+ (eventType?.parent?.team?.includeManagedEventsInLimits ? eventType?.parent?.team : null);++ const teamBookingLimits = parseBookingLimit(teamForBookingLimits?.bookingLimits);++ let teamBookingLimitsMap: Map<number, EventBusyDetails[]> | undefined = undefined;+ if (teamForBookingLimits && teamBookingLimits) {+ const usersForTeamLimits = usersWithCredentials.map((user) => ({ id: user.id, email: user.email }));+ teamBookingLimitsMap = await getBusyTimesFromTeamLimitsForUsers(+ usersForTeamLimits,+ teamBookingLimits,+ startTime,+ endTime,+ teamForBookingLimits.id,+ teamForBookingLimits.includeManagedEventsInLimits,+ usersWithCredentials[0]?.timeZone || "UTC",+ input.rescheduleUid || undefined+ );+ }+const users = monitorCallbackSync(function enrichUsersWithData() {return usersWithCredentials.map((currentUser) => {return {@@ -940,6 +1377,10 @@ const calculateHostsAndAvailabilities = async ({currentSeats,rescheduleUid: input.rescheduleUid,busyTimesFromLimitsBookings: busyTimesFromLimitsBookingsAllUsers,+ busyTimesFromLimits: busyTimesFromLimitsMap,+ eventTypeForLimits: eventType && (bookingLimits || durationLimits) ? eventType : null,+ teamBookingLimits: teamBookingLimitsMap,+ teamForBookingLimits: teamForBookingLimits,},});/* We get all users working hours and busy slots */