Handle more dry-run cases

Author: hariombalhara

packages/features/bookings/lib/handleConfirmation.ts

@@ -88,7 +88,6 @@ export async function handleConfirmation(args: {
   const scheduleResult = await eventManager.create(evt);
   const results = scheduleResult.results;
   const metadata: AdditionalInformation = {};
-
   const workflows = await getAllWorkflowsFromEventType(eventType, booking.userId);
 
   if (results.length > 0 && results.every((res) => !res.success)) {
@@ -338,14 +337,14 @@ export async function handleConfirmation(args: {
       const isFirstBooking = index === 0;
 
       if (!eventTypeMetadata?.disableStandardEmails?.all?.attendee) {
-        await scheduleMandatoryReminder(
-          evtOfBooking,
+        await scheduleMandatoryReminder({
+          evt: evtOfBooking,
           workflows,
-          false,
-          !!updatedBookings[index].eventType?.owner?.hideBranding,
-          evt.attendeeSeatId,
-          !emailsEnabled && Boolean(platformClientParams?.platformClientId)
-        );
+          requiresConfirmation: false,
+          hideBranding: !!updatedBookings[index].eventType?.owner?.hideBranding,
+          seatReferenceUid: evt.attendeeSeatId,
+          isPlatformNoEmail: !emailsEnabled && Boolean(platformClientParams?.platformClientId),
+        });
       }
 
       await scheduleWorkflowReminders({

packages/features/bookings/lib/handleNewBooking.ts

@@ -1096,6 +1096,7 @@ async function handler(
       responses,
       workflows,
       rescheduledBy: reqBody.rescheduledBy,
+      isDryRun,
     });
 
     if (newBooking) {
@@ -1764,15 +1765,16 @@ async function handler(
 
     // Convert type of eventTypePaymentAppCredential to appId: EventTypeAppList
     if (!booking.user) booking.user = organizerUser;
-    const payment = await handlePayment(
+    const payment = await handlePayment({
       evt,
-      eventType,
-      eventTypePaymentAppCredential as IEventTypePaymentCredentialType,
+      selectedEventType: eventType,
+      paymentAppCredentials: eventTypePaymentAppCredential as IEventTypePaymentCredentialType,
       booking,
-      fullName,
+      bookerName: fullName,
       bookerEmail,
-      bookerPhoneNumber
-    );
+      bookerPhoneNumber,
+      isDryRun,
+    });
     const subscriberOptionsPaymentInitiated: GetSubscriberOptions = {
       userId: triggerForUser ? organizerUser.id : null,
       eventTypeId,
@@ -1788,6 +1790,7 @@ async function handler(
         ...webhookData,
         paymentId: payment?.id,
       },
+      isDryRun,
     });
 
     req.statusCode = 201;
@@ -1830,6 +1833,7 @@ async function handler(
       //delete all scheduled triggers for meeting ended and meeting started of booking
       deleteWebhookScheduledTriggerPromise = deleteWebhookScheduledTriggers({
         booking: originalRescheduledBooking,
+        isDryRun,
       });
     }
 
@@ -1841,6 +1845,7 @@ async function handler(
             subscriberUrl: subscriber.subscriberUrl,
             subscriber,
             triggerEvent: WebhookTriggerEvents.MEETING_ENDED,
+            isDryRun,
           })
         );
       }
@@ -1852,6 +1857,7 @@ async function handler(
             subscriberUrl: subscriber.subscriberUrl,
             subscriber,
             triggerEvent: WebhookTriggerEvents.MEETING_STARTED,
+            isDryRun,
           })
         );
       }
@@ -1865,13 +1871,23 @@ async function handler(
     });
 
     // Send Webhook call if hooked to BOOKING_CREATED & BOOKING_RESCHEDULED
