Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/app.$tenant/sites/new.tsx
T

170 lines
7.1 KiB
TypeScript

import { ActionFunctionArgs, LoaderFunctionArgs, redirect, useLoaderData, useParams, useSearchParams } from "react-router";
import { useTranslation } from "react-i18next";
import invariant from "tiny-invariant";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { getTranslations } from "~/locale/i18next.server";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import BackButtonWithTitle from "~/components/ui/buttons/BackButtonWithTitle";
import { getEnabledSiteTypes, getSiteType, SITE_TYPE, translateSiteTypeDescription, translateSiteTypeName } from "~/modules/sites/site-types";
import { createSite, isSiteIdAvailable } from "~/modules/sites/db/sites.db.server";
import { getSiteServers } from "~/modules/sites/lib/servers.server";
import SiteTypeCard from "~/modules/sites/components/site-type-card";
import SiteForm from "~/modules/sites/components/site-form";
import { appPath } from "~/utils/app/CanonicalUrlUtils";
import EmptyStateSimple from "~/components/ui/emptyState/EmptyStateSimple";
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
await requireAuth({ request, params });
const siteTypes = getEnabledSiteTypes();
const url = new URL(request.url);
const selectedType = url.searchParams.get("type");
const siteType = selectedType ? getSiteType(selectedType) : null;
if (selectedType && (!siteType || !siteType.enabled)) {
throw new Response(t("shared.notFound"), { status: 404 });
}
// Get servers for the selected type
const servers = selectedType ? getSiteServers(selectedType as SITE_TYPE) : [];
return { siteTypes, selectedType, servers };
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
const { t } = await getTranslations(request);
await requireAuth({ request, params });
const tenantId = await getTenantIdFromUrl(params);
const { userId } = await getUserInfo(request);
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString();
if (action === "create") {
try {
const type = form.get("type")?.toString();
const siteId = form.get("siteId")?.toString();
const name = form.get("name")?.toString();
const serverName = form.get("serverName")?.toString();
const serverHost = form.get("serverHost")?.toString();
const serverResolution = form.get("serverResolution")?.toString();
invariant(type, t("shared.isRequired", { 0: t("models.site.type") }));
invariant(siteId, t("shared.isRequired", { 0: t("models.site.siteId") }));
invariant(name, t("shared.isRequired", { 0: t("shared.name") }));
invariant(serverName, t("shared.isRequired", { 0: t("models.site.serverName") }));
invariant(serverHost, t("shared.isRequired", { 0: t("models.site.serverHost") }));
invariant(serverResolution, t("shared.isRequired", { 0: t("models.site.serverResolution") }));
// Validate site type exists
const siteType = getSiteType(type);
if (!siteType || !siteType.enabled) {
return { error: t("shared.notFound") };
}
// Check if siteId is available
const isAvailable = await isSiteIdAvailable(type, siteId);
if (!isAvailable) {
return { error: t("models.site.errors.siteIdTaken", { siteId, type: translateSiteTypeName(t, type, siteType) }) };
}
await createSite({
tenantId,
type,
siteId,
name,
serverName,
serverHost,
serverResolution,
createdByUserId: userId,
isActive: true,
});
return redirect(appPath({ tenantSlug: params.tenant ?? "", path: `sites/${type}`, mode: "host-aware" }));
} catch (e: any) {
return { error: e.message };
}
}
return { error: t("shared.invalidForm") };
};
export default function NewSite() {
const { t } = useTranslation();
const { siteTypes, selectedType, servers } = useLoaderData<typeof loader>();
const params = useParams();
const [searchParams, setSearchParams] = useSearchParams();
const currentType = searchParams.get("type") || selectedType;
const siteType = currentType ? getSiteType(currentType) : null;
const siteTypeName = currentType && siteType ? translateSiteTypeName(t, currentType, siteType) : "";
const siteTypeDescription = currentType && siteType ? translateSiteTypeDescription(t, currentType, siteType) : "";
const tenantSitePath = (path: string) => appPath({ tenantSlug: params.tenant ?? "", path, mode: "host-aware" });
function selectType(type: string) {
searchParams.set("type", type);
setSearchParams(searchParams);
}
return (
<EditPageLayout
title={
<BackButtonWithTitle href={tenantSitePath(currentType ? `sites/${currentType}` : "dashboard")}>
{siteType ? t("models.site.actions.newTyped", { type: siteTypeName }) : t("models.site.actions.new")}
</BackButtonWithTitle>
}
>
<div className="space-y-6">
{!currentType ? (
// Step 1: Select Site Type
<div>
{siteTypes.length === 0 ? (
<EmptyStateSimple>
<div className="text-center">
<h2 className="text-lg font-semibold">{t("models.site.types.emptyTitle")}</h2>
<p className="text-muted-foreground mt-1 text-sm">{t("models.site.types.emptyDescription")}</p>
</div>
</EmptyStateSimple>
) : (
<div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
{siteTypes.map((st) => (
// Mouse-only "click anywhere on the card" affordance. The card already
// contains a keyboard-accessible "Create" <Link> to the same ?type= URL,
// so this wrapper must not add a redundant tab stop.
// eslint-disable-next-line jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events
<div key={st.slug} onClick={() => selectType(st.slug)} className="cursor-pointer">
<SiteTypeCard slug={st.slug} config={st} sitesCount={0} createUrl={`?type=${st.slug}`} />
</div>
))}
</div>
)}
</div>
) : (
// Step 2: Configure Site
<div className="mx-auto max-w-lg">
<div className="bg-card rounded-lg border p-6">
<div className="mb-6">
<h3 className="text-lg font-medium">{t("models.site.actions.createTyped", { type: siteTypeName })}</h3>
<p className="text-muted-foreground text-sm">{siteTypeDescription}</p>
</div>
<SiteForm
type={currentType}
siteType={siteType!}
servers={servers}
onCancel={() => {
searchParams.delete("type");
setSearchParams(searchParams);
}}
/>
</div>
</div>
)}
</div>
</EditPageLayout>
);
}