167 lines
6.6 KiB
TypeScript
167 lines
6.6 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 { loadAuditVerificationContext } from "@hivegrid/db/audit-chain-checkpoint.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 { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
|
|
import { getUserInfo } from "~/utils/session.server";
|
|
import { getTranslations } from "~/locale/i18next.server";
|
|
import {
|
|
AUDIT_EXPORT_MAX_ROWS,
|
|
buildAuditExportWhere,
|
|
computeAuditIntegritySummary,
|
|
hasAuditExportPrefixFilters,
|
|
parseAuditExportFilters,
|
|
renderAuditExportCsv,
|
|
stripAuditExportFilterSentinels,
|
|
type AuditExportRow,
|
|
} from "./audit-export.helpers.server";
|
|
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()}`);
|
|
}
|
|
|
|
export const action = async ({ request }: ActionFunctionArgs): Promise<ActionData> => {
|
|
await requireAdminIdentityPermission(request, "admin_identity.audit.export");
|
|
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 requireAdminIdentityPermission(request, "admin_identity.audit.export");
|
|
const { t } = await getTranslations(request);
|
|
const url = stripAuditExportFilterSentinels(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 verification = await loadAuditVerificationContext(db as never, rows, {
|
|
allowPartialPrefix: hasAuditExportPrefixFilters(filters),
|
|
});
|
|
const integrity = computeAuditIntegritySummary(rows, verification);
|
|
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 { buildAuditPdfLabels, renderAuditExportPdfResponse } = await import("~/utils/audit/pdfRender");
|
|
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 verification = await loadAuditVerificationContext(db as never, rows, {
|
|
allowPartialPrefix: hasAuditExportPrefixFilters(filters),
|
|
});
|
|
const integrity = computeAuditIntegritySummary(rows, verification);
|
|
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 />;
|
|
}
|