Merged in feat/SW-1719-strikethrough-rates (pull request #2266)

Feat/SW-1719 strikethrough rates

* feat(SW-1719): Strikethrough rate if logged in on regular rate cards

* feat(SW-1719): Strikethrough rate if logged in on rate summary

* feat(SW-1719): Strikethrough rate if logged in on mobile rate summary

* feat(SW-1719): Strikethrough rate if logged in on enter details

* feat(SW-1719): Strikethrough rate support for multiple rooms

* feat(SW-1719): booking receipt fixes on confirmation page

* feat(SW-1719): improve initial total price calculation

* feat: harmonize enter details total price to use one and the same function


Approved-by: Michael Zetterberg

apps/scandic-web/stores/enter-details/helpers.ts

@@ -8,12 +8,20 @@ import {
 
 import { detailsStorageName } from "."
 
+import type { BreakfastPackage } from "@/types/components/hotelReservation/breakfast"
 import { type RoomRate } from "@/types/components/hotelReservation/enterDetails/details"
 import type { Price } from "@/types/components/hotelReservation/price"
 import type { SelectRateBooking } from "@/types/components/hotelReservation/selectRate/selectRate"
 import { CurrencyEnum } from "@/types/enums/currency"
-import type { Package } from "@/types/requests/packages"
+import { RateTypeEnum } from "@/types/enums/rateType"
+import type { Packages } from "@/types/requests/packages"
 import type { PersistedState, RoomState } from "@/types/stores/enter-details"
+import type {
+  CorporateChequeProduct,
+  PriceProduct,
+  RedemptionProduct,
+  VoucherProduct,
+} from "@/types/trpc/routers/hotel/roomAvailability"
 import type { SafeUser } from "@/types/user"
 
 export function extractGuestFromUser(user: NonNullable<SafeUser>) {
@@ -75,6 +83,13 @@ export function add(...nums: (number | string | undefined)[]) {
 
 export function getRoomPrice(roomRate: RoomRate, isMember: boolean) {
   if (isMember && "member" in roomRate && roomRate.member) {
+    let publicRate
+    if (
+      "public" in roomRate &&
+      roomRate.public?.rateType === RateTypeEnum.Regular
+    ) {
+      publicRate = roomRate.public
+    }
     return {
       perNight: {
         requested: roomRate.member.requestedPrice
@@ -86,6 +101,9 @@ export function getRoomPrice(roomRate: RoomRate, isMember: boolean) {
         local: {
           currency: roomRate.member.localPrice.currency,
           price: roomRate.member.localPrice.pricePerNight,
+          regularPrice:
+            publicRate?.localPrice.pricePerStay ||
+            roomRate.member.localPrice.regularPricePerNight,
         },
       },
       perStay: {
@@ -98,6 +116,9 @@ export function getRoomPrice(roomRate: RoomRate, isMember: boolean) {
         local: {
           currency: roomRate.member.localPrice.currency,
           price: roomRate.member.localPrice.pricePerStay,
+          regularPrice:
+            publicRate?.localPrice.pricePerStay ||
+            roomRate.member.localPrice.regularPricePerStay,
         },
       },
     }
@@ -231,329 +252,6 @@ export function getRoomPrice(roomRate: RoomRate, isMember: boolean) {
   )
 }
 
-export function getTotalPrice(roomRates: RoomRate[], isMember: boolean) {
-  const totalPrice = roomRates.reduce<Price>(
-    (total, roomRate, idx) => {
-      const isMainRoom = idx === 0
-      let rate
-      if (isMainRoom && isMember && "member" in roomRate && roomRate.member) {
-        rate = roomRate.member
-      } else if ("public" in roomRate && roomRate.public) {
-        rate = roomRate.public
-      }
-      // TODO: Handle other products?
-      if (!rate) {
-        return total
-      }
-
-      total.local.currency = rate.localPrice.currency
-      total.local.price = add(total.local.price, rate.localPrice.pricePerStay)
-      if (rate.localPrice.regularPricePerStay) {
-        total.local.regularPrice = add(
-          total.local.regularPrice,
-          rate.localPrice.regularPricePerStay
-        )
-      }
-
-      if (rate.requestedPrice) {
-        if (total.requested) {
-          total.requested.price = add(
-            total.requested.price,
-            rate.requestedPrice.pricePerStay
-          )
-        } else {
-          total.requested = {
-            currency: rate.requestedPrice.currency,
-            price: rate.requestedPrice.pricePerStay,
-          }
-        }
-      }
-
-      return total
-    },
-    {
-      local: {
-        currency: CurrencyEnum.Unknown,
-        price: 0,
-      },
-      requested: undefined,
-    }
-  )
-
-  if (totalPrice.local.regularPrice) {
-    const totalPriceWithRegularPrice = roomRates.reduce(
-      (total, roomRate, idx) => {
-        const isMainRoom = idx === 0
-        let rate
-        if (isMainRoom && isMember && "member" in roomRate && roomRate.member) {
-          rate = roomRate.member
-        } else if ("public" in roomRate && roomRate.public) {
-          rate = roomRate.public
-        }
-
-        if (!rate) {
-          return total
-        }
-
-        if (rate.localPrice.regularPricePerStay) {
-          total.local.regularPrice =
-            total.local.regularPrice + rate.localPrice.regularPricePerStay
-        } else {
-          total.local.regularPrice =
-            total.local.regularPrice + rate.localPrice.pricePerStay
-        }
-
-        return total
-      },
-      {
-        ...totalPrice,
-        local: {
-          ...totalPrice.local,
-          regularPrice: 0,
-        },
-      }
-    )
-
-    if (
-      totalPriceWithRegularPrice.local.price ===
-      totalPriceWithRegularPrice.local.regularPrice
-    ) {
-      totalPriceWithRegularPrice.local.regularPrice = 0
-    }
-
-    return totalPriceWithRegularPrice
-  }
-
-  return totalPrice
-}
-
-export function calculateVoucherPrice(
-  roomRates: RoomRate[],
-  packages: Package[]
-) {
-  return roomRates.reduce<Price>(
-    (total, room) => {
-      if (!("voucher" in room)) {
-        return total
-      }
-
-      const pkgsSum = sumPackages(packages)
-
-      return {
-        local: {
-          additionalPrice: pkgsSum.price,
-          additionalPriceCurrency: pkgsSum.currency,
-          currency: total.local.currency,
-          price: total.local.price + room.voucher.numberOfVouchers,
-        },
-        requested: undefined,
-      }
-    },
-    {
-      local: {
-        currency: CurrencyEnum.Voucher,
-        price: 0,
-      },
-      requested: undefined,
-    }
-  )
-}
-
-export function calculateCorporateChequePrice(roomRates: RoomRate[]) {
-  return roomRates.reduce<Price>(
-    (total, room) => {
-      if (!("corporateCheque" in room)) {
-        return total
-      }
-
-      const rate = room.corporateCheque
-
-      total.local.price = add(
-        total.local.price,
-        rate.localPrice.numberOfCheques
-      )
-
-      if (rate.localPrice.additionalPricePerStay) {
-        total.local.additionalPrice = add(
-          total.local.additionalPrice,
-          rate.localPrice.additionalPricePerStay
-        )
-      }
-      if (rate.localPrice.currency) {
-        total.local.additionalPriceCurrency = rate.localPrice.currency
-      }
-
-      if (rate.requestedPrice) {
-        if (total.requested) {
-          total.requested.price = add(
-            total.requested.price,
-            rate.requestedPrice.numberOfCheques
-          )
-        } else {
-          total.requested = {
-            currency: CurrencyEnum.CC,
-            price: rate.requestedPrice.numberOfCheques,
-          }
-        }
-
-        if (rate.requestedPrice.additionalPricePerStay) {
-          total.requested.additionalPrice = add(
-            total.requested.additionalPrice,
-            rate.requestedPrice.additionalPricePerStay
-          )
-        }
-
-        if (rate.requestedPrice.currency) {
-          total.requested.additionalPriceCurrency = rate.requestedPrice.currency
-        }
-      }
-
-      return total
-    },
-    {
-      local: {
-        currency: CurrencyEnum.CC,
-        price: 0,
-      },
-      requested: undefined,
-    }
-  )
-}
-
-export function calcTotalPrice(
-  rooms: RoomState[],
-  currency: Price["local"]["currency"],
-  isMember: boolean,
-  nights: number
-) {
-  return rooms.reduce<Price>(
-    (acc, { room }, index) => {
-      const isFirstRoomAndMember = index === 0 && isMember
-      const join = Boolean(room.guest.join || room.guest.membershipNo)
-
-      const roomPrice = getRoomPrice(
-        room.roomRate,
-        isFirstRoomAndMember || join
-      )
-
-      if (!roomPrice) {
-        return acc
-      }
-
-      const isSpecialRate =
-        "corporateCheque" in room.roomRate ||
-        "redemption" in room.roomRate ||
-        "voucher" in room.roomRate
-
-      const breakfastRequestedPrice = room.breakfast
-        ? (room.breakfast.requestedPrice?.price ?? 0)
-        : 0
-      const breakfastLocalPrice = room.breakfast
-        ? (room.breakfast.localPrice?.price ?? 0)
-        : 0
-
-      const pkgsSum = sumPackages(room.roomFeatures)
-      const pkgsSumRequested = sumPackagesRequestedPrice(room.roomFeatures)
-
-      const breakfastRequestedTotalPrice =
-        breakfastRequestedPrice * room.adults * nights
-      if (roomPrice.perStay.requested) {
-        if (!acc.requested) {
-          acc.requested = {
-            currency: roomPrice.perStay.requested.currency,
-            price: 0,
-          }
-        }
-
-        if (isSpecialRate) {
-          acc.requested.price = add(
-            acc.requested.price,
-            roomPrice.perStay.requested.price
-          )
-
-          acc.requested.additionalPrice = add(
-            breakfastRequestedTotalPrice,
-            pkgsSumRequested.price
-          )
-
-          if (!acc.requested.additionalPriceCurrency) {
-            if (roomPrice.perStay.requested.additionalPriceCurrency) {
-              acc.requested.additionalPriceCurrency =
-                roomPrice.perStay.requested.additionalPriceCurrency
-            } else if (room.breakfast) {
-              acc.requested.additionalPriceCurrency =
-                room.breakfast.localPrice.currency
-            } else if (pkgsSumRequested.currency) {
-              acc.requested.additionalPriceCurrency = pkgsSumRequested.currency
-            }
-          }
-        } else {
-          acc.requested.price = add(
-            acc.requested.price,
-            roomPrice.perStay.requested.price,
-            breakfastRequestedTotalPrice,
-            pkgsSumRequested.price
-          )
-        }
-      }
-
-      const breakfastLocalTotalPrice =
-        breakfastLocalPrice * room.adults * nights
-
-      if (isSpecialRate) {
-        acc.local.price = add(acc.local.price, roomPrice.perStay.local.price)
-
-        if (
-          roomPrice.perStay.local.additionalPrice ||
-          breakfastLocalTotalPrice ||
-          pkgsSum.price
-        ) {
-          acc.local.additionalPrice = add(
-            acc.local.additionalPrice,
-            roomPrice.perStay.local.additionalPrice,
-            breakfastLocalTotalPrice,
-            pkgsSum.price
-          )
-        }
-
-        if (!acc.local.additionalPriceCurrency) {
-          if (roomPrice.perStay.local.additionalPriceCurrency) {
-            acc.local.additionalPriceCurrency =
-              roomPrice.perStay.local.additionalPriceCurrency
-          } else if (room.breakfast) {
-            acc.local.additionalPriceCurrency =
-              room.breakfast.localPrice.currency
-          } else if (pkgsSum.currency) {
-            acc.local.additionalPriceCurrency = pkgsSum.currency
-          }
-        }
-      } else {
-        acc.local.price = add(
-          acc.local.price,
-          roomPrice.perStay.local.price,
-          breakfastLocalTotalPrice,
-          pkgsSum.price
-        )
-
-        if (roomPrice.perStay.local.regularPrice) {
-          acc.local.regularPrice = add(
-            acc.local.regularPrice,
-            roomPrice.perStay.local.regularPrice,
-            breakfastLocalTotalPrice,
-            pkgsSum.price
-          )
-        }
-      }
-
-      return acc
-    },
-    {
-      requested: undefined,
-      local: { currency, price: 0 },
-    }
-  )
-}
-
 export const checkRoomProgress = (steps: RoomState["steps"]) => {
   return Object.values(steps)
     .filter(Boolean)
@@ -602,3 +300,373 @@ export function clearSessionStorage() {
   }
   sessionStorage.removeItem(detailsStorageName)
 }
+
+function getAdditionalPrice(
+  total: Price,
+  adults: number,
+  breakfast: BreakfastPackage | false | undefined,
+  nights: number,
+  packages: Packages | null,
+  additionalPrice = 0,
+  additionalPriceCurrency?: CurrencyEnum | null | undefined
+) {
+  const breakfastLocalPrice =
+    (breakfast ? breakfast.localPrice.price : 0) * nights * adults
+  const pkgsSum = sumPackages(packages)
+
+  total.local.additionalPrice = add(
+    total.local.additionalPrice,
+    additionalPrice,
+    breakfastLocalPrice,
+    pkgsSum.price
+  )
+
+  if (!total.local.additionalPriceCurrency) {
+    if (additionalPriceCurrency) {
+      total.local.additionalPriceCurrency = additionalPriceCurrency
+    } else if (breakfast && breakfast.localPrice.currency) {
+      total.local.additionalPriceCurrency = breakfast.localPrice.currency
+    } else if (pkgsSum.currency) {
+      total.local.additionalPriceCurrency = pkgsSum.currency
+    }
+  }
+}
+
+function getRequestedAdditionalPrice(
+  total: Price,
+  adults: number,
+  breakfast: BreakfastPackage | false | undefined,
+  nights: number,
+  packages: Packages | null,
+  additionalPrice = 0,
+  additionalPriceCurrency: CurrencyEnum | null | undefined
+) {
+  if (!total.requested) {
+    total.requested = {
+      currency: CurrencyEnum.CC,
+      price: 0,
+    }
+  }
+
+  const breakfastRequestedPrice =
+    (breakfast ? breakfast.requestedPrice?.price || 0 : 0) * nights * adults
+  const pkgsSumRequested = sumPackagesRequestedPrice(packages)
+
+  total.requested.additionalPrice = add(
+    total.requested.additionalPrice,
+    additionalPrice,
+    breakfastRequestedPrice,
+    pkgsSumRequested.price
+  )
+
+  if (!total.requested.additionalPriceCurrency) {
+    if (additionalPriceCurrency) {
+      total.requested.additionalPriceCurrency = additionalPriceCurrency
+    } else if (pkgsSumRequested.currency) {
+      total.requested.additionalPriceCurrency = pkgsSumRequested.currency
+    } else if (breakfast && breakfast.requestedPrice) {
+      total.requested.additionalPriceCurrency =
+        breakfast.requestedPrice.currency
+    }
+  }
+}
+
+interface TRoom
+  extends Pick<
+    RoomState["room"],
+    "adults" | "breakfast" | "guest" | "roomFeatures" | "roomRate"
+  > {}
+
+interface TRoomCorporateCheque extends TRoom {
+  roomRate: CorporateChequeProduct
+}
+
+export function getCorporateChequePrice(rooms: TRoom[], nights: number) {
+  return rooms
+    .filter(
+      (room): room is TRoomCorporateCheque => "corporateCheque" in room.roomRate
+    )
+    .reduce<Price>(
+      (total, room) => {
+        const corporateCheque = room.roomRate.corporateCheque
+
+        total.local.price = add(
+          total.local.price,
+          corporateCheque.localPrice.numberOfCheques
+        )
+
+        getAdditionalPrice(
+          total,
+          room.adults,
+          room.breakfast,
+          nights,
+          room.roomFeatures,
+          corporateCheque.localPrice.additionalPricePerStay,
+          corporateCheque.localPrice.currency
+        )
+
+        if (corporateCheque.requestedPrice) {
+          getRequestedAdditionalPrice(
+            total,
+            room.adults,
+            room.breakfast,
+            nights,
+            room.roomFeatures,
+            corporateCheque.requestedPrice?.additionalPricePerStay,
+            corporateCheque.requestedPrice?.currency
+          )
+        }
+
+        return total
+      },
+      {
+        local: {
+          currency: CurrencyEnum.CC,
+          price: 0,
+        },
+        requested: undefined,
+      }
+    )
+}
+
+interface TRoomVoucher extends TRoom {
+  roomRate: VoucherProduct
+}
+
+export function getVoucherPrice(rooms: TRoom[], nights: number) {
+  return rooms
+    .filter((room): room is TRoomVoucher => "voucher" in room.roomRate)
+    .reduce<Price>(
+      (total, room) => {
+        const voucher = room.roomRate.voucher
+
+        total.local.price = add(total.local.price, voucher.numberOfVouchers)
+
+        getAdditionalPrice(
+          total,
+          room.adults,
+          room.breakfast,
+          nights,
+          room.roomFeatures
+        )
+
+        return total
+      },
+      {
+        local: {
+          currency: CurrencyEnum.Voucher,
+          price: 0,
+        },
+        requested: undefined,
+      }
+    )
+}
+
+interface TRoomRedemption extends TRoom {
+  roomRate: RedemptionProduct
+}
+
+export function getRedemptionPrice(rooms: TRoom[], nights: number) {
+  return rooms
+    .filter((room): room is TRoomRedemption => "redemption" in room.roomRate)
+    .reduce<Price>(
+      (total, room) => {
+        const redemption = room.roomRate.redemption
+
+        total.local.price = add(
+          total.local.price,
+          redemption.localPrice.pointsPerStay
+        )
+
+        getAdditionalPrice(
+          total,
+          room.adults,
+          room.breakfast,
+          nights,
+          room.roomFeatures,
+          redemption.localPrice.additionalPricePerStay,
+          redemption.localPrice.currency
+        )
+
+        return total
+      },
+      {
+        local: {
+          currency: CurrencyEnum.POINTS,
+          price: 0,
+        },
+        requested: undefined,
+      }
+    )
+}
+
+interface TRoomPriceProduct extends TRoom {
+  roomRate: PriceProduct
+}
+
+export function getRegularPrice(
+  rooms: TRoom[],
+  isMember: boolean,
+  nights: number
+) {
+  const totalPrice = rooms
+    .filter(
+      (room): room is TRoomPriceProduct =>
+        "member" in room.roomRate || "public" in room.roomRate
+    )
+    .reduce<Price>(
+      (total, room, idx) => {
+        const isMainRoomAndMember = idx === 0 && isMember
+        const join = Boolean(room.guest.join || room.guest.membershipNo)
+        const getMemberRate = isMainRoomAndMember || join
+
+        const memberRate = "member" in room.roomRate && room.roomRate.member
+        const publicRate = "public" in room.roomRate && room.roomRate.public
+
+        let rate
+        if (getMemberRate && memberRate) {
+          rate = memberRate
+        } else if (publicRate) {
+          rate = publicRate
+        }
+
+        if (!rate) {
+          return total
+        }
+
+        const breakfastLocalPrice =
+          (room.breakfast ? room.breakfast.localPrice.price || 0 : 0) *
+          nights *
+          room.adults
+        const pkgsSum = sumPackages(room.roomFeatures)
+        const additionalCost = breakfastLocalPrice + pkgsSum.price
+
+        total.local.currency = rate.localPrice.currency
+        total.local.price = add(
+          total.local.price,
+          rate.localPrice.pricePerStay,
+          additionalCost
+        )
+
+        if (rate.requestedPrice) {
+          if (!total.requested) {
+            total.requested = {
+              currency: rate.requestedPrice.currency,
+              price: 0,
+            }
+          }
+
+          const breakfastRequestedPrice =
+            (room.breakfast ? (room.breakfast.requestedPrice?.price ?? 0) : 0) *
+            nights *
+            room.adults
+          const pkgsSumRequested = sumPackagesRequestedPrice(room.roomFeatures)
+
+          total.requested.price = add(
+            total.requested.price,
+            rate.requestedPrice.pricePerStay,
+            breakfastRequestedPrice,
+            pkgsSumRequested.price
+          )
+        }
+
+        // Legend:
+        // - total.local.price = Total Price = Black price, what the user pays
+        // - total.local.regularPrice = Regular Price = Strikethrough price (could potentially be none)
+        // - total.requested.price = Requested Price = EUR approx price
+
+        // We sometimes don't get all the required data to calculate the correct strikethrough total.
+        // Therefore we try these different approach to get a number that is close
+        // enough to the real number if all data would've been present.
+        if (getMemberRate && memberRate) {
+          if (publicRate) {
+            // #1 Member price uses public price as strikethrough
+            total.local.regularPrice = add(
+              total.local.regularPrice,
+              publicRate.localPrice.pricePerStay,
+              additionalCost
+            )
+          } else if (memberRate.localPrice.regularPricePerStay) {
+            // #2 Member price uses member regular price as strikethrough
+            total.local.regularPrice = add(
+              total.local.regularPrice,
+              memberRate.localPrice.regularPricePerStay,
+              additionalCost
+            )
+          } else {
+            // #3 Member price uses member price as strikethrough
+            // NOTE: If all rooms end up using this, no strikethrough price is shown.
+            total.local.regularPrice = add(
+              total.local.regularPrice,
+              memberRate.localPrice.pricePerStay,
+              additionalCost
+            )
+          }
+        } else if (publicRate) {
+          if (publicRate.localPrice.regularPricePerStay) {
+            // #1 Public price uses public regular price as strikethrough
+            total.local.regularPrice = add(
+              total.local.regularPrice,
+              publicRate.localPrice.regularPricePerStay,
+              additionalCost
+            )
+          } else {
+            // #2 Public price uses public price as strikethrough
+            // NOTE: If all rooms end up using this, no strikethrough price is shown.
+            total.local.regularPrice = add(
+              total.local.regularPrice,
+              publicRate.localPrice.pricePerStay,
+              additionalCost
+            )
+          }
+        } else {
+          // We cannot do anything, too much data is missing.
+          return total
+        }
+
+        return total
+      },
+      {
+        local: {
+          currency: CurrencyEnum.Unknown,
+          price: 0,
+          regularPrice: 0,
+        },
+        requested: undefined,
+      }
+    )
+
+  if (
+    totalPrice.local.regularPrice &&
+    totalPrice.local.price >= totalPrice.local.regularPrice
+  ) {
+    totalPrice.local.regularPrice = 0
+  }
+
+  return totalPrice
+}
+
+export function getTotalPrice(
+  rooms: TRoom[],
+  isMember: boolean,
+  nights: number
+) {
+  const hasCorpChqRates = rooms.some(
+    (room) => "corporateCheque" in room.roomRate
+  )
+  if (hasCorpChqRates) {
+    return getCorporateChequePrice(rooms, nights)
+  }
+
+  const hasRedemptionRates = rooms.some((room) => "redemption" in room.roomRate)
+  if (hasRedemptionRates) {
+    return getRedemptionPrice(rooms, nights)
+  }
+
+  const hasVoucherRates = rooms.some((room) => "voucher" in room.roomRate)
+  if (hasVoucherRates) {
+    return getVoucherPrice(rooms, nights)
+  }
+
+  return getRegularPrice(rooms, isMember, nights)
+}