Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/admin/audit-export.tsx
T
2026-07-08 16:15:37 +02:00

168 lines
6.4 KiB
TypeScript

/**
* Phase 10 Task #67 — Admin (system-wide) Compliance-Audit-Export.
*
* Streams a filtered CSV of AuditEvent rows across ALL tenants. Filters:
* date range, regulatoryScope, actorType, outcome. The first CSV line is
* a `# verifyAuditChain` integrity header so the download itself doubles
* as evidence that the chain is intact.
*
* Tenant-scoped variant lives at routes/app.$tenant/settings/audit-export.tsx.
*/
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData } from "react-router";
import { getDbClient } from "@hivegrid/db/client.server";
import { buildAuditExportVM, toAuditExportResultVM, type AuditExportVM } from "@hivegrid/view-models";
import { AuditExportPage } from "~/components/screens/audit/AuditExportPage";
import ServerError from "~/components/ui/errors/ServerError";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getUserInfo } from "~/utils/session.server";
import { getTranslations } from "~/locale/i18next.server";
import {
AUDIT_EXPORT_MAX_ROWS,
buildAuditExportWhere,
computeAuditIntegritySummary,
parseAuditExportFilters,
renderAuditExportCsv,
type AuditExportRow,
} from "./audit-export.helpers.server";
import { buildAuditPdfLabels, renderAuditExportPdfResponse } from "~/utils/audit/pdfRender";
import {
AuditExportPurposeRequiredError,
AuditExportStorageUnavailableError,
parseAuditExportFormat,
runAuditExportToStorage,
} from "~/utils/audit/auditExportStorage.server";
type ActionData =
| { ok: true; url: string; rowCount: number; integrityOk: boolean; expiresInSeconds: number }
| { ok: false; errorKey: string };
// Interim-screen Selects submit a "__all__" sentinel for "no filter" (empty
// string is not a valid ~/ui Select value) — treat it as absent everywhere.
const FILTER_ALL = "__all__";
function filtersFromForm(form: FormData): URL {
const params = new URLSearchParams();
for (const key of ["from", "to", "actorType", "outcome", "tenantId"]) {
const value = form.get(key)?.toString().trim();
if (value && value !== FILTER_ALL) params.set(key, value);
}
for (const value of form.getAll("regulatoryScope")) {
const v = value.toString().trim();
if (v && v !== FILTER_ALL) params.append("regulatoryScope", v);
}
return new URL(`https://audit.local/?${params.toString()}`);
}
function stripFilterSentinels(url: URL): URL {
const cleaned = new URL(url.toString());
for (const key of Array.from(cleaned.searchParams.keys())) {
const values = cleaned.searchParams.getAll(key).filter((value) => value.trim() !== FILTER_ALL);
cleaned.searchParams.delete(key);
for (const value of values) cleaned.searchParams.append(key, value);
}
return cleaned;
}
export const action = async ({ request }: ActionFunctionArgs): Promise<ActionData> => {
await verifyUserHasPermission(request, "admin.auditTrails.view");
const [userInfo, form] = await Promise.all([getUserInfo(request), request.formData()]);
const filters = parseAuditExportFilters(filtersFromForm(form));
try {
const result = await runAuditExportToStorage({
filters,
format: parseAuditExportFormat(form.get("format")?.toString()),
purpose: form.get("purpose")?.toString() ?? "",
actor: { id: userInfo.userId, type: "admin" },
tenantId: filters.tenantId,
});
return { ok: true, url: result.url, rowCount: result.rowCount, integrityOk: result.integrityOk, expiresInSeconds: result.expiresInSeconds };
} catch (error) {
if (error instanceof AuditExportPurposeRequiredError) return { ok: false, errorKey: "auditExport.storage.errorPurpose" };
if (error instanceof AuditExportStorageUnavailableError) return { ok: false, errorKey: "auditExport.storage.errorUnavailable" };
throw error;
}
};
type LoaderData = {
title: string;
vm: AuditExportVM;
};
export const loader = async ({ request }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.auditTrails.view");
const { t } = await getTranslations(request);
const url = stripFilterSentinels(new URL(request.url));
if (url.searchParams.get("export") === "csv") {
return streamAdminAuditExport(url);
}
if (url.searchParams.get("export") === "pdf" || url.searchParams.get("format") === "pdf") {
return streamAdminAuditPdfExport(url, t);
}
const today = new Date();
const fromDate = new Date(today);
fromDate.setDate(fromDate.getDate() - 30);
const data: LoaderData = {
title: `${t("translations:models.log.plural")} | ${process.env.APP_NAME}`,
vm: buildAuditExportVM({
defaultFrom: fromDate.toISOString().slice(0, 10),
defaultTo: today.toISOString().slice(0, 10),
maxRows: AUDIT_EXPORT_MAX_ROWS,
}),
};
return Response.json(data);
};
async function streamAdminAuditExport(url: URL): Promise<Response> {
const filters = parseAuditExportFilters(url);
const db = getDbClient();
const rows = (await db.auditEvent.findMany({
where: buildAuditExportWhere(filters),
orderBy: { createdAt: "asc" },
take: AUDIT_EXPORT_MAX_ROWS,
})) as unknown as AuditExportRow[];
const integrity = computeAuditIntegritySummary(rows);
const csv = renderAuditExportCsv(rows, integrity);
return new Response(csv, {
headers: {
"Content-Type": "text/csv; charset=utf-8",
"Content-Disposition": `attachment; filename="audit-export-admin-${url.searchParams.get("from") ?? "all"}_${url.searchParams.get("to") ?? "all"}.csv"`,
"X-Audit-Chain-Status": integrity.ok ? "ok" : "broken",
},
});
}
async function streamAdminAuditPdfExport(url: URL, t: Awaited<ReturnType<typeof getTranslations>>["t"]): Promise<Response> {
const filters = parseAuditExportFilters(url);
const db = getDbClient();
const rows = (await db.auditEvent.findMany({
where: buildAuditExportWhere(filters),
orderBy: { createdAt: "asc" },
take: AUDIT_EXPORT_MAX_ROWS,
})) as unknown as AuditExportRow[];
const integrity = computeAuditIntegritySummary(rows);
return renderAuditExportPdfResponse(
{
tenantId: filters.tenantId,
filters,
integrity,
rows,
labels: buildAuditPdfLabels(t),
},
{ filenamePrefix: "audit-export-admin" }
);
}
export default function AdminAuditExportRoute() {
const { vm } = useLoaderData<LoaderData>();
const actionData = useActionData<unknown>();
return <AuditExportPage vm={vm} result={toAuditExportResultVM(actionData)} />;
}
export function ErrorBoundary() {
return <ServerError />;
}