Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/availability.tsx
T

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 };