Uncodedtech
diff --git a/‎apps/web/modules/troubleshooter/components/LargeCalendar.tsx‎
Lines changed: 9 additions & 3 deletions b/‎apps/web/modules/troubleshooter/components/LargeCalendar.tsx‎
Lines changed: 9 additions & 3 deletions
diff --git a/‎packages/features/availability/lib/getUserAvailability.ts‎
Lines changed: 78 additions & 19 deletions b/‎packages/features/availability/lib/getUserAvailability.ts‎
Lines changed: 78 additions & 19 deletions
@@ -6,6 +6,7 @@ import { useAvailableTimeSlots } from "@calcom/features/bookings/Booker/hooks/us
 import { useTimePreferences } from "@calcom/features/bookings/lib/timePreferences";
 import { Calendar } from "@calcom/features/calendars/weeklyview/components/Calendar";
 import { useTroubleshooterStore } from "@calcom/features/troubleshooter/store";
+import { useLocale } from "@calcom/lib/hooks/useLocale";
 import { BookingStatus } from "@calcom/prisma/enums";
 import { trpc } from "@calcom/trpc/react";
 
@@ -14,6 +15,7 @@ import { useSchedule } from "~/schedules/hooks/useSchedule";
 import { OutOfOfficeInSlots } from "../../bookings/components/OutOfOfficeInSlots";
 
 export const LargeCalendar = ({ extraDays }: { extraDays: number }) => {
+  const { t } = useLocale();
   const { timezone } = useTimePreferences();
   const selectedDate = useTroubleshooterStore((state) => state.selectedDate);
   const event = useTroubleshooterStore((state) => state.event);
@@ -34,7 +36,8 @@ export const LargeCalendar = ({ extraDays }: { extraDays: number }) => {
       withSource: true,
     },
     {
-      enabled: !!session?.user?.username,
+      // Busy Times need eventTypeId to correctly have all busy times. event.id check here also avoids sending double requests for availability.user
+      enabled: !!session?.user?.username && !!event?.id,
     }
   );
 