-    await monitorCallbackAsync(handleWebhookTrigger, { subscriberOptions, eventTrigger, webhookData });
+    await monitorCallbackAsync(handleWebhookTrigger, {
+      subscriberOptions,
+      eventTrigger,
+      webhookData,
+      isDryRun,
+    });
   } else {
     // if eventType requires confirmation we will trigger the BOOKING REQUESTED Webhook
     const eventTrigger: WebhookTriggerEvents = WebhookTriggerEvents.BOOKING_REQUESTED;
     subscriberOptions.triggerEvent = eventTrigger;
     webhookData.status = "PENDING";
-    await monitorCallbackAsync(handleWebhookTrigger, { subscriberOptions, eventTrigger, webhookData });
+    await monitorCallbackAsync(handleWebhookTrigger, {
+      subscriberOptions,
+      eventTrigger,
+      webhookData,
+      isDryRun,
+    });
   }
 
   try {
@@ -1917,14 +1933,15 @@ async function handler(
   };
 
   if (!eventType.metadata?.disableStandardEmails?.all?.attendee) {
-    await scheduleMandatoryReminder(
-      evtWithMetadata,
+    await scheduleMandatoryReminder({
+      evt: evtWithMetadata,
       workflows,
-      !isConfirmedByDefault,
-      !!eventType.owner?.hideBranding,
-      evt.attendeeSeatId,
-      noEmail && Boolean(platformClientId)
-    );
+      requiresConfirmation: !isConfirmedByDefault,
+      hideBranding: !!eventType.owner?.hideBranding,
+      seatReferenceUid: evt.attendeeSeatId,
+      isPlatformNoEmail: noEmail && Boolean(platformClientId),
+      isDryRun,
+    });
   }
 
   try {
@@ -1937,6 +1954,7 @@ async function handler(
       isFirstRecurringEvent: req.body.allRecurringDates ? req.body.isFirstRecurringSlot : undefined,
       hideBranding: !!eventType.owner?.hideBranding,
       seatReferenceUid: evt.attendeeSeatId,
+      isDryRun,
     });
   } catch (error) {
     loggerWithEventDetails.error("Error while scheduling workflow reminders", JSON.stringify({ error }));
@@ -1951,6 +1969,7 @@ async function handler(
         eventTypeId,
         teamId,
         orgId,
+        isDryRun,
       });
     }
   } catch (error) {

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

@@ -14,10 +14,22 @@ type ScheduleNoShowTriggersArgs = {
   teamId?: number | null;
   orgId?: number | null;
   oAuthClientId?: string | null;
+  isDryRun?: boolean;
 };
 
 export const scheduleNoShowTriggers = async (args: ScheduleNoShowTriggersArgs) => {
-  const { booking, triggerForUser, organizerUser, eventTypeId, teamId, orgId, oAuthClientId } = args;
+  const {
+    booking,
+    triggerForUser,
+    organizerUser,
+    eventTypeId,
+    teamId,
+    orgId,
+    oAuthClientId,
+    isDryRun = false,
+  } = args;
+
+  if (isDryRun) return;
 
   // Add task for automatic no show in cal video
   const noShowPromises: Promise<any>[] = [];

packages/features/bookings/lib/handleSeats/create/createNewSeat.ts

@@ -185,15 +185,15 @@ const createNewSeat = async (
       throw new HttpError({ statusCode: 400, message: ErrorCode.MissingPaymentAppId });
     }
 
-    const payment = await handlePayment(
+    const payment = await handlePayment({
       evt,
-      eventType,
-      eventTypePaymentAppCredential as IEventTypePaymentCredentialType,
-      seatedBooking,
-      fullName,
+      selectedEventType: eventType,
+      paymentAppCredentials: eventTypePaymentAppCredential as IEventTypePaymentCredentialType,
+      booking: seatedBooking,
+      bookerName: fullName,
       bookerEmail,
-      bookerPhoneNumber
-    );
+      bookerPhoneNumber,
+    });
 
     resultBooking = { ...foundBooking };
     resultBooking["message"] = "Payment required";

packages/features/bookings/lib/handleSeats/handleSeats.ts

@@ -32,8 +32,10 @@ const handleSeats = async (newSeatedBookingObject: NewSeatedBookingObject) => {
     evt,
     workflows,
     rescheduledBy,
+    isDryRun = false,
   } = newSeatedBookingObject;
-
+  // TODO: We could allow doing more things to support good dry run for seats
+  if (isDryRun) return;
   const loggerWithEventDetails = createLoggerWithEventDetails(eventType.id, reqBodyUser, eventType.slug);
 
   let resultBooking: HandleSeatsResultBooking = null;
@@ -124,6 +126,7 @@ const handleSeats = async (newSeatedBookingObject: NewSeatedBookingObject) => {
         isFirstRecurringEvent: true,
         emailAttendeeSendToOverride: bookerEmail,
         seatReferenceUid: evt.attendeeSeatId,
+        isDryRun,
       });
     } catch (error) {
       loggerWithEventDetails.error("Error while scheduling workflow reminders", JSON.stringify({ error }));
@@ -149,7 +152,7 @@ const handleSeats = async (newSeatedBookingObject: NewSeatedBookingObject) => {
       rescheduledBy,
     };
 
-    await handleWebhookTrigger({ subscriberOptions, eventTrigger, webhookData });
+    await handleWebhookTrigger({ subscriberOptions, eventTrigger, webhookData, isDryRun });
   }
 
   return resultBooking;

packages/features/bookings/lib/handleSeats/types.d.ts

@@ -43,6 +43,7 @@ export type NewSeatedBookingObject = {
   responses: z.infer<ReturnType<typeof getBookingDataSchema>>["responses"] | null;
   rescheduledBy?: string;
   workflows: Workflow[];
+  isDryRun?: boolean;
 };
 
 export type RescheduleSeatedBookingObject = NewSeatedBookingObject & { rescheduleUid: string };

packages/features/bookings/lib/handleWebhookTrigger.ts

