- add scenario upload and download UI with typed file API helpers - show run artifacts on run detail pages after polling completes - handle multipart uploads and absolute file paths for downloads
251 lines
7.3 KiB
TypeScript
251 lines
7.3 KiB
TypeScript
import { useCallback, useEffect, useRef, useState } from 'react';
|
|
import { useNavigate, useParams } from 'react-router-dom';
|
|
import { useTranslation } from 'react-i18next';
|
|
import { usePageTitle } from '../../hooks/usePageTitle';
|
|
import { Play, ClipboardList, Activity } from 'lucide-react';
|
|
import { environments, scenarios, runs } from '../../api';
|
|
import type { Environment, Scenario, ScenarioRun, ScenarioRunStatus } from '../../api';
|
|
import {
|
|
AutoRefreshIndicator,
|
|
Badge,
|
|
Breadcrumbs,
|
|
Button,
|
|
Modal,
|
|
Select,
|
|
Table,
|
|
Timestamp,
|
|
UuidBadge,
|
|
useToast,
|
|
type TableColumn,
|
|
type SortDirection,
|
|
} from '../../ui';
|
|
import type { BadgeVariant } from '../../ui';
|
|
import styles from '../Page.module.css';
|
|
|
|
const STATUS_VARIANT: Record<ScenarioRunStatus, BadgeVariant> = {
|
|
pending: 'neutral',
|
|
in_progress: 'info',
|
|
pass: 'success',
|
|
fail: 'error',
|
|
};
|
|
|
|
const STATUS_LABEL: Record<ScenarioRunStatus, string> = {
|
|
pending: 'Pending',
|
|
in_progress: 'Running',
|
|
pass: 'Pass',
|
|
fail: 'Fail',
|
|
};
|
|
|
|
type RunRow = ScenarioRun;
|
|
|
|
export function RunsPage() {
|
|
const { t } = useTranslation();
|
|
const { id } = useParams<{ id: string }>();
|
|
const navigate = useNavigate();
|
|
const toast = useToast();
|
|
|
|
const [scenario, setScenario] = useState<Scenario | null>(null);
|
|
const [items, setItems] = useState<RunRow[]>([]);
|
|
usePageTitle(scenario ? `${t('runs.title')} — ${scenario.name}` : t('runs.title'));
|
|
const [loading, setLoading] = useState(true);
|
|
const [error, setError] = useState<string | null>(null);
|
|
const [pulseKey, setPulseKey] = useState(0);
|
|
const [runModalOpen, setRunModalOpen] = useState(false);
|
|
const [running, setRunning] = useState(false);
|
|
const [envs, setEnvs] = useState<Environment[]>([]);
|
|
const [selectedEnvId, setSelectedEnvId] = useState('');
|
|
const pollRef = useRef<ReturnType<typeof setInterval> | null>(null);
|
|
const hasDataRef = useRef(false);
|
|
|
|
const [sortBy, setSortBy] = useState('createdAt');
|
|
const [sortDir, setSortDir] = useState<SortDirection>('desc');
|
|
const [page, setPage] = useState(1);
|
|
const [pageSize, setPageSize] = useState(20);
|
|
const [total, setTotal] = useState(0);
|
|
|
|
// Keep refs so the poll interval always reads current values
|
|
const sortByRef = useRef(sortBy);
|
|
const sortDirRef = useRef(sortDir);
|
|
const pageRef = useRef(page);
|
|
const pageSizeRef = useRef(pageSize);
|
|
sortByRef.current = sortBy;
|
|
sortDirRef.current = sortDir;
|
|
pageRef.current = page;
|
|
pageSizeRef.current = pageSize;
|
|
|
|
const load = useCallback(
|
|
(orderBy: string, orderDir: SortDirection, p: number, limit: number) => {
|
|
if (!id) return;
|
|
if (!hasDataRef.current) setLoading(true);
|
|
Promise.all([
|
|
scenarios.get(id!),
|
|
runs.list(id!, p, limit, orderBy, orderDir === 'asc' ? 'ASC' : 'DESC'),
|
|
])
|
|
.then(([sc, res]) => {
|
|
setScenario(sc);
|
|
setItems(res.data);
|
|
setTotal(res.total);
|
|
setError(null);
|
|
setPulseKey((k) => k + 1);
|
|
hasDataRef.current = true;
|
|
})
|
|
.catch((err: Error) => setError(err.message))
|
|
.finally(() => setLoading(false));
|
|
},
|
|
[id],
|
|
);
|
|
|
|
useEffect(() => {
|
|
load('createdAt', 'desc', 1, 20);
|
|
pollRef.current = setInterval(
|
|
() => load(sortByRef.current, sortDirRef.current, pageRef.current, pageSizeRef.current),
|
|
10_000,
|
|
);
|
|
return () => {
|
|
if (pollRef.current) clearInterval(pollRef.current);
|
|
};
|
|
}, [load]);
|
|
|
|
const handleSort = (key: string, dir: SortDirection) => {
|
|
setSortBy(key);
|
|
setSortDir(dir);
|
|
setPage(1);
|
|
load(key, dir, 1, pageSize);
|
|
};
|
|
|
|
const handlePageChange = (p: number) => {
|
|
setPage(p);
|
|
load(sortBy, sortDir, p, pageSize);
|
|
};
|
|
|
|
const handlePageSizeChange = (size: number) => {
|
|
setPageSize(size);
|
|
setPage(1);
|
|
load(sortBy, sortDir, 1, size);
|
|
};
|
|
|
|
useEffect(() => {
|
|
environments
|
|
.list(1, 200)
|
|
.then((res) => {
|
|
setEnvs(res.data);
|
|
setSelectedEnvId((prev) => prev || res.data[0]?.id || '');
|
|
})
|
|
.catch(() => {});
|
|
}, []);
|
|
|
|
const handleRun = async () => {
|
|
if (!selectedEnvId) {
|
|
toast.error(t('scenarios.run_modal_env_required'));
|
|
return;
|
|
}
|
|
setRunning(true);
|
|
try {
|
|
const run = await scenarios.run(id!, selectedEnvId);
|
|
toast.success(t('scenarios.run_started'));
|
|
navigate(`/scenarios/${id}/runs/${run.id}`);
|
|
setRunModalOpen(false);
|
|
} catch (err) {
|
|
toast.error((err as Error).message);
|
|
} finally {
|
|
setRunning(false);
|
|
}
|
|
};
|
|
|
|
const columns: TableColumn<RunRow>[] = [
|
|
{ key: 'id', header: t('runs.col_id'), render: (r) => <UuidBadge id={r.id} />, width: 60 },
|
|
{
|
|
key: 'status',
|
|
header: t('runs.col_status'),
|
|
width: 100,
|
|
sortable: true,
|
|
render: (r) => <Badge variant={STATUS_VARIANT[r.status]}>{STATUS_LABEL[r.status]}</Badge>,
|
|
},
|
|
{
|
|
key: 'createdAt',
|
|
header: t('runs.col_created'),
|
|
width: 160,
|
|
sortable: true,
|
|
render: (r) => <Timestamp value={r.createdAt} />,
|
|
},
|
|
];
|
|
|
|
return (
|
|
<div>
|
|
<div className={styles.pageToolbar}>
|
|
<Breadcrumbs
|
|
items={[
|
|
{
|
|
label: t('scenarios.title'),
|
|
icon: <ClipboardList size={14} />,
|
|
onClick: () => navigate('/scenarios'),
|
|
},
|
|
{
|
|
label: scenario?.name ?? `#${id}`,
|
|
onClick: () => navigate(`/scenarios/${id}`),
|
|
},
|
|
{ label: t('runs.title'), icon: <Activity size={14} /> },
|
|
]}
|
|
/>
|
|
<div className={styles.toolbarActions}>
|
|
<AutoRefreshIndicator
|
|
active
|
|
pulseKey={pulseKey}
|
|
error={!!error}
|
|
onClick={() => load(sortBy, sortDir, page, pageSize)}
|
|
/>
|
|
<Button size="sm" onClick={() => setRunModalOpen(true)}>
|
|
<Play size={14} />
|
|
{t('runs.action_run')}
|
|
</Button>
|
|
</div>
|
|
</div>
|
|
|
|
<Table
|
|
columns={columns}
|
|
data={items}
|
|
rowKey={(r) => r.id}
|
|
loading={loading}
|
|
emptyMessage={t('runs.empty')}
|
|
pageSize={pageSize}
|
|
pageSizeOptions={[10, 20, 50]}
|
|
onRowClick={(r) => navigate(`/scenarios/${id}/runs/${r.id}`)}
|
|
sortBy={sortBy}
|
|
sortDir={sortDir}
|
|
onSort={handleSort}
|
|
total={total}
|
|
page={page}
|
|
onPageChange={handlePageChange}
|
|
onPageSizeChange={handlePageSizeChange}
|
|
/>
|
|
|
|
<Modal
|
|
open={runModalOpen}
|
|
title={t('scenarios.run_modal_title')}
|
|
onClose={() => !running && setRunModalOpen(false)}
|
|
footer={
|
|
<>
|
|
<Button variant="secondary" onClick={() => setRunModalOpen(false)} disabled={running}>
|
|
{t('common.button_cancel')}
|
|
</Button>
|
|
<Button variant="primary" onClick={handleRun} disabled={running || !selectedEnvId}>
|
|
{t('runs.action_run')}
|
|
</Button>
|
|
</>
|
|
}
|
|
>
|
|
{envs.length === 0 ? (
|
|
<p>{t('scenarios.run_modal_no_env')}</p>
|
|
) : (
|
|
<Select
|
|
label={t('scenarios.run_modal_env_label')}
|
|
value={selectedEnvId}
|
|
onChange={(e) => setSelectedEnvId(e.target.value)}
|
|
options={envs.map((env) => ({ value: env.id, label: env.name }))}
|
|
/>
|
|
)}
|
|
</Modal>
|
|
</div>
|
|
);
|
|
}
|