Files
crawler-plugin/frontend-vue/src/pages/brand/components/BrandQueryAsinTab.vue
T

1186 lines
42 KiB
Vue
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<template>
<div class="page-shell module-page">
<AmazonToolPageShell tool-id="qasin">
<div class="main-content">
<aside class="left-panel">
<div class="section-title">店铺输入</div>
<div class="input-zone">
<div class="hint">
左侧负责录入店铺并加入备选区,确认匹配结果后启动任务。查询会按店铺逐个执行:上一个店铺查完会自动开始下一个,失败也会继续。
</div>
<div class="input-row">
<el-input
v-model="shopInput"
clearable
placeholder="请输入店铺名后回车或点击添加"
@keyup.enter="confirmAdd"
/>
<button
type="button"
class="opt-btn"
:disabled="adding"
@click="confirmAdd"
>
{{ adding ? "添加中..." : "添加" }}
</button>
</div>
</div>
<div class="section-title">备选区</div>
<div v-if="!candidates.length" class="empty-candidates">
暂无备选店铺,请先输入并添加
</div>
<div v-else class="candidate-table-scroll">
<el-table
ref="candidateTableRef"
:data="pagedCandidates"
row-key="id"
height="260"
class="candidate-table"
@selection-change="onSelectionChange"
>
<el-table-column type="selection" width="42" />
<el-table-column
prop="shop_name"
label="店铺名"
min-width="140"
show-overflow-tooltip
/>
<el-table-column label="操作" width="72" align="center">
<template #default="{ row }">
<button
type="button"
class="link-danger"
@click="removeCandidate(row.id)"
>
删除
</button>
</template>
</el-table-column>
</el-table>
</div>
<el-pagination
v-if="candidateTotal > candidatePageSize"
class="candidate-pagination"
layout="total, prev, pager, next"
:total="candidateTotal"
:page-size="candidatePageSize"
v-model:current-page="candidatePage"
/>
<div v-if="candidateSelectionNotice" class="loading-msg">{{ candidateSelectionNotice }}</div>
<div class="run-row">
<button
type="button"
class="btn-run"
:disabled="matching"
@click="runMatch"
>
{{ matching ? "匹配中..." : "匹配店铺" }}
</button>
<button
type="button"
class="btn-run btn-queue"
:disabled="isQueueBusy || !matchedRunnableItems.length"
@click="pushToPythonQueue"
>
{{ isQueueBusy ? "按顺序执行中..." : "启动任务" }}
</button>
</div>
<p class="loading-msg">
店铺会按顺序逐个查询:上一个店铺查完(无论成功或失败)都会自动开始下一个。如果中途网络异常,系统会自动恢复并继续处理。
</p>
<div v-if="queuePushResult" class="queue-debug-card">
<div class="section-title queue-debug-title">任务状态</div>
<div class="queue-debug-line">{{ queuePushResult }}</div>
<pre v-if="queuePayloadText" class="queue-debug-payload">{{
queuePayloadText
}}</pre>
</div>
</aside>
<section class="right-panel">
<TaskCenterPanel
:on-batch-delete="batchDeleteHistory"
:on-refresh="refreshBoard"
title="匹配与任务"
:cards="queryAsinCards"
:current-items="currentTaskViews"
:history-items="historyTaskViews"
current-empty-text="暂无当前任务。启动任务后,正在执行的任务会展示在这里,历史任务可在右上角「历史任务」中查看"
history-empty-text="暂无历史记录"
>
<template #cards-extra>
<div class="subsection-title">匹配结果</div>
<BrandShopMatchTable
v-model:page="matchedPage"
:items="pagedMatchedItems"
:total="matchedTotal"
:page-size="matchedPageSize"
:row-key="rowKeyForMatch"
:status-text="formatMatchStatus"
:remark-text="formatMatchRemark"
empty-text="完成“匹配店铺”后,这里会展示匹配结果。"
@remove="removeMatchedRow"
/>
</template>
<template #item-actions="{ item }">
<button type="button" class="btn-delete" @click="deleteTaskRecord(itemSource(item))">删除</button>
</template>
<template #history-item-actions="{ item }">
<button v-if="canDownload(itemSource(item))" type="button" class="download"
@click="downloadResult(itemSource(item))">下载结果</button>
<button type="button" class="btn-delete" @click="deleteTaskRecord(itemSource(item))">删除</button>
</template>
</TaskCenterPanel>
</section>
</div>
</AmazonToolPageShell>
</div>
</template>
<script setup lang="ts">
import { computed, nextTick, onMounted, onUnmounted, ref, watch } from "vue";
import { userNotice } from '@/shared/utils/user-notice'
import { ElMessage } from "element-plus";
import type { TableInstance } from "element-plus";
import AmazonToolPageShell from '@/pages/amazon/components/AmazonToolPageShell.vue';
import TaskCenterPanel from "@/shared/components/tasks/TaskCenterPanel.vue";
import BrandShopMatchTable from './BrandShopMatchTable.vue'
import {
formatMatchRemark,
formatMatchStatus,
historyItemKey,
isTransientBackendError,
rowKeyForMatch,
uidForStorage,
} from './brand-shop-match-shared'
import type { TaskItemView, TaskStatCard } from "@/shared/components/tasks/types";
import {
addQueryAsinCandidate,
createQueryAsinTask,
deleteQueryAsinCandidate,
deleteQueryAsinHistory,
deleteQueryAsinTask,
getQueryAsinDashboard,
getQueryAsinHistory,
getQueryAsinTaskProgressBatch,
getQueryAsinResultDownloadUrl,
listQueryAsinCandidates,
matchQueryAsinShops,
submitQueryAsinTaskResult,
type QueryAsinCandidateVo,
type QueryAsinCountryAsins,
type QueryAsinDashboardVo,
type QueryAsinHistoryItem,
type QueryAsinShopQueueItem,
type QueryAsinTaskItem,
} from "@/shared/api/java-modules";
import { getPywebviewApi } from "@/shared/bridges/pywebview";
import { getTaskPollIntervalMs } from "@/shared/task-progress-config";
import { createCategorizedTimers } from "@/shared/utils/categorized-timers";
import { saveUrlWithProgress } from "@/shared/utils/download-progress";
import { checkQueuePayload } from "@/shared/dispatch-guard";
import { passGuard } from "@/shared/dispatch-guard-ui";
import { formatDateTime } from '@/shared/utils/datetime'
import { RUNNING_UNTIL_DONE_STATUS_OPTIONS, taskStatusClass, taskStatusText } from '@/shared/utils/task-status-text'
import { useHistoryPolling } from '@/shared/composables/useHistoryPolling'
import { runBatchDelete } from '@/shared/utils/batch-delete'
import { isRecordMissingError, parseTaskStartTimes, removeTaskStartTime, upsertTaskStartTime } from '@/shared/utils/task-queue-state.ts'
import { useTablePaging } from '@/shared/composables/useTablePaging.ts'
import { getModuleProgressLight } from '@/shared/api/progress-light.ts'
import { createRowsVersionTracker } from '@/shared/api/task-progress-polling.ts'
import { liveProgress } from '@/shared/api/task-progress-live.ts'
import { confirmTaskDeletion } from '@/shared/task-delete-confirm';
import { TERMINAL_TASK_STATUSES, isTerminalTaskStatus, waitForTaskTerminal as waitForTaskTerminalShared } from '@/shared/utils/task-terminal'
import { dispatchedPruneNotice, mergeDispatchedArchive, pruneRows } from '@/shared/utils/dispatch-row-prune';
import {
parseRememberedNames,
reconcileRememberedNames,
selectableRows,
selectionMemoryKey,
selectionNotice,
} from '@/shared/utils/candidate-selection-memory';
const MAX_TRANSIENT_ERRORS = 30;
const shopInput = ref("");
const candidates = ref<QueryAsinCandidateVo[]>([]);
const selectedCandidates = ref<QueryAsinCandidateVo[]>([]);
const matchedItems = ref<QueryAsinShopQueueItem[]>([]);
// F9:匹配结果表分页(只切渲染窗口,不加选择语义)
const {
page: matchedPage,
pageSize: matchedPageSize,
total: matchedTotal,
paged: pagedMatchedItems,
} = useTablePaging(matchedItems)
// F9:备选店铺表同样只切渲染窗口(分页不改变数据源,勾选/删除语义不变)
const {
page: candidatePage,
pageSize: candidatePageSize,
total: candidateTotal,
paged: pagedCandidates,
} = useTablePaging(candidates)
// 勾选记忆:按 uid + 页签存店铺名,翻页与重载后自动恢复,不发任何请求
const candidateTableRef = ref<TableInstance | null>(null);
const rememberedCandidates = ref<string[]>([]);
const candidateSelectionNotice = ref("");
let restoringSelection = false;
const historyItems = ref<QueryAsinHistoryItem[]>([]);
const dashboard = ref<QueryAsinDashboardVo>({
candidateCount: 0,
processedTaskCount: 0,
successTaskCount: 0,
failedTaskCount: 0,
});
const adding = ref(false);
const matching = ref(false);
const pushing = ref(false);
const queuePushResult = ref("");
const queuePayloadText = ref("");
const pendingQueue = ref<QueryAsinShopQueueItem[]>([]);
// 已派发但历史卡片的 ASIN 明细仍要靠它回退(见 fallbackQueryAsinsForShop),所以只裁匹配表、不删数据
const dispatchedArchive = ref<QueryAsinShopQueueItem[]>([]);
const activeTaskId = ref<number | null>(null);
const activeQueueItem = ref<QueryAsinShopQueueItem | null>(null);
const queueWorkerRunning = ref(false);
const autoQueueEnabled = ref(false);
const taskStartTimes = ref<Record<number, string>>({});
const timers = createCategorizedTimers("query-asin");
const matchedRunnableItems = computed(() =>
matchedItems.value.filter((item) => item.matched && (item.queryAsins || []).some((row) => row.asins?.length)),
);
const currentSectionItems = computed(() =>
historyItems.value.filter((item) => !isTaskTerminal(item.taskStatus)),
);
const historySectionItems = computed(() =>
historyItems.value.filter((item) => isTaskTerminal(item.taskStatus)),
);
/** 统一统计卡:运行中任务按页面当前列表实时计算,其余沿用后端 dashboard */
const queryAsinCards = computed<TaskStatCard[]>(() => [
{ label: '运行中任务', value: currentSectionItems.value.length },
{ label: '已结束任务', value: dashboard.value.processedTaskCount },
{ label: '成功任务', value: dashboard.value.successTaskCount },
{ label: '失败任务', value: dashboard.value.failedTaskCount },
]);
const currentTaskViews = computed<TaskItemView[]>(() => currentSectionItems.value.map(toQueryAsinTaskView));
const historyTaskViews = computed<TaskItemView[]>(() => historySectionItems.value.map(toQueryAsinTaskView));
function itemSource(item: TaskItemView) {
return item.source as QueryAsinHistoryItem;
}
function toQueryAsinTaskView(item: QueryAsinHistoryItem): TaskItemView {
const startedRaw = taskStartTime(item.taskId);
return {
key: `qasin-${item.taskId ?? "r"}-${item.resultId ?? ""}-${item.shopName ?? ""}`,
title: item.shopName || "-",
taskId: item.taskId ?? "-",
startedAt: formatDateTime(startedRaw || item.createdAt),
finishedAt: item.finishedAt ? formatDateTime(item.finishedAt) : "进行中",
statusText: statusText(item.taskStatus),
statusClass: statusClass(item.taskStatus),
extraLines: [
...(item.resultId ? [`结果 ID: ${item.resultId}`] : []),
...(item.shopId ? [`店铺 ID: ${item.shopId}`] : []),
...(item.platform ? [`平台: ${item.platform}`] : []),
...(startedRaw && item.createdAt && startedRaw !== item.createdAt ? [`创建时间: ${formatDateTime(item.createdAt)}`] : []),
`ASIN结构: ${formatTemplateSummary(item)}`,
...(item.error ? [`错误: ${userNotice(item.error)}`] : []),
],
progress: liveProgress(Number(item.taskId)),
source: item,
};
}
const hasQueuedTaskWork = computed(
() =>
!!activeTaskId.value ||
pendingQueue.value.length > 0,
);
const hasQueueWork = computed(() => queueWorkerRunning.value || hasQueuedTaskWork.value);
const isQueueBusy = computed(() => queueWorkerRunning.value && hasQueuedTaskWork.value);
function matchedStorageKey() {
return `query-asin:matched:${uidForStorage()}`;
}
function queueStateStorageKey() {
return `query-asin:queue-state:${uidForStorage()}`;
}
function taskStartTimeStorageKey() {
return `query-asin:start-times:${uidForStorage()}`;
}
let disposed = false;
const historyPolling = useHistoryPolling({
timers,
isDisposed: () => disposed,
shouldPoll: () => hasQueueWork.value,
refresh: () => refreshActiveTaskProgress(),
})
function sleep(ms: number) {
if (disposed) return Promise.resolve();
return timers.sleep("queue-wait", ms);
}
function clearSleepTimers() {
timers.clearCategory("queue-wait");
}
async function withTransientRetry<T>(
action: () => Promise<T>,
onRetry?: (attempt: number, maxAttempts: number) => void,
maxAttempts = 20,
) {
let attempt = 0;
while (true) {
if (disposed) throw new Error("component disposed");
try {
return await action();
} catch (error) {
if (!isTransientBackendError(error) || attempt >= maxAttempts - 1) {
throw error;
}
attempt += 1;
onRetry?.(attempt, maxAttempts);
await sleep(getTaskPollIntervalMs());
}
}
}
function createSubmissionId(taskId: number, shopName?: string) {
return `query-asin:${taskId}:${shopName || "shop"}:${Date.now()}`;
}
function flattenQueryAsinRows(record: Pick<QueryAsinHistoryItem, "shopName" | "queryAsins">) {
const sections = readQueryAsins(record);
const rowCount = Math.max(...sections.map((section) => section.asins?.length || 0), 1);
return Array.from({ length: rowCount }, (_, rowIndex) => ({
shopName: rowIndex === 0 ? record.shopName : "",
countries: sections.map((section) => ({
country: section.country,
asin: section.asins?.[rowIndex] || "",
})),
}));
}
function formatTemplateSummary(record: Pick<QueryAsinHistoryItem, "shopName" | "queryAsins">) {
const sections = readQueryAsins(record);
const total = sections.reduce((sum, section) => sum + (section.asins?.length || 0), 0);
const countries = sections.filter((section) => section.asins?.length).map((section) => section.country).join("、");
return `${countries || "无国家"},共 ${total} 个 ASIN`;
}
function copyQueryAsins(items?: QueryAsinCountryAsins[]) {
return (items || [])
.map((item) => ({
country: (item.country || "").trim().toUpperCase(),
asins: Array.from(new Set((item.asins || []).map((asin) => (asin || "").trim().toUpperCase()).filter(Boolean))),
}))
.filter((item) => item.country && item.asins.length);
}
function readQueryAsins(record?: { queryAsins?: QueryAsinCountryAsins[]; query_asins?: QueryAsinCountryAsins[] } | null) {
return copyQueryAsins(record?.queryAsins?.length ? record.queryAsins : record?.query_asins);
}
function hasQueryAsins(item?: { queryAsins?: QueryAsinCountryAsins[]; query_asins?: QueryAsinCountryAsins[] } | null) {
return readQueryAsins(item).some((section) => section.asins.length);
}
function fallbackQueryAsinsForShop(shopName?: string) {
const normalizedShopName = (shopName || "").trim();
const candidates = [
activeQueueItem.value,
...pendingQueue.value,
...matchedItems.value,
...dispatchedArchive.value,
];
const exact = candidates.find((item) => (item?.shopName || "").trim() === normalizedShopName && hasQueryAsins(item));
return readQueryAsins(exact);
}
function withQueryAsinFallback<T extends QueryAsinHistoryItem | QueryAsinShopQueueItem>(
item: T,
fallback?: QueryAsinShopQueueItem | QueryAsinHistoryItem | null,
) {
// 已有 queryAsins 时直接返回原对象:本函数在每轮轮询里对全量历史调用,
// 无条件 { ...item } 会让下游历史抽屉的全部卡片因 props 变化而每轮重渲染
if (hasQueryAsins(item)) {
return item;
}
const fallbackAsins = readQueryAsins(fallback || undefined);
const resolved = fallbackAsins.length ? fallbackAsins : fallbackQueryAsinsForShop(item.shopName);
return {
...item,
queryAsins: resolved,
};
}
function isTaskTerminal(status?: string) {
return status === "SUCCESS" || status === "FAILED" || status === "COMPLETED";
}
function statusText(status?: string) {
return taskStatusText(status, RUNNING_UNTIL_DONE_STATUS_OPTIONS);
}
function statusClass(status?: string) {
return taskStatusClass(status, RUNNING_UNTIL_DONE_STATUS_OPTIONS);
}
function canDownload(item: QueryAsinHistoryItem) {
return Boolean(item.resultId && (item.fileReady || item.downloadUrl));
}
function saveMatchedItems() {
if (typeof window === "undefined") return;
window.localStorage.setItem(
matchedStorageKey(),
JSON.stringify(matchedItems.value),
);
}
function loadMatchedItems() {
try {
const raw =
typeof window !== "undefined"
? window.localStorage.getItem(matchedStorageKey())
: null;
matchedItems.value = raw ? JSON.parse(raw) : [];
} catch {
matchedItems.value = [];
}
}
function saveQueueState() {
if (typeof window === "undefined") return;
const payload = {
pendingQueue: pendingQueue.value,
dispatchedArchive: dispatchedArchive.value,
activeTaskId: activeTaskId.value,
activeQueueItem: activeQueueItem.value,
};
window.localStorage.setItem(queueStateStorageKey(), JSON.stringify(payload));
}
function saveTaskStartTimes() {
if (typeof window === "undefined") return;
if (!Object.keys(taskStartTimes.value).length) {
window.localStorage.removeItem(taskStartTimeStorageKey());
return;
}
window.localStorage.setItem(taskStartTimeStorageKey(), JSON.stringify(taskStartTimes.value));
}
function loadQueueState() {
try {
const raw =
typeof window !== "undefined"
? window.localStorage.getItem(queueStateStorageKey())
: null;
if (!raw) return;
const parsed = JSON.parse(raw) as {
pendingQueue?: QueryAsinShopQueueItem[];
dispatchedArchive?: QueryAsinShopQueueItem[];
activeTaskId?: number | null;
activeQueueItem?: QueryAsinShopQueueItem | null;
};
pendingQueue.value = parsed.pendingQueue || [];
dispatchedArchive.value = Array.isArray(parsed.dispatchedArchive)
? parsed.dispatchedArchive
: [];
activeTaskId.value = parsed.activeTaskId ?? null;
activeQueueItem.value = parsed.activeQueueItem ?? null;
} catch {
pendingQueue.value = [];
dispatchedArchive.value = [];
activeTaskId.value = null;
activeQueueItem.value = null;
}
}
function loadTaskStartTimes() {
try {
const raw =
typeof window !== "undefined"
? window.localStorage.getItem(taskStartTimeStorageKey())
: null;
taskStartTimes.value = parseTaskStartTimes(raw);
} catch {
taskStartTimes.value = {};
}
}
function setTaskStartTime(taskId: number, startedAt = new Date().toISOString()) {
if (!Number.isFinite(taskId) || taskId <= 0) return;
taskStartTimes.value = upsertTaskStartTime(taskStartTimes.value, taskId, startedAt);
saveTaskStartTimes();
}
function clearTaskStartTime(taskId?: number | null) {
if (!taskId || !(taskId in taskStartTimes.value)) return;
taskStartTimes.value = removeTaskStartTime(taskStartTimes.value, taskId);
saveTaskStartTimes();
}
function taskStartTime(taskId?: number | null) {
if (!taskId) return "";
return taskStartTimes.value[taskId] || "";
}
function clearActiveQueueTask() {
activeTaskId.value = null;
activeQueueItem.value = null;
saveQueueState();
}
function resetQueueWorkerIfIdle() {
if (hasQueuedTaskWork.value) {
return;
}
queueWorkerRunning.value = false;
pushing.value = false;
autoQueueEnabled.value = false;
historyPolling.stop();
saveQueueState();
}
function removeHistoryItemLocally(item: QueryAsinHistoryItem) {
historyItems.value = historyItems.value.filter((row) => {
if (item.resultId != null && row.resultId === item.resultId) return false;
if (item.taskId != null && row.taskId === item.taskId) return false;
return true;
});
}
function mergeQueueItems(
base: QueryAsinShopQueueItem[],
incoming: QueryAsinShopQueueItem[],
) {
const map = new Map<string, QueryAsinShopQueueItem>();
for (const item of base) map.set(rowKeyForMatch(item), item);
for (const item of incoming) map.set(rowKeyForMatch(item), item);
return Array.from(map.values());
}
async function loadCandidates() {
candidates.value = await listQueryAsinCandidates();
}
async function loadDashboard() {
dashboard.value = await getQueryAsinDashboard();
}
async function loadHistory() {
const data = await getQueryAsinHistory();
historyItems.value = (data.items || []).map((item) => withQueryAsinFallback(item));
}
/** 手动刷新:强拉历史 + 统计 + 活跃任务进度(轮询意外中断后的自救出口) */
async function refreshBoard() {
await refreshTaskViews()
await refreshActiveTaskProgress()
}
async function refreshTaskViews() {
await Promise.all([loadDashboard(), loadHistory()]);
}
function reconcileActiveQueueTaskWithHistory() {
if (!activeTaskId.value) {
resetQueueWorkerIfIdle();
return;
}
const exists = historyItems.value.some((item) => item.taskId === activeTaskId.value);
if (exists) {
return;
}
const missingTaskId = activeTaskId.value;
clearActiveQueueTask();
queuePushResult.value = pendingQueue.value.length
? `任务 ${missingTaskId} 已不存在,已跳过并继续剩余任务`
: "当前任务已不存在,已重置本地状态";
resetQueueWorkerIfIdle();
}
function mergeHistoryProgressItems(incoming: QueryAsinHistoryItem[]) {
if (!incoming.length) {
return;
}
const incomingMap = new Map(
incoming.map((item) => [historyItemKey(item), withQueryAsinFallback(item)] as const),
);
const merged = historyItems.value.map((item) => {
const next = incomingMap.get(historyItemKey(item));
if (!next) {
return withQueryAsinFallback(item);
}
const queryAsins = hasQueryAsins(next)
? readQueryAsins(next)
: readQueryAsins(item).length
? readQueryAsins(item)
: fallbackQueryAsinsForShop(next.shopName || item.shopName);
return {
...item,
...next,
queryAsins,
};
});
// 判重改 Set:此前 merged.some(...) 是 O(n×m),历史 500 条 × 每轮 20 条即 1 万次比较
const mergedKeys = new Set(merged.map(historyItemKey));
for (const item of incoming) {
const key = historyItemKey(item);
if (!mergedKeys.has(key)) {
merged.push(withQueryAsinFallback(item));
mergedKeys.add(key);
}
}
historyItems.value = merged;
}
/** 结果行版本跟踪:版本未变的任务不再拉取行明细(F5 后续) */
const rowsVersionTracker = createRowsVersionTracker()
async function refreshActiveTaskProgress(taskIds?: number[]) {
const ids = Array.from(
new Set(
(taskIds && taskIds.length
? taskIds
: currentSectionItems.value.map((item) => item.taskId ?? 0)
).filter((taskId) => Number.isFinite(taskId) && taskId > 0),
),
);
if (!ids.length) {
return;
}
// 行数据按需拉取(审查 F5 后续):先问轻量端点拿"结果行版本",版本未变的任务跳过重型 batch
let heavyIds = ids;
let missingIds: number[] = [];
try {
const light = await getModuleProgressLight('queryAsin', ids);
heavyIds = rowsVersionTracker.selectTasksNeedingRows(light.items || [], ids);
missingIds = light.missingTaskIds || [];
if (!heavyIds.length) {
if (missingIds.length) {
await loadHistory();
reconcileActiveQueueTaskWithHistory();
}
return;
}
} catch {
// 轻量端点不可用(老后端/网络)→ 照旧全量拉取,行为与原来一致
heavyIds = ids;
}
const batch = await getQueryAsinTaskProgressBatch(heavyIds);
missingIds = Array.from(new Set([...missingIds, ...(batch.missingTaskIds || [])]));
mergeHistoryProgressItems(batch.items || []);
if (missingIds.length) {
await loadHistory();
reconcileActiveQueueTaskWithHistory();
}
}
function candidateNameOf(row: QueryAsinCandidateVo) {
return row.shop_name || "";
}
function selectionMemoryStorageKey() {
return selectionMemoryKey(uidForStorage(), "query-asin");
}
function loadSelectionMemory() {
try {
const raw =
typeof window === "undefined"
? null
: window.localStorage.getItem(selectionMemoryStorageKey());
rememberedCandidates.value = parseRememberedNames(raw ? JSON.parse(raw) : []);
} catch {
rememberedCandidates.value = [];
}
}
function saveSelectionMemory() {
if (typeof window === "undefined") return;
try {
window.localStorage.setItem(
selectionMemoryStorageKey(),
JSON.stringify(rememberedCandidates.value),
);
} catch {
/* 配额满:记忆丢了不影响任务 */
}
}
async function restoreCandidateSelection() {
await nextTick();
const table = candidateTableRef.value;
if (!table) return;
const rows = selectableRows(pagedCandidates.value, rememberedCandidates.value, candidateNameOf);
if (!rows.length) {
candidateSelectionNotice.value = "";
return;
}
// 恢复期间的 selection-change 不回写记忆:半程重算会把还没勾上的名字抹掉
restoringSelection = true;
try {
for (const row of rows) table.toggleRowSelection(row, true);
} finally {
restoringSelection = false;
}
candidateSelectionNotice.value = selectionNotice(rows.length);
}
function onSelectionChange(rows: QueryAsinCandidateVo[]) {
selectedCandidates.value = rows;
if (restoringSelection) return;
rememberedCandidates.value = reconcileRememberedNames(
rememberedCandidates.value,
pagedCandidates.value.map(candidateNameOf),
rows.map(candidateNameOf),
);
saveSelectionMemory();
}
watch(pagedCandidates, () => {
void restoreCandidateSelection();
});
async function confirmAdd() {
const name = shopInput.value.trim();
if (!name) {
ElMessage.warning("请输入店铺名");
return;
}
adding.value = true;
try {
await addQueryAsinCandidate(name);
shopInput.value = "";
await Promise.all([loadCandidates(), loadDashboard()]);
ElMessage.success("已加入备选区");
} catch (error) {
ElMessage.error(error instanceof Error ? error.message : "添加失败");
} finally {
adding.value = false;
}
}
async function removeCandidate(id: number) {
try {
await deleteQueryAsinCandidate(id);
selectedCandidates.value = selectedCandidates.value.filter(
(item) => item.id !== id,
);
await Promise.all([loadCandidates(), loadDashboard()]);
ElMessage.success("已删除");
} catch (error) {
ElMessage.error(error instanceof Error ? error.message : "删除失败");
}
}
function mergeMatchedItems(
base: QueryAsinShopQueueItem[],
incoming: QueryAsinShopQueueItem[],
) {
const map = new Map<string, QueryAsinShopQueueItem>();
for (const item of base) map.set(rowKeyForMatch(item), item);
for (const item of incoming) map.set(rowKeyForMatch(item), item);
return Array.from(map.values());
}
async function runMatch() {
const names = selectedCandidates.value
.map((item) => item.shop_name)
.filter(Boolean);
if (!names.length) {
ElMessage.warning("请先勾选备选区店铺");
return;
}
matching.value = true;
try {
const data = await matchQueryAsinShops(names);
matchedItems.value = mergeMatchedItems(matchedItems.value, data.items || []);
saveMatchedItems();
ElMessage.success(`本次返回 ${data.items?.length || 0} 条匹配结果`);
} catch (error) {
ElMessage.error(error instanceof Error ? error.message : "匹配失败");
} finally {
matching.value = false;
}
}
function removeMatchedRow(row: QueryAsinShopQueueItem) {
if (hasQueueWork.value) {
ElMessage.warning("任务执行中,请等待当前任务结束后再调整");
return;
}
matchedItems.value = matchedItems.value.filter(
(item) => rowKeyForMatch(item) !== rowKeyForMatch(row),
);
saveMatchedItems();
}
function buildTaskItem(item: QueryAsinShopQueueItem): QueryAsinTaskItem {
return {
shopName: item.shopName,
matched: item.matched,
shopId: item.shopId,
platform: item.platform,
companyName: item.companyName,
matchStatus: item.matchStatus,
matchMessage: item.matchMessage,
queryAsins: copyQueryAsins(item.queryAsins),
};
}
function buildQueuePayload(taskId: number, item: QueryAsinHistoryItem) {
const submissionId = createSubmissionId(taskId, item.shopName);
return {
type: "query-asin-run",
ts: Date.now(),
data: {
taskId,
user_id: Number(uidForStorage()) || 0,
source: "frontend-vue-query-asin",
submissionId,
items: [
{
shopName: item.shopName,
submissionId,
shopId: item.shopId,
platform: item.platform,
companyName: item.companyName,
matched: item.matched,
matchStatus: item.matchStatus,
matchMessage: item.matchMessage,
queryAsins: copyQueryAsins(item.queryAsins),
},
],
query_asins: copyQueryAsins(item.queryAsins),
query_asin_rows: flattenQueryAsinRows(item),
},
};
}
function findHistoryItemByTaskId(taskId: number) {
return historyItems.value.find((item) => item.taskId === taskId);
}
async function waitForTaskTerminal(taskId: number) {
// 取数与文案留在本页,循环骨架(disposed / 瞬断预算 / 每轮 sleep / 非瞬断上抛)走共用实现
return waitForTaskTerminalShared({
taskId,
isDisposed: () => disposed,
pollStatus: async () => {
await refreshActiveTaskProgress([taskId]);
if (activeTaskId.value !== taskId) return "FAILED";
return findHistoryItemByTaskId(taskId)?.taskStatus || "";
},
onRecovered: () => {
queuePushResult.value = `任务 ${taskId} 服务已恢复,继续等待执行结果...`;
},
onTransient: (attempt, budget) => {
queuePushResult.value = `任务 ${taskId} 执行中,正在等待服务恢复(${attempt}/${budget})...`;
},
isTransient: isTransientBackendError,
intervalMs: getTaskPollIntervalMs,
sleep,
transientBudget: MAX_TRANSIENT_ERRORS,
});
}
async function processQueue() {
if (disposed || queueWorkerRunning.value) return;
queueWorkerRunning.value = true;
pushing.value = true;
historyPolling.start();
try {
const api = getPywebviewApi();
if (!api?.enqueue_json) {
throw new Error("当前客户端未提供 enqueue_json");
}
while (!disposed && (activeTaskId.value || pendingQueue.value.length)) {
if (activeTaskId.value) {
const finalStatus = await waitForTaskTerminal(activeTaskId.value);
queuePushResult.value =
pendingQueue.value.length > 0
? `任务 ${activeTaskId.value} ${finalStatus === "SUCCESS" ? "已完成" : "执行失败"},自动继续下一个(剩余 ${pendingQueue.value.length} 条)`
: `任务 ${activeTaskId.value} ${finalStatus === "SUCCESS" ? "已完成" : "执行失败"}`;
clearActiveQueueTask();
continue;
}
const nextItem = pendingQueue.value.shift();
saveQueueState();
if (!nextItem) break;
const created = await withTransientRetry(
() => createQueryAsinTask([buildTaskItem(nextItem)]),
(attempt, maxAttempts) => {
queuePushResult.value = `服务暂时不可用,正在重试创建任务(${attempt}/${maxAttempts})...`;
},
);
const createdItem = created.items?.[0]
? withQueryAsinFallback(created.items[0], nextItem)
: undefined;
if (!createdItem?.taskId || !createdItem.resultId) {
throw new Error("后端未返回有效任务标识");
}
activeTaskId.value = created.taskId;
activeQueueItem.value = withQueryAsinFallback(nextItem, createdItem);
saveQueueState();
await refreshTaskViews();
const payload = buildQueuePayload(created.taskId, createdItem);
queuePayloadText.value = JSON.stringify(payload, null, 2);
// 模板里一个有效 ASIN 都没解析出来时,Python 端拿到空列表会空转,任务停在执行中
const guard = checkQueuePayload(payload, {
expectedType: "query-asin-run",
requiredDataKeys: ["taskId"],
nonEmptyArrayKeys: ["items", "query_asins"],
});
if (!(await passGuard(guard))) {
await submitQueryAsinTaskResult(created.taskId, {
shops: [
{
shopName: createdItem.shopName || nextItem.shopName || "",
error: `任务 ${created.taskId} 数据校验未通过,已阻止启动`,
shopDone: true,
submissionId: createSubmissionId(
created.taskId,
createdItem.shopName || nextItem.shopName,
),
},
],
});
await refreshTaskViews();
queuePushResult.value = `任务 ${created.taskId} 数据校验未通过,已阻止启动并继续下一个任务`;
clearActiveQueueTask();
continue;
}
const pushResult = await api.enqueue_json(payload);
if (!pushResult?.success) {
await submitQueryAsinTaskResult(created.taskId, {
shops: [
{
shopName: createdItem.shopName || nextItem.shopName || "",
error: pushResult?.error || `任务 ${created.taskId} 启动失败`,
shopDone: true,
submissionId: createSubmissionId(
created.taskId,
createdItem.shopName || nextItem.shopName,
),
},
],
});
await refreshTaskViews();
queuePushResult.value = `任务 ${created.taskId} 启动失败,已自动继续下一个任务`;
clearActiveQueueTask();
continue;
}
setTaskStartTime(created.taskId);
queuePushResult.value =
pendingQueue.value.length > 0
? `任务 ${created.taskId} 已提交,等待完成后自动继续下一个(剩余 ${pendingQueue.value.length} 条)`
: `任务 ${created.taskId} 已提交,等待执行完成`;
}
queuePushResult.value = "任务已按顺序执行完成";
await refreshTaskViews();
ElMessage.success("查询ASIN队列已按顺序执行完成");
} catch (error) {
if (disposed) return;
const message = error instanceof Error ? error.message : "队列执行失败";
queuePushResult.value = message;
ElMessage.error(message);
await refreshTaskViews();
} finally {
queueWorkerRunning.value = false;
pushing.value = false;
historyPolling.stop();
saveQueueState();
}
}
async function pushToPythonQueue() {
autoQueueEnabled.value = true;
resetQueueWorkerIfIdle();
const runnable = matchedRunnableItems.value;
if (!runnable.length) {
ElMessage.warning("请先匹配可用店铺");
return;
}
const { remaining, removed } = pruneRows(matchedItems.value, runnable, rowKeyForMatch);
matchedItems.value = remaining;
saveMatchedItems();
dispatchedArchive.value = mergeDispatchedArchive(dispatchedArchive.value, removed, rowKeyForMatch);
pendingQueue.value = mergeQueueItems(pendingQueue.value, runnable);
saveQueueState();
queuePushResult.value = dispatchedPruneNotice(runnable.length, remaining.length);
await processQueue();
}
async function downloadResult(item: QueryAsinHistoryItem) {
if (!item.resultId) return;
const url = getQueryAsinResultDownloadUrl(item.resultId);
const filename = item.outputFilename || `${item.shopName || "result"}.xlsx`;
const result = await saveUrlWithProgress(url, filename, `query-asin:${item.resultId}`);
if (result.success) {
ElMessage.success(`已保存: ${result.path || filename}`);
} else if (result.error && result.error !== "用户取消") {
ElMessage.error(userNotice(result.error));
}
}
async function deleteTaskRecord(item: QueryAsinHistoryItem, opts: { skipConfirm?: boolean; silent?: boolean } = {}) {
if (!opts.skipConfirm && !(await confirmTaskDeletion(item))) return
try {
if (item.taskId) {
await deleteQueryAsinTask(item.taskId);
if (activeTaskId.value === item.taskId) {
clearActiveQueueTask();
}
clearTaskStartTime(item.taskId);
} else if (item.resultId) {
await deleteQueryAsinHistory(item.resultId);
clearTaskStartTime(item.taskId);
} else {
throw new Error("缺少可删除的任务标识");
}
if (opts.silent) return
await Promise.all([loadCandidates(), refreshTaskViews()]);
resetQueueWorkerIfIdle();
ElMessage.success("已删除");
} catch (error) {
if (isRecordMissingError(error)) {
if (item.taskId && activeTaskId.value === item.taskId) {
clearActiveQueueTask();
}
clearTaskStartTime(item.taskId);
removeHistoryItemLocally(item);
if (opts.silent) return
await loadCandidates();
resetQueueWorkerIfIdle();
ElMessage.success("记录已不存在,已同步移除本地记录");
return;
}
if (opts.silent) throw error
ElMessage.error(error instanceof Error ? error.message : "删除失败");
}
}
onMounted(async () => {
loadSelectionMemory();
loadMatchedItems();
loadQueueState();
loadTaskStartTimes();
await Promise.all([loadCandidates(), loadDashboard(), loadHistory()]);
reconcileActiveQueueTaskWithHistory();
if (activeTaskId.value || pendingQueue.value.length) {
autoQueueEnabled.value = true;
queuePushResult.value =
activeTaskId.value != null
? `检测到未完成队列,继续等待任务 ${activeTaskId.value} 完成并自动接续后续店铺`
: `检测到未完成队列,继续执行剩余 ${pendingQueue.value.length} 条店铺`;
void processQueue();
}
});
onUnmounted(() => {
disposed = true;
historyPolling.stop();
clearSleepTimers();
timers.clearScope();
});
/**
* 历史记录批量删除:复用单条删除逻辑(silent 模式逐条不弹框、不逐条刷新)。
* 批量入口已确认过一次,全部删完统一刷新一次、只报一次总数。
*/
async function batchDeleteHistory(views: TaskItemView[]) {
const { total, failed } = await runBatchDelete(views, (view) => deleteTaskRecord(itemSource(view), { skipConfirm: true, silent: true }))
if (!total) return
await Promise.allSettled([loadCandidates(), refreshTaskViews()])
resetQueueWorkerIfIdle();
if (failed > 0) {
ElMessage.warning(`删除完成:成功 ${total - failed} 条,失败 ${failed} 条`)
} else {
ElMessage.success(`已删除 ${total} 条历史记录`)
}
}
</script>
<style scoped>
.module-page { min-height: 100vh; background: #242424; }
.main-content { display: flex; min-height: calc(100vh - 56px); height: calc(100vh - 56px); }
.left-panel { width: 400px; background: #242424; padding: 20px; overflow-y: auto; border-right: 1px solid #2e3a52; }
.right-panel { flex: 1; display: flex; flex-direction: column; min-width: 0; background: #242424; }
.section-title { font-size: 13px; color: #a0acbe; margin-bottom: 10px; }
.input-zone { border: 1px dashed #3e4a62; border-radius: 10px; padding: 16px; background: #242424; margin-bottom: 20px; }
.hint { color: #5e6878; font-size: 12px; margin-bottom: 12px; line-height: 1.5; text-align: left; }
.input-row { display: flex; gap: 10px; align-items: center; }
.input-row :deep(.el-input) { flex: 1; }
.opt-btn { padding: 8px 12px; font-size: 12px; color: #c8d2e2; background: #242424; border: 1px solid #3e4a62; border-radius: 6px; cursor: pointer; white-space: nowrap; }
.opt-btn:hover:not(:disabled) { color: #3498db; border-color: #3498db; }
.opt-btn:disabled { opacity: 0.6; cursor: not-allowed; }
.empty-candidates { color: #5e6878; font-size: 13px; padding: 16px; border: 1px dashed #333; border-radius: 8px; margin-bottom: 16px; }
.candidate-table-scroll { max-height: 320px; overflow: auto; margin-bottom: 18px; border-radius: 8px; border: 1px solid #2e3a52; }
.candidate-table { --el-table-bg-color: #242424; --el-table-tr-bg-color: #242424; --el-table-header-bg-color: #2e3a52; --el-table-text-color: #c8d2e2; --el-table-border-color: #333; }
.link-danger { background: none; border: none; color: #e74c3c; cursor: pointer; font-size: 12px; padding: 0; }
.link-danger:hover { text-decoration: underline; }
.run-row { display: flex; flex-wrap: wrap; gap: 10px; margin-top: 8px; }
.btn-run { padding: 10px 18px; font-size: 14px; font-weight: 600; color: #f5f8fc; background: #3498db; border: none; border-radius: 8px; cursor: pointer; }
.btn-run:hover:not(:disabled) { background: #2980b9; }
.btn-run:disabled { opacity: 0.55; cursor: not-allowed; }
.btn-queue { background: #27ae60; }
.btn-queue:hover:not(:disabled) { background: #219a52; }
.loading-msg { margin-top: 12px; font-size: 12px; color: #5e6878; line-height: 1.5; }
.queue-debug-card { margin-top: 18px; padding: 14px; border: 1px solid #2e3a52; border-radius: 10px; background: #222b3d; }
.queue-debug-title { margin-bottom: 8px; }
.queue-debug-line { color: #a0acbe; font-size: 12px; line-height: 1.6; margin-bottom: 8px; }
.queue-debug-payload { margin: 0; max-height: 220px; overflow: auto; padding: 10px; border-radius: 8px; background: #10141f; color: #8fd3ff; font-size: 11px; line-height: 1.5; white-space: pre-wrap; word-break: break-all; }
.subsection-title { font-size: 13px; color: #a0acbe; margin: 8px 0 10px; }
.match-empty { color: #5e6878; font-size: 13px; padding: 12px 8px; margin-bottom: 12px; text-align: center; }
.match-table { margin-bottom: 18px; }
.match-table :deep(.el-table__body tr:hover > td.el-table__cell), .match-table :deep(.el-table__body tr.hover-row > td.el-table__cell), .match-table :deep(.el-table__body tr.current-row > td.el-table__cell) { background-color: var(--el-table-tr-bg-color, #242424) !important; }
.result-table { --el-table-bg-color: #242424; --el-table-tr-bg-color: #242424; --el-table-header-bg-color: #2e3a52; --el-table-text-color: #c8d2e2; --el-table-border-color: #333; }
.ok { color: #27ae60; }
.fail { color: #e67e22; }
.download { padding: 6px 10px; border-radius: 6px; font-size: 12px; background: rgba(52, 152, 219, 0.18); color: #69b6ff; border: none; cursor: pointer; }
.download:hover { background: rgba(52, 152, 219, 0.28); }
.btn-delete { padding: 6px 10px; border-radius: 6px; font-size: 12px; background: rgba(231, 76, 60, 0.12); color: #ff8f8f; border: none; cursor: pointer; }
.btn-delete:hover { background: rgba(231, 76, 60, 0.22); }
@media (max-width: 1100px) {
.main-content { flex-direction: column; height: auto; }
.left-panel { width: 100%; border-right: none; border-bottom: 1px solid #2e3a52; }
}
</style>