v3.5.0

Fixes: https://github.com/calcom/cal.com/issues/12297
Fixes https://github.com/calcom/cal.com/issues/11234

- Displaying error message and X-Vercel-Id( Unique Request Id ) to user on book event form
- Improve error logging 
- Add Error codes

Few things to discuss

1) How to handle calendar integration failures ?
   Currently if for example google integration is broken and someone is trying to book that person then we log the error but don't inform the user that the google calendar is broken and the meeting goes through.
   
 Should I throw error when integration is broken ?
   
<img width="758" alt="Screenshot 2023-11-12 at 12 52 36 AM" src="https://github.com/calcom/cal.com/assets/53316345/c4d921c4-9c8a-4b9b-82a2-bbe0fdbcb3d4">

   
2)  How to handle conferencing app failures? 
 We just default to Cal Video  as location if we are unable to generated conferencing url and log the error and not inform the user(organizer).

.env.example

@@ -115,6 +115,10 @@ SENDGRID_API_KEY=
 SENDGRID_EMAIL=
 NEXT_PUBLIC_SENDGRID_SENDER_NAME=
 
+# Sentry
+# Used for capturing exceptions and logging messages
+NEXT_PUBLIC_SENTRY_DSN=
+
 # Twilio
 # Used to send SMS reminders in workflows
 TWILIO_SID=
@@ -126,7 +130,7 @@ TWILIO_WHATSAPP_PHONE_NUMBER=
 NEXT_PUBLIC_SENDER_ID=
 TWILIO_VERIFY_SID=
 
-# Set it to "1" if you need to run E2E tests locally. 
+# Set it to "1" if you need to run E2E tests locally.
 NEXT_PUBLIC_IS_E2E=
 
 # Used for internal billing system
@@ -203,6 +207,8 @@ CSP_POLICY=
 EDGE_CONFIG=
 
 NEXT_PUBLIC_MINUTES_TO_BOOK=5 # Minutes
+# Control time intervals on a user's Schedule availability
+NEXT_PUBLIC_AVAILABILITY_SCHEDULE_INTERVAL=
 
 # - ORGANIZATIONS *******************************************************************************************
 # Enable Organizations non-prod domain setup, works in combination with organizations feature flag

.github/ISSUE_TEMPLATE/feature_request.md

@@ -47,3 +47,9 @@ assignees: ""
 -->
 
 (Share it here.)
+
+---
+##### House rules
+- If this issue has a `🚨 needs approval` label, don't start coding yet. Wait until a core member approves feature request by removing this label, then you can start coding.
+  - For clarity: Non-core member issues automatically get the `🚨 needs approval` label.
+  - Your feature ideas are invaluable to us! However, they undergo review to ensure alignment with the product's direction.

.github/PULL_REQUEST_TEMPLATE.md

@@ -40,7 +40,7 @@ Fixes # (issue)
 
 ## Checklist
 
-<!-- Please remove all the irrelevant bullets to your PR -->
+<!-- Remove bullet points below that don't apply to you -->
 
 - I haven't read the [contributing guide](https://github.com/calcom/cal.com/blob/main/CONTRIBUTING.md)
 - My code doesn't follow the style guidelines of this project

.github/workflows/merge-conflict.yml

@@ -1,18 +0,0 @@
-name: Auto Comment Merge Conflicts
-on: push
-
-permissions:
-  pull-requests: write
-
-jobs:
-  auto-comment-merge-conflicts:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: codytseng/auto-comment-merge-conflicts@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          comment-body: "Hey there, there is a merge conflict, can you take a look?"
-          wait-ms: 3000
-          max-retries: 5
-          label-name: "🚨 merge conflict"
-          ignore-authors: dependabot,otherAuthor

.github/workflows/welcome-new-contributors.yml

