131 lines
5.8 KiB
TypeScript
131 lines
5.8 KiB
TypeScript
import type { ActionFunctionArgs, LoaderFunctionArgs, MetaFunction } from "react-router";
|
|
import { useFetcher, useLoaderData } from "react-router";
|
|
|
|
import type { AuditEventWriterClient } from "@hivegrid/db/audit-events.server";
|
|
import { ADMIN_EDITABLE_ROLE_KEYS, ADMIN_ROLE_KEYS, isAdminPermissionName } from "@hivegrid/db/admin-permissions";
|
|
import { runWithRlsTransaction } from "@hivegrid/db/rls-context.server";
|
|
import { buildAdminRoleEditorVM } from "@hivegrid/view-models";
|
|
|
|
import { AdminRolesPage } from "~/components/screens/admin/sales/security/AdminRolesPage";
|
|
import { useSaveToast } from "~/hooks/use-save-toast";
|
|
import { getTranslations } from "~/locale/i18next.server";
|
|
import { assertAdminActionReason, recordAdminAction } from "~/services/admin/admin-action-audit.server";
|
|
import { runAsAdminIdentity } from "~/services/admin/admin-identity.server";
|
|
import { useRootData } from "~/utils/data/useRootData";
|
|
import { db } from "~/utils/db.server";
|
|
import { validateCSRFToken } from "~/utils/session.server";
|
|
|
|
type ActionData = { ok: true; messageKey: string } | { ok: false; errorKey: string };
|
|
const editableRoleKeySet = new Set<string>(ADMIN_EDITABLE_ROLE_KEYS);
|
|
|
|
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
|
|
|
|
export async function loader({ request }: LoaderFunctionArgs) {
|
|
const { t } = await getTranslations(request);
|
|
const vm = await runAsAdminIdentity(request, "admin_identity.roles.read", async () => {
|
|
const [roles, permissions] = await Promise.all([
|
|
db.adminRole.findMany({
|
|
where: { active: true, systemKey: { in: [...ADMIN_ROLE_KEYS] } },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
description: true,
|
|
systemKey: true,
|
|
isSystem: true,
|
|
permissions: { select: { permission: { select: { name: true } } } },
|
|
_count: { select: { users: true } },
|
|
},
|
|
}),
|
|
db.adminPermission.findMany({ select: { name: true, description: true } }),
|
|
]);
|
|
return buildAdminRoleEditorVM({ roles, permissions });
|
|
});
|
|
return { title: `${t("admin.sales.adminRoles.title")} | ${process.env.APP_NAME}`, vm };
|
|
}
|
|
|
|
export async function action({ request }: ActionFunctionArgs) {
|
|
await validateCSRFToken(request);
|
|
const form = await request.formData();
|
|
if (form.get("intent") !== "save-role") {
|
|
return Response.json({ ok: false, errorKey: "admin.sales.adminRoles.errors.updateFailed" } satisfies ActionData, { status: 400 });
|
|
}
|
|
let reason: string;
|
|
try {
|
|
reason = assertAdminActionReason(String(form.get("reason") ?? ""));
|
|
} catch {
|
|
return Response.json({ ok: false, errorKey: "admin.audit.errors.reasonTooShort" } satisfies ActionData, { status: 400 });
|
|
}
|
|
const roleId = String(form.get("roleId") ?? "");
|
|
const permissions = [...new Set(form.getAll("permission").map(String).filter(isAdminPermissionName))];
|
|
try {
|
|
await runAsAdminIdentity(request, "admin_identity.roles.manage", async (session) =>
|
|
db.$transaction((transaction) =>
|
|
runWithRlsTransaction(transaction, async () => {
|
|
const role = await transaction.adminRole.findUnique({ where: { id: roleId }, select: { id: true, systemKey: true } });
|
|
if (!role?.systemKey || !editableRoleKeySet.has(role.systemKey)) {
|
|
throw new Error("Only editable system role bundles may be changed");
|
|
}
|
|
const permissionRows = await transaction.adminPermission.findMany({
|
|
where: { name: { in: permissions } },
|
|
select: { id: true, name: true },
|
|
});
|
|
if (permissionRows.length !== permissions.length) throw new Error("Unknown permission");
|
|
await transaction.adminRolePermission.deleteMany({ where: { adminRoleId: roleId } });
|
|
await transaction.adminRolePermission.createMany({
|
|
data: permissionRows.map((permission) => ({ adminRoleId: roleId, adminPermissionId: permission.id })),
|
|
});
|
|
const revokedSessions = await transaction.adminSession.updateMany({
|
|
where: {
|
|
revokedAt: null,
|
|
adminUser: { roles: { some: { adminRoleId: roleId } } },
|
|
},
|
|
data: { revokedAt: new Date() },
|
|
});
|
|
await recordAdminAction(
|
|
{
|
|
action: "security.adminRolePermissionsChanged",
|
|
actorUserId: session.adminUserId,
|
|
actorEmail: session.adminUser.email,
|
|
targetKind: "admin-role",
|
|
targetId: roleId,
|
|
reason,
|
|
request,
|
|
after: { permissions, revokedSessions: revokedSessions.count },
|
|
},
|
|
transaction as unknown as AuditEventWriterClient
|
|
);
|
|
})
|
|
)
|
|
);
|
|
return Response.json({ ok: true, messageKey: "admin.sales.adminRoles.toast.saved" } satisfies ActionData);
|
|
} catch (error) {
|
|
if (error instanceof Response) throw error;
|
|
return Response.json({ ok: false, errorKey: "admin.sales.adminRoles.errors.updateFailed" } satisfies ActionData, { status: 400 });
|
|
}
|
|
}
|
|
|
|
export default function AdminRolesRoute() {
|
|
const { vm } = useLoaderData<typeof loader>();
|
|
const fetcher = useFetcher<ActionData>();
|
|
const root = useRootData();
|
|
useSaveToast(fetcher.data?.ok ? fetcher.data : undefined);
|
|
return (
|
|
<AdminRolesPage
|
|
vm={vm}
|
|
busy={fetcher.state !== "idle"}
|
|
errorKey={fetcher.data && !fetcher.data.ok ? fetcher.data.errorKey : undefined}
|
|
actions={{
|
|
onSaveRole: ({ roleId, permissions, reason }) => {
|
|
const form = new FormData();
|
|
form.set("intent", "save-role");
|
|
form.set("roleId", roleId);
|
|
form.set("reason", reason);
|
|
for (const permission of permissions) form.append("permission", permission);
|
|
if (root.csrf) form.set("csrf", root.csrf);
|
|
fetcher.submit(form, { method: "post" });
|
|
},
|
|
}}
|
|
/>
|
|
);
|
|
}
|