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

339 lines
15 KiB
TypeScript

import { useEffect } from "react";
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useActionData, useLoaderData } from "react-router";
import { hashPassword, verifyPassword } from "~/utils/auth/passwordHasher.server";
import { validatePassword as validatePolicyPassword } from "~/services/auth/password-policy.server";
import toast from "react-hot-toast";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { getTranslations } from "~/locale/i18next.server";
import UserProfileSettings from "~/modules/users/components/UserProfileSettings";
import EventsService from "~/modules/events/services/.server/EventsService";
import { UserProfileUpdatedDto } from "~/modules/events/dtos/UserProfileUpdatedDto";
import { UserPasswordUpdatedDto } from "~/modules/events/dtos/UserPasswordUpdatedDto";
import { AccountDeletedDto } from "~/modules/events/dtos/AccountDeletedDto";
import { UserProfileDeletedDto } from "~/modules/events/dtos/UserProfileDeletedDto";
import { generateRecoveryCodes } from "~/utils/auth/mfa/recovery-codes.server";
import { checkMfaStepUpState, clearMfaStepUpState } from "~/utils/auth/mfa/step-up.server";
import { startTotpEnrollment, verifyTotpCode } from "~/services/auth/totp.server";
import { db } from "~/utils/db.server";
import {
activateUserTotpPendingSecret,
disableUserTotp,
getUserTotpPendingEnrollment,
getUserTotpStatus,
setUserMfaRecoveryCodes,
setUserTotpPendingSecret,
updateUserPassword,
updateUserProfile,
type UserTotpStatus,
} from "~/utils/db/users.db.server";
import { useAdminData } from "~/utils/data/useAdminData";
import { storeFile } from "~/utils/integrations/storageService";
import { auditRejectedUpload } from "~/utils/integrations/storageAudit.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { deleteUserWithItsTenants } from "~/utils/services/userService";
import { commitSession, getUserInfo, getUserSession, storage, validateCSRFToken } from "~/utils/session.server";
import type { CurrentSessionSettings } from "~/routes/app.$tenant/settings/profile";
type LoaderData = {
title: string;
mfaStatus: UserTotpStatus | null;
currentSession: CurrentSessionSettings;
};
type ActionData = {
success?: string;
error?: string;
mfaError?: string;
mfaStatus?: UserTotpStatus | null;
otpauthUri?: string;
recoveryCodes?: string[];
currentSession?: CurrentSessionSettings;
};
type CurrentSessionMfaStepUp = CurrentSessionSettings["mfaStepUp"];
function getCurrentSessionMfaStepUp(stepUp: ReturnType<typeof checkMfaStepUpState>): CurrentSessionMfaStepUp {
if (stepUp.verified) {
return { present: true, verified: true, stale: false, method: stepUp.state.method };
}
if (stepUp.reason === "missing") {
return { present: false, verified: false, stale: false, reason: "missing" };
}
return { present: true, verified: false, stale: stepUp.reason === "stale", reason: stepUp.reason };
}
function getCurrentSessionSettings(userInfo: Awaited<ReturnType<typeof getUserInfo>>, session: Awaited<ReturnType<typeof getUserSession>>): CurrentSessionSettings {
const stepUp = checkMfaStepUpState(session, userInfo.userId);
const cookies = Array.isArray(userInfo.cookies) ? userInfo.cookies : [];
return {
locale: userInfo.lng,
lightOrDarkMode: userInfo.lightOrDarkMode === "dark" ? "dark" : "light",
theme: typeof userInfo.theme === "string" && userInfo.theme.length > 0 ? userInfo.theme : null,
cookieConsentCount: cookies.filter((cookie) => cookie?.allowed).length,
impersonationActive: Boolean(userInfo.impersonatingFromUserId),
mfaStepUp: getCurrentSessionMfaStepUp(stepUp),
};
}
function mfaJson(
body: { mfaStatus: UserTotpStatus | null; mfaError?: string; otpauthUri?: string; recoveryCodes?: string[]; success?: string },
init?: ResponseInit
) {
return Response.json(body, init);
}
function isSixDigitTotpCode(code: FormDataEntryValue | null): code is string {
return typeof code === "string" && /^\d{6}$/.test(code);
}
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const userInfo = await getUserInfo(request);
const session = await getUserSession(request);
const data: LoaderData = {
title: `${t("settings.profile.profileTitle")} | ${process.env.APP_NAME}`,
mfaStatus: await getUserTotpStatus(userInfo.userId),
currentSession: getCurrentSessionSettings(userInfo, session),
};
return data;
};
export const action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const userInfo = await getUserInfo(request);
const form = await request.formData();
const action = form.get("action");
if (typeof action !== "string") {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
const user = await db.user.findUnique({
where: { id: userInfo.userId },
include: { admin: true },
});
if (!user) {
return Response.json({ error: t("settings.profile.errors.userNotFound") }, { status: 400 });
}
const passwordCurrent = form.get("passwordCurrent")?.toString();
switch (action) {
case "startTotpEnrollment": {
const mfaStatus = await getUserTotpStatus(user.id);
if (typeof passwordCurrent !== "string") {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.errors.currentPasswordRequired") }, { status: 400 });
}
const isCorrectPassword = (await verifyPassword(passwordCurrent, user.passwordHash)).valid;
if (!isCorrectPassword) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.errors.invalidPassword") }, { status: 400 });
}
const enrollment = startTotpEnrollment(user.email);
await setUserTotpPendingSecret(user.id, enrollment.encryptedSecret);
const updatedMfaStatus = await getUserTotpStatus(user.id);
await EventsService.create({
request,
event: "user.mfa.totp.enrollment.started",
tenantId: null,
userId: user.id,
data: { user: { id: user.id, email: user.email }, mfaStatus: updatedMfaStatus },
});
return mfaJson({ success: t("settings.profile.mfa.enrollmentStarted"), mfaStatus: updatedMfaStatus, otpauthUri: enrollment.otpauthUri });
}
case "confirmTotpEnrollment": {
const mfaStatus = await getUserTotpStatus(user.id);
const code = form.get("code");
if (!isSixDigitTotpCode(code)) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.mfa.enterCode") }, { status: 400 });
}
const pending = await getUserTotpPendingEnrollment(user.id);
if (!pending?.totpPendingSecretEncrypted || !pending.totpPendingCreatedAt) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.mfa.noPendingEnrollment") }, { status: 400 });
}
if (!verifyTotpCode(pending.totpPendingSecretEncrypted, code)) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.mfa.invalidCode") }, { status: 400 });
}
await activateUserTotpPendingSecret(user.id, pending.totpPendingSecretEncrypted);
const recoveryCodeGeneration = generateRecoveryCodes();
await setUserMfaRecoveryCodes(user.id, recoveryCodeGeneration.entries, recoveryCodeGeneration.generatedAt);
const updatedMfaStatus = await getUserTotpStatus(user.id);
await EventsService.create({
request,
event: "user.mfa.totp.enabled",
tenantId: null,
userId: user.id,
data: {
user: { id: user.id, email: user.email },
mfaStatus: updatedMfaStatus,
recoveryCodes: {
generatedCount: recoveryCodeGeneration.codes.length,
remainingCount: recoveryCodeGeneration.entries.filter((entry) => !entry.usedAt).length,
generatedAt: recoveryCodeGeneration.generatedAt,
},
},
});
return mfaJson({ success: t("settings.profile.mfa.enabled"), mfaStatus: updatedMfaStatus, recoveryCodes: recoveryCodeGeneration.codes });
}
case "disableTotpEnrollment": {
const mfaStatus = await getUserTotpStatus(user.id);
if (typeof passwordCurrent !== "string") {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.errors.currentPasswordRequired") }, { status: 400 });
}
const isCorrectPassword = (await verifyPassword(passwordCurrent, user.passwordHash)).valid;
if (!isCorrectPassword) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.errors.invalidPassword") }, { status: 400 });
}
await disableUserTotp(user.id);
const updatedMfaStatus = await getUserTotpStatus(user.id);
await EventsService.create({
request,
event: "user.mfa.totp.disabled",
tenantId: null,
userId: user.id,
data: { user: { id: user.id, email: user.email }, mfaStatus: updatedMfaStatus },
});
return mfaJson({ success: t("settings.profile.mfa.disabled"), mfaStatus: updatedMfaStatus });
}
case "clearMfaStepUp": {
const session = await getUserSession(request);
clearMfaStepUpState(session);
return Response.json(
{ success: t("settings.profile.mfa.sessionCleared"), currentSession: getCurrentSessionSettings(userInfo, session) },
{ headers: { "Set-Cookie": await commitSession(session) } }
);
}
case "profile": {
const firstName = form.get("firstName")?.toString();
const lastName = form.get("lastName")?.toString() ?? "";
const avatar = form.get("avatar")?.toString() ?? "";
if (typeof firstName !== "string" || firstName.length < 2) {
return Response.json({ error: t("settings.profile.errors.firstNameRequired") }, { status: 400 });
}
const avatarStored = avatar ? await storeFile({ bucket: "users-icons", content: avatar, id: userInfo.userId, scan: { context: "avatar", enqueuePostScan: true, onReject: auditRejectedUpload(request, "admin.profile.avatar"), filename: `${userInfo.userId}.avatar` } }) : avatar;
const profile = await updateUserProfile({ firstName, lastName, avatar: avatarStored }, userInfo.userId);
if (!profile) {
return Response.json({ error: t("settings.profile.errors.profileUpdateFailed") }, { status: 400 });
}
await EventsService.create({
request,
event: "user.profile.updated",
tenantId: null,
userId: user.id,
data: {
email: user.email,
new: { firstName, lastName },
old: { firstName: user.firstName, lastName: user.lastName },
userId: userInfo.userId,
} satisfies UserProfileUpdatedDto,
});
return Response.json({ success: t("shared.updated") });
}
case "password": {
const passwordNew = form.get("passwordNew")?.toString();
const passwordNewConfirm = form.get("passwordNewConfirm")?.toString();
if (typeof passwordCurrent !== "string" || typeof passwordNew !== "string" || typeof passwordNewConfirm !== "string") {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
if (passwordNew !== passwordNewConfirm) {
return Response.json({ error: t("account.shared.passwordMismatch") }, { status: 400 });
}
const policyResult = await validatePolicyPassword(passwordNew, { email: user.email });
if (!policyResult.valid) {
const first = policyResult.errors[0];
return Response.json({ error: first ? t(first.code, first.args ?? {}) : t("settings.profile.errors.passwordMinLength") }, { status: 400 });
}
const isCorrectPassword = (await verifyPassword(passwordCurrent, user.passwordHash)).valid;
if (!isCorrectPassword) {
return Response.json({ error: t("settings.profile.errors.invalidPassword") }, { status: 400 });
}
const passwordHash = await hashPassword(passwordNew);
await updateUserPassword({ passwordHash }, userInfo.userId);
await EventsService.create({
request,
event: "user.password.updated",
tenantId: null,
userId: user.id,
data: { user: { id: user.id, email: user.email } } satisfies UserPasswordUpdatedDto,
});
return Response.json({ success: t("settings.profile.passwordUpdated") });
}
case "deleteAccount": {
if (user.admin !== null) {
return Response.json({ error: t("settings.profile.errors.cannotDeleteAdmin") }, { status: 400 });
}
if (typeof passwordCurrent !== "string" || passwordCurrent.length === 0) {
return Response.json({ error: t("settings.profile.errors.currentPasswordRequired") }, { status: 400 });
}
const isCorrectPassword = (await verifyPassword(passwordCurrent, user.passwordHash)).valid;
if (!isCorrectPassword) {
return Response.json({ error: t("settings.profile.errors.invalidPassword") }, { status: 400 });
}
const { deletedTenants } = await deleteUserWithItsTenants(user.id);
const deletedAccounts = await Promise.all(
deletedTenants.map(async (tenant) => {
const data = {
tenant: { id: tenant.id, name: tenant.name },
user: { id: user.id, email: user.email },
} satisfies AccountDeletedDto;
await EventsService.create({ request, event: "account.deleted", tenantId: null, userId: null, data });
return data;
})
);
await EventsService.create({
request,
event: "user.profile.deleted",
tenantId: null,
userId: null,
data: {
id: user.id,
email: user.email,
firstName: user.firstName,
lastName: user.lastName,
deletedAccounts,
} satisfies UserProfileDeletedDto,
});
const session = await getUserSession(request);
return redirect("/login", { headers: { "Set-Cookie": await storage.destroySession(session) } });
}
}
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function ProfileRoute() {
const adminData = useAdminData();
const loaderData = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
useEffect(() => {
if (actionData?.success) {
toast.success(actionData.success);
} else if (actionData?.error) {
toast.error(actionData.error);
}
}, [actionData]);
return (
<EditPageLayout className="pb-20">
<UserProfileSettings
user={{
...adminData.user,
firstName: adminData.user.firstName ?? "",
lastName: adminData.user.lastName ?? "",
}}
mfaStatus={actionData?.mfaStatus ?? loaderData.mfaStatus}
otpauthUri={actionData?.otpauthUri}
mfaError={actionData?.mfaError}
recoveryCodes={actionData?.recoveryCodes}
currentSession={actionData?.currentSession ?? loaderData.currentSession}
/>
</EditPageLayout>
);
}