Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/settings.integrations.calendar._index.tsx
T
2026-07-08 16:15:37 +02:00

145 lines
6.3 KiB
TypeScript

// AK-P16a · calendar connections settings route (M25 Block B/C). Lists the current
// user's OWN connections (leak-protection, DoD 3) + the Google connect action. The
// connect action redirects to the Google consent screen with a signed state. Module
// off -> locked empty; missing calendar.connect_own -> 404.
import { type ActionFunctionArgs, type LoaderFunctionArgs, redirect, useLoaderData, Form } from "react-router";
import { useTranslation } from "react-i18next";
import {
buildCalendarConnectionListVM,
calendarConnectionStatusKey,
calendarSyncDirectionKey,
type CalendarConnectionRow,
type CalendarConnectionListVM,
} from "@hivegrid/view-models";
import { getTranslations } from "~/locale/i18next.server";
import { validateCSRFToken } from "~/utils/session.server";
import { useRootData } from "~/utils/data/useRootData";
import { loadCalendarContext, requireCalendarPermission, calendarHasPermission, CALENDAR_PERMISSIONS } from "~/modules/calendar/routes/calendarAccess.server";
import { CALENDAR_MODULE_KEY, calendarConnectionDetailPath, calendarConnectionsPath, notFoundResponse } from "~/modules/calendar/routes/calendarRoutePaths";
import { listConnectionsForUser } from "~/modules/calendar/db/calendar.db.server";
import { buildConnectUrl, CalendarConnectError } from "~/modules/calendar/services/CalendarConnectionService.server";
import { googleCalendarAdapter } from "~/modules/calendar/services/adapters/GoogleCalendarAdapter.server";
import ServerError from "~/components/ui/errors/ServerError";
type LoaderData = { title: string; vm: CalendarConnectionListVM };
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
const ctx = await loadCalendarContext({ request, params });
const tenantSlug = params.tenant ?? "";
const title = `${t("calendar.connections.title")} | ${process.env.APP_NAME}`;
if (!ctx.hasModule) {
return Response.json({ title, vm: buildCalendarConnectionListVM({ rows: [], canConnect: false, isConfigured: false, connectHref: calendarConnectionsPath(tenantSlug) }) } satisfies LoaderData);
}
try {
requireCalendarPermission(ctx, CALENDAR_PERMISSIONS.connectOwn);
} catch {
throw notFoundResponse();
}
const connections = await listConnectionsForUser(ctx.tenantId, ctx.userId);
const rows: CalendarConnectionRow[] = connections.map((c) => ({
id: c.id,
provider: "google",
externalAccountEmail: c.externalAccountEmail,
status: c.status,
statusKey: calendarConnectionStatusKey(c.status),
syncDirection: c.syncDirection,
syncDirectionKey: calendarSyncDirectionKey(c.syncDirection),
lastSyncAt: c.lastSyncAt ? c.lastSyncAt.toISOString() : null,
lastErrorText: c.lastErrorText,
detailHref: calendarConnectionDetailPath(tenantSlug, c.id),
}));
const vm = buildCalendarConnectionListVM({
rows,
canConnect: calendarHasPermission(ctx, CALENDAR_PERMISSIONS.connectOwn),
isConfigured: googleCalendarAdapter.isConfigured(),
connectHref: calendarConnectionsPath(tenantSlug),
});
return Response.json({ title, vm } satisfies LoaderData);
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
const ctx = await loadCalendarContext({ request, params, requireModule: true });
requireCalendarPermission(ctx, CALENDAR_PERMISSIONS.connectOwn);
await validateCSRFToken(request);
const form = await request.formData();
if (form.get("intent") !== "connect") {
throw notFoundResponse();
}
try {
const url = buildConnectUrl({ tenantId: ctx.tenantId, userId: ctx.userId, tenantSlug: params.tenant ?? "" });
return redirect(url);
} catch (error) {
if (error instanceof CalendarConnectError) {
return Response.json({ error: "calendar.connections.notConfigured" }, { status: 400 });
}
throw error;
}
};
export default function CalendarConnectionsRoute() {
const { t } = useTranslation();
const rootData = useRootData();
const { vm } = useLoaderData<LoaderData>();
if (vm.status !== "ready" || !vm.data) {
return <main className="mx-auto max-w-3xl px-4 py-10" data-ui-id="ui.calendar.connections" />;
}
const { rows, canConnect, isConfigured, emptyHeadlineKey, emptyBodyKey, notConfiguredKey } = vm.data;
return (
<main className="mx-auto max-w-3xl px-4 py-10" data-ui-id="ui.calendar.connections">
<h1 className="text-foreground text-xl font-semibold">{t("calendar.connections.title")}</h1>
<p className="text-muted-foreground mt-1 text-sm">{t("calendar.connections.subtitle")}</p>
{!isConfigured && (
<p className="border-border text-muted-foreground mt-4 rounded-md border px-3 py-2 text-sm" data-ui-id="ui.calendar.connections.notConfigured">
{t(notConfiguredKey)}
</p>
)}
{canConnect && isConfigured && (
<Form method="post" className="mt-4">
{rootData.csrf && <input type="hidden" name="csrf" value={rootData.csrf} />}
<input type="hidden" name="intent" value="connect" />
<button type="submit" className="bg-theme-600 rounded-md px-4 py-2 text-sm font-medium text-white" data-ui-id="ui.calendar.connections.connect">
{t("calendar.connections.connectButton")}
</button>
</Form>
)}
{rows.length === 0 ? (
<div className="mt-10 text-center" data-ui-id="ui.calendar.connections.empty">
<p className="text-foreground font-medium">{t(emptyHeadlineKey)}</p>
<p className="text-muted-foreground mt-1 text-sm">{t(emptyBodyKey)}</p>
</div>
) : (
<ul className="mt-6 divide-border divide-y" data-ui-id="ui.calendar.connections.list">
{rows.map((row) => (
<li key={row.id} className="flex items-center justify-between py-3" data-row-id={row.id}>
<div>
<a href={row.detailHref} className="text-theme-600 font-medium">
{row.externalAccountEmail}
</a>
<p className="text-muted-foreground text-xs">{t(row.syncDirectionKey)}</p>
</div>
<span className="text-muted-foreground text-xs" data-status={row.status}>
{t(row.statusKey)}
</span>
</li>
))}
</ul>
)}
</main>
);
}
export function ErrorBoundary() {
return <ServerError />;
}
export const handle = { moduleKey: CALENDAR_MODULE_KEY };