chore: release v4.7.14

## What does this PR do?

<!-- Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change. -->

We were parsing routes based on `eventTypeId` but routes could be pointing to the same event type. This was causing misroutings.

- Fixes #XXXX (GitHub issue number)
- Fixes CAL-XXXX (Linear issue number - should be visible at the bottom of the GitHub issue description)

<!-- Please provide a loom video for visual changes to speed up reviews
 Loom Video: https://www.loom.com/
-->

## Mandatory Tasks (DO NOT REMOVE)

- [x] I have self-reviewed the code (A decent size PR without self-review might be rejected).
- [ ] I have updated the developer docs in /docs if this PR makes changes that would require a [documentation change](https://cal.com/docs). If N/A, write N/A here and check the checkbox.
- [ ] I confirm automated tests are in place that prove my fix is effective or that my feature works.

.env.example

@@ -129,6 +129,10 @@ GOOGLE_LOGIN_ENABLED=false
 # Needed to enable Google Calendar integration and Login with Google
 # @see https://github.com/calcom/cal.com#obtaining-the-google-api-credentials
 GOOGLE_API_CREDENTIALS=
+# Token to verify incoming webhooks from Google Calendar
+GOOGLE_WEBHOOK_TOKEN=
+# Optional URL to override for tunelling webhooks. Defaults to NEXT_PUBLIC_WEBAPP_URL.
+GOOGLE_WEBHOOK_URL=
 
 # Inbox to send user feedback
 SEND_FEEDBACK_EMAIL=
@@ -143,6 +147,8 @@ NEXT_PUBLIC_SENDGRID_SENDER_NAME=
 # Used for capturing exceptions and logging messages
 NEXT_PUBLIC_SENTRY_DSN=
 SENTRY_DEBUG=
+SENTRY_DISABLE_CLIENT_SOURCE_MAPS=
+SENTRY_DISABLE_SERVER_SOURCE_MAPS=
 SENTRY_MAX_SPANS=
 SENTRY_TRACES_SAMPLE_RATE=
 
@@ -342,7 +348,6 @@ AB_TEST_BUCKET_PROBABILITY=50
 # whether we redirect to the future/event-types from event-types or not
 APP_ROUTER_EVENT_TYPES_ENABLED=0
 APP_ROUTER_SETTINGS_DEVELOPER_ENABLED=0
-APP_ROUTER_SETTINGS_ORG_ENABLED=0
 APP_ROUTER_APPS_INSTALLED_CATEGORY_ENABLED=0
 APP_ROUTER_APPS_SLUG_ENABLED=0
 APP_ROUTER_APPS_SLUG_SETUP_ENABLED=0
@@ -408,3 +413,6 @@ NEXT_PUBLIC_WEBSITE_TERMS_URL=
 # NEXT_PUBLIC_LOGGER_LEVEL=3 sets to log info, warn, error and fatal logs.
 # [0: silly & upwards, 1: trace & upwards, 2: debug & upwards, 3: info & upwards, 4: warn & upwards, 5: error & fatal, 6: fatal]
 NEXT_PUBLIC_LOGGER_LEVEL=
+
+# Used to use Replexica SDK, a tool for real-time AI-powered localization
+REPLEXICA_API_KEY=

.github/workflows/draft-release.yml

@@ -0,0 +1,50 @@
+name: Draft release
+run-name: Draft release ${{ inputs.next_version }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      next_version:
+        required: true
+        type: string
+        description: 'Version name'
+
+permissions:
+  contents: write
+
+jobs:
+  draft_release:
+    runs-on: ubuntu-latest
+
+    steps:
+      
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: 'main'
+          token: ${{ secrets.GH_ACCESS_TOKEN }}
+
+      - name: Configure git
+        run: |
+          git config --local user.email "github-actions@github.com"
+          git config --local user.name "GitHub Actions"
+
+      - uses: ./.github/actions/yarn-install
+
+      - name: Bump version
+        run: |
+          cd apps/web
+          yarn version ${{ inputs.next_version }}
+
+      - name: Commit changes
+        run: |
+          git add .
+          git commit -m "chore: release v${{ inputs.next_version }}"
+          git push
+
+      - name: Draft release
+        run: gh release create v$VERSION --generate-notes --draft
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          VERSION: ${{ inputs.next_version }}

.github/workflows/e2e-api-v2.yml

@@ -65,7 +65,6 @@ jobs:
       - uses: actions/checkout@v4
       - uses: ./.github/actions/dangerous-git-checkout
       - uses: ./.github/actions/yarn-install
-      - uses: ./.github/actions/yarn-playwright-install
       - uses: ./.github/actions/cache-db
       - name: Run Tests
         working-directory: apps/api/v2

.github/workflows/on-changes-requested.yml

@@ -0,0 +1,21 @@
+name: Changes Requested
+on:
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  changes-requested:
+    if: github.event.review.state == 'changes_requested'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Explanation
+        run: echo "This workflow triggers a workflow_run; it's necessary because otherwise the repo secrets aren't available for 'pull_request_review' events from externally forked pull requests"
+      - name: Save PR number to context.json
+        run: |
+            printf '{
+              "pr_number": ${{ github.event.pull_request.number }}
+            }' >> context.json
+      - uses: actions/upload-artifact@v3
+        with:
+          name: context.json
+          path: ./

.github/workflows/post-release.yml

@@ -0,0 +1,25 @@
+name: Post release
+on:
+  workflow_dispatch:
+  push:
+    # Pattern matched against refs/tags
+    tags:
+      - "*"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: 'main'
+          token: ${{ secrets.GH_ACCESS_TOKEN }}
+
+      - name: Configure git
+        run: |
+          git config --local user.email "github-actions@github.com"
+          git config --local user.name "GitHub Actions"
+
+      - run: git push origin +main:production

.github/workflows/re-draft.yml

@@ -0,0 +1,104 @@
+name: Re-draft
+on:
+  workflow_run:
+    workflows:
+      - Changes Requested
+    types:
+      - completed
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+  statuses: write
+
+jobs:
+  download-context:
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Download artifact'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            let allArtifacts = await github.rest.actions.listWorkflowRunArtifacts({
+               owner: context.repo.owner,
+               repo: context.repo.repo,
+               run_id: context.payload.workflow_run.id,
+            });
+            
+            let matchArtifact = allArtifacts.data.artifacts.filter((artifact) => {
+              return artifact.name == "context.json"
+            })[0];
+            
+            let download = await github.rest.actions.downloadArtifact({
+               owner: context.repo.owner,
+               repo: context.repo.repo,
+               artifact_id: matchArtifact.id,
+               archive_format: 'zip',
+            });
+            
+            let fs = require('fs');
+            fs.writeFileSync(`${process.env.GITHUB_WORKSPACE}/context.zip`, Buffer.from(download.data));
+            
+      - name: 'Unzip artifact'
+        run: unzip context.zip
+
+      - name: 'Return Parsed JSON'
+        uses: actions/github-script@v7
+        id: return-parsed-json
+        with:
+          script: |
+            let fs = require('fs');
+            let data = fs.readFileSync('./context.json');
+            return JSON.parse(data);
+
+    outputs:
+      pr_number: ${{fromJSON(steps.return-parsed-json.outputs.result).pr_number}}
+
+  re-draft:
+    needs:
+      - download-context
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      statuses: write
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo "This PR was rejected"
+      - name: Convert PR to draft when changes are requested
+        uses: actions/github-script@v7
+        with:
+          script: |
+            async function getPullRequestId() {
+              const pull_number = ${{ needs.download-context.outputs.pr_number }}; 
+              const pullRequest = await github.rest.pulls.get({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                pull_number,
+              });
+              if (!pullRequest.data.node_id) throw new Error(`pullRequestId no found for '${pull_number}'`);
+              return pullRequest.data.node_id;
+            }
+            const query = `
+              mutation($id: ID!) {
+                convertPullRequestToDraft(input: { pullRequestId: $id }) {
+                  pullRequest {
+                    id
+                    number
+                    isDraft
+                  }
+                }
+              }
+            `;
+            const pullRequestId = await getPullRequestId();
+            const variables = {
+              id: pullRequestId,
+            }
+            const response = await github.graphql(query, variables)
+            if (!response.convertPullRequestToDraft) {
+              throw new Error("Failed to convert pull request to draft");
+            }
+            console.info("Pull request successfully converted to draft.");
+            console.info(`Draft conversion response: ${JSON.stringify(response, null, 2)}`);

.github/workflows/release.yml

@@ -1,17 +0,0 @@
-on:
-  workflow_dispatch:
-  push:
-    # Pattern matched against refs/tags
-    tags:
-      - "*" # Push events to every tag not containing /
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: main # Always checkout main even for tagged releases
-          fetch-depth: 0
-          token: ${{ secrets.GH_ACCESS_TOKEN }}
-      - run: git push origin +main:production

.yarn/versions/354f3ba3.yml

@@ -0,0 +1,2 @@
+undecided:
+  - "@calcom/prisma"

.yarn/versions/8f86d7b6.yml

@@ -0,0 +1,8 @@
+undecided:
+  - calcom-monorepo
+  - "@calcom/app-store-cli"
+  - "@calcom/platform-constants"
+  - "@calcom/platform-enums"
+  - "@calcom/platform-types"
+  - "@calcom/platform-utils"
+  - "@calcom/prisma"

.yarn/versions/ab66eddc.yml

@@ -0,0 +1,8 @@
+undecided:
+  - calcom-monorepo
+  - "@calcom/app-store-cli"
+  - "@calcom/platform-constants"
+  - "@calcom/platform-enums"
+  - "@calcom/platform-types"
+  - "@calcom/platform-utils"
+  - "@calcom/prisma"

.yarnrc.yml

@@ -5,5 +5,7 @@ plugins:
     spec: "@yarnpkg/plugin-interactive-tools"
   - path: .yarn/plugins/@yarnpkg/plugin-workspace-tools.cjs
     spec: "@yarnpkg/plugin-workspace-tools"
+  - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
+    spec: "@yarnpkg/plugin-version"
 
 yarnPath: .yarn/releases/yarn-3.4.1.cjs

apps/api/v2/jest-e2e.json

@@ -10,7 +10,7 @@
   "transform": {
     "^.+\\.(t|j)s$": "ts-jest"
   },
-  "setupFiles": ["<rootDir>/test/setEnvVars.ts"],
+  "setupFiles": ["<rootDir>/test/setEnvVars.ts", "jest-date-mock"],
   "reporters": ["default", "jest-summarizing-reporter"],
   "workerIdleMemoryLimit": "512MB",
   "maxWorkers": 2

apps/api/v2/package.json

@@ -11,7 +11,7 @@
     "start": "nest start",
     "dev:build:watch": "yarn workspace @calcom/platform-constants build:watch & yarn workspace @calcom/platform-utils build:watch & yarn workspace @calcom/platform-types build:watch",
     "dev:build": "yarn workspace @calcom/platform-constants build && yarn workspace @calcom/platform-enums build && yarn workspace @calcom/platform-utils build && yarn workspace @calcom/platform-types build ",
-    "dev": "yarn dev:build && docker-compose up -d && yarn copy-swagger-module && yarn start --watch",
+    "dev": "yarn dev:build && ts-node scripts/docker-start.ts && yarn copy-swagger-module && yarn start --watch",
     "dev:no-docker": "yarn dev:build && yarn copy-swagger-module && yarn start --watch",
     "start:debug": "nest start --debug --watch",
     "start:prod": "node ./dist/apps/api/v2/src/main.js",
@@ -29,7 +29,7 @@
     "@axiomhq/winston": "^1.2.0",
     "@calcom/platform-constants": "*",
     "@calcom/platform-enums": "*",
-    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.60",
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.63",
     "@calcom/platform-libraries-0.0.2": "npm:@calcom/platform-libraries@0.0.2",
     "@calcom/platform-types": "*",
     "@calcom/platform-utils": "*",
@@ -87,6 +87,7 @@
     "@types/passport-jwt": "^3.0.13",
     "@types/supertest": "^2.0.12",
     "jest": "^29.7.0",
+    "jest-date-mock": "^1.0.10",
     "prettier": "^2.8.6",
     "source-map-support": "^0.5.21",
     "supertest": "^6.3.3",

