Merged in feat/SW-1356-reward-night-booking-2- (pull request #1559)

feat: SW-1356 Reward night bookingflow

* feat: SW-1356 Reward night bookingflow

* feat: SW-1356 Removed extra param booking call

* feat: SW-1356 Optimized as review comments

* feat: SW-1356 Schema validation updates

* feat: SW-1356 Fix after rebase

* feat: SW-1356 Optimised price.redemptions check

* feat: SW-1356 Updated Props naming


Approved-by: Arvid Norlin

apps/scandic-web/server/routers/hotels/output.ts

@@ -151,7 +151,7 @@ function sortRoomConfigs(a: RoomConfiguration, b: RoomConfiguration) {
   return statusLookup[a.status] - statusLookup[b.status]
 }
 
-export const roomsCombinedAvailabilitySchema = z
+const baseRoomsCombinedAvailabilitySchema = z
   .object({
     data: z.object({
       attributes: z.object({
@@ -204,83 +204,86 @@ export const roomsCombinedAvailabilitySchema = z
       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")
-          )
+function transformRoomConfigs({
+  data: { attributes },
+}: typeof baseRoomsCombinedAvailabilitySchema._type) {
+  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
+  }, {})
 
-          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 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
-                  }
+          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
-          })
+          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]
-          )
-        }
+        // 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 room
+    })
+    .sort(sortRoomConfigs)
 
-    return {
-      ...attributes,
-      roomConfigurations,
-    }
-  })
+  return {
+    ...attributes,
+    roomConfigurations,
+  }
+}
 
 export const roomsAvailabilitySchema = z
   .object({
@@ -298,85 +301,30 @@ export const roomsAvailabilitySchema = z
       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
-    }, {})
+  .transform(transformRoomConfigs)
 
-    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")
-          )
+export const roomsCombinedAvailabilitySchema =
+  baseRoomsCombinedAvailabilitySchema.transform(transformRoomConfigs)
 
+export const redemptionRoomsCombinedAvailabilitySchema =
+  baseRoomsCombinedAvailabilitySchema.transform((data) => {
+    // In Redemption, rates are always Flex terms
+    data.data.attributes.roomConfigurations =
+      data.data.attributes.roomConfigurations
+        .map((room) => {
           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
-                  }
-                }
-              }
-            }
-
+            product.rate = "flex"
+            product.isFlex = true
             return product
           })
+          return room
+        })
+        .sort(
+          // @ts-expect-error - array indexing
+          (a, b) => statusLookup[a.status] - statusLookup[b.status]
+        )
 
-          // 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(
-        // @ts-expect-error - array indexing
-        (a, b) => statusLookup[a.status] - statusLookup[b.status]
-      )
-
-    return {
-      ...attributes,
-      roomConfigurations,
-    }
+    return transformRoomConfigs(data)
   })
 
 export const ratesSchema = z.array(rateSchema)