Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/admin/accounts/new.tsx
T

156 lines
5.9 KiB
TypeScript

import { randomUUID } from "node:crypto";
import { ActionFunctionArgs, LoaderFunctionArgs, MetaFunction, redirect, useActionData, useLoaderData, useNavigation } from "react-router";
import { CatalogError } from "@hivegrid/foundation";
import { AdminTenantCreatePage } from "~/components/screens/admin/AdminTenantCreatePage";
import ServerError from "~/components/ui/errors/ServerError";
import { getTranslations } from "~/locale/i18next.server";
import { AdminActionInputError, assertAdminActionReason, recordAdminAction } from "~/services/admin/admin-action-audit.server";
import { AdminBillingError, extendTenantTrial, setTenantBillingPlanSeats } from "~/services/admin/billing-admin.server";
import { prepareReservedOwnerInvitation } from "~/domain/tenant-bootstrap/ownerInvitationIssuance.server";
import { reserveTenantWithoutOwner } from "~/domain/tenant-bootstrap/tenantBootstrapService.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import UrlUtils from "~/utils/app/UrlUtils";
import UserValidationUtils from "~/utils/app/UserValidationUtils";
import { useRootData } from "~/utils/data/useRootData";
import { getUser } from "~/utils/db/users.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { isReservedTenantSlug, normalizeTenantSlug } from "~/utils/services/tenantService";
import { requireUserId, validateCSRFToken } from "~/utils/session.server";
const RESERVATION_REQUEST_KEY_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
type LoaderData = {
title: string;
reservationRequestKey: string;
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export const loader = async ({ request }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.accounts.create");
const { t } = await getTranslations(request);
return {
title: `${t("admin.accounts.create.title")} | ${process.env.APP_NAME}`,
reservationRequestKey: randomUUID(),
} satisfies LoaderData;
};
type ActionData = {
error?: string;
};
function badRequest(data: ActionData, status = 400) {
return Response.json(data, { status });
}
export const action = async ({ request }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.accounts.create");
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
const name = form.get("name")?.toString().trim() ?? "";
const slug = normalizeTenantSlug(form.get("slug")?.toString() ?? "");
const reservationRequestKey = form.get("reservationRequestKey")?.toString() ?? "";
const ownerEmail = form.get("ownerEmail")?.toString().trim().toLowerCase() ?? "";
const ownerFirstName = form.get("ownerFirstName")?.toString().trim() ?? "";
const ownerLastName = form.get("ownerLastName")?.toString().trim() ?? "";
const planCode = form.get("planCode")?.toString().trim() ?? "";
const seatQuantity = form.get("seatQuantity")?.toString() ?? "1";
const trialDays = Number.parseInt(form.get("trialDays")?.toString() ?? "0", 10) || 0;
if (
!name ||
!slug ||
!RESERVATION_REQUEST_KEY_PATTERN.test(reservationRequestKey) ||
!UserValidationUtils.validateEmail(ownerEmail) ||
!ownerFirstName ||
!ownerLastName
) {
return badRequest({ error: t("shared.invalidForm") });
}
if (slug !== UrlUtils.slugify(slug) || isReservedTenantSlug(slug)) {
return badRequest({ error: t("settings.tenant.errors.reservedSlug", { slug }) });
}
const operatorUserId = await requireUserId(request);
const operator = await getUser(operatorUserId);
if (!operator) {
return badRequest({ error: t("shared.invalidForm") });
}
let reason: string;
try {
reason = assertAdminActionReason(form.get("reason")?.toString());
} catch (error) {
if (error instanceof AdminActionInputError) return badRequest({ error: t(error.i18nKey) });
throw error;
}
try {
const ownerInvitation = await prepareReservedOwnerInvitation({
request,
issuanceKey: reservationRequestKey,
tenantName: name,
email: ownerEmail,
firstName: ownerFirstName,
lastName: ownerLastName,
issuer: { id: operator.id, firstName: operator.firstName, locale: operator.locale },
});
const tenant = await reserveTenantWithoutOwner({ name, slug, operatorUserId, reservationRequestKey, ownerInvitation });
const actor = { actorUserId: operator.id, actorEmail: operator.email, request };
if (planCode) {
await setTenantBillingPlanSeats({ tenantId: tenant.id, planCode, seatQuantity, reason, ...actor });
}
if (trialDays > 0) {
await extendTenantTrial({ tenantId: tenant.id, days: trialDays, reason, ...actor });
}
await recordAdminAction({
action: "tenant.created",
targetKind: "tenant",
targetId: tenant.id,
reason,
after: {
name,
slug,
ownerEmail,
planCode: planCode || null,
trialDays: trialDays || null,
},
...actor,
});
return redirect(`${adminPath(`accounts/${tenant.id}`, { mode: "host-aware" })}?toast=${encodeURIComponent("admin.accounts.toast.created")}`);
} catch (error) {
if (error instanceof AdminActionInputError || error instanceof AdminBillingError) {
return badRequest({ error: t(error.i18nKey) });
}
if (error instanceof CatalogError) {
return badRequest({ error: t("admin.accounts.create.failed") }, 409);
}
throw error;
}
};
export default function AdminTenantCreateRoute() {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const navigation = useNavigation();
const rootData = useRootData();
return (
<AdminTenantCreatePage
reservationRequestKey={data.reservationRequestKey}
csrf={rootData.csrf ?? ""}
submitting={navigation.state === "submitting"}
feedback={{ error: actionData?.error }}
/>
);
}
export function ErrorBoundary() {
return <ServerError />;
}