fix: close summary sheet

stores/enter-details/helpers.ts

@@ -1,14 +1,9 @@
+import isEqual from "lodash.isequal"
 import { z } from "zod"
 
 import { Lang } from "@/constants/languages"
 import { breakfastPackageSchema } from "@/server/routers/hotels/output"
 
-import { bedTypeSchema } from "@/components/HotelReservation/EnterDetails/BedType/schema"
-import { breakfastStoreSchema } from "@/components/HotelReservation/EnterDetails/Breakfast/schema"
-import {
-  guestDetailsSchema,
-  signedInDetailsSchema,
-} from "@/components/HotelReservation/EnterDetails/Details/schema"
 import { getLang } from "@/i18n/serverContext"
 
 import type { BookingData } from "@/types/components/hotelReservation/enterDetails/bookingData"
@@ -53,42 +48,7 @@ export function navigate(step: StepEnum, searchParams: string) {
 }
 
 export function checkIsSameBooking(prev: BookingData, next: BookingData) {
-  return (
-    prev.fromDate === next.fromDate ||
-    prev.toDate === next.toDate ||
-    prev.hotel === next.hotel ||
-    prev.rooms[0].adults === next.rooms[0].adults ||
-    prev.rooms[0].children === next.rooms[0].children ||
-    prev.rooms[0].roomTypeCode === next.rooms[0].roomTypeCode
-  )
-}
-
-export function validateSteps(currentState: DetailsState, isMember: boolean) {
-  const validPaths = [StepEnum.selectBed]
-  const validatedBedType = bedTypeSchema.safeParse(currentState)
-  if (validatedBedType.success) {
-    currentState.isValid["select-bed"] = true
-    validPaths.push(currentState.steps[1])
-  }
-
-  const validatedBreakfast = breakfastStoreSchema.safeParse(currentState)
-  if (validatedBreakfast.success) {
-    currentState.isValid.breakfast = true
-    validPaths.push(StepEnum.details)
-  }
-
-  const detailsSchema = isMember ? signedInDetailsSchema : guestDetailsSchema
-  const validatedDetails = detailsSchema.safeParse(currentState.guest)
-  // Need to add the breakfast check here too since
-  // when a member comes into the flow, their data is
-  // already added and valid, and thus to avoid showing a
-  // step the user hasn't been on yet as complete
-  if (currentState.isValid.breakfast && validatedDetails.success) {
-    currentState.isValid.details = true
-    validPaths.push(StepEnum.payment)
-  }
-
-  return validPaths
+  return isEqual(prev, next)
 }
 
 export function add(...nums: (number | string | undefined)[]) {
@@ -177,17 +137,43 @@ export function calcTotalMemberPrice(state: DetailsState) {
     }
   }
 
