Merged in feat/SW-1557-implement-booking-code-select (pull request #1304)

feat: SW-1577 Implemented booking code city search

* feat: SW-1577 Implemented booking code city search

* feat: SW-1557 Strict comparison

* feat: SW-1557 Review comments fix


Approved-by: Michael Zetterberg
Approved-by: Pontus Dreij

server/routers/hotels/metrics.ts

@@ -32,6 +32,15 @@ export const metrics = {
     fail: meter.createCounter("trpc.hotel.availability.hotels-fail"),
     success: meter.createCounter("trpc.hotel.availability.hotels-success"),
   },
+  hotelsAvailabilityBookingCode: {
+    counter: meter.createCounter("trpc.hotel.availability.hotels-booking-code"),
+    fail: meter.createCounter(
+      "trpc.hotel.availability.hotels-booking-code-fail"
+    ),
+    success: meter.createCounter(
+      "trpc.hotel.availability.hotels-booking-code-success"
+    ),
+  },
   hotelsByHotelIdAvailability: {
     counter: meter.createCounter("trpc.hotel.availability.hotels-by-hotel-id"),
     fail: meter.createCounter(

server/routers/hotels/query.ts

@@ -64,6 +64,10 @@ import { BreakfastPackageEnum } from "@/types/enums/breakfast"
 import { HotelTypeEnum } from "@/types/enums/hotelType"
 import type { RequestOptionsWithOutBody } from "@/types/fetch"
 import type { HotelDataWithUrl } from "@/types/hotel"
+import type {
+  HotelsAvailabilityInputSchema,
+  HotelsByHotelIdsAvailabilityInputSchema,
+} from "@/types/trpc/routers/hotel/availability"
 import type { HotelInput } from "@/types/trpc/routers/hotel/hotel"
 import type { CityLocation } from "@/types/trpc/routers/hotel/locations"
 
@@ -203,6 +207,251 @@ export const getHotel = cache(
   }
 )
 
+export const getHotelsAvailabilityByCity = async (
+  input: HotelsAvailabilityInputSchema,
+  apiLang: string,
+  serviceToken: string
+) => {
+  const {
+    cityId,
+    roomStayStartDate,
+    roomStayEndDate,
+    adults,
+    children,
+    bookingCode,
+  } = input
+
+  const params: Record<string, string | number> = {
+    roomStayStartDate,
+    roomStayEndDate,
+    adults,
+    ...(children && { children }),
+    ...(bookingCode && { bookingCode }),
+    language: apiLang,
+  }
+  metrics.hotelsAvailability.counter.add(1, {
+    cityId,
+    roomStayStartDate,
+    roomStayEndDate,
+    adults,
+    children,
+    bookingCode,
+  })
+  console.info(
+    "api.hotels.hotelsAvailability start",
+    JSON.stringify({ query: { cityId, params } })
+  )
+  const apiResponse = await api.get(
+    api.endpoints.v1.Availability.city(cityId),
+    {
+      cache: undefined,
+      headers: {
+        Authorization: `Bearer ${serviceToken}`,
+      },
+      next: {
+        revalidate: env.CACHE_TIME_CITY_SEARCH,
+      },
+    },
+    params
+  )
+  if (!apiResponse.ok) {
+    const text = await apiResponse.text()
+    metrics.hotelsAvailability.fail.add(1, {
+      cityId,
+      roomStayStartDate,
+      roomStayEndDate,
+      adults,
+      children,
+      bookingCode,
+      error_type: "http_error",
+      error: JSON.stringify({
+        status: apiResponse.status,
+        statusText: apiResponse.statusText,
+        text,
+      }),
+    })
+    console.error(
+      "api.hotels.hotelsAvailability error",
+      JSON.stringify({
+        query: { cityId, params },
+        error: {
+          status: apiResponse.status,
+          statusText: apiResponse.statusText,
+          text,
+        },
+      })
+    )
+    return null
+  }
+  const apiJson = await apiResponse.json()
+  const validateAvailabilityData = hotelsAvailabilitySchema.safeParse(apiJson)
+  if (!validateAvailabilityData.success) {
+    metrics.hotelsAvailability.fail.add(1, {
+      cityId,
+      roomStayStartDate,
+      roomStayEndDate,
+      adults,
+      children,
+      bookingCode,
+      error_type: "validation_error",
+      error: JSON.stringify(validateAvailabilityData.error),
+    })
+    console.error(
+      "api.hotels.hotelsAvailability validation error",
+      JSON.stringify({
+        query: { cityId, params },
+        error: validateAvailabilityData.error,
+      })
+    )
+    throw badRequestError()
+  }
+  metrics.hotelsAvailability.success.add(1, {
+    cityId,
+    roomStayStartDate,
+    roomStayEndDate,
+    adults,
+    children,
+    bookingCode,
+  })
+  console.info(
+    "api.hotels.hotelsAvailability success",
+    JSON.stringify({
+      query: { cityId, params: params },
+    })
+  )
+  return {
+    availability: validateAvailabilityData.data.data.flatMap(
+      (hotels) => hotels.attributes
+    ),
+  }
+}
+
+export const getHotelsAvailabilityByHotelIds = async (
+  input: HotelsByHotelIdsAvailabilityInputSchema,
+  apiLang: string,
+  serviceToken: string
+) => {
+  const {
+    hotelIds,
+    roomStayStartDate,
+    roomStayEndDate,
+    adults,
+    children,
+    bookingCode,
+  } = input
+
+  /**
+   * Since API expects the params appended and not just
+   * a comma separated string we need to initialize the
+   * SearchParams with a sequence of pairs
+   * (hotelIds=810&hotelIds=879&hotelIds=222 etc.)
+   **/
+  const params = new URLSearchParams([
+    ["roomStayStartDate", roomStayStartDate],
+    ["roomStayEndDate", roomStayEndDate],
+    ["adults", adults.toString()],
+    ["children", children ?? ""],
+    ["bookingCode", bookingCode],
+    ["language", apiLang],
+  ])
+  hotelIds.forEach((hotelId) => params.append("hotelIds", hotelId.toString()))
+  metrics.hotelsByHotelIdAvailability.counter.add(1, {
+    hotelIds,
+    roomStayStartDate,
+    roomStayEndDate,
+    adults,
+    children,
+    bookingCode,
+  })
+  console.info(
+    "api.hotels.hotelsByHotelIdAvailability start",
+    JSON.stringify({ query: { params } })
+  )
+  const apiResponse = await api.get(
+    api.endpoints.v1.Availability.hotels(),
+    {
+      cache: undefined,
+      headers: {
+        Authorization: `Bearer ${serviceToken}`,
+      },
+      next: {
+        revalidate: env.CACHE_TIME_CITY_SEARCH,
+      },
+    },
+    params
+  )
+  if (!apiResponse.ok) {
+    const text = await apiResponse.text()
+    metrics.hotelsByHotelIdAvailability.fail.add(1, {
+      hotelIds,
+      roomStayStartDate,
+      roomStayEndDate,
+      adults,
+      children,
+      bookingCode,
+      error_type: "http_error",
+      error: JSON.stringify({
+        status: apiResponse.status,
+        statusText: apiResponse.statusText,
+        text,
+      }),
+    })
+    console.error(
+      "api.hotels.hotelsByHotelIdAvailability error",
+      JSON.stringify({
+        query: { params },
+        error: {
+          status: apiResponse.status,
+          statusText: apiResponse.statusText,
+          text,
+        },
+      })
+    )
+    return null
+  }
+  const apiJson = await apiResponse.json()
+  const validateAvailabilityData = hotelsAvailabilitySchema.safeParse(apiJson)
+  if (!validateAvailabilityData.success) {
+    metrics.hotelsByHotelIdAvailability.fail.add(1, {
+      hotelIds,
+      roomStayStartDate,
+      roomStayEndDate,
+      adults,
+      children,
+      bookingCode,
+      error_type: "validation_error",
+      error: JSON.stringify(validateAvailabilityData.error),
+    })
+    console.error(
+      "api.hotels.hotelsByHotelIdAvailability validation error",
+      JSON.stringify({
+        query: { params },
+        error: validateAvailabilityData.error,
+      })
+    )
+    throw badRequestError()
+  }
+  metrics.hotelsByHotelIdAvailability.success.add(1, {
+    hotelIds,
+    roomStayStartDate,
+    roomStayEndDate,
+    adults,
+    children,
+    bookingCode,
+  })
+  console.info(
+    "api.hotels.hotelsByHotelIdAvailability success",
+    JSON.stringify({
+      query: { params },
+    })
+  )
+  return {
+    availability: validateAvailabilityData.data.data.flatMap(
+      (hotels) => hotels.attributes
+    ),
+  }
+}
+
 export const hotelQueryRouter = router({
   availability: router({
     hotelsByCity: serviceProcedure
@@ -210,239 +459,14 @@ export const hotelQueryRouter = router({
       .query(async ({ input, ctx }) => {
         const { lang } = ctx
         const apiLang = toApiLang(lang)
-        const {
-          cityId,
-          roomStayStartDate,
-          roomStayEndDate,
-          adults,
-          children,
-          bookingCode,
-        } = input
-
-        const params: Record<string, string | number> = {
-          roomStayStartDate,
-          roomStayEndDate,
-          adults,
-          ...(children && { children }),
-          ...(bookingCode && { bookingCode }),
-          language: apiLang,
-        }
-        metrics.hotelsAvailability.counter.add(1, {
-          cityId,
-          roomStayStartDate,
-          roomStayEndDate,
-          adults,
-          children,
-          bookingCode,
-        })
-        console.info(
-          "api.hotels.hotelsAvailability start",
-          JSON.stringify({ query: { cityId, params } })
-        )
-        const apiResponse = await api.get(
-          api.endpoints.v1.Availability.city(cityId),
-          {
-            cache: undefined,
-            headers: {
-              Authorization: `Bearer ${ctx.serviceToken}`,
-            },
-            next: {
-              revalidate: env.CACHE_TIME_CITY_SEARCH,
-            },
-          },
-          params
-        )
-        if (!apiResponse.ok) {
-          const text = await apiResponse.text()
-          metrics.hotelsAvailability.fail.add(1, {
-            cityId,
-            roomStayStartDate,
-            roomStayEndDate,
-            adults,
-            children,
-            bookingCode,
-            error_type: "http_error",
-            error: JSON.stringify({
-              status: apiResponse.status,
-              statusText: apiResponse.statusText,
-              text,
-            }),
-          })
-          console.error(
-            "api.hotels.hotelsAvailability error",
-            JSON.stringify({
-              query: { cityId, params },
-              error: {
-                status: apiResponse.status,
-                statusText: apiResponse.statusText,
-                text,
-              },
-            })
-          )
-          return null
-        }
-        const apiJson = await apiResponse.json()
-        const validateAvailabilityData =
-          hotelsAvailabilitySchema.safeParse(apiJson)
-        if (!validateAvailabilityData.success) {
-          metrics.hotelsAvailability.fail.add(1, {
-            cityId,
-            roomStayStartDate,
-            roomStayEndDate,
-            adults,
-            children,
-            bookingCode,
-            error_type: "validation_error",
-            error: JSON.stringify(validateAvailabilityData.error),
-          })
-          console.error(
-            "api.hotels.hotelsAvailability validation error",
-            JSON.stringify({
-              query: { cityId, params },
-              error: validateAvailabilityData.error,
-            })
-          )
-          throw badRequestError()
-        }
-        metrics.hotelsAvailability.success.add(1, {
-          cityId,
-          roomStayStartDate,
-          roomStayEndDate,
-          adults,
-          children,
-          bookingCode,
-        })
-        console.info(
-          "api.hotels.hotelsAvailability success",
-          JSON.stringify({
-            query: { cityId, params: params },
-          })
-        )
-        return {
-          availability: validateAvailabilityData.data.data.flatMap(
-            (hotels) => hotels.attributes
-          ),
-        }
+        return getHotelsAvailabilityByCity(input, apiLang, ctx.serviceToken)
       }),
     hotelsByHotelIds: serviceProcedure
       .input(getHotelsByHotelIdsAvailabilityInputSchema)
       .query(async ({ input, ctx }) => {
         const { lang } = ctx
         const apiLang = toApiLang(lang)
-        const {
-          hotelIds,
-          roomStayStartDate,
-          roomStayEndDate,
-          adults,
-          children,
-          bookingCode,
-        } = input
-
-        const params: Record<string, string | number | number[]> = {
-          hotelIds,
-          roomStayStartDate,
-          roomStayEndDate,
-          adults,
-          ...(children && { children }),
-          ...(bookingCode && { bookingCode }),
-          language: apiLang,
-        }
-        metrics.hotelsByHotelIdAvailability.counter.add(1, {
-          hotelIds,
-          roomStayStartDate,
-          roomStayEndDate,
-          adults,
-          children,
-          bookingCode,
-        })
-        console.info(
-          "api.hotels.hotelsByHotelIdAvailability start",
-          JSON.stringify({ query: { params } })
-        )
-        const apiResponse = await api.get(
-          api.endpoints.v1.Availability.hotels(),
-          {
-            cache: undefined,
-            headers: {
-              Authorization: `Bearer ${ctx.serviceToken}`,
-            },
-            next: {
-              revalidate: env.CACHE_TIME_CITY_SEARCH,
-            },
-          },
-          params
-        )
-        if (!apiResponse.ok) {
-          const text = await apiResponse.text()
-          metrics.hotelsByHotelIdAvailability.fail.add(1, {
-            hotelIds,
-            roomStayStartDate,
-            roomStayEndDate,
-            adults,
-            children,
-            bookingCode,
-            error_type: "http_error",
-            error: JSON.stringify({
-              status: apiResponse.status,
-              statusText: apiResponse.statusText,
-              text,
-            }),
-          })
-          console.error(
-            "api.hotels.hotelsByHotelIdAvailability error",
-            JSON.stringify({
-              query: { params },
-              error: {
-                status: apiResponse.status,
-                statusText: apiResponse.statusText,
-                text,
-              },
-            })
-          )
-          return null
-        }
-        const apiJson = await apiResponse.json()
-        const validateAvailabilityData =
-          hotelsAvailabilitySchema.safeParse(apiJson)
-        if (!validateAvailabilityData.success) {
-          metrics.hotelsByHotelIdAvailability.fail.add(1, {
-            hotelIds,
-            roomStayStartDate,
-            roomStayEndDate,
-            adults,
-            children,
-            bookingCode,
-            error_type: "validation_error",
-            error: JSON.stringify(validateAvailabilityData.error),
-          })
-          console.error(
-            "api.hotels.hotelsByHotelIdAvailability validation error",
-            JSON.stringify({
-              query: { params },
-              error: validateAvailabilityData.error,
-            })
-          )
-          throw badRequestError()
-        }
-        metrics.hotelsByHotelIdAvailability.success.add(1, {
-          hotelIds,
-          roomStayStartDate,
-          roomStayEndDate,
-          adults,
-          children,
-          bookingCode,
-        })
-        console.info(
-          "api.hotels.hotelsByHotelIdAvailability success",
-          JSON.stringify({
-            query: { params },
-          })
-        )
-        return {
-          availability: validateAvailabilityData.data.data.flatMap(
-            (hotels) => hotels.attributes
-          ),
-        }
+        return getHotelsAvailabilityByHotelIds(input, apiLang, ctx.serviceToken)
       }),
     rooms: serviceProcedure
       .input(roomsAvailabilityInputSchema)
@@ -793,6 +817,70 @@ export const hotelQueryRouter = router({
           bedTypes,
         }
       }),
+    hotelsByCityWithBookingCode: serviceProcedure
+      .input(hotelsAvailabilityInputSchema)
+      .query(async ({ input, ctx }) => {
+        const { lang } = ctx
+        const apiLang = toApiLang(lang)
+
+        metrics.hotelsAvailabilityBookingCode.counter.add(1, {
+          ...input,
+        })
+        const bookingCodeAvailabilityResponse =
+          await getHotelsAvailabilityByCity(input, apiLang, ctx.serviceToken)
+        if (!bookingCodeAvailabilityResponse) {
+          metrics.hotelsAvailabilityBookingCode.fail.add(1, {
+            ...input,
+            error_type: "unknown",
+          })
+          return null
+        }
+
+        // Get regular availability of hotels which don't have availability with booking code.
+        const unavailableHotelIds =
+          bookingCodeAvailabilityResponse?.availability
+            .filter((hotel) => {
+              return hotel.status === "NotAvailable"
+            })
+            .flatMap((hotel) => {
+              return hotel.hotelId
+            })
+
+        // All hotels have availability with booking code no need to fetch regular prices.
+        // return response as is without any filtering as below.
+        if (!unavailableHotelIds || !unavailableHotelIds.length) {
+          return bookingCodeAvailabilityResponse
+        }
+        const unavailableHotelsInput = {
+          ...input,
+          bookingCode: "",
+          hotelIds: unavailableHotelIds,
+        }
+        const unavailableHotels = await getHotelsAvailabilityByHotelIds(
+          unavailableHotelsInput,
+          apiLang,
+          ctx.serviceToken
+        )
+
+        metrics.hotelsAvailabilityBookingCode.success.add(1, {
+          ...input,
+        })
+        console.info("api.hotels.hotelsAvailabilityBookingCode success")
+
+        // No regular rates available due to network or API failure (no need to filter & merge).
+        if (!unavailableHotels) {
+          return bookingCodeAvailabilityResponse
+        }
+
+        // Filtering the response hotels to merge bookingCode rates and regular rates in single response.
+        return {
+          availability: bookingCodeAvailabilityResponse.availability
+            .filter((hotel) => {
+              return hotel.status === "Available"
+            })
+            .concat(unavailableHotels.availability),
+        }
+      }),
   }),
   rates: router({
     get: publicProcedure