chore: v4.7.4 (#17728)

* chore: sync with main

* feat: update translations via @replexica

---------

Co-authored-by: Replexica <support@replexica.com>

.env.appStore.example

@@ -5,6 +5,7 @@
 #   - DAILY.CO VIDEO
 #   - GOOGLE CALENDAR/MEET/LOGIN
 #   - HUBSPOT
+#   - HUDDLE01
 #   - OFFICE 365
 #   - SLACK
 #   - STRIPE
@@ -137,3 +138,7 @@ REVERT_PUBLIC_TOKEN=
 # NOTE: If you're self hosting Revert, update this URL to point to your own instance.
 REVERT_API_URL=https://api.revert.dev/
 # *********************************************************************************************************
+
+#   - Huddle01
+# Used for the huddle01 integration
+HUDDLE01_API_TOKEN=

.env.example

@@ -16,7 +16,7 @@
 # - Acquire a commercial license to remove these terms by visiting: cal.com/sales
 #
 
-# To enable enterprise-only features please add your envrionment variable to the .env file then make your way to /auth/setup to select your license and follow instructions. 
+# To enable enterprise-only features please add your environment variable to the .env file then make your way to /auth/setup to select your license and follow instructions.
 CALCOM_LICENSE_KEY=
 # Signature token for the Cal.com License API (used for self-hosted integrations)
 # We will give you a token when we provide you with a license key this ensure you and only you can communicate with the Cal.com License API for your license key
@@ -102,6 +102,11 @@ NEXT_PUBLIC_INTERCOM_APP_ID=
 # Secret to enable Intercom Identity Verification
 INTERCOM_SECRET=
 
+# Posthog Config
+NEXT_PUBLIC_POSTHOG_KEY=
+
+NEXT_PUBLIC_POSTHOG_HOST=
+
 # Zendesk Config
 NEXT_PUBLIC_ZENDESK_KEY=
 
@@ -124,11 +129,15 @@ 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=
 
-# Sengrid
+# Sendgrid
 # Used for email reminders in workflows and internal sync services
 SENDGRID_API_KEY=
 SENDGRID_EMAIL=
@@ -137,6 +146,9 @@ NEXT_PUBLIC_SENDGRID_SENDER_NAME=
 # Sentry
 # Used for capturing exceptions and logging messages
 NEXT_PUBLIC_SENTRY_DSN=
+SENTRY_DEBUG=
+SENTRY_MAX_SPANS=
+SENTRY_TRACES_SAMPLE_RATE=
 
 # Formbricks Experience Management Integration
 NEXT_PUBLIC_FORMBRICKS_HOST_URL=https://app.formbricks.com
@@ -262,7 +274,7 @@ ORGANIZATIONS_ENABLED=
 NEXT_PUBLIC_ORGANIZATIONS_MIN_SELF_SERVE_SEATS=30
 NEXT_PUBLIC_ORGANIZATIONS_SELF_SERVE_PRICE=3700 # $37.00 per seat
 
-# This variable should only be set to 1 or true if you want to autolink external provider sing-ups with
+# This variable should only be set to 1 or true if you want to autolink external provider sign-ups with
 # existing organizations based on email domain address
 ORGANIZATIONS_AUTOLINK=
 
@@ -334,9 +346,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_ADMIN_ENABLED=0
-APP_ROUTER_SETTINGS_MY_ACCOUNT_ENABLED=0
-APP_ROUTER_SETTINGS_PLATFORM_ENABLED=0
 APP_ROUTER_SETTINGS_ORG_ENABLED=0
 APP_ROUTER_APPS_INSTALLED_CATEGORY_ENABLED=0
 APP_ROUTER_APPS_SLUG_ENABLED=0
@@ -385,6 +394,9 @@ UNKEY_ROOT_KEY=
 # https://retellai.com
 RETELL_AI_KEY=
 
+# Used for the huddle01 integration
+HUDDLE01_API_TOKEN=
+
 # Used to disallow emails as being added as guests on bookings
 BLACKLISTED_GUEST_EMAILS=
 
@@ -400,3 +412,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/api-v1-production-build.yml

@@ -83,11 +83,12 @@ jobs:
             **/.turbo/**
             **/dist/**
           key: ${{ runner.os }}-${{ env.cache-name }}-${{ env.key-1 }}-${{ env.key-2 }}-${{ env.key-3 }}-${{ env.key-4 }}
-      - run: |
+      - name: Log Cache Hit
+        if: steps.cache-api-v1-build.outputs.cache-hit == 'true'
+        run: echo "Cache hit for API v1 build. Skipping build."
+      - name: Run build
+        if: steps.cache-api-v1-build.outputs.cache-hit != 'true'
+        run: |
           export NODE_OPTIONS="--max_old_space_size=8192"
-          if [ ${{ steps.cache-api-v1-build.outputs.cache-hit }} == 'true' ]; then
-            echo "Cache hit for API v1 build. Skipping build."
-          else
-            yarn turbo run build --filter=@calcom/api...
-          fi
+          yarn turbo run build --filter=@calcom/api...
         shell: bash

.github/workflows/api-v2-production-build.yml

@@ -49,14 +49,15 @@ jobs:
           path: |
             **/dist/**
           key: ${{ runner.os }}-${{ env.cache-name }}-${{ env.key-1 }}-${{ env.key-2 }}-${{ env.key-3 }}-${{ env.key-4 }}
-      - run: |
+      - name: Log Cache Hit
+        if: steps.cache-api-v2-build.outputs.cache-hit == 'true'
+        run: echo "Cache hit for API v2 build. Skipping build."
+      - name: Run build
+        if: steps.cache-api-v2-build.outputs.cache-hit != 'true'
+        run: |
           export NODE_OPTIONS="--max_old_space_size=8192"
-          if [ ${{ steps.cache-api-v2-build.outputs.cache-hit }} == 'true' ]; then
-            echo "Cache hit for API v2 build. Skipping build."
-          else
-            yarn workspace @calcom/api-v2 run generate-schemas
-            rm -rf apps/api/v2/node_modules
-            yarn install
-            yarn workspace @calcom/api-v2 run build
-          fi
+          yarn workspace @calcom/api-v2 run generate-schemas
+          rm -rf apps/api/v2/node_modules
+          yarn install
+          yarn workspace @calcom/api-v2 run build
         shell: bash

.github/workflows/atoms-production-build.yml

@@ -5,7 +5,7 @@ on:
 
 jobs:
   build:
-    name: Build atoms
+    name: Build Atoms
     permissions:
       contents: read
     runs-on: buildjet-4vcpu-ubuntu-2204
@@ -28,13 +28,14 @@ jobs:
           path: |
             **/dist/**
           key: ${{ runner.os }}-${{ env.cache-name }}-${{ env.key-1 }}-${{ env.key-2 }}-${{ env.key-3 }}-${{ env.key-4 }}
-      - run: |
+      - name: Log Cache Hit
+        if: steps.cache-atoms-build.outputs.cache-hit == 'true'
+        run: echo "Cache hit for Atoms build. Skipping build."
+      - name: Run build
+        if: steps.cache-atoms-build.outputs.cache-hit != 'true'
+        run: |
           export NODE_OPTIONS="--max_old_space_size=8192"
-          if [ ${{ steps.cache-atoms-build.outputs.cache-hit }} == 'true' ]; then
-            echo "Cache hit for atoms build. Skipping build."
-          else
-            rm -rf packages/platform/atoms/node_modules
-            yarn install
-            yarn workspace @calcom/atoms run build
-          fi
+          rm -rf packages/platform/atoms/node_modules
+          yarn install
+          yarn workspace @calcom/atoms run build
         shell: bash

.github/workflows/docs-build.yml

@@ -26,16 +26,17 @@ jobs:
           path: |
             **/docs/**
           key: ${{ runner.os }}-${{ env.cache-name }}-${{ env.key-1 }}-${{ env.key-2 }}-${{ env.key-3 }}-${{ env.key-4 }}
+            # Log cache hit
+      - name: Log Cache Hit
+        if: steps.cache-docs-build.outputs.cache-hit == 'true'
+        run: echo "Cache hit for Docs build. Skipping build."
       - name: Run build
+        if: steps.cache-docs-build.outputs.cache-hit != 'true'
         working-directory: docs
         run: |
           export NODE_OPTIONS="--max_old_space_size=8192"
-          if [ ${{ steps.cache-docs-build.outputs.cache-hit }} == 'true' ]; then
-            echo "Cache hit for Docs build. Skipping build."
-          else
-            npm install -g mintlify
-            mintlify dev &
-            sleep 5 # Let it run for 5 seconds
-            kill $!
-          fi
+          npm install -g mintlify
+          mintlify dev &
+          sleep 5 # Let it run for 5 seconds
+          kill $!
         shell: bash

.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

CONTRIBUTING.md

@@ -108,10 +108,10 @@ To develop locally:
    nvm use
    ```
 
-   You first might need to install the specific version and then use it:
+   You first might need to install the specific version:
 
    ```sh
-   nvm install && nvm use
+   nvm install
    ```
 
    You can install nvm from [here](https://github.com/nvm-sh/nvm).

apps/api/v1/lib/validations/event-type.ts

@@ -168,7 +168,10 @@ export const schemaEventTypeReadPublic = EventType.pick({
     metadata: jsonSchema.nullable(),
     customInputs: customInputSchema.array().optional(),
     link: z.string().optional(),
-    hashedLink: z.object({ link: z.string() }).optional().nullable(),
+    hashedLink: z
+      .array(z.object({ link: z.string() }))
+      .optional()
+      .default([]),
     bookingFields: eventTypeBookingFields.optional().nullable(),
   })
 );

apps/api/v1/pages/api/availability/_get.ts

@@ -199,6 +199,7 @@ async function handler(req: NextApiRequest) {
       eventTypeId,
       userId,
       returnDateOverrides: true,
+      bypassBusyCalendarTimes: false,
     });
   const team = await prisma.team.findUnique({
     where: { id: teamId },
@@ -235,6 +236,7 @@ async function handler(req: NextApiRequest) {
         dateTo,
         eventTypeId,
         returnDateOverrides: true,
+        bypassBusyCalendarTimes: false,
       }),
     };
   });

apps/api/v1/pages/api/slots/_get.test.ts

@@ -66,11 +66,8 @@ describe("GET /api/slots", () => {
         buildMockData();
         await handler(req, res);
         console.log({ statusCode: res._getStatusCode(), data: JSON.parse(res._getData()) });
-        expect(JSON.parse(res._getData())).toMatchInlineSnapshot(`
-          {
-            "slots": {},
-          }
-        `);
+        const response = JSON.parse(res._getData());
+        expect(response.slots).toEqual(expect.objectContaining({}));
       });
       test("Returns and event type available slots with passed timeZone", async () => {
         const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
@@ -87,11 +84,8 @@ describe("GET /api/slots", () => {
         buildMockData();
         await handler(req, res);
         console.log({ statusCode: res._getStatusCode(), data: JSON.parse(res._getData()) });
-        expect(JSON.parse(res._getData())).toMatchInlineSnapshot(`
-          {
-            "slots": {},
-          }
-        `);
+        const response = JSON.parse(res._getData());
+        expect(response.slots).toEqual(expect.objectContaining({}));
       });
     });
   });

apps/api/v1/test/lib/utils/retrieveScopedAccessibleUsers.integration-test.ts

@@ -81,7 +81,7 @@ describe("retrieveScopedAccessibleUsers tests", () => {
         where: { email: "member2-acme@example.com" },
       });
 
-      expect(accessibleUserIds.length).toBe(3);
+      expect(accessibleUserIds.length).toBe(11);
       expect(accessibleUserIds).toContain(memberOneUser.id);
       expect(accessibleUserIds).toContain(memberTwoUser.id);
       expect(accessibleUserIds).toContain(adminUser.id);

apps/api/v2/.env.example

@@ -28,3 +28,7 @@ API_KEY_PREFIX=cal_
 GET_LICENSE_KEY_URL="https://console.cal.com/api/license"
 IS_E2E=false
 DOCS_URL=
+
+# Axiom logging
+AXIOM_DATASET=
+AXIOM_TOKEN=

apps/api/v2/package.json

@@ -19,16 +19,17 @@
     "test:watch": "yarn dev:build && jest --watch",
     "test:cov": "yarn dev:build && jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
-    "test:e2e": "yarn dev:build && NODE_OPTIONS='--max_old_space_size=8192' jest --ci --forceExit --config ./jest-e2e.json",
+    "test:e2e": "yarn dev:build && NODE_OPTIONS='--max_old_space_size=8192 --experimental-vm-modules' jest --ci --forceExit --config ./jest-e2e.json",
     "test:e2e:watch": "yarn dev:build && jest --runInBand --detectOpenHandles --forceExit --config ./jest-e2e.json --watch",
     "prisma": "yarn workspace @calcom/prisma prisma",
     "generate-schemas": "yarn prisma generate && yarn prisma format",
     "copy-swagger-module": "ts-node -r tsconfig-paths/register swagger/copy-swagger-module.ts"
   },
   "dependencies": {
+    "@axiomhq/winston": "^1.2.0",
     "@calcom/platform-constants": "*",
     "@calcom/platform-enums": "*",
-    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.45",
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.61",
     "@calcom/platform-libraries-0.0.2": "npm:@calcom/platform-libraries@0.0.2",
     "@calcom/platform-types": "*",
     "@calcom/platform-utils": "*",
@@ -45,7 +46,9 @@
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/swagger": "^7.3.0",
     "@nestjs/throttler": "6.2.1",
+    "@sentry/nestjs": "^8.37.1",
     "@sentry/node": "^8.8.0",
+    "@sentry/profiling-node": "^8.37.1",
     "body-parser": "^1.20.2",
     "bull": "^4.12.4",
     "class-transformer": "^0.5.1",
@@ -67,7 +70,8 @@
     "rxjs": "^7.8.1",
     "stripe": "^15.3.0",
     "uuid": "^8.3.2",
-    "winston": "^3.11.0",
+    "winston": "^3.13.0",
+    "winston-transport": "^4.7.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {

apps/api/v2/src/app.module.ts

@@ -17,13 +17,15 @@ import { ThrottlerStorageRedisService } from "@nest-lab/throttler-storage-redis"
 import { BullModule } from "@nestjs/bull";
 import { MiddlewareConsumer, Module, NestModule, RequestMethod } from "@nestjs/common";
 import { ConfigModule } from "@nestjs/config";
-import { APP_GUARD, APP_INTERCEPTOR } from "@nestjs/core";
+import { APP_GUARD, APP_INTERCEPTOR, APP_FILTER } from "@nestjs/core";
 import { seconds, ThrottlerModule } from "@nestjs/throttler";
+import { SentryModule, SentryGlobalFilter } from "@sentry/nestjs/setup";
 
 import { AppController } from "./app.controller";
 
 @Module({
   imports: [
+    SentryModule.forRoot(),
     ConfigModule.forRoot({
       ignoreEnvFile: true,
       isGlobal: true,
@@ -59,6 +61,10 @@ import { AppController } from "./app.controller";
   ],
   controllers: [AppController],
   providers: [
+    {
+      provide: APP_FILTER,
+      useClass: SentryGlobalFilter,
+    },
     {
       provide: ThrottlerStorageRedisService,
       useFactory: (redisService: RedisService) => {

apps/api/v2/src/app.ts

@@ -7,7 +7,6 @@ import type { ValidationError } from "@nestjs/common";
 import { BadRequestException, ValidationPipe, VersioningType } from "@nestjs/common";
 import { BaseExceptionFilter, HttpAdapterHost } from "@nestjs/core";
 import type { NestExpressApplication } from "@nestjs/platform-express";
-import * as Sentry from "@sentry/node";
 import * as cookieParser from "cookie-parser";
 import { Request } from "express";
 import helmet from "helmet";
@@ -71,9 +70,6 @@ export const bootstrap = (app: NestExpressApplication): NestExpressApplication =
 
   // Exception filters, new filters go at the bottom, keep the order
   const { httpAdapter } = app.get(HttpAdapterHost);
-  if (process.env.SENTRY_DSN) {
-    Sentry.setupNestErrorHandler(app, new BaseExceptionFilter(httpAdapter));
-  }
   app.useGlobalFilters(new PrismaExceptionFilter());
   app.useGlobalFilters(new ZodExceptionFilter());
   app.useGlobalFilters(new HttpExceptionFilter());

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

@@ -89,7 +89,7 @@ const DEFAULT_PLATFORM_PARAMS = {
 @UseGuards(PermissionsGuard)
 @DocsExcludeController(true)
 export class BookingsController_2024_04_15 {
-  private readonly logger = new Logger("BookingsController");
+  private readonly logger = new Logger("BookingsController_2024_04_15");
 
   constructor(
     private readonly oAuthFlowService: OAuthFlowService,
@@ -111,8 +111,9 @@ export class BookingsController_2024_04_15 {
     @Query() queryParams: GetBookingsInput_2024_04_15
   ): Promise<GetBookingsOutput_2024_04_15> {
     const { filters, cursor, limit } = queryParams;
+    const bookingListingByStatus = filters?.status ?? Status_2024_04_15["upcoming"];
     const bookings = await getAllUserBookings({
-      bookingListingByStatus: [filters.status],
+      bookingListingByStatus: [bookingListingByStatus],
       skip: cursor ?? 0,
       take: limit ?? 10,
       filters,
@@ -355,13 +356,22 @@ export class BookingsController_2024_04_15 {
     oAuthClientId?: string,
     platformBookingLocation?: string
   ): Promise<NextApiRequest & { userId?: number } & OAuthRequestParams> {
+    const requestId = req.get("X-Request-Id");
+    const clone = { ...req };
     const userId = (await this.getOwnerId(req)) ?? -1;
     const oAuthParams = oAuthClientId
       ? await this.getOAuthClientsParams(oAuthClientId)
       : DEFAULT_PLATFORM_PARAMS;
-    Object.assign(req, { userId, ...oAuthParams, platformBookingLocation });
-    req.body = { ...req.body, noEmail: !oAuthParams.arePlatformEmailsEnabled };
-    return req as unknown as NextApiRequest & { userId?: number } & OAuthRequestParams;
+    this.logger.log(`createNextApiBookingRequest_2024_04_15`, {
+      requestId,
+      ownerId: userId,
+      platformBookingLocation,
+      oAuthClientId,
+      ...oAuthParams,
+    });
+    Object.assign(clone, { userId, ...oAuthParams, platformBookingLocation });
+    clone.body = { ...clone.body, noEmail: !oAuthParams.arePlatformEmailsEnabled };
+    return clone as unknown as NextApiRequest & { userId?: number } & OAuthRequestParams;
   }
 
   private async createNextApiRecurringBookingRequest(
@@ -369,17 +379,26 @@ export class BookingsController_2024_04_15 {
     oAuthClientId?: string,
     platformBookingLocation?: string
   ): Promise<NextApiRequest & { userId?: number } & OAuthRequestParams> {
+    const clone = { ...req };
     const userId = (await this.getOwnerId(req)) ?? -1;
     const oAuthParams = oAuthClientId
       ? await this.getOAuthClientsParams(oAuthClientId)
       : DEFAULT_PLATFORM_PARAMS;
-    Object.assign(req, {
+    const requestId = req.get("X-Request-Id");
+    this.logger.log(`createNextApiRecurringBookingRequest_2024_04_15`, {
+      requestId,
+      ownerId: userId,
+      platformBookingLocation,
+      oAuthClientId,
+      ...oAuthParams,
+    });
+    Object.assign(clone, {
       userId,
       ...oAuthParams,
       platformBookingLocation,
       noEmail: !oAuthParams.arePlatformEmailsEnabled,
     });
-    return req as unknown as NextApiRequest & { userId?: number } & OAuthRequestParams;
+    return clone as unknown as NextApiRequest & { userId?: number } & OAuthRequestParams;
   }
 
   private handleBookingErrors(

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

@@ -6,6 +6,8 @@ import { OutputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/servi
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
 import { ApiKeyRepository } from "@/modules/api-key/api-key-repository";
 import { BillingModule } from "@/modules/billing/billing.module";
+import { BookingSeatModule } from "@/modules/booking-seat/booking-seat.module";
+import { BookingSeatRepository } from "@/modules/booking-seat/booking-seat.repository";
 import { OAuthClientRepository } from "@/modules/oauth-clients/oauth-client.repository";
 import { OAuthFlowService } from "@/modules/oauth-clients/services/oauth-flow.service";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
@@ -16,7 +18,7 @@ import { UsersModule } from "@/modules/users/users.module";
 import { Module } from "@nestjs/common";
 
 @Module({
-  imports: [PrismaModule, RedisModule, TokensModule, BillingModule, UsersModule],
+  imports: [PrismaModule, RedisModule, TokensModule, BillingModule, UsersModule, BookingSeatModule],
   providers: [
     TokensRepository,
     OAuthFlowService,
@@ -26,6 +28,7 @@ import { Module } from "@nestjs/common";
     OutputBookingsService_2024_08_13,
     BookingsRepository_2024_08_13,
     EventTypesRepository_2024_06_14,
+    BookingSeatRepository,
     ApiKeyRepository,
   ],
   controllers: [BookingsController_2024_08_13],

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

@@ -29,6 +29,25 @@ export class BookingsRepository_2024_08_13 {
     });
   }
 
+  async getByIdsWithAttendeesWithBookingSeatAndUserAndEvent(ids: number[]) {
+    return this.dbRead.prisma.booking.findMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+      include: {
+        attendees: {
+          include: {
+            bookingSeat: true,
+          },
+        },
+        user: true,
+        eventType: true,
+      },
+    });
+  }
+
   async getByUid(bookingUid: string) {
     return this.dbRead.prisma.booking.findUnique({
       where: {
@@ -37,6 +56,17 @@ export class BookingsRepository_2024_08_13 {
     });
   }
 
+  async getByUidWithUser(bookingUid: string) {
+    return this.dbRead.prisma.booking.findUnique({
+      where: {
+        uid: bookingUid,
+      },
+      include: {
+        user: true,
+      },
+    });
+  }
+
   async getByIdWithAttendeesAndUserAndEvent(id: number) {
     return this.dbRead.prisma.booking.findUnique({
       where: {
@@ -50,6 +80,23 @@ export class BookingsRepository_2024_08_13 {
     });
   }
 
+  async getByIdWithAttendeesWithBookingSeatAndUserAndEvent(id: number) {
+    return this.dbRead.prisma.booking.findUnique({
+      where: {
+        id,
+      },
+      include: {
+        attendees: {
+          include: {
+            bookingSeat: true,
+          },
+        },
+        user: true,
+        eventType: true,
+      },
+    });
+  }
+
   async getByUidWithAttendeesAndUserAndEvent(uid: string) {
     return this.dbRead.prisma.booking.findUnique({
       where: {
@@ -63,6 +110,31 @@ export class BookingsRepository_2024_08_13 {
     });
   }
 
+  async getByUidWithAttendeesWithBookingSeatAndUserAndEvent(uid: string) {
+    return this.dbRead.prisma.booking.findUnique({
+      where: {
+        uid,
+      },
+      include: {
+        attendees: {
+          include: {
+            bookingSeat: true,
+          },
+        },
+        user: true,
+        eventType: true,
+      },
+    });
+  }
+
+  async getRecurringByUid(uid: string) {
+    return this.dbRead.prisma.booking.findMany({
+      where: {
+        recurringEventId: uid,
+      },
+    });
+  }
+
   async getRecurringByUidWithAttendeesAndUserAndEvent(uid: string) {
     return this.dbRead.prisma.booking.findMany({
       where: {

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

@@ -2,6 +2,7 @@ import { BookingUidGuard } from "@/ee/bookings/2024-08-13/guards/booking-uid.gua
 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 { ReassignBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reassign-booking.output";
 import { RescheduleBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reschedule-booking.output";
 import { BookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/bookings.service";
 import { VERSION_2024_08_13_VALUE } from "@/lib/api-versions";
@@ -9,6 +10,7 @@ import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
 import { Permissions } from "@/modules/auth/decorators/permissions/permissions.decorator";
 import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
 import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { UserWithProfile } from "@/modules/users/users.repository";
 import {
   Controller,
   Post,
@@ -34,17 +36,24 @@ import { User } from "@prisma/client";
 import { Request } from "express";
 
 import { BOOKING_READ, BOOKING_WRITE, SUCCESS_STATUS } from "@calcom/platform-constants";
-import { GetBookingOutput_2024_08_13, GetBookingsOutput_2024_08_13 } from "@calcom/platform-types";
+import {
+  CancelBookingInput,
+  CancelBookingInputPipe,
+  GetBookingOutput_2024_08_13,
+  GetBookingsOutput_2024_08_13,
+  RescheduleBookingInput,
+  RescheduleBookingInputPipe,
+} from "@calcom/platform-types";
 import {
   CreateBookingInputPipe,
   CreateBookingInput,
   GetBookingsInput_2024_08_13,
-  RescheduleBookingInput_2024_08_13,
-  CancelBookingInput_2024_08_13,
+  ReassignToUserBookingInput_2024_08_13,
   MarkAbsentBookingInput_2024_08_13,
   CreateBookingInput_2024_08_13,
   CreateInstantBookingInput_2024_08_13,
   CreateRecurringBookingInput_2024_08_13,
+  DeclineBookingInput_2024_08_13,
 } from "@calcom/platform-types";
 
 @Controller({
@@ -59,7 +68,7 @@ import {
   required: true,
 })
 export class BookingsController_2024_08_13 {
-  private readonly logger = new Logger("BookingsController");
+  private readonly logger = new Logger("BookingsController_2024_08_13");
 
   constructor(private readonly bookingsService: BookingsService_2024_08_13) {}
 
@@ -166,7 +175,8 @@ export class BookingsController_2024_08_13 {
   })
   async rescheduleBooking(
     @Param("bookingUid") bookingUid: string,
-    @Body() body: RescheduleBookingInput_2024_08_13,
+    @Body(new RescheduleBookingInputPipe())
+    body: RescheduleBookingInput,
     @Req() request: Request
   ): Promise<RescheduleBookingOutput_2024_08_13> {
     const newBooking = await this.bookingsService.rescheduleBooking(request, bookingUid, body);
@@ -181,11 +191,17 @@ 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,
-    @Body() body: CancelBookingInput_2024_08_13
+    @Body(new CancelBookingInputPipe())
+    body: CancelBookingInput
   ): Promise<CancelBookingOutput_2024_08_13> {
     const cancelledBooking = await this.bookingsService.cancelBooking(request, bookingUid, body);
 
@@ -218,4 +234,104 @@ export class BookingsController_2024_08_13 {
       data: booking,
     };
   }
+
+  @Post("/:bookingUid/reassign")
+  @HttpCode(HttpStatus.OK)
+  @Permissions([BOOKING_WRITE])
+  @UseGuards(ApiAuthGuard, BookingUidGuard)
+  @ApiHeader({
+    name: "Authorization",
+    description:
+      "value must be `Bearer <token>` where `<token>` either managed user access token or api key prefixed with cal_",
+    required: true,
+  })
+  @ApiOperation({ summary: "Automatically reassign booking to a new host" })
+  async reassignBooking(
+    @Param("bookingUid") bookingUid: string,
+    @GetUser() user: UserWithProfile
+  ): Promise<ReassignBookingOutput_2024_08_13> {
+    const booking = await this.bookingsService.reassignBooking(bookingUid, user);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: booking,
+    };
+  }
+
+  @Post("/:bookingUid/reassign/:userId")
+  @HttpCode(HttpStatus.OK)
+  @Permissions([BOOKING_WRITE])
+  @UseGuards(ApiAuthGuard, BookingUidGuard)
+  @ApiHeader({
+    name: "Authorization",
+    description:
+      "value must be `Bearer <token>` where `<token>` either managed user access token or api key prefixed with cal_",
+    required: true,
+  })
+  @ApiOperation({ summary: "Reassign a booking to a specific user" })
+  async reassignBookingToUser(
+    @Param("bookingUid") bookingUid: string,
+    @Param("userId") userId: number,
+    @GetUser("id") reassignedById: number,
+    @Body() body: ReassignToUserBookingInput_2024_08_13
+  ): Promise<ReassignBookingOutput_2024_08_13> {
+    const booking = await this.bookingsService.reassignBookingToUser(
+      bookingUid,
+      userId,
+      reassignedById,
+      body
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: booking,
+    };
+  }
+
+  @Post("/:bookingUid/confirm")
+  @HttpCode(HttpStatus.OK)
+  @Permissions([BOOKING_WRITE])
+  @UseGuards(ApiAuthGuard, BookingUidGuard)
+  @ApiHeader({
+    name: "Authorization",
+    description:
+      "value must be `Bearer <token>` where `<token>` either managed user access token or api key prefixed with cal_",
+    required: true,
+  })
+  @ApiOperation({ summary: "Confirm booking that requires a confirmation" })
+  async confirmBooking(
+    @Param("bookingUid") bookingUid: string,
+    @GetUser() user: UserWithProfile
+  ): Promise<GetBookingOutput_2024_08_13> {
+    const booking = await this.bookingsService.confirmBooking(bookingUid, user);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: booking,
+    };
+  }
+
+  @Post("/:bookingUid/decline")
+  @HttpCode(HttpStatus.OK)
+  @Permissions([BOOKING_WRITE])
+  @UseGuards(ApiAuthGuard, BookingUidGuard)
+  @ApiHeader({
+    name: "Authorization",
+    description:
+      "value must be `Bearer <token>` where `<token>` either managed user access token or api key prefixed with cal_",
+    required: true,
+  })
+  @ApiOperation({ summary: "Decline booking that requires a confirmation" })
+  async declineBooking(
+    @Param("bookingUid") bookingUid: string,
+    @Body() body: DeclineBookingInput_2024_08_13,
+    @GetUser() user: UserWithProfile
+  ): Promise<GetBookingOutput_2024_08_13> {
+    const booking = await this.bookingsService.declineBooking(bookingUid, user, body.reason);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: booking,
+    };
+  }
 }

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

@@ -0,0 +1,262 @@
+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 {
+  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;
+    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;
+
+    let eventTypeId: number;
+    const eventTypeSlug = "peer-coding";
+
+    let createdBooking1: Booking;
+    let createdBooking2: Booking;
+
+    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 event = await eventTypesRepositoryFixture.create(
+        { title: "peer coding", slug: eventTypeSlug, length: 60 },
+        user.id
+      );
+      eventTypeId = event.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 be defined", () => {
+      expect(userRepositoryFixture).toBeDefined();
+      expect(user).toBeDefined();
+    });
+
+    it("should confirm a booking", async () => {
+      const status = "PENDING";
+      createdBooking1 = await bookingsRepositoryFixture.create({
+        user: {
+          connect: {
+            id: user.id,
+          },
+        },
+        startTime: new Date(Date.UTC(2050, 0, 7, 13, 0, 0)),
+        endTime: new Date(Date.UTC(2050, 0, 7, 14, 0, 0)),
+        title: "peer coding",
+        uid: "peer-coding-one",
+        eventType: {
+          connect: {
+            id: eventTypeId,
+          },
+        },
+        location: "via 10, rome, italy",
+        customInputs: {},
+        metadata: {},
+        responses: {
+          name: "Bob",
+          email: "bob@gmail.com",
+        },
+        attendees: {
+          create: {
+            email: "bob@gmail.com",
+            name: "Bob",
+            locale: "it",
+            timeZone: "Europe/Rome",
+          },
+        },
+        status,
+      });
+      expect(createdBooking1.status).toEqual("PENDING");
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${createdBooking1.uid}/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(responseDataIsBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsBooking(responseBody.data)) {
+            const data: BookingOutput_2024_08_13 = responseBody.data;
+            expect(data.uid).toBeDefined();
+            expect(data.status).toEqual("accepted");
+
+            const dbBooking = await bookingsRepositoryFixture.getByUid(data.uid);
+            expect(dbBooking?.status).toEqual("ACCEPTED");
+          } else {
+            throw new Error(
+              "Invalid response data - expected booking but received array of possibily recurring bookings"
+            );
+          }
+        });
+    });
+
+    it("should decline a booking", async () => {
+      const status = "PENDING";
+      createdBooking2 = await bookingsRepositoryFixture.create({
+        user: {
+          connect: {
+            id: user.id,
+          },
+        },
+        startTime: new Date(Date.UTC(2050, 0, 7, 10, 0, 0)),
+        endTime: new Date(Date.UTC(2050, 0, 7, 11, 0, 0)),
+        title: "peer coding",
+        uid: "peer-coding-two",
+        eventType: {
+          connect: {
+            id: eventTypeId,
+          },
+        },
+        location: "via 10, rome, italy",
+        customInputs: {},
+        metadata: {},
+        responses: {
+          name: "Bob",
+          email: "bob@gmail.com",
+        },
+        attendees: {
+          create: {
+            email: "bob@gmail.com",
+            name: "Bob",
+            locale: "it",
+            timeZone: "Europe/Rome",
+          },
+        },
+        status,
+      });
+      expect(createdBooking2.status).toEqual("PENDING");
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${createdBooking2.uid}/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(responseDataIsBooking(responseBody.data)).toBe(true);
+
+          if (responseDataIsBooking(responseBody.data)) {
+            const data: BookingOutput_2024_08_13 = responseBody.data;
+            expect(data.uid).toBeDefined();
+            expect(data.status).toEqual("rejected");
+
+            const dbBooking = await bookingsRepositoryFixture.getByUid(data.uid);
+            expect(dbBooking?.status).toEqual("REJECTED");
+          } 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/reassign-bookings.e2e-spec.ts

@@ -0,0 +1,331 @@
+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";
+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 { Booking, 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 { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.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 { 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", () => {
+  describe("Reassign bookings", () => {
+    let app: INestApplication;
+    let organization: Team;
+    let team: 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;
+    let membershipsRepositoryFixture: MembershipRepositoryFixture;
+    let hostsRepositoryFixture: HostsRepositoryFixture;
+    let organizationsRepositoryFixture: OrganizationRepositoryFixture;
+    let profileRepositoryFixture: ProfileRepositoryFixture;
+
+    const teamUserEmail = "orgUser1team1@api.com";
+    const teamUserEmail2 = "orgUser2team1@api.com";
+    let teamUser1: User;
+    let teamUser2: User;
+
+    let teamRoundRobinEventTypeId: number;
+
+    let roundRobinBooking: Booking;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        teamUserEmail,
+        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);
+      organizationsRepositoryFixture = new OrganizationRepositoryFixture(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 organizationsRepositoryFixture.create({ name: "organization team bookings" });
+      team = await teamRepositoryFixture.create({
+        name: "team 1",
+        isOrganization: false,
+        parent: { connect: { id: organization.id } },
+      });
+
+      oAuthClient = await createOAuthClient(organization.id);
+
+      teamUser1 = await userRepositoryFixture.create({
+        email: teamUserEmail,
+        locale: "it",
+        name: "orgUser1team1",
+      });
+
+      teamUser2 = await userRepositoryFixture.create({
+        email: teamUserEmail2,
+        locale: "it",
+        name: "orgUser2team1",
+      });
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(teamUser1.id, userSchedule);
+      await schedulesService.createUserSchedule(teamUser2.id, userSchedule);
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${teamUser1.id}`,
+        username: teamUserEmail,
+        organization: {
+          connect: {
+            id: organization.id,
+          },
+        },
+        user: {
+          connect: {
+            id: teamUser1.id,
+          },
+        },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${teamUser2.id}`,
+        username: teamUserEmail2,
+        organization: {
+          connect: {
+            id: organization.id,
+          },
+        },
+        user: {
+          connect: {
+            id: teamUser2.id,
+          },
+        },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        team: { connect: { id: team.id } },
+        user: { connect: { id: teamUser1.id } },
+        accepted: true,
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        team: { connect: { id: team.id } },
+        user: { connect: { id: teamUser2.id } },
+        accepted: true,
+      });
+
+      const team1EventType = await eventTypesRepositoryFixture.createTeamEventType({
+        schedulingType: "ROUND_ROBIN",
+        team: {
+          connect: { id: team.id },
+        },
+        users: {
+          connect: [{ id: teamUser1.id }, { id: teamUser2.id }],
+        },
+        title: "Round Robin Event Type",
+        slug: "round-robin-event-type",
+        length: 60,
+        assignAllTeamMembers: false,
+        bookingFields: [],
+        locations: [{ type: "inPerson", address: "via 10, rome, italy" }],
+      });
+
+      teamRoundRobinEventTypeId = team1EventType.id;
+
+      await hostsRepositoryFixture.create({
+        isFixed: false,
+        user: {
+          connect: {
+            id: teamUser1.id,
+          },
+        },
+        eventType: {
+          connect: {
+            id: team1EventType.id,
+          },
+        },
+      });
+
+      await hostsRepositoryFixture.create({
+        isFixed: false,
+        user: {
+          connect: {
+            id: teamUser2.id,
+          },
+        },
+        eventType: {
+          connect: {
+            id: team1EventType.id,
+          },
+        },
+      });
+
+      roundRobinBooking = await bookingsRepositoryFixture.create({
+        user: {
+          connect: {
+            id: teamUser1.id,
+          },
+        },
+        startTime: new Date(Date.UTC(2050, 0, 7, 13, 0, 0)),
+        endTime: new Date(Date.UTC(2050, 0, 7, 14, 0, 0)),
+        title: "round robin coding lets goo",
+        uid: "round-robin-coding",
+        eventType: {
+          connect: {
+            id: teamRoundRobinEventTypeId,
+          },
+        },
+        location: "via 10, rome, italy",
+        customInputs: {},
+        metadata: {},
+        responses: {
+          name: "Bob",
+          email: "bob@gmail.com",
+        },
+        attendees: {
+          create: {
+            email: "bob@gmail.com",
+            name: "Bob",
+            locale: "it",
+            timeZone: "Europe/Rome",
+          },
+        },
+      });
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    it("should reassign round robin booking", async () => {
+      const booking = await bookingsRepositoryFixture.getByUid(roundRobinBooking.uid);
+      expect(booking?.userId).toEqual(teamUser1.id);
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${roundRobinBooking.uid}/reassign`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: ReassignBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+
+          const data: ReassignBookingOutput_2024_08_13["data"] = responseBody.data;
+          expect(data.bookingUid).toEqual(roundRobinBooking.uid);
+          expect(data.reassignedTo).toEqual({
+            id: teamUser2.id,
+            name: teamUser2.name,
+            email: teamUser2.email,
+          });
+
+          const reassigned = await bookingsRepositoryFixture.getByUid(roundRobinBooking.uid);
+          expect(reassigned?.userId).toEqual(teamUser2.id);
+        });
+    });
+
+    it("should reassign round robin booking to a specific user", async () => {
+      const booking = await bookingsRepositoryFixture.getByUid(roundRobinBooking.uid);
+      expect(booking?.userId).toEqual(teamUser2.id);
+
+      const body: CreateBookingInput_2024_08_13 = {
+        start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+        eventTypeId: teamRoundRobinEventTypeId,
+        attendee: {
+          name: "alice",
+          email: "alice@gmail.com",
+          timeZone: "Europe/Madrid",
+          language: "es",
+        },
+        meetingUrl: "https://meet.google.com/abc-def-ghi",
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/bookings/${roundRobinBooking.uid}/reassign/${teamUser1.id}`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: ReassignBookingOutput_2024_08_13 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data).toBeDefined();
+
+          const data: ReassignBookingOutput_2024_08_13["data"] = responseBody.data;
+          expect(data.bookingUid).toEqual(roundRobinBooking.uid);
+          expect(data.reassignedTo).toEqual({
+            id: teamUser1.id,
+            name: teamUser1.name,
+            email: teamUser1.email,
+          });
+
+          const reassigned = await bookingsRepositoryFixture.getByUid(roundRobinBooking.uid);
+          expect(reassigned?.userId).toEqual(teamUser1.id);
+        });
+    });
+
+    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;
+    }
+
+    function responseDataIsBooking(data: any): data is BookingOutput_2024_08_13 {
+      return !Array.isArray(data) && typeof data === "object" && data && "id" in data;
+    }
+
+    afterAll(async () => {
+      await oauthClientRepositoryFixture.delete(oAuthClient.id);
+      await teamRepositoryFixture.delete(organization.id);
+      await userRepositoryFixture.deleteByEmail(teamUser1.email);
+      await userRepositoryFixture.deleteByEmail(teamUserEmail2);
+      await bookingsRepositoryFixture.deleteAllBookings(teamUser1.id, teamUser1.email);
+      await bookingsRepositoryFixture.deleteAllBookings(teamUser2.id, teamUser2.email);
+      await app.close();
+    });
+  });
+});

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

@@ -0,0 +1,691 @@
+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,
+      });
+
+      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,
+      });
+
+      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,
+      });
+
+      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/team-bookings.controller.e2e-spec.ts

@@ -29,6 +29,7 @@ import {
   BookingOutput_2024_08_13,
   RecurringBookingOutput_2024_08_13,
   GetBookingsOutput_2024_08_13,
+  GetSeatedBookingOutput_2024_08_13,
 } from "@calcom/platform-types";
 import { PlatformOAuthClient, Team } from "@calcom/prisma/client";
 
@@ -369,7 +370,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(1);
             expect(data[0].eventTypeId).toEqual(team1EventTypeId);
           });
@@ -384,7 +389,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(1);
             expect(data[0].eventTypeId).toEqual(team2EventTypeId);
           });
@@ -399,7 +408,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(2);
             expect(data.find((booking) => booking.eventTypeId === team1EventTypeId)).toBeDefined();
             expect(data.find((booking) => booking.eventTypeId === team2EventTypeId)).toBeDefined();
@@ -428,6 +441,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
       await oauthClientRepositoryFixture.delete(oAuthClient.id);
       await teamRepositoryFixture.delete(organization.id);
       await userRepositoryFixture.deleteByEmail(teamUser.email);
+      await userRepositoryFixture.deleteByEmail(teamUserEmail2);
       await bookingsRepositoryFixture.deleteAllBookings(teamUser.id, teamUser.email);
       await app.close();
     });

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

@@ -28,7 +28,11 @@ import {
   VERSION_2024_08_13,
   X_CAL_CLIENT_ID,
 } from "@calcom/platform-constants";
-import { GetBookingOutput_2024_08_13, GetBookingsOutput_2024_08_13 } from "@calcom/platform-types";
+import {
+  GetBookingOutput_2024_08_13,
+  GetBookingsOutput_2024_08_13,
+  GetSeatedBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
 import {
   CreateBookingInput_2024_08_13,
   BookingOutput_2024_08_13,
@@ -478,7 +482,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(5);
           });
       });
@@ -492,7 +500,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(3);
           });
       });
@@ -506,7 +518,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(3);
           });
       });
@@ -520,7 +536,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(4);
           });
       });
@@ -534,7 +554,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(1);
           });
       });
@@ -548,7 +572,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(5);
           });
       });
@@ -562,7 +590,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(3);
           });
       });
@@ -576,7 +608,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(1);
           });
       });
@@ -590,7 +626,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(3);
           });
       });
@@ -604,7 +644,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(2);
           });
       });
@@ -618,7 +662,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(5);
           });
       });
@@ -632,7 +680,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(2);
           });
       });
@@ -646,7 +698,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(3);
           });
       });
@@ -660,9 +716,12 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(2);
-            console.log("asap data", JSON.stringify(data, null, 2));
             expect(data[0].start).toEqual(createdBooking.start);
             expect(data[1].start).toEqual(bookingInThePast.startTime.toISOString());
           });
@@ -677,7 +736,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(2);
             expect(data[0].start).toEqual(bookingInThePast.startTime.toISOString());
             expect(data[1].start).toEqual(createdBooking.start);
@@ -693,7 +756,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(2);
             expect(data[0].start).toEqual(createdBooking.start);
             expect(data[1].start).toEqual(bookingInThePast.startTime.toISOString());
@@ -709,7 +776,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(2);
             expect(data[0].start).toEqual(bookingInThePast.startTime.toISOString());
             expect(data[1].start).toEqual(createdBooking.start);
@@ -725,7 +796,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(2);
             expect(data[0].start).toEqual(createdBooking.start);
             expect(data[1].start).toEqual(bookingInThePast.startTime.toISOString());
@@ -741,7 +816,11 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: GetBookingsOutput_2024_08_13 = response.body;
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
-            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
             expect(data.length).toEqual(2);
             expect(data[0].start).toEqual(bookingInThePast.startTime.toISOString());
             expect(data[1].start).toEqual(createdBooking.start);
@@ -765,6 +844,8 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: RescheduleBookingOutput_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.reschedulingReason).toEqual(body.reschedulingReason);
             expect(data.start).toEqual(body.start);
@@ -793,6 +874,8 @@ describe("Bookings Endpoints 2024-08-13", () => {
             const responseBody: RescheduleBookingOutput_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.status).toEqual("cancelled");
 
@@ -1044,293 +1127,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/variable-length-bookings.controller.e2e-spec.ts

@@ -0,0 +1,251 @@
+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";
+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 { EventType, 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 { 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", () => {
+  describe("User 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;
+
+    let variableLengthEventType: EventType;
+    const variableLengthEventTypeSlug = "variable-length-event";
+    let normalEventType: EventType;
+
+    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);
+
+      variableLengthEventType = await eventTypesRepositoryFixture.create(
+        {
+          title: "variable length event",
+          slug: variableLengthEventTypeSlug,
+          length: 15,
+          metadata: { multipleDuration: [15, 30, 60] },
+        },
+        user.id
+      );
+
+      normalEventType = await eventTypesRepositoryFixture.create(
+        { title: "normal event", slug: "normal-event", length: 15 },
+        user.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 be defined", () => {
+      expect(userRepositoryFixture).toBeDefined();
+      expect(user).toBeDefined();
+    });
+
+    describe("create bookings", () => {
+      it("should not be able to specify length of booking for non variable length event type", async () => {
+        const lengthInMinutes = 30;
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 10, 0, 0)).toISOString(),
+          eventTypeId: normalEventType.id,
+          lengthInMinutes,
+          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",
+          },
+        };
+
+        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 with default length", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 10, 0, 0)).toISOString(),
+          eventTypeId: variableLengthEventType.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",
+          },
+        };
+
+        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.id).toBeDefined();
+              expect(data.uid).toBeDefined();
+              expect(data.status).toEqual("accepted");
+              expect(data.start).toEqual(body.start);
+              expect(data.end).toEqual(
+                new Date(Date.UTC(2030, 0, 8, 10, variableLengthEventType.length, 0)).toISOString()
+              );
+              expect(data.duration).toEqual(variableLengthEventType.length);
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+
+      it("should create a booking with specified length that is not default length", async () => {
+        const lengthInMinutes = 30;
+        const body: CreateBookingInput_2024_08_13 = {
+          lengthInMinutes,
+          start: new Date(Date.UTC(2030, 0, 8, 11, 0, 0)).toISOString(),
+          eventTypeId: variableLengthEventType.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",
+          },
+        };
+
+        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.id).toBeDefined();
+              expect(data.uid).toBeDefined();
+              expect(data.status).toEqual("accepted");
+              expect(data.start).toEqual(body.start);
+              expect(data.end).toEqual(new Date(Date.UTC(2030, 0, 8, 11, lengthInMinutes, 0)).toISOString());
+              expect(data.duration).toEqual(lengthInMinutes);
+            } 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/outputs/cancel-booking.output.ts

@@ -3,7 +3,12 @@ import { Type } from "class-transformer";
 import { IsEnum, ValidateNested } from "class-validator";
 
 import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
-import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+import {
+  BookingOutput_2024_08_13,
+  GetRecurringSeatedBookingOutput_2024_08_13,
+  GetSeatedBookingOutput_2024_08_13,
+  RecurringBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
 
 @ApiExtraModels(BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13)
 export class CancelBookingOutput_2024_08_13 {
@@ -17,10 +22,19 @@ export class CancelBookingOutput_2024_08_13 {
       { $ref: getSchemaPath(BookingOutput_2024_08_13) },
       { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) },
       { type: "array", items: { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) } },
+      { $ref: getSchemaPath(GetSeatedBookingOutput_2024_08_13) },
+      { $ref: getSchemaPath(GetRecurringSeatedBookingOutput_2024_08_13) },
+      { type: "array", items: { $ref: getSchemaPath(GetRecurringSeatedBookingOutput_2024_08_13) } },
     ],
     description:
       "Booking data, which can be either a BookingOutput object, a RecurringBookingOutput object, or an array of RecurringBookingOutput objects",
   })
   @Type(() => Object)
-  data!: BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13[];
+  data!:
+    | BookingOutput_2024_08_13
+    | RecurringBookingOutput_2024_08_13
+    | RecurringBookingOutput_2024_08_13[]
+    | GetSeatedBookingOutput_2024_08_13
+    | GetRecurringSeatedBookingOutput_2024_08_13
+    | GetRecurringSeatedBookingOutput_2024_08_13[];
 }

apps/api/v2/src/ee/bookings/2024-08-13/outputs/create-booking.output.ts

@@ -3,7 +3,12 @@ import { Type } from "class-transformer";
 import { IsEnum, ValidateNested } from "class-validator";
 
 import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
-import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+import {
+  BookingOutput_2024_08_13,
+  RecurringBookingOutput_2024_08_13,
+  CreateSeatedBookingOutput_2024_08_13,
+  CreateRecurringSeatedBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
 
 @ApiExtraModels(BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13)
 export class CreateBookingOutput_2024_08_13 {
@@ -21,5 +26,9 @@ export class CreateBookingOutput_2024_08_13 {
       "Booking data, which can be either a BookingOutput object or an array of RecurringBookingOutput objects",
   })
   @Type(() => Object)
-  data!: BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13[];
+  data!:
+    | BookingOutput_2024_08_13
+    | RecurringBookingOutput_2024_08_13[]
+    | CreateSeatedBookingOutput_2024_08_13
+    | CreateRecurringSeatedBookingOutput_2024_08_13[];
 }

apps/api/v2/src/ee/bookings/2024-08-13/outputs/reassign-booking.output.ts

@@ -0,0 +1,21 @@
+import { ApiProperty, getSchemaPath } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsEnum, ValidateNested } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { ReassignBookingOutput_2024_08_13 as ReassignBookingOutputData_2024_08_13 } from "@calcom/platform-types";
+
+export class ReassignBookingOutput_2024_08_13 {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ApiProperty({
+    oneOf: [{ $ref: getSchemaPath(ReassignBookingOutputData_2024_08_13) }],
+    description:
+      "Booking data, which can be either a ReassignAutoBookingOutput object or a ReassignManualBookingOutput object",
+  })
+  @ValidateNested()
+  @Type(() => Object)
+  data!: ReassignBookingOutputData_2024_08_13;
+}

apps/api/v2/src/ee/bookings/2024-08-13/outputs/reschedule-booking.output.ts

@@ -3,7 +3,14 @@ import { Type } from "class-transformer";
 import { IsEnum, ValidateNested } from "class-validator";
 
 import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
-import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+import {
+  BookingOutput_2024_08_13,
+  CreateRecurringSeatedBookingOutput_2024_08_13,
+  CreateSeatedBookingOutput_2024_08_13,
+  GetRecurringSeatedBookingOutput_2024_08_13,
+  GetSeatedBookingOutput_2024_08_13,
+  RecurringBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
 
 @ApiExtraModels(BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13)
 export class RescheduleBookingOutput_2024_08_13 {
@@ -15,11 +22,17 @@ export class RescheduleBookingOutput_2024_08_13 {
     oneOf: [
       { $ref: getSchemaPath(BookingOutput_2024_08_13) },
       { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) },
+      { $ref: getSchemaPath(CreateSeatedBookingOutput_2024_08_13) },
+      { $ref: getSchemaPath(CreateRecurringSeatedBookingOutput_2024_08_13) },
     ],
     description:
       "Booking data, which can be either a BookingOutput object or a RecurringBookingOutput object",
   })
   @ValidateNested()
   @Type(() => Object)
-  data!: BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13;
+  data!:
+    | BookingOutput_2024_08_13
+    | RecurringBookingOutput_2024_08_13
+    | CreateSeatedBookingOutput_2024_08_13
+    | CreateRecurringSeatedBookingOutput_2024_08_13;
 }

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

@@ -3,7 +3,10 @@ import { InputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/servic
 import { OutputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/output.service";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
 import { BillingService } from "@/modules/billing/services/billing.service";
+import { BookingSeatRepository } from "@/modules/booking-seat/booking-seat.repository";
 import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { UsersService } from "@/modules/users/services/users.service";
+import { UsersRepository, UserWithProfile } from "@/modules/users/users.repository";
 import { Injectable, Logger, NotFoundException } from "@nestjs/common";
 import { BadRequestException } from "@nestjs/common";
 import { Request } from "express";
@@ -14,19 +17,25 @@ import {
   getAllUserBookings,
   handleInstantMeeting,
   handleCancelBooking,
+  roundRobinReassignment,
+  roundRobinManualReassignment,
   handleMarkNoShow,
+  confirmBookingHandler,
 } from "@calcom/platform-libraries";
 import {
   CreateBookingInput_2024_08_13,
-  RescheduleBookingInput_2024_08_13,
   CreateBookingInput,
   CreateRecurringBookingInput_2024_08_13,
   GetBookingsInput_2024_08_13,
   CreateInstantBookingInput_2024_08_13,
-  CancelBookingInput_2024_08_13,
   MarkAbsentBookingInput_2024_08_13,
+  ReassignToUserBookingInput_2024_08_13,
   BookingOutput_2024_08_13,
   RecurringBookingOutput_2024_08_13,
+  GetSeatedBookingOutput_2024_08_13,
+  GetRecurringSeatedBookingOutput_2024_08_13,
+  RescheduleBookingInput,
+  CancelBookingInput,
 } from "@calcom/platform-types";
 import { PrismaClient } from "@calcom/prisma";
 
@@ -43,9 +52,12 @@ export class BookingsService_2024_08_13 {
     private readonly inputService: InputBookingsService_2024_08_13,
     private readonly outputService: OutputBookingsService_2024_08_13,
     private readonly bookingsRepository: BookingsRepository_2024_08_13,
+    private readonly bookingSeatRepository: BookingSeatRepository,
     private readonly eventTypesRepository: EventTypesRepository_2024_06_14,
     private readonly prismaReadService: PrismaReadService,
-    private readonly billingService: BillingService
+    private readonly billingService: BillingService,
+    private readonly usersService: UsersService,
+    private readonly usersRepository: UsersRepository
   ) {}
 
   async createBooking(request: Request, body: CreateBookingInput) {
@@ -54,9 +66,19 @@ export class BookingsService_2024_08_13 {
         return await this.createInstantBooking(request, body);
       }
 
-      if (await this.isRecurring(body)) {
+      const eventType = await this.eventTypesRepository.getEventTypeById(body.eventTypeId);
+      const isRecurring = !!eventType?.recurringEvent;
+      const isSeated = !!eventType?.seatsPerTimeSlot;
+
+      if (isRecurring && isSeated) {
+        return await this.createRecurringSeatedBooking(request, body);
+      }
+      if (isRecurring && !isSeated) {
         return await this.createRecurringBooking(request, body);
       }
+      if (isSeated) {
+        return await this.createSeatedBooking(request, body);
+      }
 
       return await this.createRegularBooking(request, body);
     } catch (error) {
@@ -83,47 +105,71 @@ export class BookingsService_2024_08_13 {
     return this.outputService.getOutputBooking(databaseBooking);
   }
 
-  async isRecurring(body: CreateBookingInput) {
-    const eventType = await this.eventTypesRepository.getEventTypeById(body.eventTypeId);
-    return !!eventType?.recurringEvent;
-  }
-
   async createRecurringBooking(request: Request, body: CreateRecurringBookingInput_2024_08_13) {
     const bookingRequest = await this.inputService.createRecurringBookingRequest(request, body);
     const bookings = await handleNewRecurringBooking(bookingRequest);
-    const uid = bookings[0].recurringEventId;
-    if (!uid) {
-      throw new Error("Recurring booking was not created");
-    }
+    const ids = bookings.map((booking) => booking.id || 0);
+    return this.outputService.getOutputRecurringBookings(ids);
+  }
 
-    const recurringBooking = await this.bookingsRepository.getRecurringByUidWithAttendeesAndUserAndEvent(uid);
-    return this.outputService.getOutputRecurringBookings(recurringBooking);
+  async createRecurringSeatedBooking(request: Request, body: CreateRecurringBookingInput_2024_08_13) {
+    const bookingRequest = await this.inputService.createRecurringBookingRequest(request, body);
+    const bookings = await handleNewRecurringBooking(bookingRequest);
+    return this.outputService.getOutputCreateRecurringSeatedBookings(
+      bookings.map((booking) => ({ uid: booking.uid || "", seatUid: booking.seatReferenceUid || "" }))
+    );
   }
 
   async createRegularBooking(request: Request, body: CreateBookingInput_2024_08_13) {
     const bookingRequest = await this.inputService.createBookingRequest(request, body);
     const booking = await handleNewBooking(bookingRequest);
 
-    if (!booking.id) {
-      throw new Error("Booking was not created");
+    if (!booking.uid) {
+      throw new Error("Booking missing uid");
     }
 
-    const databaseBooking = await this.bookingsRepository.getByIdWithAttendeesAndUserAndEvent(booking.id);
+    const databaseBooking = await this.bookingsRepository.getByUidWithAttendeesAndUserAndEvent(booking.uid);
     if (!databaseBooking) {
-      throw new Error(`Booking with id=${booking.id} was not found in the database`);
+      throw new Error(`Booking with uid=${booking.uid} was not found in the database`);
     }
 
     return this.outputService.getOutputBooking(databaseBooking);
   }
 
+  async createSeatedBooking(request: Request, body: CreateBookingInput_2024_08_13) {
+    const bookingRequest = await this.inputService.createBookingRequest(request, body);
+    const booking = await handleNewBooking(bookingRequest);
+
+    if (!booking.uid) {
+      throw new Error("Booking missing uid");
+    }
+
+    const databaseBooking = await this.bookingsRepository.getByUidWithAttendeesWithBookingSeatAndUserAndEvent(
+      booking.uid
+    );
+    if (!databaseBooking) {
+      throw new Error(`Booking with uid=${booking.uid} was not found in the database`);
+    }
+
+    return this.outputService.getOutputCreateSeatedBooking(databaseBooking, booking.seatReferenceUid || "");
+  }
+
   async getBooking(uid: string) {
-    const booking = await this.bookingsRepository.getByUidWithAttendeesAndUserAndEvent(uid);
+    const booking = await this.bookingsRepository.getByUidWithAttendeesWithBookingSeatAndUserAndEvent(uid);
 
     if (booking) {
       const isRecurring = !!booking.recurringEventId;
-      if (isRecurring) {
+      const isSeated = !!booking.eventType?.seatsPerTimeSlot;
+
+      if (isRecurring && !isSeated) {
         return this.outputService.getOutputRecurringBooking(booking);
       }
+      if (isRecurring && isSeated) {
+        return this.outputService.getOutputRecurringSeatedBooking(booking);
+      }
+      if (isSeated) {
+        return this.outputService.getOutputSeatedBooking(booking);
+      }
       return this.outputService.getOutputBooking(booking);
     }
 
@@ -131,8 +177,13 @@ export class BookingsService_2024_08_13 {
     if (!recurringBooking.length) {
       throw new NotFoundException(`Booking with uid=${uid} was not found in the database`);
     }
+    const ids = recurringBooking.map((booking) => booking.id);
+    const isRecurringSeated = !!recurringBooking[0].eventType?.seatsPerTimeSlot;
+    if (isRecurringSeated) {
+      return this.outputService.getOutputRecurringSeatedBookings(ids);
+    }
 
-    return this.outputService.getOutputRecurringBookings(recurringBooking);
+    return this.outputService.getOutputRecurringBookings(ids);
   }
 
   async getBookings(queryParams: GetBookingsInput_2024_08_13, user: { email: string; id: number }) {
@@ -151,12 +202,17 @@ export class BookingsService_2024_08_13 {
     // note(Lauris): fetchedBookings don't have attendees information and responses and i don't want to add them to the handler query,
     // because its used elsewhere in code that does not need that information, so i get ids, fetch bookings and then return them formatted in same order as ids.
     const ids = fetchedBookings.bookings.map((booking) => booking.id);
-    const bookings = await this.bookingsRepository.getByIdsWithAttendeesAndUserAndEvent(ids);
+    const bookings = await this.bookingsRepository.getByIdsWithAttendeesWithBookingSeatAndUserAndEvent(ids);
 
     const bookingMap = new Map(bookings.map((booking) => [booking.id, booking]));
     const orderedBookings = ids.map((id) => bookingMap.get(id));
 
-    const formattedBookings: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = [];
+    const formattedBookings: (
+      | BookingOutput_2024_08_13
+      | RecurringBookingOutput_2024_08_13
+      | GetSeatedBookingOutput_2024_08_13
+      | GetRecurringSeatedBookingOutput_2024_08_13
+    )[] = [];
     for (const booking of orderedBookings) {
       if (!booking) {
         continue;
@@ -172,8 +228,13 @@ export class BookingsService_2024_08_13 {
       };
 
       const isRecurring = !!formatted.recurringEventId;
-      if (isRecurring) {
+      const isSeated = !!formatted.eventType?.seatsPerTimeSlot;
+      if (isRecurring && !isSeated) {
         formattedBookings.push(this.outputService.getOutputRecurringBooking(formatted));
+      } else if (isRecurring && isSeated) {
+        formattedBookings.push(this.outputService.getOutputRecurringSeatedBooking(formatted));
+      } else if (isSeated) {
+        formattedBookings.push(this.outputService.getOutputSeatedBooking(formatted));
       } else {
         formattedBookings.push(this.outputService.getOutputBooking(formatted));
       }
@@ -182,7 +243,7 @@ export class BookingsService_2024_08_13 {
     return formattedBookings;
   }
 
-  async rescheduleBooking(request: Request, bookingUid: string, body: RescheduleBookingInput_2024_08_13) {
+  async rescheduleBooking(request: Request, bookingUid: string, body: RescheduleBookingInput) {
     try {
       const bookingRequest = await this.inputService.createRescheduleBookingRequest(
         request,
@@ -190,18 +251,34 @@ export class BookingsService_2024_08_13 {
         body
       );
       const booking = await handleNewBooking(bookingRequest);
-      if (!booking.id) {
-        throw new Error("Booking was not created");
+      if (!booking.uid) {
+        throw new Error("Booking missing uid");
       }
 
-      const databaseBooking = await this.bookingsRepository.getByIdWithAttendeesAndUserAndEvent(booking.id);
+      const databaseBooking =
+        await this.bookingsRepository.getByUidWithAttendeesWithBookingSeatAndUserAndEvent(booking.uid);
       if (!databaseBooking) {
-        throw new Error(`Booking with id=${booking.id} was not found in the database`);
+        throw new Error(`Booking with uid=${booking.uid} was not found in the database`);
       }
 
-      if (databaseBooking.recurringEventId) {
+      const isRecurring = !!databaseBooking.recurringEventId;
+      const isSeated = !!databaseBooking.eventType?.seatsPerTimeSlot;
+
+      if (isRecurring && !isSeated) {
         return this.outputService.getOutputRecurringBooking(databaseBooking);
       }
+      if (isRecurring && isSeated) {
+        return this.outputService.getOutputCreateRecurringSeatedBooking(
+          databaseBooking,
+          booking?.seatReferenceUid || ""
+        );
+      }
+      if (isSeated) {
+        return this.outputService.getOutputCreateSeatedBooking(
+          databaseBooking,
+          booking.seatReferenceUid || ""
+        );
+      }
       return this.outputService.getOutputBooking(databaseBooking);
     } catch (error) {
       if (error instanceof Error) {
@@ -213,12 +290,43 @@ export class BookingsService_2024_08_13 {
     }
   }
 
-  async cancelBooking(request: Request, bookingUid: string, body: CancelBookingInput_2024_08_13) {
+  async cancelBooking(request: Request, bookingUid: string, body: CancelBookingInput) {
+    if (this.inputService.isCancelSeatedBody(body)) {
+      const seat = await this.bookingSeatRepository.getByReferenceUid(body.seatUid);
+
+      if (!seat) {
+        throw new BadRequestException(
+          "Invalid seatUid: this seat does not exist or has already been cancelled."
+        );
+      }
+
+      if (seat && bookingUid !== seat.booking.uid) {
+        throw new BadRequestException("Invalid seatUid: this seat does not belong to this booking.");
+      }
+    }
+
     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);
 
@@ -249,7 +357,7 @@ export class BookingsService_2024_08_13 {
   }
 
   async billBooking(booking: CreatedBooking) {
-    const hostId = booking.hosts[0].id;
+    const hostId = booking.hosts?.[0]?.id;
     if (!hostId) {
       this.logger.error(`Booking with uid=${booking.uid} has no host`);
       return;
@@ -274,4 +382,95 @@ export class BookingsService_2024_08_13 {
       fromReschedule: oldBookingUid,
     });
   }
+
+  async reassignBooking(bookingUid: string, requestUser: UserWithProfile) {
+    const booking = await this.bookingsRepository.getByUid(bookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    const profile = this.usersService.getUserMainProfile(requestUser);
+
+    await roundRobinReassignment({
+      bookingId: booking.id,
+      orgId: profile?.organizationId || null,
+    });
+
+    const reassigned = await this.bookingsRepository.getByUidWithUser(bookingUid);
+    if (!reassigned) {
+      throw new NotFoundException(`Reassigned booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    return this.outputService.getOutputReassignedBooking(reassigned);
+  }
+
+  async reassignBookingToUser(
+    bookingUid: string,
+    newUserId: number,
+    reassignedById: number,
+    body: ReassignToUserBookingInput_2024_08_13
+  ) {
+    const booking = await this.bookingsRepository.getByUid(bookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    const user = await this.usersRepository.findByIdWithProfile(newUserId);
+    if (!user) {
+      throw new NotFoundException(`User with id=${newUserId} was not found in the database`);
+    }
+
+    const profile = this.usersService.getUserMainProfile(user);
+
+    const reassigned = await roundRobinManualReassignment({
+      bookingId: booking.id,
+      newUserId,
+      orgId: profile?.organizationId || null,
+      reassignReason: body.reason,
+      reassignedById,
+    });
+
+    return this.outputService.getOutputReassignedBooking(reassigned);
+  }
+
+  async confirmBooking(bookingUid: string, requestUser: UserWithProfile) {
+    const booking = await this.bookingsRepository.getByUid(bookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    await confirmBookingHandler({
+      ctx: {
+        user: requestUser,
+      },
+      input: {
+        bookingId: booking.id,
+        confirmed: true,
+        recurringEventId: booking.recurringEventId,
+      },
+    });
+
+    return this.getBooking(bookingUid);
+  }
+
+  async declineBooking(bookingUid: string, requestUser: UserWithProfile, reason?: string) {
+    const booking = await this.bookingsRepository.getByUid(bookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    await confirmBookingHandler({
+      ctx: {
+        user: requestUser,
+      },
+      input: {
+        bookingId: booking.id,
+        confirmed: false,
+        recurringEventId: booking.recurringEventId,
+        reason,
+      },
+    });
+
+    return this.getBooking(bookingUid);
+  }
 }

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

@@ -1,8 +1,12 @@
 import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.repository";
-import { bookingResponsesSchema } from "@/ee/bookings/2024-08-13/services/output.service";
+import {
+  bookingResponsesSchema,
+  seatedBookingResponsesSchema,
+} from "@/ee/bookings/2024-08-13/services/output.service";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
 import { hashAPIKey, isApiKey, stripApiKey } from "@/lib/api-key";
 import { ApiKeyRepository } from "@/modules/api-key/api-key-repository";
+import { BookingSeatRepository } from "@/modules/booking-seat/booking-seat.repository";
 import { OAuthClientRepository } from "@/modules/oauth-clients/oauth-client.repository";
 import { OAuthFlowService } from "@/modules/oauth-clients/services/oauth-flow.service";
 import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
@@ -15,15 +19,21 @@ 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,
   CancelBookingInput_2024_08_13,
+  CancelSeatedBookingInput_2024_08_13,
   CreateBookingInput_2024_08_13,
   CreateInstantBookingInput_2024_08_13,
   CreateRecurringBookingInput_2024_08_13,
   GetBookingsInput_2024_08_13,
   MarkAbsentBookingInput_2024_08_13,
+  RescheduleBookingInput,
   RescheduleBookingInput_2024_08_13,
+  RescheduleSeatedBookingInput_2024_08_13,
 } from "@calcom/platform-types";
+import { EventType } from "@calcom/prisma/client";
 
 type BookingRequest = NextApiRequest & { userId: number | undefined } & OAuthRequestParams;
 
@@ -73,7 +83,8 @@ export class InputBookingsService_2024_08_13 {
     private readonly eventTypesRepository: EventTypesRepository_2024_06_14,
     private readonly bookingsRepository: BookingsRepository_2024_08_13,
     private readonly config: ConfigService,
-    private readonly apiKeyRepository: ApiKeyRepository
+    private readonly apiKeyRepository: ApiKeyRepository,
+    private readonly bookingSeatRepository: BookingSeatRepository
   ) {}
 
   async createBookingRequest(
@@ -82,6 +93,7 @@ export class InputBookingsService_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 newRequest = { ...request };
     const userId = (await this.createBookingRequestOwnerId(request)) ?? undefined;
@@ -90,6 +102,13 @@ export class InputBookingsService_2024_08_13 {
       : DEFAULT_PLATFORM_PARAMS;
 
     const location = request.body.location || request.body.meetingUrl;
+    this.logger.log(`createBookingRequest_2024_04_15`, {
+      requestId,
+      ownerId: userId,
+      location,
+      oAuthClientId,
+      ...oAuthParams,
+    });
     Object.assign(newRequest, { userId, ...oAuthParams, platformBookingLocation: location });
 
     newRequest.body = { ...bodyTransformed, noEmail: !oAuthParams.arePlatformEmailsEnabled };
@@ -106,10 +125,13 @@ export class InputBookingsService_2024_08_13 {
       throw new NotFoundException(`Event type with id=${inputBooking.eventTypeId} not found`);
     }
 
+    this.validateBookingLengthInMinutes(inputBooking, eventType);
+
+    const lengthInMinutes = inputBooking.lengthInMinutes ?? eventType.length;
     const startTime = DateTime.fromISO(inputBooking.start, { zone: "utc" }).setZone(
       inputBooking.attendee.timeZone
     );
-    const endTime = startTime.plus({ minutes: eventType.length });
+    const endTime = startTime.plus({ minutes: lengthInMinutes });
 
     return {
       start: startTime.toISO(),
@@ -133,6 +155,25 @@ export class InputBookingsService_2024_08_13 {
     };
   }
 
+  validateBookingLengthInMinutes(inputBooking: CreateBookingInput_2024_08_13, eventType: EventType) {
+    const eventTypeMetadata = EventTypeMetaDataSchema.parse(eventType.metadata);
+    if (inputBooking.lengthInMinutes && !eventTypeMetadata?.multipleDuration) {
+      throw new BadRequestException(
+        "Can't specify 'lengthInMinutes' because event type does not have multiple possible lengths. Please, remove the 'lengthInMinutes' field from the request."
+      );
+    }
+    if (
+      inputBooking.lengthInMinutes &&
+      !eventTypeMetadata?.multipleDuration?.includes(inputBooking.lengthInMinutes)
+    ) {
+      throw new BadRequestException(
+        `Provided 'lengthInMinutes' is not one of the possible lengths for the event type. The possible lengths are: ${eventTypeMetadata?.multipleDuration?.join(
+          ", "
+        )}`
+      );
+    }
+  }
+
   async createRecurringBookingRequest(
     request: Request,
     body: CreateRecurringBookingInput_2024_08_13
@@ -239,9 +280,11 @@ export class InputBookingsService_2024_08_13 {
   async createRescheduleBookingRequest(
     request: Request,
     bookingUid: string,
-    body: RescheduleBookingInput_2024_08_13
+    body: RescheduleBookingInput
   ): Promise<BookingRequest> {
-    const bodyTransformed = await this.transformInputRescheduleBooking(bookingUid, body);
+    const bodyTransformed = this.isRescheduleSeatedBody(body)
+      ? await this.transformInputRescheduleSeatedBooking(bookingUid, body)
+      : await this.transformInputRescheduleBooking(bookingUid, body);
     const oAuthClientId = request.get(X_CAL_CLIENT_ID);
 
     const newRequest = { ...request };
@@ -258,6 +301,60 @@ export class InputBookingsService_2024_08_13 {
     return newRequest as unknown as BookingRequest;
   }
 
+  isRescheduleSeatedBody(body: RescheduleBookingInput): body is RescheduleSeatedBookingInput_2024_08_13 {
+    return body.hasOwnProperty("seatUid");
+  }
+
+  async transformInputRescheduleSeatedBooking(
+    bookingUid: string,
+    inputBooking: RescheduleSeatedBookingInput_2024_08_13
+  ) {
+    const booking = await this.bookingsRepository.getByUidWithAttendeesAndUserAndEvent(bookingUid);
+    // todo create booking seat module, repository and fetch the seat to get info
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} not found`);
+    }
+    if (!booking.eventTypeId) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} is missing event type`);
+    }
+    const eventType = await this.eventTypesRepository.getEventTypeByIdWithOwnerAndTeam(booking.eventTypeId);
+    if (!eventType) {
+      throw new NotFoundException(`Event type with id=${booking.eventTypeId} not found`);
+    }
+
+    const seat = await this.bookingSeatRepository.getByReferenceUid(inputBooking.seatUid);
+    if (!seat) {
+      throw new NotFoundException(`Seat with uid=${inputBooking.seatUid} does not exist.`);
+    }
+
+    const { responses: bookingResponses } = seatedBookingResponsesSchema.parse(seat.data);
+    const attendee = booking.attendees.find((attendee) => attendee.email === bookingResponses.email);
+
+    if (!attendee) {
+      throw new NotFoundException(
+        `Attendee with e-mail ${bookingResponses.email} for booking with uid=${bookingUid} and seatUid=${inputBooking.seatUid} not found`
+      );
+    }
+
+    const startTime = DateTime.fromISO(inputBooking.start, { zone: "utc" }).setZone(attendee.timeZone);
+    const endTime = startTime.plus({ minutes: eventType.length });
+
+    return {
+      start: startTime.toISO(),
+      end: endTime.toISO(),
+      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: {},
+      hasHashedBookingLink: false,
+      guests: [],
+      responses: { ...bookingResponses },
+      rescheduleUid: inputBooking.seatUid,
+    };
+  }
+
   async transformInputRescheduleBooking(bookingUid: string, inputBooking: RescheduleBookingInput_2024_08_13) {
     const booking = await this.bookingsRepository.getByUidWithAttendeesAndUserAndEvent(bookingUid);
     if (!booking) {
@@ -371,9 +468,11 @@ export class InputBookingsService_2024_08_13 {
   async createCancelBookingRequest(
     request: Request,
     bookingUid: string,
-    body: CancelBookingInput_2024_08_13
+    body: CancelBookingInput
   ): Promise<BookingRequest> {
-    const bodyTransformed = await this.transformInputCancelBooking(bookingUid, body);
+    const bodyTransformed = this.isCancelSeatedBody(body)
+      ? await this.transformInputCancelSeatedBooking(bookingUid, body)
+      : await this.transformInputCancelBooking(bookingUid, body);
     const oAuthClientId = request.get(X_CAL_CLIENT_ID);
 
     const newRequest = { ...request };
@@ -389,24 +488,57 @@ export class InputBookingsService_2024_08_13 {
     return newRequest as unknown as BookingRequest;
   }
 
-  async transformInputCancelBooking(bookingUid: string, inputBooking: CancelBookingInput_2024_08_13) {
-    let allRemainingBookings = false;
-    let uid = bookingUid;
-    const recurringBooking = await this.bookingsRepository.getRecurringByUidWithAttendeesAndUserAndEvent(
-      bookingUid
-    );
+  isCancelSeatedBody(body: CancelBookingInput): body is CancelSeatedBookingInput_2024_08_13 {
+    return body.hasOwnProperty("seatUid");
+  }
 
-    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;
+  async transformInputCancelBooking(bookingUid: string, inputBooking: CancelBookingInput_2024_08_13) {
+    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 (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,
+    };
+  }
+
+  async transformInputCancelSeatedBooking(
+    bookingUid: string,
+    inputBooking: CancelSeatedBookingInput_2024_08_13
+  ) {
+    // 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: bookingUid,
+      cancellationReason: "",
+      allRemainingBookings: false,
+      seatReferenceUid: inputBooking.seatUid,
     };
   }
 

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

@@ -4,15 +4,35 @@ import { plainToClass } from "class-transformer";
 import { DateTime } from "luxon";
 import { z } from "zod";
 
-import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
-import { Booking } from "@calcom/prisma/client";
+import {
+  BookingOutput_2024_08_13,
+  CreateRecurringSeatedBookingOutput_2024_08_13,
+  CreateSeatedBookingOutput_2024_08_13,
+  GetRecurringSeatedBookingOutput_2024_08_13,
+  GetSeatedBookingOutput_2024_08_13,
+  ReassignBookingOutput_2024_08_13,
+  RecurringBookingOutput_2024_08_13,
+  SeatedAttendee,
+} from "@calcom/platform-types";
+import { Booking, BookingSeat } from "@calcom/prisma/client";
 
 export const bookingResponsesSchema = z
   .object({
     email: z.string(),
     name: z.string(),
     guests: z.array(z.string()).optional(),
-    rescheduledReason: z.string().optional(),
+    rescheduleReason: z.string().optional(),
+  })
+  .passthrough();
+
+export const seatedBookingResponsesSchema = z
+  .object({
+    responses: z
+      .object({
+        email: z.string(),
+        name: z.string(),
+      })
+      .passthrough(),
   })
   .passthrough();
 
@@ -27,9 +47,12 @@ type DatabaseBooking = Booking & {
     timeZone: string;
     locale: string | null;
     noShow: boolean | null;
+    bookingSeat?: BookingSeat | null;
   }[];
 } & { user: { id: number; name: string | null; email: string } | null };
 
+type BookingWithUser = Booking & { user: { id: number; name: string | null; email: string } | null };
+
 @Injectable()
 export class OutputBookingsService_2024_08_13 {
   constructor(private readonly bookingsRepository: BookingsRepository_2024_08_13) {}
@@ -72,17 +95,18 @@ export class OutputBookingsService_2024_08_13 {
     };
 
     const bookingTransformed = plainToClass(BookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
+    // note(Lauris): I don't know why plainToClass erases bookings responses so attaching manually
     bookingTransformed.bookingFieldsResponses = bookingResponses;
     return bookingTransformed;
   }
 
-  async getOutputRecurringBookings(databaseBookings: DatabaseBooking[]) {
+  async getOutputRecurringBookings(bookingsIds: number[]) {
     const transformed = [];
 
-    for (const booking of databaseBookings) {
-      const databaseBooking = await this.bookingsRepository.getByIdWithAttendeesAndUserAndEvent(booking.id);
+    for (const bookingId of bookingsIds) {
+      const databaseBooking = await this.bookingsRepository.getByIdWithAttendeesAndUserAndEvent(bookingId);
       if (!databaseBooking) {
-        throw new Error(`Booking with id=${booking.id} was not found in the database`);
+        throw new Error(`Booking with id=${bookingId} was not found in the database`);
       }
 
       transformed.push(this.getOutputRecurringBooking(databaseBooking));
@@ -132,4 +156,172 @@ export class OutputBookingsService_2024_08_13 {
 
     return plainToClass(RecurringBookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
   }
+
+  getOutputCreateSeatedBooking(
+    databaseBooking: DatabaseBooking,
+    seatUid: string
+  ): CreateSeatedBookingOutput_2024_08_13 {
+    const getSeatedBookingOutput = this.getOutputSeatedBooking(databaseBooking);
+    return { ...getSeatedBookingOutput, seatUid };
+  }
+
+  getOutputSeatedBooking(databaseBooking: DatabaseBooking) {
+    const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
+    const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
+    const duration = dateEnd.diff(dateStart, "minutes").minutes;
+
+    const booking = {
+      id: databaseBooking.id,
+      uid: databaseBooking.uid,
+      title: databaseBooking.title,
+      description: databaseBooking.description,
+      hosts: [databaseBooking.user],
+      status: databaseBooking.status.toLowerCase(),
+      rescheduledFromUid: databaseBooking.fromReschedule || undefined,
+      start: databaseBooking.startTime,
+      end: databaseBooking.endTime,
+      duration,
+      eventType: databaseBooking.eventType,
+      // note(Lauris): eventTypeId is deprecated
+      eventTypeId: databaseBooking.eventTypeId,
+      attendees: [],
+      location: databaseBooking.location,
+      // note(Lauris): meetingUrl is deprecated
+      meetingUrl: databaseBooking.location,
+      absentHost: !!databaseBooking.noShowHost,
+    };
+
+    const parsed = plainToClass(GetSeatedBookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
+
+    // note(Lauris): I don't know why plainToClass erases booking.attendees[n].responses so attaching manually
+    parsed.attendees = databaseBooking.attendees.map((attendee) => {
+      const { responses } = seatedBookingResponsesSchema.parse(attendee.bookingSeat?.data);
+
+      const attendeeData = {
+        name: attendee.name,
+        email: attendee.email,
+        timeZone: attendee.timeZone,
+        language: attendee.locale,
+        absent: !!attendee.noShow,
+        seatUid: attendee.bookingSeat?.referenceUid,
+        bookingFieldsResponses: {},
+      };
+      const attendeeParsed = plainToClass(SeatedAttendee, attendeeData, { strategy: "excludeAll" });
+      attendeeParsed.bookingFieldsResponses = responses || {};
+      // note(Lauris): as of now email is not returned for privacy
+      delete attendeeParsed.bookingFieldsResponses.email;
+
+      return attendeeParsed;
+    });
+
+    return parsed;
+  }
+
+  async getOutputRecurringSeatedBookings(bookingsIds: number[]) {
+    const transformed = [];
+
+    for (const bookingId of bookingsIds) {
+      const databaseBooking =
+        await this.bookingsRepository.getByIdWithAttendeesWithBookingSeatAndUserAndEvent(bookingId);
+      if (!databaseBooking) {
+        throw new Error(`Booking with id=${bookingId} was not found in the database`);
+      }
+
+      transformed.push(this.getOutputRecurringSeatedBooking(databaseBooking));
+    }
+
+    return transformed.sort((a, b) => new Date(a.start).getTime() - new Date(b.start).getTime());
+  }
+
+  async getOutputCreateRecurringSeatedBookings(bookings: { uid: string; seatUid: string }[]) {
+    const transformed = [];
+
+    for (const booking of bookings) {
+      const databaseBooking =
+        await this.bookingsRepository.getByUidWithAttendeesWithBookingSeatAndUserAndEvent(booking.uid);
+      if (!databaseBooking) {
+        throw new Error(`Booking with uid=${booking.uid} was not found in the database`);
+      }
+      transformed.push(this.getOutputCreateRecurringSeatedBooking(databaseBooking, booking.seatUid));
+    }
+
+    return transformed.sort((a, b) => new Date(a.start).getTime() - new Date(b.start).getTime());
+  }
+
+  getOutputCreateRecurringSeatedBooking(
+    databaseBooking: DatabaseBooking,
+    seatUid: string
+  ): CreateRecurringSeatedBookingOutput_2024_08_13 {
+    const getRecurringSeatedBookingOutput = this.getOutputRecurringSeatedBooking(databaseBooking);
+    return { ...getRecurringSeatedBookingOutput, seatUid };
+  }
+
+  getOutputRecurringSeatedBooking(databaseBooking: DatabaseBooking) {
+    const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
+    const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
+    const duration = dateEnd.diff(dateStart, "minutes").minutes;
+
+    const booking = {
+      id: databaseBooking.id,
+      uid: databaseBooking.uid,
+      title: databaseBooking.title,
+      description: databaseBooking.description,
+      hosts: [databaseBooking.user],
+      status: databaseBooking.status.toLowerCase(),
+      cancellationReason: databaseBooking.cancellationReason || undefined,
+      rescheduledFromUid: databaseBooking.fromReschedule || undefined,
+      start: databaseBooking.startTime,
+      end: databaseBooking.endTime,
+      duration,
+      eventType: databaseBooking.eventType,
+      // note(Lauris): eventTypeId is deprecated
+      eventTypeId: databaseBooking.eventTypeId,
+      attendees: [],
+      location: databaseBooking.location,
+      // note(Lauris): meetingUrl is deprecated
+      meetingUrl: databaseBooking.location,
+      recurringBookingUid: databaseBooking.recurringEventId,
+      absentHost: !!databaseBooking.noShowHost,
+    };
+
+    const parsed = plainToClass(GetRecurringSeatedBookingOutput_2024_08_13, booking, {
+      strategy: "excludeAll",
+    });
+
+    // note(Lauris): I don't know why plainToClass erases booking.attendees[n].responses so attaching manually
+    parsed.attendees = databaseBooking.attendees.map((attendee) => {
+      const { responses } = seatedBookingResponsesSchema.parse(attendee.bookingSeat?.data);
+
+      const attendeeData = {
+        name: attendee.name,
+        email: attendee.email,
+        timeZone: attendee.timeZone,
+        language: attendee.locale,
+        absent: !!attendee.noShow,
+        seatUid: attendee.bookingSeat?.referenceUid,
+        bookingFieldsResponses: {},
+      };
+      const attendeeParsed = plainToClass(SeatedAttendee, attendeeData, { strategy: "excludeAll" });
+      attendeeParsed.bookingFieldsResponses = responses || {};
+      // note(Lauris): as of now email is not returned for privacy
+      delete attendeeParsed.bookingFieldsResponses.email;
+
+      return attendeeParsed;
+    });
+
+    return parsed;
+  }
+
+  getOutputReassignedBooking(
+    databaseBooking: Pick<BookingWithUser, "uid" | "user">
+  ): ReassignBookingOutput_2024_08_13 {
+    return {
+      bookingUid: databaseBooking.uid,
+      reassignedTo: {
+        id: databaseBooking?.user?.id || 0,
+        name: databaseBooking?.user?.name || "unknown",
+        email: databaseBooking?.user?.email || "unknown",
+      },
+    };
+  }
 }

apps/api/v2/src/ee/event-types/event-types_2024_06_14/constants/constants.ts

@@ -1,4 +1,4 @@
-import { IntegrationLocation } from "@calcom/lib";
+import { OrganizerIntegrationLocation } from "@calcom/lib";
 
 type BaseEventType = {
   length: number;
@@ -7,7 +7,7 @@ type BaseEventType = {
 };
 
 type EventTypeWithLocation = BaseEventType & {
-  locations: IntegrationLocation[];
+  locations: OrganizerIntegrationLocation[];
 };
 
 const thirtyMinutes: BaseEventType = {

apps/api/v2/src/ee/event-types/event-types_2024_06_14/controllers/event-types.controller.e2e-spec.ts

@@ -31,6 +31,7 @@ import {
   ApiSuccessResponse,
   CreateEventTypeInput_2024_06_14,
   EventTypeOutput_2024_06_14,
+  NameFieldInput_2024_06_14,
   UpdateEventTypeInput_2024_06_14,
 } from "@calcom/platform-types";
 import { SchedulingType } from "@calcom/prisma/enums";
@@ -199,18 +200,36 @@ describe("Event types Endpoints", () => {
     });
 
     it("should create an event type", async () => {
+      const nameBookingField: NameFieldInput_2024_06_14 = {
+        type: "name",
+        label: "Your name sir / madam",
+        placeholder: "john doe",
+        disableOnPrefill: false,
+      };
+
       const body: CreateEventTypeInput_2024_06_14 = {
         title: "Coding class",
         slug: "coding-class",
         description: "Let's learn how to code like a pro.",
         lengthInMinutes: 60,
+        lengthInMinutesOptions: [30, 60, 90],
         locations: [
           {
             type: "integration",
             integration: "cal-video",
           },
+          {
+            type: "attendeePhone",
+          },
+          {
+            type: "attendeeAddress",
+          },
+          {
+            type: "attendeeDefined",
+          },
         ],
         bookingFields: [
+          nameBookingField,
           {
             type: "select",
             label: "select which language you want to learn",
@@ -218,6 +237,7 @@ describe("Event types Endpoints", () => {
             required: true,
             placeholder: "select language",
             options: ["javascript", "python", "cobol"],
+            disableOnPrefill: true,
           },
         ],
         scheduleId: firstSchedule.id,
@@ -281,6 +301,7 @@ describe("Event types Endpoints", () => {
           expect(createdEventType.title).toEqual(body.title);
           expect(createdEventType.description).toEqual(body.description);
           expect(createdEventType.lengthInMinutes).toEqual(body.lengthInMinutes);
+          expect(createdEventType.lengthInMinutesOptions).toEqual(body.lengthInMinutesOptions);
           expect(createdEventType.locations).toEqual(body.locations);
           expect(createdEventType.ownerId).toEqual(user.id);
           expect(createdEventType.scheduleId).toEqual(firstSchedule.id);
@@ -304,12 +325,16 @@ describe("Event types Endpoints", () => {
           );
           expect(createdEventType.color).toEqual(body.color);
 
-          const responseBookingFields = body.bookingFields || [];
+          const requestBookingFields = body.bookingFields || [];
           const expectedBookingFields = [
-            { isDefault: true, required: true, slug: "name", type: "name" },
+            { isDefault: true, required: true, slug: "name", ...nameBookingField },
             { isDefault: true, required: true, slug: "email", type: "email" },
+            // note(Lauris): location booking field is added if multiple locations are passed
+            { isDefault: true, required: false, slug: "location", type: "radioInput" },
             { isDefault: true, required: false, slug: "rescheduleReason", type: "textarea" },
-            ...responseBookingFields.map((field) => ({ isDefault: false, ...field })),
+            ...requestBookingFields
+              .filter((field) => field.type !== "name" && field.type !== "email")
+              .map((field) => ({ isDefault: false, ...field })),
           ];
 
           expect(createdEventType.bookingFields).toEqual(expectedBookingFields);
@@ -337,6 +362,7 @@ describe("Event types Endpoints", () => {
       expect(fetchedEventType?.title).toEqual(eventType.title);
       expect(fetchedEventType?.description).toEqual(eventType.description);
       expect(fetchedEventType?.lengthInMinutes).toEqual(eventType.lengthInMinutes);
+      expect(fetchedEventType?.lengthInMinutesOptions).toEqual(eventType.lengthInMinutesOptions);
       expect(fetchedEventType?.locations).toEqual(eventType.locations);
       expect(fetchedEventType?.bookingFields).toEqual(eventType.bookingFields);
       expect(fetchedEventType?.ownerId).toEqual(user.id);
@@ -630,11 +656,31 @@ describe("Event types Endpoints", () => {
     });
 
     it("should update event type", async () => {
+      const nameBookingField: NameFieldInput_2024_06_14 = {
+        type: "name",
+        label: "Your name sir / madam",
+        placeholder: "john doe",
+        disableOnPrefill: true,
+      };
+
       const newTitle = "Coding class in Italian!";
 
       const body: UpdateEventTypeInput_2024_06_14 = {
         title: newTitle,
         scheduleId: secondSchedule.id,
+        lengthInMinutesOptions: [15, 30],
+        bookingFields: [
+          nameBookingField,
+          {
+            type: "select",
+            label: "select which language you want to learn",
+            slug: "select-language",
+            required: true,
+            placeholder: "select language",
+            options: ["javascript", "python", "cobol"],
+            disableOnPrefill: false,
+          },
+        ],
         bookingLimitsCount: {
           day: 4,
           week: 10,
@@ -691,10 +737,23 @@ describe("Event types Endpoints", () => {
 
           expect(updatedEventType.id).toEqual(eventType.id);
           expect(updatedEventType.title).toEqual(newTitle);
+          expect(updatedEventType.lengthInMinutesOptions).toEqual(body.lengthInMinutesOptions);
           expect(updatedEventType.description).toEqual(eventType.description);
           expect(updatedEventType.lengthInMinutes).toEqual(eventType.lengthInMinutes);
           expect(updatedEventType.locations).toEqual(eventType.locations);
-          expect(updatedEventType.bookingFields).toEqual(eventType.bookingFields);
+
+          const requestBookingFields = body.bookingFields || [];
+          const expectedBookingFields = [
+            { isDefault: true, required: true, slug: "name", ...nameBookingField },
+            { isDefault: true, required: true, slug: "email", type: "email" },
+            { isDefault: true, required: false, slug: "rescheduleReason", type: "textarea" },
+            ...requestBookingFields
+              .filter((field) => field.type !== "name" && field.type !== "email")
+              .map((field) => ({ isDefault: false, ...field })),
+          ];
+
+          expect(updatedEventType.bookingFields).toEqual(expectedBookingFields);
+
           expect(updatedEventType.ownerId).toEqual(user.id);
           expect(updatedEventType.scheduleId).toEqual(secondSchedule.id);
           expect(updatedEventType.bookingLimitsCount).toEqual(body.bookingLimitsCount);
@@ -718,6 +777,7 @@ describe("Event types Endpoints", () => {
 
           eventType.title = newTitle;
           eventType.scheduleId = secondSchedule.id;
+          eventType.lengthInMinutesOptions = updatedEventType.lengthInMinutesOptions;
           eventType.bookingLimitsCount = updatedEventType.bookingLimitsCount;
           eventType.onlyShowFirstAvailableSlot = updatedEventType.onlyShowFirstAvailableSlot;
           eventType.bookingLimitsDuration = updatedEventType.bookingLimitsDuration;
@@ -732,6 +792,7 @@ describe("Event types Endpoints", () => {
           eventType.hideCalendarEventDetails = updatedEventType.hideCalendarEventDetails;
           eventType.lockTimeZoneToggleOnBookingPage = updatedEventType.lockTimeZoneToggleOnBookingPage;
           eventType.color = updatedEventType.color;
+          eventType.bookingFields = updatedEventType.bookingFields;
         });
     });
 
@@ -764,6 +825,7 @@ describe("Event types Endpoints", () => {
       expect(fetchedEventType.title).toEqual(eventType.title);
       expect(fetchedEventType.description).toEqual(eventType.description);
       expect(fetchedEventType.lengthInMinutes).toEqual(eventType.lengthInMinutes);
+      expect(fetchedEventType.lengthInMinutesOptions).toEqual(eventType.lengthInMinutesOptions);
       expect(fetchedEventType.locations).toEqual(eventType.locations);
       expect(fetchedEventType.bookingFields).toEqual(eventType.bookingFields);
       expect(fetchedEventType.ownerId).toEqual(user.id);
@@ -802,6 +864,7 @@ describe("Event types Endpoints", () => {
       expect(fetchedEventType?.title).toEqual(eventType.title);
       expect(fetchedEventType?.description).toEqual(eventType.description);
       expect(fetchedEventType?.lengthInMinutes).toEqual(eventType.lengthInMinutes);
+      expect(fetchedEventType?.lengthInMinutesOptions).toEqual(eventType.lengthInMinutesOptions);
       expect(fetchedEventType?.locations).toEqual(eventType.locations);
       expect(fetchedEventType?.bookingFields).toEqual(eventType.bookingFields);
       expect(fetchedEventType?.ownerId).toEqual(user.id);
@@ -860,7 +923,7 @@ describe("Event types Endpoints", () => {
     });
   });
 
-  describe("Handle legacy event-types booking fields", () => {
+  describe("Handle event-types booking fields", () => {
     let app: INestApplication;
 
     let oAuthClient: PlatformOAuthClient;
@@ -885,6 +948,7 @@ describe("Event types Endpoints", () => {
       { isDefault: true, required: false, slug: "notes", type: "textarea" },
       { isDefault: true, required: false, slug: "guests", type: "multiemail" },
       { isDefault: true, required: false, slug: "rescheduleReason", type: "textarea" },
+      { isDefault: true, type: "phone", slug: "attendeePhoneNumber", required: false },
     ];
 
     beforeAll(async () => {
@@ -1037,6 +1101,21 @@ describe("Event types Endpoints", () => {
             defaultLabel: "reason_for_reschedule",
             defaultPlaceholder: "reschedule_placeholder",
           },
+          {
+            name: "attendeePhoneNumber",
+            type: "phone",
+            hidden: true,
+            sources: [
+              {
+                id: "default",
+                type: "default",
+                label: "Default",
+              },
+            ],
+            editable: "system-but-optional",
+            required: false,
+            defaultLabel: "phone_number",
+          },
         ],
       };
       const legacyEventType = await eventTypesRepositoryFixture.create(legacyEventTypeInput, user.id);
@@ -1152,6 +1231,21 @@ describe("Event types Endpoints", () => {
             defaultLabel: "reason_for_reschedule",
             defaultPlaceholder: "reschedule_placeholder",
           },
+          {
+            name: "attendeePhoneNumber",
+            type: "phone",
+            hidden: true,
+            sources: [
+              {
+                id: "default",
+                type: "default",
+                label: "Default",
+              },
+            ],
+            editable: "system-but-optional",
+            required: false,
+            defaultLabel: "phone_number",
+          },
         ],
       };
       const legacyEventType = await eventTypesRepositoryFixture.create(legacyEventTypeInput, user.id);
@@ -1179,6 +1273,204 @@ describe("Event types Endpoints", () => {
         });
     });
 
+    it("should return event type with unknown bookingField", async () => {
+      const unknownSystemField = {
+        name: "unknown-whatever",
+        type: "unknown-whatever",
+        label: "your team",
+        sources: [
+          {
+            id: "user",
+            type: "user",
+            label: "User",
+            fieldRequired: true,
+          },
+        ],
+        editable: "user",
+        required: true,
+        placeholder: "FC Barcelona",
+      };
+
+      const eventTypeInput = {
+        title: "unknown field event type two",
+        description: "unknown field event type description two",
+        length: 40,
+        hidden: false,
+        slug: "unknown-field-type-two",
+        locations: [],
+        schedulingType: SchedulingType.ROUND_ROBIN,
+        bookingFields: [unknownSystemField],
+      };
+      const eventType = await eventTypesRepositoryFixture.create(eventTypeInput, user.id);
+
+      return request(app.getHttpServer())
+        .get(`/api/v2/event-types/${eventType.id}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14> = response.body;
+          const fetchedEventType = responseBody.data;
+
+          expect(fetchedEventType.bookingFields).toEqual([
+            {
+              type: "unknown",
+              slug: "unknown",
+              bookingField: JSON.stringify(unknownSystemField),
+            },
+          ]);
+        });
+    });
+
+    afterAll(async () => {
+      await oauthClientRepositoryFixture.delete(oAuthClient.id);
+      await teamRepositoryFixture.delete(organization.id);
+      try {
+        await eventTypesRepositoryFixture.delete(legacyEventTypeId1);
+        await eventTypesRepositoryFixture.delete(legacyEventTypeId2);
+      } catch (e) {
+        // Event type might have been deleted by the test
+      }
+      try {
+        await userRepositoryFixture.delete(user.id);
+      } catch (e) {
+        // User might have been deleted by the test
+      }
+      await app.close();
+    });
+  });
+
+  describe("Handle event-types locations", () => {
+    let app: INestApplication;
+
+    let oAuthClient: PlatformOAuthClient;
+    let organization: Team;
+    let userRepositoryFixture: UserRepositoryFixture;
+    let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+    let teamRepositoryFixture: TeamRepositoryFixture;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+
+    const userEmail = "locations-event-types-test-e2e@api.com";
+    const name = "bob-the-locations-builder";
+    const username = name;
+    let user: User;
+    let legacyEventTypeId1: number;
+    let legacyEventTypeId2: number;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        userEmail,
+        Test.createTestingModule({
+          providers: [PrismaExceptionFilter, HttpExceptionFilter],
+          imports: [AppModule, UsersModule, EventTypesModule_2024_06_14, TokensModule],
+        })
+      )
+        .overrideGuard(PermissionsGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .compile();
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+
+      organization = await teamRepositoryFixture.create({ name: "organization" });
+      oAuthClient = await createOAuthClient(organization.id);
+      user = await userRepositoryFixture.create({
+        email: userEmail,
+        name,
+        username,
+      });
+
+      await app.init();
+    });
+
+    async function createOAuthClient(organizationId: number) {
+      const data = {
+        logo: "logo-url",
+        name: "name",
+        redirectUris: ["redirect-uri"],
+        permissions: 32,
+      };
+      const secret = "secret";
+
+      const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+      return client;
+    }
+
+    it("should return integration location with link and credentialId", async () => {
+      const eventTypeInput = {
+        title: "event type discord",
+        description: "event type description",
+        length: 40,
+        hidden: false,
+        slug: "discord-event-type",
+        locations: [
+          {
+            type: "integrations:discord_video",
+            link: "https://discord.com/users/100",
+            credentialId: 100,
+          },
+        ],
+        schedulingType: SchedulingType.ROUND_ROBIN,
+        bookingFields: [],
+      };
+      const legacyEventType = await eventTypesRepositoryFixture.create(eventTypeInput, user.id);
+      legacyEventTypeId1 = legacyEventType.id;
+
+      return request(app.getHttpServer())
+        .get(`/api/v2/event-types/${legacyEventTypeId1}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14> = response.body;
+          const fetchedEventType = responseBody.data;
+          expect(fetchedEventType.locations).toEqual([
+            {
+              type: "integration",
+              integration: "discord-video",
+              link: eventTypeInput.locations[0].link,
+              credentialId: eventTypeInput.locations[0].credentialId,
+            },
+          ]);
+        });
+    });
+
+    it("should return unsupported location", async () => {
+      const eventTypeInput = {
+        title: "event type not existing",
+        description: "event type description",
+        length: 40,
+        hidden: false,
+        slug: "not-existing-event-type",
+        locations: [
+          {
+            type: "this-type-does-not-exist",
+          },
+        ],
+        schedulingType: SchedulingType.ROUND_ROBIN,
+        bookingFields: [],
+      };
+      const legacyEventType = await eventTypesRepositoryFixture.create(eventTypeInput, user.id);
+      legacyEventTypeId1 = legacyEventType.id;
+
+      return request(app.getHttpServer())
+        .get(`/api/v2/event-types/${legacyEventTypeId1}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14> = response.body;
+          const fetchedEventType = responseBody.data;
+          expect(fetchedEventType.locations).toEqual([
+            { type: "unknown", location: JSON.stringify(eventTypeInput.locations[0]) },
+          ]);
+        });
+    });
+
     afterAll(async () => {
       await oauthClientRepositoryFixture.delete(oAuthClient.id);
       await teamRepositoryFixture.delete(organization.id);

apps/api/v2/src/ee/event-types/event-types_2024_06_14/services/input-event-types.service.ts

@@ -20,6 +20,8 @@ import {
   transformEventColorsApiToInternal,
   validateCustomEventName,
   transformSeatsApiToInternal,
+  SystemField,
+  CustomField,
 } from "@calcom/platform-libraries";
 import {
   CreateEventTypeInput_2024_06_14,
@@ -102,6 +104,7 @@ export class InputEventTypesService_2024_06_14 {
 
     const {
       lengthInMinutes,
+      lengthInMinutesOptions,
       locations,
       bookingFields,
       bookingLimitsCount,
@@ -133,6 +136,7 @@ export class InputEventTypesService_2024_06_14 {
         bookerLayouts: this.transformInputBookerLayouts(bookerLayouts),
         requiresConfirmationThreshold:
           confirmationPolicyTransformed?.requiresConfirmationThreshold ?? undefined,
+        multipleDuration: lengthInMinutesOptions,
       },
       requiresConfirmation: confirmationPolicyTransformed?.requiresConfirmation ?? undefined,
       requiresConfirmationWillBlockSlot:
@@ -150,6 +154,7 @@ export class InputEventTypesService_2024_06_14 {
   async transformInputUpdateEventType(inputEventType: UpdateEventTypeInput_2024_06_14, eventTypeId: number) {
     const {
       lengthInMinutes,
+      lengthInMinutesOptions,
       locations,
       bookingFields,
       bookingLimitsCount,
@@ -189,6 +194,7 @@ export class InputEventTypesService_2024_06_14 {
         bookerLayouts: this.transformInputBookerLayouts(bookerLayouts),
         requiresConfirmationThreshold:
           confirmationPolicyTransformed?.requiresConfirmationThreshold ?? undefined,
+        multipleDuration: lengthInMinutesOptions,
       },
       recurringEvent: recurrence ? this.transformInputRecurrignEvent(recurrence) : undefined,
       requiresConfirmation: confirmationPolicyTransformed?.requiresConfirmation ?? undefined,
@@ -211,16 +217,27 @@ export class InputEventTypesService_2024_06_14 {
     inputBookingFields: CreateEventTypeInput_2024_06_14["bookingFields"],
     hasMultipleLocations: boolean
   ) {
-    const defaultFieldsBefore = [systemBeforeFieldName, systemBeforeFieldEmail];
+    const customFields: (SystemField | CustomField)[] = inputBookingFields
+      ? transformBookingFieldsApiToInternal(inputBookingFields)
+      : [];
+    const customFieldsWithoutNameEmail = customFields.filter(
+      (field) => field.type !== "name" && field.type !== "email"
+    );
+    const customNameField = customFields?.find((field) => field.type === "name");
+    const customEmailField = customFields?.find((field) => field.type === "email");
+
+    const defaultFieldsBefore: (SystemField | CustomField)[] = [
+      customNameField || systemBeforeFieldName,
+      customEmailField || systemBeforeFieldEmail,
+    ];
     // note(Lauris): if event type has multiple locations then a radio button booking field has to be displayed to allow booker to pick location
     if (hasMultipleLocations) {
       defaultFieldsBefore.push(systemBeforeFieldLocation);
     }
 
-    const customFields = transformBookingFieldsApiToInternal(inputBookingFields);
     const defaultFieldsAfter = [systemAfterFieldRescheduleReason];
 
-    return [...defaultFieldsBefore, ...customFields, ...defaultFieldsAfter];
+    return [...defaultFieldsBefore, ...customFieldsWithoutNameEmail, ...defaultFieldsAfter];
   }
 
   transformInputIntervalLimits(inputBookingFields: CreateEventTypeInput_2024_06_14["bookingLimitsCount"]) {

apps/api/v2/src/ee/event-types/event-types_2024_06_14/services/output-event-types.service.ts

@@ -7,8 +7,7 @@ import {
   transformLocationsInternalToApi,
   transformBookingFieldsInternalToApi,
   parseRecurringEvent,
-  TransformedLocationsSchema,
-  BookingFieldsSchema,
+  InternalLocationSchema,
   SystemField,
   CustomField,
   parseBookingLimit,
@@ -20,12 +19,16 @@ import {
   transformEventTypeColorsInternalToApi,
   parseEventTypeColor,
   transformSeatsInternalToApi,
+  InternalLocation,
+  BookingFieldSchema,
 } from "@calcom/platform-libraries";
 import {
   TransformFutureBookingsLimitSchema_2024_06_14,
   BookerLayoutsTransformedSchema,
   NoticeThresholdTransformedSchema,
   EventTypeOutput_2024_06_14,
+  OutputUnknownLocation_2024_06_14,
+  OutputUnknownBookingField_2024_06_14,
 } from "@calcom/platform-types";
 
 type EventTypeRelations = {
@@ -118,7 +121,7 @@ export class OutputEventTypesService_2024_06_14 {
     const locations = this.transformLocations(databaseEventType.locations);
     const customName = databaseEventType?.eventName ?? undefined;
     const bookingFields = databaseEventType.bookingFields
-      ? this.transformBookingFields(BookingFieldsSchema.parse(databaseEventType.bookingFields))
+      ? this.transformBookingFields(databaseEventType.bookingFields)
       : [];
     const recurrence = this.transformRecurringEvent(databaseEventType.recurringEvent);
     const metadata = this.transformMetadata(databaseEventType.metadata) || {};
@@ -150,6 +153,7 @@ export class OutputEventTypesService_2024_06_14 {
       id,
       ownerId,
       lengthInMinutes: length,
+      lengthInMinutesOptions: metadata.multipleDuration,
       title,
       slug,
       description: description || "",
@@ -190,7 +194,20 @@ export class OutputEventTypesService_2024_06_14 {
 
   transformLocations(locations: any) {
     if (!locations) return [];
-    return transformLocationsInternalToApi(TransformedLocationsSchema.parse(locations));
+
+    const knownLocations: InternalLocation[] = [];
+    const unknownLocations: OutputUnknownLocation_2024_06_14[] = [];
+
+    for (const location of locations) {
+      const result = InternalLocationSchema.safeParse(location);
+      if (result.success) {
+        knownLocations.push(result.data);
+      } else {
+        unknownLocations.push({ type: "unknown", location: JSON.stringify(location) });
+      }
+    }
+
+    return [...transformLocationsInternalToApi(knownLocations), ...unknownLocations];
   }
 
   transformDestinationCalendar(destinationCalendar?: DestinationCalendar | null) {
@@ -201,10 +218,26 @@ export class OutputEventTypesService_2024_06_14 {
     };
   }
 
-  transformBookingFields(bookingFields: (SystemField | CustomField)[] | null) {
+  transformBookingFields(bookingFields: any) {
     if (!bookingFields) return [];
 
-    return transformBookingFieldsInternalToApi(bookingFields);
+    const knownBookingFields: (SystemField | CustomField)[] = [];
+    const unknownBookingFields: OutputUnknownBookingField_2024_06_14[] = [];
+
+    for (const bookingField of bookingFields) {
+      const result = BookingFieldSchema.safeParse(bookingField);
+      if (result.success) {
+        knownBookingFields.push(result.data);
+      } else {
+        unknownBookingFields.push({
+          type: "unknown",
+          slug: "unknown",
+          bookingField: JSON.stringify(bookingField),
+        });
+      }
+    }
+
+    return [...transformBookingFieldsInternalToApi(knownBookingFields), ...unknownBookingFields];
   }
 
   transformRecurringEvent(recurringEvent: any) {

apps/api/v2/src/ee/schedules/schedules_2024_06_11/controllers/schedules.controller.e2e-spec.ts

@@ -121,11 +121,13 @@ describe("Schedules Endpoints", () => {
       expect(outputSchedule?.isDefault).toEqual(expected.isDefault);
       expect(outputSchedule?.availability.length).toEqual(expectedAvailabilityLength);
 
-      const outputScheduleAvailability = outputSchedule?.availability[0];
-      expect(outputScheduleAvailability).toBeDefined();
-      expect(outputScheduleAvailability?.days).toEqual(expected.availability?.[0].days);
-      expect(outputScheduleAvailability?.startTime).toEqual(expected.availability?.[0].startTime);
-      expect(outputScheduleAvailability?.endTime).toEqual(expected.availability?.[0].endTime);
+      if (expectedAvailabilityLength) {
+        const outputScheduleAvailability = outputSchedule?.availability[0];
+        expect(outputScheduleAvailability).toBeDefined();
+        expect(outputScheduleAvailability?.days).toEqual(expected.availability?.[0].days);
+        expect(outputScheduleAvailability?.startTime).toEqual(expected.availability?.[0].startTime);
+        expect(outputScheduleAvailability?.endTime).toEqual(expected.availability?.[0].endTime);
+      }
 
       expect(JSON.stringify(outputSchedule?.overrides)).toEqual(JSON.stringify(expected.overrides));
     }
@@ -222,6 +224,33 @@ describe("Schedules Endpoints", () => {
         });
     });
 
+    it("should empty availabilities and overrides", async () => {
+      const body: UpdateScheduleInput_2024_06_11 = {
+        availability: [],
+        overrides: [],
+      };
+
+      return request(app.getHttpServer())
+        .patch(`/api/v2/schedules/${createdSchedule.id}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_11)
+        .send(body)
+        .expect(200)
+        .then((response: any) => {
+          const responseData: UpdateScheduleOutput_2024_06_11 = response.body;
+          expect(responseData.status).toEqual(SUCCESS_STATUS);
+          const responseSchedule = responseData.data;
+
+          const expectedSchedule = {
+            ...createdSchedule,
+            overrides: body.overrides,
+            availability: body.availability,
+          };
+          outputScheduleMatchesExpected(responseSchedule, expectedSchedule, 0);
+
+          createdSchedule = responseSchedule;
+        });
+    });
+
     it("should delete schedule", async () => {
       return request(app.getHttpServer()).delete(`/api/v2/schedules/${createdSchedule.id}`).expect(200);
     });

apps/api/v2/src/ee/schedules/schedules_2024_06_11/schedules.repository.ts

@@ -119,14 +119,17 @@ export class SchedulesRepository_2024_06_11 {
       timeZone: schedule.timeZone,
     };
 
-    const availabilitiesAndOverrides: Prisma.AvailabilityCreateManyInput[] = [];
+    const createAvailabilityStatements: Prisma.AvailabilityCreateManyInput[] = [];
+    const createOverridesStatements: Prisma.AvailabilityCreateManyInput[] = [];
+
+    const deleteAvailabilityStatements: Prisma.AvailabilityWhereInput[] = [];
+    const deleteOverridesStatements: Prisma.AvailabilityWhereInput[] = [];
 
-    const deleteConditions = [];
     if (availability) {
       // note(Lauris): availabilities and overrides are stored in the same "Availability" table,
       // but availabilities have "date" field as null, while overrides have it as not null, so delete
       // condition below results in deleting only rows from Availability table that are availabilities.
-      deleteConditions.push({
+      deleteAvailabilityStatements.push({
         scheduleId: { equals: scheduleId },
         date: null,
       });
@@ -136,7 +139,7 @@ export class SchedulesRepository_2024_06_11 {
       // note(Lauris): availabilities and overrides are stored in the same "Availability" table,
       // but overrides have "date" field as not-null, while availabilities have it as null, so delete
       // condition below results in deleting only rows from Availability table that are overrides.
-      deleteConditions.push({
+      deleteOverridesStatements.push({
         scheduleId: { equals: scheduleId },
         NOT: { date: null },
       });
@@ -144,7 +147,7 @@ export class SchedulesRepository_2024_06_11 {
 
     if (availability && availability.length > 0) {
       availability.forEach((availability) => {
-        availabilitiesAndOverrides.push({
+        createAvailabilityStatements.push({
           days: availability.days,
           startTime: availability.startTime,
           endTime: availability.endTime,
@@ -155,7 +158,7 @@ export class SchedulesRepository_2024_06_11 {
 
     if (overrides && overrides.length > 0) {
       overrides.forEach((override) => {
-        availabilitiesAndOverrides.push({
+        createOverridesStatements.push({
           date: override.date,
           startTime: override.startTime,
           endTime: override.endTime,
@@ -164,11 +167,21 @@ export class SchedulesRepository_2024_06_11 {
       });
     }
 
-    if (availabilitiesAndOverrides.length > 0) {
+    const deleteStatements = [...deleteAvailabilityStatements, ...deleteOverridesStatements];
+    const createStatements = [...createAvailabilityStatements, ...createOverridesStatements];
+
+    if (deleteStatements.length > 0) {
       updateScheduleData.availability = {
-        deleteMany: deleteConditions,
+        deleteMany: deleteStatements,
+      };
+    }
+
+    if (createStatements.length > 0) {
+      updateScheduleData.availability = {
+        // note(Lauris): keep deleteMany statements
+        ...(updateScheduleData.availability || {}),
         createMany: {
-          data: availabilitiesAndOverrides,
+          data: createStatements,
         },
       };
     }

apps/api/v2/src/env.ts

@@ -10,6 +10,8 @@ export type Environment = {
   DATABASE_URL: string;
   JWT_SECRET: string;
   SENTRY_DSN: string;
+  SENTRY_TRACES_SAMPLE_RATE?: number;
+  SENTRY_PROFILES_SAMPLE_RATE?: number;
   LOG_LEVEL: keyof typeof logLevels;
   REDIS_URL: string;
   STRIPE_API_KEY: string;
@@ -26,6 +28,8 @@ export type Environment = {
   RATE_LIMIT_DEFAULT_LIMIT_ACCESS_TOKEN: number;
   RATE_LIMIT_DEFAULT_LIMIT: number;
   RATE_LIMIT_DEFAULT_BLOCK_DURATION_MS: number;
+  AXIOM_DATASET: string;
+  AXIOM_TOKEN: string;
 };
 
 export const getEnv = <K extends keyof Environment>(key: K, fallback?: Environment[K]): Environment[K] => {

apps/api/v2/src/instrument.ts

@@ -1,12 +1,15 @@
 import { getEnv } from "@/env";
-import * as Sentry from "@sentry/node";
+import * as Sentry from "@sentry/nestjs";
+import { nodeProfilingIntegration } from "@sentry/profiling-node";
 
 if (process.env.SENTRY_DSN) {
   // Ensure to call this before requiring any other modules!
   Sentry.init({
     dsn: getEnv("SENTRY_DSN"),
-    // Add Performance Monitoring by setting tracesSampleRate
-    // We recommend adjusting this value in production
-    // todo: Evaluate? tracesSampleRate: 1.0
+    integrations: [nodeProfilingIntegration()],
+    // Performance Monitoring
+    tracesSampleRate: getEnv("SENTRY_TRACES_SAMPLE_RATE") ?? 1.0, //  Capture 100% of the transactions
+    // Set sampling rate for profiling - this is relative to tracesSampleRate
+    profilesSampleRate: getEnv("SENTRY_PROFILES_SAMPLE_RATE") ?? 1.0,
   });
 }

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

@@ -1,5 +1,7 @@
+import { WinstonTransport as AxiomTransport } from "@axiomhq/winston";
 import type { LoggerOptions } from "winston";
-import { format, transports } from "winston";
+import { format, transports as Transports } from "winston";
+import type Transport from "winston-transport";
 
 const formattedTimestamp = format.timestamp({
   format: "YYYY-MM-DD HH:mm:ss.SSS",
@@ -36,13 +38,25 @@ export const logLevels = {
 export const loggerConfig = (): LoggerOptions => {
   const isProduction = process.env.NODE_ENV === "production";
 
+  const transports: Transport[] = [];
+  transports.push(new Transports.Console());
+
+  if (!!process.env.AXIOM_TOKEN && !!process.env.AXIOM_DATASET) {
+    transports.push(
+      new AxiomTransport({
+        token: process.env.AXIOM_TOKEN,
+        dataset: process.env.AXIOM_DATASET,
+      })
+    );
+  }
+
   return {
     levels: logLevels,
     level: process.env.LOG_LEVEL ?? "info",
     format: isProduction ? WINSTON_PROD_FORMAT : WINSTON_DEV_FORMAT,
-    transports: [new transports.Console()],
-    exceptionHandlers: [new transports.Console()],
-    rejectionHandlers: [new transports.Console()],
+    transports,
+    exceptionHandlers: transports,
+    rejectionHandlers: transports,
     defaultMeta: {
       service: "cal-platform-api",
     },

apps/api/v2/src/main.ts

@@ -1,4 +1,5 @@
 import type { AppConfig } from "@/config/type";
+import { getEnv } from "@/env";
 import { Logger } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { NestFactory } from "@nestjs/core";
@@ -107,13 +108,20 @@ async function generateSwagger(app: NestExpressApplication<Server>) {
   const document = SwaggerModule.createDocument(app, config);
   document.paths = groupAndSortPathsByFirstTag(document.paths);
 
-  const outputFile = "./swagger/documentation.json";
+  const swaggerOutputFile = "./swagger/documentation.json";
+  const docsOutputFile = "../../../docs/api-reference/v2/openapi.json";
+  const stringifiedContents = JSON.stringify(document, null, 2);
 
-  if (fs.existsSync(outputFile)) {
-    fs.unlinkSync(outputFile);
+  if (fs.existsSync(swaggerOutputFile)) {
+    fs.unlinkSync(swaggerOutputFile);
   }
 
-  fs.writeFileSync(outputFile, JSON.stringify(document, null, 2), { encoding: "utf8" });
+  fs.writeFileSync(swaggerOutputFile, stringifiedContents, { encoding: "utf8" });
+
+  if (fs.existsSync(docsOutputFile) && getEnv("NODE_ENV") === "development") {
+    fs.unlinkSync(docsOutputFile);
+    fs.writeFileSync(docsOutputFile, stringifiedContents, { encoding: "utf8" });
+  }
 
   if (!process.env.DOCS_URL) {
     SwaggerModule.setup("docs", app, document, {

apps/api/v2/src/middleware/request-ids/request-id.interceptor.ts

@@ -1,8 +1,11 @@
-import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from "@nestjs/common";
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor, Logger } from "@nestjs/common";
 import { Request, Response } from "express";
+import { tap } from "rxjs/operators";
 
 @Injectable()
 export class ResponseInterceptor implements NestInterceptor {
+  private readonly logger = new Logger("ResponseInterceptor - NestInterceptor");
+
   intercept(context: ExecutionContext, next: CallHandler) {
     const ctx = context.switchToHttp();
     const request = ctx.getRequest<Request>();
@@ -10,7 +13,24 @@ export class ResponseInterceptor implements NestInterceptor {
 
     const requestId = request.headers["X-Request-Id"] ?? "unknown-request-id";
     response.setHeader("X-Request-Id", requestId.toString());
+    const { method, url } = request;
+    const startTime = Date.now();
 
-    return next.handle();
+    return next.handle().pipe(
+      tap((data) => {
+        const { statusCode } = response;
+        const responseTime = Date.now() - startTime;
+
+        this.logger.log("Outgoing Response", {
+          requestId,
+          method,
+          url,
+          statusCode,
+          responseTime,
+          responseBody: data,
+          timestamp: new Date().toISOString(),
+        });
+      })
+    );
   }
 }

apps/api/v2/src/middleware/request-ids/request-id.middleware.ts

@@ -1,11 +1,25 @@
-import { Injectable, NestMiddleware } from "@nestjs/common";
+import { Injectable, NestMiddleware, Logger } from "@nestjs/common";
 import { Request, Response, NextFunction } from "express";
 import { v4 as uuid } from "uuid";
 
 @Injectable()
 export class RequestIdMiddleware implements NestMiddleware {
+  private readonly logger = new Logger("RequestIdMiddleware - NestMiddleware");
+
   use(req: Request, res: Response, next: NextFunction) {
-    req.headers["X-Request-Id"] = uuid();
+    const requestId = uuid();
+    req.headers["X-Request-Id"] = requestId;
+    const { method, headers, body: requestBody, baseUrl } = req;
+
+    this.logger.log("Incoming Request", {
+      requestId,
+      method,
+      url: baseUrl,
+      headers,
+      requestBody,
+      timestamp: new Date().toISOString(),
+    });
+
     next();
   }
 }

apps/api/v2/src/modules/apps/apps.repository.ts

@@ -21,4 +21,15 @@ export class AppsRepository {
       },
     });
   }
+
+  async createTeamAppCredential(type: string, key: Prisma.InputJsonValue, teamId: number, appId: string) {
+    return this.dbWrite.prisma.credential.create({
+      data: {
+        type: type,
+        key: key,
+        teamId: teamId,
+        appId: appId,
+      },
+    });
+  }
 }

apps/api/v2/src/modules/atoms/atoms.module.ts

@@ -1,19 +1,24 @@
 import { EventTypesModule_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.module";
 import { SchedulesRepository_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.repository";
+import { AtomsRepository } from "@/modules/atoms/atoms.repository";
 import { AtomsController } from "@/modules/atoms/controllers/atoms.controller";
 import { EventTypesAtomService } from "@/modules/atoms/services/event-types-atom.service";
+import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
+import { OrganizationsModule } from "@/modules/organizations/organizations.module";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { UsersService } from "@/modules/users/services/users.service";
 import { UsersRepository } from "@/modules/users/users.repository";
 import { Module } from "@nestjs/common";
 
 @Module({
-  imports: [PrismaModule, EventTypesModule_2024_06_14],
+  imports: [PrismaModule, EventTypesModule_2024_06_14, OrganizationsModule],
   providers: [
     EventTypesAtomService,
     MembershipsRepository,
+    CredentialsRepository,
     UsersRepository,
+    AtomsRepository,
     UsersService,
     SchedulesRepository_2024_06_11,
   ],

apps/api/v2/src/modules/atoms/atoms.repository.ts

@@ -0,0 +1,17 @@
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+
+import { paymentDataSelect } from "@calcom/platform-libraries";
+
+@Injectable()
+export class AtomsRepository {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async getRawPayment(uid: string) {
+    return await this.dbRead.prisma.payment.findFirst({
+      where: { uid },
+      select: paymentDataSelect,
+    });
+  }
+}

apps/api/v2/src/modules/atoms/controllers/atoms.controller.ts

@@ -1,4 +1,5 @@
 import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { EventTypesAppInput } from "@/modules/atoms/inputs/event-types-app.input";
 import { EventTypesAtomService } from "@/modules/atoms/services/event-types-atom.service";
 import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
 import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
@@ -13,6 +14,7 @@ import {
   VERSION_NEUTRAL,
   Patch,
   Body,
+  Query,
 } from "@nestjs/common";
 import { ApiTags as DocsTags, ApiExcludeController as DocsExcludeController } from "@nestjs/swagger";
 
@@ -50,6 +52,38 @@ export class AtomsController {
     };
   }
 
+  @Get("event-types-app/:appSlug")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async getAtomEventTypeApp(
+    @GetUser() user: UserWithProfile,
+    @Param("appSlug") appSlug: string,
+    @Query() queryParams: EventTypesAppInput
+  ): Promise<ApiResponse<unknown>> {
+    const { teamId } = queryParams;
+
+    const app = await this.eventTypesService.getEventTypesAppIntegration(appSlug, user.id, user.name, teamId);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: {
+        app,
+      },
+    };
+  }
+
+  @Get("payment/:uid")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async getUserPaymentInfoById(@Param("uid") uid: string): Promise<ApiResponse<unknown>> {
+    const data = await this.eventTypesService.getUserPaymentInfo(uid);
+
+    return {
+      status: SUCCESS_STATUS,
+      data,
+    };
+  }
+
   @Patch("event-types/:eventTypeId")
   @Version(VERSION_NEUTRAL)
   @UseGuards(ApiAuthGuard)
@@ -64,4 +98,20 @@ export class AtomsController {
       data: eventType,
     };
   }
+
+  @Patch("/organizations/:organizationId/teams/:teamId/event-types/:eventTypeId")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async updateAtomTeamEventType(
+    @GetUser() user: UserWithProfile,
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Body() body: UpdateEventTypeReturn
+  ): Promise<ApiResponse<UpdateEventTypeReturn>> {
+    const eventType = await this.eventTypesService.updateTeamEventType(eventTypeId, body, user, teamId);
+    return {
+      status: SUCCESS_STATUS,
+      data: eventType,
+    };
+  }
 }

apps/api/v2/src/modules/atoms/inputs/event-types-app.input.ts

@@ -0,0 +1,9 @@
+import { Transform } from "class-transformer";
+import { IsNumber, IsOptional } from "class-validator";
+
+export class EventTypesAppInput {
+  @Transform(({ value }: { value: string }) => value && parseInt(value))
+  @IsNumber()
+  @IsOptional()
+  teamId?: number;
+}

apps/api/v2/src/modules/atoms/services/event-types-atom.service.ts

@@ -1,31 +1,58 @@
 import { EventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/event-types.service";
+import { AtomsRepository } from "@/modules/atoms/atoms.repository";
+import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
+import { OrganizationsTeamsRepository } from "@/modules/organizations/repositories/organizations-teams.repository";
+import { OrganizationsEventTypesService } from "@/modules/organizations/services/event-types/organizations-event-types.service";
 import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { UsersService } from "@/modules/users/services/users.service";
 import { UserWithProfile } from "@/modules/users/users.repository";
-import { Injectable, NotFoundException } from "@nestjs/common";
+import { Injectable, NotFoundException, ForbiddenException } from "@nestjs/common";
 
 import {
   updateEventType,
   TUpdateEventTypeInputSchema,
   systemBeforeFieldEmail,
   getEventTypeById,
+  getEnabledAppsFromCredentials,
+  getAppFromSlug,
+  MembershipRole,
+  EventTypeMetaDataSchema,
 } from "@calcom/platform-libraries";
+import type {
+  App,
+  CredentialDataWithTeamName,
+  LocationOption,
+  TeamQuery,
+  CredentialOwner,
+  TDependencyData,
+  CredentialPayload,
+} from "@calcom/platform-libraries";
+import { getClientSecretFromPayment } from "@calcom/platform-libraries";
 import { PrismaClient } from "@calcom/prisma/client";
 
+type EnabledAppType = App & {
+  credential: CredentialDataWithTeamName;
+  credentials: CredentialDataWithTeamName[];
+  locationOption: LocationOption | null;
+};
+
 @Injectable()
 export class EventTypesAtomService {
   constructor(
     private readonly membershipsRepository: MembershipsRepository,
+    private readonly credentialsRepository: CredentialsRepository,
+    private readonly atomsRepository: AtomsRepository,
+    private readonly organizationsTeamsRepository: OrganizationsTeamsRepository,
     private readonly usersService: UsersService,
     private readonly dbWrite: PrismaWriteService,
     private readonly dbRead: PrismaReadService,
-    private readonly eventTypeService: EventTypesService_2024_06_14
+    private readonly eventTypeService: EventTypesService_2024_06_14,
+    private readonly teamEventTypeService: OrganizationsEventTypesService
   ) {}
 
   async getUserEventType(user: UserWithProfile, eventTypeId: number) {
-    this.eventTypeService.checkUserOwnsEventType(user.id, { id: eventTypeId, userId: user.id });
     const organizationId = this.usersService.getUserMainOrgId(user);
 
     const isUserOrganizationAdmin = organizationId
@@ -45,12 +72,22 @@ export class EventTypesAtomService {
       throw new NotFoundException(`Event type with id ${eventTypeId} not found`);
     }
 
-    this.eventTypeService.checkUserOwnsEventType(user.id, eventType.eventType);
+    if (eventType?.team?.id) {
+      await this.checkTeamOwnsEventType(user.id, eventType.eventType.id, eventType.team.id);
+    } else {
+      this.eventTypeService.checkUserOwnsEventType(user.id, eventType.eventType);
+    }
+
     return eventType;
   }
 
-  async updateEventType(eventTypeId: number, body: TUpdateEventTypeInputSchema, user: UserWithProfile) {
-    this.eventTypeService.checkCanUpdateEventType(user.id, eventTypeId, body.scheduleId);
+  async updateTeamEventType(
+    eventTypeId: number,
+    body: TUpdateEventTypeInputSchema,
+    user: UserWithProfile,
+    teamId: number
+  ) {
+    await this.checkCanUpdateTeamEventType(user.id, eventTypeId, teamId, body.scheduleId);
     const eventTypeUser = await this.eventTypeService.getUserToUpdateEvent(user);
     const bookingFields = [...(body.bookingFields || [])];
 
@@ -77,4 +114,207 @@ export class EventTypesAtomService {
 
     return eventType.eventType;
   }
+
+  async updateEventType(eventTypeId: number, body: TUpdateEventTypeInputSchema, user: UserWithProfile) {
+    await this.eventTypeService.checkCanUpdateEventType(user.id, eventTypeId, body.scheduleId);
+    const eventTypeUser = await this.eventTypeService.getUserToUpdateEvent(user);
+    const bookingFields = [...(body.bookingFields || [])];
+
+    if (
+      !bookingFields.find((field) => field.type === "email") &&
+      !bookingFields.find((field) => field.type === "phone")
+    ) {
+      bookingFields.push(systemBeforeFieldEmail);
+    }
+
+    const eventType = await updateEventType({
+      input: { id: eventTypeId, ...body, bookingFields },
+      ctx: {
+        user: eventTypeUser,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        prisma: this.dbWrite.prisma,
+      },
+    });
+
+    if (!eventType) {
+      throw new NotFoundException(`Event type with id ${eventTypeId} not found`);
+    }
+
+    return eventType.eventType;
+  }
+
+  async checkCanUpdateTeamEventType(userId: number, eventTypeId: number, teamId: number, scheduleId: number) {
+    await this.checkTeamOwnsEventType(userId, eventTypeId, teamId);
+    await this.teamEventTypeService.validateEventTypeExists(teamId, eventTypeId);
+    await this.eventTypeService.checkUserOwnsSchedule(userId, scheduleId);
+  }
+
+  async checkTeamOwnsEventType(userId: number, eventTypeId: number, teamId: number) {
+    const membership = await this.dbRead.prisma.membership.findFirst({
+      where: {
+        userId,
+        teamId,
+        accepted: true,
+        OR: [{ role: "ADMIN" }, { role: "OWNER" }],
+      },
+      select: {
+        team: {
+          select: {
+            eventTypes: true,
+          },
+        },
+      },
+    });
+    if (!membership?.team?.eventTypes?.some((item) => item.id === eventTypeId)) {
+      throw new ForbiddenException(
+        `Access denied. Either the team with ID=${teamId} does not own the event type with ID=${eventTypeId}, or your MEMBER role does not have permission to access this resource.`
+      );
+    }
+  }
+
+  async getEventTypesAppIntegration(slug: string, userId: number, userName: string | null, teamId?: number) {
+    let credentials = await this.credentialsRepository.getAllUserCredentialsById(userId);
+    let userTeams: TeamQuery[] = [];
+    if (teamId) {
+      const teamsQuery = await this.organizationsTeamsRepository.getUserTeamsById(userId);
+      // If a team is a part of an org then include those apps
+      // Don't want to iterate over these parent teams
+      const filteredTeams: TeamQuery[] = [];
+      const parentTeams: TeamQuery[] = [];
+      // Only loop and grab parent teams if a teamId was given. If not then all teams will be queried
+      if (teamId) {
+        teamsQuery.forEach((team) => {
+          if (team?.parent) {
+            const { parent, ...filteredTeam } = team;
+            filteredTeams.push(filteredTeam);
+            // Only add parent team if it's not already in teamsQuery
+            if (!teamsQuery.some((t) => t.id === parent.id)) {
+              parentTeams.push(parent);
+            }
+          }
+        });
+      }
+      userTeams = [...teamsQuery, ...parentTeams];
+      const teamAppCredentials: CredentialPayload[] = userTeams.flatMap((teamApp) => {
+        return teamApp.credentials ? teamApp.credentials.flat() : [];
+      });
+      if (teamId) {
+        credentials = teamAppCredentials;
+      } else {
+        credentials = credentials.concat(teamAppCredentials);
+      }
+    }
+    const enabledApps = await getEnabledAppsFromCredentials(credentials, {
+      where: { slug },
+    });
+    const apps = await Promise.all(
+      enabledApps
+        .filter(({ ...app }) => app.slug === slug)
+        .map(
+          async ({
+            credentials: _,
+            credential,
+            key: _2 /* don't leak to frontend */,
+            ...app
+          }: EnabledAppType) => {
+            const userCredentialIds = credentials
+              .filter((c) => c.appId === app.slug && !c.teamId)
+              .map((c) => c.id);
+            const invalidCredentialIds = credentials
+              .filter((c) => c.appId === app.slug && c.invalid)
+              .map((c) => c.id);
+            const teams = await Promise.all(
+              credentials
+                .filter((c) => c.appId === app.slug && c.teamId)
+                .map(async (c) => {
+                  const team = userTeams.find((team) => team.id === c.teamId);
+                  if (!team) {
+                    return null;
+                  }
+                  return {
+                    teamId: team.id,
+                    name: team.name,
+                    logoUrl: team.logoUrl,
+                    credentialId: c.id,
+                    isAdmin:
+                      team.members[0].role === MembershipRole.ADMIN ||
+                      team.members[0].role === MembershipRole.OWNER,
+                  };
+                })
+            );
+            const isSetupAlready = credential && app.categories.includes("payment") ? true : undefined;
+            let dependencyData: TDependencyData = [];
+            if (app.dependencies?.length) {
+              dependencyData = app.dependencies.map((dependency) => {
+                const dependencyInstalled = enabledApps.some(
+                  (dbAppIterator: EnabledAppType) =>
+                    dbAppIterator.credentials.length && dbAppIterator.slug === dependency
+                );
+                // If the app marked as dependency is simply deleted from the codebase,
+                // we can have the situation where App is marked installed in DB but we couldn't get the app.
+                const dependencyName = getAppFromSlug(dependency)?.name;
+                return { name: dependencyName, installed: dependencyInstalled };
+              });
+            }
+            const credentialOwner: CredentialOwner = {
+              name: userName,
+              teamId,
+            };
+            return {
+              ...app,
+              ...(teams.length && {
+                credentialOwner,
+              }),
+              userCredentialIds,
+              invalidCredentialIds,
+              teams,
+              isInstalled: !!userCredentialIds.length || !!teams.length || app.isGlobal,
+              isSetupAlready,
+              ...(app.dependencies && { dependencyData }),
+            };
+          }
+        )
+    );
+    return apps[0];
+  }
+
+  async getUserPaymentInfo(uid: string) {
+    const rawPayment = await this.atomsRepository.getRawPayment(uid);
+    if (!rawPayment) throw new NotFoundException(`Payment with uid ${uid} not found`);
+    const { data, booking: _booking, ...restPayment } = rawPayment;
+    const payment = {
+      ...restPayment,
+      data: data as Record<string, unknown>,
+    };
+    if (!_booking) throw new NotFoundException(`Booking with uid ${uid} not found`);
+    const { startTime, endTime, eventType, ...restBooking } = _booking;
+    const booking = {
+      ...restBooking,
+      startTime: startTime.toString(),
+      endTime: endTime.toString(),
+    };
+    if (!eventType) throw new NotFoundException(`Event type with uid ${uid} not found`);
+    if (eventType.users.length === 0 && !!!eventType.team)
+      throw new NotFoundException(`No users found or no team present for event type with uid ${uid}`);
+    const [user] = eventType?.users.length
+      ? eventType.users
+      : [{ name: null, theme: null, hideBranding: null, username: null }];
+    const profile = {
+      name: eventType.team?.name || user?.name || null,
+      theme: (!eventType.team?.name && user?.theme) || null,
+      hideBranding: eventType.team?.hideBranding || user?.hideBranding || null,
+    };
+    return {
+      user,
+      eventType: {
+        ...eventType,
+        metadata: EventTypeMetaDataSchema.parse(eventType.metadata),
+      },
+      booking,
+      payment,
+      clientSecret: getClientSecretFromPayment(payment),
+      profile,
+    };
+  }
 }

