// AK-P16b ยท provider availability route (M06 Block F). Every provider edits // their OWN weekly rules + date exceptions (bookings.read_own covers own // availability; foreign availability via bookings.admin is deferred). The // editor submits one serialized payload, replaced atomically by // AvailabilityService. Module off -> locked empty; missing permission -> 404. import { type ActionFunctionArgs, type LoaderFunctionArgs, useActionData, useLoaderData } from "react-router"; import { buildAvailabilityVM, parseAvailabilityPayload, type AvailabilityVM } from "@hivegrid/view-models"; import { getTranslations } from "~/locale/i18next.server"; import { APP_TIME_ZONE } from "~/locale/format"; import { validateCSRFToken } from "~/utils/session.server"; import { useRootData } from "~/utils/data/useRootData"; import { loadBookingContext, requireBookingPermission, BOOKING_PERMISSIONS } from "~/modules/booking/routes/bookingAccess.server"; import { BOOKING_MODULE_KEY, notFoundResponse } from "~/modules/booking/routes/bookingRoutePaths"; import { listProviderAvailability, replaceProviderAvailability, AvailabilityValidationError } from "~/modules/booking/services/AvailabilityService.server"; import { AvailabilityPage } from "~/components/screens/booking/AvailabilityPage"; import ServerError from "~/components/ui/errors/ServerError"; type LoaderData = { title: string; vm: AvailabilityVM }; type ActionData = { ok: true } | { ok: false; errorKey: string }; export const loader = async ({ request, params }: LoaderFunctionArgs) => { const { t } = await getTranslations(request); const ctx = await loadBookingContext({ request, params }); const title = `${t("bookings.availability.title")} | ${process.env.APP_NAME}`; if (!ctx.hasModule) { return Response.json({ title, vm: buildAvailabilityVM({ rules: [], exceptions: [], fallbackTimezone: APP_TIME_ZONE }) } satisfies LoaderData); } try { requireBookingPermission(ctx, BOOKING_PERMISSIONS.readOwn); } catch { throw notFoundResponse(); } const settings = await listProviderAvailability(ctx.tenantId, ctx.userId); const vm = buildAvailabilityVM({ rules: settings.rules.map((rule) => ({ id: rule.id, dayOfWeek: rule.dayOfWeek, startTime: rule.startTime, endTime: rule.endTime, timezone: rule.timezone })), exceptions: settings.exceptions.map((exception) => ({ id: exception.id, date: exception.date, kind: exception.kind, startTime: exception.startTime, endTime: exception.endTime, reason: exception.reason, timezone: exception.timezone, })), fallbackTimezone: APP_TIME_ZONE, }); return Response.json({ title, vm } satisfies LoaderData); }; export const action = async ({ request, params }: ActionFunctionArgs) => { const ctx = await loadBookingContext({ request, params, requireModule: true }); requireBookingPermission(ctx, BOOKING_PERMISSIONS.readOwn); await validateCSRFToken(request); const form = await request.formData(); const parsed = parseAvailabilityPayload((form.get("payload") as string | null) ?? ""); if (!parsed.ok) { return Response.json({ ok: false, errorKey: parsed.errorKey } satisfies ActionData, { status: 400 }); } try { await replaceProviderAvailability({ tenantId: ctx.tenantId, providerUserId: ctx.userId, rules: parsed.payload.rules, exceptions: parsed.payload.exceptions, }); } catch (error) { if (error instanceof AvailabilityValidationError) { return Response.json({ ok: false, errorKey: error.code } satisfies ActionData, { status: 400 }); } throw error; } return Response.json({ ok: true } satisfies ActionData); }; export default function AvailabilityRoute() { const { vm } = useLoaderData(); const actionData = useActionData(); const rootData = useRootData(); return ; } export function ErrorBoundary() { return ; } export const handle = { moduleKey: BOOKING_MODULE_KEY };