feat(看板): 删净在跑店铺看板,进度文案对齐客户端,加国家列,默认筛「在跑」

- 店铺看板整条移除(面板/`/shops`/`shops()`/`TaskCenterShopVo`),汇总卡「在跑店铺」保留;
- 采集数据行进度改成客户端那句「关键词进度:第 N/总 个」(只改文字,数字口径与夹取不变),
  其余无进度条的模块仍显示「—」;
- 列表加「国家」列:值来自 request_json 的 7 条路径(线上实测顺序与覆盖 315/451=69.8%),
  按页内主键点查、不进列表 UNION,以免把大 JSON 列拉回已知慢查询;品牌行不发查询;
  只展示不筛选,无迁移;
- 状态默认「在跑」= PENDING∪RUNNING∪SCHEDULED,前端下发 ACTIVE 哨兵、只在服务层 statusFilter
  一处展开,成员与 ACTIVE_STATUS_SET/ACTIVE_STATUSES 同源钉死;
- 护栏:后端 task-center 77 例(新增状态 IN 渲染、7 路径顺序、归一两形态、品牌不查国家等)、
  前端 21 例;4 个变异点(路径顺序/哨兵不展开/归一截断/文案分支)全部被抓到并字节级还原。
This commit is contained in:
2026-10-04 12:48:18 +08:00
parent ea15cc58bf
commit 48aad3f2fd
14 changed files with 550 additions and 460 deletions
+3 -17
View File
@@ -1,7 +1,7 @@
import { http } from './http'
import { unwrap } from './envelope'
/** 客户端任务管理(后台看板):按店铺 × 账号 × 业务统一查看客户端在跑任务,全部只读。 */
/** 客户端任务管理(后台看板):按账号 × 店铺 × 业务统一查看客户端任务,全部只读。 */
/** 查询参数(由页面侧 buildTaskQuery / buildVariantQuery 产出,空白项不下传)。 */
type QueryParams = Record<string, string | number>
@@ -14,16 +14,6 @@ export interface TaskCenterOverview {
stuckTasks: number
}
/** 店铺面板行:一个店铺在当前所有进行中任务里的汇总;「不挂店铺」是兜住无店铺模块的合成桶。 */
export interface TaskCenterShop {
shop: string
noShop: boolean
runningTasks: number
stuckTasks: number
moduleSummary: string
lastReportAt: string | null
}
export interface TaskCenterTaskRow {
id: number
taskNo: string
@@ -37,6 +27,8 @@ export interface TaskCenterTaskRow {
webDevice: boolean
shopName: string | null
shopCount: number
/** 目标站点国家码(后端从 request_json 归一,多国家用 / 连);该模块不写国家时为 null。 */
country: string | null
createdAt: string | null
finishedAt: string | null
lastReportAt: string | null
@@ -92,12 +84,6 @@ export async function fetchTaskCenterOverview(): Promise<TaskCenterOverview> {
return unwrap<TaskCenterOverview>(data)
}
/** 店铺面板:当前全部进行中任务按店铺归组(与汇总卡的「在跑店铺」同源):GET /api/admin/task-center/shops */
export async function fetchTaskCenterShops(): Promise<TaskCenterShop[]> {
const { data } = await http.get('/api/admin/task-center/shops')
return unwrap<TaskCenterShop[]>(data)
}
/** 店铺筛选候选(店铺库内的店铺名,精确匹配):GET /api/admin/task-center/shop-options */
export async function fetchTaskCenterShopOptions(): Promise<string[]> {
const { data } = await http.get('/api/admin/task-center/shop-options')
@@ -95,8 +95,8 @@ export const OPERATION_GUIDES: Record<string, OperationGuideData> = {
steps: ['选择日期范围', '筛选用户或分组', '核对各模块次数'],
},
admin_task_center: {
text: '在跑店铺看板按店铺汇总当前进行中的客户端任务;点店铺行筛出该店铺任务,点任务查看明细。',
steps: ['看在跑店铺看板', '点店铺行筛任务', '打开任务详情'],
text: '按账号、业务、状态、店铺和创建时间筛出客户端任务,点任务查看明细与分组结果;顶部汇总卡给当前在跑与疑似卡住的总量。',
steps: ['按条件筛任务', '查看任务明细', '核对汇总卡'],
},
}
@@ -1,6 +1,6 @@
<script setup lang="ts">
/** 客户端任务管理看板:全局看板看「哪些店铺有任务在跑」,再下钻到任务明细(只读,仅超管或被授权管理员)。
* 页签一「客户端任务」= biz_file_task(12 个客户端模块)∪ brand_crawl_tasks,顶部是按店铺归组的在跑面板;
/** 客户端任务管理看板:全局看有哪些客户端任务在跑,再下钻到任务明细(只读,仅超管或被授权管理员)。
* 页签一「客户端任务」= biz_file_task(12 个客户端模块)∪ brand_crawl_tasks;
* 页签二「变体采集」= 麦象批量任务(variant-collection),数据口径与列不同故独立页签。
* 30s 轮询:页面隐藏暂停、回前台立即刷新、卸载清理;另有手动刷新。 */
import { computed, onMounted, onUnmounted, reactive, ref } from 'vue'
@@ -10,17 +10,16 @@ import { formatDateTime, todayDateTimeRange } from '@/utils/datetime'
import {
fetchTaskCenterOverview,
fetchTaskCenterShopOptions,
fetchTaskCenterShops,
fetchTaskCenterTaskDetail,
fetchTaskCenterTasks,
fetchTaskCenterVariantTasks,
type TaskCenterOverview,
type TaskCenterShop,
type TaskCenterTaskDetail,
type TaskCenterTaskRow,
type TaskCenterVariantTaskRow,
} from '@/api/task-center'
import {
ACTIVE_TASK_STATUS,
MODULE_OPTIONS,
TASK_STATUS_OPTIONS,
VARIANT_STATUS_OPTIONS,
@@ -50,14 +49,18 @@ const activeTab = ref<BoardTab>('tasks')
// ---------------------------------------------------------------- 客户端任务
const overview = ref<TaskCenterOverview | null>(null)
const shops = ref<TaskCenterShop[]>([])
const shopOptions = ref<string[]>([])
/** 首屏与「重置」都锁定当天;共享工厂 createTaskFilter 保持全空(它被单测与别处复用)。 */
function todayTaskRange(): Pick<TaskCenterTaskFilter, 'startTime' | 'endTime'> {
const [startTime, endTime] = todayDateTimeRange()
return { startTime, endTime }
}
const filter = reactive<TaskCenterTaskFilter>({ ...createTaskFilter(), ...todayTaskRange() })
/** 默认视图 = 今天 + 只看在跑(合并哨兵,后端展开成三个进行中状态);历史状态仍在下拉里可查。 */
function defaultTaskFilter(): TaskCenterTaskFilter {
return { ...createTaskFilter(), ...todayTaskRange(), status: ACTIVE_TASK_STATUS }
}
const filter = reactive<TaskCenterTaskFilter>(defaultTaskFilter())
const tasks = ref<TaskCenterTaskRow[]>([])
const taskTotal = ref(0)
const taskPage = ref(1)
@@ -89,15 +92,6 @@ const variantTotalPages = computed(() => Math.max(1, Math.ceil((variantTotal.val
* 列表 total(历史全量,且每天 00:00 的 7 天保留清理会往下掉)只用于分页,不上徽章。 */
const runningBadge = computed(() => tabCount(overview.value?.runningTasks))
/** 下拉候选 = 店铺库 + 面板上出现的店铺名(后者可能已从店铺库删掉,下钻要筛得动)。 */
const shopFilterOptions = computed(() => {
const names = new Set(shopOptions.value)
for (const row of shops.value) {
if (!row.noShop) names.add(row.shop)
}
return [...names]
})
function errorText(error: unknown, fallback: string): string {
return error instanceof Error && error.message ? error.message : fallback
}
@@ -110,14 +104,6 @@ async function loadOverview() {
}
}
async function loadShops() {
try {
shops.value = (await fetchTaskCenterShops()) || []
} catch (error) {
ElMessage.error(errorText(error, '在跑店铺加载失败'))
}
}
/** 店铺库下拉候选。 */
async function loadShopOptions() {
try {
@@ -156,11 +142,10 @@ async function loadVariants(silent = false) {
}
}
/** 汇总卡与在跑店铺面板只描述客户端任务,两个页签都刷新它们(切页签时看到的就是最新)。 */
/** 汇总卡与店铺候选只描述客户端任务,两个页签都刷新它们(切页签时看到的就是最新)。 */
async function refreshAll(silent = false) {
await Promise.all([
loadOverview(),
loadShops(),
loadShopOptions(),
activeTab.value === 'tasks' ? loadTasks(silent) : loadVariants(silent),
])
@@ -190,14 +175,7 @@ function search() {
}
function resetFilter() {
Object.assign(filter, createTaskFilter(), todayTaskRange())
taskPage.value = 1
void loadTasks()
}
/** 点店铺面板行:按该店铺精确筛选任务(再点一次取消);「不挂店铺」合成桶没有可下钻的店铺名。 */
function selectShop(shop: string) {
filter.shop = filter.shop === shop ? '' : shop
Object.assign(filter, defaultTaskFilter())
taskPage.value = 1
void loadTasks()
}
@@ -346,52 +324,10 @@ onUnmounted(() => {
<!-- ============ 页签一:客户端任务 ============ -->
<template v-if="activeTab === 'tasks'">
<section class="panel-box">
<div class="box-head">
<h3>在跑店铺看板</h3>
<span class="box-note">全局看每家店当前有哪些任务在跑,点店铺行筛出它的任务,不必逐台客户端检查</span>
</div>
<div v-if="shops.length" class="table-scroll">
<table>
<thead>
<tr>
<th style="width: 210px">店铺</th>
<th style="width: 90px">在跑任务</th>
<th style="width: 90px">疑似卡住</th>
<th style="width: 230px">业务分布</th>
<th style="width: 165px">最近上报</th>
</tr>
</thead>
<tbody>
<tr
v-for="row in shops"
:key="row.shop"
class="shop-row"
:class="{ 'is-bucket': row.noShop, active: !row.noShop && filter.shop === row.shop }"
@click="row.noShop ? null : selectShop(row.shop)"
>
<td>
<span class="strong">{{ row.shop }}</span>
<span v-if="row.noShop" class="sub">采集/货源/品牌这类任务不落店铺,按业务筛选查看</span>
</td>
<td>{{ row.runningTasks }}</td>
<td>
<span :class="{ 'is-warn-text': row.stuckTasks > 0 }">{{ row.stuckTasks }}</span>
</td>
<td>
<span class="scope" :title="row.moduleSummary">{{ row.moduleSummary || '—' }}</span>
</td>
<td>{{ row.lastReportAt ? formatDateTime(row.lastReportAt) : '—' }}</td>
</tr>
</tbody>
</table>
</div>
<div v-else class="empty-tip">暂无在跑店铺</div>
</section>
<section class="panel-box">
<div class="box-head">
<h3>任务筛选</h3>
<span class="box-note">默认只列今天的在跑任务(待执行/执行中/已排期算一个口径),看历史请换状态或放宽创建时间</span>
</div>
<div class="form-row">
<div class="form-group" style="min-width: 160px">
@@ -421,7 +357,7 @@ onUnmounted(() => {
style="width: 220px"
@change="search"
>
<el-option v-for="shop in shopFilterOptions" :key="shop" :label="shop" :value="shop" />
<el-option v-for="shop in shopOptions" :key="shop" :label="shop" :value="shop" />
</el-select>
<span class="filter-tip">精确匹配店铺名</span>
</div>
@@ -448,6 +384,7 @@ onUnmounted(() => {
<tr>
<th style="width: 120px">账号</th>
<th style="width: 160px">店铺</th>
<th style="width: 90px">国家</th>
<th style="width: 120px">业务</th>
<th style="width: 120px">状态</th>
<th style="width: 170px">任务ID</th>
@@ -464,6 +401,7 @@ onUnmounted(() => {
<span class="strong">{{ accountOf(row) }}</span>
</td>
<td>{{ shopDisplayName(row.shopName, row.shopCount) }}</td>
<td class="mono">{{ row.country || '—' }}</td>
<td>{{ row.moduleLabel || row.moduleType }}</td>
<td>
<span class="st-pill" :class="`is-${taskStatusType(row.status)}`">{{ taskStatusLabel(row.status) }}</span>
@@ -491,10 +429,10 @@ onUnmounted(() => {
</tr>
</template>
<tr v-else-if="tasksLoading">
<td colspan="9" class="empty-tip">加载中...</td>
<td colspan="10" class="empty-tip">加载中...</td>
</tr>
<tr v-else>
<td colspan="9" class="empty-tip">暂无符合条件的任务</td>
<td colspan="10" class="empty-tip">暂无符合条件的任务</td>
</tr>
</tbody>
</table>
@@ -768,20 +706,6 @@ h3 {
color: #8598ab;
font-size: 12.5px;
}
.shop-row {
cursor: pointer;
}
.shop-row:hover td {
background: #f2f8fd;
}
.shop-row.active td {
background: #eaf2fb;
}
.shop-row.is-bucket,
.shop-row.is-bucket:hover td {
cursor: default;
background: #fafcfe;
}
.is-warn-text {
color: #b3803a;
font-weight: 650;
@@ -923,13 +847,6 @@ td {
.cell-link:hover {
text-decoration: underline;
}
.scope {
display: inline-block;
max-width: 160px;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.res-mes {
display: block;
word-break: break-all;
@@ -44,8 +44,15 @@ export const MODULE_OPTIONS: Array<{ value: string; label: string }> = [
{ value: 'BRAND', label: '品牌检测' },
]
/**
* 「在跑」= 待执行 ∪ 执行中 ∪ 已排期 的合并哨兵(后端展开成 IN 列表),不是表里的状态值。
* 看板默认就用它:客户端任务的日常问题是「现在有什么在跑」,历史状态保留但不用来看。
*/
export const ACTIVE_TASK_STATUS = 'ACTIVE'
export const TASK_STATUS_OPTIONS: Array<{ value: string; label: string }> = [
{ value: '', label: '全部状态' },
{ value: ACTIVE_TASK_STATUS, label: '在跑' },
{ value: 'PENDING', label: '待执行' },
{ value: 'RUNNING', label: '执行中' },
{ value: 'SCHEDULED', label: '已排期' },
@@ -152,16 +159,23 @@ export interface TaskCenterProgress {
progressSuccess: number
progressFailed: number
progressTotal: number
moduleType?: string | null
}
function progressDone(row: TaskCenterProgress): number {
return Math.max(0, Number(row.progressSuccess || 0)) + Math.max(0, Number(row.progressFailed || 0))
}
/** 采集数据在客户端写的是「关键词进度:第 N/总 个」(N = 已处理 + 1,封顶总个数),
* 照抄口径而不是这里另造一套说法:见 frontend-vue BrandCollectDataTab.vue taskKeywordProgress。 */
export function progressText(row: TaskCenterProgress): string {
const total = Number(row.progressTotal || 0)
if (total <= 0) return '—'
return `已完成 ${progressDone(row)} / 总 ${total}`
const done = progressDone(row)
if ((row.moduleType || '').toUpperCase() === 'COLLECT_DATA') {
return `关键词进度:第 ${Math.min(total, done + 1)}/${total} 个`
}
return `已完成 ${done} / 总 ${total}`
}
export function progressPercent(row: TaskCenterProgress): number {
@@ -4,6 +4,7 @@ import { readSource } from './helpers.ts'
import { adminPages, validateAdminPages } from '../src/router/routes.ts'
import { operationGuideFor } from '../src/layout/operation-guides.ts'
import {
ACTIVE_TASK_STATUS,
MODULE_OPTIONS,
TASK_STATUS_OPTIONS,
VARIANT_STATUS_OPTIONS,
@@ -44,11 +45,10 @@ test('task_center_guide_present_for_menu_key', () => {
assert.equal(guide.steps.length, 3)
})
test('task_center_api_has_six_endpoints', () => {
test('task_center_api_has_five_endpoints', () => {
const api = readSource(API)
for (const path of [
'/api/admin/task-center/overview',
'/api/admin/task-center/shops',
'/api/admin/task-center/shop-options',
'/api/admin/task-center/tasks',
'/api/admin/task-center/tasks/detail',
@@ -58,7 +58,6 @@ test('task_center_api_has_six_endpoints', () => {
}
for (const fn of [
'fetchTaskCenterOverview',
'fetchTaskCenterShops',
'fetchTaskCenterShopOptions',
'fetchTaskCenterTasks',
'fetchTaskCenterTaskDetail',
@@ -166,6 +165,43 @@ test('task_center_progress_counts_done_rows_like_the_client', () => {
assert.equal(progressPercent({ progressSuccess: -5, progressFailed: 0, progressTotal: 10 }), 0, '脏负数不按负进度画')
})
/**
* 采集数据的进度文案逐字抄客户端(BrandCollectDataTab.vue taskKeywordProgress):
* 客户端从不显示「已完成 0 / 总 1」,看板这么写就会被读成任务卡在第 0 步。
* N = 已处理 + 1(下一个要处理的关键词),封顶总个数——跑完时客户端也停在「第 总/总 个」,不会跳到 总+1。
*/
test('task_center_collect_data_progress_wording_matches_the_client', () => {
assert.equal(
progressText({ progressSuccess: 0, progressFailed: 0, progressTotal: 1, moduleType: 'COLLECT_DATA' }),
'关键词进度:第 1/1 个',
)
assert.equal(
progressText({ progressSuccess: 1, progressFailed: 0, progressTotal: 2, moduleType: 'COLLECT_DATA' }),
'关键词进度:第 2/2 个',
'已处理 1/2 ⇒ 正在处理第 2 个,不是 50% 那种读法',
)
assert.equal(
progressText({ progressSuccess: 41, progressFailed: 0, progressTotal: 41, moduleType: 'COLLECT_DATA' }),
'关键词进度:第 41/41 个',
'跑完不溢出成 42/41',
)
assert.equal(
progressText({ progressSuccess: 3, progressFailed: 0, progressTotal: 10, moduleType: 'collect_data' }),
'关键词进度:第 4/10 个',
'大小写差异不放过(品牌任务状态就是小写)',
)
assert.equal(
progressText({ progressSuccess: 3, progressFailed: 0, progressTotal: 10, moduleType: 'PUBLISH' }),
'已完成 3 / 总 10',
'只有采集数据换文案,按文件数计进度的模块不动',
)
assert.equal(
progressText({ progressSuccess: 0, progressFailed: 0, progressTotal: 0, moduleType: 'COLLECT_DATA' }),
'—',
'客户端 total 不可用时也是空串,这边继续画「—」',
)
})
/**
* 后端把「客户端没有进度条」的模块(跟价/定时匹配)progressTotal 置 0 ⇒ 前端只画「—」:
* 留一条 0% 空进度轨会被读成「进度 0%」,和「这里没有进度可看」是两件事。
@@ -218,7 +254,6 @@ test('task_center_filter_reset_clears_every_field', () => {
test('task_center_page_handles_empty_and_error_states', () => {
const page = readSource(PAGE)
assert.match(page, /暂无符合条件的任务/, '任务空态')
assert.match(page, /暂无在跑店铺/, '店铺面板空态')
assert.match(page, /暂无在跑的变体采集任务/, '变体空态:口径是在跑不是全部')
assert.match(page, /ElMessage\.error/, '接口失败提示')
assert.match(page, /resetFilter/, '筛选重置接线')
@@ -226,16 +261,15 @@ test('task_center_page_handles_empty_and_error_states', () => {
assert.match(page, /@size-change="changeVariantSize"/, '变体分页每页条数切换')
})
test('task_center_shop_panel_is_the_board_and_drills_down_by_exact_shop', () => {
test('task_center_has_no_shop_panel_anymore', () => {
const page = readSource(PAGE)
assert.match(page, /在跑店铺看板/, '面板标题')
assert.match(page, /最近上报/, '面板与任务表都带最近上报')
assert.match(page, /row\.noShop \? null : selectShop\(row\.shop\)/, '点店铺行下钻,「不挂店铺」桶不可点')
assert.match(page, /不落店铺/, '桶行说明:这类任务本来就没有店铺维度')
assert.match(page, /shopFilterOptions/, '店铺下拉候选 = 店铺库 ∪ 面板出现的店铺')
assert.match(page, /fetchTaskCenterShops/, '面板取数')
assert.match(page, /fetchTaskCenterShopOptions/, '候选取数')
assert.match(page, /moduleSummary/, '业务分布列')
for (const gone of ['在跑店铺看板', 'selectShop', 'shopFilterOptions', 'fetchTaskCenterShops', 'moduleSummary']) {
assert.equal(page.includes(gone), false, `店铺看板已整条拆除,页面里不该再出现 ${gone}`)
}
assert.equal(readSource(API).includes('/api/admin/task-center/shops'), false, '接口层不留 /shops')
assert.match(page, /fetchTaskCenterShopOptions/, '店铺筛选候选仍要取数')
assert.match(page, /v-for="shop in shopOptions"/, '下拉候选就是店铺库本身,不再并入面板出现的店铺')
assert.match(page, /最近上报/, '任务表仍带最近上报')
assert.equal(page.includes('device-strip'), false, '设备卡条已删除')
})
@@ -260,8 +294,8 @@ test('task_center_task_list_columns_are_trimmed_to_the_data_that_exists', () =>
assert.equal(/<span class="sub">\{\{ row\.taskNo \}\}<\/span>/.test(page), false, '账号下方不再重复任务号')
assert.equal(/<th[^>]*>操作<\/th>/.test(page), false, '操作列已删')
assert.equal(page.includes('btn-sm'), false, '没有别的按钮后 btn-sm 样式一并撤掉')
assert.equal(/colspan="10"/.test(page), false, '任务表空态不再是 10 列')
assert.equal(page.match(/colspan="9"/g)?.length, 2, '加载中/空态两处收到 9 列')
assert.equal(page.match(/colspan="10"/g)?.length, 2, '加载中/空态两处 = 任务表 10 列(含国家)')
assert.equal(/colspan="9"/.test(page), false, '加国家列后空态不该还写 9 列')
assert.match(style, /\.shop-filter\s*\{[^}]*position: relative/, '店铺组是提示的定位父元素')
assert.match(style, /\.filter-tip\s*\{[^}]*position: absolute/, '提示绝对定位,不再撑高该组把 label 顶上去')
@@ -273,6 +307,41 @@ test('task_center_task_list_columns_are_trimmed_to_the_data_that_exists', () =>
)
})
test('task_center_country_column_is_display_only', () => {
const page = readSource(PAGE)
assert.match(page, /<th style="width: 90px">国家<\/th>/, '国家列在店铺与业务之间')
assert.match(page, /<td class="mono">\{\{ row\.country \|\| '—' \}\}<\/td>/,
'取不到国家画「—」:七条 JSON 路径只覆盖约七成行,留白会被读成数据缺失')
assert.equal(readSource(API).includes('country: string | null'), true, '接口类型带 country 且可为 null')
// 只加列,不做筛选(用户 2026-10-04 定案):不许冒出国家筛选或 country 查询参数
assert.equal(/filter\.country/.test(page), false, '没有国家筛选')
assert.equal('country' in buildTaskQuery({ ...createTaskFilter(), status: 'ACTIVE' }, 1, 20), false,
'查询参数不带 country')
})
/**
* 默认「在跑」(用户 2026-10-04 要求:其他状态保留,但默认看执行中的):
* ACTIVE 是三个进行中状态的合并哨兵,展开发生在后端,所以这里只钉
* ① 选项在位且排在「全部状态」之后,② 页面默认值与重置都走它,③ createTaskFilter 仍是全空
* (全空 = 不裁剪,是「重置到无筛选」语义的底座,页面默认值再覆盖上去)。
*/
test('task_center_defaults_to_the_merged_active_status', () => {
assert.equal(TASK_STATUS_OPTIONS[0].value, '', '首项仍是全部状态')
assert.equal(TASK_STATUS_OPTIONS[1].value, ACTIVE_TASK_STATUS, '第二项就是默认的在跑')
assert.deepEqual(TASK_STATUS_OPTIONS.map((o) => o.value),
['', 'ACTIVE', 'PENDING', 'RUNNING', 'SCHEDULED', 'SUCCESS', 'FAILED', 'CANCELLED'],
'七个状态一个不少(用户要求历史状态保留入口)')
assert.equal(buildTaskQuery({ ...createTaskFilter(), status: ACTIVE_TASK_STATUS }, 1, 20).status, 'ACTIVE',
'哨兵原样下传,展开在后端做')
assert.equal(createTaskFilter().status, '', 'createTaskFilter 保持全空')
const page = readSource(PAGE)
assert.match(page, /status: ACTIVE_TASK_STATUS/, '页面默认筛在跑')
assert.match(page, /Object\.assign\(filter, defaultTaskFilter\(\)\)/, '重置回到默认「在跑」而不是全部状态')
})
test('task_center_page_wires_tabs_filters_and_polling', () => {
const page = readSource(PAGE)
assert.match(page, /客户端任务/, '页签一文案')
@@ -6,7 +6,6 @@ import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskQuery;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterOverviewVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterShopVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskDetailVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskPageVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterVariantPageVo;
@@ -52,15 +51,6 @@ public class AdminTaskCenterController {
return ApiResponse.success(queryService.overview(scope));
}
@GetMapping("/shops")
@Operation(summary = "店铺面板",
description = "当前所有进行中任务按店铺归组:在跑任务数/疑似卡住数/业务分布/最近上报时间;"
+ "不落店铺的任务归进「不挂店铺」桶,与汇总卡的在跑店铺数同源。")
public ApiResponse<List<TaskCenterShopVo>> shops(HttpServletRequest request) {
TaskCenterScopeService.ScopeContext scope = resolveScope(request);
return ApiResponse.success(queryService.shops(scope));
}
@GetMapping("/shop-options")
@Operation(summary = "店铺筛选候选",
description = "店铺库(biz_shop_manage)在可见范围内的店铺名,供筛选下拉精确匹配;只出店铺名。")
@@ -1,6 +1,7 @@
package com.nanri.aiimage.modules.taskcenter.mapper;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCollectStatsRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCountryRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterDeviceRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopStatRow;
@@ -45,6 +46,15 @@ public interface TaskCenterQueryMapper {
*/
Set<String> ACTIVE_STATUS_SET = Set.of("PENDING", "RUNNING", "SCHEDULED");
/**
* {@link #ACTIVE_STATUS_SET} 的固定顺序版本:前端「在跑」筛选项就是这个集合的合并口径,
* 展开成 IN 列表后 SQL 文本要可断言({@code Set} 的迭代顺序不保证,不能直接下 SQL)。
*/
List<String> ACTIVE_STATUSES_ORDERED = List.of("PENDING", "RUNNING", "SCHEDULED");
/** 状态筛选的合并哨兵值:它不是表里的状态,服务层负责展开成 {@link #ACTIVE_STATUSES_ORDERED}。 */
String ACTIVE_STATUS_SENTINEL = "ACTIVE";
/** biz_file_task 终态(CANCELLED 与历史脏值 CANCELED 并存)。 */
Set<String> TERMINAL_STATUS_SET = Set.of("SUCCESS", "FAILED", "CANCELLED", "CANCELED");
@@ -190,10 +200,19 @@ public interface TaskCenterQueryMapper {
+ " WHERE f.task_id = t.id AND LOWER(TRIM(f.source_filename)) = LOWER(TRIM(#{shop}))))"
+ ")</if>";
/**
* 状态筛选:两组大写状态({@code statuses} 由服务层展开,「在跑」= PENDING/RUNNING/SCHEDULED)。
* 两张表都按归一化后的输出列比较,品牌表的小写状态在 {@code STATUS_B} 里已经 UPPER。
*/
String STATUSES_FILTER_T = "<if test='statuses != null'> AND " + STATUS_T + " IN"
+ " <foreach collection='statuses' item='st' open='(' separator=',' close=')'>#{st}</foreach></if>";
String STATUSES_FILTER_B = "<if test='statuses != null'> AND " + STATUS_B + " IN"
+ " <foreach collection='statuses' item='st' open='(' separator=',' close=')'>#{st}</foreach></if>";
/** biz_file_task 分支筛选(账号范围 + 业务/状态/时间范围 + 店铺)。 */
String TASK_FILTER_T = USER_SCOPE_T
+ "<if test='moduleType != null'> AND UPPER(t.module_type) = #{moduleType}</if>"
+ "<if test='status != null'> AND " + STATUS_T + " = #{status}</if>"
+ STATUSES_FILTER_T
+ "<if test='startTime != null'> AND t.created_at &gt;= #{startTime}</if>"
+ "<if test='endTime != null'> AND t.created_at &lt;= #{endTime}</if>"
+ SHOP_FILTER_T;
@@ -204,7 +223,7 @@ public interface TaskCenterQueryMapper {
*/
String TASK_FILTER_B = USER_SCOPE_B
+ "<if test='moduleType != null'> AND 'BRAND' = #{moduleType}</if>"
+ "<if test='status != null'> AND " + STATUS_B + " = #{status}</if>"
+ STATUSES_FILTER_B
+ "<if test='startTime != null'> AND b.created_at &gt;= #{startTime}</if>"
+ "<if test='endTime != null'> AND b.created_at &lt;= #{endTime}</if>"
+ "<if test='shop != null'> AND 1 = 0</if>";
@@ -244,7 +263,7 @@ public interface TaskCenterQueryMapper {
+ "</script>")
List<TaskCenterTaskRow> selectTaskPage(@Param("userIds") List<Long> userIds,
@Param("moduleType") String moduleType,
@Param("status") String status,
@Param("statuses") List<String> statuses,
@Param("shop") String shop,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime,
@@ -255,11 +274,11 @@ public interface TaskCenterQueryMapper {
+ "SELECT COUNT(*) FROM " + TASK_LIST_ROWS + " m"
+ "</script>")
long countTaskPage(@Param("userIds") List<Long> userIds,
@Param("moduleType") String moduleType,
@Param("status") String status,
@Param("shop") String shop,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
@Param("moduleType") String moduleType,
@Param("statuses") List<String> statuses,
@Param("shop") String shop,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/** 店铺面板的原料:当前全部进行中任务(超管口径下上限 500,截断由服务层显式提示)。 */
@Select("<script>"
@@ -345,6 +364,32 @@ public interface TaskCenterQueryMapper {
+ "</script>")
List<TaskCenterCollectStatsRow> selectCollectDataKeywordStats(@Param("taskIds") List<Long> taskIds);
/**
* 任务的目标国家:{@code biz_file_task} 没有国家列,只能按各模块在 {@code request_json}
* 里的写法取,七条路径与先后顺序 = 2026-10-04 生产实测(近 7 天 12 个模块 5 个能取到、70.7% 行有值),
* 换序就是另一套覆盖率,由 {@code countryPathsAreTheMeasuredSevenInOrder} 钉死。
*
* <p>只按页内任务号取(主键点查),不进列表主查询:那条 UNION 的护栏是不碰 {@code request_json}。
* 取到的是 JSON 原文,裸串 {@code DE} 与数组 {@code ["UK", "DE"]} 两种形状都由服务层归一化,
* SQL 不猜。品牌表没有国家,调用方按 {@code brand} 行筛掉。</p>
*/
String COUNTRY_PATHS = "COALESCE("
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.filters.countryCode')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.countryCode')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.country')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.publish_country')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.countryCodes')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.country_codes')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.filters.countryCodes')), ''), 'null')"
+ ")";
@Select("<script>"
+ "SELECT t.id AS taskId, " + COUNTRY_PATHS + " AS country"
+ " FROM biz_file_task t"
+ " WHERE t.id IN <foreach collection='taskIds' item='tid' open='(' separator=',' close=')'>#{tid}</foreach>"
+ "</script>")
List<TaskCenterCountryRow> selectTaskCountries(@Param("taskIds") List<Long> taskIds);
/** 详情:按任务号取单行(只认 12 个客户端模块,其余模块不在看板范围)。 */
@Select("SELECT t.id AS id, t.task_no AS taskNo, UPPER(t.module_type) AS moduleType,"
+ " " + STATUS_T + " AS status, t.user_id AS userId, t.device_id AS deviceId,"
@@ -0,0 +1,12 @@
package com.nanri.aiimage.modules.taskcenter.model.dto;
import lombok.Data;
/** 任务的目标国家行({@code request_json} 七条路径任一的原文),只按页内任务号点查。 */
@Data
public class TaskCenterCountryRow {
private Long taskId;
/** JSON 原文:可能是裸串({@code DE}),也可能是数组文本({@code ["UK", "DE"]});取不到为 null。 */
private String country;
}
@@ -1,28 +0,0 @@
package com.nanri.aiimage.modules.taskcenter.model.vo;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 店铺面板行:一个店铺在当前所有进行中任务里的汇总(点行下钻到该店铺的任务列表)。
*
* <p>「不挂店铺」是一行合成桶({@code noShop=true}):采集数据、货源查询、品牌检测这些模块
* 的任务不落店铺,但它们同样在跑,不能让它们在看板里消失。</p>
*/
@Data
public class TaskCenterShopVo {
/** 店铺名(沿用首次出现的写法);合成桶时为「不挂店铺」。 */
private String shop;
/** 是否为「不挂店铺」合成桶(不可下钻,按业务筛选看这些任务)。 */
private boolean noShop;
/** 该店铺进行中任务数(一个任务挂多个店铺时,在每个店铺下各计一次)。 */
private long runningTasks;
/** 其中疑似卡住数(进行中且超过 10 分钟无上报)。 */
private long stuckTasks;
/** 业务分布,如「跟价×2 / 定时匹配×1」。 */
private String moduleSummary;
/** 该店铺所有在跑任务里最近一次上报时间(心跳与结果回传都会顶新)。 */
private LocalDateTime lastReportAt;
}
@@ -24,6 +24,8 @@ public class TaskCenterTaskRowVo {
/** 店铺:主来源的第一个店铺名(多店铺时前端显示「共 N 个」);来源只有上架结果文件与逐店落行的结果文件名。 */
private String shopName;
private long shopCount;
/** 目标站点:{@code request_json} 里的国家码,多国家用 / 连接({@code UK/DE});该模块不写国家时为 null。 */
private String country;
private LocalDateTime createdAt;
private LocalDateTime finishedAt;
/** 最近一次上报(updated_at;心跳与结果回传都会顶新)。进行中且它超过 10 分钟即疑似卡住。 */
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.taskcenter.service;
import com.nanri.aiimage.common.module.TaskModuleRegistry;
import com.nanri.aiimage.modules.taskcenter.mapper.TaskCenterQueryMapper;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCollectStatsRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCountryRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterDeviceRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopStatRow;
@@ -12,7 +13,6 @@ import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterUserRow;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterOverviewVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterShopStatVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterShopVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskDetailVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskPageVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskRowVo;
@@ -23,26 +23,20 @@ import org.springframework.stereotype.Service;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
/**
* 客户端任务管理的只读查询,看板维度是<b>店铺</b>。
* 客户端任务管理的只读查询。
*
* <p>时间口径只有一个:进行中且 {@code updated_at} 超过 10 分钟没动 = 疑似卡住。
* {@code updated_at} 由客户端心跳(60s)与结果回传共同顶新,所以「在跑的任务必然在上报」
* 是这条判定的前提;设备维度不再参与统计(设备号只在详情里作为附注展示)。</p>
*
* <p>店铺面板与汇总卡共用 {@link #aggregateShops} 一份聚合,卡片说几家在跑、面板就列几行,
* 不允许两个数字各算各的。</p>
*/
@Service
@RequiredArgsConstructor
@@ -50,135 +44,56 @@ import java.util.stream.Collectors;
public class TaskCenterQueryService {
private static final long STUCK_IDLE_MINUTES = 10;
/** 面板原料的行数上界:进行中任务正常在几十量级,触顶时打 warn(汇总卡仍按 SQL 精确计数)。 */
private static final long SHOP_PANEL_TASK_CAP = 500;
/** 在跑店铺数原料的行数上界:进行中任务正常在几十量级,触顶时打 warn(数字会偏小)。 */
private static final long ACTIVE_TASK_SCAN_CAP = 500;
private static final long DEFAULT_PAGE_SIZE = 20;
private static final long MAX_PAGE_SIZE = 100;
/** 不落店铺的模块(采集数据、货源查询、品牌检测…)在面板里的合成桶,保证在跑任务不消失。 */
static final String NO_SHOP_LABEL = "不挂店铺";
/** 进行中状态与 mapper SQL 同源,避免「计数说在跑、卡住判定说不在跑」。 */
private static final Set<String> ACTIVE_STATUSES = TaskCenterQueryMapper.ACTIVE_STATUS_SET;
/** 面板排序:该去看谁的店排前面——有卡住的先,其次最久没上报的,「不挂店铺」桶永远垫底。 */
private static final Comparator<TaskCenterShopVo> SHOP_ROW_ORDER = Comparator
.comparing(TaskCenterShopVo::isNoShop)
.thenComparingLong(vo -> -vo.getStuckTasks())
.thenComparing(TaskCenterShopVo::getLastReportAt, Comparator.nullsLast(Comparator.naturalOrder()))
.thenComparing(TaskCenterShopVo::getShop);
private final TaskCenterQueryMapper queryMapper;
public TaskCenterOverviewVo overview(TaskCenterScopeService.ScopeContext scope) {
LocalDateTime now = LocalDateTime.now();
List<Long> userIds = scope.sqlUserIds();
ShopBoard board = aggregateShops(userIds, now);
TaskCenterOverviewVo vo = new TaskCenterOverviewVo();
vo.setShopTotal(queryMapper.countShops(userIds));
vo.setShopRunning(board.runningShops());
vo.setShopRunning(runningShops(userIds));
vo.setRunningTasks(queryMapper.countRunningTasks(userIds));
vo.setStuckTasks(queryMapper.countStuckTasks(userIds, now.minusMinutes(STUCK_IDLE_MINUTES)));
vo.setTodayFinishedTasks(queryMapper.countFinishedTasksSince(userIds, LocalDate.now().atStartOfDay()));
return vo;
}
/** 店铺面板:当前所有进行中任务按店铺归组(含「不挂店铺」桶)。 */
public List<TaskCenterShopVo> shops(TaskCenterScopeService.ScopeContext scope) {
return aggregateShops(scope.sqlUserIds(), LocalDateTime.now()).rows();
}
/** 店铺筛选下拉候选(店铺库内的店铺名,精确匹配用)。 */
public List<String> shopOptions(TaskCenterScopeService.ScopeContext scope) {
return safe(queryMapper.selectShopNames(scope.sqlUserIds()));
}
/** 店铺面板的聚合结果:行 + 其中真店铺数(不含合成桶)。 */
private record ShopBoard(List<TaskCenterShopVo> rows, long runningShops) {
private static final ShopBoard EMPTY = new ShopBoard(List.of(), 0);
}
private ShopBoard aggregateShops(List<Long> userIds, LocalDateTime now) {
List<TaskCenterTaskRow> rows = safe(queryMapper.selectActiveTasks(userIds, SHOP_PANEL_TASK_CAP));
if (rows.size() >= SHOP_PANEL_TASK_CAP) {
log.warn("task-center 店铺面板进行中任务数触顶, cap={}, 面板行数会少于汇总卡", SHOP_PANEL_TASK_CAP);
/**
* 汇总卡「在跑店铺」= 进行中任务挂到的去重店铺数。归组键走 {@link #shopKey} 规范化,
* 同一店两种写法算一家;不落店铺的任务(采集/货源/品牌…)没有店铺维度,天然不计入。
*
* <p>原料是 {@code selectActiveTasks} 的有界扫描,触顶时这个数字会偏小,按 warn 报出来,
* 不静默当成准确值。</p>
*/
private long runningShops(List<Long> userIds) {
List<TaskCenterTaskRow> rows = safe(queryMapper.selectActiveTasks(userIds, ACTIVE_TASK_SCAN_CAP));
if (rows.size() >= ACTIVE_TASK_SCAN_CAP) {
log.warn("task-center 进行中任务数触顶, cap={}, 在跑店铺数会偏小", ACTIVE_TASK_SCAN_CAP);
}
if (rows.isEmpty()) {
return ShopBoard.EMPTY;
}
List<Long> bizIds = rows.stream().filter(row -> !row.isBrand())
.map(TaskCenterTaskRow::getId).filter(Objects::nonNull).distinct().toList();
Map<Long, List<String>> shopsByTask = collectShops(bizIds);
Map<String, ShopAggregate> byShopKey = new LinkedHashMap<>();
Set<String> shopKeys = new HashSet<>();
for (TaskCenterTaskRow row : rows) {
List<String> rowShops = row.isBrand() ? List.of() : shopsByTask.get(row.getId());
if (rowShops == null || rowShops.isEmpty()) {
bucket(byShopKey, NO_SHOP_LABEL).accept(row, now);
continue;
}
for (String shop : rowShops) {
bucket(byShopKey, shop).accept(row, now);
for (String shop : shopsByTask.getOrDefault(row.getId(), List.of())) {
shopKeys.add(shopKey(shop));
}
}
List<TaskCenterShopVo> vos = new ArrayList<>(byShopKey.size());
for (ShopAggregate aggregate : byShopKey.values()) {
vos.add(aggregate.toVo());
}
vos.sort(SHOP_ROW_ORDER);
long runningShops = vos.stream().filter(vo -> !vo.isNoShop()).count();
return new ShopBoard(vos, runningShops);
}
/** 归组键走规范化(小写 + trim),展示名沿用首次出现的写法:同一店两种写法不拆成两行。 */
private static ShopAggregate bucket(Map<String, ShopAggregate> byShopKey, String shopName) {
return byShopKey.computeIfAbsent(shopKey(shopName), key -> new ShopAggregate(shopName.trim()));
}
/** 单个店铺的累计量(进行中任务可能挂多店,一个任务在它挂的每家店下各计一次)。 */
private static final class ShopAggregate {
private final String shop;
private long runningTasks;
private long stuckTasks;
private LocalDateTime lastReportAt;
private final Map<String, Long> modules = new HashMap<>();
private ShopAggregate(String shop) {
this.shop = shop;
this.lastReportAt = null;
}
private void accept(TaskCenterTaskRow row, LocalDateTime now) {
runningTasks++;
if (isStuck(row, now)) {
stuckTasks++;
}
LocalDateTime reportedAt = row.getUpdatedAt() == null ? row.getCreatedAt() : row.getUpdatedAt();
if (reportedAt != null && (lastReportAt == null || reportedAt.isAfter(lastReportAt))) {
lastReportAt = reportedAt;
}
modules.merge(TaskModuleRegistry.labelOf(row.getModuleType()), 1L, Long::sum);
}
private TaskCenterShopVo toVo() {
TaskCenterShopVo vo = new TaskCenterShopVo();
vo.setShop(shop);
vo.setNoShop(NO_SHOP_LABEL.equals(shop));
vo.setRunningTasks(runningTasks);
vo.setStuckTasks(stuckTasks);
vo.setLastReportAt(lastReportAt);
vo.setModuleSummary(modules.entrySet().stream()
.sorted(Map.Entry.<String, Long>comparingByValue(Comparator.reverseOrder())
.thenComparing(Map.Entry.comparingByKey()))
.map(entry -> entry.getKey() + "×" + entry.getValue())
.collect(Collectors.joining(" / ")));
return vo;
}
return shopKeys.size();
}
/** 任务列表:两表 UNION 分页 + 当页行的账号/店铺/进度装配(设备名只在详情装配)。 */
@@ -192,14 +107,15 @@ public class TaskCenterQueryService {
return TaskCenterTaskPageVo.empty(page, pageSize);
}
long total = queryMapper.countTaskPage(userIds, query.getModuleType(), query.getStatus(),
List<String> statuses = statusFilter(query.getStatus());
long total = queryMapper.countTaskPage(userIds, query.getModuleType(), statuses,
query.getShop(), query.getStartTime(), query.getEndTime());
if (total <= 0) {
return TaskCenterTaskPageVo.empty(page, pageSize);
}
List<TaskCenterTaskRow> rows = queryMapper.selectTaskPage(userIds, query.getModuleType(),
query.getStatus(), query.getShop(), query.getStartTime(), query.getEndTime(),
statuses, query.getShop(), query.getStartTime(), query.getEndTime(),
pageSize, (page - 1) * pageSize);
if (rows == null || rows.isEmpty()) {
return TaskCenterTaskPageVo.empty(page, pageSize);
@@ -213,6 +129,22 @@ public class TaskCenterQueryService {
return vo;
}
/**
* 状态筛选展开:空白 = 不裁剪;{@code ACTIVE} = 前端默认的「在跑」,等于三个进行中状态的合并
* (与判卡住用的 {@link #ACTIVE_STATUSES} 同一组,不另定口径);其余按单值下传。
* 品牌表状态本是小写,SQL 里 {@code STATUS_B} 已 UPPER 归一,这里只统一入参大小写。
*/
static List<String> statusFilter(String status) {
if (status == null || status.isBlank()) {
return null;
}
String key = status.trim().toUpperCase(Locale.ROOT);
if (TaskCenterQueryMapper.ACTIVE_STATUS_SENTINEL.equals(key)) {
return TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED;
}
return List.of(key);
}
/**
* 账号名 → 可见账号集合:超管用命中的全部账号,非超管与可见集合求交。
* 未传账号名时返回 {@code scope.sqlUserIds()}(超管为 null = 不裁剪)。
@@ -264,7 +196,7 @@ public class TaskCenterQueryService {
: selectCollectStats(List.of(row), snapshots);
TaskCenterTaskDetailVo vo = fillRow(new TaskCenterTaskDetailVo(), row, usernames, deviceNames,
snapshots, collectStats, collectShops(bizIds), LocalDateTime.now());
snapshots, collectStats, collectShops(bizIds), collectCountries(bizIds), LocalDateTime.now());
vo.setShops(shopStats(row));
vo.setErrorMessage(row.getErrorMessage());
return vo;
@@ -316,12 +248,13 @@ public class TaskCenterQueryService {
: toSnapshots(safe(queryMapper.selectSnapshots(rowIds)));
Map<Long, TaskCenterCollectStatsRow> collectStats = selectCollectStats(rows, snapshots);
Map<Long, List<String>> shops = collectShops(bizIds);
Map<Long, String> countries = collectCountries(bizIds);
LocalDateTime now = LocalDateTime.now();
List<TaskCenterTaskRowVo> items = new ArrayList<>(rows.size());
for (TaskCenterTaskRow row : rows) {
items.add(fillRow(new TaskCenterTaskRowVo(), row, usernames, Map.of(), snapshots,
collectStats, shops, now));
collectStats, shops, countries, now));
}
return items;
}
@@ -397,6 +330,41 @@ public class TaskCenterQueryService {
}
}
/**
* 目标国家:按页内 biz 任务号点查 {@code request_json}(列表主查询不碰大 JSON 列),
* 品牌表与该模块没写国家的任务都不在结果里,前端画「—」。
*/
private Map<Long, String> collectCountries(List<Long> bizIds) {
if (bizIds.isEmpty()) {
return Map.of();
}
Map<Long, String> countries = new HashMap<>();
for (TaskCenterCountryRow row : safe(queryMapper.selectTaskCountries(bizIds))) {
String country = normalizeCountry(row.getCountry());
if (row.getTaskId() != null && country != null) {
countries.put(row.getTaskId(), country);
}
}
return countries;
}
/**
* 国家原文两种形状并存(生产实测:裸串 {@code UK} 与数组文本 {@code ["UK", "DE"]},
* 同一模块两种写法都有),归一为 {@code UK} / {@code UK/DE};取不到返回 null,不猜。
*/
static String normalizeCountry(String raw) {
if (raw == null || raw.isBlank()) {
return null;
}
List<String> codes = new ArrayList<>();
for (String token : raw.replaceAll("[\\[\"\\]\\s]", "").split(",")) {
if (!token.isBlank() && !"null".equals(token)) {
codes.add(token);
}
}
return codes.isEmpty() ? null : String.join("/", codes);
}
/** 列表行与详情行共用同一套装配口径(详情只是多带分组明细与错误信息)。 */
private <T extends TaskCenterTaskRowVo> T fillRow(T vo,
TaskCenterTaskRow row,
@@ -405,6 +373,7 @@ public class TaskCenterQueryService {
Map<String, TaskCenterSnapshotRow> snapshots,
Map<Long, TaskCenterCollectStatsRow> collectStats,
Map<Long, List<String>> shops,
Map<Long, String> countries,
LocalDateTime now) {
vo.setId(row.getId());
vo.setTaskNo(row.getTaskNo());
@@ -434,6 +403,8 @@ public class TaskCenterQueryService {
// 品牌检测按关键字执行、不落店铺;品牌行的 current_scope_key 是品牌名,不能当店铺用。
if (!row.isBrand()) {
// 国家与店铺同样只按 biz id 取(品牌 id 会与 biz 撞号)。
vo.setCountry(countries.get(row.getId()));
List<String> rowShops = shops.get(row.getId());
if (rowShops != null && !rowShops.isEmpty()) {
vo.setShopName(rowShops.get(0));
@@ -515,7 +486,7 @@ public class TaskCenterQueryService {
return lastSeen != null && lastSeen.isBefore(now.minusMinutes(STUCK_IDLE_MINUTES));
}
/** 店铺名的归一化键:与 SQL 的 LOWER(TRIM(...)) 同口径,面板下钻与筛选才对得上。 */
/** 店铺名的归一化键:与 SQL 的 LOWER(TRIM(...)) 同口径,去重计数与筛选才对得上。 */
private static String shopKey(String shopName) {
return shopName.trim().toLowerCase(Locale.ROOT);
}
@@ -10,6 +10,7 @@ import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -54,9 +55,9 @@ class TaskCenterQueryMapperSqlTest {
.replaceAll("\\s*,\\s*", ",");
}
/** 任务列表分页的查询参数(店铺口径下已不再有设备号)。 */
/** 任务列表分页的查询参数(状态已改为「一组大写状态」,「在跑」由服务层展开)。 */
private static Map<String, Object> taskPageParams(Object shop, long limit, long offset) {
return params("userIds", null, "moduleType", null, "status", null, "shop", shop,
return params("userIds", null, "moduleType", null, "statuses", null, "shop", shop,
"startTime", null, "endTime", null, "limit", limit, "offset", offset);
}
@@ -207,8 +208,8 @@ class TaskCenterQueryMapperSqlTest {
@Test
void taskListFiltersReachBothBranchesAndBrandDropsShopFilter() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", List.of(5L, 11L), "moduleType", "PUBLISH", "status", "RUNNING",
"shop", "旗舰店",
params("userIds", List.of(5L, 11L), "moduleType", "PUBLISH",
"statuses", List.of("RUNNING"), "shop", "旗舰店",
"startTime", LocalDateTime.of(2026, 9, 1, 0, 0),
"endTime", LocalDateTime.of(2026, 9, 28, 0, 0),
"limit", 20L, "offset", 20L));
@@ -260,17 +261,55 @@ class TaskCenterQueryMapperSqlTest {
@Test
void taskCountSharesTheUnionBody() {
BoundSql boundSql = render("countTaskPage",
params("userIds", null, "moduleType", "BRAND", "status", "RUNNING",
params("userIds", null, "moduleType", "BRAND", "statuses", List.of("RUNNING"),
"shop", null, "startTime", null, "endTime", null));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("SELECT COUNT(*) FROM(SELECT t.id AS id"));
assertTrue(sql.contains("brand_crawl_tasks"));
assertTrue(sql.contains("AND 'BRAND' = ?"));
assertTrue(sql.contains("AND CASE WHEN UPPER(b.status) = 'CANCELED' THEN 'CANCELLED' ELSE UPPER(b.status) END = ?"));
assertTrue(sql.contains("AND CASE WHEN UPPER(b.status) = 'CANCELED' THEN 'CANCELLED' ELSE UPPER(b.status) END"
+ " IN(?)"));
assertEquals(4, boundSql.getParameterMappings().size(), "业务 + 状态在两张表各绑一次");
}
/**
* 状态筛选必须是 IN:前端默认项「在跑」= PENDING∪RUNNING∪SCHEDULED 三个状态的合并,
* 留旧的单值等号会让默认视图恒空(选了「在跑」却拿 ACTIVE 去比表里的状态)。
*/
@Test
void statusFilterIsAnInListSoTheMergedActiveSentinelWorks() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", null, "moduleType", null,
"statuses", TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED,
"shop", null, "startTime", null, "endTime", null,
"limit", 20L, "offset", 0L));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("AND " + TaskCenterQueryMapper.STATUS_T + " IN(?,?,?)"),
"biz 分支按展开后的三个状态过滤:" + sql);
assertTrue(sql.contains("AND " + TaskCenterQueryMapper.STATUS_B + " IN(?,?,?)"),
"品牌分支同口径(小写状态已由 STATUS_B 归一为大写)");
assertEquals(8, boundSql.getParameterMappings().size(), "两张表各绑三个状态 + 分页两个");
assertEquals("PENDING", boundSql.getAdditionalParameter("__frch_st_0"));
assertEquals("RUNNING", boundSql.getAdditionalParameter("__frch_st_1"));
assertEquals("SCHEDULED", boundSql.getAdditionalParameter("__frch_st_2"));
}
/** 选了具体状态时就是单元素 IN,行为与旧的等号一致;不选则整段不渲染。 */
@Test
void singleStatusStillRendersAsOneElementInList() {
String one = sqlOf(render("countTaskPage",
params("userIds", null, "moduleType", null, "statuses", List.of("SUCCESS"),
"shop", null, "startTime", null, "endTime", null)));
String none = sqlOf(render("countTaskPage",
params("userIds", null, "moduleType", null, "statuses", null,
"shop", null, "startTime", null, "endTime", null)));
assertTrue(one.contains("AND " + TaskCenterQueryMapper.STATUS_T + " IN(?)"), "单状态 = IN 一个值:" + one);
assertFalse(none.contains(TaskCenterQueryMapper.STATUS_T + " IN"), "未选状态不加状态条件");
}
@Test
void usernameLookupIsFuzzyAndBounded() {
BoundSql boundSql = render("selectUserIdsByUsername", params("keyword", "ali"));
@@ -311,6 +350,32 @@ class TaskCenterQueryMapperSqlTest {
assertEquals(2L, boundSql.getAdditionalParameter("__frch_tid_1"));
}
/**
* 国家列的取数:七条 JSON 路径与先后顺序 = 2026-10-04 生产实测(近 30 天 20 行页采样 16 行有值、
* 全量 70.7%),少一条或换序就是另一套覆盖率,所以按「出现顺序」断言而不是只看包含。
* 形状钉死:只回 taskId + country 两列、按主键点查,不进列表主查询(那条不许碰 request_json)。
*/
@Test
void countryLookupReadsTheMeasuredSevenPathsInOrderByPrimaryKey() {
List<String> measuredOrder = List.of("$.filters.countryCode", "$.countryCode", "$.country",
"$.publish_country", "$.countryCodes", "$.country_codes", "$.filters.countryCodes");
BoundSql boundSql = render("selectTaskCountries", params("taskIds", List.of(1L, 2L)));
String sql = sqlOf(boundSql);
int previous = -1;
for (String path : measuredOrder) {
int at = sql.indexOf("JSON_UNQUOTE(JSON_EXTRACT(t.request_json,'" + path + "'))");
assertTrue(at > previous, "路径缺失或顺序变了(顺序就是优先级):" + path + " at=" + at);
previous = at;
}
assertEquals(7, sql.split("JSON_UNQUOTE\\(JSON_EXTRACT\\(t\\.request_json,", -1).length - 1,
"七条路径一条不多一条不少");
assertTrue(sql.startsWith("SELECT t.id AS taskId,COALESCE("), "只出两列,大 JSON 不回服务层");
assertTrue(sql.endsWith("WHERE t.id IN(?,?)"), "按页内任务号点查");
assertFalse(sql.contains("result_json"), "国家不碰进度那个 JSON 列");
assertEquals(2, boundSql.getParameterMappings().size());
}
/** 店铺只有两个真来源:上架结果文件的 shop_name、逐店落行的模块的 source_filename。 */
@Test
void shopSourcesAreBatchedByTaskId() {
@@ -369,6 +434,11 @@ class TaskCenterQueryMapperSqlTest {
TaskCenterQueryMapper.BRAND_ACTIVE_STATUSES);
assertEquals(TaskCenterQueryMapper.sqlList(TaskCenterQueryMapper.BRAND_TERMINAL_STATUS_SET),
TaskCenterQueryMapper.BRAND_TERMINAL_STATUSES);
// 「在跑」筛选项走有序版本(IN 列表要可断言),成员必须与判在跑/判卡住用的那个 Set 完全一致
assertEquals(TaskCenterQueryMapper.ACTIVE_STATUS_SET,
Set.copyOf(TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED), "展开成 IN 的那组 = 进行中状态集合");
assertEquals(List.of("PENDING", "RUNNING", "SCHEDULED"),
TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED, "顺序固定,SQL 文本与日志才可断言");
}
/**
@@ -2,6 +2,7 @@ package com.nanri.aiimage.modules.taskcenter.service;
import com.nanri.aiimage.modules.taskcenter.mapper.TaskCenterQueryMapper;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCollectStatsRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCountryRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterDeviceRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopStatRow;
@@ -10,7 +11,6 @@ import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskQuery;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterUserRow;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterOverviewVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterShopVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskDetailVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskPageVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskRowVo;
@@ -150,16 +150,18 @@ class TaskCenterQueryServiceTest {
return row;
}
private static TaskCenterCountryRow countryRow(long taskId, String country) {
TaskCenterCountryRow row = new TaskCenterCountryRow();
row.setTaskId(taskId);
row.setCountry(country);
return row;
}
private static TaskCenterTaskRowVo item(TaskCenterTaskPageVo page, long id) {
return page.getItems().stream().filter(row -> Long.valueOf(id).equals(row.getId()))
.findFirst().orElseThrow(() -> new AssertionError("任务缺失: " + id));
}
private static TaskCenterShopVo shop(List<TaskCenterShopVo> rows, String name) {
return rows.stream().filter(row -> name.equals(row.getShop()))
.findFirst().orElseThrow(() -> new AssertionError("店铺行缺失: " + name));
}
private void stubPage(List<TaskCenterTaskRow> rows) {
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any()))
.thenReturn((long) rows.size());
@@ -181,6 +183,15 @@ class TaskCenterQueryServiceTest {
when(queryMapper.selectFileResultShops(any())).thenReturn(rows);
}
/** 「在跑店铺」只从汇总卡这个真实出口读,不给私有方法开后门。 */
private long shopRunning() {
when(queryMapper.countShops(isNull())).thenReturn(86L);
when(queryMapper.countRunningTasks(isNull())).thenReturn(0L);
when(queryMapper.countStuckTasks(isNull(), any())).thenReturn(0L);
when(queryMapper.countFinishedTasksSince(isNull(), any())).thenReturn(0L);
return service.overview(superScope()).getShopRunning();
}
// ── 汇总卡 ──────────────────────────────────────────────────────────
@Test
@@ -210,80 +221,29 @@ class TaskCenterQueryServiceTest {
}
@Test
void overviewRunningShopsEqualsPanelRowsExcludingTheBucket() {
void runningShopsCountsRealShopsOnly() {
LocalDateTime now = LocalDateTime.now();
when(queryMapper.countShops(isNull())).thenReturn(86L);
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "COLLECT_DATA", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "林芳旗舰店")));
stubFileResultShops(List.of());
TaskCenterOverviewVo vo = service.overview(superScope());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(1L, vo.getShopRunning(), "2 个在跑任务里只有 1 家真店铺,另一行是不挂店铺桶");
assertEquals(2, panel.size(), "卡片与面板共用同一份聚合:面板 1 家店铺 + 1 行桶");
assertEquals(1L, panel.stream().filter(row -> !row.isNoShop()).count());
assertEquals(1L, shopRunning(), "2 个在跑任务里只有 1 家真店铺,采集数据不落店铺");
}
@Test
void scopedOperatorPassesVisibleUsersToEveryQuery() {
service.overview(scoped(5L, 11L));
service.shops(scoped(5L, 11L));
service.shopOptions(scoped(5L, 11L));
// 可见集合由 Set 转来、顺序不定,断言必须与顺序无关。
verify(queryMapper).countShops(argThat(TaskCenterQueryServiceTest::visiblePair));
verify(queryMapper).countRunningTasks(argThat(TaskCenterQueryServiceTest::visiblePair));
verify(queryMapper, times(2))
.selectActiveTasks(argThat(TaskCenterQueryServiceTest::visiblePair), anyLong());
verify(queryMapper).selectShopNames(argThat(TaskCenterQueryServiceTest::visiblePair));
}
@Test
void shopOptionsAreTheRegistryNamesAsReturned() {
when(queryMapper.selectShopNames(isNull())).thenReturn(List.of("林芳旗舰店", "美国店"));
assertEquals(List.of("林芳旗舰店", "美国店"), service.shopOptions(superScope()));
}
// ── 店铺面板 ────────────────────────────────────────────────────────
@Test
void everyActiveTaskLandsInExactlyOnePanelBucket() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "COLLECT_DATA", "RUNNING", now, now),
brandTaskRow(3L, "running", now, now)));
stubPublishShops(List.of(shopRow(1L, "林芳旗舰店")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(2, panel.size(), "1 家店铺 + 1 行不挂店铺桶");
assertEquals(3L, panel.stream().mapToLong(TaskCenterShopVo::getRunningTasks).sum(),
"每个进行中任务恰好落进一个桶,采集数据与品牌任务不许在看板里消失");
assertEquals(2L, shop(panel, TaskCenterQueryService.NO_SHOP_LABEL).getRunningTasks());
}
@Test
void multiShopTaskIsCountedUnderEachOfItsShops() {
void multiShopTaskMakesEveryShopCount() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(taskRow(1L, "PRICE_TRACK", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "甲店"), shopRow(1L, "乙店")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(2, panel.size());
assertEquals(1L, shop(panel, "甲店").getRunningTasks());
assertEquals(1L, shop(panel, "乙店").getRunningTasks(), "一个任务挂两家店 → 两家店各算 1 个在跑任务");
assertEquals(2L, shopRunning(), "一个任务挂两家店 → 两家店各算一家在跑");
}
@Test
void sameShopWrittenTwoWaysStaysOneRow() {
void sameShopWrittenTwoWaysCountsOnce() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
@@ -291,81 +251,34 @@ class TaskCenterQueryServiceTest {
stubPublishShops(List.of(shopRow(1L, "Amazon 美国店"), shopRow(2L, "amazon 美国店 ")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(1, panel.size(), "大小写与首尾空格差异不拆成两行(与 SQL 的 LOWER(TRIM) 同口径)");
assertEquals("Amazon 美国店", panel.get(0).getShop(), "展示名沿用首次出现的写法");
assertEquals(2L, panel.get(0).getRunningTasks());
assertEquals(1L, shopRunning(), "大小写与首尾空格差异不拆成两家(与 SQL 的 LOWER(TRIM) 同口径)");
}
@Test
void panelRowFlagsStuckTasksAndCarriesFreshestReport() {
void sameShopFromBothSourcesCountsOnce() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now.minusHours(2), now.minusMinutes(30)),
taskRow(2L, "SHOP_MATCH", "RUNNING", now.minusHours(1), now.minusSeconds(40))));
stubPublishShops(List.of(shopRow(1L, "林芳旗舰店"), shopRow(2L, "林芳旗舰店")));
stubFileResultShops(List.of());
stubActiveTasks(List.of(taskRow(1L, "PRICE_TRACK", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "甲店")));
stubFileResultShops(List.of(shopRow(1L, "甲店")));
TaskCenterShopVo row = shop(service.shops(superScope()), "林芳旗舰店");
assertEquals(2L, row.getRunningTasks());
assertEquals(1L, row.getStuckTasks(), "只有 30 分钟没上报的那个算卡住");
assertTrue(within(row.getLastReportAt(), now.minusSeconds(40), 5), "最近上报取该店所有在跑任务里最新的一次");
assertEquals("定时匹配×1 / 跟价×1", row.getModuleSummary(), "按任务数倒序、同数按业务名稳定排列");
assertEquals(1L, shopRunning(), "上架文件与逐店结果行指向同一家店时不重复计数");
}
@Test
void moduleSummaryAggregatesCountsPerBusiness() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(3L, "SHOP_MATCH", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "甲店"), shopRow(2L, "甲店"), shopRow(3L, "甲店")));
stubFileResultShops(List.of());
assertEquals("跟价×2 / 定时匹配×1", shop(service.shops(superScope()), "甲店").getModuleSummary());
}
@Test
void panelSortsStuckFirstThenStalestReportWithBucketLast() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now.minusMinutes(1)),
taskRow(2L, "PRICE_TRACK", "RUNNING", now, now.minusMinutes(30)),
taskRow(3L, "SHOP_MATCH", "RUNNING", now, now.minusMinutes(5)),
taskRow(4L, "COLLECT_DATA", "RUNNING", now, now.minusHours(3))));
stubPublishShops(List.of(shopRow(1L, "A店"), shopRow(2L, "B店"), shopRow(3L, "C店")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(List.of("B店", "C店", "A店", TaskCenterQueryService.NO_SHOP_LABEL),
panel.stream().map(TaskCenterShopVo::getShop).toList(),
"有卡住的排最前,其次最久没上报的,桶永远垫底(哪怕它最久没动)");
}
@Test
void brandTasksNeverQueryShopSourcesAndLandInTheBucket() {
void brandTasksNeverQueryShopSources() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(brandTaskRow(7L, "running", now, now)));
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(1, panel.size());
assertTrue(panel.get(0).isNoShop(), "品牌任务按关键字执行,不落店铺,只能进桶");
assertEquals(1L, panel.get(0).getRunningTasks());
assertEquals(0L, shopRunning(), "品牌任务按关键字执行,没有店铺维度");
verify(queryMapper, never()).selectPublishShops(any());
verify(queryMapper, never()).selectFileResultShops(any());
}
@Test
void emptyPanelDoesNotQueryShopSources() {
void noActiveTaskMeansNoShopSourceQuery() {
stubActiveTasks(List.of());
assertEquals(List.of(), service.shops(superScope()));
assertEquals(0L, shopRunning());
verify(queryMapper, never()).selectPublishShops(any());
verify(queryMapper, never()).selectFileResultShops(any());
}
@@ -432,12 +345,71 @@ class TaskCenterQueryServiceTest {
service.tasks(superScope(), query);
verify(queryMapper).countTaskPage(isNull(), eq("PUBLISH"), eq("RUNNING"),
verify(queryMapper).countTaskPage(isNull(), eq("PUBLISH"), eq(List.of("RUNNING")),
eq("旗舰店"), eq(start), eq(end));
verify(queryMapper).selectTaskPage(isNull(), eq("PUBLISH"), eq("RUNNING"),
verify(queryMapper).selectTaskPage(isNull(), eq("PUBLISH"), eq(List.of("RUNNING")),
eq("旗舰店"), eq(start), eq(end), eq(100L), eq(200L));
}
/** 前端默认项「在跑」= 三个进行中状态的合并:下传的是状态序列,不是字面量 ACTIVE。 */
@Test
void activeSentinelExpandsIntoTheThreeRunningStates() {
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any())).thenReturn(0L);
TaskCenterTaskQuery query = new TaskCenterTaskQuery();
query.setStatus("ACTIVE");
service.tasks(superScope(), query);
verify(queryMapper).countTaskPage(isNull(), isNull(),
eq(TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED), isNull(), isNull(), isNull());
assertEquals(Set.copyOf(TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED),
TaskCenterQueryMapper.ACTIVE_STATUS_SET, "「在跑」的合并口径必须与判卡住用的那组同源");
}
@Test
void statusFilterKeepsSingleStatesAndIgnoresBlank() {
assertEquals(List.of("RUNNING"), TaskCenterQueryService.statusFilter("running"), "大小写不敏感");
assertEquals(List.of("CANCELLED"), TaskCenterQueryService.statusFilter(" CANCELLED "));
assertNull(TaskCenterQueryService.statusFilter(""), "空 = 不裁剪");
assertNull(TaskCenterQueryService.statusFilter(null));
}
/** 国家列:原文两种形状都要归一,取不到留空(前端画「—」),不许把 null 当国家名。 */
@Test
void countryColumnIsNormalizedFromBothJsonShapes() {
LocalDateTime now = LocalDateTime.now();
stubPage(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "PUBLISH", "RUNNING", now, now),
taskRow(3L, "SHOP_MATCH", "RUNNING", now, now),
taskRow(4L, "COLLECT_DATA", "RUNNING", now, now)));
when(queryMapper.selectSnapshots(any())).thenReturn(List.of());
stubPublishShops(List.of());
stubFileResultShops(List.of());
when(queryMapper.selectTaskCountries(List.of(1L, 2L, 3L, 4L))).thenReturn(List.of(
countryRow(1L, "[\"UK\"]"),
countryRow(2L, "[\"UK\", \"DE\"]"),
countryRow(3L, "DE")));
TaskCenterTaskPageVo page = service.tasks(superScope(), new TaskCenterTaskQuery());
assertEquals("UK", item(page, 1L).getCountry(), "单元素数组去掉括号,与裸串 UK 同值");
assertEquals("UK/DE", item(page, 2L).getCountry(), "多国家任务不能只显示第一个");
assertEquals("DE", item(page, 3L).getCountry());
assertNull(item(page, 4L).getCountry(), "该模块不写国家 → 无值,不是空串");
}
/** 品牌任务按关键字执行、没有国家维度;它的 id 还会与 biz 表撞号,所以连点查都不发。 */
@Test
void brandRowsAreNotAskedForCountries() {
LocalDateTime now = LocalDateTime.now();
stubPage(List.of(brandTaskRow(7L, "running", now, now)));
when(queryMapper.selectSnapshots(any())).thenReturn(List.of());
assertNull(item(service.tasks(superScope(), new TaskCenterTaskQuery()), 7L).getCountry());
verify(queryMapper, never()).selectTaskCountries(any());
}
@Test
void stuckFlagBoundary() {
LocalDateTime now = LocalDateTime.now();
+112 -42
View File
@@ -19,11 +19,11 @@
- **默认只有超管可见**;管理员需超管在「用户管理 → 菜单权限」授权后可见 —— 复用现有菜单授权机制
(`columns` + `user_column_permission`),**不新建权限机制**:无授权记录 = 管理员看不到。
- 顶部汇总卡:总店铺 / 在跑店铺 / 进行中任务 / 今日完成 / 疑似卡住。
- 全局在跑店铺面板:一行一个店铺,列在跑任务数、疑似卡住数、业务分布、最近上报;点行下钻到该店铺的任务。
- 列表字段:账号名、店铺、业务名称、任务状态、任务ID、开始时间、最近上报、结束时间、执行进度
(进度按「已完成数 / 总数」,已完成 = 成功 + 失败,与客户端任务面板同口径),
并提供筛选(账号/业务/状态/店铺/时间范围)。
- 「只要客户端任务在跑就上报」是面板的前提:进行中任务的 `updated_at` 由心跳(60s)与结果回传共同顶新,
- 列表字段:账号名、店铺、国家、业务名称、任务状态、任务ID、开始时间、最近上报、结束时间、执行进度
(进度按「已完成数 / 总数」,已完成 = 成功 + 失败,与客户端任务面板同口径;采集数据这一列照抄客户端
文案「关键词进度:第 N/总 个」),
并提供筛选(账号/业务/状态/店铺/时间范围);状态默认「在跑」,其余状态保留入口。
- 「只要客户端任务在跑就上报」是「在跑店铺」与「疑似卡住」两张卡的前提:进行中任务的 `updated_at` 由心跳(60s)与结果回传共同顶新,
因此不再需要任何设备身份基线(曾用过的 code.txt 台账已放弃)。
## 依赖关系
@@ -59,7 +59,7 @@
- `created_at` / `updated_at` 同名;品牌任务无 `finished_at`,用终态时的 `updated_at` 代替
- 进度:品牌任务用 `progress_current / progress_total`
- 过滤条件(账号/状态/店铺/时间范围)分别下推到两个子查询,各自走自己的索引
(`biz_file_task` 有 `idx_module_status(module_type, status)`,进行中面板直接复用它)
(`biz_file_task` 有 `idx_module_status(module_type, status)`,进行中店铺数直接复用它)
### 设备号(只作附注,不参与统计)
@@ -74,9 +74,9 @@
- 原「设备花名册 + 5 分钟在线」口径已整体删除(任务设备近 30 天 ∪ 日志设备近 7 天那套 UNION、
`countOnlineDevices`、`/devices` 接口与前端设备条),不再有任何以设备为分母的数字。
### 店铺归属:两个真来源 + 一个「不挂店铺」桶
### 店铺归属:只认两个真来源
面板与列表的店铺只认两个来源:
汇总卡与列表的店铺只认两个来源:
| 来源 | 覆盖模块 | 说明 |
|---|---|---|
@@ -90,21 +90,19 @@
- `biz_task_result_item.scope_key` —— 任务结果分组名。
- `request_json.items[].shopName` —— 大 JSON 列;列表主查询刻意不拉它,为兜底把它读出来过一次代价太大。
COLLECT_DATA / SIMILAR_ASIN / APPEARANCE_PATENT / BRAND 这些不落店铺,面板给它们一行合成桶
**「不挂店铺」**(`noShop=true`):按线上一次实测 42 个在跑任务里有 19 个属于这一类,
没有桶它们就会在看板里静默消失。桶行不可下钻(没有可筛的店铺名),要看这些任务用业务筛选。
COLLECT_DATA / SIMILAR_ASIN / APPEARANCE_PATENT / BRAND 这些任务不落店铺:按线上一次实测,42 个在跑
任务里有 19 个属于这一类。它们没有店铺归属,只能按业务筛出来看。
一个任务挂多家店铺时在每家店下各计一次;归组键 `LOWER(TRIM(...))`,同一店两种写法不拆成两行,
展示名沿用首次出现的写法。
一个任务挂多家店铺时每家都算;归组键 `LOWER(TRIM(...))`,同一店两种写法算一家。
### 店铺口径(面板与卡片)
### 店铺口径(只有汇总卡)
- **总店铺** = `biz_shop_manage` 中可见账号(`created_by_id`)名下的店铺数(超管不裁剪)。
- **在跑店铺** = 面板行数减去「不挂店铺」桶。汇总卡与 `/shops` **共用同一次聚合**
(`TaskCenterQueryService.aggregateShops`),卡片说几家在跑、面板就列几行,两处不允许各算各的。
- 面板原料 = 当前全部进行中任务(客户端 12 模块 ∪ 品牌),行数上限 500;触顶时服务层 `log.warn`,
卡片的进行中/卡住/今日完成三项仍走 SQL 精确计数。
- 面板排序:有卡住的排前面 → 最久没上报的排前面 → 「不挂店铺」桶永远垫底。
- **在跑店铺** = 进行中任务挂到的**去重店铺数**(`TaskCenterQueryService.runningShops`,
归组键同上)。不落店铺的任务天然不计入,所以「在跑店铺 5」不等于「5 个任务在跑」,
后者看「进行中任务」那张卡。
- 原料 = 当前全部进行中任务(客户端 12 模块 ∪ 品牌),扫描行数上限 500;触顶时服务层 `log.warn`
并说明该数会偏小,卡片的进行中/卡住/今日完成三项仍走 SQL 精确计数。
- 店铺筛选:上面两个来源任一命中(EXISTS + `LOWER(TRIM(...)) = LOWER(TRIM(?))` **精确**匹配,
LIKE 会让「林芳」命中「林芳芳」);品牌分支带店铺筛选时恒空(品牌不存店铺,且品牌 id 会与 biz 撞号)。
@@ -113,6 +111,18 @@ COLLECT_DATA / SIMILAR_ASIN / APPEARANCE_PATENT / BRAND 这些不落店铺,面
`shopName` 取该任务店铺列表的第一个,`shopCount` 是数量;无来源命中时留空(显示「—」),
不做文件名/请求体兜底 —— 宁可空,不把文件名当店铺。
### 状态筛选:默认「在跑」= 三个进行中状态合并
用户 2026-10-04 要求「其他状态也保留,但默认显示执行中的任务」,落地方式是把合并口径放在**一处**:
- 前端 `TASK_STATUS_OPTIONS` 首项仍是「全部状态」,第二项新增 `ACTIVE`「在跑」并作为页面默认值
(`createTaskFilter()` 保持全空 = 不裁剪,默认值由页面 `defaultTaskFilter()` 覆盖,重置也回到「在跑」);
- `ACTIVE` 不是表里的状态,后端 `TaskCenterQueryService.statusFilter` 把它展开成
`ACTIVE_STATUSES_ORDERED`(= 判在跑/判卡住用的 `ACTIVE_STATUS_SET`,两者由用例钉成同一组成员),
SQL 侧状态筛选相应从单值 `= ?` 改成 `IN (...)`,两张表分支各自展开,品牌表小写状态仍由 `STATUS_B` 归一;
- 近 7 天 PENDING/SCHEDULED 实际 0 行,所以默认「在跑」今天等价于旧的「执行中」,
但排期与待领取的任务不会再被默认视图漏掉。
### 进度口径(列表/详情展示)
1. `biz_task_progress_snapshot`(task_id + module_type)优先:total/success/failed/pending +
@@ -124,8 +134,39 @@ COLLECT_DATA / SIMILAR_ASIN / APPEARANCE_PATENT / BRAND 这些不落店铺,面
5. 其余无快照模块(跟价、定时匹配…)→ 进度置 0,**不回退文件数**:客户端在这些模块没有进度条,
而单文件任务回退成「已完成 0 / 总 1」会被读成"一步没跑",是误导。
前端展示「已完成 X / 总 Y(失败 Z 徽标)」+ 百分比进度条;`progressTotal ≤ 0` 时只显示「—」,
不画 0% 空进度轨(空轨="进度 0%",与"这里没有进度可看"是两件事)。
前端文案两档(2026-10-04 用户要求「和客户端同步一致」):采集数据行逐字抄客户端
`BrandCollectDataTab.vue#taskKeywordProgress` —— **关键词进度:第 min(总, 已处理+1)/总 个**;
其余模块仍是「已完成 X / 总 Y(失败 Z 徽标)」+ 百分比进度条。
`progressTotal ≤ 0` 时只显示「—」,不画 0% 空进度轨(空轨="进度 0%",与"这里没有进度可看"是两件事)。
### 国家列(只展示,不做筛选)
`biz_file_task` / `brand_crawl_tasks` 都没有国家列,目标站点只存在于 `request_json` 里,且各模块写法不同
(2026-10-04 生产实测,七条路径按下面的优先级 COALESCE):
| 顺序 | JSON 路径 | 近 7 天实际命中(模块 → 条数) |
|---|---|---|
| 1 | `$.filters.countryCode` | 采集数据 138 |
| 2 | `$.countryCode` | — 0 条 |
| 3 | `$.country` | — 0 条 |
| 4 | `$.publish_country` | 上架 13 |
| 5 | `$.countryCodes` | 跟价 141、店铺数据抓取 8 |
| 6 | `$.country_codes` | 定时匹配 15 |
| 7 | `$.filters.countryCodes` | 采集数据 138(与路径 1 同值,靠优先级取 1) |
- **覆盖率**:近 7 天 315/451 = **69.8%**,12 个在跑的模块里 **5 个**能取到(跟价、采集数据、定时匹配、上架、
店铺数据抓取);取不到的是外观专利检测 46、货源查询 36、去重 29、商品风险解决 21、删除ASIN 2,
以及不在业务下拉里的 SPLIT 1 / CONVERT 1
—— 这些模块的请求参数里本就没有国家,显示「—」,不用店铺名或账号默认站点猜;
全历史比例更低(老任务写法不同);
- **形状**两种并存:裸串 `UK` 与数组文本 `["UK", "DE"]`(同一模块两种都有:`UK`140 / `["DE"]`80 /
`["UK"]`75 / `DE`10 / `["UK", "DE"]`5 / `["DE", "UK"]`4 / `ES`1),服务层归一为 `UK` / `UK/DE`,
多国家不截断成第一个(多国家任务共 9 条:定时匹配 5、店铺数据抓取 4);
- **取数位置**:`selectTaskCountries` 按页内 biz 任务号主键点查,**不进列表主查询** ——
那条 UNION 的既有护栏是不碰 `request_json`(大 JSON 列是列表慢查询的主因之一)。
实测同形状点查 20 行 45ms,与不带 JSON 表达式的 41ms 同量级;
- 品牌任务没有国家维度(该表 14 列无相关字段),且品牌 id 会与 biz id 撞号,所以按 `brand` 行筛掉、不发查询;
- 按用户定案**只加列不动筛选**:不加国家下拉、不加 `country` 查询参数。
### 「是否正常在跑」判定
@@ -133,7 +174,7 @@ COLLECT_DATA / SIMILAR_ASIN / APPEARANCE_PATENT / BRAND 这些不落店铺,面
- 进行中且 > 10 分钟无更新 → 「疑似卡住」(**仅展示提示,不做处置动作**);
`updated_at` 缺失时回落 `created_at` 判老;
- 终态 → 成功/失败/已取消,按 `status` 展示;
- 列表/详情/面板统一输出 `lastReportAt`(= `updated_at`,缺失回落 `created_at`),文案用「最近上报」,
- 列表/详情统一输出 `lastReportAt`(= `updated_at`,缺失回落 `created_at`),文案用「最近上报」,
不再说「在线/离线」——设备是否在线与任务是否在跑是两件事。
- 唯一的窗口就是这 10 分钟;30 天 / 7 天 / 5 分钟那三个设备窗口随设备维度一起删除。
@@ -164,9 +205,8 @@ SQL 用 `@Select` 注解 mapper + 手写 LIMIT/OFFSET 分页(先例 `ImageVide
| 接口 | 说明 |
|---|---|
| `GET /api/admin/task-center/overview` | 汇总卡:shopTotal 总店铺、shopRunning 在跑店铺、runningTasks 进行中、todayFinishedTasks 今日完成、stuckTasks 疑似卡住 |
| `GET /api/admin/task-center/shops` | 在跑店铺面板:shop、noShop(是否「不挂店铺」桶)、runningTasks、stuckTasks、moduleSummary(如「跟价×2 / 定时匹配×1」)、lastReportAt |
| `GET /api/admin/task-center/shop-options` | 店铺筛选候选:`biz_shop_manage` 去重店铺名(`LIMIT 2000`,只取 `shop_name` 一列,不带 account/password/zn_username) |
| `GET /api/admin/task-center/tasks` | 任务列表(分页 + 筛选:page、pageSize、username、moduleType、status、shop、startTime/endTime);字段:id、taskNo、moduleType、moduleLabel、status、userId、username、deviceId、webDevice、shopName、shopCount、createdAt、finishedAt、lastReportAt、progressTotal/progressSuccess/progressFailed、currentScope、message、stuck(`deviceName` 只在详情装配) |
| `GET /api/admin/task-center/tasks` | 任务列表(分页 + 筛选:page、pageSize、username、moduleType、status、shop、startTime/endTime;`status=ACTIVE` = 三个进行中状态合并,其余按单值);字段:id、taskNo、moduleType、moduleLabel、status、userId、username、deviceId、webDevice、shopName、shopCount、country、createdAt、finishedAt、lastReportAt、progressTotal/progressSuccess/progressFailed、currentScope、message、stuck(`deviceName` 只在详情装配) |
| `GET /api/admin/task-center/tasks/detail` | 任务详情(参数 `taskNo`,品牌任务为 `brand-<id>`):基础信息 + 进度快照 + 店铺/文件明细 |
| `GET /api/admin/task-center/variant-tasks` | 变体采集列表(代理麦象 console):uid 集合 = 可见用户;page/pageSize + status/taskType 筛选;**不传 status = 只看在跑**(等待 0 ∪ 处理中 1 各拉一页合并,历史终态不再展示) |
@@ -175,15 +215,15 @@ SQL 用 `@Select` 注解 mapper + 手写 LIMIT/OFFSET 分页(先例 `ImageVide
`admin-frontend-vue/src/pages/task-center/`:
- `TaskCenterBoardPage.vue`:外层页签 + 汇总卡(总店铺/在跑店铺/进行中任务/今日完成/疑似卡住)+
在跑店铺看板 + 筛选栏(账号/业务/状态/店铺/时间范围);
- 在跑店铺看板:表格一行一个店铺(店铺、在跑任务、疑似卡住、业务分布、最近上报),
点真店铺行 = 按该店铺精确筛任务(再点一次取消),「不挂店铺」桶行不可点并带说明文案;
筛选栏(账号/业务/状态/店铺/时间范围);
- 店铺筛选:`el-select class="admin-filter" filterable clearable`(`admin-filter` 把控件补到 42px,
与同行原生控件同高,`align-items: flex-end` 的筛选行里 label 才不会被顶偏),
候选 = 店铺库 ∪ 面板出现的店铺名
(店铺已删、但任务还在的情形也筛得动);
- 页签一「客户端任务」:表格(账号、店铺、业务、状态、任务ID、开始、最近上报、结束、进度)
候选 = 店铺库(`shop-options`);看板下线后不再并入「看板上出现过的店铺」,
店铺已从店铺库删掉但任务还在的情形,改用账号或业务筛;
- 页签一「客户端任务」:表格(账号、店铺、国家、业务、状态、任务ID、开始、最近上报、结束、进度)
+ 详情 `el-drawer`(设备名、当前处理与分组明细只在详情出现;「操作」列已删,任务ID 单元格是详情入口);
状态下拉默认「在跑」(`ACTIVE` 哨兵,见「状态筛选」节),国家列只展示不可筛;
采集数据行的进度文案 = 客户端那句「关键词进度:第 N/总 个」;
- 页签二「变体采集」:**只看在跑**——状态下拉三项(在跑=不传 status/等待执行/处理中,历史终态不提供入口),
表格(账号、任务号、状态、开始/更新时间、进度文字 res_mes);徽章是在跑条数,麦象单状态拉取上限 200,
触顶时服务层记 warn 且翻页尾部会缺行;
@@ -208,15 +248,27 @@ Java 侧同步扩展 `MaixiangConsoleClient.BatchTaskItem`(加 resMes 字段
## 测试策略
- Java:`TaskCenterQueryServiceTest` 守「卡片在跑店铺 = 面板行数减桶」「每个进行中任务恰好落进一个桶
(无店铺归属的不许消失)」「多店任务每店各计一次」「两种写法归一行」「快照 scope 不是店铺」
「品牌行撞号时不继承 biz 行店铺」「卡住边界 9/10/11 分钟」「列表不查设备名」;
`TaskCenterQueryMapperSqlTest` 守 SQL:店铺筛选带模块白名单 + 精确匹配、面板查询不带筛选占位符、
- Java(task-center 四支共 77 例:Mapper SQL 29 + 服务层 33 + 组裁剪 7 + 变体 8)。
`TaskCenterQueryServiceTest` 守「在跑店铺 = 进行中任务挂到的去重店铺数」「多店任务每店各计一次」
「两种写法归一行」「两个来源指向同一家店不重复计」「品牌任务不查店铺来源」「快照 scope 不是店铺」
「品牌行撞号时不继承 biz 行店铺」「卡住边界 9/10/11 分钟」「列表不查设备名」,
本轮新增「`ACTIVE` 哨兵展开成三个进行中状态」「单状态仍按单值下发、空值不下发筛选」
「国家两种 JSON 形态都归一(`["UK"]`→`UK`、`["UK", "DE"]`→`UK/DE`、缺字段→`null`)」
「品牌行不发国家查询」;
`TaskCenterQueryMapperSqlTest` 守 SQL:店铺筛选带模块白名单 + 精确匹配、进行中任务查询不带筛选占位符、
`current_scope_key` 不出现在店铺位置,并用反射断言 `selectRequestJson`/`selectResultItemShops`/
设备花名册那批方法已不存在;组裁剪(超管直通 / 空集 `IN(-1)` / 组内多用户)、V138 幂等同前;
- 前端:`tests/task-center-board.test.ts` 守接口清单(6 个)、设备维度不得回流(`deviceTotal`/
`deviceOnline`/`/devices`/`filter.deviceId` 全部断言不存在)、面板下钻与桶行不可点接线、
筛选参数与三种空态;
设备花名册那批方法已不存在;组裁剪(超管直通 / 空集 `IN(-1)` / 组内多用户)、V138 幂等同前,
本轮新增「状态筛选渲染成 `IN (…)` 且绑定顺序 = PENDING/RUNNING/SCHEDULED」「单状态仍是单元素 `IN`」
「国家查询按线上实测的 7 条 JSON 路径顺序逐条定位、只按主键批查、整条不出现 `result_json` 列名」
「状态字面量与 `ACTIVE_STATUS_SET`/`ACTIVE_STATUSES` 三处同源」;
- 前端:`tests/task-center-board.test.ts`(21 例)守接口清单(5 个)、设备维度不得回流(`deviceTotal`/
`deviceOnline`/`/devices`/`filter.deviceId` 全部断言不存在)、**店铺看板整条不得回流**
(`在跑店铺看板`/`selectShop`/`shopFilterOptions`/`fetchTaskCenterShops`/`moduleSummary` 与 `/shops` 全部断言不存在)、
筛选参数与三种空态,本轮新增「采集数据行文案为「关键词进度:第 N/总 个」且 N 封顶总个数」
「国家列只展示:`row.country || '—'`,同时断言 `filter.country` 与 `country` 查询参数都不存在」
「默认筛选 `status = ACTIVE`,重置后仍是 ACTIVE」「列头顺序含国家、空态 colspan 随列数走」;
- 护栏自证:4 个变异点(国家路径顺序调换 / 哨兵不展开 / 归一只取第一个 / 采集文案分支删掉)
全部被对应用例抓到,注入文件按还原前读进内存的字节回写并复验一致;
- 麦象:多 uid 过滤与 res_mes 返回(pytest);
- 既有门禁:`align-operation-guide` / `AdminMenuRouteMatrix` / 路由注册表校验必须保持绿。
@@ -231,12 +283,30 @@ Java 侧同步扩展 `MaixiangConsoleClient.BatchTaskItem`(加 resMes 字段
## 风险与边界
- 历史任务无设备号(V138 之前创建)→ 详情显示「未记录」;看板不看设备,不受影响;
- 「不挂店铺」桶里的任务不能按店铺下钻(它们本来没有店铺维度),只能按业务筛;
- 没有店铺归属的任务(采集/货源/外观/品牌)在列表里店铺列显示「—」,只能按业务筛;
- `biz_file_result.source_filename` 作为店铺只在这 6 个逐店落行的模块成立,其余模块该列是上传文件名,
由 SQL 模块白名单挡在外面;店铺名对不上时表现为「不挂店铺」,不会串到别的店;
- 面板取进行中任务上限 500 行:触顶时卡片仍按 SQL 精确计数、面板会少列,服务层 `log.warn`
(实测在跑任务为数十量级);
由 SQL 模块白名单挡在外面;店铺名对不上时表现为该任务没有店铺(列表「—」),不会串到别的店;
- 「在跑店铺」取进行中任务上限 500 行:触顶时该数会偏小,服务层 `log.warn` 报出来,其余三张卡
仍按 SQL 精确计数(实测在跑任务为数十量级);
- 组裁剪按 **任务发起账号(user_id)** 判定任务可见性,店铺库按 `created_by_id`;
店铺若跨组共用,任务仍按账号归组,不会因为店铺同名而串组;
- 品牌任务状态小写、其余大写,**接口层统一转大写**,前端只认一套;
- 变体采集无店铺归属(麦象侧无此数据),页签二不显示店铺列。
- **国家列是「读得到才显示」,不是保证有值**:`biz_file_task`/`brand_crawl_tasks` 都没有国家列,
值只埋在 `request_json` 里,且线上有 7 种拼法、裸串(`UK`)与数组文本(`["UK", "DE"]`)两种形态。
近 7 天实测 315/451 = 69.8%(12 个模块里 5 个能取到,见「国家列」节);取不到即显示「—」,
与「该任务没有国家」在 UI 上不可区分——这是刻意的:不为此建列、不做迁移。
多国家用 `/` 连接成一个字符串,不展开成多行。老客户端可能写第 8 种拼法:读不到的按「—」处理,
补路径要同步改这条护栏用例(它钉的就是当前 7 条的顺序与条数)。
- 国家**只按主键批查当前页**(≤ 页大小个 id),不进列表 UNION:一旦把 `request_json` 塞进主查询,
就是已知的「列表查询拉大 JSON 列」慢 SQL 老问题。线上实测该表达式 20 行一页 45ms,
同口径不取国家 41ms,差值可忽略;但这一条只对「当前页」成立,不许改成全表扫或加进 `COLS_T`。
- 品牌行**不发国家查询**:`brand_crawl_tasks` 14 个线上真实列里没有任何国家字段,
且其 id 与 `biz_file_task.id` 会撞号,若按 id 去查会拿别的任务的国家糊上去。
- 默认筛选变成「在跑」(`ACTIVE` = 待执行 ∪ 执行中 ∪ 已排期)+ 今天:这是**行为变更**,
进页面不再看到历史任务,要看历史必须换状态或放宽创建时间(页头有说明文字)。
合并口径只在服务层 `statusFilter` 一处展开,状态成员由 `ACTIVE_STATUSES_ORDERED` 与
`ACTIVE_STATUS_SET`/`ACTIVE_STATUSES` 三处同源测试钉住——新增进行中状态时若漏改,测试即红。
- 采集数据进度文案改成客户端口径,**只改文字不改数字**:后端对 COLLECT_DATA 令
`progressFailed = 0` 并把 `progressSuccess` 夹在 `[0, total]`,故 `已完成行数 + 1` 与客户端
「第 N 个」同源;`Math.min(total, done + 1)` 保证跑完时显示「第 总/总 个」而不是「第 总+1/总 个」。