feat(看板): 客户端任务管理从设备维度改为店铺维度全局在跑看板

原「在线设备」卡按日志上报窗口统计,把 89 台算成在线,与实际在跑的客户端数差一个
量级,且设备维度并不能回答"哪台机器上有任务卡住"。改为:

- 汇总卡:总店铺 / 在跑店铺 / 进行中任务 / 今日完成 / 疑似卡住
- 新增「在跑店铺看板」:当前所有进行中任务按店铺归组(在跑数、卡住数、业务分布、
  最近上报),点店铺行下筛该店铺任务;不落店铺的任务归「不挂店铺」桶
- 卡片与面板同源(同一个 aggregateShops),杜绝口径分裂
- 店铺只认两个真来源:上架结果文件 + 逐店落行的结果文件名;
  biz_task_progress_snapshot.current_scope_key 是实例锁不是店铺,已从口径中剔除
- 设备号退为详情附注,花名册 /devices 与在线判定整条链删除
- 上报口径只留一个 10 分钟窗口(进行中且超 10 分钟无上报 = 疑似卡住)

后端 3487 例全绿;新增反射护栏断言设备维度查询与快照当店铺的来源已彻底移除。
This commit is contained in:
2026-10-03 22:41:29 +08:00
parent e3541a7aa7
commit e1f1aa8b16
18 changed files with 1222 additions and 1037 deletions
+21 -14
View File
@@ -1,27 +1,27 @@
import { http } from './http'
import { unwrap } from './envelope'
/** 客户端任务管理(后台看板):按账号 × 设备 × 业务统一查看客户端任务,全部只读。 */
/** 客户端任务管理(后台看板):按店铺 × 账号 × 业务统一查看客户端在跑任务,全部只读。 */
/** 查询参数(由页面侧 buildTaskQuery / buildVariantQuery 产出,空白项不下传)。 */
type QueryParams = Record<string, string | number>
export interface TaskCenterOverview {
deviceTotal: number
deviceOnline: number
shopTotal: number
shopRunning: number
runningTasks: number
todayFinishedTasks: number
stuckTasks: number
}
export interface TaskCenterDevice {
deviceId: string
deviceName: string | null
lastActiveAt: string | null
online: boolean
/** 店铺面板行:一个店铺在当前所有进行中任务里的汇总;「不挂店铺」是兜住无店铺模块的合成桶。 */
export interface TaskCenterShop {
shop: string
noShop: boolean
runningTasks: number
recentTaskAt: string | null
webDevice: boolean
stuckTasks: number
moduleSummary: string
lastReportAt: string | null
}
export interface TaskCenterTaskRow {
@@ -39,6 +39,7 @@ export interface TaskCenterTaskRow {
shopCount: number
createdAt: string | null
finishedAt: string | null
lastReportAt: string | null
progressTotal: number
progressSuccess: number
progressFailed: number
@@ -91,10 +92,16 @@ export async function fetchTaskCenterOverview(): Promise<TaskCenterOverview> {
return unwrap<TaskCenterOverview>(data)
}
/** 设备花名册(任务设备近 30 天 ∪ 日志设备近 7 天):GET /api/admin/task-center/devices */
export async function fetchTaskCenterDevices(): Promise<TaskCenterDevice[]> {
const { data } = await http.get('/api/admin/task-center/devices')
return unwrap<TaskCenterDevice[]>(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')
return unwrap<string[]>(data)
}
/** 任务分页列表:GET /api/admin/task-center/tasks */
@@ -91,8 +91,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'
@@ -8,13 +8,14 @@ import { ElMessage } from 'element-plus'
import OldPagination from '@/components/OldPagination.vue'
import { formatDateTime } from '@/utils/datetime'
import {
fetchTaskCenterDevices,
fetchTaskCenterOverview,
fetchTaskCenterShopOptions,
fetchTaskCenterShops,
fetchTaskCenterTaskDetail,
fetchTaskCenterTasks,
fetchTaskCenterVariantTasks,
type TaskCenterDevice,
type TaskCenterOverview,
type TaskCenterShop,
type TaskCenterTaskDetail,
type TaskCenterTaskRow,
type TaskCenterVariantTaskRow,
@@ -48,7 +49,8 @@ const activeTab = ref<BoardTab>('tasks')
// ---------------------------------------------------------------- 客户端任务
const overview = ref<TaskCenterOverview | null>(null)
const devices = ref<TaskCenterDevice[]>([])
const shops = ref<TaskCenterShop[]>([])
const shopOptions = ref<string[]>([])
const filter = reactive<TaskCenterTaskFilter>(createTaskFilter())
const tasks = ref<TaskCenterTaskRow[]>([])
const taskTotal = ref(0)
@@ -76,6 +78,15 @@ const updatedAt = ref('')
const taskTotalPages = computed(() => Math.max(1, Math.ceil(taskTotal.value / taskPageSize.value)))
const variantTotalPages = computed(() => Math.max(1, Math.ceil(variantTotal.value / variantPageSize.value)))
/** 下拉候选 = 店铺库 + 面板上出现的店铺名(后者可能已从店铺库删掉,下钻要筛得动)。 */
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
}
@@ -88,11 +99,20 @@ async function loadOverview() {
}
}
async function loadDevices() {
async function loadShops() {
try {
devices.value = (await fetchTaskCenterDevices()) || []
shops.value = (await fetchTaskCenterShops()) || []
} catch (error) {
ElMessage.error(errorText(error, '设备列表加载失败'))
ElMessage.error(errorText(error, '在跑店铺加载失败'))
}
}
/** 店铺库下拉候选。 */
async function loadShopOptions() {
try {
shopOptions.value = (await fetchTaskCenterShopOptions()) || []
} catch (error) {
ElMessage.error(errorText(error, '店铺候选加载失败'))
}
}
@@ -124,11 +144,12 @@ async function loadVariants(silent = false) {
}
}
/** 汇总卡与设备条只描述客户端任务,两个页签都刷新它们(切页签时看到的就是最新)。 */
/** 汇总卡与在跑店铺面板只描述客户端任务,两个页签都刷新它们(切页签时看到的就是最新)。 */
async function refreshAll(silent = false) {
await Promise.all([
loadOverview(),
loadDevices(),
loadShops(),
loadShopOptions(),
activeTab.value === 'tasks' ? loadTasks(silent) : loadVariants(silent),
])
updatedAt.value = formatDateTime(Date.now())
@@ -155,9 +176,9 @@ function resetFilter() {
void loadTasks()
}
/** 点设备卡:按该设备筛选任务(再点一次取消)。 */
function selectDevice(deviceId: string) {
filter.deviceId = filter.deviceId === deviceId ? '' : deviceId
/** 点店铺面板行:按该店铺精确筛选任务(再点一次取消);「不挂店铺」合成桶没有可下钻的店铺名。 */
function selectShop(shop: string) {
filter.shop = filter.shop === shop ? '' : shop
taskPage.value = 1
void loadTasks()
}
@@ -274,14 +295,14 @@ onUnmounted(() => {
<div v-if="activeTab === 'tasks'" class="tc-cards">
<div class="tc-card">
<span class="tc-card-label">设备总数</span>
<span class="tc-card-value">{{ overview?.deviceTotal ?? '—' }}</span>
<span class="tc-card-note">近 30 天任务 ∪ 近 7 天日志</span>
<span class="tc-card-label">总店铺</span>
<span class="tc-card-value">{{ overview?.shopTotal ?? '—' }}</span>
<span class="tc-card-note">店铺库内可见店铺</span>
</div>
<div class="tc-card">
<span class="tc-card-label">在线设备</span>
<span class="tc-card-value is-ok">{{ overview?.deviceOnline ?? '—' }}</span>
<span class="tc-card-note">5 分钟内有上报</span>
<span class="tc-card-label">在跑店铺</span>
<span class="tc-card-value is-ok">{{ overview?.shopRunning ?? '—' }}</span>
<span class="tc-card-note">有进行中任务的店铺</span>
</div>
<div class="tc-card">
<span class="tc-card-label">进行中任务</span>
@@ -298,7 +319,7 @@ onUnmounted(() => {
<span class="tc-card-value" :class="{ 'is-warn': (overview?.stuckTasks || 0) > 0 }">
{{ overview?.stuckTasks ?? '—' }}
</span>
<span class="tc-card-note">超过 10 分钟无更新</span>
<span class="tc-card-note">超过 10 分钟无上报</span>
</div>
</div>
</section>
@@ -307,31 +328,45 @@ onUnmounted(() => {
<template v-if="activeTab === 'tasks'">
<section class="panel-box">
<div class="box-head">
<h3>设备</h3>
<span class="box-note">点击设备卡按该设备筛选任务,再点一次取消</span>
<h3>在跑店铺看板</h3>
<span class="box-note">全局看每家店当前有哪些任务在跑,点店铺行筛出它的任务,不必逐台客户端检查</span>
</div>
<div v-if="devices.length" class="device-strip">
<button
v-for="device in devices"
:key="device.deviceId"
class="device-card"
:class="{ active: filter.deviceId === device.deviceId, online: device.online }"
type="button"
:title="device.deviceId"
@click="selectDevice(device.deviceId)"
>
<span class="device-line">
<span class="dot" :class="device.online ? 'is-online' : 'is-offline'"></span>
<span class="device-name">{{ deviceDisplayName(device.deviceName, device.deviceId) }}</span>
<span v-if="device.webDevice" class="badge web">网页</span>
</span>
<span class="device-meta">
{{ device.runningTasks > 0 ? `跑任务 ${device.runningTasks}` : '空闲' }} ·
{{ device.lastActiveAt ? formatDateTime(device.lastActiveAt) : '窗口内无活动' }}
</span>
</button>
<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>
<div v-else class="empty-tip">暂无在跑店铺</div>
</section>
<section class="panel-box">
@@ -355,18 +390,19 @@ onUnmounted(() => {
<option v-for="option in TASK_STATUS_OPTIONS" :key="option.value" :value="option.value">{{ option.label }}</option>
</select>
</div>
<div class="form-group" style="min-width: 190px">
<label>设备</label>
<select v-model="filter.deviceId">
<option value="">全部设备</option>
<option v-for="device in devices" :key="device.deviceId" :value="device.deviceId">
{{ deviceDisplayName(device.deviceName, device.deviceId) }}
</option>
</select>
</div>
<div class="form-group" style="min-width: 160px">
<div class="form-group shop-filter">
<label>店铺</label>
<input v-model="filter.shop" type="text" placeholder="模糊搜索店铺名" @keyup.enter="search" />
<el-select
v-model="filter.shop"
filterable
clearable
placeholder="全部店铺"
style="width: 220px"
@change="search"
>
<el-option v-for="shop in shopFilterOptions" :key="shop" :label="shop" :value="shop" />
</el-select>
<span class="filter-tip">精确匹配店铺名</span>
</div>
<div class="form-group" style="min-width: 190px">
<label>创建时间(起)</label>
@@ -395,6 +431,7 @@ onUnmounted(() => {
<th style="width: 120px">状态</th>
<th style="width: 170px">当前处理</th>
<th style="width: 165px">开始时间</th>
<th style="width: 165px">最近上报</th>
<th style="width: 165px">结束时间</th>
<th style="width: 190px">进度</th>
<th style="width: 90px">操作</th>
@@ -417,6 +454,11 @@ onUnmounted(() => {
<span class="scope" :title="currentScopeOf(row)">{{ currentScopeOf(row) }}</span>
</td>
<td>{{ formatDateTime(row.createdAt) }}</td>
<td>
<span :class="{ 'is-warn-text': row.stuck }">
{{ row.lastReportAt ? formatDateTime(row.lastReportAt) : '—' }}
</span>
</td>
<td>{{ row.finishedAt ? formatDateTime(row.finishedAt) : '—' }}</td>
<td>
<div class="progress-line">
@@ -431,10 +473,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>
@@ -542,6 +584,7 @@ onUnmounted(() => {
<span v-if="detail.stuck" class="badge warn">疑似卡住</span>
</el-descriptions-item>
<el-descriptions-item label="开始时间">{{ formatDateTime(detail.createdAt) }}</el-descriptions-item>
<el-descriptions-item label="最近上报">{{ detail.lastReportAt ? formatDateTime(detail.lastReportAt) : '—' }}</el-descriptions-item>
<el-descriptions-item label="结束时间">{{ detail.finishedAt ? formatDateTime(detail.finishedAt) : '—' }}</el-descriptions-item>
<el-descriptions-item label="进度">
{{ progressText(detail) }}
@@ -707,63 +750,31 @@ h3 {
color: #8598ab;
font-size: 12.5px;
}
.device-strip {
display: flex;
flex-wrap: wrap;
gap: 10px;
}
.device-card {
display: flex;
flex-direction: column;
gap: 6px;
min-width: 190px;
max-width: 260px;
padding: 10px 14px;
border: 1px solid #dbe6f0;
border-radius: 11px;
background: #ffffff;
color: #24384d;
font-family: inherit;
font-size: 13px;
text-align: left;
.shop-row {
cursor: pointer;
}
.device-card:hover {
border-color: #95b1cb;
.shop-row:hover td {
background: #f2f8fd;
}
.device-card.active {
border-color: #4f78a5;
box-shadow: 0 0 0 2px rgba(79, 120, 165, 0.18);
.shop-row.active td {
background: #eaf2fb;
}
.device-line {
display: flex;
align-items: center;
gap: 7px;
min-width: 0;
.shop-row.is-bucket,
.shop-row.is-bucket:hover td {
cursor: default;
background: #fafcfe;
}
.device-name {
font-weight: 600;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
.is-warn-text {
color: #b3803a;
font-weight: 650;
}
.device-meta {
color: #8598ab;
.shop-filter {
position: relative;
}
.filter-tip {
color: #93a4b5;
font-size: 11.5px;
}
.dot {
flex: none;
width: 8px;
height: 8px;
border-radius: 50%;
}
.dot.is-online {
background: #4f9a58;
}
.dot.is-offline {
background: #c2cdd8;
}
.form-row {
display: flex;
flex-wrap: wrap;
@@ -5,7 +5,7 @@ export interface TaskCenterTaskFilter {
username: string
moduleType: string
status: string
deviceId: string
/** 店铺名精确匹配(后端按 LOWER(TRIM(...)) 比较),候选来自 /shop-options 与面板下钻。 */
shop: string
startTime: string
endTime: string
@@ -19,7 +19,7 @@ export interface TaskCenterVariantFilter {
export type TaskCenterQueryParams = Record<string, string | number>
export function createTaskFilter(): TaskCenterTaskFilter {
return { username: '', moduleType: '', status: '', deviceId: '', shop: '', startTime: '', endTime: '' }
return { username: '', moduleType: '', status: '', shop: '', startTime: '', endTime: '' }
}
export function createVariantFilter(): TaskCenterVariantFilter {
@@ -173,7 +173,6 @@ export function buildTaskQuery(
put('username', text(filter.username))
put('moduleType', text(filter.moduleType))
put('status', text(filter.status))
put('deviceId', text(filter.deviceId))
put('shop', text(filter.shop))
put('startTime', toApiTime(filter.startTime))
put('endTime', toApiTime(filter.endTime))
@@ -43,11 +43,12 @@ test('task_center_guide_present_for_menu_key', () => {
assert.equal(guide.steps.length, 3)
})
test('task_center_api_has_five_endpoints', () => {
test('task_center_api_has_six_endpoints', () => {
const api = readSource(API)
for (const path of [
'/api/admin/task-center/overview',
'/api/admin/task-center/devices',
'/api/admin/task-center/shops',
'/api/admin/task-center/shop-options',
'/api/admin/task-center/tasks',
'/api/admin/task-center/tasks/detail',
'/api/admin/task-center/variant-tasks',
@@ -56,7 +57,8 @@ test('task_center_api_has_five_endpoints', () => {
}
for (const fn of [
'fetchTaskCenterOverview',
'fetchTaskCenterDevices',
'fetchTaskCenterShops',
'fetchTaskCenterShopOptions',
'fetchTaskCenterTasks',
'fetchTaskCenterTaskDetail',
'fetchTaskCenterVariantTasks',
@@ -66,6 +68,20 @@ test('task_center_api_has_five_endpoints', () => {
assert.match(api, /unwrap</, '统一走 unwrap 解包')
})
/** 设备维度已下线:卡片是店铺,接口不再有 /devices,筛选不再有 deviceId。 */
test('task_center_device_dimension_is_gone', () => {
const api = readSource(API)
const model = readSource('src/pages/task-center/task-center-model.ts')
const page = readSource(PAGE)
for (const dead of ['deviceTotal', 'deviceOnline', 'TaskCenterDevice', '/devices', 'fetchTaskCenterDevices']) {
assert.equal(api.includes(dead), false, `接口层不再有 ${dead}`)
}
assert.equal(model.includes("deviceId: ''"), false, '筛选条件不再有设备号')
assert.equal(/buildTaskQuery[\s\S]*put\('deviceId'/.test(model), false, '查询参数不再下传 deviceId')
assert.equal(page.includes('filter.deviceId'), false, '页面不再按设备筛')
assert.equal('deviceId' in createTaskFilter(), false)
})
test('task_center_status_labels_cover_backend_states', () => {
assert.equal(taskStatusLabel('PENDING'), '待执行')
assert.equal(taskStatusLabel('RUNNING'), '执行中')
@@ -118,7 +134,7 @@ test('task_center_progress_text_and_percent_boundaries', () => {
test('task_center_query_builder_omits_blanks_and_normalizes_time', () => {
const query = buildTaskQuery(
{ username: ' 张三 ', moduleType: 'COLLECT_DATA', status: 'RUNNING', deviceId: 'dev-1', shop: '', startTime: '2026-09-28T10:00', endTime: '' },
{ username: ' 张三 ', moduleType: 'COLLECT_DATA', status: 'RUNNING', shop: '林芳旗舰店', startTime: '2026-09-28T10:00', endTime: '' },
2,
20,
)
@@ -127,8 +143,7 @@ test('task_center_query_builder_omits_blanks_and_normalizes_time', () => {
assert.equal(query.username, '张三')
assert.equal(query.moduleType, 'COLLECT_DATA')
assert.equal(query.status, 'RUNNING')
assert.equal(query.deviceId, 'dev-1')
assert.equal(query.shop, undefined, '空白店铺不下传')
assert.equal(query.shop, '林芳旗舰店', '店铺名原样下传,由后端做 LOWER(TRIM) 精确匹配')
assert.equal(query.startTime, '2026-09-28T10:00:00')
assert.equal(query.endTime, undefined)
assert.equal(toApiTime(' 2026-09-28T10:00 '), '2026-09-28T10:00:00')
@@ -148,7 +163,7 @@ test('task_center_variant_query_builder_keeps_paging', () => {
test('task_center_filter_reset_clears_every_field', () => {
const filter = createTaskFilter()
assert.deepEqual(Object.values(filter), ['', '', '', '', '', '', ''])
assert.deepEqual(Object.values(filter), ['', '', '', '', '', ''])
assert.deepEqual(createVariantFilter(), { status: '' })
assert.deepEqual(buildTaskQuery(createTaskFilter(), 1, 20), { page: 1, pageSize: 20 }, '重置后只带分页参数')
assert.equal(variantAccountText({ username: 'wangwu', uid: '1048' }), 'wangwu')
@@ -159,7 +174,7 @@ 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, /暂无变体采集任务/, '变体空态')
assert.match(page, /ElMessage\.error/, '接口失败提示')
assert.match(page, /resetFilter/, '筛选重置接线')
@@ -167,6 +182,19 @@ 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', () => {
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/, '业务分布列')
assert.equal(page.includes('device-strip'), false, '设备卡条已删除')
})
test('task_center_page_wires_tabs_filters_and_polling', () => {
const page = readSource(PAGE)
assert.match(page, /客户端任务/, '页签一文案')
@@ -5,8 +5,8 @@ import com.nanri.aiimage.common.model.entity.AdminUserEntity;
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.TaskCenterDeviceVo;
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;
@@ -26,7 +26,7 @@ import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* 后台「客户端任务管理」:按账号 × 设备 × 业务统一看客户端任务,不必逐台排查。
* 后台「客户端任务管理」:按店铺 × 账号 × 业务统一看客户端任务,不必逐台客户端排查。
*
* <p>仅超管默认可见;管理员需超管在「用户管理 → 菜单权限」授权 {@code admin_task_center}
* 后才能访问。数据范围 = 本人 + 本组用户 + 自己管理的成员(超管不裁剪)。</p>
@@ -35,7 +35,7 @@ import java.util.List;
@RequiredArgsConstructor
@Slf4j
@RequestMapping("/api/admin/task-center")
@Tag(name = "客户端任务管理(后台)", description = "客户端任务与设备状态看板;设备号取自 JWT 签名 claim。")
@Tag(name = "客户端任务管理(后台)", description = "客户端任务与店铺在跑状态看板;全部只读。")
public class AdminTaskCenterController {
private final AdminAuthSupport adminAuthSupport;
@@ -45,24 +45,35 @@ public class AdminTaskCenterController {
private final TaskCenterVariantService variantService;
@GetMapping("/overview")
@Operation(summary = "汇总卡", description = "设备总数/在线数、进行中任务数、今日完成任务数、疑似卡住数(>10 分钟无更新)。")
@Operation(summary = "汇总卡", description = "总店铺/在跑店铺数、进行中任务数、今日完成任务数、"
+ "疑似卡住数(进行中且 >10 分钟无上报)。")
public ApiResponse<TaskCenterOverviewVo> overview(HttpServletRequest request) {
TaskCenterScopeService.ScopeContext scope = resolveScope(request);
return ApiResponse.success(queryService.overview(scope));
}
@GetMapping("/devices")
@Operation(summary = "设备列表",
description = "设备花名册(任务设备近 30 天 ∪ 客户端日志设备近 7 天)+ 在线/跑任务状态;在线优先排序。")
public ApiResponse<List<TaskCenterDeviceVo>> devices(HttpServletRequest request) {
@GetMapping("/shops")
@Operation(summary = "店铺面板",
description = "当前所有进行中任务按店铺归组:在跑任务数/疑似卡住数/业务分布/最近上报时间;"
+ "不落店铺的任务归进「不挂店铺」桶,与汇总卡的在跑店铺数同源。")
public ApiResponse<List<TaskCenterShopVo>> shops(HttpServletRequest request) {
TaskCenterScopeService.ScopeContext scope = resolveScope(request);
return ApiResponse.success(queryService.devices(scope));
return ApiResponse.success(queryService.shops(scope));
}
@GetMapping("/shop-options")
@Operation(summary = "店铺筛选候选",
description = "店铺库(biz_shop_manage)在可见范围内的店铺名,供筛选下拉精确匹配;只出店铺名。")
public ApiResponse<List<String>> shopOptions(HttpServletRequest request) {
TaskCenterScopeService.ScopeContext scope = resolveScope(request);
return ApiResponse.success(queryService.shopOptions(scope));
}
@GetMapping("/tasks")
@Operation(summary = "任务分页列表",
description = "biz_file_task(12 个客户端模块)∪ brand_crawl_tasks 按创建时间倒序;"
+ "店铺跨 4 个来源模糊匹配;进行中且 >10 分钟无更新标记 stuck。")
+ "店铺按规范化名精确匹配(来源=上架结果文件 + 逐店落行的结果文件名);"
+ "进行中且 >10 分钟无上报标记 stuck。")
public ApiResponse<TaskCenterTaskPageVo> tasks(HttpServletRequest request, TaskCenterTaskQuery query) {
TaskCenterScopeService.ScopeContext scope = resolveScope(request);
return ApiResponse.success(queryService.tasks(scope, query));
@@ -22,6 +22,10 @@ import java.util.stream.Collectors;
* (品牌检测自建表,不写 biz_file_task)。状态口径:biz_file_task 大写、brand_crawl_tasks
* 小写,这里统一在 SQL 内各自匹配,不依赖外层转换。</p>
*
* <p>看板维度是<b>店铺</b>不是设备:店铺只有两个真来源({@link #FILE_RESULT_SHOP_MODULES}
* 里的模块写 {@code biz_file_result.source_filename},上架写 {@code biz_publish_file.shop_name}),
* 店铺库取 {@code biz_shop_manage}。任务侧的存活口径是 {@code updated_at}(心跳与结果回传都会顶新)。</p>
*
* <p>范围裁剪:{@code userIds == null} 表示超管(不过滤);非超管传可见用户集合
* (空集由调用方兜底为 {@code [-1]},保证选中零行)。</p>
*/
@@ -49,6 +53,20 @@ public interface TaskCenterQueryMapper {
/** brand_crawl_tasks 终态。 */
Set<String> BRAND_TERMINAL_STATUS_SET = Set.of("success", "failed", "cancelled");
/**
* 逐行把「规范化后的店铺名」写进 {@code biz_file_result.source_filename} 的模块白名单
* (各模块在结果行落库时调 {@code ziniaoShopSwitchService.normalizeShopName})。
*
* <p>不能放宽:{@code source_filename} 对所有模块都写,其它模块写的就是上传文件名
* (如「采集中.xlsx」「货源查询 文档格式.xlsx」)。加成员前必须去核实该模块的逐店行写法,
* 由 {@code TaskCenterQueryMapperSqlTest.fileResultShopSourceIsLimitedToPerShopModules} 守住。</p>
*/
Set<String> FILE_RESULT_SHOP_MODULE_SET = Set.of("PATROL_DELETE", "PRICE_TRACK",
"PRODUCT_RISK_RESOLVE", "QUERY_ASIN", "SHOP_DATA_CRAWL", "SHOP_MATCH");
String FILE_RESULT_SHOP_MODULES = "'PATROL_DELETE','PRICE_TRACK','PRODUCT_RISK_RESOLVE',"
+ "'QUERY_ASIN','SHOP_DATA_CRAWL','SHOP_MATCH'";
String ACTIVE_STATUSES = "'PENDING','RUNNING','SCHEDULED'";
String TERMINAL_STATUSES = "'CANCELED','CANCELLED','FAILED','SUCCESS'";
String BRAND_ACTIVE_STATUSES = "'pending','running'";
@@ -60,73 +78,26 @@ public interface TaskCenterQueryMapper {
.collect(Collectors.joining(","));
}
/**
* 任务设备原始行:近 N 天创建过任务、设备号非空(biz_file_task ∪ brand_crawl_tasks)。
* {@code createdAt} 供「最近任务时间」,{@code activityAt} 供在线判定;任务侧没有设备名。
*/
String TASK_DEVICE_ROWS = "(SELECT t.device_id AS deviceId, NULL AS deviceName,"
+ " t.updated_at AS activityAt, t.created_at AS createdAt"
+ " FROM biz_file_task t"
+ " WHERE t.module_type IN (" + CLIENT_MODULE_TYPES + ")"
+ " AND t.device_id IS NOT NULL AND t.device_id != ''"
+ " AND t.created_at >= #{taskSince}"
+ " <if test='userIds != null'> AND t.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>"
+ " UNION ALL"
+ " SELECT b.device_id, NULL, b.updated_at, b.created_at FROM brand_crawl_tasks b"
+ " WHERE b.device_id IS NOT NULL AND b.device_id != ''"
+ " AND b.created_at >= #{taskSince}"
+ " <if test='userIds != null'> AND b.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>)";
/** 账号范围裁剪:两张任务表各写一份,别名不同。 */
String USER_SCOPE_T = "<if test='userIds != null'> AND t.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>";
String USER_SCOPE_B = "<if test='userIds != null'> AND b.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>";
/**
* 日志设备原始行:客户端日志、uid 非空(为空无法归组)、近 N 天有上报。
* {@code createdAt} 恒空,只为了与任务侧列对齐。
*
* <p>{@code device_id} 必须显式 COLLATE:本表列是 utf8mb4_0900_ai_ci,两张任务表是
* utf8mb4_general_ci,三个 UNION 分支混排规则会直接报 ERROR 1271。</p>
*/
String LOG_DEVICE_ROWS = "(SELECT d.device_id COLLATE utf8mb4_general_ci AS deviceId,"
+ " d.device_name AS deviceName,"
+ " COALESCE(d.last_upload_at, d.updated_at) AS activityAt, NULL AS createdAt"
+ " FROM device_log_file d"
+ " WHERE d.source = 'client'"
+ " AND d.device_id != ''"
+ " AND d.uid IS NOT NULL"
+ " AND d.last_upload_at >= #{logSince}"
+ " <if test='userIds != null'> AND d.uid IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>)";
/** 设备花名册:任务设备 ∪ 日志设备(同设备多行由外层聚合)。 */
String ROSTER_ROWS = "(" + TASK_DEVICE_ROWS + " UNION ALL " + LOG_DEVICE_ROWS + ")";
/** 进行中任务原始行(带设备号),供按设备计数。 */
String RUNNING_TASK_DEVICE_ROWS = "(SELECT t.device_id AS deviceId"
+ " FROM biz_file_task t"
+ " WHERE t.module_type IN (" + CLIENT_MODULE_TYPES + ")"
+ " AND t.status IN (" + ACTIVE_STATUSES + ")"
+ " AND t.device_id IS NOT NULL AND t.device_id != ''"
+ " <if test='userIds != null'> AND t.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>"
+ " UNION ALL"
+ " SELECT b.device_id FROM brand_crawl_tasks b"
+ " WHERE b.status IN (" + BRAND_ACTIVE_STATUSES + ")"
+ " AND b.device_id IS NOT NULL AND b.device_id != ''"
+ " <if test='userIds != null'> AND b.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>)";
/** 店铺库范围裁剪({@code biz_shop_manage.created_by_id} = 归属账号)。 */
String USER_SCOPE_S = "<if test='userIds != null'> AND s.created_by_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>";
@Select("<script>"
+ "SELECT COUNT(*) FROM ("
+ " SELECT t.id FROM biz_file_task t"
+ " WHERE t.module_type IN (" + CLIENT_MODULE_TYPES + ")"
+ " AND t.status IN (" + ACTIVE_STATUSES + ")"
+ " <if test='userIds != null'> AND t.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>"
+ USER_SCOPE_T
+ " UNION ALL"
+ " SELECT b.id FROM brand_crawl_tasks b"
+ " WHERE b.status IN (" + BRAND_ACTIVE_STATUSES + ")"
+ " <if test='userIds != null'> AND b.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>"
+ USER_SCOPE_B
+ ") u"
+ "</script>")
long countRunningTasks(@Param("userIds") List<Long> userIds);
@@ -137,14 +108,12 @@ public interface TaskCenterQueryMapper {
+ " WHERE t.module_type IN (" + CLIENT_MODULE_TYPES + ")"
+ " AND t.status IN (" + ACTIVE_STATUSES + ")"
+ " AND t.updated_at &lt; #{idleBefore}"
+ " <if test='userIds != null'> AND t.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>"
+ USER_SCOPE_T
+ " UNION ALL"
+ " SELECT b.id FROM brand_crawl_tasks b"
+ " WHERE b.status IN (" + BRAND_ACTIVE_STATUSES + ")"
+ " AND b.updated_at &lt; #{idleBefore}"
+ " <if test='userIds != null'> AND b.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>"
+ USER_SCOPE_B
+ ") u"
+ "</script>")
long countStuckTasks(@Param("userIds") List<Long> userIds,
@@ -156,56 +125,36 @@ public interface TaskCenterQueryMapper {
+ " WHERE t.module_type IN (" + CLIENT_MODULE_TYPES + ")"
+ " AND t.status IN (" + TERMINAL_STATUSES + ")"
+ " AND COALESCE(t.finished_at, t.updated_at) >= #{since}"
+ " <if test='userIds != null'> AND t.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>"
+ USER_SCOPE_T
+ " UNION ALL"
+ " SELECT b.id FROM brand_crawl_tasks b"
+ " WHERE b.status IN (" + BRAND_TERMINAL_STATUSES + ")"
+ " AND b.updated_at >= #{since}"
+ " <if test='userIds != null'> AND b.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>"
+ USER_SCOPE_B
+ ") u"
+ "</script>")
long countFinishedTasksSince(@Param("userIds") List<Long> userIds,
@Param("since") LocalDateTime since);
/** 总店铺:店铺库(biz_shop_manage)在可见账号下的数量。 */
@Select("<script>"
+ "SELECT COUNT(DISTINCT u.deviceId) FROM " + ROSTER_ROWS + " u"
+ "SELECT COUNT(*) FROM biz_shop_manage s WHERE 1 = 1"
+ USER_SCOPE_S
+ "</script>")
long countRosterDevices(@Param("userIds") List<Long> userIds,
@Param("taskSince") LocalDateTime taskSince,
@Param("logSince") LocalDateTime logSince);
long countShops(@Param("userIds") List<Long> userIds);
/**
* 店铺筛选下拉候选:只取店铺名。
*
* <p>biz_shop_manage 里带 account/password/zn_username,这一列之外的都不能出,
* 由 {@code TaskCenterQueryMapperSqlTest.shopOptionsAreDistinctNamesWithoutCredentialColumns} 守住。</p>
*/
@Select("<script>"
+ "SELECT COUNT(*) FROM ("
+ " SELECT u.deviceId, MAX(u.activityAt) AS lastActiveAt FROM " + ROSTER_ROWS + " u"
+ " GROUP BY u.deviceId"
+ " HAVING MAX(u.activityAt) >= #{onlineSince}"
+ ") online"
+ "SELECT DISTINCT s.shop_name FROM biz_shop_manage s WHERE 1 = 1"
+ USER_SCOPE_S
+ " ORDER BY s.shop_name LIMIT 2000"
+ "</script>")
long countOnlineDevices(@Param("userIds") List<Long> userIds,
@Param("taskSince") LocalDateTime taskSince,
@Param("logSince") LocalDateTime logSince,
@Param("onlineSince") LocalDateTime onlineSince);
/** 设备花名册列表:名称取日志侧,活动时间取两侧最大,最近任务时间取任务侧最大创建时间。 */
@Select("<script>"
+ "SELECT u.deviceId AS deviceId, MAX(u.deviceName) AS deviceName,"
+ " MAX(u.activityAt) AS lastActiveAt, MAX(u.createdAt) AS recentTaskAt"
+ " FROM " + ROSTER_ROWS + " u"
+ " GROUP BY u.deviceId"
+ "</script>")
List<TaskCenterDeviceRow> listRosterDevices(@Param("userIds") List<Long> userIds,
@Param("taskSince") LocalDateTime taskSince,
@Param("logSince") LocalDateTime logSince);
/** 按设备统计进行中任务数(设备号为空的任务不归属任何设备)。 */
@Select("<script>"
+ "SELECT u.deviceId AS deviceId, COUNT(*) AS runningTasks"
+ " FROM " + RUNNING_TASK_DEVICE_ROWS + " u"
+ " GROUP BY u.deviceId"
+ "</script>")
List<TaskCenterDeviceRow> countRunningTasksByDevice(@Param("userIds") List<Long> userIds);
List<String> selectShopNames(@Param("userIds") List<Long> userIds);
/** 状态归一化:CANCELED 并入 CANCELLED(历史脏值),前端只认一套。 */
String STATUS_T = "CASE WHEN UPPER(t.status) = 'CANCELED' THEN 'CANCELLED' ELSE UPPER(t.status) END";
@@ -213,27 +162,37 @@ public interface TaskCenterQueryMapper {
/** 品牌表状态本是小写,统一 UPPER 输出。 */
String STATUS_B = "CASE WHEN UPPER(b.status) = 'CANCELED' THEN 'CANCELLED' ELSE UPPER(b.status) END";
/** biz_file_task 分支列(列表与店铺面板共用同一套列,避免两处漂移)。 */
String COLS_T = "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,"
+ " t.created_at AS createdAt, t.finished_at AS finishedAt, t.updated_at AS updatedAt,"
+ " t.source_file_count AS totalCount, t.success_file_count AS successCount,"
+ " t.failed_file_count AS failedCount, 0 AS brand";
/** brand_crawl_tasks 分支列(与 {@link #COLS_T} 同序)。 */
String COLS_B = "b.id, CONCAT('brand-', b.id), 'BRAND', " + STATUS_B + ", b.user_id, b.device_id,"
+ " b.created_at, CASE WHEN b.status IN (" + BRAND_TERMINAL_STATUSES + ")"
+ " THEN b.updated_at END, b.updated_at,"
+ " b.progress_total, b.progress_current, 0, 1";
/**
* 店铺筛选:四个来源任一命中即可(去重靠 EXISTS,不需要 JOIN 放大行数)。
* 四张表都有 task_id 索引,子查询由外层行驱动;request_json 兜底不参与筛选。
* 店铺筛选:两个真来源任一命中即可(去重靠 EXISTS,不需要 JOIN 放大行数)。
*
* <p>按 {@code LOWER(TRIM(...))} 规范化后<b>精确</b>匹配:面板行下钻和下拉候选给的都是
* 整名,模糊 LIKE 会把「林芳」命中「林芳芳」。biz_file_result 一侧必须带模块白名单,
* 否则会把采集数据/货源查询的上传文件名当店铺。</p>
*/
String SHOP_FILTER_T = "<if test='shop != null'>"
+ " AND (EXISTS (SELECT 1 FROM biz_publish_file p"
+ " WHERE p.task_id = t.id AND p.shop_name LIKE CONCAT('%', #{shop}, '%'))"
+ " OR EXISTS (SELECT 1 FROM biz_task_result_item i"
+ " WHERE i.task_id = t.id AND i.scope_key LIKE CONCAT('%', #{shop}, '%'))"
+ " OR EXISTS (SELECT 1 FROM biz_file_result f"
+ " WHERE f.task_id = t.id AND f.source_filename LIKE CONCAT('%', #{shop}, '%'))"
+ " OR EXISTS (SELECT 1 FROM biz_task_progress_snapshot s"
+ " WHERE s.task_id = t.id AND s.current_scope_key LIKE CONCAT('%', #{shop}, '%')))"
+ "</if>";
+ " WHERE p.task_id = t.id AND LOWER(TRIM(p.shop_name)) = LOWER(TRIM(#{shop})))"
+ " OR (t.module_type IN (" + FILE_RESULT_SHOP_MODULES + ") AND EXISTS (SELECT 1 FROM biz_file_result f"
+ " WHERE f.task_id = t.id AND LOWER(TRIM(f.source_filename)) = LOWER(TRIM(#{shop}))))"
+ ")</if>";
/** biz_file_task 分支筛选(账号范围 + 业务/状态/设备/时间范围 + 店铺)。 */
String TASK_FILTER_T = "<if test='userIds != null'> AND t.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</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>"
+ "<if test='deviceId != null'> AND t.device_id = #{deviceId}</if>"
+ "<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;
@@ -242,11 +201,9 @@ public interface TaskCenterQueryMapper {
* 品牌分支筛选:业务名固定 BRAND(选了别的业务则该分支恒空);品牌任务不存店铺,
* 带店铺筛选时直接排除——否则品牌 id 与 biz id 撞号会被 EXISTS 误判命中。
*/
String TASK_FILTER_B = "<if test='userIds != null'> AND b.user_id IN"
+ " <foreach collection='userIds' item='uid' open='(' separator=',' close=')'>#{uid}</foreach></if>"
String TASK_FILTER_B = USER_SCOPE_B
+ "<if test='moduleType != null'> AND 'BRAND' = #{moduleType}</if>"
+ "<if test='status != null'> AND " + STATUS_B + " = #{status}</if>"
+ "<if test='deviceId != null'> AND b.device_id = #{deviceId}</if>"
+ "<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>";
@@ -255,24 +212,30 @@ public interface TaskCenterQueryMapper {
* 任务列表行:biz_file_task(12 个客户端模块)∪ brand_crawl_tasks。
* 品牌行 task_no 合成 {@code brand-<id>},终态时用 updated_at 充当 finished_at。
*/
String TASK_LIST_ROWS = "(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,"
+ " t.created_at AS createdAt, t.finished_at AS finishedAt, t.updated_at AS updatedAt,"
+ " t.source_file_count AS totalCount, t.success_file_count AS successCount,"
+ " t.failed_file_count AS failedCount, 0 AS brand"
String TASK_LIST_ROWS = "(SELECT " + COLS_T
+ " FROM biz_file_task t"
+ " WHERE t.module_type IN (" + CLIENT_MODULE_TYPES + ")"
+ TASK_FILTER_T
+ " UNION ALL"
+ " SELECT b.id, CONCAT('brand-', b.id), 'BRAND', " + STATUS_B + ", b.user_id, b.device_id,"
+ " b.created_at, CASE WHEN b.status IN (" + BRAND_TERMINAL_STATUSES + ")"
+ " THEN b.updated_at END, b.updated_at,"
+ " b.progress_total, b.progress_current, 0, 1"
+ " SELECT " + COLS_B
+ " FROM brand_crawl_tasks b"
+ " WHERE 1 = 1"
+ TASK_FILTER_B
+ ")";
/** 进行中任务行:与列表同一套列,只按「客户端模块 ∪ 品牌 + 进行中」取,无筛选占位符。 */
String ACTIVE_TASK_ROWS = "(SELECT " + COLS_T
+ " FROM biz_file_task t"
+ " WHERE t.module_type IN (" + CLIENT_MODULE_TYPES + ")"
+ " AND t.status IN (" + ACTIVE_STATUSES + ")"
+ USER_SCOPE_T
+ " UNION ALL"
+ " SELECT " + COLS_B
+ " FROM brand_crawl_tasks b"
+ " WHERE b.status IN (" + BRAND_ACTIVE_STATUSES + ")"
+ USER_SCOPE_B
+ ")";
@Select("<script>"
+ "SELECT m.* FROM " + TASK_LIST_ROWS + " m"
+ " ORDER BY m.createdAt DESC, m.id DESC"
@@ -281,7 +244,6 @@ public interface TaskCenterQueryMapper {
List<TaskCenterTaskRow> selectTaskPage(@Param("userIds") List<Long> userIds,
@Param("moduleType") String moduleType,
@Param("status") String status,
@Param("deviceId") String deviceId,
@Param("shop") String shop,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime,
@@ -294,11 +256,19 @@ public interface TaskCenterQueryMapper {
long countTaskPage(@Param("userIds") List<Long> userIds,
@Param("moduleType") String moduleType,
@Param("status") String status,
@Param("deviceId") String deviceId,
@Param("shop") String shop,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/** 店铺面板的原料:当前全部进行中任务(超管口径下上限 500,截断由服务层显式提示)。 */
@Select("<script>"
+ "SELECT m.* FROM " + ACTIVE_TASK_ROWS + " m"
+ " ORDER BY m.createdAt DESC, m.id DESC"
+ " LIMIT #{limit}"
+ "</script>")
List<TaskCenterTaskRow> selectActiveTasks(@Param("userIds") List<Long> userIds,
@Param("limit") long limit);
/** 账号名筛选 → 用户号(与可见账号集合求交由服务层负责)。 */
@Select("SELECT id FROM users WHERE username LIKE CONCAT('%', #{keyword}, '%') LIMIT 500")
List<Long> selectUserIdsByUsername(@Param("keyword") String keyword);
@@ -309,7 +279,7 @@ public interface TaskCenterQueryMapper {
+ "</script>")
List<TaskCenterUserRow> selectUsernames(@Param("userIds") List<Long> userIds);
/** 设备展示名(不限窗口:设备名与任务时间无关)。 */
/** 设备展示名(详情里保留「跑在哪台机」;列表与面板不再按设备装配)。 */
@Select("<script>"
+ "SELECT d.device_id AS deviceId, MAX(d.device_name) AS deviceName"
+ " FROM device_log_file d WHERE d.device_id IN"
@@ -329,25 +299,25 @@ public interface TaskCenterQueryMapper {
+ " GROUP BY p.task_id, p.shop_name"
+ "</script>")
List<TaskCenterShopRow> selectPublishShops(@Param("taskIds") List<Long> taskIds);
/** 店铺来源二:任务结果分组(scope_key)。 */
@Select("<script>"
+ "SELECT i.task_id AS taskId, i.scope_key AS shop FROM biz_task_result_item i"
+ " WHERE i.task_id IN <foreach collection='taskIds' item='tid' open='(' separator=',' close=')'>#{tid}</foreach>"
+ " AND i.scope_key IS NOT NULL AND i.scope_key != ''"
+ " GROUP BY i.task_id, i.scope_key"
+ "</script>")
List<TaskCenterShopRow> selectResultItemShops(@Param("taskIds") List<Long> taskIds);
/** 店铺来源三:结果文件名(跟价/定时匹配的文件名里带店铺)。 */
/**
* 店铺来源二:结果行的 source_filename,只认 {@link #FILE_RESULT_SHOP_MODULES} 里的模块
* (其余模块这里存的是上传文件名)。
*
* <p>JOIN 回 biz_file_task 而不是靠调用方保证:店铺面板传进来的是两表混合 id,
* 品牌任务 id 与 biz id 会撞号,白名单必须先由 biz 行筛掉。</p>
*/
@Select("<script>"
+ "SELECT f.task_id AS taskId, f.source_filename AS shop FROM biz_file_result f"
+ " JOIN biz_file_task ft ON ft.id = f.task_id"
+ " AND ft.module_type IN (" + FILE_RESULT_SHOP_MODULES + ")"
+ " WHERE f.task_id IN <foreach collection='taskIds' item='tid' open='(' separator=',' close=')'>#{tid}</foreach>"
+ " AND f.source_filename IS NOT NULL AND f.source_filename != ''"
+ " GROUP BY f.task_id, f.source_filename"
+ "</script>")
List<TaskCenterShopRow> selectFileResultShops(@Param("taskIds") List<Long> taskIds);
/** 进度快照(同时充当店铺来源四:current_scope_key)。按 (taskId, moduleType) 由服务层匹配。 */
/** 进度快照(只用于「当前处理」与进度列,不作为店铺来源)。按 (taskId, moduleType) 由服务层匹配。 */
@Select("<script>"
+ "SELECT s.task_id AS taskId, s.module_type AS moduleType, s.total_count AS totalCount,"
+ " s.success_count AS successCount, s.failed_count AS failedCount, s.pending_count AS pendingCount,"
@@ -357,13 +327,6 @@ public interface TaskCenterQueryMapper {
+ "</script>")
List<TaskCenterSnapshotRow> selectSnapshots(@Param("taskIds") List<Long> taskIds);
/** 店铺兜底:请求体 items[].shopName(只在前面四个来源都为空时按需拉取,避免列表查询带大 JSON 列)。 */
@Select("<script>"
+ "SELECT t.id AS id, t.request_json AS requestJson FROM biz_file_task t"
+ " WHERE t.id IN <foreach collection='taskIds' item='tid' open='(' separator=',' close=')'>#{tid}</foreach>"
+ "</script>")
List<TaskCenterTaskRow> selectRequestJson(@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,"
@@ -385,7 +348,7 @@ public interface TaskCenterQueryMapper {
+ " FROM brand_crawl_tasks b WHERE b.id = #{id}")
TaskCenterTaskRow selectBrandTaskById(@Param("id") Long id);
/** 详情店铺明细(上架):按店铺聚合文件数 + 成功/失败文件数,最多的排前面。 */
/** 详情分组明细(上架):按店铺聚合文件数 + 成功/失败文件数,最多的排前面。 */
@Select("SELECT p.shop_name AS scopeKey, COUNT(*) AS total,"
+ " SUM(UPPER(p.status) = 'SUCCESS') AS success, SUM(UPPER(p.status) = 'FAILED') AS failed"
+ " FROM biz_publish_file p"
@@ -2,26 +2,11 @@ package com.nanri.aiimage.modules.taskcenter.model.dto;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 设备聚合行:三条查询各填一部分字段(MyBatis 自动映射,未选出的列留空)。
*
* <ul>
* <li>花名册查询(任务设备 ∪ 日志设备):deviceId / deviceName / lastActiveAt / recentTaskAt</li>
* <li>进行中统计(按设备):deviceId / runningTasks</li>
* </ul>
*/
/** 设备展示名行(详情里「跑在哪台机」用;看板维度是店铺,不再装配设备列表)。 */
@Data
public class TaskCenterDeviceRow {
private String deviceId;
/** 日志侧展示名(机器名/登录名);任务侧无此数据。 */
private String deviceName;
/** 最近活动:任务 updated_at ∪ 日志上报时间。 */
private LocalDateTime lastActiveAt;
/** 最近一次任务的创建时间(30 天窗口内)。 */
private LocalDateTime recentTaskAt;
/** 该设备进行中任务数。 */
private Long runningTasks;
}
@@ -5,7 +5,7 @@ import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
/** 任务列表查询条件(账号/业务/状态/设备/店铺/时间范围 + 分页)。 */
/** 任务列表查询条件(账号/业务/状态/店铺/时间范围 + 分页)。 */
@Data
public class TaskCenterTaskQuery {
@@ -14,8 +14,7 @@ public class TaskCenterTaskQuery {
private String moduleType;
/** 大写状态:PENDING/RUNNING/SCHEDULED/SUCCESS/FAILED/CANCELLED。 */
private String status;
private String deviceId;
/** 店铺模糊匹配(跨 4 个来源的 EXISTS)。 */
/** 店铺名精确匹配(规范化为小写 + trim 后比较;候选来自店铺库与面板下钻)。 */
private String shop;
/** 任务创建时间(含),ISO-8601。 */
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
@@ -28,8 +28,6 @@ public class TaskCenterTaskRow {
private Long successCount;
private Long failedCount;
private boolean brand;
/** 仅店铺兜底查询填充(列表主查询不拉大 JSON 列)。 */
private String requestJson;
/** 仅详情查询填充(列表不带这一列)。 */
private String errorMessage;
}
@@ -1,24 +0,0 @@
package com.nanri.aiimage.modules.taskcenter.model.vo;
import lombok.Data;
import java.time.LocalDateTime;
/** 设备状态行:花名册内的设备 + 在线/跑任务状态。 */
@Data
public class TaskCenterDeviceVo {
private String deviceId;
/** 展示名(device_log_file 的主机名/登录名);任务侧设备无此字段,前端按 deviceId 截断显示。 */
private String deviceName;
/** 最近活动时间;为空表示只有进行中任务、窗口内无活动记录。 */
private LocalDateTime lastActiveAt;
/** 在线 = 最近活动 ≤ 5 分钟。 */
private boolean online;
/** 该设备进行中任务数。 */
private long runningTasks;
/** 最近一次任务创建时间(30 天窗口内)。 */
private LocalDateTime recentTaskAt;
/** 网页登录设备(device_id 前缀 web-)。 */
private boolean webDevice;
}
@@ -3,19 +3,22 @@ package com.nanri.aiimage.modules.taskcenter.model.vo;
import lombok.Data;
/**
* 客户端任务管理汇总卡。设备口径见设备花名册(任务设备近 30 天 ∪ 日志设备近 7 天)。
* 客户端任务管理汇总卡(店铺口径)。
*
* <p>总店铺来自店铺库 {@code biz_shop_manage},在跑店铺来自进行中任务的店铺归属聚合,
* 两者口径不同:后者是前者的子集,加上「不挂店铺」的任务不进任何店铺。</p>
*/
@Data
public class TaskCenterOverviewVo {
/** 花名册设备总数。 */
private long deviceTotal;
/** 在线设备数(最近上报 ≤ 5 分钟)。 */
private long deviceOnline;
/** 店铺库里的店铺数(可见范围内)。 */
private long shopTotal;
/** 有进行中任务的店铺数(不含「不挂店铺」桶)。 */
private long shopRunning;
/** 进行中任务数(含品牌检测)。 */
private long runningTasks;
/** 今日完成任务数(终态且完成时间在今日)。 */
private long todayFinishedTasks;
/** 疑似卡住:进行中且超过 10 分钟无更新。 */
/** 疑似卡住:进行中且超过 10 分钟无上报。 */
private long stuckTasks;
}
@@ -0,0 +1,28 @@
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;
}
@@ -18,14 +18,16 @@ public class TaskCenterTaskRowVo {
private Long userId;
private String username;
private String deviceId;
/** device_log_file 的设备名;查不到时前端按 deviceId 截断显示。 */
/** device_log_file 的设备名;只在详情装配(列表与店铺面板不再按设备看)。 */
private String deviceName;
private boolean webDevice;
/** 店铺:主来源的第一个店铺名(多店铺时前端显示「共 N 个」)。 */
/** 店铺:主来源的第一个店铺名(多店铺时前端显示「共 N 个」);来源只有上架结果文件与逐店落行的结果文件名。 */
private String shopName;
private long shopCount;
private LocalDateTime createdAt;
private LocalDateTime finishedAt;
/** 最近一次上报(updated_at;心跳与结果回传都会顶新)。进行中且它超过 10 分钟即疑似卡住。 */
private LocalDateTime lastReportAt;
private long progressTotal;
private long progressSuccess;
private long progressFailed;
@@ -1,8 +1,5 @@
package com.nanri.aiimage.modules.taskcenter.service;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.module.TaskModuleRegistry;
import com.nanri.aiimage.modules.taskcenter.mapper.TaskCenterQueryMapper;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterDeviceRow;
@@ -12,13 +9,14 @@ import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterSnapshotRow;
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.TaskCenterDeviceVo;
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;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.LocalDate;
@@ -26,103 +24,163 @@ 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.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 客户端任务管理的只读查询。时间口径:卡住 10 分钟、在线 5 分钟、
* 任务设备回看 30 天、日志设备回看 7 天。
* 客户端任务管理的只读查询,看板维度是<b>店铺</b>。
*
* <p>时间口径只有一个:进行中且 {@code updated_at} 超过 10 分钟没动 = 疑似卡住。
* {@code updated_at} 由客户端心跳(60s)与结果回传共同顶新,所以「在跑的任务必然在上报」
* 是这条判定的前提;设备维度不再参与统计(设备号只在详情里作为附注展示)。</p>
*
* <p>店铺面板与汇总卡共用 {@link #aggregateShops} 一份聚合,卡片说几家在跑、面板就列几行,
* 不允许两个数字各算各的。</p>
*/
@Service
@RequiredArgsConstructor
@Slf4j
public class TaskCenterQueryService {
private static final long STUCK_IDLE_MINUTES = 10;
private static final long ONLINE_WINDOW_MINUTES = 5;
private static final long TASK_DEVICE_WINDOW_DAYS = 30;
private static final long LOG_DEVICE_WINDOW_DAYS = 7;
/** 面板原料的行数上界:进行中任务正常在几十量级,触顶时打 warn(汇总卡仍按 SQL 精确计数)。 */
private static final long SHOP_PANEL_TASK_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 ObjectMapper JSON = new ObjectMapper();
/** 面板排序:该去看谁的店排前面——有卡住的先,其次最久没上报的,「不挂店铺」桶永远垫底。 */
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();
LocalDateTime taskSince = now.minusDays(TASK_DEVICE_WINDOW_DAYS);
LocalDateTime logSince = now.minusDays(LOG_DEVICE_WINDOW_DAYS);
List<Long> userIds = scope.sqlUserIds();
ShopBoard board = aggregateShops(userIds, now);
TaskCenterOverviewVo vo = new TaskCenterOverviewVo();
vo.setShopTotal(queryMapper.countShops(userIds));
vo.setShopRunning(board.runningShops());
vo.setRunningTasks(queryMapper.countRunningTasks(userIds));
vo.setStuckTasks(queryMapper.countStuckTasks(userIds, now.minusMinutes(STUCK_IDLE_MINUTES)));
vo.setTodayFinishedTasks(queryMapper.countFinishedTasksSince(userIds, LocalDate.now().atStartOfDay()));
vo.setDeviceTotal(queryMapper.countRosterDevices(userIds, taskSince, logSince));
vo.setDeviceOnline(queryMapper.countOnlineDevices(userIds, taskSince, logSince,
now.minusMinutes(ONLINE_WINDOW_MINUTES)));
return vo;
}
/** 设备花名册:任务设备 ∪ 日志设备,在线优先、活动时间倒序。 */
public List<TaskCenterDeviceVo> devices(TaskCenterScopeService.ScopeContext scope) {
LocalDateTime now = LocalDateTime.now();
List<Long> userIds = scope.sqlUserIds();
Map<String, TaskCenterDeviceVo> byDevice = new LinkedHashMap<>();
for (TaskCenterDeviceRow row : queryMapper.listRosterDevices(userIds,
now.minusDays(TASK_DEVICE_WINDOW_DAYS), now.minusDays(LOG_DEVICE_WINDOW_DAYS))) {
TaskCenterDeviceVo vo = deviceOf(byDevice, row.getDeviceId());
if (vo != null) {
vo.setDeviceName(row.getDeviceName());
vo.setLastActiveAt(row.getLastActiveAt());
vo.setRecentTaskAt(row.getRecentTaskAt());
}
}
for (TaskCenterDeviceRow row : queryMapper.countRunningTasksByDevice(userIds)) {
TaskCenterDeviceVo vo = deviceOf(byDevice, row.getDeviceId());
if (vo != null && row.getRunningTasks() != null) {
vo.setRunningTasks(row.getRunningTasks());
}
}
LocalDateTime onlineSince = now.minusMinutes(ONLINE_WINDOW_MINUTES);
List<TaskCenterDeviceVo> devices = new ArrayList<>(byDevice.values());
for (TaskCenterDeviceVo vo : devices) {
vo.setOnline(vo.getLastActiveAt() != null && !vo.getLastActiveAt().isBefore(onlineSince));
}
devices.sort(Comparator
.comparing(TaskCenterDeviceVo::isOnline, Comparator.reverseOrder())
.thenComparing(TaskCenterDeviceVo::getLastActiveAt, Comparator.nullsLast(Comparator.reverseOrder()))
.thenComparing(vo -> vo.getDeviceName() == null ? "" : vo.getDeviceName())
.thenComparing(TaskCenterDeviceVo::getDeviceId));
return devices;
/** 店铺面板:当前所有进行中任务按店铺归组(含「不挂店铺」桶)。 */
public List<TaskCenterShopVo> shops(TaskCenterScopeService.ScopeContext scope) {
return aggregateShops(scope.sqlUserIds(), LocalDateTime.now()).rows();
}
/** 空设备号入册无意义(SQL 已滤,这里挡住直调服务或脏数据)。 */
private static TaskCenterDeviceVo deviceOf(Map<String, TaskCenterDeviceVo> byDevice, String deviceId) {
if (deviceId == null || deviceId.isBlank()) {
return null;
/** 店铺筛选下拉候选(店铺库内的店铺名,精确匹配用)。 */
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);
}
String key = deviceId.trim();
return byDevice.computeIfAbsent(key, id -> {
TaskCenterDeviceVo vo = new TaskCenterDeviceVo();
vo.setDeviceId(id);
vo.setWebDevice(id.startsWith("web-"));
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<>();
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);
}
}
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;
});
}
}
/** 任务列表:两表 UNION 分页 + 当页行的账号/设备名/店铺/进度装配。 */
/** 任务列表:两表 UNION 分页 + 当页行的账号/店铺/进度装配(设备名只在详情装配)。 */
public TaskCenterTaskPageVo tasks(TaskCenterScopeService.ScopeContext scope, TaskCenterTaskQuery query) {
long page = query.getPage() == null || query.getPage() < 1 ? 1 : query.getPage();
long pageSize = query.getPageSize() == null || query.getPageSize() < 1 ? DEFAULT_PAGE_SIZE
@@ -134,20 +192,20 @@ public class TaskCenterQueryService {
}
long total = queryMapper.countTaskPage(userIds, query.getModuleType(), query.getStatus(),
query.getDeviceId(), query.getShop(), query.getStartTime(), query.getEndTime());
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.getDeviceId(), query.getShop(), query.getStartTime(),
query.getEndTime(), pageSize, (page - 1) * pageSize);
query.getStatus(), query.getShop(), query.getStartTime(), query.getEndTime(),
pageSize, (page - 1) * pageSize);
if (rows == null || rows.isEmpty()) {
return TaskCenterTaskPageVo.empty(page, pageSize);
}
TaskCenterTaskPageVo vo = new TaskCenterTaskPageVo();
vo.setItems(assembleRows(rows, collectShops(rows)));
vo.setItems(assembleRows(rows));
vo.setTotal(total);
vo.setPage(page);
vo.setPageSize(pageSize);
@@ -190,7 +248,7 @@ public class TaskCenterQueryService {
return null;
}
List<TaskCenterTaskRow> rows = List.of(row);
List<Long> bizIds = row.isBrand() || row.getId() == null ? List.of() : List.of(row.getId());
List<String> deviceIds = row.getDeviceId() == null || row.getDeviceId().isBlank()
? List.of() : List.of(row.getDeviceId());
List<Long> userIds = row.getUserId() == null || row.getUserId() <= 0
@@ -199,11 +257,11 @@ public class TaskCenterQueryService {
: toDeviceNames(safe(queryMapper.selectDeviceNames(deviceIds)));
Map<Long, String> usernames = userIds.isEmpty() ? Map.of()
: toUserNames(safe(queryMapper.selectUsernames(userIds)));
Map<String, TaskCenterSnapshotRow> snapshots = toSnapshots(safe(queryMapper.selectSnapshots(List.of(row.getId()))));
Map<Long, List<String>> shops = collectShops(rows);
Map<String, TaskCenterSnapshotRow> snapshots = row.getId() == null ? Map.of()
: toSnapshots(safe(queryMapper.selectSnapshots(List.of(row.getId()))));
TaskCenterTaskDetailVo vo = fillRow(new TaskCenterTaskDetailVo(), row, usernames, deviceNames,
snapshots, shops, collectRequestShops(rows, shops, snapshots), LocalDateTime.now());
snapshots, collectShops(bizIds), LocalDateTime.now());
vo.setShops(shopStats(row));
vo.setErrorMessage(row.getErrorMessage());
return vo;
@@ -221,7 +279,7 @@ public class TaskCenterQueryService {
}
}
/** 详情分组明细:上架按店铺(publish_file),其余按任务结果分组(result_item);品牌无店铺维度。 */
/** 详情分组明细:上架按店铺(publish_file),其余按任务结果分组(result_item);品牌无分组维度。 */
private List<TaskCenterShopStatVo> shopStats(TaskCenterTaskRow row) {
if (row.isBrand() || row.getId() == null) {
return List.of();
@@ -241,27 +299,24 @@ public class TaskCenterQueryService {
return stats;
}
private List<TaskCenterTaskRowVo> assembleRows(List<TaskCenterTaskRow> rows, Map<Long, List<String>> shops) {
List<String> deviceIds = rows.stream().map(TaskCenterTaskRow::getDeviceId)
.filter(id -> id != null && !id.isBlank()).distinct().toList();
private List<TaskCenterTaskRowVo> assembleRows(List<TaskCenterTaskRow> rows) {
List<Long> userIds = rows.stream().map(TaskCenterTaskRow::getUserId)
.filter(id -> id != null && id > 0).distinct().toList();
List<Long> rowIds = rows.stream().map(TaskCenterTaskRow::getId)
.filter(Objects::nonNull).distinct().toList();
List<Long> bizIds = rows.stream().filter(row -> !row.isBrand())
.map(TaskCenterTaskRow::getId).filter(Objects::nonNull).distinct().toList();
Map<Long, String> usernames = userIds.isEmpty() ? Map.of()
: toUserNames(safe(queryMapper.selectUsernames(userIds)));
Map<String, String> deviceNames = deviceIds.isEmpty() ? Map.of()
: toDeviceNames(safe(queryMapper.selectDeviceNames(deviceIds)));
Map<String, TaskCenterSnapshotRow> snapshots = rowIds.isEmpty() ? Map.of()
: toSnapshots(safe(queryMapper.selectSnapshots(rowIds)));
Map<Long, List<String>> requestShops = collectRequestShops(rows, shops, snapshots);
Map<Long, List<String>> shops = collectShops(bizIds);
LocalDateTime now = LocalDateTime.now();
List<TaskCenterTaskRowVo> items = new ArrayList<>(rows.size());
for (TaskCenterTaskRow row : rows) {
items.add(fillRow(new TaskCenterTaskRowVo(), row, usernames, deviceNames, snapshots,
shops, requestShops, now));
items.add(fillRow(new TaskCenterTaskRowVo(), row, usernames, Map.of(), snapshots, shops, now));
}
return items;
}
@@ -305,97 +360,35 @@ public class TaskCenterQueryService {
}
/**
* 店铺候选:按来源优先级依次取第一个非空的来源
* (上架结果文件 → 任务结果分组 → 结果文件名 → 进度快照 → 请求体 items[].shopName)。
* 与各模块的主来源一致,未列出的模块自动降级到下一来源。品牌行不取店铺。
* 店铺归属:只有两个真来源——上架的 {@code biz_publish_file.shop_name} 与
* 逐店落行模块的 {@code biz_file_result.source_filename}(SQL 里已按模块白名单筛)。
*
* <p>任务结果分组与进度快照的 scope 都不是店铺(快照那是 {@code task:<id>:owner:<instance>}
* 实例锁),请求体兜底也不再用:宁可显示「不挂店铺」,不把文件名当店铺。</p>
*
* <p>入参只接 biz 表 id:品牌任务 id 会与 biz 撞号。</p>
*/
private Map<Long, List<String>> collectShops(List<TaskCenterTaskRow> rows) {
List<Long> bizIds = rows.stream().filter(row -> !row.isBrand())
.map(TaskCenterTaskRow::getId).filter(Objects::nonNull).distinct().toList();
private Map<Long, List<String>> collectShops(List<Long> bizIds) {
if (bizIds.isEmpty()) {
return Map.of();
}
Map<Long, List<String>> shops = new HashMap<>();
lazyMerge(bizIds, shops, missing -> toShops(safe(queryMapper.selectPublishShops(missing))));
lazyMerge(bizIds, shops, missing -> toShops(safe(queryMapper.selectResultItemShops(missing))));
lazyMerge(bizIds, shops, missing -> toShops(safe(queryMapper.selectFileResultShops(missing))));
Set<String> taken = new HashSet<>();
appendShops(safe(queryMapper.selectPublishShops(bizIds)), shops, taken);
appendShops(safe(queryMapper.selectFileResultShops(bizIds)), shops, taken);
return shops;
}
/** 只对仍缺店铺的任务打这个来源的批量查询;已命中的任务保持更高优先级。 */
private void lazyMerge(List<Long> ids, Map<Long, List<String>> target,
Function<List<Long>, Map<Long, List<String>>> source) {
List<Long> missing = ids.stream().filter(id -> !target.containsKey(id)).toList();
if (missing.isEmpty()) {
return;
}
for (Map.Entry<Long, List<String>> entry : source.apply(missing).entrySet()) {
target.putIfAbsent(entry.getKey(), entry.getValue());
}
}
private static Map<Long, List<String>> toShops(List<TaskCenterShopRow> rows) {
Map<Long, List<String>> map = new HashMap<>();
private static void appendShops(List<TaskCenterShopRow> rows, Map<Long, List<String>> shops, Set<String> taken) {
for (TaskCenterShopRow row : rows) {
if (row.getTaskId() != null && row.getShop() != null && !row.getShop().isBlank()) {
map.computeIfAbsent(row.getTaskId(), key -> new ArrayList<>()).add(row.getShop().trim());
}
}
return map;
}
/** 兜底:前四个来源都空时批量拉一次 request_json(列表主查询刻意不拉大 JSON 列)。 */
private Map<Long, List<String>> collectRequestShops(List<TaskCenterTaskRow> rows,
Map<Long, List<String>> shops,
Map<String, TaskCenterSnapshotRow> snapshots) {
List<Long> candidates = rows.stream()
.filter(row -> !row.isBrand() && row.getId() != null)
.filter(row -> {
List<String> hit = shops.get(row.getId());
if (hit != null && !hit.isEmpty()) {
return false;
}
TaskCenterSnapshotRow snapshot = snapshots.get(snapshotKey(row.getId(), row.getModuleType()));
return snapshot == null || snapshot.getCurrentScopeKey() == null
|| snapshot.getCurrentScopeKey().isBlank();
})
.map(TaskCenterTaskRow::getId).distinct().toList();
if (candidates.isEmpty()) {
return Map.of();
}
Map<Long, List<String>> result = new HashMap<>();
for (TaskCenterTaskRow row : safe(queryMapper.selectRequestJson(candidates))) {
if (row.getId() == null || row.getRequestJson() == null) {
String shop = row.getShop() == null ? "" : row.getShop().trim();
if (row.getTaskId() == null || shop.isEmpty()) {
continue;
}
List<String> names = extractShopNames(row.getRequestJson());
if (!names.isEmpty()) {
result.put(row.getId(), names);
if (!taken.add(row.getTaskId() + "#" + shopKey(shop))) {
continue;
}
}
return result;
}
/** 解析 request_json 里的 items[].shopName(去重保序,容忍结构不认识)。 */
private static List<String> extractShopNames(String requestJson) {
if (requestJson.isBlank()) {
return List.of();
}
try {
JsonNode items = JSON.readTree(requestJson).path("items");
if (!items.isArray()) {
return List.of();
}
LinkedHashSet<String> names = new LinkedHashSet<>();
for (JsonNode item : items) {
String shopName = item.path("shopName").asText(null);
if (shopName != null && !shopName.isBlank()) {
names.add(shopName.trim());
}
}
return List.copyOf(names);
} catch (JsonProcessingException ex) {
return List.of();
shops.computeIfAbsent(row.getTaskId(), key -> new ArrayList<>()).add(shop);
}
}
@@ -406,7 +399,6 @@ public class TaskCenterQueryService {
Map<String, String> deviceNames,
Map<String, TaskCenterSnapshotRow> snapshots,
Map<Long, List<String>> shops,
Map<Long, List<String>> requestShops,
LocalDateTime now) {
vo.setId(row.getId());
vo.setTaskNo(row.getTaskNo());
@@ -420,6 +412,7 @@ public class TaskCenterQueryService {
vo.setWebDevice(row.getDeviceId() != null && row.getDeviceId().startsWith("web-"));
vo.setCreatedAt(row.getCreatedAt());
vo.setFinishedAt(row.getFinishedAt());
vo.setLastReportAt(row.getUpdatedAt() == null ? row.getCreatedAt() : row.getUpdatedAt());
vo.setStuck(isStuck(row, now));
TaskCenterSnapshotRow snapshot = snapshots.get(snapshotKey(row.getId(), row.getModuleType()));
@@ -438,13 +431,6 @@ public class TaskCenterQueryService {
// 品牌检测按关键字执行、不落店铺;品牌行的 current_scope_key 是品牌名,不能当店铺用。
if (!row.isBrand()) {
List<String> rowShops = shops.get(row.getId());
if ((rowShops == null || rowShops.isEmpty()) && snapshot != null
&& snapshot.getCurrentScopeKey() != null && !snapshot.getCurrentScopeKey().isBlank()) {
rowShops = List.of(snapshot.getCurrentScopeKey().trim());
}
if (rowShops == null || rowShops.isEmpty()) {
rowShops = requestShops.get(row.getId());
}
if (rowShops != null && !rowShops.isEmpty()) {
vo.setShopName(rowShops.get(0));
vo.setShopCount(rowShops.size());
@@ -461,6 +447,11 @@ public class TaskCenterQueryService {
return lastSeen != null && lastSeen.isBefore(now.minusMinutes(STUCK_IDLE_MINUTES));
}
/** 店铺名的归一化键:与 SQL 的 LOWER(TRIM(...)) 同口径,面板下钻与筛选才对得上。 */
private static String shopKey(String shopName) {
return shopName.trim().toLowerCase(Locale.ROOT);
}
private static long nullToZero(Long value) {
return value == null ? 0L : value;
}
@@ -54,6 +54,12 @@ 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,
"startTime", null, "endTime", null, "limit", limit, "offset", offset);
}
@Test
void runningCountWithoutScopeFiltersNothing() {
BoundSql boundSql = render("countRunningTasks", params("userIds", null));
@@ -104,75 +110,67 @@ class TaskCenterQueryMapperSqlTest {
assertEquals(4, boundSql.getParameterMappings().size());
}
// ── 店铺面板(Task 4)──────────────────────────────────────────────
@Test
void rosterExcludesBlankDeviceAndUngroupedLogDevices() {
LocalDateTime since = LocalDateTime.of(2026, 9, 1, 0, 0);
BoundSql boundSql = render("countRosterDevices",
params("userIds", List.of(5L), "taskSince", since, "logSince", since));
void shopTotalCountsOnlyTheShopRegistry() {
BoundSql boundSql = render("countShops", params("userIds", List.of(5L)));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("SELECT COUNT(DISTINCT u.deviceId)"));
assertTrue(sql.contains("d.device_id != ''"), "空设备号不参与");
assertTrue(sql.contains("d.uid IS NOT NULL"), "无归属账号的日志设备不显示");
assertTrue(sql.contains("d.source = 'client'"), "只看客户端日志设备");
assertTrue(sql.contains("AND d.last_upload_at >= ?"), "日志设备回看窗口");
assertEquals(6, boundSql.getParameterMappings().size(), "任务窗口×2 + 日志窗口 + 账号集合×3");
}
/**
* 日志表 device_id 是 utf8mb4_0900_ai_ci,任务表是 utf8mb4_general_ci;不显式 COLLATE
* 三个 UNION 分支混排会报 ERROR 1271(本地不连库测不出,生产库空跑才能发现)。
*/
@Test
void rosterDeviceIdUnifiesCollationBeforeUnion() {
LocalDateTime since = LocalDateTime.of(2026, 9, 1, 0, 0);
String sql = sqlOf(render("countRosterDevices",
params("userIds", null, "taskSince", since, "logSince", since)));
assertTrue(sql.contains("d.device_id COLLATE utf8mb4_general_ci AS deviceId"),
"日志侧 device_id 显式统一排序规则");
assertTrue(sql.contains("SELECT COUNT(*) FROM biz_shop_manage s"));
assertTrue(sql.contains("AND s.created_by_id IN(?)"), "非超管按可见账号裁剪店铺库");
assertFalse(sql.contains("device_log_file"), "总店铺不看设备花名册");
assertEquals(1, boundSql.getParameterMappings().size());
}
@Test
void rosterListAggregatesNameAndRecencyPerDevice() {
LocalDateTime since = LocalDateTime.of(2026, 9, 1, 0, 0);
BoundSql boundSql = render("listRosterDevices",
params("userIds", null, "taskSince", since, "logSince", since));
void shopTotalForSuperAdminSkipsScope() {
BoundSql boundSql = render("countShops", params("userIds", null));
assertFalse(sqlOf(boundSql).contains("created_by_id"), "超管不裁剪店铺库");
assertEquals(0, boundSql.getParameterMappings().size());
}
/** 店铺库里有 account/password/zn_username,候选下拉只能取店铺名。 */
@Test
void shopOptionsAreDistinctNamesWithoutCredentialColumns() {
BoundSql boundSql = render("selectShopNames", params("userIds", List.of(5L)));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("MAX(u.deviceName) AS deviceName"), "设备名取日志侧");
assertTrue(sql.contains("MAX(u.activityAt) AS lastActiveAt"), "活动时间取两侧最大");
assertTrue(sql.contains("MAX(u.createdAt) AS recentTaskAt"), "最近任务时间取任务侧最大创建时间");
assertTrue(sql.contains("GROUP BY u.deviceId"));
assertTrue(sql.contains("NULL AS deviceName"), "任务侧没有设备名");
assertTrue(sql.contains("NULL AS createdAt"), "日志侧不贡献最近任务时间");
assertTrue(sql.contains("SELECT DISTINCT s.shop_name FROM biz_shop_manage s"));
assertTrue(sql.contains("ORDER BY s.shop_name"), "店铺名去重、下拉稳定排序");
assertTrue(sql.contains("LIMIT 2000"), "候选数量有上界");
for (String secretColumn : List.of("password", "account", "zn_username", "mall_name")) {
assertFalse(sql.contains(secretColumn), "候选下拉不得带出凭据列: " + secretColumn);
}
assertEquals(1, boundSql.getParameterMappings().size());
}
@Test
void runningCountByDeviceCountsOnlyDevicelessRows() {
BoundSql boundSql = render("countRunningTasksByDevice", params("userIds", List.of(5L)));
void activeTaskRowsUseBothSourcesWithTheSameStatusSets() {
BoundSql boundSql = render("selectActiveTasks", params("userIds", List.of(5L), "limit", 500L));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("COUNT(*) AS runningTasks"));
assertTrue(sql.contains("GROUP BY u.deviceId"));
assertTrue(sql.contains("t.device_id IS NOT NULL AND t.device_id != ''"), "空设备号任务不归属设备");
assertTrue(sql.contains("b.device_id IS NOT NULL AND b.device_id != ''"));
assertEquals(2, boundSql.getParameterMappings().size(), "两张表各绑一次可见账号集合");
assertTrue(sql.contains("WHERE t.module_type IN('PUBLISH','DELETE_BRAND'"),
"只取客户端模块,服务端模块不入面板");
assertFalse(sql.contains("'DEDUPE'"), "去重为服务端执行,不进面板");
assertTrue(sql.contains("AND t.status IN('PENDING','RUNNING','SCHEDULED')"));
assertTrue(sql.contains("WHERE b.status IN('pending','running')"), "品牌表状态小写");
assertTrue(sql.contains("CONCAT('brand-',b.id)"), "面板含品牌检测任务");
assertTrue(sql.contains("t.updated_at AS updatedAt"), "最近上报时间来自 updated_at");
assertTrue(sql.contains("LIMIT ?"));
assertEquals(3, boundSql.getParameterMappings().size(),
"可见账号在 biz/品牌两分支各绑定一次 + 行数上限");
}
@Test
void onlineCountGroupsByDeviceAndKeepsOnlyFreshOnes() {
LocalDateTime since = LocalDateTime.of(2026, 9, 1, 0, 0);
BoundSql boundSql = render("countOnlineDevices",
params("userIds", null, "taskSince", since, "logSince", since,
"onlineSince", LocalDateTime.of(2026, 9, 28, 10, 0)));
String sql = sqlOf(boundSql);
void activeTaskRowsCarryNoFilterPlaceholders() {
String sql = sqlOf(render("selectActiveTasks", params("userIds", null, "limit", 500L)));
assertTrue(sql.contains("GROUP BY u.deviceId"));
assertTrue(sql.contains("HAVING MAX(u.activityAt) >= ?"));
assertFalse(sql.contains("t.device_id ="), "面板不按设备筛");
assertFalse(sql.contains("EXISTS"), "面板不带店铺 EXISTS");
assertFalse(sql.contains("request_json"), "面板不拉大 JSON 列");
assertFalse(sql.contains("__frch"), "超管不渲染账号占位符");
assertEquals(4, boundSql.getParameterMappings().size(),
"任务窗口×2 + 日志窗口 + 在线阈值");
}
@Test
@@ -188,9 +186,7 @@ class TaskCenterQueryMapperSqlTest {
@Test
void taskListUnionsBizAndBrandWithoutTouchingRequestJson() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", null, "moduleType", null, "status", null, "deviceId", null,
"shop", null, "startTime", null, "endTime", null, "limit", 20L, "offset", 0L));
BoundSql boundSql = render("selectTaskPage", taskPageParams(null, 20L, 0L));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("SELECT m.* FROM(SELECT t.id AS id"));
@@ -212,7 +208,7 @@ class TaskCenterQueryMapperSqlTest {
void taskListFiltersReachBothBranchesAndBrandDropsShopFilter() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", List.of(5L, 11L), "moduleType", "PUBLISH", "status", "RUNNING",
"deviceId", "pc-0001", "shop", "旗舰店",
"shop", "旗舰店",
"startTime", LocalDateTime.of(2026, 9, 1, 0, 0),
"endTime", LocalDateTime.of(2026, 9, 28, 0, 0),
"limit", 20L, "offset", 20L));
@@ -221,27 +217,37 @@ class TaskCenterQueryMapperSqlTest {
assertTrue(sql.contains("AND UPPER(t.module_type) = ?"));
assertTrue(sql.contains("AND t.user_id IN(?,?)"));
assertTrue(sql.contains("AND b.user_id IN(?,?)"));
assertTrue(sql.contains("AND t.device_id = ?"));
assertTrue(sql.contains("AND t.created_at >= ?"));
assertTrue(sql.contains("AND t.created_at <= ?"));
assertTrue(sql.contains("AND 'BRAND' = ?"), "选了具体业务时品牌分支恒空");
assertTrue(sql.contains("AND 1 = 0"), "品牌任务不存店铺:带店铺筛选直接排除该分支");
assertTrue(sql.contains("EXISTS(SELECT 1 FROM biz_publish_file p WHERE p.task_id = t.id AND p.shop_name LIKE CONCAT('%',?,'%'))"));
assertTrue(sql.contains("EXISTS(SELECT 1 FROM biz_task_result_item i WHERE i.task_id = t.id AND i.scope_key LIKE CONCAT('%',?,'%'))"));
assertTrue(sql.contains("EXISTS(SELECT 1 FROM biz_file_result f WHERE f.task_id = t.id AND f.source_filename LIKE CONCAT('%',?,'%'))"));
assertTrue(sql.contains("EXISTS(SELECT 1 FROM biz_task_progress_snapshot s WHERE s.task_id = t.id AND s.current_scope_key LIKE CONCAT('%',?,'%'))"));
assertTrue(sql.contains("EXISTS(SELECT 1 FROM biz_publish_file p WHERE p.task_id = t.id"
+ " AND LOWER(TRIM(p.shop_name)) = LOWER(TRIM(?)))"));
assertTrue(sql.contains("EXISTS(SELECT 1 FROM biz_file_result f WHERE f.task_id = t.id"
+ " AND LOWER(TRIM(f.source_filename)) = LOWER(TRIM(?)))"));
assertTrue(sql.contains("OR(t.module_type IN(" + TaskCenterQueryMapper.FILE_RESULT_SHOP_MODULES
+ ") AND EXISTS(SELECT 1 FROM biz_file_result f"),
"店铺筛选必须与店铺列同一条模块白名单,否则面板下钻会带出不该出现的任务");
assertFalse(sql.contains("LIKE CONCAT('%',?,'%')"), "店铺筛选按规范化精确匹配,模糊会命中同名前缀");
assertEquals(5L, boundSql.getAdditionalParameter("__frch_uid_0"));
assertEquals(20, boundSql.getParameterMappings().size(),
"biz 11(账号×2/业务/状态/设备/起止/店铺×4)+ 品牌 7(账号×2/业务/状态/设备/起止)+ 分页 2");
assertEquals(16, boundSql.getParameterMappings().size(),
"biz 8(账号×2/业务/状态/起止/店铺×2)+ 品牌 6(账号×2/业务/状态/起止)+ 分页 2");
}
@Test
void shopFilterDoesNotReadSnapshotScopeOrResultItemGroup() {
String filtered = sqlOf(render("selectTaskPage", taskPageParams("林芳", 20L, 0L)));
assertFalse(filtered.contains("biz_task_result_item"), "任务结果分组不是店铺来源");
assertFalse(filtered.contains("biz_task_progress_snapshot"), "进度快照不是店铺来源");
assertFalse(filtered.contains("current_scope_key"), "快照 scope 是实例锁,不能当店铺筛");
}
@Test
void taskListWithoutFiltersOnlyBindsPaging() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", null, "moduleType", null, "status", null, "deviceId", null,
"shop", null, "startTime", null, "endTime", null, "limit", 100L, "offset", 0L));
BoundSql boundSql = render("selectTaskPage", taskPageParams(null, 100L, 0L));
String sql = sqlOf(boundSql);
assertFalse(sql.contains("AND UPPER(t.module_type)"), "未选业务不加条件");
@@ -254,7 +260,7 @@ class TaskCenterQueryMapperSqlTest {
@Test
void taskCountSharesTheUnionBody() {
BoundSql boundSql = render("countTaskPage",
params("userIds", null, "moduleType", "BRAND", "status", "RUNNING", "deviceId", null,
params("userIds", null, "moduleType", "BRAND", "status", "RUNNING",
"shop", null, "startTime", null, "endTime", null));
String sql = sqlOf(boundSql);
@@ -280,28 +286,45 @@ class TaskCenterQueryMapperSqlTest {
String sql = sqlOf(boundSql);
assertTrue(sql.contains("s.module_type AS moduleType"), "品牌 id 与 biz id 可能撞号,必须带业务名");
assertTrue(sql.contains("s.current_scope_key AS currentScopeKey"));
assertTrue(sql.contains("s.current_scope_key AS currentScopeKey"), "快照 scope 只用于「当前处理」列");
assertEquals(2, boundSql.getParameterMappings().size());
}
/** 店铺只有两个真来源:上架结果文件的 shop_name、逐店落行的模块的 source_filename。 */
@Test
void shopSourcesAreBatchedByTaskId() {
assertTrue(sqlOf(render("selectPublishShops", params("taskIds", List.of(1L))))
.contains("GROUP BY p.task_id,p.shop_name"));
assertTrue(sqlOf(render("selectResultItemShops", params("taskIds", List.of(1L))))
.contains("GROUP BY i.task_id,i.scope_key"));
assertTrue(sqlOf(render("selectFileResultShops", params("taskIds", List.of(1L))))
.contains("GROUP BY f.task_id,f.source_filename"));
BoundSql publishSql = render("selectPublishShops", params("taskIds", List.of(1L, 2L)));
BoundSql fileResultSql = render("selectFileResultShops", params("taskIds", List.of(1L, 2L)));
String publish = sqlOf(publishSql);
String fileResult = sqlOf(fileResultSql);
assertTrue(publish.contains("GROUP BY p.task_id,p.shop_name"));
assertTrue(publish.contains("p.shop_name IS NOT NULL AND p.shop_name != ''"));
assertTrue(fileResult.contains("GROUP BY f.task_id,f.source_filename"));
assertTrue(fileResult.contains("f.source_filename IS NOT NULL AND f.source_filename != ''"));
assertEquals(2, publishSql.getParameterMappings().size(), "一次批量取,避免逐行 N+1");
assertEquals(2, fileResultSql.getParameterMappings().size());
}
/**
* biz_file_result.source_filename 对所有模块都写「上传文件名」,只有 6 个模块写的是店铺名;
* 不加模块白名单就会把「采集中.xlsx」当店铺显示。
*/
@Test
void fileResultShopSourceIsLimitedToPerShopModules() {
String sql = sqlOf(render("selectFileResultShops", params("taskIds", List.of(1L))));
assertTrue(sql.contains("JOIN biz_file_task ft ON ft.id = f.task_id"));
assertTrue(sql.contains("AND ft.module_type IN(" + TaskCenterQueryMapper.FILE_RESULT_SHOP_MODULES + ")"),
"逐行落店铺名的模块白名单必须是这条查询的条件");
assertFalse(sql.contains("biz_task_result_item"), "任务结果分组不是店铺来源");
assertFalse(sql.contains("biz_task_progress_snapshot"), "进度快照不是店铺来源");
}
@Test
void requestJsonLookupIsBatchedAndNarrow() {
BoundSql boundSql = render("selectRequestJson", params("taskIds", List.of(1L, 2L)));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("t.request_json AS requestJson"));
assertTrue(sql.contains("IN(?,?)"), "一次批量拉取,避免逐行 N+1");
assertEquals(2, boundSql.getParameterMappings().size());
void requestJsonFallbackIsGoneFromShopSources() {
assertFalse(sqlOf(render("selectPublishShops", params("taskIds", List.of(1L)))).contains("request_json"));
assertFalse(sqlOf(render("selectFileResultShops", params("taskIds", List.of(1L)))).contains("request_json"));
}
@Test
@@ -314,7 +337,7 @@ class TaskCenterQueryMapperSqlTest {
assertFalse(sql.contains("last_upload_at"), "设备名与任务时间无关,不限窗口");
}
/** 注解值必须是编译期常量,SQL 里只能写字面量;这条测试守住它与 Java 集合不漂移。 */
/** 注解值必须是编译期常量,SQL 里只能写字面量;这两条测试守住它们与 Java 集合不漂移。 */
@Test
void statusLiteralsStayInSyncWithSets() {
assertEquals(TaskCenterQueryMapper.sqlList(TaskCenterQueryMapper.ACTIVE_STATUS_SET),
@@ -327,6 +350,20 @@ class TaskCenterQueryMapperSqlTest {
TaskCenterQueryMapper.BRAND_TERMINAL_STATUSES);
}
/**
* 店铺来源白名单同样必须同源:这 6 个模块在结果行里写规范化店铺名
* (上架走 biz_publish_file.shop_name,不在此列)。加一个模块 = 先确认它真逐行落店铺。
*/
@Test
void shopModuleLiteralsStayInSyncWithSets() {
assertEquals(TaskCenterQueryMapper.sqlList(TaskCenterQueryMapper.FILE_RESULT_SHOP_MODULE_SET),
TaskCenterQueryMapper.FILE_RESULT_SHOP_MODULES);
assertEquals(List.of("PATROL_DELETE", "PRICE_TRACK", "PRODUCT_RISK_RESOLVE", "QUERY_ASIN",
"SHOP_DATA_CRAWL", "SHOP_MATCH"),
TaskCenterQueryMapper.FILE_RESULT_SHOP_MODULE_SET.stream().sorted().toList(),
"白名单成员变动必须是有意的(每加一个都要核实它的逐店行写法)");
}
// ── 任务详情(Task 6)──────────────────────────────────────────────
@Test
@@ -353,7 +390,7 @@ class TaskCenterQueryMapperSqlTest {
assertTrue(publish.contains("LIMIT 200"), "分组过多时封顶,防详情页拉爆");
String items = sqlOf(render("selectResultItemShopStats", params("taskId", 1L)));
assertTrue(items.contains("i.scope_key AS scopeKey"));
assertTrue(items.contains("i.scope_key AS scopeKey"), "详情分组仍按 result_item 的分组键");
assertTrue(items.contains("SUM(UPPER(i.status) = 'SUCCESS') AS success"));
assertTrue(items.contains("GROUP BY i.scope_key"));
assertTrue(items.contains("LIMIT 200"));
+96 -56
View File
@@ -2,8 +2,13 @@
## 模块职责
后台新增「客户端任务管理」页面,让管理员**按账号 × 设备 × 业务**统一查看客户端任务执行情况,
不必逐台设备排查;超管可看全部。管理员只能看本组(本人 + 本组用户 + 自己管理的成员)。
后台「客户端任务管理」页面,让管理员**按店铺 × 账号 × 业务**统一查看客户端任务执行情况。
本页的目的地是「哪家店现在有任务在跑、跑得到不到底」,一屏看完,不必逐台客户端登录检查;
超管可看全部,管理员只能看本组(本人 + 本组用户 + 自己管理的成员)。
看板维度是**店铺**,不是设备:设备号只是任务的一个附注(详情里展示「跑在哪台机」),
不参与任何统计口径。改造前用「在线设备」计数,把「近 5 分钟有日志上报的设备」当成了存活,
网页登录设备与只上报日志的设备一起进数,与「有客户端任务在跑」根本不是同一件事。
覆盖页面:
@@ -13,8 +18,12 @@
- **默认只有超管可见**;管理员需超管在「用户管理 → 菜单权限」授权后可见 —— 复用现有菜单授权机制
(`columns` + `user_column_permission`),**不新建权限机制**:无授权记录 = 管理员看不到。
- 列表字段:账号名、店铺、业务名称、任务状态、执行开始时间、任务结束时间、执行进度 +
当前处理等补充列,并提供筛选;设备维度经设备条 / 设备筛选与详情抽屉呈现。
- 顶部汇总卡:总店铺 / 在跑店铺 / 进行中任务 / 今日完成 / 疑似卡住。
- 全局在跑店铺面板:一行一个店铺,列在跑任务数、疑似卡住数、业务分布、最近上报;点行下钻到该店铺的任务。
- 列表字段:账号名、店铺、业务名称、任务状态、当前处理、开始时间、最近上报、结束时间、执行进度,
并提供筛选(账号/业务/状态/店铺/时间范围)。
- 「只要客户端任务在跑就上报」是面板的前提:进行中任务的 `updated_at` 由心跳(60s)与结果回传共同顶新,
因此不再需要任何设备身份基线(曾用过的 code.txt 台账已放弃)。
## 依赖关系
@@ -23,9 +32,11 @@
- 菜单授权:`columns` / `user_column_permission`(整树替换授权;超管直通)
- 组范围裁剪:`ShopManageGroupMapper.selectAccessibleGroupIds / selectUserIdsByGroupIds /
selectManagedMemberUserIds`(先例 `DedupeTotalDataService.resolveAccessScope:1179`)
- 设备标识:`AdminAuthSupport.currentDeviceId`(JWT 签名 deviceId claim,空串=来源不明;
先例 `PublishController` → `biz_publish_file.device_id`,V130)
- 设备花名册/存活:`device_log_file`(V127;客户端日志上报 60s 一轮)
- 设备标识(只在详情展示,不参与统计):`AdminAuthSupport.currentDeviceId`(JWT 签名 deviceId claim,
空串=来源不明;先例 `PublishController` → `biz_publish_file.device_id`,V130),
展示名回落 `device_log_file`(V127)
- 店铺库:`biz_shop_manage`(`shop_name` 唯一、`created_by_id` 归组,无软删列)
- 逐店落行的结果文件:`biz_file_result.source_filename`(仅 6 个模块按店铺建行)
- 进度口径:`biz_task_progress_snapshot` 优先,文件计数兜底
- 麦象 console:`MaixiangConsoleClient`(复用,token 查询参数鉴权)
@@ -37,7 +48,7 @@
|---|---|
| `biz_file_task`(12) | PUBLISH 上架、DELETE_BRAND 删除ASIN、PRODUCT_RISK_RESOLVE 商品风险解决、PRICE_TRACK 跟价、SHOP_MATCH 定时匹配、PATROL_DELETE 巡店删除、QUERY_ASIN 查询ASIN、WITHDRAW 取款、APPEARANCE_PATENT 外观专利检测、SIMILAR_ASIN 货源查询、COLLECT_DATA 采集数据、SHOP_DATA_CRAWL 店铺数据抓取 |
| `brand_crawl_tasks`(1) | BRAND 品牌检测(该表自建、不写 biz_file_task,见 BrandTaskRetentionService 注释) |
| 不显示 | DEDUPE / SPLIT / CONVERT(纯服务端执行,无客户端设备归属) |
| 不显示 | DEDUPE / SPLIT / CONVERT(纯服务端执行,客户端不跑,也就没有店铺/设备归属) |
两表字段映射(UNION ALL,子查询内下推过滤,外层排序分页):
@@ -45,51 +56,60 @@
- `status` 统一大写输出(品牌表存小写):`UPPER(status)`
- `created_at` / `updated_at` 同名;品牌任务无 `finished_at`,用终态时的 `updated_at` 代替
- 进度:品牌任务用 `progress_current / progress_total`
- 过滤条件(账号/状态/设备/时间范围)分别下推到两个子查询,各自走自己的索引
- 过滤条件(账号/状态/店铺/时间范围)分别下推到两个子查询,各自走自己的索引
(`biz_file_task` 有 `idx_module_status(module_type, status)`,进行中面板直接复用它)
### 设备口径
### 设备号(只作附注,不参与统计)
- 任务创建时记录 `device_id` = JWT 签名 claim(`AdminAuthSupport.currentDeviceId`)。
**网页登录**(`web-<ts>-<rand>`)照记,列表按 `web-` 前缀识别并标注「网页」。
- 任务创建时记录 `device_id` = JWT 签名 claim。
**网页登录**(`web-<ts>-<rand>`)照记,详情按 `web-` 前缀识别并标注「网页」。
- 记录点:13 个模块创建入口 controller 取 deviceId → service 落库(内部令牌调用取到空串,
照记空 = 未记录);续跑任务(`TaskResumeService`)**继承原任务 device_id**。
- 新列:`biz_file_task.device_id`、`brand_crawl_tasks.device_id`(V138)。
- 历史任务 device_id 为空 → 显示「未记录」(不回填,无法追溯)。
- 设备展示名:`device_id` → `device_log_file` 该设备 `device_name`(主机名,同设备多行聚合取 MAX,
与 `DeviceLogService.recentDevices` 同款);查不到时显示 device_id 截断值。
- 列:`biz_file_task.device_id`、`brand_crawl_tasks.device_id`(V138)。
历史任务 device_id 为空 → 显示「未记录」(不回填,无法追溯)。
- 展示名:`device_id` → `device_log_file` 该设备 `device_name`(主机名,同设备多行聚合取 MAX,
与 `DeviceLogService.recentDevices` 同款);**只在详情查一次**,列表不查设备名。
- 原「设备花名册 + 5 分钟在线」口径已整体删除(任务设备近 30 天 ∪ 日志设备近 7 天那套 UNION、
`countOnlineDevices`、`/devices` 接口与前端设备条),不再有任何以设备为分母的数字。
### 设备花名册(设备筛选器 + 设备状态卡)
### 店铺归属:两个真来源 + 一个「不挂店铺」桶
两台来源合并去重:
面板与列表的店铺只认两个来源:
1. **任务设备**:`biz_file_task` / `brand_crawl_tasks` 中该范围可见用户**近 30 天创建过任务**
的 device_id(空值不参与);
2. **日志设备**:`device_log_file` 中 `source='client'`、`uid` ∈ 可见用户且**近 7 天有上报**
(`last_upload_at`);`uid` 为空的日志设备不能归组,不显示(若其 device_id 已在任务设备
集合内则保留)。
| 来源 | 覆盖模块 | 说明 |
|---|---|---|
| `biz_publish_file.shop_name` | PUBLISH | 上架结果文件,按 task_id 聚合 distinct |
| `biz_file_result.source_filename` | PATROL_DELETE、PRICE_TRACK、PRODUCT_RISK_RESOLVE、QUERY_ASIN、SHOP_DATA_CRAWL、SHOP_MATCH | 这 6 个模块逐店落行,`source_filename` 存的就是规范化后的店铺名;SQL 里必须带这份模块白名单,否则会把别的模块的**上传文件名**当店铺 |
状态判定:
已否决的候选(都会把不是店铺的东西当店铺):
- **在线** = 最近上报(`last_upload_at` 或任务 `updated_at` 取最新)≤ 5 分钟;
- **正在跑任务** = 该设备存在 RUNNING/进行中任务(含 BRAND 的 running/pending);
- 两者独立展示:在线但空闲、离线但仍有终态任务都可区分。
- `biz_task_progress_snapshot.current_scope_key` —— 形如 `task:<id>:owner:<instance>`,是**实例锁**;
品牌行该列是品牌关键字。列表仍原样透出这一列(排查「哪个实例占着任务」),但它不是店铺。
- `biz_task_result_item.scope_key` —— 任务结果分组名。
- `request_json.items[].shopName` —— 大 JSON 列;列表主查询刻意不拉它,为兜底把它读出来过一次代价太大。
### 店铺口径
COLLECT_DATA / SIMILAR_ASIN / APPEARANCE_PATENT / BRAND 这些不落店铺,面板给它们一行合成桶
**「不挂店铺」**(`noShop=true`):按线上一次实测 42 个在跑任务里有 19 个属于这一类,
没有桶它们就会在看板里静默消失。桶行不可下钻(没有可筛的店铺名),要看这些任务用业务筛选。
任务本身不存店铺(品牌检测按关键字执行,不落店铺),按**来源优先级链**取第一个非空的来源;
多店铺统一显示「当前店铺 + 共 N 个」:
一个任务挂多家店铺时在每家店下各计一次;归组键 `LOWER(TRIM(...))`,同一店两种写法不拆成两行,
展示名沿用首次出现的写法。
1. `biz_publish_file.shop_name`(上架结果文件,按 task_id 聚合 distinct);
2. `biz_task_result_item.scope_key`(任务结果分组);
3. `biz_file_result.source_filename`(结果文件名里带店铺,如跟价/定时匹配);
4. `biz_task_progress_snapshot.current_scope_key`;
5. `request_json.items[].shopName`(兜底,只对当页前四个来源都为空的任务批量拉一次)。
### 店铺口径(面板与卡片)
各模块的主来源天然落在链上的对应位置,未列出的模块自动降级到下一来源;品牌行店铺恒空。
- **总店铺** = `biz_shop_manage` 中可见账号(`created_by_id`)名下的店铺数(超管不裁剪)。
- **在跑店铺** = 面板行数减去「不挂店铺」桶。汇总卡与 `/shops` **共用同一次聚合**
(`TaskCenterQueryService.aggregateShops`),卡片说几家在跑、面板就列几行,两处不允许各算各的。
- 面板原料 = 当前全部进行中任务(客户端 12 模块 ∪ 品牌),行数上限 500;触顶时服务层 `log.warn`,
卡片的进行中/卡住/今日完成三项仍走 SQL 精确计数。
- 面板排序:有卡住的排前面 → 最久没上报的排前面 → 「不挂店铺」桶永远垫底。
- 店铺筛选:上面两个来源任一命中(EXISTS + `LOWER(TRIM(...)) = LOWER(TRIM(?))` **精确**匹配,
LIKE 会让「林芳」命中「林芳芳」);品牌分支带店铺筛选时恒空(品牌不存店铺,且品牌 id 会与 biz 撞号)。
店铺筛选:对来源 1~4 做 EXISTS 子查询(四张表都有 task_id 索引:`biz_publish_file` /
`idx_result_item_task` / `idx_task_id` / `uk_task_progress_snapshot`),与其余筛选一起下推到
主查询;`request_json` 不参与筛选。
### 任务列表的店铺列
`shopName` 取该任务店铺列表的第一个,`shopCount` 是数量;无来源命中时留空(显示「—」),
不做文件名/请求体兜底 —— 宁可空,不把文件名当店铺。
### 进度口径(列表/详情展示)
@@ -102,9 +122,13 @@
### 「是否正常在跑」判定
- 进行中且 `updated_at` 距今 ≤ 10 分钟 → 正常(任务心跳 60s 一轮);
- 进行中且 `updated_at` 距今 ≤ 10 分钟 → 正常(任务心跳 60s 一轮,结果回传也顶新);
- 进行中且 > 10 分钟无更新 → 「疑似卡住」(**仅展示提示,不做处置动作**);
- 终态 → 成功/失败/已取消,按 `status` 展示。
`updated_at` 缺失时回落 `created_at` 判老;
- 终态 → 成功/失败/已取消,按 `status` 展示;
- 列表/详情/面板统一输出 `lastReportAt`(= `updated_at`,缺失回落 `created_at`),文案用「最近上报」,
不再说「在线/离线」——设备是否在线与任务是否在跑是两件事。
- 唯一的窗口就是这 10 分钟;30 天 / 7 天 / 5 分钟那三个设备窗口随设备维度一起删除。
## 数据库迁移 V138
@@ -118,7 +142,7 @@
回滚:DROP 两列与索引;`DELETE FROM columns WHERE column_key='admin_task_center'`。
## 后端接口(5 个,全部只读)
## 后端接口(6 个,全部只读)
新模块包 `modules/taskcenter/`(controller / service / mapper / vo)。
@@ -132,9 +156,10 @@ SQL 用 `@Select` 注解 mapper + 手写 LIMIT/OFFSET 分页(先例 `ImageVide
| 接口 | 说明 |
|---|---|
| `GET /api/admin/task-center/overview` | 汇总卡:设备总数/在线数、进行中任务数、今日完成任务数、疑似卡住数 |
| `GET /api/admin/task-center/devices` | 设备列表:deviceId、deviceName、lastActiveAt(最近上报/任务活动)、online、runningTasks、recentTaskAt、webDevice(`web-` 前缀=网页登录) |
| `GET /api/admin/task-center/tasks` | 任务列表(分页 + 筛选:page、pageSize、username、moduleType、status、deviceId、shop、startTime/endTime);字段:id、taskNo、moduleType、moduleLabel、status、userId、username、deviceId、deviceName、webDevice、shopName、shopCount、createdAt、finishedAt、progressTotal/progressSuccess/progressFailed、currentScope、message、stuck |
| `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/detail` | 任务详情(参数 `taskNo`,品牌任务为 `brand-<id>`):基础信息 + 进度快照 + 店铺/文件明细 |
| `GET /api/admin/task-center/variant-tasks` | 变体采集列表(代理麦象 console):uid 集合 = 可见用户;page/pageSize + status/taskType 筛选 |
@@ -142,10 +167,14 @@ SQL 用 `@Select` 注解 mapper + 手写 LIMIT/OFFSET 分页(先例 `ImageVide
`admin-frontend-vue/src/pages/task-center/`:
- `TaskCenterBoardPage.vue`:外层页签 + 筛选栏(账号/业务/状态/设备/店铺/时间范围)+ 汇总卡 +
设备状态卡条(在线点、运行中任务数,点击筛选该设备);
- 页签一「客户端任务」:`el-table`(账号、店铺、业务、状态、当前处理、开始、结束、进度条、操作)
+ 详情 `el-drawer`;
- `TaskCenterBoardPage.vue`:外层页签 + 汇总卡(总店铺/在跑店铺/进行中任务/今日完成/疑似卡住)+
在跑店铺看板 + 筛选栏(账号/业务/状态/店铺/时间范围);
- 在跑店铺看板:表格一行一个店铺(店铺、在跑任务、疑似卡住、业务分布、最近上报),
点真店铺行 = 按该店铺精确筛任务(再点一次取消),「不挂店铺」桶行不可点并带说明文案;
- 店铺筛选:`el-select filterable clearable`,候选 = 店铺库 ∪ 面板出现的店铺名
(店铺已删、但任务还在的情形也筛得动);
- 页签一「客户端任务」:表格(账号、店铺、业务、状态、当前处理、开始、最近上报、结束、进度条、操作)
+ 详情 `el-drawer`(设备名与分组明细只在详情出现);
- 页签二「变体采集」:状态筛选 + 表格(账号、任务号、状态、开始/更新时间、进度文字 res_mes);
- 30s 轮询:`document.hidden` 暂停、卸载清理、手动刷新按钮。
@@ -168,9 +197,15 @@ Java 侧同步扩展 `MaixiangConsoleClient.BatchTaskItem`(加 resMes 字段
## 测试策略
- Java:组裁剪(超管直通 / 空集 IN(-1) / 组内多用户)、两表 UNION 分页与筛选、
设备花名册合并、进度兜底、卡住判定边界(9/10/11 分钟)、V138 幂等;
- 前端:页面渲染/筛选/页签切换/轮询清理(vitest);
- Java:`TaskCenterQueryServiceTest` 守「卡片在跑店铺 = 面板行数减桶」「每个进行中任务恰好落进一个桶
(无店铺归属的不许消失)」「多店任务每店各计一次」「两种写法归一行」「快照 scope 不是店铺」
「品牌行撞号时不继承 biz 行店铺」「卡住边界 9/10/11 分钟」「列表不查设备名」;
`TaskCenterQueryMapperSqlTest` 守 SQL:店铺筛选带模块白名单 + 精确匹配、面板查询不带筛选占位符、
`current_scope_key` 不出现在店铺位置,并用反射断言 `selectRequestJson`/`selectResultItemShops`/
设备花名册那批方法已不存在;组裁剪(超管直通 / 空集 `IN(-1)` / 组内多用户)、V138 幂等同前;
- 前端:`tests/task-center-board.test.ts` 守接口清单(6 个)、设备维度不得回流(`deviceTotal`/
`deviceOnline`/`/devices`/`filter.deviceId` 全部断言不存在)、面板下钻与桶行不可点接线、
筛选参数与三种空态;
- 麦象:多 uid 过滤与 res_mes 返回(pytest);
- 既有门禁:`align-operation-guide` / `AdminMenuRouteMatrix` / 路由注册表校验必须保持绿。
@@ -184,8 +219,13 @@ Java 侧同步扩展 `MaixiangConsoleClient.BatchTaskItem`(加 resMes 字段
## 风险与边界
- 历史任务无设备号(V138 之前创建)→ 统一「未记录」;
- 组裁剪按 **任务发起账号(user_id)** 判定可见性,不按设备归属;
设备若跨组使用(同机多账号),任务仍按账号归组,不会串组;
- 历史任务无设备号(V138 之前创建)→ 详情显示「未记录」;看板不看设备,不受影响;
- 「不挂店铺」桶里的任务不能按店铺下钻(它们本来没有店铺维度),只能按业务筛;
- `biz_file_result.source_filename` 作为店铺只在这 6 个逐店落行的模块成立,其余模块该列是上传文件名,
由 SQL 模块白名单挡在外面;店铺名对不上时表现为「不挂店铺」,不会串到别的店;
- 面板取进行中任务上限 500 行:触顶时卡片仍按 SQL 精确计数、面板会少列,服务层 `log.warn`
(实测在跑任务为数十量级);
- 组裁剪按 **任务发起账号(user_id)** 判定任务可见性,店铺库按 `created_by_id`;
店铺若跨组共用,任务仍按账号归组,不会因为店铺同名而串组;
- 品牌任务状态小写、其余大写,**接口层统一转大写**,前端只认一套;
- 变体采集无设备/店铺归属(麦象侧无此数据),页签二不显示这两列。
- 变体采集无店铺归属(麦象侧无此数据),页签二不显示店铺列。