1757 lines
66 KiB
TypeScript
1757 lines
66 KiB
TypeScript
/**
|
|
* Admin user management — advanced data grid with batch operations,
|
|
* enriched columns, filters, sorting, and Excel export.
|
|
*/
|
|
import {
|
|
Alert,
|
|
Box,
|
|
Button,
|
|
Card,
|
|
CardContent,
|
|
Chip,
|
|
Collapse,
|
|
Dialog,
|
|
DialogActions,
|
|
DialogContent,
|
|
DialogTitle,
|
|
FormControl,
|
|
FormControlLabel,
|
|
FormGroup,
|
|
Checkbox,
|
|
Grid,
|
|
IconButton,
|
|
InputLabel,
|
|
Menu,
|
|
MenuItem,
|
|
Paper,
|
|
Select,
|
|
Skeleton,
|
|
Snackbar,
|
|
Stack,
|
|
Switch,
|
|
TextField,
|
|
Tooltip,
|
|
Typography,
|
|
useMediaQuery,
|
|
} from '@mui/material';
|
|
import ContentCopyRoundedIcon from '@mui/icons-material/ContentCopyRounded';
|
|
import ExpandMoreRoundedIcon from '@mui/icons-material/ExpandMoreRounded';
|
|
import ExpandLessRoundedIcon from '@mui/icons-material/ExpandLessRounded';
|
|
import ClearRoundedIcon from '@mui/icons-material/ClearRounded';
|
|
import DownloadRoundedIcon from '@mui/icons-material/DownloadRounded';
|
|
import FilterListRoundedIcon from '@mui/icons-material/FilterListRounded';
|
|
import { useTheme } from '@mui/material/styles';
|
|
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
|
|
import { Trans, useTranslation } from 'react-i18next';
|
|
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
|
|
import dayjs from 'dayjs';
|
|
import { api } from '../../shared/services/api';
|
|
import { PageHeader, RefreshIconButton } from '../../shared/components/PageHeader';
|
|
import {
|
|
DataGrid,
|
|
GridToolbarColumnsButton,
|
|
GridToolbarContainer,
|
|
GridToolbarDensitySelector,
|
|
type GridRowSelectionModel,
|
|
type GridRenderCellParams,
|
|
type GridSortModel,
|
|
useGridApiRef,
|
|
} from '@mui/x-data-grid';
|
|
import { humanToRaw, rawToHuman } from '../wallet/utils/walletFormat';
|
|
import { CountryAutocomplete } from '../../shared/components/CountryAutocomplete';
|
|
import {
|
|
type AdminUser,
|
|
type AdminUserFilters,
|
|
type AdminUserSortField,
|
|
DEFAULT_FILTERS,
|
|
SERVER_SORT_FIELDS,
|
|
buildListParams,
|
|
buildExportRequestBody,
|
|
type AdminUserListResponse,
|
|
type AdminUserExportJob,
|
|
fullName,
|
|
deriveAccountStatus,
|
|
accountStatusReasons,
|
|
ageCategory,
|
|
formatDateOfBirth,
|
|
ageFilterLabel,
|
|
DEFAULT_HIDDEN_COLUMNS,
|
|
COLUMN_VISIBILITY_STORAGE_KEY,
|
|
} from './adminUserTypes';
|
|
|
|
const USDT_DECIMALS = 6;
|
|
const ROWS_PER_PAGE = 25;
|
|
|
|
function UsersGridToolbar({
|
|
onOpenDownload,
|
|
exportLimitLabel,
|
|
disabled,
|
|
selectedCount,
|
|
t,
|
|
}: {
|
|
onOpenDownload: (e: React.MouseEvent<HTMLElement>) => void;
|
|
exportLimitLabel: string;
|
|
disabled: boolean;
|
|
selectedCount: number;
|
|
t: ReturnType<typeof useTranslation>['t'];
|
|
}) {
|
|
return (
|
|
<GridToolbarContainer sx={{ gap: 1, justifyContent: 'space-between', flexWrap: 'wrap', width: '100%' }}>
|
|
<Stack direction="row" spacing={1} sx={{ alignItems: 'center', flexWrap: 'wrap', minWidth: 0 }}>
|
|
<GridToolbarColumnsButton />
|
|
<GridToolbarDensitySelector />
|
|
<Chip size="small" label={t('admin.users.columnsHint')} variant="outlined" />
|
|
<Button
|
|
size="small"
|
|
variant="outlined"
|
|
startIcon={<DownloadRoundedIcon />}
|
|
onClick={onOpenDownload}
|
|
disabled={disabled}
|
|
>
|
|
{selectedCount > 0 ? t('admin.users.exportSelected', { count: selectedCount }) : t('admin.users.download')}
|
|
</Button>
|
|
<Chip size="small" label={exportLimitLabel} variant="outlined" />
|
|
{selectedCount > 0 && (
|
|
<Chip size="small" color="primary" label={t('admin.users.selected', { count: selectedCount })} />
|
|
)}
|
|
</Stack>
|
|
</GridToolbarContainer>
|
|
);
|
|
}
|
|
|
|
function statusColor(status: AdminUser['account_status']): 'success' | 'warning' | 'error' | 'default' {
|
|
if (status === 'active') return 'success';
|
|
if (status === 'disabled') return 'default';
|
|
return 'warning';
|
|
}
|
|
|
|
function formatUsdt(raw: string): string {
|
|
return rawToHuman(raw || '0', USDT_DECIMALS);
|
|
}
|
|
|
|
function formatSignedUsdt(raw: string): string {
|
|
const n = BigInt(raw?.trim() || '0');
|
|
const human = rawToHuman(raw || '0', USDT_DECIMALS);
|
|
if (n > 0n) return `+${human} USDT`;
|
|
if (n < 0n) return `${human} USDT`;
|
|
return `${human} USDT`;
|
|
}
|
|
|
|
function formatDate(value: string | null | undefined): string {
|
|
if (!value) return '—';
|
|
return dayjs(value).format('YYYY-MM-DD HH:mm');
|
|
}
|
|
|
|
type ToggleField =
|
|
| 'isEnabled'
|
|
| 'isAccountNonExpired'
|
|
| 'isAccountNonLocked'
|
|
| 'isCredentialsNonExpired'
|
|
| 'withdrawalsSuspended'
|
|
| 'underSurveillance'
|
|
| 'reactivateWithdrawals';
|
|
|
|
/** Compact switch aligned like default grid cells. */
|
|
function FlagSwitch({
|
|
checked,
|
|
onChange,
|
|
label,
|
|
}: {
|
|
checked: boolean;
|
|
onChange: (next: boolean) => void;
|
|
label: string;
|
|
}) {
|
|
return (
|
|
<Switch
|
|
size="small"
|
|
checked={checked}
|
|
onChange={(_, next) => onChange(next)}
|
|
slotProps={{ input: { 'aria-label': label } as React.HTMLAttributes<HTMLInputElement> }}
|
|
/>
|
|
);
|
|
}
|
|
|
|
export function UserManagementPage() {
|
|
const { t } = useTranslation();
|
|
const theme = useTheme();
|
|
const isMobile = useMediaQuery(theme.breakpoints.down('md'));
|
|
const qc = useQueryClient();
|
|
const apiRef = useGridApiRef();
|
|
|
|
const [filters, setFilters] = useState<AdminUserFilters>(DEFAULT_FILTERS);
|
|
const [debouncedSearch, setDebouncedSearch] = useState('');
|
|
const [filtersOpen, setFiltersOpen] = useState(true);
|
|
const [page, setPage] = useState(0);
|
|
const [orderBy, setOrderBy] = useState<AdminUserSortField>('created_at');
|
|
const [order, setOrder] = useState<'asc' | 'desc'>('desc');
|
|
const [rowSelection, setRowSelection] = useState<GridRowSelectionModel>({
|
|
type: 'include',
|
|
ids: new Set(),
|
|
});
|
|
|
|
const [confirm, setConfirm] = useState<null | {
|
|
userId: string;
|
|
label: string;
|
|
field: ToggleField;
|
|
next: boolean;
|
|
}>(null);
|
|
|
|
const [batchDialog, setBatchDialog] = useState<
|
|
null | 'enable' | 'disable' | 'suspend' | 'reactivate' | 'bonus'
|
|
>(null);
|
|
const [batchBonusForm, setBatchBonusForm] = useState({
|
|
amountDisplay: '',
|
|
reason: '',
|
|
adjustmentType: 'bonus' as 'bonus' | 'admin_adjustment',
|
|
});
|
|
|
|
const [toast, setToast] = useState<string | null>(null);
|
|
const [expanded, setExpanded] = useState<Record<string, boolean>>({});
|
|
const [exportDialogOpen, setExportDialogOpen] = useState(false);
|
|
const [downloadAnchorEl, setDownloadAnchorEl] = useState<null | HTMLElement>(null);
|
|
const [exportLimitInput, setExportLimitInput] = useState<string>(() => {
|
|
try {
|
|
return localStorage.getItem('admin_users_export_limit') ?? '';
|
|
} catch {
|
|
return '';
|
|
}
|
|
});
|
|
const [exportVisibleOnly, setExportVisibleOnly] = useState<boolean>(() => {
|
|
try {
|
|
return (localStorage.getItem('admin_users_export_visible_only') ?? 'true') === 'true';
|
|
} catch {
|
|
return true;
|
|
}
|
|
});
|
|
const [exporting, setExporting] = useState(false);
|
|
const [exportProgress, setExportProgress] = useState<number | null>(null);
|
|
const [exportSelectedOnly, setExportSelectedOnly] = useState(false);
|
|
|
|
const [roleDialog, setRoleDialog] = useState<null | {
|
|
userId: string;
|
|
email: string | null;
|
|
roles: string[];
|
|
}>(null);
|
|
const [roleDraft, setRoleDraft] = useState<string[]>(['user']);
|
|
|
|
const ALL_ROLES = ['user', 'moderator', 'admin', 'super_admin'] as const;
|
|
|
|
const [columnVisibilityModel, setColumnVisibilityModel] = useState<Record<string, boolean>>(() => {
|
|
try {
|
|
const raw = localStorage.getItem(COLUMN_VISIBILITY_STORAGE_KEY);
|
|
if (raw) return { ...DEFAULT_HIDDEN_COLUMNS, ...JSON.parse(raw) };
|
|
} catch {
|
|
// ignore
|
|
}
|
|
return { ...DEFAULT_HIDDEN_COLUMNS };
|
|
});
|
|
const [gridMinWidth, setGridMinWidth] = useState<number>(0);
|
|
const gridScrollRef = useRef<HTMLDivElement | null>(null);
|
|
const [gridContainerWidth, setGridContainerWidth] = useState<number>(0);
|
|
const pageCursorsRef = useRef<Record<number, string>>({});
|
|
const [cachedTotal, setCachedTotal] = useState<number | null>(null);
|
|
const [totalIsExact, setTotalIsExact] = useState(true);
|
|
|
|
const listQueryKey = useMemo(
|
|
() =>
|
|
JSON.stringify({
|
|
filters,
|
|
debouncedSearch,
|
|
orderBy,
|
|
order,
|
|
}),
|
|
[filters, debouncedSearch, orderBy, order]
|
|
);
|
|
|
|
useEffect(() => {
|
|
pageCursorsRef.current = {};
|
|
setCachedTotal(null);
|
|
setTotalIsExact(true);
|
|
}, [listQueryKey]);
|
|
|
|
useEffect(() => {
|
|
try {
|
|
localStorage.setItem(COLUMN_VISIBILITY_STORAGE_KEY, JSON.stringify(columnVisibilityModel));
|
|
} catch {
|
|
// ignore
|
|
}
|
|
}, [columnVisibilityModel]);
|
|
|
|
useEffect(() => {
|
|
const t = window.setTimeout(() => {
|
|
setDebouncedSearch(filters.search.trim());
|
|
setPage(0);
|
|
}, 300);
|
|
return () => window.clearTimeout(t);
|
|
}, [filters.search]);
|
|
|
|
const listParams = useMemo(() => {
|
|
const cursor = page > 0 ? pageCursorsRef.current[page] : undefined;
|
|
const useOffset = page > 0 && !cursor;
|
|
return buildListParams(
|
|
{ ...filters, search: debouncedSearch },
|
|
orderBy,
|
|
order,
|
|
ROWS_PER_PAGE,
|
|
humanToRaw,
|
|
{
|
|
cursor: useOffset ? undefined : cursor,
|
|
offset: useOffset ? page * ROWS_PER_PAGE : undefined,
|
|
includeTotal: page === 0 && !cursor,
|
|
}
|
|
);
|
|
}, [filters, debouncedSearch, orderBy, order, page, listQueryKey]);
|
|
|
|
const q = useQuery({
|
|
queryKey: ['admin-users', listParams],
|
|
queryFn: async () => {
|
|
const res = await api.get<AdminUserListResponse>('/api/v1/admin/users', {
|
|
params: listParams,
|
|
});
|
|
if (res.data.nextCursor) {
|
|
pageCursorsRef.current[page + 1] = res.data.nextCursor;
|
|
}
|
|
if (res.data.total != null) {
|
|
setCachedTotal(res.data.total);
|
|
setTotalIsExact(res.data.totalIsExact);
|
|
}
|
|
return res.data;
|
|
},
|
|
});
|
|
|
|
const walletTypesQ = useQuery({
|
|
queryKey: ['wallet-types'],
|
|
queryFn: async () => {
|
|
const res = await api.get<Array<{ id: number; code: string; decimals: number }>>(
|
|
'/api/v1/wallet-types'
|
|
);
|
|
return res.data;
|
|
},
|
|
});
|
|
|
|
const usdtWalletTypeId = walletTypesQ.data?.find((w) => w.code === 'USDT_TRC20')?.id ?? 1;
|
|
|
|
const countriesQ = useQuery({
|
|
queryKey: ['admin-countries'],
|
|
queryFn: async () => {
|
|
const res = await api.get<{ items: Array<{ code: string; name: string }> }>(
|
|
'/api/v1/admin/countries'
|
|
);
|
|
return res.data.items ?? [];
|
|
},
|
|
});
|
|
|
|
const countryOptions = useMemo(
|
|
() => (countriesQ.data ?? []).map((c) => ({ code: c.code, name: c.name })),
|
|
[countriesQ.data]
|
|
);
|
|
|
|
const countryNameByCode = useMemo(() => {
|
|
const map = new Map<string, string>();
|
|
for (const c of countriesQ.data ?? []) {
|
|
map.set(c.code, c.name);
|
|
}
|
|
return map;
|
|
}, [countriesQ.data]);
|
|
|
|
const countryLabel = useCallback(
|
|
(code: string | null | undefined) => {
|
|
if (!code) return '—';
|
|
return countryNameByCode.get(code) ?? code;
|
|
},
|
|
[countryNameByCode]
|
|
);
|
|
|
|
const batchMut = useMutation({
|
|
mutationFn: async (body: Record<string, unknown>) => {
|
|
const endpoint =
|
|
batchDialog === 'bonus'
|
|
? '/api/v1/admin/users/batch/ledger-credit'
|
|
: batchDialog === 'suspend' || batchDialog === 'reactivate'
|
|
? '/api/v1/admin/users/batch/security'
|
|
: '/api/v1/admin/users/batch/flags';
|
|
const res = await api.post<{ succeeded: string[]; failed: Array<{ userId: string; error: string }> }>(
|
|
endpoint,
|
|
body
|
|
);
|
|
return res.data;
|
|
},
|
|
onSuccess: (data) => {
|
|
setBatchDialog(null);
|
|
setBatchBonusForm({ amountDisplay: '', reason: '', adjustmentType: 'bonus' });
|
|
setRowSelection({ type: 'include', ids: new Set() });
|
|
void qc.invalidateQueries({ queryKey: ['admin-users'] });
|
|
const failed = data.failed?.length ?? 0;
|
|
const ok = data.succeeded?.length ?? 0;
|
|
setToast(failed ? `${ok} succeeded, ${failed} failed` : `${ok} user(s) updated`);
|
|
},
|
|
onError: (e: any) => {
|
|
setToast(e?.response?.data?.error ?? e?.message ?? t('admin.users.batchFailed'));
|
|
},
|
|
});
|
|
|
|
const verifyEmailMut = useMutation({
|
|
mutationFn: async (userId: string) => {
|
|
const res = await api.post<{ message: string }>(`/api/v1/admin/users/${userId}/verify-email`);
|
|
return res.data;
|
|
},
|
|
onSuccess: () => {
|
|
setToast(t('admin.users.emailVerified'));
|
|
void qc.invalidateQueries({ queryKey: ['admin-users'] });
|
|
},
|
|
onError: (e: unknown) => {
|
|
const err = e as { response?: { data?: { error?: string } }; message?: string };
|
|
setToast(err?.response?.data?.error ?? err?.message ?? t('admin.users.emailVerifyFailed'));
|
|
},
|
|
});
|
|
|
|
const roleMut = useMutation({
|
|
mutationFn: (body: { userId: string; roles: string[] }) =>
|
|
api.patch(`/api/v1/admin/users/${body.userId}/roles`, { roles: body.roles }),
|
|
onSuccess: () => {
|
|
setRoleDialog(null);
|
|
setToast(t('admin.users.rolesUpdated'));
|
|
void qc.invalidateQueries({ queryKey: ['admin-users'] });
|
|
},
|
|
onError: (e: unknown) => {
|
|
const err = e as { response?: { data?: { error?: string } }; message?: string };
|
|
setToast(err?.response?.data?.error ?? err?.message ?? t('admin.users.roleUpdateFailed'));
|
|
},
|
|
});
|
|
|
|
const openRoleDialog = useCallback(async (u: AdminUser) => {
|
|
try {
|
|
const res = await api.get<{ user: { roles?: string[]; role_name: string } }>(
|
|
`/api/v1/admin/users/${u.id}`
|
|
);
|
|
const roles = res.data.user.roles?.length
|
|
? res.data.user.roles
|
|
: [res.data.user.role_name || 'user'];
|
|
setRoleDraft(roles);
|
|
setRoleDialog({ userId: u.id, email: u.email, roles });
|
|
} catch {
|
|
const fallback = u.role_name ? [u.role_name] : ['user'];
|
|
setRoleDraft(fallback);
|
|
setRoleDialog({ userId: u.id, email: u.email, roles: fallback });
|
|
}
|
|
}, []);
|
|
|
|
const users = q.data?.users ?? [];
|
|
const total = cachedTotal ?? q.data?.total ?? 0;
|
|
const totalLabel = q.isLoading
|
|
? t('common.loading')
|
|
: totalIsExact
|
|
? t('admin.users.totalExact', { count: total })
|
|
: t('admin.users.totalEstimate', { count: total.toLocaleString() });
|
|
const selectedIds = useMemo(() => {
|
|
if (rowSelection.type === 'include') {
|
|
return [...rowSelection.ids].map(String);
|
|
}
|
|
return users.filter((u) => !rowSelection.ids.has(u.id)).map((u) => u.id);
|
|
}, [rowSelection, users]);
|
|
|
|
const copy = async (text: string) => {
|
|
try {
|
|
await navigator.clipboard.writeText(text);
|
|
setToast(t('admin.users.copied'));
|
|
} catch {
|
|
setToast(t('admin.users.copyFailed'));
|
|
}
|
|
};
|
|
|
|
const onToggle = useCallback((u: AdminUser, field: NonNullable<typeof confirm>['field'], next: boolean) => {
|
|
const fieldLabel = t(`admin.users.fields.${field}`);
|
|
setConfirm({
|
|
userId: u.id,
|
|
label: `${u.email ?? u.id} · ${fieldLabel}`,
|
|
field,
|
|
next,
|
|
});
|
|
}, [t]);
|
|
|
|
const applyToggle = async () => {
|
|
if (!confirm) return;
|
|
try {
|
|
if (
|
|
confirm.field === 'withdrawalsSuspended' ||
|
|
confirm.field === 'underSurveillance' ||
|
|
confirm.field === 'reactivateWithdrawals'
|
|
) {
|
|
const row = users.find((u) => u.id === confirm.userId);
|
|
const body: Record<string, unknown> = { [confirm.field]: confirm.next };
|
|
if (confirm.field === 'reactivateWithdrawals') {
|
|
body.reactivateWithdrawals = true;
|
|
} else if (!confirm.next && row) {
|
|
const wdOff =
|
|
confirm.field === 'withdrawalsSuspended' ? true : !row.withdrawals_suspended;
|
|
const survOff = confirm.field === 'underSurveillance' ? true : !row.under_surveillance;
|
|
if (wdOff && survOff) body.reactivateWithdrawals = true;
|
|
}
|
|
await api.patch(`/api/v1/admin/users/${confirm.userId}/security`, body);
|
|
} else {
|
|
await api.patch(`/api/v1/admin/users/${confirm.userId}/flags`, {
|
|
[confirm.field]: confirm.next,
|
|
});
|
|
}
|
|
setConfirm(null);
|
|
void q.refetch();
|
|
} catch (e: any) {
|
|
setToast(e?.response?.data?.error ?? e?.message ?? t('admin.users.updateFailed'));
|
|
}
|
|
};
|
|
|
|
const columns = useMemo(
|
|
() => [
|
|
{ field: 'id', headerName: t('admin.users.columns.id'), width: 180, sortable: true },
|
|
{
|
|
field: 'email',
|
|
headerName: t('admin.users.columns.email'),
|
|
width: 280,
|
|
valueGetter: (_v: unknown, row: AdminUser) => row.email ?? '—',
|
|
},
|
|
{
|
|
field: 'full_name',
|
|
headerName: t('admin.users.columns.fullName'),
|
|
width: 200,
|
|
sortable: false,
|
|
valueGetter: (_v: unknown, row: AdminUser) => fullName(row),
|
|
},
|
|
{
|
|
field: 'account_status',
|
|
headerName: t('admin.users.columns.status'),
|
|
width: 120,
|
|
sortable: false,
|
|
renderCell: (p: { row: AdminUser }) => {
|
|
const status = deriveAccountStatus(p.row);
|
|
const reasons = accountStatusReasons(t, p.row);
|
|
const tip =
|
|
status === 'active'
|
|
? t('admin.users.accountStatus.fullyActive')
|
|
: reasons.length
|
|
? reasons.join(' · ')
|
|
: t(`admin.users.accountStatus.${status}`);
|
|
return (
|
|
<Tooltip title={tip} arrow placement="top">
|
|
<Chip
|
|
size="small"
|
|
label={t(`admin.users.accountStatus.${status}`)}
|
|
color={statusColor(status)}
|
|
sx={{ cursor: 'help' }}
|
|
/>
|
|
</Tooltip>
|
|
);
|
|
},
|
|
},
|
|
{
|
|
field: 'email_verified',
|
|
headerName: t('admin.users.columns.emailOk'),
|
|
width: 110,
|
|
sortable: true,
|
|
renderCell: (p: { row: AdminUser }) =>
|
|
p.row.email_verified ? (
|
|
<Chip size="small" label={t('common.yes')} color="success" variant="outlined" />
|
|
) : (
|
|
<Tooltip title={t('admin.users.tooltips.verifyEmail')} arrow placement="top">
|
|
<Chip
|
|
size="small"
|
|
label={t('common.no')}
|
|
color="warning"
|
|
variant="outlined"
|
|
onClick={(e) => {
|
|
e.stopPropagation();
|
|
verifyEmailMut.mutate(p.row.id);
|
|
}}
|
|
disabled={verifyEmailMut.isPending}
|
|
sx={{ cursor: 'pointer' }}
|
|
/>
|
|
</Tooltip>
|
|
),
|
|
},
|
|
{
|
|
field: 'role_name',
|
|
headerName: t('admin.users.columns.role'),
|
|
width: 120,
|
|
sortable: true,
|
|
renderCell: (p: { row: AdminUser }) => (
|
|
<Tooltip title={t('admin.users.tooltips.changeRole')} arrow placement="top">
|
|
<Chip
|
|
size="small"
|
|
label={p.row.role_name}
|
|
variant="outlined"
|
|
color={p.row.role_name === 'admin' ? 'primary' : 'default'}
|
|
onClick={(e) => {
|
|
e.stopPropagation();
|
|
openRoleDialog(p.row);
|
|
}}
|
|
sx={{ cursor: 'pointer' }}
|
|
/>
|
|
</Tooltip>
|
|
),
|
|
},
|
|
{
|
|
field: 'country_of_residence',
|
|
headerName: t('admin.users.columns.country'),
|
|
width: 160,
|
|
sortable: true,
|
|
valueGetter: (_v: unknown, row: AdminUser) => countryLabel(row.country_of_residence),
|
|
},
|
|
{
|
|
field: 'nationality',
|
|
headerName: t('admin.users.columns.nationality'),
|
|
width: 160,
|
|
sortable: false,
|
|
valueGetter: (_v: unknown, row: AdminUser) => countryLabel(row.nationality),
|
|
},
|
|
{
|
|
field: 'date_of_birth',
|
|
headerName: t('admin.users.columns.dob'),
|
|
width: 110,
|
|
sortable: false,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatDateOfBirth(row.date_of_birth),
|
|
},
|
|
{
|
|
field: 'age_category',
|
|
headerName: t('admin.users.columns.ageGroup'),
|
|
width: 110,
|
|
sortable: false,
|
|
valueGetter: (_v: unknown, row: AdminUser) => ageCategory(t, row.date_of_birth),
|
|
},
|
|
{
|
|
field: 'referral_code',
|
|
headerName: t('admin.users.columns.referralCode'),
|
|
width: 130,
|
|
sortable: false,
|
|
valueGetter: (_v: unknown, row: AdminUser) => row.referral_code ?? '—',
|
|
},
|
|
{
|
|
field: 'first_deposit_at',
|
|
headerName: t('admin.users.columns.firstDeposit'),
|
|
width: 150,
|
|
sortable: false,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatDate(row.first_deposit_at),
|
|
},
|
|
{
|
|
field: 'first_deposit_transaction_id',
|
|
headerName: t('admin.users.columns.firstDepositTx'),
|
|
width: 180,
|
|
sortable: false,
|
|
valueGetter: (_v: unknown, row: AdminUser) => row.first_deposit_transaction_id ?? '—',
|
|
},
|
|
{
|
|
field: 'main_balance_raw',
|
|
headerName: t('admin.users.columns.mainUsdt'),
|
|
width: 120,
|
|
sortable: true,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatUsdt(row.main_balance_raw),
|
|
},
|
|
{
|
|
field: 'bonus_balance_raw',
|
|
headerName: t('admin.users.columns.bonusUsdt'),
|
|
width: 120,
|
|
sortable: true,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatUsdt(row.bonus_balance_raw),
|
|
},
|
|
{
|
|
field: 'total_bonus_received_raw',
|
|
headerName: t('admin.users.columns.bonusReceived'),
|
|
width: 130,
|
|
sortable: true,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatUsdt(row.total_bonus_received_raw),
|
|
},
|
|
{
|
|
field: 'prediction_count',
|
|
headerName: t('admin.users.columns.predictions'),
|
|
width: 110,
|
|
sortable: true,
|
|
type: 'number' as const,
|
|
},
|
|
{
|
|
field: 'net_pnl_raw',
|
|
headerName: t('admin.users.columns.netPnl'),
|
|
width: 130,
|
|
sortable: true,
|
|
description: 'Cumulative result on Candle Predict: total payouts minus total stakes (USDT).',
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatSignedUsdt(row.net_pnl_raw),
|
|
renderCell: (params: GridRenderCellParams<AdminUser>) => {
|
|
const n = BigInt(params.row.net_pnl_raw?.trim() || '0');
|
|
const color = n > 0n ? 'success.main' : n < 0n ? 'warning.main' : 'text.secondary';
|
|
return (
|
|
<Box
|
|
component="span"
|
|
sx={{
|
|
color,
|
|
fontWeight: n === 0n ? 400 : 600,
|
|
}}
|
|
>
|
|
{params.value}
|
|
</Box>
|
|
);
|
|
},
|
|
},
|
|
{
|
|
field: 'total_stake_raw',
|
|
headerName: t('admin.users.columns.totalStake'),
|
|
width: 110,
|
|
sortable: true,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatUsdt(row.total_stake_raw),
|
|
},
|
|
{
|
|
field: 'total_payout_raw',
|
|
headerName: t('admin.users.columns.totalPayout'),
|
|
width: 110,
|
|
sortable: true,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatUsdt(row.total_payout_raw),
|
|
},
|
|
{
|
|
field: 'created_at',
|
|
headerName: t('admin.users.columns.created'),
|
|
width: 150,
|
|
sortable: true,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatDate(row.created_at),
|
|
},
|
|
{
|
|
field: 'last_login_at',
|
|
headerName: t('admin.users.columns.lastLogin'),
|
|
width: 150,
|
|
sortable: true,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatDate(row.last_login_at),
|
|
},
|
|
{
|
|
field: 'last_activity_at',
|
|
headerName: t('admin.users.columns.lastActivity'),
|
|
width: 150,
|
|
sortable: true,
|
|
valueGetter: (_v: unknown, row: AdminUser) => formatDate(row.last_activity_at),
|
|
},
|
|
{
|
|
field: 'is_enabled',
|
|
headerName: t('admin.users.columns.enabled'),
|
|
width: 100,
|
|
sortable: true,
|
|
align: 'center' as const,
|
|
headerAlign: 'center' as const,
|
|
renderCell: (p: { row: AdminUser }) => (
|
|
<FlagSwitch
|
|
checked={!!p.row.is_enabled}
|
|
label={t('admin.users.fields.isEnabled')}
|
|
onChange={(v) => onToggle(p.row, 'isEnabled', v)}
|
|
/>
|
|
),
|
|
},
|
|
{
|
|
field: 'withdrawals_suspended',
|
|
headerName: t('admin.users.columns.wdSuspended'),
|
|
width: 120,
|
|
sortable: false,
|
|
align: 'center' as const,
|
|
headerAlign: 'center' as const,
|
|
renderCell: (p: { row: AdminUser }) => (
|
|
<FlagSwitch
|
|
checked={!!p.row.withdrawals_suspended}
|
|
label={t('admin.users.fields.withdrawalsSuspended')}
|
|
onChange={(v) => onToggle(p.row, 'withdrawalsSuspended', v)}
|
|
/>
|
|
),
|
|
},
|
|
{
|
|
field: 'under_surveillance',
|
|
headerName: t('admin.users.columns.surveillance'),
|
|
width: 110,
|
|
sortable: false,
|
|
align: 'center' as const,
|
|
headerAlign: 'center' as const,
|
|
renderCell: (p: { row: AdminUser }) => (
|
|
<FlagSwitch
|
|
checked={!!p.row.under_surveillance}
|
|
label={t('admin.users.fields.underSurveillance')}
|
|
onChange={(v) => onToggle(p.row, 'underSurveillance', v)}
|
|
/>
|
|
),
|
|
},
|
|
{
|
|
field: 'totp_enabled',
|
|
headerName: t('admin.users.columns.twoFa'),
|
|
width: 80,
|
|
sortable: false,
|
|
renderCell: (p: { row: AdminUser }) => (
|
|
<Chip size="small" label={p.row.totp_enabled ? t('common.on') : t('common.off')} variant="outlined" />
|
|
),
|
|
},
|
|
{
|
|
field: 'is_account_non_expired',
|
|
headerName: t('admin.users.columns.nonExpired'),
|
|
width: 120,
|
|
sortable: false,
|
|
align: 'center' as const,
|
|
headerAlign: 'center' as const,
|
|
renderCell: (p: { row: AdminUser }) => (
|
|
<FlagSwitch
|
|
checked={!!p.row.is_account_non_expired}
|
|
label={t('admin.users.fields.isAccountNonExpired')}
|
|
onChange={(v) => onToggle(p.row, 'isAccountNonExpired', v)}
|
|
/>
|
|
),
|
|
},
|
|
{
|
|
field: 'is_account_non_locked',
|
|
headerName: t('admin.users.columns.nonLocked'),
|
|
width: 120,
|
|
sortable: false,
|
|
align: 'center' as const,
|
|
headerAlign: 'center' as const,
|
|
renderCell: (p: { row: AdminUser }) => (
|
|
<FlagSwitch
|
|
checked={!!p.row.is_account_non_locked}
|
|
label={t('admin.users.fields.isAccountNonLocked')}
|
|
onChange={(v) => onToggle(p.row, 'isAccountNonLocked', v)}
|
|
/>
|
|
),
|
|
},
|
|
{
|
|
field: 'is_credentials_non_expired',
|
|
headerName: t('admin.users.columns.credsValid'),
|
|
width: 120,
|
|
sortable: false,
|
|
align: 'center' as const,
|
|
headerAlign: 'center' as const,
|
|
renderCell: (p: { row: AdminUser }) => (
|
|
<FlagSwitch
|
|
checked={!!p.row.is_credentials_non_expired}
|
|
label={t('admin.users.fields.isCredentialsNonExpired')}
|
|
onChange={(v) => onToggle(p.row, 'isCredentialsNonExpired', v)}
|
|
/>
|
|
),
|
|
},
|
|
{
|
|
field: 'actions',
|
|
headerName: t('admin.users.columns.copy'),
|
|
width: 90,
|
|
sortable: false,
|
|
renderCell: (p: { row: AdminUser }) => (
|
|
<Stack direction="row" spacing={0.5}>
|
|
<Tooltip title={t('admin.users.tooltips.copyUserId')} arrow placement="top">
|
|
<IconButton size="small" onClick={() => copy(p.row.id)} aria-label={t('admin.users.tooltips.copyUserId')}>
|
|
<ContentCopyRoundedIcon fontSize="small" />
|
|
</IconButton>
|
|
</Tooltip>
|
|
{p.row.email && (
|
|
<Tooltip title={t('admin.users.tooltips.copyEmail')} arrow placement="top">
|
|
<IconButton size="small" onClick={() => copy(p.row.email!)} aria-label={t('admin.users.tooltips.copyEmail')}>
|
|
<ContentCopyRoundedIcon fontSize="small" />
|
|
</IconButton>
|
|
</Tooltip>
|
|
)}
|
|
</Stack>
|
|
),
|
|
},
|
|
],
|
|
[copy, onToggle, countryLabel, verifyEmailMut, openRoleDialog, t]
|
|
);
|
|
|
|
const exportColumnDefs = useMemo(
|
|
() => [
|
|
{ field: 'id', header: t('admin.users.columns.id'), get: (u: AdminUser) => u.id },
|
|
{ field: 'email', header: t('admin.users.columns.email'), get: (u: AdminUser) => u.email ?? '' },
|
|
{ field: 'full_name', header: t('admin.users.columns.fullName'), get: (u: AdminUser) => fullName(u) },
|
|
{ field: 'account_status', header: t('admin.users.columns.status'), get: (u: AdminUser) => deriveAccountStatus(u) },
|
|
{ field: 'role_name', header: t('admin.users.columns.role'), get: (u: AdminUser) => u.role_name },
|
|
{
|
|
field: 'country_of_residence',
|
|
header: t('admin.users.columns.country'),
|
|
get: (u: AdminUser) => countryLabel(u.country_of_residence),
|
|
},
|
|
{
|
|
field: 'nationality',
|
|
header: t('admin.users.columns.nationality'),
|
|
get: (u: AdminUser) => countryLabel(u.nationality),
|
|
},
|
|
{ field: 'date_of_birth', header: t('admin.users.columns.dob'), get: (u: AdminUser) => formatDateOfBirth(u.date_of_birth) },
|
|
{ field: 'age_category', header: t('admin.users.columns.ageGroup'), get: (u: AdminUser) => ageCategory(t, u.date_of_birth) },
|
|
{ field: 'referral_code', header: t('admin.users.columns.referralCode'), get: (u: AdminUser) => u.referral_code ?? '' },
|
|
{
|
|
field: 'first_deposit_at',
|
|
header: t('admin.users.columns.firstDeposit'),
|
|
get: (u: AdminUser) => formatDate(u.first_deposit_at),
|
|
},
|
|
{
|
|
field: 'first_deposit_transaction_id',
|
|
header: t('admin.users.columns.firstDepositTx'),
|
|
get: (u: AdminUser) => u.first_deposit_transaction_id ?? '',
|
|
},
|
|
{ field: 'email_verified', header: t('admin.users.filterLabels.emailVerified'), get: (u: AdminUser) => (u.email_verified ? 'yes' : 'no') },
|
|
{ field: 'main_balance_raw', header: t('admin.users.columns.mainUsdt'), get: (u: AdminUser) => formatUsdt(u.main_balance_raw) },
|
|
{ field: 'bonus_balance_raw', header: t('admin.users.columns.bonusUsdt'), get: (u: AdminUser) => formatUsdt(u.bonus_balance_raw) },
|
|
{
|
|
field: 'total_bonus_received_raw',
|
|
header: t('admin.users.columns.bonusReceived'),
|
|
get: (u: AdminUser) => formatUsdt(u.total_bonus_received_raw),
|
|
},
|
|
{ field: 'prediction_count', header: t('admin.users.columns.predictions'), get: (u: AdminUser) => String(u.prediction_count) },
|
|
{ field: 'net_pnl_raw', header: t('admin.users.columns.netPnl'), get: (u: AdminUser) => formatSignedUsdt(u.net_pnl_raw) },
|
|
{ field: 'total_stake_raw', header: t('admin.users.columns.totalStake'), get: (u: AdminUser) => formatUsdt(u.total_stake_raw) },
|
|
{ field: 'total_payout_raw', header: t('admin.users.columns.totalPayout'), get: (u: AdminUser) => formatUsdt(u.total_payout_raw) },
|
|
{ field: 'created_at', header: t('admin.users.columns.created'), get: (u: AdminUser) => formatDate(u.created_at) },
|
|
{ field: 'last_login_at', header: t('admin.users.columns.lastLogin'), get: (u: AdminUser) => formatDate(u.last_login_at) },
|
|
{ field: 'last_activity_at', header: t('admin.users.columns.lastActivity'), get: (u: AdminUser) => formatDate(u.last_activity_at) },
|
|
{ field: 'is_enabled', header: t('admin.users.columns.enabled'), get: (u: AdminUser) => (u.is_enabled ? 'true' : 'false') },
|
|
{
|
|
field: 'withdrawals_suspended',
|
|
header: t('admin.users.fields.withdrawalsSuspended'),
|
|
get: (u: AdminUser) => (u.withdrawals_suspended ? 'true' : 'false'),
|
|
},
|
|
{
|
|
field: 'under_surveillance',
|
|
header: t('admin.users.fields.underSurveillance'),
|
|
get: (u: AdminUser) => (u.under_surveillance ? 'true' : 'false'),
|
|
},
|
|
{ field: 'totp_enabled', header: t('admin.users.columns.twoFa'), get: (u: AdminUser) => (u.totp_enabled ? 'yes' : 'no') },
|
|
{
|
|
field: 'is_account_non_expired',
|
|
header: t('admin.users.fields.isAccountNonExpired'),
|
|
get: (u: AdminUser) => (u.is_account_non_expired ? 'true' : 'false'),
|
|
},
|
|
{
|
|
field: 'is_account_non_locked',
|
|
header: t('admin.users.fields.isAccountNonLocked'),
|
|
get: (u: AdminUser) => (u.is_account_non_locked ? 'true' : 'false'),
|
|
},
|
|
{
|
|
field: 'is_credentials_non_expired',
|
|
header: t('admin.users.fields.isCredentialsNonExpired'),
|
|
get: (u: AdminUser) => (u.is_credentials_non_expired ? 'true' : 'false'),
|
|
},
|
|
],
|
|
[countryLabel, t]
|
|
);
|
|
|
|
useEffect(() => {
|
|
if (!gridScrollRef.current) return;
|
|
const el = gridScrollRef.current;
|
|
const ro = new ResizeObserver(() => {
|
|
setGridContainerWidth(Math.max(0, Math.floor(el.getBoundingClientRect().width)));
|
|
});
|
|
ro.observe(el);
|
|
setGridContainerWidth(Math.max(0, Math.floor(el.getBoundingClientRect().width)));
|
|
return () => ro.disconnect();
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
const visibleFields = columns
|
|
.map((c) => c.field)
|
|
.filter((f) => f && (columnVisibilityModel[f] ?? true));
|
|
const sum = columns.reduce((acc, c) => {
|
|
if (!visibleFields.includes(c.field)) return acc;
|
|
const w = typeof c.width === 'number' ? c.width : 120;
|
|
return acc + w;
|
|
}, 0);
|
|
setGridMinWidth(Math.max(1400, sum + 80));
|
|
}, [columns, columnVisibilityModel]);
|
|
|
|
const activeFilters = useMemo(() => {
|
|
let n = 0;
|
|
if (debouncedSearch) n += 1;
|
|
if (filters.roleFilter !== 'all') n += 1;
|
|
if (filters.emailVerifiedFilter !== 'all') n += 1;
|
|
if (filters.countryFilter.trim()) n += 1;
|
|
if (filters.accountStatusFilter !== 'all') n += 1;
|
|
if (filters.inactiveSinceDays.trim()) n += 1;
|
|
if (filters.hasReceivedBonusFilter !== 'all') n += 1;
|
|
if (filters.minMainBalance.trim() || filters.maxMainBalance.trim()) n += 1;
|
|
if (filters.minBonusReceived.trim() || filters.maxBonusReceived.trim()) n += 1;
|
|
if (filters.minAge.trim() || filters.maxAge.trim()) n += 1;
|
|
if (filters.createdFrom || filters.createdTo) n += 1;
|
|
return n;
|
|
}, [debouncedSearch, filters]);
|
|
|
|
const exportLimitLabel = useMemo(() => {
|
|
const n = exportLimitInput.trim() ? parseInt(exportLimitInput.trim(), 10) : 0;
|
|
if (Number.isFinite(n) && n > 0) return t('admin.users.exportLimit', { count: n });
|
|
return t('admin.users.exportLimitDefault');
|
|
}, [exportLimitInput, t]);
|
|
|
|
const sleep = (ms: number) => new Promise((resolve) => window.setTimeout(resolve, ms));
|
|
|
|
const exportXlsx = async (selectedOnly: boolean) => {
|
|
const limitNum = exportLimitInput.trim() ? parseInt(exportLimitInput.trim(), 10) : 0;
|
|
const effectiveLimit = Number.isFinite(limitNum) && limitNum > 0 ? limitNum : undefined;
|
|
|
|
try {
|
|
setExporting(true);
|
|
setExportProgress(0);
|
|
|
|
if (selectedOnly && selectedIds.length === 0) {
|
|
setToast(t('admin.users.noUsersSelected'));
|
|
return;
|
|
}
|
|
|
|
let fieldsToExport: string[];
|
|
if (exportVisibleOnly && apiRef.current) {
|
|
const visible = apiRef.current.getVisibleColumns?.() ?? [];
|
|
fieldsToExport = visible
|
|
.map((c: { field?: string }) => c.field)
|
|
.filter((f): f is string => !!f && f !== 'actions' && f !== '__check__');
|
|
if (fieldsToExport.length === 0) {
|
|
fieldsToExport = exportColumnDefs.map((c) => c.field);
|
|
}
|
|
} else {
|
|
fieldsToExport = exportColumnDefs.map((c) => c.field);
|
|
}
|
|
|
|
const body = {
|
|
...buildExportRequestBody(
|
|
{ ...filters, search: debouncedSearch },
|
|
orderBy,
|
|
order,
|
|
humanToRaw
|
|
),
|
|
columns: fieldsToExport,
|
|
maxRows: selectedOnly ? undefined : effectiveLimit,
|
|
userIds: selectedOnly ? selectedIds : undefined,
|
|
format: 'xlsx' as const,
|
|
};
|
|
|
|
const start = await api.post<AdminUserExportJob>('/api/v1/admin/users/export', body);
|
|
let job = start.data;
|
|
|
|
while (job.status === 'queued' || job.status === 'running') {
|
|
setExportProgress(job.progress);
|
|
await sleep(800);
|
|
const status = await api.get<AdminUserExportJob>(`/api/v1/admin/users/export/${job.id}`);
|
|
job = status.data;
|
|
}
|
|
|
|
if (job.status === 'failed') {
|
|
throw new Error(job.error ?? t('admin.users.exportFailed'));
|
|
}
|
|
|
|
const download = await api.get<Blob>(`/api/v1/admin/users/export/${job.id}/download`, {
|
|
responseType: 'blob',
|
|
});
|
|
const fileName = job.fileName ?? `users_export_${dayjs().format('YYYY-MM-DD')}.xlsx`;
|
|
const url = URL.createObjectURL(download.data);
|
|
const anchor = document.createElement('a');
|
|
anchor.href = url;
|
|
anchor.download = fileName;
|
|
anchor.click();
|
|
URL.revokeObjectURL(url);
|
|
setToast(`Exported ${job.rowCount} row(s)`);
|
|
} catch (e: unknown) {
|
|
const err = e as { response?: { data?: { error?: string } }; message?: string };
|
|
setToast(err?.response?.data?.error ?? err?.message ?? t('admin.users.exportFailed'));
|
|
} finally {
|
|
setExporting(false);
|
|
setExportProgress(null);
|
|
}
|
|
};
|
|
|
|
const onGridSortChange = (model: GridSortModel) => {
|
|
const first = model[0];
|
|
if (!first?.field) return;
|
|
if (!SERVER_SORT_FIELDS.has(first.field)) return;
|
|
setOrderBy(first.field as AdminUserSortField);
|
|
setOrder((first.sort ?? 'asc') as 'asc' | 'desc');
|
|
setPage(0);
|
|
};
|
|
|
|
const clearFilters = () => {
|
|
setFilters(DEFAULT_FILTERS);
|
|
setDebouncedSearch('');
|
|
setPage(0);
|
|
setExpanded({});
|
|
};
|
|
|
|
const runBatch = () => {
|
|
if (selectedIds.length === 0) return;
|
|
if (batchDialog === 'enable') {
|
|
batchMut.mutate({ userIds: selectedIds, isEnabled: true });
|
|
} else if (batchDialog === 'disable') {
|
|
batchMut.mutate({ userIds: selectedIds, isEnabled: false });
|
|
} else if (batchDialog === 'suspend') {
|
|
batchMut.mutate({ userIds: selectedIds, withdrawalsSuspended: true, underSurveillance: true });
|
|
} else if (batchDialog === 'reactivate') {
|
|
batchMut.mutate({ userIds: selectedIds, reactivateWithdrawals: true });
|
|
} else if (batchDialog === 'bonus') {
|
|
const amountRaw = humanToRaw(batchBonusForm.amountDisplay, USDT_DECIMALS);
|
|
if (amountRaw === '0') {
|
|
setToast(t('admin.users.invalidBonusAmount'));
|
|
return;
|
|
}
|
|
batchMut.mutate({
|
|
userIds: selectedIds,
|
|
walletTypeId: usdtWalletTypeId,
|
|
adjustmentType: batchBonusForm.adjustmentType,
|
|
amountRaw,
|
|
reason: batchBonusForm.reason,
|
|
});
|
|
}
|
|
};
|
|
|
|
const batchLabel =
|
|
batchDialog === 'enable'
|
|
? t('admin.users.batch.enableAccounts')
|
|
: batchDialog === 'disable'
|
|
? t('admin.users.batch.disableAccounts')
|
|
: batchDialog === 'suspend'
|
|
? t('admin.users.batch.suspendAccounts')
|
|
: batchDialog === 'reactivate'
|
|
? t('admin.users.batch.reactivateAccounts')
|
|
: t('admin.users.batch.grantBonusTitle');
|
|
|
|
return (
|
|
<Grid container spacing={2.5} sx={{ minWidth: 0, overflowX: 'hidden' }}>
|
|
<Grid size={{ xs: 12 }}>
|
|
<PageHeader
|
|
title={t('admin.users.title')}
|
|
subtitle={t('admin.users.subtitle')}
|
|
actions={<RefreshIconButton label={t('admin.users.refresh')} onClick={() => void q.refetch()} />}
|
|
/>
|
|
</Grid>
|
|
|
|
{selectedIds.length > 0 && (
|
|
<Grid size={{ xs: 12 }}>
|
|
<Paper
|
|
sx={{
|
|
p: 1.5,
|
|
borderRadius: 3,
|
|
border: '1px solid rgba(255,255,255,0.12)',
|
|
backgroundImage: 'none',
|
|
}}
|
|
>
|
|
<Stack direction="row" spacing={1} sx={{ alignItems: 'center', flexWrap: 'wrap' }}>
|
|
<Typography sx={{ fontWeight: 700, mr: 1 }}>{t('admin.users.selected', { count: selectedIds.length })}</Typography>
|
|
<Button size="small" variant="outlined" onClick={() => setBatchDialog('enable')}>
|
|
{t('admin.users.batch.enable')}
|
|
</Button>
|
|
<Button size="small" variant="outlined" color="warning" onClick={() => setBatchDialog('disable')}>
|
|
{t('admin.users.batch.disable')}
|
|
</Button>
|
|
<Button size="small" variant="outlined" color="warning" onClick={() => setBatchDialog('suspend')}>
|
|
{t('admin.users.batch.suspend')}
|
|
</Button>
|
|
<Button size="small" variant="outlined" color="success" onClick={() => setBatchDialog('reactivate')}>
|
|
{t('admin.users.batch.reactivate')}
|
|
</Button>
|
|
<Button size="small" variant="contained" onClick={() => setBatchDialog('bonus')}>
|
|
{t('admin.users.batch.grantBonus')}
|
|
</Button>
|
|
<Button
|
|
size="small"
|
|
variant="text"
|
|
startIcon={<DownloadRoundedIcon />}
|
|
onClick={() => void exportXlsx(true)}
|
|
disabled={exporting}
|
|
>
|
|
{t('admin.users.batch.exportSelected')}
|
|
</Button>
|
|
<Button size="small" color="inherit" onClick={() => setRowSelection({ type: 'include', ids: new Set() })}>
|
|
{t('admin.users.batch.clearSelection')}
|
|
</Button>
|
|
</Stack>
|
|
</Paper>
|
|
</Grid>
|
|
)}
|
|
|
|
<Grid size={{ xs: 12 }}>
|
|
<Paper sx={{ p: 2, borderRadius: 3, border: '1px solid rgba(255,255,255,0.08)', backgroundImage: 'none' }}>
|
|
<Stack direction="row" spacing={1} sx={{ alignItems: 'center', mb: filtersOpen ? 1.5 : 0 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.searchLabel')}
|
|
placeholder={t('admin.users.searchPlaceholder')}
|
|
value={filters.search}
|
|
onChange={(e) => setFilters((f) => ({ ...f, search: e.target.value }))}
|
|
/>
|
|
<Button
|
|
variant={filtersOpen ? 'contained' : 'outlined'}
|
|
startIcon={<FilterListRoundedIcon />}
|
|
onClick={() => setFiltersOpen((v) => !v)}
|
|
sx={{ whiteSpace: 'nowrap', minWidth: 120 }}
|
|
>
|
|
{t('admin.users.filters')}
|
|
</Button>
|
|
<Button
|
|
variant="text"
|
|
color="inherit"
|
|
onClick={clearFilters}
|
|
startIcon={<ClearRoundedIcon />}
|
|
disabled={activeFilters === 0 && !filters.search}
|
|
>
|
|
{t('admin.users.clear')}
|
|
</Button>
|
|
</Stack>
|
|
|
|
<Collapse in={filtersOpen}>
|
|
<Grid container spacing={1.5} sx={{ mt: 0.5 }}>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<FormControl fullWidth>
|
|
<InputLabel>{t('admin.users.filterLabels.role')}</InputLabel>
|
|
<Select
|
|
label={t('admin.users.filterLabels.role')}
|
|
value={filters.roleFilter}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, roleFilter: e.target.value as AdminUserFilters['roleFilter'] }));
|
|
}}
|
|
>
|
|
<MenuItem value="all">{t('common.all')}</MenuItem>
|
|
<MenuItem value="user">{t('admin.users.roles.user')}</MenuItem>
|
|
<MenuItem value="moderator">{t('admin.users.roles.moderator')}</MenuItem>
|
|
<MenuItem value="admin">{t('admin.users.roles.admin')}</MenuItem>
|
|
</Select>
|
|
</FormControl>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<FormControl fullWidth>
|
|
<InputLabel>{t('admin.users.filterLabels.accountStatus')}</InputLabel>
|
|
<Select
|
|
label={t('admin.users.filterLabels.accountStatus')}
|
|
value={filters.accountStatusFilter}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({
|
|
...f,
|
|
accountStatusFilter: e.target.value as AdminUserFilters['accountStatusFilter'],
|
|
}));
|
|
}}
|
|
>
|
|
<MenuItem value="all">{t('common.all')}</MenuItem>
|
|
<MenuItem value="active">{t('admin.users.accountStatus.active')}</MenuItem>
|
|
<MenuItem value="disabled">{t('admin.users.accountStatus.disabled')}</MenuItem>
|
|
<MenuItem value="suspended">{t('admin.users.accountStatus.suspended')}</MenuItem>
|
|
</Select>
|
|
</FormControl>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<FormControl fullWidth>
|
|
<InputLabel>{t('admin.users.filterLabels.emailVerified')}</InputLabel>
|
|
<Select
|
|
label={t('admin.users.filterLabels.emailVerified')}
|
|
value={filters.emailVerifiedFilter}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({
|
|
...f,
|
|
emailVerifiedFilter: e.target.value as AdminUserFilters['emailVerifiedFilter'],
|
|
}));
|
|
}}
|
|
>
|
|
<MenuItem value="all">{t('common.all')}</MenuItem>
|
|
<MenuItem value="yes">{t('admin.users.filterLabels.verified')}</MenuItem>
|
|
<MenuItem value="no">{t('admin.users.filterLabels.notVerified')}</MenuItem>
|
|
</Select>
|
|
</FormControl>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<FormControl fullWidth>
|
|
<InputLabel>{t('admin.users.filterLabels.receivedBonus')}</InputLabel>
|
|
<Select
|
|
label={t('admin.users.filterLabels.receivedBonus')}
|
|
value={filters.hasReceivedBonusFilter}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({
|
|
...f,
|
|
hasReceivedBonusFilter: e.target.value as AdminUserFilters['hasReceivedBonusFilter'],
|
|
}));
|
|
}}
|
|
>
|
|
<MenuItem value="all">{t('common.all')}</MenuItem>
|
|
<MenuItem value="yes">{t('admin.users.filterLabels.receivedBonusYes')}</MenuItem>
|
|
<MenuItem value="no">{t('admin.users.filterLabels.receivedBonusNo')}</MenuItem>
|
|
</Select>
|
|
</FormControl>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<CountryAutocomplete
|
|
label={t('admin.users.filterLabels.country')}
|
|
value={filters.countryFilter}
|
|
onChange={(code) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, countryFilter: code }));
|
|
}}
|
|
options={countryOptions}
|
|
loading={countriesQ.isLoading}
|
|
placeholder={t('admin.users.filterLabels.countryPlaceholder')}
|
|
/>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.filterLabels.inactiveSince')}
|
|
type="number"
|
|
value={filters.inactiveSinceDays}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, inactiveSinceDays: e.target.value }));
|
|
}}
|
|
placeholder={t('admin.users.filterLabels.inactivePlaceholder')}
|
|
/>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.filterLabels.minMainBalance')}
|
|
value={filters.minMainBalance}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, minMainBalance: e.target.value }));
|
|
}}
|
|
/>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.filterLabels.maxMainBalance')}
|
|
value={filters.maxMainBalance}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, maxMainBalance: e.target.value }));
|
|
}}
|
|
/>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.filterLabels.minBonusReceived')}
|
|
value={filters.minBonusReceived}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, minBonusReceived: e.target.value }));
|
|
}}
|
|
/>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.filterLabels.maxBonusReceived')}
|
|
value={filters.maxBonusReceived}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, maxBonusReceived: e.target.value }));
|
|
}}
|
|
/>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.filterLabels.minAge')}
|
|
type="number"
|
|
value={filters.minAge}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, minAge: e.target.value }));
|
|
}}
|
|
placeholder={t('admin.users.filterLabels.minAgePlaceholder')}
|
|
helperText={t('admin.users.filterLabels.minAgeHelper')}
|
|
slotProps={{ input: { inputProps: { min: 0, max: 150 } } }}
|
|
/>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.filterLabels.maxAge')}
|
|
type="number"
|
|
value={filters.maxAge}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, maxAge: e.target.value }));
|
|
}}
|
|
placeholder={t('admin.users.filterLabels.maxAgePlaceholder')}
|
|
helperText={t('admin.users.filterLabels.maxAgeHelper')}
|
|
slotProps={{ input: { inputProps: { min: 0, max: 150 } } }}
|
|
/>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.filterLabels.createdFrom')}
|
|
type="date"
|
|
value={filters.createdFrom}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, createdFrom: e.target.value }));
|
|
}}
|
|
slotProps={{ inputLabel: { shrink: true } }}
|
|
/>
|
|
</Grid>
|
|
<Grid size={{ xs: 12, sm: 6, md: 3 }}>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.filterLabels.createdTo')}
|
|
type="date"
|
|
value={filters.createdTo}
|
|
onChange={(e) => {
|
|
setPage(0);
|
|
setFilters((f) => ({ ...f, createdTo: e.target.value }));
|
|
}}
|
|
slotProps={{ inputLabel: { shrink: true } }}
|
|
/>
|
|
</Grid>
|
|
</Grid>
|
|
</Collapse>
|
|
|
|
<Stack direction="row" spacing={1} sx={{ mt: 1.5, alignItems: 'center', flexWrap: 'wrap' }}>
|
|
<Chip size="small" label={totalLabel} variant="outlined" />
|
|
{ageFilterLabel(t, filters.minAge, filters.maxAge) && (
|
|
<Chip
|
|
size="small"
|
|
label={ageFilterLabel(t, filters.minAge, filters.maxAge)!}
|
|
color="primary"
|
|
variant="outlined"
|
|
/>
|
|
)}
|
|
<Chip
|
|
size="small"
|
|
label={t('admin.users.filtersActive', { count: activeFilters })}
|
|
color={activeFilters ? 'primary' : 'default'}
|
|
variant={activeFilters ? 'filled' : 'outlined'}
|
|
/>
|
|
</Stack>
|
|
</Paper>
|
|
</Grid>
|
|
|
|
<Grid size={{ xs: 12 }}>
|
|
{q.isError ? (
|
|
<Alert severity="error" action={<Button color="inherit" size="small" onClick={() => q.refetch()}>{t('common.retry')}</Button>}>
|
|
{(q.error as { response?: { data?: { error?: string } }; message?: string })?.response?.data?.error ??
|
|
(q.error as Error)?.message ??
|
|
t('admin.users.loadError')}
|
|
</Alert>
|
|
) : isMobile ? (
|
|
<Stack spacing={1.5}>
|
|
{(q.isLoading ? (Array.from({ length: 6 }) as (AdminUser | undefined)[]) : users).map(
|
|
(u, idx) => (
|
|
<Card key={u?.id ?? idx}>
|
|
<CardContent>
|
|
{q.isLoading || !u ? (
|
|
<>
|
|
<Skeleton variant="text" width="60%" />
|
|
<Skeleton variant="text" width="80%" />
|
|
</>
|
|
) : (
|
|
<>
|
|
<Stack direction="row" spacing={1} sx={{ alignItems: 'center', flexWrap: 'wrap' }}>
|
|
<Typography sx={{ fontWeight: 800 }}>{u.email ?? '—'}</Typography>
|
|
<Chip size="small" label={u.account_status} color={statusColor(u.account_status)} />
|
|
<Chip
|
|
size="small"
|
|
label={u.role_name}
|
|
variant="outlined"
|
|
color={u.role_name === 'admin' ? 'primary' : 'default'}
|
|
onClick={() => openRoleDialog(u)}
|
|
sx={{ cursor: 'pointer' }}
|
|
/>
|
|
</Stack>
|
|
<Typography variant="body2" sx={{ opacity: 0.72, mt: 0.5 }}>
|
|
{t('admin.users.mobile.mainBonusPredictions', {
|
|
main: formatUsdt(u.main_balance_raw),
|
|
bonus: formatUsdt(u.bonus_balance_raw),
|
|
count: u.prediction_count,
|
|
})}
|
|
</Typography>
|
|
<Button
|
|
size="small"
|
|
variant="text"
|
|
sx={{ mt: 1 }}
|
|
onClick={() => setExpanded((prev) => ({ ...prev, [u.id]: !prev[u.id] }))}
|
|
startIcon={expanded[u.id] ? <ExpandLessRoundedIcon /> : <ExpandMoreRoundedIcon />}
|
|
>
|
|
{expanded[u.id] ? t('admin.users.mobile.hideFlags') : t('admin.users.mobile.showFlags')}
|
|
</Button>
|
|
<Collapse in={!!expanded[u.id]} unmountOnExit>
|
|
<Stack spacing={0.75} sx={{ mt: 1 }}>
|
|
<FlagRow label={t('admin.users.fields.isEnabled')} value={u.is_enabled} onChange={(v) => onToggle(u, 'isEnabled', v)} />
|
|
<FlagRow
|
|
label={t('admin.users.fields.withdrawalsSuspended')}
|
|
value={u.withdrawals_suspended}
|
|
onChange={(v) => onToggle(u, 'withdrawalsSuspended', v)}
|
|
/>
|
|
</Stack>
|
|
</Collapse>
|
|
</>
|
|
)}
|
|
</CardContent>
|
|
</Card>
|
|
))}
|
|
</Stack>
|
|
) : (
|
|
<Paper sx={{ borderRadius: 3, border: '1px solid rgba(255,255,255,0.08)', overflow: 'visible', backgroundImage: 'none', width: '100%', minWidth: 0 }}>
|
|
<Box ref={gridScrollRef} sx={{ width: '100%', maxWidth: '100%', overflowX: 'auto', overflowY: 'hidden', scrollbarGutter: 'stable' }}>
|
|
<DataGrid
|
|
apiRef={apiRef}
|
|
autoHeight
|
|
rows={users}
|
|
getRowId={(r) => r.id}
|
|
loading={q.isLoading}
|
|
rowCount={total}
|
|
checkboxSelection
|
|
rowSelectionModel={rowSelection}
|
|
onRowSelectionModelChange={setRowSelection}
|
|
keepNonExistentRowsSelected
|
|
pagination
|
|
paginationMode="server"
|
|
sortingMode="server"
|
|
paginationModel={{ page, pageSize: ROWS_PER_PAGE }}
|
|
onPaginationModelChange={(m) => setPage(m.page)}
|
|
sortModel={[{ field: orderBy, sort: order }]}
|
|
onSortModelChange={onGridSortChange}
|
|
columnVisibilityModel={columnVisibilityModel}
|
|
onColumnVisibilityModelChange={setColumnVisibilityModel}
|
|
columns={columns}
|
|
slots={{
|
|
toolbar: () => (
|
|
<UsersGridToolbar
|
|
onOpenDownload={(e) => setDownloadAnchorEl(e.currentTarget)}
|
|
exportLimitLabel={exportLimitLabel}
|
|
disabled={q.isLoading || (total === 0 && selectedIds.length === 0) || exporting}
|
|
selectedCount={selectedIds.length}
|
|
t={t}
|
|
/>
|
|
),
|
|
}}
|
|
sx={{
|
|
border: 0,
|
|
width: Math.max(gridContainerWidth, gridMinWidth || 1400),
|
|
'& .MuiDataGrid-filler': { display: 'none' },
|
|
'& .MuiDataGrid-scrollbarFiller': { display: 'none' },
|
|
'& .MuiDataGrid-toolbarContainer': { px: 1, py: 1, borderBottom: '1px solid rgba(255,255,255,0.08)' },
|
|
'& .MuiDataGrid-columnHeaders': { backgroundColor: 'rgba(255,255,255,0.03)' },
|
|
}}
|
|
/>
|
|
</Box>
|
|
</Paper>
|
|
)}
|
|
</Grid>
|
|
|
|
<Menu anchorEl={downloadAnchorEl} open={!!downloadAnchorEl} onClose={() => setDownloadAnchorEl(null)}>
|
|
<MenuItem
|
|
onClick={() => {
|
|
setDownloadAnchorEl(null);
|
|
try {
|
|
apiRef.current?.exportDataAsCsv?.();
|
|
setToast(t('admin.users.csvExported'));
|
|
} catch {
|
|
setToast(t('admin.users.csvExportFailed'));
|
|
}
|
|
}}
|
|
disabled={q.isLoading || total === 0}
|
|
>
|
|
{t('admin.users.export.csvCurrentPage')}
|
|
</MenuItem>
|
|
<MenuItem
|
|
onClick={() => {
|
|
setDownloadAnchorEl(null);
|
|
setExportSelectedOnly(false);
|
|
setExportDialogOpen(true);
|
|
}}
|
|
disabled={q.isLoading || total === 0 || exporting}
|
|
>
|
|
{t('admin.users.export.xlsxAllFiltered')}
|
|
</MenuItem>
|
|
{selectedIds.length > 0 && (
|
|
<MenuItem
|
|
onClick={() => {
|
|
setDownloadAnchorEl(null);
|
|
void exportXlsx(true);
|
|
}}
|
|
disabled={exporting}
|
|
>
|
|
{t('admin.users.export.xlsxSelected')}
|
|
</MenuItem>
|
|
)}
|
|
</Menu>
|
|
|
|
<Dialog open={exportDialogOpen} onClose={() => !exporting && setExportDialogOpen(false)} maxWidth="xs" fullWidth>
|
|
<DialogTitle>{t('admin.users.export.dialogTitle')}</DialogTitle>
|
|
<DialogContent>
|
|
<Stack direction="row" spacing={1} sx={{ mt: 0.5, alignItems: 'center' }}>
|
|
<Switch checked={exportVisibleOnly} onChange={(_, v) => setExportVisibleOnly(v)} />
|
|
<Typography variant="body2">{t('admin.users.export.visibleOnly')}</Typography>
|
|
<Typography variant="caption" sx={{ opacity: 0.7, display: 'block' }}>
|
|
<Trans i18nKey="admin.users.export.visibleOnlyHint" />
|
|
</Typography>
|
|
</Stack>
|
|
<TextField
|
|
sx={{ mt: 2 }}
|
|
fullWidth
|
|
label={t('admin.users.export.maxRows')}
|
|
type="number"
|
|
value={exportLimitInput}
|
|
onChange={(e) => setExportLimitInput(e.target.value)}
|
|
placeholder={t('admin.users.export.maxRowsPlaceholder')}
|
|
/>
|
|
<Typography variant="caption" sx={{ opacity: 0.7, mt: 1, display: 'block' }}>
|
|
{t('admin.users.export.matchingUsers', { label: totalLabel.replace(t('common.loading'), '…') })}
|
|
</Typography>
|
|
{exporting && exportProgress !== null && (
|
|
<Typography variant="caption" sx={{ mt: 1, display: 'block' }}>
|
|
{t('admin.users.export.inProgress', { count: exportProgress.toLocaleString() })}
|
|
</Typography>
|
|
)}
|
|
</DialogContent>
|
|
<DialogActions>
|
|
<Button onClick={() => setExportDialogOpen(false)} disabled={exporting}>{t('common.cancel')}</Button>
|
|
<Button
|
|
variant="contained"
|
|
disabled={exporting || total === 0}
|
|
onClick={async () => {
|
|
try {
|
|
localStorage.setItem('admin_users_export_limit', exportLimitInput);
|
|
localStorage.setItem('admin_users_export_visible_only', exportVisibleOnly ? 'true' : 'false');
|
|
} catch {
|
|
// ignore
|
|
}
|
|
await exportXlsx(exportSelectedOnly);
|
|
setExportDialogOpen(false);
|
|
}}
|
|
>
|
|
{exporting ? t('common.exporting') : t('admin.users.export.export')}
|
|
</Button>
|
|
</DialogActions>
|
|
</Dialog>
|
|
|
|
<Dialog open={!!batchDialog} onClose={() => setBatchDialog(null)} maxWidth="xs" fullWidth>
|
|
<DialogTitle>{batchLabel}</DialogTitle>
|
|
<DialogContent>
|
|
<Typography variant="body2" sx={{ mb: 1.5 }}>
|
|
<Trans i18nKey="admin.users.batch.applyTo" values={{ count: selectedIds.length }} />
|
|
</Typography>
|
|
{batchDialog === 'bonus' && (
|
|
<Stack spacing={1.5}>
|
|
<FormControl fullWidth>
|
|
<InputLabel>{t('common.type')}</InputLabel>
|
|
<Select
|
|
label={t('common.type')}
|
|
value={batchBonusForm.adjustmentType}
|
|
onChange={(e) =>
|
|
setBatchBonusForm((f) => ({
|
|
...f,
|
|
adjustmentType: e.target.value as 'bonus' | 'admin_adjustment',
|
|
}))
|
|
}
|
|
>
|
|
<MenuItem value="bonus">{t('admin.users.batch.bonusType')}</MenuItem>
|
|
<MenuItem value="admin_adjustment">{t('admin.users.batch.adminAdjustment')}</MenuItem>
|
|
</Select>
|
|
</FormControl>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.batch.amountUsdt')}
|
|
value={batchBonusForm.amountDisplay}
|
|
onChange={(e) => setBatchBonusForm((f) => ({ ...f, amountDisplay: e.target.value }))}
|
|
/>
|
|
<TextField
|
|
fullWidth
|
|
label={t('admin.users.batch.reason')}
|
|
multiline
|
|
minRows={2}
|
|
value={batchBonusForm.reason}
|
|
onChange={(e) => setBatchBonusForm((f) => ({ ...f, reason: e.target.value }))}
|
|
/>
|
|
</Stack>
|
|
)}
|
|
</DialogContent>
|
|
<DialogActions>
|
|
<Button onClick={() => setBatchDialog(null)} disabled={batchMut.isPending}>{t('common.cancel')}</Button>
|
|
<Button variant="contained" onClick={runBatch} disabled={batchMut.isPending}>
|
|
{t('common.confirm')}
|
|
</Button>
|
|
</DialogActions>
|
|
</Dialog>
|
|
|
|
<Dialog open={!!roleDialog} onClose={() => setRoleDialog(null)} maxWidth="xs" fullWidth>
|
|
<DialogTitle>{t('admin.users.roleDialog.title')}</DialogTitle>
|
|
<DialogContent>
|
|
<Typography variant="body2" sx={{ opacity: 0.75, mb: 2 }}>
|
|
{roleDialog?.email ?? roleDialog?.userId}
|
|
</Typography>
|
|
<FormGroup>
|
|
{ALL_ROLES.map((role) => (
|
|
<FormControlLabel
|
|
key={role}
|
|
control={
|
|
<Checkbox
|
|
checked={roleDraft.includes(role)}
|
|
onChange={(e) => {
|
|
setRoleDraft((prev) => {
|
|
if (e.target.checked) return [...new Set([...prev, role])];
|
|
const next = prev.filter((r) => r !== role);
|
|
return next.length ? next : ['user'];
|
|
});
|
|
}}
|
|
/>
|
|
}
|
|
label={t(`admin.users.roles.${role}` as 'admin.users.roles.user')}
|
|
/>
|
|
))}
|
|
</FormGroup>
|
|
</DialogContent>
|
|
<DialogActions>
|
|
<Button onClick={() => setRoleDialog(null)} disabled={roleMut.isPending}>
|
|
{t('common.cancel')}
|
|
</Button>
|
|
<Button
|
|
variant="contained"
|
|
disabled={
|
|
roleMut.isPending ||
|
|
JSON.stringify([...roleDraft].sort()) ===
|
|
JSON.stringify([...(roleDialog?.roles ?? [])].sort())
|
|
}
|
|
onClick={() => {
|
|
if (!roleDialog) return;
|
|
roleMut.mutate({ userId: roleDialog.userId, roles: roleDraft });
|
|
}}
|
|
>
|
|
{roleMut.isPending ? t('common.saving') : t('common.save')}
|
|
</Button>
|
|
</DialogActions>
|
|
</Dialog>
|
|
|
|
<Dialog open={!!confirm} onClose={() => setConfirm(null)} maxWidth="xs" fullWidth>
|
|
<DialogTitle>{t('admin.users.confirmDialog.title')}</DialogTitle>
|
|
<DialogContent>
|
|
<Typography>
|
|
<Trans
|
|
i18nKey="admin.users.confirmDialog.body"
|
|
values={{
|
|
field: confirm ? t(`admin.users.fields.${confirm.field}`) : '',
|
|
value: confirm?.next ? t('admin.users.confirmDialog.true') : t('admin.users.confirmDialog.false'),
|
|
}}
|
|
/>
|
|
</Typography>
|
|
<Typography variant="body2" sx={{ opacity: 0.75, mt: 1 }}>{confirm?.label}</Typography>
|
|
</DialogContent>
|
|
<DialogActions>
|
|
<Button onClick={() => setConfirm(null)}>{t('common.cancel')}</Button>
|
|
<Button variant="contained" onClick={applyToggle}>{t('common.confirm')}</Button>
|
|
</DialogActions>
|
|
</Dialog>
|
|
|
|
<Snackbar
|
|
open={!!toast}
|
|
autoHideDuration={2500}
|
|
onClose={() => setToast(null)}
|
|
message={toast ?? ''}
|
|
anchorOrigin={{ vertical: 'bottom', horizontal: 'center' }}
|
|
/>
|
|
</Grid>
|
|
);
|
|
}
|
|
|
|
function FlagRow({
|
|
label,
|
|
value,
|
|
onChange,
|
|
}: {
|
|
label: string;
|
|
value: boolean;
|
|
onChange: (v: boolean) => void;
|
|
}) {
|
|
return (
|
|
<Stack direction="row" sx={{ alignItems: 'center', justifyContent: 'space-between' }}>
|
|
<Typography variant="body2" sx={{ opacity: 0.85, fontWeight: 600 }}>{label}</Typography>
|
|
<Switch checked={value} onChange={(_, v) => onChange(v)} />
|
|
</Stack>
|
|
);
|
|
}
|