91 lines
4.0 KiB
TypeScript
91 lines
4.0 KiB
TypeScript
// 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<LoaderData>();
|
|
const actionData = useActionData<ActionData>();
|
|
const rootData = useRootData();
|
|
return <AvailabilityPage vm={vm} csrf={rootData.csrf ?? null} actionData={actionData ?? null} />;
|
|
}
|
|
|
|
export function ErrorBoundary() {
|
|
return <ServerError />;
|
|
}
|
|
|
|
export const handle = { moduleKey: BOOKING_MODULE_KEY };
|