apps/api/v2/src/modules/auth/guards/users/is-user-in-org-team.guard.ts

@@ -0,0 +1,42 @@
+import { OrganizationsRepository } from "@/modules/organizations/organizations.repository";
+import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from "@nestjs/common";
+import { Request } from "express";
+
+import { Team } from "@calcom/prisma/client";
+
+@Injectable()
+export class IsUserInOrgTeam implements CanActivate {
+  constructor(private organizationsRepository: OrganizationsRepository) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest<Request & { team: Team }>();
+    const teamId: string = request.params.teamId;
+    const orgId: string = request.params.orgId;
+    const userId: string = request.params.userId;
+
+    if (!userId) {
+      throw new ForbiddenException("No user id found in request params.");
+    }
+
+    if (!orgId) {
+      throw new ForbiddenException("No org id found in request params.");
+    }
+
+    if (!teamId) {
+      throw new ForbiddenException("No team id found in request params.");
+    }
+
+    const user = await this.organizationsRepository.findOrgTeamUser(
+      Number(orgId),
+      Number(teamId),
+      Number(userId)
+    );
+
+    if (user) {
+      request.user = user;
+      return true;
+    }
+
+    return false;
+  }
+}

apps/api/v2/src/modules/billing/billing.processor.ts

@@ -46,9 +46,9 @@ export class BillingProcessor {
         return;
       }
 