@@ -9,8 +9,10 @@ export async function handleWebhookTrigger(args: {
   subscriberOptions: GetSubscriberOptions;
   eventTrigger: string;
   webhookData: WebhookPayloadType;
+  isDryRun?: boolean;
 }) {
   try {
+    if (args.isDryRun) return;
     const subscribers = await getWebhooks(args.subscriberOptions);
 
     const promises = subscribers.map((sub) =>

packages/features/ee/workflows/lib/reminders/reminderScheduler.ts

@@ -37,6 +37,7 @@ export interface ScheduleWorkflowRemindersArgs extends ProcessWorkflowStepParams
   isNotConfirmed?: boolean;
   isRescheduleEvent?: boolean;
   isFirstRecurringEvent?: boolean;
+  isDryRun?: boolean;
 }
 
 const processWorkflowStep = async (
@@ -159,7 +160,9 @@ export const scheduleWorkflowReminders = async (args: ScheduleWorkflowRemindersA
     emailAttendeeSendToOverride = "",
     hideBranding,
     seatReferenceUid,
+    isDryRun = false,
   } = args;
+  if (isDryRun) return;
   if (isNotConfirmed || !workflows.length) return;
 
   for (const workflow of workflows) {

packages/features/ee/workflows/lib/reminders/scheduleMandatoryReminder.ts

@@ -11,14 +11,24 @@ const log = logger.getSubLogger({ prefix: ["[scheduleMandatoryReminder]"] });
 
 export type NewBookingEventType = Awaited<ReturnType<typeof getDefaultEvent>> | getEventTypeResponse;
 
-export async function scheduleMandatoryReminder(
-  evt: ExtendedCalendarEvent,
-  workflows: Workflow[],
-  requiresConfirmation: boolean,
-  hideBranding: boolean,
-  seatReferenceUid: string | undefined,
-  isPlatformNoEmail = false
-) {
+export async function scheduleMandatoryReminder({
+  evt,
+  workflows,
+  requiresConfirmation,
+  hideBranding,
+  seatReferenceUid,
+  isPlatformNoEmail = false,
+  isDryRun = false,
+}: {
+  evt: ExtendedCalendarEvent;
+  workflows: Workflow[];
+  requiresConfirmation: boolean;
+  hideBranding: boolean;
+  seatReferenceUid: string | undefined;
+  isPlatformNoEmail?: boolean;
+  isDryRun?: boolean;
+}) {
+  if (isDryRun) return;
   if (isPlatformNoEmail) return;
   try {
     const hasExistingWorkflow = workflows.some((workflow) => {

packages/features/webhooks/lib/scheduleTrigger.ts

@@ -246,12 +246,15 @@ export async function scheduleTrigger({
   subscriberUrl,
   subscriber,
   triggerEvent,
+  isDryRun = false,
 }: {
   booking: { id: number; endTime: Date; startTime: Date };
   subscriberUrl: string;
   subscriber: { id: string; appId: string | null };
   triggerEvent: WebhookTriggerEvents;
+  isDryRun?: boolean;
 }) {
+  if (isDryRun) return;
   try {
     const payload = JSON.stringify({ triggerEvent, ...booking });
 
@@ -285,14 +288,17 @@ export async function deleteWebhookScheduledTriggers({
   webhookId,
   userId,
   teamId,
+  isDryRun = false,
 }: {
   booking?: { id: number; uid: string };
   appId?: string | null;
   triggerEvent?: WebhookTriggerEvents;
   webhookId?: string;
   userId?: number;
   teamId?: number;
+  isDryRun?: boolean;
 }) {
+  if (isDryRun) return;
   try {
     if (appId && (userId || teamId)) {
       const where: Prisma.BookingWhereInput = {};

packages/lib/payment/handlePayment.ts

@@ -6,28 +6,39 @@ import type { CompleteEventType } from "@calcom/prisma/zod";
 import type { CalendarEvent } from "@calcom/types/Calendar";
 import type { IAbstractPaymentService, PaymentApp } from "@calcom/types/PaymentService";
 
-const handlePayment = async (
-  evt: CalendarEvent,
-  selectedEventType: Pick<CompleteEventType, "metadata" | "title">,
+const handlePayment = async ({
+  evt,
+  selectedEventType,
+  paymentAppCredentials,
+  booking,
+  bookerName,
+  bookerEmail,
+  bookerPhoneNumber,
+  isDryRun = false,
+}: {
+  evt: CalendarEvent;
+  selectedEventType: Pick<CompleteEventType, "metadata" | "title">;
   paymentAppCredentials: {
     key: Prisma.JsonValue;
     appId: EventTypeAppsList;
     app: {
       dirName: string;
       categories: AppCategories[];
     } | null;
-  },
+  };
   booking: {
     user: { email: string | null; name: string | null; timeZone: string; username: string | null } | null;
     id: number;
     userId: number | null;
     startTime: { toISOString: () => string };
     uid: string;
-  },
-  bookerName: string,
-  bookerEmail: string,
-  bookerPhoneNumber?: string | null
-) => {
+  };
+  bookerName: string;
+  bookerEmail: string;
+  bookerPhoneNumber?: string | null;
+  isDryRun?: boolean;
+}) => {
+  if (isDryRun) return null;
   const paymentApp = (await appStore[
     paymentAppCredentials?.app?.dirName as keyof typeof appStore
   ]?.()) as PaymentApp;