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

- 店铺看板整条移除(面板/`/shops`/`shops()`/`TaskCenterShopVo`),汇总卡「在跑店铺」保留;
- 采集数据行进度改成客户端那句「关键词进度:第 N/总 个」(只改文字,数字口径与夹取不变),
  其余无进度条的模块仍显示「—」;
- 列表加「国家」列:值来自 request_json 的 7 条路径(线上实测顺序与覆盖 315/451=69.8%),
  按页内主键点查、不进列表 UNION,以免把大 JSON 列拉回已知慢查询;品牌行不发查询;
  只展示不筛选,无迁移;
- 状态默认「在跑」= PENDING∪RUNNING∪SCHEDULED,前端下发 ACTIVE 哨兵、只在服务层 statusFilter
  一处展开,成员与 ACTIVE_STATUS_SET/ACTIVE_STATUSES 同源钉死;
- 护栏:后端 task-center 77 例(新增状态 IN 渲染、7 路径顺序、归一两形态、品牌不查国家等)、
  前端 21 例;4 个变异点(路径顺序/哨兵不展开/归一截断/文案分支)全部被抓到并字节级还原。
This commit is contained in:
2026-10-04 12:48:18 +08:00
parent ea15cc58bf
commit 48aad3f2fd
14 changed files with 550 additions and 460 deletions
@@ -6,7 +6,6 @@ import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskQuery;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterOverviewVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterShopVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskDetailVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskPageVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterVariantPageVo;
@@ -52,15 +51,6 @@ public class AdminTaskCenterController {
return ApiResponse.success(queryService.overview(scope));
}
@GetMapping("/shops")
@Operation(summary = "店铺面板",
description = "当前所有进行中任务按店铺归组:在跑任务数/疑似卡住数/业务分布/最近上报时间;"
+ "不落店铺的任务归进「不挂店铺」桶,与汇总卡的在跑店铺数同源。")
public ApiResponse<List<TaskCenterShopVo>> shops(HttpServletRequest request) {
TaskCenterScopeService.ScopeContext scope = resolveScope(request);
return ApiResponse.success(queryService.shops(scope));
}
@GetMapping("/shop-options")
@Operation(summary = "店铺筛选候选",
description = "店铺库(biz_shop_manage)在可见范围内的店铺名,供筛选下拉精确匹配;只出店铺名。")
@@ -1,6 +1,7 @@
package com.nanri.aiimage.modules.taskcenter.mapper;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCollectStatsRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCountryRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterDeviceRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopStatRow;
@@ -45,6 +46,15 @@ public interface TaskCenterQueryMapper {
*/
Set<String> ACTIVE_STATUS_SET = Set.of("PENDING", "RUNNING", "SCHEDULED");
/**
* {@link #ACTIVE_STATUS_SET} 的固定顺序版本:前端「在跑」筛选项就是这个集合的合并口径,
* 展开成 IN 列表后 SQL 文本要可断言({@code Set} 的迭代顺序不保证,不能直接下 SQL)。
*/
List<String> ACTIVE_STATUSES_ORDERED = List.of("PENDING", "RUNNING", "SCHEDULED");
/** 状态筛选的合并哨兵值:它不是表里的状态,服务层负责展开成 {@link #ACTIVE_STATUSES_ORDERED}。 */
String ACTIVE_STATUS_SENTINEL = "ACTIVE";
/** biz_file_task 终态(CANCELLED 与历史脏值 CANCELED 并存)。 */
Set<String> TERMINAL_STATUS_SET = Set.of("SUCCESS", "FAILED", "CANCELLED", "CANCELED");
@@ -190,10 +200,19 @@ public interface TaskCenterQueryMapper {
+ " WHERE f.task_id = t.id AND LOWER(TRIM(f.source_filename)) = LOWER(TRIM(#{shop}))))"
+ ")</if>";
/**
* 状态筛选:两组大写状态({@code statuses} 由服务层展开,「在跑」= PENDING/RUNNING/SCHEDULED)。
* 两张表都按归一化后的输出列比较,品牌表的小写状态在 {@code STATUS_B} 里已经 UPPER。
*/
String STATUSES_FILTER_T = "<if test='statuses != null'> AND " + STATUS_T + " IN"
+ " <foreach collection='statuses' item='st' open='(' separator=',' close=')'>#{st}</foreach></if>";
String STATUSES_FILTER_B = "<if test='statuses != null'> AND " + STATUS_B + " IN"
+ " <foreach collection='statuses' item='st' open='(' separator=',' close=')'>#{st}</foreach></if>";
/** biz_file_task 分支筛选(账号范围 + 业务/状态/时间范围 + 店铺)。 */
String TASK_FILTER_T = USER_SCOPE_T
+ "<if test='moduleType != null'> AND UPPER(t.module_type) = #{moduleType}</if>"
+ "<if test='status != null'> AND " + STATUS_T + " = #{status}</if>"
+ STATUSES_FILTER_T
+ "<if test='startTime != null'> AND t.created_at &gt;= #{startTime}</if>"
+ "<if test='endTime != null'> AND t.created_at &lt;= #{endTime}</if>"
+ SHOP_FILTER_T;
@@ -204,7 +223,7 @@ public interface TaskCenterQueryMapper {
*/
String TASK_FILTER_B = USER_SCOPE_B
+ "<if test='moduleType != null'> AND 'BRAND' = #{moduleType}</if>"
+ "<if test='status != null'> AND " + STATUS_B + " = #{status}</if>"
+ STATUSES_FILTER_B
+ "<if test='startTime != null'> AND b.created_at &gt;= #{startTime}</if>"
+ "<if test='endTime != null'> AND b.created_at &lt;= #{endTime}</if>"
+ "<if test='shop != null'> AND 1 = 0</if>";
@@ -244,7 +263,7 @@ public interface TaskCenterQueryMapper {
+ "</script>")
List<TaskCenterTaskRow> selectTaskPage(@Param("userIds") List<Long> userIds,
@Param("moduleType") String moduleType,
@Param("status") String status,
@Param("statuses") List<String> statuses,
@Param("shop") String shop,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime,
@@ -255,11 +274,11 @@ public interface TaskCenterQueryMapper {
+ "SELECT COUNT(*) FROM " + TASK_LIST_ROWS + " m"
+ "</script>")
long countTaskPage(@Param("userIds") List<Long> userIds,
@Param("moduleType") String moduleType,
@Param("status") String status,
@Param("shop") String shop,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
@Param("moduleType") String moduleType,
@Param("statuses") List<String> statuses,
@Param("shop") String shop,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
/** 店铺面板的原料:当前全部进行中任务(超管口径下上限 500,截断由服务层显式提示)。 */
@Select("<script>"
@@ -345,6 +364,32 @@ public interface TaskCenterQueryMapper {
+ "</script>")
List<TaskCenterCollectStatsRow> selectCollectDataKeywordStats(@Param("taskIds") List<Long> taskIds);
/**
* 任务的目标国家:{@code biz_file_task} 没有国家列,只能按各模块在 {@code request_json}
* 里的写法取,七条路径与先后顺序 = 2026-10-04 生产实测(近 7 天 12 个模块 5 个能取到、70.7% 行有值),
* 换序就是另一套覆盖率,由 {@code countryPathsAreTheMeasuredSevenInOrder} 钉死。
*
* <p>只按页内任务号取(主键点查),不进列表主查询:那条 UNION 的护栏是不碰 {@code request_json}。
* 取到的是 JSON 原文,裸串 {@code DE} 与数组 {@code ["UK", "DE"]} 两种形状都由服务层归一化,
* SQL 不猜。品牌表没有国家,调用方按 {@code brand} 行筛掉。</p>
*/
String COUNTRY_PATHS = "COALESCE("
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.filters.countryCode')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.countryCode')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.country')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.publish_country')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.countryCodes')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.country_codes')), ''), 'null'),"
+ "NULLIF(NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.request_json, '$.filters.countryCodes')), ''), 'null')"
+ ")";
@Select("<script>"
+ "SELECT t.id AS taskId, " + COUNTRY_PATHS + " AS country"
+ " FROM biz_file_task t"
+ " WHERE t.id IN <foreach collection='taskIds' item='tid' open='(' separator=',' close=')'>#{tid}</foreach>"
+ "</script>")
List<TaskCenterCountryRow> selectTaskCountries(@Param("taskIds") List<Long> taskIds);
/** 详情:按任务号取单行(只认 12 个客户端模块,其余模块不在看板范围)。 */
@Select("SELECT t.id AS id, t.task_no AS taskNo, UPPER(t.module_type) AS moduleType,"
+ " " + STATUS_T + " AS status, t.user_id AS userId, t.device_id AS deviceId,"
@@ -0,0 +1,12 @@
package com.nanri.aiimage.modules.taskcenter.model.dto;
import lombok.Data;
/** 任务的目标国家行({@code request_json} 七条路径任一的原文),只按页内任务号点查。 */
@Data
public class TaskCenterCountryRow {
private Long taskId;
/** JSON 原文:可能是裸串({@code DE}),也可能是数组文本({@code ["UK", "DE"]});取不到为 null。 */
private String country;
}
@@ -1,28 +0,0 @@
package com.nanri.aiimage.modules.taskcenter.model.vo;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 店铺面板行:一个店铺在当前所有进行中任务里的汇总(点行下钻到该店铺的任务列表)。
*
* <p>「不挂店铺」是一行合成桶({@code noShop=true}):采集数据、货源查询、品牌检测这些模块
* 的任务不落店铺,但它们同样在跑,不能让它们在看板里消失。</p>
*/
@Data
public class TaskCenterShopVo {
/** 店铺名(沿用首次出现的写法);合成桶时为「不挂店铺」。 */
private String shop;
/** 是否为「不挂店铺」合成桶(不可下钻,按业务筛选看这些任务)。 */
private boolean noShop;
/** 该店铺进行中任务数(一个任务挂多个店铺时,在每个店铺下各计一次)。 */
private long runningTasks;
/** 其中疑似卡住数(进行中且超过 10 分钟无上报)。 */
private long stuckTasks;
/** 业务分布,如「跟价×2 / 定时匹配×1」。 */
private String moduleSummary;
/** 该店铺所有在跑任务里最近一次上报时间(心跳与结果回传都会顶新)。 */
private LocalDateTime lastReportAt;
}
@@ -24,6 +24,8 @@ public class TaskCenterTaskRowVo {
/** 店铺:主来源的第一个店铺名(多店铺时前端显示「共 N 个」);来源只有上架结果文件与逐店落行的结果文件名。 */
private String shopName;
private long shopCount;
/** 目标站点:{@code request_json} 里的国家码,多国家用 / 连接({@code UK/DE});该模块不写国家时为 null。 */
private String country;
private LocalDateTime createdAt;
private LocalDateTime finishedAt;
/** 最近一次上报(updated_at;心跳与结果回传都会顶新)。进行中且它超过 10 分钟即疑似卡住。 */
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.taskcenter.service;
import com.nanri.aiimage.common.module.TaskModuleRegistry;
import com.nanri.aiimage.modules.taskcenter.mapper.TaskCenterQueryMapper;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCollectStatsRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCountryRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterDeviceRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopStatRow;
@@ -12,7 +13,6 @@ import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterUserRow;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterOverviewVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterShopStatVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterShopVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskDetailVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskPageVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskRowVo;
@@ -23,26 +23,20 @@ import org.springframework.stereotype.Service;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
/**
* 客户端任务管理的只读查询,看板维度是<b>店铺</b>。
* 客户端任务管理的只读查询。
*
* <p>时间口径只有一个:进行中且 {@code updated_at} 超过 10 分钟没动 = 疑似卡住。
* {@code updated_at} 由客户端心跳(60s)与结果回传共同顶新,所以「在跑的任务必然在上报」
* 是这条判定的前提;设备维度不再参与统计(设备号只在详情里作为附注展示)。</p>
*
* <p>店铺面板与汇总卡共用 {@link #aggregateShops} 一份聚合,卡片说几家在跑、面板就列几行,
* 不允许两个数字各算各的。</p>
*/
@Service
@RequiredArgsConstructor
@@ -50,135 +44,56 @@ import java.util.stream.Collectors;
public class TaskCenterQueryService {
private static final long STUCK_IDLE_MINUTES = 10;
/** 面板原料的行数上界:进行中任务正常在几十量级,触顶时打 warn(汇总卡仍按 SQL 精确计数)。 */
private static final long SHOP_PANEL_TASK_CAP = 500;
/** 在跑店铺数原料的行数上界:进行中任务正常在几十量级,触顶时打 warn(数字会偏小)。 */
private static final long ACTIVE_TASK_SCAN_CAP = 500;
private static final long DEFAULT_PAGE_SIZE = 20;
private static final long MAX_PAGE_SIZE = 100;
/** 不落店铺的模块(采集数据、货源查询、品牌检测…)在面板里的合成桶,保证在跑任务不消失。 */
static final String NO_SHOP_LABEL = "不挂店铺";
/** 进行中状态与 mapper SQL 同源,避免「计数说在跑、卡住判定说不在跑」。 */
private static final Set<String> ACTIVE_STATUSES = TaskCenterQueryMapper.ACTIVE_STATUS_SET;
/** 面板排序:该去看谁的店排前面——有卡住的先,其次最久没上报的,「不挂店铺」桶永远垫底。 */
private static final Comparator<TaskCenterShopVo> SHOP_ROW_ORDER = Comparator
.comparing(TaskCenterShopVo::isNoShop)
.thenComparingLong(vo -> -vo.getStuckTasks())
.thenComparing(TaskCenterShopVo::getLastReportAt, Comparator.nullsLast(Comparator.naturalOrder()))
.thenComparing(TaskCenterShopVo::getShop);
private final TaskCenterQueryMapper queryMapper;
public TaskCenterOverviewVo overview(TaskCenterScopeService.ScopeContext scope) {
LocalDateTime now = LocalDateTime.now();
List<Long> userIds = scope.sqlUserIds();
ShopBoard board = aggregateShops(userIds, now);
TaskCenterOverviewVo vo = new TaskCenterOverviewVo();
vo.setShopTotal(queryMapper.countShops(userIds));
vo.setShopRunning(board.runningShops());
vo.setShopRunning(runningShops(userIds));
vo.setRunningTasks(queryMapper.countRunningTasks(userIds));
vo.setStuckTasks(queryMapper.countStuckTasks(userIds, now.minusMinutes(STUCK_IDLE_MINUTES)));
vo.setTodayFinishedTasks(queryMapper.countFinishedTasksSince(userIds, LocalDate.now().atStartOfDay()));
return vo;
}
/** 店铺面板:当前所有进行中任务按店铺归组(含「不挂店铺」桶)。 */
public List<TaskCenterShopVo> shops(TaskCenterScopeService.ScopeContext scope) {
return aggregateShops(scope.sqlUserIds(), LocalDateTime.now()).rows();
}
/** 店铺筛选下拉候选(店铺库内的店铺名,精确匹配用)。 */
public List<String> shopOptions(TaskCenterScopeService.ScopeContext scope) {
return safe(queryMapper.selectShopNames(scope.sqlUserIds()));
}
/** 店铺面板的聚合结果:行 + 其中真店铺数(不含合成桶)。 */
private record ShopBoard(List<TaskCenterShopVo> rows, long runningShops) {
private static final ShopBoard EMPTY = new ShopBoard(List.of(), 0);
}
private ShopBoard aggregateShops(List<Long> userIds, LocalDateTime now) {
List<TaskCenterTaskRow> rows = safe(queryMapper.selectActiveTasks(userIds, SHOP_PANEL_TASK_CAP));
if (rows.size() >= SHOP_PANEL_TASK_CAP) {
log.warn("task-center 店铺面板进行中任务数触顶, cap={}, 面板行数会少于汇总卡", SHOP_PANEL_TASK_CAP);
/**
* 汇总卡「在跑店铺」= 进行中任务挂到的去重店铺数。归组键走 {@link #shopKey} 规范化,
* 同一店两种写法算一家;不落店铺的任务(采集/货源/品牌…)没有店铺维度,天然不计入。
*
* <p>原料是 {@code selectActiveTasks} 的有界扫描,触顶时这个数字会偏小,按 warn 报出来,
* 不静默当成准确值。</p>
*/
private long runningShops(List<Long> userIds) {
List<TaskCenterTaskRow> rows = safe(queryMapper.selectActiveTasks(userIds, ACTIVE_TASK_SCAN_CAP));
if (rows.size() >= ACTIVE_TASK_SCAN_CAP) {
log.warn("task-center 进行中任务数触顶, cap={}, 在跑店铺数会偏小", ACTIVE_TASK_SCAN_CAP);
}
if (rows.isEmpty()) {
return ShopBoard.EMPTY;
}
List<Long> bizIds = rows.stream().filter(row -> !row.isBrand())
.map(TaskCenterTaskRow::getId).filter(Objects::nonNull).distinct().toList();
Map<Long, List<String>> shopsByTask = collectShops(bizIds);
Map<String, ShopAggregate> byShopKey = new LinkedHashMap<>();
Set<String> shopKeys = new HashSet<>();
for (TaskCenterTaskRow row : rows) {
List<String> rowShops = row.isBrand() ? List.of() : shopsByTask.get(row.getId());
if (rowShops == null || rowShops.isEmpty()) {
bucket(byShopKey, NO_SHOP_LABEL).accept(row, now);
continue;
}
for (String shop : rowShops) {
bucket(byShopKey, shop).accept(row, now);
for (String shop : shopsByTask.getOrDefault(row.getId(), List.of())) {
shopKeys.add(shopKey(shop));
}
}
List<TaskCenterShopVo> vos = new ArrayList<>(byShopKey.size());
for (ShopAggregate aggregate : byShopKey.values()) {
vos.add(aggregate.toVo());
}
vos.sort(SHOP_ROW_ORDER);
long runningShops = vos.stream().filter(vo -> !vo.isNoShop()).count();
return new ShopBoard(vos, runningShops);
}
/** 归组键走规范化(小写 + trim),展示名沿用首次出现的写法:同一店两种写法不拆成两行。 */
private static ShopAggregate bucket(Map<String, ShopAggregate> byShopKey, String shopName) {
return byShopKey.computeIfAbsent(shopKey(shopName), key -> new ShopAggregate(shopName.trim()));
}
/** 单个店铺的累计量(进行中任务可能挂多店,一个任务在它挂的每家店下各计一次)。 */
private static final class ShopAggregate {
private final String shop;
private long runningTasks;
private long stuckTasks;
private LocalDateTime lastReportAt;
private final Map<String, Long> modules = new HashMap<>();
private ShopAggregate(String shop) {
this.shop = shop;
this.lastReportAt = null;
}
private void accept(TaskCenterTaskRow row, LocalDateTime now) {
runningTasks++;
if (isStuck(row, now)) {
stuckTasks++;
}
LocalDateTime reportedAt = row.getUpdatedAt() == null ? row.getCreatedAt() : row.getUpdatedAt();
if (reportedAt != null && (lastReportAt == null || reportedAt.isAfter(lastReportAt))) {
lastReportAt = reportedAt;
}
modules.merge(TaskModuleRegistry.labelOf(row.getModuleType()), 1L, Long::sum);
}
private TaskCenterShopVo toVo() {
TaskCenterShopVo vo = new TaskCenterShopVo();
vo.setShop(shop);
vo.setNoShop(NO_SHOP_LABEL.equals(shop));
vo.setRunningTasks(runningTasks);
vo.setStuckTasks(stuckTasks);
vo.setLastReportAt(lastReportAt);
vo.setModuleSummary(modules.entrySet().stream()
.sorted(Map.Entry.<String, Long>comparingByValue(Comparator.reverseOrder())
.thenComparing(Map.Entry.comparingByKey()))
.map(entry -> entry.getKey() + "×" + entry.getValue())
.collect(Collectors.joining(" / ")));
return vo;
}
return shopKeys.size();
}
/** 任务列表:两表 UNION 分页 + 当页行的账号/店铺/进度装配(设备名只在详情装配)。 */
@@ -192,14 +107,15 @@ public class TaskCenterQueryService {
return TaskCenterTaskPageVo.empty(page, pageSize);
}
long total = queryMapper.countTaskPage(userIds, query.getModuleType(), query.getStatus(),
List<String> statuses = statusFilter(query.getStatus());
long total = queryMapper.countTaskPage(userIds, query.getModuleType(), statuses,
query.getShop(), query.getStartTime(), query.getEndTime());
if (total <= 0) {
return TaskCenterTaskPageVo.empty(page, pageSize);
}
List<TaskCenterTaskRow> rows = queryMapper.selectTaskPage(userIds, query.getModuleType(),
query.getStatus(), query.getShop(), query.getStartTime(), query.getEndTime(),
statuses, query.getShop(), query.getStartTime(), query.getEndTime(),
pageSize, (page - 1) * pageSize);
if (rows == null || rows.isEmpty()) {
return TaskCenterTaskPageVo.empty(page, pageSize);
@@ -213,6 +129,22 @@ public class TaskCenterQueryService {
return vo;
}
/**
* 状态筛选展开:空白 = 不裁剪;{@code ACTIVE} = 前端默认的「在跑」,等于三个进行中状态的合并
* (与判卡住用的 {@link #ACTIVE_STATUSES} 同一组,不另定口径);其余按单值下传。
* 品牌表状态本是小写,SQL 里 {@code STATUS_B} 已 UPPER 归一,这里只统一入参大小写。
*/
static List<String> statusFilter(String status) {
if (status == null || status.isBlank()) {
return null;
}
String key = status.trim().toUpperCase(Locale.ROOT);
if (TaskCenterQueryMapper.ACTIVE_STATUS_SENTINEL.equals(key)) {
return TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED;
}
return List.of(key);
}
/**
* 账号名 → 可见账号集合:超管用命中的全部账号,非超管与可见集合求交。
* 未传账号名时返回 {@code scope.sqlUserIds()}(超管为 null = 不裁剪)。
@@ -264,7 +196,7 @@ public class TaskCenterQueryService {
: selectCollectStats(List.of(row), snapshots);
TaskCenterTaskDetailVo vo = fillRow(new TaskCenterTaskDetailVo(), row, usernames, deviceNames,
snapshots, collectStats, collectShops(bizIds), LocalDateTime.now());
snapshots, collectStats, collectShops(bizIds), collectCountries(bizIds), LocalDateTime.now());
vo.setShops(shopStats(row));
vo.setErrorMessage(row.getErrorMessage());
return vo;
@@ -316,12 +248,13 @@ public class TaskCenterQueryService {
: toSnapshots(safe(queryMapper.selectSnapshots(rowIds)));
Map<Long, TaskCenterCollectStatsRow> collectStats = selectCollectStats(rows, snapshots);
Map<Long, List<String>> shops = collectShops(bizIds);
Map<Long, String> countries = collectCountries(bizIds);
LocalDateTime now = LocalDateTime.now();
List<TaskCenterTaskRowVo> items = new ArrayList<>(rows.size());
for (TaskCenterTaskRow row : rows) {
items.add(fillRow(new TaskCenterTaskRowVo(), row, usernames, Map.of(), snapshots,
collectStats, shops, now));
collectStats, shops, countries, now));
}
return items;
}
@@ -397,6 +330,41 @@ public class TaskCenterQueryService {
}
}
/**
* 目标国家:按页内 biz 任务号点查 {@code request_json}(列表主查询不碰大 JSON 列),
* 品牌表与该模块没写国家的任务都不在结果里,前端画「—」。
*/
private Map<Long, String> collectCountries(List<Long> bizIds) {
if (bizIds.isEmpty()) {
return Map.of();
}
Map<Long, String> countries = new HashMap<>();
for (TaskCenterCountryRow row : safe(queryMapper.selectTaskCountries(bizIds))) {
String country = normalizeCountry(row.getCountry());
if (row.getTaskId() != null && country != null) {
countries.put(row.getTaskId(), country);
}
}
return countries;
}
/**
* 国家原文两种形状并存(生产实测:裸串 {@code UK} 与数组文本 {@code ["UK", "DE"]},
* 同一模块两种写法都有),归一为 {@code UK} / {@code UK/DE};取不到返回 null,不猜。
*/
static String normalizeCountry(String raw) {
if (raw == null || raw.isBlank()) {
return null;
}
List<String> codes = new ArrayList<>();
for (String token : raw.replaceAll("[\\[\"\\]\\s]", "").split(",")) {
if (!token.isBlank() && !"null".equals(token)) {
codes.add(token);
}
}
return codes.isEmpty() ? null : String.join("/", codes);
}
/** 列表行与详情行共用同一套装配口径(详情只是多带分组明细与错误信息)。 */
private <T extends TaskCenterTaskRowVo> T fillRow(T vo,
TaskCenterTaskRow row,
@@ -405,6 +373,7 @@ public class TaskCenterQueryService {
Map<String, TaskCenterSnapshotRow> snapshots,
Map<Long, TaskCenterCollectStatsRow> collectStats,
Map<Long, List<String>> shops,
Map<Long, String> countries,
LocalDateTime now) {
vo.setId(row.getId());
vo.setTaskNo(row.getTaskNo());
@@ -434,6 +403,8 @@ public class TaskCenterQueryService {
// 品牌检测按关键字执行、不落店铺;品牌行的 current_scope_key 是品牌名,不能当店铺用。
if (!row.isBrand()) {
// 国家与店铺同样只按 biz id 取(品牌 id 会与 biz 撞号)。
vo.setCountry(countries.get(row.getId()));
List<String> rowShops = shops.get(row.getId());
if (rowShops != null && !rowShops.isEmpty()) {
vo.setShopName(rowShops.get(0));
@@ -515,7 +486,7 @@ public class TaskCenterQueryService {
return lastSeen != null && lastSeen.isBefore(now.minusMinutes(STUCK_IDLE_MINUTES));
}
/** 店铺名的归一化键:与 SQL 的 LOWER(TRIM(...)) 同口径,面板下钻与筛选才对得上。 */
/** 店铺名的归一化键:与 SQL 的 LOWER(TRIM(...)) 同口径,去重计数与筛选才对得上。 */
private static String shopKey(String shopName) {
return shopName.trim().toLowerCase(Locale.ROOT);
}
@@ -10,6 +10,7 @@ import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -54,9 +55,9 @@ class TaskCenterQueryMapperSqlTest {
.replaceAll("\\s*,\\s*", ",");
}
/** 任务列表分页的查询参数(店铺口径下已不再有设备号)。 */
/** 任务列表分页的查询参数(状态已改为「一组大写状态」,「在跑」由服务层展开)。 */
private static Map<String, Object> taskPageParams(Object shop, long limit, long offset) {
return params("userIds", null, "moduleType", null, "status", null, "shop", shop,
return params("userIds", null, "moduleType", null, "statuses", null, "shop", shop,
"startTime", null, "endTime", null, "limit", limit, "offset", offset);
}
@@ -207,8 +208,8 @@ class TaskCenterQueryMapperSqlTest {
@Test
void taskListFiltersReachBothBranchesAndBrandDropsShopFilter() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", List.of(5L, 11L), "moduleType", "PUBLISH", "status", "RUNNING",
"shop", "旗舰店",
params("userIds", List.of(5L, 11L), "moduleType", "PUBLISH",
"statuses", List.of("RUNNING"), "shop", "旗舰店",
"startTime", LocalDateTime.of(2026, 9, 1, 0, 0),
"endTime", LocalDateTime.of(2026, 9, 28, 0, 0),
"limit", 20L, "offset", 20L));
@@ -260,17 +261,55 @@ class TaskCenterQueryMapperSqlTest {
@Test
void taskCountSharesTheUnionBody() {
BoundSql boundSql = render("countTaskPage",
params("userIds", null, "moduleType", "BRAND", "status", "RUNNING",
params("userIds", null, "moduleType", "BRAND", "statuses", List.of("RUNNING"),
"shop", null, "startTime", null, "endTime", null));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("SELECT COUNT(*) FROM(SELECT t.id AS id"));
assertTrue(sql.contains("brand_crawl_tasks"));
assertTrue(sql.contains("AND 'BRAND' = ?"));
assertTrue(sql.contains("AND CASE WHEN UPPER(b.status) = 'CANCELED' THEN 'CANCELLED' ELSE UPPER(b.status) END = ?"));
assertTrue(sql.contains("AND CASE WHEN UPPER(b.status) = 'CANCELED' THEN 'CANCELLED' ELSE UPPER(b.status) END"
+ " IN(?)"));
assertEquals(4, boundSql.getParameterMappings().size(), "业务 + 状态在两张表各绑一次");
}
/**
* 状态筛选必须是 IN:前端默认项「在跑」= PENDING∪RUNNING∪SCHEDULED 三个状态的合并,
* 留旧的单值等号会让默认视图恒空(选了「在跑」却拿 ACTIVE 去比表里的状态)。
*/
@Test
void statusFilterIsAnInListSoTheMergedActiveSentinelWorks() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", null, "moduleType", null,
"statuses", TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED,
"shop", null, "startTime", null, "endTime", null,
"limit", 20L, "offset", 0L));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("AND " + TaskCenterQueryMapper.STATUS_T + " IN(?,?,?)"),
"biz 分支按展开后的三个状态过滤:" + sql);
assertTrue(sql.contains("AND " + TaskCenterQueryMapper.STATUS_B + " IN(?,?,?)"),
"品牌分支同口径(小写状态已由 STATUS_B 归一为大写)");
assertEquals(8, boundSql.getParameterMappings().size(), "两张表各绑三个状态 + 分页两个");
assertEquals("PENDING", boundSql.getAdditionalParameter("__frch_st_0"));
assertEquals("RUNNING", boundSql.getAdditionalParameter("__frch_st_1"));
assertEquals("SCHEDULED", boundSql.getAdditionalParameter("__frch_st_2"));
}
/** 选了具体状态时就是单元素 IN,行为与旧的等号一致;不选则整段不渲染。 */
@Test
void singleStatusStillRendersAsOneElementInList() {
String one = sqlOf(render("countTaskPage",
params("userIds", null, "moduleType", null, "statuses", List.of("SUCCESS"),
"shop", null, "startTime", null, "endTime", null)));
String none = sqlOf(render("countTaskPage",
params("userIds", null, "moduleType", null, "statuses", null,
"shop", null, "startTime", null, "endTime", null)));
assertTrue(one.contains("AND " + TaskCenterQueryMapper.STATUS_T + " IN(?)"), "单状态 = IN 一个值:" + one);
assertFalse(none.contains(TaskCenterQueryMapper.STATUS_T + " IN"), "未选状态不加状态条件");
}
@Test
void usernameLookupIsFuzzyAndBounded() {
BoundSql boundSql = render("selectUserIdsByUsername", params("keyword", "ali"));
@@ -311,6 +350,32 @@ class TaskCenterQueryMapperSqlTest {
assertEquals(2L, boundSql.getAdditionalParameter("__frch_tid_1"));
}
/**
* 国家列的取数:七条 JSON 路径与先后顺序 = 2026-10-04 生产实测(近 30 天 20 行页采样 16 行有值、
* 全量 70.7%),少一条或换序就是另一套覆盖率,所以按「出现顺序」断言而不是只看包含。
* 形状钉死:只回 taskId + country 两列、按主键点查,不进列表主查询(那条不许碰 request_json)。
*/
@Test
void countryLookupReadsTheMeasuredSevenPathsInOrderByPrimaryKey() {
List<String> measuredOrder = List.of("$.filters.countryCode", "$.countryCode", "$.country",
"$.publish_country", "$.countryCodes", "$.country_codes", "$.filters.countryCodes");
BoundSql boundSql = render("selectTaskCountries", params("taskIds", List.of(1L, 2L)));
String sql = sqlOf(boundSql);
int previous = -1;
for (String path : measuredOrder) {
int at = sql.indexOf("JSON_UNQUOTE(JSON_EXTRACT(t.request_json,'" + path + "'))");
assertTrue(at > previous, "路径缺失或顺序变了(顺序就是优先级):" + path + " at=" + at);
previous = at;
}
assertEquals(7, sql.split("JSON_UNQUOTE\\(JSON_EXTRACT\\(t\\.request_json,", -1).length - 1,
"七条路径一条不多一条不少");
assertTrue(sql.startsWith("SELECT t.id AS taskId,COALESCE("), "只出两列,大 JSON 不回服务层");
assertTrue(sql.endsWith("WHERE t.id IN(?,?)"), "按页内任务号点查");
assertFalse(sql.contains("result_json"), "国家不碰进度那个 JSON 列");
assertEquals(2, boundSql.getParameterMappings().size());
}
/** 店铺只有两个真来源:上架结果文件的 shop_name、逐店落行的模块的 source_filename。 */
@Test
void shopSourcesAreBatchedByTaskId() {
@@ -369,6 +434,11 @@ class TaskCenterQueryMapperSqlTest {
TaskCenterQueryMapper.BRAND_ACTIVE_STATUSES);
assertEquals(TaskCenterQueryMapper.sqlList(TaskCenterQueryMapper.BRAND_TERMINAL_STATUS_SET),
TaskCenterQueryMapper.BRAND_TERMINAL_STATUSES);
// 「在跑」筛选项走有序版本(IN 列表要可断言),成员必须与判在跑/判卡住用的那个 Set 完全一致
assertEquals(TaskCenterQueryMapper.ACTIVE_STATUS_SET,
Set.copyOf(TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED), "展开成 IN 的那组 = 进行中状态集合");
assertEquals(List.of("PENDING", "RUNNING", "SCHEDULED"),
TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED, "顺序固定,SQL 文本与日志才可断言");
}
/**
@@ -2,6 +2,7 @@ package com.nanri.aiimage.modules.taskcenter.service;
import com.nanri.aiimage.modules.taskcenter.mapper.TaskCenterQueryMapper;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCollectStatsRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCountryRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterDeviceRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopStatRow;
@@ -10,7 +11,6 @@ import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskQuery;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterUserRow;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterOverviewVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterShopVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskDetailVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskPageVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskRowVo;
@@ -150,16 +150,18 @@ class TaskCenterQueryServiceTest {
return row;
}
private static TaskCenterCountryRow countryRow(long taskId, String country) {
TaskCenterCountryRow row = new TaskCenterCountryRow();
row.setTaskId(taskId);
row.setCountry(country);
return row;
}
private static TaskCenterTaskRowVo item(TaskCenterTaskPageVo page, long id) {
return page.getItems().stream().filter(row -> Long.valueOf(id).equals(row.getId()))
.findFirst().orElseThrow(() -> new AssertionError("任务缺失: " + id));
}
private static TaskCenterShopVo shop(List<TaskCenterShopVo> rows, String name) {
return rows.stream().filter(row -> name.equals(row.getShop()))
.findFirst().orElseThrow(() -> new AssertionError("店铺行缺失: " + name));
}
private void stubPage(List<TaskCenterTaskRow> rows) {
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any()))
.thenReturn((long) rows.size());
@@ -181,6 +183,15 @@ class TaskCenterQueryServiceTest {
when(queryMapper.selectFileResultShops(any())).thenReturn(rows);
}
/** 「在跑店铺」只从汇总卡这个真实出口读,不给私有方法开后门。 */
private long shopRunning() {
when(queryMapper.countShops(isNull())).thenReturn(86L);
when(queryMapper.countRunningTasks(isNull())).thenReturn(0L);
when(queryMapper.countStuckTasks(isNull(), any())).thenReturn(0L);
when(queryMapper.countFinishedTasksSince(isNull(), any())).thenReturn(0L);
return service.overview(superScope()).getShopRunning();
}
// ── 汇总卡 ──────────────────────────────────────────────────────────
@Test
@@ -210,80 +221,29 @@ class TaskCenterQueryServiceTest {
}
@Test
void overviewRunningShopsEqualsPanelRowsExcludingTheBucket() {
void runningShopsCountsRealShopsOnly() {
LocalDateTime now = LocalDateTime.now();
when(queryMapper.countShops(isNull())).thenReturn(86L);
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "COLLECT_DATA", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "林芳旗舰店")));
stubFileResultShops(List.of());
TaskCenterOverviewVo vo = service.overview(superScope());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(1L, vo.getShopRunning(), "2 个在跑任务里只有 1 家真店铺,另一行是不挂店铺桶");
assertEquals(2, panel.size(), "卡片与面板共用同一份聚合:面板 1 家店铺 + 1 行桶");
assertEquals(1L, panel.stream().filter(row -> !row.isNoShop()).count());
assertEquals(1L, shopRunning(), "2 个在跑任务里只有 1 家真店铺,采集数据不落店铺");
}
@Test
void scopedOperatorPassesVisibleUsersToEveryQuery() {
service.overview(scoped(5L, 11L));
service.shops(scoped(5L, 11L));
service.shopOptions(scoped(5L, 11L));
// 可见集合由 Set 转来、顺序不定,断言必须与顺序无关。
verify(queryMapper).countShops(argThat(TaskCenterQueryServiceTest::visiblePair));
verify(queryMapper).countRunningTasks(argThat(TaskCenterQueryServiceTest::visiblePair));
verify(queryMapper, times(2))
.selectActiveTasks(argThat(TaskCenterQueryServiceTest::visiblePair), anyLong());
verify(queryMapper).selectShopNames(argThat(TaskCenterQueryServiceTest::visiblePair));
}
@Test
void shopOptionsAreTheRegistryNamesAsReturned() {
when(queryMapper.selectShopNames(isNull())).thenReturn(List.of("林芳旗舰店", "美国店"));
assertEquals(List.of("林芳旗舰店", "美国店"), service.shopOptions(superScope()));
}
// ── 店铺面板 ────────────────────────────────────────────────────────
@Test
void everyActiveTaskLandsInExactlyOnePanelBucket() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "COLLECT_DATA", "RUNNING", now, now),
brandTaskRow(3L, "running", now, now)));
stubPublishShops(List.of(shopRow(1L, "林芳旗舰店")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(2, panel.size(), "1 家店铺 + 1 行不挂店铺桶");
assertEquals(3L, panel.stream().mapToLong(TaskCenterShopVo::getRunningTasks).sum(),
"每个进行中任务恰好落进一个桶,采集数据与品牌任务不许在看板里消失");
assertEquals(2L, shop(panel, TaskCenterQueryService.NO_SHOP_LABEL).getRunningTasks());
}
@Test
void multiShopTaskIsCountedUnderEachOfItsShops() {
void multiShopTaskMakesEveryShopCount() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(taskRow(1L, "PRICE_TRACK", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "甲店"), shopRow(1L, "乙店")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(2, panel.size());
assertEquals(1L, shop(panel, "甲店").getRunningTasks());
assertEquals(1L, shop(panel, "乙店").getRunningTasks(), "一个任务挂两家店 → 两家店各算 1 个在跑任务");
assertEquals(2L, shopRunning(), "一个任务挂两家店 → 两家店各算一家在跑");
}
@Test
void sameShopWrittenTwoWaysStaysOneRow() {
void sameShopWrittenTwoWaysCountsOnce() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
@@ -291,81 +251,34 @@ class TaskCenterQueryServiceTest {
stubPublishShops(List.of(shopRow(1L, "Amazon 美国店"), shopRow(2L, "amazon 美国店 ")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(1, panel.size(), "大小写与首尾空格差异不拆成两行(与 SQL 的 LOWER(TRIM) 同口径)");
assertEquals("Amazon 美国店", panel.get(0).getShop(), "展示名沿用首次出现的写法");
assertEquals(2L, panel.get(0).getRunningTasks());
assertEquals(1L, shopRunning(), "大小写与首尾空格差异不拆成两家(与 SQL 的 LOWER(TRIM) 同口径)");
}
@Test
void panelRowFlagsStuckTasksAndCarriesFreshestReport() {
void sameShopFromBothSourcesCountsOnce() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now.minusHours(2), now.minusMinutes(30)),
taskRow(2L, "SHOP_MATCH", "RUNNING", now.minusHours(1), now.minusSeconds(40))));
stubPublishShops(List.of(shopRow(1L, "林芳旗舰店"), shopRow(2L, "林芳旗舰店")));
stubFileResultShops(List.of());
stubActiveTasks(List.of(taskRow(1L, "PRICE_TRACK", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "甲店")));
stubFileResultShops(List.of(shopRow(1L, "甲店")));
TaskCenterShopVo row = shop(service.shops(superScope()), "林芳旗舰店");
assertEquals(2L, row.getRunningTasks());
assertEquals(1L, row.getStuckTasks(), "只有 30 分钟没上报的那个算卡住");
assertTrue(within(row.getLastReportAt(), now.minusSeconds(40), 5), "最近上报取该店所有在跑任务里最新的一次");
assertEquals("定时匹配×1 / 跟价×1", row.getModuleSummary(), "按任务数倒序、同数按业务名稳定排列");
assertEquals(1L, shopRunning(), "上架文件与逐店结果行指向同一家店时不重复计数");
}
@Test
void moduleSummaryAggregatesCountsPerBusiness() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(3L, "SHOP_MATCH", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "甲店"), shopRow(2L, "甲店"), shopRow(3L, "甲店")));
stubFileResultShops(List.of());
assertEquals("跟价×2 / 定时匹配×1", shop(service.shops(superScope()), "甲店").getModuleSummary());
}
@Test
void panelSortsStuckFirstThenStalestReportWithBucketLast() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now.minusMinutes(1)),
taskRow(2L, "PRICE_TRACK", "RUNNING", now, now.minusMinutes(30)),
taskRow(3L, "SHOP_MATCH", "RUNNING", now, now.minusMinutes(5)),
taskRow(4L, "COLLECT_DATA", "RUNNING", now, now.minusHours(3))));
stubPublishShops(List.of(shopRow(1L, "A店"), shopRow(2L, "B店"), shopRow(3L, "C店")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(List.of("B店", "C店", "A店", TaskCenterQueryService.NO_SHOP_LABEL),
panel.stream().map(TaskCenterShopVo::getShop).toList(),
"有卡住的排最前,其次最久没上报的,桶永远垫底(哪怕它最久没动)");
}
@Test
void brandTasksNeverQueryShopSourcesAndLandInTheBucket() {
void brandTasksNeverQueryShopSources() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(brandTaskRow(7L, "running", now, now)));
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(1, panel.size());
assertTrue(panel.get(0).isNoShop(), "品牌任务按关键字执行,不落店铺,只能进桶");
assertEquals(1L, panel.get(0).getRunningTasks());
assertEquals(0L, shopRunning(), "品牌任务按关键字执行,没有店铺维度");
verify(queryMapper, never()).selectPublishShops(any());
verify(queryMapper, never()).selectFileResultShops(any());
}
@Test
void emptyPanelDoesNotQueryShopSources() {
void noActiveTaskMeansNoShopSourceQuery() {
stubActiveTasks(List.of());
assertEquals(List.of(), service.shops(superScope()));
assertEquals(0L, shopRunning());
verify(queryMapper, never()).selectPublishShops(any());
verify(queryMapper, never()).selectFileResultShops(any());
}
@@ -432,12 +345,71 @@ class TaskCenterQueryServiceTest {
service.tasks(superScope(), query);
verify(queryMapper).countTaskPage(isNull(), eq("PUBLISH"), eq("RUNNING"),
verify(queryMapper).countTaskPage(isNull(), eq("PUBLISH"), eq(List.of("RUNNING")),
eq("旗舰店"), eq(start), eq(end));
verify(queryMapper).selectTaskPage(isNull(), eq("PUBLISH"), eq("RUNNING"),
verify(queryMapper).selectTaskPage(isNull(), eq("PUBLISH"), eq(List.of("RUNNING")),
eq("旗舰店"), eq(start), eq(end), eq(100L), eq(200L));
}
/** 前端默认项「在跑」= 三个进行中状态的合并:下传的是状态序列,不是字面量 ACTIVE。 */
@Test
void activeSentinelExpandsIntoTheThreeRunningStates() {
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any())).thenReturn(0L);
TaskCenterTaskQuery query = new TaskCenterTaskQuery();
query.setStatus("ACTIVE");
service.tasks(superScope(), query);
verify(queryMapper).countTaskPage(isNull(), isNull(),
eq(TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED), isNull(), isNull(), isNull());
assertEquals(Set.copyOf(TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED),
TaskCenterQueryMapper.ACTIVE_STATUS_SET, "「在跑」的合并口径必须与判卡住用的那组同源");
}
@Test
void statusFilterKeepsSingleStatesAndIgnoresBlank() {
assertEquals(List.of("RUNNING"), TaskCenterQueryService.statusFilter("running"), "大小写不敏感");
assertEquals(List.of("CANCELLED"), TaskCenterQueryService.statusFilter(" CANCELLED "));
assertNull(TaskCenterQueryService.statusFilter(""), "空 = 不裁剪");
assertNull(TaskCenterQueryService.statusFilter(null));
}
/** 国家列:原文两种形状都要归一,取不到留空(前端画「—」),不许把 null 当国家名。 */
@Test
void countryColumnIsNormalizedFromBothJsonShapes() {
LocalDateTime now = LocalDateTime.now();
stubPage(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "PUBLISH", "RUNNING", now, now),
taskRow(3L, "SHOP_MATCH", "RUNNING", now, now),
taskRow(4L, "COLLECT_DATA", "RUNNING", now, now)));
when(queryMapper.selectSnapshots(any())).thenReturn(List.of());
stubPublishShops(List.of());
stubFileResultShops(List.of());
when(queryMapper.selectTaskCountries(List.of(1L, 2L, 3L, 4L))).thenReturn(List.of(
countryRow(1L, "[\"UK\"]"),
countryRow(2L, "[\"UK\", \"DE\"]"),
countryRow(3L, "DE")));
TaskCenterTaskPageVo page = service.tasks(superScope(), new TaskCenterTaskQuery());
assertEquals("UK", item(page, 1L).getCountry(), "单元素数组去掉括号,与裸串 UK 同值");
assertEquals("UK/DE", item(page, 2L).getCountry(), "多国家任务不能只显示第一个");
assertEquals("DE", item(page, 3L).getCountry());
assertNull(item(page, 4L).getCountry(), "该模块不写国家 → 无值,不是空串");
}
/** 品牌任务按关键字执行、没有国家维度;它的 id 还会与 biz 表撞号,所以连点查都不发。 */
@Test
void brandRowsAreNotAskedForCountries() {
LocalDateTime now = LocalDateTime.now();
stubPage(List.of(brandTaskRow(7L, "running", now, now)));
when(queryMapper.selectSnapshots(any())).thenReturn(List.of());
assertNull(item(service.tasks(superScope(), new TaskCenterTaskQuery()), 7L).getCountry());
verify(queryMapper, never()).selectTaskCountries(any());
}
@Test
void stuckFlagBoundary() {
LocalDateTime now = LocalDateTime.now();