339 lines
15 KiB
TypeScript
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 || "system",
|
|
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>
|
|
);
|
|
}
|