+  return calcTotalPrice({
+    breakfast: state.breakfast,
+    packages: state.packages,
+    roomPrice: state.roomPrice,
+    totalPrice: state.totalPrice,
+    ...state.roomRate.memberRate,
+  })
+}
+
+export function calcTotalPublicPrice(state: DetailsState) {
+  return calcTotalPrice({
+    breakfast: state.breakfast,
+    packages: state.packages,
+    roomPrice: state.roomPrice,
+    totalPrice: state.totalPrice,
+    ...state.roomRate.publicRate,
+  })
+}
+
+export function calcTotalPrice(
+  state: Pick<
+    DetailsState,
+    "breakfast" | "packages" | "roomPrice" | "totalPrice"
+  > &
+    DetailsState["roomRate"]["publicRate"]
+) {
   const roomAndTotalPrice = {
     roomPrice: state.roomPrice,
     totalPrice: state.totalPrice,
   }
-  if (state.roomRate.memberRate.requestedPrice?.pricePerStay) {
+  if (state.requestedPrice?.pricePerStay) {
     roomAndTotalPrice.roomPrice.euro = {
       currency: CurrencyEnum.EUR,
-      price: state.roomRate.memberRate.requestedPrice.pricePerStay,
+      price: state.requestedPrice.pricePerStay,
     }
 
-    let totalPriceEuro = state.roomRate.memberRate.requestedPrice.pricePerStay
+    let totalPriceEuro = state.requestedPrice.pricePerStay
     if (state.breakfast) {
       totalPriceEuro = add(
         totalPriceEuro,
@@ -210,7 +196,7 @@ export function calcTotalMemberPrice(state: DetailsState) {
     }
   }
 
-  const roomPriceLocal = state.roomRate.memberRate.localPrice
+  const roomPriceLocal = state.localPrice
   roomAndTotalPrice.roomPrice.local = {
     currency: roomPriceLocal.currency,
     price: roomPriceLocal.pricePerStay,
@@ -239,116 +225,3 @@ export function calcTotalMemberPrice(state: DetailsState) {
 
   return roomAndTotalPrice
 }
-
-export function getHydratedMemberPrice(
-  memberRate: NonNullable<RoomRate["memberRate"]>,
-  breakfast: DetailsState["breakfast"],
-  packages: DetailsState["packages"]
-) {
-  const memberPrice = {
-    euro: {
-      currency: CurrencyEnum.EUR,
-      price: memberRate.requestedPrice?.pricePerStay ?? 0,
-    },
-    local: {
-      currency: memberRate.localPrice.currency,
-      price: memberRate.localPrice.pricePerStay,
-    },
-  }
-
-  if (breakfast) {
-    memberPrice.euro.price = add(
-      memberPrice.euro.price,
-      breakfast.requestedPrice.totalPrice
-    )
-    memberPrice.local.price = add(
-      memberPrice.local.price,
-      breakfast.localPrice.totalPrice
-    )
-  }
-
-  if (packages) {
-    packages.forEach((pkg) => {
-      memberPrice.euro.price = add(
-        memberPrice.euro.price,
-        pkg.requestedPrice.totalPrice
-      )
-      memberPrice.local.price = add(
-        memberPrice.local.price,
-        pkg.localPrice.totalPrice
-      )
-    })
-  }
-
-  return {
-    roomPrice: {
-      euro: {
-        currency: CurrencyEnum.EUR,
-        price: memberRate.requestedPrice?.pricePerStay ?? 0,
-      },
-      local: {
-        currency: memberRate.localPrice.currency,
-        price: memberRate.localPrice.pricePerStay,
-      },
-    },
-    totalPrice: memberPrice,
-  }
-}
-
-export const persistedStateSchema = z
-  .object({
-    bedType: z
-      .object({
-        description: z.string(),
-        roomTypeCode: z.string(),
-      })
-      .optional(),
-    booking: z.object({
-      hotel: z.string(),
-      fromDate: z.string(),
-      toDate: z.string(),
-      rooms: z.array(
-        z.object({
-          adults: z.number().int(),
-          counterRateCode: z.string(),
-          rateCode: z.string(),
-          roomTypeCode: z.string(),
-          children: z
-            .array(
-              z.object({
-                age: z.number().int(),
-                bed: z.string(),
-              })
-            )
-            .optional(),
-          packages: z.array(z.nativeEnum(RoomPackageCodeEnum)).optional(),
-        })
-      ),
-    }),
-    breakfast: breakfastPackageSchema.or(z.literal(false)).optional(),
-    guest: z.object({
-      countryCode: z.string().default(""),
-      email: z.string().default(""),
-      firstName: z.string().default(""),
-      lastName: z.string().default(""),
-      membershipNo: z.string().default(""),
-      phoneNumber: z.string().default(""),
-      join: z
-        .boolean()
-        .optional()
-        .transform((_) => false),
-      dateOfBirth: z.string().default(""),
-      zipCode: z.string().default(""),
-    }),
-    totalPrice: z.object({
-      euro: z.object({
-        currency: z.literal(CurrencyEnum.EUR),
-        price: z.number().int(),
-      }),
-      local: z.object({
-        currency: z.nativeEnum(CurrencyEnum),
-        price: z.number().int(),
-      }),
-    }),
-  })
-  .optional()