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): 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>, session: Awaited>): 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 = ({ data }) => [{ title: data?.title }]; export default function ProfileRoute() { const adminData = useAdminData(); const loaderData = useLoaderData(); const actionData = useActionData(); useEffect(() => { if (actionData?.success) { toast.success(actionData.success); } else if (actionData?.error) { toast.error(actionData.error); } }, [actionData]); return ( ); }