feat: Implement global booking limits for users

apps/web/components/settings/GlobalBookingLimitsController.tsx

@@ -0,0 +1,99 @@
+"use client";
+
+import { useForm, Controller } from "react-hook-form";
+
+import { IntervalLimitsManager } from "@calcom/features/eventtypes/components/tabs/limits/EventLimitsTab";
+import SectionBottomActions from "@calcom/features/settings/SectionBottomActions";
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { parseBookingLimit } from "@calcom/lib/intervalLimits/isBookingLimits";
+import { validateIntervalLimitOrder } from "@calcom/lib/intervalLimits/validateIntervalLimitOrder";
+import { trpc } from "@calcom/trpc/react";
+import type { IntervalLimit } from "@calcom/types/Calendar";
+import classNames from "@calcom/ui/classNames";
+import { Button } from "@calcom/ui/components/button";
+import { Form, SettingsToggle } from "@calcom/ui/components/form";
+import { showToast } from "@calcom/ui/components/toast";
+
+const GlobalBookingLimitsController = ({
+  bookingLimits,
+}: {
+  bookingLimits: IntervalLimit | null | undefined;
+}) => {
+  const { t } = useLocale();
+  const safeBookingLimits = bookingLimits ?? {};
+  const bookingsLimitFormMethods = useForm({
+    defaultValues: {
+      bookingLimits: safeBookingLimits,
+    },
+  });
+
+  const utils = trpc.useUtils();
+  const updateProfileMutation = trpc.viewer.me.updateProfile.useMutation({
+    onSuccess: async () => {
+      await utils.viewer.me.invalidate();
+      bookingsLimitFormMethods.reset(bookingsLimitFormMethods.getValues());
+      showToast(t("booking_limits_updated_successfully"), "success");
+    },
+    onError: () => {
+      showToast(t("failed_to_save_global_settings"), "error");
+    },
+  });
+
+  const handleSubmit = async (values: { bookingLimits: IntervalLimit }) => {
+    const { bookingLimits } = values;
+    const parsedBookingLimits = parseBookingLimit(bookingLimits) || {};
+    if (bookingLimits) {
+      const isValid = validateIntervalLimitOrder(parsedBookingLimits);
+      if (!isValid) throw new Error(t("event_setup_booking_limits_error"));
+    }
+    updateProfileMutation.mutate({ ...values, bookingLimits: parsedBookingLimits });
+  };
+
+  return (
+    <Form form={bookingsLimitFormMethods} handleSubmit={handleSubmit}>
+      <Controller
+        name="bookingLimits"
+        render={({ field: { value } }) => {
+          const isChecked = Object.keys(value ?? {}).length > 0;
+          return (
+            <SettingsToggle
+              toggleSwitchAtTheEnd={true}
+              title={t("limit_booking_frequency")}
+              description={t("global_limit_booking_frequency_description")}
+              checked={isChecked}
+              onCheckedChange={(active) => {
+                if (active) {
+                  bookingsLimitFormMethods.setValue("bookingLimits", {
+                    PER_DAY: 1,
+                  });
+                } else {
+                  bookingsLimitFormMethods.setValue("bookingLimits", {});
+                }
+                handleSubmit(bookingsLimitFormMethods.getValues());
+              }}
+              switchContainerClassName={classNames(
+                "border-subtle mt-6 rounded-lg border py-6 px-4 sm:px-6",
+                isChecked && "rounded-b-none"
+              )}
+              childrenClassName="lg:ml-0">
+              <div className="border-subtle border border-y-0 p-6">
+                <IntervalLimitsManager propertyName="bookingLimits" defaultLimit={1} step={1} />
+              </div>
+              <SectionBottomActions align="end">
+                <Button
+                  color="primary"
+                  type="submit"
+                  loading={updateProfileMutation.isPending}
+                  disabled={!bookingsLimitFormMethods.formState.dirtyFields.bookingLimits}>
+                  {t("update")}
+                </Button>
+              </SectionBottomActions>
+            </SettingsToggle>
+          );
+        }}
+      />
+    </Form>
+  );
+};
+
+export default GlobalBookingLimitsController;

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

@@ -21,6 +21,7 @@ import { SettingsToggle } from "@calcom/ui/components/form";
 import { SkeletonButton, SkeletonContainer, SkeletonText } from "@calcom/ui/components/skeleton";
 import { showToast } from "@calcom/ui/components/toast";
 