@@ -1,27 +0,0 @@
-name: "Welcome new contributors"
-
-on:
-  issues:
-    types: opened
-  pull_request:
-    types: opened
-
-permissions:
-  pull-requests: write
-  issues: write
-
-jobs:
-  welcome-message:
-    name: Welcoming New Users
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    if: github.event.action == 'opened'
-    steps:
-      - uses: actions/first-interaction@v1
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          pr-message: |-
-            Thank you for making your first Pull Request and taking the time to improve Cal.com ! ❤️🎉
-            Feel free to join our [discord](https://go.cal.com/discord) and post your PR link to [collect XP and win prizes!](https://cal.com/blog/community-incentives)            
-          issue-message: |
-            Thank you for opening your first issue, one of our team members will review it as soon as it possible. ❤️🎉

.yarn/patches/libphonenumber-js-npm-1.10.12-51c84f8bf1.patch

@@ -0,0 +1,15 @@
+diff --git a/index.cjs b/index.cjs
+index b645707a3549fc298508726e404243499bbed499..f34b0891e99b275a9218e253f303f43d31ef3f73 100644
+--- a/index.cjs
++++ b/index.cjs
+@@ -13,8 +13,8 @@ function withMetadataArgument(func, _arguments) {
+ // https://github.com/babel/babel/issues/2212#issuecomment-131827986
+ // An alternative approach:
+ // https://www.npmjs.com/package/babel-plugin-add-module-exports
+-exports = module.exports = min.parsePhoneNumberFromString
+-exports['default'] = min.parsePhoneNumberFromString
++// exports = module.exports = min.parsePhoneNumberFromString
++// exports['default'] = min.parsePhoneNumberFromString
+ 
+ // `parsePhoneNumberFromString()` named export is now considered legacy:
+ // it has been promoted to a default export due to being too verbose.

.yarn/patches/next-i18next-npm-13.3.0-bf25b0943c.patch

@@ -0,0 +1,26 @@
+diff --git a/dist/commonjs/serverSideTranslations.js b/dist/commonjs/serverSideTranslations.js
+index bcad3d02fbdfab8dacb1d85efd79e98623a0c257..fff668f598154a13c4030d1b4a90d5d9c18214ad 100644
+--- a/dist/commonjs/serverSideTranslations.js
++++ b/dist/commonjs/serverSideTranslations.js
+@@ -36,7 +36,6 @@ var _fs = _interopRequireDefault(require("fs"));
+ var _path = _interopRequireDefault(require("path"));
+ var _createConfig = require("./config/createConfig");
+ var _node = _interopRequireDefault(require("./createClient/node"));
+-var _appWithTranslation = require("./appWithTranslation");
+ var _utils = require("./utils");
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+@@ -110,12 +109,8 @@ var serverSideTranslations = /*#__PURE__*/function () {
+               lng: initialLocale
+             }));
+             localeExtension = config.localeExtension, localePath = config.localePath, fallbackLng = config.fallbackLng, reloadOnPrerender = config.reloadOnPrerender;
+-            if (!reloadOnPrerender) {
+-              _context.next = 18;
+-              break;
+-            }
+             _context.next = 18;
+-            return _appWithTranslation.globalI18n === null || _appWithTranslation.globalI18n === void 0 ? void 0 : _appWithTranslation.globalI18n.reloadResources();
++            return void 0;
+           case 18:
+             _createClient = (0, _node["default"])(_objectSpread(_objectSpread({}, config), {}, {
+               lng: initialLocale

CONTRIBUTING.md

@@ -2,7 +2,18 @@
 
 Contributions are what makes the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
 
-- Before jumping into a PR be sure to search [existing PRs](https://github.com/calcom/cal.com/pulls) or [issues](https://github.com/calcom/cal.com/issues) for an open or closed item that relates to your submission.
+## House rules
+
+- Before submitting a new issue or PR, check if it already exists in [issues](https://github.com/calcom/cal.com/issues) or [PRs](https://github.com/calcom/cal.com/pulls).
+- GitHub issues: take note of the `🚨 needs approval` label.
+  - **For Contributors**:
+    - Feature Requests: Wait for a core member to approve and remove the `🚨 needs approval` label before you start coding or submit a PR.
+    - Bugs, Security, Performance, Documentation, etc.: You can start coding immediately, even if the `🚨 needs approval` label is present. This label mainly concerns feature requests.
+  - **Our Process**:
+    - Issues from non-core members automatically receive the `🚨 needs approval` label.
+    - We greatly value new feature ideas. To ensure consistency in the product's direction, they undergo review and approval.
+
+
 
 ## Priorities
 

README.md

@@ -122,7 +122,7 @@ Here is what you need to be able to run Cal.com.
 
 ### Setup
 
-1. Clone the repo into a public GitHub repository (or fork https://github.com/calcom/cal.com/fork). If you plan to distribute the code, keep the source code public to comply with [AGPLv3](https://github.com/calcom/cal.com/blob/main/LICENSE). To clone in a private repository, [acquire a commercial license](https://cal.com/sales))
+1. Clone the repo into a public GitHub repository (or fork https://github.com/calcom/cal.com/fork). If you plan to distribute the code, keep the source code public to comply with [AGPLv3](https://github.com/calcom/cal.com/blob/main/LICENSE). To clone in a private repository, [acquire a commercial license](https://cal.com/sales)
 
    ```sh
    git clone https://github.com/calcom/cal.com.git
@@ -221,7 +221,7 @@ echo 'NEXT_PUBLIC_DEBUG=1' >> .env
 
 1. Copy and paste your `DATABASE_URL` from `.env` to `.env.appStore`.
 
-1. Set a 32 character random string in your `.env` file for the `CALENDSO_ENCRYPTION_KEY` (You can use a command like `openssl rand -base64 24` to generate one).
+1. Set a 24 character random string in your `.env` file for the `CALENDSO_ENCRYPTION_KEY` (You can use a command like `openssl rand -base64 24` to generate one).
 1. Set up the database using the Prisma schema (found in `packages/prisma/schema.prisma`)
 
    In a development environment, run:
@@ -597,8 +597,6 @@ Distributed under the [AGPLv3 License](https://github.com/calcom/cal.com/blob/ma
 
 Special thanks to these amazing projects which help power Cal.com:
 
-[<img src="https://cal.com/powered-by-vercel.svg">](https://vercel.com/?utm_source=calend-so&utm_campaign=oss)
-
 - [Vercel](https://vercel.com/?utm_source=calend-so&utm_campaign=oss)
 - [Next.js](https://nextjs.org/)
 - [Day.js](https://day.js.org/)

__checks__/README.md

@@ -0,0 +1,4 @@
+# Checkly Tests
+
+Run as `yarn checkly test`
+Deploy the tests as `yarn checkly deploy`

__checks__/organization.spec.ts

@@ -0,0 +1,53 @@
+import type { Page } from "@playwright/test";
+import { test, expect } from "@playwright/test";
+
+test.describe("Org", () => {
+  // Because these pages involve next.config.js rewrites, it's better to test them on production
+  test.describe("Embeds - i.cal.com", () => {
+    test("Org Profile Page should be embeddable", async ({ page }) => {
+      const response = await page.goto("https://i.cal.com/embed");
+      expect(response?.status()).toBe(200);
+      await page.screenshot({ path: "screenshot.jpg" });
+      await expectPageToBeServerSideRendered(page);
+    });
+
+    test("Org User(Peer) Page should be embeddable", async ({ page }) => {
+      const response = await page.goto("https://i.cal.com/peer/embed");
+      expect(response?.status()).toBe(200);
+      await expect(page.locator("text=Peer Richelsen")).toBeVisible();
+      await expectPageToBeServerSideRendered(page);
+    });
+
+    test("Org User Event(peer/meet) Page should be embeddable", async ({ page }) => {
+      const response = await page.goto("https://i.cal.com/peer/meet/embed");
+      expect(response?.status()).toBe(200);
+      await expect(page.locator('[data-testid="decrementMonth"]')).toBeVisible();
+      await expect(page.locator('[data-testid="incrementMonth"]')).toBeVisible();
+      await expectPageToBeServerSideRendered(page);
+    });
+
+    test("Org Team Profile(/sales) page should be embeddable", async ({ page }) => {
+      const response = await page.goto("https://i.cal.com/sales/embed");
+      expect(response?.status()).toBe(200);
+      await expect(page.locator("text=Cal.com Sales")).toBeVisible();
+      await expectPageToBeServerSideRendered(page);
+    });
+
+    test("Org Team Event page(/sales/hippa) should be embeddable", async ({ page }) => {
+      const response = await page.goto("https://i.cal.com/sales/hipaa/embed");
+      expect(response?.status()).toBe(200);
+      await expect(page.locator('[data-testid="decrementMonth"]')).toBeVisible();
+      await expect(page.locator('[data-testid="incrementMonth"]')).toBeVisible();
+      await expectPageToBeServerSideRendered(page);
+    });
+  });
+});
+
+// This ensures that the route is actually mapped to a page that is using withEmbedSsr
+async function expectPageToBeServerSideRendered(page: Page) {
+  expect(
+    await page.evaluate(() => {
+      return window.__NEXT_DATA__.props.pageProps.isEmbed;
+    })
+  ).toBe(true);
+}

app.json

@@ -83,6 +83,10 @@
     "NEXT_PUBLIC_TEAM_IMPERSONATION": {
       "description": "Set the following value to true if you wish to enable Team Impersonation",
       "value": "false"
+    },
+    "NEXT_PUBLIC_AVAILABILITY_SCHEDULE_INTERVAL": {
+      "description": "Control time intervals on a user's Schedule availability",
+      "value": "15"
     }
   },
   "scripts": {

apps/api/lib/utils/isValidBase64Image.ts

@@ -0,0 +1,4 @@
+export function isValidBase64Image(input: string): boolean {
+  const regex = /^data:image\/[^;]+;base64,(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+  return regex.test(input);
+}

apps/api/lib/validations/availability.ts

@@ -26,6 +26,7 @@ const schemaAvailabilityCreateParams = z
     startTime: z.date().or(z.string()),
     endTime: z.date().or(z.string()),
     days: z.array(z.number()).optional(),
+    date: z.date().or(z.string()).optional(),
   })
   .strict();
 
@@ -34,6 +35,7 @@ const schemaAvailabilityEditParams = z
     startTime: z.date().or(z.string()).optional(),
     endTime: z.date().or(z.string()).optional(),
     days: z.array(z.number()).optional(),
+    date: z.date().or(z.string()).optional(),
   })
   .strict();
 

apps/api/lib/validations/destination-calendar.ts

@@ -3,7 +3,6 @@ import { z } from "zod";
 import { _DestinationCalendarModel as DestinationCalendar } from "@calcom/prisma/zod";
 
 export const schemaDestinationCalendarBaseBodyParams = DestinationCalendar.pick({
-  credentialId: true,
   integration: true,
   externalId: true,
   eventTypeId: true,
@@ -15,7 +14,6 @@ const schemaDestinationCalendarCreateParams = z
   .object({
     integration: z.string(),
     externalId: z.string(),
-    credentialId: z.number(),
     eventTypeId: z.number().optional(),
     bookingId: z.number().optional(),
     userId: z.number().optional(),
@@ -47,5 +45,4 @@ export const schemaDestinationCalendarReadPublic = DestinationCalendar.pick({
   eventTypeId: true,
   bookingId: true,
   userId: true,
-  credentialId: true,
 });

apps/api/lib/validations/schedule.ts

@@ -21,7 +21,16 @@ export const schemaSchedulePublic = z
   .merge(
     z.object({
       availability: z
-        .array(Availability.pick({ id: true, eventTypeId: true, days: true, startTime: true, endTime: true }))
+        .array(
+          Availability.pick({
+            id: true,
+            eventTypeId: true,
+            date: true,
+            days: true,
+            startTime: true,
+            endTime: true,
+          })
+        )
         .transform((v) =>
           v.map((item) => ({
             ...item,

apps/api/lib/validations/user.ts

@@ -4,6 +4,7 @@ import { checkUsername } from "@calcom/lib/server/checkUsername";
 import { _UserModel as User } from "@calcom/prisma/zod";
 import { iso8601 } from "@calcom/prisma/zod-utils";
 
+import { isValidBase64Image } from "~/lib/utils/isValidBase64Image";
 import { timeZone } from "~/lib/validations/shared/timeZone";
 
 // @note: These are the ONLY values allowed as weekStart. So user don't introduce bad data.
@@ -106,6 +107,7 @@ const schemaUserEditParams = z.object({
     .optional()
     .nullable(),
   locale: z.nativeEnum(locales).optional().nullable(),
+  avatar: z.string().refine(isValidBase64Image).optional(),
 });
 
 // @note: These are the values that are editable via PATCH method on the user Model,
@@ -128,6 +130,7 @@ const schemaUserCreateParams = z.object({
     .nullable(),
   locale: z.nativeEnum(locales).optional(),
   createdDate: iso8601.optional(),
+  avatar: z.string().refine(isValidBase64Image).optional(),
 });
 
 // @note: These are the values that are editable via PATCH method on the user Model,

apps/api/package.json

@@ -13,6 +13,7 @@
     "lint": "eslint . --ignore-path .gitignore",
     "lint:fix": "eslint . --ext .ts,.js,.tsx,.jsx --fix",
     "start": "PORT=3002 next start",
+    "docker-start-api": "PORT=80 next start",
     "type-check": "tsc --pretty --noEmit"
   },
   "devDependencies": {
@@ -29,7 +30,7 @@
     "@calcom/lib": "*",
     "@calcom/prisma": "*",
     "@calcom/trpc": "*",
-    "@sentry/nextjs": "^7.20.0",
+    "@sentry/nextjs": "^7.73.0",
     "bcryptjs": "^2.4.3",
     "memory-cache": "^0.2.0",
     "next": "^13.4.6",

apps/api/pages/api/bookings/[id]/_delete.ts

@@ -56,10 +56,6 @@ import { schemaQueryIdParseInt } from "~/lib/validations/shared/queryIdTransform
  *               <td>The provided id didn't correspond to any existing booking.</td>
  *             </tr>
  *             <tr>
- *               <td>Cannot cancel past events</td>
- *               <td>The provided id matched an existing booking with a past startDate.</td>
- *             </tr>
- *             <tr>
  *               <td>User not found</td>
  *               <td>The userId did not matched an existing user.</td>
  *             </tr>

apps/api/pages/api/bookings/_post.ts

@@ -205,8 +205,8 @@ import { defaultResponder } from "@calcom/lib/server";
 async function handler(req: NextApiRequest) {
   const { userId, isAdmin } = req;
   if (isAdmin) req.userId = req.body.userId || userId;
-  const booking = await handleNewBooking(req);
-  return booking;
+
+  return await handleNewBooking(req);
 }
 
 export default defaultResponder(handler);

apps/api/pages/api/destination-calendars/[id]/_patch.ts

@@ -1,6 +1,12 @@
+import type { Prisma } from "@prisma/client";
 import type { NextApiRequest } from "next";
+import type { z } from "zod";
 
+import { getCalendarCredentials, getConnectedCalendars } from "@calcom/core/CalendarManager";
+import { HttpError } from "@calcom/lib/http-error";
 import { defaultResponder } from "@calcom/lib/server";
+import type { PrismaClient } from "@calcom/prisma";
+import { credentialForCalendarServiceSelect } from "@calcom/prisma/selects/credential";
 
 import {
   schemaDestinationCalendarEditBodyParams,
@@ -56,16 +62,251 @@ import { schemaQueryIdParseInt } from "~/lib/validations/shared/queryIdTransform
  *       404:
  *        description: Destination calendar not found
  */
+type DestinationCalendarType = {
+  userId?: number | null;
+  eventTypeId?: number | null;
+  credentialId: number | null;
+};
+
+type UserCredentialType = {
+  id: number;
+  appId: string | null;
+  type: string;
+  userId: number | null;
+  user: {
+    email: string;
+  } | null;
+  teamId: number | null;
+  key: Prisma.JsonValue;
+  invalid: boolean | null;
+};
+
 export async function patchHandler(req: NextApiRequest) {
-  const { prisma, query, body } = req;
+  const { userId, isAdmin, prisma, query, body } = req;
   const { id } = schemaQueryIdParseInt.parse(query);
   const parsedBody = schemaDestinationCalendarEditBodyParams.parse(body);
+  const assignedUserId = isAdmin ? parsedBody.userId || userId : userId;
 
+  validateIntegrationInput(parsedBody);
+  const destinationCalendarObject: DestinationCalendarType = await getDestinationCalendar(id, prisma);
+  await validateRequestAndOwnership({ destinationCalendarObject, parsedBody, assignedUserId, prisma });
+
+  const userCredentials = await getUserCredentials({
+    credentialId: destinationCalendarObject.credentialId,
+    userId: assignedUserId,
+    prisma,
+  });
+  const credentialId = await verifyCredentialsAndGetId({
+    parsedBody,
+    userCredentials,
+    currentCredentialId: destinationCalendarObject.credentialId,
+  });
+  // If the user has passed eventTypeId, we need to remove userId from the update data to make sure we don't link it to user as well
+  if (parsedBody.eventTypeId) parsedBody.userId = undefined;
   const destinationCalendar = await prisma.destinationCalendar.update({
     where: { id },
-    data: parsedBody,
+    data: { ...parsedBody, credentialId },
   });
   return { destinationCalendar: schemaDestinationCalendarReadPublic.parse(destinationCalendar) };
 }
 
+/**
+ * Retrieves user credentials associated with a given credential ID and user ID and validates if the credentials belong to this user
+ *
+ * @param credentialId - The ID of the credential to fetch. If not provided, an error is thrown.
+ * @param userId - The user ID against which the credentials need to be verified.
+ * @param prisma - An instance of PrismaClient for database operations.
+ *
+ * @returns - An array containing the matching user credentials.
+ *
+ * @throws HttpError - If `credentialId` is not provided or no associated credentials are found in the database.
+ */
+async function getUserCredentials({
+  credentialId,
+  userId,
+  prisma,
+}: {
+  credentialId: number | null;
+  userId: number;
+  prisma: PrismaClient;
+}) {
+  if (!credentialId) {
+    throw new HttpError({
+      statusCode: 404,
+      message: `Destination calendar missing credential id`,
+    });
+  }
+  const userCredentials = await prisma.credential.findMany({
+    where: { id: credentialId, userId },
+    select: credentialForCalendarServiceSelect,
+  });
+
+  if (!userCredentials || userCredentials.length === 0) {
+    throw new HttpError({
+      statusCode: 400,
+      message: `Bad request, no associated credentials found`,
+    });
+  }
+  return userCredentials;
+}
+
+/**
+ * Verifies the provided credentials and retrieves the associated credential ID.
+ *
+ * This function checks if the `integration` and `externalId` properties from the parsed body are present.
+ * If both properties exist, it fetches the connected calendar credentials using the provided user credentials
+ * and checks for a matching external ID and integration from the list of connected calendars.
+ *
+ * If a match is found, it updates the `credentialId` with the one from the connected calendar.
+ * Otherwise, it throws an HTTP error with a 400 status indicating an invalid credential ID.
+ *
+ * If the parsed body does not contain the necessary properties, the function
+ * returns the `credentialId` from the destination calendar object.
+ *
+ * @param parsedBody - The parsed body from the incoming request, validated against a predefined schema.
+ *                     Checked if it contain properties like `integration` and `externalId`.
+ * @param userCredentials - An array of user credentials used to fetch the connected calendar credentials.
+ * @param destinationCalendarObject - An object representing the destination calendar. Primarily used
+ *                                    to fetch the default `credentialId`.
+ *
+ * @returns - The verified `credentialId` either from the matched connected calendar in case of updating the destination calendar,
+ *            or the provided destination calendar object in other cases.
+ *
+ * @throws HttpError - If no matching connected calendar is found for the given `integration` and `externalId`.
+ */
+async function verifyCredentialsAndGetId({
+  parsedBody,
+  userCredentials,
+  currentCredentialId,
+}: {
+  parsedBody: z.infer<typeof schemaDestinationCalendarEditBodyParams>;
+  userCredentials: UserCredentialType[];
+  currentCredentialId: number | null;
+}) {
+  if (parsedBody.integration && parsedBody.externalId) {
+    const calendarCredentials = getCalendarCredentials(userCredentials);
+
+    const { connectedCalendars } = await getConnectedCalendars(
+      calendarCredentials,
+      [],
+      parsedBody.externalId
+    );
+    const eligibleCalendars = connectedCalendars[0]?.calendars?.filter((calendar) => !calendar.readOnly);
+    const calendar = eligibleCalendars?.find(
+      (c) => c.externalId === parsedBody.externalId && c.integration === parsedBody.integration
+    );
+
+    if (!calendar?.credentialId)
+      throw new HttpError({
+        statusCode: 400,
+        message: "Bad request, credential id invalid",
+      });
+    return calendar?.credentialId;
+  }
+  return currentCredentialId;
+}
+
+/**
+ * Validates the request for updating a destination calendar.
+ *
+ * This function checks the validity of the provided eventTypeId against the existing destination calendar object
+ * in the sense that if the destination calendar is not linked to an event type, the eventTypeId can not be provided.
+ *
+ * It also ensures that the eventTypeId, if provided, belongs to the assigned user.
+ *
+ * @param destinationCalendarObject - An object representing the destination calendar.
+ * @param parsedBody - The parsed body from the incoming request, validated against a predefined schema.
+ * @param assignedUserId - The user ID assigned for the operation, which might be an admin or a regular user.
+ * @param prisma - An instance of PrismaClient for database operations.
+ *
+ * @throws HttpError - If the validation fails or inconsistencies are detected in the request data.
+ */
+async function validateRequestAndOwnership({
+  destinationCalendarObject,
+  parsedBody,
+  assignedUserId,
+  prisma,
+}: {
+  destinationCalendarObject: DestinationCalendarType;
+  parsedBody: z.infer<typeof schemaDestinationCalendarEditBodyParams>;
+  assignedUserId: number;
+  prisma: PrismaClient;
+}) {
+  if (parsedBody.eventTypeId) {
+    if (!destinationCalendarObject.eventTypeId) {
+      throw new HttpError({
+        statusCode: 400,
+        message: `The provided destination calendar can not be linked to an event type`,
+      });
+    }
+
+    const userEventType = await prisma.eventType.findFirst({
+      where: { id: parsedBody.eventTypeId },
+      select: { userId: true },
+    });
+
+    if (!userEventType || userEventType.userId !== assignedUserId) {
+      throw new HttpError({
+        statusCode: 404,
+        message: `Event type with ID ${parsedBody.eventTypeId} not found`,
+      });
+    }
+  }
+
+  if (!parsedBody.eventTypeId) {
+    if (destinationCalendarObject.eventTypeId) {
+      throw new HttpError({
+        statusCode: 400,
+        message: `The provided destination calendar can only be linked to an event type`,
+      });
+    }
+    if (destinationCalendarObject.userId !== assignedUserId) {
+      throw new HttpError({
+        statusCode: 403,
+        message: `Forbidden`,
+      });
+    }
+  }
+}
+
+/**
+ * Fetches the destination calendar based on the provided ID as the path parameter, specifically `credentialId` and `eventTypeId`.
+ *
+ * If no matching destination calendar is found for the provided ID, an HTTP error with a 404 status
+ * indicating that the desired destination calendar was not found is thrown.
+ *
+ * @param id - The ID of the destination calendar to be retrieved.
+ * @param prisma - An instance of PrismaClient for database operations.
+ *
+ * @returns - An object containing details of the matching destination calendar, specifically `credentialId` and `eventTypeId`.
+ *
+ * @throws HttpError - If no destination calendar matches the provided ID.
+ */
+async function getDestinationCalendar(id: number, prisma: PrismaClient) {
+  const destinationCalendarObject = await prisma.destinationCalendar.findFirst({
+    where: {
+      id,
+    },
+    select: { userId: true, eventTypeId: true, credentialId: true },
+  });
+
+  if (!destinationCalendarObject) {
+    throw new HttpError({
+      statusCode: 404,
+      message: `Destination calendar with ID ${id} not found`,
+    });
+  }
+
+  return destinationCalendarObject;
+}
+
+function validateIntegrationInput(parsedBody: z.infer<typeof schemaDestinationCalendarEditBodyParams>) {
+  if (parsedBody.integration && !parsedBody.externalId) {
+    throw new HttpError({ statusCode: 400, message: "External Id is required with integration value" });
+  }
+  if (!parsedBody.integration && parsedBody.externalId) {
+    throw new HttpError({ statusCode: 400, message: "Integration value is required with external ID" });
+  }
+}
+
 export default defaultResponder(patchHandler);

apps/api/pages/api/destination-calendars/_post.ts

@@ -1,7 +1,9 @@
 import type { NextApiRequest } from "next";
 
+import { getCalendarCredentials, getConnectedCalendars } from "@calcom/core/CalendarManager";
 import { HttpError } from "@calcom/lib/http-error";
 import { defaultResponder } from "@calcom/lib/server";
+import { credentialForCalendarServiceSelect } from "@calcom/prisma/selects/credential";
 
 import {
   schemaDestinationCalendarReadPublic,
@@ -38,9 +40,6 @@ import {
  *               externalId:
  *                 type: string
  *                 description: 'The external ID of the integration'
- *               credentialId:
- *                 type: integer
- *                 description: 'The credential ID it is associated with'
  *               eventTypeId:
  *                 type: integer
  *                 description: 'The ID of the eventType it is associated with'
@@ -65,20 +64,38 @@ async function postHandler(req: NextApiRequest) {
   const parsedBody = schemaDestinationCalendarCreateBodyParams.parse(body);
   await checkPermissions(req, userId);
 
-  const assignedUserId = isAdmin ? parsedBody.userId || userId : userId;
+  const assignedUserId = isAdmin && parsedBody.userId ? parsedBody.userId : userId;
 
   /* Check if credentialId data matches the ownership and integration passed in */
-  const credential = await prisma.credential.findFirst({
-    where: { type: parsedBody.integration, userId: assignedUserId },
-    select: { id: true, type: true, userId: true },
+  const userCredentials = await prisma.credential.findMany({
+    where: {
+      type: parsedBody.integration,
+      userId: assignedUserId,
+    },
+    select: credentialForCalendarServiceSelect,
   });
 
-  if (!credential)
+  if (userCredentials.length === 0)
     throw new HttpError({
       statusCode: 400,
       message: "Bad request, credential id invalid",
     });
 
+  const calendarCredentials = getCalendarCredentials(userCredentials);
+
+  const { connectedCalendars } = await getConnectedCalendars(calendarCredentials, [], parsedBody.externalId);
+
+  const eligibleCalendars = connectedCalendars[0]?.calendars?.filter((calendar) => !calendar.readOnly);
+  const calendar = eligibleCalendars?.find(
+    (c) => c.externalId === parsedBody.externalId && c.integration === parsedBody.integration
+  );
+  if (!calendar?.credentialId)
+    throw new HttpError({
+      statusCode: 400,
+      message: "Bad request, credential id invalid",
+    });
+  const credentialId = calendar.credentialId;
+
   if (parsedBody.eventTypeId) {
     const eventType = await prisma.eventType.findFirst({
       where: { id: parsedBody.eventTypeId, userId: parsedBody.userId },
@@ -91,7 +108,9 @@ async function postHandler(req: NextApiRequest) {
     parsedBody.userId = undefined;
   }
 
-  const destination_calendar = await prisma.destinationCalendar.create({ data: { ...parsedBody } });
+  const destination_calendar = await prisma.destinationCalendar.create({
+    data: { ...parsedBody, credentialId },
+  });
 
   return {
     destinationCalendar: schemaDestinationCalendarReadPublic.parse(destination_calendar),

apps/api/pages/api/event-types/[id]/_get.ts

@@ -51,6 +51,7 @@ export async function getHandler(req: NextApiRequest) {
       customInputs: true,
       team: { select: { slug: true } },
       users: true,
+      hosts: { select: { userId: true, isFixed: true } },
       owner: { select: { username: true, id: true } },
       children: { select: { id: true, userId: true } },
     },

apps/api/pages/api/event-types/_get.ts

@@ -45,6 +45,7 @@ async function getHandler(req: NextApiRequest) {
       customInputs: true,
       team: { select: { slug: true } },
       users: true,
+      hosts: { select: { userId: true, isFixed: true } },
       owner: { select: { username: true, id: true } },
       children: { select: { id: true, userId: true } },
     },

apps/api/pages/api/event-types/_post.ts

@@ -316,8 +316,9 @@ async function checkPermissions(req: NextApiRequest) {
       statusCode: 401,
       message: "ADMIN required for `userId`",
     });
-  /* Admin users are required to pass in a userId */
-  if (isAdmin && !body.userId) throw new HttpError({ statusCode: 400, message: "`userId` required" });
+  /* Admin users are required to pass in a userId or teamId */
+  if (isAdmin && (!body.userId || !body.teamId))
+    throw new HttpError({ statusCode: 400, message: "`userId` or `teamId` required" });
 }
 
 export default defaultResponder(postHandler);

apps/api/pages/api/users/[userId]/_patch.ts

@@ -65,6 +65,9 @@ import { schemaUserEditBodyParams, schemaUserReadPublic } from "~/lib/validation
  *               locale:
  *                 description: The user's locale. Acceptable values are one of [EN, FR, IT, RU, ES, DE, PT, RO, NL, PT_BR, ES_419, KO, JA, PL, AR, IW, ZH_CH, ZH_TW, CS, SR, SV, VI]
  *                 type: string
+ *               avatar:
+ *                 description: The user's avatar, in base64 format
+ *                 type: string
  *           examples:
  *              user:
  *                summary: An example of USER

apps/api/pages/api/users/_post.ts

@@ -60,6 +60,9 @@ import { schemaUserCreateBodyParams } from "~/lib/validations/user";
  *               locale:
  *                 description: The new user's locale. Acceptable values are one of [EN, FR, IT, RU, ES, DE, PT, RO, NL, PT_BR, ES_419, KO, JA, PL, AR, IW, ZH_CH, ZH_TW, CS, SR, SV, VI]
  *                 type: string
+ *               avatar:
+ *                 description: The user's avatar, in base64 format
+ *                 type: string
  *           examples:
  *              user:
  *                summary: An example of USER

apps/api/test/lib/bookings/_post.test.ts

@@ -8,6 +8,7 @@ import { describe, expect, test, vi } from "vitest";
 
 import dayjs from "@calcom/dayjs";
 import sendPayload from "@calcom/features/webhooks/lib/sendPayload";
+import { ErrorCode } from "@calcom/lib/errorCodes";
 import { buildBooking, buildEventType, buildWebhook } from "@calcom/lib/test/builder";
 import prisma from "@calcom/prisma";
 
@@ -148,7 +149,7 @@ describe.skipIf(true)("POST /api/bookings", () => {
       expect(res._getStatusCode()).toBe(500);
       expect(JSON.parse(res._getData())).toEqual(
         expect.objectContaining({
-          message: "No available users found.",
+          message: ErrorCode.NoAvailableUsersFound,
         })
       );
     });

apps/api/vercel.json

@@ -0,0 +1,7 @@
+{
+  "functions": {
+    "pages/api/slots/*.ts": {
+      "memory": 512
+    }
+  }
+}

apps/web/abTest/middlewareFactory.ts

@@ -0,0 +1,50 @@
+import { getBucket } from "abTest/utils";
+import type { NextMiddleware, NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import z from "zod";
+
+const ROUTES: [RegExp, boolean][] = [
+  [/^\/event-types$/, Boolean(process.env.APP_ROUTER_EVENT_TYPES_ENABLED)],
+];
+
+const FUTURE_ROUTES_OVERRIDE_COOKIE_NAME = "x-calcom-future-routes-override";
+const FUTURE_ROUTES_ENABLED_COOKIE_NAME = "x-calcom-future-routes-enabled";
+
+const bucketSchema = z.union([z.literal("legacy"), z.literal("future")]).default("legacy");
+
+export const abTestMiddlewareFactory =
+  (next: (req: NextRequest) => Promise<NextResponse<unknown>>): NextMiddleware =>
+  async (req: NextRequest) => {
+    const response = await next(req);
+
+    const { pathname } = req.nextUrl;
+
+    const override = req.cookies.has(FUTURE_ROUTES_OVERRIDE_COOKIE_NAME);
+
+    const route = ROUTES.find(([regExp]) => regExp.test(pathname)) ?? null;
+
+    const enabled = route !== null ? route[1] || override : false;
+
+    if (pathname.includes("future") || !enabled) {
+      return response;
+    }
+
+    const safeParsedBucket = override
+      ? { success: true as const, data: "future" as const }
+      : bucketSchema.safeParse(req.cookies.get(FUTURE_ROUTES_ENABLED_COOKIE_NAME)?.value);
+
+    if (!safeParsedBucket.success) {
+      // cookie does not exist or it has incorrect value
+
+      const res = NextResponse.next(response);
+      res.cookies.set(FUTURE_ROUTES_ENABLED_COOKIE_NAME, getBucket(), { expires: 1000 * 60 * 30 }); // 30 min in ms
+      return res;
+    }
+
+    const bucketUrlPrefix = safeParsedBucket.data === "future" ? "future" : "";
+
+    const url = req.nextUrl.clone();
+    url.pathname = `${bucketUrlPrefix}${pathname}/`;
+
+    return NextResponse.rewrite(url, response);
+  };

apps/web/abTest/utils.ts

@@ -0,0 +1,9 @@
+import { AB_TEST_BUCKET_PROBABILITY } from "@calcom/lib/constants";
+
+const cryptoRandom = () => {
+  return crypto.getRandomValues(new Uint8Array(1))[0] / 0xff;
+};
+
+export const getBucket = () => {
+  return cryptoRandom() * 100 < AB_TEST_BUCKET_PROBABILITY ? "future" : "legacy";
+};

apps/web/app/layout.tsx

@@ -0,0 +1,109 @@
+import type { Metadata } from "next";
+import { headers as nextHeaders, cookies as nextCookies } from "next/headers";
+import Script from "next/script";
+import React from "react";
+
+import { getLocale } from "@calcom/features/auth/lib/getLocale";
+import { IS_PRODUCTION } from "@calcom/lib/constants";
+
+import "../styles/globals.css";
+
+export const metadata: Metadata = {
+  icons: {
+    icon: [
+      {
+        sizes: "32x32",
+        url: "/api/logo?type=favicon-32",
+      },
+      {
+        sizes: "16x16",
+        url: "/api/logo?type=favicon-16",
+      },
+    ],
+    apple: {
+      sizes: "180x180",
+      url: "/api/logo?type=apple-touch-icon",
+    },
+    other: [
+      {
+        url: "/safari-pinned-tab.svg",
+        rel: "mask-icon",
+      },
+    ],
+  },
+  manifest: "/site.webmanifest",
+  themeColor: [
+    { media: "(prefers-color-scheme: light)", color: "#f9fafb" },
+    { media: "(prefers-color-scheme: dark)", color: "#1C1C1C" },
+  ],
+  other: {
+    "msapplication-TileColor": "#000000",
+  },
+};
+
+const getInitialProps = async (
+  url: string,
+  headers: ReturnType<typeof nextHeaders>,
+  cookies: ReturnType<typeof nextCookies>
+) => {
+  const { pathname, searchParams } = new URL(url);
+
+  const isEmbed = pathname.endsWith("/embed") || (searchParams?.get("embedType") ?? null) !== null;
+  const embedColorScheme = searchParams?.get("ui.color-scheme");
+
+  // @ts-expect-error we cannot access ctx.req in app dir, however headers and cookies are only properties needed to extract the locale
+  const newLocale = await getLocale({ headers, cookies });
+  let direction = "ltr";
+
+  try {
+    const intlLocale = new Intl.Locale(newLocale);
+    // @ts-expect-error INFO: Typescript does not know about the Intl.Locale textInfo attribute
+    direction = intlLocale.textInfo?.direction;
+  } catch (e) {
+    console.error(e);
+  }
+
+  return { isEmbed, embedColorScheme, locale: newLocale, direction };
+};
+
+export default async function RootLayout({ children }: { children: React.ReactNode }) {
+  const headers = nextHeaders();
+  const cookies = nextCookies();
+
+  const fullUrl = headers.get("x-url") ?? "";
+  const nonce = headers.get("x-csp") ?? "";
+
+  const { locale, direction, isEmbed, embedColorScheme } = await getInitialProps(fullUrl, headers, cookies);
+  return (
+    <html
+      lang={locale}
+      dir={direction}
+      style={embedColorScheme ? { colorScheme: embedColorScheme as string } : undefined}>
+      <head nonce={nonce}>
+        {!IS_PRODUCTION && process.env.VERCEL_ENV === "preview" && (
+          // eslint-disable-next-line @next/next/no-sync-scripts
+          <Script
+            data-project-id="KjpMrKTnXquJVKfeqmjdTffVPf1a6Unw2LZ58iE4"
+            src="https://snippet.meticulous.ai/v1/stagingMeticulousSnippet.js"
+          />
+        )}
+      </head>
+      <body
+        className="dark:bg-darkgray-50 desktop-transparent bg-subtle antialiased"
+        style={
+          isEmbed
+            ? {
+                background: "transparent",
+                // Keep the embed hidden till parent initializes and
+                // - gives it the appropriate styles if UI instruction is there.
+                // - gives iframe the appropriate height(equal to document height) which can only be known after loading the page once in browser.
+                // - Tells iframe which mode it should be in (dark/light) - if there is a a UI instruction for that
+                visibility: "hidden",
+              }
+            : {}
+        }>
+        {children}
+      </body>
+    </html>
+  );
+}

apps/web/calendso.yaml

@@ -631,8 +631,7 @@ paths:
                   type: string
                 role:
                   type: string
-                sendEmailInvitation:
-                  type: boolean
+                  
     parameters:
       - schema:
           type: string

apps/web/components/PageWrapperAppDir.tsx

@@ -0,0 +1,88 @@
+"use client";
+
+import type { SSRConfig } from "next-i18next";
+import { Inter } from "next/font/google";
+import localFont from "next/font/local";
+// import I18nLanguageHandler from "@components/I18nLanguageHandler";
+import { usePathname } from "next/navigation";
+import Script from "next/script";
+import type { ReactNode } from "react";
+
+import "@calcom/embed-core/src/embed-iframe";
+import LicenseRequired from "@calcom/features/ee/common/components/LicenseRequired";
+import { trpc } from "@calcom/trpc/react";
+
+import type { AppProps } from "@lib/app-providers-app-dir";
+import AppProviders from "@lib/app-providers-app-dir";
+
+export interface CalPageWrapper {
+  (props?: AppProps): JSX.Element;
+  PageWrapper?: AppProps["Component"]["PageWrapper"];
+}
+
+const interFont = Inter({ subsets: ["latin"], variable: "--font-inter", preload: true, display: "swap" });
+const calFont = localFont({
+  src: "../fonts/CalSans-SemiBold.woff2",
+  variable: "--font-cal",
+  preload: true,
+  display: "swap",
+});
+
+export type PageWrapperProps = Readonly<{
+  getLayout: (page: React.ReactElement) => ReactNode;
+  children: React.ReactElement;
+  requiresLicense: boolean;
+  isThemeSupported: boolean;
+  isBookingPage: boolean;
+  nonce: string | undefined;
+  themeBasis: string | null;
+  i18n?: SSRConfig;
+}>;
+
+function PageWrapper(props: PageWrapperProps) {
+  const pathname = usePathname();
+  let pageStatus = "200";
+
+  if (pathname === "/404") {
+    pageStatus = "404";
+  } else if (pathname === "/500") {
+    pageStatus = "500";
+  }
+
+  // On client side don't let nonce creep into DOM
+  // It also avoids hydration warning that says that Client has the nonce value but server has "" because browser removes nonce attributes before DOM is built
+  // See https://github.com/kentcdodds/nonce-hydration-issues
+  // Set "" only if server had it set otherwise keep it undefined because server has to match with client to avoid hydration error
+  const nonce = typeof window !== "undefined" ? (props.nonce ? "" : undefined) : props.nonce;
+  const providerProps: PageWrapperProps = {
+    ...props,
+    nonce,
+  };
+
+  const getLayout: (page: React.ReactElement) => ReactNode = props.getLayout ?? ((page) => page);
+
+  return (
+    <AppProviders {...providerProps}>
+      {/* <I18nLanguageHandler locales={props.router.locales || []} /> */}
+      <>
+        <Script
+          nonce={nonce}
+          id="page-status"
+          dangerouslySetInnerHTML={{ __html: `window.CalComPageStatus = '${pageStatus}'` }}
+        />
+        <style jsx global>{`
+          :root {
+            --font-inter: ${interFont.style.fontFamily};
+            --font-cal: ${calFont.style.fontFamily};
+          }
+        `}</style>
+
+        {getLayout(
+          props.requiresLicense ? <LicenseRequired>{props.children}</LicenseRequired> : props.children
+        )}
+      </>
+    </AppProviders>
+  );
+}
+
+export default trpc.withTRPC(PageWrapper);

apps/web/components/apps/AppPage.tsx

@@ -42,6 +42,7 @@ export type AppPageProps = {
   disableInstall?: boolean;
   dependencies?: string[];
   concurrentMeetings: AppType["concurrentMeetings"];
+  paid?: AppType["paid"];
 };
 
 export const AppPage = ({
@@ -67,6 +68,7 @@ export const AppPage = ({
   isTemplate,
   dependencies,
   concurrentMeetings,
+  paid,
 }: AppPageProps) => {
   const { t, i18n } = useLocale();
   const hasDescriptionItems = descriptionItems && descriptionItems.length > 0;
@@ -163,6 +165,19 @@ export const AppPage = ({
                 className="bg-subtle text-emphasis rounded-md p-1 text-xs capitalize">
                 {categories[0]}
               </Link>{" "}
+              {paid && (
+                <>
+                  <Badge className="mr-1">
+                    {Intl.NumberFormat(i18n.language, {
+                      style: "currency",
+                      currency: "USD",
+                      useGrouping: false,
+                      maximumFractionDigits: 0,
+                    }).format(paid.priceInUsd)}
+                    /{t("month")}
+                  </Badge>
+                </>
+              )}
               •{" "}
               <a target="_blank" rel="noreferrer" href={website}>
                 {t("published_by", { author })}
@@ -206,6 +221,7 @@ export const AppPage = ({
                         addAppMutationInput={{ type, variant, slug }}
                         multiInstall
                         concurrentMeetings={concurrentMeetings}
+                        paid={paid}
                         {...props}
                       />
                     );
@@ -244,6 +260,7 @@ export const AppPage = ({
                     addAppMutationInput={{ type, variant, slug }}
                     credentials={appDbQuery.data?.credentials}
                     concurrentMeetings={concurrentMeetings}
+                    paid={paid}
                     {...props}
                   />
                 );
@@ -263,7 +280,7 @@ export const AppPage = ({
             <SkeletonButton className="mt-6 h-20 grow" />
           ))}
 
-        {price !== 0 && (
+        {price !== 0 && !paid && (
           <span className="block text-right">
             {feeType === "usage-based" ? `${commission}% + ${priceInDollar}/booking` : priceInDollar}
             {feeType === "monthly" && `/${t("month")}`}
@@ -273,23 +290,27 @@ export const AppPage = ({
         <div className="prose-sm prose prose-a:text-default prose-headings:text-emphasis prose-code:text-default prose-strong:text-default text-default mt-8">
           {body}
         </div>
-        <h4 className="text-emphasis mt-8 font-semibold ">{t("pricing")}</h4>
-        <span className="text-default">
-          {teamsPlanRequired ? (
-            t("teams_plan_required")
-          ) : price === 0 ? (
-            t("free_to_use_apps")
-          ) : (
-            <>
-              {Intl.NumberFormat(i18n.language, {
-                style: "currency",
-                currency: "USD",
-                useGrouping: false,
-              }).format(price)}
-              {feeType === "monthly" && `/${t("month")}`}
-            </>
-          )}
-        </span>
+        {!paid && (
+          <>
+            <h4 className="text-emphasis mt-8 font-semibold ">{t("pricing")}</h4>
+            <span className="text-default">
+              {teamsPlanRequired ? (
+                t("teams_plan_required")
+              ) : price === 0 ? (
+                t("free_to_use_apps")
+              ) : (
+                <>
+                  {Intl.NumberFormat(i18n.language, {
+                    style: "currency",
+                    currency: "USD",
+                    useGrouping: false,
+                  }).format(price)}
+                  {feeType === "monthly" && `/${t("month")}`}
+                </>
+              )}
+            </span>
+          </>
+        )}
 
         <h4 className="text-emphasis mb-2 mt-8 font-semibold ">{t("contact")}</h4>
         <ul className="prose-sm -ml-1 -mr-1 leading-5">

apps/web/components/apps/CalendarListContainer.tsx

@@ -221,6 +221,7 @@ export function CalendarListContainer(props: { heading?: boolean; fromOnboarding
                             hidePlaceholder
                             isLoading={mutation.isLoading}
                             value={data.destinationCalendar?.externalId}
+                            hideAdvancedText
                           />
                         </div>
                       </div>

apps/web/components/apps/InstallAppButtonChild.tsx

@@ -26,6 +26,7 @@ export const InstallAppButtonChild = ({
   multiInstall,
   credentials,
   concurrentMeetings,
+  paid,
   ...props
 }: {
   userAdminTeams?: UserAdminTeams;
@@ -34,6 +35,7 @@ export const InstallAppButtonChild = ({
   multiInstall?: boolean;
   credentials?: RouterOutputs["viewer"]["appCredentialsByType"]["credentials"];
   concurrentMeetings?: boolean;
+  paid?: AppFrontendPayload["paid"];
 } & ButtonProps) => {
   const { t } = useLocale();
 
@@ -46,8 +48,27 @@ export const InstallAppButtonChild = ({
       if (error instanceof Error) showToast(error.message || t("app_could_not_be_installed"), "error");
     },
   });
+  const shouldDisableInstallation = !multiInstall ? !!(credentials && credentials.length) : false;
 
-  if (!userAdminTeams?.length || !doesAppSupportTeamInstall(appCategories, concurrentMeetings)) {
+  // Paid apps don't support team installs at the moment
+  // Also, cal.ai(the only paid app at the moment) doesn't support team install either
+  if (paid) {
+    return (
+      <Button
+        data-testid="install-app-button"
+        {...props}
+        disabled={shouldDisableInstallation}
+        color="primary"
+        size="base">
+        {paid.trial ? t("start_paid_trial") : t("install_paid_app")}
+      </Button>
+    );
+  }
+
+  if (
+    !userAdminTeams?.length ||
+    !doesAppSupportTeamInstall({ appCategories, concurrentMeetings, isPaid: !!paid })
+  ) {
     return (
       <Button
         data-testid="install-app-button"
@@ -55,6 +76,7 @@ export const InstallAppButtonChild = ({
         // @TODO: Overriding color and size prevent us from
         // having to duplicate InstallAppButton for now.
         color="primary"
+        disabled={shouldDisableInstallation}
         size="base">
         {multiInstall ? t("install_another") : t("install_app")}
       </Button>

apps/web/components/booking/BookingListItem.tsx

@@ -32,8 +32,6 @@ import {
 } from "@calcom/ui";
 import { Ban, Check, Clock, CreditCard, MapPin, RefreshCcw, Send, X } from "@calcom/ui/components/icon";
 
-import useMeQuery from "@lib/hooks/useMeQuery";
-
 import { ChargeCardDialog } from "@components/dialog/ChargeCardDialog";
 import { EditLocationDialog } from "@components/dialog/EditLocationDialog";
 import { RescheduleDialog } from "@components/dialog/RescheduleDialog";
@@ -45,14 +43,18 @@ type BookingItem = RouterOutputs["viewer"]["bookings"]["get"]["bookings"][number
 type BookingItemProps = BookingItem & {
   listingStatus: BookingListingStatus;
   recurringInfo: RouterOutputs["viewer"]["bookings"]["get"]["recurringInfo"][number] | undefined;
+  loggedInUser: {
+    userId: number | undefined;
+    userTimeZone: string | undefined;
+    userTimeFormat: number | null | undefined;
+    userEmail: string | undefined;
+  };
 };
 
 function BookingListItem(booking: BookingItemProps) {
-  // Get user so we can determine 12/24 hour format preferences
-  const query = useMeQuery();
   const bookerUrl = useBookerUrl();
+  const { userId, userTimeZone, userTimeFormat, userEmail } = booking.loggedInUser;
 
-  const user = query.data;
   const {
     t,
     i18n: { language },
@@ -141,17 +143,6 @@ function BookingListItem(booking: BookingItemProps) {
       : []),
   ];
 
-  const showRecordingActions: ActionType[] = [
-    {
-      id: "view_recordings",
-      label: t("view_recordings"),
-      onClick: () => {
-        setViewRecordingsDialogIsOpen(true);
-      },
-      disabled: mutation.isLoading,
-    },
-  ];
-
   let bookedActions: ActionType[] = [
     {
       id: "cancel",
@@ -226,7 +217,7 @@ function BookingListItem(booking: BookingItemProps) {
   };
 
   const startTime = dayjs(booking.startTime)
-    .tz(user?.timeZone)
+    .tz(userTimeZone)
     .locale(language)
     .format(isUpcoming ? "ddd, D MMM" : "D MMMM YYYY");
   const [isOpenRescheduleDialog, setIsOpenRescheduleDialog] = useState(false);
@@ -270,11 +261,19 @@ function BookingListItem(booking: BookingItemProps) {
   const bookingLink = buildBookingLink();
 
   const title = booking.title;
-  // To be used after we run query on legacy bookings
-  // const showRecordingsButtons = booking.isRecorded && isPast && isConfirmed;
 
-  const showRecordingsButtons =
-    (booking.location === "integrations:daily" || booking?.location?.trim() === "") && isPast && isConfirmed;
+  const showRecordingsButtons = !!(booking.isRecorded && isPast && isConfirmed);
+
+  const showRecordingActions: ActionType[] = [
+    {
+      id: "view_recordings",
+      label: t("view_recordings"),
+      onClick: () => {
+        setViewRecordingsDialogIsOpen(true);
+      },
+      disabled: mutation.isLoading,
+    },
+  ];
 
   return (
     <>
@@ -304,7 +303,7 @@ function BookingListItem(booking: BookingItemProps) {
           booking={booking}
           isOpenDialog={viewRecordingsDialogIsOpen}
           setIsOpenDialog={setViewRecordingsDialogIsOpen}
-          timeFormat={user?.timeFormat ?? null}
+          timeFormat={userTimeFormat ?? null}
         />
       )}
       {/* NOTE: Should refactor this dialog component as is being rendered multiple times */}
@@ -344,11 +343,11 @@ function BookingListItem(booking: BookingItemProps) {
             <div className="cursor-pointer py-4">
               <div className="text-emphasis text-sm leading-6">{startTime}</div>
               <div className="text-subtle text-sm">
-                {formatTime(booking.startTime, user?.timeFormat, user?.timeZone)} -{" "}
-                {formatTime(booking.endTime, user?.timeFormat, user?.timeZone)}
+                {formatTime(booking.startTime, userTimeFormat, userTimeZone)} -{" "}
+                {formatTime(booking.endTime, userTimeFormat, userTimeZone)}
                 <MeetingTimeInTimezones
-                  timeFormat={user?.timeFormat}
-                  userTimezone={user?.timeZone}
+                  timeFormat={userTimeFormat}
+                  userTimezone={userTimeZone}
                   startTime={booking.startTime}
                   endTime={booking.endTime}
                   attendees={booking.attendees}
@@ -375,7 +374,12 @@ function BookingListItem(booking: BookingItemProps) {
               ) : null}
               {recurringDates !== undefined && (
                 <div className="text-muted mt-2 text-sm">
-                  <RecurringBookingsTooltip booking={booking} recurringDates={recurringDates} />
+                  <RecurringBookingsTooltip
+                    userTimeFormat={userTimeFormat}
+                    userTimeZone={userTimeZone}
+                    booking={booking}
+                    recurringDates={recurringDates}
+                  />
                 </div>
               )}
             </div>
@@ -388,11 +392,11 @@ function BookingListItem(booking: BookingItemProps) {
               <div className="flex w-full items-center justify-between sm:hidden">
                 <div className="text-emphasis text-sm leading-6">{startTime}</div>
                 <div className="text-subtle pr-2 text-sm">
-                  {formatTime(booking.startTime, user?.timeFormat, user?.timeZone)} -{" "}
-                  {formatTime(booking.endTime, user?.timeFormat, user?.timeZone)}
+                  {formatTime(booking.startTime, userTimeFormat, userTimeZone)} -{" "}
+                  {formatTime(booking.endTime, userTimeFormat, userTimeZone)}
                   <MeetingTimeInTimezones
-                    timeFormat={user?.timeFormat}
-                    userTimezone={user?.timeZone}
+                    timeFormat={userTimeFormat}
+                    userTimezone={userTimeZone}
                     startTime={booking.startTime}
                     endTime={booking.endTime}
                     attendees={booking.attendees}
@@ -417,7 +421,12 @@ function BookingListItem(booking: BookingItemProps) {
               )}
               {recurringDates !== undefined && (
                 <div className="text-muted text-sm sm:hidden">
-                  <RecurringBookingsTooltip booking={booking} recurringDates={recurringDates} />
+                  <RecurringBookingsTooltip
+                    userTimeFormat={userTimeFormat}
+                    userTimeZone={userTimeZone}
+                    booking={booking}
+                    recurringDates={recurringDates}
+                  />
                 </div>
               )}
             </div>
@@ -449,7 +458,7 @@ function BookingListItem(booking: BookingItemProps) {
                 <DisplayAttendees
                   attendees={booking.attendees}
                   user={booking.user}
-                  currentEmail={user?.email}
+                  currentEmail={userEmail}
                 />
               )}
               {isCancelled && booking.rescheduled && (
@@ -463,7 +472,7 @@ function BookingListItem(booking: BookingItemProps) {
         <td className="flex w-full justify-end py-4 pl-4 text-right text-sm font-medium ltr:pr-4 rtl:pl-4 sm:pl-0">
           {isUpcoming && !isCancelled ? (
             <>
-              {isPending && user?.id === booking.user?.id && <TableActions actions={pendingActions} />}
+              {isPending && userId === booking.user?.id && <TableActions actions={pendingActions} />}
               {isConfirmed && <TableActions actions={bookedActions} />}
               {isRejected && <div className="text-subtle text-sm">{t("rejected")}</div>}
             </>
@@ -489,12 +498,16 @@ function BookingListItem(booking: BookingItemProps) {
 interface RecurringBookingsTooltipProps {
   booking: BookingItemProps;
   recurringDates: Date[];
+  userTimeZone: string | undefined;
+  userTimeFormat: number | null | undefined;
 }
 
-const RecurringBookingsTooltip = ({ booking, recurringDates }: RecurringBookingsTooltipProps) => {
-  // Get user so we can determine 12/24 hour format preferences
-  const query = useMeQuery();
-  const user = query.data;
+const RecurringBookingsTooltip = ({
+  booking,
+  recurringDates,
+  userTimeZone,
+  userTimeFormat,
+}: RecurringBookingsTooltipProps) => {
   const {
     t,
     i18n: { language },
@@ -526,7 +539,7 @@ const RecurringBookingsTooltip = ({ booking, recurringDates }: RecurringBookings
                     .includes(aDate.toDateString());
                 return (
                   <p key={key} className={classNames(pastOrCancelled && "line-through")}>
-                    {formatTime(aDate, user?.timeFormat, user?.timeZone)}
+                    {formatTime(aDate, userTimeFormat, userTimeZone)}
                     {" - "}
                     {dayjs(aDate).locale(language).format("D MMMM YYYY")}
                   </p>
@@ -539,7 +552,7 @@ const RecurringBookingsTooltip = ({ booking, recurringDates }: RecurringBookings
                 />
                 <p className="mt-1 pl-5 text-xs">
                   {booking.status === BookingStatus.ACCEPTED
-                    ? `${t("event_remaining", {
+                    ? `${t("event_remaining_other", {
                         count: recurringCount,
                       })}`
                     : getEveryFreqFor({

apps/web/components/dialog/EditLocationDialog.tsx

@@ -356,9 +356,9 @@ export const EditLocationDialog = (props: ISetLocationDialog) => {
                             onChange={(val) => {
                               if (val) {
                                 locationFormMethods.setValue("locationType", val.value);
-                                if (val.credential) {
-                                  locationFormMethods.setValue("credentialId", val.credential.id);
-                                  locationFormMethods.setValue("teamName", val.credential.team?.name);
+                                if (!!val.credentialId) {
+                                  locationFormMethods.setValue("credentialId", val.credentialId);
+                                  locationFormMethods.setValue("teamName", val.teamName);
                                 }
 
                                 locationFormMethods.unregister([

apps/web/components/eventtype/EventAdvancedTab.tsx

@@ -134,7 +134,9 @@ export const EventAdvancedTab = ({ eventType, team }: Pick<EventTypeSetupProps,
         {!!connectedCalendarsQuery.data?.connectedCalendars.length && !team && (
           <div className="flex flex-col">
             <div className="flex justify-between">
-              <Label className="font-medium">{t("add_to_calendar")}</Label>
+              <div>
+                <Label className="text-emphasis mb-0 font-medium">{t("add_to_calendar")}</Label>
+              </div>
               <Link
                 href="/apps/categories/calendar"
                 target="_blank"
@@ -142,21 +144,20 @@ export const EventAdvancedTab = ({ eventType, team }: Pick<EventTypeSetupProps,
                 {t("add_another_calendar")}
               </Link>
             </div>
-            <div className="-mt-1 w-full">
-              <Controller
-                control={formMethods.control}
-                name="destinationCalendar"
-                defaultValue={eventType.destinationCalendar || undefined}
-                render={({ field: { onChange, value } }) => (
-                  <DestinationCalendarSelector
-                    destinationCalendar={eventType.destinationCalendar}
-                    value={value ? value.externalId : undefined}
-                    onChange={onChange}
-                    hidePlaceholder
-                  />
-                )}
-              />
-            </div>
+            <Controller
+              control={formMethods.control}
+              name="destinationCalendar"
+              defaultValue={eventType.destinationCalendar || undefined}
+              render={({ field: { onChange, value } }) => (
+                <DestinationCalendarSelector
+                  destinationCalendar={eventType.destinationCalendar}
+                  value={value ? value.externalId : undefined}
+                  onChange={onChange}
+                  hidePlaceholder
+                  hideAdvancedText
+                />
+              )}
+            />
             <p className="text-subtle text-sm">{t("select_which_cal")}</p>
           </div>
         )}
@@ -433,6 +434,23 @@ export const EventAdvancedTab = ({ eventType, team }: Pick<EventTypeSetupProps,
           </>
         )}
       />
+      <Controller
+        name="lockTimeZoneToggleOnBookingPage"
+        control={formMethods.control}
+        defaultValue={eventType.lockTimeZoneToggleOnBookingPage}
+        render={({ field: { value, onChange } }) => (
+          <SettingsToggle
+            labelClassName="text-sm"
+            toggleSwitchAtTheEnd={true}
+            switchContainerClassName="border-subtle rounded-lg border py-6 px-4 sm:px-6"
+            title={t("lock_timezone_toggle_on_booking_page")}
+            {...shouldLockDisableProps("lockTimeZoneToggleOnBookingPage")}
+            description={t("description_lock_timezone_toggle_on_booking_page")}
+            checked={value}
+            onCheckedChange={(e) => onChange(e)}
+          />
+        )}
+      />
       {allowDisablingAttendeeConfirmationEmails(workflows) && (
         <>
           <Controller

apps/web/components/eventtype/EventSetupTab.tsx

@@ -8,7 +8,7 @@ import { Controller, useFormContext, useFieldArray } from "react-hook-form";
 import type { MultiValue } from "react-select";
 
 import type { EventLocationType } from "@calcom/app-store/locations";
-import { getEventLocationType, LocationType, MeetLocationType } from "@calcom/app-store/locations";
+import { getEventLocationType, MeetLocationType } from "@calcom/app-store/locations";
 import useLockedFieldsManager from "@calcom/features/ee/managed-event-types/hooks/useLockedFieldsManager";
 import { useOrgBranding } from "@calcom/features/ee/organizations/context/provider";
 import { CAL_URL } from "@calcom/lib/constants";
@@ -30,8 +30,7 @@ import {
   Button,
   showToast,
 } from "@calcom/ui";
-import { Plus, X, Check } from "@calcom/ui/components/icon";
-import { CornerDownRight } from "@calcom/ui/components/icon";
+import { Plus, X, Check, CornerDownRight } from "@calcom/ui/components/icon";
 
 import CheckboxField from "@components/ui/form/CheckboxField";
 import type { SingleValueLocationOption } from "@components/ui/form/LocationSelect";
@@ -200,23 +199,16 @@ export const EventSetupTab = (
             defaultValue={defaultValue}
             render={({ field: { onChange, value } }) => {
               return (
-                <>
-                  <Input
-                    name={`locations[${index}].${eventLocationType.defaultValueVariable}`}
-                    type="text"
-                    required
-                    onChange={onChange}
-                    value={value}
-                    className="my-0"
-                    {...rest}
-                  />
-                  <ErrorMessage
-                    errors={formMethods.formState.errors.locations?.[index]}
-                    name={eventLocationType.defaultValueVariable}
-                    className="text-error my-1 text-sm"
-                    as="div"
-                  />
-                </>
+                <Input
+                  name={`locations[${index}].${eventLocationType.defaultValueVariable}`}
+                  placeholder={t(eventLocationType.organizerInputPlaceholder || "")}
+                  type="text"
+                  required
+                  onChange={onChange}
+                  value={value}
+                  className="my-0"
+                  {...rest}
+                />
               );
             }}
           />
@@ -231,21 +223,14 @@ export const EventSetupTab = (
             defaultValue={defaultValue}
             render={({ field: { onChange, value } }) => {
               return (
-                <>
-                  <PhoneInput
-                    required
-                    name={`locations[${index}].${eventLocationType.defaultValueVariable}`}
-                    value={value}
-                    onChange={onChange}
-                    {...rest}
-                  />
-                  <ErrorMessage
-                    errors={formMethods.formState.errors.locations?.[index]}
-                    name={eventLocationType.defaultValueVariable}
-                    className="text-error my-1 text-sm"
-                    as="div"
-                  />
-                </>
+                <PhoneInput
+                  required
+                  placeholder={t(eventLocationType.organizerInputPlaceholder || "")}
+                  name={`locations[${index}].${eventLocationType.defaultValueVariable}`}
+                  value={value}
+                  onChange={onChange}
+                  {...rest}
+                />
               );
             }}
           />
@@ -262,15 +247,7 @@ export const EventSetupTab = (
         <ul ref={animationRef} className="space-y-2">
           {locationFields.map((field, index) => {
             const eventLocationType = getEventLocationType(field.type);
-            const defaultLocation = formMethods
-              .getValues("locations")
-              ?.find((location: { type: EventLocationType["type"]; address?: string }) => {
-                if (location.type === LocationType.InPerson) {
-                  return location.type === eventLocationType?.type && location.address === field?.address;
-                } else {
-                  return location.type === eventLocationType?.type;
-                }
-              });
+            const defaultLocation = field;
 
             const option = getLocationFromType(field.type, locationOptions);
 
@@ -298,9 +275,21 @@ export const EventSetupTab = (
                           !validLocations.find((location) => location.type === newLocationType);
 
                         if (canAddLocation) {
-                          updateLocationField(index, { type: newLocationType });
+                          updateLocationField(index, {
+                            type: newLocationType,
+                            ...(e.credentialId && {
+                              credentialId: e.credentialId,
+                              teamName: e.teamName,
+                            }),
+                          });
                         } else {
-                          updateLocationField(index, { type: field.type });
+                          updateLocationField(index, {
+                            type: field.type,
+                            ...(field.credentialId && {
+                              credentialId: field.credentialId,
+                              teamName: field.teamName,
+                            }),
+                          });
                           showToast(t("location_already_exists"), "warning");
                         }
                       }
@@ -320,11 +309,11 @@ export const EventSetupTab = (
 
                 {eventLocationType?.organizerInputType && (
                   <div className="mt-2 space-y-2">
-                    <div className="flex gap-2">
-                      <div className="flex items-center justify-center">
-                        <CornerDownRight className="h-4 w-4" />
-                      </div>
-                      <div className="w-full">
+                    <div className="w-full">
+                      <div className="flex gap-2">
+                        <div className="flex items-center justify-center">
+                          <CornerDownRight className="h-4 w-4" />
+                        </div>
                         <LocationInput
                           defaultValue={
                             defaultLocation
@@ -335,9 +324,17 @@ export const EventSetupTab = (
                           index={index}
                         />
                       </div>
+                      <ErrorMessage
+                        errors={formMethods.formState.errors.locations?.[index]}
+                        name={eventLocationType.defaultValueVariable}
+                        className="text-error my-1 ml-6 text-sm"
+                        as="div"
+                        id="location-error"
+                      />
                     </div>
                     <div className="ml-6">
                       <CheckboxField
+                        name={`locations[${index}].displayLocationPublicly`}
                         data-testid="display-location"
                         defaultChecked={defaultLocation?.displayLocationPublicly}
                         description={t("display_location_label")}
@@ -382,7 +379,13 @@ export const EventSetupTab = (
                       !validLocations.find((location) => location.type === newLocationType);
 
                     if (canAppendLocation) {
-                      append({ type: newLocationType });
+                      append({
+                        type: newLocationType,
+                        ...(e.credentialId && {
+                          credentialId: e.credentialId,
+                          teamName: e.teamName,
+                        }),
+                      });
                       setSelectedNewOption(e);
                     } else {
                       showToast(t("location_already_exists"), "warning");

apps/web/components/ui/form/LocationSelect.tsx

@@ -2,7 +2,6 @@ import type { GroupBase, Props, SingleValue } from "react-select";
 import { components } from "react-select";
 
 import type { EventLocationType } from "@calcom/app-store/locations";
-import type { CredentialDataWithTeamName } from "@calcom/app-store/utils";
 import { classNames } from "@calcom/lib";
 import invertLogoOnDark from "@calcom/lib/invertLogoOnDark";
 import { Select } from "@calcom/ui";
@@ -13,7 +12,8 @@ export type LocationOption = {
   icon?: string;
   disabled?: boolean;
   address?: string;
-  credential?: CredentialDataWithTeamName;
+  credentialId?: number;
+  teamName?: string;
 };
 
 export type SingleValueLocationOption = SingleValue<LocationOption>;

apps/web/lib/app-providers-app-dir.tsx

@@ -0,0 +1,291 @@
+import { TooltipProvider } from "@radix-ui/react-tooltip";
+import { dir } from "i18next";
+import type { Session } from "next-auth";
+import { SessionProvider, useSession } from "next-auth/react";
+import { EventCollectionProvider } from "next-collect/client";
+import { appWithTranslation, type SSRConfig } from "next-i18next";
+import { ThemeProvider } from "next-themes";
+import type { AppProps as NextAppProps } from "next/app";
+import type { ReadonlyURLSearchParams } from "next/navigation";
+import { useSearchParams } from "next/navigation";
+import { useEffect, type ReactNode } from "react";
+
+import { OrgBrandingProvider } from "@calcom/features/ee/organizations/context/provider";
+import DynamicHelpscoutProvider from "@calcom/features/ee/support/lib/helpscout/providerDynamic";
+import DynamicIntercomProvider from "@calcom/features/ee/support/lib/intercom/providerDynamic";
+import { FeatureProvider } from "@calcom/features/flags/context/provider";
+import { useFlags } from "@calcom/features/flags/hooks";
+import { MetaProvider } from "@calcom/ui";
+
+import useIsBookingPage from "@lib/hooks/useIsBookingPage";
+import type { WithNonceProps } from "@lib/withNonce";
+
+import { useViewerI18n } from "@components/I18nLanguageHandler";
+import type { PageWrapperProps } from "@components/PageWrapperAppDir";
+
+// Workaround for https://github.com/vercel/next.js/issues/8592
+export type AppProps = Omit<
+  NextAppProps<
+    WithNonceProps<{
+      themeBasis?: string;
+      session: Session;
+    }>
+  >,
+  "Component"
+> & {
+  Component: NextAppProps["Component"] & {
+    requiresLicense?: boolean;
+    isThemeSupported?: boolean;
+    isBookingPage?: boolean | ((arg: { router: NextAppProps["router"] }) => boolean);
+    getLayout?: (page: React.ReactElement) => ReactNode;
+    PageWrapper?: (props: AppProps) => JSX.Element;
+  };
+
+  /** Will be defined only is there was an error */
+  err?: Error;
+};
+
+const getEmbedNamespace = (searchParams: ReadonlyURLSearchParams) => {
+  // Mostly embed query param should be available on server. Use that there.
+  // Use the most reliable detection on client
+  return typeof window !== "undefined" ? window.getEmbedNamespace() : searchParams.get("embed") ?? null;
+};
+
+// @ts-expect-error appWithTranslation expects AppProps
+const AppWithTranslationHoc = appWithTranslation(({ children }) => <>{children}</>);
+
+const CustomI18nextProvider = (props: { children: React.ReactElement; i18n?: SSRConfig }) => {
+  /**
+   * i18n should never be clubbed with other queries, so that it's caching can be managed independently.
+   **/
+  // @TODO
+
+  const session = useSession();
+  const locale =
+    session?.data?.user.locale ?? typeof window !== "undefined" ? window.document.documentElement.lang : "en";
+
+  useEffect(() => {
+    try {
+      // @ts-expect-error TS2790: The operand of a 'delete' operator must be optional.
+      delete window.document.documentElement["lang"];
+
+      window.document.documentElement.lang = locale;
+
+      // Next.js writes the locale to the same attribute
+      // https://github.com/vercel/next.js/blob/1609da2d9552fed48ab45969bdc5631230c6d356/packages/next/src/shared/lib/router/router.ts#L1786
+      // which can result in a race condition
+      // this property descriptor ensures this never happens
+      Object.defineProperty(window.document.documentElement, "lang", {
+        configurable: true,
+        // value: locale,
+        set: function (this) {
+          // empty setter on purpose
+        },
+        get: function () {
+          return locale;
+        },
+      });
+    } catch (error) {
+      console.error(error);
+
+      window.document.documentElement.lang = locale;
+    }
+    window.document.dir = dir(locale);
+  }, [locale]);
+
+  const clientViewerI18n = useViewerI18n(locale);
+  const i18n = clientViewerI18n.data?.i18n ?? props.i18n;
+
+  if (!i18n || !i18n._nextI18Next) {
+    return null;
+  }
+
+  return (
+    // @ts-expect-error AppWithTranslationHoc expects AppProps
+    <AppWithTranslationHoc pageProps={{ _nextI18Next: i18n._nextI18Next }}>
+      {props.children}
+    </AppWithTranslationHoc>
+  );
+};
+
+const enum ThemeSupport {
+  // e.g. Login Page
+  None = "none",
+  // Entire App except Booking Pages
+  App = "systemOnly",
+  // Booking Pages(including Routing Forms)
+  Booking = "userConfigured",
+}
+
+type CalcomThemeProps = Readonly<{
+  isBookingPage: boolean;
+  themeBasis: string | null;
+  nonce: string | undefined;
+  isThemeSupported: boolean;
+  children: React.ReactNode;
+}>;
+
+const CalcomThemeProvider = (props: CalcomThemeProps) => {
+  // Use namespace of embed to ensure same namespaced embed are displayed with same theme. This allows different embeds on the same website to be themed differently
+  // One such example is our Embeds Demo and Testing page at http://localhost:3100
+  // Having `getEmbedNamespace` defined on window before react initializes the app, ensures that embedNamespace is available on the first mount and can be used as part of storageKey
+
+  const searchParams = useSearchParams();
+  const embedNamespace = searchParams ? getEmbedNamespace(searchParams) : null;
+  const isEmbedMode = typeof embedNamespace === "string";
+
+  return (
+    <ThemeProvider {...getThemeProviderProps({ ...props, isEmbedMode, embedNamespace })}>
+      {/* Embed Mode can be detected reliably only on client side here as there can be static generated pages as well which can't determine if it's embed mode at backend */}
+      {/* color-scheme makes background:transparent not work in iframe which is required by embed. */}
+      {typeof window !== "undefined" && !isEmbedMode && (
+        <style jsx global>
+          {`
+            .dark {
+              color-scheme: dark;
+            }
+          `}
+        </style>
+      )}
+      {props.children}
+    </ThemeProvider>
+  );
+};
+
+/**
+ * The most important job for this fn is to generate correct storageKey for theme persistenc.
+ * `storageKey` is important because that key is listened for changes(using [`storage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/storage_event) event) and any pages opened will change it's theme based on that(as part of next-themes implementation).
+ * Choosing the right storageKey avoids theme flickering caused by another page using different theme
+ * So, we handle all the cases here namely,
+ * - Both Booking Pages, /free/30min and /pro/30min but configured with different themes but being operated together.
+ * - Embeds using different namespace. They can be completely themed different on the same page.
+ * - Embeds using the same namespace but showing different cal.com links with different themes
+ * - Embeds using the same namespace and showing same cal.com links with different themes(Different theme is possible for same cal.com link in case of embed because of theme config available in embed)
+ * - App has different theme then Booking Pages.
+ *
+ * All the above cases have one thing in common, which is the origin and thus localStorage is shared and thus `storageKey` is critical to avoid theme flickering.
+ *
+ * Some things to note:
+ * - There is a side effect of so many factors in `storageKey` that many localStorage keys will be created if a user goes through all these scenarios(e.g like booking a lot of different users)
+ * - Some might recommend disabling localStorage persistence but that doesn't give good UX as then we would default to light theme always for a few seconds before switching to dark theme(if that's the user's preference).
+ * - We can't disable [`storage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/storage_event) event handling as well because changing theme in one tab won't change the theme without refresh in other tabs. That's again a bad UX
+ * - Theme flickering becomes infinitely ongoing in case of embeds because of the browser's delay in processing `storage` event within iframes. Consider two embeds simulatenously opened with pages A and B. Note the timeline and keep in mind that it happened
+ *  because 'setItem(A)' and 'Receives storageEvent(A)' allowed executing setItem(B) in b/w because of the delay.
+ *    - t1 -> setItem(A) & Fires storageEvent(A) - On Page A) - Current State(A)
+ *    - t2 -> setItem(B) & Fires storageEvent(B) - On Page B) - Current State(B)
+ *    - t3 -> Receives storageEvent(A) & thus setItem(A) & thus fires storageEvent(A) (On Page B) - Current State(A)
+ *    - t4 -> Receives storageEvent(B) & thus setItem(B) & thus fires storageEvent(B) (On Page A) - Current State(B)
+ *    - ... and so on ...
+ */
+function getThemeProviderProps(props: {
+  isBookingPage: boolean;
+  themeBasis: string | null;
+  nonce: string | undefined;
+  isEmbedMode: boolean;
+  embedNamespace: string | null;
+  isThemeSupported: boolean;
+}) {
+  const themeSupport = props.isBookingPage
+    ? ThemeSupport.Booking
+    : // if isThemeSupported is explicitly false, we don't use theme there
+    props.isThemeSupported === false
+    ? ThemeSupport.None
+    : ThemeSupport.App;
+
+  const isBookingPageThemeSupportRequired = themeSupport === ThemeSupport.Booking;
+
+  if ((isBookingPageThemeSupportRequired || props.isEmbedMode) && !props.themeBasis) {
+    console.warn(
+      "`themeBasis` is required for booking page theme support. Not providing it will cause theme flicker."
+    );
+  }
+
+  const appearanceIdSuffix = props.themeBasis ? `:${props.themeBasis}` : "";
+  const forcedTheme = themeSupport === ThemeSupport.None ? "light" : undefined;
+  let embedExplicitlySetThemeSuffix = "";
+
+  if (typeof window !== "undefined") {
+    const embedTheme = window.getEmbedTheme();
+    if (embedTheme) {
+      embedExplicitlySetThemeSuffix = `:${embedTheme}`;
+    }
+  }
+
+  const storageKey = props.isEmbedMode
+    ? // Same Namespace, Same Organizer but different themes would still work seamless and not cause theme flicker
+      // Even though it's recommended to use different namespaces when you want to theme differently on the same page but if the embeds are on different pages, the problem can still arise
+      `embed-theme-${props.embedNamespace}${appearanceIdSuffix}${embedExplicitlySetThemeSuffix}`
+    : themeSupport === ThemeSupport.App
+    ? "app-theme"
+    : isBookingPageThemeSupportRequired
+    ? `booking-theme${appearanceIdSuffix}`
+    : undefined;
+
+  return {
+    storageKey,
+    forcedTheme,
+    themeSupport,
+    nonce: props.nonce,
+    enableColorScheme: false,
+    enableSystem: themeSupport !== ThemeSupport.None,
+    // next-themes doesn't listen to changes on storageKey. So we need to force a re-render when storageKey changes
+    // This is how login to dashboard soft navigation changes theme from light to dark
+    key: storageKey,
+    attribute: "class",
+  };
+}
+
+function FeatureFlagsProvider({ children }: { children: React.ReactNode }) {
+  const flags = useFlags();
+  return <FeatureProvider value={flags}>{children}</FeatureProvider>;
+}
+
+function useOrgBrandingValues() {
+  const session = useSession();
+  return session?.data?.user.org;
+}
+
+function OrgBrandProvider({ children }: { children: React.ReactNode }) {
+  const orgBrand = useOrgBrandingValues();
+  return <OrgBrandingProvider value={{ orgBrand }}>{children}</OrgBrandingProvider>;
+}
+
+const AppProviders = (props: PageWrapperProps) => {
+  // No need to have intercom on public pages - Good for Page Performance
+  const isBookingPage = useIsBookingPage();
+
+  const RemainingProviders = (
+    <EventCollectionProvider options={{ apiPath: "/api/collect-events" }}>
+      <SessionProvider>
+        <CustomI18nextProvider i18n={props.i18n}>
+          <TooltipProvider>
+            {/* color-scheme makes background:transparent not work which is required by embed. We need to ensure next-theme adds color-scheme to `body` instead of `html`(https://github.com/pacocoursey/next-themes/blob/main/src/index.tsx#L74). Once that's done we can enable color-scheme support */}
+            <CalcomThemeProvider
+              themeBasis={props.themeBasis}
+              nonce={props.nonce}
+              isThemeSupported={props.isThemeSupported}
+              isBookingPage={props.isBookingPage || isBookingPage}>
+              <FeatureFlagsProvider>
+                <OrgBrandProvider>
+                  <MetaProvider>{props.children}</MetaProvider>
+                </OrgBrandProvider>
+              </FeatureFlagsProvider>
+            </CalcomThemeProvider>
+          </TooltipProvider>
+        </CustomI18nextProvider>
+      </SessionProvider>
+    </EventCollectionProvider>
+  );
+
+  if (isBookingPage) {
+    return RemainingProviders;
+  }
+
+  return (
+    <DynamicHelpscoutProvider>
+      <DynamicIntercomProvider>{RemainingProviders}</DynamicIntercomProvider>
+    </DynamicHelpscoutProvider>
+  );
+};
+
+export default AppProviders;

apps/web/lib/csp.ts

@@ -1,10 +1,11 @@
 import type { IncomingMessage, OutgoingMessage } from "http";
+import type { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 
 import { IS_PRODUCTION } from "@calcom/lib/constants";
 import { WEBAPP_URL } from "@calcom/lib/constants";
 
-import { buildNonce } from "@lib/buildNonce";
+import { buildNonce } from "./buildNonce";
 
 function getCspPolicy(nonce: string) {
   //TODO: Do we need to explicitly define it in turbo.json
@@ -46,11 +47,12 @@ const isPagePathRequest = (url: URL) => {
   return !isNonPagePathPrefix.test(pathname) && !isFile.test(pathname);
 };
 
-export function csp(req: IncomingMessage | null, res: OutgoingMessage | null) {
+export function csp(req: IncomingMessage | NextRequest | null, res: OutgoingMessage | NextResponse | null) {
   if (!req) {
     return { nonce: undefined };
   }
-  const existingNonce = req.headers["x-nonce"];
+  const existingNonce = "cache" in req ? req.headers.get("x-nonce") : req.headers["x-nonce"];
+
   if (existingNonce) {
     const existingNoneParsed = z.string().safeParse(existingNonce);
     return { nonce: existingNoneParsed.success ? existingNoneParsed.data : "" };
@@ -71,17 +73,28 @@ export function csp(req: IncomingMessage | null, res: OutgoingMessage | null) {
   }
   // Set x-nonce request header to be used by `getServerSideProps` or similar fns and `Document.getInitialProps` to read the nonce from
   // It is generated for all page requests but only used by pages that need CSP
-  req.headers["x-nonce"] = nonce;
+
+  if ("cache" in req) {
+    req.headers.set("x-nonce", nonce);
+  } else {
+    req.headers["x-nonce"] = nonce;
+  }
 
   if (res) {
-    res.setHeader(
-      req.headers["x-csp-enforce"] === "true"
-        ? "Content-Security-Policy"
-        : "Content-Security-Policy-Report-Only",
-      getCspPolicy(nonce)
-        .replace(/\s{2,}/g, " ")
-        .trim()
-    );
+    const enforced =
+      "cache" in req ? req.headers.get("x-csp-enforce") === "true" : req.headers["x-csp-enforce"] === "true";
+
+    const name = enforced ? "Content-Security-Policy" : "Content-Security-Policy-Report-Only";
+
+    const value = getCspPolicy(nonce)
+      .replace(/\s{2,}/g, " ")
+      .trim();
+
+    if ("body" in res) {
+      res.headers.set(name, value);
+    } else {
+      res.setHeader(name, value);
+    }
   }
 
   return { nonce };

apps/web/lib/getTemporaryOrgRedirect.test.ts

@@ -0,0 +1,162 @@
+import prismaMock from "../../../tests/libs/__mocks__/prismaMock";
+
+import { describe, it, expect } from "vitest";
+
+import { RedirectType } from "@calcom/prisma/client";
+
+import { getTemporaryOrgRedirect } from "./getTemporaryOrgRedirect";
+
+function mockARedirectInDB({
+  toUrl,
+  slug,
+  redirectType,
+}: {
+  toUrl: string;
+  slug: string;
+  redirectType: RedirectType;
+}) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  //@ts-ignore
+  prismaMock.tempOrgRedirect.findUnique.mockImplementation(({ where }) => {
+    return new Promise((resolve) => {
+      if (
+        where.from_type_fromOrgId.type === redirectType &&
+        where.from_type_fromOrgId.from === slug &&
+        where.from_type_fromOrgId.fromOrgId === 0
+      ) {
+        resolve({ toUrl });
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+
+describe("getTemporaryOrgRedirect", () => {
+  it("should generate event-type URL without existing query params", async () => {
+    mockARedirectInDB({ slug: "slug", toUrl: "https://calcom.cal.com", redirectType: RedirectType.User });
+    const redirect = await getTemporaryOrgRedirect({
+      slug: "slug",
+      redirectType: RedirectType.User,
+      eventTypeSlug: "30min",
+      currentQuery: {},
+    });
+
+    expect(redirect).toEqual({
+      redirect: {
+        permanent: false,
+        destination: "https://calcom.cal.com/30min",
+      },
+    });
+  });
+
+  it("should generate event-type URL with existing query params", async () => {
+    mockARedirectInDB({ slug: "slug", toUrl: "https://calcom.cal.com", redirectType: RedirectType.User });
+
+    const redirect = await getTemporaryOrgRedirect({
+      slug: "slug",
+      redirectType: RedirectType.User,
+      eventTypeSlug: "30min",
+      currentQuery: {
+        abc: "1",
+      },
+    });
+
+    expect(redirect).toEqual({
+      redirect: {
+        permanent: false,
+        destination: "https://calcom.cal.com/30min?abc=1",
+      },
+    });
+  });
+
+  it("should generate User URL with existing query params", async () => {
+    mockARedirectInDB({ slug: "slug", toUrl: "https://calcom.cal.com", redirectType: RedirectType.User });
+
+    const redirect = await getTemporaryOrgRedirect({
+      slug: "slug",
+      redirectType: RedirectType.User,
+      eventTypeSlug: null,
+      currentQuery: {
+        abc: "1",
+      },
+    });
+
+    expect(redirect).toEqual({
+      redirect: {
+        permanent: false,
+        destination: "https://calcom.cal.com?abc=1",
+      },
+    });
+  });
+
+  it("should generate Team Profile URL with existing query params", async () => {
+    mockARedirectInDB({
+      slug: "seeded-team",
+      toUrl: "https://calcom.cal.com",
+      redirectType: RedirectType.Team,
+    });
+
+    const redirect = await getTemporaryOrgRedirect({
+      slug: "seeded-team",
+      redirectType: RedirectType.Team,
+      eventTypeSlug: null,
+      currentQuery: {
+        abc: "1",
+      },
+    });
+
+    expect(redirect).toEqual({
+      redirect: {
+        permanent: false,
+        destination: "https://calcom.cal.com?abc=1",
+      },
+    });
+  });
+
+  it("should generate Team Event URL with existing query params", async () => {
+    mockARedirectInDB({
+      slug: "seeded-team",
+      toUrl: "https://calcom.cal.com",
+      redirectType: RedirectType.Team,
+    });
+
+    const redirect = await getTemporaryOrgRedirect({
+      slug: "seeded-team",
+      redirectType: RedirectType.Team,
+      eventTypeSlug: "30min",
+      currentQuery: {
+        abc: "1",
+      },
+    });
+
+    expect(redirect).toEqual({
+      redirect: {
+        permanent: false,
+        destination: "https://calcom.cal.com/30min?abc=1",
+      },
+    });
+  });
+
+  it("should generate Team Event URL without query params", async () => {
+    mockARedirectInDB({
+      slug: "seeded-team",
+      toUrl: "https://calcom.cal.com",
+      redirectType: RedirectType.Team,
+    });
+
+    const redirect = await getTemporaryOrgRedirect({
+      slug: "seeded-team",
+      redirectType: RedirectType.Team,
+      eventTypeSlug: "30min",
+      currentQuery: {},
+    });
+
+    expect(redirect).toEqual({
+      redirect: {
+        permanent: false,
+        destination: "https://calcom.cal.com/30min",
+      },
+    });
+  });
+});

apps/web/lib/getTemporaryOrgRedirect.ts

@@ -1,3 +1,6 @@
+import type { ParsedUrlQuery } from "querystring";
+import { stringify } from "querystring";
+
 import logger from "@calcom/lib/logger";
 import { safeStringify } from "@calcom/lib/safeStringify";
 import type { RedirectType } from "@calcom/prisma/client";
@@ -7,10 +10,12 @@ export const getTemporaryOrgRedirect = async ({
   slug,
   redirectType,
   eventTypeSlug,
+  currentQuery,
 }: {
   slug: string;
   redirectType: RedirectType;
   eventTypeSlug: string | null;
+  currentQuery: ParsedUrlQuery;
 }) => {
   const prisma = (await import("@calcom/prisma")).default;
   log.debug(
@@ -33,10 +38,12 @@ export const getTemporaryOrgRedirect = async ({
 
   if (redirect) {
     log.debug(`Redirecting ${slug} to ${redirect.toUrl}`);
+    const newDestinationWithoutQuery = eventTypeSlug ? `${redirect.toUrl}/${eventTypeSlug}` : redirect.toUrl;
+    const currentQueryString = stringify(currentQuery);
     return {
       redirect: {
         permanent: false,
-        destination: eventTypeSlug ? `${redirect.toUrl}/${eventTypeSlug}` : redirect.toUrl,
+        destination: `${newDestinationWithoutQuery}${currentQueryString ? `?${currentQueryString}` : ""}`,
       },
     } as const;
   }

apps/web/lib/withEmbedSsr.test.ts

@@ -0,0 +1,258 @@
+import type { Request, Response } from "express";
+import type { Redirect } from "next";
+import type { NextApiRequest, NextApiResponse } from "next";
+import { createMocks } from "node-mocks-http";
+import { describe, expect, it } from "vitest";
+
+import withEmbedSsr from "./withEmbedSsr";
+
+export type CustomNextApiRequest = NextApiRequest & Request;
+
+export type CustomNextApiResponse = NextApiResponse & Response;
+export function createMockNextJsRequest(...args: Parameters<typeof createMocks>) {
+  return createMocks<CustomNextApiRequest, CustomNextApiResponse>(...args);
+}
+
+function getServerSidePropsFnGenerator(
+  config:
+    | { redirectUrl: string }
+    | { props: Record<string, unknown> }
+    | {
+        notFound: true;
+      }
+) {
+  if ("redirectUrl" in config)
+    return async () => {
+      return {
+        redirect: {
+          permanent: false,
+          destination: config.redirectUrl,
+        } satisfies Redirect,
+      };
+    };
+
+  if ("props" in config)
+    return async () => {
+      return {
+        props: config.props,
+      };
+    };
+
+  if ("notFound" in config)
+    return async () => {
+      return {
+        notFound: true as const,
+      };
+    };
+
+  throw new Error("Invalid config");
+}
+
+function getServerSidePropsContextArg({
+  embedRelatedParams,
+}: {
+  embedRelatedParams?: Record<string, string>;
+}) {
+  return {
+    ...createMockNextJsRequest(),
+    query: {
+      ...embedRelatedParams,
+    },
+    resolvedUrl: "/MOCKED_RESOLVED_URL",
+  };
+}
+
+describe("withEmbedSsr", () => {
+  describe("when gSSP returns redirect", () => {
+    describe("when redirect destination is relative, should add /embed to end of the path", () => {
+      it("should add layout and embed params from the current query", async () => {
+        const withEmbedGetSsr = withEmbedSsr(
+          getServerSidePropsFnGenerator({
+            redirectUrl: "/reschedule",
+          })
+        );
+
+        const ret = await withEmbedGetSsr(
+          getServerSidePropsContextArg({
+            embedRelatedParams: {
+              layout: "week_view",
+              embed: "namespace1",
+            },
+          })
+        );
+        expect(ret).toEqual({
+          redirect: {
+            destination: "/reschedule/embed?layout=week_view&embed=namespace1",
+            permanent: false,
+          },
+        });
+      });
+
+      it("should add layout and embed params without losing query params that were in redirect", async () => {
+        const withEmbedGetSsr = withEmbedSsr(
+          getServerSidePropsFnGenerator({
+            redirectUrl: "/reschedule?redirectParam=1",
+          })
+        );
+
+        const ret = await withEmbedGetSsr(
+          getServerSidePropsContextArg({
+            embedRelatedParams: {
+              layout: "week_view",
+              embed: "namespace1",
+            },
+          })
+        );
+        expect(ret).toEqual({
+          redirect: {
+            destination: "/reschedule/embed?redirectParam=1&layout=week_view&embed=namespace1",
+            permanent: false,
+          },
+        });
+      });
+
+      it("should add embed param even when it was empty(i.e. default namespace of embed)", async () => {
+        const withEmbedGetSsr = withEmbedSsr(
+          getServerSidePropsFnGenerator({
+            redirectUrl: "/reschedule?redirectParam=1",
+          })
+        );
+
+        const ret = await withEmbedGetSsr(
+          getServerSidePropsContextArg({
+            embedRelatedParams: {
+              layout: "week_view",
+              embed: "",
+            },
+          })
+        );
+        expect(ret).toEqual({
+          redirect: {
+            destination: "/reschedule/embed?redirectParam=1&layout=week_view&embed=",
+            permanent: false,
+          },
+        });
+      });
+    });
+
+    describe("when redirect destination is absolute, should add /embed to end of the path", () => {
+      it("should add layout and embed params from the current query when destination URL is HTTPS", async () => {
+        const withEmbedGetSsr = withEmbedSsr(
+          getServerSidePropsFnGenerator({
+            redirectUrl: "https://calcom.cal.local/owner",
+          })
+        );
+
+        const ret = await withEmbedGetSsr(
+          getServerSidePropsContextArg({
+            embedRelatedParams: {
+              layout: "week_view",
+              embed: "namespace1",
+            },
+          })
+        );
+
+        expect(ret).toEqual({
+          redirect: {
+            destination: "https://calcom.cal.local/owner/embed?layout=week_view&embed=namespace1",
+            permanent: false,
+          },
+        });
+      });
+      it("should add layout and embed params from the current query when destination URL is HTTP", async () => {
+        const withEmbedGetSsr = withEmbedSsr(
+          getServerSidePropsFnGenerator({
+            redirectUrl: "http://calcom.cal.local/owner",
+          })
+        );
+
+        const ret = await withEmbedGetSsr(
+          getServerSidePropsContextArg({
+            embedRelatedParams: {
+              layout: "week_view",
+              embed: "namespace1",
+            },
+          })
+        );
+
+        expect(ret).toEqual({
+          redirect: {
+            destination: "http://calcom.cal.local/owner/embed?layout=week_view&embed=namespace1",
+            permanent: false,
+          },
+        });
+      });
+      it("should correctly identify a URL as non absolute URL if protocol is missing", async () => {
+        const withEmbedGetSsr = withEmbedSsr(
+          getServerSidePropsFnGenerator({
+            redirectUrl: "httpcalcom.cal.local/owner",
+          })
+        );
+
+        const ret = await withEmbedGetSsr(
+          getServerSidePropsContextArg({
+            embedRelatedParams: {
+              layout: "week_view",
+              embed: "namespace1",
+            },
+          })
+        );
+
+        expect(ret).toEqual({
+          redirect: {
+            // FIXME: Note that it is adding a / in the beginning of the path, which might be fine for now, but could be an issue
+            destination: "/httpcalcom.cal.local/owner/embed?layout=week_view&embed=namespace1",
+            permanent: false,
+          },
+        });
+      });
+    });
+  });
+
+  describe("when gSSP returns props", () => {
+    it("should add isEmbed=true prop", async () => {
+      const withEmbedGetSsr = withEmbedSsr(
+        getServerSidePropsFnGenerator({
+          props: {
+            prop1: "value1",
+          },
+        })
+      );
+      const ret = await withEmbedGetSsr(
+        getServerSidePropsContextArg({
+          embedRelatedParams: {
+            layout: "week_view",
+            embed: "",
+          },
+        })
+      );
+      expect(ret).toEqual({
+        props: {
+          prop1: "value1",
+          isEmbed: true,
+        },
+      });
+    });
+  });
+
+  describe("when gSSP doesn't have props or redirect ", () => {
+    it("should return the result from gSSP as is", async () => {
+      const withEmbedGetSsr = withEmbedSsr(
+        getServerSidePropsFnGenerator({
+          notFound: true,
+        })
+      );
+
+      const ret = await withEmbedGetSsr(
+        getServerSidePropsContextArg({
+          embedRelatedParams: {
+            layout: "week_view",
+            embed: "",
+          },
+        })
+      );
+
+      expect(ret).toEqual({ notFound: true });
+    });
+  });
+});

apps/web/lib/withEmbedSsr.tsx

@@ -1,5 +1,7 @@
 import type { GetServerSideProps, GetServerSidePropsContext, GetServerSidePropsResult } from "next";
 
+import { WEBAPP_URL } from "@calcom/lib/constants";
+
 export type EmbedProps = {
   isEmbed?: boolean;
 };
@@ -11,14 +13,25 @@ export default function withEmbedSsr(getServerSideProps: GetServerSideProps) {
     const layout = context.query.layout;
 
     if ("redirect" in ssrResponse) {
-      // Use a dummy URL https://base as the fallback base URL so that URL parsing works for relative URLs as well.
-      const destinationUrlObj = new URL(ssrResponse.redirect.destination, "https://base");
+      const destinationUrl = ssrResponse.redirect.destination;
+      let urlPrefix = "";
 
+      // Get the URL parsed from URL so that we can reliably read pathname and searchParams from it.
+      const destinationUrlObj = new URL(ssrResponse.redirect.destination, WEBAPP_URL);
+
+      // If it's a complete URL, use the origin as the prefix to ensure we redirect to the same domain.
+      if (destinationUrl.search(/^(http:|https:).*/) !== -1) {
+        urlPrefix = destinationUrlObj.origin;
+      } else {
+        // Don't use any prefix for relative URLs to ensure we stay on the same domain
+        urlPrefix = "";
+      }
+
+      const destinationQueryStr = destinationUrlObj.searchParams.toString();
       // Make sure that redirect happens to /embed page and pass on embed query param as is for preserving Cal JS API namespace
-      const newDestinationUrl = `${
-        destinationUrlObj.pathname
-      }/embed?${destinationUrlObj.searchParams.toString()}&layout=${layout}&embed=${embed}`;
-
+      const newDestinationUrl = `${urlPrefix}${destinationUrlObj.pathname}/embed?${
+        destinationQueryStr ? `${destinationQueryStr}&` : ""
+      }layout=${layout}&embed=${embed}`;
       return {
         ...ssrResponse,
         redirect: {

apps/web/middleware.ts

@@ -5,10 +5,14 @@ import { NextResponse } from "next/server";
 
 import { extendEventData, nextCollectBasicSettings } from "@calcom/lib/telemetry";
 
+import { csp } from "@lib/csp";
+
 const middleware: NextMiddleware = async (req) => {
   const url = req.nextUrl;
   const requestHeaders = new Headers(req.headers);
 
+  requestHeaders.set("x-url", req.url);
+
   if (!url.pathname.startsWith("/api")) {
     //
     // NOTE: When tRPC hits an error a 500 is returned, when this is received
@@ -32,6 +36,18 @@ const middleware: NextMiddleware = async (req) => {
   }
 
   const res = routingForms.handle(url);
+
+  const { nonce } = csp(req, res ?? null);
+
+  if (!process.env.CSP_POLICY) {
+    req.headers.set("x-csp", "not-opted-in");
+  } else if (!req.headers.get("x-csp")) {
+    // If x-csp not set by gSSP, then it's initialPropsOnly
+    req.headers.set("x-csp", "initialPropsOnly");
+  } else {
+    req.headers.set("x-csp", nonce ?? "");
+  }
+
   if (res) {
     return res;
   }

apps/web/next.config.js

@@ -3,6 +3,7 @@ const CopyWebpackPlugin = require("copy-webpack-plugin");
 const os = require("os");
 const englishTranslation = require("./public/static/locales/en/common.json");
 const { withAxiom } = require("next-axiom");
+const { withSentryConfig } = require("@sentry/nextjs");
 const { version } = require("./package.json");
 const { i18n } = require("./next-i18next.config");
 const {
@@ -92,6 +93,7 @@ if (process.env.ANALYZE === "true") {
 }
 
 plugins.push(withAxiom);
+
 const matcherConfigRootPath = {
   has: [
     {
@@ -102,6 +104,16 @@ const matcherConfigRootPath = {
   source: "/",
 };
 
+const matcherConfigRootPathEmbed = {
+  has: [
+    {
+      type: "host",
+      value: orgHostPath,
+    },
+  ],
+  source: "/embed",
+};
+
 const matcherConfigUserRoute = {
   has: [
     {
@@ -226,6 +238,14 @@ const nextConfig = {
   },
   async rewrites() {
     const beforeFiles = [
+      {
+        /**
+         * Needed due to the introduction of dotted usernames
+         * @see https://github.com/calcom/cal.com/pull/11706
+         */
+        source: "/embed.js",
+        destination: "/embed/embed.js",
+      },
       {
         source: "/login",
         destination: "/auth/login",
@@ -237,6 +257,10 @@ const nextConfig = {
               ...matcherConfigRootPath,
               destination: "/team/:orgSlug?isOrgProfile=1",
             },
+            {
+              ...matcherConfigRootPathEmbed,
+              destination: "/team/:orgSlug/embed?isOrgProfile=1",
+            },
             {
               ...matcherConfigUserRoute,
               destination: "/org/:orgSlug/:user",
@@ -525,4 +549,13 @@ const nextConfig = {
   },
 };
 
+if (!!process.env.NEXT_PUBLIC_SENTRY_DSN) {
+  nextConfig["sentry"] = {
+    autoInstrumentServerFunctions: true,
+    hideSourceMaps: true,
+  };
+
+  plugins.push(withSentryConfig);
+}
+
 module.exports = () => plugins.reduce((acc, next) => next(acc), nextConfig);

apps/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcom/web",
-  "version": "3.4.4",
+  "version": "3.5.0",
   "private": true,
   "scripts": {
     "analyze": "ANALYZE=true next build",
@@ -57,6 +57,7 @@
     "@radix-ui/react-switch": "^1.0.0",
     "@radix-ui/react-toggle-group": "^1.0.0",
     "@radix-ui/react-tooltip": "^1.0.0",
+    "@sentry/nextjs": "^7.73.0",
     "@stripe/react-stripe-js": "^1.10.0",
     "@stripe/stripe-js": "^1.35.0",
     "@tanstack/react-query": "^4.3.9",

apps/web/pages/404.tsx

@@ -3,7 +3,10 @@ import Link from "next/link";
 import { usePathname } from "next/navigation";
 import { useEffect, useState } from "react";
 
-import { orgDomainConfig, subdomainSuffix } from "@calcom/features/ee/organizations/lib/orgDomains";
+import {
+  getOrgDomainConfigFromHostname,
+  subdomainSuffix,
+} from "@calcom/features/ee/organizations/lib/orgDomains";
 import { DOCS_URL, IS_CALCOM, JOIN_DISCORD, WEBSITE_URL } from "@calcom/lib/constants";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
 import { HeadSeo } from "@calcom/ui";
@@ -50,7 +53,10 @@ export default function Custom404() {
 
   const [url, setUrl] = useState(`${WEBSITE_URL}/signup`);
   useEffect(() => {
-    const { isValidOrgDomain, currentOrgDomain } = orgDomainConfig(window.location.host);
+    const { isValidOrgDomain, currentOrgDomain } = getOrgDomainConfigFromHostname({
+      hostname: window.location.host,
+    });
+
     const [routerUsername] = pathname?.replace("%20", "-").split(/[?#]/) ?? [];
     if (routerUsername && (!isValidOrgDomain || !currentOrgDomain)) {
       const splitPath = routerUsername.split("/");

apps/web/pages/[user].tsx

@@ -264,6 +264,7 @@ export type UserPageProps = {
     | "slug"
     | "length"
     | "hidden"
+    | "lockTimeZoneToggleOnBookingPage"
     | "requiresConfirmation"
     | "requiresBookerEmailVerification"
     | "price"
@@ -274,10 +275,7 @@ export type UserPageProps = {
 
 export const getServerSideProps: GetServerSideProps<UserPageProps> = async (context) => {
   const ssr = await ssrInit(context);
-  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(
-    context.req.headers.host ?? "",
-    context.params?.orgSlug
-  );
+  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(context.req, context.params?.orgSlug);
   const usernameList = getUsernameList(context.query.user as string);
   const isOrgContext = isValidOrgDomain && currentOrgDomain;
   const dataFetchStart = Date.now();
@@ -342,6 +340,7 @@ export const getServerSideProps: GetServerSideProps<UserPageProps> = async (cont
       slug: usernameList[0],
       redirectType: RedirectType.User,
       eventTypeSlug: null,
+      currentQuery: context.query,
     });
 
     if (redirect) {

apps/web/pages/[user]/[type].tsx

@@ -72,10 +72,7 @@ async function getDynamicGroupPageProps(context: GetServerSidePropsContext) {
 
   const { ssrInit } = await import("@server/lib/ssr");
   const ssr = await ssrInit(context);
-  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(
-    context.req.headers.host ?? "",
-    context.params?.orgSlug
-  );
+  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(context.req, context.params?.orgSlug);
 
   const users = await prisma.user.findMany({
     where: {
@@ -148,10 +145,7 @@ async function getUserPageProps(context: GetServerSidePropsContext) {
   const { user: usernames, type: slug } = paramsSchema.parse(context.params);
   const username = usernames[0];
   const { rescheduleUid, bookingUid, duration: queryDuration } = context.query;
-  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(
-    context.req.headers.host ?? "",
-    context.params?.orgSlug
-  );
+  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(context.req, context.params?.orgSlug);
 
   const isOrgContext = currentOrgDomain && isValidOrgDomain;
 
@@ -160,6 +154,7 @@ async function getUserPageProps(context: GetServerSidePropsContext) {
       slug: usernames[0],
       redirectType: RedirectType.User,
       eventTypeSlug: slug,
+      currentQuery: context.query,
     });
 
     if (redirect) {

apps/web/pages/api/book/event.ts

@@ -2,9 +2,18 @@ import type { NextApiRequest, NextApiResponse } from "next";
 
 import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
 import handleNewBooking from "@calcom/features/bookings/lib/handleNewBooking";
+import { checkRateLimitAndThrowError } from "@calcom/lib/checkRateLimitAndThrowError";
+import getIP from "@calcom/lib/getIP";
 import { defaultResponder } from "@calcom/lib/server";
 
 async function handler(req: NextApiRequest & { userId?: number }, res: NextApiResponse) {
+  const userIp = getIP(req);
+
+  await checkRateLimitAndThrowError({
+    rateLimitingType: "core",
+    identifier: userIp,
+  });
+
   const session = await getServerSession({ req, res });
   /* To mimic API behavior and comply with types */
   req.userId = session?.user?.id || -1;

apps/web/pages/api/book/recurring-event.ts

@@ -3,39 +3,49 @@ import type { NextApiRequest, NextApiResponse } from "next";
 import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
 import handleNewBooking from "@calcom/features/bookings/lib/handleNewBooking";
 import type { BookingResponse, RecurringBookingCreateBody } from "@calcom/features/bookings/types";
+import { checkRateLimitAndThrowError } from "@calcom/lib/checkRateLimitAndThrowError";
+import getIP from "@calcom/lib/getIP";
 import { defaultResponder } from "@calcom/lib/server";
 import type { AppsStatus } from "@calcom/types/Calendar";
 
 // @TODO: Didn't look at the contents of this function in order to not break old booking page.
 
 async function handler(req: NextApiRequest & { userId?: number }, res: NextApiResponse) {
+  const userIp = getIP(req);
+
+  await checkRateLimitAndThrowError({
+    rateLimitingType: "core",
+    identifier: userIp,
+  });
   const data: RecurringBookingCreateBody[] = req.body;
   const session = await getServerSession({ req, res });
   const createdBookings: BookingResponse[] = [];
   const allRecurringDates: string[] = data.map((booking) => booking.start);
-  let appsStatus: AppsStatus[] | undefined = undefined;
+  const appsStatus: AppsStatus[] | undefined = undefined;
 
   /* To mimic API behavior and comply with types */
   req.userId = session?.user?.id || -1;
+  const numSlotsToCheckForAvailability = 2;
 
-  // Reversing to accumulate results for noEmail instances first, to then lastly, create the
-  // emailed booking taking into account accumulated results to send app status accurately
-  for (let key = data.length - 1; key >= 0; key--) {
+  for (let key = 0; key < data.length; key++) {
     const booking = data[key];
-    if (key === 0) {
-      const calcAppsStatus: { [key: string]: AppsStatus } = createdBookings
-        .flatMap((book) => (book.appsStatus !== undefined ? book.appsStatus : []))
-        .reduce((prev, curr) => {
-          if (prev[curr.type]) {
-            prev[curr.type].failures += curr.failures;
-            prev[curr.type].success += curr.success;
-          } else {
-            prev[curr.type] = curr;
-          }
-          return prev;
-        }, {} as { [key: string]: AppsStatus });
-      appsStatus = Object.values(calcAppsStatus);
-    }
+    // Disable AppStatus in Recurring Booking Email as it requires us to iterate backwards to be able to compute the AppsStatus for all the bookings except the very first slot and then send that slot's email with statuses
+    // It is also doubtful that how useful is to have the AppsStatus of all the bookings in the email.
+    // It is more important to iterate forward and check for conflicts for only first few bookings defined by 'numSlotsToCheckForAvailability'
+    // if (key === 0) {
+    //   const calcAppsStatus: { [key: string]: AppsStatus } = createdBookings
+    //     .flatMap((book) => (book.appsStatus !== undefined ? book.appsStatus : []))
+    //     .reduce((prev, curr) => {
+    //       if (prev[curr.type]) {
+    //         prev[curr.type].failures += curr.failures;
+    //         prev[curr.type].success += curr.success;
+    //       } else {
+    //         prev[curr.type] = curr;
+    //       }
+    //       return prev;
+    //     }, {} as { [key: string]: AppsStatus });
+    //   appsStatus = Object.values(calcAppsStatus);
+    // }
 
     const recurringEventReq: NextApiRequest & { userId?: number } = req;
 
@@ -49,6 +59,7 @@ async function handler(req: NextApiRequest & { userId?: number }, res: NextApiRe
 
     const eachRecurringBooking = await handleNewBooking(recurringEventReq, {
       isNotAnApiCall: true,
+      skipAvailabilityCheck: key >= numSlotsToCheckForAvailability,
     });
 
     createdBookings.push(eachRecurringBooking);
@@ -56,4 +67,6 @@ async function handler(req: NextApiRequest & { userId?: number }, res: NextApiRe
   return createdBookings;
 }
 
+export const handleRecurringEventBooking = handler;
+
 export default defaultResponder(handler);

apps/web/pages/api/integrations/subscriptions/webhook.ts

@@ -0,0 +1,116 @@
+import { buffer } from "micro";
+import type { NextApiRequest, NextApiResponse } from "next";
+import type Stripe from "stripe";
+
+import stripe from "@calcom/app-store/stripepayment/lib/server";
+import { IS_PRODUCTION } from "@calcom/lib/constants";
+import { getErrorFromUnknown } from "@calcom/lib/errors";
+import { HttpError as HttpCode } from "@calcom/lib/http-error";
+import prisma from "@calcom/prisma";
+
+export const config = {
+  api: {
+    bodyParser: false,
+  },
+};
+
+// This file is a catch-all for any integration related subscription/paid app.
+
+const handleSubscriptionUpdate = async (event: Stripe.Event) => {
+  const subscription = event.data.object as Stripe.Subscription;
+  if (!subscription.id) throw new HttpCode({ statusCode: 400, message: "Subscription ID not found" });
+
+  const app = await prisma.credential.findFirst({
+    where: {
+      subscriptionId: subscription.id,
+    },
+  });
+
+  if (!app) {
+    throw new HttpCode({ statusCode: 202, message: "Received and discarded" });
+  }
+
+  await prisma.credential.update({
+    where: {
+      id: app.id,
+    },
+    data: {
+      paymentStatus: subscription.status,
+    },
+  });
+};
+
+const handleSubscriptionDeleted = async (event: Stripe.Event) => {
+  const subscription = event.data.object as Stripe.Subscription;
+  if (!subscription.id) throw new HttpCode({ statusCode: 400, message: "Subscription ID not found" });
+
+  const app = await prisma.credential.findFirst({
+    where: {
+      subscriptionId: subscription.id,
+    },
+  });
+
+  if (!app) {
+    throw new HttpCode({ statusCode: 202, message: "Received and discarded" });
+  }
+
+  // should we delete the credential here rather than marking as inactive?
+  await prisma.credential.update({
+    where: {
+      id: app.id,
+    },
+    data: {
+      paymentStatus: "inactive",
+      billingCycleStart: null,
+    },
+  });
+};
+
+type WebhookHandler = (event: Stripe.Event) => Promise<void>;
+
+const webhookHandlers: Record<string, WebhookHandler | undefined> = {
+  "customer.subscription.updated": handleSubscriptionUpdate,
+  "customer.subscription.deleted": handleSubscriptionDeleted,
+};
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  try {
+    if (req.method !== "POST") {
+      throw new HttpCode({ statusCode: 405, message: "Method Not Allowed" });
+    }
+    const sig = req.headers["stripe-signature"];
+    if (!sig) {
+      throw new HttpCode({ statusCode: 400, message: "Missing stripe-signature" });
+    }
+
+    if (!process.env.STRIPE_WEBHOOK_SECRET) {
+      throw new HttpCode({ statusCode: 500, message: "Missing process.env.STRIPE_WEBHOOK_SECRET" });
+    }
+    const requestBuffer = await buffer(req);
+    const payload = requestBuffer.toString();
+
+    const event = stripe.webhooks.constructEvent(payload, sig, process.env.STRIPE_WEBHOOK_SECRET);
+
+    const handler = webhookHandlers[event.type];
+    if (handler) {
+      await handler(event);
+    } else {
+      /** Not really an error, just letting Stripe know that the webhook was received but unhandled */
+      throw new HttpCode({
+        statusCode: 202,
+        message: `Unhandled Stripe Webhook event type ${event.type}`,
+      });
+    }
+  } catch (_err) {
+    const err = getErrorFromUnknown(_err);
+    console.error(`Webhook Error: ${err.message}`);
+    res.status(err.statusCode ?? 500).send({
+      message: err.message,
+      stack: IS_PRODUCTION ? undefined : err.stack,
+    });
+    return;
+  }
+
+  // Return a response to acknowledge receipt of the event
+  res.json({ received: true });
+}

apps/web/pages/api/logo.ts

@@ -154,7 +154,7 @@ async function getTeamLogos(subdomain: string, isValidOrgDomain: boolean) {
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   const { query } = req;
   const parsedQuery = logoApiSchema.parse(query);
-  const { isValidOrgDomain } = orgDomainConfig(req.headers.host ?? "");
+  const { isValidOrgDomain } = orgDomainConfig(req);
 
   const hostname = req?.headers["host"];
   if (!hostname) throw new Error("No hostname");

apps/web/pages/api/recorded-daily-video.ts

@@ -62,6 +62,46 @@ const triggerWebhook = async ({
   await Promise.all(promises);
 };
 
+const checkIfUserIsPartOfTheSameTeam = async (
+  teamId: number | undefined | null,
+  userId: number,
+  userEmail: string | undefined | null
+) => {
+  if (!teamId) return false;
+
+  const getUserQuery = () => {
+    if (!!userEmail) {
+      return {
+        OR: [
+          {
+            id: userId,
+          },
+          {
+            email: userEmail,
+          },
+        ],
+      };
+    } else {
+      return {
+        id: userId,
+      };
+    }
+  };
+
+  const team = await prisma.team.findFirst({
+    where: {
+      id: teamId,
+      members: {
+        some: {
+          user: getUserQuery(),
+        },
+      },
+    },
+  });
+
+  return !!team;
+};
+
 async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (!process.env.SENDGRID_API_KEY || !process.env.SENDGRID_EMAIL) {
     return res.status(405).json({ message: "No SendGrid API key or email" });
@@ -137,12 +177,22 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
 
     const isUserAttendeeOrOrganiser =
       booking?.user?.id === session.user.id ||
-      attendeesList.find((attendee) => attendee.id === session.user.id);
+      attendeesList.find(
+        (attendee) => attendee.id === session.user.id || attendee.email === session.user.email
+      );
 
     if (!isUserAttendeeOrOrganiser) {
-      return res.status(403).send({
-        message: "Unauthorised",
-      });
+      const isUserMemberOfTheTeam = checkIfUserIsPartOfTheSameTeam(
+        booking?.eventType?.teamId,
+        session.user.id,
+        session.user.email
+      );
+
+      if (!isUserMemberOfTheTeam) {
+        return res.status(403).send({
+          message: "Unauthorised",
+        });
+      }
     }
 
     await prisma.booking.update({
@@ -202,7 +252,7 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
 
     return res.status(403).json({ message: "User does not have team plan to send out emails" });
   } catch (err) {
-    console.warn("something_went_wrong", err);
+    console.warn("Error in /recorded-daily-video", err);
     return res.status(500).json({ message: "something went wrong" });
   }
 }

apps/web/pages/api/user/avatar.ts

@@ -29,7 +29,7 @@ const querySchema = z
 
 async function getIdentityData(req: NextApiRequest) {
   const { username, teamname, orgId, orgSlug } = querySchema.parse(req.query);
-  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(req.headers.host ?? "");
+  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(req);
 
   const org = isValidOrgDomain ? currentOrgDomain : null;
 

apps/web/pages/api/username.ts

@@ -9,7 +9,7 @@ type Response = {
 };
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse<Response>): Promise<void> {
-  const { currentOrgDomain } = orgDomainConfig(req.headers.host ?? "");
+  const { currentOrgDomain } = orgDomainConfig(req);
   const result = await checkUsername(req.body.username, currentOrgDomain);
   return res.status(200).json(result);
 }

apps/web/pages/apps/[slug]/index.tsx

@@ -79,6 +79,7 @@ function SingleAppPage(props: inferSSRProps<typeof getStaticProps>) {
       isTemplate={data.isTemplate}
       dependencies={data.dependencies}
       concurrentMeetings={data.concurrentMeetings}
+      paid={data.paid}
       //   tos="https://zoom.us/terms"
       //   privacy="https://zoom.us/privacy"
       body={

apps/web/pages/auth/login.tsx

@@ -278,7 +278,7 @@ inferSSRProps<typeof _getServerSideProps> & WithNonceProps<{}>) {
 
 // TODO: Once we understand how to retrieve prop types automatically from getServerSideProps, remove this temporary variable
 const _getServerSideProps = async function getServerSideProps(context: GetServerSidePropsContext) {
-  const { req, res } = context;
+  const { req, res, query } = context;
 
   const session = await getServerSession({ req, res });
   const ssr = await ssrInit(context);
@@ -318,6 +318,24 @@ const _getServerSideProps = async function getServerSideProps(context: GetServer
   }
 
   if (session) {
+    const { callbackUrl } = query;
+
+    if (callbackUrl) {
+      try {
+        const destination = getSafeRedirectUrl(callbackUrl as string);
+        if (destination) {
+          return {
+            redirect: {
+              destination,
+              permanent: false,
+            },
+          };
+        }
+      } catch (e) {
+        console.warn(e);
+      }
+    }
+
     return {
       redirect: {
         destination: "/",

apps/web/pages/auth/sso/[provider].tsx

@@ -65,7 +65,7 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
 
   const session = await getServerSession({ req, res });
   const ssr = await ssrInit(context);
-  const { currentOrgDomain } = orgDomainConfig(context.req.headers.host ?? "");
+  const { currentOrgDomain } = orgDomainConfig(context.req);
 
   if (session) {
     // Validating if username is Premium, while this is true an email its required for stripe user confirmation

apps/web/pages/booking/[uid].tsx

@@ -342,14 +342,17 @@ export default function Success(props: SuccessProps) {
           <div
             className={classNames(
               shouldAlignCentrally ? "text-center" : "",
-              "flex items-end justify-center px-4 pb-20 pt-4  sm:block sm:p-0"
+              "flex items-end justify-center px-4 pb-20 pt-4 sm:flex sm:p-0"
             )}>
             <div
-              className={classNames("my-4 transition-opacity sm:my-0", isEmbed ? "" : " inset-0")}
+              className={classNames(
+                "main my-4 flex flex-col transition-opacity sm:my-0 ",
+                isEmbed ? "" : " inset-0"
+              )}
               aria-hidden="true">
               <div
                 className={classNames(
-                  "main inline-block transform overflow-hidden rounded-lg border sm:my-8 sm:max-w-xl",
+                  "inline-block transform overflow-hidden rounded-lg border sm:my-8 sm:max-w-xl",
                   !isBackgroundTransparent && " bg-default dark:bg-muted border-booker border-booker-width",
                   "px-8 pb-4 pt-5 text-left align-bottom transition-all sm:w-full sm:py-8 sm:align-middle"
                 )}

apps/web/pages/bookings/[status].tsx

@@ -5,6 +5,7 @@ import React from "react";
 import { z } from "zod";
 
 import { WipeMyCalActionButton } from "@calcom/app-store/wipemycalother/components";
+import dayjs from "@calcom/dayjs";
 import { getLayout } from "@calcom/features/MainLayout";
 import { FiltersContainer } from "@calcom/features/bookings/components/FiltersContainer";
 import type { filterQuerySchema } from "@calcom/features/bookings/lib/useFilterQuery";
@@ -20,6 +21,7 @@ import { Alert, Button, EmptyScreen } from "@calcom/ui";
 import { Calendar } from "@calcom/ui/components/icon";
 
 import { useInViewObserver } from "@lib/hooks/useInViewObserver";
+import useMeQuery from "@lib/hooks/useMeQuery";
 
 import PageWrapper from "@components/PageWrapper";
 import BookingListItem from "@components/booking/BookingListItem";
@@ -78,6 +80,7 @@ export default function Bookings() {
   const { data: filterQuery } = useFilterQuery();
   const { status } = params ? querySchema.parse(params) : { status: "upcoming" as const };
   const { t } = useLocale();
+  const user = useMeQuery().data;
 
   const query = trpc.viewer.bookings.get.useInfiniteQuery(
     {
@@ -119,7 +122,10 @@ export default function Bookings() {
       }
       shownBookings[booking.recurringEventId] = [booking];
     } else if (status === "upcoming") {
-      return new Date(booking.startTime).toDateString() !== new Date().toDateString();
+      return (
+        dayjs(booking.startTime).tz(user?.timeZone).format("YYYY-MM-DD") !==
+        dayjs().tz(user?.timeZone).format("YYYY-MM-DD")
+      );
     }
     return true;
   };
@@ -132,7 +138,11 @@ export default function Bookings() {
         recurringInfoToday = page.recurringInfo.find(
           (info) => info.recurringEventId === booking.recurringEventId
         );
-        return new Date(booking.startTime).toDateString() === new Date().toDateString();
+
+        return (
+          dayjs(booking.startTime).tz(user?.timeZone).format("YYYY-MM-DD") ===
+          dayjs().tz(user?.timeZone).format("YYYY-MM-DD")
+        );
       })
     )[0] || [];
 
@@ -166,6 +176,12 @@ export default function Bookings() {
                             {bookingsToday.map((booking: BookingOutput) => (
                               <BookingListItem
                                 key={booking.id}
+                                loggedInUser={{
+                                  userId: user?.id,
+                                  userTimeZone: user?.timeZone,
+                                  userTimeFormat: user?.timeFormat,
+                                  userEmail: user?.email,
+                                }}
                                 listingStatus={status}
                                 recurringInfo={recurringInfoToday}
                                 {...booking}
@@ -190,6 +206,12 @@ export default function Bookings() {
                               return (
                                 <BookingListItem
                                   key={booking.id}
+                                  loggedInUser={{
+                                    userId: user?.id,
+                                    userTimeZone: user?.timeZone,
+                                    userTimeFormat: user?.timeFormat,
+                                    userEmail: user?.email,
+                                  }}
                                   listingStatus={status}
                                   recurringInfo={recurringInfo}
                                   {...booking}

apps/web/pages/d/[link]/[slug].tsx

@@ -61,7 +61,7 @@ async function getUserPageProps(context: GetServerSidePropsContext) {
   const session = await getServerSession(context);
   const { link, slug } = paramsSchema.parse(context.params);
   const { rescheduleUid, duration: queryDuration } = context.query;
-  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(context.req.headers.host ?? "");
+  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(context.req);
   const org = isValidOrgDomain ? currentOrgDomain : null;
 
   const { ssrInit } = await import("@server/lib/ssr");

apps/web/pages/enterprise/index.tsx

@@ -0,0 +1,74 @@
+import { getLayout } from "@calcom/features/MainLayout";
+import { ShellMain } from "@calcom/features/shell/Shell";
+import { UpgradeTip } from "@calcom/features/tips";
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { Button, ButtonGroup } from "@calcom/ui";
+import { BarChart, CreditCard, Globe, Lock, Paintbrush, Users } from "@calcom/ui/components/icon";
+
+import PageWrapper from "@components/PageWrapper";
+
+export default function EnterprisePage() {
+  const { t } = useLocale();
+
+  const features = [
+    {
+      icon: <Globe className="h-5 w-5 text-red-500" />,
+      title: t("branded_subdomain"),
+      description: t("branded_subdomain_description"),
+    },
+    {
+      icon: <BarChart className="h-5 w-5 text-blue-500" />,
+      title: t("org_insights"),
+      description: t("org_insights_description"),
+    },
+    {
+      icon: <Paintbrush className="h-5 w-5 text-pink-500" />,
+      title: t("extensive_whitelabeling"),
+      description: t("extensive_whitelabeling_description"),
+    },
+    {
+      icon: <Users className="h-5 w-5 text-orange-500" />,
+      title: t("unlimited_teams"),
+      description: t("unlimited_teams_description"),
+    },
+    {
+      icon: <CreditCard className="h-5 w-5 text-green-500" />,
+      title: t("unified_billing"),
+      description: t("unified_billing_description"),
+    },
+    {
+      icon: <Lock className="h-5 w-5 text-purple-500" />,
+      title: t("advanced_managed_events"),
+      description: t("advanced_managed_events_description"),
+    },
+  ];
+  return (
+    <div>
+      <ShellMain heading="Enterprise" subtitle={t("enterprise_description")}>
+        <UpgradeTip
+          plan="enterprise"
+          title={t("create_your_org")}
+          description={t("create_your_org_description")}
+          features={features}
+          background="/tips/enterprise"
+          buttons={
+            <div className="space-y-2 rtl:space-x-reverse sm:space-x-2">
+              <ButtonGroup>
+                <Button color="primary" href="https://i.cal.com/sales/enterprise?duration=25" target="_blank">
+                  {t("contact_sales")}
+                </Button>
+                <Button color="minimal" href="https://cal.com/enterprise" target="_blank">
+                  {t("learn_more")}
+                </Button>
+              </ButtonGroup>
+            </div>
+          }>
+          <>Create Org</>
+        </UpgradeTip>
+      </ShellMain>
+    </div>
+  );
+}
+
+EnterprisePage.PageWrapper = PageWrapper;
+EnterprisePage.getLayout = getLayout;

apps/web/pages/event-types/[type]/index.tsx

@@ -8,6 +8,7 @@ import { useEffect, useMemo, useState } from "react";
 import { useForm } from "react-hook-form";
 import { z } from "zod";
 
+import { getEventLocationType } from "@calcom/app-store/locations";
 import { validateCustomEventName } from "@calcom/core/event";
 import type { EventLocationType } from "@calcom/core/location";
 import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
@@ -87,6 +88,7 @@ export type FormValues = {
   offsetStart: number;
   description: string;
   disableGuests: boolean;
+  lockTimeZoneToggleOnBookingPage: boolean;
   requiresConfirmation: boolean;
   requiresBookerEmailVerification: boolean;
   recurringEvent: RecurringEvent | null;
@@ -320,6 +322,47 @@ const EventTypePage = (props: EventTypeSetupProps) => {
                   teamName: z.string().optional(),
                 })
                 .passthrough()
+                .superRefine((val, ctx) => {
+                  if (val?.link) {
+                    const link = val.link;
+                    const eventLocationType = getEventLocationType(val.type);
+                    if (
+                      eventLocationType &&
+                      !eventLocationType.default &&
+                      eventLocationType.linkType === "static" &&
+                      eventLocationType.urlRegExp
+                    ) {
+                      const valid = z
+                        .string()
+                        .regex(new RegExp(eventLocationType.urlRegExp))
+                        .safeParse(link).success;
+
+                      if (!valid) {
+                        const sampleUrl = eventLocationType.organizerInputPlaceholder;
+                        ctx.addIssue({
+                          code: z.ZodIssueCode.custom,
+                          path: [eventLocationType?.defaultValueVariable ?? "link"],
+                          message: t("invalid_url_error_message", {
+                            label: eventLocationType.label,
+                            sampleUrl: sampleUrl ?? "https://cal.com",
+                          }),
+                        });
+                      }
+                      return;
+                    }
+
+                    const valid = z.string().url().optional().safeParse(link).success;
+
+                    if (!valid) {
+                      ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: [eventLocationType?.defaultValueVariable ?? "link"],
+                        message: `Invalid URL`,
+                      });
+                    }
+                  }
+                  return;
+                })
             )
             .optional(),
         })

apps/web/pages/event-types/index.tsx

@@ -386,7 +386,7 @@ export const EventTypeList = ({ group, groupIndex, readOnly, types }: EventTypeL
             type.metadata?.managedEventConfig !== undefined && type.schedulingType !== SchedulingType.MANAGED;
           return (
             <li key={type.id}>
-              <div className="hover:bg-muted flex w-full items-center justify-between">
+              <div className="hover:bg-muted flex w-full items-center justify-between transition">
                 <div className="group flex w-full max-w-full items-center justify-between overflow-hidden px-4 py-4 sm:px-6">
                   {!(firstItem && firstItem.id === type.id) && (
                     <ArrowButton onClick={() => moveEventType(index, -1)} arrowDirection="up" />

apps/web/pages/insights/index.tsx

@@ -46,6 +46,7 @@ export default function InsightsPage() {
     <div>
       <ShellMain heading="Insights" subtitle={t("insights_subtitle")}>
         <UpgradeTip
+          plan="team"
           title={t("make_informed_decisions")}
           description={t("make_informed_decisions_description")}
           features={features}

apps/web/pages/org/[orgSlug]/[user]/embed.tsx

@@ -0,0 +1,7 @@
+import withEmbedSsr from "@lib/withEmbedSsr";
+
+import { getServerSideProps as _getServerSideProps } from "../[user]";
+
+export { default } from "../[user]";
+
+export const getServerSideProps = withEmbedSsr(_getServerSideProps);

apps/web/pages/org/[orgSlug]/embed.tsx

@@ -0,0 +1,7 @@
+import withEmbedSsr from "@lib/withEmbedSsr";
+
+import { getServerSideProps as _getServerSideProps } from "./index";
+
+export { default } from "./index";
+
+export const getServerSideProps = withEmbedSsr(_getServerSideProps);

apps/web/pages/settings/my-account/calendars.tsx

@@ -25,6 +25,7 @@ import {
   SkeletonContainer,
   SkeletonText,
   showToast,
+  Label,
 } from "@calcom/ui";
 import { Plus, Calendar } from "@calcom/ui/components/icon";
 
@@ -113,17 +114,20 @@ const CalendarsView = () => {
                 <h2 className="text-emphasis mb-1 text-base font-bold leading-5 tracking-wide">
                   {t("add_to_calendar")}
                 </h2>
-                <p className="text-default text-sm leading-tight">{t("add_to_calendar_description")}</p>
+                <p className="text-subtle text-sm leading-tight">{t("add_to_calendar_description")}</p>
               </div>
               <div className="border-subtle flex w-full flex-col space-y-3 border border-x border-y-0 px-4 py-6 sm:px-6">
-                <DestinationCalendarSelector
-                  hidePlaceholder
-                  value={selectedDestinationCalendarOption?.externalId}
-                  onChange={(option) => {
-                    setSelectedDestinationCalendar(option);
-                  }}
-                  isLoading={mutation.isLoading}
-                />
+                <div>
+                  <Label className="text-default mb-0 font-medium">{t("add_events_to")}</Label>
+                  <DestinationCalendarSelector
+                    hidePlaceholder
+                    value={selectedDestinationCalendarOption?.externalId}
+                    onChange={(option) => {
+                      setSelectedDestinationCalendar(option);
+                    }}
+                    isLoading={mutation.isLoading}
+                  />
+                </div>
               </div>
               <SectionBottomActions align="end">
                 <Button

apps/web/pages/settings/my-account/profile.tsx

@@ -9,8 +9,8 @@ import { ErrorCode } from "@calcom/features/auth/lib/ErrorCode";
 import OrganizationMemberAvatar from "@calcom/features/ee/organizations/components/OrganizationMemberAvatar";
 import SectionBottomActions from "@calcom/features/settings/SectionBottomActions";
 import { getLayout } from "@calcom/features/settings/layouts/SettingsLayout";
+import checkIfItFallbackImage from "@calcom/lib/checkIfItFallbackImage";
 import { APP_NAME, FULL_NAME_LENGTH_MAX_LIMIT } from "@calcom/lib/constants";
-import { AVATAR_FALLBACK } from "@calcom/lib/constants";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
 import { md } from "@calcom/lib/markdownIt";
 import turndown from "@calcom/lib/turndownService";
@@ -72,32 +72,24 @@ interface DeleteAccountValues {
 
 type FormValues = {
   username: string;
-  avatar: string | null;
+  avatar: string;
   name: string;
   email: string;
   bio: string;
 };
 
-const checkIfItFallbackImage = (fetchedImgSrc?: string) => {
-  return !fetchedImgSrc || fetchedImgSrc.endsWith(AVATAR_FALLBACK);
-};
-
 const ProfileView = () => {
   const { t } = useLocale();
   const utils = trpc.useContext();
   const { update } = useSession();
 
-  const [fetchedImgSrc, setFetchedImgSrc] = useState<string | undefined>(undefined);
+  const [fetchedImgSrc, setFetchedImgSrc] = useState<string>("");
 
   const { data: user, isLoading } = trpc.viewer.me.useQuery(undefined, {
     onSuccess: async (userData) => {
       try {
-        if (!userData.organization) {
-          const res = await fetch(userData.avatar);
-          if (res.url) setFetchedImgSrc(res.url);
-        } else {
-          setFetchedImgSrc("");
-        }
+        const res = await fetch(userData.avatar);
+        if (res.url) setFetchedImgSrc(res.url);
       } catch (err) {
         setFetchedImgSrc("");
       }
@@ -234,7 +226,7 @@ const ProfileView = () => {
 
   const defaultValues = {
     username: user.username || "",
-    avatar: user.avatar || "",
+    avatar: fetchedImgSrc || "",
     name: user.name || "",
     email: user.email || "",
     bio: user.bio || "",
@@ -251,8 +243,6 @@ const ProfileView = () => {
         key={JSON.stringify(defaultValues)}
         defaultValues={defaultValues}
         isLoading={updateProfileMutation.isLoading}
-        isFallbackImg={checkIfItFallbackImage(fetchedImgSrc)}
-        userAvatar={user.avatar}
         user={user}
         userOrganization={user.organization}
         onSubmit={(values) => {
@@ -283,8 +273,8 @@ const ProfileView = () => {
       />
 
       <div className="border-subtle mt-6 rounded-lg rounded-b-none border border-b-0 p-6">
-        <Label className="text-base font-semibold text-red-700">{t("danger_zone")}</Label>
-        <p className="text-subtle">{t("account_deletion_cannot_be_undone")}</p>
+        <Label className="mb-0 text-base font-semibold text-red-700">{t("danger_zone")}</Label>
+        <p className="text-subtle text-sm">{t("account_deletion_cannot_be_undone")}</p>
       </div>
       {/* Delete account Dialog */}
       <Dialog open={deleteAccountOpen} onOpenChange={setDeleteAccountOpen}>
@@ -397,8 +387,6 @@ const ProfileForm = ({
   onSubmit,
   extraField,
   isLoading = false,
-  isFallbackImg,
-  userAvatar,
   user,
   userOrganization,
 }: {
@@ -406,8 +394,6 @@ const ProfileForm = ({
   onSubmit: (values: FormValues) => void;
   extraField?: React.ReactNode;
   isLoading: boolean;
-  isFallbackImg: boolean;
-  userAvatar: string;
   user: RouterOutputs["viewer"]["me"];
   userOrganization: RouterOutputs["viewer"]["me"]["organization"];
 }) => {
@@ -416,7 +402,7 @@ const ProfileForm = ({
 
   const profileFormSchema = z.object({
     username: z.string(),
-    avatar: z.string().nullable(),
+    avatar: z.string(),
     name: z
       .string()
       .trim()
@@ -438,7 +424,6 @@ const ProfileForm = ({
   } = formMethods;
 
   const isDisabled = isSubmitting || !isDirty;
-
   return (
     <Form form={formMethods} handleSubmit={onSubmit}>
       <div className="border-subtle border-x px-4 pb-10 pt-8 sm:px-6">
@@ -447,7 +432,7 @@ const ProfileForm = ({
             control={formMethods.control}
             name="avatar"
             render={({ field: { value } }) => {
-              const showRemoveAvatarButton = !isFallbackImg || (value && userAvatar !== value);
+              const showRemoveAvatarButton = !checkIfItFallbackImage(value);
               const organization =
                 userOrganization && userOrganization.id
                   ? {
@@ -474,7 +459,7 @@ const ProfileForm = ({
                         handleAvatarChange={(newAvatar) => {
                           formMethods.setValue("avatar", newAvatar, { shouldDirty: true });
                         }}
-                        imageSrc={value || undefined}
+                        imageSrc={value}
                         triggerButtonColor={showRemoveAvatarButton ? "secondary" : "primary"}
                       />
 
@@ -482,7 +467,7 @@ const ProfileForm = ({
                         <Button
                           color="secondary"
                           onClick={() => {
-                            formMethods.setValue("avatar", null, { shouldDirty: true });
+                            formMethods.setValue("avatar", "", { shouldDirty: true });
                           }}>
                           {t("remove")}
                         </Button>

apps/web/pages/settings/security/password.tsx

@@ -164,14 +164,13 @@ const PasswordView = ({ user }: PasswordViewProps) => {
     <>
       <Meta title={t("password")} description={t("password_description")} borderInShellHeader={true} />
       {user && user.identityProvider !== IdentityProvider.CAL ? (
-        <div>
-          <div className="mt-6">
-            <h2 className="font-cal text-emphasis text-lg font-medium leading-6">
-              {t("account_managed_by_identity_provider", {
-                provider: identityProviderNameMap[user.identityProvider],
-              })}
-            </h2>
-          </div>
+        <div className="border-subtle rounded-b-xl border border-t-0 px-4 py-6 sm:px-6">
+          <h2 className="font-cal text-emphasis text-lg font-medium leading-6">
+            {t("account_managed_by_identity_provider", {
+              provider: identityProviderNameMap[user.identityProvider],
+            })}
+          </h2>
+
           <p className="text-subtle mt-1 text-sm">
             {t("account_managed_by_identity_provider_description", {
               provider: identityProviderNameMap[user.identityProvider],
@@ -180,7 +179,7 @@ const PasswordView = ({ user }: PasswordViewProps) => {
         </div>
       ) : (
         <Form form={formMethods} handleSubmit={handleSubmit}>
-          <div className="border-x px-4 py-6 sm:px-6">
+          <div className="border-subtle border-x px-4 py-6 sm:px-6">
             {formMethods.formState.errors.apiError && (
               <div className="pb-6">
                 <Alert severity="error" message={formMethods.formState.errors.apiError?.message} />

apps/web/pages/team/[slug].tsx

@@ -269,10 +269,7 @@ function TeamPage({
 
 export const getServerSideProps = async (context: GetServerSidePropsContext) => {
   const slug = Array.isArray(context.query?.slug) ? context.query.slug.pop() : context.query.slug;
-  const { isValidOrgDomain, currentOrgDomain } = orgDomainConfig(
-    context.req.headers.host ?? "",
-    context.params?.orgSlug
-  );
+  const { isValidOrgDomain, currentOrgDomain } = orgDomainConfig(context.req, context.params?.orgSlug);
   const isOrgContext = isValidOrgDomain && currentOrgDomain;
 
   // Provided by Rewrite from next.config.js
@@ -299,6 +296,7 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
       slug: slug,
       redirectType: RedirectType.Team,
       eventTypeSlug: null,
+      currentQuery: context.query,
     });
 
     if (redirect) {

apps/web/pages/team/[slug]/[type].tsx

@@ -74,10 +74,7 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
   const { rescheduleUid, duration: queryDuration } = context.query;
   const { ssrInit } = await import("@server/lib/ssr");
   const ssr = await ssrInit(context);
-  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(
-    context.req.headers.host ?? "",
-    context.params?.orgSlug
-  );
+  const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(context.req, context.params?.orgSlug);
   const isOrgContext = currentOrgDomain && isValidOrgDomain;
 
   if (!isOrgContext) {
@@ -85,6 +82,7 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
       slug: teamSlug,
       redirectType: RedirectType.Team,
       eventTypeSlug: meetingSlug,
+      currentQuery: context.query,
     });
 
     if (redirect) {

apps/web/pagesAndRewritePaths.js

@@ -11,10 +11,6 @@ let pages = (exports.pages = glob
   )
   .filter((v, i, self) => self.indexOf(v) === i && !v.startsWith("[user]")));
 
-// Following routes don't exist but they work by doing rewrite. Thus they need to be excluded from matching the orgRewrite patterns
-// Make sure to keep it upto date as more nonExistingRouteRewrites are added.
-const otherNonExistingRoutePrefixes = ["forms", "router", "success", "cancel"];
-
 // .* matches / as well(Note: *(i.e wildcard) doesn't match / but .*(i.e. RegExp) does)
 // It would match /free/30min but not /bookings/upcoming because 'bookings' is an item in pages
 // It would also not match /free/30min/embed because we are ensuring just two slashes
@@ -27,11 +23,26 @@ let subdomainRegExp = (exports.subdomainRegExp = getSubdomainRegExp(
 ));
 exports.orgHostPath = `^(?<orgSlug>${subdomainRegExp})\\.(?!vercel\.app).*`;
 
-let beforeRewriteExcludePages = pages.concat(otherNonExistingRoutePrefixes);
-exports.orgUserRoutePath = `/:user((?!${beforeRewriteExcludePages.join("|")}|_next|public)[a-zA-Z0-9\-_]+)`;
-exports.orgUserTypeRoutePath = `/:user((?!${beforeRewriteExcludePages.join(
-  "/|"
-)}|_next/|public/)[^/]+)/:type((?!avatar\.png)[^/]+)`;
-exports.orgUserTypeEmbedRoutePath = `/:user((?!${beforeRewriteExcludePages.join(
-  "/|"
-)}|_next/|public/)[^/]+)/:type/embed`;
+/**
+ * Returns a regex that matches all existing routes, virtual routes (like /forms, /router, /success etc) and nextjs special paths (_next, public)
+ */
+function getRegExpMatchingAllReservedRoutes(suffix) {
+  // Following routes don't exist but they work by doing rewrite. Thus they need to be excluded from matching the orgRewrite patterns
+  // Make sure to keep it upto date as more nonExistingRouteRewrites are added.
+  const otherNonExistingRoutePrefixes = ["forms", "router", "success", "cancel"];
+  const nextJsSpecialPaths = ["_next", "public"];
+
+  let beforeRewriteExcludePages = pages.concat(otherNonExistingRoutePrefixes).concat(nextJsSpecialPaths);
+  return beforeRewriteExcludePages.join(`${suffix}|`) + suffix;
+}
+
+// To handle /something
+exports.orgUserRoutePath = `/:user((?!${getRegExpMatchingAllReservedRoutes("/?$")})[a-zA-Z0-9\-_]+)`;
+
+// To handle /something/somethingelse
+exports.orgUserTypeRoutePath = `/:user((?!${getRegExpMatchingAllReservedRoutes(
+  "/"
+)})[^/]+)/:type((?!avatar\.png)[^/]+)`;
+
+// To handle /something/somethingelse/embed
+exports.orgUserTypeEmbedRoutePath = `/:user((?!${getRegExpMatchingAllReservedRoutes("/")})[^/]+)/:type/embed`;

apps/web/playwright/booking-pages.e2e.ts

@@ -1,6 +1,8 @@
 import { expect } from "@playwright/test";
 
 import { randomString } from "@calcom/lib/random";
+import { SchedulingType } from "@calcom/prisma/client";
+import type { Schedule, TimeRange } from "@calcom/types/schedule";
 
 import { test } from "./lib/fixtures";
 import {
@@ -342,3 +344,92 @@ test.describe("Booking on different layouts", () => {
     await expect(page.locator("[data-testid=success-page]")).toBeVisible();
   });
 });
+
+test.describe("Booking round robin event", () => {
+  test.beforeEach(async ({ page, users }) => {
+    const teamMatesObj = [{ name: "teammate-1" }];
+
+    const dateRanges: TimeRange = {
+      start: new Date(new Date().setUTCHours(10, 0, 0, 0)), //one hour after default schedule (teammate-1's schedule)
+      end: new Date(new Date().setUTCHours(17, 0, 0, 0)),
+    };
+
+    const schedule: Schedule = [[], [dateRanges], [dateRanges], [dateRanges], [dateRanges], [dateRanges], []];
+
+    const testUser = await users.create(
+      { username: "test-user", name: "Test User", email: "testuser@example.com", schedule },
+      {
+        hasTeam: true,
+        schedulingType: SchedulingType.ROUND_ROBIN,
+        teamEventLength: 120,
+        teammates: teamMatesObj,
+      }
+    );
+    const team = await testUser.getFirstTeam();
+    await page.goto(`/team/${team.team.slug}`);
+  });
+
+  test("Does not book round robin host outside availability with date override", async ({ page, users }) => {
+    const [testUser] = users.get();
+    testUser.apiLogin();
+
+    const team = await testUser.getFirstTeam();
+
+    // Click first event type (round robin)
+    await page.click('[data-testid="event-type-link"]');
+
+    await page.click('[data-testid="incrementMonth"]');
+
+    // books 9AM slots for 120 minutes (test-user is not available at this time, availability starts at 10)
+    await page.locator('[data-testid="time"]').nth(0).click();
+
+    await page.waitForLoadState("networkidle");
+
+    await page.locator('[name="name"]').fill("Test name");
+    await page.locator('[name="email"]').fill(`${randomString(4)}@example.com`);
+
+    await page.click('[data-testid="confirm-book-button"]');
+
+    await page.waitForURL((url) => {
+      return url.pathname.startsWith("/booking");
+    });
+
+    await expect(page.locator("[data-testid=success-page]")).toBeVisible();
+
+    await expect(page.locator("[data-testid=success-page]")).toBeVisible();
+
+    const host = await page.locator('[data-testid="booking-host-name"]');
+    const hostName = await host.innerText();
+
+    //expect teammate-1 to be booked, test-user is not available at this time
+    expect(hostName).toBe("teammate-1");
+
+    // make another booking to see if also for the second booking teammate-1 is booked
+    await page.goto(`/team/${team.team.slug}`);
+
+    await page.click('[data-testid="event-type-link"]');
+
+    await page.click('[data-testid="incrementMonth"]');
+    await page.click('[data-testid="incrementMonth"]');
+
+    // Again book a 9AM slot for 120 minutes where test-user is not available
+    await page.locator('[data-testid="time"]').nth(0).click();
+
+    await page.waitForLoadState("networkidle");
+
+    await page.locator('[name="name"]').fill("Test name");
+    await page.locator('[name="email"]').fill(`${randomString(4)}@example.com`);
+
+    await page.click('[data-testid="confirm-book-button"]');
+
+    await page.waitForURL((url) => {
+      return url.pathname.startsWith("/booking");
+    });
+
+    await expect(page.locator("[data-testid=success-page]")).toBeVisible();
+
+    const hostSecondBooking = await page.locator('[data-testid="booking-host-name"]');
+    const hostNameSecondBooking = await hostSecondBooking.innerText();
+    expect(hostNameSecondBooking).toBe("teammate-1"); // teammate-1 should be booked again
+  });
+});

apps/web/playwright/booking-seats.e2e.ts

@@ -435,6 +435,8 @@ test.describe("Reschedule for booking with seats", () => {
 
     await page.locator('[data-testid="confirm_cancel"]').click();
 
+    await page.waitForLoadState("networkidle");
+
     const oldBooking = await prisma.booking.findFirst({
       where: { uid: booking.uid },
       select: {

apps/web/playwright/booking/addressQuestione2e/addressQuestion.e2e.ts

@@ -0,0 +1,483 @@
+import { loginUser } from "../../fixtures/regularBookings";
+import { test } from "../../lib/fixtures";
+
+test.describe("Booking With Address Question and Each Other Question", () => {
+  const bookingOptions = { hasPlaceholder: true, isRequired: true };
+
+  test.beforeEach(async ({ page, users }) => {
+    await loginUser(users);
+    await page.goto("/event-types");
+  });
+
+  test.describe("Booking With Address Question and Checkbox Group Question", () => {
+    test("Address required and checkbox group required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Checkbox Group question (both required)",
+        secondQuestion: "checkbox",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Address and checkbox group not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Checkbox Group question (only address required)",
+        secondQuestion: "checkbox",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Address Question and Checkbox Question", () => {
+    test("Address required and checkbox required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Checkbox question (both required)",
+        secondQuestion: "boolean",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Addres and checkbox not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Checkbox question (only address required)",
+        secondQuestion: "boolean",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Address Question and Long text Question", () => {
+    test("Addres required and Long Text required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", true, "textarea test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Long Text question (both required)",
+        secondQuestion: "textarea",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Address and Long Text not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", false, "textarea test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Long Text question (only address required)",
+        secondQuestion: "textarea",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Address Question and Multi email Question", () => {
+    test("Address required and Multi email required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Multiemail question (both required)",
+        secondQuestion: "multiemail",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Address and Multi email not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        false,
+        "multiemail test"
+      );
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Multiemail question (only address required)",
+        secondQuestion: "multiemail",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Address Question and multiselect Question", () => {
+    test("Address required and multiselect text required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Multi Select question (both required)",
+        secondQuestion: "multiselect",
+        options: { ...bookingOptions, isMultiSelect: true },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Address and multiselect text not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Multi Select question (only address required)",
+        secondQuestion: "multiselect",
+        options: { ...bookingOptions, isMultiSelect: true, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Address Question and Number Question", () => {
+    test("Address required and Number required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("number", "number-test", "number test", true, "number test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Number question (both required)",
+        secondQuestion: "number",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Address and Number not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("number", "number-test", "number test", false, "number test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Number question (only address required)",
+        secondQuestion: "number",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Address Question and Phone Question", () => {
+    test("Address required and Phone required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("phone", "phone-test", "phone test", true, "phone-test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Multi Select question (both required)",
+        secondQuestion: "phone",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Address and Phone not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("phone", "phone-test", "phone test", false, "phone-test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Multi Select question (only address required)",
+        secondQuestion: "phone",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Address Question and Radio group Question", () => {
+    test("Address required and Radio group required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Radio question (both required)",
+        secondQuestion: "radio",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Address and Radio group not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("radio", "radio-test", "radio test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Radio question (only address required)",
+        secondQuestion: "radio",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Address Question and select Question", () => {
+    test("Address required and select required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Select question (both required)",
+        secondQuestion: "select",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Address and select not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("select", "select-test", "select test", false, "select test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Select question (both required)",
+        secondQuestion: "select",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Address Question and Short text question", () => {
+    test("Address required and Short text required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("text", "text-test", "text test", true, "text test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Multi Select question (both required)",
+        secondQuestion: "text",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Address and Short text not required", async ({ bookingPage }) => {
+      await bookingPage.goToEventType("30 min");
+      await bookingPage.goToTab("event_advanced_tab_title");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.addQuestion("text", "text-test", "text test", false, "text test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "address",
+        fillText: "Test Address question and Multi Select question (only address required)",
+        secondQuestion: "text",
+        options: { ...bookingOptions, isRequired: true },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+});

apps/web/playwright/booking/allQuestions.e2e.ts

@@ -0,0 +1,110 @@
+/* eslint-disable playwright/no-conditional-in-test */
+import { loginUser } from "../fixtures/regularBookings";
+import { test } from "../lib/fixtures";
+
+test.describe("Booking With All Questions", () => {
+  test.beforeEach(async ({ page, users, bookingPage }) => {
+    await loginUser(users);
+    await page.goto("/event-types");
+    await bookingPage.goToEventType("30 min");
+    await bookingPage.goToTab("event_advanced_tab_title");
+  });
+
+  const bookingOptions = { isAllRequired: true };
+
+  test("Selecting and filling all questions as required", async ({ bookingPage }) => {
+    const allQuestions = [
+      "phone",
+      "address",
+      "checkbox",
+      "boolean",
+      "textarea",
+      "multiemail",
+      "multiselect",
+      "number",
+      "radio",
+      "select",
+      "text",
+    ];
+    for (const question of allQuestions) {
+      if (
+        question !== "number" &&
+        question !== "select" &&
+        question !== "checkbox" &&
+        question !== "boolean" &&
+        question !== "multiselect" &&
+        question !== "radio"
+      ) {
+        await bookingPage.addQuestion(
+          question,
+          `${question}-test`,
+          `${question} test`,
+          true,
+          `${question} test`
+        );
+      } else {
+        await bookingPage.addQuestion(question, `${question}-test`, `${question} test`, true);
+      }
+      await bookingPage.checkField(question);
+    }
+
+    await bookingPage.updateEventType();
+    const eventTypePage = await bookingPage.previewEventType();
+    await bookingPage.selectTimeSlot(eventTypePage);
+    await bookingPage.fillAllQuestions(eventTypePage, allQuestions, bookingOptions);
+    await bookingPage.rescheduleBooking(eventTypePage);
+    await bookingPage.assertBookingRescheduled(eventTypePage);
+    await bookingPage.cancelBooking(eventTypePage);
+    await bookingPage.assertBookingCanceled(eventTypePage);
+  });
+
+  test("Selecting and filling all questions as optional", async ({ bookingPage }) => {
+    const allQuestions = [
+      "phone",
+      "address",
+      "checkbox",
+      "boolean",
+      "textarea",
+      "multiemail",
+      "multiselect",
+      "number",
+      "radio",
+      "select",
+      "text",
+    ];
+    for (const question of allQuestions) {
+      if (
+        question !== "number" &&
+        question !== "select" &&
+        question !== "checkbox" &&
+        question !== "boolean" &&
+        question !== "multiselect" &&
+        question !== "radio"
+      ) {
+        await bookingPage.addQuestion(
+          question,
+          `${question}-test`,
+          `${question} test`,
+          false,
+          `${question} test`
+        );
+      } else {
+        await bookingPage.addQuestion(question, `${question}-test`, `${question} test`, false);
+      }
+      await bookingPage.checkField(question);
+    }
+
+    await bookingPage.updateEventType();
+    const eventTypePage = await bookingPage.previewEventType();
+    await bookingPage.selectTimeSlot(eventTypePage);
+    await bookingPage.fillAllQuestions(eventTypePage, allQuestions, {
+      ...bookingOptions,
+      isAllRequired: false,
+    });
+
+    await bookingPage.rescheduleBooking(eventTypePage);
+    await bookingPage.assertBookingRescheduled(eventTypePage);
+    await bookingPage.cancelBooking(eventTypePage);
+    await bookingPage.assertBookingCanceled(eventTypePage);
+  });
+});

apps/web/playwright/booking/checkboxGroupQuestion.e2e.ts

@@ -0,0 +1,445 @@
+import { loginUser } from "../fixtures/regularBookings";
+import { test } from "../lib/fixtures";
+
+test.describe("Booking With Checkbox Group Question and Each Other Question", () => {
+  const bookingOptions = { hasPlaceholder: true, isRequired: true };
+
+  test.beforeEach(async ({ page, users, bookingPage }) => {
+    await loginUser(users);
+    await page.goto("/event-types");
+    await bookingPage.goToEventType("30 min");
+    await bookingPage.goToTab("event_advanced_tab_title");
+  });
+
+  test.describe("Booking With Checkbox Group Question and Address Question", () => {
+    test("Checkbox Group required and Address required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "checkbox",
+        fillText: "Test Checkbox Group question and Address question (both required)",
+        secondQuestion: "address",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Checkbox Group and Address not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+      await bookingPage.addQuestion("address", "address-test", "address test", false, "address test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "checkbox",
+        fillText: "Test Checkbox Group question and Address question (only checkbox required)",
+        secondQuestion: "address",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test.describe("Booking With Checkbox Group Question and Phone Question", () => {
+      test("Checkbox Group required and Phone required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("phone", "phone-test", "phone test", true, "phone test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and phone question (both required)",
+          secondQuestion: "phone",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Checkbox Group and Phone not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("phone", "phone-test", "phone test", false, "phone test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Phone question (only checkbox required)",
+          secondQuestion: "phone",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Checkbox Group Question and checkbox Question", () => {
+      test("Checkbox Group required and checkbox required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", true);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and checkbox question (both required)",
+          secondQuestion: "boolean",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Checkbox Group and checkbox not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", false);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and checkbox (only checkbox required)",
+          secondQuestion: "boolean",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Checkbox Group Question and Long text Question", () => {
+      test("Checkbox Group required and Long text required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", true, "textarea test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Long Text question (both required)",
+          secondQuestion: "textarea",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Checkbox Group and Long text not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", false, "textarea test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Long Text question (only checkbox required)",
+          secondQuestion: "textarea",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Checkbox Group Question and Multi email Question", () => {
+      test("Checkbox Group required and Multi email required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion(
+          "multiemail",
+          "multiemail-test",
+          "multiemail test",
+          true,
+          "multiemail test"
+        );
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Multi Email question (both required)",
+          secondQuestion: "multiemail",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Checkbox Group and Multi email not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion(
+          "multiemail",
+          "multiemail-test",
+          "multiemail test",
+          false,
+          "multiemail test"
+        );
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Multi Email question (only checkbox required)",
+          secondQuestion: "multiemail",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Checkbox Group Question and multiselect Question", () => {
+      test("Checkbox Group required and multiselect text required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", true);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Multi Select question (both required)",
+          secondQuestion: "multiselect",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Checkbox Group and multiselect text not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", false);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Multi Select question (only checkbox required)",
+          secondQuestion: "multiselect",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Checkbox Group Question and Number Question", () => {
+      test("Checkbox Group required and Number required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("number", "number-test", "number test", true, "number test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Number question (both required)",
+          secondQuestion: "number",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Checkbox Group and Number not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("number", "number-test", "number test", false, "number test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Number question (only checkbox required)",
+          secondQuestion: "number",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Checkbox Group Question and Radio group Question", () => {
+      test("Checkbox Group required and Radio group required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Radio question (both required)",
+          secondQuestion: "radio",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Checkbox Group and Radio group not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", false);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Radio question (only checkbox required)",
+          secondQuestion: "radio",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Checkbox Group Question and select Question", () => {
+      test("Checkbox Group required and select required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Select question (both required)",
+          secondQuestion: "select",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Checkbox Group and select not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("select", "select-test", "select test", false, "select test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Select question (only checkbox required)",
+          secondQuestion: "select",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Checkbox Group Question and Short text question", () => {
+      test("Checkbox Group required and Short Text required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("text", "text-test", "text test", true, "text test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Text question (both required)",
+          secondQuestion: "text",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Checkbox Group and Short Text not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.addQuestion("text", "text-test", "text test", false, "text test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "checkbox",
+          fillText: "Test Checkbox Group question and Text question (only checkbox required)",
+          secondQuestion: "text",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+  });
+});

apps/web/playwright/booking/multipleEmailQuestion.e2e.ts

@@ -0,0 +1,553 @@
+import { loginUser } from "../fixtures/regularBookings";
+import { test } from "../lib/fixtures";
+
+test.describe("Booking With Multiple Email Question and Each Other Question", () => {
+  const bookingOptions = { hasPlaceholder: true, isRequired: true };
+
+  test.beforeEach(async ({ page, users, bookingPage }) => {
+    await loginUser(users);
+    await page.goto("/event-types");
+    await bookingPage.goToEventType("30 min");
+    await bookingPage.goToTab("event_advanced_tab_title");
+  });
+
+  test.describe("Booking With Multiple Email Question and Address Question", () => {
+    test("Multiple Email required and Address required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Address question (both required)",
+        secondQuestion: "address",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Multiple Email and Address not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("address", "address-test", "address test", false, "address test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Address question (only Multiple Email required)",
+        secondQuestion: "address",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Multiple Email Question and checkbox group Question", () => {
+    test("Multiple Email required and checkbox group required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and checkbox group question (both required)",
+        secondQuestion: "checkbox",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Multiple Email and checkbox group not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and checkbox group question (only Multiple Email required)",
+        secondQuestion: "checkbox",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Multiple Email Question and checkbox Question", () => {
+    test("Multiple Email required and checkbox required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and checkbox question (both required)",
+        secondQuestion: "boolean",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Multiple Email and checkbox not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and checkbox (only Multiple Email required)",
+        secondQuestion: "boolean",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Multiple Email Question and Long text Question", () => {
+    test("Multiple Email required and Long text required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", true, "textarea test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Long Text question (both required)",
+        secondQuestion: "textarea",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Multiple Email and Long text not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", false, "textarea test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Long Text question (only Multiple Email required)",
+        secondQuestion: "textarea",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Multiple Email Question and multiselect Question", () => {
+    test("Multiple Email required and multiselect text required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Multi Select question (both required)",
+        secondQuestion: "multiselect",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Multiple Email and multiselect text not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Multi Select question (only  Multiple Email required)",
+        secondQuestion: "multiselect",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Multiple Email Question and Number Question", () => {
+    test("Multiple Email required and Number required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("number", "number-test", "number test", true, "number test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Number question (both required)",
+        secondQuestion: "number",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Multiple Email and Number not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("number", "number-test", "number test", false, "number test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Number question (only Multiple Email required)",
+        secondQuestion: "number",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Multiple email Question and phone Question", () => {
+    test("Multiple email required and Phone required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("phone", "phone-test", "phone test", true, "phone test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Phone question (both required)",
+        secondQuestion: "phone",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Multiple email and Phone not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("phone", "phone-test", "phone test", false, "phone test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Phone question (both required)",
+        secondQuestion: "phone",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Multiple Email Question and Radio group Question", () => {
+    test("Multiple Email required and Radio group required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test  Multiple Email question and Radio question (both required)",
+        secondQuestion: "radio",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Multiple Email and Radio group not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.addQuestion("radio", "radio-test", "radio test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "multiemail",
+        fillText: "Test Multiple Email question and Radio question (only  Multiple Email required)",
+        secondQuestion: "radio",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test.describe("Booking With Multiple Email Question and select Question", () => {
+      test("Multiple Email required and select required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion(
+          "multiemail",
+          "multiemail-test",
+          "multiemail test",
+          true,
+          "multiemail test"
+        );
+        await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "multiemail",
+          fillText: "Test Multiple Email question and Select question (both required)",
+          secondQuestion: "select",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Multiple Email and select not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion(
+          "multiemail",
+          "multiemail-test",
+          "multiemail test",
+          true,
+          "multiemail test"
+        );
+        await bookingPage.addQuestion("select", "select-test", "select test", false, "select test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "multiemail",
+          fillText: "Test Multiple Email question and Select question (only Multiple Email required)",
+          secondQuestion: "select",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Multiple Email Question and Short text question", () => {
+      test("Multiple Email required and Short text required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion(
+          "multiemail",
+          "multiemail-test",
+          "multiemail test",
+          true,
+          "multiemail test"
+        );
+        await bookingPage.addQuestion("text", "text-test", "text test", true, "text test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "multiemail",
+          fillText: "Test Multiple Email question and Text question (both required)",
+          secondQuestion: "text",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Multiple Email and Short text not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion(
+          "multiemail",
+          "multiemail-test",
+          "multiemail test",
+          true,
+          "multiemail test"
+        );
+        await bookingPage.addQuestion("text", "text-test", "text test", false, "text test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "multiemail",
+          fillText: "Test Multiple Email question and Text question (only Multiple Email required)",
+          secondQuestion: "text",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+  });
+});

apps/web/playwright/booking/phoneQuestion.e2e.ts

@@ -402,7 +402,6 @@ test.describe("Booking With Phone Question and Each Other Question", () => {
     });
 
     test.describe("Booking With Phone Question and Short text question", () => {
-      const bookingOptions = { hasPlaceholder: true, isRequired: true };
       test("Phone and Short text required", async ({ bookingPage }) => {
         await bookingPage.addQuestion("phone", "phone-test", "phone test", true, "phone test");
         await bookingPage.addQuestion("text", "text-test", "text test", true, "text test");

apps/web/playwright/booking/radioGroupQuestion.e2e.ts

@@ -0,0 +1,444 @@
+import { loginUser } from "../fixtures/regularBookings";
+import { test } from "../lib/fixtures";
+
+test.describe("Booking With Radio Question and Each Other Question", () => {
+  const bookingOptions = { hasPlaceholder: true, isRequired: true };
+
+  test.beforeEach(async ({ page, users, bookingPage }) => {
+    await loginUser(users);
+    await page.goto("/event-types");
+    await bookingPage.goToEventType("30 min");
+    await bookingPage.goToTab("event_advanced_tab_title");
+  });
+
+  test.describe("Booking With Radio Question and Address Question", () => {
+    test("Radio required and Address required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "radio",
+        fillText: "Test Radio question and Address question (both required)",
+        secondQuestion: "address",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Radio and Address not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+      await bookingPage.addQuestion("address", "address-test", "address test", false, "address test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "radio",
+        fillText: "Test Radio question and Address question (only radio required)",
+        secondQuestion: "address",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test.describe("Booking With Radio Question and checkbox group Question", () => {
+      test("Radio required and checkbox group required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and checkbox group question (both required)",
+          secondQuestion: "checkbox",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Radio and checkbox group not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", false);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and checkbox group question (only radio required)",
+          secondQuestion: "checkbox",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Radio Question and checkbox Question", () => {
+      test("Radio required and checkbox required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", true);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and checkbox question (both required)",
+          secondQuestion: "boolean",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+      test("Radio and checkbox not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", false);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and checkbox (only radio required)",
+          secondQuestion: "boolean",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Radio Question and Long text Question", () => {
+      test("Radio required and Long text required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", true, "textarea test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Long Text question (both required)",
+          secondQuestion: "textarea",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Radio and Long text not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", false, "textarea test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Long Text question (only radio required)",
+          secondQuestion: "textarea",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Radio Question and Multi email Question", () => {
+      test("Radio required and Multi email required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion(
+          "multiemail",
+          "multiemail-test",
+          "multiemail test",
+          true,
+          "multiemail test"
+        );
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Multi Email question (both required)",
+          secondQuestion: "multiemail",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Radio and Multi email not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion(
+          "multiemail",
+          "multiemail-test",
+          "multiemail test",
+          false,
+          "multiemail test"
+        );
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Multi Email question (only radio required)",
+          secondQuestion: "multiemail",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Radio Question and multiselect Question", () => {
+      test("Radio required and multiselect text required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", true);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Multi Select question (both required)",
+          secondQuestion: "multiselect",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Radio and multiselect text not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", false);
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Multi Select question (only radio required)",
+          secondQuestion: "multiselect",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Radio Question and Number Question", () => {
+      test("Radio required and Number required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("number", "number-test", "number test", true, "number test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Number question (both required)",
+          secondQuestion: "number",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Radio and Number not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("number", "number-test", "number test", false, "number test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Number question (only radio required)",
+          secondQuestion: "number",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Radio Question and Phone Question", () => {
+      test("Radio required and Phone required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("phone", "phone-test", "phone test", true, "phone test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Phone question (both required)",
+          secondQuestion: "phone",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Radio and Phone not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("phone", "phone-test", "phone test", false, "phone test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Phone question (only radio required)",
+          secondQuestion: "phone",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Radio Question and select Question", () => {
+      test("Radio required and select required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Select question (both required)",
+          secondQuestion: "select",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Radio and select not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("select", "select-test", "select test", false, "select test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Select question (only radio required)",
+          secondQuestion: "select",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+
+    test.describe("Booking With Radio Question and Short text question", () => {
+      test("Radio required and Short text required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("text", "text-test", "text test", true, "text test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Text question (both required)",
+          secondQuestion: "text",
+          options: bookingOptions,
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+
+      test("Radio and Short text not required", async ({ bookingPage }) => {
+        await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+        await bookingPage.addQuestion("text", "text-test", "text test", false, "text test");
+        await bookingPage.updateEventType();
+        const eventTypePage = await bookingPage.previewEventType();
+        await bookingPage.selectTimeSlot(eventTypePage);
+        await bookingPage.fillAndConfirmBooking({
+          eventTypePage,
+          placeholderText: "Please share anything that will help prepare for our meeting.",
+          question: "radio",
+          fillText: "Test Radio question and Text question (only radio required)",
+          secondQuestion: "text",
+          options: { ...bookingOptions, isRequired: false },
+        });
+        await bookingPage.rescheduleBooking(eventTypePage);
+        await bookingPage.assertBookingRescheduled(eventTypePage);
+        await bookingPage.cancelBooking(eventTypePage);
+        await bookingPage.assertBookingCanceled(eventTypePage);
+      });
+    });
+  });
+});

apps/web/playwright/booking/selectQuestion.e2e.ts

@@ -0,0 +1,441 @@
+import { loginUser } from "../fixtures/regularBookings";
+import { test } from "../lib/fixtures";
+
+test.describe("Booking With Phone Question and Each Other Question", () => {
+  const bookingOptions = { hasPlaceholder: true, isRequired: true };
+
+  test.beforeEach(async ({ page, users, bookingPage }) => {
+    await loginUser(users);
+    await page.goto("/event-types");
+    await bookingPage.goToEventType("30 min");
+    await bookingPage.goToTab("event_advanced_tab_title");
+  });
+
+  test.describe("Booking With Select Question and Address Question", () => {
+    test("Select required and Address required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("address", "address-test", "address test", true, "address test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and Address question (both required)",
+        secondQuestion: "address",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and Address not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("address", "address-test", "address test", false, "address test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and Address question (only select required)",
+        secondQuestion: "address",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Select Question and checkbox group Question", () => {
+    test("Select required and checkbox group required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and Checkbox question (both required)",
+        secondQuestion: "checkbox",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and checkbox group not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("checkbox", "checkbox-test", "checkbox test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and Checkbox question (only Select required)",
+        secondQuestion: "checkbox",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Select Question and checkbox Question", () => {
+    test("Select required and checkbox required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and boolean question (both required)",
+        secondQuestion: "boolean",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and checkbox not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("boolean", "boolean-test", "boolean test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and boolean question (only select required)",
+        secondQuestion: "boolean",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Select Question and Long text Question", () => {
+    test("Select required and Long text required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", true, "textarea test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and textarea question (both required)",
+        secondQuestion: "textarea",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and Long text not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("textarea", "textarea-test", "textarea test", false, "textarea test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and textarea question (only select required)",
+        secondQuestion: "textarea",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Select Question and Multi email Question", () => {
+    test("Select required and Multi email required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        true,
+        "multiemail test"
+      );
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and multiemail question (both required)",
+        secondQuestion: "multiemail",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and Multi email not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion(
+        "multiemail",
+        "multiemail-test",
+        "multiemail test",
+        false,
+        "multiemail test"
+      );
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and multiemail question (only select required)",
+        secondQuestion: "multiemail",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Select Question and multiselect Question", () => {
+    test("Select required and multiselect text required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and multiselect question (both required)",
+        secondQuestion: "multiselect",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and multiselect text not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("multiselect", "multiselect-test", "multiselect test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and multiselect question (only select required)",
+        secondQuestion: "multiselect",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Select Question and Number Question", () => {
+    test("Select required and Number required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("number", "number-test", "number test", true, "number test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and number question (both required)",
+        secondQuestion: "number",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and Number not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("number", "number-test", "number test", false, "number test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and number question (only select required)",
+        secondQuestion: "number",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Select Question and Phone Question", () => {
+    test("Select required and select required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("phone", "phone-test", "phone test", true, "phone test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and phone question (both required)",
+        secondQuestion: "phone",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and Phone not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("phone", "phone-test", "phone test", false, "phone test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and phone question (only select required)",
+        secondQuestion: "phone",
+        options: { ...bookingOptions, isRequired: false },
+      });
+    });
+  });
+
+  test.describe("Booking With Select Question and Radio group Question", () => {
+    test("Select required and Radio group required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("radio", "radio-test", "radio test", true);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and radio question (both required)",
+        secondQuestion: "radio",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and Radio group not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("radio", "radio-test", "radio test", false);
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and radio question (only select required)",
+        secondQuestion: "radio",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+
+  test.describe("Booking With Select Question and Short text question", () => {
+    test("Select required and Short text required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("text", "text-test", "text test", true, "text test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and text question (both required)",
+        secondQuestion: "text",
+        options: bookingOptions,
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+
+    test("Select and Short text not required", async ({ bookingPage }) => {
+      await bookingPage.addQuestion("select", "select-test", "select test", true, "select test");
+      await bookingPage.addQuestion("text", "text-test", "text test", false, "text test");
+      await bookingPage.updateEventType();
+      const eventTypePage = await bookingPage.previewEventType();
+      await bookingPage.selectTimeSlot(eventTypePage);
+      await bookingPage.fillAndConfirmBooking({
+        eventTypePage,
+        placeholderText: "Please share anything that will help prepare for our meeting.",
+        question: "select",
+        fillText: "Test Select question and text question (only select required)",
+        secondQuestion: "text",
+        options: { ...bookingOptions, isRequired: false },
+      });
+      await bookingPage.rescheduleBooking(eventTypePage);
+      await bookingPage.assertBookingRescheduled(eventTypePage);
+      await bookingPage.cancelBooking(eventTypePage);
+      await bookingPage.assertBookingCanceled(eventTypePage);
+    });
+  });
+});

apps/web/playwright/event-types.e2e.ts

@@ -254,6 +254,87 @@ test.describe("Event Types tests", () => {
         await expect(page.locator("[data-testid=success-page]")).toBeVisible();
         await expect(page.locator("[data-testid=where]")).toHaveText(/Cal Video/);
       });
+
+      test("can add single organizer address location without display location public option", async ({
+        page,
+      }) => {
+        const $eventTypes = page.locator("[data-testid=event-types] > li a");
+        const firstEventTypeElement = $eventTypes.first();
+        await firstEventTypeElement.click();
+        await page.waitForURL((url) => {
+          return !!url.pathname.match(/\/event-types\/.+/);
+        });
+
+        const locationAddress = "New Delhi";
+
+        await fillLocation(page, locationAddress, 0, false);
+        await page.locator("[data-testid=update-eventtype]").click();
+
+        await page.goto("/event-types");
+
+        const previewLink = await page
+          .locator("[data-testid=preview-link-button]")
+          .first()
+          .getAttribute("href");
+
+        await page.goto(previewLink ?? "");
+        await selectFirstAvailableTimeSlotNextMonth(page);
+        await bookTimeSlot(page);
+        await expect(page.locator("[data-testid=success-page]")).toBeVisible();
+        await expect(page.locator(`[data-testid="where"]`)).toHaveText(locationAddress);
+      });
+
+      test("can select 'display on booking page' option when multiple organizer input type are present", async ({
+        page,
+      }) => {
+        await gotoFirstEventType(page);
+
+        await page.locator("#location-select").click();
+        await page.locator(`text="Link meeting"`).click();
+
+        const locationInputName = (idx: number) => `locations[${idx}].link`;
+
+        const testUrl1 = "https://cal.ai/";
+        await page.locator(`input[name="${locationInputName(0)}"]`).fill(testUrl1);
+        await page.locator("[data-testid=display-location]").last().check();
+        await checkDisplayLocation(page);
+        await unCheckDisplayLocation(page);
+
+        await page.locator("[data-testid=add-location]").click();
+
+        const testUrl2 = "https://cal.com/ai";
+        await page.locator(`text="Link meeting"`).last().click();
+        await page.locator(`input[name="${locationInputName(1)}"]`).waitFor();
+        await page.locator(`input[name="${locationInputName(1)}"]`).fill(testUrl2);
+        await checkDisplayLocation(page);
+        await unCheckDisplayLocation(page);
+
+        // Remove Both of the locations
+        const removeButtomId = "delete-locations.0.type";
+        await page.getByTestId(removeButtomId).click();
+        await page.getByTestId(removeButtomId).click();
+
+        // Add Multiple Organizer Phone Number options
+        await page.locator("#location-select").click();
+        await page.locator(`text="Organizer Phone Number"`).click();
+
+        const organizerPhoneNumberInputName = (idx: number) => `locations[${idx}].hostPhoneNumber`;
+
+        const testPhoneInputValue1 = "9199999999";
+        await page.locator(`input[name="${organizerPhoneNumberInputName(0)}"]`).waitFor();
+        await page.locator(`input[name="${organizerPhoneNumberInputName(0)}"]`).fill(testPhoneInputValue1);
+        await page.locator("[data-testid=display-location]").last().check();
+        await checkDisplayLocation(page);
+        await unCheckDisplayLocation(page);
+        await page.locator("[data-testid=add-location]").click();
+
+        const testPhoneInputValue2 = "9188888888";
+        await page.locator(`text="Organizer Phone Number"`).last().click();
+        await page.locator(`input[name="${organizerPhoneNumberInputName(1)}"]`).waitFor();
+        await page.locator(`input[name="${organizerPhoneNumberInputName(1)}"]`).fill(testPhoneInputValue2);
+        await checkDisplayLocation(page);
+        await unCheckDisplayLocation(page);
+      });
     });
   });
 });
@@ -293,7 +374,7 @@ async function addAnotherLocation(page: Page, locationOptionText: string) {
   await page.locator(`text="${locationOptionText}"`).click();
 }
 
-const fillLocation = async (page: Page, inputText: string, index: number) => {
+const fillLocation = async (page: Page, inputText: string, index: number, selectDisplayLocation = true) => {
   // Except the first location, dropdown automatically opens when adding another location
   if (index == 0) {
     await page.locator("#location-select").last().click();
@@ -303,5 +384,17 @@ const fillLocation = async (page: Page, inputText: string, index: number) => {
   const locationInputName = `locations[${index}].address`;
   await page.locator(`input[name="${locationInputName}"]`).waitFor();
   await page.locator(`input[name="locations[${index}].address"]`).fill(inputText);
-  await page.locator("[data-testid=display-location]").last().check();
+  if (selectDisplayLocation) {
+    await page.locator("[data-testid=display-location]").last().check();
+  }
+};
+
+const checkDisplayLocation = async (page: Page) => {
+  await page.locator("[data-testid=display-location]").last().check();
+  await expect(page.locator("[data-testid=display-location]").last()).toBeChecked();
+};
+
+const unCheckDisplayLocation = async (page: Page) => {
+  await page.locator("[data-testid=display-location]").last().uncheck();
+  await expect(page.locator("[data-testid=display-location]").last()).toBeChecked({ checked: false });
 };

apps/web/playwright/fixtures/orgs.ts

@@ -0,0 +1,56 @@
+import type { Page } from "@playwright/test";
+import type { Team } from "@prisma/client";
+
+import { prisma } from "@calcom/prisma";
+
+const getRandomSlug = () => `org-${Math.random().toString(36).substring(7)}`;
+
+// creates a user fixture instance and stores the collection
+export const createOrgsFixture = (page: Page) => {
+  const store = { orgs: [], page } as { orgs: Team[]; page: typeof page };
+  return {
+    create: async (opts: { name: string; slug?: string; requestedSlug?: string }) => {
+      const org = await createOrgInDb({
+        name: opts.name,
+        slug: opts.slug || getRandomSlug(),
+        requestedSlug: opts.requestedSlug,
+      });
+      store.orgs.push(org);
+      return org;
+    },
+    get: () => store.orgs,
+    deleteAll: async () => {
+      await prisma.team.deleteMany({ where: { id: { in: store.orgs.map((org) => org.id) } } });
+      store.orgs = [];
+    },
+    delete: async (id: number) => {
+      await prisma.team.delete({ where: { id } });
+      store.orgs = store.orgs.filter((b) => b.id !== id);
+    },
+  };
+};
+
+async function createOrgInDb({
+  name,
+  slug,
+  requestedSlug,
+}: {
+  name: string;
+  slug: string | null;
+  requestedSlug?: string;
+}) {
+  return await prisma.team.create({
+    data: {
+      name: name,
+      slug: slug,
+      metadata: {
+        isOrganization: true,
+        ...(requestedSlug
+          ? {
+              requestedSlug,
+            }
+          : null),
+      },
+    },
+  });
+}

apps/web/playwright/fixtures/regularBookings.ts

@@ -1,5 +1,7 @@
 import { expect, type Page } from "@playwright/test";
 
+import dayjs from "@calcom/dayjs";
+
 import type { createUsersFixture } from "./users";
 
 const reschedulePlaceholderText = "Let others know why you need to reschedule";
@@ -13,6 +15,8 @@ type BookingOptions = {
   hasPlaceholder?: boolean;
   isReschedule?: boolean;
   isRequired?: boolean;
+  isAllRequired?: boolean;
+  isMultiSelect?: boolean;
 };
 
 interface QuestionActions {
@@ -37,6 +41,12 @@ type fillAndConfirmBookingParams = {
 
 type UserFixture = ReturnType<typeof createUsersFixture>;
 
+function isLastDayOfMonth(): boolean {
+  const today = dayjs();
+  const endOfMonth = today.endOf("month");
+  return today.isSame(endOfMonth, "day");
+}
+
 const fillQuestion = async (eventTypePage: Page, questionType: string, customLocators: customLocators) => {
   const questionActions: QuestionActions = {
     phone: async () => {
@@ -102,17 +112,82 @@ const fillQuestion = async (eventTypePage: Page, questionType: string, customLoc
       await eventTypePage.getByPlaceholder(`${questionType} test`).fill("text test");
     },
   };
-
   if (questionActions[questionType]) {
     await questionActions[questionType]();
   }
 };
 
+const fillAllQuestions = async (eventTypePage: Page, questions: string[], options: BookingOptions) => {
+  if (options.isAllRequired) {
+    for (const question of questions) {
+      switch (question) {
+        case "email":
+          await eventTypePage.getByPlaceholder("Email").click();
+          await eventTypePage.getByPlaceholder("Email").fill(EMAIL);
+          break;
+        case "phone":
+          await eventTypePage.getByPlaceholder("Phone test").click();
+          await eventTypePage.getByPlaceholder("Phone test").fill(PHONE);
+          break;
+        case "address":
+          await eventTypePage.getByPlaceholder("Address test").click();
+          await eventTypePage.getByPlaceholder("Address test").fill("123 Main St, City, Country");
+          break;
+        case "textarea":
+          await eventTypePage.getByPlaceholder("Textarea test").click();
+          await eventTypePage.getByPlaceholder("Textarea test").fill("This is a sample text for textarea.");
+          break;
+        case "select":
+          await eventTypePage.locator("form svg").last().click();
+          await eventTypePage.getByTestId("select-option-Option 1").click();
+          break;
+        case "multiselect":
+          await eventTypePage.locator("form svg").nth(4).click();
+          await eventTypePage.getByTestId("select-option-Option 1").click();
+          break;
+        case "number":
+          await eventTypePage.getByLabel("number test").click();
+          await eventTypePage.getByLabel("number test").fill("123");
+          break;
+        case "radio":
+          await eventTypePage.getByRole("radiogroup").getByText("Option 1").check();
+          break;
+        case "text":
+          await eventTypePage.getByPlaceholder("Text test").click();
+          await eventTypePage.getByPlaceholder("Text test").fill("Sample text");
+          break;
+        case "checkbox":
+          await eventTypePage.getByLabel("Option 1").first().check();
+          await eventTypePage.getByLabel("Option 2").first().check();
+          break;
+        case "boolean":
+          await eventTypePage.getByLabel(`${question} test`).check();
+          break;
+        case "multiemail":
+          await eventTypePage.getByRole("button", { name: "multiemail test" }).click();
+          await eventTypePage.getByPlaceholder("multiemail test").fill(EMAIL);
+          break;
+      }
+    }
+  }
+};
+
 export async function loginUser(users: UserFixture) {
   const pro = await users.create({ name: "testuser" });
   await pro.apiLogin();
 }
 
+const goToNextMonthIfNoAvailabilities = async (eventTypePage: Page) => {
+  try {
+    if (isLastDayOfMonth()) {
+      await eventTypePage.getByTestId("view_next_month").waitFor({ timeout: 6000 });
+      await eventTypePage.getByTestId("view_next_month").click();
+    }
+  } catch (err) {
+    console.info("No need to click on view next month button");
+  }
+};
+
 export function createBookingPageFixture(page: Page) {
   return {
     goToEventType: async (eventType: string) => {
@@ -153,22 +228,17 @@ export function createBookingPageFixture(page: Page) {
       return eventtypePromise;
     },
     selectTimeSlot: async (eventTypePage: Page) => {
-      while (await eventTypePage.getByRole("button", { name: "View next" }).isVisible()) {
-        await eventTypePage.getByRole("button", { name: "View next" }).click();
-      }
+      await goToNextMonthIfNoAvailabilities(eventTypePage);
       await eventTypePage.getByTestId("time").first().click();
     },
     clickReschedule: async () => {
       await page.getByText("Reschedule").click();
     },
-    navigateToAvailableTimeSlot: async () => {
-      while (await page.getByRole("button", { name: "View next" }).isVisible()) {
-        await page.getByRole("button", { name: "View next" }).click();
-      }
-    },
+
     selectFirstAvailableTime: async () => {
       await page.getByTestId("time").first().click();
     },
+
     fillRescheduleReasonAndConfirm: async () => {
       await page.getByPlaceholder(reschedulePlaceholderText).click();
       await page.getByPlaceholder(reschedulePlaceholderText).fill("Test reschedule");
@@ -185,6 +255,7 @@ export function createBookingPageFixture(page: Page) {
     },
 
     rescheduleBooking: async (eventTypePage: Page) => {
+      await goToNextMonthIfNoAvailabilities(eventTypePage);
       await eventTypePage.getByText("Reschedule").click();
       while (await eventTypePage.getByRole("button", { name: "View next" }).isVisible()) {
         await eventTypePage.getByRole("button", { name: "View next" }).click();
@@ -193,6 +264,14 @@ export function createBookingPageFixture(page: Page) {
       await eventTypePage.getByPlaceholder(reschedulePlaceholderText).click();
       await eventTypePage.getByPlaceholder(reschedulePlaceholderText).fill("Test reschedule");
       await eventTypePage.getByTestId("confirm-reschedule-button").click();
+      await eventTypePage.waitForTimeout(400);
+      if (
+        await eventTypePage.getByRole("heading", { name: "Could not reschedule the meeting." }).isVisible()
+      ) {
+        await eventTypePage.getByTestId("back").click();
+        await eventTypePage.getByTestId("time").last().click();
+        await eventTypePage.getByTestId("confirm-reschedule-button").click();
+      }
     },
 
     assertBookingRescheduled: async (page: Page) => {
@@ -221,7 +300,7 @@ export function createBookingPageFixture(page: Page) {
 
       // Change the selector for specifics cases related to select question
       const shouldChangeSelectLocator = (question: string, secondQuestion: string): boolean =>
-        question === "select" && ["multiemail", "multiselect"].includes(secondQuestion);
+        question === "select" && ["multiemail", "multiselect", "address"].includes(secondQuestion);
 
       const shouldUseLastRadioGroupLocator = (question: string, secondQuestion: string): boolean =>
         question === "radio" && secondQuestion === "checkbox";
@@ -247,6 +326,32 @@ export function createBookingPageFixture(page: Page) {
       options.isRequired && (await fillQuestion(eventTypePage, secondQuestion, customLocators));
 
       await eventTypePage.getByTestId(confirmButton).click();
+      await eventTypePage.waitForTimeout(400);
+      if (await eventTypePage.getByRole("heading", { name: "Could not book the meeting." }).isVisible()) {
+        await eventTypePage.getByTestId("back").click();
+        await eventTypePage.getByTestId("time").last().click();
+        await fillQuestion(eventTypePage, question, customLocators);
+        options.isRequired && (await fillQuestion(eventTypePage, secondQuestion, customLocators));
+        await eventTypePage.getByTestId(confirmButton).click();
+      }
+      const scheduleSuccessfullyPage = eventTypePage.getByText(scheduleSuccessfullyText);
+      await scheduleSuccessfullyPage.waitFor({ state: "visible" });
+      await expect(scheduleSuccessfullyPage).toBeVisible();
+    },
+    checkField: async (question: string) => {
+      await expect(page.getByTestId(`field-${question}-test`)).toBeVisible();
+    },
+    fillAllQuestions: async (eventTypePage: Page, questions: string[], options: BookingOptions) => {
+      const confirmButton = options.isReschedule ? "confirm-reschedule-button" : "confirm-book-button";
+      await fillAllQuestions(eventTypePage, questions, options);
+      await eventTypePage.getByTestId(confirmButton).click();
+      await eventTypePage.waitForTimeout(400);
+      if (await eventTypePage.getByRole("heading", { name: "Could not book the meeting." }).isVisible()) {
+        await eventTypePage.getByTestId("back").click();
+        await eventTypePage.getByTestId("time").last().click();
+        await fillAllQuestions(eventTypePage, questions, options);
+        await eventTypePage.getByTestId(confirmButton).click();
+      }
       const scheduleSuccessfullyPage = eventTypePage.getByText(scheduleSuccessfullyText);
       await scheduleSuccessfullyPage.waitFor({ state: "visible" });
       await expect(scheduleSuccessfullyPage).toBeVisible();

apps/web/playwright/fixtures/users.ts

@@ -9,6 +9,8 @@ import { DEFAULT_SCHEDULE, getAvailabilityFromSchedule } from "@calcom/lib/avail
 import { WEBAPP_URL } from "@calcom/lib/constants";
 import { prisma } from "@calcom/prisma";
 import { MembershipRole, SchedulingType } from "@calcom/prisma/enums";
+import { teamMetadataSchema } from "@calcom/prisma/zod-utils";
+import type { Schedule } from "@calcom/types/schedule";
 
 import { selectFirstAvailableTimeSlotNextMonth, teamEventSlug, teamEventTitle } from "../lib/testUtils";
 import { TimeZoneEnum } from "./types";
@@ -45,6 +47,7 @@ const createTeamEventType = async (
     schedulingType?: SchedulingType;
     teamEventTitle?: string;
     teamEventSlug?: string;
+    teamEventLength?: number;
   }
 ) => {
   return await prisma.eventType.create({
@@ -64,10 +67,16 @@ const createTeamEventType = async (
           id: user.id,
         },
       },
+      hosts: {
+        create: {
+          userId: user.id,
+          isFixed: scenario?.schedulingType === SchedulingType.COLLECTIVE ? true : false,
+        },
+      },
       schedulingType: scenario?.schedulingType ?? SchedulingType.COLLECTIVE,
       title: scenario?.teamEventTitle ?? `${teamEventTitle}-team-id-${team.id}`,
       slug: scenario?.teamEventSlug ?? `${teamEventSlug}-team-id-${team.id}`,
-      length: 30,
+      length: scenario?.teamEventLength ?? 30,
     },
   });
 };
@@ -78,11 +87,13 @@ const createTeamAndAddUser = async (
     isUnpublished,
     isOrg,
     hasSubteam,
+    organizationId,
   }: {
     user: { id: number; username: string | null; role?: MembershipRole };
     isUnpublished?: boolean;
     isOrg?: boolean;
     hasSubteam?: true;
+    organizationId?: number | null;
   },
   workerInfo: WorkerInfo
 ) => {
@@ -101,6 +112,7 @@ const createTeamAndAddUser = async (
     data.children = { connect: [{ id: team.id }] };
   }
   data.orgUsers = isOrg ? { connect: [{ id: user.id }] } : undefined;
+  data.parent = organizationId ? { connect: { id: organizationId } } : undefined;
   const team = await prisma.team.create({
     data,
   });
@@ -114,6 +126,7 @@ const createTeamAndAddUser = async (
       accepted: true,
     },
   });
+
   return team;
 };
 
@@ -130,6 +143,7 @@ export const createUsersFixture = (page: Page, emails: API | undefined, workerIn
         schedulingType?: SchedulingType;
         teamEventTitle?: string;
         teamEventSlug?: string;
+        teamEventLength?: number;
         isOrg?: boolean;
         hasSubteam?: true;
         isUnpublished?: true;
@@ -282,6 +296,7 @@ export const createUsersFixture = (page: Page, emails: API | undefined, workerIn
             isUnpublished: scenario.isUnpublished,
             isOrg: scenario.isOrg,
             hasSubteam: scenario.hasSubteam,
+            organizationId: opts?.organizationId,
           },
           workerInfo
         );
@@ -399,11 +414,27 @@ const createUserFixture = (user: UserWithIncludes, page: Page) => {
     logout: async () => {
       await page.goto("/auth/logout");
     },
-    getTeam: async () => {
-      return prisma.membership.findFirstOrThrow({
+    getFirstTeam: async () => {
+      const memberships = await prisma.membership.findMany({
         where: { userId: user.id },
         include: { team: true },
       });
+
+      const membership = memberships
+        .map((membership) => {
+          return {
+            ...membership,
+            team: {
+              ...membership.team,
+              metadata: teamMetadataSchema.parse(membership.team.metadata),
+            },
+          };
+        })
+        .find((membership) => !membership.team?.metadata?.isOrganization);
+      if (!membership) {
+        throw new Error("No team found for user");
+      }
+      return membership;
     },
     getOrg: async () => {
       return prisma.membership.findFirstOrThrow({
@@ -453,16 +484,28 @@ const createUserFixture = (user: UserWithIncludes, page: Page) => {
 type SupportedTestEventTypes = PrismaType.EventTypeCreateInput & {
   _bookings?: PrismaType.BookingCreateInput[];
 };
-type CustomUserOptsKeys = "username" | "password" | "completedOnboarding" | "locale" | "name" | "email";
+type CustomUserOptsKeys =
+  | "username"
+  | "password"
+  | "completedOnboarding"
+  | "locale"
+  | "name"
+  | "email"
+  | "organizationId";
 type CustomUserOpts = Partial<Pick<Prisma.User, CustomUserOptsKeys>> & {
   timeZone?: TimeZoneEnum;
   eventTypes?: SupportedTestEventTypes[];
   // ignores adding the worker-index after username
   useExactUsername?: boolean;
+  roleInOrganization?: MembershipRole;
+  schedule?: Schedule;
 };
 
 // creates the actual user in the db.
-const createUser = (workerInfo: WorkerInfo, opts?: CustomUserOpts | null): PrismaType.UserCreateInput => {
+const createUser = (
+  workerInfo: WorkerInfo,
+  opts?: CustomUserOpts | null
+): PrismaType.UserUncheckedCreateInput => {
   // build a unique name for our user
   const uname =
     opts?.useExactUsername && opts?.username
@@ -478,6 +521,7 @@ const createUser = (workerInfo: WorkerInfo, opts?: CustomUserOpts | null): Prism
     completedOnboarding: opts?.completedOnboarding ?? true,
     timeZone: opts?.timeZone ?? TimeZoneEnum.UK,
     locale: opts?.locale ?? "en",
+    ...getOrganizationRelatedProps({ organizationId: opts?.organizationId, role: opts?.roleInOrganization }),
     schedules:
       opts?.completedOnboarding ?? true
         ? {
@@ -486,13 +530,49 @@ const createUser = (workerInfo: WorkerInfo, opts?: CustomUserOpts | null): Prism
               timeZone: opts?.timeZone ?? TimeZoneEnum.UK,
               availability: {
                 createMany: {
-                  data: getAvailabilityFromSchedule(DEFAULT_SCHEDULE),
+                  data: getAvailabilityFromSchedule(opts?.schedule ?? DEFAULT_SCHEDULE),
                 },
               },
             },
           }
         : undefined,
   };
+
+  function getOrganizationRelatedProps({
+    organizationId,
+    role,
+  }: {
+    organizationId: number | null | undefined;
+    role: MembershipRole | undefined;
+  }) {
+    if (!organizationId) {
+      return null;
+    }
+    if (!role) {
+      throw new Error("Missing role for user in organization");
+    }
+    return {
+      organizationId: organizationId || null,
+      ...(organizationId
+        ? {
+            teams: {
+              // Create membership
+              create: [
+                {
+                  team: {
+                    connect: {
+                      id: organizationId,
+                    },
+                  },
+                  accepted: true,
+                  role: MembershipRole.ADMIN,
+                },
+              ],
+            },
+          }
+        : null),
+    };
+  }
 };
 
 async function confirmPendingPayment(page: Page) {

apps/web/playwright/lib/fixtures.ts

@@ -9,6 +9,7 @@ import prisma from "@calcom/prisma";
 import type { ExpectedUrlDetails } from "../../../../playwright.config";
 import { createBookingsFixture } from "../fixtures/bookings";
 import { createEmbedsFixture } from "../fixtures/embeds";
+import { createOrgsFixture } from "../fixtures/orgs";
 import { createPaymentsFixture } from "../fixtures/payments";
 import { createBookingPageFixture } from "../fixtures/regularBookings";
 import { createRoutingFormsFixture } from "../fixtures/routingForms";
@@ -17,6 +18,7 @@ import { createUsersFixture } from "../fixtures/users";
 
 export interface Fixtures {
   page: Page;
+  orgs: ReturnType<typeof createOrgsFixture>;
   users: ReturnType<typeof createUsersFixture>;
   bookings: ReturnType<typeof createBookingsFixture>;
   payments: ReturnType<typeof createPaymentsFixture>;
@@ -48,6 +50,10 @@ declare global {
  *  @see https://playwright.dev/docs/test-fixtures
  */
 export const test = base.extend<Fixtures>({
+  orgs: async ({ page }, use) => {
+    const orgsFixture = createOrgsFixture(page);
+    await use(orgsFixture);
+  },
   users: async ({ page, context, emails }, use, workerInfo) => {
     const usersFixture = createUsersFixture(page, emails, workerInfo);
     await use(usersFixture);

apps/web/playwright/locale.e2e.ts

@@ -150,14 +150,14 @@ test.describe("unauthorized user sees correct translations (pt)", async () => {
 
 test.describe("unauthorized user sees correct translations (pt-br)", async () => {
   test.use({
-    locale: "pt-br",
+    locale: "pt-BR",
   });
 
   test("should use correct translations and html attributes", async ({ page }) => {
     await page.goto("/");
     await page.waitForLoadState("load");
 
-    await page.locator("html[lang=pt-br]").waitFor({ state: "attached" });
+    await page.locator("html[lang=pt-BR]").waitFor({ state: "attached" });
     await page.locator("html[dir=ltr]").waitFor({ state: "attached" });
 
     {
@@ -181,7 +181,8 @@ test.describe("unauthorized user sees correct translations (es-419)", async () =
     await page.goto("/");
     await page.waitForLoadState("load");
 
-    await page.locator("html[lang=es-419]").waitFor({ state: "attached" });
+    // es-419 is disabled in i18n config, so es should be used as fallback
+    await page.locator("html[lang=es]").waitFor({ state: "attached" });
     await page.locator("html[dir=ltr]").waitFor({ state: "attached" });
 
     {

apps/web/playwright/teams.e2e.ts

@@ -1,16 +1,16 @@
+import type { Page } from "@playwright/test";
 import { expect } from "@playwright/test";
 
 import { prisma } from "@calcom/prisma";
-import { SchedulingType } from "@calcom/prisma/enums";
+import { MembershipRole, SchedulingType } from "@calcom/prisma/enums";
 
 import { test } from "./lib/fixtures";
 import { bookTimeSlot, selectFirstAvailableTimeSlotNextMonth, testName, todo } from "./lib/testUtils";
 
 test.describe.configure({ mode: "parallel" });
 
-test.afterEach(({ users }) => users.deleteAll());
-
-test.describe("Teams", () => {
+test.describe("Teams - NonOrg", () => {
+  test.afterEach(({ users }) => users.deleteAll());
   test("Can create teams via Wizard", async ({ page, users }) => {
     const user = await users.create();
     const inviteeEmail = `${user.username}+invitee@example.com`;
@@ -64,6 +64,7 @@ test.describe("Teams", () => {
       // await expect(page.locator('[data-testid="empty-screen"]')).toBeVisible();
     });
   });
+
   test("Can create a booking for Collective EventType", async ({ page, users }) => {
     const ownerObj = { username: "pro-user", name: "pro-user" };
     const teamMatesObj = [
@@ -78,7 +79,7 @@ test.describe("Teams", () => {
       teammates: teamMatesObj,
       schedulingType: SchedulingType.COLLECTIVE,
     });
-    const { team } = await owner.getTeam();
+    const { team } = await owner.getFirstTeam();
     const { title: teamEventTitle, slug: teamEventSlug } = await owner.getFirstTeamEvent(team.id);
 
     await page.goto(`/team/${team.slug}/${teamEventSlug}`);
@@ -99,6 +100,7 @@ test.describe("Teams", () => {
 
     // TODO: Assert whether the user received an email
   });
+
   test("Can create a booking for Round Robin EventType", async ({ page, users }) => {
     const ownerObj = { username: "pro-user", name: "pro-user" };
     const teamMatesObj = [
@@ -113,7 +115,7 @@ test.describe("Teams", () => {
       schedulingType: SchedulingType.ROUND_ROBIN,
     });
 
-    const { team } = await owner.getTeam();
+    const { team } = await owner.getFirstTeam();
     const { title: teamEventTitle, slug: teamEventSlug } = await owner.getFirstTeamEvent(team.id);
 
     await page.goto(`/team/${team.slug}/${teamEventSlug}`);
@@ -132,9 +134,10 @@ test.describe("Teams", () => {
     // Anyone of the teammates could be the Host of the booking.
     const chosenUser = await page.getByTestId("booking-host-name").textContent();
     expect(chosenUser).not.toBeNull();
-    expect(teamMatesObj.some(({ name }) => name === chosenUser)).toBe(true);
+    expect(teamMatesObj.concat([{ name: ownerObj.name }]).some(({ name }) => name === chosenUser)).toBe(true);
     // TODO: Assert whether the user received an email
   });
+
   test("Non admin team members cannot create team in org", async ({ page, users }) => {
     const teamMateName = "teammate-1";
 
@@ -169,6 +172,7 @@ test.describe("Teams", () => {
       await prisma.team.delete({ where: { id: org.teamId } });
     }
   });
+
   test("Can create team with same name as user", async ({ page, users }) => {
     // Name to be used for both user and team
     const uniqueName = "test-unique-name";
@@ -210,6 +214,7 @@ test.describe("Teams", () => {
       await prisma.team.delete({ where: { id: team?.id } });
     });
   });
+
   test("Can create a private team", async ({ page, users }) => {
     const ownerObj = { username: "pro-user", name: "pro-user" };
     const teamMatesObj = [
@@ -226,7 +231,7 @@ test.describe("Teams", () => {
     });
 
     await owner.apiLogin();
-    const { team } = await owner.getTeam();
+    const { team } = await owner.getFirstTeam();
 
     // Mark team as private
     await page.goto(`/settings/teams/${team.id}/members`);
@@ -247,3 +252,180 @@ test.describe("Teams", () => {
   todo("Reschedule a Collective EventType booking");
   todo("Reschedule a Round Robin EventType booking");
 });
+
+test.describe("Teams - Org", () => {
+  test.afterEach(({ orgs, users }) => {
+    orgs.deleteAll();
+    users.deleteAll();
+  });
+
+  test("Can create teams via Wizard", async ({ page, users, orgs }) => {
+    const org = await orgs.create({
+      name: "TestOrg",
+    });
+    const user = await users.create({
+      organizationId: org.id,
+      roleInOrganization: MembershipRole.ADMIN,
+    });
+    const inviteeEmail = `${user.username}+invitee@example.com`;
+    await user.apiLogin();
+    await page.goto("/teams");
+
+    await test.step("Can create team", async () => {
+      // Click text=Create Team
+      await page.locator("text=Create a new Team").click();
+      await page.waitForURL((url) => url.pathname === "/settings/teams/new");
+      // Fill input[name="name"]
+      await page.locator('input[name="name"]').fill(`${user.username}'s Team`);
+      // Click text=Continue
+      await page.locator("text=Continue").click();
+      await page.waitForURL(/\/settings\/teams\/(\d+)\/onboard-members$/i);
+      await page.waitForSelector('[data-testid="pending-member-list"]');
+      expect(await page.locator('[data-testid="pending-member-item"]').count()).toBe(1);
+    });
+
+    await test.step("Can add members", async () => {
+      // Click [data-testid="new-member-button"]
+      await page.locator('[data-testid="new-member-button"]').click();
+      // Fill [placeholder="email\@example\.com"]
+      await page.locator('[placeholder="email\\@example\\.com"]').fill(inviteeEmail);
+      // Click [data-testid="invite-new-member-button"]
+      await page.locator('[data-testid="invite-new-member-button"]').click();
+      await expect(page.locator(`li:has-text("${inviteeEmail}")`)).toBeVisible();
+      expect(await page.locator('[data-testid="pending-member-item"]').count()).toBe(2);
+    });
+
+    await test.step("Can remove members", async () => {
+      expect(await page.locator('[data-testid="pending-member-item"]').count()).toBe(2);
+
+      const lastRemoveMemberButton = page.locator('[data-testid="remove-member-button"]').last();
+      await lastRemoveMemberButton.click();
+      await page.waitForLoadState("networkidle");
+      expect(await page.locator('[data-testid="pending-member-item"]').count()).toBe(1);
+
+      // Cleanup here since this user is created without our fixtures.
+      await prisma.user.delete({ where: { email: inviteeEmail } });
+    });
+
+    await test.step("Can finish team creation", async () => {
+      await page.locator("text=Finish").click();
+      await page.waitForURL("/settings/teams");
+    });
+
+    await test.step("Can disband team", async () => {
+      await page.locator('[data-testid="team-list-item-link"]').click();
+      await page.waitForURL(/\/settings\/teams\/(\d+)\/profile$/i);
+      await page.locator("text=Disband Team").click();
+      await page.locator("text=Yes, disband team").click();
+      await page.waitForURL("/teams");
+      expect(await page.locator(`text=${user.username}'s Team`).count()).toEqual(0);
+    });
+  });
+
+  test("Can create a booking for Collective EventType", async ({ page, users, orgs }) => {
+    const org = await orgs.create({
+      name: "TestOrg",
+    });
+    const teamMatesObj = [
+      { name: "teammate-1" },
+      { name: "teammate-2" },
+      { name: "teammate-3" },
+      { name: "teammate-4" },
+    ];
+
+    const owner = await users.create(
+      {
+        username: "pro-user",
+        name: "pro-user",
+        organizationId: org.id,
+        roleInOrganization: MembershipRole.MEMBER,
+      },
+      {
+        hasTeam: true,
+        teammates: teamMatesObj,
+        schedulingType: SchedulingType.COLLECTIVE,
+      }
+    );
+    const { team } = await owner.getFirstTeam();
+    const { title: teamEventTitle, slug: teamEventSlug } = await owner.getFirstTeamEvent(team.id);
+
+    await page.goto(`/team/${team.slug}/${teamEventSlug}`);
+
+    await expect(page.locator('[data-testid="404-page"]')).toBeVisible();
+    await doOnOrgDomain(
+      {
+        orgSlug: org.slug,
+        page,
+      },
+      async () => {
+        await page.goto(`/team/${team.slug}/${teamEventSlug}`);
+        await selectFirstAvailableTimeSlotNextMonth(page);
+        await bookTimeSlot(page);
+        await expect(page.locator("[data-testid=success-page]")).toBeVisible();
+
+        // The title of the booking
+        const BookingTitle = `${teamEventTitle} between ${team.name} and ${testName}`;
+        await expect(page.locator("[data-testid=booking-title]")).toHaveText(BookingTitle);
+        // The booker should be in the attendee list
+        await expect(page.locator(`[data-testid="attendee-name-${testName}"]`)).toHaveText(testName);
+
+        // All the teammates should be in the booking
+        for (const teammate of teamMatesObj.concat([{ name: owner.name || "" }])) {
+          await expect(page.getByText(teammate.name, { exact: true })).toBeVisible();
+        }
+      }
+    );
+
+    // TODO: Assert whether the user received an email
+  });
+
+  test("Can create a booking for Round Robin EventType", async ({ page, users }) => {
+    const ownerObj = { username: "pro-user", name: "pro-user" };
+    const teamMatesObj = [
+      { name: "teammate-1" },
+      { name: "teammate-2" },
+      { name: "teammate-3" },
+      { name: "teammate-4" },
+    ];
+    const owner = await users.create(ownerObj, {
+      hasTeam: true,
+      teammates: teamMatesObj,
+      schedulingType: SchedulingType.ROUND_ROBIN,
+    });
+
+    const { team } = await owner.getFirstTeam();
+    const { title: teamEventTitle, slug: teamEventSlug } = await owner.getFirstTeamEvent(team.id);
+
+    await page.goto(`/team/${team.slug}/${teamEventSlug}`);
+    await selectFirstAvailableTimeSlotNextMonth(page);
+    await bookTimeSlot(page);
+    await expect(page.locator("[data-testid=success-page]")).toBeVisible();
+
+    // The person who booked the meeting should be in the attendee list
+    await expect(page.locator(`[data-testid="attendee-name-${testName}"]`)).toHaveText(testName);
+
+    // The title of the booking
+    const BookingTitle = `${teamEventTitle} between ${team.name} and ${testName}`;
+    await expect(page.locator("[data-testid=booking-title]")).toHaveText(BookingTitle);
+
+    // Since all the users have the same leastRecentlyBooked value
+    // Anyone of the teammates could be the Host of the booking.
+    const chosenUser = await page.getByTestId("booking-host-name").textContent();
+    expect(chosenUser).not.toBeNull();
+    expect(teamMatesObj.concat([{ name: ownerObj.name }]).some(({ name }) => name === chosenUser)).toBe(true);
+    // TODO: Assert whether the user received an email
+  });
+});
+
+async function doOnOrgDomain(
+  { orgSlug, page }: { orgSlug: string | null; page: Page },
+  callback: ({ page }: { page: Page }) => Promise<void>
+) {
+  if (!orgSlug) {
+    throw new Error("orgSlug is not available");
+  }
+  page.setExtraHTTPHeaders({
+    "x-cal-force-slug": orgSlug,
+  });
+  await callback({ page });
+}

apps/web/playwright/unpublished.e2e.ts

@@ -18,7 +18,7 @@ test.afterAll(async ({ users }) => {
 test.describe("Unpublished", () => {
   test("Regular team profile", async ({ page, users }) => {
     const owner = await users.create(undefined, { hasTeam: true, isUnpublished: true });
-    const { team } = await owner.getTeam();
+    const { team } = await owner.getFirstTeam();
     const { requestedSlug } = team.metadata as { requestedSlug: string };
     await page.goto(`/team/${requestedSlug}`);
     expect(await page.locator('[data-testid="empty-screen"]').count()).toBe(1);
@@ -33,7 +33,7 @@ test.describe("Unpublished", () => {
       isUnpublished: true,
       schedulingType: SchedulingType.COLLECTIVE,
     });
-    const { team } = await owner.getTeam();
+    const { team } = await owner.getFirstTeam();
     const { requestedSlug } = team.metadata as { requestedSlug: string };
     const { slug: teamEventSlug } = await owner.getFirstTeamEvent(team.id);
     await page.goto(`/team/${requestedSlug}/${teamEventSlug}`);

apps/web/public/static/locales/ar/common.json

@@ -268,6 +268,7 @@
   "set_availability": "تحديد الوقت الذي تكون فيه متاحًا",
   "availability_settings": "إعدادات التوافرية",
   "continue_without_calendar": "المتابعة من دون تقويم",
+  "continue_with": "الاستمرار مع {{appName}}",
   "connect_your_calendar": "ربط التقويم لديك",
   "connect_your_video_app": "اربط تطبيقات الفيديو لديك",
   "connect_your_video_app_instructions": "قم بتوصيل تطبيقات الفيديو لديك لاستخدامها في أنواع الأحداث الخاصة بك.",
@@ -288,6 +289,8 @@
   "when": "متى",
   "where": "أين",
   "add_to_calendar": "إضافة إلى التقويم",
+  "add_to_calendar_description": "اختر أين ستُضاف الأحداث الجديدة عندما يتم الحجز لديك.",
+  "add_events_to": "إضافة أحداث إلى",
   "add_another_calendar": "إضافة تقويم آخر",
   "other": "آخر",
   "email_sign_in_subject": "رابط تسجيل الدخول بك لـ{{appName}}",
@@ -422,6 +425,7 @@
   "booking_created": "تم إنشاء الحجز",
   "booking_rejected": "تم رفض الحجز",
   "booking_requested": "تم طلب الحجز",
+  "booking_payment_initiated": "بدء الدفع للحجز",
   "meeting_ended": "انتهى الاجتماع",
   "form_submitted": "تم إرسال النموذج",
   "booking_paid": "تم الدفع لقاء الحجز",
@@ -456,6 +460,7 @@
   "no_event_types_have_been_setup": "لم يقم هذا المستخدم بإعداد أي أنواع للحدث حتى الآن.",
   "edit_logo": "تعديل الشعار",
   "upload_a_logo": "تحميل شعار",
+  "upload_logo": "تحميل شعار",
   "remove_logo": "إزالة الشعار",
   "enable": "تمكين",
   "code": "الرمز",
@@ -568,6 +573,7 @@
   "your_team_name": "اسم فريقك",
   "team_updated_successfully": "تم تحديث الفريق بنجاح",
   "your_team_updated_successfully": "تم تحديث فريقك بنجاح.",
+  "your_org_updated_successfully": "تم تحديث منظمتك بنجاح.",
   "about": "حول",
   "team_description": "بضع جمل عن فريقك. ستظهر على صفحة رابط فريقك.",
   "org_description": "بضع جمل عن منظمتك. ستظهر على صفحة رابط منظمتك.",
@@ -599,6 +605,7 @@
   "hide_book_a_team_member": "إخفاء الزر \"حجز عضو فريق\"",
   "hide_book_a_team_member_description": "إخفاء الزر \"حجز عضو فريق\" من صفحاتك العامة.",
   "danger_zone": "منطقة خطر",
+  "account_deletion_cannot_be_undone": "احترس. لا يمكن التراجع عن حذف الحساب.",
   "back": "عودة",
   "cancel": "إلغاء",
   "cancel_all_remaining": "إلغاء كل ما تبقى",
@@ -688,6 +695,7 @@
   "people": "الأشخاص",
   "your_email": "بريدك الإلكتروني",
   "change_avatar": "تغيير الصورة الرمزية",
+  "upload_avatar": "تحميل صورة رمزية",
   "language": "اللغة",
   "timezone": "المنطقة الزمنية",
   "first_day_of_week": "أول يوم في الأسبوع",
@@ -778,6 +786,7 @@
   "disable_guests": "تعطيل خاصية الضيوف",
   "disable_guests_description": "قم بتعطيل إضافة مزيد من الضيوف أثناء الحجز.",
   "private_link": "إنشاء رابط خاص",
+  "enable_private_url": "تمكين عنوان URL خاص",
   "private_link_label": "رابط خاص",
   "private_link_hint": "سيتم إعادة توليد الرابط الخاص بك بعد كل استخدام",
   "copy_private_link": "نسخ الرابط الخاص",
@@ -840,6 +849,7 @@
   "next_step": "تخطي الخطوة",
   "prev_step": "الخطوة السابقة",
   "install": "تثبيت",
+  "install_paid_app": "اشتراك",
   "installed": "تم التثبيت",
   "active_install_one": "{{count}} تثبيت نشط",
   "active_install_other": "{{count}} تثبيت نشط",
@@ -1213,6 +1223,7 @@
   "organizer_name_variable": "اسم المنظم",
   "app_upgrade_description": "لاستخدام هذه الميزة، تحتاج إلى الترقية إلى حساب Pro.",
   "invalid_number": "رقم الهاتف غير صالح",
+  "invalid_url_error_message": "عنوان URL غير صالح من أجل {{label}}. عنوان URL للعينة: {{sampleUrl}}",
   "navigate": "تنقّل",
   "open": "فتح",
   "close": "إغلاق",
@@ -1276,6 +1287,7 @@
   "personal_cal_url": "عنوان {{appName}} URL الخاص بي",
   "bio_hint": "اكتب بضع جمل عن نفسك، والتي ستظهر على صفحة عنوان Url الشخصية لديك.",
   "user_has_no_bio": "لم يُضف هذا المستخدم لمحة عنه بعد.",
+  "bio": "سيرة ذاتية",
   "delete_account_modal_title": "حذف الحساب",
   "confirm_delete_account_modal": "هل أنت متأكد من أنك تريد حذف حساب {{appName}} الخاص بك؟",
   "delete_my_account": "حذف حسابي",
@@ -1286,6 +1298,7 @@
   "select_calendars": "حدد الرزنامات التي تريد التحقق منها بحثًا عن تضاربات لمنع الحجوزات المزدوجة.",
   "check_for_conflicts": "التحقق من وجود تضاربات",
   "view_recordings": "عرض التسجيلات",
+  "check_for_recordings": "تحقق من وجود تسجيلات",
   "adding_events_to": "إضافة أحداث إلى",
   "follow_system_preferences": "اتبع تفضيلات النظام",
   "custom_brand_colors": "ألوان العلامة التجارية المخصصة",
@@ -1530,6 +1543,7 @@
   "problem_registering_domain": "حدثت مشكلة في تسجيل المجال الفرعي، يُرجى المحاولة لاحقاً أو الاتصال بالمشرف",
   "team_publish": "نشر فريق",
   "number_text_notifications": "رقم الهاتف (إشعارات الرسائل النصية)",
+  "number_sms_notifications": "رقم الهاتف (إشعارات الرسائل النصية)",
   "attendee_email_variable": "اسم الحاضر",
   "attendee_email_info": "البريد الإلكتروني للشخص الحجز",
   "kbar_search_placeholder": "اكتب أمرًا أو بحثًا...",
@@ -1594,6 +1608,7 @@
   "options": "خيارات",
   "enter_option": "أدخل خيار {{index}}",
   "add_an_option": "إضافة خيار",
+  "location_already_exists": "هذا الموقع موجود بالفعل. الرجاء اختيار موقع جديد",
   "radio": "الراديو",
   "google_meet_warning": "من أجل استخدام Google Meet، يجب عليك تعيين تقويم وجهتك على تقويم Google",
   "individual": "فرد",
@@ -1613,6 +1628,7 @@
   "date_overrides_mark_all_day_unavailable_other": "وضع علامة غير متاح على التواريخ المحددة",
   "date_overrides_add_btn": "إضافة تجاوز",
   "date_overrides_update_btn": "تحديث التجاوز",
+  "date_successfully_added": "تم إضافة تخطّي التاريخ بنجاح",
   "event_type_duplicate_copy_text": "{{slug}}-نسخ",
   "set_as_default": "تعيين كافتراضي",
   "hide_eventtype_details": "إخفاء تفاصيل نوع الحدث",
@@ -1639,6 +1655,7 @@
   "minimum_round_robin_hosts_count": "عدد المضيفين المطلوب حضورهم",
   "hosts": "المضيفون",
   "upgrade_to_enable_feature": "تحتاج إلى إنشاء فريق لتمكين هذه الميزة. انقر لإنشاء فريق.",
+  "orgs_upgrade_to_enable_feature": "تحتاج إلى الترقية إلى خطة enterprise لتفعيل هذه الميزة.",
   "new_attendee": "حضور جديد",
   "awaiting_approval": "في انتظار الموافقة",
   "requires_google_calendar": "يتطلب هذا التطبيق اتصال تقويم Google",
@@ -1743,6 +1760,7 @@
   "show_on_booking_page": "إظهار في صفحة الحجز",
   "get_started_zapier_templates": "البدء في استخدام قوالب Zapier",
   "team_is_unpublished": "لم يُنشر {{team}}",
+  "org_is_unpublished_description": "رابط هذه المنظمة غير متاح حاليًا. يرجى الاتصال بمالك المنظمة أو طلب النشر منه.",
   "team_is_unpublished_description": "رابط هذا {{entity}} غير متاح حاليًا. يرجى الاتصال بمالك {{entity}} أو طلب نشره منه.",
   "team_member": "عضو الفريق",
   "a_routing_form": "نموذج توجيه",
@@ -1877,6 +1895,7 @@
   "edit_invite_link": "تعديل إعدادات الرابط",
   "invite_link_copied": "تم نسخ رابط الدعوة",
   "invite_link_deleted": "تم حذف رابط الدعوة",
+  "api_key_deleted": "تم حذف مفتاح API",
   "invite_link_updated": "تم حفظ إعدادات رابط الدعوة",
   "link_expires_after": "تم تعيين انتهاء صلاحية الروابط بعد...",
   "one_day": "1 يوم",
@@ -2009,7 +2028,13 @@
   "attendee_last_name_variable": "اسم العائلة للحاضر",
   "attendee_first_name_info": "الاسم الأول للشخص صاحب الحجز",
   "attendee_last_name_info": "اسم العائلة للشخص صاحب الحجز",
+  "your_monthly_digest": "موجزك الشهري",
+  "member_name": "اسم العضو",
+  "most_popular_events": "الأحداث الأكثر شعبية",
+  "summary_of_events_for_your_team_for_the_last_30_days": "إليك ملخصك للأحداث الشعبية لفريقك {{teamName}} خلال آخر 30 يومًا",
   "me": "أنا",
+  "monthly_digest_email": "الرسالة الإلكترونية للموجز الشهري",
+  "monthly_digest_email_for_teams": "رسالة إلكترونية بالموجز الشهري للفرق",
   "verify_team_tooltip": "تأكيد فريقك لتمكين إرسال الرسائل إلى الحاضرين",
   "member_removed": "تمت إزالة العضو",
   "my_availability": "أوقاتي المتاحة",
@@ -2039,12 +2064,41 @@
   "team_no_event_types": "ليس لدى هذا الفريق أنواع من الفعاليات",
   "seat_options_doesnt_multiple_durations": "لا يدعم خيار المقعد فترات متعددة",
   "include_calendar_event": "إدراج فعاليات في التقويم",
+  "oAuth": "OAuth",
   "recently_added": "تمت الإضافة مؤخراً",
   "no_members_found": "لم يُعثر على أعضاء",
   "event_setup_length_error": "إعداد الفعالية: يجب أن تكون المدة لدقيقة على الأقل.",
   "availability_schedules": "جدولة التوافر",
+  "unauthorized": "غير مصرح به",
+  "access_cal_account": "يرغب {{clientName}} في الوصول إلى حسابك على {{appName}}",
+  "select_account_team": "اختر حسابًا أو فريق",
+  "allow_client_to": "سيمنح هذا {{clientName}} القدرة على",
+  "associate_with_cal_account": "رافق نفسك بمعلوماتك الشخصية من {{clientName}}",
+  "see_personal_info": "شاهد معلوماتك الشخصية، بما في ذلك أي معلومات شخصية جعلتها متاحة للجمهور",
+  "see_primary_email_address": "طالع عنوان بريدك الإلكتروني الأساسي",
+  "connect_installed_apps": "قم بالارتباط بتطبيقاتك المثبتة",
+  "access_event_type": "اقرأ وعدّل واحذف أنواع الأحداث لديك",
+  "access_availability": "اقرأ وعّدل واحذف توافرك",
+  "access_bookings": "اقرأ وعدّل واحذف الحجوزات لديك",
+  "allow_client_to_do": "السماح لـ {{clientName}} بالقيام بهذا؟",
+  "oauth_access_information": "عبر نقرك على السماح، ستسمح لهذا التطبيق باستخدام معلوماتك وفقاً لشروط الخدمة وسياسة الخصوصية لديه. يمكنك إزالة هذا الوصول من متجر التطبيقات {{appName}}.",
+  "allow": "السماح",
   "view_only_edit_availability_not_onboarded": "لم يكمل هذا المستخدم عملية الانضمام. لن تتمكن من تعيين توافره حتى يكتمل انضمامه.",
   "view_only_edit_availability": "أنت تشاهد توافر هذا المستخدم. يمكنك تعديل توافرك فقط.",
+  "you_can_override_calendar_in_advanced_tab": "يمكنك تجاوز هذا لكل حدث على حدة في الإعدادات المتقدمة في كل نوع من أنواع الأحداث.",
   "edit_users_availability": "تعديل توافر المستخدم: {{username}}",
+  "resend_invitation": "إعادة إرسال الدعوة",
+  "invitation_resent": "تم إعادة إرسال الدعوة.",
+  "add_client": "إضافة عميل",
+  "copy_client_secret_info": "لن تتمكن من مطالعة السر بعد نسخه بعد الآن",
+  "add_new_client": "إضافة عميل جديد",
+  "this_app_is_not_setup_already": "لم يتم إعداد هذا التطبيق بعد",
+  "as_csv": "كـ CSV",
+  "overlay_my_calendar": "تركيب تقويمي",
+  "overlay_my_calendar_toc": "من خلال الارتباط بتقويمك، أنت تقبل سياسة الخصوصية وشروط الاستخدام. يمكنك إلغاء الوصول في أي وقت.",
+  "view_overlay_calendar_events": "طالع أحداث تقويمك لمنع التضارب بين الحجوزات.",
+  "lock_timezone_toggle_on_booking_page": "قفل المنطقة الزمنية في صفحة الحجز",
+  "description_lock_timezone_toggle_on_booking_page": "تقفل المنطقة الزمنية على صفحة الحجز، وهذا مفيد للأحداث وجهاً لوجه.",
+  "extensive_whitelabeling": "عملية انضمام ودعم هندسي مخصصين",
   "ADD_NEW_STRINGS_ABOVE_THIS_LINE_TO_PREVENT_MERGE_CONFLICTS": "↑↑↑↑↑↑↑↑↑↑↑↑↑ أضف السلاسل الجديدة أعلاه هنا ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"
 }

apps/web/public/static/locales/cs/common.json

@@ -268,6 +268,7 @@
   "set_availability": "Nastavte, jak jste dostupní",
   "availability_settings": "Nastavení dostupnosti",
   "continue_without_calendar": "Pokračovat bez kalendáře",
+  "continue_with": "Pokračovat přes {{appName}}",
   "connect_your_calendar": "Připojit svůj kalendář",
   "connect_your_video_app": "Propojte své video aplikace",
   "connect_your_video_app_instructions": "Propojte své video aplikace a používejte je ve svých typech událostí.",
@@ -288,6 +289,8 @@
   "when": "Kdy",
   "where": "Kde",
   "add_to_calendar": "Přidat do kalendáře",
+  "add_to_calendar_description": "Vyberte, kam se mají přidávat události, pokud jste zarezervováni.",
+  "add_events_to": "Přidat události do",
   "add_another_calendar": "Přidat další kalendář",
   "other": "Ostatní",
   "email_sign_in_subject": "Váš přihlašovací odkaz pro {{appName}}",
@@ -422,6 +425,7 @@
   "booking_created": "Rezervace vytvořena",
   "booking_rejected": "Rezervace byla zamítnuta",
   "booking_requested": "Váš požadavek na rezervaci byl úspěšně odeslán",
+  "booking_payment_initiated": "Platba za rezervaci zahájena",
   "meeting_ended": "Schůzka skončila",
   "form_submitted": "Formulář byl odeslán",
   "booking_paid": "Rezervace uhrazena",
@@ -456,6 +460,7 @@
   "no_event_types_have_been_setup": "Tento uživatel zatím nezaložil žádné typy událostí.",
   "edit_logo": "Upravit logo",
   "upload_a_logo": "Nahrát logo",
+  "upload_logo": "Nahrát logo",
   "remove_logo": "Odstranit logo",
   "enable": "Povolit",
   "code": "Kód",
@@ -568,6 +573,7 @@
   "your_team_name": "Název vašeho týmu",
   "team_updated_successfully": "Tým byl úspěšně aktualizován",
   "your_team_updated_successfully": "Váš tým byl úspěšně aktualizován.",
+  "your_org_updated_successfully": "Vaše organizace byla aktualizována.",
   "about": "O aplikaci",
   "team_description": "Pár vět o vašem týmu. Objeví se na URL stránce vašeho týmu.",
   "org_description": "Několik vět o vaší organizaci. Zobrazí se na adrese URL vaší organizace.",
@@ -599,6 +605,7 @@
   "hide_book_a_team_member": "Skrýt tlačítko Rezervovat člena týmu",
   "hide_book_a_team_member_description": "Skrýt tlačítko Rezervovat člena týmu na veřejných stránkách.",
   "danger_zone": "Nebezpečná zóna",
+  "account_deletion_cannot_be_undone": "Pozor. Odstranění účtu nelze vrátit.",
   "back": "Zpět",
   "cancel": "Zrušit",
   "cancel_all_remaining": "Zrušit vše zbývající",
@@ -688,6 +695,7 @@
   "people": "Lidé",
   "your_email": "Váš e-mail",
   "change_avatar": "Změnit avatar",
+  "upload_avatar": "Nahrát avatar",
   "language": "Jazyk",
   "timezone": "Časová zóna",
   "first_day_of_week": "První den v týdnu",
@@ -778,6 +786,7 @@
   "disable_guests": "Zakázat hosty",
   "disable_guests_description": "Zakázat přidávání dalších hostů během rezervace.",
   "private_link": "Vygenerovat soukromou adresu URL",
+  "enable_private_url": "Zapnout soukromou adresu URL",
   "private_link_label": "Soukromý odkaz",
   "private_link_hint": "Váš soukromý odkaz se po každém použití obnoví",
   "copy_private_link": "Zkopírovat soukromý odkaz",
@@ -840,6 +849,7 @@
   "next_step": "Přeskočit krok",
   "prev_step": "Předchozí krok",
   "install": "Nainstalovat",
+  "install_paid_app": "Odebírat",
   "installed": "Nainstalováno",
   "active_install_one": "Aktivní instalace: {{count}}",
   "active_install_other": "Aktivní instalace: {{count}}",
@@ -1213,6 +1223,7 @@
   "organizer_name_variable": "Jméno organizátora",
   "app_upgrade_description": "Pokud chcete použít tuto funkci, musíte provést aktualizaci na účet Pro.",
   "invalid_number": "Neplatné telefonní číslo",
+  "invalid_url_error_message": "Neplatná adresa URL pro {{label}}. Příklad URL: {{sampleUrl}}",
   "navigate": "Navigace",
   "open": "Otevřít",
   "close": "Zavřít",
@@ -1276,6 +1287,7 @@
   "personal_cal_url": "Moje osobní adresa URL {{appName}}",
   "bio_hint": "Několik vět o vás. Obsah se zobrazí se na vaší osobní stránce URL.",
   "user_has_no_bio": "Tento uživatel zatím nepřidal životopis.",
+  "bio": "Bio",
   "delete_account_modal_title": "Odstranit účet",
   "confirm_delete_account_modal": "Opravdu chcete odstranit svůj účet {{appName}}?",
   "delete_my_account": "Odstranit můj účet",
@@ -1286,6 +1298,7 @@
   "select_calendars": "Vyberte kalendáře, u kterých chcete kontrolovat konflikty v zájmu prevence dvojích rezervací.",
   "check_for_conflicts": "Zkontrolovat konflikty",
   "view_recordings": "Zobrazit nahrávky",
+  "check_for_recordings": "Zkontrolovat nahrávky",
   "adding_events_to": "Přidání událostí do:",
   "follow_system_preferences": "Řídit se předvolbami systému",
   "custom_brand_colors": "Vlastní barvy značky",
@@ -1530,6 +1543,7 @@
   "problem_registering_domain": "Při registraci subdomény došlo k problému, zkuste to prosím znovu nebo kontaktujte správce",
   "team_publish": "Zveřejnit tým",
   "number_text_notifications": "Telefonní číslo (SMS oznámení)",
+  "number_sms_notifications": "Telefonní číslo (SMS oznámení)",
   "attendee_email_variable": "E-mail účastníka",
   "attendee_email_info": "E-mail osoby provádějící rezervaci",
   "kbar_search_placeholder": "Zadejte příkaz nebo vyhledejte...",
@@ -1594,6 +1608,7 @@
   "options": "Možnosti",
   "enter_option": "Zadejte možnost {{index}}",
   "add_an_option": "Přidat možnost",
+  "location_already_exists": "Toto místo již existuje. Vyberte prosím nové místo",
   "radio": "Přepínač",
   "google_meet_warning": "Abyste mohli používat službu Google Meet, musíte jako cílový kalendář nastavit Kalendář Google",
   "individual": "Jedinec",
@@ -1613,6 +1628,7 @@
   "date_overrides_mark_all_day_unavailable_other": "Zadat nedostupnost ve vybraných datech",
   "date_overrides_add_btn": "Přidat změnu",
   "date_overrides_update_btn": "Aktualizovat změnu",
+  "date_successfully_added": "Přidána změna dnů",
   "event_type_duplicate_copy_text": "{{slug}} – kopie",
   "set_as_default": "Nastavit jako výchozí",
   "hide_eventtype_details": "Skrýt podrobnosti o typu události",
@@ -1639,6 +1655,7 @@
   "minimum_round_robin_hosts_count": "Počet hostitelů, kteří se musí zúčastnit",
   "hosts": "Hostitelé",
   "upgrade_to_enable_feature": "K povolení této funkce je třeba vytvořit tým. Tým vytvoříte kliknutím.",
+  "orgs_upgrade_to_enable_feature": "Pokud chcete zapnout tuto funkci, musíte upgradovat na náš tarif Enterprise.",
   "new_attendee": "Nový účastník",
   "awaiting_approval": "Čeká na schválení",
   "requires_google_calendar": "Tato aplikace vyžaduje připojení ke Kalendáři Google",
@@ -1743,6 +1760,7 @@
   "show_on_booking_page": "Zobrazit na stránce rezervace",
   "get_started_zapier_templates": "Začněte používat šablony Zapier",
   "team_is_unpublished": "Tým {{team}} není zveřejněn",
+  "org_is_unpublished_description": "Tento odkaz organizace není v současné době k dispozici. Kontaktujte prosím vlastníka organizace nebo ho požádejte o jeho zveřejnění.",
   "team_is_unpublished_description": "Tento odkaz subjektu ({{entity}}) není v současné době k dispozici. Kontaktujte prosím vlastníka subjektu ({{entity}}) nebo ho požádejte o jeho zveřejnění.",
   "team_member": "Člen týmu",
   "a_routing_form": "Směrovací formulář",
@@ -1877,6 +1895,7 @@
   "edit_invite_link": "Upravit nastavení odkazu",
   "invite_link_copied": "Odkaz pozvánky byl zkopírován",
   "invite_link_deleted": "Odkaz pozvánky byl odstraněn",
+  "api_key_deleted": "Klíč API odstraněn",
   "invite_link_updated": "Nastavení odkazu pozvánky bylo uloženo",
   "link_expires_after": "Platnost odkazů vyprší za...",
   "one_day": "1 den",
@@ -2009,7 +2028,13 @@
   "attendee_last_name_variable": "Příjmení účastníka",
   "attendee_first_name_info": "Jméno rezervující osoby",
   "attendee_last_name_info": "Příjmení rezervující osoby",
+  "your_monthly_digest": "Váš měsíční přehled",
+  "member_name": "Jméno člena",
+  "most_popular_events": "Nejoblíbenější události",
+  "summary_of_events_for_your_team_for_the_last_30_days": "Zde je přehled oblíbených událostí vašeho týmu {{teamName}} za posledních 30 dní",
   "me": "Já",
+  "monthly_digest_email": "E-mail s měsíčním přehledem",
+  "monthly_digest_email_for_teams": "Měsíční e-mail s přehledem pro týmy",
   "verify_team_tooltip": "Proveďte ověření svého týmu a zapněte odesílání zpráv účastníkům",
   "member_removed": "Člen odstraněn",
   "my_availability": "Moje dostupnost",
@@ -2039,12 +2064,41 @@
   "team_no_event_types": "Tento tým nemá žádné typy událostí",
   "seat_options_doesnt_multiple_durations": "Volba místa nepodporuje více dob trvání",
   "include_calendar_event": "Zahrnout událost kalendáře",
+  "oAuth": "OAuth",
   "recently_added": "Nedávno přidáno",
   "no_members_found": "Nenalezeni žádní členové",
   "event_setup_length_error": "Nastavení události: Doba trvání musí být alespoň 1 minuta.",
   "availability_schedules": "Plány dostupnosti",
+  "unauthorized": "Neautorizováno",
+  "access_cal_account": "{{clientName}} žádá o přístup k vašemu účtu {{appName}}",
+  "select_account_team": "Vyberte účet nebo tým",
+  "allow_client_to": "To umožní klientovi {{clientName}}",
+  "associate_with_cal_account": "Přiřadit vám vaše osobní údaje z klienta {{clientName}}",
+  "see_personal_info": "Zobrazit vaše osobní údaje, včetně všech osobních údajů, které jste zveřejnili",
+  "see_primary_email_address": "Zobrazit vaši primární e-mailovou adresu",
+  "connect_installed_apps": "Připojit se k vašim nainstalovaným aplikacím",
+  "access_event_type": "Číst, upravovat a odstraňovat vaše typy událostí",
+  "access_availability": "Číst, upravovat a odstraňovat vaši dostupnost",
+  "access_bookings": "Číst, upravovat a odstraňovat rezervace",
+  "allow_client_to_do": "Chcete povolit klientovi {{clientName}} provádět uvedené akce?",
+  "oauth_access_information": "Kliknutím na tlačítko Povolit této aplikaci umožníte používat vaše údaje v souladu s podmínkami služby a zásadami ochrany osobních údajů. Přístup k aplikaci {{appName}} můžete odebrat přes App Store.",
+  "allow": "Povolit",
   "view_only_edit_availability_not_onboarded": "Tento uživatel ještě nedokončil onboarding. Dokud nedokončí onboarding, dostupnost nebude možné nastavit.",
   "view_only_edit_availability": "Právě máte zobrazenou dostupnost tohoto uživatele. Upravovat lze pouze vlastní dostupnost.",
+  "you_can_override_calendar_in_advanced_tab": "Tuto možnost můžete zrušit pro každou událost zvlášť v pokročilém nastavení jednotlivých typů událostí.",
   "edit_users_availability": "Upravte dostupnost uživatele: {{username}}",
+  "resend_invitation": "Znovu odeslat pozvánku",
+  "invitation_resent": "Pozvánka byla odeslána znovu.",
+  "add_client": "Přidat klienta",
+  "copy_client_secret_info": "Po zkopírování již nebude možné tajný klíč zobrazit",
+  "add_new_client": "Přidat nového klienta",
+  "this_app_is_not_setup_already": "Tato aplikace ještě nebyla nastavena",
+  "as_csv": "jako CSV",
+  "overlay_my_calendar": "Překryv mého kalendáře",
+  "overlay_my_calendar_toc": "Připojením ke svému kalendáři přijímáte naše zásady ochrany osobních údajů a podmínky používání. Přístup můžete kdykoli odvolat.",
+  "view_overlay_calendar_events": "Zobrazení událostí v kalendáři, aby se zabránilo kolidujícím rezervacím.",
+  "lock_timezone_toggle_on_booking_page": "Uzamčení časového pásma na stránce rezervace",
+  "description_lock_timezone_toggle_on_booking_page": "Uzamčení časového pásma na stránce rezervace (užitečné pro osobní události).",
+  "extensive_whitelabeling": "Vyhrazená podpora zaškolovací a inženýrská podpora",
   "ADD_NEW_STRINGS_ABOVE_THIS_LINE_TO_PREVENT_MERGE_CONFLICTS": "↑↑↑↑↑↑↑↑↑↑↑↑↑ Přidejte své nové řetězce nahoru ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"
 }

apps/web/public/static/locales/da/common.json

@@ -717,6 +717,7 @@
   "next_step": "Spring trin over",
   "prev_step": "Forrige trin",
   "install": "Installér",
+  "install_paid_app": "Abonnér",
   "installed": "Installeret",
   "active_install_one": "{{count}} aktiv installation",
   "active_install_other": "{{count}} aktive installationer",

apps/web/public/static/locales/de/common.json

@@ -268,6 +268,7 @@
   "set_availability": "Verfügbarkeit festlegen",
   "availability_settings": "Verfügbarkeitseinstellungen",
   "continue_without_calendar": "Ohne Kalender fortfahren",
+  "continue_with": "Mit {{appName}} fortfahren",
   "connect_your_calendar": "Kalender verbinden",
   "connect_your_video_app": "Verbinden Sie Ihre Video-Apps",
   "connect_your_video_app_instructions": "Verbinden Sie Ihre Video-Apps, um sie für Ihre Termintypen zu verwenden.",
@@ -289,6 +290,7 @@
   "where": "Wo",
   "add_to_calendar": "Zum Kalender hinzufügen",
   "add_to_calendar_description": "Legen Sie fest, wo neue Termine hinzugefügt werden sollen, wenn Sie gebucht werden.",
+  "add_events_to": "Termine hinzufügen zu",
   "add_another_calendar": "Einen weiteren Kalender hinzufügen",
   "other": "Sonstige",
   "email_sign_in_subject": "Ihr Anmelde-Link für {{appName}}",
@@ -423,6 +425,7 @@
   "booking_created": "Termin erstellt",
   "booking_rejected": "Termin abgelehnt",
   "booking_requested": "Buchung angefragt",
+  "booking_payment_initiated": "Buchungszahlung eingeleitet",
   "meeting_ended": "Meeting beendet",
   "form_submitted": "Formular gesendet",
   "booking_paid": "Buchung bezahlt",
@@ -457,6 +460,7 @@
   "no_event_types_have_been_setup": "Dieser Benutzer hat noch keine Termintypen eingerichtet.",
   "edit_logo": "Logo bearbeiten",
   "upload_a_logo": "Logo hochladen",
+  "upload_logo": "Logo hochladen",
   "remove_logo": "Logos entfernen",
   "enable": "Aktivieren",
   "code": "Code",
@@ -569,6 +573,7 @@
   "your_team_name": "Ihr Teamname",
   "team_updated_successfully": "Team erfolgreich aktualisiert",
   "your_team_updated_successfully": "Ihr Team wurde erfolgreich aktualisiert.",
+  "your_org_updated_successfully": "Ihre Org wurde erfolgreich aktualisiert.",
   "about": "Beschreibung",
   "team_description": "Ein paar Sätze über Ihr Team auf der öffentlichen Teamseite.",
   "org_description": "Ein paar Sätze zu Ihrer Organisation. Dies wird auf der URL-Seite Ihrer Organisation erscheinen.",
@@ -781,6 +786,7 @@
   "disable_guests": "Gäste deaktivieren",
   "disable_guests_description": "Das Hinzufügen zusätzlicher Gäste deaktivieren.",
   "private_link": "Privaten Link generieren",
+  "enable_private_url": "Private URL aktivieren",
   "private_link_label": "Privater Link",
   "private_link_hint": "Ihr privater Link wird nach jeder Nutzung neu generiert",
   "copy_private_link": "Privaten Link kopieren",
@@ -843,6 +849,7 @@
   "next_step": "Schritt überspringen",
   "prev_step": "Vorheriger Schritt",
   "install": "Installieren",
+  "install_paid_app": "Abonnieren",
   "installed": "Installiert",
   "active_install_one": "{{count}} aktive Installation",
   "active_install_other": "{{count}} aktive Installationen",
@@ -1216,6 +1223,7 @@
   "organizer_name_variable": "Organisator Name",
   "app_upgrade_description": "Um diese Funktion nutzen zu können, müssen Sie ein Upgrade auf einen Pro-Account durchführen.",
   "invalid_number": "Ungültige Telefonnummer",
+  "invalid_url_error_message": "Ungültige URL für {{label}}. Beispiel-URL: {{sampleUrl}}",
   "navigate": "Navigieren",
   "open": "Öffnen",
   "close": "Schließen",
@@ -1290,6 +1298,7 @@
   "select_calendars": "Wählen Sie aus, in welchen Kalendern Sie nach Konflikten suchen wollen, um Doppelbuchungen zu vermeiden.",
   "check_for_conflicts": "Auf Konflikte prüfen",
   "view_recordings": "Aufnahmen anzeigen",
+  "check_for_recordings": "Nach Aufnahmen suchen",
   "adding_events_to": "Termine hinzufügen zu",
   "follow_system_preferences": "Systemeinstellungen folgen",
   "custom_brand_colors": "Eigene Marken-Farben",
@@ -1599,6 +1608,7 @@
   "options": "Optionen",
   "enter_option": "Option {{index}} eingeben",
   "add_an_option": "Option hinzufügen",
+  "location_already_exists": "Dieser Standort existiert bereits. Bitte wählen Sie einen neuen Standort",
   "radio": "Radio",
   "google_meet_warning": "Um Google Meet nutzen zu können, müssen Sie Ihren Zielkalender zu einem Google Calendar ändern",
   "individual": "Person",
@@ -1618,6 +1628,7 @@
   "date_overrides_mark_all_day_unavailable_other": "An ausgewählten Daten als „nicht verfügbar“ markieren",
   "date_overrides_add_btn": "Überschreibung hinzufügen",
   "date_overrides_update_btn": "Überschreiben aktualisieren",
+  "date_successfully_added": "Datumsüberbrückung erfolgreich hinzugefügt",
   "event_type_duplicate_copy_text": "{{slug}}-Kopie",
   "set_as_default": "Als Standard festlegen",
   "hide_eventtype_details": "Ereignistyp-Einzelheiten ausblenden",
@@ -2062,6 +2073,7 @@
   "access_cal_account": "{{clientName}} möchte auf Ihr {{appName}} Konto zugreifen",
   "select_account_team": "Konto oder Team auswählen",
   "allow_client_to": "Dies wird {{clientName}} erlauben",
+  "associate_with_cal_account": "Verknüpfen Sie sich mit Ihren persönlichen Daten von {{clientName}}",
   "see_personal_info": "Ihre persönlichen Daten einzusehen, einschließlich persönlicher Informationen, die Sie öffentlich zugänglich gemacht haben",
   "see_primary_email_address": "Ihre primäre E-Mail-Adresse einzusehen",
   "connect_installed_apps": "Sich mit Ihren installierten Apps zu verbinden",
@@ -2069,12 +2081,24 @@
   "access_availability": "Lesen, Bearbeiten, Löschen Ihrer Verfügbarkeiten",
   "access_bookings": "Lesen, Bearbeiten, Löschen Ihrer Termine",
   "allow_client_to_do": "{{clientName}} zulassen, dies zu tun?",
+  "oauth_access_information": "Indem Sie auf „Erlauben“ klicken, erlauben Sie dieser App, Ihre Informationen gemäß ihrer Nutzungsbedingungen und Datenschutzrichtlinien zu verwenden. Sie können den Zugriff im {{appName}} App Store aufheben.",
   "allow": "Zulassen",
   "view_only_edit_availability_not_onboarded": "Dieser Benutzer hat das Onboarding noch nicht abgeschlossen. Sie können seine Verfügbarkeit erst festlegen, wenn er das Onboarding abgeschlossen hat.",
   "view_only_edit_availability": "Sie sehen die Verfügbarkeit dieses Benutzers. Sie können nur Ihre eigene Verfügbarkeit bearbeiten.",
+  "you_can_override_calendar_in_advanced_tab": "Sie können dies in den erweiterten Einstellungen pro Termin für jeden Termintyp überschreiben.",
   "edit_users_availability": "Benutzerverfügbarkeit bearbeiten: {{username}}",
   "resend_invitation": "Einladung erneut senden",
   "invitation_resent": "Die Einladung wurde erneut gesendet.",
+  "add_client": "Kunde hinzufügen",
+  "copy_client_secret_info": "Nach dem Kopieren des Geheimnisses können Sie es nicht mehr ansehen",
+  "add_new_client": "Neuen Kunden hinzufügen",
   "this_app_is_not_setup_already": "Diese App wurde noch nicht eingerichtet",
+  "as_csv": "als CSV",
+  "overlay_my_calendar": "Meinen Kalender überlagern",
+  "overlay_my_calendar_toc": "Durch das Verbinden mit Ihrem Kalender akzeptieren Sie unsere Datenschutzerklärung und Nutzungsbedingungen. Sie können den Zugriff jederzeit widerrufen.",
+  "view_overlay_calendar_events": "Sehen Sie sich Ihre Kalendertermine an, um Buchungskonflikte zu vermeiden.",
+  "lock_timezone_toggle_on_booking_page": "Zeitzone auf der Buchungsseite sperren",
+  "description_lock_timezone_toggle_on_booking_page": "Um die Zeitzone auf der Buchungsseite zu sperren, nützlich für Termine in Person.",
+  "extensive_whitelabeling": "Dedizierte Onboarding- und Engineeringsupport",
   "ADD_NEW_STRINGS_ABOVE_THIS_LINE_TO_PREVENT_MERGE_CONFLICTS": "↑↑↑↑↑↑↑↑↑↑↑↑↑ Fügen Sie Ihre neuen Code-Zeilen über dieser hinzu ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"
 }