feat(taskcenter): 两表 UNION 任务列表 + 筛选 + 店铺/进度装配

- biz_file_task(12 个客户端模块)∪ brand_crawl_tasks,品牌任务号合成 brand-<id>、
  终态用 updated_at 充当 finished_at;子查询内下推过滤、外层排序分页
- 筛选:账号名(users LIKE → ∩ 可见账号)、业务、状态、设备、店铺(4 个来源 EXISTS)、
  创建时间范围;选具体业务时品牌分支恒空,带店铺筛选时品牌分支直接排除(防撞号误判)
- 状态口径单一来源:SQL 字面量与 Java 集合由测试守同步,服务层判「卡住」复用同一集合
- 店铺来源优先级链:上架结果文件 → 任务结果分组 → 结果文件名 → 快照 scope → 请求体
  items[].shopName(最后一级批量一次拉取,列表主查询不拉大 JSON 列);品牌行店铺恒空
- 进度:快照(按 moduleType+taskId 匹配,防品牌 id 撞号)优先,无快照用行内文件计数

Tests run: 42, Failures: 0, Errors: 0
This commit is contained in:
2026-09-28 23:09:21 +08:00
parent cd9bf509ec
commit 186c288dbf
13 changed files with 1058 additions and 20 deletions
@@ -169,4 +169,147 @@ class TaskCenterQueryMapperSqlTest {
assertFalse(sql.contains("'SPLIT'"));
assertFalse(sql.contains("'CONVERT'"));
}
// ── 任务列表(Task 5)──────────────────────────────────────────────
@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));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("SELECT m.* FROM(SELECT t.id AS id"));
assertTrue(sql.contains("UNION ALL"));
assertTrue(sql.contains("CONCAT('brand-',b.id)"), "品牌任务号合成 brand-<id>");
assertTrue(sql.contains("CASE WHEN UPPER(t.status) = 'CANCELED' THEN 'CANCELLED' ELSE UPPER(t.status) END AS status"),
"历史脏值 CANCELED 并入 CANCELLED");
assertTrue(sql.contains("0 AS brand"));
assertTrue(sql.contains("b.progress_total,b.progress_current,0,1"), "品牌进度取自有列");
assertTrue(sql.contains("CASE WHEN b.status IN('cancelled','failed','success') THEN b.updated_at END"),
"品牌表无 finished_at,终态用 updated_at");
assertTrue(sql.contains("ORDER BY m.createdAt DESC,m.id DESC"));
assertTrue(sql.contains("LIMIT ? OFFSET ?"));
assertEquals(2, boundSql.getParameterMappings().size(), "只有分页两个参数");
assertFalse(sql.contains("request_json"), "列表主查询不拉大 JSON 列");
}
@Test
void taskListFiltersReachBothBranchesAndBrandDropsShopFilter() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", List.of(5L, 11L), "moduleType", "PUBLISH", "status", "RUNNING",
"deviceId", "pc-0001", "shop", "旗舰店",
"startTime", LocalDateTime.of(2026, 9, 1, 0, 0),
"endTime", LocalDateTime.of(2026, 9, 28, 0, 0),
"limit", 20L, "offset", 20L));
String sql = sqlOf(boundSql);
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('%',?,'%'))"));
assertEquals(5L, boundSql.getAdditionalParameter("__frch_uid_0"));
assertEquals(20, boundSql.getParameterMappings().size(),
"biz 11(账号×2/业务/状态/设备/起止/店铺×4)+ 品牌 7(账号×2/业务/状态/设备/起止)+ 分页 2");
}
@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));
String sql = sqlOf(boundSql);
assertFalse(sql.contains("AND UPPER(t.module_type)"), "未选业务不加条件");
assertFalse(sql.contains("AND 1 = 0"), "未选店铺时品牌分支照常入列");
assertFalse(sql.contains("EXISTS"), "未选店铺不做 EXISTS 子查询");
assertFalse(sql.contains("__frch"), "超管不渲染账号占位符");
assertEquals(2, boundSql.getParameterMappings().size());
}
@Test
void taskCountSharesTheUnionBody() {
BoundSql boundSql = render("countTaskPage",
params("userIds", null, "moduleType", "BRAND", "status", "RUNNING", "deviceId", null,
"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 = ?"));
assertEquals(4, boundSql.getParameterMappings().size(), "业务 + 状态在两张表各绑一次");
}
@Test
void usernameLookupIsFuzzyAndBounded() {
BoundSql boundSql = render("selectUserIdsByUsername", params("keyword", "ali"));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("WHERE username LIKE CONCAT('%',?,'%')"));
assertTrue(sql.contains("LIMIT 500"), "模糊匹配有上界,防全表命中");
}
@Test
void snapshotLookupKeepsModuleTypeForCollisionSafety() {
BoundSql boundSql = render("selectSnapshots", params("taskIds", List.of(7L, 8L)));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("s.module_type AS moduleType"), "品牌 id 与 biz id 可能撞号,必须带业务名");
assertTrue(sql.contains("s.current_scope_key AS currentScopeKey"));
assertEquals(2, boundSql.getParameterMappings().size());
}
@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"));
}
@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());
}
@Test
void deviceNameLookupAggregatesWithoutWindow() {
BoundSql boundSql = render("selectDeviceNames", params("deviceIds", List.of("dev-a")));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("MAX(d.device_name) AS deviceName"));
assertTrue(sql.contains("GROUP BY d.device_id"));
assertFalse(sql.contains("last_upload_at"), "设备名与任务时间无关,不限窗口");
}
/** 注解值必须是编译期常量,SQL 里只能写字面量;这条测试守住它与 Java 集合不漂移。 */
@Test
void statusLiteralsStayInSyncWithSets() {
assertEquals(TaskCenterQueryMapper.sqlList(TaskCenterQueryMapper.ACTIVE_STATUS_SET),
TaskCenterQueryMapper.ACTIVE_STATUSES, "进行中状态(服务层判卡住复用同一集合)");
assertEquals(TaskCenterQueryMapper.sqlList(TaskCenterQueryMapper.TERMINAL_STATUS_SET),
TaskCenterQueryMapper.TERMINAL_STATUSES);
assertEquals(TaskCenterQueryMapper.sqlList(TaskCenterQueryMapper.BRAND_ACTIVE_STATUS_SET),
TaskCenterQueryMapper.BRAND_ACTIVE_STATUSES);
assertEquals(TaskCenterQueryMapper.sqlList(TaskCenterQueryMapper.BRAND_TERMINAL_STATUS_SET),
TaskCenterQueryMapper.BRAND_TERMINAL_STATUSES);
}
}
@@ -2,8 +2,14 @@ package com.nanri.aiimage.modules.taskcenter.service;
import com.nanri.aiimage.modules.taskcenter.mapper.TaskCenterQueryMapper;
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.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.vo.TaskCenterDeviceVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterOverviewVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskPageVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskRowVo;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
@@ -21,15 +27,19 @@ import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 只读查询的 Java 侧口径:时间窗口(卡住 10 分钟 / 在线 5 分钟 / 任务 30 天 / 日志 7 天)、
* 设备花名册合并与在线判定、账号范围透传。SQL 本身由 TaskCenterQueryMapperSqlTest 守。
* 设备花名册合并与在线判定、账号范围透传、任务列表装配(店铺来源优先级 / 快照匹配 / 分页)。
* SQL 本身由 TaskCenterQueryMapperSqlTest 守。
*/
@ExtendWith(MockitoExtension.class)
class TaskCenterQueryServiceTest {
@@ -216,4 +226,236 @@ class TaskCenterQueryServiceTest {
verify(queryMapper).listRosterDevices(eq(List.of(5L)), any(), any());
verify(queryMapper).countRunningTasksByDevice(eq(List.of(5L)));
}
// ── 任务列表(Task 5)──────────────────────────────────────────────
private static TaskCenterTaskRow taskRow(long id, String moduleType, String status,
LocalDateTime createdAt, LocalDateTime updatedAt) {
TaskCenterTaskRow row = new TaskCenterTaskRow();
row.setId(id);
row.setTaskNo(moduleType + "-" + id);
row.setModuleType(moduleType);
row.setStatus(status);
row.setCreatedAt(createdAt);
row.setUpdatedAt(updatedAt);
return row;
}
private static TaskCenterSnapshotRow snapshotRow(long taskId, String moduleType, long total,
long success, long failed, String scope, String message) {
TaskCenterSnapshotRow row = new TaskCenterSnapshotRow();
row.setTaskId(taskId);
row.setModuleType(moduleType);
row.setTotalCount(total);
row.setSuccessCount(success);
row.setFailedCount(failed);
row.setCurrentScopeKey(scope);
row.setMessage(message);
return row;
}
private static TaskCenterShopRow shopRow(long taskId, String shop) {
TaskCenterShopRow row = new TaskCenterShopRow();
row.setTaskId(taskId);
row.setShop(shop);
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 void stubPage(List<TaskCenterTaskRow> rows) {
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any(), any()))
.thenReturn((long) rows.size());
when(queryMapper.selectTaskPage(any(), any(), any(), any(), any(), any(), any(), anyLong(), anyLong()))
.thenReturn(rows);
}
@Test
void usernameFilterIntersectsVisibleUsers() {
when(queryMapper.selectUserIdsByUsername("ali")).thenReturn(List.of(11L, 99L));
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any(), any())).thenReturn(0L);
TaskCenterTaskQuery query = new TaskCenterTaskQuery();
query.setUsername("ali");
TaskCenterTaskPageVo page = service.tasks(scoped(5L, 11L), query);
assertEquals(0, page.getTotal(), "只有 11 在本组可见集合内,99 越界");
verify(queryMapper).countTaskPage(argThat(ids -> List.of(11L).equals(ids)),
isNull(), isNull(), isNull(), isNull(), isNull(), isNull());
}
@Test
void usernameFilterNoHitSkipsQueriesEntirely() {
when(queryMapper.selectUserIdsByUsername("ghost")).thenReturn(List.of());
TaskCenterTaskQuery query = new TaskCenterTaskQuery();
query.setUsername("ghost");
TaskCenterTaskPageVo page = service.tasks(scoped(5L), query);
assertEquals(0, page.getTotal());
assertEquals(1, page.getPage());
assertEquals(20, page.getPageSize(), "空页也带默认分页口径");
verify(queryMapper, never()).countTaskPage(any(), any(), any(), any(), any(), any(), any());
}
@Test
void superAdminUsernameFilterKeepsAllMatches() {
when(queryMapper.selectUserIdsByUsername("ali")).thenReturn(List.of(11L, 99L));
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any(), any())).thenReturn(0L);
TaskCenterTaskQuery query = new TaskCenterTaskQuery();
query.setUsername("ali");
service.tasks(superScope(), query);
verify(queryMapper).countTaskPage(argThat(ids -> List.of(11L, 99L).equals(ids)),
isNull(), isNull(), isNull(), isNull(), isNull(), isNull());
}
@Test
void filtersPassThroughAndPageSizeIsCapped() {
LocalDateTime start = LocalDateTime.of(2026, 9, 1, 0, 0);
LocalDateTime end = LocalDateTime.of(2026, 9, 28, 23, 59);
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any(), any())).thenReturn(1L);
when(queryMapper.selectTaskPage(any(), any(), any(), any(), any(), any(), any(), anyLong(), anyLong()))
.thenReturn(List.of());
TaskCenterTaskQuery query = new TaskCenterTaskQuery();
query.setModuleType("PUBLISH");
query.setStatus("RUNNING");
query.setDeviceId("pc-0001");
query.setShop("旗舰店");
query.setStartTime(start);
query.setEndTime(end);
query.setPage(3L);
query.setPageSize(500L);
service.tasks(superScope(), query);
verify(queryMapper).countTaskPage(isNull(), eq("PUBLISH"), eq("RUNNING"), eq("pc-0001"),
eq("旗舰店"), eq(start), eq(end));
verify(queryMapper).selectTaskPage(isNull(), eq("PUBLISH"), eq("RUNNING"), eq("pc-0001"),
eq("旗舰店"), eq(start), eq(end), eq(100L), eq(200L));
}
@Test
void stuckFlagBoundary() {
LocalDateTime now = LocalDateTime.now();
List<TaskCenterTaskRow> rows = List.of(
taskRow(1L, "PUBLISH", "RUNNING", now.minusHours(1), now.minusMinutes(9).minusSeconds(59)),
taskRow(2L, "PUBLISH", "RUNNING", now.minusHours(1), now.minusMinutes(10).minusSeconds(1)),
taskRow(3L, "PUBLISH", "SUCCESS", now.minusHours(3), now.minusHours(2)),
taskRow(4L, "PUBLISH", "RUNNING", now.minusMinutes(11), null));
stubPage(rows);
when(queryMapper.selectSnapshots(any())).thenReturn(List.of());
when(queryMapper.selectPublishShops(any())).thenReturn(List.of());
when(queryMapper.selectResultItemShops(any())).thenReturn(List.of());
when(queryMapper.selectFileResultShops(any())).thenReturn(List.of());
when(queryMapper.selectRequestJson(any())).thenReturn(List.of());
TaskCenterTaskPageVo page = service.tasks(superScope(), new TaskCenterTaskQuery());
assertEquals(4, page.getTotal());
assertFalse(item(page, 1L).isStuck(), "进行中 9:59 未更新 → 不算卡住");
assertTrue(item(page, 2L).isStuck(), "进行中 10:01 未更新 → 卡住");
assertFalse(item(page, 3L).isStuck(), "终态不判卡住");
assertTrue(item(page, 4L).isStuck(), "updated_at 缺失时用 created_at 判老");
}
@Test
void progressAndShopsPreferSnapshotThenFileCount() {
LocalDateTime now = LocalDateTime.now();
TaskCenterTaskRow plain = taskRow(1L, "PUBLISH", "SUCCESS", now, now);
plain.setTotalCount(10L);
plain.setSuccessCount(7L);
plain.setFailedCount(3L);
TaskCenterTaskRow snapshotted = taskRow(2L, "PUBLISH", "RUNNING", now, now);
snapshotted.setTotalCount(99L);
stubPage(List.of(plain, snapshotted));
when(queryMapper.selectSnapshots(any())).thenReturn(List.of(
snapshotRow(2L, "PUBLISH", 20L, 15L, 2L, "快照店铺", "处理中")));
when(queryMapper.selectPublishShops(any())).thenReturn(List.of(
shopRow(1L, "店铺甲"), shopRow(1L, "店铺乙")));
when(queryMapper.selectResultItemShops(any())).thenReturn(List.of(shopRow(2L, "结果分组店铺")));
TaskCenterTaskPageVo page = service.tasks(superScope(), new TaskCenterTaskQuery());
TaskCenterTaskRowVo first = item(page, 1L);
assertEquals(10L, first.getProgressTotal(), "无快照时用行内文件计数");
assertEquals(7L, first.getProgressSuccess());
assertEquals(3L, first.getProgressFailed());
assertEquals("店铺甲", first.getShopName(), "上架结果文件优先,且取第一个店铺");
assertEquals(2L, first.getShopCount(), "同任务多店铺计数");
assertNull(first.getCurrentScope());
TaskCenterTaskRowVo second = item(page, 2L);
assertEquals(20L, second.getProgressTotal(), "有快照优先用快照");
assertEquals(15L, second.getProgressSuccess());
assertEquals(2L, second.getProgressFailed());
assertEquals("处理中", second.getMessage());
assertEquals("快照店铺", second.getCurrentScope());
assertEquals("结果分组店铺", second.getShopName(), "无上架文件时降级到任务结果分组");
}
@Test
void brandRowKeepsItsOwnIdentityWhenIdsCollide() {
LocalDateTime now = LocalDateTime.now();
TaskCenterTaskRow biz = taskRow(7L, "PUBLISH", "SUCCESS", now, now);
TaskCenterTaskRow brand = taskRow(7L, "BRAND", "FAILED", now, now);
brand.setTaskNo("brand-7");
brand.setBrand(true);
stubPage(List.of(biz, brand));
when(queryMapper.selectSnapshots(any())).thenReturn(List.of(
snapshotRow(7L, "PUBLISH", 30L, 30L, 0L, "上架快照店铺", null),
snapshotRow(7L, "BRAND", 5L, 1L, 4L, "品牌关键字", null)));
when(queryMapper.selectPublishShops(any())).thenReturn(List.of(shopRow(7L, "店铺甲")));
TaskCenterTaskPageVo page = service.tasks(superScope(), new TaskCenterTaskQuery());
TaskCenterTaskRowVo bizVo = page.getItems().get(0);
TaskCenterTaskRowVo brandVo = page.getItems().get(1);
assertEquals("上架", bizVo.getModuleLabel());
assertEquals(30L, bizVo.getProgressTotal(), "biz 行取 (PUBLISH,id) 快照");
assertEquals("店铺甲", bizVo.getShopName());
assertEquals("品牌检测", brandVo.getModuleLabel());
assertEquals("brand-7", brandVo.getTaskNo());
assertEquals("FAILED", brandVo.getStatus(), "品牌状态大写输出");
assertEquals(5L, brandVo.getProgressTotal(), "品牌行按 (BRAND,id) 取快照");
assertEquals(1L, brandVo.getProgressSuccess());
assertEquals(4L, brandVo.getProgressFailed());
assertNull(brandVo.getShopName(), "撞号时品牌行不得继承 biz 行的店铺");
assertEquals(0L, brandVo.getShopCount());
assertFalse(brandVo.isStuck(), "终态品牌任务不判卡住");
}
@Test
void requestJsonFallbackParsesShopNamesOnce() {
LocalDateTime now = LocalDateTime.now();
stubPage(List.of(taskRow(1L, "COLLECT_DATA", "SUCCESS", now, now),
taskRow(2L, "COLLECT_DATA", "SUCCESS", now, now)));
when(queryMapper.selectSnapshots(any())).thenReturn(List.of());
when(queryMapper.selectPublishShops(any())).thenReturn(List.of());
when(queryMapper.selectResultItemShops(any())).thenReturn(List.of());
when(queryMapper.selectFileResultShops(any())).thenReturn(List.of());
TaskCenterTaskRow raw1 = new TaskCenterTaskRow();
raw1.setId(1L);
raw1.setRequestJson("{\"items\":[{\"shopName\":\"美国店\"},{\"shopName\":\"日本店\"},{\"shopName\":\"美国店\"}]}");
TaskCenterTaskRow raw2 = new TaskCenterTaskRow();
raw2.setId(2L);
raw2.setRequestJson("not-json");
when(queryMapper.selectRequestJson(any())).thenReturn(List.of(raw1, raw2));
TaskCenterTaskPageVo page = service.tasks(superScope(), new TaskCenterTaskQuery());
assertEquals("美国店", item(page, 1L).getShopName(), "取第一个店铺");
assertEquals(2L, item(page, 1L).getShopCount(), "去重后计数");
assertNull(item(page, 2L).getShopName(), "结构不认识时不炸,店铺留空");
verify(queryMapper, times(1)).selectRequestJson(any());
}
}