231 lines
7.1 KiB
TypeScript
231 lines
7.1 KiB
TypeScript
import { randomUUID } from "node:crypto";
|
|
|
|
import { AdminBookingError } from "@hivegrid/db/admin-booking.server";
|
|
import { buildAdminPublicBookingVM } from "@hivegrid/view-models";
|
|
import {
|
|
useActionData,
|
|
useLoaderData,
|
|
useNavigation,
|
|
type ActionFunctionArgs,
|
|
type LoaderFunctionArgs,
|
|
} from "react-router";
|
|
|
|
import { AdminPublicBookingPage } from "~/components/screens/admin/sales/booking/AdminPublicBookingPage";
|
|
import { getTranslations } from "~/locale/i18next.server";
|
|
import {
|
|
issueAdminBookingManageToken,
|
|
} from "~/services/admin/admin-booking-manage-token.server";
|
|
import {
|
|
checkAdminPublicBookingRateLimit,
|
|
isAdminPublicBookingHost,
|
|
loadAdminPublicBookingPage,
|
|
submitAdminPublicBooking,
|
|
} from "~/services/admin/admin-public-booking.server";
|
|
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
|
|
|
|
type ActionData = {
|
|
readonly confirmed: boolean;
|
|
readonly errorCode: string | null;
|
|
readonly manageUrl: string | null;
|
|
};
|
|
|
|
export async function loader({ request, params }: LoaderFunctionArgs) {
|
|
assertBookingHost(request);
|
|
const slug = requiredSlug(params.slug);
|
|
const url = new URL(request.url);
|
|
const timeZone = validTimeZone(url.searchParams.get("tz"));
|
|
const date = validDate(url.searchParams.get("date")) ?? dateInTimeZone(new Date(), timeZone);
|
|
const [page, translations] = await Promise.all([
|
|
loadAdminPublicBookingPage({ slug, date }),
|
|
getTranslations(request),
|
|
]);
|
|
if (!page) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
|
|
return {
|
|
vm: buildAdminPublicBookingVM({
|
|
...page,
|
|
submissionId: randomUUID(),
|
|
locale: translations.locale,
|
|
timeZone,
|
|
}),
|
|
};
|
|
}
|
|
|
|
export async function action({ request, params }: ActionFunctionArgs) {
|
|
assertBookingHost(request);
|
|
assertSameOrigin(request);
|
|
const slug = requiredSlug(params.slug);
|
|
const form = await request.formData();
|
|
const emailValue = form.get("email");
|
|
const email =
|
|
typeof emailValue === "string" ? emailValue.trim() : "";
|
|
const rateLimit = await checkAdminPublicBookingRateLimit({
|
|
request,
|
|
slug,
|
|
email,
|
|
secret: process.env.SESSION_SECRET?.trim() ?? "",
|
|
});
|
|
if (!rateLimit.allowed) {
|
|
return Response.json(
|
|
{
|
|
confirmed: false,
|
|
errorCode: "rate_limited",
|
|
manageUrl: null,
|
|
} satisfies ActionData,
|
|
{
|
|
status: 429,
|
|
headers: { "Retry-After": String(rateLimit.retryAfterSeconds) },
|
|
}
|
|
);
|
|
}
|
|
|
|
try {
|
|
if (!email) throw new AdminBookingError("invalid_email");
|
|
const [startsAt, endsAt] = parseSlot(requiredFormText(form, "slot"));
|
|
const date = requiredFormText(form, "date");
|
|
const secret = manageSecret();
|
|
const reservation = await submitAdminPublicBooking({
|
|
slug,
|
|
date,
|
|
startsAt,
|
|
endsAt,
|
|
firstName: requiredFormText(form, "firstName"),
|
|
lastName: requiredFormText(form, "lastName"),
|
|
email,
|
|
timeZone: validTimeZone(form.get("timeZone")),
|
|
locale: request.headers.get("accept-language")?.split(",")[0] ?? "de",
|
|
answers: readAnswers(form),
|
|
submissionId: requiredFormText(form, "submissionId"),
|
|
});
|
|
const token = issueAdminBookingManageToken({
|
|
bookingId: reservation.booking.id,
|
|
adminUserId: reservation.booking.adminUserId,
|
|
version: reservation.booking.manageTokenVersion,
|
|
expiresAt: reservation.booking.manageTokenExpiresAt,
|
|
secret,
|
|
});
|
|
return Response.json({
|
|
confirmed: true,
|
|
errorCode: null,
|
|
manageUrl: `${new URL(request.url).origin}/manage/${token}`,
|
|
} satisfies ActionData);
|
|
} catch (error) {
|
|
const errorCode =
|
|
error instanceof AdminBookingError ? error.code : "invalid_request";
|
|
return Response.json(
|
|
{ confirmed: false, errorCode, manageUrl: null } satisfies ActionData,
|
|
{ status: errorCode === "slot_taken" ? 409 : 422 }
|
|
);
|
|
}
|
|
}
|
|
|
|
export default function AdminPublicBookingRoute() {
|
|
const { vm } = useLoaderData<typeof loader>();
|
|
const actionData = useActionData<ActionData>();
|
|
const navigation = useNavigation();
|
|
return (
|
|
<AdminPublicBookingPage
|
|
vm={vm}
|
|
confirmed={actionData?.confirmed ?? false}
|
|
errorCode={actionData?.errorCode ?? null}
|
|
manageUrl={actionData?.manageUrl ?? null}
|
|
pending={navigation.state === "submitting"}
|
|
/>
|
|
);
|
|
}
|
|
|
|
function manageSecret(): string {
|
|
const secret = process.env.SESSION_SECRET?.trim() ?? "";
|
|
if (secret.length < 32) throw new AdminBookingError("invalid_request");
|
|
return secret;
|
|
}
|
|
|
|
function assertBookingHost(request: Request): void {
|
|
if (!isAdminPublicBookingHost(request)) {
|
|
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
|
|
}
|
|
}
|
|
|
|
function assertSameOrigin(request: Request): void {
|
|
const origin = request.headers.get("origin");
|
|
const fetchSite = request.headers.get("sec-fetch-site");
|
|
if (
|
|
(origin && origin !== new URL(request.url).origin) ||
|
|
(fetchSite && fetchSite !== "same-origin" && fetchSite !== "none")
|
|
) {
|
|
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
|
|
}
|
|
}
|
|
|
|
function requiredSlug(value: string | undefined): string {
|
|
const normalized = value?.trim().toLowerCase();
|
|
if (!normalized || !/^[a-z0-9][a-z0-9-]{0,62}$/u.test(normalized)) {
|
|
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
|
|
}
|
|
return normalized;
|
|
}
|
|
|
|
function requiredFormText(form: FormData, name: string): string {
|
|
const value = form.get(name);
|
|
if (typeof value !== "string" || !value.trim()) {
|
|
throw new AdminBookingError("invalid_request");
|
|
}
|
|
return value.trim();
|
|
}
|
|
|
|
function readAnswers(form: FormData): Record<string, string> {
|
|
const answers: Record<string, string> = {};
|
|
for (const [key, value] of form.entries()) {
|
|
if (key.startsWith("answer:") && typeof value === "string") {
|
|
answers[key.slice("answer:".length)] = value;
|
|
}
|
|
}
|
|
return answers;
|
|
}
|
|
|
|
function parseSlot(value: string): readonly [Date, Date] {
|
|
const [rawStart, rawEnd, ...extra] = value.split("|");
|
|
const startsAt = new Date(rawStart ?? Number.NaN);
|
|
const endsAt = new Date(rawEnd ?? Number.NaN);
|
|
if (
|
|
extra.length > 0 ||
|
|
!Number.isFinite(startsAt.getTime()) ||
|
|
!Number.isFinite(endsAt.getTime()) ||
|
|
endsAt <= startsAt
|
|
) {
|
|
throw new AdminBookingError("invalid_slot");
|
|
}
|
|
return [startsAt, endsAt];
|
|
}
|
|
|
|
function validDate(value: FormDataEntryValue | string | null): string | null {
|
|
return typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/u.test(value)
|
|
? value
|
|
: null;
|
|
}
|
|
|
|
function validTimeZone(value: FormDataEntryValue | string | null): string {
|
|
const candidate =
|
|
typeof value === "string" && value.trim()
|
|
? value.trim()
|
|
: "Europe/Berlin";
|
|
try {
|
|
new Intl.DateTimeFormat("de-DE", { timeZone: candidate }).format(
|
|
new Date()
|
|
);
|
|
return candidate;
|
|
} catch {
|
|
return "Europe/Berlin";
|
|
}
|
|
}
|
|
|
|
function dateInTimeZone(now: Date, timeZone: string): string {
|
|
const parts = new Intl.DateTimeFormat("en-CA", {
|
|
year: "numeric",
|
|
month: "2-digit",
|
|
day: "2-digit",
|
|
timeZone,
|
|
}).formatToParts(now);
|
|
const byType = new Map(parts.map((part) => [part.type, part.value]));
|
|
return `${byType.get("year")}-${byType.get("month")}-${byType.get("day")}`;
|
|
}
|