-      const stripeSubscription = await this.stripeService.stripe.subscriptions.retrieve(
-        billingSubscription.subscriptionId
-      );
+      const stripeSubscription = await this.stripeService
+        .getStripe()
+        .subscriptions.retrieve(billingSubscription.subscriptionId);
       if (!stripeSubscription?.id) {
         this.logger.error(`Failed to retrieve stripe subscription (${billingSubscription.subscriptionId})`, {
           teamId,
@@ -69,7 +69,7 @@ export class BillingProcessor {
         return;
       }
 
-      await this.stripeService.stripe.subscriptionItems.createUsageRecord(meteredItem.id, {
+      await this.stripeService.getStripe().subscriptionItems.createUsageRecord(meteredItem.id, {
         action: "increment",
         quantity: 1,
         timestamp: "now",

apps/api/v2/src/modules/billing/billing.repository.ts

@@ -1,10 +1,11 @@
 import { PlatformPlan } from "@/modules/billing/types";
 import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
-import { Injectable } from "@nestjs/common";
+import { Injectable, Logger } from "@nestjs/common";
 
 @Injectable()
 export class BillingRepository {
+  private readonly logger = new Logger("BillingRepository");
   constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
 
   getBillingForTeam = (teamId: number) =>
@@ -30,6 +31,35 @@ export class BillingRepository {
         billingCycleEnd: billingEnd,
         subscriptionId,
         plan: plan.toString(),
+        overdue: false,
+      },
+    });
+  }
+
+  async updateBillingOverdue(subId: string, cusId: string, overdue: boolean) {
+    try {
+      return this.dbWrite.prisma.platformBilling.update({
+        where: {
+          subscriptionId: subId,
+          customerId: cusId,
+        },
+        data: {
+          overdue,
+        },
+      });
+    } catch (err) {
+      this.logger.error("Could not update billing overdue", {
+        subId,
+        cusId,
+        err,
+      });
+    }
+  }
+
+  async deleteBilling(id: number) {
+    return this.dbWrite.prisma.platformBilling.delete({
+      where: {
+        id,
       },
     });
   }

apps/api/v2/src/modules/billing/controllers/billing.controller.e2e-spec.ts

@@ -0,0 +1,211 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { StripeService } from "@/modules/stripe/stripe.service";
+import { TokensModule } from "@/modules/tokens/tokens.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { UserWithProfile } from "@/modules/users/users.repository";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import Stripe from "stripe";
+import * as request from "supertest";
+import { PlatformBillingRepositoryFixture } from "test/fixtures/repository/billing.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.repository.fixture";
+import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { withApiAuth } from "test/utils/withApiAuth";
+
+import { Team, PlatformOAuthClient, PlatformBilling } from "@calcom/prisma/client";
+
+describe("Platform Billing Controller (e2e)", () => {
+  let app: INestApplication;
+  const userEmail = "platform-billing-controller-e2e@api.com";
+  let user: UserWithProfile;
+  let billing: PlatformBilling;
+  let userRepositoryFixture: UserRepositoryFixture;
+  let organizationsRepositoryFixture: OrganizationRepositoryFixture;
+  let profileRepositoryFixture: ProfileRepositoryFixture;
+  let membershipsRepositoryFixture: MembershipRepositoryFixture;
+  let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+  let oAuthClient: PlatformOAuthClient;
+  let platformBillingRepositoryFixture: PlatformBillingRepositoryFixture;
+  let organization: Team;
+
+  beforeAll(async () => {
+    const moduleRef = await withApiAuth(
+      userEmail,
+      Test.createTestingModule({
+        imports: [AppModule, PrismaModule, UsersModule, TokensModule],
+      })
+    ).compile();
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+    organizationsRepositoryFixture = new OrganizationRepositoryFixture(moduleRef);
+    profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+    oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+    membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+    platformBillingRepositoryFixture = new PlatformBillingRepositoryFixture(moduleRef);
+    organization = await organizationsRepositoryFixture.create({ name: "platform billing" });
+
+    user = await userRepositoryFixture.create({
+      email: userEmail,
+      username: userEmail,
+    });
+
+    await profileRepositoryFixture.create({
+      uid: `usr-${user.id}`,
+      username: userEmail,
+      organization: {
+        connect: {
+          id: organization.id,
+        },
+      },
+      user: {
+        connect: {
+          id: user.id,
+        },
+      },
+    });
+    await membershipsRepositoryFixture.create({
+      role: "OWNER",
+      team: { connect: { id: organization.id } },
+      user: { connect: { id: user.id } },
+      accepted: true,
+    });
+
+    billing = await platformBillingRepositoryFixture.create(organization.id);
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    await app.init();
+  });
+
+  afterAll(async () => {
+    userRepositoryFixture.deleteByEmail(user.email);
+    await app.close();
+  });
+
+  it("/billing/webhook (POST) should set billing free plan for org", () => {
+    jest.spyOn(StripeService.prototype, "getStripe").mockImplementation(
+      () =>
+        ({
+          webhooks: {
+            constructEventAsync: async () => {
+              return {
+                type: "checkout.session.completed",
+                data: {
+                  object: {
+                    metadata: {
+                      teamId: organization.id,
+                      plan: "FREE",
+                    },
+                    mode: "subscription",
+                  },
+                },
+              };
+            },
+          },
+        } as unknown as Stripe)
+    );
+
+    return request(app.getHttpServer())
+      .post("/v2/billing/webhook")
+      .expect(200)
+      .then(async (res) => {
+        const billing = await platformBillingRepositoryFixture.get(organization.id);
+        expect(billing?.plan).toEqual("FREE");
+      });
+  });
+  it("/billing/webhook (POST) failed payment should set billing free plan to overdue", () => {
+    jest.spyOn(StripeService.prototype, "getStripe").mockImplementation(
+      () =>
+        ({
+          webhooks: {
+            constructEventAsync: async () => {
+              return {
+                type: "invoice.payment_failed",
+                data: {
+                  object: {
+                    customer: billing?.customerId,
+                    subscription: billing?.subscriptionId,
+                  },
+                },
+              };
+            },
+          },
+        } as unknown as Stripe)
+    );
+
+    return request(app.getHttpServer())
+      .post("/v2/billing/webhook")
+      .expect(200)
+      .then(async (res) => {
+        const billing = await platformBillingRepositoryFixture.get(organization.id);
+        expect(billing?.overdue).toEqual(true);
+      });
+  });
+
+  it("/billing/webhook (POST) success payment should set billing free plan to not overdue", () => {
+    jest.spyOn(StripeService.prototype, "getStripe").mockImplementation(
+      () =>
+        ({
+          webhooks: {
+            constructEventAsync: async () => {
+              return {
+                type: "invoice.payment_succeeded",
+                data: {
+                  object: {
+                    customer: billing?.customerId,
+                    subscription: billing?.subscriptionId,
+                  },
+                },
+              };
+            },
+          },
+        } as unknown as Stripe)
+    );
+
+    return request(app.getHttpServer())
+      .post("/v2/billing/webhook")
+      .expect(200)
+      .then(async (res) => {
+        const billing = await platformBillingRepositoryFixture.get(organization.id);
+        expect(billing?.overdue).toEqual(false);
+      });
+  });
+
+  it("/billing/webhook (POST) should delete subscription", () => {
+    jest.spyOn(StripeService.prototype, "getStripe").mockImplementation(
+      () =>
+        ({
+          webhooks: {
+            constructEventAsync: async () => {
+              return {
+                type: "customer.subscription.deleted",
+                data: {
+                  object: {
+                    metadata: {
+                      teamId: organization.id,
+                      plan: "FREE",
+                    },
+                    id: billing?.subscriptionId,
+                  },
+                },
+              };
+            },
+          },
+        } as unknown as Stripe)
+    );
+
+    return request(app.getHttpServer())
+      .post("/v2/billing/webhook")
+      .expect(200)
+      .then(async (res) => {
+        const billing = await platformBillingRepositoryFixture.get(organization.id);
+        expect(billing).toBeNull();
+      });
+  });
+});

apps/api/v2/src/modules/billing/controllers/billing.controller.ts

@@ -102,13 +102,26 @@ export class BillingController {
     @Req() request: Request,
     @Headers("stripe-signature") stripeSignature: string
   ): Promise<ApiResponse> {
-    const event = await this.billingService.stripeService.stripe.webhooks.constructEventAsync(
-      request.body,
-      stripeSignature,
-      this.stripeWhSecret
-    );
+    const event = await this.billingService.stripeService
+      .getStripe()
+      .webhooks.constructEventAsync(request.body, stripeSignature, this.stripeWhSecret);
 
-    await this.billingService.createOrUpdateStripeSubscription(event);
+    switch (event.type) {
+      case "checkout.session.completed":
+        await this.billingService.handleStripeCheckoutEvents(event);
+        break;
+      case "customer.subscription.deleted":
+        await this.billingService.handleStripeSubscriptionDeleted(event);
+        break;
+      case "invoice.payment_failed":
+        await this.billingService.handleStripePaymentFailed(event);
+        break;
+      case "invoice.payment_succeeded":
+        await this.billingService.handleStripePaymentSuccess(event);
+        break;
+      default:
+        break;
+    }
 
     return {
       status: "success",

apps/api/v2/src/modules/billing/services/billing.service.ts

@@ -64,7 +64,7 @@ export class BillingService implements OnModuleDestroy {
   }
 
   async redirectToSubscribeCheckout(teamId: number, plan: PlatformPlan, customerId?: string) {
-    const { url } = await this.stripeService.stripe.checkout.sessions.create({
+    const { url } = await this.stripeService.getStripe().checkout.sessions.create({
       customer: customerId,
       line_items: [
         {
@@ -101,7 +101,7 @@ export class BillingService implements OnModuleDestroy {
     const teamWithBilling = await this.teamsRepository.findByIdIncludeBilling(teamId);
     const customerId = teamWithBilling?.platformBilling?.customerId;
 
-    const { url } = await this.stripeService.stripe.checkout.sessions.create({
+    const { url } = await this.stripeService.getStripe().checkout.sessions.create({
       customer: customerId,
       success_url: `${this.webAppUrl}/settings/platform/`,
       cancel_url: `${this.webAppUrl}/settings/platform/plans`,
@@ -131,41 +131,92 @@ export class BillingService implements OnModuleDestroy {
     );
   }
 
-  async createOrUpdateStripeSubscription(event: Stripe.Event) {
-    if (event.type === "checkout.session.completed") {
-      const subscription = event.data.object as Stripe.Checkout.Session;
-
-      if (!subscription.metadata?.teamId) {
-        return {
-          status: "success",
-        };
-      }
-
-      const teamId = Number.parseInt(subscription.metadata.teamId);
-      const plan = subscription.metadata.plan;
-      if (!plan || !teamId) {
-        this.logger.log("Webhook received but not pertaining to Platform, discarding.");
-        return {
-          status: "success",
-        };
-      }
-
-      if (subscription.mode === "subscription") {
-        await this.setSubscriptionForTeam(
+  async handleStripeSubscriptionDeleted(event: Stripe.Event) {
+    const subscription = event.data.object as Stripe.Subscription;
+    const teamId = subscription?.metadata?.teamId;
+    const plan = PlatformPlan[subscription?.metadata?.plan?.toUpperCase() as keyof typeof PlatformPlan];
+    if (teamId && plan) {
+      const currentBilling = await this.billingRepository.getBillingForTeam(Number.parseInt(teamId));
+      if (currentBilling?.subscriptionId === subscription.id) {
+        await this.billingRepository.deleteBilling(currentBilling.id);
+        this.logger.log(`Stripe Subscription deleted`, {
+          customerId: currentBilling.customerId,
+          subscriptionId: currentBilling.subscriptionId,
           teamId,
-          subscription.subscription as string,
-          PlatformPlan[plan.toUpperCase() as keyof typeof PlatformPlan]
-        );
+        });
+        return;
       }
-
-      if (subscription.mode === "setup") {
-        await this.updateStripeSubscriptionForTeam(teamId, plan as PlatformPlan);
-      }
-
-      return {
-        status: "success",
-      };
+      this.logger.log("No platform billing found.");
+      return;
     }
+    this.logger.log("Webhook received but not pertaining to Platform, discarding.");
+    return;
+  }
+
+  getSubscriptionIdFromInvoice(invoice: Stripe.Invoice): string | null {
+    if (typeof invoice.subscription === "string") {
+      return invoice.subscription;
+    } else if (invoice.subscription && typeof invoice.subscription === "object") {
+      return invoice.subscription.id;
+    } else {
+      return null;
+    }
+  }
+  getCustomerIdFromInvoice(invoice: Stripe.Invoice): string | null {
+    if (typeof invoice.customer === "string") {
+      return invoice.customer;
+    } else if (invoice.customer && typeof invoice.customer === "object") {
+      return invoice.customer.id;
+    } else {
+      return null;
+    }
+  }
+
+  async handleStripePaymentSuccess(event: Stripe.Event) {
+    const invoice = event.data.object as Stripe.Invoice;
+    const subscriptionId = this.getSubscriptionIdFromInvoice(invoice);
+    const customerId = this.getCustomerIdFromInvoice(invoice);
+    if (subscriptionId && customerId) {
+      await this.billingRepository.updateBillingOverdue(subscriptionId, customerId, false);
+    }
+  }
+
+  async handleStripePaymentFailed(event: Stripe.Event) {
+    const invoice = event.data.object as Stripe.Invoice;
+    const subscriptionId = this.getSubscriptionIdFromInvoice(invoice);
+    const customerId = this.getCustomerIdFromInvoice(invoice);
+    if (subscriptionId && customerId) {
+      await this.billingRepository.updateBillingOverdue(subscriptionId, customerId, true);
+    }
+  }
+
+  async handleStripeCheckoutEvents(event: Stripe.Event) {
+    const checkoutSession = event.data.object as Stripe.Checkout.Session;
+
+    if (!checkoutSession.metadata?.teamId) {
+      return;
+    }
+
+    const teamId = Number.parseInt(checkoutSession.metadata.teamId);
+    const plan = checkoutSession.metadata.plan;
+    if (!plan || !teamId) {
+      this.logger.log("Webhook received but not pertaining to Platform, discarding.");
+      return;
+    }
+
+    if (checkoutSession.mode === "subscription") {
+      await this.setSubscriptionForTeam(
+        teamId,
+        checkoutSession.subscription as string,
+        PlatformPlan[plan.toUpperCase() as keyof typeof PlatformPlan]
+      );
+    }
+
+    if (checkoutSession.mode === "setup") {
+      await this.updateStripeSubscriptionForTeam(teamId, plan as PlatformPlan);
+    }
+
+    return;
   }
 
   async updateStripeSubscriptionForTeam(teamId: number, plan: PlatformPlan) {
@@ -175,9 +226,9 @@ export class BillingService implements OnModuleDestroy {
       throw new NotFoundException("Team plan not found");
     }
 
-    const existingUserSubscription = await this.stripeService.stripe.subscriptions.retrieve(
-      teamWithBilling?.platformBilling?.subscriptionId
-    );
+    const existingUserSubscription = await this.stripeService
+      .getStripe()
+      .subscriptions.retrieve(teamWithBilling?.platformBilling?.subscriptionId);
     const currentLicensedItem = existingUserSubscription.items.data.find(
       (item) => item.price?.recurring?.usage_type === "licensed"
     );
@@ -193,21 +244,23 @@ export class BillingService implements OnModuleDestroy {
       throw new NotFoundException("There is no overage item present in the subscription");
     }
 
-    await this.stripeService.stripe.subscriptions.update(teamWithBilling?.platformBilling?.subscriptionId, {
-      items: [
-        {
-          id: currentLicensedItem.id,
-          price: this.billingConfigService.get(plan)?.base,
-        },
-        {
-          id: currentOverageItem.id,
-          price: this.billingConfigService.get(plan)?.overage,
-          clear_usage: false,
-        },
-      ],
-      billing_cycle_anchor: "now",
-      proration_behavior: "create_prorations",
-    });
+    await this.stripeService
+      .getStripe()
+      .subscriptions.update(teamWithBilling?.platformBilling?.subscriptionId, {
+        items: [
+          {
+            id: currentLicensedItem.id,
+            price: this.billingConfigService.get(plan)?.base,
+          },
+          {
+            id: currentOverageItem.id,
+            price: this.billingConfigService.get(plan)?.overage,
+            clear_usage: false,
+          },
+        ],
+        billing_cycle_anchor: "now",
+        proration_behavior: "create_prorations",
+      });
 
     await this.setSubscriptionForTeam(
       teamId,

apps/api/v2/src/modules/billing/types.ts

@@ -1,8 +1,9 @@
 export enum PlatformPlan {
+  FREE = "FREE",
   STARTER = "STARTER",
   ESSENTIALS = "ESSENTIALS",
   SCALE = "SCALE",
   ENTERPRISE = "ENTERPRISE",
 }
 
-export type PlatformPlanType = "STARTER" | "ESSENTIALS" | "SCALE" | "ENTERPRISE";
+export type PlatformPlanType = "FREE" | "STARTER" | "ESSENTIALS" | "SCALE" | "ENTERPRISE";

apps/api/v2/src/modules/booking-seat/booking-seat.module.ts

@@ -0,0 +1,10 @@
+import { BookingSeatRepository } from "@/modules/booking-seat/booking-seat.repository";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { Module } from "@nestjs/common";
+
+@Module({
+  imports: [PrismaModule],
+  providers: [BookingSeatRepository],
+  exports: [BookingSeatRepository],
+})
+export class BookingSeatModule {}

apps/api/v2/src/modules/booking-seat/booking-seat.repository.ts

@@ -0,0 +1,20 @@
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+import { Prisma } from "@prisma/client";
+
+@Injectable()
+export class BookingSeatRepository {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async getByReferenceUid(referenceUid: string) {
+    return this.dbRead.prisma.bookingSeat.findUnique({
+      where: {
+        referenceUid,
+      },
+      include: {
+        booking: { select: { uid: true } },
+      },
+    });
+  }
+}

apps/api/v2/src/modules/credentials/credentials.repository.ts

@@ -4,6 +4,7 @@ import { Injectable } from "@nestjs/common";
 import { Prisma } from "@prisma/client";
 
 import { APPS_TYPE_ID_MAPPING } from "@calcom/platform-constants";
+import { credentialForCalendarServiceSelect } from "@calcom/platform-libraries";
 
 @Injectable()
 export class CredentialsRepository {
@@ -36,6 +37,10 @@ export class CredentialsRepository {
     return this.dbWrite.prisma.credential.findFirst({ where: { type, userId } });
   }
 
+  getByTypeAndTeamId(type: string, teamId: number) {
+    return this.dbWrite.prisma.credential.findFirst({ where: { type, teamId } });
+  }
+
   getAllUserCredentialsByTypeAndId(type: string, userId: number) {
     return this.dbRead.prisma.credential.findMany({ where: { type, userId } });
   }
@@ -65,6 +70,18 @@ export class CredentialsRepository {
     });
   }
 
+  async getAllUserCredentialsById(userId: number) {
+    return await this.dbRead.prisma.credential.findMany({
+      where: {
+        userId,
+      },
+      select: credentialForCalendarServiceSelect,
+      orderBy: {
+        id: "asc",
+      },
+    });
+  }
+
   async getUserCredentialById(userId: number, credentialId: number, type: string) {
     return await this.dbRead.prisma.credential.findUnique({
       where: {

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

@@ -248,6 +248,30 @@ describe("OAuth Client Users Endpoints", () => {
       expect(schedule?.userId).toEqual(userId);
     }
 
+    it(`should fail /POST using already used managed user email`, async () => {
+      const requestBody: CreateManagedUserInput = {
+        email: userEmail,
+        timeZone: userTimeZone,
+        weekStart: "Monday",
+        timeFormat: 24,
+        locale: Locales.FR,
+        name: "Alice Smith",
+      };
+
+      const response = await request(app.getHttpServer())
+        .post(`/api/v2/oauth-clients/${oAuthClient.id}/users`)
+        .set("x-cal-secret-key", oAuthClient.secret)
+        .send(requestBody)
+        .expect(409);
+
+      const responseBody: CreateManagedUserOutput = response.body;
+      const error = responseBody.error;
+      expect(error).toBeDefined();
+      expect(error?.message).toEqual(
+        `User with the provided e-mail already exists. Existing user ID=${postResponseData.user.id}`
+      );
+    });
+
     it(`/GET: return list of managed users`, async () => {
       const response = await request(app.getHttpServer())
         .get(`/api/v2/oauth-clients/${oAuthClient.id}/users?limit=10&offset=0`)
@@ -486,7 +510,7 @@ describe("OAuth Client Users Endpoints", () => {
       expect(oAuthClient1).toBeDefined();
     });
 
-    it(`should create managed user and update team event-types of OAuthClient marked as assignAllTeamMembers: true`, async () => {
+    it(`should create managed user and update team event-types`, async () => {
       const requestBody: CreateManagedUserInput = {
         email: userEmail,
         timeZone: userTimeZone,
@@ -508,48 +532,13 @@ describe("OAuth Client Users Endpoints", () => {
       expect(responseBody.status).toEqual(SUCCESS_STATUS);
       expect(responseBody.data).toBeDefined();
 
-      await userHasCorrectEventTypes(responseBody.data.user.id);
       await teamHasCorrectEventTypes(team1.id);
       expect(responseBody.data.user.name).toEqual(requestBody.name);
     });
 
-    async function userHasCorrectEventTypes(userId: number) {
-      const eventTypes = await eventTypesRepositoryFixture.getAllUserEventTypes(userId);
-
-      expect(eventTypes?.length).toEqual(5);
-
-      // note(Lauris): managed event-types with assignAllTeamMembers: true
-      expect(eventTypes?.find((eventType) => eventType.slug === managedEventType1.slug)).toBeTruthy();
-
-      // note(Lauris): default event types
-      expect(
-        eventTypes?.find((eventType) => eventType.slug === DEFAULT_EVENT_TYPES.thirtyMinutes.slug)
-      ).toBeTruthy();
-      expect(
-        eventTypes?.find((eventType) => eventType.slug === DEFAULT_EVENT_TYPES.sixtyMinutes.slug)
-      ).toBeTruthy();
-      expect(
-        eventTypes?.find((eventType) => eventType.slug === DEFAULT_EVENT_TYPES.thirtyMinutesVideo.slug)
-      ).toBeTruthy();
-      expect(
-        eventTypes?.find((eventType) => eventType.slug === DEFAULT_EVENT_TYPES.sixtyMinutesVideo.slug)
-      ).toBeTruthy();
-    }
-
     async function teamHasCorrectEventTypes(teamId: number) {
       const eventTypes = await eventTypesRepositoryFixture.getAllTeamEventTypes(teamId);
-
       expect(eventTypes?.length).toEqual(2);
-
-      // note(Lauris): managed event-types with assignAllTeamMembers: true
-      expect(eventTypes?.find((eventType) => eventType.slug === managedEventType1.slug)).toBeTruthy();
-
-      // note(Lauris): check if managed user added to collective event-type hosts given that it has assignAllTeamMembers: true
-      const collective = eventTypes?.find((eventType) => eventType.schedulingType === "COLLECTIVE");
-      expect(collective).toBeTruthy();
-      expect(collective?.hosts).toBeDefined();
-      expect(collective?.hosts?.length).toEqual(1);
-      expect(collective?.hosts[0].userId).toEqual(postResponseData.user.id);
     }
 
     afterAll(async () => {

apps/api/v2/src/modules/oauth-clients/controllers/oauth-client-users/outputs/create-managed-user.output.ts

@@ -34,4 +34,6 @@ export class CreateManagedUserOutput {
   @ValidateNested()
   @Type(() => CreateManagedUserData)
   data!: CreateManagedUserData;
+
+  error?: Error;
 }

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

@@ -25,9 +25,9 @@ import {
 import {
   ApiTags as DocsTags,
   ApiExcludeController as DocsExcludeController,
-  ApiExcludeEndpoint as DocsExcludeEndpoint,
   ApiOperation as DocsOperation,
   ApiOkResponse as DocsOkResponse,
+  ApiExcludeEndpoint as DocsExcludeEndpoint,
   ApiBadRequestResponse as DocsBadRequestResponse,
   ApiHeader as DocsHeader,
 } from "@nestjs/swagger";
@@ -50,20 +50,7 @@ export class OAuthFlowController {
   @Post("/authorize")
   @HttpCode(HttpStatus.OK)
   @UseGuards(NextAuthGuard)
-  @DocsOperation({
-    summary: "Authorize an OAuth client",
-    description:
-      "Redirects the user to the specified 'redirect_uri' with an authorization code in query parameter if the client is authorized successfully. The code is then exchanged for access and refresh tokens via the `/exchange` endpoint.",
-  })
-  @DocsOkResponse({
-    description:
-      "The user is redirected to the 'redirect_uri' with an authorization code in query parameter e.g. `redirectUri?code=secretcode.`",
-  })
-  @DocsBadRequestResponse({
-    description:
-      "Bad request if the OAuth client is not found, if the redirect URI is invalid, or if the user has already authorized the client.",
-  })
-  @DocsExcludeEndpoint(getEnv("NODE_ENV") === "production")
+  @DocsExcludeEndpoint()
   async authorize(
     @Param("clientId") clientId: string,
     @Body() body: OAuthAuthorizeInput,
@@ -97,20 +84,7 @@ export class OAuthFlowController {
 
   @Post("/exchange")
   @HttpCode(HttpStatus.OK)
-  @DocsOperation({
-    summary: "Exchange authorization code for access tokens",
-    description:
-      "Exchanges the authorization code received from the `/authorize` endpoint for access and refresh tokens. The authorization code should be provided in the 'Authorization' header prefixed with 'Bearer '.",
-  })
-  @DocsOkResponse({
-    type: KeysResponseDto,
-    description: "Successfully exchanged authorization code for access and refresh tokens.",
-  })
-  @DocsBadRequestResponse({
-    description:
-      "Bad request if the authorization code is missing, invalid, or if the client ID and secret do not match.",
-  })
-  @DocsExcludeEndpoint(getEnv("NODE_ENV") === "production")
+  @DocsExcludeEndpoint()
   async exchange(
     @Headers("Authorization") authorization: string,
     @Param("clientId") clientId: string,

apps/api/v2/src/modules/oauth-clients/services/oauth-clients-users.service.ts

@@ -5,7 +5,7 @@ import { TokensRepository } from "@/modules/tokens/tokens.repository";
 import { CreateManagedUserInput } from "@/modules/users/inputs/create-managed-user.input";
 import { UpdateManagedUserInput } from "@/modules/users/inputs/update-managed-user.input";
 import { UsersRepository } from "@/modules/users/users.repository";
-import { BadRequestException, Injectable } from "@nestjs/common";
+import { BadRequestException, ConflictException, Injectable } from "@nestjs/common";
 import { User } from "@prisma/client";
 
 import { createNewUsersConnectToOrgIfExists, slugify } from "@calcom/platform-libraries";
@@ -26,9 +26,11 @@ export class OAuthClientUsersService {
     isPlatformManaged: boolean,
     organizationId?: number
   ) {
-    const existsWithEmail = await this.managedUserExistsWithEmail(oAuthClientId, body.email);
-    if (existsWithEmail) {
-      throw new BadRequestException("User with the provided e-mail already exists.");
+    const existingUser = await this.getExistingUserByEmail(oAuthClientId, body.email);
+    if (existingUser) {
+      throw new ConflictException(
+        `User with the provided e-mail already exists. Existing user ID=${existingUser.id}`
+      );
     }
 
     let user: User;
@@ -81,8 +83,6 @@ export class OAuthClientUsersService {
       user.defaultScheduleId = defaultSchedule.id;
     }
 
-    await this.organizationsTeamsService.addUserToPlatformTeamEvents(user.id, organizationId, oAuthClientId);
-
     return {
       user,
       tokens: {
@@ -93,10 +93,9 @@ export class OAuthClientUsersService {
     };
   }
 
-  async managedUserExistsWithEmail(oAuthClientId: string, email: string) {
+  async getExistingUserByEmail(oAuthClientId: string, email: string) {
     const oAuthEmail = this.getOAuthUserEmail(oAuthClientId, email);
-    const user = await this.userRepository.findByEmail(oAuthEmail);
-    return !!user;
+    return await this.userRepository.findByEmail(oAuthEmail);
   }
 
   async updateOAuthClientUser(oAuthClientId: string, userId: number, body: UpdateManagedUserInput) {

apps/api/v2/src/modules/organizations/controllers/event-types/organizations-event-types.e2e-spec.ts

@@ -387,15 +387,18 @@ describe("Organizations Event Types Endpoints", () => {
             1
           );
 
-          const responseTeamEvent = responseBody.data[0];
-          expect(responseTeamEvent?.teamId).toEqual(team.id);
+          const responseTeamEvent = responseBody.data.find((event) => event.teamId === team.id);
+          expect(responseTeamEvent).toBeDefined();
+          if (!responseTeamEvent) {
+            throw new Error("Team event not found");
+          }
 
-          const responseTeammate1Event = responseBody.data[1];
-          expect(responseTeammate1Event?.ownerId).toEqual(teammate1.id);
+          const responseTeammate1Event = responseBody.data.find((event) => event.ownerId === teammate1.id);
+          expect(responseTeammate1Event).toBeDefined();
           expect(responseTeammate1Event?.parentEventTypeId).toEqual(responseTeamEvent?.id);
 
-          const responseTeammate2Event = responseBody.data[2];
-          expect(responseTeammate2Event?.ownerId).toEqual(teammate2.id);
+          const responseTeammate2Event = responseBody.data.find((event) => event.ownerId === teammate2.id);
+          expect(responseTeammate2Event).toBeDefined();
           expect(responseTeammate2Event?.parentEventTypeId).toEqual(responseTeamEvent?.id);
 
           managedEventType = responseTeamEvent;

apps/api/v2/src/modules/organizations/controllers/teams/memberships/organizations-teams-memberships.controller.e2e-spec.ts

@@ -2,14 +2,16 @@ import { bootstrap } from "@/app";
 import { AppModule } from "@/app.module";
 import { CreateOrgTeamMembershipDto } from "@/modules/organizations/inputs/create-organization-team-membership.input";
 import { UpdateOrgTeamMembershipDto } from "@/modules/organizations/inputs/update-organization-team-membership.input";
+import { OrgTeamMembershipOutputDto } from "@/modules/organizations/outputs/organization-teams-memberships.output";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { TokensModule } from "@/modules/tokens/tokens.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 { EventType, User } 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 { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.repository.fixture";
 import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
@@ -25,6 +27,7 @@ describe("Organizations Teams Memberships Endpoints", () => {
   describe("User Authentication - User is Org Admin", () => {
     let app: INestApplication;
 
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
     let userRepositoryFixture: UserRepositoryFixture;
     let organizationsRepositoryFixture: OrganizationRepositoryFixture;
     let teamsRepositoryFixture: TeamRepositoryFixture;
@@ -35,9 +38,11 @@ describe("Organizations Teams Memberships Endpoints", () => {
     let org: Team;
     let orgTeam: Team;
     let nonOrgTeam: Team;
+    let teamEventType: EventType;
+    let managedEventType: EventType;
     let membership: Membership;
     let membership2: Membership;
-    let membershipCreatedViaApi: Membership;
+    let membershipCreatedViaApi: OrgTeamMembershipOutputDto;
 
     const userEmail = "org-admin-membership-teams-controller-e2e@api.com";
     const userEmail2 = "org-member-membership-teams-controller-e2e@api.com";
@@ -65,6 +70,7 @@ describe("Organizations Teams Memberships Endpoints", () => {
       profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
 
       membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
 
       user = await userRepositoryFixture.create({
         email: userEmail,
@@ -96,6 +102,32 @@ describe("Organizations Teams Memberships Endpoints", () => {
         parent: { connect: { id: org.id } },
       });
 
+      teamEventType = await eventTypesRepositoryFixture.createTeamEventType({
+        schedulingType: "COLLECTIVE",
+        team: {
+          connect: { id: orgTeam.id },
+        },
+        title: "Collective Event Type",
+        slug: "collective-event-type",
+        length: 30,
+        assignAllTeamMembers: true,
+        bookingFields: [],
+        locations: [],
+      });
+
+      managedEventType = await eventTypesRepositoryFixture.createTeamEventType({
+        schedulingType: "MANAGED",
+        team: {
+          connect: { id: orgTeam.id },
+        },
+        title: "Managed Event Type",
+        slug: "managed-event-type",
+        length: 60,
+        assignAllTeamMembers: true,
+        bookingFields: [],
+        locations: [],
+      });
+
       nonOrgTeam = await teamsRepositoryFixture.create({
         name: "Non Org Team",
         isOrganization: false,
@@ -200,7 +232,7 @@ describe("Organizations Teams Memberships Endpoints", () => {
         .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships`)
         .expect(200)
         .then((response) => {
-          const responseBody: ApiSuccessResponse<Membership[]> = response.body;
+          const responseBody: ApiSuccessResponse<OrgTeamMembershipOutputDto[]> = response.body;
           expect(responseBody.status).toEqual(SUCCESS_STATUS);
           expect(responseBody.data[0].id).toEqual(membership.id);
           expect(responseBody.data[1].id).toEqual(membership2.id);
@@ -219,7 +251,7 @@ describe("Organizations Teams Memberships Endpoints", () => {
         .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships?skip=1&take=1`)
         .expect(200)
         .then((response) => {
-          const responseBody: ApiSuccessResponse<Membership[]> = response.body;
+          const responseBody: ApiSuccessResponse<OrgTeamMembershipOutputDto[]> = response.body;
           expect(responseBody.status).toEqual(SUCCESS_STATUS);
           expect(responseBody.data[0].id).toEqual(membership2.id);
           expect(responseBody.data[0].userId).toEqual(user2.id);
@@ -238,10 +270,11 @@ describe("Organizations Teams Memberships Endpoints", () => {
         .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships/${membership.id}`)
         .expect(200)
         .then((response) => {
-          const responseBody: ApiSuccessResponse<Membership> = response.body;
+          const responseBody: ApiSuccessResponse<OrgTeamMembershipOutputDto> = response.body;
           expect(responseBody.status).toEqual(SUCCESS_STATUS);
           expect(responseBody.data.id).toEqual(membership.id);
           expect(responseBody.data.userId).toEqual(user.id);
+          expect(responseBody.data.user.email).toEqual(user.email);
         });
     });
 
@@ -262,7 +295,7 @@ describe("Organizations Teams Memberships Endpoints", () => {
         .expect(404);
     });
 
-    it("should create the membership of the org's team", async () => {
+    it("should have created the membership of the org's team and assigned team wide events", async () => {
       return request(app.getHttpServer())
         .post(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships`)
         .send({
@@ -272,15 +305,29 @@ describe("Organizations Teams Memberships Endpoints", () => {
         } satisfies CreateOrgTeamMembershipDto)
         .expect(201)
         .then((response) => {
-          const responseBody: ApiSuccessResponse<Membership> = response.body;
+          const responseBody: ApiSuccessResponse<OrgTeamMembershipOutputDto> = response.body;
           expect(responseBody.status).toEqual(SUCCESS_STATUS);
           membershipCreatedViaApi = responseBody.data;
           expect(membershipCreatedViaApi.teamId).toEqual(orgTeam.id);
           expect(membershipCreatedViaApi.role).toEqual("MEMBER");
           expect(membershipCreatedViaApi.userId).toEqual(userToInviteViaApi.id);
+          expect(membershipCreatedViaApi.user.email).toEqual(userToInviteViaApi.email);
+          userHasCorrectEventTypes(membershipCreatedViaApi.userId);
         });
     });
 
+    async function userHasCorrectEventTypes(userId: number) {
+      const managedEventTypes = await eventTypesRepositoryFixture.getAllUserEventTypes(userId);
+      const teamEventTypes = await eventTypesRepositoryFixture.getAllTeamEventTypes(orgTeam.id);
+      expect(managedEventTypes?.length).toEqual(1);
+      expect(teamEventTypes?.length).toEqual(2);
+      const collectiveEvenType = teamEventTypes?.find((eventType) => eventType.slug === teamEventType.slug);
+      expect(collectiveEvenType).toBeTruthy();
+      const userHost = collectiveEvenType?.hosts.find((host) => host.userId === userId);
+      expect(userHost).toBeTruthy();
+      expect(managedEventTypes?.find((eventType) => eventType.slug === managedEventType.slug)).toBeTruthy();
+    }
+
     it("should fail to create the membership of the org's team for a non org user", async () => {
       return request(app.getHttpServer())
         .post(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships`)
@@ -300,7 +347,7 @@ describe("Organizations Teams Memberships Endpoints", () => {
         } satisfies UpdateOrgTeamMembershipDto)
         .expect(200)
         .then((response) => {
-          const responseBody: ApiSuccessResponse<Membership> = response.body;
+          const responseBody: ApiSuccessResponse<OrgTeamMembershipOutputDto> = response.body;
           expect(responseBody.status).toEqual(SUCCESS_STATUS);
           membershipCreatedViaApi = responseBody.data;
           expect(membershipCreatedViaApi.role).toEqual("OWNER");
@@ -312,7 +359,7 @@ describe("Organizations Teams Memberships Endpoints", () => {
         .delete(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships/${membershipCreatedViaApi.id}`)
         .expect(200)
         .then((response) => {
-          const responseBody: ApiSuccessResponse<Membership> = response.body;
+          const responseBody: ApiSuccessResponse<OrgTeamMembershipOutputDto> = response.body;
           expect(responseBody.status).toEqual(SUCCESS_STATUS);
           expect(responseBody.data.id).toEqual(membershipCreatedViaApi.id);
         });

apps/api/v2/src/modules/organizations/controllers/teams/memberships/organizations-teams-memberships.controller.ts

@@ -15,6 +15,7 @@ import {
   OrgTeamMembershipsOutputResponseDto,
   OrgTeamMembershipOutputResponseDto,
 } from "@/modules/organizations/outputs/organization-teams-memberships.output";
+import { OrganizationsEventTypesService } from "@/modules/organizations/services/event-types/organizations-event-types.service";
 import { OrganizationsTeamsMembershipsService } from "@/modules/organizations/services/organizations-teams-memberships.service";
 import {
   Controller,
@@ -30,11 +31,13 @@ import {
   HttpStatus,
   HttpCode,
   UnprocessableEntityException,
+  Logger,
 } from "@nestjs/common";
 import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { plainToClass } from "class-transformer";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { updateNewTeamMemberEventTypes } from "@calcom/platform-libraries";
 import { SkipTakePagination } from "@calcom/platform-types";
 
 @Controller({
@@ -44,8 +47,11 @@ import { SkipTakePagination } from "@calcom/platform-types";
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
 @DocsTags("Orgs / Teams / Memberships")
 export class OrganizationsTeamsMembershipsController {
+  private logger = new Logger("OrganizationsTeamsMembershipsController");
+
   constructor(
     private organizationsTeamsMembershipsService: OrganizationsTeamsMembershipsService,
+    private oganizationsEventTypesService: OrganizationsEventTypesService,
     private readonly organizationsRepository: OrganizationsRepository
   ) {}
 
@@ -112,6 +118,9 @@ export class OrganizationsTeamsMembershipsController {
       teamId,
       membershipId
     );
+
+    await this.oganizationsEventTypesService.deleteUserTeamEventTypesAndHosts(membership.userId, teamId);
+
     return {
       status: SUCCESS_STATUS,
       data: plainToClass(OrgTeamMembershipOutputDto, membership, { strategy: "excludeAll" }),
@@ -129,15 +138,29 @@ export class OrganizationsTeamsMembershipsController {
     @Param("membershipId", ParseIntPipe) membershipId: number,
     @Body() data: UpdateOrgTeamMembershipDto
   ): Promise<OrgTeamMembershipOutputResponseDto> {
-    const membership = await this.organizationsTeamsMembershipsService.updateOrgTeamMembership(
+    const currentMembership = await this.organizationsTeamsMembershipsService.getOrgTeamMembership(
+      orgId,
+      teamId,
+      membershipId
+    );
+    const updatedMembership = await this.organizationsTeamsMembershipsService.updateOrgTeamMembership(
       orgId,
       teamId,
       membershipId,
       data
     );
+
+    if (!currentMembership.accepted && updatedMembership.accepted) {
+      try {
+        await updateNewTeamMemberEventTypes(updatedMembership.userId, teamId);
+      } catch (err) {
+        this.logger.error("Could not update new team member eventTypes", err);
+      }
+    }
+
     return {
       status: SUCCESS_STATUS,
-      data: plainToClass(OrgTeamMembershipOutputDto, membership, { strategy: "excludeAll" }),
+      data: plainToClass(OrgTeamMembershipOutputDto, updatedMembership, { strategy: "excludeAll" }),
     };
   }
 
@@ -158,6 +181,13 @@ export class OrganizationsTeamsMembershipsController {
     }
 
     const membership = await this.organizationsTeamsMembershipsService.createOrgTeamMembership(teamId, data);
+    if (membership.accepted) {
+      try {
+        await updateNewTeamMemberEventTypes(user.id, teamId);
+      } catch (err) {
+        this.logger.error("Could not update new team member eventTypes", err);
+      }
+    }
     return {
       status: SUCCESS_STATUS,
       data: plainToClass(OrgTeamMembershipOutputDto, membership, { strategy: "excludeAll" }),

apps/api/v2/src/modules/organizations/controllers/teams/organizations-teams.controller.e2e-spec.ts

@@ -162,6 +162,7 @@ describe("Organizations Team Endpoints", () => {
           const responseBody: ApiSuccessResponse<OrgMeTeamOutputDto[]> = response.body;
           expect(responseBody.data.find((t) => t.id === teamCreatedViaApi.id)).toBeDefined();
           expect(responseBody.data.some((t) => t.accepted)).toBeTruthy();
+          expect(responseBody.data.find((t) => t.id === teamCreatedViaApi.id)?.role).toBe("OWNER");
         });
     });
 

apps/api/v2/src/modules/organizations/controllers/teams/organizations-teams.controller.ts

@@ -67,7 +67,7 @@ export class OrganizationsTeamsController {
   }
 
   @Get("/me")
-  @ApiOperation({ summary: "Get team membership for user" })
+  @ApiOperation({ summary: "Get teams membership for user" })
   @Roles("ORG_MEMBER")
   @PlatformPlan("ESSENTIALS")
   async getMyTeams(
@@ -84,13 +84,14 @@ export class OrganizationsTeamsController {
     );
     return {
       status: SUCCESS_STATUS,
-      data: teams.map((team) =>
-        plainToClass(
+      data: teams.map((team) => {
+        const me = team.members.find((member) => member.userId === user.id);
+        return plainToClass(
           OrgMeTeamOutputDto,
-          { ...team, accepted: team.members.find((member) => member.userId === user.id)?.accepted ?? false },
+          me ? { ...team, role: me.role, accepted: me.accepted } : team,
           { strategy: "excludeAll" }
-        )
-      ),
+        );
+      }),
     };
   }
 

apps/api/v2/src/modules/organizations/controllers/teams/schedules/organizations-teams-schedules.controller.ts

@@ -0,0 +1,43 @@
+import { SchedulesService_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/services/schedules.service";
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
+import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.guard";
+import { IsAdminAPIEnabledGuard } from "@/modules/auth/guards/organizations/is-admin-api-enabled.guard";
+import { IsOrgGuard } from "@/modules/auth/guards/organizations/is-org.guard";
+import { RolesGuard } from "@/modules/auth/guards/roles/roles.guard";
+import { IsTeamInOrg } from "@/modules/auth/guards/teams/is-team-in-org.guard";
+import { IsUserInOrgTeam } from "@/modules/auth/guards/users/is-user-in-org-team.guard";
+import { Controller, UseGuards, Get, Param, ParseIntPipe } from "@nestjs/common";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { GetSchedulesOutput_2024_06_11 } from "@calcom/platform-types";
+
+@Controller({
+  path: "/v2/organizations/:orgId/teams/:teamId",
+  version: API_VERSIONS_VALUES,
+})
+@UseGuards(ApiAuthGuard, IsOrgGuard, IsTeamInOrg, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+@DocsTags("Orgs / Teams / Schedules")
+export class OrganizationsTeamsSchedulesController {
+  constructor(private schedulesService: SchedulesService_2024_06_11) {}
+
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  @UseGuards(IsUserInOrgTeam)
+  @Get("/users/:userId/schedules")
+  @DocsTags("Orgs / Teams / Users / Schedules")
+  @ApiOperation({ summary: "Get schedules of a team member" })
+  async getUserSchedules(
+    @Param("userId", ParseIntPipe) userId: number
+  ): Promise<GetSchedulesOutput_2024_06_11> {
+    const schedules = await this.schedulesService.getUserSchedules(userId);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: schedules,
+    };
+  }
+}

apps/api/v2/src/modules/organizations/controllers/teams/schedules/organizations-teams-schedules.e2e-spec.ts

@@ -0,0 +1,227 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { TokensModule } from "@/modules/tokens/tokens.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 { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+import { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.repository.fixture";
+import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
+import { SchedulesRepositoryFixture } from "test/fixtures/repository/schedules.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 { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { ApiSuccessResponse, ScheduleOutput_2024_06_11 } from "@calcom/platform-types";
+import { Team, Schedule } from "@calcom/prisma/client";
+
+describe("Organizations Teams Schedules Endpoints", () => {
+  describe("User Authentication - User is Org Admin", () => {
+    let app: INestApplication;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let organizationsRepositoryFixture: OrganizationRepositoryFixture;
+    let teamsRepositoryFixture: TeamRepositoryFixture;
+    let profileRepositoryFixture: ProfileRepositoryFixture;
+    let scheduleRepositoryFixture: SchedulesRepositoryFixture;
+
+    let membershipsRepositoryFixture: MembershipRepositoryFixture;
+
+    let org: Team;
+    let orgTeam: Team;
+    let nonOrgTeam: Team;
+    let user2Schedule: Schedule;
+
+    const userEmail = "org-admin-schedules-teams-controller-e2e@api.com";
+    const userEmail2 = "org-member-schedules-teams-controller-e2e@api.com";
+    const nonOrgUserEmail = "non-org-member-schedules-teams-controller-e2e@api.com";
+
+    const invitedUserEmail = "org-member-invited-schedules-teams-controller-e2e@api.com";
+
+    let user: User;
+    let user2: User;
+    let nonOrgUser: User;
+
+    let userToInviteViaApi: User;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        userEmail,
+        Test.createTestingModule({
+          imports: [AppModule, PrismaModule, UsersModule, TokensModule],
+        })
+      ).compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      organizationsRepositoryFixture = new OrganizationRepositoryFixture(moduleRef);
+      teamsRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+      scheduleRepositoryFixture = new SchedulesRepositoryFixture(moduleRef);
+      membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+
+      user = await userRepositoryFixture.create({
+        email: userEmail,
+        username: userEmail,
+      });
+      user2 = await userRepositoryFixture.create({
+        email: userEmail2,
+        username: userEmail2,
+      });
+
+      user2Schedule = await scheduleRepositoryFixture.create({
+        user: {
+          connect: {
+            id: user2.id,
+          },
+        },
+        name: "User 2 schedule",
+        timeZone: "America/New_York",
+      });
+
+      nonOrgUser = await userRepositoryFixture.create({
+        email: nonOrgUserEmail,
+        username: nonOrgUserEmail,
+      });
+
+      userToInviteViaApi = await userRepositoryFixture.create({
+        email: invitedUserEmail,
+        username: invitedUserEmail,
+      });
+
+      org = await organizationsRepositoryFixture.create({
+        name: "Test Organization",
+        isOrganization: true,
+      });
+
+      orgTeam = await teamsRepositoryFixture.create({
+        name: "Org Team",
+        isOrganization: false,
+        parent: { connect: { id: org.id } },
+      });
+
+      nonOrgTeam = await teamsRepositoryFixture.create({
+        name: "Non Org Team",
+        isOrganization: false,
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "ADMIN",
+        user: { connect: { id: user.id } },
+        team: { connect: { id: orgTeam.id } },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: user2.id } },
+        team: { connect: { id: orgTeam.id } },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "ADMIN",
+        user: { connect: { id: user.id } },
+        team: { connect: { id: org.id } },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: user2.id } },
+        team: { connect: { id: org.id } },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: userToInviteViaApi.id } },
+        team: { connect: { id: org.id } },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: nonOrgUser.id } },
+        team: { connect: { id: nonOrgTeam.id } },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${user.id}`,
+        username: userEmail,
+        organization: {
+          connect: {
+            id: org.id,
+          },
+        },
+        user: {
+          connect: {
+            id: user.id,
+          },
+        },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${user2.id}`,
+        username: userEmail2,
+        organization: {
+          connect: {
+            id: org.id,
+          },
+        },
+        user: {
+          connect: {
+            id: user2.id,
+          },
+        },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${userToInviteViaApi.id}`,
+        username: invitedUserEmail,
+        organization: {
+          connect: {
+            id: org.id,
+          },
+        },
+        user: {
+          connect: {
+            id: userToInviteViaApi.id,
+          },
+        },
+      });
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    it("should be defined", () => {
+      expect(userRepositoryFixture).toBeDefined();
+      expect(organizationsRepositoryFixture).toBeDefined();
+      expect(user).toBeDefined();
+      expect(org).toBeDefined();
+    });
+
+    it("should get all the schedule of the org's team's member", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/users/${user2.id}/schedules`)
+        .expect(200)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<ScheduleOutput_2024_06_11[]> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data.find((d) => d.id === user2Schedule.id)?.name).toEqual(user2Schedule.name);
+        });
+    });
+
+    afterAll(async () => {
+      await userRepositoryFixture.deleteByEmail(user.email);
+      await userRepositoryFixture.deleteByEmail(userToInviteViaApi.email);
+      await userRepositoryFixture.deleteByEmail(nonOrgUser.email);
+      await userRepositoryFixture.deleteByEmail(user2.email);
+      await organizationsRepositoryFixture.delete(org.id);
+      await teamsRepositoryFixture.delete(nonOrgTeam.id);
+      await app.close();
+    });
+  });
+});

apps/api/v2/src/modules/organizations/controllers/users/organizations-users.e2e-spec.ts

@@ -469,34 +469,13 @@ describe("Organizations Users Endpoints", () => {
 
       const userData = body.data;
       expect(body.status).toBe(SUCCESS_STATUS);
-      userHasCorrectEventTypes(userData.id);
       createdUser = userData;
       teamHasCorrectEventTypes(team.id);
     });
 
-    async function userHasCorrectEventTypes(userId: number) {
-      const eventTypes = await eventTypesRepositoryFixture.getAllUserEventTypes(userId);
-
-      expect(eventTypes?.length).toEqual(1);
-
-      // note(Lauris): managed event-types with assignAllTeamMembers: true
-      expect(eventTypes?.find((eventType) => eventType.slug === managedEventType.slug)).toBeTruthy();
-    }
-
     async function teamHasCorrectEventTypes(teamId: number) {
       const eventTypes = await eventTypesRepositoryFixture.getAllTeamEventTypes(teamId);
-
       expect(eventTypes?.length).toEqual(2);
-
-      // note(Lauris): managed event-types with assignAllTeamMembers: true
-      expect(eventTypes?.find((eventType) => eventType.slug === managedEventType.slug)).toBeTruthy();
-
-      // note(Lauris): check if managed user added to collective event-type hosts given that it has assignAllTeamMembers: true
-      const collective = eventTypes?.find((eventType) => eventType.schedulingType === "COLLECTIVE");
-      expect(collective).toBeTruthy();
-      expect(collective?.hosts).toBeDefined();
-      expect(collective?.hosts?.length).toEqual(1);
-      expect(collective?.hosts[0].userId).toEqual(createdUser.id);
     }
 
     afterAll(async () => {

apps/api/v2/src/modules/organizations/organizations.module.ts

@@ -11,6 +11,7 @@ import { OutputTeamEventTypesResponsePipe } from "@/modules/organizations/contro
 import { OrganizationsSchedulesController } from "@/modules/organizations/controllers/schedules/organizations-schedules.controller";
 import { OrganizationsTeamsMembershipsController } from "@/modules/organizations/controllers/teams/memberships/organizations-teams-memberships.controller";
 import { OrganizationsTeamsController } from "@/modules/organizations/controllers/teams/organizations-teams.controller";
+import { OrganizationsTeamsSchedulesController } from "@/modules/organizations/controllers/teams/schedules/organizations-teams-schedules.controller";
 import { OrganizationsUsersController } from "@/modules/organizations/controllers/users/organizations-users.controller";
 import { OrganizationsWebhooksController } from "@/modules/organizations/controllers/webhooks/organizations-webhooks.controller";
 import { OrganizationsRepository } from "@/modules/organizations/organizations.repository";
@@ -100,6 +101,7 @@ import { Module } from "@nestjs/common";
     OrganizationsWebhooksService,
     WebhooksRepository,
     WebhooksService,
+    OrganizationsEventTypesService,
   ],
   controllers: [
     OrganizationsTeamsController,
@@ -111,6 +113,7 @@ import { Module } from "@nestjs/common";
     OrganizationsAttributesController,
     OrganizationsOptionsAttributesController,
     OrganizationsWebhooksController,
+    OrganizationsTeamsSchedulesController,
   ],
 })
 export class OrganizationsModule {}

apps/api/v2/src/modules/organizations/organizations.repository.ts

@@ -33,7 +33,7 @@ export class OrganizationsRepository {
   }
 
   async createNewBillingRelation(orgId: number, plan?: PlatformPlan) {
-    const { id } = await this.stripeService.stripe.customers.create({
+    const { id } = await this.stripeService.getStripe().customers.create({
       metadata: {
         createdBy: "oauth_client_no_csid", // mark in case this is needed in the future.
       },
@@ -103,6 +103,24 @@ export class OrganizationsRepository {
     });
   }
 
+  async findOrgTeamUser(organizationId: number, teamId: number, userId: number) {
+    return this.dbRead.prisma.user.findUnique({
+      where: {
+        id: userId,
+        profiles: {
+          some: {
+            organizationId,
+          },
+        },
+        teams: {
+          some: {
+            teamId: teamId,
+          },
+        },
+      },
+    });
+  }
+
   async fetchOrgAdminApiStatus(organizationId: number) {
     return this.dbRead.prisma.organizationSettings.findUnique({
       where: {

apps/api/v2/src/modules/organizations/outputs/organization-team.output.ts

@@ -1,4 +1,5 @@
 import { ApiProperty } from "@nestjs/swagger";
+import { MembershipRole } from "@prisma/client";
 import { Expose, Type } from "class-transformer";
 import { IsEnum, IsString, ValidateNested } from "class-validator";
 
@@ -9,6 +10,14 @@ export class OrgMeTeamOutputDto extends OrgTeamOutputDto {
   @IsString()
   @Expose()
   readonly accepted!: boolean;
+
+  @ApiProperty({
+    example: MembershipRole.MEMBER,
+    enum: [MembershipRole.ADMIN, MembershipRole.OWNER, MembershipRole.MEMBER],
+  })
+  @IsEnum([MembershipRole.ADMIN, MembershipRole.OWNER, MembershipRole.MEMBER])
+  @Expose()
+  readonly role!: MembershipRole;
 }
 
 export class OrgTeamsOutputResponseDto {

apps/api/v2/src/modules/organizations/outputs/organization-teams-memberships.output.ts

@@ -5,6 +5,27 @@ import { IsArray, IsBoolean, IsEnum, IsInt, IsOptional, IsString, ValidateNested
 
 import { ERROR_STATUS, SUCCESS_STATUS } from "@calcom/platform-constants";
 
+export class MembershipUserOutputDto {
+  @IsOptional()
+  @IsString()
+  @Expose()
+  readonly avatarUrl?: string;
+
+  @IsOptional()
+  @IsString()
+  @Expose()
+  readonly username?: string;
+
+  @IsOptional()
+  @IsString()
+  @Expose()
+  readonly name?: string;
+
+  @IsBoolean()
+  @Expose()
+  readonly email!: string;
+}
+
 export class OrgTeamMembershipOutputDto {
   @IsInt()
   @Expose()
@@ -31,6 +52,11 @@ export class OrgTeamMembershipOutputDto {
   @IsBoolean()
   @Expose()
   readonly disableImpersonation?: boolean;
+
+  @ValidateNested()
+  @Type(() => MembershipUserOutputDto)
+  @Expose()
+  user!: MembershipUserOutputDto;
 }
 
 export class OrgTeamMembershipsOutputResponseDto {

apps/api/v2/src/modules/organizations/repositories/organizations-event-types.repository.ts

@@ -70,4 +70,26 @@ export class OrganizationsEventTypesRepository {
       include: { children: true },
     });
   }
+
+  async deleteUserManagedTeamEventTypes(userId: number, teamId: number) {
+    return this.dbWrite.prisma.eventType.deleteMany({
+      where: {
+        parent: {
+          teamId,
+        },
+        userId,
+      },
+    });
+  }
+
+  async removeUserFromTeamEventTypesHosts(userId: number, teamId: number) {
+    return this.dbWrite.prisma.host.deleteMany({
+      where: {
+        userId,
+        eventType: {
+          teamId,
+        },
+      },
+    });
+  }
 }

apps/api/v2/src/modules/organizations/repositories/organizations-teams-memberships.repository.ts

@@ -9,13 +9,14 @@ export class OrganizationsTeamsMembershipsRepository {
   constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
 
   async findOrgTeamMembershipsPaginated(organizationId: number, teamId: number, skip: number, take: number) {
-    return this.dbRead.prisma.membership.findMany({
+    return await this.dbRead.prisma.membership.findMany({
       where: {
         teamId: teamId,
         team: {
           parentId: organizationId,
         },
       },
+      include: { user: { select: { username: true, email: true, avatarUrl: true, name: true } } },
       skip,
       take,
     });
@@ -30,6 +31,7 @@ export class OrganizationsTeamsMembershipsRepository {
           parentId: organizationId,
         },
       },
+      include: { user: { select: { username: true, email: true, avatarUrl: true, name: true } } },
     });
   }
   async deleteOrgTeamMembershipById(organizationId: number, teamId: number, membershipId: number) {
@@ -59,12 +61,14 @@ export class OrganizationsTeamsMembershipsRepository {
           parentId: organizationId,
         },
       },
+      include: { user: { select: { username: true, email: true, avatarUrl: true, name: true } } },
     });
   }
 
   async createOrgTeamMembership(teamId: number, data: CreateOrgTeamMembershipDto) {
     return this.dbWrite.prisma.membership.create({
       data: { ...data, teamId: teamId },
+      include: { user: { select: { username: true, email: true, avatarUrl: true, name: true } } },
     });
   }
 }

apps/api/v2/src/modules/organizations/repositories/organizations-teams.repository.ts

@@ -4,6 +4,8 @@ import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { Injectable } from "@nestjs/common";
 
+import { credentialForCalendarServiceSelect } from "@calcom/platform-libraries";
+
 @Injectable()
 export class OrganizationsTeamsRepository {
   constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
@@ -97,7 +99,7 @@ export class OrganizationsTeamsRepository {
         },
       },
       include: {
-        members: { select: { accepted: true, userId: true } },
+        members: { select: { accepted: true, userId: true, role: true } },
       },
       skip,
       take,
@@ -119,4 +121,53 @@ export class OrganizationsTeamsRepository {
 
     return team.members.map((member) => member.userId);
   }
+
+  async getUserTeamsById(userId: number) {
+    const userTeams = await this.dbRead.prisma.team.findMany({
+      where: {
+        members: {
+          some: {
+            userId,
+            accepted: true,
+          },
+        },
+      },
+      select: {
+        id: true,
+        credentials: {
+          select: credentialForCalendarServiceSelect,
+        },
+        name: true,
+        logoUrl: true,
+        members: {
+          where: {
+            userId,
+          },
+          select: {
+            role: true,
+          },
+        },
+        parent: {
+          select: {
+            id: true,
+            credentials: {
+              select: credentialForCalendarServiceSelect,
+            },
+            name: true,
+            logoUrl: true,
+            members: {
+              where: {
+                userId,
+              },
+              select: {
+                role: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return userTeams;
+  }
 }

apps/api/v2/src/modules/organizations/services/event-types/organizations-event-types.service.ts

@@ -6,13 +6,15 @@ import { DatabaseTeamEventType } from "@/modules/organizations/services/event-ty
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { UsersService } from "@/modules/users/services/users.service";
 import { UserWithProfile } from "@/modules/users/users.repository";
-import { Injectable, NotFoundException } from "@nestjs/common";
+import { Injectable, NotFoundException, Logger } from "@nestjs/common";
 
 import { createEventType, updateEventType } from "@calcom/platform-libraries";
 import { InputTeamEventTransformed_2024_06_14 } from "@calcom/platform-types";
 
 @Injectable()
 export class OrganizationsEventTypesService {
+  private readonly logger = new Logger("OrganizationsEventTypesService");
+
   constructor(
     private readonly eventTypesService: EventTypesService_2024_06_14,
     private readonly dbWrite: PrismaWriteService,
@@ -145,4 +147,17 @@ export class OrganizationsEventTypesService {
 
     return this.eventTypesRepository.deleteEventType(eventTypeId);
   }
+
+  async deleteUserTeamEventTypesAndHosts(userId: number, teamId: number) {
+    try {
+      await this.organizationEventTypesRepository.deleteUserManagedTeamEventTypes(userId, teamId);
+      await this.organizationEventTypesRepository.removeUserFromTeamEventTypesHosts(userId, teamId);
+    } catch (err) {
+      this.logger.error("Could not remove user from all team event-types.", {
+        error: err,
+        userId,
+        teamId,
+      });
+    }
+  }
 }

apps/api/v2/src/modules/organizations/services/organizations-teams.service.ts

@@ -5,8 +5,6 @@ import { OrganizationsTeamsRepository } from "@/modules/organizations/repositori
 import { UserWithProfile } from "@/modules/users/users.repository";
 import { Injectable } from "@nestjs/common";
 
-import { updateNewTeamMemberEventTypes } from "@calcom/platform-libraries";
-
 @Injectable()
 export class OrganizationsTeamsService {
   constructor(
@@ -69,23 +67,4 @@ export class OrganizationsTeamsService {
     }
     return team;
   }
-
-  async addUserToTeamEvents(userId: number, organizationId: number) {
-    const orgTeams = await this.organizationsTeamRepository.findOrgTeams(organizationId);
-
-    for (const team of orgTeams) {
-      await updateNewTeamMemberEventTypes(userId, team.id);
-    }
-  }
-
-  async addUserToPlatformTeamEvents(userId: number, organizationId: number, oAuthClientId: string) {
-    const oAuthClientTeams = await this.organizationsTeamRepository.getPlatformOrgTeams(
-      organizationId,
-      oAuthClientId
-    );
-
-    for (const team of oAuthClientTeams) {
-      await updateNewTeamMemberEventTypes(userId, team.id);
-    }
-  }
 }

apps/api/v2/src/modules/organizations/services/organizations-users-service.ts

@@ -79,8 +79,6 @@ export class OrganizationsUsersService {
       updateUserBody
     );
 
-    await this.organizationsTeamsService.addUserToTeamEvents(user.id, org.id);
-
     // Need to send email to new user to create password
     await this.emailService.sendSignupToOrganizationEmail({
       usernameOrEmail,

apps/api/v2/src/modules/stripe/controllers/stripe.controller.ts

@@ -21,6 +21,7 @@ import {
   Req,
   BadRequestException,
   Headers,
+  Param,
 } from "@nestjs/common";
 import { ApiTags as DocsTags, ApiOperation } from "@nestjs/swagger";
 import { plainToClass } from "class-transformer";
@@ -46,7 +47,8 @@ export class StripeController {
     @Headers("Authorization") authorization: string,
     @GetUser() user: UserWithProfile,
     @Query("redir") redir?: string | null,
-    @Query("errorRedir") errorRedir?: string | null
+    @Query("errorRedir") errorRedir?: string | null,
+    @Query("teamId") teamId?: string | null
   ): Promise<StripConnectOutputResponseDto> {
     const origin = req.headers.origin;
     const accessToken = authorization.replace("Bearer ", "");
@@ -56,6 +58,7 @@ export class StripeController {
       fromApp: false,
       returnTo: !!redir ? redir : origin,
       accessToken,
+      teamId: Number(teamId) ?? null,
     };
 
     const stripeRedirectUrl = await this.stripeService.getStripeRedirectUrl(
@@ -99,6 +102,16 @@ export class StripeController {
   @HttpCode(HttpStatus.OK)
   @ApiOperation({ summary: "Check stripe connection" })
   async check(@GetUser() user: UserWithProfile): Promise<StripCredentialsCheckOutputResponseDto> {
-    return await this.stripeService.checkIfStripeAccountConnected(user.id);
+    return await this.stripeService.checkIfIndividualStripeAccountConnected(user.id);
+  }
+
+  @Get("/check/:teamId")
+  @UseGuards(ApiAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Check team stripe connection" })
+  async checkTeamStripeConnection(
+    @Param("teamId") teamId: string
+  ): Promise<StripCredentialsCheckOutputResponseDto> {
+    return await this.stripeService.checkIfTeamStripeAccountConnected(Number(teamId));
   }
 }

apps/api/v2/src/modules/stripe/stripe.module.ts

@@ -1,5 +1,6 @@
 import { AppsRepository } from "@/modules/apps/apps.repository";
 import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
+import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { StripeController } from "@/modules/stripe/controllers/stripe.controller";
 import { StripeService } from "@/modules/stripe/stripe.service";
@@ -10,7 +11,7 @@ import { ConfigModule } from "@nestjs/config";
 @Module({
   imports: [ConfigModule, PrismaModule],
   exports: [StripeService],
-  providers: [StripeService, AppsRepository, CredentialsRepository, TokensRepository],
+  providers: [StripeService, AppsRepository, CredentialsRepository, TokensRepository, MembershipsRepository],
   controllers: [StripeController],
 })
 export class StripeModule {}

apps/api/v2/src/modules/stripe/stripe.service.ts

@@ -1,13 +1,14 @@
 import { AppConfig } from "@/config/type";
 import { AppsRepository } from "@/modules/apps/apps.repository";
 import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
+import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { getReturnToValueFromQueryState } from "@/modules/stripe/utils/getReturnToValueFromQueryState";
 import { stripeInstance } from "@/modules/stripe/utils/newStripeInstance";
 import { StripeData } from "@/modules/stripe/utils/stripeDataSchemas";
 import { TokensRepository } from "@/modules/tokens/tokens.repository";
 import { Injectable, NotFoundException, BadRequestException, UnauthorizedException } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
-import type { Prisma } from "@prisma/client";
+import type { Prisma, Credential } from "@prisma/client";
 import Stripe from "stripe";
 import { z } from "zod";
 
@@ -17,9 +18,17 @@ import { stripeKeysResponseSchema } from "./utils/stripeDataSchemas";
 
 import stringify = require("qs-stringify");
 
+type IntegrationOAuthCallbackState = {
+  accessToken: string;
+  returnTo: string;
+  onErrorReturnTo: string;
+  fromApp: boolean;
+  teamId?: number | null;
+};
+
 @Injectable()
 export class StripeService {
-  public stripe: Stripe;
+  private stripe: Stripe;
   private redirectUri = `${this.config.get("api.url")}/stripe/save`;
 
   constructor(
@@ -27,13 +36,18 @@ export class StripeService {
     private readonly config: ConfigService,
     private readonly appsRepository: AppsRepository,
     private readonly credentialRepository: CredentialsRepository,
-    private readonly tokensRepository: TokensRepository
+    private readonly tokensRepository: TokensRepository,
+    private readonly membershipRepository: MembershipsRepository
   ) {
     this.stripe = new Stripe(configService.get("stripe.apiKey", { infer: true }) ?? "", {
       apiVersion: "2020-08-27",
     });
   }
 
+  getStripe() {
+    return this.stripe;
+  }
+
   async getStripeRedirectUrl(state: string, userEmail?: string, userName?: string | null) {
     const { client_id } = await this.getStripeAppKeys();
 
@@ -76,6 +90,7 @@ export class StripeService {
 
   async saveStripeAccount(state: string, code: string, accessToken: string): Promise<{ url: string }> {
     const userId = await this.tokensRepository.getAccessTokenOwnerId(accessToken);
+    const oAuthCallbackState: IntegrationOAuthCallbackState = JSON.parse(state);
 
     if (!userId) {
       throw new UnauthorizedException("Invalid Access token.");
@@ -92,6 +107,19 @@ export class StripeService {
       data["default_currency"] = account.default_currency;
     }
 
+    if (oAuthCallbackState.teamId) {
+      await this.checkIfUserHasAdminAccessToTeam(oAuthCallbackState.teamId, userId);
+
+      await this.appsRepository.createTeamAppCredential(
+        "stripe_payment",
+        data as unknown as Prisma.InputJsonObject,
+        oAuthCallbackState.teamId,
+        "stripe"
+      );
+
+      return { url: getReturnToValueFromQueryState(state) };
+    }
+
     await this.appsRepository.createAppCredential(
       "stripe_payment",
       data as unknown as Prisma.InputJsonObject,
@@ -102,18 +130,39 @@ export class StripeService {
     return { url: getReturnToValueFromQueryState(state) };
   }
 
-  async checkIfStripeAccountConnected(userId: number): Promise<{ status: typeof SUCCESS_STATUS }> {
+  async checkIfIndividualStripeAccountConnected(userId: number): Promise<{ status: typeof SUCCESS_STATUS }> {
     const stripeCredentials = await this.credentialRepository.getByTypeAndUserId("stripe_payment", userId);
 
-    if (!stripeCredentials) {
+    return await this.validateStripeCredentials(stripeCredentials);
+  }
+
+  async checkIfTeamStripeAccountConnected(teamId: number): Promise<{ status: typeof SUCCESS_STATUS }> {
+    const stripeCredentials = await this.credentialRepository.getByTypeAndTeamId("stripe_payment", teamId);
+
+    return await this.validateStripeCredentials(stripeCredentials);
+  }
+
+  async checkIfUserHasAdminAccessToTeam(teamId: number, userId: number) {
+    const teamMembership = await this.membershipRepository.findMembershipByTeamId(teamId, userId);
+    const hasAdminAccessToTeam = teamMembership?.role === "ADMIN" || teamMembership?.role === "OWNER";
+
+    if (!hasAdminAccessToTeam) {
+      throw new BadRequestException("You must be team owner or admin to do this");
+    }
+  }
+
+  async validateStripeCredentials(
+    credentials?: Credential | null
+  ): Promise<{ status: typeof SUCCESS_STATUS }> {
+    if (!credentials) {
       throw new NotFoundException("Credentials for stripe not found.");
     }
 
-    if (stripeCredentials.invalid) {
+    if (credentials.invalid) {
       throw new BadRequestException("Invalid stripe credentials.");
     }
 
-    const stripeKey = JSON.stringify(stripeCredentials.key);
+    const stripeKey = JSON.stringify(credentials.key);
     const stripeKeyObject = JSON.parse(stripeKey);
 
     const stripeAccount = await stripeInstance.accounts.retrieve(stripeKeyObject?.stripe_user_id);

apps/api/v2/src/modules/users/inputs/create-managed-user.input.ts

@@ -33,7 +33,8 @@ export class CreateManagedUserInput {
   @ApiProperty({
     example: "America/New_York",
     description: `Timezone is used to create user's default schedule from Monday to Friday from 9AM to 5PM. If it is not passed then user does not have
-      a default schedule and it must be created manually via the /schedules endpoint. Until the schedule is created, the user can't access availability atom to set his / her availability nor booked.`,
+      a default schedule and it must be created manually via the /schedules endpoint. Until the schedule is created, the user can't access availability atom to set his / her availability nor booked.
+      It will default to Europe/London if not passed.`,
   })
   timeZone?: string;
 

apps/api/v2/src/modules/webhooks/controllers/webhooks.controller.ts

@@ -82,7 +82,10 @@ export class WebhooksController {
   }
 
   @Get("/")
-  @ApiOperation({ summary: "Get all webooks (paginated)" })
+  @ApiOperation({
+    summary: "Get all webooks",
+    description: "Gets a paginated list of webhooks for the authenticated user.",
+  })
   async getWebhooks(
     @GetUser() user: UserWithProfile,
     @Query() query: SkipTakePagination

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

@@ -23,6 +23,14 @@ export class PlatformBillingRepositoryFixture {
     });
   }
 
+  async get(orgId: number) {
+    return this.prismaWriteClient.platformBilling.findFirst({
+      where: {
+        id: orgId,
+      },
+    });
+  }
+
   async deleteSubscriptionForTeam(teamId: number) {
     // silently try to delete the subscription
     try {

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/web/abTest/middlewareFactory.ts

@@ -8,9 +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/admin/:path*", process.env.APP_ROUTER_SETTINGS_ADMIN_ENABLED === "1"] as const,
-  ["/settings/my-account/:path*", process.env.APP_ROUTER_SETTINGS_MY_ACCOUNT_ENABLED === "1"] as const,
-  ["/settings/platform/:path*", process.env.APP_ROUTER_SETTINGS_PLATFORM_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/web/app/api/tasks/cron/route.ts

@@ -1 +1,7 @@
 export { GET } from "@calcom/features/tasker/api/cron";
+
+/**
+ * This runs each minute and we need fresh data each time
+ * @see https://nextjs.org/docs/app/building-your-application/caching#opting-out-2
+ **/
+export const revalidate = 0;

apps/web/app/future/apps/page.tsx

@@ -4,7 +4,7 @@ import { WithLayout } from "app/layoutHOC";
 
 import { getServerSideProps } from "@lib/apps/getServerSideProps";
 
-import AppsPage, { LayoutWrapper } from "~/apps/apps-view";
+import AppsPage from "~/apps/apps-view";
 
 export const generateMetadata = async () => {
   return await _generateMetadata(
@@ -14,7 +14,6 @@ export const generateMetadata = async () => {
 };
 
 export default WithLayout({
-  getLayout: LayoutWrapper,
   getData: withAppDirSsr(getServerSideProps),
   Page: AppsPage,
 });

apps/web/app/future/settings/(admin)/admin/flags/page.tsx

@@ -1,20 +0,0 @@
-import { _generateMetadata } from "app/_utils";
-
-import { FlagListingView } from "@calcom/features/flags/pages/flag-listing-view";
-import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
-
-export const generateMetadata = async () =>
-  await _generateMetadata(
-    () => "Feature Flags",
-    () => "Here you can toggle your Cal.com instance features."
-  );
-
-const Page = async () => {
-  return (
-    <SettingsHeader title="Feature Flags" description="Here you can toggle your Cal.com instance features.">
-      <FlagListingView />
-    </SettingsHeader>
-  );
-};
-
-export default Page;

apps/web/app/future/settings/(admin)/admin/lockedSMS/page.tsx

@@ -1,21 +0,0 @@
-import { _generateMetadata } from "app/_utils";
-
-import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
-
-import LockedSMSView from "~/settings/admin/locked-sms-view";
-
-export const generateMetadata = async () =>
-  await _generateMetadata(
-    () => "Locked SMS",
-    () => "Lock or unlock SMS sending for users"
-  );
-
-const Page = () => {
-  return (
-    <SettingsHeader title="Locked SMS" description="Lock or unlock SMS sending for users">
-      <LockedSMSView />
-    </SettingsHeader>
-  );
-};
-
-export default Page;

apps/web/app/future/settings/(admin)/admin/oAuth/page.tsx

@@ -1,21 +0,0 @@
-import { _generateMetadata } from "app/_utils";
-
-import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
-
-import LegacyPage from "~/settings/admin/oauth-view";
-
-export const generateMetadata = async () =>
-  await _generateMetadata(
-    () => "OAuth",
-    () => "Add new OAuth Clients"
-  );
-
-const Page = () => {
-  return (
-    <SettingsHeader title="OAuth" description="Add new OAuth Clients">
-      <LegacyPage />
-    </SettingsHeader>
-  );
-};
-
-export default Page;

apps/web/app/future/settings/(admin)/admin/users/add/page.tsx

@@ -1,20 +0,0 @@
-import { _generateMetadata } from "app/_utils";
-
-import UsersAddView from "@calcom/features/ee/users/pages/users-add-view";
-import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
-
-export const generateMetadata = async () =>
-  await _generateMetadata(
-    () => "Add new user",
-    () => "Here you can add a new user."
-  );
-
-const Page = () => {
-  return (
-    <SettingsHeader title="Add new user" description="Here you can add a new user">
-      <UsersAddView />
-    </SettingsHeader>
-  );
-};
-
-export default Page;

apps/web/app/future/settings/platform/oauth-clients/[clientId]/edit/page.tsx

@@ -5,7 +5,7 @@ import EditView from "~/settings/platform/oauth-clients/[clientId]/edit/edit-vie
 
 export const generateMetadata = async () =>
   await _generateMetadata(
-    () => "OAuth client updation form",
+    (t) => t("oAuth_client_updation_form"),
     () => ""
   );