@@ -68,11 +71,13 @@ export const LargeCalendar = ({ extraDays }: { extraDays: number }) => {
     //   .toDate(),
 
     const calendarEvents = busyEvents?.busy.map((event, idx) => {
+      const translatedTitle = event.title ? t(event.title) : t("busy_time.busy");
       return {
         id: idx,
-        title: event.title ?? `Busy`,
+        title: translatedTitle,
         start: new Date(event.start),
         end: new Date(event.end),
+        source: event.source,
         options: {
           color:
             event.source && calendarToColorMap[event.source] ? calendarToColorMap[event.source] : undefined,
@@ -104,6 +109,7 @@ export const LargeCalendar = ({ extraDays }: { extraDays: number }) => {
           title: "Date Override",
           start: dateOverrideStart.add(workingHoursForDay.startTime, "minutes").toDate(),
           end: dateOverrideEnd.add(workingHoursForDay.endTime, "minutes").toDate(),
+          source: "date-override",
           options: {
             color: "black",
             status: BookingStatus.ACCEPTED,
@@ -113,7 +119,7 @@ export const LargeCalendar = ({ extraDays }: { extraDays: number }) => {
       });
     }
     return calendarEvents;
-  }, [busyEvents, calendarToColorMap]);
+  }, [busyEvents, calendarToColorMap, t]);
 
   return (
     <div className="h-full [--calendar-dates-sticky-offset:66px]">
 
@@ -40,6 +40,7 @@ import { EventTypeMetaDataSchema } from "@calcom/prisma/zod-utils";
 import type { CalendarFetchMode, EventBusyDetails, IntervalLimitUnit } from "@calcom/types/Calendar";
 import type { CredentialForCalendarService } from "@calcom/types/Credential";
 import type { TimeRange, WorkingHours as WorkingHoursWithUserId } from "@calcom/types/schedule";
+import type { Ensure, Optional } from "@calcom/types/utils";
 import * as Sentry from "@sentry/nextjs";
 import { z } from "zod";
 import { detectEventTypeScheduleForUser } from "./detectEventTypeScheduleForUser";
@@ -167,8 +168,10 @@ export type CurrentSeats = Awaited<
   ReturnType<(typeof UserAvailabilityService)["prototype"]["_getCurrentSeats"]>
 >;
 
+type UserAvailabilityBusyDetails = Optional<EventBusyDetails, "source">;
+
 export type GetUserAvailabilityResult = {
-  busy: EventBusyDetails[];
+  busy: UserAvailabilityBusyDetails[];
   timeZone: string;
   dateRanges: {
     start: dayjs.Dayjs;
@@ -338,6 +341,22 @@ export class UserAvailabilityService {
 
   getCurrentSeats = withReporting(this._getCurrentSeats.bind(this), "getCurrentSeats");
 
+  private async parseLimits(eventType: { durationLimits?: unknown; bookingLimits?: unknown } | null) {
+    const bookingLimits =
+      eventType?.bookingLimits &&
+      typeof eventType.bookingLimits === "object" &&
+      Object.keys(eventType.bookingLimits).length > 0
+        ? parseBookingLimit(eventType.bookingLimits)
+        : null;
+    const durationLimits =
+      eventType?.durationLimits &&
+      typeof eventType.durationLimits === "object" &&
+      Object.keys(eventType.durationLimits).length > 0
+        ? parseDurationLimit(eventType.durationLimits)
+        : null;
+    return { bookingLimits, durationLimits };
+  }
+
   /** This should be called getUsersWorkingHoursAndBusySlots (...and remaining seats, and final timezone) */
   async _getUserAvailability(
     params: GetUserAvailabilityParams,
@@ -356,6 +375,7 @@ export class UserAvailabilityService {
       bypassBusyCalendarTimes = false,
       silentlyHandleCalendarFailures = false,
       mode = "none",
+      withSource = false,
     } = params;
 
     log.debug(
@@ -371,7 +391,6 @@ export class UserAvailabilityService {
 
     let eventType: EventType | null = initialData?.eventType || null;
     if (!eventType && eventTypeId) eventType = await this.getEventType(eventTypeId);
-
     /* Current logic is if a booking is in a time slot mark it as busy, but seats can have more than one attendee so grab
     current bookings with a seats event type and display them on the calendar, even if they are full */
     let currentSeats: CurrentSeats | null = initialData?.currentSeats || null;
@@ -510,19 +529,7 @@ export class UserAvailabilityService {
         datesOutOfOffice: undefined,
       };
 
-    const bookingLimits =
-      eventType?.bookingLimits &&
-      typeof eventType.bookingLimits === "object" &&
-      Object.keys(eventType.bookingLimits).length > 0
-        ? parseBookingLimit(eventType.bookingLimits)
-        : null;
-
-    const durationLimits =
-      eventType?.durationLimits &&
-      typeof eventType.durationLimits === "object" &&
-      Object.keys(eventType.durationLimits).length > 0
-        ? parseDurationLimit(eventType.durationLimits)
-        : null;
+    const { bookingLimits, durationLimits } = await this.parseLimits(eventType);
 
     // TODO: only query what we need after applying limits (shrink date range)
     const getBusyTimesStart = dateFrom.toISOString();
@@ -533,11 +540,9 @@ export class UserAvailabilityService {
       : user.userLevelSelectedCalendars;
 
     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,
@@ -612,18 +617,22 @@ export class UserAvailabilityService {
       };
     }
 
-    const detailedBusyTimes: EventBusyDetails[] = [
+    const detailedBusyTimesWithSource: EventBusyDetails[] = [
       ...busyTimes.map((a) => ({
         ...a,
         start: dayjs(a.start).toISOString(),
         end: dayjs(a.end).toISOString(),
         title: a.title,
-        source: params.withSource ? a.source : undefined,
+        source: a.source,
       })),
       ...busyTimesFromLimits,
       ...busyTimesFromTeamLimits,
     ];
 
+    const detailedBusyTimes: UserAvailabilityBusyDetails[] = withSource
+      ? detailedBusyTimesWithSource
+      : detailedBusyTimesWithSource.map(({ source, ...rest }) => rest);
+
     log.debug(
       `EventType: ${eventTypeId} | User: ${username} (ID: ${userId}) - usingSchedule: ${safeStringify({
         chosenSchedule: schedule,
@@ -657,6 +666,56 @@ export class UserAvailabilityService {
     return result;
   }
 
+  /**
+   * This fn mainly uses _getUserAvailability but sends busy times from limits too to _getUserAvailability as expected by _getUserAvailability.
+   */
+  async getUserAvailabilityIncludingBusyTimesFromLimits(
+    params: GetUserAvailabilityParams,
+    initialData: Ensure<GetUserAvailabilityInitialData, "user">
+  ): Promise<GetUserAvailabilityResult> {
+    const { user } = initialData || {};
+    const { dateFrom, dateTo, eventTypeId } = params;
+    let eventType: EventType | null = initialData?.eventType || null;
+    if (!eventType && eventTypeId) eventType = await this.getEventType(eventTypeId);
+
+    const { bookingLimits, durationLimits } = await this.parseLimits(eventType);
+
+    let busyTimesFromLimitsBookings: EventBusyDetails[] | undefined =
+      initialData?.busyTimesFromLimitsBookings;
+    if (!busyTimesFromLimitsBookings && eventType && (bookingLimits || durationLimits)) {
+      const busyTimesService = getBusyTimesService();
+      const { limitDateFrom, limitDateTo } = busyTimesService.getStartEndDateforLimitCheck(
+        dateFrom.toISOString(),
+        dateTo.toISOString(),
+        bookingLimits,
+        durationLimits
+      );
+
+      // For team events with booking/duration limits, fetch bookings for all team members
+      // to accurately calculate if limits are reached for the event
+      const userIdsForLimitCheck =
+        eventType.hosts && eventType.hosts.length > 0
+          ? eventType.hosts.map((host) => host.user.id)
+          : [user.id];
+
+      busyTimesFromLimitsBookings = await busyTimesService.getBusyTimesForLimitChecks({
+        userIds: userIdsForLimitCheck,
+        eventTypeId: eventType.id,
+        startDate: limitDateFrom.format(),
+        endDate: limitDateTo.format(),
+        rescheduleUid: initialData?.rescheduleUid ?? undefined,
+        bookingLimits,
+        durationLimits,
+      });
+    }
+    const result = await this._getUserAvailability(params, {
+      ...initialData,
+      ...(eventType ? { eventType } : {}),
+      ...(busyTimesFromLimitsBookings ? { busyTimesFromLimitsBookings } : {}),
+    });
+    return result;
+  }
+
   getUserAvailability = withReporting(this._getUserAvailability.bind(this), "getUserAvailability");
 
   getPeriodStartDatesBetween = withReporting(