621 lines
21 KiB
TypeScript
621 lines
21 KiB
TypeScript
"use client";
|
|
|
|
import { useCallback, useEffect, useMemo, useState } from "react";
|
|
import { useTranslation } from "react-i18next";
|
|
import { toast } from "sonner";
|
|
|
|
import {
|
|
deleteOddsVersion,
|
|
getAdminPlayTypes,
|
|
getAllConfigVersions,
|
|
getOddsVersion,
|
|
getOddsVersions,
|
|
postOddsVersion,
|
|
publishOddsVersion,
|
|
putOddsItems,
|
|
} from "@/api/admin-config";
|
|
import { Button } from "@/components/ui/button";
|
|
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
|
|
import {
|
|
Dialog,
|
|
DialogContent,
|
|
DialogDescription,
|
|
DialogFooter,
|
|
DialogHeader,
|
|
DialogTitle,
|
|
} from "@/components/ui/dialog";
|
|
import { Input } from "@/components/ui/input";
|
|
import { Label } from "@/components/ui/label";
|
|
import { ConfigReadonlyValue } from "@/modules/config/config-readonly-value";
|
|
import { ConfigVersionActions } from "@/modules/config/config-version-actions";
|
|
import { ConfigVersionSwitcher } from "@/modules/config/config-version-switcher";
|
|
import { cn } from "@/lib/utils";
|
|
import { useAdminDateTimeFormatter } from "@/hooks/use-admin-datetime-formatter";
|
|
import { LotteryApiBizError } from "@/types/api/errors";
|
|
import type {
|
|
AdminPlayTypeRow,
|
|
ConfigVersionSummary,
|
|
OddsItemRow,
|
|
OddsVersionDetail,
|
|
} from "@/types/api/admin-config";
|
|
|
|
import {
|
|
PRIZE_SCOPE_LABELS,
|
|
PRIZE_SCOPE_MULTIPLIER_HINT,
|
|
PRIZE_SCOPE_ORDER,
|
|
type PrizeScopeCode,
|
|
} from "@/modules/config/doc/prize-scopes";
|
|
|
|
type CatTab = "all" | "d4" | "d3" | "d2" | "jackpot";
|
|
|
|
function oddsMultiplierLabel(oddsValue: number): string {
|
|
return (oddsValue / 10000).toFixed(4);
|
|
}
|
|
|
|
function filterTypes(tab: CatTab, types: AdminPlayTypeRow[]): AdminPlayTypeRow[] {
|
|
if (tab === "all") {
|
|
return types;
|
|
}
|
|
if (tab === "jackpot") {
|
|
return types.filter((t) => t.category.toLowerCase().includes("jackpot"));
|
|
}
|
|
const dim = tab === "d4" ? 4 : tab === "d3" ? 3 : 2;
|
|
return types.filter((t) => t.dimension === dim);
|
|
}
|
|
|
|
export function OddsConfigDocScreen() {
|
|
const { t } = useTranslation(["config", "adminUsers", "common"]);
|
|
const formatDt = useAdminDateTimeFormatter();
|
|
const [types, setTypes] = useState<AdminPlayTypeRow[]>([]);
|
|
const [list, setList] = useState<ConfigVersionSummary[]>([]);
|
|
const [selectedId, setSelectedId] = useState("");
|
|
const [detail, setDetail] = useState<OddsVersionDetail | null>(null);
|
|
const [draftRows, setDraftRows] = useState<OddsItemRow[]>([]);
|
|
const [loadingTypes, setLoadingTypes] = useState(true);
|
|
const [loadingList, setLoadingList] = useState(true);
|
|
const [loadingDetail, setLoadingDetail] = useState(false);
|
|
const [saving, setSaving] = useState(false);
|
|
const [error, setError] = useState<string | null>(null);
|
|
|
|
const [catTab, setCatTab] = useState<CatTab>("all");
|
|
/** User-selected play type. Empty means none selected yet and falls back to the first item in the category. */
|
|
const [playCode, setPlayCode] = useState<string>("");
|
|
|
|
const [rollbackOpen, setRollbackOpen] = useState(false);
|
|
const [rollbackTarget, setRollbackTarget] = useState<ConfigVersionSummary | null>(null);
|
|
const [publishConfirmOpen, setPublishConfirmOpen] = useState(false);
|
|
const [activeCompareRows, setActiveCompareRows] = useState<OddsItemRow[]>([]);
|
|
|
|
const refreshTypes = useCallback(async () => {
|
|
setLoadingTypes(true);
|
|
try {
|
|
const d = await getAdminPlayTypes();
|
|
setTypes(d.items);
|
|
} catch (e) {
|
|
toast.error(e instanceof LotteryApiBizError ? e.message : t("errors.loadFailed", { ns: "common" }));
|
|
setTypes([]);
|
|
} finally {
|
|
setLoadingTypes(false);
|
|
}
|
|
}, [t]);
|
|
|
|
const refreshList = useCallback(async () => {
|
|
setLoadingList(true);
|
|
setError(null);
|
|
try {
|
|
const d = await getAllConfigVersions(getOddsVersions);
|
|
setList(d.items);
|
|
} catch (e) {
|
|
const msg = e instanceof LotteryApiBizError ? e.message : t("errors.loadFailed", { ns: "common" });
|
|
setError(msg);
|
|
setList([]);
|
|
} finally {
|
|
setLoadingList(false);
|
|
}
|
|
}, [t]);
|
|
|
|
useEffect(() => {
|
|
queueMicrotask(() => {
|
|
void refreshTypes();
|
|
void refreshList();
|
|
});
|
|
}, [refreshTypes, refreshList]);
|
|
|
|
const loadDetail = useCallback(async (id: number) => {
|
|
setLoadingDetail(true);
|
|
try {
|
|
const d = await getOddsVersion(id);
|
|
setDetail(d);
|
|
setDraftRows(d.items.map((it) => ({ ...it })));
|
|
} catch (e) {
|
|
toast.error(e instanceof LotteryApiBizError ? e.message : t("errors.loadFailed", { ns: "common" }));
|
|
setDetail(null);
|
|
setDraftRows([]);
|
|
} finally {
|
|
setLoadingDetail(false);
|
|
}
|
|
}, [t]);
|
|
|
|
useEffect(() => {
|
|
if (list.length === 0 || selectedId !== "") {
|
|
return;
|
|
}
|
|
queueMicrotask(() => {
|
|
const drafts = list.filter((x) => x.status === "draft").sort((a, b) => b.id - a.id);
|
|
const active = list.find((x) => x.status === "active");
|
|
const pick = drafts[0] ?? active ?? [...list].sort((a, b) => b.id - a.id)[0];
|
|
if (pick) {
|
|
setSelectedId(String(pick.id));
|
|
}
|
|
});
|
|
}, [list, selectedId]);
|
|
|
|
useEffect(() => {
|
|
if (selectedId === "") {
|
|
return;
|
|
}
|
|
const id = Number(selectedId);
|
|
if (!Number.isFinite(id)) {
|
|
return;
|
|
}
|
|
queueMicrotask(() => {
|
|
void loadDetail(id);
|
|
});
|
|
}, [selectedId, loadDetail]);
|
|
|
|
const sortedTypes = useMemo(
|
|
() => [...types].sort((a, b) => a.sort_order - b.sort_order || a.play_code.localeCompare(b.play_code)),
|
|
[types],
|
|
);
|
|
|
|
const filteredTypes = useMemo(() => filterTypes(catTab, sortedTypes), [catTab, sortedTypes]);
|
|
|
|
const resolvedPlayCode = useMemo(() => {
|
|
if (filteredTypes.length === 0) {
|
|
return "";
|
|
}
|
|
if (playCode && filteredTypes.some((t) => t.play_code === playCode)) {
|
|
return playCode;
|
|
}
|
|
return filteredTypes[0].play_code;
|
|
}, [filteredTypes, playCode]);
|
|
|
|
const selectedVersionSummary = useMemo(
|
|
() => list.find((x) => String(x.id) === selectedId) ?? null,
|
|
[list, selectedId],
|
|
);
|
|
const isSelectedDetail = detail !== null && String(detail.id) === selectedId;
|
|
const selectedStatus = isSelectedDetail ? detail.status : selectedVersionSummary?.status;
|
|
const isDraft = selectedStatus === "draft";
|
|
|
|
const scopeRows = useMemo(() => {
|
|
const rows: Partial<Record<PrizeScopeCode, OddsItemRow>> = {};
|
|
if (!resolvedPlayCode) {
|
|
return rows;
|
|
}
|
|
for (const scope of PRIZE_SCOPE_ORDER) {
|
|
const hit = draftRows.find((r) => r.play_code === resolvedPlayCode && r.prize_scope === scope);
|
|
if (hit) {
|
|
rows[scope] = hit;
|
|
}
|
|
}
|
|
return rows;
|
|
}, [draftRows, resolvedPlayCode]);
|
|
|
|
const rebatePercentUi = useMemo(() => {
|
|
const first = PRIZE_SCOPE_ORDER.map((s) => scopeRows[s]).find(Boolean);
|
|
if (!first) {
|
|
return "0";
|
|
}
|
|
const n = Number.parseFloat(String(first.rebate_rate));
|
|
if (!Number.isFinite(n)) {
|
|
return "0";
|
|
}
|
|
return String(Math.round(n * 10000) / 100);
|
|
}, [scopeRows]);
|
|
|
|
function rowIndex(play_code: string, prize_scope: string): number {
|
|
return draftRows.findIndex((r) => r.play_code === play_code && r.prize_scope === prize_scope);
|
|
}
|
|
|
|
function updateOddsRow(idx: number, patch: Partial<OddsItemRow>) {
|
|
setDraftRows((prev) => prev.map((r, i) => (i === idx ? { ...r, ...patch } : r)));
|
|
}
|
|
|
|
function updateOddsForScope(scope: PrizeScopeCode, patch: Partial<OddsItemRow>) {
|
|
const idx = rowIndex(resolvedPlayCode, scope);
|
|
if (idx >= 0) {
|
|
updateOddsRow(idx, patch);
|
|
}
|
|
}
|
|
|
|
function setRebateForPlayPercent(percentStr: string) {
|
|
const p = Number.parseFloat(percentStr);
|
|
const rate = Number.isFinite(p) ? p / 100 : 0;
|
|
setDraftRows((prev) =>
|
|
prev.map((r) =>
|
|
r.play_code === resolvedPlayCode ? { ...r, rebate_rate: String(rate) } : r,
|
|
),
|
|
);
|
|
}
|
|
|
|
async function handleSave() {
|
|
if (!detail || !isDraft) {
|
|
return;
|
|
}
|
|
setSaving(true);
|
|
try {
|
|
const payload = draftRows.map((r) => ({
|
|
play_code: r.play_code,
|
|
prize_scope: r.prize_scope,
|
|
odds_value: r.odds_value,
|
|
rebate_rate: Number.parseFloat(String(r.rebate_rate)) || 0,
|
|
commission_rate: Number.parseFloat(String(r.commission_rate)) || 0,
|
|
currency_code: r.currency_code,
|
|
extra_config_json: r.extra_config_json,
|
|
}));
|
|
const d = await putOddsItems(detail.id, payload);
|
|
setDetail(d);
|
|
setDraftRows(d.items.map((it) => ({ ...it })));
|
|
toast.success(t("versionActions.saveDraft", { ns: "config" }));
|
|
void refreshList();
|
|
} catch (e) {
|
|
toast.error(e instanceof LotteryApiBizError ? e.message : t("wallet.saveFailed", { ns: "config" }));
|
|
} finally {
|
|
setSaving(false);
|
|
}
|
|
}
|
|
|
|
async function handlePublish() {
|
|
if (!detail || !isDraft) {
|
|
return;
|
|
}
|
|
setSaving(true);
|
|
try {
|
|
const d = await publishOddsVersion(detail.id);
|
|
setDetail(d);
|
|
setDraftRows(d.items.map((it) => ({ ...it })));
|
|
toast.success(t("versionActions.publishCurrent", { ns: "config" }));
|
|
void refreshList();
|
|
setSelectedId(String(d.id));
|
|
} catch (e) {
|
|
toast.error(e instanceof LotteryApiBizError ? e.message : "Publish failed");
|
|
} finally {
|
|
setSaving(false);
|
|
}
|
|
}
|
|
|
|
async function requestPublishConfirm() {
|
|
if (!detail || !isDraft) {
|
|
return;
|
|
}
|
|
const active = list.find((x) => x.status === "active");
|
|
if (active && active.id !== detail.id) {
|
|
try {
|
|
const d = await getOddsVersion(active.id);
|
|
setActiveCompareRows(d.items);
|
|
} catch {
|
|
setActiveCompareRows([]);
|
|
}
|
|
} else {
|
|
setActiveCompareRows([]);
|
|
}
|
|
setPublishConfirmOpen(true);
|
|
}
|
|
|
|
async function handleNewDraft() {
|
|
setSaving(true);
|
|
try {
|
|
const active = list.find((x) => x.status === "active");
|
|
const d = await postOddsVersion({
|
|
reason: `draft ${new Date().toISOString()}`,
|
|
clone_from_version_id: active?.id ?? null,
|
|
});
|
|
toast.success(`Created draft v${d.version_no}`);
|
|
await refreshList();
|
|
setSelectedId(String(d.id));
|
|
setDetail(d);
|
|
setDraftRows(d.items.map((it) => ({ ...it })));
|
|
} catch (e) {
|
|
toast.error(e instanceof LotteryApiBizError ? e.message : "Create draft failed");
|
|
} finally {
|
|
setSaving(false);
|
|
}
|
|
}
|
|
|
|
async function handleRollback() {
|
|
if (!rollbackTarget) {
|
|
return;
|
|
}
|
|
setSaving(true);
|
|
try {
|
|
const d = await postOddsVersion({
|
|
reason: `rollback from v${rollbackTarget.version_no}`,
|
|
clone_from_version_id: rollbackTarget.id,
|
|
});
|
|
toast.success(`Cloned v${rollbackTarget.version_no} into new draft v${d.version_no}`);
|
|
await refreshList();
|
|
setSelectedId(String(d.id));
|
|
setDetail(d);
|
|
setDraftRows(d.items.map((it) => ({ ...it })));
|
|
setRollbackOpen(false);
|
|
setRollbackTarget(null);
|
|
} catch (e) {
|
|
toast.error(e instanceof LotteryApiBizError ? e.message : "Rollback failed");
|
|
} finally {
|
|
setSaving(false);
|
|
}
|
|
}
|
|
|
|
const activeHead = list.find((x) => x.status === "active");
|
|
|
|
async function handleDeleteVersion(row: ConfigVersionSummary) {
|
|
try {
|
|
await deleteOddsVersion(row.id);
|
|
toast.success(t("versionSwitcher.delete", { ns: "config" }));
|
|
await refreshList();
|
|
} catch (e) {
|
|
toast.error(e instanceof LotteryApiBizError ? e.message : "Delete failed");
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
function requestRollback(row: ConfigVersionSummary) {
|
|
setRollbackTarget(row);
|
|
setRollbackOpen(true);
|
|
}
|
|
|
|
const publishDiffRows = useMemo(() => {
|
|
if (!detail) {
|
|
return [];
|
|
}
|
|
|
|
const selectedPlay = resolvedPlayCode;
|
|
|
|
return PRIZE_SCOPE_ORDER.map((scope) => {
|
|
const next = draftRows.find((r) => r.play_code === selectedPlay && r.prize_scope === scope);
|
|
const old = activeCompareRows.find((r) => r.play_code === selectedPlay && r.prize_scope === scope);
|
|
return {
|
|
scope,
|
|
label: PRIZE_SCOPE_LABELS[scope],
|
|
oldValue: old?.odds_value ?? null,
|
|
newValue: next?.odds_value ?? null,
|
|
};
|
|
});
|
|
}, [activeCompareRows, detail, draftRows, resolvedPlayCode]);
|
|
|
|
const catTabs: { id: CatTab; label: string }[] = [
|
|
{ id: "all", label: "All" },
|
|
{ id: "d4", label: "4D" },
|
|
{ id: "d3", label: "3D" },
|
|
{ id: "d2", label: "2D" },
|
|
{ id: "jackpot", label: "Jackpot" },
|
|
];
|
|
|
|
return (
|
|
<Card>
|
|
<CardHeader className="space-y-1">
|
|
<CardTitle className="text-lg">{t("nav.items.odds", { ns: "config" })}</CardTitle>
|
|
</CardHeader>
|
|
<CardContent className="space-y-6">
|
|
<div className="flex flex-wrap gap-2">
|
|
<span className="text-base text-muted-foreground self-center mr-2">Category</span>
|
|
{catTabs.map((t) => (
|
|
<Button
|
|
key={t.id}
|
|
type="button"
|
|
variant={catTab === t.id ? "default" : "outline"}
|
|
className={cn(catTab === t.id && "shadow-sm")}
|
|
onClick={() => setCatTab(t.id)}
|
|
>
|
|
{t.label}
|
|
</Button>
|
|
))}
|
|
</div>
|
|
|
|
<div className="space-y-2 min-h-[96px]">
|
|
<p className="text-base text-muted-foreground">Play Type</p>
|
|
<div className="flex flex-wrap gap-2 min-h-[44px]">
|
|
{filteredTypes.length === 0 ? (
|
|
<span className="text-base text-muted-foreground">No play types in this category.</span>
|
|
) : (
|
|
filteredTypes.map((t) => (
|
|
<Button
|
|
key={t.play_code}
|
|
type="button"
|
|
variant={resolvedPlayCode === t.play_code ? "secondary" : "outline"}
|
|
className={cn(
|
|
"h-9 border-slate-300 px-5 text-[18px] font-medium",
|
|
resolvedPlayCode === t.play_code
|
|
? "border-slate-950 bg-slate-950 text-white shadow-sm hover:bg-slate-900"
|
|
: "bg-white text-slate-900 hover:border-slate-400 hover:bg-slate-50",
|
|
)}
|
|
onClick={() => setPlayCode(t.play_code)}
|
|
>
|
|
{t.display_name_zh ?? t.play_code}
|
|
</Button>
|
|
))
|
|
)}
|
|
</div>
|
|
</div>
|
|
|
|
<div className="rounded-xl border bg-muted/20 p-3">
|
|
<div className="flex flex-col gap-3 lg:flex-row lg:items-end lg:justify-between">
|
|
<ConfigVersionSwitcher
|
|
versions={list}
|
|
selectedId={selectedId}
|
|
onSelectedIdChange={setSelectedId}
|
|
loading={loadingList}
|
|
sheetTitle={`${t("nav.items.odds", { ns: "config" })} ${t("versionSwitcher.sheetTitle", { ns: "config" })}`}
|
|
sheetDescription="Choose a version to view here. Non-draft versions can be rolled back into a new draft."
|
|
onDeleteVersion={handleDeleteVersion}
|
|
onRollbackVersion={requestRollback}
|
|
rollbackBusy={saving}
|
|
className="lg:flex-1"
|
|
/>
|
|
|
|
<ConfigVersionActions
|
|
isDraft={isDraft}
|
|
loadingList={loadingList}
|
|
loadingDetail={loadingDetail}
|
|
saving={saving}
|
|
onRefresh={() => void refreshList()}
|
|
onNewDraft={() => void handleNewDraft()}
|
|
onSaveDraft={() => void handleSave()}
|
|
onPublish={() => void requestPublishConfirm()}
|
|
/>
|
|
</div>
|
|
</div>
|
|
|
|
{detail ? (
|
|
<p className="text-sm text-muted-foreground">
|
|
Active version:
|
|
{activeHead ? (
|
|
<>
|
|
v{activeHead.version_no}
|
|
{activeHead.effective_at ? ` · ${formatDt(activeHead.effective_at)}` : ""}
|
|
</>
|
|
) : (
|
|
"—"
|
|
)}
|
|
{!isDraft ? (
|
|
<span className="text-amber-600 dark:text-amber-400"> - This version is read-only. Create a draft before editing odds.</span>
|
|
) : null}
|
|
</p>
|
|
) : null}
|
|
|
|
{error ? <p className="text-sm text-destructive">{error}</p> : null}
|
|
|
|
{loadingDetail || loadingTypes ? (
|
|
<div className="flex min-h-[420px] items-center">
|
|
<p className="text-base text-muted-foreground">Loading details…</p>
|
|
</div>
|
|
) : resolvedPlayCode ? (
|
|
<div className="grid min-h-[420px] gap-4 max-w-md">
|
|
{PRIZE_SCOPE_ORDER.map((scope) => {
|
|
const row = scopeRows[scope];
|
|
const hint = PRIZE_SCOPE_MULTIPLIER_HINT[scope];
|
|
const idx = row ? rowIndex(resolvedPlayCode, scope) : -1;
|
|
return (
|
|
<div key={scope} className="grid gap-1">
|
|
<Label className="flex items-baseline gap-2">
|
|
{PRIZE_SCOPE_LABELS[scope]}
|
|
{hint ? <span className="text-sm text-muted-foreground font-normal">{hint}</span> : null}
|
|
</Label>
|
|
{row && idx >= 0 ? (
|
|
<div className="flex flex-wrap items-center gap-2">
|
|
{isDraft ? (
|
|
<Input
|
|
type="text"
|
|
inputMode="numeric"
|
|
className="h-9 max-w-[200px] font-mono tabular-nums"
|
|
disabled={saving}
|
|
value={row.odds_value}
|
|
onChange={(e) =>
|
|
updateOddsForScope(scope, {
|
|
odds_value: Number.parseInt(e.target.value, 10) || 0,
|
|
})
|
|
}
|
|
/>
|
|
) : (
|
|
<ConfigReadonlyValue mono className="max-w-[200px]">
|
|
{row.odds_value}
|
|
</ConfigReadonlyValue>
|
|
)}
|
|
<span className="text-sm text-muted-foreground tabular-nums">
|
|
Multiplier x{oddsMultiplierLabel(row.odds_value)} · {row.currency_code}
|
|
</span>
|
|
</div>
|
|
) : (
|
|
<p className="text-sm text-destructive">Missing {scope} row. Check seed or version data.</p>
|
|
)}
|
|
</div>
|
|
);
|
|
})}
|
|
<div className="grid gap-1 pt-2 border-t">
|
|
<Label>Rebate Rate (%)</Label>
|
|
{isDraft ? (
|
|
<Input
|
|
type="text"
|
|
inputMode="decimal"
|
|
className="h-9 max-w-[200px] font-mono tabular-nums"
|
|
disabled={saving}
|
|
value={rebatePercentUi}
|
|
onChange={(e) => setRebateForPlayPercent(e.target.value)}
|
|
/>
|
|
) : (
|
|
<ConfigReadonlyValue mono className="max-w-[200px]">
|
|
{rebatePercentUi}
|
|
</ConfigReadonlyValue>
|
|
)}
|
|
<p className="text-sm text-muted-foreground">Writes rebate_rate to all prize scopes under this play type.</p>
|
|
</div>
|
|
</div>
|
|
) : null}
|
|
|
|
</CardContent>
|
|
|
|
<Dialog open={rollbackOpen} onOpenChange={setRollbackOpen}>
|
|
<DialogContent showCloseButton className="sm:max-w-md">
|
|
<DialogHeader>
|
|
<DialogTitle>Confirm rollback</DialogTitle>
|
|
<DialogDescription>
|
|
A new draft will be cloned from version v{rollbackTarget?.version_no}. The active version will not be overwritten directly.
|
|
</DialogDescription>
|
|
</DialogHeader>
|
|
<DialogFooter>
|
|
<Button type="button" variant="outline" onClick={() => setRollbackOpen(false)}>
|
|
{t("actions.cancel", { ns: "adminUsers" })}
|
|
</Button>
|
|
<Button type="button" onClick={() => void handleRollback()} disabled={!rollbackTarget || saving}>
|
|
Confirm rollback
|
|
</Button>
|
|
</DialogFooter>
|
|
</DialogContent>
|
|
</Dialog>
|
|
|
|
<Dialog open={publishConfirmOpen} onOpenChange={setPublishConfirmOpen}>
|
|
<DialogContent showCloseButton className="sm:max-w-lg">
|
|
<DialogHeader>
|
|
<DialogTitle>Publish odds version?</DialogTitle>
|
|
<DialogDescription>
|
|
New odds affect new tickets immediately. Existing successful tickets still settle by their saved odds snapshot.
|
|
</DialogDescription>
|
|
</DialogHeader>
|
|
<div className="rounded-lg border">
|
|
<div className="grid grid-cols-3 border-b bg-muted/40 px-3 py-2 text-sm font-medium">
|
|
<span>Prize Scope</span>
|
|
<span className="text-right">Current Active</span>
|
|
<span className="text-right">After Publish</span>
|
|
</div>
|
|
{publishDiffRows.map((row) => (
|
|
<div key={row.scope} className="grid grid-cols-3 px-3 py-2 text-sm">
|
|
<span>{row.label}</span>
|
|
<span className="text-right font-mono tabular-nums">
|
|
{row.oldValue === null ? "—" : row.oldValue}
|
|
</span>
|
|
<span className="text-right font-mono tabular-nums">{row.newValue ?? "—"}</span>
|
|
</div>
|
|
))}
|
|
</div>
|
|
<DialogFooter>
|
|
<Button type="button" variant="outline" onClick={() => setPublishConfirmOpen(false)}>
|
|
{t("actions.cancel", { ns: "adminUsers" })}
|
|
</Button>
|
|
<Button
|
|
type="button"
|
|
disabled={saving}
|
|
onClick={() => {
|
|
setPublishConfirmOpen(false);
|
|
void handlePublish();
|
|
}}
|
|
>
|
|
Confirm publish
|
|
</Button>
|
|
</DialogFooter>
|
|
</DialogContent>
|
|
</Dialog>
|
|
</Card>
|
|
);
|
|
}
|