606 lines
17 KiB
TypeScript
606 lines
17 KiB
TypeScript
import isEqual from "fast-deep-equal"
|
|
|
|
import { detailsStorageName } from "."
|
|
|
|
import { type RoomRate } from "@/types/components/hotelReservation/enterDetails/details"
|
|
import type { Price } from "@/types/components/hotelReservation/price"
|
|
import type { SelectRateSearchParams } from "@/types/components/hotelReservation/selectRate/selectRate"
|
|
import { CurrencyEnum } from "@/types/enums/currency"
|
|
import { StepEnum } from "@/types/enums/step"
|
|
import type {
|
|
DetailsState,
|
|
PersistedState,
|
|
RoomState,
|
|
} from "@/types/stores/enter-details"
|
|
import type { SafeUser } from "@/types/user"
|
|
|
|
export function extractGuestFromUser(user: NonNullable<SafeUser>) {
|
|
return {
|
|
countryCode: user.address.countryCode?.toString(),
|
|
email: user.email,
|
|
firstName: user.firstName,
|
|
lastName: user.lastName,
|
|
join: false,
|
|
membershipNo: user.membership?.membershipNumber,
|
|
phoneNumber: user.phoneNumber ?? "",
|
|
}
|
|
}
|
|
|
|
export function checkIsSameBooking(
|
|
prev: SelectRateSearchParams & { errorCode?: string },
|
|
next: SelectRateSearchParams & { errorCode?: string }
|
|
) {
|
|
const { rooms: prevRooms, errorCode: prevErrorCode, ...prevBooking } = prev
|
|
|
|
const prevRoomsWithoutRateCodes = prevRooms.map(
|
|
({ rateCode, counterRateCode, roomTypeCode, ...room }) => room
|
|
)
|
|
const { rooms: nextRooms, errorCode: nextErrorCode, ...nextBooking } = next
|
|
|
|
const nextRoomsWithoutRateCodes = nextRooms.map(
|
|
({ rateCode, counterRateCode, roomTypeCode, ...room }) => room
|
|
)
|
|
|
|
return isEqual(
|
|
{
|
|
...prevBooking,
|
|
rooms: prevRoomsWithoutRateCodes,
|
|
},
|
|
{
|
|
...nextBooking,
|
|
rooms: nextRoomsWithoutRateCodes,
|
|
}
|
|
)
|
|
}
|
|
|
|
export function add(...nums: (number | string | undefined)[]) {
|
|
return nums.reduce((total: number, num) => {
|
|
if (typeof num === "undefined") {
|
|
num = 0
|
|
}
|
|
total = total + parseInt(`${num}`)
|
|
return total
|
|
}, 0)
|
|
}
|
|
|
|
export function subtract(...nums: (number | string | undefined)[]) {
|
|
return nums.reduce((total: number, num, idx) => {
|
|
if (typeof num === "undefined") {
|
|
num = 0
|
|
}
|
|
if (idx === 0) {
|
|
return parseInt(`${num}`)
|
|
}
|
|
total = total - parseInt(`${num}`)
|
|
if (total < 0) {
|
|
return 0
|
|
}
|
|
return total
|
|
}, 0)
|
|
}
|
|
|
|
export function getCurrency(roomRate: RoomRate) {
|
|
if ("corporateCheque" in roomRate) {
|
|
return {
|
|
localCurrency: CurrencyEnum.CC,
|
|
requestedCurrency: CurrencyEnum.CC,
|
|
}
|
|
} else if ("redemption" in roomRate) {
|
|
return {
|
|
localCurrency: CurrencyEnum.POINTS,
|
|
requestedCurrency: CurrencyEnum.POINTS,
|
|
}
|
|
} else if ("voucher" in roomRate) {
|
|
return {
|
|
localCurrency: CurrencyEnum.Voucher,
|
|
requestedCurrency: CurrencyEnum.Voucher,
|
|
}
|
|
} else if ("public" in roomRate && roomRate.public) {
|
|
return {
|
|
localCurrency: roomRate.public.localPrice.currency,
|
|
requestedCurrency: roomRate.public.requestedPrice?.currency,
|
|
}
|
|
} else if ("member" in roomRate && roomRate.member) {
|
|
return {
|
|
localCurrency: roomRate.member.localPrice.currency,
|
|
requestedCurrency: roomRate.member.requestedPrice?.currency,
|
|
}
|
|
}
|
|
|
|
return {
|
|
localCurrency: CurrencyEnum.Unknown,
|
|
requestedCurrency: CurrencyEnum.Unknown,
|
|
}
|
|
}
|
|
|
|
export function getRoomPrice(roomRate: RoomRate, isMember: boolean) {
|
|
if (isMember && "member" in roomRate && roomRate.member) {
|
|
return {
|
|
perNight: {
|
|
requested: roomRate.member.requestedPrice
|
|
? {
|
|
currency: roomRate.member.requestedPrice.currency,
|
|
price: roomRate.member.requestedPrice.pricePerNight,
|
|
}
|
|
: undefined,
|
|
local: {
|
|
currency: roomRate.member.localPrice.currency,
|
|
price: roomRate.member.localPrice.pricePerNight,
|
|
},
|
|
},
|
|
perStay: {
|
|
requested: roomRate.member.requestedPrice
|
|
? {
|
|
currency: roomRate.member.requestedPrice.currency,
|
|
price: roomRate.member.requestedPrice.pricePerStay,
|
|
}
|
|
: undefined,
|
|
local: {
|
|
currency: roomRate.member.localPrice.currency,
|
|
price: roomRate.member.localPrice.pricePerStay,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
if ("public" in roomRate && roomRate.public) {
|
|
return {
|
|
perNight: {
|
|
requested: roomRate.public.requestedPrice
|
|
? {
|
|
currency: roomRate.public.requestedPrice.currency,
|
|
price: roomRate.public.requestedPrice.pricePerNight,
|
|
}
|
|
: undefined,
|
|
local: {
|
|
currency: roomRate.public.localPrice.currency,
|
|
price: roomRate.public.localPrice.pricePerNight,
|
|
regularPrice: roomRate.public.localPrice.regularPricePerNight,
|
|
},
|
|
},
|
|
perStay: {
|
|
requested: roomRate.public.requestedPrice
|
|
? {
|
|
currency: roomRate.public.requestedPrice.currency,
|
|
price: roomRate.public.requestedPrice.pricePerStay,
|
|
}
|
|
: undefined,
|
|
local: {
|
|
currency: roomRate.public.localPrice.currency,
|
|
price: roomRate.public.localPrice.pricePerStay,
|
|
regularPrice: roomRate.public.localPrice.regularPricePerStay,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
if ("corporateCheque" in roomRate) {
|
|
return {
|
|
perNight: {
|
|
requested: roomRate.corporateCheque.requestedPrice
|
|
? {
|
|
currency: CurrencyEnum.CC,
|
|
price: roomRate.corporateCheque.requestedPrice.numberOfCheques,
|
|
additionalPrice:
|
|
roomRate.corporateCheque.requestedPrice.additionalPricePerStay,
|
|
additionalPriceCurrency:
|
|
roomRate.corporateCheque.requestedPrice.currency ?? undefined,
|
|
}
|
|
: undefined,
|
|
local: {
|
|
currency: CurrencyEnum.CC,
|
|
price: roomRate.corporateCheque.localPrice.numberOfCheques,
|
|
additionalPrice:
|
|
roomRate.corporateCheque.localPrice.additionalPricePerStay,
|
|
additionalPriceCurrency:
|
|
roomRate.corporateCheque.localPrice.currency ?? undefined,
|
|
},
|
|
},
|
|
perStay: {
|
|
requested: roomRate.corporateCheque.requestedPrice
|
|
? {
|
|
currency: CurrencyEnum.CC,
|
|
price: roomRate.corporateCheque.requestedPrice.numberOfCheques,
|
|
additionalPrice:
|
|
roomRate.corporateCheque.requestedPrice.additionalPricePerStay,
|
|
additionalPriceCurrency:
|
|
roomRate.corporateCheque.requestedPrice.currency ?? undefined,
|
|
}
|
|
: undefined,
|
|
local: {
|
|
currency: CurrencyEnum.CC,
|
|
price: roomRate.corporateCheque.localPrice.numberOfCheques,
|
|
additionalPrice:
|
|
roomRate.corporateCheque.localPrice.additionalPricePerStay,
|
|
additionalPriceCurrency:
|
|
roomRate.corporateCheque.localPrice.currency ?? undefined,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
if ("voucher" in roomRate) {
|
|
return {
|
|
perNight: {
|
|
requested: undefined,
|
|
local: {
|
|
currency: CurrencyEnum.Voucher,
|
|
price: roomRate.voucher.numberOfVouchers,
|
|
},
|
|
},
|
|
perStay: {
|
|
requested: undefined,
|
|
local: {
|
|
currency: CurrencyEnum.Voucher,
|
|
price: roomRate.voucher.numberOfVouchers,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
if ("redemption" in roomRate) {
|
|
return {
|
|
// ToDo Handle perNight as undefined
|
|
perNight: {
|
|
requested: undefined,
|
|
local: {
|
|
currency: CurrencyEnum.POINTS,
|
|
price: roomRate.redemption.localPrice.pointsPerStay,
|
|
additionalPrice:
|
|
roomRate.redemption.localPrice.additionalPricePerStay,
|
|
additionalPriceCurrency:
|
|
roomRate.redemption.localPrice.currency ?? undefined,
|
|
},
|
|
},
|
|
perStay: {
|
|
requested: undefined,
|
|
local: {
|
|
currency: CurrencyEnum.POINTS,
|
|
price: roomRate.redemption.localPrice.pointsPerStay,
|
|
additionalPrice:
|
|
roomRate.redemption.localPrice.additionalPricePerStay,
|
|
additionalPriceCurrency:
|
|
roomRate.redemption.localPrice.currency ?? undefined,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
throw new Error(
|
|
`Unable to calculate RoomPrice since user is neither a member or memberRate is missing, or publicRate is missing`
|
|
)
|
|
}
|
|
|
|
export function getTotalPrice(roomRates: RoomRate[], isMember: boolean) {
|
|
return 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,
|
|
}
|
|
)
|
|
}
|
|
|
|
export function calculateVoucherPrice(roomRates: RoomRate[]) {
|
|
return roomRates.reduce<Price>(
|
|
(total, room) => {
|
|
if (!("voucher" in room)) {
|
|
return total
|
|
}
|
|
|
|
return {
|
|
local: {
|
|
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 breakfastRequestedPrice = room.breakfast
|
|
? (room.breakfast.requestedPrice?.price ?? 0)
|
|
: 0
|
|
const breakfastLocalPrice = room.breakfast
|
|
? (room.breakfast.localPrice?.price ?? 0)
|
|
: 0
|
|
|
|
const roomFeaturesTotal = room.roomFeatures?.reduce(
|
|
(total, pkg) => {
|
|
if (pkg.requestedPrice.totalPrice) {
|
|
total.requestedPrice = add(
|
|
total.requestedPrice,
|
|
pkg.requestedPrice.totalPrice
|
|
)
|
|
}
|
|
total.local = add(total.local, pkg.localPrice.totalPrice)
|
|
|
|
return total
|
|
},
|
|
{ local: 0, requestedPrice: 0 }
|
|
)
|
|
|
|
const result: Price = {
|
|
requested: roomPrice.perStay.requested
|
|
? {
|
|
currency: roomPrice.perStay.requested.currency,
|
|
price: add(
|
|
acc.requested?.price ?? 0,
|
|
roomPrice.perStay.requested.price,
|
|
breakfastRequestedPrice * room.adults * nights
|
|
),
|
|
}
|
|
: undefined,
|
|
local: {
|
|
currency: roomPrice.perStay.local.currency,
|
|
price: add(
|
|
acc.local.price,
|
|
roomPrice.perStay.local.price,
|
|
breakfastLocalPrice * room.adults * nights,
|
|
roomFeaturesTotal?.local ?? 0
|
|
),
|
|
regularPrice: add(
|
|
acc.local.regularPrice,
|
|
roomPrice.perStay.local.regularPrice,
|
|
breakfastLocalPrice * room.adults * nights,
|
|
roomFeaturesTotal?.requestedPrice ?? 0
|
|
),
|
|
additionalPrice: add(
|
|
acc.local.additionalPrice,
|
|
roomPrice.perStay.local.additionalPrice,
|
|
breakfastLocalPrice * room.adults * nights,
|
|
roomFeaturesTotal?.local ?? 0
|
|
),
|
|
additionalPriceCurrency: roomPrice.perStay.local
|
|
.additionalPriceCurrency
|
|
? roomPrice.perStay.local.additionalPriceCurrency
|
|
: undefined,
|
|
},
|
|
}
|
|
|
|
return result
|
|
},
|
|
{
|
|
requested: undefined,
|
|
local: { currency, price: 0 },
|
|
}
|
|
)
|
|
}
|
|
|
|
export function getFirstInteractiveStepOfRoom(room: RoomState["room"]) {
|
|
if (!room.bedType) {
|
|
return StepEnum.selectBed
|
|
}
|
|
if (room.breakfast !== false) {
|
|
return StepEnum.breakfast
|
|
}
|
|
return StepEnum.details
|
|
}
|
|
|
|
export function findNextInvalidStep(roomState: RoomState) {
|
|
return (
|
|
Object.values(roomState.steps).find((stp) => !stp.isValid)?.step ??
|
|
getFirstInteractiveStepOfRoom(roomState.room)
|
|
)
|
|
}
|
|
|
|
export const selectNextStep = (room: RoomState) => {
|
|
if (room.currentStep === null) {
|
|
throw new Error("getNextStep: currentStep is null")
|
|
}
|
|
|
|
if (!room.steps[room.currentStep]?.isValid) {
|
|
return room.currentStep
|
|
}
|
|
|
|
const stepsArray = Object.values(room.steps)
|
|
const currentIndex = stepsArray.findIndex(
|
|
(step) => step?.step === room.currentStep
|
|
)
|
|
if (currentIndex === stepsArray.length - 1) {
|
|
return null
|
|
}
|
|
|
|
const nextInvalidStep = stepsArray
|
|
.slice(currentIndex + 1)
|
|
.find((step) => !step.isValid)
|
|
|
|
return nextInvalidStep?.step ?? null
|
|
}
|
|
|
|
export const checkRoomProgress = (steps: RoomState["steps"]) => {
|
|
return Object.values(steps)
|
|
.filter(Boolean)
|
|
.every((step) => step.isValid)
|
|
}
|
|
|
|
export function handleStepProgression(room: RoomState, state: DetailsState) {
|
|
const isAllRoomsCompleted = state.rooms.every((r) => r.isComplete)
|
|
if (isAllRoomsCompleted) {
|
|
room.currentStep = null
|
|
state.canProceedToPayment = true
|
|
} else if (room.isComplete) {
|
|
room.currentStep = null
|
|
const nextRoomIndex = state.rooms.findIndex((r) => !r.isComplete)
|
|
state.activeRoom = nextRoomIndex
|
|
|
|
const nextRoom = state.rooms[nextRoomIndex]
|
|
const nextStep = selectNextStep(nextRoom)
|
|
nextRoom.currentStep = nextStep
|
|
} else if (selectNextStep(room)) {
|
|
room.currentStep = selectNextStep(room)
|
|
}
|
|
}
|
|
|
|
export function readFromSessionStorage(): PersistedState | undefined {
|
|
if (typeof window === "undefined") {
|
|
return undefined
|
|
}
|
|
|
|
try {
|
|
const storedData = sessionStorage.getItem(detailsStorageName)
|
|
if (!storedData) {
|
|
return undefined
|
|
}
|
|
|
|
const parsedData = JSON.parse(storedData) as PersistedState
|
|
|
|
if (!parsedData.booking || !parsedData.rooms) {
|
|
return undefined
|
|
}
|
|
|
|
return parsedData
|
|
} catch (error) {
|
|
console.error("Error reading from session storage:", error)
|
|
return undefined
|
|
}
|
|
}
|
|
|
|
export function writeToSessionStorage(state: PersistedState) {
|
|
if (typeof window === "undefined") {
|
|
return
|
|
}
|
|
|
|
try {
|
|
sessionStorage.setItem(detailsStorageName, JSON.stringify(state))
|
|
} catch (error) {
|
|
console.error("Error writing to session storage:", error)
|
|
}
|
|
}
|
|
|
|
export function clearSessionStorage() {
|
|
if (typeof window === "undefined") {
|
|
return
|
|
}
|
|
sessionStorage.removeItem(detailsStorageName)
|
|
}
|