Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/app.$tenant/settings/profile.tsx
T

434 lines
17 KiB
TypeScript

import { useEffect } from "react";
import { useAppData } from "~/utils/data/useAppData";
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useLoaderData } from "react-router";
import { useActionData } from "react-router";
import {
activateUserTotpPendingSecret,
disableUserTotp,
getUserTotpPendingEnrollment,
getUserTotpStatus,
setUserMfaRecoveryCodes,
setUserTotpPendingSecret,
updateUserPassword,
updateUserProfile,
type UserTotpStatus,
} from "~/utils/db/users.db.server";
import { commitSession, getUserInfo, getUserSession, storage, validateCSRFToken } from "~/utils/session.server";
import { db } from "~/utils/db.server";
import { hashPassword, verifyPassword } from "~/utils/auth/passwordHasher.server";
import { validatePassword as validatePolicyPassword } from "~/services/auth/password-policy.server";
import { getTranslations } from "~/locale/i18next.server";
import { deleteUserWithItsTenants } from "~/utils/services/userService";
import { storeFile } from "~/utils/integrations/storageService";
import { auditRejectedUpload } from "~/utils/integrations/storageAudit.server";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import EventsService from "~/modules/events/services/.server/EventsService";
import { UserProfileUpdatedDto } from "~/modules/events/dtos/UserProfileUpdatedDto";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getTenant } from "~/utils/db/tenants.db.server";
import { UserPasswordUpdatedDto } from "~/modules/events/dtos/UserPasswordUpdatedDto";
import { AccountDeletedDto } from "~/modules/events/dtos/AccountDeletedDto";
import { UserProfileDeletedDto } from "~/modules/events/dtos/UserProfileDeletedDto";
import MyProfileScreen from "~/modules/users/components/MyProfileScreen";
import toast from "react-hot-toast";
import { requireAuth } from "~/utils/loaders.middleware";
import { generateRecoveryCodes } from "~/utils/auth/mfa/recovery-codes.server";
import { startTotpEnrollment, verifyTotpCode } from "~/services/auth/totp.server";
import { checkMfaStepUpState, clearMfaStepUpState } from "~/utils/auth/mfa/step-up.server";
type CurrentSessionMfaStepUp =
| { present: false; verified: false; stale: false; reason: "missing" }
| { present: true; verified: true; stale: false; method: string }
| { present: true; verified: false; stale: boolean; reason: "malformed" | "wrong-user" | "stale" };
export type CurrentSessionSettings = {
locale: string;
lightOrDarkMode: string;
theme: string | null;
cookieConsentCount: number;
impersonationActive: boolean;
mfaStepUp: CurrentSessionMfaStepUp;
};
type LoaderData = {
title: string;
mfaStatus: UserTotpStatus | null;
currentSession: CurrentSessionSettings;
};
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),
};
}
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;
};
type ActionData = {
success?: string;
passwordSuccess?: string;
error?: string;
mfaError?: string;
mfaStatus?: UserTotpStatus | null;
otpauthUri?: string;
recoveryCodes?: string[];
currentSession?: CurrentSessionSettings;
};
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 action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
const userInfo = await getUserInfo(request);
const form = await request.formData();
const action = form.get("action");
const firstName = form.get("firstName")?.toString();
const lastName = form.get("lastName")?.toString() ?? "";
const avatar = form.get("avatar")?.toString() ?? "";
const passwordCurrent = form.get("passwordCurrent")?.toString();
const passwordNew = form.get("passwordNew")?.toString();
const passwordNewConfirm = form.get("passwordNewConfirm")?.toString();
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,
},
});
const tenant = await getTenant(tenantId);
if (!user) {
return Response.json({ error: t("settings.profile.errors.userNotFound") }, { status: 400 });
}
if (!tenant) {
return Response.json({ error: t("settings.profile.errors.accountNotFound") }, { status: 400 });
}
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 fields = { action, firstName, lastName, avatar, passwordCurrent, passwordNew, passwordNewConfirm };
const fieldErrors = {
firstName: action === "profile" && (fields.firstName ?? "").length < 2 ? t("settings.profile.errors.firstNameRequired") : "",
};
if (Object.values(fieldErrors).some(Boolean)) {
return Response.json({ error: t("shared.invalidForm"), fields: fieldErrors }, { status: 400 });
}
if (typeof firstName !== "string" || typeof lastName !== "string") {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
let avatarStored = avatar
? await storeFile({
bucket: "users-icons",
content: avatar,
id: userInfo?.userId,
scan: {
context: "avatar",
enqueuePostScan: true,
onReject: auditRejectedUpload(request, "tenant.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": {
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 });
}
if (!user) return null;
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({
passwordSuccess: t("settings.profile.passwordUpdated"),
});
}
case "deleteAccount": {
if (!user) {
return null;
}
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 });
}
try {
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,
});
} catch (error) {
// eslint-disable-next-line no-console
console.error(error);
return Response.json(
{
error: t("shared.unexpectedError"),
},
{ status: 400 }
);
}
const session = await getUserSession(request);
return redirect("/login", {
headers: {
"Set-Cookie": await storage.destroySession(session),
},
});
}
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function ProfileRoute() {
const appData = useAppData();
const loaderData = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
useEffect(() => {
const successMessage = actionData?.success ?? actionData?.passwordSuccess;
if (successMessage) {
toast.success(successMessage);
} else if (actionData?.error) {
toast.error(actionData.error);
}
}, [actionData]);
return (
<EditPageLayout className="pb-20">
<MyProfileScreen
user={appData.user}
mfaStatus={actionData?.mfaStatus ?? loaderData.mfaStatus}
otpauthUri={actionData?.otpauthUri}
recoveryCodes={actionData?.recoveryCodes}
mfaError={actionData?.mfaError}
/>
</EditPageLayout>
);
}