Merge master

2025-05-02 14:01:50 +02:00
parent db3e9e6cd9 74d37dad93
commit f450f2a5db
116 changed files with 2531 additions and 1682 deletions
--- a/apps/scandic-web/server/routers/booking/input.ts
+++ b/apps/scandic-web/server/routers/booking/input.ts
@@ -103,7 +103,7 @@ export const createBookingInput = z.object({
 })

 export const addPackageInput = z.object({
-  confirmationNumber: z.string(),
+  refId: z.string(),
  ancillaryComment: z.string(),
  ancillaryDeliveryTime: z.string().nullish(),
  packages: z.array(
@@ -117,27 +117,22 @@ export const addPackageInput = z.object({
 })

 export const removePackageInput = z.object({
-  confirmationNumber: z.string(),
+  refId: z.string(),
  codes: z.array(z.string()),
  language: z.nativeEnum(Lang).transform((val) => langToApiLang[val]),
 })

 export const priceChangeInput = z.object({
-  confirmationNumber: z.string(),
+  refId: z.string(),
 })

-export const cancelBookingInput = z.object({
-  confirmationNumber: z.string(),
-  language: z.nativeEnum(Lang).transform((val) => langToApiLang[val]),
-})
-
-export const cancelManyBookingsInput = z.object({
-  confirmationNumbers: z.array(z.string()),
-  language: z.nativeEnum(Lang).transform((val) => langToApiLang[val]),
+export const cancelBookingsInput = z.object({
+  refIds: z.array(z.string()),
+  lang: z.nativeEnum(Lang),
 })

 export const guaranteeBookingInput = z.object({
-  confirmationNumber: z.string(),
+  refId: z.string(),
  card: z
    .object({
      alias: z.string(),
@@ -161,7 +156,7 @@ export const createRefIdInput = z.object({
 })

 export const updateBookingInput = z.object({
-  confirmationNumber: z.string(),
+  refId: z.string(),
  checkInDate: z.string().optional(),
  checkOutDate: z.string().optional(),
  guest: z
@@ -173,20 +168,14 @@ export const updateBookingInput = z.object({
    .optional(),
 })

-// Query
-const confirmationNumberInput = z.object({
-  confirmationNumber: z.string(),
+export const bookingConfirmationInput = z.object({
+  refId: z.string(),
  lang: z.nativeEnum(Lang).optional(),
 })

-export const getBookingInput = confirmationNumberInput
 export const getLinkedReservationsInput = z.object({
+  refId: z.string(),
  lang: z.nativeEnum(Lang).optional(),
-  rooms: z.array(
-    z.object({
-      confirmationNumber: z.string(),
-    })
-  ),
 })

 export const findBookingInput = z.object({
@@ -199,4 +188,15 @@ export const findBookingInput = z.object({

 export type LinkedReservationsInput = z.input<typeof getLinkedReservationsInput>

-export const getBookingStatusInput = confirmationNumberInput
+export const getBookingStatusInput = z.object({
+  refId: z.string(),
+})
+
+export const getBookingConfirmationErrorInput = z.object({
+  refId: z.string(),
+})
+
+export const getConfirmationCompletedInput = z.object({
+  refId: z.string(),
+  lang: z.nativeEnum(Lang),
+})
--- a/apps/scandic-web/server/routers/booking/mutation.ts
+++ b/apps/scandic-web/server/routers/booking/mutation.ts
@@ -1,19 +1,21 @@
 import * as api from "@/lib/api"
 import { getMembershipNumber } from "@/server/routers/user/utils"
 import { createCounter } from "@/server/telemetry"
+import { getUserOrServiceToken } from "@/server/tokenManager"
 import { router, safeProtectedServiceProcedure } from "@/server/trpc"

+import { parseRefId } from "@/utils/refId"
+
 import {
  addPackageInput,
-  cancelBookingInput,
-  cancelManyBookingsInput,
+  cancelBookingsInput,
  createBookingInput,
  guaranteeBookingInput,
  priceChangeInput,
  removePackageInput,
  updateBookingInput,
 } from "./input"
-import { bookingConfirmationSchema, createBookingSchema } from "./output"
+import { bookingSchema, createBookingSchema } from "./output"
 import { cancelBooking } from "./utils"

 export const bookingMutationRouter = router({
@@ -74,8 +76,17 @@ export const bookingMutationRouter = router({
    }),
  priceChange: safeProtectedServiceProcedure
    .input(priceChangeInput)
+    .use(async ({ input, next }) => {
+      const { confirmationNumber } = parseRefId(input.refId)
+
+      return next({
+        ctx: {
+          confirmationNumber,
+        },
+      })
+    })
    .mutation(async function ({ ctx, input }) {
-      const { confirmationNumber } = input
+      const { confirmationNumber } = ctx

      const priceChangeCounter = createCounter("trpc.booking", "price-change")
      const metricsPriceChange = priceChangeCounter.init({ confirmationNumber })
@@ -110,24 +121,29 @@ export const bookingMutationRouter = router({

      metricsPriceChange.success()

-      return verifiedData.data
+      return verifiedData.data.id
    }),
  cancel: safeProtectedServiceProcedure
-    .input(cancelBookingInput)
+    .input(cancelBookingsInput)
+    .use(async ({ input, next }) => {
+      const confirmationNumbers = input.refIds.map((refId) => {
+        const { confirmationNumber } = parseRefId(refId)
+        return confirmationNumber
+      })
+
+      return next({
+        ctx: {
+          confirmationNumbers,
+        },
+      })
+    })
    .mutation(async function ({ ctx, input }) {
-      const token = ctx.session?.token.access_token ?? ctx.serviceToken
-      const { confirmationNumber, language } = input
-      return await cancelBooking(confirmationNumber, language, token)
-    }),
-  cancelMany: safeProtectedServiceProcedure
-    .input(cancelManyBookingsInput)
-    .mutation(async function ({ ctx, input }) {
-      const token = ctx.session?.token.access_token ?? ctx.serviceToken
-      const { confirmationNumbers, language } = input
+      const { confirmationNumbers } = ctx
+      const { lang } = input

      const responses = await Promise.allSettled(
        confirmationNumbers.map((confirmationNumber) =>
-          cancelBooking(confirmationNumber, language, token)
+          cancelBooking(confirmationNumber, lang)
        )
      )

@@ -152,10 +168,19 @@ export const bookingMutationRouter = router({
    }),
  packages: safeProtectedServiceProcedure
    .input(addPackageInput)
+    .use(async ({ input, next }) => {
+      const { confirmationNumber } = parseRefId(input.refId)
+
+      return next({
+        ctx: {
+          confirmationNumber,
+        },
+      })
+    })
    .mutation(async function ({ ctx, input }) {
      const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
-      const { confirmationNumber, ...body } = input
-
+      const { refId, ...body } = input
+      const { confirmationNumber } = ctx
      const addPackageCounter = createCounter("trpc.booking", "package.add")
      const metricsAddPackage = addPackageCounter.init({ confirmationNumber })

@@ -191,10 +216,19 @@ export const bookingMutationRouter = router({
    }),
  guarantee: safeProtectedServiceProcedure
    .input(guaranteeBookingInput)
+    .use(async ({ input, next }) => {
+      const { confirmationNumber } = parseRefId(input.refId)
+
+      return next({
+        ctx: {
+          confirmationNumber,
+        },
+      })
+    })
    .mutation(async function ({ ctx, input }) {
      const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
-      const { confirmationNumber, language, ...body } = input
-
+      const { refId, language, ...body } = input
+      const { confirmationNumber } = ctx
      const guaranteeBookingCounter = createCounter("trpc.booking", "guarantee")
      const metricsGuaranteeBooking = guaranteeBookingCounter.init({
        confirmationNumber,
@@ -233,10 +267,16 @@ export const bookingMutationRouter = router({
    }),
  update: safeProtectedServiceProcedure
    .input(updateBookingInput)
+    .use(async ({ input, next }) => {
+      const { confirmationNumber } = parseRefId(input.refId)
+      return next({
+        ctx: {
+          confirmationNumber,
+        },
+      })
+    })
    .mutation(async function ({ ctx, input }) {
-      const accessToken = ctx.session?.token.access_token || ctx.serviceToken
-      const { confirmationNumber, ...body } = input
-
+      const { confirmationNumber } = ctx
      const updateBookingCounter = createCounter("trpc.booking", "update")
      const metricsUpdateBooking = updateBookingCounter.init({
        confirmationNumber,
@@ -244,12 +284,17 @@ export const bookingMutationRouter = router({

      metricsUpdateBooking.start()

+      const token = getUserOrServiceToken()
      const apiResponse = await api.put(
        api.endpoints.v1.Booking.booking(confirmationNumber),
        {
-          body,
+          body: {
+            checkInDate: input.checkInDate,
+            checkOutDate: input.checkOutDate,
+            guest: input.guest,
+          },
          headers: {
-            Authorization: `Bearer ${accessToken}`,
+            Authorization: `Bearer ${token}`,
          },
        }
      )
@@ -261,7 +306,7 @@ export const bookingMutationRouter = router({

      const apiJson = await apiResponse.json()

-      const verifiedData = bookingConfirmationSchema.safeParse(apiJson)
+      const verifiedData = bookingSchema.safeParse(apiJson)
      if (!verifiedData.success) {
        metricsUpdateBooking.validationError(verifiedData.error)
        return null
@@ -269,14 +314,23 @@ export const bookingMutationRouter = router({

      metricsUpdateBooking.success()

-      return verifiedData.data
+      return verifiedData.data.refId
    }),
  removePackage: safeProtectedServiceProcedure
    .input(removePackageInput)
+    .use(async ({ input, next }) => {
+      const { confirmationNumber } = parseRefId(input.refId)
+
+      return next({
+        ctx: {
+          confirmationNumber,
+        },
+      })
+    })
    .mutation(async function ({ ctx, input }) {
      const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
-      const { confirmationNumber, codes, language } = input
-
+      const { codes, language } = input
+      const { confirmationNumber } = ctx
      const removePackageCounter = createCounter(
        "trpc.booking",
        "package.remove"
@@ -297,7 +351,7 @@ export const bookingMutationRouter = router({
        api.endpoints.v1.Booking.packages(confirmationNumber),
        {
          headers,
-        } as RequestInit,
+        },
        [["language", language], ...codes.map((code) => ["codes", code])]
      )

--- a/apps/scandic-web/server/routers/booking/output.ts
+++ b/apps/scandic-web/server/routers/booking/output.ts
@@ -2,6 +2,7 @@ import { z } from "zod"

 import { BookingStatusEnum, ChildBedTypeEnum } from "@/constants/booking"

+import { calculateRefId } from "@/utils/refId"
 import { nullableArrayObjectValidator } from "@/utils/zod/arrayValidator"
 import { nullableIntValidator } from "@/utils/zod/numberValidator"
 import {
@@ -78,7 +79,13 @@ export const createBookingSchema = z
    type: d.data.type,
    reservationStatus: d.data.attributes.reservationStatus,
    paymentUrl: d.data.attributes.paymentUrl,
-    rooms: d.data.attributes.rooms,
+    rooms: d.data.attributes.rooms.map((room) => {
+      const lastName = d.data.attributes.guest?.lastName || ""
+      return {
+        ...room,
+        refId: calculateRefId(room.confirmationNumber, lastName),
+      }
+    }),
    errors: d.data.attributes.errors,
    guest: d.data.attributes.guest,
  }))
@@ -195,7 +202,7 @@ const linksSchema = z.object({
    .nullable(),
 })

-export const bookingConfirmationSchema = z
+export const bookingSchema = z
  .object({
    data: z.object({
      attributes: z.object({
@@ -248,6 +255,19 @@ export const bookingConfirmationSchema = z
  })
  .transform(({ data }) => ({
    ...data.attributes,
+    refId: calculateRefId(
+      data.attributes.confirmationNumber,
+      data.attributes.guest.lastName
+    ),
+    linkedReservations: data.attributes.linkedReservations.map(
+      (linkedReservation) => {
+        const lastName = data.attributes.guest.lastName
+        return {
+          ...linkedReservation,
+          refId: calculateRefId(linkedReservation.confirmationNumber, lastName),
+        }
+      }
+    ),
    packages: data.attributes.packages.filter((p) => p.type !== "Ancillary"),
    ancillaries: data.attributes.packages.filter((p) => p.type === "Ancillary"),
    extraBedTypes: data.attributes.childBedPreferences,
--- a/apps/scandic-web/server/routers/booking/query.ts
+++ b/apps/scandic-web/server/routers/booking/query.ts
@@ -1,3 +1,5 @@
+import { BookingStatusEnum } from "@/constants/booking"
+import { bookingConfirmation } from "@/constants/routes/hotelReservation"
 import * as api from "@/lib/api"
 import { badRequestError, serverErrorByStatus } from "@/server/errors/trpc"
 import { createCounter } from "@/server/telemetry"
@@ -6,39 +8,47 @@ import {
  safeProtectedServiceProcedure,
  serviceProcedure,
 } from "@/server/trpc"
+import { getBookedHotelRoom } from "@/stores/my-stay"
+
+import { calculateRefId, parseRefId } from "@/utils/refId"

 import { getHotel } from "../hotels/utils"
-import { encrypt } from "../utils/encryption"
 import {
+  bookingConfirmationInput,
  createRefIdInput,
  findBookingInput,
-  getBookingInput,
+  getBookingConfirmationErrorInput,
  getBookingStatusInput,
+  getConfirmationCompletedInput,
  getLinkedReservationsInput,
 } from "./input"
 import { createBookingSchema } from "./output"
-import { findBooking, getBookedHotelRoom, getBooking } from "./utils"
+import { findBooking, getBooking, getLinkedReservations } from "./utils"
+
+import type { BookingSchema } from "@/types/trpc/routers/booking/confirmation"

 export const bookingQueryRouter = router({
-  get: safeProtectedServiceProcedure
-    .input(getBookingInput)
+  confirmation: safeProtectedServiceProcedure
+    .input(bookingConfirmationInput)
    .use(async ({ ctx, input, next }) => {
      const lang = input.lang ?? ctx.lang
-      const token = ctx.session?.token.access_token ?? ctx.serviceToken
+      const { confirmationNumber } = parseRefId(input.refId)
      return next({
        ctx: {
          lang,
-          token,
+          confirmationNumber,
        },
      })
    })
-    .query(async function ({ ctx, input: { confirmationNumber } }) {
+    .query(async function ({
+      ctx: { confirmationNumber, lang, serviceToken },
+    }) {
      const getBookingCounter = createCounter("trpc.booking", "get")
      const metricsGetBooking = getBookingCounter.init({ confirmationNumber })

      metricsGetBooking.start()

-      const booking = await getBooking(confirmationNumber, ctx.lang, ctx.token)
+      const booking = await getBooking(confirmationNumber, lang)

      if (!booking) {
        metricsGetBooking.dataError(
@@ -52,9 +62,9 @@ export const bookingQueryRouter = router({
        {
          hotelId: booking.hotelId,
          isCardOnlyPayment: false,
-          language: ctx.lang,
+          language: lang,
        },
-        ctx.serviceToken
+        serviceToken
      )

      if (!hotelData) {
@@ -68,15 +78,29 @@ export const bookingQueryRouter = router({
        throw serverErrorByStatus(404)
      }

+      const room = getBookedHotelRoom(
+        hotelData.roomCategories,
+        booking.roomTypeCode
+      )
+
+      if (!room) {
+        metricsGetBooking.dataError(
+          `Failed to extract booked room ${booking.roomTypeCode} from room categories for ${booking.hotelId}`,
+          {
+            roomTypeCode: booking.roomTypeCode,
+            hotelId: booking.hotelId,
+          }
+        )
+
+        throw serverErrorByStatus(404)
+      }
+
      metricsGetBooking.success()

      return {
-        ...hotelData,
+        hotelData,
        booking,
-        room: getBookedHotelRoom(
-          hotelData.roomCategories,
-          booking.roomTypeCode
-        ),
+        room,
      }
    }),
  findBooking: safeProtectedServiceProcedure
@@ -128,109 +152,248 @@ export const bookingQueryRouter = router({
        throw serverErrorByStatus(404)
      }

+      const room = getBookedHotelRoom(
+        hotelData.roomCategories,
+        booking.roomTypeCode
+      )
+
+      if (!room) {
+        metricsFindBooking.dataError(
+          `Failed to extract booked room ${booking.roomTypeCode} from room categories for ${booking.hotelId}`,
+          {
+            roomTypeCode: booking.roomTypeCode,
+            hotelId: booking.hotelId,
+          }
+        )
+
+        throw serverErrorByStatus(404)
+      }
+
      metricsFindBooking.success()

      return {
-        ...hotelData,
+        hotelData,
        booking,
-        room: getBookedHotelRoom(
-          hotelData.roomCategories,
-          booking.roomTypeCode
-        ),
+        room,
      }
    }),
  linkedReservations: safeProtectedServiceProcedure
    .input(getLinkedReservationsInput)
    .use(async ({ ctx, input, next }) => {
      const lang = input.lang ?? ctx.lang
-      const token = ctx.session?.token.access_token ?? ctx.serviceToken
+      const { confirmationNumber } = parseRefId(input.refId)
+
      return next({
        ctx: {
          lang,
-          token,
+          confirmationNumber,
        },
      })
    })
-    .query(async function ({ ctx, input: { rooms } }) {
-      const getLinkedReservationsCounter = createCounter(
+    .query(async function ({ ctx: { confirmationNumber, lang } }) {
+      const linkedReservationsCounter = createCounter(
        "trpc.booking",
        "linkedReservations"
      )
-      const metricsGetLinkedReservations = getLinkedReservationsCounter.init({
-        confirmationNumbers: rooms,
+      const metricsLinkedReservations = linkedReservationsCounter.init({
+        confirmationNumber,
      })

-      metricsGetLinkedReservations.start()
+      metricsLinkedReservations.start()

-      const linkedReservationsResult = await Promise.allSettled(
-        rooms.map((room) =>
-          getBooking(room.confirmationNumber, ctx.lang, ctx.token)
-        )
+      const linkedReservations = await getLinkedReservations(
+        confirmationNumber,
+        lang
      )
-      const linkedReservations = []
-      for (const booking of linkedReservationsResult) {
-        if (booking.status === "fulfilled") {
-          if (booking.value) {
-            linkedReservations.push(booking.value)
-          } else {
-            metricsGetLinkedReservations.dataError(
-              `Unexpected value for linked reservation`
-            )
-          }
-        } else {
-          metricsGetLinkedReservations.dataError(
-            `Failed to get linked reservation`
+
+      if (!linkedReservations) {
+        metricsLinkedReservations.noDataError()
+        return null
+      }
+
+      const validLinkedReservations = linkedReservations.reduce<
+        BookingSchema[]
+      >((acc, linkedReservation) => {
+        if ("error" in linkedReservation) {
+          metricsLinkedReservations.dataError(
+            `Failed to get linked reservations ${linkedReservation.confirmationNumber}`,
+            {
+              linkedReservationConfirmationNumber:
+                linkedReservation.confirmationNumber,
+            }
          )
+          return acc
        }
-      }

-      metricsGetLinkedReservations.success()
+        acc.push(linkedReservation)
+        return acc
+      }, [])

-      return linkedReservations
+      metricsLinkedReservations.success()
+
+      return validLinkedReservations
    }),
-  status: serviceProcedure.input(getBookingStatusInput).query(async function ({
-    ctx,
-    input,
-  }) {
-    const { confirmationNumber } = input
+  status: serviceProcedure
+    .input(getBookingStatusInput)
+    .use(async ({ input, next }) => {
+      const { confirmationNumber } = parseRefId(input.refId)

-    const getBookingStatusCounter = createCounter("trpc.booking", "status")
-    const metricsGetBookingStatus = getBookingStatusCounter.init({
-      confirmationNumber,
-    })
-
-    metricsGetBookingStatus.start()
-
-    const apiResponse = await api.get(
-      api.endpoints.v1.Booking.status(confirmationNumber),
-      {
-        headers: {
-          Authorization: `Bearer ${ctx.serviceToken}`,
+      return next({
+        ctx: {
+          confirmationNumber,
        },
+      })
+    })
+    .query(async function ({ ctx: { confirmationNumber, serviceToken } }) {
+      const getBookingStatusCounter = createCounter("trpc.booking", "status")
+      const metricsGetBookingStatus = getBookingStatusCounter.init({
+        confirmationNumber,
+      })
+
+      metricsGetBookingStatus.start()
+
+      const apiResponse = await api.get(
+        api.endpoints.v1.Booking.status(confirmationNumber),
+        {
+          headers: {
+            Authorization: `Bearer ${serviceToken}`,
+          },
+        }
+      )
+
+      if (!apiResponse.ok) {
+        await metricsGetBookingStatus.httpError(apiResponse)
+        throw serverErrorByStatus(apiResponse.status, apiResponse)
      }
-    )

-    if (!apiResponse.ok) {
-      await metricsGetBookingStatus.httpError(apiResponse)
-      throw serverErrorByStatus(apiResponse.status, apiResponse)
-    }
+      const apiJson = await apiResponse.json()
+      const verifiedData = createBookingSchema.safeParse(apiJson)
+      if (!verifiedData.success) {
+        metricsGetBookingStatus.validationError(verifiedData.error)
+        throw badRequestError()
+      }

-    const apiJson = await apiResponse.json()
-    const verifiedData = createBookingSchema.safeParse(apiJson)
-    if (!verifiedData.success) {
-      metricsGetBookingStatus.validationError(verifiedData.error)
-      throw badRequestError()
-    }
+      metricsGetBookingStatus.success()

-    metricsGetBookingStatus.success()
+      return verifiedData.data
+    }),
+
+  confirmationCompleted: serviceProcedure
+    .input(getConfirmationCompletedInput)
+    .use(async ({ input, next }) => {
+      const { confirmationNumber } = parseRefId(input.refId)
+
+      return next({
+        ctx: {
+          confirmationNumber,
+        },
+      })
+    })
+    .query(async function ({ ctx, input }) {
+      const { confirmationNumber } = ctx
+
+      const confirmationCompletedCounter = createCounter(
+        "trpc.booking",
+        "confirmationCompleted"
+      )
+      const metricsConfirmationCompleted = confirmationCompletedCounter.init({
+        confirmationNumber,
+      })
+
+      metricsConfirmationCompleted.start()
+
+      const apiResponse = await api.get(
+        api.endpoints.v1.Booking.status(confirmationNumber),
+        {
+          headers: {
+            Authorization: `Bearer ${ctx.serviceToken}`,
+          },
+        }
+      )
+
+      if (!apiResponse.ok) {
+        await metricsConfirmationCompleted.httpError(apiResponse)
+        throw serverErrorByStatus(apiResponse.status, apiResponse)
+      }
+
+      const apiJson = await apiResponse.json()
+      const verifiedData = createBookingSchema.safeParse(apiJson)
+      if (!verifiedData.success) {
+        metricsConfirmationCompleted.validationError(verifiedData.error)
+        throw badRequestError()
+      }
+
+      const confirmationUrl =
+        verifiedData.data.reservationStatus ===
+        BookingStatusEnum.BookingCompleted
+          ? `${bookingConfirmation(input.lang)}?RefId=${verifiedData.data.rooms[0].refId}`
+          : ""
+
+      const result = {
+        ...verifiedData.data,
+        redirectUrl: verifiedData.data.paymentUrl || confirmationUrl,
+      }
+
+      metricsConfirmationCompleted.success()
+
+      return result
+    }),
+
+  confirmationError: serviceProcedure
+    .input(getBookingConfirmationErrorInput)
+    .use(async ({ input, next }) => {
+      const { confirmationNumber } = parseRefId(input.refId)
+
+      return next({
+        ctx: {
+          confirmationNumber,
+        },
+      })
+    })
+    .query(async function ({ ctx }) {
+      const { confirmationNumber } = ctx
+
+      const confirmationErrorCounter = createCounter(
+        "trpc.booking",
+        "confirmationError"
+      )
+      const metricsConfirmationError = confirmationErrorCounter.init({
+        confirmationNumber,
+      })
+
+      metricsConfirmationError.start()
+
+      const apiResponse = await api.get(
+        api.endpoints.v1.Booking.status(confirmationNumber),
+        {
+          headers: {
+            Authorization: `Bearer ${ctx.serviceToken}`,
+          },
+        }
+      )
+
+      if (!apiResponse.ok) {
+        await metricsConfirmationError.httpError(apiResponse)
+        throw serverErrorByStatus(apiResponse.status, apiResponse)
+      }
+
+      const apiJson = await apiResponse.json()
+      const verifiedData = createBookingSchema.safeParse(apiJson)
+      if (!verifiedData.success) {
+        metricsConfirmationError.validationError(verifiedData.error)
+        throw badRequestError()
+      }
+
+      metricsConfirmationError.success()
+
+      return verifiedData.data
+    }),

-    return verifiedData.data
-  }),
  createRefId: serviceProcedure
    .input(createRefIdInput)
    .mutation(async function ({ input }) {
      const { confirmationNumber, lastName } = input
-      const encryptedRefId = encrypt(`${confirmationNumber},${lastName}`)
+      const encryptedRefId = calculateRefId(confirmationNumber, lastName)

      if (!encryptedRefId) {
        throw serverErrorByStatus(422, "Was not able to encrypt ref id")
--- a/apps/scandic-web/server/routers/booking/utils.ts
+++ b/apps/scandic-web/server/routers/booking/utils.ts
@@ -1,81 +1,163 @@
 import * as api from "@/lib/api"
 import { badRequestError, serverErrorByStatus } from "@/server/errors/trpc"
 import { createCounter } from "@/server/telemetry"
+import { getUserOrServiceToken } from "@/server/tokenManager"
 import { toApiLang } from "@/server/utils"

-import { bookingConfirmationSchema, createBookingSchema } from "./output"
+import { getCacheClient } from "@/services/dataCache"

-import type { Room } from "@/types/hotel"
-import type { BookingConfirmation } from "@/types/trpc/routers/booking/confirmation"
+import { bookingSchema, createBookingSchema } from "./output"
+
+import type { BookingSchema } from "@/types/trpc/routers/booking/confirmation"
 import type { Lang } from "@/constants/languages"

-export function getBookedHotelRoom(
-  rooms: Room[] | undefined,
-  roomTypeCode: BookingConfirmation["booking"]["roomTypeCode"]
-) {
-  if (!rooms?.length || !roomTypeCode) {
-    return null
-  }
-  const room = rooms?.find((r) => {
-    return r.roomTypes.find((roomType) => roomType.code === roomTypeCode)
-  })
-  if (!room) {
-    return null
-  }
-  const bedType = room.roomTypes.find(
-    (roomType) => roomType.code === roomTypeCode
-  )
-  if (!bedType) {
-    return null
-  }
-  return {
-    ...room,
-    bedType,
-  }
-}
-
-export async function getBooking(
-  confirmationNumber: string,
-  lang: Lang,
-  token: string
-) {
+export async function getBooking(confirmationNumber: string, lang: Lang) {
  const getBookingCounter = createCounter("booking", "get")
  const metricsGetBooking = getBookingCounter.init({ confirmationNumber })

  metricsGetBooking.start()

-  const apiResponse = await api.get(
-    api.endpoints.v1.Booking.booking(confirmationNumber),
+  const cacheKey = `${lang}:booking:${confirmationNumber}`
+  const cache = await getCacheClient()
+
+  const result: BookingSchema | null = await cache.cacheOrGet(
+    cacheKey,
+    async () => {
+      const token = getUserOrServiceToken()
+
+      const apiResponse = await api.get(
+        api.endpoints.v1.Booking.booking(confirmationNumber),
+        {
+          headers: {
+            Authorization: `Bearer ${token}`,
+          },
+        },
+        { language: toApiLang(lang) }
+      )
+
+      if (!apiResponse.ok) {
+        await metricsGetBooking.httpError(apiResponse)
+
+        // If the booking is not found, return null.
+        // This scenario is expected to happen when a logged in user trying to access a booking that doesn't belong to them.
+        if (apiResponse.status === 400) {
+          return null
+        }
+
+        throw serverErrorByStatus(apiResponse.status, apiResponse)
+      }
+
+      const apiJson = await apiResponse.json()
+      const booking = bookingSchema.safeParse(apiJson)
+      if (!booking.success) {
+        metricsGetBooking.validationError(booking.error)
+        throw badRequestError()
+      }
+
+      return booking.data
+    },
+    "1h"
+  )
+
+  metricsGetBooking.success()
+
+  return result
+}
+
+export async function getBookings(confirmationNumbers: string[], lang: Lang) {
+  const results = await Promise.allSettled(
+    confirmationNumbers.map((confirmationNumber) => {
+      return getBooking(confirmationNumber, lang)
+    })
+  )
+
+  return results.map((result) => {
+    if (result.status === "fulfilled" && result.value) {
+      return result.value
+    }
+    return null
+  })
+}
+
+export async function getLinkedReservations(
+  confirmationNumber: string,
+  lang: Lang
+) {
+  const booking = await getBooking(confirmationNumber, lang)
+
+  if (!booking) {
+    return null
+  }
+
+  if (booking.linkedReservations.length > 0) {
+    const confirmationNumbers = booking.linkedReservations.map(
+      (linkedReservation) => {
+        return linkedReservation.confirmationNumber
+      }
+    )
+
+    const bookings = await getBookings(confirmationNumbers, lang)
+
+    const linkedReservations = bookings.map((booking, i) => {
+      if (booking === null) {
+        return {
+          confirmationNumber: confirmationNumbers[i],
+          error: true,
+        } as const
+      }
+      return booking
+    })
+
+    return linkedReservations
+  }
+
+  return []
+}
+
+export async function cancelBooking(confirmationNumber: string, lang: Lang) {
+  const cancelBookingCounter = createCounter("booking", "cancel")
+  const metricsCancelBooking = cancelBookingCounter.init({
+    confirmationNumber,
+    lang,
+  })
+
+  metricsCancelBooking.start()
+
+  const token = getUserOrServiceToken()
+  const headers = {
+    Authorization: `Bearer ${token}`,
+  }
+
+  const booking = await getBooking(confirmationNumber, lang)
+  if (!booking) {
+    metricsCancelBooking.noDataError({ confirmationNumber })
+    return null
+  }
+  const { firstName, lastName, email } = booking.guest
+  const apiResponse = await api.remove(
+    api.endpoints.v1.Booking.cancel(confirmationNumber),
    {
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
+      headers,
+      body: { firstName, lastName, email },
    },
    { language: toApiLang(lang) }
  )

  if (!apiResponse.ok) {
-    await metricsGetBooking.httpError(apiResponse)
-
-    // If the booking is not found, return null.
-    // This scenario is expected to happen when a logged in user trying to access a booking that doesn't belong to them.
-    if (apiResponse.status === 400) {
-      return null
-    }
-
-    throw serverErrorByStatus(apiResponse.status, apiResponse)
+    await metricsCancelBooking.httpError(apiResponse)
+    return null
  }

  const apiJson = await apiResponse.json()
-  const booking = bookingConfirmationSchema.safeParse(apiJson)
-  if (!booking.success) {
-    metricsGetBooking.validationError(booking.error)
-    throw badRequestError()
+  const verifiedData = createBookingSchema.safeParse(apiJson)
+  if (!verifiedData.success) {
+    metricsCancelBooking.validationError(verifiedData.error)
+    return null
  }

-  metricsGetBooking.success()
+  metricsCancelBooking.success()

-  return booking.data
+  return verifiedData.data
 }

 export async function findBooking(
@@ -124,7 +206,7 @@ export async function findBooking(
  }

  const apiJson = await apiResponse.json()
-  const booking = bookingConfirmationSchema.safeParse(apiJson)
+  const booking = bookingSchema.safeParse(apiJson)
  if (!booking.success) {
    metricsGetBooking.validationError(booking.error)
    throw badRequestError()
@@ -134,52 +216,3 @@ export async function findBooking(

  return booking.data
 }
-
-export async function cancelBooking(
-  confirmationNumber: string,
-  language: string,
-  token: string
-) {
-  const cancellationReason = {
-    reasonCode: "WEB-CANCEL",
-    reason: "WEB-CANCEL",
-  }
-
-  const cancelBookingCounter = createCounter("booking", "cancel")
-  const metricsCancelBooking = cancelBookingCounter.init({
-    cancellationReason,
-    confirmationNumber,
-    language,
-  })
-
-  metricsCancelBooking.start()
-
-  const headers = {
-    Authorization: `Bearer ${token}`,
-  }
-
-  const apiResponse = await api.remove(
-    api.endpoints.v1.Booking.cancel(confirmationNumber),
-    {
-      headers,
-      body: JSON.stringify(cancellationReason),
-    } as RequestInit,
-    { language }
-  )
-
-  if (!apiResponse.ok) {
-    await metricsCancelBooking.httpError(apiResponse)
-    return false
-  }
-
-  const apiJson = await apiResponse.json()
-  const verifiedData = createBookingSchema.safeParse(apiJson)
-  if (!verifiedData.success) {
-    metricsCancelBooking.validationError(verifiedData.error)
-    return null
-  }
-
-  metricsCancelBooking.success()
-
-  return verifiedData.data
-}
--- a/apps/scandic-web/server/routers/user/utils.ts
+++ b/apps/scandic-web/server/routers/user/utils.ts
@@ -4,10 +4,10 @@ import { myStay } from "@/constants/routes/myStay"
 import { env } from "@/env/server"
 import * as api from "@/lib/api"
 import { dt } from "@/lib/dt"
-import { encrypt } from "@/server/routers/utils/encryption"
 import { createCounter } from "@/server/telemetry"

 import { cache } from "@/utils/cache"
+import { encrypt } from "@/utils/encryption"
 import * as maskValue from "@/utils/maskValue"
 import { isValidSession } from "@/utils/session"
 import { getCurrentWebUrl } from "@/utils/url"
--- a/apps/scandic-web/server/routers/utils/encryption.ts
+++ b/apps/scandic-web/server/routers/utils/encryption.ts
@@ -1,54 +0,0 @@
-import "server-only"
-
-import crypto from "crypto"
-
-import { env } from "@/env/server"
-
-export { decrypt, encrypt }
-
-const algorithm = "DES-ECB"
-const encryptionKey = env.BOOKING_ENCRYPTION_KEY
-const bufferKey = Buffer.from(encryptionKey, "utf8")
-
-function encrypt(originalString: string) {
-  try {
-    const cipher = crypto.createCipheriv(algorithm, bufferKey, null)
-    cipher.setAutoPadding(false)
-    const bufferString = Buffer.from(originalString, "utf8")
-    const paddingSize =
-      bufferKey.length - (bufferString.length % bufferKey.length)
-    const paddedStr = Buffer.concat([
-      bufferString,
-      Buffer.alloc(paddingSize, 0),
-    ])
-    const buffers: Buffer[] = []
-    buffers.push(cipher.update(paddedStr))
-    buffers.push(cipher.final())
-    const result = Buffer.concat(buffers).toString("base64").replace(/\+/g, "-")
-    return result
-  } catch (e) {
-    console.log(e)
-    return ""
-  }
-}
-
-function decrypt(encryptedString: string) {
-  try {
-    const decipher = crypto.createDecipheriv(algorithm, bufferKey, null)
-    decipher.setAutoPadding(false)
-    const buffers: Buffer[] = []
-    buffers.push(decipher.update(encryptedString, "base64"))
-    buffers.push(decipher.final())
-    const result = Buffer.concat(buffers)
-      .toString("utf8")
-      /*
-       * Hexadecimal byte (null byte) replace. These occur when decrypting because
-       * we're disabling the auto padding for historical/compatibility reasons.
-       */
-      .replace(/(\x00)*/g, "")
-    return result
-  } catch (e) {
-    console.log(e)
-    return ""
-  }
-}
--- a/apps/scandic-web/server/tokenManager.ts
+++ b/apps/scandic-web/server/tokenManager.ts
@@ -3,7 +3,9 @@ import { trace, type Tracer } from "@opentelemetry/api"
 import { env } from "@/env/server"
 import { createCounter } from "@/server/telemetry"

+import { auth } from "@/auth"
 import { getCacheClient } from "@/services/dataCache"
+import { isValidSession } from "@/utils/session"

 import type { ServiceTokenResponse } from "@/types/tokens"

@@ -117,3 +119,12 @@ async function fetchServiceToken(scopes: string[]) {
 function getServiceTokenCacheKey(scopes: string[]): string {
  return `serviceToken:${scopes.join(",")}`
 }
+
+export async function getUserOrServiceToken() {
+  const serviceToken = await getServiceToken()
+  const session = await auth()
+
+  return isValidSession(session)
+    ? session.token.access_token
+    : serviceToken.access_token
+}