Bug fix when retrieving booking

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

@@ -92,6 +92,7 @@ const querySchema = z.object({
   isSuccessBookingPage: stringToBoolean,
   formerTime: z.string().optional(),
   seatReferenceUid: z.string().optional(),
+  alreadyRescheduled: stringToBoolean,
 });
 
 export default function Success(props: SuccessProps) {
@@ -107,6 +108,7 @@ export default function Success(props: SuccessProps) {
     formerTime,
     email,
     seatReferenceUid,
+    alreadyRescheduled,
   } = querySchema.parse(routerQuery);
 
   const attendeeTimeZone = props?.bookingInfo?.attendees.find(
@@ -283,6 +285,9 @@ export default function Success(props: SuccessProps) {
       }
       return t(`needs_to_be_confirmed_or_rejected${titleSuffix}`);
     }
+    if (alreadyRescheduled) {
+      return t("below_are_the_details_of_your_rescheduled_meeting");
+    }
     return t(`emailed_you_and_attendees${titleSuffix}`);
   }
 
@@ -396,6 +401,8 @@ export default function Success(props: SuccessProps) {
                         : t("event_cancelled")
                       : props.recurringBookings
                       ? t("meeting_is_scheduled_recurring")
+                      : alreadyRescheduled
+                      ? t("meeting_is_already_rescheduled")
                       : t("meeting_is_scheduled")}
                   </h3>
                   <div className="mt-3">

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

@@ -23,12 +23,96 @@ export async function getServerSideProps(context: GetServerSidePropsContext) {
     prisma,
     bookingUid
   );
+
+  // A booking might have been rescheduled multiple times. We need to find the last booking
+  let firstQuery = true;
+  let allBookingsQueried = false;
+  let queryUid = uid;
+  let bookingAlreadyRescheduled = false;
+
+  let bookingInRescheduleChain: {
+    uid: string;
+    fromReschedule: string | null;
+    rescheduledTo: string | null;
+  } = {
+    uid,
+    fromReschedule: null,
+    rescheduledTo: null,
+  };
+  while (!allBookingsQueried) {
+    if (firstQuery) {
+      const bookingQuery = await prisma.booking.findMany({
+        where: {
+          OR: [
+            {
+              uid: queryUid,
+            },
+            {
+              fromReschedule: queryUid,
+            },
+          ],
+        },
+
+        select: {
+          uid: true,
+          fromReschedule: true,
+          rescheduledTo: true,
+        },
+      });
+
+      bookingInRescheduleChain =
+        bookingQuery.find((booking) => {
+          if (booking.fromReschedule === uid) {
+            bookingAlreadyRescheduled = true;
+            return true;
+          } else {
+            return false;
+          }
+        }) || bookingQuery[0];
+
+      // There is not the last booking in the rescheduleChain
+      if (bookingInRescheduleChain.rescheduledTo) {
+        queryUid = bookingInRescheduleChain.rescheduledTo;
+      } else {
+        allBookingsQueried = true;
+      }
+
+      firstQuery = false;
+    } else {
+      const bookingQuery = await prisma.booking.findFirst({
+        where: {
+          uid: queryUid,
+        },
+        select: {
+          uid: true,
+          fromReschedule: true,
+          rescheduledTo: true,
+        },
+      });
+
+      // If somewhere along the chain was broken. Return the last found booking
+      if (!bookingQuery) {
+        allBookingsQueried = true;
+      } else {
+        bookingInRescheduleChain = bookingQuery;
+      }
+
+      // See if this booking was the last in the chain
+      if (bookingQuery?.rescheduledTo) {
+        queryUid = bookingQuery.rescheduledTo;
+      } else {
+        allBookingsQueried = true;
+      }
+    }
+  }
+
   const booking = await prisma.booking.findUnique({
     where: {
-      uid,
+      uid: bookingInRescheduleChain?.uid,
     },
     select: {
       ...bookingMinimalSelect,
+      uid: true,
       eventType: {
         select: {
           users: {
@@ -65,6 +149,7 @@ export async function getServerSideProps(context: GetServerSidePropsContext) {
       user: true,
     },
   });
+
   const dynamicEventSlugRef = booking?.dynamicEventSlugRef || "";
 
   if (!booking) {
@@ -73,6 +158,17 @@ export async function getServerSideProps(context: GetServerSidePropsContext) {
     } as const;
   }
 
+  // If booking with uid was already rescheduled. Show the booking that was rescheduled
+
+  if (bookingAlreadyRescheduled) {
+    return {
+      redirect: {
+        destination: `/booking/${booking.uid}?alreadyRescheduled=true`,
+        permanent: false,
+      },
+    };
+  }
+
   if (!booking?.eventType && !booking?.dynamicEventSlugRef) {
     // TODO: Show something in UI to let user know that this booking is not rescheduleable
     return {

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

@@ -2192,5 +2192,7 @@
   "uprade_to_create_instant_bookings": "Upgrade to Enterprise and let guests join an instant call that attendees can jump straight into. This is only for team event types",
   "dont_want_to_wait": "Don't want to wait?",
   "meeting_started": "Meeting Started",
+  "meeting_is_already_rescheduled": "The meeting has already been rescheduled",
+  "below_are_the_details_of_your_rescheduled_meeting": "Below is the most current information for your booking",
   "ADD_NEW_STRINGS_ABOVE_THIS_LINE_TO_PREVENT_MERGE_CONFLICTS": "↑↑↑↑↑↑↑↑↑↑↑↑↑ Add your new strings above here ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"
 }

packages/features/bookings/lib/handleNewBooking.ts

@@ -2230,6 +2230,7 @@ async function handler(
         data: {
           rescheduled: true,
           status: BookingStatus.CANCELLED,
+          rescheduledTo: booking.uid,
         },
       });
     }

packages/prisma/migrations/20231222030736_add_rescheduled_to_field/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Booking" ADD COLUMN     "rescheduledTo" TEXT;

packages/prisma/schema.prisma

@@ -443,6 +443,7 @@ model Booking {
   dynamicGroupSlugRef   String?
   rescheduled           Boolean?
   fromReschedule        String?
+  rescheduledTo         String?
   recurringEventId      String?
   smsReminderNumber     String?
   workflowReminders     WorkflowReminder[]