(null);
const mfaRequiredByPolicy =
!demoMode && !user?.mfa_enabled && (searchParams.get('mfa') === 'required' || appRequireMfa);
const backupCodesText = backupCodes?.join('\n') || '';
const skipBackupCodes = ignoreEmptyBackupCodes && !backupCodesText;
useEffect(() => {
if (!user?.mfa_enabled || backupCodes) return;
try {
const raw = sessionStorage.getItem(MFA_BACKUP_SESSION_KEY);
if (!raw) return;
const parsed = JSON.parse(raw) as unknown;
if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((x) => typeof x === 'string')) {
setBackupCodes(parsed);
}
} catch {
sessionStorage.removeItem(MFA_BACKUP_SESSION_KEY);
}
}, [user?.mfa_enabled, backupCodes]);
const dismissBackupCodes = () => {
sessionStorage.removeItem(MFA_BACKUP_SESSION_KEY);
setBackupCodes(null);
};
const copyBackupCodes = async () => {
if (skipBackupCodes) return;
try {
await navigator.clipboard.writeText(backupCodesText);
toast.success(t('settings.mfa.backupCopied'));
} catch {
toast.error(t('common.error'));
}
};
const downloadBackupCodes = () => {
if (skipBackupCodes) return;
const blob = new Blob([backupCodesText + '\n'], { type: 'text/plain;charset=utf-8' });
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = 'trek-mfa-backup-codes.txt';
document.body.appendChild(a);
a.click();
a.remove();
URL.revokeObjectURL(url);
};
const printBackupCodes = () => {
if (skipBackupCodes) return;
const html = `TREK MFA Backup Codes
TREK MFA Backup Codes
${escapeHtml(formatDisplayDateTime(new Date(), undefined, {}, dateFormat))}
${escapeHtml(backupCodesText)}`;
const w = window.open('', '_blank', 'width=900,height=700');
if (!w) return;
w.document.open();
w.document.write(html);
w.document.close();
w.focus();
w.print();
};
const handleAvatarUpload = async (e: React.ChangeEvent) => {
const file = e.target.files?.[0];
if (!file) return;
try {
await uploadAvatar(file);
toast.success(t('settings.avatarUploaded'));
} catch {
toast.error(t('settings.avatarError'));
}
if (avatarInputRef.current) avatarInputRef.current.value = '';
};
const handleAvatarRemove = async () => {
try {
await deleteAvatar();
toast.success(t('settings.avatarRemoved'));
} catch {
toast.error(t(avatarRemoveErrorKey));
}
};
const saveProfile = async () => {
setSaving(true);
try {
await updateProfile({ username, email });
toast.success(t('settings.toast.profileSaved'));
} catch (err: unknown) {
toast.error(err instanceof Error ? err.message : t('common.error'));
} finally {
setSaving(false);
}
};
const changePassword = async () => {
if (!currentPassword) return toast.error(t('settings.currentPasswordRequired'));
if (!newPassword) return toast.error(t('settings.passwordRequired'));
const weak = passwordErrorKey(newPassword);
if (weak) return toast.error(t(weak));
if (newPassword !== confirmPassword) return toast.error(t('settings.passwordMismatch'));
try {
await authApi.changePassword({ current_password: currentPassword, new_password: newPassword });
toast.success(t('settings.passwordChanged'));
setCurrentPassword('');
setNewPassword('');
setConfirmPassword('');
await loadUser({ silent: true });
} catch (err: unknown) {
toast.error(getApiErrorMessage(err, t('common.error')));
}
};
const startMfaSetup = async () => {
setMfaLoading(true);
try {
const data = (await authApi.mfaSetup()) as { qr_svg: string; secret: string };
setMfaQr(data.qr_svg);
setMfaSecret(data.secret);
setMfaSetupCode('');
} catch (err: unknown) {
toast.error(getApiErrorMessage(err, t('common.error')));
} finally {
setMfaLoading(false);
}
};
const cancelMfaSetup = () => {
setMfaQr(null);
setMfaSecret(null);
setMfaSetupCode('');
};
const enableMfa = async () => {
setMfaLoading(true);
try {
const resp = (await authApi.mfaEnable({ code: mfaSetupCode })) as { backup_codes?: string[] };
toast.success(t('settings.mfa.toastEnabled'));
setMfaQr(null);
setMfaSecret(null);
setMfaSetupCode('');
const codes = resp.backup_codes || null;
if (codes?.length) {
try {
sessionStorage.setItem(MFA_BACKUP_SESSION_KEY, JSON.stringify(codes));
} catch {
/* ignore */
}
}
setBackupCodes(codes);
await loadUser({ silent: true });
} catch (err: unknown) {
toast.error(getApiErrorMessage(err, t('common.error')));
} finally {
setMfaLoading(false);
}
};
const disableMfa = async () => {
setMfaLoading(true);
try {
await authApi.mfaDisable({ password: mfaDisablePwd, code: mfaDisableCode });
toast.success(t('settings.mfa.toastDisabled'));
setMfaDisablePwd('');
setMfaDisableCode('');
sessionStorage.removeItem(MFA_BACKUP_SESSION_KEY);
setBackupCodes(null);
await loadUser({ silent: true });
} catch (err: unknown) {
toast.error(getApiErrorMessage(err, t('common.error')));
} finally {
setMfaLoading(false);
}
};
const requestDelete = async () => {
if (user?.role === 'admin') {
try {
await adminApi.stats();
const adminUsers = (await adminApi.users()).users.filter((u: { role: string }) => u.role === 'admin');
if (adminUsers.length <= 1) {
setShowDeleteConfirm('blocked');
return;
}
} catch {
/* fall through to the normal confirm */
}
}
setShowDeleteConfirm(true);
};
const deleteAccount = async () => {
try {
await authApi.deleteOwnAccount();
logout();
navigate('/login', { state: { noRedirect: true } });
} catch (err: unknown) {
toast.error(getApiErrorMessage(err, t('common.error')));
setShowDeleteConfirm(false);
}
};
const oidcIssuer = (user as UserWithOidc)?.oidc_issuer;
return {
user,
demoMode,
avatarInputRef,
saving,
showDeleteConfirm,
setShowDeleteConfirm,
username,
setUsername,
email,
setEmail,
currentPassword,
setCurrentPassword,
newPassword,
setNewPassword,
confirmPassword,
setConfirmPassword,
oidcOnlyMode,
mfaQr,
mfaSecret,
mfaSetupCode,
setMfaSetupCode,
mfaDisablePwd,
setMfaDisablePwd,
mfaDisableCode,
setMfaDisableCode,
mfaLoading,
backupCodes,
backupCodesText,
mfaRequiredByPolicy,
oidcIssuer,
dismissBackupCodes,
copyBackupCodes,
downloadBackupCodes,
printBackupCodes,
handleAvatarUpload,
handleAvatarRemove,
saveProfile,
changePassword,
startMfaSetup,
cancelMfaSetup,
enableMfa,
disableMfa,
requestDelete,
deleteAccount,
};
}