342 lines
15 KiB
TypeScript
342 lines
15 KiB
TypeScript
import { useEffect } from "react";
|
|
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useActionData, useLoaderData } from "react-router";
|
|
import { useNavigate, useNavigation, useOutlet, useParams, useSubmit } from "react-router";
|
|
import { useTranslation } from "react-i18next";
|
|
import toast from "react-hot-toast";
|
|
import { buildMembersListVM, type MembersListVM, type MemberStatus } from "@hivegrid/view-models";
|
|
import { getTenant, getTenantMember, getTenantUsers } from "~/utils/db/tenants.db.server";
|
|
import { deleteUserInvitation, getUserInvitation, getUserInvitations } from "~/utils/db/tenantUserInvitations.db.server";
|
|
import { getTranslations } from "~/locale/i18next.server";
|
|
import UrlUtils from "~/utils/app/UrlUtils";
|
|
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
|
|
import { getUserPermission, verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
|
|
import { getTenantAssignableAppRole, getTenantAssignableAppRoles } from "~/utils/db/permissions/roles.db.server";
|
|
import { getEnabledTotpUserIds, getUser, getUserTotpStatus } from "~/utils/db/users.db.server";
|
|
import { createAdminLog } from "~/utils/db/logs.db.server";
|
|
import { createUserRole, deleteUserRole } from "~/utils/db/permissions/userRoles.db.server";
|
|
import { createImpersonationStartedAt, createUserSession, getUserInfo, getUserSession, setLoggedUser, validateCSRFToken } from "~/utils/session.server";
|
|
import { deactivateTenantUser, reactivateTenantUser } from "~/utils/services/tenantUserLifecycle.server";
|
|
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
|
|
import { MembersPage, type MembersActions } from "~/components/screens/users/MembersPage";
|
|
import { Dialog } from "~/ui/components/Dialog";
|
|
import { DefaultAppRoles } from "~/application/dtos/shared/DefaultAppRoles";
|
|
import { useRootData } from "~/utils/data/useRootData";
|
|
import EventsService from "~/modules/events/services/.server/EventsService";
|
|
import { RoleAssignedDto } from "~/modules/events/dtos/RoleAssignedDto";
|
|
import { RoleUnassignedDto } from "~/modules/events/dtos/RoleUnassignedDto";
|
|
import { enforceAdminMfa } from "~/utils/auth/mfa/enforcement.server";
|
|
import { checkMfaStepUpState } from "~/utils/auth/mfa/step-up.server";
|
|
import { appPath } from "~/utils/app/CanonicalUrlUtils";
|
|
import { loadRequiredWebConfig } from "@hivegrid/config";
|
|
import { absoluteAdminPath, absoluteAppPath } from "~/utils/app/CrossHostUrls";
|
|
import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus";
|
|
|
|
type LoaderData = {
|
|
title: string;
|
|
vm: MembersListVM;
|
|
canViewRoles: boolean;
|
|
};
|
|
|
|
function toMemberStatus(status: TenantUserStatus): MemberStatus {
|
|
if (status === TenantUserStatus.ACTIVE) return "active";
|
|
if (status === TenantUserStatus.INACTIVE) return "inactive";
|
|
return "invited";
|
|
}
|
|
|
|
async function hasPermission(userId: string, permissionName: string, tenantId: string): Promise<boolean> {
|
|
const { permission, userPermission } = await getUserPermission({ userId, permissionName, tenantId });
|
|
return !permission || Boolean(userPermission);
|
|
}
|
|
|
|
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
|
|
const { t } = await getTranslations(request);
|
|
const tenantId = await getTenantIdFromUrl(params);
|
|
const userInfo = await getUserInfo(request);
|
|
await verifyUserHasPermission(request, "app.settings.members.view", tenantId);
|
|
|
|
// Deactivated members stay visible with status "Deaktiviert" (David's S01/M03).
|
|
const [users, pendingInvitations, roles, canInvite, canEditRoles, canManageMembers, canViewRoles] = await Promise.all([
|
|
getTenantUsers(tenantId, { includeInactive: true }),
|
|
getUserInvitations(tenantId),
|
|
// Assignable defaults + the tenant's own custom/SHK roles (D01 dropdown).
|
|
getTenantAssignableAppRoles(tenantId),
|
|
hasPermission(userInfo.userId, "app.settings.members.create", tenantId),
|
|
hasPermission(userInfo.userId, "app.settings.roles.set", tenantId),
|
|
hasPermission(userInfo.userId, "app.settings.members.update", tenantId),
|
|
hasPermission(userInfo.userId, "app.settings.roles.view", tenantId),
|
|
]);
|
|
const mfaEnabledUserIds = new Set(await getEnabledTotpUserIds(users.map((member) => member.user.id)));
|
|
|
|
const vm = buildMembersListVM({
|
|
rows: users.map((member) => ({
|
|
tenantUserId: member.id,
|
|
userId: member.userId,
|
|
firstName: member.user.firstName,
|
|
lastName: member.user.lastName,
|
|
email: member.user.email,
|
|
phone: member.user.phone,
|
|
status: toMemberStatus(member.status),
|
|
mfaEnabled: mfaEnabledUserIds.has(member.user.id),
|
|
roles: member.user.roles
|
|
.filter((userRole) => userRole.tenantId === tenantId)
|
|
.map((userRole) => ({ id: userRole.role.id, name: userRole.role.name, description: userRole.role.description })),
|
|
})),
|
|
pendingInvitations: pendingInvitations.map((invitation) => ({
|
|
id: invitation.id,
|
|
email: invitation.email,
|
|
name: [invitation.firstName, invitation.lastName].filter(Boolean).join(" "),
|
|
createdAtIso: null,
|
|
})),
|
|
assignableRoles: roles.map((role) => ({ id: role.id, name: role.name, description: role.description })),
|
|
currentUserId: userInfo.userId,
|
|
canInvite,
|
|
canEditRoles,
|
|
canManageMembers,
|
|
});
|
|
|
|
const data: LoaderData = {
|
|
title: `${t("settings.members.title")} | ${process.env.APP_NAME}`,
|
|
vm,
|
|
canViewRoles,
|
|
};
|
|
return data;
|
|
};
|
|
|
|
type ActionData = {
|
|
success?: string;
|
|
error?: string;
|
|
/** Machine-readable guard code — "last-admin" opens the V01 blocker dialog. */
|
|
code?: string;
|
|
};
|
|
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
|
|
export const action: ActionFunction = async ({ request, params }) => {
|
|
const { t } = await getTranslations(request);
|
|
const tenantId = await getTenantIdFromUrl(params);
|
|
await verifyUserHasPermission(request, "app.settings.members.update", tenantId);
|
|
await validateCSRFToken(request);
|
|
const userInfo = await getUserInfo(request);
|
|
const form = await request.formData();
|
|
const action = form.get("action")?.toString();
|
|
const fromUser = await getUser(userInfo.userId);
|
|
if (!fromUser) {
|
|
return badRequest({ error: t("settings.members.errors.invalidUser") });
|
|
}
|
|
|
|
if (action === "delete-invitation") {
|
|
await verifyUserHasPermission(request, "app.settings.members.delete", tenantId);
|
|
const invitationId = form.get("invitation-id")?.toString() ?? "";
|
|
const invitation = await getUserInvitation(invitationId, tenantId);
|
|
if (!invitation) {
|
|
return badRequest({
|
|
error: t("settings.members.errors.invitationNotFound"),
|
|
});
|
|
}
|
|
await deleteUserInvitation(invitation.id, tenantId);
|
|
return Response.json({ success: t("settings.members.success.invitationDeleted") });
|
|
}
|
|
if (action === "deactivate" || action === "reactivate") {
|
|
// R-P2b user lifecycle (M03/V01): soft-deactivation via the lifecycle service.
|
|
// Reassign-on-deactivate stays Backlog/V2 (David) — the service keeps the option.
|
|
const userId = form.get("user-id")?.toString() ?? "";
|
|
const tenant = await getTenant(tenantId);
|
|
const tenantMember = await getTenantMember(userId, tenantId);
|
|
if (!tenant || !tenantMember) {
|
|
return badRequest({ error: t("shared.invalidForm") });
|
|
}
|
|
if (action === "deactivate") {
|
|
const result = await deactivateTenantUser({ tenantId, targetUserId: userId });
|
|
if (!result.ok) {
|
|
if (result.reason === "last-admin") {
|
|
return badRequest({ error: t("settings.members.errors.lastAdminBody"), code: "last-admin" });
|
|
}
|
|
return badRequest({ error: t("shared.invalidForm") });
|
|
}
|
|
createAdminLog(request, "settings.members.deactivated", `[${tenant.name}] ${tenantMember.user.email}`);
|
|
return Response.json({ success: t("settings.members.success.deactivated") });
|
|
}
|
|
const result = await reactivateTenantUser({ tenantId, targetUserId: userId });
|
|
if (!result.ok) {
|
|
return badRequest({ error: t("shared.invalidForm") });
|
|
}
|
|
createAdminLog(request, "settings.members.reactivated", `[${tenant.name}] ${tenantMember.user.email}`);
|
|
return Response.json({ success: t("settings.members.success.reactivated") });
|
|
}
|
|
if (action === "edit") {
|
|
await verifyUserHasPermission(request, "app.settings.roles.set", tenantId);
|
|
const userId = form.get("user-id")?.toString() ?? "";
|
|
const roleId = form.get("role-id")?.toString() ?? "";
|
|
const add = form.get("add") === "true";
|
|
|
|
const tenant = await getTenant(tenantId);
|
|
const tenantMember = await getTenantMember(userId, tenantId);
|
|
const user = tenantMember?.user ?? null;
|
|
const role = await getTenantAssignableAppRole(roleId, tenantId);
|
|
|
|
if (!tenantMember || !user || !role || role.type !== "app" || !tenant) {
|
|
return badRequest({ error: t("shared.invalidForm") });
|
|
}
|
|
|
|
if (role?.name === DefaultAppRoles.SuperUser) {
|
|
const allMembers = await getTenantUsers(tenantId);
|
|
const activeMembers = allMembers.filter((member) => member.status === TenantUserStatus.ACTIVE);
|
|
const superAdmins = activeMembers.filter((m) => m.user.roles.some((r) => r.tenantId === tenantId && r.role.name === DefaultAppRoles.SuperUser));
|
|
if (superAdmins.length === 1 && !add) {
|
|
// Same guard family as deactivation: the workspace must keep an admin (V01).
|
|
return badRequest({
|
|
error: t("settings.members.errors.atLeastOneSuperAdmin"),
|
|
code: "last-admin",
|
|
});
|
|
}
|
|
if (userId === userInfo.userId) {
|
|
return badRequest({
|
|
error: t("settings.members.errors.cannotRemoveOwnSuperAdminRole"),
|
|
});
|
|
}
|
|
}
|
|
if (add) {
|
|
await createUserRole(userId, roleId, tenantId);
|
|
if (fromUser && user && role) {
|
|
await EventsService.create({
|
|
request,
|
|
event: "role.assigned",
|
|
tenantId,
|
|
userId: fromUser.id,
|
|
data: {
|
|
fromUser: { id: fromUser.id, email: fromUser.email },
|
|
toUser: { id: user.id, email: user.email },
|
|
role: { id: role.id, name: role.name, description: role.description },
|
|
} satisfies RoleAssignedDto,
|
|
});
|
|
}
|
|
createAdminLog(request, "settings.memberRoles.created", `[${tenant?.name}] ${user?.email} - ${role?.name}`);
|
|
} else {
|
|
await EventsService.create({
|
|
request,
|
|
event: "role.unassigned",
|
|
tenantId: tenant?.id ?? null,
|
|
userId: fromUser.id,
|
|
data: {
|
|
fromUser: { id: fromUser.id, email: fromUser.email },
|
|
toUser: { id: user.id, email: user.email },
|
|
role: { id: role.id, name: role.name, description: role.description },
|
|
} satisfies RoleUnassignedDto,
|
|
});
|
|
await deleteUserRole(userId, roleId, tenantId);
|
|
createAdminLog(request, "settings.memberRoles.deleted", `[${tenant?.name}] ${user?.email} - ${role?.name}`);
|
|
}
|
|
return Response.json({});
|
|
} else if (action === "impersonate") {
|
|
await verifyUserHasPermission(request, "app.settings.members.impersonate", tenantId);
|
|
const session = await getUserSession(request);
|
|
const mfaEnforcement = enforceAdminMfa({
|
|
requestUrl: request.url,
|
|
userId: fromUser.id,
|
|
isAdmin: Boolean(fromUser.admin),
|
|
totpStatus: await getUserTotpStatus(fromUser.id),
|
|
stepUp: checkMfaStepUpState(session, fromUser.id),
|
|
redirectMode: "host-aware",
|
|
appFallbackPath: appPath({ tenantSlug: params.tenant ?? "", path: "settings/members", mode: "host-aware" }),
|
|
});
|
|
if (!mfaEnforcement.allowed) {
|
|
const routing = loadRequiredWebConfig().routing;
|
|
if (mfaEnforcement.reason === "missing-admin" || mfaEnforcement.reason === "missing-user") {
|
|
throw redirect(absoluteAppPath(routing, params.tenant ?? "", "settings/members"));
|
|
}
|
|
throw redirect(absoluteAdminPath(routing, mfaEnforcement.redirectTo));
|
|
}
|
|
|
|
const userId = form.get("user-id")?.toString();
|
|
const tenantMember = await getTenantMember(userId, tenantId);
|
|
const user = tenantMember ? await getUser(userId) : null;
|
|
if (!tenantMember || !user) {
|
|
return badRequest({ error: t("shared.notFound") });
|
|
}
|
|
if (user.admin) {
|
|
return badRequest({ error: t("settings.members.errors.cannotImpersonateSuperAdmin") });
|
|
}
|
|
const userSession = await setLoggedUser(user);
|
|
if (!userSession) {
|
|
return badRequest({ error: t("shared.notFound") });
|
|
}
|
|
const tenant = await getTenant(tenantId);
|
|
return createUserSession(
|
|
{
|
|
...userInfo,
|
|
...userSession,
|
|
impersonatingFromUserId: userInfo.userId,
|
|
impersonatingStartedAt: createImpersonationStartedAt(),
|
|
},
|
|
tenant ? appPath({ tenantSlug: tenant.slug, path: "dashboard", mode: "host-aware" }) : "/"
|
|
);
|
|
} else {
|
|
return badRequest({ error: t("shared.invalidForm") });
|
|
}
|
|
};
|
|
|
|
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
|
|
|
|
export default function MembersSettingsRoute() {
|
|
const { t } = useTranslation();
|
|
const params = useParams();
|
|
const data = useLoaderData<LoaderData>();
|
|
const actionData = useActionData<ActionData>();
|
|
const rootData = useRootData();
|
|
const navigate = useNavigate();
|
|
const navigation = useNavigation();
|
|
const outlet = useOutlet();
|
|
const submit = useSubmit();
|
|
|
|
const submitting = navigation.state === "submitting";
|
|
const lastAdminBlocked = actionData?.code === "last-admin";
|
|
|
|
useEffect(() => {
|
|
if (actionData?.success) {
|
|
toast.success(actionData.success);
|
|
} else if (actionData?.error && actionData.code !== "last-admin") {
|
|
toast.error(actionData.error);
|
|
}
|
|
}, [actionData]);
|
|
|
|
function post(fields: Record<string, string>) {
|
|
const formData = new FormData();
|
|
if (rootData.csrf) formData.set("csrf", rootData.csrf);
|
|
for (const [name, value] of Object.entries(fields)) {
|
|
formData.set(name, value);
|
|
}
|
|
submit(formData, { method: "post" });
|
|
}
|
|
|
|
const actions: MembersActions = {
|
|
onToggleRole: ({ userId, roleId, add }) => post({ action: "edit", "user-id": userId, "role-id": roleId, add: String(add) }),
|
|
onDeactivate: ({ userId }) => post({ action: "deactivate", "user-id": userId }),
|
|
onReactivate: ({ userId }) => post({ action: "reactivate", "user-id": userId }),
|
|
onDeleteInvitation: ({ invitationId }) => post({ action: "delete-invitation", "invitation-id": invitationId }),
|
|
onInvite: () => navigate(UrlUtils.currentTenantUrl(params, "settings/members/new")),
|
|
};
|
|
|
|
return (
|
|
<EditPageLayout>
|
|
<MembersPage
|
|
vm={data.vm}
|
|
actions={actions}
|
|
rolesTabHref={data.canViewRoles ? UrlUtils.currentTenantUrl(params, "settings/roles-and-permissions/roles") : null}
|
|
editRouteFor={(tenantUserId) => UrlUtils.currentTenantUrl(params, `settings/members/edit/${tenantUserId}`)}
|
|
submitting={submitting}
|
|
lastAdminBlocked={lastAdminBlocked}
|
|
/>
|
|
|
|
{/* Child routes (M01 invite, member edit, group forms) render in a real Dialog (S 560). */}
|
|
<Dialog
|
|
open={!!outlet}
|
|
onOpenChange={(open: boolean) => {
|
|
if (!open) navigate(".", { replace: true });
|
|
}}
|
|
>
|
|
<Dialog.Content className="w-[560px] max-w-[90vw] p-6" aria-label={t("settings.members.form.newTitle")}>
|
|
<div className="w-full">{outlet}</div>
|
|
</Dialog.Content>
|
|
</Dialog>
|
|
</EditPageLayout>
|
|
);
|
|
}
|