+import GlobalBookingLimitsController from "@components/settings/GlobalBookingLimitsController";
 import TravelScheduleModal from "@components/settings/TravelScheduleModal";
 
 export type FormValues = {
@@ -395,6 +396,7 @@ const GeneralView = ({ localeProp, user, travelSchedules, revalidatePage }: Gene
         setValue={formMethods.setValue}
         existingSchedules={formMethods.getValues("travelSchedules") ?? []}
       />
+      <GlobalBookingLimitsController bookingLimits={user.bookingLimits} />
     </div>
   );
 };

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

@@ -2673,6 +2673,8 @@
   "disconnect_account": "Disconnect connected account",
   "disconnect_account_hint": "Disconnecting your connected account will change the way you log in. You will only be able to login to your account using email + password",
   "cookie_consent_checkbox": "I agree to the privacy policy and cookie usage",
+  "global_limit_booking_frequency_description": "Limit how many bookings you allow across all your event types.",
+  "failed_to_save_global_settings": "Failed to save global settings",
   "make_a_call": "Make a Call",
   "skip_rr_assignment_label": "Skip round robin assignment if contact exists in Salesforce",
   "skip_rr_description": "URL must contain the contacts email as a parameter ex. ?email=contactEmail",

apps/web/test/utils/bookingScenario/bookingScenario.ts

@@ -1485,6 +1485,7 @@ export function getOrganizer({
   organizationId,
   metadata,
   smsLockState,
+  bookingLimits,
   completedOnboarding,
   username,
   locked,
@@ -1502,6 +1503,7 @@ export function getOrganizer({
   teams?: InputUser["teams"];
   metadata?: userMetadataType;
   smsLockState?: SMSLockState;
+  bookingLimits?: IntervalLimit;
   completedOnboarding?: boolean;
   username?: string;
   locked?: boolean;
@@ -1524,6 +1526,7 @@ export function getOrganizer({
     profiles: [],
     metadata,
     smsLockState,
+    bookingLimits,
     completedOnboarding,
     locked,
   };

packages/features/bookings/lib/handleNewBooking/checkBookingAndDurationLimits.ts

@@ -3,10 +3,14 @@ import type { IntervalLimit } from "@calcom/lib/intervalLimits/intervalLimitSche
 import { checkBookingLimits } from "@calcom/lib/intervalLimits/server/checkBookingLimits";
 import { checkDurationLimits } from "@calcom/lib/intervalLimits/server/checkDurationLimits";
 import { withReporting } from "@calcom/lib/sentryWrapper";
+import prisma from "@calcom/prisma";
 
 import type { NewBookingEventType } from "./getEventTypesFromDB";
 
-type EventType = Pick<NewBookingEventType, "bookingLimits" | "durationLimits" | "id" | "schedule">;
+type EventType = Pick<
+  NewBookingEventType,
+  "bookingLimits" | "durationLimits" | "id" | "schedule" | "userId" | "schedulingType"
+>;
 
 type InputProps = {
   eventType: EventType;
@@ -19,11 +23,11 @@ const _checkBookingAndDurationLimits = async ({
   reqBodyStart,
   reqBodyRescheduleUid,
 }: InputProps) => {
+  const startAsDate = dayjs(reqBodyStart).toDate();
   if (
     Object.prototype.hasOwnProperty.call(eventType, "bookingLimits") ||
     Object.prototype.hasOwnProperty.call(eventType, "durationLimits")
   ) {
-    const startAsDate = dayjs(reqBodyStart).toDate();
     if (eventType.bookingLimits && Object.keys(eventType.bookingLimits).length > 0) {
       await checkBookingLimits(
         eventType.bookingLimits as IntervalLimit,
@@ -42,6 +46,31 @@ const _checkBookingAndDurationLimits = async ({
       );
     }
   }
+
+  // We are only interested in global booking limits for individual and managed events for which schedulingType is null
+  if (eventType.userId && !eventType.schedulingType) {
+    const eventTypeUser = await prisma.user.findUnique({
+      where: {
+        id: eventType.userId,
+      },
+      select: {
+        id: true,
+        email: true,
+        bookingLimits: true,
+      },
+    });
+    if (eventTypeUser?.bookingLimits && Object.keys(eventTypeUser.bookingLimits).length > 0) {
+      await checkBookingLimits(
+        eventTypeUser.bookingLimits as IntervalLimit,
+        startAsDate,
+        eventType.id,
+        reqBodyRescheduleUid,
+        eventType.schedule?.timeZone,
+        { id: eventTypeUser.id, email: eventTypeUser.email },
+        /* isGlobalBookingLimits */ true
+      );
+    }
+  }
 };
 
 export const checkBookingAndDurationLimits = withReporting(