apps/api/v2/scripts/docker-start.ts

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+
+function checkCommandExists(command: string): boolean {
+  try {
+    execSync(`${command} --version`, { stdio: "ignore" });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+try {
+  // Check if docker is installed
+  if (!checkCommandExists("docker")) {
+    throw new Error("Docker is not installed");
+  }
+
+  // Try docker compose first (new syntax)
+  try {
+    execSync("docker compose version", { stdio: "ignore" });
+    console.log("Starting containers with docker compose...");
+    execSync("docker compose up -d", { stdio: "inherit" });
+  } catch (e) {
+    // Fall back to docker-compose if the above fails
+    if (checkCommandExists("docker-compose")) {
+      console.log("Starting containers with docker-compose...");
+      execSync("docker-compose up -d", { stdio: "inherit" });
+    } else {
+      throw new Error("Neither 'docker compose' nor 'docker-compose' command is available");
+    }
+  }
+} catch (error) {
+  console.error(`Error: ${error instanceof Error ? error.message : "Unknown error occurred"}`);
+  process.exit(1);
+}

apps/api/v2/src/ee/bookings/2024-04-15/controllers/bookings.controller.ts

@@ -333,7 +333,7 @@ export class BookingsController_2024_04_15 {
   }
 
   private async getOAuthClientsParams(clientId: string): Promise<OAuthRequestParams> {
-    const res = DEFAULT_PLATFORM_PARAMS;
+    const res = { ...DEFAULT_PLATFORM_PARAMS };
     try {
       const client = await this.oAuthClientRepository.getOAuthClient(clientId);
       // fetch oAuthClient from db and use data stored in db to set these values

apps/api/v2/src/ee/bookings/2024-08-13/controllers/api-key-bookings.controller.e2e-spec.ts

@@ -1,160 +0,0 @@
-import { bootstrap } from "@/app";
-import { AppModule } from "@/app.module";
-import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
-import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
-import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
-import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
-import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
-import { PrismaModule } from "@/modules/prisma/prisma.module";
-import { UsersModule } from "@/modules/users/users.module";
-import { INestApplication } from "@nestjs/common";
-import { NestExpressApplication } from "@nestjs/platform-express";
-import { Test } from "@nestjs/testing";
-import { User } from "@prisma/client";
-import * as request from "supertest";
-import { ApiKeysRepositoryFixture } from "test/fixtures/repository/api-keys.repository.fixture";
-import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
-import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
-import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
-import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
-import { withApiAuth } from "test/utils/withApiAuth";
-
-import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
-import { CreateBookingInput_2024_08_13, BookingOutput_2024_08_13 } from "@calcom/platform-types";
-import { Team } from "@calcom/prisma/client";
-
-describe("Bookings Endpoints 2024-08-13", () => {
-  describe("With api key", () => {
-    let app: INestApplication;
-    let organization: Team;
-
-    let userRepositoryFixture: UserRepositoryFixture;
-    let bookingsRepositoryFixture: BookingsRepositoryFixture;
-    let schedulesService: SchedulesService_2024_04_15;
-    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
-    let teamRepositoryFixture: TeamRepositoryFixture;
-    let apiKeysRepositoryFixture: ApiKeysRepositoryFixture;
-    let apiKeyString: string;
-
-    const userEmail = "bookings-controller-e2e@api.com";
-    let user: User;
-
-    let eventTypeId: number;
-
-    beforeAll(async () => {
-      const moduleRef = await withApiAuth(
-        userEmail,
-        Test.createTestingModule({
-          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
-        })
-      )
-        .overrideGuard(PermissionsGuard)
-        .useValue({
-          canActivate: () => true,
-        })
-        .compile();
-
-      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
-      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
-      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
-      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
-      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
-      apiKeysRepositoryFixture = new ApiKeysRepositoryFixture(moduleRef);
-
-      organization = await teamRepositoryFixture.create({ name: "organization bookings" });
-
-      user = await userRepositoryFixture.create({
-        email: userEmail,
-      });
-
-      const { keyString } = await apiKeysRepositoryFixture.createApiKey(user.id, null);
-      apiKeyString = keyString;
-
-      const userSchedule: CreateScheduleInput_2024_04_15 = {
-        name: "working time",
-        timeZone: "Europe/Rome",
-        isDefault: true,
-      };
-      await schedulesService.createUserSchedule(user.id, userSchedule);
-      const event = await eventTypesRepositoryFixture.create(
-        { title: "peer coding", slug: "peer-coding", length: 60 },
-        user.id
-      );
-      eventTypeId = event.id;
-
-      app = moduleRef.createNestApplication();
-      bootstrap(app as NestExpressApplication);
-
-      await app.init();
-    });
-
-    it("should be defined", () => {
-      expect(userRepositoryFixture).toBeDefined();
-      expect(user).toBeDefined();
-    });
-
-    describe("create bookings", () => {
-      it("should create a booking with api key", async () => {
-        const body: CreateBookingInput_2024_08_13 = {
-          start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
-          eventTypeId,
-          attendee: {
-            name: "Mr Key",
-            email: "mr_key@gmail.com",
-            timeZone: "Europe/Rome",
-            language: "it",
-          },
-          meetingUrl: "https://meet.google.com/abc-def-ghi",
-        };
-
-        return request(app.getHttpServer())
-          .post("/v2/bookings")
-          .send(body)
-          .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
-          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
-          .expect(201)
-          .then(async (response) => {
-            const responseBody: CreateBookingOutput_2024_08_13 = response.body;
-            expect(responseBody.status).toEqual(SUCCESS_STATUS);
-            expect(responseBody.data).toBeDefined();
-            expect(responseDataIsBooking(responseBody.data)).toBe(true);
-
-            if (responseDataIsBooking(responseBody.data)) {
-              const data: BookingOutput_2024_08_13 = responseBody.data;
-              expect(data.id).toBeDefined();
-              expect(data.uid).toBeDefined();
-              expect(data.hosts[0].id).toEqual(user.id);
-              expect(data.status).toEqual("accepted");
-              expect(data.start).toEqual(body.start);
-              expect(data.end).toEqual(new Date(Date.UTC(2030, 0, 8, 14, 0, 0)).toISOString());
-              expect(data.duration).toEqual(60);
-              expect(data.eventTypeId).toEqual(eventTypeId);
-              expect(data.attendees[0]).toEqual({
-                name: body.attendee.name,
-                timeZone: body.attendee.timeZone,
-                language: body.attendee.language,
-                absent: false,
-              });
-              expect(data.meetingUrl).toEqual(body.meetingUrl);
-              expect(data.absentHost).toEqual(false);
-            } else {
-              throw new Error(
-                "Invalid response data - expected booking but received array of possibily recurring bookings"
-              );
-            }
-          });
-      });
-    });
-
-    function responseDataIsBooking(data: any): data is BookingOutput_2024_08_13 {
-      return !Array.isArray(data) && typeof data === "object" && data && "id" in data;
-    }
-
-    afterAll(async () => {
-      await teamRepositoryFixture.delete(organization.id);
-      await userRepositoryFixture.deleteByEmail(user.email);
-      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
-      await app.close();
-    });
-  });
-});

apps/api/v2/src/ee/bookings/2024-08-13/controllers/bookings.controller.ts

@@ -191,7 +191,12 @@ export class BookingsController_2024_08_13 {
   @Post("/:bookingUid/cancel")
   @UseGuards(BookingUidGuard)
   @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: "Cancel a booking" })
+  @ApiOperation({
+    summary: "Cancel a booking",
+    description: `:bookingUid can be :bookingUid of an usual booking, individual recurrence or recurring booking to cancel all recurrences.
+    For seated bookings to cancel one individual booking provide :bookingUid and :seatUid in the request body. For recurring seated bookings it is not possible to cancel all of them with 1 call
+    like with non-seated recurring bookings by providing recurring bookind uid - you have to cancel each recurrence booking by its bookingUid + seatUid.`,
+  })
   async cancelBooking(
     @Req() request: Request,
     @Param("bookingUid") bookingUid: string,

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/api-key-bookings.e2e-spec.ts

@@ -0,0 +1,291 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CancelBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/cancel-booking.output";
+import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
+import { RescheduleBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reschedule-booking.output";
+import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
+import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
+import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { User } from "@prisma/client";
+import * as request from "supertest";
+import { ApiKeysRepositoryFixture } from "test/fixtures/repository/api-keys.repository.fixture";
+import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { withApiAuth } from "test/utils/withApiAuth";
+
+import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
+import {
+  AttendeeScheduledEmail,
+  OrganizerScheduledEmail,
+  AttendeeRescheduledEmail,
+  OrganizerRescheduledEmail,
+  AttendeeCancelledEmail,
+  OrganizerCancelledEmail,
+} from "@calcom/platform-libraries";
+import {
+  CreateBookingInput_2024_08_13,
+  BookingOutput_2024_08_13,
+  RescheduleBookingInput_2024_08_13,
+  CancelBookingInput_2024_08_13,
+} from "@calcom/platform-types";
+import { Team } from "@calcom/prisma/client";
+
+jest.spyOn(AttendeeScheduledEmail.prototype as any, "getHtml").mockImplementation(async function () {
+  return "<html><body>Mocked Email Content</body></html>";
+});
+
+jest.spyOn(OrganizerScheduledEmail.prototype as any, "getHtml").mockImplementation(async function () {
+  return "<html><body>Mocked Email Content</body></html>";
+});
+
+jest
+  .spyOn(AttendeeRescheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerRescheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(AttendeeCancelledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerCancelledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+
+describe("Bookings Endpoints 2024-08-13", () => {
+  describe("With api key", () => {
+    let app: INestApplication;
+    let organization: Team;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let bookingsRepositoryFixture: BookingsRepositoryFixture;
+    let schedulesService: SchedulesService_2024_04_15;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+    let teamRepositoryFixture: TeamRepositoryFixture;
+    let apiKeysRepositoryFixture: ApiKeysRepositoryFixture;
+    let apiKeyString: string;
+
+    const userEmail = "bookings-controller-e2e@api.com";
+    let user: User;
+
+    let eventTypeId: number;
+
+    let createdBooking: BookingOutput_2024_08_13;
+    let rescheduledBooking: BookingOutput_2024_08_13;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        userEmail,
+        Test.createTestingModule({
+          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+        })
+      )
+        .overrideGuard(PermissionsGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+      apiKeysRepositoryFixture = new ApiKeysRepositoryFixture(moduleRef);
+
+      organization = await teamRepositoryFixture.create({ name: "organization bookings" });
+
+      user = await userRepositoryFixture.create({
+        email: userEmail,
+      });
+
+      const { keyString } = await apiKeysRepositoryFixture.createApiKey(user.id, null);
+      apiKeyString = keyString;
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(user.id, userSchedule);
+      const event = await eventTypesRepositoryFixture.create(
+        { title: "peer coding", slug: "peer-coding", length: 60 },
+        user.id
+      );
+      eventTypeId = event.id;
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    it("should be defined", () => {
+      expect(userRepositoryFixture).toBeDefined();
+      expect(user).toBeDefined();
+    });
+
+    it("should create a booking with api key", async () => {
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+        eventTypeId,
+        attendee: {
+          name: "Mr Key",
+          email: "mr_key@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        meetingUrl: "https://meet.google.com/abc-def-ghi",
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsBooking(responseBody.data)) {
+            const data: BookingOutput_2024_08_13 = responseBody.data;
+            expect(data.id).toBeDefined();
+            expect(data.uid).toBeDefined();
+            expect(data.hosts[0].id).toEqual(user.id);
+            expect(data.status).toEqual("accepted");
+            expect(data.start).toEqual(body.start);
+            expect(data.end).toEqual(new Date(Date.UTC(2030, 0, 8, 14, 0, 0)).toISOString());
+            expect(data.duration).toEqual(60);
+            expect(data.eventTypeId).toEqual(eventTypeId);
+            expect(data.attendees[0]).toEqual({
+              name: body.attendee.name,
+              timeZone: body.attendee.timeZone,
+              language: body.attendee.language,
+              absent: false,
+            });
+            expect(data.meetingUrl).toEqual(body.meetingUrl);
+            expect(data.absentHost).toEqual(false);
+            expect(AttendeeScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            createdBooking = data;
+          } else {
+            throw new Error(
+              "Invalid response data - expected booking but received array of possibily recurring bookings"
+            );
+          }
+        });
+    });
+
+    it("should reschedule a booking with api key", async () => {
+      const body: RescheduleBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2035, 0, 8, 14, 0, 0)).toISOString(),
+        reschedulingReason: "Flying to mars that day",
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${createdBooking.uid}/reschedule`)
+        .send(body)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsBooking(responseBody.data)) {
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            const data: BookingOutput_2024_08_13 = responseBody.data;
+            expect(data.reschedulingReason).toEqual(body.reschedulingReason);
+            expect(data.start).toEqual(body.start);
+            expect(data.end).toEqual(new Date(Date.UTC(2035, 0, 8, 15, 0, 0)).toISOString());
+            expect(data.rescheduledFromUid).toEqual(createdBooking.uid);
+            expect(data.id).toBeDefined();
+            expect(data.uid).toBeDefined();
+            expect(data.hosts[0].id).toEqual(user.id);
+            expect(data.status).toEqual(createdBooking.status);
+            expect(data.duration).toEqual(createdBooking.duration);
+            expect(data.eventTypeId).toEqual(createdBooking.eventTypeId);
+            expect(data.attendees[0]).toEqual(createdBooking.attendees[0]);
+            expect(data.location).toEqual(createdBooking.location);
+            expect(data.absentHost).toEqual(createdBooking.absentHost);
+            expect(data.metadata).toEqual(createdBooking.metadata);
+            expect(AttendeeRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            rescheduledBooking = data;
+          } else {
+            throw new Error(
+              "Invalid response data - expected booking but received array of possibily recurring bookings"
+            );
+          }
+        });
+    });
+
+    it("should cancel booking", async () => {
+      const body: CancelBookingInput_2024_08_13 = {
+        cancellationReason: "Going on a vacation",
+      };
+
+      const booking = await bookingsRepositoryFixture.getByUid(rescheduledBooking.uid);
+      expect(booking).toBeDefined();
+      expect(booking?.status).toEqual("ACCEPTED");
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${rescheduledBooking.uid}/cancel`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          const data: BookingOutput_2024_08_13 = responseBody.data;
+          expect(data.id).toBeDefined();
+          expect(data.uid).toBeDefined();
+          expect(data.hosts[0].id).toEqual(user.id);
+          expect(data.status).toEqual("cancelled");
+          expect(data.cancellationReason).toEqual(body.cancellationReason);
+          expect(data.start).toEqual(rescheduledBooking.start);
+          expect(data.end).toEqual(rescheduledBooking.end);
+          expect(data.duration).toEqual(rescheduledBooking.duration);
+          expect(data.eventTypeId).toEqual(rescheduledBooking.eventTypeId);
+          expect(data.attendees[0]).toEqual(rescheduledBooking.attendees[0]);
+          expect(data.location).toEqual(rescheduledBooking.location);
+          expect(data.absentHost).toEqual(rescheduledBooking.absentHost);
+
+          const cancelledBooking = await bookingsRepositoryFixture.getByUid(rescheduledBooking.uid);
+          expect(cancelledBooking).toBeDefined();
+          expect(cancelledBooking?.status).toEqual("CANCELLED");
+          expect(AttendeeCancelledEmail.prototype.getHtml).toHaveBeenCalled();
+          expect(OrganizerCancelledEmail.prototype.getHtml).toHaveBeenCalled();
+        });
+    });
+
+    function responseDataIsBooking(data: any): data is BookingOutput_2024_08_13 {
+      return !Array.isArray(data) && typeof data === "object" && data && "id" in data;
+    }
+
+    afterAll(async () => {
+      await teamRepositoryFixture.delete(organization.id);
+      await userRepositoryFixture.deleteByEmail(user.email);
+      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
+      await app.close();
+    });
+  });
+});

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/booking-fields.e2e-spec.ts

@@ -0,0 +1,526 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
+import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
+import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
+import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import * as request from "supertest";
+import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { randomNumber } from "test/utils/randomNumber";
+import { withApiAuth } from "test/utils/withApiAuth";
+
+import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
+import {
+  CreateBookingInput_2024_08_13,
+  GetBookingOutput_2024_08_13,
+  GetSeatedBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
+import { BookingOutput_2024_08_13 } from "@calcom/platform-types";
+import { Booking, PlatformOAuthClient, Team, User } from "@calcom/prisma/client";
+
+const suffix = randomNumber();
+
+describe("Bookings Endpoints 2024-08-13", () => {
+  describe("Booking fields", () => {
+    let app: INestApplication;
+    let organization: Team;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let bookingsRepositoryFixture: BookingsRepositoryFixture;
+    let schedulesService: SchedulesService_2024_04_15;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+    let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+    let oAuthClient: PlatformOAuthClient;
+    let teamRepositoryFixture: TeamRepositoryFixture;
+
+    const userEmail = `alice-${suffix}@api.com`;
+    let user: User;
+
+    let bookingWithSplitName: Booking;
+    const splitName = {
+      firstName: "Oldie",
+      lastName: "Goldie",
+    };
+
+    let seatedBookingWithSplitName: Booking;
+
+    let eventTypeWithBookingFieldsId: number;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        userEmail,
+        Test.createTestingModule({
+          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+        })
+      )
+        .overrideGuard(PermissionsGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+      oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+
+      organization = await teamRepositoryFixture.create({ name: `booking fields ${suffix}` });
+      oAuthClient = await createOAuthClient(organization.id);
+
+      user = await userRepositoryFixture.create({
+        email: userEmail,
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
+      });
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(user.id, userSchedule);
+      const event = await eventTypesRepositoryFixture.create(
+        { title: "peer coding", slug: `normal-booking-${randomNumber()}`, length: 60 },
+        user.id
+      );
+
+      bookingWithSplitName = await bookingsRepositoryFixture.create({
+        user: {
+          connect: {
+            id: user.id,
+          },
+        },
+        startTime: new Date(Date.UTC(2020, 0, 8, 12, 0, 0)),
+        endTime: new Date(Date.UTC(2020, 0, 8, 13, 0, 0)),
+        title: "peer coding lets goo",
+        uid: "booking",
+        eventType: {
+          connect: {
+            id: event.id,
+          },
+        },
+        location: "integrations:daily",
+        customInputs: {},
+        metadata: {},
+        responses: {
+          name: splitName,
+          email: "oldie@gmail.com",
+        },
+        attendees: {
+          create: {
+            email: "oldie@gmail.com",
+            name: "Oldie Goldie",
+            locale: "lv",
+            timeZone: "Europe/Rome",
+          },
+        },
+      });
+
+      const seatedEvent = await eventTypesRepositoryFixture.create(
+        { title: "peer coding", slug: `seated-${randomNumber()}`, length: 60, seatsPerTimeSlot: 3 },
+        user.id
+      );
+
+      seatedBookingWithSplitName = await bookingsRepositoryFixture.create({
+        user: {
+          connect: {
+            id: user.id,
+          },
+        },
+        startTime: new Date(Date.UTC(2020, 0, 8, 14, 0, 0)),
+        endTime: new Date(Date.UTC(2020, 0, 8, 15, 0, 0)),
+        title: "peer coding lets goo",
+        uid: "seated-booking",
+        eventType: {
+          connect: {
+            id: seatedEvent.id,
+          },
+        },
+        location: "integrations:daily",
+        customInputs: {},
+        metadata: {},
+        responses: {
+          name: splitName,
+          email: "oldie@gmail.com",
+        },
+        attendees: {
+          create: {
+            email: "oldie@gmail.com",
+            name: "Oldie Goldie",
+            locale: "lv",
+            timeZone: "Europe/Rome",
+            bookingSeat: {
+              create: {
+                referenceUid: "unique-seat-uid",
+                data: {
+                  responses: {
+                    email: "oldie@gmail.com",
+                    name: {
+                      firstName: "Oldie",
+                      lastName: "Goldie",
+                    },
+                  },
+                },
+                metadata: {},
+                booking: {
+                  connect: {
+                    uid: "seated-booking",
+                  },
+                },
+              },
+            },
+          },
+        },
+      });
+
+      const eventTypeWithBookingFields = await eventTypesRepositoryFixture.create(
+        {
+          title: "peer coding with booking fields",
+          slug: `with-custom-booking-fields-${randomNumber()}`,
+          length: 60,
+          bookingFields: [
+            {
+              name: "name",
+              type: "name",
+              label: "",
+              sources: [
+                {
+                  id: "default",
+                  type: "default",
+                  label: "Default",
+                },
+              ],
+              variant: "fullName",
+              editable: "system",
+              required: true,
+              placeholder: "",
+              defaultLabel: "your_name",
+              variantsConfig: {
+                variants: {
+                  fullName: {
+                    fields: [
+                      {
+                        name: "fullName",
+                        type: "text",
+                        label: "your_name",
+                        required: true,
+                        placeholder: "",
+                      },
+                    ],
+                  },
+                  firstAndLastName: {
+                    fields: [
+                      {
+                        name: "firstName",
+                        type: "text",
+                        label: "name",
+                        required: true,
+                        placeholder: "lauris",
+                      },
+                      {
+                        name: "lastName",
+                        type: "text",
+                        label: "surname",
+                        required: true,
+                        placeholder: "skraucis",
+                      },
+                    ],
+                  },
+                },
+              },
+              disableOnPrefill: false,
+            },
+            {
+              name: "email",
+              type: "email",
+              sources: [
+                {
+                  id: "default",
+                  type: "default",
+                  label: "Default",
+                },
+              ],
+              editable: "system",
+              required: true,
+              defaultLabel: "email_address",
+            },
+            {
+              name: "location",
+              type: "radioInput",
+              sources: [
+                {
+                  id: "default",
+                  type: "default",
+                  label: "Default",
+                },
+              ],
+              editable: "system",
+              required: false,
+              defaultLabel: "location",
+              getOptionsAt: "locations",
+              optionsInputs: {
+                phone: {
+                  type: "phone",
+                  required: true,
+                  placeholder: "",
+                },
+                somewhereElse: {
+                  type: "text",
+                  required: true,
+                  placeholder: "",
+                },
+                attendeeInPerson: {
+                  type: "address",
+                  required: true,
+                  placeholder: "",
+                },
+              },
+              hideWhenJustOneOption: true,
+            },
+            {
+              name: "title",
+              type: "text",
+              hidden: true,
+              sources: [
+                {
+                  id: "default",
+                  type: "default",
+                  label: "Default",
+                },
+              ],
+              editable: "system-but-optional",
+              required: true,
+              defaultLabel: "what_is_this_meeting_about",
+              defaultPlaceholder: "",
+            },
+            {
+              name: "notes",
+              type: "textarea",
+              sources: [
+                {
+                  id: "default",
+                  type: "default",
+                  label: "Default",
+                },
+              ],
+              editable: "system-but-optional",
+              required: false,
+              defaultLabel: "additional_notes",
+              defaultPlaceholder: "share_additional_notes",
+            },
+            {
+              name: "guests",
+              type: "multiemail",
+              hidden: false,
+              sources: [
+                {
+                  id: "default",
+                  type: "default",
+                  label: "Default",
+                },
+              ],
+              editable: "system-but-optional",
+              required: false,
+              defaultLabel: "additional_guests",
+              defaultPlaceholder: "email",
+            },
+            {
+              name: "rescheduleReason",
+              type: "textarea",
+              views: [
+                {
+                  id: "reschedule",
+                  label: "Reschedule View",
+                },
+              ],
+              sources: [
+                {
+                  id: "default",
+                  type: "default",
+                  label: "Default",
+                },
+              ],
+              editable: "system-but-optional",
+              required: false,
+              defaultLabel: "reason_for_reschedule",
+              defaultPlaceholder: "reschedule_placeholder",
+            },
+            {
+              name: "favorite-movie",
+              type: "text",
+              label: "favorite movie",
+              sources: [
+                {
+                  id: "user",
+                  type: "user",
+                  label: "User",
+                  fieldRequired: true,
+                },
+              ],
+              editable: "user",
+              required: true,
+              placeholder: "matrix",
+              disableOnPrefill: false,
+            },
+          ],
+        },
+        user.id
+      );
+      eventTypeWithBookingFieldsId = eventTypeWithBookingFields.id;
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    async function createOAuthClient(organizationId: number) {
+      const data = {
+        logo: "logo-url",
+        name: "name",
+        redirectUris: ["http://localhost:5555"],
+        permissions: 32,
+      };
+      const secret = "secret";
+
+      const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+      return client;
+    }
+
+    describe("get individual booking", () => {
+      it("should should get a seated booking with split name responses", async () => {
+        return request(app.getHttpServer())
+          .get(`/v2/bookings/${bookingWithSplitName.uid}`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: GetBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+            if (responseDataIsBooking(responseBody.data)) {
+              const data: BookingOutput_2024_08_13 = responseBody.data;
+              expect(data.attendees[0].name).toEqual(`${splitName.firstName} ${splitName.lastName}`);
+              expect(data.bookingFieldsResponses.name).toEqual(splitName);
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+
+      it("should should get a seated booking with split name responses", async () => {
+        return request(app.getHttpServer())
+          .get(`/v2/bookings/${seatedBookingWithSplitName.uid}`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: GetBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+            if (responseDataIsBooking(responseBody.data)) {
+              // eslint-disable-next-line
+              // @ts-ignore
+              const data: GetSeatedBookingOutput_2024_08_13 = responseBody.data;
+              console.log("asap data", JSON.stringify(data, null, 2));
+              expect(data.attendees[0].name).toEqual(`${splitName.firstName} ${splitName.lastName}`);
+              expect(data.attendees[0].bookingFieldsResponses.name).toEqual(splitName);
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+    });
+
+    describe("make booking", () => {
+      it("should not be able to book an event type with custom required booking fields if they are missing in bookingFieldsResponses", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+          eventTypeId: eventTypeWithBookingFieldsId,
+          attendee: {
+            name: "Mr Proper",
+            email: "mr_proper@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          location: "https://meet.google.com/abc-def-ghi",
+        };
+        return request(app.getHttpServer())
+          .post(`/v2/bookings`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(400);
+      });
+
+      it("should be able to book an event type with custom required booking fields", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+          eventTypeId: eventTypeWithBookingFieldsId,
+          attendee: {
+            name: "Mr Proper",
+            email: "mr_proper@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          location: "https://meet.google.com/abc-def-ghi",
+          bookingFieldsResponses: {
+            "favorite-movie": "lord of the rings",
+          },
+        };
+        return request(app.getHttpServer())
+          .post(`/v2/bookings`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+            if (responseDataIsBooking(responseBody.data)) {
+              const data: BookingOutput_2024_08_13 = responseBody.data;
+              expect(data.bookingFieldsResponses["favorite-movie"]).toEqual("lord of the rings");
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+    });
+
+    afterAll(async () => {
+      await oauthClientRepositoryFixture.delete(oAuthClient.id);
+      await teamRepositoryFixture.delete(organization.id);
+      await userRepositoryFixture.deleteByEmail(user.email);
+      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
+      await app.close();
+    });
+  });
+
+  function responseDataIsBooking(data: any): data is BookingOutput_2024_08_13 {
+    return !Array.isArray(data) && typeof data === "object" && data && "id" in data;
+  }
+});

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/confirm-bookings.e2e-spec.ts

@@ -1,6 +1,5 @@
 import { bootstrap } from "@/app";
 import { AppModule } from "@/app.module";
-import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
 import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
 import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
 import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
@@ -20,26 +19,9 @@ import { UserRepositoryFixture } from "test/fixtures/repository/users.repository
 import { withApiAuth } from "test/utils/withApiAuth";
 
 import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
-import {
-  AttendeeScheduledEmail,
-  OrganizerScheduledEmail,
-  AttendeeDeclinedEmail,
-} from "@calcom/platform-libraries";
 import { BookingOutput_2024_08_13, GetBookingOutput_2024_08_13 } from "@calcom/platform-types";
 import { Booking, PlatformOAuthClient, Team } from "@calcom/prisma/client";
 
-jest.spyOn(AttendeeScheduledEmail.prototype as any, "getHtml").mockImplementation(async function () {
-  return "<html><body>Mocked Email Content</body></html>";
-});
-
-jest.spyOn(OrganizerScheduledEmail.prototype as any, "getHtml").mockImplementation(async function () {
-  return "<html><body>Mocked Email Content</body></html>";
-});
-
-jest.spyOn(AttendeeDeclinedEmail.prototype as any, "getHtml").mockImplementation(async function () {
-  return "<html><body>Mocked Email Content</body></html>";
-});
-
 describe("Bookings Endpoints 2024-08-13", () => {
   describe("Bookings confirmation", () => {
     let app: INestApplication;
@@ -87,6 +69,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
 
       user = await userRepositoryFixture.create({
         email: userEmail,
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
       const userSchedule: CreateScheduleInput_2024_04_15 = {

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/emails/confirm-emails.e2e-spec.ts

@@ -0,0 +1,474 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CancelBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/cancel-booking.output";
+import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
+import { RescheduleBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reschedule-booking.output";
+import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
+import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
+import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { User } from "@prisma/client";
+import * as request from "supertest";
+import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { withApiAuth } from "test/utils/withApiAuth";
+
+import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
+import {
+  OrganizerScheduledEmail,
+  AttendeeScheduledEmail,
+  OrganizerRescheduledEmail,
+  AttendeeRescheduledEmail,
+  OrganizerCancelledEmail,
+  AttendeeCancelledEmail,
+  AttendeeRequestEmail,
+  OrganizerRequestEmail,
+  AttendeeDeclinedEmail,
+} from "@calcom/platform-libraries";
+import {
+  CreateBookingInput_2024_08_13,
+  BookingOutput_2024_08_13,
+  RescheduleBookingInput_2024_08_13,
+  GetBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
+import { CancelBookingInput_2024_08_13 } from "@calcom/platform-types";
+import { Team } from "@calcom/prisma/client";
+
+jest
+  .spyOn(AttendeeScheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerScheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(AttendeeRescheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerRescheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(AttendeeCancelledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerCancelledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(AttendeeRequestEmail.prototype, "getHtmlRequestEmail")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerRequestEmail.prototype, "getHtmlRequestEmail")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(AttendeeDeclinedEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+
+type EmailSetup = {
+  user: User;
+  eventTypeId: number;
+  createdBookingUid: string;
+  rescheduledBookingUid: string;
+};
+
+describe("Bookings Endpoints 2024-08-13 confirm emails", () => {
+  let app: INestApplication;
+  let organization: Team;
+
+  let userRepositoryFixture: UserRepositoryFixture;
+  let bookingsRepositoryFixture: BookingsRepositoryFixture;
+  let schedulesService: SchedulesService_2024_04_15;
+  let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+  let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+  let teamRepositoryFixture: TeamRepositoryFixture;
+
+  let emailsEnabledSetup: EmailSetup;
+  let emailsDisabledSetup: EmailSetup;
+
+  const authEmail = `admin-${Math.floor(Math.random() * 1000)}@example.com`;
+
+  beforeAll(async () => {
+    const moduleRef = await withApiAuth(
+      authEmail,
+      Test.createTestingModule({
+        imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+      })
+    )
+      .overrideGuard(PermissionsGuard)
+      .useValue({
+        canActivate: () => true,
+      })
+      .compile();
+
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+    bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+    eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+    oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+    teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+    schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+
+    organization = await teamRepositoryFixture.create({ name: "organization bookings" });
+
+    await setupEnabledEmails();
+    await setupDisabledEmails();
+
+    await userRepositoryFixture.create({
+      email: authEmail,
+      organization: {
+        connect: {
+          id: organization.id,
+        },
+      },
+      role: "ADMIN",
+    });
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    await app.init();
+  });
+
+  async function setupEnabledEmails() {
+    const oAuthClientEmailsEnabled = await createOAuthClient(organization.id, true);
+
+    const user = await userRepositoryFixture.create({
+      email: `alice-${Math.floor(Math.random() * 1000)}@gmail.com`,
+      platformOAuthClients: {
+        connect: {
+          id: oAuthClientEmailsEnabled.id,
+        },
+      },
+    });
+
+    const userSchedule: CreateScheduleInput_2024_04_15 = {
+      name: "working time",
+      timeZone: "Europe/Rome",
+      isDefault: true,
+    };
+    await schedulesService.createUserSchedule(user.id, userSchedule);
+
+    const event = await eventTypesRepositoryFixture.create(
+      { title: "peer coding", slug: "peer-coding", length: 60, requiresConfirmation: true },
+      user.id
+    );
+
+    emailsEnabledSetup = {
+      user,
+      eventTypeId: event.id,
+      createdBookingUid: "",
+      rescheduledBookingUid: "",
+    };
+  }
+
+  async function setupDisabledEmails() {
+    const oAuthClientEmailsDisabled = await createOAuthClient(organization.id, false);
+
+    const user = await userRepositoryFixture.create({
+      email: `bob-${Math.floor(Math.random() * 1000)}@gmail.com`,
+      platformOAuthClients: {
+        connect: {
+          id: oAuthClientEmailsDisabled.id,
+        },
+      },
+    });
+    const userSchedule: CreateScheduleInput_2024_04_15 = {
+      name: "working time",
+      timeZone: "Europe/Rome",
+      isDefault: true,
+    };
+    await schedulesService.createUserSchedule(user.id, userSchedule);
+    const event = await eventTypesRepositoryFixture.create(
+      { title: "peer coding", slug: "peer-coding", length: 60, requiresConfirmation: true },
+      user.id
+    );
+
+    emailsDisabledSetup = {
+      user,
+      eventTypeId: event.id,
+      createdBookingUid: "",
+      rescheduledBookingUid: "",
+    };
+  }
+
+  async function createOAuthClient(organizationId: number, emailsEnabled: boolean) {
+    const data = {
+      logo: "logo-url",
+      name: "name",
+      redirectUris: ["http://localhost:5555"],
+      permissions: 32,
+      areEmailsEnabled: emailsEnabled,
+    };
+    const secret = "secret";
+
+    const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+    return client;
+  }
+
+  describe("OAuth client managed user bookings - emails disabled", () => {
+    beforeEach(async () => {
+      jest.clearAllMocks();
+    });
+
+    it("should not send an email when creating a booking that requires confirmation", async () => {
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+        eventTypeId: emailsDisabledSetup.eventTypeId,
+        attendee: {
+          name: "Mr Proper",
+          email: "mr_proper@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        bookingFieldsResponses: {
+          customField: "customValue",
+        },
+        metadata: {
+          userId: "100",
+        },
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          if (responseDataIsBooking(responseBody.data)) {
+            expect(responseBody.data.status).toEqual("pending");
+            expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(AttendeeRequestEmail.prototype.getHtmlRequestEmail).not.toHaveBeenCalled();
+            expect(OrganizerRequestEmail.prototype.getHtmlRequestEmail).not.toHaveBeenCalled();
+            emailsDisabledSetup.createdBookingUid = responseBody.data.uid;
+          } else {
+            throw new Error(
+              "Invalid response data - expected booking but received array of possibily recurring bookings"
+            );
+          }
+        });
+    });
+
+    it("should not send an email when confirming a booking", async () => {
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${emailsDisabledSetup.createdBookingUid}/confirm`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: GetBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          emailsDisabledSetup.rescheduledBookingUid = responseBody.data.uid;
+        });
+    });
+
+    it("should not send an email when creating a booking that requires confirmation", async () => {
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 10, 0, 0)).toISOString(),
+        eventTypeId: emailsDisabledSetup.eventTypeId,
+        attendee: {
+          name: "Mr Proper",
+          email: "mr_proper@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        bookingFieldsResponses: {
+          customField: "customValue",
+        },
+        metadata: {
+          userId: "100",
+        },
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          if (responseDataIsBooking(responseBody.data)) {
+            expect(responseBody.data.status).toEqual("pending");
+            expect(AttendeeRequestEmail.prototype.getHtmlRequestEmail).not.toHaveBeenCalled();
+            expect(OrganizerRequestEmail.prototype.getHtmlRequestEmail).not.toHaveBeenCalled();
+            emailsDisabledSetup.createdBookingUid = responseBody.data.uid;
+          } else {
+            throw new Error(
+              "Invalid response data - expected booking but received array of possibily recurring bookings"
+            );
+          }
+        });
+    });
+
+    it("should not send an email when declining a booking", async () => {
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${emailsDisabledSetup.createdBookingUid}/decline`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: GetBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(AttendeeDeclinedEmail.prototype.getHtml).not.toHaveBeenCalled();
+
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          emailsDisabledSetup.rescheduledBookingUid = responseBody.data.uid;
+        });
+    });
+  });
+
+  describe("OAuth client managed user bookings - emails enabled", () => {
+    beforeEach(async () => {
+      jest.clearAllMocks();
+    });
+
+    it("should send an email when creating a booking that requires confirmation", async () => {
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+        eventTypeId: emailsEnabledSetup.eventTypeId,
+        attendee: {
+          name: "Mr Proper",
+          email: "mr_proper@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        bookingFieldsResponses: {
+          customField: "customValue",
+        },
+        metadata: {
+          userId: "100",
+        },
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          if (responseDataIsBooking(responseBody.data)) {
+            expect(responseBody.data.status).toEqual("pending");
+            expect(AttendeeRequestEmail.prototype.getHtmlRequestEmail).toHaveBeenCalled();
+            expect(OrganizerRequestEmail.prototype.getHtmlRequestEmail).toHaveBeenCalled();
+            emailsEnabledSetup.createdBookingUid = responseBody.data.uid;
+          } else {
+            throw new Error(
+              "Invalid response data - expected booking but received array of possibily recurring bookings"
+            );
+          }
+        });
+    });
+
+    it("should send an email when confirming a booking", async () => {
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${emailsEnabledSetup.createdBookingUid}/confirm`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: GetBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(AttendeeScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+          expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          emailsEnabledSetup.rescheduledBookingUid = responseBody.data.uid;
+        });
+    });
+
+    it("should send an email when creating a booking that requires confirmation", async () => {
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 10, 0, 0)).toISOString(),
+        eventTypeId: emailsEnabledSetup.eventTypeId,
+        attendee: {
+          name: "Mr Proper",
+          email: "mr_proper@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        bookingFieldsResponses: {
+          customField: "customValue",
+        },
+        metadata: {
+          userId: "100",
+        },
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          if (responseDataIsBooking(responseBody.data)) {
+            expect(responseBody.data.status).toEqual("pending");
+            expect(AttendeeRequestEmail.prototype.getHtmlRequestEmail).toHaveBeenCalled();
+            expect(OrganizerRequestEmail.prototype.getHtmlRequestEmail).toHaveBeenCalled();
+            emailsEnabledSetup.createdBookingUid = responseBody.data.uid;
+          } else {
+            throw new Error(
+              "Invalid response data - expected booking but received array of possibily recurring bookings"
+            );
+          }
+        });
+    });
+
+    it("should send an email when declining a booking", async () => {
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${emailsEnabledSetup.createdBookingUid}/decline`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: GetBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(AttendeeDeclinedEmail.prototype.getHtml).toHaveBeenCalled();
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          emailsEnabledSetup.rescheduledBookingUid = responseBody.data.uid;
+        });
+    });
+  });
+
+  afterAll(async () => {
+    await teamRepositoryFixture.delete(organization.id);
+    await userRepositoryFixture.deleteByEmail(emailsEnabledSetup.user.email);
+    await userRepositoryFixture.deleteByEmail(emailsDisabledSetup.user.email);
+    await userRepositoryFixture.deleteByEmail(authEmail);
+    await bookingsRepositoryFixture.deleteAllBookings(
+      emailsEnabledSetup.user.id,
+      emailsEnabledSetup.user.email
+    );
+    await bookingsRepositoryFixture.deleteAllBookings(
+      emailsDisabledSetup.user.id,
+      emailsDisabledSetup.user.email
+    );
+    await app.close();
+  });
+
+  function responseDataIsBooking(data: any): data is BookingOutput_2024_08_13 {
+    return !Array.isArray(data) && typeof data === "object" && data && "id" in data;
+  }
+});

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/emails/team-emails.e2e-spec.ts

@@ -0,0 +1,979 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CancelBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/cancel-booking.output";
+import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
+import { RescheduleBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reschedule-booking.output";
+import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
+import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
+import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { createParamDecorator, INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { User } from "@prisma/client";
+import * as request from "supertest";
+import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { HostsRepositoryFixture } from "test/fixtures/repository/hosts.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { withApiAuth } from "test/utils/withApiAuth";
+
+import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
+import {
+  OrganizerScheduledEmail,
+  AttendeeScheduledEmail,
+  OrganizerRescheduledEmail,
+  AttendeeRescheduledEmail,
+  OrganizerCancelledEmail,
+  AttendeeCancelledEmail,
+  OrganizerReassignedEmail,
+} from "@calcom/platform-libraries";
+import {
+  CreateBookingInput_2024_08_13,
+  BookingOutput_2024_08_13,
+  RescheduleBookingInput_2024_08_13,
+} from "@calcom/platform-types";
+import { CancelBookingInput_2024_08_13 } from "@calcom/platform-types";
+import { Team } from "@calcom/prisma/client";
+
+jest
+  .spyOn(AttendeeScheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerScheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(AttendeeRescheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerRescheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(AttendeeCancelledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerCancelledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+
+jest
+  .spyOn(OrganizerReassignedEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+
+type EmailSetup = {
+  team: Team;
+  member1: User;
+  member2: User;
+  collectiveEventType: {
+    id: number;
+    createdBookingUid: string;
+    rescheduledBookingUid: string;
+  };
+  roundRobinEventType: {
+    id: number;
+    createdBookingUid: string;
+    rescheduledBookingUid: string;
+    currentHostId: number;
+  };
+};
+
+describe("Bookings Endpoints 2024-08-13 team emails", () => {
+  let app: INestApplication;
+  let organization: Team;
+
+  let userRepositoryFixture: UserRepositoryFixture;
+  let bookingsRepositoryFixture: BookingsRepositoryFixture;
+  let schedulesService: SchedulesService_2024_04_15;
+  let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+  let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+  let teamRepositoryFixture: TeamRepositoryFixture;
+  let profileRepositoryFixture: ProfileRepositoryFixture;
+  let membershipsRepositoryFixture: MembershipRepositoryFixture;
+  let hostsRepositoryFixture: HostsRepositoryFixture;
+
+  let emailsEnabledSetup: EmailSetup;
+  let emailsDisabledSetup: EmailSetup;
+
+  const authEmail = "admin@example.com";
+
+  beforeAll(async () => {
+    const moduleRef = await withApiAuth(
+      authEmail,
+      Test.createTestingModule({
+        imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+      })
+    )
+      .overrideGuard(PermissionsGuard)
+      .useValue({
+        canActivate: () => true,
+      })
+      .compile();
+
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+    bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+    eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+    oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+    teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+    profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+    membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+    hostsRepositoryFixture = new HostsRepositoryFixture(moduleRef);
+    schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+
+    organization = await teamRepositoryFixture.create({ name: "organization bookings" });
+
+    await setupEnabledEmails();
+    await setupDisabledEmails();
+
+    await userRepositoryFixture.create({
+      email: authEmail,
+      organization: {
+        connect: {
+          id: organization.id,
+        },
+      },
+    });
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    await app.init();
+  });
+
+  async function setupEnabledEmails() {
+    const oAuthClientEmailsEnabled = await createOAuthClient(organization.id, true);
+
+    const team = await teamRepositoryFixture.create({
+      name: "team 1",
+      isOrganization: false,
+      parent: { connect: { id: organization.id } },
+      createdByOAuthClient: {
+        connect: {
+          id: oAuthClientEmailsEnabled.id,
+        },
+      },
+    });
+
+    const member1 = await userRepositoryFixture.create({
+      email: "alice@gmail.com",
+      platformOAuthClients: {
+        connect: {
+          id: oAuthClientEmailsEnabled.id,
+        },
+      },
+    });
+
+    const member2 = await userRepositoryFixture.create({
+      email: "bob@gmail.com",
+      platformOAuthClients: {
+        connect: {
+          id: oAuthClientEmailsEnabled.id,
+        },
+      },
+    });
+
+    const userSchedule: CreateScheduleInput_2024_04_15 = {
+      name: "working time",
+      timeZone: "Europe/Rome",
+      isDefault: true,
+    };
+    await schedulesService.createUserSchedule(member1.id, userSchedule);
+    await schedulesService.createUserSchedule(member2.id, userSchedule);
+
+    await profileRepositoryFixture.create({
+      uid: `usr-${member1.id}`,
+      username: member1.email,
+      organization: {
+        connect: {
+          id: organization.id,
+        },
+      },
+      user: {
+        connect: {
+          id: member1.id,
+        },
+      },
+    });
+
+    await profileRepositoryFixture.create({
+      uid: `usr-${member2.id}`,
+      username: member2.email,
+      organization: {
+        connect: {
+          id: organization.id,
+        },
+      },
+      user: {
+        connect: {
+          id: member2.id,
+        },
+      },
+    });
+
+    await membershipsRepositoryFixture.create({
+      role: "MEMBER",
+      user: { connect: { id: member1.id } },
+      team: { connect: { id: team.id } },
+      accepted: true,
+    });
+
+    await membershipsRepositoryFixture.create({
+      role: "MEMBER",
+      user: { connect: { id: member2.id } },
+      team: { connect: { id: team.id } },
+      accepted: true,
+    });
+
+    const collectiveEvent = await eventTypesRepositoryFixture.createTeamEventType({
+      schedulingType: "COLLECTIVE",
+      team: {
+        connect: { id: team.id },
+      },
+      title: "Collective Event Type",
+      slug: "collective-event-type",
+      length: 60,
+      assignAllTeamMembers: true,
+      bookingFields: [],
+      locations: [],
+    });
+
+    await hostsRepositoryFixture.create({
+      isFixed: true,
+      user: {
+        connect: {
+          id: member1.id,
+        },
+      },
+      eventType: {
+        connect: {
+          id: collectiveEvent.id,
+        },
+      },
+    });
+
+    await hostsRepositoryFixture.create({
+      isFixed: true,
+      user: {
+        connect: {
+          id: member2.id,
+        },
+      },
+      eventType: {
+        connect: {
+          id: collectiveEvent.id,
+        },
+      },
+    });
+
+    const roundRobinEvent = await eventTypesRepositoryFixture.createTeamEventType({
+      schedulingType: "ROUND_ROBIN",
+      team: {
+        connect: { id: team.id },
+      },
+      title: "Round Robin Event Type",
+      slug: "round-robin-event-type",
+      length: 60,
+      assignAllTeamMembers: false,
+      bookingFields: [],
+      locations: [],
+    });
+
+    await hostsRepositoryFixture.create({
+      isFixed: false,
+      user: {
+        connect: {
+          id: member1.id,
+        },
+      },
+      eventType: {
+        connect: {
+          id: roundRobinEvent.id,
+        },
+      },
+    });
+
+    await hostsRepositoryFixture.create({
+      isFixed: false,
+      user: {
+        connect: {
+          id: member2.id,
+        },
+      },
+      eventType: {
+        connect: {
+          id: roundRobinEvent.id,
+        },
+      },
+    });
+
+    emailsEnabledSetup = {
+      team,
+      member1: member1,
+      member2: member2,
+      collectiveEventType: {
+        id: collectiveEvent.id,
+        createdBookingUid: "",
+        rescheduledBookingUid: "",
+      },
+      roundRobinEventType: {
+        id: roundRobinEvent.id,
+        createdBookingUid: "",
+        rescheduledBookingUid: "",
+        currentHostId: 0,
+      },
+    };
+  }
+
+  async function setupDisabledEmails() {
+    const oAuthClientEmailsDisabled = await createOAuthClient(organization.id, false);
+
+    const team = await teamRepositoryFixture.create({
+      name: "team 2",
+      isOrganization: false,
+      parent: { connect: { id: organization.id } },
+      createdByOAuthClient: {
+        connect: {
+          id: oAuthClientEmailsDisabled.id,
+        },
+      },
+    });
+
+    const member1 = await userRepositoryFixture.create({
+      email: "charlie@gmail.com",
+      platformOAuthClients: {
+        connect: {
+          id: oAuthClientEmailsDisabled.id,
+        },
+      },
+    });
+
+    const member2 = await userRepositoryFixture.create({
+      email: "dean@gmail.com",
+      platformOAuthClients: {
+        connect: {
+          id: oAuthClientEmailsDisabled.id,
+        },
+      },
+    });
+
+    const userSchedule: CreateScheduleInput_2024_04_15 = {
+      name: "working time",
+      timeZone: "Europe/Rome",
+      isDefault: true,
+    };
+    await schedulesService.createUserSchedule(member1.id, userSchedule);
+    await schedulesService.createUserSchedule(member2.id, userSchedule);
+
+    await profileRepositoryFixture.create({
+      uid: `usr-${member1.id}`,
+      username: member1.email,
+      organization: {
+        connect: {
+          id: organization.id,
+        },
+      },
+      user: {
+        connect: {
+          id: member1.id,
+        },
+      },
+    });
+
+    await profileRepositoryFixture.create({
+      uid: `usr-${member2.id}`,
+      username: member2.email,
+      organization: {
+        connect: {
+          id: organization.id,
+        },
+      },
+      user: {
+        connect: {
+          id: member2.id,
+        },
+      },
+    });
+
+    await membershipsRepositoryFixture.create({
+      role: "MEMBER",
+      user: { connect: { id: member1.id } },
+      team: { connect: { id: team.id } },
+      accepted: true,
+    });
+
+    await membershipsRepositoryFixture.create({
+      role: "MEMBER",
+      user: { connect: { id: member2.id } },
+      team: { connect: { id: team.id } },
+      accepted: true,
+    });
+
+    const collectiveEvent = await eventTypesRepositoryFixture.createTeamEventType({
+      schedulingType: "COLLECTIVE",
+      team: {
+        connect: { id: team.id },
+      },
+      title: "Collective Event Type",
+      slug: "collective-event-type",
+      length: 60,
+      assignAllTeamMembers: true,
+      bookingFields: [],
+      locations: [],
+    });
+
+    await hostsRepositoryFixture.create({
+      isFixed: true,
+      user: {
+        connect: {
+          id: member1.id,
+        },
+      },
+      eventType: {
+        connect: {
+          id: collectiveEvent.id,
+        },
+      },
+    });
+
+    await hostsRepositoryFixture.create({
+      isFixed: true,
+      user: {
+        connect: {
+          id: member2.id,
+        },
+      },
+      eventType: {
+        connect: {
+          id: collectiveEvent.id,
+        },
+      },
+    });
+
+    const roundRobinEvent = await eventTypesRepositoryFixture.createTeamEventType({
+      schedulingType: "ROUND_ROBIN",
+      team: {
+        connect: { id: team.id },
+      },
+      title: "Round Robin Event Type",
+      slug: "round-robin-event-type",
+      length: 60,
+      assignAllTeamMembers: false,
+      bookingFields: [],
+      locations: [],
+    });
+
+    await hostsRepositoryFixture.create({
+      isFixed: false,
+      user: {
+        connect: {
+          id: member1.id,
+        },
+      },
+      eventType: {
+        connect: {
+          id: roundRobinEvent.id,
+        },
+      },
+    });
+
+    await hostsRepositoryFixture.create({
+      isFixed: false,
+      user: {
+        connect: {
+          id: member2.id,
+        },
+      },
+      eventType: {
+        connect: {
+          id: roundRobinEvent.id,
+        },
+      },
+    });
+
+    emailsDisabledSetup = {
+      team,
+      member1: member1,
+      member2: member2,
+      collectiveEventType: {
+        id: collectiveEvent.id,
+        createdBookingUid: "",
+        rescheduledBookingUid: "",
+      },
+      roundRobinEventType: {
+        id: roundRobinEvent.id,
+        createdBookingUid: "",
+        rescheduledBookingUid: "",
+        currentHostId: 0,
+      },
+    };
+  }
+
+  async function createOAuthClient(organizationId: number, emailsEnabled: boolean) {
+    const data = {
+      logo: "logo-url",
+      name: "name",
+      redirectUris: ["http://localhost:5555"],
+      permissions: 32,
+      areEmailsEnabled: emailsEnabled,
+    };
+    const secret = "secret";
+
+    const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+    return client;
+  }
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+  });
+
+  describe("OAuth client team bookings - emails disabled", () => {
+    describe("book", () => {
+      it("should not send an email when booking collective event", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 9, 0, 0)).toISOString(),
+          eventTypeId: emailsDisabledSetup.collectiveEventType.id,
+          attendee: {
+            name: "Mr Proper",
+            email: "mr_proper@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          location: "https://meet.google.com/abc-def-ghi",
+          bookingFieldsResponses: {
+            customField: "customValue",
+          },
+          metadata: {
+            userId: "100",
+          },
+        };
+
+        return request(app.getHttpServer())
+          .post("/v2/bookings")
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            if (responseDataIsBooking(responseBody.data)) {
+              expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+              expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+              emailsDisabledSetup.collectiveEventType.createdBookingUid = responseBody.data.uid;
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+
+      it("should not send an email when booking round robin event", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 10, 0, 0)).toISOString(),
+          eventTypeId: emailsDisabledSetup.roundRobinEventType.id,
+          attendee: {
+            name: "Mr Proper",
+            email: "mr_proper@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          location: "https://meet.google.com/abc-def-ghi",
+          bookingFieldsResponses: {
+            customField: "customValue",
+          },
+          metadata: {
+            userId: "100",
+          },
+        };
+
+        return request(app.getHttpServer())
+          .post("/v2/bookings")
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            if (responseDataIsBooking(responseBody.data)) {
+              expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+              expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+              emailsDisabledSetup.roundRobinEventType.createdBookingUid = responseBody.data.uid;
+              emailsDisabledSetup.roundRobinEventType.currentHostId = responseBody.data.hosts[0].id;
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+    });
+
+    describe("reschedule", () => {
+      it("should not send an email when rescheduling collective booking", async () => {
+        const body: RescheduleBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2035, 0, 8, 11, 0, 0)).toISOString(),
+          reschedulingReason: "Flying to mars that day",
+        };
+
+        return request(app.getHttpServer())
+          .post(`/v2/bookings/${emailsDisabledSetup.collectiveEventType.createdBookingUid}/reschedule`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(AttendeeRescheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerRescheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            emailsDisabledSetup.collectiveEventType.rescheduledBookingUid = responseBody.data.uid;
+          });
+      });
+
+      it("should not send an email when rescheduling round robin booking", async () => {
+        const body: RescheduleBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2035, 0, 8, 12, 0, 0)).toISOString(),
+          reschedulingReason: "Flying to mars that day",
+        };
+
+        return request(app.getHttpServer())
+          .post(`/v2/bookings/${emailsDisabledSetup.roundRobinEventType.createdBookingUid}/reschedule`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(AttendeeRescheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerRescheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            emailsDisabledSetup.roundRobinEventType.rescheduledBookingUid = responseBody.data.uid;
+            emailsDisabledSetup.roundRobinEventType.currentHostId = responseBody.data.hosts[0].id;
+          });
+      });
+    });
+
+    describe("reassign", () => {
+      it("should not send an email when manually reassigning round robin booking", async () => {
+        const reassignToId =
+          emailsDisabledSetup.roundRobinEventType.currentHostId === emailsDisabledSetup.member1.id
+            ? emailsDisabledSetup.member2.id
+            : emailsDisabledSetup.member1.id;
+
+        return request(app.getHttpServer())
+          .post(
+            `/v2/bookings/${emailsDisabledSetup.roundRobinEventType.rescheduledBookingUid}/reassign/${reassignToId}`
+          )
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            emailsDisabledSetup.roundRobinEventType.currentHostId = reassignToId;
+          });
+      });
+
+      it("should not send an email when automatically reassigning round robin booking", async () => {
+        return request(app.getHttpServer())
+          .post(`/v2/bookings/${emailsDisabledSetup.roundRobinEventType.rescheduledBookingUid}/reassign`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerReassignedEmail.prototype.getHtml).not.toHaveBeenCalled();
+          });
+      });
+    });
+
+    describe("cancel", () => {
+      it("should not send an email when cancelling a collective booking", async () => {
+        const body: CancelBookingInput_2024_08_13 = {
+          cancellationReason: "Going on a vacation",
+        };
+
+        return request(app.getHttpServer())
+          .post(`/v2/bookings/${emailsDisabledSetup.collectiveEventType.rescheduledBookingUid}/cancel`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          });
+      });
+    });
+
+    it("should not send an email when cancelling a round robin booking", async () => {
+      const body: CancelBookingInput_2024_08_13 = {
+        cancellationReason: "Going on a vacation",
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${emailsDisabledSetup.roundRobinEventType.rescheduledBookingUid}/cancel`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(AttendeeCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          expect(OrganizerCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+        });
+    });
+  });
+
+  describe("OAuth client team bookings - emails enabled", () => {
+    beforeEach(async () => {
+      jest.clearAllMocks();
+    });
+
+    describe("book", () => {
+      it("should send an email when booking collective event", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 9, 0, 0)).toISOString(),
+          eventTypeId: emailsEnabledSetup.collectiveEventType.id,
+          attendee: {
+            name: "Mr Proper",
+            email: "mr_proper@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          location: "https://meet.google.com/abc-def-ghi",
+          bookingFieldsResponses: {
+            customField: "customValue",
+          },
+          metadata: {
+            userId: "100",
+          },
+        };
+
+        return request(app.getHttpServer())
+          .post("/v2/bookings")
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            if (responseDataIsBooking(responseBody.data)) {
+              expect(AttendeeScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+              expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+              emailsEnabledSetup.collectiveEventType.createdBookingUid = responseBody.data.uid;
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+
+      it("should send an email when booking round robin event", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 10, 0, 0)).toISOString(),
+          eventTypeId: emailsEnabledSetup.roundRobinEventType.id,
+          attendee: {
+            name: "Mr Proper",
+            email: "mr_proper@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          location: "https://meet.google.com/abc-def-ghi",
+          bookingFieldsResponses: {
+            customField: "customValue",
+          },
+          metadata: {
+            userId: "100",
+          },
+        };
+
+        return request(app.getHttpServer())
+          .post("/v2/bookings")
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            if (responseDataIsBooking(responseBody.data)) {
+              expect(AttendeeScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+              expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+              emailsEnabledSetup.roundRobinEventType.createdBookingUid = responseBody.data.uid;
+              emailsEnabledSetup.roundRobinEventType.currentHostId = responseBody.data.hosts[0].id;
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+    });
+
+    describe("reschedule", () => {
+      it("should send an email when rescheduling collective booking", async () => {
+        const body: RescheduleBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2035, 0, 8, 11, 0, 0)).toISOString(),
+          reschedulingReason: "Flying to mars that day",
+        };
+
+        return request(app.getHttpServer())
+          .post(`/v2/bookings/${emailsEnabledSetup.collectiveEventType.createdBookingUid}/reschedule`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(AttendeeRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            emailsEnabledSetup.collectiveEventType.rescheduledBookingUid = responseBody.data.uid;
+          });
+      });
+
+      it("should send an email when rescheduling round robin booking", async () => {
+        const body: RescheduleBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2035, 0, 8, 12, 0, 0)).toISOString(),
+          reschedulingReason: "Flying to mars that day",
+        };
+
+        return request(app.getHttpServer())
+          .post(`/v2/bookings/${emailsEnabledSetup.roundRobinEventType.createdBookingUid}/reschedule`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(AttendeeRescheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+
+            expect(OrganizerRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerCancelledEmail.prototype.getHtml).toHaveBeenCalled();
+            emailsEnabledSetup.roundRobinEventType.rescheduledBookingUid = responseBody.data.uid;
+            emailsEnabledSetup.roundRobinEventType.currentHostId = responseBody.data.hosts[0].id;
+          });
+      });
+    });
+
+    describe("reassign", () => {
+      it("should send an email when manually reassigning round robin booking", async () => {
+        const reassignToId =
+          emailsEnabledSetup.roundRobinEventType.currentHostId === emailsEnabledSetup.member1.id
+            ? emailsEnabledSetup.member2.id
+            : emailsEnabledSetup.member1.id;
+
+        return request(app.getHttpServer())
+          .post(
+            `/v2/bookings/${emailsEnabledSetup.roundRobinEventType.rescheduledBookingUid}/reassign/${reassignToId}`
+          )
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            emailsDisabledSetup.roundRobinEventType.currentHostId = reassignToId;
+          });
+      });
+
+      it("should send an email when automatically reassigning round robin booking", async () => {
+        return request(app.getHttpServer())
+          .post(`/v2/bookings/${emailsEnabledSetup.roundRobinEventType.rescheduledBookingUid}/reassign`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerReassignedEmail.prototype.getHtml).toHaveBeenCalled();
+          });
+      });
+    });
+
+    describe("cancel", () => {
+      it("should send an email when cancelling a collective booking", async () => {
+        const body: CancelBookingInput_2024_08_13 = {
+          cancellationReason: "Going on a vacation",
+        };
+
+        return request(app.getHttpServer())
+          .post(`/v2/bookings/${emailsEnabledSetup.collectiveEventType.rescheduledBookingUid}/cancel`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeCancelledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerCancelledEmail.prototype.getHtml).toHaveBeenCalled();
+          });
+      });
+
+      it("should send an email when cancelling round robin booking", async () => {
+        const body: CancelBookingInput_2024_08_13 = {
+          cancellationReason: "Going on a vacation",
+        };
+
+        return request(app.getHttpServer())
+          .post(`/v2/bookings/${emailsEnabledSetup.roundRobinEventType.rescheduledBookingUid}/cancel`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            expect(AttendeeCancelledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerCancelledEmail.prototype.getHtml).toHaveBeenCalled();
+          });
+      });
+    });
+  });
+  afterAll(async () => {
+    await teamRepositoryFixture.delete(organization.id);
+    await userRepositoryFixture.deleteByEmail(emailsEnabledSetup.member1.email);
+    await userRepositoryFixture.deleteByEmail(emailsDisabledSetup.member1.email);
+    await bookingsRepositoryFixture.deleteAllBookings(
+      emailsEnabledSetup.member1.id,
+      emailsEnabledSetup.member1.email
+    );
+    await bookingsRepositoryFixture.deleteAllBookings(
+      emailsDisabledSetup.member1.id,
+      emailsDisabledSetup.member1.email
+    );
+    await app.close();
+  });
+
+  function responseDataIsBooking(data: any): data is BookingOutput_2024_08_13 {
+    return !Array.isArray(data) && typeof data === "object" && data && "id" in data;
+  }
+});

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/emails/user-emails.e2e-spec.ts

@@ -0,0 +1,482 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CancelBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/cancel-booking.output";
+import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
+import { RescheduleBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reschedule-booking.output";
+import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
+import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
+import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { User } from "@prisma/client";
+import * as request from "supertest";
+import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+
+import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
+import {
+  OrganizerScheduledEmail,
+  AttendeeScheduledEmail,
+  OrganizerRescheduledEmail,
+  AttendeeRescheduledEmail,
+  OrganizerCancelledEmail,
+  AttendeeCancelledEmail,
+} from "@calcom/platform-libraries";
+import {
+  CreateBookingInput_2024_08_13,
+  BookingOutput_2024_08_13,
+  RescheduleBookingInput_2024_08_13,
+  RecurringBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
+import { CancelBookingInput_2024_08_13 } from "@calcom/platform-types";
+import { Team } from "@calcom/prisma/client";
+
+jest
+  .spyOn(AttendeeScheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerScheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(AttendeeRescheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerRescheduledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(AttendeeCancelledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+jest
+  .spyOn(OrganizerCancelledEmail.prototype, "getHtml")
+  .mockImplementation(() => Promise.resolve("<p>email</p>"));
+
+type EmailSetup = {
+  user: User;
+  eventTypeId: number;
+  recurringEventTypeId: number;
+  createdBookingUid: string;
+  rescheduledBookingUid: string;
+};
+
+describe("Bookings Endpoints 2024-08-13 user emails", () => {
+  let app: INestApplication;
+  let organization: Team;
+
+  let userRepositoryFixture: UserRepositoryFixture;
+  let bookingsRepositoryFixture: BookingsRepositoryFixture;
+  let schedulesService: SchedulesService_2024_04_15;
+  let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+  let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+  let teamRepositoryFixture: TeamRepositoryFixture;
+
+  let emailsEnabledSetup: EmailSetup;
+  let emailsDisabledSetup: EmailSetup;
+
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+    })
+      .overrideGuard(PermissionsGuard)
+      .useValue({
+        canActivate: () => true,
+      })
+      .overrideGuard(ApiAuthGuard)
+      .useValue({
+        canActivate: () => true,
+      })
+      .compile();
+
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+    bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+    eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+    oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+    teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+    schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+
+    organization = await teamRepositoryFixture.create({ name: "organization bookings" });
+
+    await setupEnabledEmails();
+    await setupDisabledEmails();
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    await app.init();
+  });
+
+  async function setupEnabledEmails() {
+    const oAuthClientEmailsEnabled = await createOAuthClient(organization.id, true);
+
+    const user = await userRepositoryFixture.create({
+      email: `alice-${Math.floor(Math.random() * 1000)}@gmail.com`,
+      platformOAuthClients: {
+        connect: {
+          id: oAuthClientEmailsEnabled.id,
+        },
+      },
+    });
+
+    const userSchedule: CreateScheduleInput_2024_04_15 = {
+      name: "working time",
+      timeZone: "Europe/Rome",
+      isDefault: true,
+    };
+    await schedulesService.createUserSchedule(user.id, userSchedule);
+
+    const event = await eventTypesRepositoryFixture.create(
+      { title: "peer coding", slug: "peer-coding", length: 60 },
+      user.id
+    );
+
+    const recurringEvent = await eventTypesRepositoryFixture.create(
+      // note(Lauris): freq 2 means weekly, interval 1 means every week and count 3 means 3 weeks in a row
+      {
+        title: "peer coding recurring",
+        slug: "peer-coding-recurring",
+        length: 60,
+        recurringEvent: { freq: 2, count: 3, interval: 1 },
+      },
+      user.id
+    );
+
+    emailsEnabledSetup = {
+      user,
+      eventTypeId: event.id,
+      recurringEventTypeId: recurringEvent.id,
+      createdBookingUid: "",
+      rescheduledBookingUid: "",
+    };
+  }
+
+  async function setupDisabledEmails() {
+    const oAuthClientEmailsDisabled = await createOAuthClient(organization.id, false);
+
+    const user = await userRepositoryFixture.create({
+      email: `bob-${Math.floor(Math.random() * 1000)}@gmail.com`,
+      platformOAuthClients: {
+        connect: {
+          id: oAuthClientEmailsDisabled.id,
+        },
+      },
+    });
+    const userSchedule: CreateScheduleInput_2024_04_15 = {
+      name: "working time",
+      timeZone: "Europe/Rome",
+      isDefault: true,
+    };
+    await schedulesService.createUserSchedule(user.id, userSchedule);
+    const event = await eventTypesRepositoryFixture.create(
+      { title: "peer coding", slug: "peer-coding", length: 60 },
+      user.id
+    );
+
+    const recurringEvent = await eventTypesRepositoryFixture.create(
+      // note(Lauris): freq 2 means weekly, interval 1 means every week and count 3 means 3 weeks in a row
+      {
+        title: "peer coding recurring",
+        slug: "peer-coding-recurring",
+        length: 60,
+        recurringEvent: { freq: 2, count: 3, interval: 1 },
+      },
+      user.id
+    );
+
+    emailsDisabledSetup = {
+      user,
+      eventTypeId: event.id,
+      recurringEventTypeId: recurringEvent.id,
+      createdBookingUid: "",
+      rescheduledBookingUid: "",
+    };
+  }
+
+  async function createOAuthClient(organizationId: number, emailsEnabled: boolean) {
+    const data = {
+      logo: "logo-url",
+      name: "name",
+      redirectUris: ["http://localhost:5555"],
+      permissions: 32,
+      areEmailsEnabled: emailsEnabled,
+    };
+    const secret = "secret";
+
+    const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+    return client;
+  }
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+  });
+
+  describe("OAuth client managed user bookings - emails disabled", () => {
+    it("should not send an email when creating a booking", async () => {
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+        eventTypeId: emailsDisabledSetup.eventTypeId,
+        attendee: {
+          name: "Mr Proper",
+          email: "mr_proper@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        bookingFieldsResponses: {
+          customField: "customValue",
+        },
+        metadata: {
+          userId: "100",
+        },
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          if (responseDataIsBooking(responseBody.data)) {
+            expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            emailsDisabledSetup.createdBookingUid = responseBody.data.uid;
+          } else {
+            throw new Error(
+              "Invalid response data - expected booking but received array of possibily recurring bookings"
+            );
+          }
+        });
+    });
+
+    it("should not send an email when creating a recurring booking", async () => {
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 9, 0, 0)).toISOString(),
+        eventTypeId: emailsDisabledSetup.recurringEventTypeId,
+        attendee: {
+          name: "Mr Proper",
+          email: "mr_proper@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        bookingFieldsResponses: {
+          customField: "customValue",
+        },
+        metadata: {
+          userId: "100",
+        },
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          if (responseDataIsRecurringBooking(responseBody.data)) {
+            expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          } else {
+            throw new Error("Invalid response data - expected booking array but received single booking");
+          }
+        });
+    });
+
+    it("should not send an email when rescheduling a booking", async () => {
+      const body: RescheduleBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2035, 0, 8, 14, 0, 0)).toISOString(),
+        reschedulingReason: "Flying to mars that day",
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${emailsDisabledSetup.createdBookingUid}/reschedule`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          expect(AttendeeRescheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          expect(OrganizerRescheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          emailsDisabledSetup.rescheduledBookingUid = responseBody.data.uid;
+        });
+    });
+
+    it("should not send an email when cancelling a booking", async () => {
+      const body: CancelBookingInput_2024_08_13 = {
+        cancellationReason: "Going on a vacation",
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${emailsDisabledSetup.rescheduledBookingUid}/cancel`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(AttendeeCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          expect(OrganizerCancelledEmail.prototype.getHtml).not.toHaveBeenCalled();
+        });
+    });
+  });
+
+  describe("OAuth client managed user bookings - emails enabled", () => {
+    it("should send an email when creating a booking", async () => {
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+        eventTypeId: emailsEnabledSetup.eventTypeId,
+        attendee: {
+          name: "Mr Proper",
+          email: "mr_proper@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        bookingFieldsResponses: {
+          customField: "customValue",
+        },
+        metadata: {
+          userId: "100",
+        },
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          if (responseDataIsBooking(responseBody.data)) {
+            const data: BookingOutput_2024_08_13 = responseBody.data;
+            expect(AttendeeScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            emailsEnabledSetup.createdBookingUid = responseBody.data.uid;
+          } else {
+            throw new Error(
+              "Invalid response data - expected booking but received array of possibily recurring bookings"
+            );
+          }
+        });
+    });
+
+    it("should send an email when creating a recurring booking", async () => {
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 9, 0, 0)).toISOString(),
+        eventTypeId: emailsEnabledSetup.recurringEventTypeId,
+        attendee: {
+          name: "Mr Proper",
+          email: "mr_proper@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        bookingFieldsResponses: {
+          customField: "customValue",
+        },
+        metadata: {
+          userId: "100",
+        },
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          if (responseDataIsRecurringBooking(responseBody.data)) {
+            expect(AttendeeScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+            expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
+          } else {
+            throw new Error("Invalid response data - expected booking array but received single booking");
+          }
+        });
+    });
+
+    it("should send an email when rescheduling a booking", async () => {
+      const body: RescheduleBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2035, 0, 8, 14, 0, 0)).toISOString(),
+        reschedulingReason: "Flying to mars that day",
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${emailsEnabledSetup.createdBookingUid}/reschedule`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+          expect(OrganizerScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+
+          expect(AttendeeRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
+          expect(OrganizerRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
+
+          emailsEnabledSetup.rescheduledBookingUid = responseBody.data.uid;
+        });
+    });
+
+    it("should send an email when cancelling a booking", async () => {
+      const body: CancelBookingInput_2024_08_13 = {
+        cancellationReason: "Going on a vacation",
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${emailsEnabledSetup.rescheduledBookingUid}/cancel`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: CancelBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(AttendeeCancelledEmail.prototype.getHtml).toHaveBeenCalled();
+          expect(OrganizerCancelledEmail.prototype.getHtml).toHaveBeenCalled();
+        });
+    });
+  });
+
+  afterAll(async () => {
+    await teamRepositoryFixture.delete(organization.id);
+    await userRepositoryFixture.deleteByEmail(emailsEnabledSetup.user.email);
+    await userRepositoryFixture.deleteByEmail(emailsDisabledSetup.user.email);
+    await bookingsRepositoryFixture.deleteAllBookings(
+      emailsEnabledSetup.user.id,
+      emailsEnabledSetup.user.email
+    );
+    await bookingsRepositoryFixture.deleteAllBookings(
+      emailsDisabledSetup.user.id,
+      emailsDisabledSetup.user.email
+    );
+    await app.close();
+  });
+
+  function responseDataIsBooking(data: any): data is BookingOutput_2024_08_13 {
+    return !Array.isArray(data) && typeof data === "object" && data && "id" in data;
+  }
+
+  function responseDataIsRecurringBooking(data: any): data is RecurringBookingOutput_2024_08_13[] {
+    return Array.isArray(data);
+  }
+});

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/reassign-bookings.e2e-spec.ts

@@ -1,6 +1,5 @@
 import { bootstrap } from "@/app";
 import { AppModule } from "@/app.module";
-import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
 import { ReassignBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reassign-booking.output";
 import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
 import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
@@ -25,13 +24,7 @@ import { UserRepositoryFixture } from "test/fixtures/repository/users.repository
 import { withApiAuth } from "test/utils/withApiAuth";
 
 import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
-import {
-  CreateBookingInput_2024_08_13,
-  BookingOutput_2024_08_13,
-  RecurringBookingOutput_2024_08_13,
-  GetBookingsOutput_2024_08_13,
-  GetSeatedBookingOutput_2024_08_13,
-} from "@calcom/platform-types";
+import { CreateBookingInput_2024_08_13, BookingOutput_2024_08_13 } from "@calcom/platform-types";
 import { PlatformOAuthClient, Team } from "@calcom/prisma/client";
 
 describe("Bookings Endpoints 2024-08-13", () => {
@@ -86,14 +79,19 @@ describe("Bookings Endpoints 2024-08-13", () => {
       schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
 
       organization = await organizationsRepositoryFixture.create({ name: "organization team bookings" });
+      oAuthClient = await createOAuthClient(organization.id);
+
       team = await teamRepositoryFixture.create({
         name: "team 1",
         isOrganization: false,
         parent: { connect: { id: organization.id } },
+        createdByOAuthClient: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
-      oAuthClient = await createOAuthClient(organization.id);
-
       teamUser1 = await userRepositoryFixture.create({
         email: teamUserEmail,
         locale: "it",

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/recurring-bookings.e2e-spec.ts

@@ -0,0 +1,706 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
+import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
+import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
+import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { User } from "@prisma/client";
+import * as request from "supertest";
+import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { withApiAuth } from "test/utils/withApiAuth";
+
+import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
+import { AttendeeCancelledEmail, OrganizerCancelledEmail } from "@calcom/platform-libraries";
+import {
+  CreateRecurringBookingInput_2024_08_13,
+  RecurringBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
+import { CancelBookingInput_2024_08_13 } from "@calcom/platform-types";
+import { PlatformOAuthClient, Team } from "@calcom/prisma/client";
+
+describe("Bookings Endpoints 2024-08-13", () => {
+  describe("Creating recurring bookings", () => {
+    let app: INestApplication;
+    let organization: Team;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let bookingsRepositoryFixture: BookingsRepositoryFixture;
+    let schedulesService: SchedulesService_2024_04_15;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+    let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+    let oAuthClient: PlatformOAuthClient;
+    let teamRepositoryFixture: TeamRepositoryFixture;
+
+    const userEmail = "bookings-controller-e2e@api.com";
+    let user: User;
+
+    const maxRecurrenceCount = 3;
+    let recurringEventTypeId: number;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        userEmail,
+        Test.createTestingModule({
+          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+        })
+      )
+        .overrideGuard(PermissionsGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+      oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+
+      organization = await teamRepositoryFixture.create({ name: "organization bookings" });
+      oAuthClient = await createOAuthClient(organization.id);
+
+      user = await userRepositoryFixture.create({
+        email: userEmail,
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
+      });
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(user.id, userSchedule);
+
+      const recurringEvent = await eventTypesRepositoryFixture.create(
+        // note(Lauris): freq 2 means weekly, interval 1 means every week and count 3 means 3 weeks in a row
+        {
+          title: "peer coding recurring",
+          slug: "peer-coding-recurring",
+          length: 60,
+          recurringEvent: { freq: 2, count: maxRecurrenceCount, interval: 1 },
+        },
+        user.id
+      );
+      recurringEventTypeId = recurringEvent.id;
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    async function createOAuthClient(organizationId: number) {
+      const data = {
+        logo: "logo-url",
+        name: "name",
+        redirectUris: ["http://localhost:5555"],
+        permissions: 32,
+      };
+      const secret = "secret";
+
+      const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+      return client;
+    }
+
+    it("should not create recurring booking with recurrenceCount larger than event type recurrence count", async () => {
+      const recurrenceCount = 1000;
+
+      const body: CreateRecurringBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString(),
+        eventTypeId: recurringEventTypeId,
+        attendee: {
+          name: "Mr Proper Recurring",
+          email: "mr_proper_recurring@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        recurrenceCount,
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(400);
+    });
+
+    it("should create a recurring booking with recurrenceCount smaller than event type recurrence count", async () => {
+      const recurrenceCount = maxRecurrenceCount - 1;
+      const body: CreateRecurringBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString(),
+        eventTypeId: recurringEventTypeId,
+        attendee: {
+          name: "Mr Proper Recurring",
+          email: "mr_proper_recurring@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        recurrenceCount,
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(responseDataIsRecurringBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsRecurringBooking(responseBody.data)) {
+            const data: RecurringBookingOutput_2024_08_13[] = responseBody.data;
+            expect(data.length).toEqual(maxRecurrenceCount - 1);
+
+            const firstBooking = data[0];
+            expect(firstBooking.id).toBeDefined();
+            expect(firstBooking.uid).toBeDefined();
+            expect(firstBooking.hosts[0].id).toEqual(user.id);
+            expect(firstBooking.status).toEqual("accepted");
+            expect(firstBooking.start).toEqual(new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString());
+            expect(firstBooking.end).toEqual(new Date(Date.UTC(2030, 1, 4, 14, 0, 0)).toISOString());
+            expect(firstBooking.duration).toEqual(60);
+            expect(firstBooking.eventTypeId).toEqual(recurringEventTypeId);
+            expect(firstBooking.attendees[0]).toEqual({
+              name: body.attendee.name,
+              timeZone: body.attendee.timeZone,
+              language: body.attendee.language,
+              absent: false,
+            });
+            expect(firstBooking.location).toEqual(body.location);
+            expect(firstBooking.recurringBookingUid).toBeDefined();
+            expect(firstBooking.absentHost).toEqual(false);
+
+            const secondBooking = data[1];
+            expect(secondBooking.id).toBeDefined();
+            expect(secondBooking.uid).toBeDefined();
+            expect(secondBooking.hosts[0].id).toEqual(user.id);
+            expect(secondBooking.status).toEqual("accepted");
+            expect(secondBooking.start).toEqual(new Date(Date.UTC(2030, 1, 11, 13, 0, 0)).toISOString());
+            expect(secondBooking.end).toEqual(new Date(Date.UTC(2030, 1, 11, 14, 0, 0)).toISOString());
+            expect(secondBooking.duration).toEqual(60);
+            expect(secondBooking.eventTypeId).toEqual(recurringEventTypeId);
+            expect(secondBooking.recurringBookingUid).toBeDefined();
+            expect(secondBooking.attendees[0]).toEqual({
+              name: body.attendee.name,
+              timeZone: body.attendee.timeZone,
+              language: body.attendee.language,
+              absent: false,
+            });
+            expect(secondBooking.location).toEqual(body.location);
+            expect(secondBooking.absentHost).toEqual(false);
+          } else {
+            throw new Error(
+              "Invalid response data - expected recurring booking but received non array response"
+            );
+          }
+        });
+    });
+
+    it("should create a recurring booking with recurrenceCount equal to event type recurrence count", async () => {
+      const recurrenceCount = maxRecurrenceCount;
+      const body: CreateRecurringBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString(),
+        eventTypeId: recurringEventTypeId,
+        attendee: {
+          name: "Mr Proper Recurring",
+          email: "mr_proper_recurring@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        recurrenceCount,
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(responseDataIsRecurringBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsRecurringBooking(responseBody.data)) {
+            const data: RecurringBookingOutput_2024_08_13[] = responseBody.data;
+            expect(data.length).toEqual(maxRecurrenceCount);
+
+            const firstBooking = data[0];
+            expect(firstBooking.id).toBeDefined();
+            expect(firstBooking.uid).toBeDefined();
+            expect(firstBooking.hosts[0].id).toEqual(user.id);
+            expect(firstBooking.status).toEqual("accepted");
+            expect(firstBooking.start).toEqual(new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString());
+            expect(firstBooking.end).toEqual(new Date(Date.UTC(2030, 1, 4, 14, 0, 0)).toISOString());
+            expect(firstBooking.duration).toEqual(60);
+            expect(firstBooking.eventTypeId).toEqual(recurringEventTypeId);
+            expect(firstBooking.attendees[0]).toEqual({
+              name: body.attendee.name,
+              timeZone: body.attendee.timeZone,
+              language: body.attendee.language,
+              absent: false,
+            });
+            expect(firstBooking.location).toEqual(body.location);
+            expect(firstBooking.meetingUrl).toEqual(body.location);
+            expect(firstBooking.recurringBookingUid).toBeDefined();
+            expect(firstBooking.absentHost).toEqual(false);
+
+            const secondBooking = data[1];
+            expect(secondBooking.id).toBeDefined();
+            expect(secondBooking.uid).toBeDefined();
+            expect(secondBooking.hosts[0].id).toEqual(user.id);
+            expect(secondBooking.status).toEqual("accepted");
+            expect(secondBooking.start).toEqual(new Date(Date.UTC(2030, 1, 11, 13, 0, 0)).toISOString());
+            expect(secondBooking.end).toEqual(new Date(Date.UTC(2030, 1, 11, 14, 0, 0)).toISOString());
+            expect(secondBooking.duration).toEqual(60);
+            expect(secondBooking.eventTypeId).toEqual(recurringEventTypeId);
+            expect(secondBooking.recurringBookingUid).toBeDefined();
+            expect(secondBooking.attendees[0]).toEqual({
+              name: body.attendee.name,
+              timeZone: body.attendee.timeZone,
+              language: body.attendee.language,
+              absent: false,
+            });
+            expect(secondBooking.location).toEqual(body.location);
+            expect(secondBooking.absentHost).toEqual(false);
+
+            const thirdBooking = data[2];
+            expect(thirdBooking.id).toBeDefined();
+            expect(thirdBooking.uid).toBeDefined();
+            expect(thirdBooking.hosts[0].id).toEqual(user.id);
+            expect(thirdBooking.status).toEqual("accepted");
+            expect(thirdBooking.start).toEqual(new Date(Date.UTC(2030, 1, 18, 13, 0, 0)).toISOString());
+            expect(thirdBooking.end).toEqual(new Date(Date.UTC(2030, 1, 18, 14, 0, 0)).toISOString());
+            expect(thirdBooking.duration).toEqual(60);
+            expect(thirdBooking.eventTypeId).toEqual(recurringEventTypeId);
+            expect(thirdBooking.recurringBookingUid).toBeDefined();
+            expect(thirdBooking.attendees[0]).toEqual({
+              name: body.attendee.name,
+              timeZone: body.attendee.timeZone,
+              language: body.attendee.language,
+              absent: false,
+            });
+            expect(thirdBooking.location).toEqual(body.location);
+            expect(thirdBooking.absentHost).toEqual(false);
+          } else {
+            throw new Error(
+              "Invalid response data - expected recurring booking but received non array response"
+            );
+          }
+        });
+    });
+
+    afterEach(async () => {
+      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
+    });
+
+    afterAll(async () => {
+      await oauthClientRepositoryFixture.delete(oAuthClient.id);
+      await teamRepositoryFixture.delete(organization.id);
+      await userRepositoryFixture.deleteByEmail(user.email);
+      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
+      await app.close();
+    });
+  });
+
+  function responseDataIsRecurringBooking(data: any): data is RecurringBookingOutput_2024_08_13[] {
+    return Array.isArray(data);
+  }
+
+  describe("Recurring bookings cancel all subsequent bookings", () => {
+    let app: INestApplication;
+    let organization: Team;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let bookingsRepositoryFixture: BookingsRepositoryFixture;
+    let schedulesService: SchedulesService_2024_04_15;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+    let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+    let oAuthClient: PlatformOAuthClient;
+    let teamRepositoryFixture: TeamRepositoryFixture;
+
+    const userEmail = "bookings-controller-e2e@api.com";
+    let user: User;
+
+    const maxRecurrenceCount = 4;
+    let recurringEventTypeId: number;
+
+    let recurringBooking: RecurringBookingOutput_2024_08_13[];
+
+    beforeAll(async () => {
+      jest.spyOn(AttendeeCancelledEmail.prototype as any, "getHtml").mockImplementation(async function () {
+        return "<html><body>Mocked Email Content</body></html>";
+      });
+
+      jest.spyOn(OrganizerCancelledEmail.prototype as any, "getHtml").mockImplementation(async function () {
+        return "<html><body>Mocked Email Content</body></html>";
+      });
+
+      const moduleRef = await withApiAuth(
+        userEmail,
+        Test.createTestingModule({
+          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+        })
+      )
+        .overrideGuard(PermissionsGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+      oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+
+      organization = await teamRepositoryFixture.create({ name: "organization bookings" });
+      oAuthClient = await createOAuthClient(organization.id);
+
+      user = await userRepositoryFixture.create({
+        email: userEmail,
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
+      });
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(user.id, userSchedule);
+
+      const recurringEvent = await eventTypesRepositoryFixture.create(
+        // note(Lauris): freq 2 means weekly, interval 1 means every week and count 3 means 3 weeks in a row
+        {
+          title: "peer coding recurring",
+          slug: "peer-coding-recurring",
+          length: 60,
+          recurringEvent: { freq: 2, count: maxRecurrenceCount, interval: 1 },
+        },
+        user.id
+      );
+      recurringEventTypeId = recurringEvent.id;
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    async function createOAuthClient(organizationId: number) {
+      const data = {
+        logo: "logo-url",
+        name: "name",
+        redirectUris: ["http://localhost:5555"],
+        permissions: 32,
+      };
+      const secret = "secret";
+
+      const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+      return client;
+    }
+
+    it("should create a recurring booking", async () => {
+      const body: CreateRecurringBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString(),
+        eventTypeId: recurringEventTypeId,
+        attendee: {
+          name: "Mr Proper Recurring",
+          email: "mr_proper_recurring@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(responseDataIsRecurringBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsRecurringBooking(responseBody.data)) {
+            const data: RecurringBookingOutput_2024_08_13[] = responseBody.data;
+            expect(data.length).toEqual(maxRecurrenceCount);
+            recurringBooking = data;
+          } else {
+            throw new Error(
+              "Invalid response data - expected recurring booking but received non array response"
+            );
+          }
+        });
+    });
+
+    it("should cancel all recurrences after a specific recurrence", async () => {
+      const recurringBookingUid = recurringBooking[2].recurringBookingUid;
+      const bookings = await bookingsRepositoryFixture.getByRecurringBookingUid(recurringBookingUid);
+      for (const booking of bookings) {
+        expect(booking.status).toEqual("ACCEPTED");
+      }
+
+      // note(Lauris): cancel all recurrences after and including third recurrence in the series of 4 recurrences
+      // aka cancel 3rd and 4th recurrences.
+      const thirdRecurrenceUid = recurringBooking[2].uid;
+      const fourthRecurringUid = recurringBooking[3].uid;
+      const body: CancelBookingInput_2024_08_13 = {
+        cancelSubsequentBookings: true,
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${thirdRecurrenceUid}/cancel`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(responseDataIsRecurringBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsRecurringBooking(responseBody.data)) {
+            const data: RecurringBookingOutput_2024_08_13[] = responseBody.data;
+            expect(data.length).toEqual(4);
+
+            const firstRecurrence = data.find((booking) => booking.uid === recurringBooking[0].uid);
+            expect(firstRecurrence).toBeDefined();
+            expect(firstRecurrence?.status).toEqual("accepted");
+
+            const secondRecurrence = data.find((booking) => booking.uid === recurringBooking[1].uid);
+            expect(secondRecurrence).toBeDefined();
+            expect(secondRecurrence?.status).toEqual("accepted");
+
+            const thirdRecurrence = data.find((booking) => booking.uid === thirdRecurrenceUid);
+            expect(thirdRecurrence).toBeDefined();
+            expect(thirdRecurrence?.status).toEqual("cancelled");
+
+            const fourthRecurrence = data.find((booking) => booking.uid === fourthRecurringUid);
+            expect(fourthRecurrence).toBeDefined();
+            expect(fourthRecurrence?.status).toEqual("cancelled");
+
+            const bookings = await bookingsRepositoryFixture.getByRecurringBookingUid(recurringBookingUid);
+
+            const bookingFirst = bookings.find((booking) => booking.uid === recurringBooking[0].uid);
+            expect(bookingFirst?.status).toEqual("ACCEPTED");
+            const bookingSecond = bookings.find((booking) => booking.uid === recurringBooking[1].uid);
+            expect(bookingSecond?.status).toEqual("ACCEPTED");
+            const bookingThird = bookings.find((booking) => booking.uid === recurringBooking[2].uid);
+            expect(bookingThird?.status).toEqual("CANCELLED");
+            const bookingFourth = bookings.find((booking) => booking.uid === recurringBooking[3].uid);
+            expect(bookingFourth?.status).toEqual("CANCELLED");
+          } else {
+            throw new Error(
+              "Invalid response data - expected recurring booking but received non array response"
+            );
+          }
+        });
+    });
+
+    afterAll(async () => {
+      await oauthClientRepositoryFixture.delete(oAuthClient.id);
+      await teamRepositoryFixture.delete(organization.id);
+      await userRepositoryFixture.deleteByEmail(user.email);
+      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
+      await app.close();
+    });
+  });
+
+  describe("Recurring bookings cancel all remaining bookings (bookings with start time greater than this moment)", () => {
+    let app: INestApplication;
+    let organization: Team;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let bookingsRepositoryFixture: BookingsRepositoryFixture;
+    let schedulesService: SchedulesService_2024_04_15;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+    let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+    let oAuthClient: PlatformOAuthClient;
+    let teamRepositoryFixture: TeamRepositoryFixture;
+
+    const userEmail = "bookings-controller-e2e@api.com";
+    let user: User;
+
+    const maxRecurrenceCount = 4;
+    let recurringEventTypeId: number;
+
+    let recurringBooking: RecurringBookingOutput_2024_08_13[];
+
+    beforeAll(async () => {
+      jest.spyOn(AttendeeCancelledEmail.prototype as any, "getHtml").mockImplementation(async function () {
+        return "<html><body>Mocked Email Content</body></html>";
+      });
+
+      jest.spyOn(OrganizerCancelledEmail.prototype as any, "getHtml").mockImplementation(async function () {
+        return "<html><body>Mocked Email Content</body></html>";
+      });
+
+      const moduleRef = await withApiAuth(
+        userEmail,
+        Test.createTestingModule({
+          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+        })
+      )
+        .overrideGuard(PermissionsGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+      oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+
+      organization = await teamRepositoryFixture.create({ name: "organization bookings" });
+      oAuthClient = await createOAuthClient(organization.id);
+
+      user = await userRepositoryFixture.create({
+        email: userEmail,
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
+      });
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(user.id, userSchedule);
+
+      const recurringEvent = await eventTypesRepositoryFixture.create(
+        // note(Lauris): freq 2 means weekly, interval 1 means every week and count 3 means 3 weeks in a row
+        {
+          title: "peer coding recurring",
+          slug: "peer-coding-recurring",
+          length: 60,
+          recurringEvent: { freq: 2, count: maxRecurrenceCount, interval: 1 },
+        },
+        user.id
+      );
+      recurringEventTypeId = recurringEvent.id;
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    async function createOAuthClient(organizationId: number) {
+      const data = {
+        logo: "logo-url",
+        name: "name",
+        redirectUris: ["http://localhost:5555"],
+        permissions: 32,
+      };
+      const secret = "secret";
+
+      const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+      return client;
+    }
+
+    it("should create a recurring booking", async () => {
+      const body: CreateRecurringBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2040, 1, 3, 13, 0, 0)).toISOString(),
+        eventTypeId: recurringEventTypeId,
+        attendee: {
+          name: "Mr Proper Recurring",
+          email: "mr_proper_recurring@gmail.com",
+          timeZone: "Europe/Rome",
+          language: "it",
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+      };
+
+      return request(app.getHttpServer())
+        .post("/v2/bookings")
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(responseDataIsRecurringBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsRecurringBooking(responseBody.data)) {
+            const data: RecurringBookingOutput_2024_08_13[] = responseBody.data;
+            expect(data.length).toEqual(maxRecurrenceCount);
+            recurringBooking = data;
+          } else {
+            throw new Error(
+              "Invalid response data - expected recurring booking but received non array response"
+            );
+          }
+        });
+    });
+
+    it("should cancel all remaning recurrences", async () => {
+      const recurringBookingUid = recurringBooking[0].recurringBookingUid;
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${recurringBookingUid}/cancel`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+          expect(responseDataIsRecurringBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsRecurringBooking(responseBody.data)) {
+            const data: RecurringBookingOutput_2024_08_13[] = responseBody.data;
+            expect(data.length).toEqual(4);
+            for (const booking of data) {
+              expect(booking.status).toEqual("cancelled");
+            }
+          } else {
+            throw new Error(
+              "Invalid response data - expected recurring booking but received non array response"
+            );
+          }
+        });
+    });
+
+    afterAll(async () => {
+      await oauthClientRepositoryFixture.delete(oAuthClient.id);
+      await teamRepositoryFixture.delete(organization.id);
+      await userRepositoryFixture.deleteByEmail(user.email);
+      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
+      await app.close();
+    });
+  });
+});

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/seated-bookings.e2e-spec.ts

@@ -93,6 +93,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
 
       user = await userRepositoryFixture.create({
         email: userEmail,
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
       const userSchedule: CreateScheduleInput_2024_04_15 = {
@@ -163,6 +168,9 @@ describe("Bookings Endpoints 2024-08-13", () => {
         bookingFieldsResponses: {
           codingLanguage: "TypeScript",
         },
+        metadata: {
+          userId: "100",
+        },
       };
 
       return request(app.getHttpServer())
@@ -205,6 +213,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: body.attendee.name,
                 ...body.bookingFieldsResponses,
               },
+              metadata: body.metadata,
             });
             expect(data.location).toBeDefined();
             expect(data.absentHost).toEqual(false);
@@ -230,6 +239,9 @@ describe("Bookings Endpoints 2024-08-13", () => {
         bookingFieldsResponses: {
           codingLanguage: "Rust",
         },
+        metadata: {
+          userId: "200",
+        },
       };
 
       return request(app.getHttpServer())
@@ -274,6 +286,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: createdSeatedBooking.attendees[0].name,
                 ...createdSeatedBooking.attendees[0].bookingFieldsResponses,
               },
+              metadata: createdSeatedBooking.attendees[0].metadata,
             });
             const secondAttendee = data.attendees.find((attendee) => attendee.name === nameAttendeeTwo);
             expect(secondAttendee).toEqual({
@@ -286,6 +299,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: body.attendee.name,
                 ...body.bookingFieldsResponses,
               },
+              metadata: body.metadata,
             });
             expect(data.location).toBeDefined();
             expect(data.absentHost).toEqual(false);
@@ -314,6 +328,9 @@ describe("Bookings Endpoints 2024-08-13", () => {
           codingLanguage: "TypeScript",
         },
         recurrenceCount,
+        metadata: {
+          userId: "300",
+        },
       };
 
       return request(app.getHttpServer())
@@ -359,6 +376,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: body.attendee.name,
                 ...body.bookingFieldsResponses,
               },
+              metadata: body.metadata,
             });
             expect(firstBooking.location).toEqual(body.location);
             expect(firstBooking.absentHost).toEqual(false);
@@ -392,6 +410,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: body.attendee.name,
                 ...body.bookingFieldsResponses,
               },
+              metadata: body.metadata,
             });
             expect(secondBooking.location).toEqual(body.location);
             expect(secondBooking.absentHost).toEqual(false);
@@ -565,6 +584,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: attendee?.name,
                 ...attendee?.bookingFieldsResponses,
               },
+              metadata: attendee?.metadata,
             });
             expect(data.location).toBeDefined();
             expect(data.absentHost).toEqual(false);
@@ -697,6 +717,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
 
       user = await userRepositoryFixture.create({
         email: userEmail,
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
       const userSchedule: CreateScheduleInput_2024_04_15 = {
@@ -769,6 +794,9 @@ describe("Bookings Endpoints 2024-08-13", () => {
         bookingFieldsResponses: {
           codingLanguage: "TypeScript",
         },
+        metadata: {
+          userId: "1000",
+        },
         recurrenceCount,
       };
 
@@ -815,6 +843,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: body.attendee.name,
                 ...body.bookingFieldsResponses,
               },
+              metadata: body.metadata,
             });
             expect(firstBooking.location).toEqual(body.location);
             expect(firstBooking.absentHost).toEqual(false);
@@ -848,6 +877,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: body.attendee.name,
                 ...body.bookingFieldsResponses,
               },
+              metadata: body.metadata,
             });
             expect(secondBooking.location).toEqual(body.location);
             expect(secondBooking.absentHost).toEqual(false);
@@ -875,6 +905,9 @@ describe("Bookings Endpoints 2024-08-13", () => {
         bookingFieldsResponses: {
           codingLanguage: "TypeScript",
         },
+        metadata: {
+          userId: "2000",
+        },
         recurrenceCount,
       };
 
@@ -921,6 +954,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: nameAttendeeOne,
                 ...body.bookingFieldsResponses,
               },
+              metadata: createdRecurringSeatedBooking[0].attendees[0].metadata,
             });
             expect(firstBooking.attendees[1]).toEqual({
               name: nameAttendeeTwo,
@@ -932,6 +966,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: nameAttendeeTwo,
                 ...body.bookingFieldsResponses,
               },
+              metadata: body.metadata,
             });
             expect(firstBooking.location).toEqual(body.location);
             expect(firstBooking.absentHost).toEqual(false);
@@ -965,6 +1000,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: nameAttendeeOne,
                 ...body.bookingFieldsResponses,
               },
+              metadata: createdRecurringSeatedBooking[0].attendees[0].metadata,
             });
             expect(secondBooking.attendees[1]).toEqual({
               name: nameAttendeeTwo,
@@ -976,6 +1012,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 name: nameAttendeeTwo,
                 ...body.bookingFieldsResponses,
               },
+              metadata: body.metadata,
             });
             expect(secondBooking.location).toEqual(body.location);
             expect(secondBooking.absentHost).toEqual(false);

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/team-bookings.e2e-spec.ts

@@ -85,30 +85,50 @@ describe("Bookings Endpoints 2024-08-13", () => {
       schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
 
       organization = await organizationsRepositoryFixture.create({ name: "organization team bookings" });
+      oAuthClient = await createOAuthClient(organization.id);
+
       team1 = await teamRepositoryFixture.create({
         name: "team 1",
         isOrganization: false,
         parent: { connect: { id: organization.id } },
+        createdByOAuthClient: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
       team2 = await teamRepositoryFixture.create({
         name: "team 2",
         isOrganization: false,
         parent: { connect: { id: organization.id } },
+        createdByOAuthClient: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
-      oAuthClient = await createOAuthClient(organization.id);
-
       teamUser = await userRepositoryFixture.create({
         email: teamUserEmail,
         locale: "it",
         name: "orgUser1team1",
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
       teamUser2 = await userRepositoryFixture.create({
         email: teamUserEmail2,
         locale: "es",
         name: "orgUser2team1",
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
       const userSchedule: CreateScheduleInput_2024_04_15 = {

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/user-bookings.e2e-spec.ts

@@ -14,6 +14,7 @@ import { INestApplication } from "@nestjs/common";
 import { NestExpressApplication } from "@nestjs/platform-express";
 import { Test } from "@nestjs/testing";
 import { User } from "@prisma/client";
+import { advanceTo, clear } from "jest-date-mock";
 import * as request from "supertest";
 import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
 import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
@@ -95,6 +96,12 @@ describe("Bookings Endpoints 2024-08-13", () => {
 
       user = await userRepositoryFixture.create({
         email: userEmail,
+        username: `bob-${Math.floor(Math.random() * 1000)}@gmail.com`,
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
       const userSchedule: CreateScheduleInput_2024_04_15 = {
@@ -178,6 +185,136 @@ describe("Bookings Endpoints 2024-08-13", () => {
     });
 
     describe("create bookings", () => {
+      describe("invalid metadata", () => {
+        it("should not be able to create a booking with metadata with more than 50 keys", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+            eventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+            location: "https://meet.google.com/abc-def-ghi",
+            bookingFieldsResponses: {
+              customField: "customValue",
+            },
+            metadata: {
+              key1: "1",
+              key2: "2",
+              key3: "3",
+              key4: "4",
+              key5: "5",
+              key6: "6",
+              key7: "7",
+              key8: "8",
+              key9: "9",
+              key10: "10",
+              key11: "11",
+              key12: "12",
+              key13: "13",
+              key14: "14",
+              key15: "15",
+              key16: "16",
+              key17: "17",
+              key18: "18",
+              key19: "19",
+              key20: "20",
+              key21: "21",
+              key22: "22",
+              key23: "23",
+              key24: "24",
+              key25: "25",
+              key26: "26",
+              key27: "27",
+              key28: "28",
+              key29: "29",
+              key30: "30",
+              key31: "31",
+              key32: "32",
+              key33: "33",
+              key34: "34",
+              key35: "35",
+              key36: "36",
+              key37: "37",
+              key38: "38",
+              key39: "39",
+              key40: "40",
+              key41: "41",
+              key42: "42",
+              key43: "43",
+              key44: "44",
+              key45: "45",
+              key46: "46",
+              key47: "47",
+              key48: "48",
+              key49: "49",
+              key50: "50",
+              key51: "51",
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(400);
+        });
+
+        it("should not be able to create a booking with metadata with a key longer than 40 characters", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+            eventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+            location: "https://meet.google.com/abc-def-ghi",
+            bookingFieldsResponses: {
+              customField: "customValue",
+            },
+            metadata: {
+              aaaaaaaaaabbbbbbbbbbccccccccccdddddddddde: "1",
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(400);
+        });
+
+        it("should not be able to create a booking with metadata with a value longer than 500 characters", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+            eventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+            location: "https://meet.google.com/abc-def-ghi",
+            bookingFieldsResponses: {
+              customField: "customValue",
+            },
+            metadata: {
+              key: `${"a".repeat(501)}`,
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(400);
+        });
+      });
+
       it("should create a booking", async () => {
         const body: CreateBookingInput_2024_08_13 = {
           start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
@@ -192,14 +329,19 @@ describe("Bookings Endpoints 2024-08-13", () => {
           bookingFieldsResponses: {
             customField: "customValue",
           },
+          metadata: {
+            userId: "100",
+          },
         };
 
+        const beforeCreate = new Date();
         return request(app.getHttpServer())
           .post("/v2/bookings")
           .send(body)
           .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
           .expect(201)
           .then(async (response) => {
+            const afterCreate = new Date();
             const responseBody: CreateBookingOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
@@ -210,6 +352,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
               expect(data.id).toBeDefined();
               expect(data.uid).toBeDefined();
               expect(data.hosts[0].id).toEqual(user.id);
+              expect(data.hosts[0].username).toEqual(user.username);
               expect(data.status).toEqual("accepted");
               expect(data.start).toEqual(body.start);
               expect(data.end).toEqual(new Date(Date.UTC(2030, 0, 8, 14, 0, 0)).toISOString());
@@ -233,6 +376,13 @@ describe("Bookings Endpoints 2024-08-13", () => {
                 email: body.attendee.email,
                 ...body.bookingFieldsResponses,
               });
+
+              // Check createdAt date is between the time of the request and after the request
+              const createdAtDate = new Date(data.createdAt);
+              expect(createdAtDate.getTime()).toBeGreaterThanOrEqual(beforeCreate.getTime());
+              expect(createdAtDate.getTime()).toBeLessThanOrEqual(afterCreate.getTime());
+
+              expect(data.metadata).toEqual(body.metadata);
               createdBooking = data;
             } else {
               throw new Error(
@@ -253,6 +403,9 @@ describe("Bookings Endpoints 2024-08-13", () => {
             language: "it",
           },
           location: "https://meet.google.com/abc-def-ghi",
+          metadata: {
+            userId: "1000",
+          },
         };
 
         return request(app.getHttpServer())
@@ -288,6 +441,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
               expect(firstBooking.location).toEqual(body.location);
               expect(firstBooking.recurringBookingUid).toBeDefined();
               expect(firstBooking.absentHost).toEqual(false);
+              expect(firstBooking.metadata).toEqual(body.metadata);
 
               const secondBooking = data[1];
               expect(secondBooking.id).toBeDefined();
@@ -307,6 +461,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
               });
               expect(secondBooking.location).toEqual(body.location);
               expect(secondBooking.absentHost).toEqual(false);
+              expect(secondBooking.metadata).toEqual(body.metadata);
 
               const thirdBooking = data[2];
               expect(thirdBooking.id).toBeDefined();
@@ -326,6 +481,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
               });
               expect(thirdBooking.location).toEqual(body.location);
               expect(thirdBooking.absentHost).toEqual(false);
+              expect(thirdBooking.metadata).toEqual(body.metadata);
 
               createdRecurringBooking = data;
             } else {
@@ -354,6 +510,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
               expect(data.id).toEqual(createdBooking.id);
               expect(data.uid).toEqual(createdBooking.uid);
               expect(data.hosts[0].id).toEqual(user.id);
+              expect(data.hosts[0].username).toEqual(user.username);
               expect(data.status).toEqual(createdBooking.status);
               expect(data.start).toEqual(createdBooking.start);
               expect(data.end).toEqual(createdBooking.end);
@@ -362,6 +519,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
               expect(data.attendees[0]).toEqual(createdBooking.attendees[0]);
               expect(data.location).toEqual(createdBooking.location);
               expect(data.absentHost).toEqual(createdBooking.absentHost);
+              expect(data.createdAt).toEqual(createdBooking.createdAt);
             } else {
               throw new Error(
                 "Invalid response data - expected booking but received array of possibily recurring bookings"
@@ -835,12 +993,14 @@ describe("Bookings Endpoints 2024-08-13", () => {
           reschedulingReason: "Flying to mars that day",
         };
 
+        const beforeCreate = new Date();
         return request(app.getHttpServer())
           .post(`/v2/bookings/${createdBooking.uid}/reschedule`)
           .send(body)
           .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
           .expect(201)
           .then(async (response) => {
+            const afterCreate = new Date();
             const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
@@ -860,6 +1020,13 @@ describe("Bookings Endpoints 2024-08-13", () => {
             expect(data.attendees[0]).toEqual(createdBooking.attendees[0]);
             expect(data.location).toEqual(createdBooking.location);
             expect(data.absentHost).toEqual(createdBooking.absentHost);
+            expect(data.metadata).toEqual(createdBooking.metadata);
+
+            // When a booking is rescheduled, a new booking is created and the old booking is cancelled.
+            // We want to make sure the createdAt date of the new booking is between the beforeCreate and afterCreate dates.
+            const createdAtDate = new Date(data.createdAt);
+            expect(createdAtDate.getTime()).toBeGreaterThanOrEqual(beforeCreate.getTime());
+            expect(createdAtDate.getTime()).toBeLessThanOrEqual(afterCreate.getTime());
 
             rescheduledBooking = data;
           });
@@ -913,6 +1080,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
             expect(data.attendees[0]).toEqual(createdRecurringBooking[0].attendees[0]);
             expect(data.location).toEqual(createdRecurringBooking[0].location);
             expect(data.absentHost).toEqual(createdRecurringBooking[0].absentHost);
+            expect(data.metadata).toEqual(createdRecurringBooking[0].metadata);
 
             const oldBooking = await bookingsRepositoryFixture.getByUid(createdRecurringBooking[0].uid);
             expect(oldBooking).toBeDefined();
@@ -952,6 +1120,14 @@ describe("Bookings Endpoints 2024-08-13", () => {
     });
 
     describe("mark absent", () => {
+      beforeAll(() => {
+        advanceTo(new Date(2035, 0, 9, 15, 0, 0));
+      });
+
+      afterAll(() => {
+        clear();
+      });
+
       it("should mark host absent", async () => {
         const body: MarkAbsentBookingInput_2024_08_13 = {
           host: true,
@@ -1018,6 +1194,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
           });
       });
     });
+
     describe("cancel bookings", () => {
       it("should cancel booking", async () => {
         const body: CancelBookingInput_2024_08_13 = {
@@ -1127,293 +1304,4 @@ describe("Bookings Endpoints 2024-08-13", () => {
   function responseDataIsRecurringBooking(data: any): data is RecurringBookingOutput_2024_08_13[] {
     return Array.isArray(data);
   }
-
-  describe("Recurring bookings", () => {
-    let app: INestApplication;
-    let organization: Team;
-
-    let userRepositoryFixture: UserRepositoryFixture;
-    let bookingsRepositoryFixture: BookingsRepositoryFixture;
-    let schedulesService: SchedulesService_2024_04_15;
-    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
-    let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
-    let oAuthClient: PlatformOAuthClient;
-    let teamRepositoryFixture: TeamRepositoryFixture;
-
-    const userEmail = "bookings-controller-e2e@api.com";
-    let user: User;
-
-    const maxRecurrenceCount = 3;
-    let recurringEventTypeId: number;
-
-    beforeAll(async () => {
-      const moduleRef = await withApiAuth(
-        userEmail,
-        Test.createTestingModule({
-          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
-        })
-      )
-        .overrideGuard(PermissionsGuard)
-        .useValue({
-          canActivate: () => true,
-        })
-        .compile();
-
-      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
-      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
-      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
-      oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
-      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
-      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
-
-      organization = await teamRepositoryFixture.create({ name: "organization bookings" });
-      oAuthClient = await createOAuthClient(organization.id);
-
-      user = await userRepositoryFixture.create({
-        email: userEmail,
-      });
-
-      const userSchedule: CreateScheduleInput_2024_04_15 = {
-        name: "working time",
-        timeZone: "Europe/Rome",
-        isDefault: true,
-      };
-      await schedulesService.createUserSchedule(user.id, userSchedule);
-
-      const recurringEvent = await eventTypesRepositoryFixture.create(
-        // note(Lauris): freq 2 means weekly, interval 1 means every week and count 3 means 3 weeks in a row
-        {
-          title: "peer coding recurring",
-          slug: "peer-coding-recurring",
-          length: 60,
-          recurringEvent: { freq: 2, count: maxRecurrenceCount, interval: 1 },
-        },
-        user.id
-      );
-      recurringEventTypeId = recurringEvent.id;
-
-      app = moduleRef.createNestApplication();
-      bootstrap(app as NestExpressApplication);
-
-      await app.init();
-    });
-
-    async function createOAuthClient(organizationId: number) {
-      const data = {
-        logo: "logo-url",
-        name: "name",
-        redirectUris: ["http://localhost:5555"],
-        permissions: 32,
-      };
-      const secret = "secret";
-
-      const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
-      return client;
-    }
-
-    it("should not create recurring booking with recurrenceCount larger than event type recurrence count", async () => {
-      const recurrenceCount = 1000;
-
-      const body: CreateRecurringBookingInput_2024_08_13 = {
-        start: new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString(),
-        eventTypeId: recurringEventTypeId,
-        attendee: {
-          name: "Mr Proper Recurring",
-          email: "mr_proper_recurring@gmail.com",
-          timeZone: "Europe/Rome",
-          language: "it",
-        },
-        location: "https://meet.google.com/abc-def-ghi",
-        recurrenceCount,
-      };
-
-      return request(app.getHttpServer())
-        .post("/v2/bookings")
-        .send(body)
-        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
-        .expect(400);
-    });
-
-    it("should create a recurring booking with recurrenceCount smaller than event type recurrence count", async () => {
-      const recurrenceCount = maxRecurrenceCount - 1;
-      const body: CreateRecurringBookingInput_2024_08_13 = {
-        start: new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString(),
-        eventTypeId: recurringEventTypeId,
-        attendee: {
-          name: "Mr Proper Recurring",
-          email: "mr_proper_recurring@gmail.com",
-          timeZone: "Europe/Rome",
-          language: "it",
-        },
-        location: "https://meet.google.com/abc-def-ghi",
-        recurrenceCount,
-      };
-
-      return request(app.getHttpServer())
-        .post("/v2/bookings")
-        .send(body)
-        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
-        .expect(201)
-        .then(async (response) => {
-          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
-          expect(responseBody.status).toEqual(SUCCESS_STATUS);
-          expect(responseBody.data).toBeDefined();
-          expect(responseDataIsRecurringBooking(responseBody.data)).toBe(true);
-
-          if (responseDataIsRecurringBooking(responseBody.data)) {
-            const data: RecurringBookingOutput_2024_08_13[] = responseBody.data;
-            expect(data.length).toEqual(maxRecurrenceCount - 1);
-
-            const firstBooking = data[0];
-            expect(firstBooking.id).toBeDefined();
-            expect(firstBooking.uid).toBeDefined();
-            expect(firstBooking.hosts[0].id).toEqual(user.id);
-            expect(firstBooking.status).toEqual("accepted");
-            expect(firstBooking.start).toEqual(new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString());
-            expect(firstBooking.end).toEqual(new Date(Date.UTC(2030, 1, 4, 14, 0, 0)).toISOString());
-            expect(firstBooking.duration).toEqual(60);
-            expect(firstBooking.eventTypeId).toEqual(recurringEventTypeId);
-            expect(firstBooking.attendees[0]).toEqual({
-              name: body.attendee.name,
-              timeZone: body.attendee.timeZone,
-              language: body.attendee.language,
-              absent: false,
-            });
-            expect(firstBooking.location).toEqual(body.location);
-            expect(firstBooking.recurringBookingUid).toBeDefined();
-            expect(firstBooking.absentHost).toEqual(false);
-
-            const secondBooking = data[1];
-            expect(secondBooking.id).toBeDefined();
-            expect(secondBooking.uid).toBeDefined();
-            expect(secondBooking.hosts[0].id).toEqual(user.id);
-            expect(secondBooking.status).toEqual("accepted");
-            expect(secondBooking.start).toEqual(new Date(Date.UTC(2030, 1, 11, 13, 0, 0)).toISOString());
-            expect(secondBooking.end).toEqual(new Date(Date.UTC(2030, 1, 11, 14, 0, 0)).toISOString());
-            expect(secondBooking.duration).toEqual(60);
-            expect(secondBooking.eventTypeId).toEqual(recurringEventTypeId);
-            expect(secondBooking.recurringBookingUid).toBeDefined();
-            expect(secondBooking.attendees[0]).toEqual({
-              name: body.attendee.name,
-              timeZone: body.attendee.timeZone,
-              language: body.attendee.language,
-              absent: false,
-            });
-            expect(secondBooking.location).toEqual(body.location);
-            expect(secondBooking.absentHost).toEqual(false);
-          } else {
-            throw new Error(
-              "Invalid response data - expected recurring booking but received non array response"
-            );
-          }
-        });
-    });
-
-    it("should create a recurring booking with recurrenceCount equal to event type recurrence count", async () => {
-      const recurrenceCount = maxRecurrenceCount;
-      const body: CreateRecurringBookingInput_2024_08_13 = {
-        start: new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString(),
-        eventTypeId: recurringEventTypeId,
-        attendee: {
-          name: "Mr Proper Recurring",
-          email: "mr_proper_recurring@gmail.com",
-          timeZone: "Europe/Rome",
-          language: "it",
-        },
-        location: "https://meet.google.com/abc-def-ghi",
-        recurrenceCount,
-      };
-
-      return request(app.getHttpServer())
-        .post("/v2/bookings")
-        .send(body)
-        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
-        .expect(201)
-        .then(async (response) => {
-          const responseBody: CreateBookingOutput_2024_08_13 = response.body;
-          expect(responseBody.status).toEqual(SUCCESS_STATUS);
-          expect(responseBody.data).toBeDefined();
-          expect(responseDataIsRecurringBooking(responseBody.data)).toBe(true);
-
-          if (responseDataIsRecurringBooking(responseBody.data)) {
-            const data: RecurringBookingOutput_2024_08_13[] = responseBody.data;
-            expect(data.length).toEqual(maxRecurrenceCount);
-
-            const firstBooking = data[0];
-            expect(firstBooking.id).toBeDefined();
-            expect(firstBooking.uid).toBeDefined();
-            expect(firstBooking.hosts[0].id).toEqual(user.id);
-            expect(firstBooking.status).toEqual("accepted");
-            expect(firstBooking.start).toEqual(new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString());
-            expect(firstBooking.end).toEqual(new Date(Date.UTC(2030, 1, 4, 14, 0, 0)).toISOString());
-            expect(firstBooking.duration).toEqual(60);
-            expect(firstBooking.eventTypeId).toEqual(recurringEventTypeId);
-            expect(firstBooking.attendees[0]).toEqual({
-              name: body.attendee.name,
-              timeZone: body.attendee.timeZone,
-              language: body.attendee.language,
-              absent: false,
-            });
-            expect(firstBooking.location).toEqual(body.location);
-            expect(firstBooking.meetingUrl).toEqual(body.location);
-            expect(firstBooking.recurringBookingUid).toBeDefined();
-            expect(firstBooking.absentHost).toEqual(false);
-
-            const secondBooking = data[1];
-            expect(secondBooking.id).toBeDefined();
-            expect(secondBooking.uid).toBeDefined();
-            expect(secondBooking.hosts[0].id).toEqual(user.id);
-            expect(secondBooking.status).toEqual("accepted");
-            expect(secondBooking.start).toEqual(new Date(Date.UTC(2030, 1, 11, 13, 0, 0)).toISOString());
-            expect(secondBooking.end).toEqual(new Date(Date.UTC(2030, 1, 11, 14, 0, 0)).toISOString());
-            expect(secondBooking.duration).toEqual(60);
-            expect(secondBooking.eventTypeId).toEqual(recurringEventTypeId);
-            expect(secondBooking.recurringBookingUid).toBeDefined();
-            expect(secondBooking.attendees[0]).toEqual({
-              name: body.attendee.name,
-              timeZone: body.attendee.timeZone,
-              language: body.attendee.language,
-              absent: false,
-            });
-            expect(secondBooking.location).toEqual(body.location);
-            expect(secondBooking.absentHost).toEqual(false);
-
-            const thirdBooking = data[2];
-            expect(thirdBooking.id).toBeDefined();
-            expect(thirdBooking.uid).toBeDefined();
-            expect(thirdBooking.hosts[0].id).toEqual(user.id);
-            expect(thirdBooking.status).toEqual("accepted");
-            expect(thirdBooking.start).toEqual(new Date(Date.UTC(2030, 1, 18, 13, 0, 0)).toISOString());
-            expect(thirdBooking.end).toEqual(new Date(Date.UTC(2030, 1, 18, 14, 0, 0)).toISOString());
-            expect(thirdBooking.duration).toEqual(60);
-            expect(thirdBooking.eventTypeId).toEqual(recurringEventTypeId);
-            expect(thirdBooking.recurringBookingUid).toBeDefined();
-            expect(thirdBooking.attendees[0]).toEqual({
-              name: body.attendee.name,
-              timeZone: body.attendee.timeZone,
-              language: body.attendee.language,
-              absent: false,
-            });
-            expect(thirdBooking.location).toEqual(body.location);
-            expect(thirdBooking.absentHost).toEqual(false);
-          } else {
-            throw new Error(
-              "Invalid response data - expected recurring booking but received non array response"
-            );
-          }
-        });
-    });
-
-    afterEach(async () => {
-      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
-    });
-
-    afterAll(async () => {
-      await oauthClientRepositoryFixture.delete(oAuthClient.id);
-      await teamRepositoryFixture.delete(organization.id);
-      await userRepositoryFixture.deleteByEmail(user.email);
-      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
-      await app.close();
-    });
-  });
 });

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/variable-length-bookings.e2e-spec.ts

@@ -1,9 +1,6 @@
 import { bootstrap } from "@/app";
 import { AppModule } from "@/app.module";
-import { CancelBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/cancel-booking.output";
 import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
-import { MarkAbsentBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/mark-absent.output";
-import { RescheduleBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reschedule-booking.output";
 import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
 import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
 import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
@@ -71,6 +68,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
 
       user = await userRepositoryFixture.create({
         email: userEmail,
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
       });
 
       const userSchedule: CreateScheduleInput_2024_04_15 = {

apps/api/v2/src/ee/bookings/2024-08-13/services/bookings.service.ts

@@ -10,6 +10,7 @@ import { UsersRepository, UserWithProfile } from "@/modules/users/users.reposito
 import { Injectable, Logger, NotFoundException } from "@nestjs/common";
 import { BadRequestException } from "@nestjs/common";
 import { Request } from "express";
+import { z } from "zod";
 
 import {
   handleNewBooking,
@@ -38,6 +39,7 @@ import {
   CancelBookingInput,
 } from "@calcom/platform-types";
 import { PrismaClient } from "@calcom/prisma";
+import { EventType } from "@calcom/prisma/client";
 
 type CreatedBooking = {
   hosts: { id: number }[];
@@ -45,6 +47,14 @@ type CreatedBooking = {
   start: string;
 };
 
+const eventTypeBookingFieldSchema = z.object({
+  name: z.string(),
+  required: z.boolean(),
+  editable: z.string(),
+});
+
+const eventTypeBookingFieldsSchema = z.array(eventTypeBookingFieldSchema);
+
 @Injectable()
 export class BookingsService_2024_08_13 {
   private readonly logger = new Logger("BookingsService");
@@ -70,6 +80,8 @@ export class BookingsService_2024_08_13 {
       const isRecurring = !!eventType?.recurringEvent;
       const isSeated = !!eventType?.seatsPerTimeSlot;
 
+      await this.hasRequiredBookingFieldsResponses(body, eventType);
+
       if (isRecurring && isSeated) {
         return await this.createRecurringSeatedBooking(request, body);
       }
@@ -91,6 +103,28 @@ export class BookingsService_2024_08_13 {
     }
   }
 
+  async hasRequiredBookingFieldsResponses(body: CreateBookingInput, eventType: EventType | null) {
+    const bookingFields = body.bookingFieldsResponses;
+    if (!bookingFields || !eventType || !eventType.bookingFields) {
+      return true;
+    }
+
+    // note(Lauris): we filter out system fields, because some of them are set by default and name and email are passed in the body.attendee
+    const eventTypeBookingFields = eventTypeBookingFieldsSchema
+      .parse(eventType.bookingFields)
+      .filter((field) => !field.editable.startsWith("system"));
+
+    for (const field of eventTypeBookingFields) {
+      if (field.required && !(field.name in bookingFields)) {
+        throw new BadRequestException(`
+          Missing required booking field response: ${field.name} - it is required by the event type booking fields, but missing in the bookingFieldsResponses.
+          You can fetch the event type with ID ${eventType.id} to see the required fields.`);
+      }
+    }
+
+    return true;
+  }
+
   async createInstantBooking(request: Request, body: CreateInstantBookingInput_2024_08_13) {
     const bookingRequest = await this.inputService.createBookingRequest(request, body);
     const booking = await handleInstantMeeting(bookingRequest);
@@ -307,9 +341,26 @@ export class BookingsService_2024_08_13 {
 
     const bookingRequest = await this.inputService.createCancelBookingRequest(request, bookingUid, body);
     await handleCancelBooking(bookingRequest);
+
+    if ("cancelSubsequentBookings" in body && body.cancelSubsequentBookings) {
+      return this.getAllRecurringBookingsByIndividualUid(bookingUid);
+    }
+
     return this.getBooking(bookingUid);
   }
 
+  private async getAllRecurringBookingsByIndividualUid(bookingUid: string) {
+    const booking = await this.bookingsRepository.getByUid(bookingUid);
+    const recurringBookingUid = booking?.recurringEventId;
+    if (!recurringBookingUid) {
+      throw new BadRequestException(
+        `Booking with bookingUid=${bookingUid} is not part of a recurring booking.`
+      );
+    }
+
+    return await this.getBooking(recurringBookingUid);
+  }
+
   async markAbsent(bookingUid: string, bookingOwnerId: number, body: MarkAbsentBookingInput_2024_08_13) {
     const bodyTransformed = this.inputService.transformInputMarkAbsentBooking(body);
 
@@ -372,11 +423,14 @@ export class BookingsService_2024_08_13 {
       throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
     }
 
+    const emailsEnabled = booking.eventTypeId ? await this.getEmailsEnabled(booking.eventTypeId) : true;
+
     const profile = this.usersService.getUserMainProfile(requestUser);
 
     await roundRobinReassignment({
       bookingId: booking.id,
       orgId: profile?.organizationId || null,
+      emailsEnabled,
     });
 
     const reassigned = await this.bookingsRepository.getByUidWithUser(bookingUid);
@@ -387,6 +441,12 @@ export class BookingsService_2024_08_13 {
     return this.outputService.getOutputReassignedBooking(reassigned);
   }
 
+  async getEmailsEnabled(eventTypeId: number) {
+    const oAuthParams = await this.inputService.getOAuthClientParams(eventTypeId);
+    const emailsEnabled = oAuthParams ? oAuthParams.arePlatformEmailsEnabled : true;
+    return emailsEnabled;
+  }
+
   async reassignBookingToUser(
     bookingUid: string,
     newUserId: number,
@@ -403,6 +463,8 @@ export class BookingsService_2024_08_13 {
       throw new NotFoundException(`User with id=${newUserId} was not found in the database`);
     }
 
+    const emailsEnabled = booking.eventTypeId ? await this.getEmailsEnabled(booking.eventTypeId) : true;
+
     const profile = this.usersService.getUserMainProfile(user);
 
     const reassigned = await roundRobinManualReassignment({
@@ -411,6 +473,7 @@ export class BookingsService_2024_08_13 {
       orgId: profile?.organizationId || null,
       reassignReason: body.reason,
       reassignedById,
+      emailsEnabled,
     });
 
     return this.outputService.getOutputReassignedBooking(reassigned);
@@ -422,6 +485,8 @@ export class BookingsService_2024_08_13 {
       throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
     }
 
+    const emailsEnabled = booking.eventTypeId ? await this.getEmailsEnabled(booking.eventTypeId) : true;
+
     await confirmBookingHandler({
       ctx: {
         user: requestUser,
@@ -430,6 +495,7 @@ export class BookingsService_2024_08_13 {
         bookingId: booking.id,
         confirmed: true,
         recurringEventId: booking.recurringEventId,
+        emailsEnabled,
       },
     });
 
@@ -442,6 +508,8 @@ export class BookingsService_2024_08_13 {
       throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
     }
 
+    const emailsEnabled = booking.eventTypeId ? await this.getEmailsEnabled(booking.eventTypeId) : true;
+
     await confirmBookingHandler({
       ctx: {
         user: requestUser,
@@ -451,6 +519,7 @@ export class BookingsService_2024_08_13 {
         confirmed: false,
         recurringEventId: booking.recurringEventId,
         reason,
+        emailsEnabled,
       },
     });
 

apps/api/v2/src/ee/bookings/2024-08-13/services/input.service.ts

@@ -18,7 +18,6 @@ import { NextApiRequest } from "next/types";
 import { v4 as uuidv4 } from "uuid";
 import { z } from "zod";
 
-import { X_CAL_CLIENT_ID } from "@calcom/platform-constants";
 import { EventTypeMetaDataSchema } from "@calcom/platform-libraries";
 import {
   CancelBookingInput,
@@ -33,19 +32,10 @@ import {
   RescheduleBookingInput_2024_08_13,
   RescheduleSeatedBookingInput_2024_08_13,
 } from "@calcom/platform-types";
-import { EventType } from "@calcom/prisma/client";
+import { EventType, PlatformOAuthClient } from "@calcom/prisma/client";
 
 type BookingRequest = NextApiRequest & { userId: number | undefined } & OAuthRequestParams;
 
-const DEFAULT_PLATFORM_PARAMS = {
-  platformClientId: "",
-  platformCancelUrl: "",
-  platformRescheduleUrl: "",
-  platformBookingUrl: "",
-  arePlatformEmailsEnabled: false,
-  platformBookingLocation: undefined,
-};
-
 type OAuthRequestParams = {
   platformClientId: string;
   platformRescheduleUrl: string;
@@ -92,30 +82,53 @@ export class InputBookingsService_2024_08_13 {
     body: CreateBookingInput_2024_08_13 | CreateInstantBookingInput_2024_08_13
   ): Promise<BookingRequest> {
     const bodyTransformed = await this.transformInputCreateBooking(body);
-    const oAuthClientId = request.get(X_CAL_CLIENT_ID);
-    const requestId = request.get("X-Request-Id");
+    const oAuthClientParams = await this.getOAuthClientParams(body.eventTypeId);
 
     const newRequest = { ...request };
     const userId = (await this.createBookingRequestOwnerId(request)) ?? undefined;
-    const oAuthParams = oAuthClientId
-      ? await this.createBookingRequestOAuthClientParams(oAuthClientId)
-      : DEFAULT_PLATFORM_PARAMS;
 
     const location = request.body.location || request.body.meetingUrl;
     this.logger.log(`createBookingRequest_2024_04_15`, {
-      requestId,
+      requestId: request.get("X-Request-Id"),
       ownerId: userId,
       location,
-      oAuthClientId,
-      ...oAuthParams,
+      oAuthClientParams,
     });
-    Object.assign(newRequest, { userId, ...oAuthParams, platformBookingLocation: location });
 
-    newRequest.body = { ...bodyTransformed, noEmail: !oAuthParams.arePlatformEmailsEnabled };
+    if (oAuthClientParams) {
+      Object.assign(newRequest, { userId, ...oAuthClientParams, platformBookingLocation: location });
+      newRequest.body = { ...bodyTransformed, noEmail: !oAuthClientParams.arePlatformEmailsEnabled };
+    } else {
+      Object.assign(newRequest, { userId, platformBookingLocation: location });
+      newRequest.body = { ...bodyTransformed, noEmail: false };
+    }
 
     return newRequest as unknown as BookingRequest;
   }
 
+  async getOAuthClientParams(eventTypeId: number) {
+    const eventType = await this.eventTypesRepository.getEventTypeById(eventTypeId);
+
+    let oAuthClient: PlatformOAuthClient | null = null;
+    if (eventType?.userId) {
+      oAuthClient = await this.oAuthClientRepository.getByUserId(eventType.userId);
+    } else if (eventType?.teamId) {
+      oAuthClient = await this.oAuthClientRepository.getByTeamId(eventType.teamId);
+    }
+
+    if (oAuthClient) {
+      return {
+        platformClientId: oAuthClient.id,
+        platformCancelUrl: oAuthClient.bookingCancelRedirectUri,
+        platformRescheduleUrl: oAuthClient.bookingRescheduleRedirectUri,
+        platformBookingUrl: oAuthClient.bookingRedirectUri,
+        arePlatformEmailsEnabled: oAuthClient.areEmailsEnabled,
+      };
+    }
+
+    return undefined;
+  }
+
   async transformInputCreateBooking(inputBooking: CreateBookingInput_2024_08_13) {
     const eventType = await this.eventTypesRepository.getEventTypeByIdWithOwnerAndTeam(
       inputBooking.eventTypeId
@@ -139,9 +152,7 @@ export class InputBookingsService_2024_08_13 {
       eventTypeId: inputBooking.eventTypeId,
       timeZone: inputBooking.attendee.timeZone,
       language: inputBooking.attendee.language || "en",
-      // todo(Lauris): expose after refactoring metadata https://app.campsite.co/cal/posts/zysq8w9rwm9c
-      // metadata: inputBooking.metadata || {},
-      metadata: {},
+      metadata: inputBooking.metadata || {},
       hasHashedBookingLink: false,
       guests: inputBooking.guests,
       // note(Lauris): responses with name and email are required by the handleNewBooking
@@ -180,21 +191,23 @@ export class InputBookingsService_2024_08_13 {
   ): Promise<BookingRequest> {
     // note(Lauris): update to this.transformInputCreate when rescheduling is implemented
     const bodyTransformed = await this.transformInputCreateRecurringBooking(body);
-    const oAuthClientId = request.get(X_CAL_CLIENT_ID);
+    const oAuthClientParams = await this.getOAuthClientParams(body.eventTypeId);
 
     const newRequest = { ...request };
     const userId = (await this.createBookingRequestOwnerId(request)) ?? undefined;
-    const oAuthParams = oAuthClientId
-      ? await this.createBookingRequestOAuthClientParams(oAuthClientId)
-      : DEFAULT_PLATFORM_PARAMS;
 
     const location = request.body.location || request.body.meetingUrl;
-    Object.assign(newRequest, {
-      userId,
-      ...oAuthParams,
-      platformBookingLocation: location,
-      noEmail: !oAuthParams.arePlatformEmailsEnabled,
-    });
+
+    if (oAuthClientParams) {
+      Object.assign(newRequest, {
+        userId,
+        ...oAuthClientParams,
+        platformBookingLocation: location,
+        noEmail: !oAuthClientParams.arePlatformEmailsEnabled,
+      });
+    } else {
+      Object.assign(newRequest, { userId, platformBookingLocation: location });
+    }
 
     newRequest.body = bodyTransformed.map((event) => ({
       ...event,
@@ -243,9 +256,7 @@ export class InputBookingsService_2024_08_13 {
         recurringEventId,
         timeZone: inputBooking.attendee.timeZone,
         language: inputBooking.attendee.language || "en",
-        // todo(Lauris): expose after refactoring metadata https://app.campsite.co/cal/posts/zysq8w9rwm9c
-        // metadata: inputBooking.metadata || {},
-        metadata: {},
+        metadata: inputBooking.metadata || {},
         hasHashedBookingLink: false,
         guests: inputBooking.guests,
         // note(Lauris): responses with name and email are required by the handleNewBooking
@@ -285,18 +296,20 @@ export class InputBookingsService_2024_08_13 {
     const bodyTransformed = this.isRescheduleSeatedBody(body)
       ? await this.transformInputRescheduleSeatedBooking(bookingUid, body)
       : await this.transformInputRescheduleBooking(bookingUid, body);
-    const oAuthClientId = request.get(X_CAL_CLIENT_ID);
+
+    const oAuthClientParams = await this.getOAuthClientParams(bodyTransformed.eventTypeId);
 
     const newRequest = { ...request };
     const userId = (await this.createBookingRequestOwnerId(request)) ?? undefined;
-    const oAuthParams = oAuthClientId
-      ? await this.createBookingRequestOAuthClientParams(oAuthClientId)
-      : DEFAULT_PLATFORM_PARAMS;
 
     const location = await this.getRescheduleBookingLocation(bookingUid);
-    Object.assign(newRequest, { userId, ...oAuthParams, platformBookingLocation: location });
-
-    newRequest.body = { ...bodyTransformed, noEmail: !oAuthParams.arePlatformEmailsEnabled };
+    if (oAuthClientParams) {
+      Object.assign(newRequest, { userId, ...oAuthClientParams, platformBookingLocation: location });
+      newRequest.body = { ...bodyTransformed, noEmail: !oAuthClientParams.arePlatformEmailsEnabled };
+    } else {
+      Object.assign(newRequest, { userId, platformBookingLocation: location });
+      newRequest.body = { ...bodyTransformed, noEmail: false };
+    }
 
     return newRequest as unknown as BookingRequest;
   }
@@ -345,9 +358,7 @@ export class InputBookingsService_2024_08_13 {
       eventTypeId: eventType.id,
       timeZone: attendee.timeZone,
       language: attendee.locale,
-      // todo(Lauris): expose after refactoring metadata https://app.campsite.co/cal/posts/zysq8w9rwm9c
-      // metadata: booking.metadata || {},
-      metadata: {},
+      metadata: seat.metadata || {},
       hasHashedBookingLink: false,
       guests: [],
       responses: { ...bookingResponses },
@@ -386,9 +397,7 @@ export class InputBookingsService_2024_08_13 {
       eventTypeId: eventType.id,
       timeZone: attendee.timeZone,
       language: attendee.locale,
-      // todo(Lauris): expose after refactoring metadata https://app.campsite.co/cal/posts/zysq8w9rwm9c
-      // metadata: booking.metadata || {},
-      metadata: {},
+      metadata: booking.metadata || {},
       hasHashedBookingLink: false,
       guests: bookingResponses.guests,
       responses: { ...bookingResponses, rescheduledReason: inputBooking.reschedulingReason },
@@ -423,24 +432,6 @@ export class InputBookingsService_2024_08_13 {
     }
   }
 
-  private async createBookingRequestOAuthClientParams(clientId: string) {
-    const params = DEFAULT_PLATFORM_PARAMS;
-    try {
-      const client = await this.oAuthClientRepository.getOAuthClient(clientId);
-      if (client) {
-        params.platformClientId = clientId;
-        params.platformCancelUrl = client.bookingCancelRedirectUri ?? "";
-        params.platformRescheduleUrl = client.bookingRescheduleRedirectUri ?? "";
-        params.platformBookingUrl = client.bookingRedirectUri ?? "";
-        params.arePlatformEmailsEnabled = client.areEmailsEnabled ?? false;
-      }
-      return params;
-    } catch (err) {
-      this.logger.error(err);
-      return params;
-    }
-  }
-
   transformGetBookingsFilters(queryParams: GetBookingsInput_2024_08_13) {
     return {
       attendeeEmail: queryParams.attendeeEmail,
@@ -473,17 +464,26 @@ export class InputBookingsService_2024_08_13 {
     const bodyTransformed = this.isCancelSeatedBody(body)
       ? await this.transformInputCancelSeatedBooking(bookingUid, body)
       : await this.transformInputCancelBooking(bookingUid, body);
-    const oAuthClientId = request.get(X_CAL_CLIENT_ID);
+
+    const booking = await this.bookingsRepository.getByUid(bodyTransformed.uid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} not found`);
+    }
+
+    const oAuthClientParams = booking.eventTypeId
+      ? await this.getOAuthClientParams(booking.eventTypeId)
+      : undefined;
 
     const newRequest = { ...request };
     const userId = (await this.createBookingRequestOwnerId(request)) ?? undefined;
-    const oAuthParams = oAuthClientId
-      ? await this.createBookingRequestOAuthClientParams(oAuthClientId)
-      : DEFAULT_PLATFORM_PARAMS;
 
-    Object.assign(newRequest, { userId, ...oAuthParams });
-
-    newRequest.body = { ...bodyTransformed, noEmail: !oAuthParams.arePlatformEmailsEnabled };
+    if (oAuthClientParams) {
+      Object.assign(newRequest, { userId, ...oAuthClientParams });
+      newRequest.body = { ...bodyTransformed, noEmail: !oAuthClientParams.arePlatformEmailsEnabled };
+    } else {
+      Object.assign(newRequest, { userId });
+      newRequest.body = { ...bodyTransformed, noEmail: false };
+    }
 
     return newRequest as unknown as BookingRequest;
   }
@@ -493,23 +493,38 @@ export class InputBookingsService_2024_08_13 {
   }
 
   async transformInputCancelBooking(bookingUid: string, inputBooking: CancelBookingInput_2024_08_13) {
-    let allRemainingBookings = false;
-    let uid = bookingUid;
-    const recurringBooking = await this.bookingsRepository.getRecurringByUidWithAttendeesAndUserAndEvent(
-      bookingUid
-    );
+    const recurringBooking = await this.bookingsRepository.getRecurringByUid(bookingUid);
+    // note(Lauris): isRecurring means that recurringEventId was passed as uid. isRecurring does not refer to the uid of 1 individual booking within a recurring booking consisting of many bookings.
+    // That is what recurringEventId refers to.
+    const isRecurringUid = !!recurringBooking.length;
 
-    if (recurringBooking.length) {
-      // note(Lauirs): this means that bookingUid is equal to recurringEventId on individual bookings of recurring one aka main recurring event
-      allRemainingBookings = true;
-      // note(Lauirs): we need to set uid as one of the individual recurring ids, not the main recurring event id
-      uid = recurringBooking[0].uid;
+    if (isRecurringUid && inputBooking.cancelSubsequentBookings) {
+      throw new BadRequestException(
+        "Cannot cancel subsequent bookings for recurring event - you have to provide uid of one of the individual bookings of a recurring booking."
+      );
+    }
+
+    if (isRecurringUid) {
+      return {
+        // note(Lauris): set uid as one of the oldest individual recurring ids
+        uid: recurringBooking[0].uid,
+        cancellationReason: inputBooking.cancellationReason,
+        allRemainingBookings: true,
+      };
+    }
+
+    if (inputBooking.cancelSubsequentBookings) {
+      return {
+        uid: bookingUid,
+        cancellationReason: inputBooking.cancellationReason,
+        cancelSubsequentBookings: true,
+      };
     }
 
     return {
-      uid,
+      uid: bookingUid,
       cancellationReason: inputBooking.cancellationReason,
-      allRemainingBookings,
+      allRemainingBookings: false,
     };
   }
 
@@ -517,23 +532,12 @@ export class InputBookingsService_2024_08_13 {
     bookingUid: string,
     inputBooking: CancelSeatedBookingInput_2024_08_13
   ) {
-    let allRemainingBookings = false;
-    let uid = bookingUid;
-    const recurringBooking = await this.bookingsRepository.getRecurringByUidWithAttendeesAndUserAndEvent(
-      bookingUid
-    );
-
-    if (recurringBooking.length) {
-      // note(Lauirs): this means that bookingUid is equal to recurringEventId on individual bookings of recurring one aka main recurring event
-      allRemainingBookings = true;
-      // note(Lauirs): we need to set uid as one of the individual recurring ids, not the main recurring event id
-      uid = recurringBooking[0].uid;
-    }
-
+    // note(Lauris): for recurring seated booking it is not possible to cancel all remaining bookings
+    // for an individual person, so api users need to call booking by booking using uid + seatUid to cancel it.
     return {
-      uid,
+      uid: bookingUid,
       cancellationReason: "",
-      allRemainingBookings,
+      allRemainingBookings: false,
       seatReferenceUid: inputBooking.seatUid,
     };
   }

apps/api/v2/src/ee/bookings/2024-08-13/services/output.service.ts

@@ -4,6 +4,7 @@ import { plainToClass } from "class-transformer";
 import { DateTime } from "luxon";
 import { z } from "zod";
 
+import { bookingMetadataSchema } from "@calcom/platform-libraries";
 import {
   BookingOutput_2024_08_13,
   CreateRecurringSeatedBookingOutput_2024_08_13,
@@ -19,7 +20,13 @@ import { Booking, BookingSeat } from "@calcom/prisma/client";
 export const bookingResponsesSchema = z
   .object({
     email: z.string(),
-    name: z.string(),
+    name: z.union([
+      z.string(),
+      z.object({
+        firstName: z.string(),
+        lastName: z.string(),
+      }),
+    ]),
     guests: z.array(z.string()).optional(),
     rescheduleReason: z.string().optional(),
   })
@@ -30,12 +37,20 @@ export const seatedBookingResponsesSchema = z
     responses: z
       .object({
         email: z.string(),
-        name: z.string(),
+        name: z.union([
+          z.string(),
+          z.object({
+            firstName: z.string(),
+            lastName: z.string(),
+          }),
+        ]),
       })
       .passthrough(),
   })
   .passthrough();
 
+type DatabaseUser = { id: number; name: string | null; email: string; username: string | null };
+
 type DatabaseBooking = Booking & {
   eventType: {
     id: number;
@@ -49,9 +64,15 @@ type DatabaseBooking = Booking & {
     noShow: boolean | null;
     bookingSeat?: BookingSeat | null;
   }[];
-} & { user: { id: number; name: string | null; email: string } | null };
+  user: DatabaseUser | null;
+  createdAt: Date;
+};
 
-type BookingWithUser = Booking & { user: { id: number; name: string | null; email: string } | null };
+type BookingWithUser = Booking & { user: DatabaseUser | null };
+
+type DatabaseMetadata = z.infer<typeof bookingMetadataSchema>;
+
+const seatedBookingMetadataSchema = z.object({}).catchall(z.string());
 
 @Injectable()
 export class OutputBookingsService_2024_08_13 {
@@ -61,15 +82,16 @@ export class OutputBookingsService_2024_08_13 {
     const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
     const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
     const duration = dateEnd.diff(dateStart, "minutes").minutes;
-
     const bookingResponses = bookingResponsesSchema.parse(databaseBooking.responses);
+    const metadata = bookingMetadataSchema.parse(databaseBooking.metadata);
+    const location = metadata?.videoCallUrl || databaseBooking.location;
 
     const booking = {
       id: databaseBooking.id,
       uid: databaseBooking.uid,
       title: databaseBooking.title,
       description: databaseBooking.description,
-      hosts: [databaseBooking.user],
+      hosts: [this.getHost(databaseBooking.user)],
       status: databaseBooking.status.toLowerCase(),
       cancellationReason: databaseBooking.cancellationReason || undefined,
       reschedulingReason: bookingResponses?.rescheduledReason,
@@ -88,18 +110,44 @@ export class OutputBookingsService_2024_08_13 {
         absent: !!attendee.noShow,
       })),
       guests: bookingResponses.guests,
-      location: databaseBooking.location,
+      location,
       // note(Lauris): meetingUrl is deprecated
-      meetingUrl: databaseBooking.location,
+      meetingUrl: location,
       absentHost: !!databaseBooking.noShowHost,
+      createdAt: databaseBooking.createdAt,
     };
 
     const bookingTransformed = plainToClass(BookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
-    // note(Lauris): I don't know why plainToClass erases bookings responses so attaching manually
+    // note(Lauris): I don't know why plainToClass erases bookings responses and metadata so attaching manually
     bookingTransformed.bookingFieldsResponses = bookingResponses;
+    bookingTransformed.metadata = this.getUserDefinedMetadata(metadata);
     return bookingTransformed;
   }
 
+  getUserDefinedMetadata(databaseMetadata: DatabaseMetadata) {
+    if (databaseMetadata === null) return {};
+
+    const { videoCallUrl, ...userDefinedMetadata } = databaseMetadata;
+
+    return userDefinedMetadata;
+  }
+
+  getHost(user: DatabaseUser | null) {
+    if (!user) {
+      return {
+        id: "unknown",
+        name: "unknown",
+        email: "unknown",
+        username: "unknown",
+      };
+    }
+
+    return {
+      ...user,
+      username: user.username || "unknown",
+    };
+  }
+
   async getOutputRecurringBookings(bookingsIds: number[]) {
     const transformed = [];
 
@@ -119,15 +167,16 @@ export class OutputBookingsService_2024_08_13 {
     const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
     const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
     const duration = dateEnd.diff(dateStart, "minutes").minutes;
-
     const bookingResponses = bookingResponsesSchema.parse(databaseBooking.responses);
+    const metadata = bookingMetadataSchema.parse(databaseBooking.metadata);
+    const location = metadata?.videoCallUrl || databaseBooking.location;
 
     const booking = {
       id: databaseBooking.id,
       uid: databaseBooking.uid,
       title: databaseBooking.title,
       description: databaseBooking.description,
-      hosts: [databaseBooking.user],
+      hosts: [this.getHost(databaseBooking.user)],
       status: databaseBooking.status.toLowerCase(),
       cancellationReason: databaseBooking.cancellationReason || undefined,
       reschedulingReason: bookingResponses?.rescheduledReason,
@@ -146,15 +195,22 @@ export class OutputBookingsService_2024_08_13 {
         absent: !!attendee.noShow,
       })),
       guests: bookingResponses.guests,
-      location: databaseBooking.location,
+      location,
       // note(Lauris): meetingUrl is deprecated
-      meetingUrl: databaseBooking.location,
+      meetingUrl: location,
       recurringBookingUid: databaseBooking.recurringEventId,
       absentHost: !!databaseBooking.noShowHost,
       bookingFieldsResponses: databaseBooking.responses,
+      createdAt: databaseBooking.createdAt,
     };
 
-    return plainToClass(RecurringBookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
+    const bookingTransformed = plainToClass(RecurringBookingOutput_2024_08_13, booking, {
+      strategy: "excludeAll",
+    });
+    // note(Lauris): I don't know why plainToClass erases bookings responses and metadata so attaching manually
+    bookingTransformed.bookingFieldsResponses = bookingResponses;
+    bookingTransformed.metadata = this.getUserDefinedMetadata(metadata);
+    return bookingTransformed;
   }
 
   getOutputCreateSeatedBooking(
@@ -169,13 +225,15 @@ export class OutputBookingsService_2024_08_13 {
     const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
     const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
     const duration = dateEnd.diff(dateStart, "minutes").minutes;
+    const metadata = bookingMetadataSchema.parse(databaseBooking.metadata);
+    const location = metadata?.videoCallUrl || databaseBooking.location;
 
     const booking = {
       id: databaseBooking.id,
       uid: databaseBooking.uid,
       title: databaseBooking.title,
       description: databaseBooking.description,
-      hosts: [databaseBooking.user],
+      hosts: [this.getHost(databaseBooking.user)],
       status: databaseBooking.status.toLowerCase(),
       rescheduledFromUid: databaseBooking.fromReschedule || undefined,
       start: databaseBooking.startTime,
@@ -185,10 +243,11 @@ export class OutputBookingsService_2024_08_13 {
       // note(Lauris): eventTypeId is deprecated
       eventTypeId: databaseBooking.eventTypeId,
       attendees: [],
-      location: databaseBooking.location,
+      location,
       // note(Lauris): meetingUrl is deprecated
-      meetingUrl: databaseBooking.location,
+      meetingUrl: location,
       absentHost: !!databaseBooking.noShowHost,
+      createdAt: databaseBooking.createdAt,
     };
 
     const parsed = plainToClass(GetSeatedBookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
@@ -208,6 +267,7 @@ export class OutputBookingsService_2024_08_13 {
       };
       const attendeeParsed = plainToClass(SeatedAttendee, attendeeData, { strategy: "excludeAll" });
       attendeeParsed.bookingFieldsResponses = responses || {};
+      attendeeParsed.metadata = seatedBookingMetadataSchema.parse(attendee.bookingSeat?.metadata);
       // note(Lauris): as of now email is not returned for privacy
       delete attendeeParsed.bookingFieldsResponses.email;
 
@@ -260,13 +320,15 @@ export class OutputBookingsService_2024_08_13 {
     const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
     const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
     const duration = dateEnd.diff(dateStart, "minutes").minutes;
+    const metadata = bookingMetadataSchema.parse(databaseBooking.metadata);
+    const location = metadata?.videoCallUrl || databaseBooking.location;
 
     const booking = {
       id: databaseBooking.id,
       uid: databaseBooking.uid,
       title: databaseBooking.title,
       description: databaseBooking.description,
-      hosts: [databaseBooking.user],
+      hosts: [this.getHost(databaseBooking.user)],
       status: databaseBooking.status.toLowerCase(),
       cancellationReason: databaseBooking.cancellationReason || undefined,
       rescheduledFromUid: databaseBooking.fromReschedule || undefined,
@@ -277,11 +339,12 @@ export class OutputBookingsService_2024_08_13 {
       // note(Lauris): eventTypeId is deprecated
       eventTypeId: databaseBooking.eventTypeId,
       attendees: [],
-      location: databaseBooking.location,
+      location,
       // note(Lauris): meetingUrl is deprecated
-      meetingUrl: databaseBooking.location,
+      meetingUrl: location,
       recurringBookingUid: databaseBooking.recurringEventId,
       absentHost: !!databaseBooking.noShowHost,
+      createdAt: databaseBooking.createdAt,
     };
 
     const parsed = plainToClass(GetRecurringSeatedBookingOutput_2024_08_13, booking, {
@@ -303,9 +366,9 @@ export class OutputBookingsService_2024_08_13 {
       };
       const attendeeParsed = plainToClass(SeatedAttendee, attendeeData, { strategy: "excludeAll" });
       attendeeParsed.bookingFieldsResponses = responses || {};
+      attendeeParsed.metadata = seatedBookingMetadataSchema.parse(attendee.bookingSeat?.metadata);
       // note(Lauris): as of now email is not returned for privacy
       delete attendeeParsed.bookingFieldsResponses.email;
-
       return attendeeParsed;
     });
 

apps/api/v2/src/lib/logger.ts

@@ -1,6 +1,6 @@
 import { WinstonTransport as AxiomTransport } from "@axiomhq/winston";
 import type { LoggerOptions } from "winston";
-import { format, transports as Transports } from "winston";
+import { format, transports as Transports, config } from "winston";
 import type Transport from "winston-transport";
 
 const formattedTimestamp = format.timestamp({
@@ -8,14 +8,7 @@ const formattedTimestamp = format.timestamp({
 });
 
 const colorizer = format.colorize({
-  colors: {
-    fatal: "red",
-    error: "red",
-    warn: "yellow",
-    info: "blue",
-    debug: "white",
-    trace: "grey",
-  },
+  colors: config.npm.colors,
 });
 
 const WINSTON_DEV_FORMAT = format.combine(
@@ -26,14 +19,7 @@ const WINSTON_DEV_FORMAT = format.combine(
 );
 const WINSTON_PROD_FORMAT = format.combine(format.errors({ stack: true }), formattedTimestamp, format.json());
 
-export const logLevels = {
-  fatal: 0,
-  error: 1,
-  warn: 2,
-  info: 3,
-  debug: 4,
-  trace: 5,
-} as const;
+export const logLevels = config.npm.levels;
 
 export const loggerConfig = (): LoggerOptions => {
   const isProduction = process.env.NODE_ENV === "production";

apps/api/v2/src/lib/throttler-guard.ts

@@ -56,7 +56,7 @@ export class CustomThrottlerGuard extends ThrottlerGuard {
     const request = context.switchToHttp().getRequest<Request>();
     const response = context.switchToHttp().getResponse<Response>();
     const tracker = await this.getTracker(request);
-    this.logger.log(
+    this.logger.verbose(
       `Tracker "${tracker}" generated based on: Bearer token "${request.get(
         "Authorization"
       )}", OAuth client ID "${request.get(X_CAL_CLIENT_ID)}" and IP "${request.ip}"`
@@ -89,7 +89,7 @@ export class CustomThrottlerGuard extends ThrottlerGuard {
 
   private async handleNonApiKeyRequest(tracker: string, response: Response): Promise<boolean> {
     const rateLimit = this.getDefaultRateLimit(tracker);
-    this.logger.log(`Tracker "${tracker}" uses default rate limits because it is not tracking api key:
+    this.logger.verbose(`Tracker "${tracker}" uses default rate limits because it is not tracking api key:
       ${JSON.stringify(rateLimit, null, 2)}
     `);
 
@@ -135,7 +135,7 @@ export class CustomThrottlerGuard extends ThrottlerGuard {
 
     const cachedRateLimits = await this.storageService.redis.get(cacheKey);
     if (cachedRateLimits) {
-      this.logger.log(`Tracker "${tracker}" rate limits retrieved from redis cache:
+      this.logger.verbose(`Tracker "${tracker}" rate limits retrieved from redis cache:
         ${cachedRateLimits}
       `);
       return rateLimitsSchema.parse(JSON.parse(cachedRateLimits));
@@ -158,13 +158,13 @@ export class CustomThrottlerGuard extends ThrottlerGuard {
     });
 
     if (rateLimits) {
-      this.logger.log(`Tracker "${tracker}" rate limits retrieved from database:
+      this.logger.verbose(`Tracker "${tracker}" rate limits retrieved from database:
         ${JSON.stringify(rateLimits, null, 2)}`);
     }
 
     if (!rateLimits || rateLimits.length === 0) {
       rateLimits = [this.getDefaultRateLimit(tracker)];
-      this.logger.log(`Tracker "${tracker}" rate limits not found in database. Using default rate limits:
+      this.logger.verbose(`Tracker "${tracker}" rate limits not found in database. Using default rate limits:
         ${JSON.stringify(rateLimits, null, 2)}`);
     }
 
@@ -194,10 +194,10 @@ export class CustomThrottlerGuard extends ThrottlerGuard {
     );
     response.setHeader(`X-RateLimit-Reset-${nameFirstUpper}`, timeToBlockExpire || timeToExpire);
 
-    this.logger.log(
+    this.logger.verbose(
       `Tracker "${tracker}" rate limit "${name}" incremented. isBlocked ${isBlocked}, totalHits ${totalHits}, timeToExpire ${timeToExpire}, timeToBlockExpire ${timeToBlockExpire}`
     );
-    this.logger.log(
+    this.logger.verbose(
       `Tracker "${tracker}" rate limit "${name}" response headers:
         X-RateLimit-Limit-${nameFirstUpper}: ${limit},
         X-RateLimit-Remaining-${nameFirstUpper}: ${timeToBlockExpire ? 0 : Math.max(0, limit - totalHits)},
@@ -227,7 +227,7 @@ export class CustomThrottlerGuard extends ThrottlerGuard {
       return `ip_${request.ip}`;
     }
 
-    this.logger.log(`no tracker found: ${request.url}`);
+    this.logger.verbose(`no tracker found: ${request.url}`);
     return "unknown";
   }
 }

apps/api/v2/src/modules/auth/guards/billing/platform-plan.guard.ts

@@ -49,7 +49,7 @@ export class PlatformPlanGuard implements CanActivate {
         canAccess = hasMinimumPlan({
           currentPlan: team.platformBilling?.plan as PlatformPlanType,
           minimumPlan: minimumPlan,
-          plans: ["STARTER", "ESSENTIALS", "SCALE", "ENTERPRISE"],
+          plans: ["FREE", "STARTER", "ESSENTIALS", "SCALE", "ENTERPRISE"],
         });
       }
     }

apps/api/v2/src/modules/oauth-clients/controllers/oauth-client-users/oauth-client-users.controller.e2e-spec.ts

@@ -16,6 +16,7 @@ import { Test } from "@nestjs/testing";
 import { PlatformOAuthClient, Team, User, EventType } from "@prisma/client";
 import * as request from "supertest";
 import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
 import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
 import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
 import { SchedulesRepositoryFixture } from "test/fixtures/repository/schedules.repository.fixture";
@@ -79,6 +80,7 @@ describe("OAuth Client Users Endpoints", () => {
     let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
     let schedulesRepositoryFixture: SchedulesRepositoryFixture;
     let profilesRepositoryFixture: ProfileRepositoryFixture;
+    let membershipsRepositoryFixture: MembershipRepositoryFixture;
 
     let postResponseData: CreateManagedUserOutput["data"];
 
@@ -103,26 +105,33 @@ describe("OAuth Client Users Endpoints", () => {
       eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
       schedulesRepositoryFixture = new SchedulesRepositoryFixture(moduleRef);
       profilesRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+      membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
 
       platformAdmin = await userRepositoryFixture.create({ email: platformAdminEmail });
 
-      organization = await teamRepositoryFixture.create({ name: "organization" });
+      organization = await teamRepositoryFixture.create({
+        name: "organization",
+        isPlatform: true,
+        isOrganization: true,
+      });
       oAuthClient = await createOAuthClient(organization.id);
 
       await profilesRepositoryFixture.create({
-        uid: "asd-asd",
+        uid: "asd1qwwqeqw-asddsadasd",
         username: platformAdminEmail,
         organization: { connect: { id: organization.id } },
-        movedFromUser: {
-          connect: {
-            id: platformAdmin.id,
-          },
-        },
         user: {
           connect: { id: platformAdmin.id },
         },
       });
 
+      await membershipsRepositoryFixture.create({
+        role: "OWNER",
+        user: { connect: { id: platformAdmin.id } },
+        team: { connect: { id: organization.id } },
+        accepted: true,
+      });
+
       await app.init();
     });
 
@@ -370,7 +379,7 @@ describe("OAuth Client Users Endpoints", () => {
     let teamRepositoryFixture: TeamRepositoryFixture;
     let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
     let profileRepositoryFixture: ProfileRepositoryFixture;
-
+    let membershipsRepositoryFixture: MembershipRepositoryFixture;
     let postResponseData: CreateManagedUserOutput["data"];
 
     const userEmail = "oauth-client-users-user@gmail.com";
@@ -390,10 +399,11 @@ describe("OAuth Client Users Endpoints", () => {
       teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
       eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
       profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
-
+      membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
       organization = await teamRepositoryFixture.create({
         name: "Testy Organization",
         isOrganization: true,
+        isPlatform: true,
       });
 
       owner = await userRepositoryFixture.create({
@@ -417,6 +427,13 @@ describe("OAuth Client Users Endpoints", () => {
         },
       });
 
+      await membershipsRepositoryFixture.create({
+        role: "OWNER",
+        user: { connect: { id: owner.id } },
+        team: { connect: { id: organization.id } },
+        accepted: true,
+      });
+
       oAuthClient1 = await createOAuthClient(organization.id);
       oAuthClient2 = await createOAuthClient(organization.id);
 

apps/api/v2/src/modules/oauth-clients/controllers/oauth-client-users/oauth-client-users.controller.ts

@@ -1,6 +1,8 @@
 import { API_VERSIONS_VALUES } from "@/lib/api-versions";
 import { Locales } from "@/lib/enums/locales";
+import { MembershipRoles } from "@/modules/auth/decorators/roles/membership-roles.decorator";
 import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { OrganizationRolesGuard } from "@/modules/auth/guards/organization-roles/organization-roles.guard";
 import { CreateManagedUserOutput } from "@/modules/oauth-clients/controllers/oauth-client-users/outputs/create-managed-user.output";
 import { GetManagedUserOutput } from "@/modules/oauth-clients/controllers/oauth-client-users/outputs/get-managed-user.output";
 import { GetManagedUsersOutput } from "@/modules/oauth-clients/controllers/oauth-client-users/outputs/get-managed-users.output";
@@ -29,7 +31,7 @@ import {
   NotFoundException,
 } from "@nestjs/common";
 import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
-import { User } from "@prisma/client";
+import { User, MembershipRole } from "@prisma/client";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
 import { Pagination } from "@calcom/platform-types";
@@ -38,7 +40,7 @@ import { Pagination } from "@calcom/platform-types";
   path: "/v2/oauth-clients/:clientId/users",
   version: API_VERSIONS_VALUES,
 })
-@UseGuards(ApiAuthGuard, OAuthClientGuard)
+@UseGuards(ApiAuthGuard, OAuthClientGuard, OrganizationRolesGuard)
 @DocsTags("Platform / Managed Users")
 export class OAuthClientUsersController {
   private readonly logger = new Logger("UserController");
@@ -52,6 +54,7 @@ export class OAuthClientUsersController {
 
   @Get("/")
   @ApiOperation({ summary: "Get all managed users" })
+  @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
   async getManagedUsers(
     @Param("clientId") oAuthClientId: string,
     @Query() queryParams: Pagination
@@ -73,6 +76,7 @@ export class OAuthClientUsersController {
 
   @Post("/")
   @ApiOperation({ summary: "Create a managed user" })
+  @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
   async createUser(
     @Param("clientId") oAuthClientId: string,
     @Body() body: CreateManagedUserInput
@@ -104,6 +108,7 @@ export class OAuthClientUsersController {
   @Get("/:userId")
   @HttpCode(HttpStatus.OK)
   @ApiOperation({ summary: "Get a managed user" })
+  @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
   async getUserById(
     @Param("clientId") clientId: string,
     @Param("userId") userId: number
@@ -119,6 +124,7 @@ export class OAuthClientUsersController {
   @Patch("/:userId")
   @HttpCode(HttpStatus.OK)
   @ApiOperation({ summary: "Update a managed user" })
+  @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
   async updateUser(
     @Param("clientId") clientId: string,
     @Param("userId") userId: number,
@@ -138,6 +144,7 @@ export class OAuthClientUsersController {
   @Delete("/:userId")
   @HttpCode(HttpStatus.OK)
   @ApiOperation({ summary: "Delete a managed user" })
+  @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
   async deleteUser(
     @Param("clientId") clientId: string,
     @Param("userId") userId: number
@@ -156,6 +163,7 @@ export class OAuthClientUsersController {
   @Post("/:userId/force-refresh")
   @HttpCode(HttpStatus.OK)
   @ApiOperation({ summary: "Force refresh tokens" })
+  @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
   async forceRefresh(
     @Param("userId") userId: number,
     @Param("clientId") oAuthClientId: string

apps/api/v2/src/modules/oauth-clients/oauth-client.repository.ts

@@ -99,4 +99,28 @@ export class OAuthClientRepository {
       where: { id: clientId },
     });
   }
+
+  async getByUserId(userId: number) {
+    return this.dbRead.prisma.platformOAuthClient.findFirst({
+      where: {
+        users: {
+          some: {
+            id: userId,
+          },
+        },
+      },
+    });
+  }
+
+  async getByTeamId(teamId: number) {
+    return this.dbRead.prisma.platformOAuthClient.findFirst({
+      where: {
+        teams: {
+          some: {
+            id: teamId,
+          },
+        },
+      },
+    });
+  }
 }

apps/api/v2/swagger/documentation.json

@@ -3162,6 +3162,7 @@
       "post": {
         "operationId": "BookingsController_2024_08_13_cancelBooking",
         "summary": "Cancel a booking",
+        "description": ":bookingUid can be :bookingUid of an usual booking, individual recurrence or recurring booking to cancel all recurrences.\n    For seated bookings to cancel one individual booking provide :bookingUid and :seatUid in the request body. For recurring seated bookings it is not possible to cancel all of them with 1 call\n    like with non-seated recurring bookings by providing recurring bookind uid - you have to cancel each recurrence booking by its bookingUid + seatUid.",
         "parameters": [
           {
             "name": "cal-api-version",
@@ -12849,6 +12850,13 @@
             "description": "Location for this booking. Displayed in email and calendar event.",
             "example": "https://example.com/meeting"
           },
+          "metadata": {
+            "type": "object",
+            "description": "You can store any additional data you want here. Metadata must have at most 50 keys, each key up to 40 characters, and string values up to 500 characters.",
+            "example": {
+              "key": "value"
+            }
+          },
           "bookingFieldsResponses": {
             "type": "object",
             "description": "Booking field responses consisting of an object with booking field slug as keys and user response as values.",
@@ -12912,6 +12920,13 @@
             "description": "Location for this booking. Displayed in email and calendar event.",
             "example": "https://example.com/meeting"
           },
+          "metadata": {
+            "type": "object",
+            "description": "You can store any additional data you want here. Metadata must have at most 50 keys, each key up to 40 characters, and string values up to 500 characters.",
+            "example": {
+              "key": "value"
+            }
+          },
           "bookingFieldsResponses": {
             "type": "object",
             "description": "Booking field responses consisting of an object with booking field slug as keys and user response as values.",
@@ -12981,6 +12996,13 @@
             "description": "Location for this booking. Displayed in email and calendar event.",
             "example": "https://example.com/meeting"
           },
+          "metadata": {
+            "type": "object",
+            "description": "You can store any additional data you want here. Metadata must have at most 50 keys, each key up to 40 characters, and string values up to 500 characters.",
+            "example": {
+              "key": "value"
+            }
+          },
           "bookingFieldsResponses": {
             "type": "object",
             "description": "Booking field responses consisting of an object with booking field slug as keys and user response as values.",
@@ -13001,6 +13023,33 @@
           "attendee"
         ]
       },
+      "BookingHost": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "number",
+            "example": 1
+          },
+          "name": {
+            "type": "string",
+            "example": "Jane Doe"
+          },
+          "username": {
+            "type": "string",
+            "example": "jane100"
+          },
+          "timeZone": {
+            "type": "string",
+            "example": "America/Los_Angeles"
+          }
+        },
+        "required": [
+          "id",
+          "name",
+          "username",
+          "timeZone"
+        ]
+      },
       "EventType": {
         "type": "object",
         "properties": {
@@ -13040,7 +13089,7 @@
           "hosts": {
             "type": "array",
             "items": {
-              "$ref": "#/components/schemas/Host"
+              "$ref": "#/components/schemas/BookingHost"
             }
           },
           "status": {
@@ -13100,6 +13149,16 @@
             "type": "boolean",
             "example": true
           },
+          "createdAt": {
+            "type": "string",
+            "example": "2024-08-13T15:30:00Z"
+          },
+          "metadata": {
+            "type": "object",
+            "example": {
+              "key": "value"
+            }
+          },
           "attendees": {
             "type": "array",
             "items": {
@@ -13137,6 +13196,7 @@
           "eventTypeId",
           "eventType",
           "absentHost",
+          "createdAt",
           "attendees"
         ]
       },
@@ -13162,7 +13222,7 @@
           "hosts": {
             "type": "array",
             "items": {
-              "$ref": "#/components/schemas/Host"
+              "$ref": "#/components/schemas/BookingHost"
             }
           },
           "status": {
@@ -13222,6 +13282,16 @@
             "type": "boolean",
             "example": true
           },
+          "createdAt": {
+            "type": "string",
+            "example": "2024-08-13T15:30:00Z"
+          },
+          "metadata": {
+            "type": "object",
+            "example": {
+              "key": "value"
+            }
+          },
           "attendees": {
             "type": "array",
             "items": {
@@ -13263,6 +13333,7 @@
           "eventTypeId",
           "eventType",
           "absentHost",
+          "createdAt",
           "attendees",
           "recurringBookingUid"
         ]

apps/api/v2/test/fixtures/repository/bookings.repository.fixture.ts

@@ -22,6 +22,14 @@ export class BookingsRepositoryFixture {
     return this.prismaReadClient.booking.findUnique({ where: { uid: bookingUid } });
   }
 
+  async getByRecurringBookingUid(recurringBookingUid: string) {
+    return this.prismaReadClient.booking.findMany({
+      where: {
+        recurringEventId: recurringBookingUid,
+      },
+    });
+  }
+
   async create(booking: Prisma.BookingCreateInput) {
     return this.prismaWriteClient.booking.create({ data: booking });
   }

apps/api/v2/test/utils/randomNumber.ts

@@ -0,0 +1,3 @@
+export function randomNumber(): number {
+  return Math.floor(Math.random() * 100000);
+}

apps/web/abTest/middlewareFactory.ts

@@ -8,7 +8,6 @@ import { FUTURE_ROUTES_ENABLED_COOKIE_NAME, FUTURE_ROUTES_OVERRIDE_COOKIE_NAME }
 const ROUTES: [URLPattern, boolean][] = [
   ["/event-types", process.env.APP_ROUTER_EVENT_TYPES_ENABLED === "1"] as const,
   ["/settings/developer/:path*", process.env.APP_ROUTER_SETTINGS_DEVELOPER_ENABLED === "1"] as const,
-  ["/settings/organizations/:path*", process.env.APP_ROUTER_SETTINGS_ORG_ENABLED === "1"] as const,
   ["/apps/installed/:category", process.env.APP_ROUTER_APPS_INSTALLED_CATEGORY_ENABLED === "1"] as const,
   ["/apps/:slug", process.env.APP_ROUTER_APPS_SLUG_ENABLED === "1"] as const,
   ["/apps/:slug/setup", process.env.APP_ROUTER_APPS_SLUG_SETUP_ENABLED === "1"] as const,

apps/web/app/future/settings/(settings)/organizations/attributes/[id]/edit/page.tsx

@@ -1,11 +0,0 @@
-import { _generateMetadata } from "app/_utils";
-
-import Page from "@calcom/ee/organizations/pages/settings/attributes/attributes-edit-view";
-
-export const generateMetadata = async () =>
-  await _generateMetadata(
-    () => "Attribute",
-    (t) => t("edit_attribute_description")
-  );
-
-export default Page;

apps/web/app/future/settings/(settings)/organizations/attributes/create/page.tsx

@@ -1,11 +0,0 @@
-import { _generateMetadata } from "app/_utils";
-
-import Page from "@calcom/ee/organizations/pages/settings/attributes/attributes-create-view";
-
-export const generateMetadata = async () =>
-  await _generateMetadata(
-    () => "Attribute",
-    () => "Create an attribute for your team members"
-  );
-
-export default Page;

apps/web/app/future/settings/(settings)/organizations/attributes/page.tsx

@@ -1,11 +0,0 @@
-import { _generateMetadata } from "app/_utils";
-
-import Page from "@calcom/ee/organizations/pages/settings/attributes/attributes-list-view";
-
-export const generateMetadata = async () =>
-  await _generateMetadata(
-    (t) => t("attributes"),
-    (t) => t("attribute_meta_description")
-  );
-
-export default Page;

apps/web/app/future/settings/(settings)/organizations/billing/page.tsx

@@ -1,5 +0,0 @@
-import BillingPage, { generateMetadata } from "../../billing/page";
-
-export { generateMetadata };
-
-export default BillingPage;

apps/web/app/settings/(settings-layout)/my-account/conferencing/page.tsx

@@ -1,11 +1,8 @@
 import { _generateMetadata } from "app/_utils";
 import { getFixedT } from "app/_utils";
 
+import { ConferencingAppsViewWebWrapper } from "@calcom/atoms/monorepo";
 import { getServerSessionForAppDir } from "@calcom/feature-auth/lib/get-server-session-for-app-dir";
-import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
-import { Button } from "@calcom/ui";
-
-import ConferencingView from "~/settings/my-account/conferencing-view";
 
 export const generateMetadata = async () =>
   await _generateMetadata(
@@ -17,22 +14,12 @@ const Page = async () => {
   const session = await getServerSessionForAppDir();
   const t = await getFixedT(session?.user.locale || "en");
 
-  const AddConferencingButton = () => {
-    return (
-      <Button color="secondary" StartIcon="plus" href="/apps/categories/conferencing">
-        {t("add")}
-      </Button>
-    );
-  };
-
   return (
-    <SettingsHeader
+    <ConferencingAppsViewWebWrapper
       title={t("conferencing")}
       description={t("conferencing_description")}
-      CTA={<AddConferencingButton />}
-      borderInShellHeader={true}>
-      <ConferencingView />
-    </SettingsHeader>
+      add={t("add")}
+    />
   );
 };
 

apps/web/app/settings/(settings-layout)/organizations/attributes/[id]/edit/page.tsx

@@ -0,0 +1,24 @@
+import { _generateMetadata, getFixedT } from "app/_utils";
+
+import OrgAttributesEditPage from "@calcom/ee/organizations/pages/settings/attributes/attributes-edit-view";
+import { getServerSessionForAppDir } from "@calcom/features/auth/lib/get-server-session-for-app-dir";
+import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
+
+export const generateMetadata = async () =>
+  await _generateMetadata(
+    (t) => t("attribute"),
+    (t) => t("edit_attribute_description")
+  );
+
+const Page = async () => {
+  const session = await getServerSessionForAppDir();
+  const t = await getFixedT(session?.user.locale || "en");
+
+  return (
+    <SettingsHeader title={t("attribute")} description={t("edit_attribute_description")}>
+      <OrgAttributesEditPage />
+    </SettingsHeader>
+  );
+};
+
+export default Page;

apps/web/app/settings/(settings-layout)/organizations/attributes/create/page.tsx

@@ -0,0 +1,24 @@
+import { _generateMetadata, getFixedT } from "app/_utils";
+
+import OrgAttributesCreatePage from "@calcom/ee/organizations/pages/settings/attributes/attributes-create-view";
+import { getServerSessionForAppDir } from "@calcom/features/auth/lib/get-server-session-for-app-dir";
+import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
+
+export const generateMetadata = async () =>
+  await _generateMetadata(
+    (t) => t("attribute"),
+    (t) => t("create_attribute_description")
+  );
+
+const Page = async () => {
+  const session = await getServerSessionForAppDir();
+  const t = await getFixedT(session?.user.locale || "en");
+
+  return (
+    <SettingsHeader title={t("attribute")} description={t("create_attribute_description")}>
+      <OrgAttributesCreatePage />
+    </SettingsHeader>
+  );
+};
+
+export default Page;

apps/web/app/settings/(settings-layout)/organizations/attributes/page.tsx

@@ -0,0 +1,24 @@
+import { _generateMetadata, getFixedT } from "app/_utils";
+
+import OrgSettingsAttributesPage from "@calcom/ee/organizations/pages/settings/attributes/attributes-list-view";
+import { getServerSessionForAppDir } from "@calcom/features/auth/lib/get-server-session-for-app-dir";
+import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
+
+export const generateMetadata = async () =>
+  await _generateMetadata(
+    (t) => t("attributes"),
+    (t) => t("attribute_meta_description")
+  );
+
+const Page = async () => {
+  const session = await getServerSessionForAppDir();
+  const t = await getFixedT(session?.user.locale || "en");
+
+  return (
+    <SettingsHeader title={t("attributes")} description={t("attribute_meta_description")}>
+      <OrgSettingsAttributesPage />
+    </SettingsHeader>
+  );
+};
+
+export default Page;

apps/web/app/settings/(settings-layout)/organizations/billing/page.tsx

@@ -0,0 +1,5 @@
+import BillingPage, { generateMetadata } from "app/future/settings/(settings)/billing/page";
+
+export { generateMetadata };
+
+export default BillingPage;

apps/web/app/settings/(settings-layout)/organizations/general/page.tsx

@@ -16,7 +16,7 @@ const Page = async () => {
 
   return (
     <SettingsHeader title={t("general")} description={t("general_description")} borderInShellHeader={true}>
-      <LegacyPage isAppDir={true} />
+      <LegacyPage />
     </SettingsHeader>
   );
 };

apps/web/app/settings/(settings-layout)/organizations/profile/page.tsx

@@ -19,7 +19,7 @@ const Page = async () => {
       title={t("profile")}
       description={t("profile_org_description")}
       borderInShellHeader={true}>
-      <LegacyPage isAppDir={true} />
+      <LegacyPage />
     </SettingsHeader>
   );
 };

apps/web/app/settings/(settings-layout)/organizations/sso/page.tsx

@@ -15,8 +15,8 @@ const Page = async () => {
   const t = await getFixedT(session?.user.locale || "en");
 
   return (
-    <SettingsHeader title={t("profile")} description={t("profile_org_description")}>
-      <OrgSSOView isAppDir={true} />
+    <SettingsHeader title={t("sso_configuration")} description={t("sso_configuration_description_orgs")}>
+      <OrgSSOView />
     </SettingsHeader>
   );
 };

apps/web/app/settings/(settings-layout)/organizations/teams/other/[id]/members/page.tsx

@@ -1,7 +1,9 @@
 import { _generateMetadata, getFixedT } from "app/_utils";
 
 import { getServerSessionForAppDir } from "@calcom/features/auth/lib/get-server-session-for-app-dir";
-import LegacyPage from "@calcom/features/ee/organizations/pages/settings/other-team-members-view";
+import LegacyPage, {
+  TeamMembersCTA,
+} from "@calcom/features/ee/organizations/pages/settings/other-team-members-view";
 import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
 
 export const generateMetadata = async () =>
@@ -15,9 +17,11 @@ const Page = async () => {
   const t = await getFixedT(session?.user.locale || "en");
 
   return (
-    // TODO: Add CTA Button
-    <SettingsHeader title={t("team_members")} description={t("members_team_description")}>
-      <LegacyPage isAppDir={true} />
+    <SettingsHeader
+      title={t("team_members")}
+      description={t("members_team_description")}
+      CTA={<TeamMembersCTA />}>
+      <LegacyPage />
     </SettingsHeader>
   );
 };

apps/web/app/settings/(settings-layout)/organizations/teams/other/[id]/profile/page.tsx

@@ -16,7 +16,7 @@ const Page = async () => {
 
   return (
     <SettingsHeader title={t("profile")} description={t("profile_team_description")}>
-      <LegacyPage isAppDir={true} />
+      <LegacyPage />
     </SettingsHeader>
   );
 };

apps/web/app/settings/(settings-layout)/organizations/teams/other/page.tsx

@@ -16,7 +16,7 @@ const Page = async () => {
 
   return (
     <SettingsHeader title={t("org_admin_other_teams")} description={t("org_admin_other_teams_description")}>
-      <LegacyPage isAppDir={true} />
+      <LegacyPage />
     </SettingsHeader>
   );
 };

apps/web/app/settings/organizations/[id]/members/page.tsx

@@ -0,0 +1,14 @@
+import { _generateMetadata } from "app/_utils";
+import { WithLayout } from "app/layoutHOC";
+
+import MembersPage from "~/members/members-view";
+
+export const generateMetadata = async () =>
+  await _generateMetadata(
+    (t) => t("organization_members"),
+    (t) => t("organization_description")
+  );
+
+export default WithLayout({
+  Page: MembersPage,
+});

apps/web/app/settings/organizations/members/page.tsx

@@ -1,8 +1,10 @@
 import { _generateMetadata, getFixedT } from "app/_utils";
+import { WithLayout } from "app/layoutHOC";
 
 import { getServerSessionForAppDir } from "@calcom/features/auth/lib/get-server-session-for-app-dir";
-import LegacyPage from "@calcom/features/ee/organizations/pages/settings/members";
+import LegacyPage from "@calcom/features/ee/organizations/pages/members";
 import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
+import SettingsLayoutAppDir from "@calcom/features/settings/appDir/SettingsLayoutAppDir";
 
 export const generateMetadata = async () =>
   await _generateMetadata(
@@ -16,9 +18,12 @@ const Page = async () => {
 
   return (
     <SettingsHeader title={t("organization_members")} description={t("organization_description")}>
-      <LegacyPage isAppDir={true} />
+      <LegacyPage />
     </SettingsHeader>
   );
 };
 
-export default Page;
+const getLayout = async (page: React.ReactElement) =>
+  await SettingsLayoutAppDir({ children: page, containerClassName: "lg:max-w-screen-2xl" });
+
+export default WithLayout({ ServerPage: Page, getServerLayout: getLayout })<"P">;

apps/web/app/settings/platform/members/page.tsx

@@ -0,0 +1,14 @@
+import { _generateMetadata } from "app/_utils";
+import { WithLayout } from "app/layoutHOC";
+
+import PlatformMembersView from "@calcom/features/ee/platform/pages/settings/members";
+
+export const generateMetadata = async () =>
+  await _generateMetadata(
+    (t) => t("platform_members"),
+    (t) => t("platform_members_description")
+  );
+
+export default WithLayout({
+  Page: PlatformMembersView,
+});

apps/web/components/apps/CalendarListContainer.tsx

@@ -7,6 +7,7 @@ import {
   SelectedCalendarsSettingsWebWrapper,
   DestinationCalendarSettingsWebWrapper,
 } from "@calcom/atoms/monorepo";
+import AppListCard from "@calcom/features/apps/components/AppListCard";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
 import { trpc } from "@calcom/trpc/react";
 import {
@@ -21,7 +22,6 @@ import {
 import { QueryCell } from "@lib/QueryCell";
 import useRouterQuery from "@lib/hooks/useRouterQuery";
 
-import AppListCard from "@components/AppListCard";
 import SubHeadingTitleWithConnections from "@components/integrations/SubHeadingTitleWithConnections";
 
 type Props = {

apps/web/components/dialog/RerouteDialog.tsx

@@ -775,7 +775,7 @@ const RerouteDialogContentAndFooterWithFormResponse = ({
   >([]);
 
   const findTeamMembersMatchingAttributeLogicMutation =
-    trpc.viewer.routingForms.findTeamMembersMatchingAttributeLogic.useMutation({
+    trpc.viewer.routingForms.findTeamMembersMatchingAttributeLogicOfRoute.useMutation({
       onSuccess(data) {
         setTeamMembersMatchingAttributeLogic(data.result ? data.result.users : data.result);
       },

apps/web/components/dialog/__tests__/RerouteDialog.test.tsx

@@ -183,7 +183,7 @@ vi.mock("@calcom/trpc/react", () => ({
         },
       },
       routingForms: {
-        findTeamMembersMatchingAttributeLogic: {
+        findTeamMembersMatchingAttributeLogicOfRoute: {
           useMutation: vi.fn(({ onSuccess }) => {
             return {
               mutate: vi.fn(() => {

apps/web/cron-tester.ts

@@ -1,9 +1,12 @@
 import { CronJob } from "cron";
+import dotEnv from "dotenv";
+
+dotEnv.config({ path: "../../.env" });
 
 async function fetchCron(endpoint: string) {
   const apiKey = process.env.CRON_API_KEY;
 
-  const res = await fetch(`http://localhost:3000/api${endpoint}?${apiKey}`, {
+  const res = await fetch(`http://localhost:3000/api${endpoint}?apiKey=${apiKey}`, {
     headers: {
       "Content-Type": "application/json",
       authorization: `Bearer ${process.env.CRON_SECRET}`,
@@ -20,7 +23,7 @@ try {
     "*/5 * * * * *",
     async function () {
       await Promise.allSettled([
-        fetchCron("/tasks/cron"),
+        fetchCron("/calendar-cache/cron"),
         // fetchCron("/cron/calVideoNoShowWebhookTriggers"),
         //
         // fetchCron("/tasks/cleanup"),

apps/web/lib/__tests__/getTeamMemberEmailFromCrm.test.ts

@@ -0,0 +1,413 @@
+import prismock from "../../../../tests/libs/__mocks__/prisma";
+
+import { v4 } from "uuid";
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+import { getCRMContactOwnerForRRLeadSkip } from "@calcom/app-store/_utils/CRMRoundRobinSkip";
+import bookingFormHandlers from "@calcom/app-store/routing-forms/appBookingFormHandler";
+import { ROUTING_FORM_RESPONSE_ID_QUERY_STRING } from "@calcom/app-store/routing-forms/lib/constants";
+import { RouteActionType } from "@calcom/app-store/routing-forms/zod";
+import { SchedulingType } from "@calcom/prisma/enums";
+
+import { getTeamMemberEmailForResponseOrContactUsingUrlQuery } from "../getTeamMemberEmailFromCrm";
+
+vi.mock("@calcom/app-store/routing-forms/appBookingFormHandler", () => ({
+  default: {
+    salesforce: vi.fn(),
+  },
+}));
+
+vi.mock("@calcom/app-store/_utils/CRMRoundRobinSkip", () => ({
+  getCRMContactOwnerForRRLeadSkip: vi.fn(),
+}));
+
+function mockGetCRMContactOwnerForRRLeadSkip({
+  bookerEmail,
+  teamMemberEmail,
+}: {
+  bookerEmail: string;
+  teamMemberEmail: string;
+}) {
+  vi.mocked(getCRMContactOwnerForRRLeadSkip).mockImplementation((_bookerEmail, _eventMetadata) => {
+    if (_bookerEmail === bookerEmail) {
+      return Promise.resolve({ email: teamMemberEmail, recordType: null, crmAppSlug: null });
+    }
+    return Promise.resolve({ email: null, recordType: null, crmAppSlug: null });
+  });
+}
+
+function mockBookingFormHandler({
+  bookerEmail,
+  teamMemberEmail,
+}: {
+  bookerEmail: string;
+  teamMemberEmail: string;
+}) {
+  vi.mocked(bookingFormHandlers.salesforce).mockImplementation(
+    (_bookerEmail, _attributeRoutingConfig, _eventTypeId) => {
+      if (_bookerEmail === bookerEmail) {
+        return Promise.resolve({ email: teamMemberEmail, recordType: null });
+      }
+      return Promise.resolve({ email: null, recordType: null });
+    }
+  );
+}
+
+async function createRoutingFormWithResponse({
+  formData,
+}: {
+  formData: {
+    routes: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      queryValue?: any;
+      action: {
+        eventTypeId: number;
+        type: RouteActionType;
+        value: string;
+      };
+      attributeRoutingConfig: {
+        skipContactOwner: boolean;
+      };
+    }[];
+  };
+}) {
+  const user = await prismock.user.create({
+    data: {
+      name: "Routing Form User",
+      username: "routing-form-user",
+      email: "routing-form-user@example.com",
+    },
+  });
+
+  const routeId = v4();
+
+  const form = await prismock.app_RoutingForms_Form.create({
+    data: {
+      ...formData,
+      name: "Test Form",
+      routes: formData.routes.map((route) => ({
+        queryValue: {
+          id: v4(),
+          type: "group",
+        },
+        id: routeId,
+        ...route,
+      })),
+      user: {
+        connect: {
+          id: user.id,
+        },
+      },
+    },
+  });
+
+  const responseRecord = await prismock.app_RoutingForms_FormResponse.create({
+    data: {
+      chosenRouteId: routeId,
+      response: {},
+      form: {
+        connect: {
+          id: form.id,
+        },
+      },
+    },
+  });
+
+  return { form, responseRecord };
+}
+
+async function createHostForEvent({
+  eventTypeData,
+  userData,
+}: {
+  eventTypeData: { id: number } & Partial<{
+    title: string;
+    slug: string;
+    length: number;
+  }>;
+  userData: {
+    email: string;
+  } & Partial<{
+    name: string;
+    username: string;
+  }>;
+}) {
+  const user = await prismock.user.create({
+    data: {
+      name: "Test User",
+      username: "testuser",
+      ...userData,
+    },
+  });
+  await prismock.eventType.create({
+    data: {
+      title: "Title",
+      slug: "slug",
+      length: 30,
+      ...eventTypeData,
+      hosts: {
+        create: {
+          userId: user.id,
+          isFixed: true,
+        },
+      },
+    },
+  });
+}
+
+describe("getTeamMemberEmailForResponseOrContactUsingUrlQuery", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  const mockEventData = {
+    id: 1,
+    isInstantEvent: false,
+    schedulingType: SchedulingType.ROUND_ROBIN,
+    metadata: null,
+    length: 30,
+  };
+
+  it("should return null when email is not provided in query", async () => {
+    const result = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+      query: {},
+      eventData: mockEventData,
+    });
+
+    const ownerEmail = result.email;
+
+    expect(ownerEmail).toBeNull();
+  });
+
+  it("should return null when scheduling type is not ROUND_ROBIN", async () => {
+    const bookerEmail = "booker@example.com";
+    const teamMemberEmail = "teamMember@example.com";
+    mockGetCRMContactOwnerForRRLeadSkip({ bookerEmail, teamMemberEmail });
+    await createHostForEvent({
+      eventTypeData: {
+        id: mockEventData.id,
+      },
+      userData: {
+        email: teamMemberEmail,
+      },
+    });
+
+    const result = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+      query: { email: bookerEmail },
+      eventData: { ...mockEventData, schedulingType: SchedulingType.COLLECTIVE },
+    });
+
+    expect(result.email).toBeNull();
+  });
+
+  it("should return CRM owner email when valid", async () => {
+    const ownerEmail = "owner@example.com";
+    const bookerEmail = "booker@example.com";
+    mockGetCRMContactOwnerForRRLeadSkip({ bookerEmail, teamMemberEmail: ownerEmail });
+    await createHostForEvent({
+      eventTypeData: {
+        id: mockEventData.id,
+      },
+      userData: {
+        email: ownerEmail,
+      },
+    });
+
+    const result = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+      query: { email: "booker@example.com" },
+      eventData: mockEventData,
+    });
+
+    expect(result.email).toBe(ownerEmail);
+  });
+
+  it("should return null when CRM owner is not found", async () => {
+    const bookerEmail = "booker@example.com";
+    const teamMemberEmail = "teamMember@example.com";
+    mockGetCRMContactOwnerForRRLeadSkip({ bookerEmail, teamMemberEmail });
+
+    const result = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+      query: { email: bookerEmail },
+      eventData: mockEventData,
+    });
+
+    expect(result.email).toBeNull();
+  });
+
+  it("should return null when CRM owner is not part of event type", async () => {
+    const ownerEmail = "owner@example.com";
+    const bookerEmail = "booker@example.com";
+    mockGetCRMContactOwnerForRRLeadSkip({ bookerEmail, teamMemberEmail: ownerEmail });
+
+    const result = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+      query: { email: bookerEmail },
+      eventData: mockEventData,
+    });
+
+    expect(result.email).toBeNull();
+  });
+
+  describe("Booking form handler", () => {
+    it("should return teamMember email through booking form handler when cal.routingFormResponseId and cal.salesforce.xxxx=true is provided", async () => {
+      const bookerEmail = "booker@example.com";
+      const teamMemberEmail = "owner@example.com";
+      mockBookingFormHandler({ bookerEmail, teamMemberEmail });
+      await createHostForEvent({
+        eventTypeData: {
+          id: mockEventData.id,
+        },
+        userData: {
+          email: teamMemberEmail,
+        },
+      });
+
+      const { responseRecord } = await createRoutingFormWithResponse({
+        formData: {
+          routes: [
+            {
+              action: {
+                eventTypeId: 1,
+                type: RouteActionType.EventTypeRedirectUrl,
+                value: "/team/sales",
+              },
+              attributeRoutingConfig: { skipContactOwner: false },
+            },
+          ],
+        },
+      });
+
+      const result = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+        query: {
+          email: bookerEmail,
+          [ROUTING_FORM_RESPONSE_ID_QUERY_STRING]: responseRecord.id.toString(),
+          "cal.salesforce.xxx": "true",
+        },
+        eventData: mockEventData,
+      });
+
+      expect(result.email).toBe(teamMemberEmail);
+    });
+
+    it("should return null when skipContactOwner is true even when cal.routingFormResponseId and cal.salesforce.xxxx=true is provided", async () => {
+      const bookerEmail = "booker@example.com";
+      const teamMemberEmail = "owner@example.com";
+      mockBookingFormHandler({ bookerEmail, teamMemberEmail });
+      await createHostForEvent({
+        eventTypeData: {
+          id: mockEventData.id,
+        },
+        userData: {
+          email: teamMemberEmail,
+        },
+      });
+
+      const { responseRecord } = await createRoutingFormWithResponse({
+        formData: {
+          routes: [
+            {
+              action: {
+                eventTypeId: 1,
+                type: RouteActionType.EventTypeRedirectUrl,
+                value: "/team/sales",
+              },
+              attributeRoutingConfig: { skipContactOwner: true },
+            },
+          ],
+        },
+      });
+
+      const result = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+        query: {
+          email: bookerEmail,
+          [ROUTING_FORM_RESPONSE_ID_QUERY_STRING]: responseRecord.id.toString(),
+          "cal.salesforce.xxx": "true",
+        },
+        eventData: mockEventData,
+      });
+
+      // Because skipContactOwner is true, the booking form handler should return null
+      expect(result.email).toBe(null);
+    });
+
+    it("should return null when when cal.routingFormResponseId and cal.salesforce.xxxx=true is provided but the returned email isn't an event member", async () => {
+      const bookerEmail = "booker@example.com";
+      const teamMemberEmail = "owner@example.com";
+      mockBookingFormHandler({ bookerEmail, teamMemberEmail });
+      const SOME_OTHER_EVENT_ID = 200;
+      await createHostForEvent({
+        eventTypeData: {
+          id: SOME_OTHER_EVENT_ID,
+        },
+        userData: {
+          email: teamMemberEmail,
+        },
+      });
+
+      const { responseRecord } = await createRoutingFormWithResponse({
+        formData: {
+          routes: [
+            {
+              action: {
+                eventTypeId: 1,
+                type: RouteActionType.EventTypeRedirectUrl,
+                value: "/team/sales",
+              },
+              attributeRoutingConfig: { skipContactOwner: false },
+            },
+          ],
+        },
+      });
+
+      const result = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+        query: {
+          email: bookerEmail,
+          [ROUTING_FORM_RESPONSE_ID_QUERY_STRING]: responseRecord.id.toString(),
+          "cal.salesforce.xxx": "true",
+        },
+        eventData: mockEventData,
+      });
+
+      expect(result.email).toBe(null);
+    });
+
+    it("should return null when cal.routingFormResponseId is provided but cal.salesforce.xxxx is not", async () => {
+      const bookerEmail = "booker@example.com";
+      const teamMemberEmail = "owner@example.com";
+      mockBookingFormHandler({ bookerEmail, teamMemberEmail });
+      await createHostForEvent({
+        eventTypeData: {
+          id: mockEventData.id,
+        },
+        userData: {
+          email: teamMemberEmail,
+        },
+      });
+
+      const { responseRecord } = await createRoutingFormWithResponse({
+        formData: {
+          routes: [
+            {
+              action: {
+                eventTypeId: 1,
+                type: RouteActionType.EventTypeRedirectUrl,
+                value: "/team/sales",
+              },
+              attributeRoutingConfig: { skipContactOwner: false },
+            },
+          ],
+        },
+      });
+
+      const result = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+        query: {
+          email: bookerEmail,
+          [ROUTING_FORM_RESPONSE_ID_QUERY_STRING]: responseRecord.id.toString(),
+          "cal.somethingelse.xxx": "true",
+        },
+        eventData: mockEventData,
+      });
+
+      expect(result.email).toBe(null);
+    });
+  });
+});

apps/web/lib/getTeamMemberEmailFromCrm.ts

@@ -21,6 +21,23 @@ interface EventData {
   length: number;
 }
 
+const returnNullValue = { email: null, recordType: null, crmAppSlug: null };
+
+async function findUserByEmailWhoIsAHostOfEventType({
+  email,
+  eventTypeId,
+}: {
+  email: string;
+  eventTypeId: number;
+}) {
+  return prisma.user.findFirst({
+    where: {
+      email,
+      hosts: { some: { eventTypeId } },
+    },
+  });
+}
+
 function getRoutingFormResponseIdFromQuery(query: ParsedUrlQuery) {
   const routingFormResponseIdAsNumber = Number(query[ROUTING_FORM_RESPONSE_ID_QUERY_STRING]);
   const routingFormResponseId = isNaN(routingFormResponseIdAsNumber) ? null : routingFormResponseIdAsNumber;
@@ -41,28 +58,29 @@ async function getAttributeRoutingConfig(
     return data.route.attributeRoutingConfig ?? null;
   }
   const { routingFormResponseId, eventTypeId } = data;
-  const routingFormQuery = await prisma.app_RoutingForms_Form.findFirst({
+
+  const routingFormResponseQuery = await prisma.app_RoutingForms_FormResponse.findFirst({
     where: {
-      responses: {
-        some: {
-          id: routingFormResponseId,
+      id: routingFormResponseId,
+    },
+    include: {
+      form: {
+        select: {
+          routes: true,
         },
       },
     },
-    select: {
-      routes: true,
-    },
   });
-  if (!routingFormQuery || !routingFormQuery?.routes) return null;
-  const parsedRoutes = routesSchema.safeParse(routingFormQuery.routes);
+
+  if (!routingFormResponseQuery || !routingFormResponseQuery?.form.routes) return null;
+  const parsedRoutes = routesSchema.safeParse(routingFormResponseQuery?.form.routes);
 
   if (!parsedRoutes.success || !parsedRoutes.data) return null;
 
   // Find the route with the attributeRoutingConfig
-  // FIXME: There could be multiple routes with same action.eventTypeId, we should actually ensure we have the chosenRouteId in here and use that route.
   const route = parsedRoutes.data.find((route) => {
     if ("action" in route) {
-      return route.action.eventTypeId === eventTypeId;
+      return route.id === routingFormResponseQuery.chosenRouteId;
     }
   });
 
@@ -96,22 +114,20 @@ function getEnabledRoutingFormAppSlugFromQuery(query: ParsedUrlQuery) {
 /**
  * Uses the owner of the contact directly from CRM
  */
-async function getOwnerEmailFromCrm(eventData: EventData, email: string): Promise<string | null> {
-  const crmContactOwnerEmail = await getCRMContactOwnerForRRLeadSkip(email, eventData.metadata);
-  if (!crmContactOwnerEmail) return null;
+async function getOwnerEmailFromCrm(
+  eventData: EventData,
+  email: string
+): Promise<{ email: string | null; recordType: string | null; crmAppSlug: string | null }> {
+  const crmContactOwner = await getCRMContactOwnerForRRLeadSkip(email, eventData.metadata);
+  if (!crmContactOwner?.email) return returnNullValue;
+
   // Determine if the contactOwner is a part of the event type
-  const contactOwnerQuery = await prisma.user.findFirst({
-    where: {
-      email: crmContactOwnerEmail,
-      hosts: {
-        some: {
-          eventTypeId: eventData.id,
-        },
-      },
-    },
+  const contactOwnerQuery = await findUserByEmailWhoIsAHostOfEventType({
+    email: crmContactOwner.email,
+    eventTypeId: eventData.id,
   });
-  if (!contactOwnerQuery) return null;
-  return crmContactOwnerEmail;
+  if (!contactOwnerQuery) return returnNullValue;
+  return crmContactOwner;
 }
 
 /**
@@ -128,7 +144,7 @@ async function getTeamMemberEmailUsingRoutingFormHandler({
   attributeRoutingConfig: AttributeRoutingConfig | null;
   crmAppSlug: string;
 }) {
-  const nullReturnValue = { email: null, skipContactOwner: false };
+  const nullReturnValue = { email: null, skipContactOwner: false, recordType: "" };
 
   if (!attributeRoutingConfig) return nullReturnValue;
 
@@ -138,49 +154,38 @@ async function getTeamMemberEmailUsingRoutingFormHandler({
   const appBookingFormHandler = (await import("@calcom/app-store/routing-forms/appBookingFormHandler"))
     .default;
   const appHandler = appBookingFormHandler[crmAppSlug];
-
   if (!appHandler) return nullReturnValue;
 
-  const { email: userEmail } = await appHandler(bookerEmail, attributeRoutingConfig, eventTypeId);
+  const { email: userEmail, recordType } = await appHandler(bookerEmail, attributeRoutingConfig, eventTypeId);
 
   if (!userEmail) return nullReturnValue;
 
   // Determine if the user is a part of the event type
-  const userQuery = await prisma.user.findFirst({
-    where: {
-      email: userEmail,
-      hosts: {
-        some: {
-          eventTypeId: eventTypeId,
-        },
-      },
-    },
-  });
+  const userQuery = await findUserByEmailWhoIsAHostOfEventType({ email: userEmail, eventTypeId });
 
   if (!userQuery) return nullReturnValue;
 
-  return { ...nullReturnValue, email: userEmail };
+  return { ...nullReturnValue, email: userEmail, recordType };
 }
 
 async function getTeamMemberEmailForResponseOrContact({
   bookerEmail,
-  eventTypeId,
   eventData,
   routingFormResponseId,
   chosenRoute,
   crmAppSlug,
 }: {
   bookerEmail: string;
-  eventTypeId: number;
   eventData: EventData;
   routingFormResponseId?: number | null;
   /**
    * If provided, we won't go look for the route from DB.
    */
   chosenRoute?: LocalRoute;
-  crmAppSlug: string;
+  crmAppSlug?: string;
 }) {
-  if (eventData.schedulingType !== SchedulingType.ROUND_ROBIN) return null;
+  const eventTypeId = eventData.id;
+  if (eventData.schedulingType !== SchedulingType.ROUND_ROBIN) return returnNullValue;
 
   const attributeRoutingConfigGetterData = routingFormResponseId
     ? { routingFormResponseId, eventTypeId }
@@ -195,49 +200,45 @@ async function getTeamMemberEmailForResponseOrContact({
       safeStringify({ attributeRoutingConfigGetterData, crmAppSlug })
     );
     const attributeRoutingConfig = await getAttributeRoutingConfig(attributeRoutingConfigGetterData);
-    const { email, skipContactOwner } = await getTeamMemberEmailUsingRoutingFormHandler({
+    const { email, skipContactOwner, recordType } = await getTeamMemberEmailUsingRoutingFormHandler({
       bookerEmail,
       eventTypeId,
       attributeRoutingConfig,
       crmAppSlug,
     });
 
-    if (skipContactOwner) return null;
-    if (email) return email;
+    if (skipContactOwner) return returnNullValue;
+    if (email) return { email, recordType, crmAppSlug };
   } else {
     log.debug("Getting the contact owner email from CRM");
     return await getOwnerEmailFromCrm(eventData, bookerEmail);
   }
 
-  return null;
+  return returnNullValue;
 }
 
 export async function getTeamMemberEmailForResponseOrContactUsingUrlQuery({
   query,
-  eventTypeId,
   eventData,
   chosenRoute,
 }: {
   query: ParsedUrlQuery;
-  eventTypeId: number;
   eventData: EventData;
   chosenRoute?: LocalRoute;
 }) {
   // Without email no lookup is possible
   if (!query.email || typeof query.email !== "string") {
-    return null;
+    return returnNullValue;
   }
 
   log.debug("getTeamMemberEmailForResponseOrContactUsingUrlQuery", safeStringify({ query }));
 
   const crmAppSlug = getEnabledRoutingFormAppSlugFromQuery(query);
-  if (!crmAppSlug) return null;
 
   const routingFormResponseId = getRoutingFormResponseIdFromQuery(query);
 
   return await getTeamMemberEmailForResponseOrContact({
     bookerEmail: query.email,
-    eventTypeId,
     eventData,
     routingFormResponseId,
     chosenRoute,

apps/web/lib/team/[slug]/[type]/getServerSideProps.tsx

@@ -89,6 +89,15 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
   const { getTeamMemberEmailForResponseOrContactUsingUrlQuery } = await import(
     "@calcom/web/lib/getTeamMemberEmailFromCrm"
   );
+  const {
+    email: teamMemberEmail,
+    recordType: crmOwnerRecordType,
+    crmAppSlug,
+  } = await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
+    query,
+    eventData,
+  });
+
   return {
     props: {
       eventData: {
@@ -112,11 +121,9 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
       isInstantMeeting: eventData && queryIsInstantMeeting ? true : false,
       themeBasis: null,
       orgBannerUrl: team.parent?.bannerUrl ?? "",
-      teamMemberEmail: await getTeamMemberEmailForResponseOrContactUsingUrlQuery({
-        query,
-        eventTypeId,
-        eventData,
-      }),
+      teamMemberEmail,
+      crmOwnerRecordType,
+      crmAppSlug,
     },
   };
 };

apps/web/modules/apps/installed/[category]/installed-category-view.tsx

@@ -3,19 +3,28 @@
 import { useReducer } from "react";
 
 import getAppCategoryTitle from "@calcom/app-store/_utils/getAppCategoryTitle";
+import type { UpdateDefaultConferencingAppParams } from "@calcom/features/apps/components/AppList";
+import { AppList } from "@calcom/features/apps/components/AppList";
 import DisconnectIntegrationModal from "@calcom/features/apps/components/DisconnectIntegrationModal";
+import type { RemoveAppParams } from "@calcom/features/apps/components/DisconnectIntegrationModal";
+import type { BulkUpdatParams } from "@calcom/features/eventtypes/components/BulkEditDefaultForEventsModal";
 import { useCompatSearchParams } from "@calcom/lib/hooks/useCompatSearchParams";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
 import { AppCategories } from "@calcom/prisma/enums";
 import { trpc } from "@calcom/trpc/react";
 import type { inferSSRProps } from "@calcom/types/inferSSRProps";
 import type { Icon } from "@calcom/ui";
-import { AppSkeletonLoader as SkeletonLoader, Button, EmptyScreen, ShellSubHeading } from "@calcom/ui";
+import {
+  AppSkeletonLoader as SkeletonLoader,
+  Button,
+  EmptyScreen,
+  ShellSubHeading,
+  showToast,
+} from "@calcom/ui";
 
 import { QueryCell } from "@lib/QueryCell";
 import type { querySchemaType, getServerSideProps } from "@lib/apps/installed/[category]/getServerSideProps";
 
-import { AppList } from "@components/apps/AppList";
 import { CalendarListContainer } from "@components/apps/CalendarListContainer";
 import InstalledAppsLayout from "@components/apps/layouts/InstalledAppsLayout";
 
@@ -31,6 +40,7 @@ const IntegrationsContainer = ({
   handleDisconnect,
 }: IntegrationsContainerProps): JSX.Element => {
   const { t } = useLocale();
+  const utils = trpc.useUtils();
   const query = trpc.viewer.integrations.useQuery({
     variant,
     exclude,
@@ -38,6 +48,42 @@ const IntegrationsContainer = ({
     includeTeamInstalledApps: true,
   });
 
+  const { data: defaultConferencingApp } = trpc.viewer.getUsersDefaultConferencingApp.useQuery();
+
+  const updateDefaultAppMutation = trpc.viewer.updateUserDefaultConferencingApp.useMutation();
+
+  const updateLocationsMutation = trpc.viewer.eventTypes.bulkUpdateToDefaultLocation.useMutation();
+
+  const handleUpdateDefaultConferencingApp = ({ appSlug, callback }: UpdateDefaultConferencingAppParams) => {
+    updateDefaultAppMutation.mutate(
+      { appSlug },
+      {
+        onSuccess: () => {
+          showToast("Default app updated successfully", "success");
+          utils.viewer.getUsersDefaultConferencingApp.invalidate();
+          callback();
+        },
+        onError: (error) => {
+          showToast(`Error: ${error.message}`, "error");
+        },
+      }
+    );
+  };
+
+  const handleBulkUpdateDefaultLocation = ({ eventTypeIds, callback }: BulkUpdatParams) => {
+    updateLocationsMutation.mutate(
+      {
+        eventTypeIds,
+      },
+      {
+        onSuccess: () => {
+          utils.viewer.getUsersDefaultConferencingApp.invalidate();
+          callback();
+        },
+      }
+    );
+  };
+
   // TODO: Refactor and reuse getAppCategories?
   const emptyIcon: Record<AppCategories, React.ComponentProps<typeof Icon>["name"]> = {
     calendar: "calendar",
@@ -95,7 +141,15 @@ const IntegrationsContainer = ({
               }
             />
 
-            <AppList handleDisconnect={handleDisconnect} data={data} variant={variant} />
+            <AppList
+              handleDisconnect={handleDisconnect}
+              data={data}
+              variant={variant}
+              defaultConferencingApp={defaultConferencingApp}
+              handleUpdateDefaultConferencingApp={handleUpdateDefaultConferencingApp}
+              handleBulkUpdateDefaultLocation={handleBulkUpdateDefaultLocation}
+              isBulkUpdateDefaultLocationPending={updateDefaultAppMutation.isPending}
+            />
           </div>
         );
       }}
@@ -114,6 +168,7 @@ export type PageProps = inferSSRProps<typeof getServerSideProps>;
 export default function InstalledApps(props: PageProps) {
   const searchParams = useCompatSearchParams();
   const { t } = useLocale();
+  const utils = trpc.useUtils();
   const category = searchParams?.get("category") as querySchemaType["category"];
   const categoryList: AppCategories[] = Object.values(AppCategories).filter((category) => {
     // Exclude calendar and other from categoryList, we handle those slightly differently below
@@ -136,6 +191,26 @@ export default function InstalledApps(props: PageProps) {
     updateData({ isOpen: true, credentialId, teamId });
   };
 
+  const deleteCredentialMutation = trpc.viewer.deleteCredential.useMutation();
+
+  const handleRemoveApp = ({ credentialId, teamId, callback }: RemoveAppParams) => {
+    deleteCredentialMutation.mutate(
+      { id: credentialId, teamId },
+      {
+        onSuccess: () => {
+          showToast(t("app_removed_successfully"), "success");
+          callback();
+          utils.viewer.integrations.invalidate();
+          utils.viewer.connectedCalendars.invalidate();
+        },
+        onError: () => {
+          showToast(t("error_removing_app"), "error");
+          callback();
+        },
+      }
+    );
+  };
+
   return (
     <>
       <InstalledAppsLayout heading={t("installed_apps")} subtitle={t("manage_your_connected_apps")}>
@@ -156,6 +231,7 @@ export default function InstalledApps(props: PageProps) {
         isOpen={data.isOpen}
         credentialId={data.credentialId}
         teamId={data.teamId}
+        handleRemoveApp={handleRemoveApp}
       />
     </>
   );

apps/web/modules/availability/[schedule]/schedule-view.tsx

@@ -4,6 +4,7 @@ import { useRouter } from "next/navigation";
 import { useState } from "react";
 
 import { AvailabilitySettings } from "@calcom/atoms/monorepo";
+import type { BulkUpdatParams } from "@calcom/features/eventtypes/components/BulkEditDefaultForEventsModal";
 import { withErrorFromUnknown } from "@calcom/lib/getClientErrorFromUnknown";
 import { useCompatSearchParams } from "@calcom/lib/hooks/useCompatSearchParams";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
@@ -47,13 +48,22 @@ export const AvailabilitySettingsWebWrapper = ({
 
   const [isBulkUpdateModalOpen, setIsBulkUpdateModalOpen] = useState(false);
   const bulkUpdateDefaultAvailabilityMutation =
-    trpc.viewer.availability.schedule.bulkUpdateToDefaultAvailability.useMutation({
-      onSuccess: () => {
-        utils.viewer.availability.list.invalidate();
-        setIsBulkUpdateModalOpen(false);
-        showToast(t("success"), "success");
+    trpc.viewer.availability.schedule.bulkUpdateToDefaultAvailability.useMutation();
+
+  const bulkUpdateFunction = ({ eventTypeIds, callback }: BulkUpdatParams) => {
+    bulkUpdateDefaultAvailabilityMutation.mutate(
+      {
+        eventTypeIds,
       },
-    });
+      {
+        onSuccess: () => {
+          utils.viewer.availability.list.invalidate();
+          callback();
+          showToast(t("success"), "success");
+        },
+      }
+    );
+  };
 
   const isDefaultSchedule = me.data?.defaultScheduleId === scheduleId;
 
@@ -130,7 +140,7 @@ export const AvailabilitySettingsWebWrapper = ({
       bulkUpdateModalProps={{
         isOpen: isBulkUpdateModalOpen,
         setIsOpen: setIsBulkUpdateModalOpen,
-        save: bulkUpdateDefaultAvailabilityMutation.mutate,
+        save: bulkUpdateFunction,
         isSaving: bulkUpdateDefaultAvailabilityMutation.isPending,
       }}
     />

apps/web/modules/availability/availability-view.tsx

@@ -7,6 +7,7 @@ import { useCallback, useState } from "react";
 
 import SkeletonLoader from "@calcom/features/availability/components/SkeletonLoader";
 import { BulkEditDefaultForEventsModal } from "@calcom/features/eventtypes/components/BulkEditDefaultForEventsModal";
+import type { BulkUpdatParams } from "@calcom/features/eventtypes/components/BulkEditDefaultForEventsModal";
 import { NewScheduleButton, ScheduleListItem } from "@calcom/features/schedules";
 import Shell from "@calcom/features/shell/Shell";
 import { AvailabilitySliderTable } from "@calcom/features/timezone-buddy/components/AvailabilitySliderTable";
@@ -80,13 +81,22 @@ export function AvailabilityList({ schedules }: RouterOutputs["viewer"]["availab
   });
 
   const bulkUpdateDefaultAvailabilityMutation =
-    trpc.viewer.availability.schedule.bulkUpdateToDefaultAvailability.useMutation({
-      onSuccess: () => {
-        utils.viewer.availability.list.invalidate();
-        setBulkUpdateModal(false);
-        showToast(t("success"), "success");
+    trpc.viewer.availability.schedule.bulkUpdateToDefaultAvailability.useMutation();
+
+  const bulkUpdateFunction = ({ eventTypeIds, callback }: BulkUpdatParams) => {
+    bulkUpdateDefaultAvailabilityMutation.mutate(
+      {
+        eventTypeIds,
       },
-    });
+      {
+        onSuccess: () => {
+          utils.viewer.availability.list.invalidate();
+          showToast(t("success"), "success");
+          callback();
+        },
+      }
+    );
+  };
 
   const duplicateMutation = trpc.viewer.availability.schedule.duplicate.useMutation({
     onSuccess: async ({ schedule }) => {
@@ -149,7 +159,7 @@ export function AvailabilityList({ schedules }: RouterOutputs["viewer"]["availab
               isPending={bulkUpdateDefaultAvailabilityMutation.isPending}
               open={bulkUpdateModal}
               setOpen={setBulkUpdateModal}
-              bulkUpdateFunction={bulkUpdateDefaultAvailabilityMutation.mutate}
+              bulkUpdateFunction={bulkUpdateFunction}
               description={t("default_schedules_bulk_description")}
             />
           )}

apps/web/modules/insights/insights-routing-view.tsx

@@ -1,12 +1,12 @@
 "use client";
 
 import {
+  FailedBookingsByField,
   RoutingFormResponsesTable,
   RoutingKPICards,
-  FailedBookingsByField,
 } from "@calcom/features/insights/components";
 import { FiltersProvider } from "@calcom/features/insights/context/FiltersProvider";
-import { Filters } from "@calcom/features/insights/filters";
+import { RoutingInsightsFilters } from "@calcom/features/insights/filters/routing/FilterBar";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
 
 import InsightsLayout from "./layout";
@@ -17,12 +17,18 @@ export default function InsightsPage() {
   return (
     <InsightsLayout>
       <FiltersProvider>
-        <Filters showRoutingFilters />
-
         <div className="mb-4 space-y-4">
-          <RoutingKPICards />
-
-          <RoutingFormResponsesTable />
+          <RoutingFormResponsesTable>
+            {/* We now render the "filters and KPI as a children of the table but we still need to pass the table instance to it so we can access column status in the toolbar.*/}
+            {(table) => (
+              <div className="header mb-4">
+                <div className="flex items-center justify-between">
+                  <RoutingInsightsFilters table={table} />
+                </div>
+                <RoutingKPICards />
+              </div>
+            )}
+          </RoutingFormResponsesTable>
 
           <FailedBookingsByField />
 

apps/web/modules/members/members-view.tsx

@@ -0,0 +1,26 @@
+"use client";
+
+import MembersView from "@calcom/features/ee/organizations/pages/members";
+import Shell from "@calcom/features/shell/Shell";
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { HeadSeo } from "@calcom/ui";
+
+const MembersPage: React.FC = () => {
+  const { t } = useLocale();
+  return (
+    <Shell
+      withoutMain={false}
+      title={t("organization_members")}
+      description={t("organization_description")}
+      withoutSeo
+      heading={t("organization_members")}
+      hideHeadingOnMobile
+      subtitle={t("organization_description")}>
+      <HeadSeo title={t("organization_members")} description={t("organization_description")} />
+
+      <MembersView />
+    </Shell>
+  );
+};
+
+export default MembersPage;

apps/web/modules/settings/my-account/conferencing-view.tsx

@@ -1,100 +0,0 @@
-"use client";
-
-import { useReducer } from "react";
-
-import DisconnectIntegrationModal from "@calcom/features/apps/components/DisconnectIntegrationModal";
-import { useLocale } from "@calcom/lib/hooks/useLocale";
-import { trpc } from "@calcom/trpc/react";
-import { Button, EmptyScreen, SkeletonContainer, SkeletonText } from "@calcom/ui";
-
-import { QueryCell } from "@lib/QueryCell";
-
-import { AppList } from "@components/apps/AppList";
-
-const SkeletonLoader = () => {
-  return (
-    <SkeletonContainer>
-      <div className="divide-subtle border-subtle space-y-6 rounded-b-lg border border-t-0 px-6 py-4">
-        <SkeletonText className="h-8 w-full" />
-        <SkeletonText className="h-8 w-full" />
-      </div>
-    </SkeletonContainer>
-  );
-};
-
-type ModalState = {
-  isOpen: boolean;
-  credentialId: null | number;
-};
-
-const ConferencingView = () => {
-  const { t } = useLocale();
-
-  const [modal, updateModal] = useReducer(
-    (data: ModalState, partialData: Partial<ModalState>) => ({ ...data, ...partialData }),
-    {
-      isOpen: false,
-      credentialId: null,
-    }
-  );
-
-  const query = trpc.viewer.integrations.useQuery({
-    variant: "conferencing",
-    onlyInstalled: true,
-  });
-
-  const handleModelClose = () => {
-    updateModal({ isOpen: false, credentialId: null });
-  };
-
-  const handleDisconnect = (credentialId: number) => {
-    updateModal({ isOpen: true, credentialId });
-  };
-
-  return (
-    <>
-      <div className="bg-default w-full sm:mx-0 xl:mt-0">
-        <QueryCell
-          query={query}
-          customLoader={<SkeletonLoader />}
-          success={({ data }) => {
-            if (!data.items.length) {
-              return (
-                <EmptyScreen
-                  Icon="calendar"
-                  headline={t("no_category_apps", {
-                    category: t("conferencing").toLowerCase(),
-                  })}
-                  description={t("no_category_apps_description_conferencing")}
-                  buttonRaw={
-                    <Button
-                      color="secondary"
-                      data-testid="connect-conferencing-apps"
-                      href="/apps/categories/conferencing">
-                      {t("connect_conference_apps")}
-                    </Button>
-                  }
-                />
-              );
-            }
-            return (
-              <AppList
-                listClassName="rounded-lg rounded-t-none border-t-0 max-w-full"
-                handleDisconnect={handleDisconnect}
-                data={data}
-                variant="conferencing"
-              />
-            );
-          }}
-        />
-      </div>
-      <DisconnectIntegrationModal
-        handleModelClose={handleModelClose}
-        isOpen={modal.isOpen}
-        credentialId={modal.credentialId}
-      />
-    </>
-  );
-};
-
-export default ConferencingView;

apps/web/modules/team/type-view.tsx

@@ -32,6 +32,8 @@ function Type({
   isInstantMeeting,
   orgBannerUrl,
   teamMemberEmail,
+  crmOwnerRecordType,
+  crmAppSlug,
 }: PageProps) {
   const searchParams = useSearchParams();
 
@@ -65,6 +67,8 @@ function Type({
         )}
         orgBannerUrl={orgBannerUrl}
         teamMemberEmail={teamMemberEmail}
+        crmOwnerRecordType={crmOwnerRecordType}
+        crmAppSlug={crmAppSlug}
       />
     </main>
   );

apps/web/next.config.js

@@ -186,7 +186,7 @@ const nextConfig = {
     locales: ["en"],
     localeDetection: false,
   },
-  productionBrowserSourceMaps: false,
+  productionBrowserSourceMaps: process.env.SENTRY_DISABLE_CLIENT_SOURCE_MAPS === "0",
   /* We already do type check on GH actions */
   typescript: {
     ignoreBuildErrors: !!process.env.CI,
@@ -223,6 +223,10 @@ const nextConfig = {
   },
   webpack: (config, { webpack, buildId, isServer }) => {
     if (isServer) {
+      if (process.env.SENTRY_DISABLE_SERVER_SOURCE_MAPS === "1") {
+        config.devtool = false;
+      }
+
       // Module not found fix @see https://github.com/boxyhq/jackson/issues/1535#issuecomment-1704381612
       config.plugins.push(
         new webpack.IgnorePlugin({
@@ -667,6 +671,10 @@ if (!!process.env.NEXT_PUBLIC_SENTRY_DSN) {
       hideSourceMaps: true,
       // disable source map generation for the server code
       disableServerWebpackPlugin: !!process.env.SENTRY_DISABLE_SERVER_WEBPACK_PLUGIN,
+      silent: false,
+      sourcemaps: {
+        disable: process.env.SENTRY_DISABLE_SERVER_SOURCE_MAPS === "1",
+      },
     })
   );
 }

apps/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcom/web",
-  "version": "4.7.0",
+  "version": "4.7.14",
   "private": true,
   "scripts": {
     "analyze": "ANALYZE=true next build",
@@ -64,6 +64,7 @@
     "@radix-ui/react-switch": "^1.0.0",
     "@radix-ui/react-toggle-group": "^1.0.0",
     "@radix-ui/react-tooltip": "^1.0.0",
+    "@replexica/sdk": "^0.7.0",
     "@sentry/nextjs": "^8.8.0",
     "@stripe/react-stripe-js": "^1.10.0",
     "@stripe/stripe-js": "^1.35.0",

apps/web/pages/api/availability/calendar.ts

@@ -3,98 +3,92 @@ import { z } from "zod";
 
 import { getCalendarCredentials, getConnectedCalendars } from "@calcom/core/CalendarManager";
 import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
+import { CalendarCache } from "@calcom/features/calendar-cache/calendar-cache";
+import { HttpError } from "@calcom/lib/http-error";
 import notEmpty from "@calcom/lib/notEmpty";
-import prisma from "@calcom/prisma";
-import { credentialForCalendarServiceSelect } from "@calcom/prisma/selects/credential";
+import { defaultHandler, defaultResponder } from "@calcom/lib/server";
+import { SelectedCalendarRepository } from "@calcom/lib/server/repository/selectedCalendar";
+import { UserRepository } from "@calcom/lib/server/repository/user";
 
 const selectedCalendarSelectSchema = z.object({
   integration: z.string(),
   externalId: z.string(),
-  credentialId: z.number().optional(),
+  credentialId: z.coerce.number(),
 });
 
-export default async function handler(req: NextApiRequest, res: NextApiResponse) {
-  const session = await getServerSession({ req, res });
+/** Shared authentication middleware for GET, DELETE and POST requests */
+async function authMiddleware(req: CustomNextApiRequest) {
+  const session = await getServerSession({ req });
 
   if (!session?.user?.id) {
-    res.status(401).json({ message: "Not authenticated" });
-    return;
+    throw new HttpError({ statusCode: 401, message: "Not authenticated" });
   }
 
-  const userWithCredentials = await prisma.user.findUnique({
-    where: {
-      id: session.user.id,
-    },
-    select: {
-      credentials: {
-        select: credentialForCalendarServiceSelect,
-      },
-      timeZone: true,
-      id: true,
-      selectedCalendars: true,
-    },
-  });
+  const userWithCredentials = await UserRepository.findUserWithCredentials({ id: session.user.id });
+
   if (!userWithCredentials) {
-    res.status(401).json({ message: "Not authenticated" });
-    return;
-  }
-  const { credentials, ...user } = userWithCredentials;
-
-  if (req.method === "POST") {
-    const { integration, externalId, credentialId } = selectedCalendarSelectSchema.parse(req.body);
-    await prisma.selectedCalendar.upsert({
-      where: {
-        userId_integration_externalId: {
-          userId: user.id,
-          integration,
-          externalId,
-        },
-      },
-      create: {
-        userId: user.id,
-        integration,
-        externalId,
-        credentialId,
-      },
-      // already exists
-      update: {},
-    });
-    res.status(200).json({ message: "Calendar Selection Saved" });
-  }
-
-  if (req.method === "DELETE") {
-    const { integration, externalId } = selectedCalendarSelectSchema.parse(req.query);
-    await prisma.selectedCalendar.delete({
-      where: {
-        userId_integration_externalId: {
-          userId: user.id,
-          externalId,
-          integration,
-        },
-      },
-    });
-
-    res.status(200).json({ message: "Calendar Selection Saved" });
-  }
-
-  if (req.method === "GET") {
-    const selectedCalendarIds = await prisma.selectedCalendar.findMany({
-      where: {
-        userId: user.id,
-      },
-      select: {
-        externalId: true,
-      },
-    });
-
-    // get user's credentials + their connected integrations
-    const calendarCredentials = getCalendarCredentials(credentials);
-    // get all the connected integrations' calendars (from third party)
-    const { connectedCalendars } = await getConnectedCalendars(calendarCredentials, user.selectedCalendars);
-    const calendars = connectedCalendars.flatMap((c) => c.calendars).filter(notEmpty);
-    const selectableCalendars = calendars.map((cal) => {
-      return { selected: selectedCalendarIds.findIndex((s) => s.externalId === cal.externalId) > -1, ...cal };
-    });
-    res.status(200).json(selectableCalendars);
+    throw new HttpError({ statusCode: 401, message: "Not authenticated" });
   }
+  req.userWithCredentials = userWithCredentials;
+  return userWithCredentials;
 }
+
+type CustomNextApiRequest = NextApiRequest & {
+  userWithCredentials?: Awaited<ReturnType<typeof authMiddleware>>;
+};
+
+async function postHandler(req: CustomNextApiRequest) {
+  if (!req.userWithCredentials) throw new HttpError({ statusCode: 401, message: "Not authenticated" });
+  const user = req.userWithCredentials;
+  const { integration, externalId, credentialId } = selectedCalendarSelectSchema.parse(req.body);
+  await SelectedCalendarRepository.upsert({
+    userId: user.id,
+    integration,
+    externalId,
+    credentialId,
+  });
+
+  return { message: "Calendar Selection Saved" };
+}
+
+async function deleteHandler(req: CustomNextApiRequest) {
+  if (!req.userWithCredentials) throw new HttpError({ statusCode: 401, message: "Not authenticated" });
+  const user = req.userWithCredentials;
+  const { integration, externalId, credentialId } = selectedCalendarSelectSchema.parse(req.query);
+  const calendarCacheRepository = await CalendarCache.initFromCredentialId(credentialId);
+  await calendarCacheRepository.unwatchCalendar({ calendarId: externalId });
+  await SelectedCalendarRepository.delete({
+    userId: user.id,
+    externalId,
+    integration,
+  });
+
+  return { message: "Calendar Selection Saved" };
+}
+
+async function getHandler(req: CustomNextApiRequest) {
+  if (!req.userWithCredentials) throw new HttpError({ statusCode: 401, message: "Not authenticated" });
+  const user = req.userWithCredentials;
+  const selectedCalendarIds = await SelectedCalendarRepository.findMany({
+    where: { userId: user.id },
+    select: { externalId: true },
+  });
+  // get user's credentials + their connected integrations
+  const calendarCredentials = getCalendarCredentials(user.credentials);
+  // get all the connected integrations' calendars (from third party)
+  const { connectedCalendars } = await getConnectedCalendars(calendarCredentials, user.selectedCalendars);
+  const calendars = connectedCalendars.flatMap((c) => c.calendars).filter(notEmpty);
+  const selectableCalendars = calendars.map((cal) => {
+    return { selected: selectedCalendarIds.findIndex((s) => s.externalId === cal.externalId) > -1, ...cal };
+  });
+  return selectableCalendars;
+}
+
+export default defaultResponder(async (req: NextApiRequest, res: NextApiResponse) => {
+  await authMiddleware(req);
+  return defaultHandler({
+    GET: Promise.resolve({ default: defaultResponder(getHandler) }),
+    POST: Promise.resolve({ default: defaultResponder(postHandler) }),
+    DELETE: Promise.resolve({ default: defaultResponder(deleteHandler) }),
+  })(req, res);
+});

apps/web/pages/api/calendar-cache/cron.ts

@@ -0,0 +1 @@
+export { default } from "@calcom/features/calendar-cache/api/cron";

apps/web/pages/api/cron/calendar-cache-cleanup.ts

@@ -3,6 +3,12 @@ import type { NextApiRequest, NextApiResponse } from "next";
 import prisma from "@calcom/prisma";
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const apiKey = req.headers.authorization || req.query.apiKey;
+  if (![process.env.CRON_API_KEY, `Bearer ${process.env.CRON_SECRET}`].includes(`${apiKey}`)) {
+    res.status(401).json({ message: "Not authenticated" });
+    return;
+  }
+
   const deleted = await prisma.calendarCache.deleteMany({
     where: {
       // Delete all cache entries that expired before now

apps/web/pages/api/social/og/image.tsx

@@ -87,7 +87,7 @@ export default async function handler(req: NextApiRequest) {
 
       return new Response(img.body, {
         status: 200,
-        headers: { "Content-Type": "image/png", "cache-control": "max-age=86400" },
+        headers: { "Content-Type": "image/png", "cache-control": "max-age=0" },
       });
     }
     case "app": {

apps/web/pages/settings/organizations/[id]/about.tsx

@@ -1,23 +0,0 @@
-import { getServerSideProps } from "@calcom/features/ee/organizations/pages/organization";
-import { useLocale } from "@calcom/lib/hooks/useLocale";
-import { Meta } from "@calcom/ui";
-
-import PageWrapper from "@components/PageWrapper";
-
-import AboutOrganizationForm, { LayoutWrapper } from "~/settings/organizations/[id]/about-view";
-
-const Page = () => {
-  const { t } = useLocale();
-  return (
-    <>
-      <Meta title={t("about_your_organization")} description={t("about_your_organization_description")} />
-      <AboutOrganizationForm />
-    </>
-  );
-};
-
-Page.getLayout = LayoutWrapper;
-Page.PageWrapper = PageWrapper;
-
-export default Page;
-export { getServerSideProps };

apps/web/pages/settings/organizations/[id]/add-teams.tsx

@@ -1,24 +0,0 @@
-import { getServerSideProps } from "@calcom/features/ee/organizations/pages/organization";
-import { useLocale } from "@calcom/lib/hooks/useLocale";
-import { Meta } from "@calcom/ui";
-
-import PageWrapper from "@components/PageWrapper";
-
-import AddNewTeamsForm, { LayoutWrapper } from "~/settings/organizations/[id]/add-teams-view";
-
-const Page = () => {
-  const { t } = useLocale();
-  return (
-    <>
-      <Meta title={t("create_your_teams")} description={t("create_your_teams_description")} />
-      <AddNewTeamsForm />
-    </>
-  );
-};
-
-Page.getLayout = LayoutWrapper;
-Page.PageWrapper = PageWrapper;
-
-export default Page;
-
-export { getServerSideProps };

apps/web/pages/settings/organizations/[id]/onboard-members.tsx

@@ -1,27 +0,0 @@
-import { getServerSideProps } from "@calcom/features/ee/organizations/pages/organization";
-import { useLocale } from "@calcom/lib/hooks/useLocale";
-import { Meta } from "@calcom/ui";
-
-import PageWrapper from "@components/PageWrapper";
-
-import OrgAddNewTeamMembers, { LayoutWrapper } from "~/settings/organizations/[id]/onboard-members-view";
-
-const Page = () => {
-  const { t } = useLocale();
-
-  return (
-    <>
-      <Meta
-        title={t("invite_organization_admins")}
-        description={t("invite_organization_admins_description")}
-      />
-      <OrgAddNewTeamMembers />
-    </>
-  );
-};
-
-Page.getLayout = LayoutWrapper;
-Page.PageWrapper = PageWrapper;
-
-export default Page;
-export { getServerSideProps };

apps/web/pages/settings/organizations/admin-api.tsx

@@ -1,25 +0,0 @@
-import AdminAPIView from "@calcom/features/ee/organizations/pages/settings/admin-api";
-import { getLayout } from "@calcom/features/settings/layouts/SettingsLayout";
-import { useLocale } from "@calcom/lib/hooks/useLocale";
-import { Meta } from "@calcom/ui";
-
-import PageWrapper from "@components/PageWrapper";
-
-const Page = () => {
-  const { t } = useLocale();
-  return (
-    <>
-      <Meta
-        title={`${t("admin")} ${t("api_reference")}`}
-        description={t("leverage_our_api")}
-        borderInShellHeader={false}
-      />
-      <AdminAPIView />
-    </>
-  );
-};
-
-Page.PageWrapper = PageWrapper;
-Page.getLayout = getLayout;
-
-export default Page;

apps/web/pages/settings/organizations/appearance.tsx

@@ -1,9 +0,0 @@
-import OrgAppearanceView from "@calcom/features/ee/organizations/pages/settings/appearance";
-
-import type { CalPageWrapper } from "@components/PageWrapper";
-import PageWrapper from "@components/PageWrapper";
-
-const Page = OrgAppearanceView as CalPageWrapper;
-Page.PageWrapper = PageWrapper;
-
-export default Page;

apps/web/pages/settings/organizations/attributes/[id]/edit.tsx

@@ -1,24 +0,0 @@
-"use client";
-
-import OrgAttributesEditPage, {
-  getLayout,
-} from "@calcom/ee/organizations/pages/settings/attributes/attributes-edit-view";
-import { useLocale } from "@calcom/lib/hooks/useLocale";
-import { Meta } from "@calcom/ui";
-
-import PageWrapper from "@components/PageWrapper";
-
-const Page = () => {
-  const { t } = useLocale();
-  return (
-    <>
-      <Meta title="Attribute" description={t("edit_attribute_description")} />
-      <OrgAttributesEditPage />
-    </>
-  );
-};
-
-Page.getLayout = getLayout;
-Page.PageWrapper = PageWrapper;
-
-export default Page;

apps/web/pages/settings/organizations/attributes/create.tsx

@@ -1,20 +0,0 @@
-import OrgAttributesCreatePage, {
-  getLayout,
-} from "@calcom/ee/organizations/pages/settings/attributes/attributes-create-view";
-import { Meta } from "@calcom/ui";
-
-import PageWrapper from "@components/PageWrapper";
-
-const Page = () => {
-  return (
-    <>
-      <Meta title="Attribute" description="Create an attribute for your team members" />
-      <OrgAttributesCreatePage />
-    </>
-  );
-};
-
-Page.getLayout = getLayout;
-Page.PageWrapper = PageWrapper;
-
-export default Page;