feat(SW-2116): Use refId instead of confirmationNumber

apps/scandic-web/server/routers/booking/input.ts

@@ -103,7 +103,6 @@ export const createBookingInput = z.object({
 })
 
 export const addPackageInput = z.object({
-  confirmationNumber: z.string(),
   ancillaryComment: z.string(),
   ancillaryDeliveryTime: z.string().nullish(),
   packages: z.array(
@@ -117,22 +116,15 @@ export const addPackageInput = z.object({
 })
 
 export const removePackageInput = z.object({
-  confirmationNumber: z.string(),
   codes: z.array(z.string()),
   language: z.nativeEnum(Lang).transform((val) => langToApiLang[val]),
 })
 
-export const priceChangeInput = z.object({
-  confirmationNumber: z.string(),
-})
-
 export const cancelBookingsInput = z.object({
-  confirmationNumbers: z.array(z.string()),
   language: z.nativeEnum(Lang),
 })
 
 export const guaranteeBookingInput = z.object({
-  confirmationNumber: z.string(),
   card: z
     .object({
       alias: z.string(),
@@ -156,7 +148,6 @@ export const createRefIdInput = z.object({
 })
 
 export const updateBookingInput = z.object({
-  confirmationNumber: z.string(),
   checkInDate: z.string().optional(),
   checkOutDate: z.string().optional(),
   guest: z
@@ -169,19 +160,13 @@ export const updateBookingInput = z.object({
 })
 
 // Query
-const confirmationNumberInput = z.object({
-  confirmationNumber: z.string(),
+
+export const getBookingInput = z.object({
   lang: z.nativeEnum(Lang).optional(),
 })
 
-export const getBookingInput = confirmationNumberInput
 export const getLinkedReservationsInput = z.object({
   lang: z.nativeEnum(Lang).optional(),
-  rooms: z.array(
-    z.object({
-      confirmationNumber: z.string(),
-    })
-  ),
 })
 
 export const findBookingInput = z.object({
@@ -194,4 +179,6 @@ export const findBookingInput = z.object({
 
 export type LinkedReservationsInput = z.input<typeof getLinkedReservationsInput>
 
-export const getBookingStatusInput = confirmationNumberInput
+export const getBookingStatusInput = z.object({
+  lang: z.nativeEnum(Lang).optional(),
+})

apps/scandic-web/server/routers/booking/mutation.ts

@@ -1,4 +1,5 @@
 import * as api from "@/lib/api"
+import { createRefIdPlugin } from "@/server/plugins/refIdToConfirmationNumber"
 import { getMembershipNumber } from "@/server/routers/user/utils"
 import { createCounter } from "@/server/telemetry"
 import { router, safeProtectedServiceProcedure } from "@/server/trpc"
@@ -8,13 +9,14 @@ import {
   cancelBookingsInput,
   createBookingInput,
   guaranteeBookingInput,
-  priceChangeInput,
   removePackageInput,
   updateBookingInput,
 } from "./input"
 import { bookingConfirmationSchema, createBookingSchema } from "./output"
 import { cancelBooking } from "./utils"
 
+const refIdPlugin = createRefIdPlugin()
+
 export const bookingMutationRouter = router({
   create: safeProtectedServiceProcedure
     .input(createBookingInput)
@@ -72,9 +74,9 @@ export const bookingMutationRouter = router({
       return verifiedData.data
     }),
   priceChange: safeProtectedServiceProcedure
-    .input(priceChangeInput)
-    .mutation(async function ({ ctx, input }) {
-      const { confirmationNumber } = input
+    .concat(refIdPlugin.toConfirmationNumber)
+    .mutation(async function ({ ctx }) {
+      const { confirmationNumber } = ctx
 
       const priceChangeCounter = createCounter("trpc.booking", "price-change")
       const metricsPriceChange = priceChangeCounter.init({ confirmationNumber })
@@ -91,7 +93,6 @@ export const bookingMutationRouter = router({
         api.endpoints.v1.Booking.priceChange(confirmationNumber),
         {
           headers,
-          body: input,
         }
       )
 
@@ -113,9 +114,11 @@ export const bookingMutationRouter = router({
     }),
   cancel: safeProtectedServiceProcedure
     .input(cancelBookingsInput)
+    .concat(refIdPlugin.toConfirmationNumbers)
     .mutation(async function ({ ctx, input }) {
       const token = ctx.session?.token.access_token ?? ctx.serviceToken
-      const { confirmationNumbers, language } = input
+      const { confirmationNumbers } = ctx
+      const { language } = input
 
       const responses = await Promise.allSettled(
         confirmationNumbers.map((confirmationNumber) =>
@@ -144,9 +147,11 @@ export const bookingMutationRouter = router({
     }),
   packages: safeProtectedServiceProcedure
     .input(addPackageInput)
+    .concat(refIdPlugin.toConfirmationNumber)
     .mutation(async function ({ ctx, input }) {
       const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
-      const { confirmationNumber, ...body } = input
+      const { confirmationNumber } = ctx
+      const { refId, ...body } = input
 
       const addPackageCounter = createCounter("trpc.booking", "package.add")
       const metricsAddPackage = addPackageCounter.init({ confirmationNumber })
@@ -183,9 +188,11 @@ export const bookingMutationRouter = router({
     }),
   guarantee: safeProtectedServiceProcedure
     .input(guaranteeBookingInput)
+    .concat(refIdPlugin.toConfirmationNumber)
     .mutation(async function ({ ctx, input }) {
       const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
-      const { confirmationNumber, language, ...body } = input
+      const { confirmationNumber } = ctx
+      const { refId, language, ...body } = input
 
       const guaranteeBookingCounter = createCounter("trpc.booking", "guarantee")
       const metricsGuaranteeBooking = guaranteeBookingCounter.init({
@@ -225,9 +232,11 @@ export const bookingMutationRouter = router({
     }),
   update: safeProtectedServiceProcedure
     .input(updateBookingInput)
+    .concat(refIdPlugin.toConfirmationNumber)
     .mutation(async function ({ ctx, input }) {
       const accessToken = ctx.session?.token.access_token || ctx.serviceToken
-      const { confirmationNumber, ...body } = input
+      const { confirmationNumber } = ctx
+      const { refId, ...body } = input
 
       const updateBookingCounter = createCounter("trpc.booking", "update")
       const metricsUpdateBooking = updateBookingCounter.init({
@@ -265,9 +274,11 @@ export const bookingMutationRouter = router({
     }),
   removePackage: safeProtectedServiceProcedure
     .input(removePackageInput)
+    .concat(refIdPlugin.toConfirmationNumber)
     .mutation(async function ({ ctx, input }) {
       const accessToken = ctx.session?.token.access_token ?? ctx.serviceToken
-      const { confirmationNumber, codes, language } = input
+      const { confirmationNumber } = ctx
+      const { codes, language } = input
 
       const removePackageCounter = createCounter(
         "trpc.booking",

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,
   }))
@@ -248,6 +255,31 @@ export const bookingConfirmationSchema = z
   })
   .transform(({ data }) => ({
     ...data.attributes,
+    refId: calculateRefId(
+      data.attributes.confirmationNumber,
+      data.attributes.guest.lastName
+    ),
+    linkedReservations: data.attributes.linkedReservations.map(
+      (linkedReservation) => {
+        /**
+         * We lazy load linked reservations in the client.
+         * The problem is that we need to load the reservation in order to
+         * calculate the refId for the reservation as the refId uses the guest's
+         * lastname in it. Ideally we should pass a promise to the React
+         * component that uses `use()` to resolve it. But right now we use tRPC
+         * in the client. That tRPC endpoint only uses the confirmationNumber
+         * from the refId. So that means we can pass whatever as the lastname
+         * here, because it is actually never read. We should change this ASAP.
+         */
+        return {
+          ...linkedReservation,
+          refId: calculateRefId(
+            linkedReservation.confirmationNumber,
+            "" // TODO: Empty lastname here, see comment above
+          ),
+        }
+      }
+    ),
     packages: data.attributes.packages.filter((p) => p.type !== "Ancillary"),
     ancillaries: data.attributes.packages.filter((p) => p.type === "Ancillary"),
     extraBedTypes: data.attributes.childBedPreferences,

apps/scandic-web/server/routers/booking/query.ts

@@ -1,5 +1,6 @@
 import * as api from "@/lib/api"
 import { badRequestError, serverErrorByStatus } from "@/server/errors/trpc"
+import { createRefIdPlugin } from "@/server/plugins/refIdToConfirmationNumber"
 import { createCounter } from "@/server/telemetry"
 import {
   router,
@@ -7,8 +8,10 @@ import {
   serviceProcedure,
 } from "@/server/trpc"
 
+import { getBookedHotelRoom } from "@/utils/booking"
+
+import { encrypt } from "../../../utils/encryption"
 import { getHotel } from "../hotels/utils"
-import { encrypt } from "../utils/encryption"
 import {
   createRefIdInput,
   findBookingInput,
@@ -17,28 +20,31 @@ import {
   getLinkedReservationsInput,
 } from "./input"
 import { createBookingSchema } from "./output"
-import { findBooking, getBookedHotelRoom, getBooking } from "./utils"
+import { findBooking, getBooking } from "./utils"
+
+const refIdPlugin = createRefIdPlugin()
 
 export const bookingQueryRouter = router({
   get: safeProtectedServiceProcedure
     .input(getBookingInput)
+    .concat(refIdPlugin.toConfirmationNumber)
     .use(async ({ ctx, input, next }) => {
       const lang = input.lang ?? ctx.lang
-      const token = ctx.session?.token.access_token ?? ctx.serviceToken
       return next({
         ctx: {
           lang,
-          token,
         },
       })
     })
-    .query(async function ({ ctx, input: { confirmationNumber } }) {
+    .query(async function ({ ctx }) {
+      const { confirmationNumber, lang, serviceToken } = ctx
+
       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, serviceToken)
 
       if (!booking) {
         metricsGetBooking.dataError(
@@ -52,9 +58,9 @@ export const bookingQueryRouter = router({
         {
           hotelId: booking.hotelId,
           isCardOnlyPayment: false,
-          language: ctx.lang,
+          language: lang,
         },
-        ctx.serviceToken
+        serviceToken
       )
 
       if (!hotelData) {
@@ -141,6 +147,7 @@ export const bookingQueryRouter = router({
     }),
   linkedReservations: safeProtectedServiceProcedure
     .input(getLinkedReservationsInput)
+    .concat(refIdPlugin.toConfirmationNumber)
     .use(async ({ ctx, input, next }) => {
       const lang = input.lang ?? ctx.lang
       const token = ctx.session?.token.access_token ?? ctx.serviceToken
@@ -151,27 +158,36 @@ export const bookingQueryRouter = router({
         },
       })
     })
-    .query(async function ({ ctx, input: { rooms } }) {
+    .query(async function ({ ctx }) {
+      const { confirmationNumber, lang, token } = ctx
+
       const getLinkedReservationsCounter = createCounter(
         "trpc.booking",
         "linkedReservations"
       )
       const metricsGetLinkedReservations = getLinkedReservationsCounter.init({
-        confirmationNumbers: rooms,
+        confirmationNumber,
       })
 
       metricsGetLinkedReservations.start()
 
-      const linkedReservationsResult = await Promise.allSettled(
-        rooms.map((room) =>
-          getBooking(room.confirmationNumber, ctx.lang, ctx.token)
+      const booking = await getBooking(confirmationNumber, lang, token)
+
+      if (!booking) {
+        return []
+      }
+
+      const linkedReservationsResults = await Promise.allSettled(
+        booking.linkedReservations.map((linkedReservation) =>
+          getBooking(linkedReservation.confirmationNumber, lang, token)
         )
       )
+
       const linkedReservations = []
-      for (const booking of linkedReservationsResult) {
-        if (booking.status === "fulfilled") {
-          if (booking.value) {
-            linkedReservations.push(booking.value)
+      for (const linkedReservationsResult of linkedReservationsResults) {
+        if (linkedReservationsResult.status === "fulfilled") {
+          if (linkedReservationsResult.value) {
+            linkedReservations.push(linkedReservationsResult.value)
           } else {
             metricsGetLinkedReservations.dataError(
               `Unexpected value for linked reservation`
@@ -188,44 +204,44 @@ export const bookingQueryRouter = router({
 
       return linkedReservations
     }),
-  status: serviceProcedure.input(getBookingStatusInput).query(async function ({
-    ctx,
-    input,
-  }) {
-    const { confirmationNumber } = input
+  status: serviceProcedure
+    .input(getBookingStatusInput)
+    .concat(refIdPlugin.toConfirmationNumber)
+    .query(async function ({ ctx }) {
+      const { confirmationNumber } = ctx
 
-    const getBookingStatusCounter = createCounter("trpc.booking", "status")
-    const metricsGetBookingStatus = getBookingStatusCounter.init({
-      confirmationNumber,
-    })
+      const getBookingStatusCounter = createCounter("trpc.booking", "status")
+      const metricsGetBookingStatus = getBookingStatusCounter.init({
+        confirmationNumber,
+      })
 
-    metricsGetBookingStatus.start()
+      metricsGetBookingStatus.start()
 
-    const apiResponse = await api.get(
-      api.endpoints.v1.Booking.status(confirmationNumber),
-      {
-        headers: {
-          Authorization: `Bearer ${ctx.serviceToken}`,
-        },
+      const apiResponse = await api.get(
+        api.endpoints.v1.Booking.status(confirmationNumber),
+        {
+          headers: {
+            Authorization: `Bearer ${ctx.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
-  }),
+      return verifiedData.data
+    }),
   createRefId: serviceProcedure
     .input(createRefIdInput)
     .mutation(async function ({ input }) {

apps/scandic-web/server/routers/booking/utils.ts

@@ -5,35 +5,8 @@ import { toApiLang } from "@/server/utils"
 
 import { bookingConfirmationSchema, createBookingSchema } from "./output"
 
-import type { Room } from "@/types/hotel"
-import type { BookingConfirmation } from "@/types/trpc/routers/booking/confirmation"
 import type { Lang } from "@/constants/languages"
 
-export function getBookedHotelRoom(
-  rooms: Room[],
-  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,

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"

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 ""
-  }
-}