Adds user management

This commit is contained in:
2026-06-22 21:14:22 +02:00
parent 5331be4279
commit 6976eb4337
40 changed files with 3392 additions and 146 deletions
+2 -2
View File
@@ -37,11 +37,11 @@ export function InviteCompletePage() {
}
} else if (validationQuery.isPending && loadingState !== 'submitting') {
// Still loading
} else if (validationQuery.error || (validationQuery.data && !validationQuery.data.valid)) {
} else if (validationQuery.error || (validationQuery.data && !validationQuery.data.isValid)) {
if (loadingState === 'loading') {
setLoadingState('error');
}
} else if (validationQuery.data?.valid && loadingState === 'loading') {
} else if (validationQuery.data?.isValid && loadingState === 'loading') {
setLoadingState('ready');
}
+1
View File
@@ -89,6 +89,7 @@ export function LoginPage() {
<Input
id="password"
type="password"
placeholder="••••••••"
autoComplete="current-password"
data-testid="login-password-input"
aria-invalid={errors.password !== undefined}
+78
View File
@@ -0,0 +1,78 @@
import { beforeEach, describe, expect, it } from 'vitest';
import { screen, within } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { http, HttpResponse } from 'msw';
import { renderApp, mockAuthenticated } from '@/test/utils';
import { server } from '@/mocks/server';
import { API_BASE } from '@/mocks/auth/fixtures';
import { getMockUsers } from '@/mocks/users/handlers';
import { _resetSetupStatusCache } from '@/router';
beforeEach(() => {
_resetSetupStatusCache();
});
const USERS_URL = `${API_BASE}/api/v1/Users`;
describe('UsersPage', () => {
it('renders the page title and invite button', async () => {
mockAuthenticated();
renderApp('/users');
expect(await screen.findByTestId('users-page', {}, { timeout: 5000 })).toBeInTheDocument();
expect(screen.getByTestId('users-invite-button')).toBeInTheDocument();
});
it('renders the users table with all mock users', async () => {
mockAuthenticated();
renderApp('/users');
const table = await screen.findByTestId('users-table');
expect(table).toBeInTheDocument();
for (const user of getMockUsers()) {
expect(screen.getByTestId(`user-row-${user.id}`)).toBeInTheDocument();
}
});
it('shows "Pending invite" badge for invitation-pending users', async () => {
mockAuthenticated();
renderApp('/users');
await screen.findByTestId('users-table');
const pendingUser = getMockUsers().find((u) => u.invitationPending)!;
const row = screen.getByTestId(`user-row-${pendingUser.id}`);
expect(within(row).getByText('Pending invite')).toBeInTheDocument();
});
it('shows copy invite link action for pending user', async () => {
mockAuthenticated();
renderApp('/users');
await screen.findByTestId('users-table');
const pendingUser = getMockUsers().find((u) => u.invitationPending)!;
const actionsBtn = screen.getByTestId(`user-actions-${pendingUser.id}`);
await userEvent.click(actionsBtn);
expect(screen.getByTestId(`user-copy-link-${pendingUser.id}`)).toBeInTheDocument();
});
it('shows an error message when the API fails', async () => {
mockAuthenticated();
server.use(http.get(USERS_URL, () => HttpResponse.json({}, { status: 500 })));
renderApp('/users');
await screen.findByTestId('users-page');
expect(await screen.findByText(/something went wrong/i)).toBeInTheDocument();
});
it('opens the invite dialog when the invite button is clicked', async () => {
mockAuthenticated();
renderApp('/users');
await screen.findByTestId('users-invite-button');
await userEvent.click(screen.getByTestId('users-invite-button'));
expect(screen.getByTestId('invite-dialog-email')).toBeInTheDocument();
});
});
+439 -6
View File
@@ -1,14 +1,447 @@
import { useState } from 'react';
import { toast } from 'sonner';
import { useTranslation } from 'react-i18next';
import { MoreHorizontal, Link as LinkIcon, Trash2, UserX, UserCheck } from 'lucide-react';
import { Button } from '@/components/ui/button';
import {
Dialog,
DialogContent,
DialogDescription,
DialogFooter,
DialogHeader,
DialogTitle,
} from '@/components/ui/dialog';
import { Badge } from '@/components/ui/badge';
import {
Table,
TableBody,
TableCell,
TableHead,
TableHeader,
TableRow,
} from '@/components/ui/table';
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuLabel,
DropdownMenuSeparator,
DropdownMenuSub,
DropdownMenuSubContent,
DropdownMenuSubTrigger,
DropdownMenuTrigger,
} from '@/components/ui/dropdown-menu';
import { InviteUserDialog } from '@/components/users/InviteUserDialog';
import { DeleteUserDialog } from '@/components/users/DeleteUserDialog';
import { useUsers, useChangeRole, useSetUserActive, useDeleteUser } from '@/api/useUsers';
import { useAuth } from '@/contexts/auth-context';
import { Trans } from 'react-i18next';
import { ProblemDetailsError } from '@/lib/api-client';
import type { UserRole, UserListItem } from '@/api/types';
function roleBadgeVariant(role: UserRole) {
if (role === 'Owner') return 'default';
if (role === 'Administrator') return 'secondary';
return 'outline';
}
function statusBadgeVariant(user: UserListItem) {
if (user.invitationPending) return 'outline';
if (!user.isActive) return 'destructive';
return 'secondary';
}
function statusLabel(user: UserListItem, t: (key: string) => string) {
if (user.invitationPending) return t('users.status.pendingInvite');
if (!user.isActive) return t('users.status.inactive');
return t('users.status.active');
}
function formatDate(iso: string) {
return new Date(iso).toLocaleDateString(undefined, { dateStyle: 'medium' });
}
/** Placeholder; full user management arrives in Unit 5. */
export function UsersPage() {
const { t } = useTranslation();
const { user: currentUser, logout } = useAuth();
const [inviteDialogOpen, setInviteDialogOpen] = useState(false);
const [deleteTarget, setDeleteTarget] = useState<UserListItem | null>(null);
const [selfRoleChangeTarget, setSelfRoleChangeTarget] = useState<{
userId: string;
newRole: UserRole;
} | null>(null);
const [ownerAssignTarget, setOwnerAssignTarget] = useState<{
userId: string;
userName: string;
} | null>(null);
const { data: users, isPending, isError } = useUsers();
const changeRole = useChangeRole();
const setUserActive = useSetUserActive();
const deleteUser = useDeleteUser();
const availableRolesFor = (user: UserListItem): UserRole[] => {
const isSelf = user.id === currentUser?.id;
if (currentUser?.role === 'Owner') return ['Owner', 'Administrator', 'User'];
if (currentUser?.role === 'Administrator') {
// Admins can demote themselves to User; they cannot touch other Admins or Owners
if (isSelf) return ['Administrator', 'User'];
if (user.role === 'User') return ['Administrator'];
}
return [];
};
const isOwnerAction = (user: UserListItem) =>
currentUser?.role === 'Owner' && user.id !== currentUser.id;
const canToggleActive = (user: UserListItem) =>
isOwnerAction(user) && !user.invitationPending;
const canDelete = (user: UserListItem) => isOwnerAction(user);
const hasAnyActions = (user: UserListItem) =>
user.invitationPending ||
availableRolesFor(user).length > 0 ||
canToggleActive(user) ||
canDelete(user);
const handleCopyInviteLink = async (user: UserListItem) => {
if (!user.inviteLink) return;
await navigator.clipboard.writeText(`${window.location.origin}${user.inviteLink}`);
toast.success(t('users.actions.linkCopied'));
};
const handleRoleChange = (user: UserListItem, newRole: UserRole) => {
if (user.id === currentUser?.id) {
setSelfRoleChangeTarget({ userId: user.id, newRole });
return;
}
if (newRole === 'Owner') {
setOwnerAssignTarget({ userId: user.id, userName: user.name });
return;
}
void executeRoleChange(user.id, newRole);
};
const executeRoleChange = async (userId: string, newRole: UserRole) => {
try {
await changeRole.mutateAsync({ userId, newRole });
} catch (err) {
if (err instanceof ProblemDetailsError) {
if (err.status === 400) {
toast.error(t('users.errors.lastOwnerRequired'));
} else if (err.status === 403) {
toast.error(t('users.errors.insufficientPermissions'));
} else {
toast.error(t('errors.generic'));
}
} else {
toast.error(t('errors.generic'));
}
}
};
const handleSelfRoleChangeConfirm = async () => {
if (!selfRoleChangeTarget) return;
try {
await changeRole.mutateAsync(selfRoleChangeTarget);
setSelfRoleChangeTarget(null);
await logout();
} catch (err) {
setSelfRoleChangeTarget(null);
if (err instanceof ProblemDetailsError && err.status === 400) {
toast.error(t('users.errors.lastOwnerRequired'));
} else {
toast.error(t('errors.generic'));
}
}
};
const handleOwnerAssignConfirm = async () => {
if (!ownerAssignTarget) return;
try {
await changeRole.mutateAsync({ userId: ownerAssignTarget.userId, newRole: 'Owner' });
setOwnerAssignTarget(null);
} catch (err) {
setOwnerAssignTarget(null);
if (err instanceof ProblemDetailsError && err.status === 400) {
toast.error(t('users.errors.lastOwnerRequired'));
} else if (err instanceof ProblemDetailsError && err.status === 403) {
toast.error(t('users.errors.insufficientPermissions'));
} else {
toast.error(t('errors.generic'));
}
}
};
const handleSetActive = async (user: UserListItem, isActive: boolean) => {
try {
await setUserActive.mutateAsync({ userId: user.id, isActive });
toast.success(
isActive
? t('users.active.successActivated', { name: user.name })
: t('users.active.successDeactivated', { name: user.name }),
);
} catch (err) {
if (err instanceof ProblemDetailsError && err.status === 400) {
toast.error(t('users.errors.lastOwnerRequired'));
} else {
toast.error(t('errors.generic'));
}
}
};
const handleDeleteConfirm = async () => {
if (!deleteTarget) return;
try {
await deleteUser.mutateAsync(deleteTarget.id);
toast.success(t('users.delete.success', { name: deleteTarget.name }));
setDeleteTarget(null);
} catch (err) {
if (err instanceof ProblemDetailsError && err.status === 400) {
toast.error(t('users.errors.lastOwnerRequired'));
setDeleteTarget(null);
} else {
toast.error(t('errors.generic'));
}
}
};
return (
<div className="space-y-2">
<h1 className="text-2xl font-semibold" data-testid="users-title">
{t('nav.users')}
</h1>
<p className="text-muted-foreground">Coming soon.</p>
<div className="space-y-4" data-testid="users-page">
<div className="flex items-center justify-between">
<h1 className="text-2xl font-semibold" data-testid="users-title">
{t('users.title')}
</h1>
<Button onClick={() => setInviteDialogOpen(true)} data-testid="users-invite-button">
{t('users.inviteButton')}
</Button>
</div>
{isPending && (
<p className="text-sm text-muted-foreground">{t('common.loading')}</p>
)}
{isError && (
<p className="text-sm text-destructive">{t('errors.generic')}</p>
)}
{users && (
<Table data-testid="users-table">
<TableHeader>
<TableRow>
<TableHead>{t('users.table.name')}</TableHead>
<TableHead>{t('users.table.email')}</TableHead>
<TableHead>{t('users.table.role')}</TableHead>
<TableHead>{t('users.table.status')}</TableHead>
<TableHead>{t('users.table.createdAt')}</TableHead>
<TableHead className="w-12" />
</TableRow>
</TableHeader>
<TableBody>
{users.map((user) => {
const roles = availableRolesFor(user);
const toggleActive = canToggleActive(user);
const deletable = canDelete(user);
const showActions = hasAnyActions(user);
return (
<TableRow key={user.id} data-testid={`user-row-${user.id}`}>
<TableCell className="font-medium">{user.name}</TableCell>
<TableCell>{user.email}</TableCell>
<TableCell>
<Badge variant={roleBadgeVariant(user.role)}>
{t(`users.roles.${user.role}`)}
</Badge>
</TableCell>
<TableCell>
<Badge variant={statusBadgeVariant(user)}>
{statusLabel(user, t)}
</Badge>
</TableCell>
<TableCell>{formatDate(user.createdAt)}</TableCell>
<TableCell>
{showActions && <DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
variant="ghost"
size="icon"
aria-label={t('users.table.actions')}
data-testid={`user-actions-${user.id}`}
>
<MoreHorizontal className="h-4 w-4" />
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent align="end">
<DropdownMenuLabel>
{t('users.table.actions')}
</DropdownMenuLabel>
{user.invitationPending && (
<>
<DropdownMenuSeparator />
<DropdownMenuItem
onClick={() => handleCopyInviteLink(user)}
data-testid={`user-copy-link-${user.id}`}
>
<LinkIcon className="mr-2 h-4 w-4" />
{t('users.actions.copyInviteLink')}
</DropdownMenuItem>
</>
)}
{roles.length > 0 && (
<>
<DropdownMenuSeparator />
<DropdownMenuSub>
<DropdownMenuSubTrigger
data-testid={`user-change-role-${user.id}`}
>
{t('users.actions.changeRole')}
</DropdownMenuSubTrigger>
<DropdownMenuSubContent>
{roles.map((role) => (
<DropdownMenuItem
key={role}
disabled={role === user.role}
onClick={() =>
handleRoleChange(user, role)
}
>
{t(`users.roles.${role}`)}
</DropdownMenuItem>
))}
</DropdownMenuSubContent>
</DropdownMenuSub>
</>
)}
{toggleActive && (
<>
<DropdownMenuSeparator />
<DropdownMenuItem
onClick={() =>
handleSetActive(user, !user.isActive)
}
data-testid={`user-toggle-active-${user.id}`}
>
{user.isActive ? (
<>
<UserX className="mr-2 h-4 w-4" />
{t('users.actions.deactivate')}
</>
) : (
<>
<UserCheck className="mr-2 h-4 w-4" />
{t('users.actions.activate')}
</>
)}
</DropdownMenuItem>
</>
)}
{deletable && (
<>
<DropdownMenuSeparator />
<DropdownMenuItem
className="text-destructive focus:text-destructive"
onClick={() => setDeleteTarget(user)}
data-testid={`user-delete-${user.id}`}
>
<Trash2 className="mr-2 h-4 w-4" />
{t('users.actions.delete')}
</DropdownMenuItem>
</>
)}
</DropdownMenuContent>
</DropdownMenu>}
</TableCell>
</TableRow>
);
})}
</TableBody>
</Table>
)}
<InviteUserDialog open={inviteDialogOpen} onOpenChange={setInviteDialogOpen} />
<Dialog
open={selfRoleChangeTarget !== null}
onOpenChange={(open) => { if (!open) setSelfRoleChangeTarget(null); }}
>
<DialogContent>
<DialogHeader>
<DialogTitle>{t('users.selfRoleChange.title')}</DialogTitle>
<DialogDescription asChild>
<div>
<Trans
i18nKey="users.selfRoleChange.description"
values={{
role: selfRoleChangeTarget
? t(`users.roles.${selfRoleChangeTarget.newRole}`)
: '',
}}
components={{ strong: <strong /> }}
/>
</div>
</DialogDescription>
</DialogHeader>
<DialogFooter>
<Button
variant="outline"
onClick={() => setSelfRoleChangeTarget(null)}
>
{t('common.cancel')}
</Button>
<Button
onClick={handleSelfRoleChangeConfirm}
disabled={changeRole.isPending}
>
{t('users.selfRoleChange.confirmButton')}
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<Dialog
open={ownerAssignTarget !== null}
onOpenChange={(open) => { if (!open) setOwnerAssignTarget(null); }}
>
<DialogContent>
<DialogHeader>
<DialogTitle>{t('users.ownerAssign.title')}</DialogTitle>
<DialogDescription asChild>
<div>
<Trans
i18nKey="users.ownerAssign.description"
values={{ name: ownerAssignTarget?.userName ?? '' }}
components={{ strong: <strong /> }}
/>
</div>
</DialogDescription>
</DialogHeader>
<DialogFooter>
<Button
variant="outline"
onClick={() => setOwnerAssignTarget(null)}
>
{t('common.cancel')}
</Button>
<Button
onClick={handleOwnerAssignConfirm}
disabled={changeRole.isPending}
>
{t('users.ownerAssign.confirmButton')}
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<DeleteUserDialog
user={deleteTarget}
open={deleteTarget !== null}
onOpenChange={(open) => { if (!open) setDeleteTarget(null); }}
onConfirm={handleDeleteConfirm}
isPending={deleteUser.isPending}
/>
</div>
);
}