fix: we showed duplicate rooms because every bed represents a room

2025-03-19 10:01:05 +01:00
parent 200ed55a2c
commit cf91d3d947
12 changed files with 356 additions and 234 deletions
--- a/apps/scandic-web/server/routers/hotels/input.ts
+++ b/apps/scandic-web/server/routers/hotels/input.ts
@@ -40,7 +40,7 @@ export const roomsCombinedAvailabilityInputSchema = z.object({
        .nullable()
    )
    .nullish(),
-  hotelId: z.number(),
+  hotelId: z.string(),
  lang: z.nativeEnum(Lang),
  rateCode: z.string().optional(),
  roomStayEndDate: z.string(),
--- a/apps/scandic-web/server/routers/hotels/output.ts
+++ b/apps/scandic-web/server/routers/hotels/output.ts
@@ -33,6 +33,7 @@ import type {
 import type {
  Product,
  RateDefinition,
+  RoomConfiguration,
 } from "@/types/trpc/routers/hotel/roomAvailability"

 // NOTE: Find schema at: https://aks-test.scandichotels.com/hotel/swagger/v1/index.html
@@ -145,6 +146,142 @@ const statusLookup = {
  [AvailabilityEnum.NotAvailable]: 2,
 }

+function sortRoomConfigs(a: RoomConfiguration, b: RoomConfiguration) {
+  // @ts-expect-error - array indexing
+  return statusLookup[a.status] - statusLookup[b.status]
+}
+
+export const roomsCombinedAvailabilitySchema = z
+  .object({
+    data: z.object({
+      attributes: z.object({
+        checkInDate: z.string(),
+        checkOutDate: z.string(),
+        hotelId: z.number(),
+        mustBeGuaranteed: z.boolean().optional(),
+        occupancy: occupancySchema.optional(),
+        rateDefinitions: z.array(rateDefinitionSchema),
+        roomConfigurations: z
+          .array(roomConfigurationSchema)
+          .transform((data) => {
+            // Initial sort to guarantee if one bed is NotAvailable and whereas
+            // the other is Available to make sure data is added to the correct
+            // roomConfig
+            const configs = data.sort(sortRoomConfigs)
+            const roomConfigs = new Map<string, RoomConfiguration>()
+            for (const roomConfig of configs) {
+              if (roomConfigs.has(roomConfig.roomType)) {
+                const currentRoomConf = roomConfigs.get(roomConfig.roomType)
+                if (currentRoomConf) {
+                  currentRoomConf.features = roomConfig.features.reduce(
+                    (feats, feature) => {
+                      const currentFeatureIndex = feats.findIndex(
+                        (f) => f.code === feature.code
+                      )
+                      if (currentFeatureIndex !== -1) {
+                        feats[currentFeatureIndex].inventory =
+                          feats[currentFeatureIndex].inventory +
+                          feature.inventory
+                      } else {
+                        feats.push(feature)
+                      }
+                      return feats
+                    },
+                    currentRoomConf.features
+                  )
+                  currentRoomConf.roomsLeft =
+                    currentRoomConf.roomsLeft + roomConfig.roomsLeft
+                  roomConfigs.set(currentRoomConf.roomType, currentRoomConf)
+                }
+              } else {
+                roomConfigs.set(roomConfig.roomType, roomConfig)
+              }
+            }
+            return Array.from(roomConfigs.values())
+          }),
+      }),
+      relationships: relationshipsSchema.optional(),
+      type: z.string().optional(),
+    }),
+  })
+  .transform(({ data: { attributes } }) => {
+    const rateDefinitions = attributes.rateDefinitions
+    const cancellationRuleLookup = rateDefinitions.reduce((acc, val) => {
+      // @ts-expect-error - index of cancellationRule TS
+      acc[val.rateCode] = cancellationRules[val.cancellationRule]
+      return acc
+    }, {})
+
+    const roomConfigurations = attributes.roomConfigurations
+      .map((room) => {
+        if (room.products.length) {
+          room.breakfastIncludedInAllRatesMember = room.products.every(
+            (product) =>
+              everyRateHasBreakfastIncluded(product, rateDefinitions, "member")
+          )
+          room.breakfastIncludedInAllRatesPublic = room.products.every(
+            (product) =>
+              everyRateHasBreakfastIncluded(product, rateDefinitions, "public")
+          )
+
+          room.products = room.products.map((product) => {
+            const publicRate = product.public
+            if (publicRate?.rateCode) {
+              const publicRateDefinition = rateDefinitions.find(
+                (rateDefinition) =>
+                  rateDefinition.rateCode === publicRate.rateCode
+              )
+              if (publicRateDefinition) {
+                const rate = getRate(publicRateDefinition)
+                if (rate) {
+                  product.rate = rate
+                  if (rate === "flex") {
+                    product.isFlex = true
+                  }
+                }
+              }
+            }
+
+            const memberRate = product.member
+            if (memberRate?.rateCode) {
+              const memberRateDefinition = rateDefinitions.find(
+                (rate) => rate.rateCode === memberRate.rateCode
+              )
+              if (memberRateDefinition) {
+                const rate = getRate(memberRateDefinition)
+                if (rate) {
+                  product.rate = rate
+                  if (rate === "flex") {
+                    product.isFlex = true
+                  }
+                }
+              }
+            }
+
+            return product
+          })
+
+          // CancellationRule is the same for public and member per product
+          // Sorting to guarantee order based on rate
+          room.products = room.products.sort(
+            (a, b) =>
+              // @ts-expect-error - index
+              cancellationRuleLookup[a.public?.rateCode || a.member?.rateCode] -
+              // @ts-expect-error - index
+              cancellationRuleLookup[b.public?.rateCode || b.member?.rateCode]
+          )
+        }
+
+        return room
+      })
+      .sort(sortRoomConfigs)
+
+    return {
+      ...attributes,
+      roomConfigurations,
+    }
+  })
+
 export const roomsAvailabilitySchema = z
  .object({
    data: z.object({
--- a/apps/scandic-web/server/routers/hotels/query.ts
+++ b/apps/scandic-web/server/routers/hotels/query.ts
@@ -50,6 +50,7 @@ import {
  packagesSchema,
  ratesSchema,
  roomsAvailabilitySchema,
+  roomsCombinedAvailabilitySchema,
 } from "./output"
 import tempRatesData from "./tempRatesData.json"
 import {
@@ -495,95 +496,110 @@ export const hotelQueryRouter = router({

    roomsCombinedAvailability: serviceProcedure
      .input(roomsCombinedAvailabilityInputSchema)
-      .query(async ({ input, ctx }) => {
-        const { lang } = input
-        const apiLang = toApiLang(lang)
-        const {
-          adultsCount,
-          bookingCode,
-          childArray,
-          hotelId,
-          rateCode,
-          roomStayEndDate,
-          roomStayStartDate,
-        } = input
+      .query(
+        async ({
+          ctx,
+          input: {
+            adultsCount,
+            bookingCode,
+            childArray,
+            hotelId,
+            lang,
+            rateCode,
+            roomStayEndDate,
+            roomStayStartDate,
+          },
+        }) => {
+          const apiLang = toApiLang(lang)

-        const metricsData = {
-          hotelId,
-          roomStayStartDate,
-          roomStayEndDate,
-          adultsCount,
-          childArray: childArray ? JSON.stringify(childArray) : undefined,
-          bookingCode,
-        }
+          const metricsData = {
+            hotelId,
+            roomStayStartDate,
+            roomStayEndDate,
+            adultsCount,
+            childArray: childArray ? JSON.stringify(childArray) : undefined,
+            bookingCode,
+          }

-        metrics.roomsCombinedAvailability.counter.add(1, metricsData)
+          metrics.roomsCombinedAvailability.counter.add(1, metricsData)

-        console.info(
-          "api.hotels.roomsCombinedAvailability start",
-          JSON.stringify({ query: { hotelId, params: metricsData } })
-        )
+          console.info(
+            "api.hotels.roomsCombinedAvailability start",
+            JSON.stringify({ query: { hotelId, params: metricsData } })
+          )

-        const availabilityResponses = await Promise.allSettled(
-          adultsCount.map(async (adultCount: number, idx: number) => {
-            const kids = childArray?.[idx]
-            const params: Record<string, string | number | undefined> = {
-              roomStayStartDate,
-              roomStayEndDate,
-              adults: adultCount,
-              ...(kids?.length && {
-                children: generateChildrenString(kids),
-              }),
-              ...(bookingCode && { bookingCode }),
-              language: apiLang,
-            }
-
-            const apiResponse = await api.get(
-              api.endpoints.v1.Availability.hotel(hotelId.toString()),
-              {
-                headers: {
-                  Authorization: `Bearer ${ctx.serviceToken}`,
-                },
-              },
-              params
-            )
-
-            if (!apiResponse.ok) {
-              const text = await apiResponse.text()
-              metrics.roomsCombinedAvailability.fail.add(1, metricsData)
-              console.error("Failed API call", { params, text })
-              return { error: "http_error", details: text }
-            }
-
-            const apiJson = await apiResponse.json()
-            const validateAvailabilityData =
-              roomsAvailabilitySchema.safeParse(apiJson)
-
-            if (!validateAvailabilityData.success) {
-              console.error("Validation error", {
-                params,
-                error: validateAvailabilityData.error,
-              })
-              metrics.roomsCombinedAvailability.fail.add(1, metricsData)
-              return {
-                error: "validation_error",
-                details: validateAvailabilityData.error,
+          const availabilityResponses = await Promise.allSettled(
+            adultsCount.map(async (adultCount: number, idx: number) => {
+              const kids = childArray?.[idx]
+              const params: Record<string, string | number | undefined> = {
+                roomStayStartDate,
+                roomStayEndDate,
+                adults: adultCount,
+                ...(kids?.length && {
+                  children: generateChildrenString(kids),
+                }),
+                ...(bookingCode && { bookingCode }),
+                language: apiLang,
              }
-            }

-            if (rateCode) {
-              validateAvailabilityData.data.mustBeGuaranteed =
-                validateAvailabilityData.data.rateDefinitions.find(
-                  (rate) => rate.rateCode === rateCode
-                )?.mustBeGuaranteed
-            }
+              const apiResponse = await api.get(
+                api.endpoints.v1.Availability.hotel(hotelId.toString()),
+                {
+                  headers: {
+                    Authorization: `Bearer ${ctx.serviceToken}`,
+                  },
+                },
+                params
+              )

-            return validateAvailabilityData.data
+              if (!apiResponse.ok) {
+                const text = await apiResponse.text()
+                metrics.roomsCombinedAvailability.fail.add(1, metricsData)
+                console.error("Failed API call", { params, text })
+                return { error: "http_error", details: text }
+              }
+
+              const apiJson = await apiResponse.json()
+              const validateAvailabilityData =
+                roomsCombinedAvailabilitySchema.safeParse(apiJson)
+
+              if (!validateAvailabilityData.success) {
+                console.error("Validation error", {
+                  params,
+                  error: validateAvailabilityData.error,
+                })
+                metrics.roomsCombinedAvailability.fail.add(1, metricsData)
+                return {
+                  error: "validation_error",
+                  details: validateAvailabilityData.error,
+                }
+              }
+
+              if (rateCode) {
+                validateAvailabilityData.data.mustBeGuaranteed =
+                  validateAvailabilityData.data.rateDefinitions.find(
+                    (rate) => rate.rateCode === rateCode
+                  )?.mustBeGuaranteed
+              }
+
+              return validateAvailabilityData.data
+            })
+          )
+          metrics.roomsCombinedAvailability.success.add(1, metricsData)
+
+          const data = availabilityResponses.map((availability) => {
+            if (availability.status === "fulfilled") {
+              return availability.value
+            }
+            return {
+              details: availability.reason,
+              error: "request_failure",
+            }
          })
-        )
-        metrics.roomsCombinedAvailability.success.add(1, metricsData)
-        return availabilityResponses
-      }),
+
+          return data
+        }
+      ),
    room: serviceProcedure
      .input(selectedRoomAvailabilityInputSchema)
      .query(async ({ input, ctx }) => {
@@ -771,9 +787,9 @@ export const hotelQueryRouter = router({
                type: matchingRoom.mainBed.type,
                extraBed: matchingRoom.fixedExtraBed
                  ? {
-                    type: matchingRoom.fixedExtraBed.type,
-                    description: matchingRoom.fixedExtraBed.description,
-                  }
+                      type: matchingRoom.fixedExtraBed.type,
+                      description: matchingRoom.fixedExtraBed.description,
+                    }
                  : undefined,
              }
            }
@@ -1102,9 +1118,9 @@ export const hotelQueryRouter = router({

              return hotelData
                ? {
-                  ...hotelData,
-                  url: hotelPage?.url ?? null,
-                }
+                    ...hotelData,
+                    url: hotelPage?.url ?? null,
+                  }
                : null
            })
          )
--- a/apps/scandic-web/server/routers/hotels/schemas/roomAvailability/configuration.ts
+++ b/apps/scandic-web/server/routers/hotels/schemas/roomAvailability/configuration.ts
@@ -45,8 +45,5 @@ export const roomConfigurationSchema = z
      }
    }

-    // Creating a new objekt since data is frozen (readony)
-    // and can cause errors to be thrown if trying to manipulate
-    // object elsewhere
-    return { ...data }
+    return data
  })