fix: Seated events and round robin - all round robin hosts are being added to the calendar event (calcom#21317)

anikdhabal · web-flow · commit 44d9c4bcc52e · 2025-05-14T22:52:26.000Z
* fix: add org email into ics

* fix: Seated events and round robin - all round robin hosts are being added to the calendar event

* added test
diff --git a/packages/features/bookings/lib/handleNewBooking.ts b/packages/features/bookings/lib/handleNewBooking.ts
@@ -1,4 +1,4 @@
-import type { DestinationCalendar } from "@prisma/client";
+import type { DestinationCalendar, User } from "@prisma/client";
 // eslint-disable-next-line no-restricted-imports
 import { cloneDeep } from "lodash";
 import short, { uuid } from "short-uuid";
@@ -250,6 +250,80 @@ const buildDryRunEventManager = () => {
   };
 };
 
+export const buildEventForTeamEventType = async ({
+  existingEvent: evt,
+  users,
+  organizerUser,
+  schedulingType,
+  team,
+}: {
+  existingEvent: Partial<CalendarEvent>;
+  users: (Pick<User, "id" | "name" | "timeZone" | "locale" | "email"> & {
+    destinationCalendar: DestinationCalendar | null;
+    isFixed?: boolean;
+  })[];
+  organizerUser: { email: string };
+  schedulingType: SchedulingType | null;
+  team?: {
+    id: number;
+    name: string;
+  } | null;
+}) => {
+  // not null assertion.
+  if (!schedulingType) {
+    throw new Error("Scheduling type is required for team event type");
+  }
+  const teamDestinationCalendars: DestinationCalendar[] = [];
+
+  // Organizer or user owner of this event type it's not listed as a team member.
+  const teamMemberPromises = users
+    .filter((user) => {
+      if (user.email === organizerUser.email) return false;
+
+      // Skip non-fixed users in ROUND_ROBIN team event
+      if (schedulingType === SchedulingType.ROUND_ROBIN && !user.isFixed) return false;
+
+      return true;
+    })
+    .map(async (user) => {
+      // TODO: Add back once EventManager tests are ready https://github.com/calcom/cal.com/pull/14610#discussion_r1567817120
+      // push to teamDestinationCalendars if it's a team event but collective only
+      if (schedulingType === "COLLECTIVE" && user.destinationCalendar) {
+        teamDestinationCalendars.push({
+          ...user.destinationCalendar,
+          externalId: processExternalId(user.destinationCalendar),
+        });
+      }
+
+      return {
+        id: user.id,
+        email: user.email ?? "",
+        name: user.name ?? "",
+        firstName: "",
+        lastName: "",
+        timeZone: user.timeZone,
+        language: {
+          translate: await getTranslation(user.locale ?? "en", "common"),
+          locale: user.locale ?? "en",
+        },
+      };
+    });
+
+  const teamMembers = await Promise.all(teamMemberPromises);
+
+  evt = CalendarEventBuilder.fromEvent(evt)
+    .withDestinationCalendar([...(evt.destinationCalendar ?? []), ...teamDestinationCalendars])
+    .build();
+
+  return CalendarEventBuilder.fromEvent(evt)
+    .withTeam({
+      members: teamMembers,
+      name: team?.name || "Nameless",
+      id: team?.id ?? 0,
+    })
+    .build();
+};
+
 function buildTroubleshooterData({
   eventType,
 }: {
@@ -925,36 +999,6 @@ async function handler(
   log.info("event type locations", eventType.locations);
 
   const customInputs = getCustomInputsResponses(reqBody, eventType.customInputs);
-  const teamDestinationCalendars: DestinationCalendar[] = [];
-
-  // Organizer or user owner of this event type it's not listed as a team member.
-  const teamMemberPromises = users
-    .filter((user) => user.email !== organizerUser.email)
-    .map(async (user) => {
-      // TODO: Add back once EventManager tests are ready https://github.com/calcom/cal.com/pull/14610#discussion_r1567817120
-      // push to teamDestinationCalendars if it's a team event but collective only
-      if (isTeamEventType && eventType.schedulingType === "COLLECTIVE" && user.destinationCalendar) {
-        teamDestinationCalendars.push({
-          ...user.destinationCalendar,
-          externalId: processExternalId(user.destinationCalendar),
-        });
-      }
-
-      return {
-        id: user.id,
-        email: user.email ?? "",
-        name: user.name ?? "",
-        firstName: "",
-        lastName: "",
-        timeZone: user.timeZone,
-        language: {
-          translate: await getTranslation(user.locale ?? "en", "common"),
-          locale: user.locale ?? "en",
-        },
-      };
-    });
-  const teamMembers = await Promise.all(teamMemberPromises);
-
   const attendeesList = [...invitee, ...guests];
 
   const responses = reqBody.responses || null;
@@ -1076,10 +1120,14 @@ async function handler(
       .build();
   }
 
-  if (isTeamEventType && eventType.schedulingType === "COLLECTIVE") {
-    evt = CalendarEventBuilder.fromEvent(evt)
-      .withDestinationCalendar([...(evt.destinationCalendar ?? []), ...teamDestinationCalendars])
-      .build();
+  if (isTeamEventType) {
+    evt = await buildEventForTeamEventType({
+      existingEvent: evt,
+      schedulingType: eventType.schedulingType,
+      users,
+      team: eventType.team,
+      organizerUser,
+    });
   }
 
   // data needed for triggering webhooks
@@ -1140,16 +1188,6 @@ async function handler(
     organizerUser.id
   );
 
-  if (isTeamEventType) {
-    evt = CalendarEventBuilder.fromEvent(evt)
-      .withTeam({
-        members: teamMembers,
-        name: eventType.team?.name || "Nameless",
-        id: eventType.team?.id ?? 0,
-      })
-      .build();
-  }
-
   // For seats, if the booking already exists then we want to add the new attendee to the existing booking
   if (eventType.seatsPerTimeSlot) {
     const newBooking = await handleSeats({
diff --git a/packages/features/bookings/lib/handleNewBooking/test/buildEventForTeamEventType.test.ts b/packages/features/bookings/lib/handleNewBooking/test/buildEventForTeamEventType.test.ts
@@ -0,0 +1,144 @@
+// or wherever it's from
+import { vi, describe, it, expect, beforeEach } from "vitest";
+
+import { SchedulingType } from "@calcom/prisma/enums";
+
+import { buildEventForTeamEventType } from "../../handleNewBooking";
+
+vi.mock("@calcom/lib/server/i18n", () => ({
+  getTranslation: vi.fn().mockResolvedValue("translated"),
+}));
+
+const withTeamSpy = vi.fn().mockReturnThis();
+const withDestinationCalendarSpy = vi.fn().mockReturnThis();
+
+vi.mock("@calcom/features/CalendarEventBuilder", () => {
+  return {
+    CalendarEventBuilder: {
+      fromEvent: vi.fn().mockImplementation((evt) => ({
+        withDestinationCalendar: withDestinationCalendarSpy,
+        withTeam: withTeamSpy,
+        build: vi.fn().mockImplementation(() => ({
+          destinationCalendar: [],
+          team: {}, // <- you won’t use this result anyway
+        })),
+      })),
+    },
+  };
+});
+
+vi.mock("@calcom/app-store/_utils/calendars/processExternalId", () => ({
+  default: vi.fn((dc) => `external-${dc?.externalId ?? "id"}`),
+}));
+
+const baseUser = (overrides: Record<string, unknown> = {}) => ({
+  id: 1,
+  name: "Alice",
+  email: "alice@example.com",
+  timeZone: "Europe/Paris",
+  locale: "fr",
+  destinationCalendar: {
+    id: 123,
+    integration: "google",
+    externalId: "ext-123",
+    primaryEmail: "alice@example.com",
+    userId: 1,
+    eventTypeId: null,
+    credentialId: null,
+    delegationCredentialId: null,
+    domainWideDelegationCredentialId: null,
+  },
+  isFixed: true,
+  ...overrides,
+});
+
+describe("buildEventForTeamEventType", () => {
+  it("throws if schedulingType is null", async () => {
+    await expect(
+      buildEventForTeamEventType({
+        existingEvent: {},
+        users: [],
+        organizerUser: { email: "organizer@example.com" },
+        schedulingType: null,
+      })
+    ).rejects.toThrow("Scheduling type is required for team event type");
+  });
+
+  it("filters out the organizer", async () => {
+    const result = await buildEventForTeamEventType({
+      existingEvent: {},
+      users: [baseUser({ email: "organizer@example.com" })],
+      organizerUser: { email: "organizer@example.com" },
+      schedulingType: SchedulingType.COLLECTIVE,
+    });
+
+    const teamArgs = withTeamSpy.mock.calls[0][0];
+    const memberEmails = teamArgs.members.map((m: any) => m.email);
+
+    expect(memberEmails).not.toContain("organizer@example.com");
+  });
+
+  it("includes destinationCalendars for COLLECTIVE", async () => {
+    await buildEventForTeamEventType({
+      existingEvent: { destinationCalendar: [] },
+      users: [baseUser({ id: 2 })],
+      organizerUser: { email: "organizer@example.com" },
+      schedulingType: SchedulingType.COLLECTIVE,
+    });
+
+    const withDestinationCalendarArgs = withDestinationCalendarSpy.mock.calls[0][0];
+
+    expect(withDestinationCalendarArgs).not.toHaveLength(0);
+  });
+
+  it("does not include destinationCalendars for ROUND_ROBIN", async () => {
+    await buildEventForTeamEventType({
+      existingEvent: { destinationCalendar: [] },
+      users: [baseUser({ id: 2 })],
+      organizerUser: { email: "organizer@example.com" },
+      schedulingType: SchedulingType.ROUND_ROBIN,
+    });
+
+    const withDestinationCalendarArgs = withDestinationCalendarSpy.mock.calls[0][0];
+
+    expect(withDestinationCalendarArgs).toHaveLength(0);
+  });
+
+  it("excludes non-fixed users for ROUND_ROBIN", async () => {
+    await buildEventForTeamEventType({
+      existingEvent: {},
+      users: [
+        baseUser({ id: 2, isFixed: false, email: "notfixed@example.com" }),
+        baseUser({ id: 3, isFixed: true, email: "fixed@example.com" }),
+      ],
+      organizerUser: { email: "organizer@example.com" },
+      schedulingType: SchedulingType.ROUND_ROBIN,
+    });
+
+    const teamArgs = withTeamSpy.mock.calls[0][0];
+    const memberEmails = teamArgs.members.map((m: any) => m.email);
+
+    expect(memberEmails).toContain("fixed@example.com");
+    expect(memberEmails).not.toContain("notfixed@example.com");
+  });
+
+  it("builds a team with fallback name and id", async () => {
+    await buildEventForTeamEventType({
+      existingEvent: {},
+      users: [baseUser()],
+      organizerUser: { email: "organizer@example.com" },
+      schedulingType: SchedulingType.COLLECTIVE,
+      team: null,
+    });
+
+    // now inspect what was passed into withTeam()
+    const teamArgs = withTeamSpy.mock.calls[0][0];
+
+    expect(teamArgs.name).toBe("Nameless");
+    expect(teamArgs.id).toBe(0);
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+});
diff --git a/packages/features/bookings/lib/handleNewBooking/test/team-bookings/seatedRoundRobin.test.ts b/packages/features/bookings/lib/handleNewBooking/test/team-bookings/seatedRoundRobin.test.ts
