mainImageByProduct = loadMainImageObjectKeys(products);
+ for (JdProductEntity product : products) {
+ jdPublishItemMapper.insert(buildSnapshotItem(task, product, request,
+ mainImageByProduct.get(product.getId()), now));
+ }
+
+ JdPublishTaskVo vo = new JdPublishTaskVo();
+ vo.setTaskId(task.getId());
+ vo.setTaskNo(task.getTaskNo());
+ vo.setCollectChannel(task.getCollectChannel());
+ vo.setQueuePayload(buildQueuePayload(task));
+ log.info("[jd-publish] 建单成功 taskId={} taskNo={} products={} userId={} channel={}",
+ task.getId(), task.getTaskNo(), request.getProductIds().size(),
+ request.getUserId(), task.getCollectChannel());
+ return vo;
+ }
+
+ /**
+ * 激活任务(PENDING→RUNNING)——页面把载荷推给本机客户端之前调用。
+ *
+ * 形状照 {@code JdCollectTaskService#activateTask} 同形(2026-11-14 真机实录:漏掉
+ * 这一步,客户端第一个回传会被「任务不在运行中(PENDING)」拒收)。只允许
+ * PENDING→RUNNING 条件更新:与客户端兜底拉取的原子认领互斥,谁先翻转谁执行。
+ */
+ public void activateTask(Long taskId, Long userId) {
+ FileTaskEntity task = fileTaskMapper.selectById(taskId);
+ // 归属谓词走公共出口(TaskLifecycleDebtRatchetTest 棘轮只许降:新增手写遍数即红)。
+ if (task == null || !TaskFinalizeSupport.belongsToModule(MODULE_TYPE, task.getModuleType())
+ || (userId != null && task.getUserId() != null && !Objects.equals(userId, task.getUserId()))) {
+ throw new BusinessException("任务不存在");
+ }
+ int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper()
+ .eq(FileTaskEntity::getId, taskId)
+ .eq(FileTaskEntity::getStatus, STATUS_PENDING)
+ .set(FileTaskEntity::getStatus, STATUS_RUNNING)
+ .set(FileTaskEntity::getUpdatedAt, LocalDateTime.now()));
+ if (updated == 0) {
+ FileTaskEntity latest = fileTaskMapper.selectById(taskId);
+ if (latest != null && STATUS_RUNNING.equals(latest.getStatus())) {
+ throw new BusinessException("任务已在执行中(可能已由客户端自动接管),无需重复启动");
+ }
+ throw new BusinessException("任务已结束");
+ }
+ log.info("[jd-publish] 已激活(PENDING→RUNNING) taskId={} userId={}", taskId, task.getUserId());
+ }
+
+ /**
+ * 明细分批下发(GET /items):只出 PENDING 行(已回传行被 SQL 状态谓词跳过,断点
+ * 重连 cursor 归零也不会重发已发布商品,AC-4 服务端半边);SKU 价按改价规则折算;
+ * 图片发 jd-products 桶预签名 GET URL(蓝图 §3)。
+ */
+ public JdPublishItemsPageVo pullItems(Long taskId, Long userId, Long cursor, Integer limit) {
+ requireOwnedTask(taskId, userId);
+ int safeLimit = Math.min(Math.max(limit == null ? itemsBatchSize : limit, 1), MAX_ITEMS_BATCH);
+ long safeCursor = cursor == null ? 0L : Math.max(0L, cursor);
+
+ List rows = jdPublishItemMapper.selectPublishableItems(taskId, safeCursor, safeLimit);
+ // 页内商品行批量取(attrs 原样透传),不逐行 selectById。
+ Map productsByPid = rows.isEmpty() ? Map.of()
+ : jdProductMapper.selectBatchIds(rows.stream().map(JdPublishItemEntity::getProductId).toList())
+ .stream().collect(Collectors.toMap(JdProductEntity::getId, Function.identity(), (a, b) -> a));
+
+ JdPublishItemsPageVo vo = new JdPublishItemsPageVo();
+ vo.setTaskId(taskId);
+ vo.setItems(rows.isEmpty() ? List.of() : rows.stream()
+ .map(row -> buildItemPayload(row, productsByPid.get(row.getProductId())))
+ .toList());
+ vo.setNextCursor(rows.isEmpty() ? safeCursor : rows.get(rows.size() - 1).getId());
+ vo.setHasMore(rows.size() == safeLimit);
+ vo.setPendingCount(aggregateStatusCounts(taskId).getOrDefault(ITEM_PENDING, 0L));
+ return vo;
+ }
+
+ /** 行级进度(R7 实时面板):任务级状态/终态原因 + 行级分组计数。 */
+ public JdPublishProgressVo queryProgress(Long taskId, Long userId) {
+ FileTaskEntity task = requireOwnedTask(taskId, userId);
+ JdPublishProgressVo vo = new JdPublishProgressVo();
+ vo.setTaskId(task.getId());
+ vo.setStatus(task.getStatus());
+ vo.setMessage(task.getErrorMessage());
+ vo.setUpdatedAt(task.getUpdatedAt());
+ Map counts = aggregateStatusCounts(taskId);
+ vo.setPendingCount(counts.getOrDefault(ITEM_PENDING, 0L));
+ vo.setPublishingCount(counts.getOrDefault(ITEM_PUBLISHING, 0L));
+ vo.setSuccessCount(counts.getOrDefault(ITEM_SUCCESS, 0L));
+ vo.setFailedCount(counts.getOrDefault(ITEM_FAILED, 0L));
+ vo.setTotalCount(vo.getPendingCount() + vo.getPublishingCount() + vo.getSuccessCount() + vo.getFailedCount());
+ return vo;
+ }
+
+ /** 回传/兜底拉取侧读建单载荷(request_json 整体);缺失/损坏按异常拒绝,不静默兜。 */
+ public JdPublishTaskCreateRequest readCreateRequest(FileTaskEntity task) {
+ try {
+ JdPublishTaskCreateRequest request = objectMapper.readValue(task.getRequestJson(),
+ JdPublishTaskCreateRequest.class);
+ if (request == null || request.getProductIds() == null || request.getProductIds().isEmpty()) {
+ throw new BusinessException("任务载荷缺少 productIds,无法下发发布明细");
+ }
+ return request;
+ } catch (BusinessException ex) {
+ throw ex;
+ } catch (Exception ex) {
+ throw new BusinessException("任务载荷解析失败 taskId=" + task.getId(), ex);
+ }
+ }
+
+ /** 建单成功页面推送载荷(铁律 32 第三件;type 与 JdPublishTaskPullSpiImpl.QUEUE_TYPE 同值)。 */
+ public Map buildQueuePayload(FileTaskEntity task) {
+ JdPublishTaskCreateRequest create = readCreateRequest(task);
+ Map data = new LinkedHashMap<>();
+ data.put("taskId", task.getId());
+ data.put("priceRule", create.getPriceRule() == null ? Map.of("mode", "none") : create.getPriceRule());
+ return Map.of("type", JdPublishTaskPullSpiImpl.QUEUE_TYPE, "data", data);
+ }
+
+ /**
+ * 心跳上报(B98-07 同形债预防,用户域半边):归属校验在调全局心跳通道之前——
+ * 可信 uid 按 (taskId, userId) 对比任务 owner,不一致一律拒;比对放服务层让全局
+ * {@code /api/tasks/{taskId}/heartbeat} 与本模块内聚端点共用同一闸(B98-07 的债是
+ * 「任意用户可给任意任务刷心跳续命」,实例域判据对 LOCAL 客户端心跳不适用,
+ * 见 {@code JdPublishTaskHeartbeatSpi} 类注释)。
+ */
+ public TaskHeartbeatVo heartbeat(Long taskId, Long userId, TaskHeartbeatRequest request) {
+ requireOwnedTask(taskId, userId);
+ taskHeartbeatPositionService.record(taskId, request);
+ return taskHeartbeatService.heartbeat(taskId, request);
+ }
+
+ /** 供测试确认快照行形状。 */
+ public List findItemRows(Long taskId) {
+ return jdPublishItemMapper.selectList(new LambdaQueryWrapper()
+ .eq(JdPublishItemEntity::getTaskId, taskId)
+ .orderByAsc(JdPublishItemEntity::getId));
+ }
+
+ /** 归属校验唯一出口:模块归属谓词走公共出口 + (taskId, userId) 归属对比(铁律 11)。 */
+ private FileTaskEntity requireOwnedTask(Long taskId, Long userId) {
+ if (taskId == null || taskId <= 0) {
+ throw new BusinessException("任务 ID 不合法");
+ }
+ FileTaskEntity task = fileTaskMapper.selectById(taskId);
+ if (task == null || !TaskFinalizeSupport.belongsToModule(MODULE_TYPE, task.getModuleType())) {
+ throw new BusinessException("任务不存在: " + taskId);
+ }
+ if (userId != null && task.getUserId() != null && !Objects.equals(userId, task.getUserId())) {
+ throw new BusinessException(403, "无权查看该任务");
+ }
+ return task;
+ }
+
+ private void validate(JdPublishTaskCreateRequest request) {
+ if (request.getUserId() == null || request.getUserId() <= 0) {
+ throw new BusinessException("user_id 不合法");
+ }
+ if (request.getProductIds() == null || request.getProductIds().isEmpty()) {
+ throw new BusinessException("请勾选要上架的商品");
+ }
+ // 保序去重:同一次提交里重复勾选同一商品,落一行而不是两行(uk_task_product 同义)。
+ request.setProductIds(request.getProductIds().stream()
+ .filter(Objects::nonNull)
+ .filter(id -> id > 0)
+ .distinct()
+ .toList());
+ if (request.getProductIds().isEmpty()) {
+ throw new BusinessException("请勾选要上架的商品");
+ }
+ if (request.getProductIds().size() > MAX_PRODUCT_IDS) {
+ throw new BusinessException("单次上架最多选 " + MAX_PRODUCT_IDS + " 个商品,当前 "
+ + request.getProductIds().size() + " 个");
+ }
+ normalizePriceRule(request);
+ }
+
+ /** 改价规则归一化写回请求体:request_json 里的值必须就是闸门认可的值(铁律 27a 同源)。 */
+ private void normalizePriceRule(JdPublishTaskCreateRequest request) {
+ PriceRule rule = request.getPriceRule();
+ if (rule == null || rule.getMode() == null || rule.getMode().isBlank()) {
+ request.setPriceRule(null);
+ return;
+ }
+ String mode = rule.getMode().trim().toLowerCase(Locale.ROOT);
+ if (!Set.of("none", "percent", "fixed").contains(mode)) {
+ throw new BusinessException("改价规则不识别: " + rule.getMode() + "(只支持 none/percent/fixed)");
+ }
+ if (!"none".equals(mode)) {
+ if (rule.getValue() == null) {
+ throw new BusinessException("改价规则 mode=" + mode + " 时必须填写加价值");
+ }
+ if (rule.getValue().compareTo(BigDecimal.ZERO) < 0) {
+ throw new BusinessException("加价值不能为负数");
+ }
+ }
+ rule.setMode(mode);
+ request.setPriceRule(rule);
+ }
+
+ /** 最终价:none 原值;percent 按百分比上浮;fixed 固定加价。2 位小数 HALF_UP。 */
+ static BigDecimal finalPriceOf(BigDecimal source, PriceRule rule) {
+ if (source == null) {
+ return null;
+ }
+ if (rule == null || rule.getValue() == null || "none".equals(rule.getMode())) {
+ return source.setScale(2, RoundingMode.HALF_UP);
+ }
+ if ("percent".equals(rule.getMode())) {
+ BigDecimal uplifted = source.add(source.multiply(rule.getValue()).movePointLeft(2));
+ return uplifted.setScale(2, RoundingMode.HALF_UP);
+ }
+ return source.add(rule.getValue()).setScale(2, RoundingMode.HALF_UP);
+ }
+
+ /** 快照明细行:商品主档列随行固化,改价折算进 price_rule_json(蓝图 §3)。 */
+ private JdPublishItemEntity buildSnapshotItem(FileTaskEntity task, JdProductEntity product,
+ JdPublishTaskCreateRequest request,
+ String mainImageObjectKey, LocalDateTime now) {
+ JdPublishItemEntity item = new JdPublishItemEntity();
+ item.setTaskId(task.getId());
+ item.setCompanyId(product.getCompanyId());
+ item.setUserId(task.getUserId());
+ item.setProductId(product.getId());
+ item.setProductCode(product.getProductCode());
+ item.setShopName(product.getShopName());
+ item.setTitle(product.getTitle());
+ item.setCategoryPath(product.getCategoryPath());
+ PriceRule rule = request.getPriceRule();
+ BigDecimal sourcePrice = product.getPriceMin();
+ Map priceJson = new LinkedHashMap<>();
+ priceJson.put("mode", rule == null ? "none" : rule.getMode());
+ priceJson.put("value", rule == null ? null : rule.getValue());
+ priceJson.put("sourcePrice", sourcePrice);
+ priceJson.put("finalPrice", finalPriceOf(sourcePrice, rule));
+ item.setPriceRuleJson(toJson(priceJson));
+ Map stockJson = new LinkedHashMap<>();
+ stockJson.put("total", product.getStockTotal());
+ item.setStockJson(toJson(stockJson));
+ item.setPublishStatus(ITEM_PENDING);
+ item.setMainImageObjectKey(mainImageObjectKey);
+ item.setCreatedAt(now);
+ item.setUpdatedAt(now);
+ return item;
+ }
+
+ private String toJson(Map value) {
+ try {
+ return objectMapper.writeValueAsString(value);
+ } catch (Exception ex) {
+ throw new BusinessException("序列化快照列失败", ex);
+ }
+ }
+
+ /** MAIN 档主图 objectKey(每商品取 sortNo 最小行);图片行缺失/无 key 的商品不落主图列。 */
+ private Map loadMainImageObjectKeys(List products) {
+ List productIds = products.stream().map(JdProductEntity::getId).toList();
+ List images = jdProductImageMapper.selectList(
+ new LambdaQueryWrapper()
+ .in(JdProductImageEntity::getProductId, productIds)
+ .eq(JdProductImageEntity::getImageType, "MAIN")
+ .orderByAsc(JdProductImageEntity::getSortNo, JdProductImageEntity::getId));
+ Map result = new LinkedHashMap<>();
+ for (JdProductImageEntity image : images) {
+ if (image.getObjectKey() != null && !image.getObjectKey().isBlank()) {
+ result.putIfAbsent(image.getProductId(), image.getObjectKey());
+ }
+ }
+ return result;
+ }
+
+ /** 行级状态聚合(XML 具名 SQL):status → 行数。 */
+ private Map aggregateStatusCounts(Long taskId) {
+ Map counts = new LinkedHashMap<>();
+ for (Map row : jdPublishItemMapper.countByPublishStatus(taskId)) {
+ Object status = row.get("publishStatus");
+ Object cnt = row.get("cnt");
+ if (status != null && cnt instanceof Number number) {
+ counts.put(String.valueOf(status), number.longValue());
+ }
+ }
+ return counts;
+ }
+
+ /** 单行下发载荷:SKU 折算价 + 图片预签名 GET(商品行由页内批量预取传入)。 */
+ private JdPublishItemPayloadVo buildItemPayload(JdPublishItemEntity row, JdProductEntity product) {
+ JdPublishItemPayloadVo vo = new JdPublishItemPayloadVo();
+ vo.setItemId(row.getId());
+ vo.setProductId(row.getProductId());
+ vo.setProductCode(row.getProductCode());
+ vo.setTitle(row.getTitle());
+ vo.setCategoryPath(row.getCategoryPath());
+ vo.setSourcePrice(sourcePriceOf(row));
+ vo.setFinalPrice(finalPriceOf(row));
+ vo.setStockTotal(stockTotalOf(row));
+ vo.setAttrs(product == null ? null : product.getAttrJson());
+ PriceRule rule = priceRuleOf(row);
+ vo.setSkus(loadSkuPayloads(row.getProductId(), rule));
+ vo.setMainImages(loadImagePayloads(row.getProductId(), "MAIN"));
+ vo.setAttrImages(loadImagePayloads(row.getProductId(), "ATTR"));
+ vo.setDetailImages(loadImagePayloads(row.getProductId(), "DETAIL"));
+ return vo;
+ }
+
+ private PriceRule priceRuleOf(JdPublishItemEntity row) {
+ Map json = readJson(row.getPriceRuleJson());
+ PriceRule rule = new PriceRule();
+ Object mode = json.get("mode");
+ Object value = json.get("value");
+ rule.setMode(mode == null ? "none" : String.valueOf(mode));
+ rule.setValue(decimalOf(value));
+ return rule;
+ }
+
+ private BigDecimal sourcePriceOf(JdPublishItemEntity row) {
+ return decimalOf(readJson(row.getPriceRuleJson()).get("sourcePrice"));
+ }
+
+ private BigDecimal finalPriceOf(JdPublishItemEntity row) {
+ return decimalOf(readJson(row.getPriceRuleJson()).get("finalPrice"));
+ }
+
+ private Integer stockTotalOf(JdPublishItemEntity row) {
+ Object total = readJson(row.getStockJson()).get("total");
+ return total instanceof Number number ? number.intValue() : null;
+ }
+
+ private Map readJson(String value) {
+ if (value == null || value.isBlank()) {
+ return Map.of();
+ }
+ try {
+ return objectMapper.readValue(value,
+ objectMapper.getTypeFactory().constructMapType(LinkedHashMap.class, String.class, Object.class));
+ } catch (Exception ex) {
+ log.warn("[jd-publish] 快照 JSON 解析失败,按空快照下发 err={}", ex.getMessage());
+ return Map.of();
+ }
+ }
+
+ private BigDecimal decimalOf(Object value) {
+ return value instanceof Number number ? BigDecimal.valueOf(number.doubleValue()) : null;
+ }
+
+ /** SKU 矩阵按 sortNo 升序下发,价按改价规则从 SKU 源价折算(与主档价同一规则同一函数)。 */
+ private List loadSkuPayloads(Long productId, PriceRule rule) {
+ List skus = jdProductSkuMapper.selectList(
+ new LambdaQueryWrapper()
+ .eq(JdProductSkuEntity::getProductId, productId)
+ .orderByAsc(JdProductSkuEntity::getSortNo, JdProductSkuEntity::getId));
+ return skus.stream().map(sku -> {
+ JdPublishItemPayloadVo.SkuVo vo = new JdPublishItemPayloadVo.SkuVo();
+ vo.setSkuId(sku.getSkuId());
+ vo.setSkuName(sku.getSkuName());
+ vo.setSourcePrice(sku.getPrice());
+ vo.setFinalPrice(finalPriceOf(sku.getPrice(), rule));
+ vo.setStock(sku.getStock());
+ vo.setSaleAttrsJson(sku.getSaleAttrsJson());
+ vo.setSortNo(sku.getSortNo());
+ return vo;
+ }).toList();
+ }
+
+ /** 指定档图片按 sortNo 升序发预签名 GET URL(objectKey 留档可重签)。 */
+ private List loadImagePayloads(Long productId, String imageType) {
+ List images = jdProductImageMapper.selectList(
+ new LambdaQueryWrapper()
+ .eq(JdProductImageEntity::getProductId, productId)
+ .eq(JdProductImageEntity::getImageType, imageType)
+ .orderByAsc(JdProductImageEntity::getSortNo, JdProductImageEntity::getId));
+ return images.stream().map(image -> {
+ JdPublishItemPayloadVo.ImageView view = new JdPublishItemPayloadVo.ImageView();
+ view.setObjectKey(image.getObjectKey());
+ view.setUrl(ossStorageService.presignObjectDownload(bucket, image.getObjectKey(),
+ IMAGE_PRESIGN_EXPIRY_SECONDS));
+ view.setAttrName(image.getAttrName());
+ view.setSortNo(image.getSortNo());
+ return view;
+ }).toList();
+ }
+}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/model/CollectChannel.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/model/CollectChannel.java
index fd53e977c..b57eecb34 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/task/model/CollectChannel.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/model/CollectChannel.java
@@ -13,7 +13,7 @@ import java.util.Locale;
* 只剩兜底窗口,不再决定执行方。
*
* 列可空,且**不回填**:空值按模块默认解释,外观专利/相似ASIN/京东店铺采集
- * (v1.4 起)读作 {@link #LOCAL}、其余模块读作 {@link #ONLINE},与 V183 之前
+ * (v1.4 起)/京东商品上架(v1.5 起)读作 {@link #LOCAL}、其余模块读作 {@link #ONLINE},与 V183 之前
* {@code AIIMAGE_COLLECT_LOCAL_*} 的出厂值 {@code true} 逐字等价。未升级的客户端与
* 全部历史任务因此行为不变。京东采集只能在本机 Windows + 紫鸟窗口执行,不加进本清单
* 就会默认 ONLINE ⇒ 任务被推给无紫鸟的 Linux worker,永不执行(铁律 19 同形)。
@@ -29,7 +29,8 @@ public enum CollectChannel {
private static final List LOCAL_DEFAULT_MODULES = List.of(
CollectRoutingProperties.MODULE_APPEARANCE_PATENT,
CollectRoutingProperties.MODULE_SIMILAR_ASIN,
- CollectRoutingProperties.MODULE_JD_SHOP_COLLECT);
+ CollectRoutingProperties.MODULE_JD_SHOP_COLLECT,
+ CollectRoutingProperties.MODULE_JD_PUBLISH);
/**
* 未登记通道时读作 {@link #LOCAL} 的模块清单。
diff --git a/backend-java/src/main/resources/application-local.example.yml b/backend-java/src/main/resources/application-local.example.yml
index bb9f33338..d745532f0 100644
--- a/backend-java/src/main/resources/application-local.example.yml
+++ b/backend-java/src/main/resources/application-local.example.yml
@@ -43,7 +43,10 @@ AIIMAGE_JD_COLLECT_IMAGE_MAX_PER_PRODUCT=200
AIIMAGE_JD_COLLECT_STALE_MINUTES=60
# SKU 矩阵单商品上限(V198 详情面):真机一个商品 12 行,超限截断并 WARN。
AIIMAGE_JD_SKU_MAX_PER_PRODUCT=200
-# 京东采集的客户端兜底拉取白名单(v1.4 P0-1):默认值已含 JD_SHOP_COLLECT(见 application.yml)。
+# 京东商品上架(v1.5):对应 application.yml 的 aiimage.jd: publish 段。
+AIIMAGE_JD_PUBLISH_STALE_MINUTES=60
+AIIMAGE_JD_PUBLISH_ITEMS_BATCH_SIZE=20
+# 京东采集/上架的客户端兜底拉取白名单(v1.4 P0-1 / v1.5):默认值已含 JD_SHOP_COLLECT、JD_PUBLISH(见 application.yml)。
# ⚠ 只有真的要覆盖整个白名单时才设 AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES——env 变量存在即生效,
# 设成空串会把白名单清空(兜底拉取对 JD 形同关闭)。打开 AIIMAGE_CLIENT_TASK_PULL_ENABLED
# 前先确认客户端版本带兜底拉取线程。
diff --git a/backend-java/src/main/resources/application.yml b/backend-java/src/main/resources/application.yml
index b9370e1be..a2f523b9b 100644
--- a/backend-java/src/main/resources/application.yml
+++ b/backend-java/src/main/resources/application.yml
@@ -177,6 +177,11 @@ aiimage:
# SKU 矩阵单商品上限(V198 详情面):真机一个商品 12 行,超限截断并 WARN,
# 防脏回传把整批撑爆。显式写在这里,不许只活在代码默认值里。
sku-max-per-product: ${AIIMAGE_JD_SKU_MAX_PER_PRODUCT:200}
+ # 京东商品上架(v1.5):发布是逐商品页面自动化,节奏比采集慢——判死窗口独立可调
+ # (按发布时长重估,蓝图 §3);items 下发批大小钳制在服务侧(上限 100)。
+ publish:
+ stale-minutes: ${AIIMAGE_JD_PUBLISH_STALE_MINUTES:60}
+ items-batch-size: ${AIIMAGE_JD_PUBLISH_ITEMS_BATCH_SIZE:20}
# 设备日志对象存储:主机B 独立 MinIO(与业务 OSS 隔离,日志只保留 7 天)。
# endpoint 未配置时日志上报/管理接口不可用(宁可失败也不静默落到业务桶)。
# 桶的 7 天过期规则由运维用 mc 配置(与 retention-days 口径一致)。
@@ -300,7 +305,7 @@ aiimage:
enabled: ${AIIMAGE_MODULE_CLEANUP_ENABLED:true}
cron: ${AIIMAGE_MODULE_CLEANUP_CRON:0 0 0 * * *}
retention-days: ${AIIMAGE_MODULE_CLEANUP_RETENTION_DAYS:7}
- module-types: ${AIIMAGE_MODULE_CLEANUP_MODULE_TYPES:DEDUPE,SPLIT,CONVERT,DELETE_BRAND,PRODUCT_RISK_RESOLVE,PRICE_TRACK,SHOP_MATCH,PATROL_DELETE,QUERY_ASIN,WITHDRAW,APPEARANCE_PATENT,SIMILAR_ASIN,COLLECT_DATA,JD_SHOP_COLLECT}
+ module-types: ${AIIMAGE_MODULE_CLEANUP_MODULE_TYPES:DEDUPE,SPLIT,CONVERT,DELETE_BRAND,PRODUCT_RISK_RESOLVE,PRICE_TRACK,SHOP_MATCH,PATROL_DELETE,QUERY_ASIN,WITHDRAW,APPEARANCE_PATENT,SIMILAR_ASIN,COLLECT_DATA,JD_SHOP_COLLECT,JD_PUBLISH}
# 以下为各业务表的保留期清理(2026-09-16 统一补齐):这些表此前只增不删,
# 或只有"读的时候顺手删一行"这类碰运气的清理。全部按天分批删除、带分布式锁单实例执行。
device-log:
@@ -405,7 +410,9 @@ aiimage:
# 2026-11-14 v1.4 加 JD_SHOP_COLLECT(P0-1):京东采集只能在本机客户端执行(紫鸟/京麦
# 登录态在桌面机),页面推送缺失时任务会永久停在 PENDING——兜底拉取是它的唯一出路;
# queuePayload 由 JdTaskPullSpiImpl 组装(type=jd-shop-collect-run,与客户端同值)。
- module-types: ${AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES:SIMILAR_ASIN,COLLECT_DATA,JD_SHOP_COLLECT}
+ # 2026-11-17 v1.5 加 JD_PUBLISH:京麦登录态在用户桌面机 19899 Chrome profile,发布同样
+ # 只能由客户端执行;queuePayload 由 JdPublishTaskPullSpiImpl 组装(type=jd-product-publish-run)。
+ module-types: ${AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES:SIMILAR_ASIN,COLLECT_DATA,JD_SHOP_COLLECT,JD_PUBLISH}
min-pending-minutes: ${AIIMAGE_CLIENT_TASK_PULL_MIN_PENDING_MINUTES:5}
limit: ${AIIMAGE_CLIENT_TASK_PULL_LIMIT:5}
# 服务端内部认领(/api/internal/tasks/pull-pending,Linux 后台 worker 专用),
diff --git a/backend-java/src/main/resources/db/V210__jd_publish_item.sql b/backend-java/src/main/resources/db/V210__jd_publish_item.sql
new file mode 100644
index 000000000..b2547734a
--- /dev/null
+++ b/backend-java/src/main/resources/db/V210__jd_publish_item.sql
@@ -0,0 +1,47 @@
+-- 迁移 V210:京东商品上架发布明细表 biz_jd_publish_item(v1.5 蓝图 docs/ITERATION_PLAN.md §3)。
+-- =============================================================
+-- 1. 号段协调(2026-11-17 当窗实核):V207=users_jd_publish_quota(5c7a310e)、
+-- V208=drop_jd_category_manage_menu、V209=jd_app_menu 已按序占用(蓝图 Phase 0 登记的
+-- V208 在飞件已转正),发布明细表取 V210;契约正则放宽到 V208~V229(JdPublishContractPendingTest)。
+--
+-- 2. 形状口径:每任务每商品一行(uk_task_product)——建单即按 biz_jd_product 快照落行
+-- (商品库有 ageCleanup 清理语义,发布记录不随商品删除丢失溯源,蓝图 §3);行级状态机
+-- PENDING → PUBLISHING → SUCCESS/FAILED 由客户端 chunk 回传逐行推进,服务端不预测
+-- (行状态唯一写入口 = JdPublishIngestService,单客户端串行回传无并发竞争)。
+-- 任务级行为复用 biz_file_task(module_type=JD_PUBLISH),本表只承载行级明细。
+-- user_id 是任务 owner 投影(biz_file_task.user_id),company_id 物化归属分公司
+-- (owner 用户的 users.company_id;读不出显式落 NULL 不回填默认,铁律 30)。
+--
+-- 3. 影响表与数据量:新表零存量行;行数 = 上架任务商品勾选数(单任务上限 500,建单口钳制)。
+--
+-- 4. 可重跑性:CREATE TABLE IF NOT EXISTS——中途失败重跑整条 no-op(V193/V198 先例)。
+-- 应用侧:MigrationInventoryTest 自动清点;JdSchemaContractTest#V210 钉形状。
+--
+-- 5. 回滚(patch,不当期执行):
+-- DROP TABLE biz_jd_publish_item;
+-- DELETE FROM flyway_schema_history WHERE version='210';
+-- =============================================================
+
+CREATE TABLE IF NOT EXISTS `biz_jd_publish_item` (
+ `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键',
+ `task_id` BIGINT NOT NULL COMMENT 'biz_file_task.id(module_type=JD_PUBLISH)',
+ `company_id` BIGINT NULL COMMENT '物化归属分公司(owner 的 users.company_id;读不出落 NULL 不回填,铁律 30)',
+ `user_id` BIGINT NOT NULL COMMENT '任务 owner uid(biz_file_task.user_id 投影)',
+ `product_id` BIGINT NOT NULL COMMENT '商品行 id(biz_jd_product.id)',
+ `product_code` VARCHAR(64) NULL COMMENT '京东商品编码快照',
+ `shop_name` VARCHAR(255) NULL COMMENT '来源店铺名快照',
+ `title` VARCHAR(600) NULL COMMENT '商品标题快照(京麦标题上限 60 字,留余量)',
+ `category_path` VARCHAR(512) NULL COMMENT '京麦类目路径快照(A > B > C)',
+ `price_rule_json` JSON NULL COMMENT '改价快照 {"mode":"none|percent|fixed","value":n,"sourcePrice":x,"finalPrice":y}(finalPrice=主档价按规则折算)',
+ `stock_json` JSON NULL COMMENT '库存快照 {"total":n}',
+ `publish_status` VARCHAR(32) NOT NULL DEFAULT 'PENDING' COMMENT '行级状态机:PENDING/PUBLISHING/SUCCESS/FAILED',
+ `publish_error` VARCHAR(1024) NULL COMMENT '行级失败真实原因(客户端回传原文,R6 单行失败隔离)',
+ `jd_ware_id` VARCHAR(64) NULL COMMENT '京麦发布成功回执的商品 id(wareId,AC-3 真机核对锚点)',
+ `main_image_object_key` VARCHAR(512) NULL COMMENT '主图 objectKey 快照(biz_jd_product_image MAIN 档 sortNo 最小行)',
+ `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '建单落行时刻',
+ `updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '最近回传/复位时刻',
+ PRIMARY KEY (`id`),
+ UNIQUE KEY `uk_task_product` (`task_id`, `product_id`),
+ KEY `idx_task_status` (`task_id`, `publish_status`),
+ KEY `idx_user_created` (`user_id`, `created_at`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='京东商品上架发布明细(v1.5,行级状态与快照,任务行在 biz_file_task)';
diff --git a/backend-java/src/main/resources/mapper/jd/JdPublishItemMapper.xml b/backend-java/src/main/resources/mapper/jd/JdPublishItemMapper.xml
new file mode 100644
index 000000000..f491bea93
--- /dev/null
+++ b/backend-java/src/main/resources/mapper/jd/JdPublishItemMapper.xml
@@ -0,0 +1,31 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java
index 1493707d8..ffdeab962 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java
@@ -44,7 +44,7 @@ class TaskModuleCoverageTest {
"PUBLISH", "DEDUPE", "SPLIT", "CONVERT", "DELETE_BRAND", "PRODUCT_RISK_RESOLVE",
"PRICE_TRACK", "SHOP_MATCH", "PATROL_DELETE", "QUERY_ASIN", "WITHDRAW",
"APPEARANCE_PATENT", "SIMILAR_ASIN", "COLLECT_DATA", "SHOP_DATA_CRAWL", "BRAND",
- "JD_SHOP_COLLECT");
+ "JD_SHOP_COLLECT", "JD_PUBLISH");
@Test
void registryCoversEveryKnownModuleWithLabel() {
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdCollectChannelGoldenTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdCollectChannelGoldenTest.java
index 82e12099e..659cc462f 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdCollectChannelGoldenTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdCollectChannelGoldenTest.java
@@ -27,13 +27,14 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
*/
class JdCollectChannelGoldenTest {
- /** Phase 1 起注册表 17 个模块且含京东:再增删模块必须同轮更新本清单。 */
+ /** Phase 1 起注册表 17 个模块且含京东;Phase 2(v1.5)加 JD_PUBLISH 后 18 个:再增删模块必须同轮更新本清单。 */
@Test
void 京东模块已注册进任务模块注册表() {
Set types = TaskModuleRegistry.moduleTypes();
- assertEquals(17, types.size(), "再增删模块时同轮更新本数(Phase 1 定格 17)");
+ assertEquals(18, types.size(), "再增删模块时同轮更新本数(Phase 1 定格 17,v1.5 Phase 2 定格 18)");
assertTrue(types.containsAll(List.of("APPEARANCE_PATENT", "SIMILAR_ASIN", "SHOP_DATA_CRAWL",
- "COLLECT_DATA", "PRICE_TRACK", "PUBLISH", "BRAND", "JD_SHOP_COLLECT")), "既有清单形状漂移,先查别人改动");
+ "COLLECT_DATA", "PRICE_TRACK", "PUBLISH", "BRAND", "JD_SHOP_COLLECT", "JD_PUBLISH")),
+ "既有清单形状漂移,先查别人改动");
}
/** 京东模块默认 LOCAL(紫鸟只在本机):谁把它翻回 ONLINE 这里先红。 */
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdPublishContractPendingTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdPublishContractPendingTest.java
index 70e8442c6..9fdf79d51 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdPublishContractPendingTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdPublishContractPendingTest.java
@@ -2,7 +2,6 @@ package com.nanri.aiimage.modules.jd;
import com.nanri.aiimage.modules.task.model.CollectChannel;
-import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import java.io.IOException;
@@ -18,12 +17,12 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* v1.5 京东商品上架到京麦(Phase 0 预置的验收契约,蓝图 docs/ITERATION_PLAN.md §1 AC / §4)。
*
- * Pending-to-Active 机制:标 {@code @Disabled("Pending Phase 2")} 的方法是 Phase 2
- * (后端地基:V208+ 迁移 / JdPublishController / JdPublishTaskService / 派发三件套)落地后才
- * 能跑绿的契约,实现合入的同一个 Phase 里必须移除注解跑绿——蓝图对应 Phase 的【待激活验收
- * 测试】栏登记了这份清单。唯一不 skip 的方法 {@link #京东分类读取口全仓唯一_B11301绊线()} 是
- * 立即生效的存量绊线:B113-01 拍板「分类选项唯一来源 GET /api/jd-collect/groups」,
- * 任何面(含本迭代新增的发布面)都不许开第二个京东分类读取口。
+ *
Pending-to-Active 机制:Phase 0 预置时标 {@code @Disabled("Pending Phase 2")} 的
+ * 7 支已在 Phase 2(后端地基:V210 迁移 / JdPublishController / JdPublishTaskService /
+ * 派发三件套)落地时移除注解正式激活(蓝图 Phase 2【待激活验收测试】清单)。
+ * {@link #京东分类读取口全仓唯一_B11301绊线()} 是立即生效的存量绊线:B113-01 拍板
+ * 「分类选项唯一来源 GET /api/jd-collect/groups」,任何面(含本迭代新增的发布面)都不许开
+ * 第二个京东分类读取口。
*
*
Pending 方法全部写成源码绊线(读源文件断言关键形状),不 import 尚不存在的新类,
* Phase 0 落盘即可编译;判据形状照 {@code JdTaskPullSpiImplTest}(白名单段绊线)与
@@ -75,7 +74,6 @@ class JdPublishContractPendingTest {
// ---------------------------------------------------------------- AC-2(Pending Phase 2:派发三件套)
@Test
- @Disabled("Pending Phase 2: AC-2 派发三件套——client-task-pull 白名单加 JD_PUBLISH 后移除本注解")
void client_task_pull白名单默认值含JD_PUBLISH_源码绊线() throws IOException {
// 照 JdTaskPullSpiImplTest 同判据:白名单不含模块名时 SPI 装载了也不会被走到。
// 逐行定位 AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES 那一行再断言,比全文 contains 精确。
@@ -88,7 +86,6 @@ class JdPublishContractPendingTest {
}
@Test
- @Disabled("Pending Phase 2: AC-2 LOCAL_DEFAULT_MODULES——JD_PUBLISH 进清单后移除本注解")
void JD_PUBLISH默认通道必须是LOCAL_铁律19同形() {
// 京东发布必须由客户端已登录京麦的 Chrome 执行,Linux worker 永远跑不了:
// 不进 LOCAL_DEFAULT_MODULES 就会默认 ONLINE ⇒ 任务被推给无京麦登录态的机器(铁律 19)。
@@ -98,7 +95,6 @@ class JdPublishContractPendingTest {
}
@Test
- @Disabled("Pending Phase 2: AC-2 SPI 实现——JdPublishTaskPullSpiImpl 落地后移除本注解")
void 派发SPI实现存在且队列类型为jd_product_publish_run() throws IOException {
assertTrue(Files.exists(PUBLISH_SPI), "缺 ClientTaskPullSpi 实现:JdPublishTaskPullSpiImpl(铁律 32 第一件)");
assertTrue(Files.readString(PUBLISH_SPI).contains(PUBLISH_QUEUE_TYPE),
@@ -110,7 +106,6 @@ class JdPublishContractPendingTest {
}
@Test
- @Disabled("Pending Phase 2: AC-2 registry 登记——TaskModuleRegistry 加 JD_PUBLISH 后移除本注解")
void TaskModuleRegistry登记JD_PUBLISH模块_源码绊线() throws IOException {
assertTrue(Files.exists(MODULE_REGISTRY), "TaskModuleRegistry 缺失");
assertTrue(Files.readString(MODULE_REGISTRY).contains(PUBLISH_MODULE),
@@ -120,11 +115,12 @@ class JdPublishContractPendingTest {
// ---------------------------------------------------------------- AC-1(Pending Phase 2:建单端点)
@Test
- @Disabled("Pending Phase 2: AC-1 建单端点——JdPublishController 落地后移除本注解")
void 建单端点形状与归属校验_源码绊线() throws IOException {
assertTrue(Files.exists(PUBLISH_CONTROLLER), "缺 JdPublishController(蓝图 §3:POST /api/jd-publish/tasks)");
String source = Files.readString(PUBLISH_CONTROLLER);
- assertTrue(source.contains("jd-publish/tasks"), "缺建单端点路径 /api/jd-publish/tasks");
+ // 类级 @RequestMapping 与方法级 @PostMapping 分开写,拼接串搜不到(照 AC-9 格同一口径)。
+ assertTrue(source.contains("/api/jd-publish"), "缺类级 @RequestMapping /api/jd-publish");
+ assertTrue(source.contains("@PostMapping(\"/tasks\")"), "缺建单端点 POST /tasks");
assertTrue(source.contains("@PostMapping"), "建单必须是 POST 端点");
// AC-9 归属半边:选了他人商品要业务码拒绝(照 JdCollectController 的 fail-closed 鉴权形状)
assertTrue(source.contains("requireOwnershipUserId"),
@@ -132,7 +128,6 @@ class JdPublishContractPendingTest {
}
@Test
- @Disabled("Pending Phase 2: AC-1 发布明细表——V208+ 迁移落地后移除本注解")
void 发布明细表迁移存在且表名为biz_jd_publish_item() throws IOException {
// 蓝图 §3:V207 已被 users_jd_publish_quota 占用(5c7a310e),发布明细表从 V208 起号。
// 号段断言放宽到 V208~V229:开工时仍须按 MigrationInventoryTest 复核当窗可用号(铁律 33)。
@@ -147,7 +142,6 @@ class JdPublishContractPendingTest {
// ---------------------------------------------------------------- AC-8(Pending Phase 2:配额闸)
@Test
- @Disabled("Pending Phase 2: AC-8 配额闸——建单入口接 assertWithinQuota 后移除本注解")
void 建单入口必须接JdPublishQuotaService配额闸_源码绊线() throws IOException {
assertTrue(Files.exists(PUBLISH_SERVICE), "缺 JdPublishTaskService");
String source = Files.readString(PUBLISH_SERVICE);
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdSchemaContractTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdSchemaContractTest.java
index bdfed307e..98b86d30d 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdSchemaContractTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/JdSchemaContractTest.java
@@ -135,6 +135,27 @@ class JdSchemaContractTest {
assertTrue(sql.contains("flyway_schema_history WHERE version='209'"), "缺回滚注释");
}
+ @Test
+ void V210_发布明细表_任务内商品唯一键与行级状态形状() {
+ String sql = read(DB_DIR.resolve("V210__jd_publish_item.sql"));
+ assertTrue(sql.contains("biz_jd_publish_item"), "缺发布明细表");
+ for (String column : List.of("task_id", "user_id", "product_id", "product_code", "shop_name",
+ "title", "category_path", "price_rule_json", "stock_json", "publish_status",
+ "publish_error", "jd_ware_id", "main_image_object_key", "created_at", "updated_at")) {
+ assertFalse(linesContaining(sql, "`" + column + "`").isEmpty(), "V210 缺列: " + column);
+ }
+ // 每任务每商品一行:重试/重复勾选不落两行(断点续跑的行级锚点)。
+ assertTrue(sql.contains("uk_task_product"), "任务内商品唯一键缺失");
+ assertTrue(linesContaining(sql, "uk_task_product").stream()
+ .anyMatch(line -> line.contains("task_id") && line.contains("product_id")),
+ "唯一键必须是 (task_id, product_id)");
+ // 行级状态机词表(chunk 回传推进的唯一真源)。
+ assertTrue(linesContaining(sql, "`publish_status`").stream()
+ .anyMatch(line -> line.contains("NOT NULL") && line.contains("DEFAULT 'PENDING'")),
+ "publish_status 必须 NOT NULL DEFAULT 'PENDING'(建单即落行,行状态由回传推进)");
+ assertTrue(sql.contains("迁移 V210"), "头注释必须是 `-- 迁移 V210…`(MigrationInventoryTest 口径)");
+ }
+
@Test
void 配置_独立图片桶不落默认桶() {
String appYml = read(RESOURCES.resolve("application.yml"));
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/jd/service/JdPublishIngestServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/service/JdPublishIngestServiceTest.java
new file mode 100644
index 000000000..12e647231
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/service/JdPublishIngestServiceTest.java
@@ -0,0 +1,266 @@
+package com.nanri.aiimage.modules.jd.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.nanri.aiimage.common.exception.BusinessException;
+import com.nanri.aiimage.modules.jd.mapper.JdPublishItemMapper;
+import com.nanri.aiimage.modules.jd.model.dto.JdPublishChunkRequest;
+import com.nanri.aiimage.modules.jd.model.dto.JdPublishChunkRequest.ItemResult;
+import com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity;
+import com.nanri.aiimage.modules.jd.model.vo.JdPublishChunkVo;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * v1.5 Phase 2 行级回传测试:R6 单行失败隔离/终态汇总、铁律 31 判死分档(京麦登录态致命、
+ * 匿名拒判死、非致命只记录)、PENDING/终态任务拒收回传。
+ */
+@ExtendWith(MockitoExtension.class)
+class JdPublishIngestServiceTest {
+
+ @Mock
+ private FileTaskMapper fileTaskMapper;
+ @Mock
+ private JdPublishItemMapper jdPublishItemMapper;
+ @Mock
+ private JdPublishStaleTaskService staleTaskService;
+ @Mock
+ private TaskProgressSnapshotService taskProgressSnapshotService;
+
+ @InjectMocks
+ private JdPublishIngestService service;
+
+ /** Mockito 纯单测无 Spring 环境:LambdaUpdateWrapper 解析 SFunction 需要 TableInfo 缓存(先例 ProgressQueryOwnershipOutletTest)。 */
+ @BeforeAll
+ static void initMybatisPlusTableInfo() {
+ MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+ TableInfoHelper.initTableInfo(assistant, FileTaskEntity.class);
+ TableInfoHelper.initTableInfo(assistant, JdPublishItemEntity.class);
+ }
+
+ private FileTaskEntity runningTask(long taskId) {
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(taskId);
+ task.setModuleType("JD_PUBLISH");
+ task.setStatus("RUNNING");
+ return task;
+ }
+
+ private ItemResult row(long productId, String status, String error, String wareId) {
+ ItemResult item = new ItemResult();
+ item.setProductId(productId);
+ item.setPublishStatus(status);
+ item.setPublishError(error);
+ item.setJdWareId(wareId);
+ return item;
+ }
+
+ private void stubCounts(long success, long failed, long pending, long publishing) {
+ when(jdPublishItemMapper.countByPublishStatus(34400L)).thenReturn(List.of(
+ Map.of("publishStatus", "SUCCESS", "cnt", success),
+ Map.of("publishStatus", "FAILED", "cnt", failed),
+ Map.of("publishStatus", "PENDING", "cnt", pending),
+ Map.of("publishStatus", "PUBLISHING", "cnt", publishing)));
+ }
+
+ @Test
+ void 行级回传SUCCESS落库并带wareId() {
+ when(fileTaskMapper.selectById(34400L)).thenReturn(runningTask(34400L));
+ stubCounts(0, 0, 1, 0);
+ when(jdPublishItemMapper.update(any(), any(LambdaUpdateWrapper.class))).thenReturn(1);
+
+ JdPublishChunkRequest request = new JdPublishChunkRequest();
+ request.setBatchId("PUB-0001");
+ request.setItems(List.of(row(101L, "SUCCESS", null, "10036498117800")));
+
+ JdPublishChunkVo vo = service.submitChunk(34400L, request, true);
+
+ assertThat(vo.getAcceptedCount()).isEqualTo(1);
+ ArgumentCaptor captor = ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
+ verify(jdPublishItemMapper).update(any(), captor.capture());
+ String sqlSet = captor.getValue().getSqlSet();
+ assertThat(sqlSet).as("行级状态与 wareId 两列一起落库")
+ .contains("publish_status").contains("jd_ware_id");
+ assertThat(captor.getValue().getParamNameValuePairs().values())
+ .extracting(String::valueOf)
+ .as("行级值:状态 + wareId").contains("SUCCESS", "10036498117800");
+ assertThat(vo.getTaskStatus()).as("未带 isEnd 不落终态").isNull();
+ }
+
+ @Test
+ void 行级FAILED带真实原因落库() {
+ when(fileTaskMapper.selectById(34400L)).thenReturn(runningTask(34400L));
+ stubCounts(0, 0, 1, 0);
+ when(jdPublishItemMapper.update(any(), any(LambdaUpdateWrapper.class))).thenReturn(1);
+
+ JdPublishChunkRequest request = new JdPublishChunkRequest();
+ request.setItems(List.of(row(101L, "FAILED", "类目不在授权树内", null)));
+
+ JdPublishChunkVo vo = service.submitChunk(34400L, request, true);
+
+ assertThat(vo.getAcceptedCount()).isEqualTo(1);
+ ArgumentCaptor captor = ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
+ verify(jdPublishItemMapper).update(any(), captor.capture());
+ assertThat(captor.getValue().getParamNameValuePairs().values())
+ .extracting(String::valueOf)
+ .as("R6:失败行落真实原因,不伪造成功").contains("FAILED", "类目不在授权树内");
+ }
+
+ @Test
+ void 不识别的行状态跳过不炸批() {
+ when(fileTaskMapper.selectById(34400L)).thenReturn(runningTask(34400L));
+ stubCounts(0, 0, 2, 0);
+ when(jdPublishItemMapper.update(any(), any(LambdaUpdateWrapper.class))).thenReturn(1);
+
+ JdPublishChunkRequest request = new JdPublishChunkRequest();
+ request.setItems(List.of(row(101L, "PENDING", null, null), row(102L, "SUCCESS", null, "w1")));
+
+ JdPublishChunkVo vo = service.submitChunk(34400L, request, true);
+
+ assertThat(vo.getAcceptedCount()).as("PENDING 不可回传写回,只有 SUCCESS 行被接受").isEqualTo(1);
+ }
+
+ @Test
+ void isEnd全成功任务落SUCCESS() {
+ when(fileTaskMapper.selectById(34400L)).thenReturn(runningTask(34400L));
+ stubCounts(3, 0, 0, 0);
+ when(jdPublishItemMapper.update(any(), any(LambdaUpdateWrapper.class))).thenReturn(1);
+ when(fileTaskMapper.update(any(), any(LambdaUpdateWrapper.class))).thenReturn(1);
+
+ JdPublishChunkRequest request = new JdPublishChunkRequest();
+ request.setIsEnd(true);
+ request.setItems(List.of(row(103L, "SUCCESS", null, "w3")));
+
+ JdPublishChunkVo vo = service.submitChunk(34400L, request, true);
+
+ assertThat(vo.getTaskStatus()).isEqualTo("SUCCESS");
+ ArgumentCaptor captor = ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
+ verify(fileTaskMapper).update(any(), captor.capture());
+ String sqlSet = captor.getValue().getSqlSet();
+ assertThat(sqlSet).as("任务终态列:状态 + 真实行数两列")
+ .contains("status").contains("success_file_count");
+ assertThat(captor.getValue().getParamNameValuePairs().values())
+ .extracting(String::valueOf)
+ .as("AC-6:任务终态汇总真实行数").contains("SUCCESS");
+ verify(taskProgressSnapshotService).markTerminal(eq(34400L), eq("JD_PUBLISH"), eq("SUCCESS"), any());
+ }
+
+ @Test
+ void isEnd有失败行任务落FAILED并汇总() {
+ when(fileTaskMapper.selectById(34400L)).thenReturn(runningTask(34400L));
+ stubCounts(2, 1, 0, 0);
+ when(fileTaskMapper.update(any(), any(LambdaUpdateWrapper.class))).thenReturn(1);
+
+ JdPublishChunkRequest request = new JdPublishChunkRequest();
+ request.setIsEnd(true);
+ request.setItems(List.of());
+
+ JdPublishChunkVo vo = service.submitChunk(34400L, request, true);
+
+ assertThat(vo.getTaskStatus()).isEqualTo("FAILED");
+ ArgumentCaptor captor = ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
+ verify(fileTaskMapper).update(any(), captor.capture());
+ assertThat(captor.getValue().getParamNameValuePairs().values())
+ .extracting(String::valueOf)
+ .as("R6:任务终态汇总成败数(文案带真实行数)")
+ .contains("FAILED", "发布完成:成功 2 行,失败 1 行");
+ }
+
+ @Test
+ void PENDING任务拒收回传点名激活() {
+ FileTaskEntity task = runningTask(34400L);
+ task.setStatus("PENDING");
+ when(fileTaskMapper.selectById(34400L)).thenReturn(task);
+ assertThatThrownBy(() -> service.submitChunk(34400L, new JdPublishChunkRequest(), true))
+ .isInstanceOf(BusinessException.class)
+ .hasMessageContaining("任务不在运行中");
+ verify(jdPublishItemMapper, never()).update(any(), any(LambdaUpdateWrapper.class));
+ }
+
+ @Test
+ void 终态任务拒收回传() {
+ FileTaskEntity task = runningTask(34400L);
+ task.setStatus("SUCCESS");
+ when(fileTaskMapper.selectById(34400L)).thenReturn(task);
+ assertThatThrownBy(() -> service.submitChunk(34400L, new JdPublishChunkRequest(), true))
+ .isInstanceOf(BusinessException.class)
+ .hasMessageContaining("任务已结束");
+ }
+
+ @Test
+ void 京麦登录态致命可信上报判死() {
+ when(fileTaskMapper.selectById(34400L)).thenReturn(runningTask(34400L));
+ stubCounts(0, 0, 1, 0);
+ when(staleTaskService.terminalizeOnJdLoginFatal(any(), anyString())).thenReturn(true);
+
+ JdPublishChunkRequest request = new JdPublishChunkRequest();
+ request.setError("发布页跳回登录页,京麦未登录");
+
+ JdPublishChunkVo vo = service.submitChunk(34400L, request, true);
+
+ assertThat(vo.getTaskStatus()).as("铁律 31:凭据不可自愈 ⇒ 整单 FAILED").isEqualTo("FAILED");
+ verify(staleTaskService).terminalizeOnJdLoginFatal(any(), eq("发布页跳回登录页,京麦未登录"));
+ verify(jdPublishItemMapper, never()).update(any(), any(LambdaUpdateWrapper.class));
+ }
+
+ @Test
+ void 匿名error上报拒绝判死() {
+ when(fileTaskMapper.selectById(34400L)).thenReturn(runningTask(34400L));
+ stubCounts(0, 0, 1, 0);
+
+ JdPublishChunkRequest request = new JdPublishChunkRequest();
+ request.setError("京麦未登录");
+
+ JdPublishChunkVo vo = service.submitChunk(34400L, request, false);
+
+ assertThat(vo.getTaskStatus()).as("判死口凭据化:匿名一律拒绝判死").isNull();
+ verify(staleTaskService, never()).terminalizeOnJdLoginFatal(any(), anyString());
+ verify(fileTaskMapper, never()).update(any(), any(LambdaUpdateWrapper.class));
+ }
+
+ @Test
+ void 非致命技术故障只记录不判死() {
+ when(fileTaskMapper.selectById(34400L)).thenReturn(runningTask(34400L));
+ stubCounts(0, 0, 1, 0);
+
+ JdPublishChunkRequest request = new JdPublishChunkRequest();
+ request.setError("页面结构变更,发布按钮定位失败");
+
+ JdPublishChunkVo vo = service.submitChunk(34400L, request, true);
+
+ assertThat(vo.getTaskStatus()).as("技术性故障只补测不判死(R5 分档)").isNull();
+ verify(staleTaskService, never()).terminalizeOnJdLoginFatal(any(), anyString());
+ verify(fileTaskMapper, never()).update(any(), any(LambdaUpdateWrapper.class));
+ }
+
+ @Test
+ void 任务不存在拒收回传() {
+ when(fileTaskMapper.selectById(99999L)).thenReturn(null);
+ assertThatThrownBy(() -> service.submitChunk(99999L, new JdPublishChunkRequest(), true))
+ .isInstanceOf(BusinessException.class)
+ .hasMessageContaining("任务不存在");
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/jd/service/JdPublishStaleTaskServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/service/JdPublishStaleTaskServiceTest.java
new file mode 100644
index 000000000..6052a1d96
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/service/JdPublishStaleTaskServiceTest.java
@@ -0,0 +1,106 @@
+package com.nanri.aiimage.modules.jd.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.nanri.aiimage.common.service.DistributedJobLockService;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import com.nanri.aiimage.modules.task.service.StaleTaskHeartbeatPolicy;
+import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
+import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * v1.5 Phase 2 判死测试:铁律 31 CAS 语义(RUNNING→FAILED、已终态可重入不改写)、
+ * AC-5 终态文案点名「京麦未登录」「登录态失效」并给动作句(不写「稍后重试」)。
+ */
+@ExtendWith(MockitoExtension.class)
+class JdPublishStaleTaskServiceTest {
+
+ @Mock
+ private FileTaskMapper fileTaskMapper;
+ @Mock
+ private TaskDistributedLockService taskDistributedLockService;
+ @Mock
+ private DistributedJobLockService distributedJobLockService;
+ @Mock
+ private StaleTaskHeartbeatPolicy staleTaskHeartbeatPolicy;
+ @Mock
+ private TaskProgressSnapshotService taskProgressSnapshotService;
+
+ @InjectMocks
+ private JdPublishStaleTaskService service;
+
+ /** Mockito 纯单测无 Spring 环境:LambdaUpdateWrapper 解析 SFunction 需要 TableInfo 缓存(先例 ProgressQueryOwnershipOutletTest)。 */
+ @BeforeAll
+ static void initMybatisPlusTableInfo() {
+ TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
+ FileTaskEntity.class);
+ }
+
+ private FileTaskEntity task(long id) {
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(id);
+ task.setModuleType("JD_PUBLISH");
+ task.setStatus("RUNNING");
+ return task;
+ }
+
+ @Test
+ void 登录态失效判死CAS成功() {
+ FileTaskEntity task = task(34400L);
+ when(fileTaskMapper.update(any(), any(LambdaUpdateWrapper.class))).thenReturn(1);
+
+ boolean terminalized = service.terminalizeOnJdLoginFatal(task, "发布页跳回登录页");
+
+ assertThat(terminalized).isTrue();
+ ArgumentCaptor captor = ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
+ verify(fileTaskMapper).update(any(), captor.capture());
+ // paramNameValuePairs 的值里有整句文案;子串断言拼成一串再判(元素级 contains 是全等)。
+ String joined = java.util.Arrays.toString(captor.getValue().getParamNameValuePairs().values().toArray());
+ assertThat(joined)
+ .as("AC-5 文案:生产者原文+两判据词+动作句")
+ .contains("发布页跳回登录页")
+ .contains("京麦未登录")
+ .contains("登录态失效")
+ .contains("重新登录京麦")
+ .as("铁律 31:不得说「稍后重试」").doesNotContain("稍后重试");
+ verify(taskProgressSnapshotService).markTerminal(eq(34400L), eq("JD_PUBLISH"), eq("FAILED"), any());
+ }
+
+ @Test
+ void 已终态任务CAS不命中可重入() {
+ FileTaskEntity task = task(34401L);
+ when(fileTaskMapper.update(any(), any(LambdaUpdateWrapper.class))).thenReturn(0);
+
+ boolean terminalized = service.terminalizeOnJdLoginFatal(task, "京麦未登录");
+
+ assertThat(terminalized).as("铁律 14:已终态不改写,可重入").isFalse();
+ verify(taskProgressSnapshotService, org.mockito.Mockito.never())
+ .markTerminal(any(), any(), any(), any());
+ }
+
+ @Test
+ void 文案判据词复用采集面同一族词表() {
+ // 判词表单一出处=JdStaleTaskService.isJdLoginStateFailure(京东域两链共用 19899 profile),
+ // 发布侧只消费不另抄一份词表(两份词表各改各的就是分叉判据)。
+ assertThat(JdStaleTaskService.isJdLoginStateFailure("发布页要求登录,京麦未登录")).isTrue();
+ assertThat(JdStaleTaskService.isJdLoginStateFailure("登录态失效")).isTrue();
+ assertThat(JdStaleTaskService.isJdLoginStateFailure("页面结构变更")).isFalse();
+ assertThat(JdStaleTaskService.isJdLoginStateFailure(" ")).isFalse();
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/jd/service/JdPublishTaskServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/service/JdPublishTaskServiceTest.java
new file mode 100644
index 000000000..690151545
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/jd/service/JdPublishTaskServiceTest.java
@@ -0,0 +1,345 @@
+package com.nanri.aiimage.modules.jd.service;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.nanri.aiimage.common.exception.BusinessException;
+import com.nanri.aiimage.common.mapper.AdminUserMapper;
+import com.nanri.aiimage.common.model.entity.AdminUserEntity;
+import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
+import com.nanri.aiimage.modules.jd.mapper.JdProductImageMapper;
+import com.nanri.aiimage.modules.jd.mapper.JdProductMapper;
+import com.nanri.aiimage.modules.jd.mapper.JdProductSkuMapper;
+import com.nanri.aiimage.modules.jd.mapper.JdPublishItemMapper;
+import com.nanri.aiimage.modules.jd.model.dto.JdPublishTaskCreateRequest;
+import com.nanri.aiimage.modules.jd.model.dto.JdPublishTaskCreateRequest.PriceRule;
+import com.nanri.aiimage.modules.jd.model.entity.JdProductEntity;
+import com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity;
+import com.nanri.aiimage.modules.jd.model.vo.JdPublishTaskVo;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
+import com.nanri.aiimage.modules.task.service.TaskHeartbeatService;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * v1.5 Phase 2 建单行为测试:AC-1 建单快照/LOCAL 显式写、AC-8 配额闸前置、AC-9 归属
+ * fail-closed、铁律 27a 改价规则同源、铁律 32 载荷 type 同值判据。
+ */
+@ExtendWith(MockitoExtension.class)
+class JdPublishTaskServiceTest {
+
+ @Mock
+ private FileTaskMapper fileTaskMapper;
+ @Mock
+ private JdProductMapper jdProductMapper;
+ @Mock
+ private JdProductImageMapper jdProductImageMapper;
+ @Mock
+ private JdProductSkuMapper jdProductSkuMapper;
+ @Mock
+ private JdPublishItemMapper jdPublishItemMapper;
+ @Mock
+ private JdPublishQuotaService jdPublishQuotaService;
+ @Mock
+ private AdminUserMapper adminUserMapper;
+ @Mock
+ private OssStorageService ossStorageService;
+ @Spy
+ private ObjectMapper objectMapper = new ObjectMapper();
+ @Mock
+ private TaskHeartbeatService taskHeartbeatService;
+ @Mock
+ private TaskHeartbeatPositionService taskHeartbeatPositionService;
+
+ @InjectMocks
+ private JdPublishTaskService service;
+
+ private JdProductEntity product(long id, long userId, String title) {
+ JdProductEntity product = new JdProductEntity();
+ product.setId(id);
+ product.setUserId(userId);
+ product.setCompanyId(2L);
+ product.setShopName("测试旗舰店");
+ product.setProductCode("JD" + id);
+ product.setTitle(title);
+ product.setCategoryPath("女装 > 连衣裙");
+ product.setPriceMin(new BigDecimal("100.00"));
+ product.setStockTotal(50);
+ return product;
+ }
+
+ private JdPublishTaskCreateRequest validRequest(long userId) {
+ JdPublishTaskCreateRequest request = new JdPublishTaskCreateRequest();
+ request.setUserId(userId);
+ request.setCategoryId(11L);
+ request.setProductIds(List.of(101L, 102L));
+ return request;
+ }
+
+ @Test
+ void 建单成功且通道显式写LOCAL并落快照行() {
+ when(adminUserMapper.selectById(7L)).thenReturn(new AdminUserEntity());
+ when(jdProductMapper.selectBatchIds(List.of(101L, 102L)))
+ .thenReturn(List.of(product(101L, 7L, "连衣裙A"), product(102L, 7L, "连衣裙B")));
+ when(fileTaskMapper.insert(any(FileTaskEntity.class))).thenAnswer(invocation -> {
+ invocation.getArgument(0, FileTaskEntity.class).setId(34400L);
+ return 1;
+ });
+ when(jdPublishItemMapper.insert(any(JdPublishItemEntity.class))).thenReturn(1);
+
+ JdPublishTaskVo vo = service.createTask(validRequest(7L), "device-abc");
+
+ assertThat(vo.getTaskId()).isEqualTo(34400L);
+ assertThat(vo.getTaskNo()).startsWith("JD_PUBLISH-");
+ assertThat(vo.getCollectChannel()).as("铁律 19:建单入口显式写通道,不依赖 defaultFor 兜底")
+ .isEqualTo("LOCAL");
+ ArgumentCaptor taskCaptor = ArgumentCaptor.forClass(FileTaskEntity.class);
+ verify(fileTaskMapper).insert(taskCaptor.capture());
+ FileTaskEntity task = taskCaptor.getValue();
+ assertThat(task.getModuleType()).isEqualTo("JD_PUBLISH");
+ assertThat(task.getStatus()).isEqualTo("PENDING");
+ assertThat(task.getUserId()).isEqualTo(7L);
+ assertThat(task.getSourceFileCount()).isEqualTo(2);
+ assertThat(task.getRequestJson()).contains("101").contains("102");
+ // AC-1 明细快照行:每勾选商品一行
+ verify(jdPublishItemMapper, org.mockito.Mockito.times(2)).insert(any(JdPublishItemEntity.class));
+ // AC-8 配额闸:前置且按勾选数计
+ verify(jdPublishQuotaService).assertWithinQuota(any(AdminUserEntity.class), eq(2));
+ // 铁律 32 第三件:建单响应带页面推送载荷,type 与 SPI QUEUE_TYPE 同值
+ assertThat(vo.getQueuePayload())
+ .containsEntry("type", "jd-product-publish-run");
+ assertThat(String.valueOf(vo.getQueuePayload().get("data")))
+ .as("data 段带 taskId(派发载荷键集)").contains("taskId").contains("34400");
+ }
+
+ @Test
+ void 快照行带改价折算与库存() {
+ when(adminUserMapper.selectById(7L)).thenReturn(new AdminUserEntity());
+ when(jdProductMapper.selectBatchIds(List.of(101L))).thenReturn(List.of(product(101L, 7L, "连衣裙A")));
+ when(fileTaskMapper.insert(any(FileTaskEntity.class))).thenAnswer(invocation -> {
+ invocation.getArgument(0, FileTaskEntity.class).setId(34401L);
+ return 1;
+ });
+ when(jdPublishItemMapper.insert(any(JdPublishItemEntity.class))).thenReturn(1);
+
+ JdPublishTaskCreateRequest request = validRequest(7L);
+ request.setProductIds(List.of(101L));
+ PriceRule rule = new PriceRule();
+ rule.setMode("percent");
+ rule.setValue(new BigDecimal("10"));
+ request.setPriceRule(rule);
+ service.createTask(request, null);
+
+ ArgumentCaptor itemCaptor = ArgumentCaptor.forClass(JdPublishItemEntity.class);
+ verify(jdPublishItemMapper).insert(itemCaptor.capture());
+ JdPublishItemEntity item = itemCaptor.getValue();
+ assertThat(item.getPriceRuleJson()).as("铁律 27a:闸门认可的改价规则随快照固化").contains("percent");
+ assertThat(item.getPriceRuleJson()).contains("110.00");
+ assertThat(item.getStockJson()).contains("50");
+ assertThat(item.getTitle()).isEqualTo("连衣裙A");
+ assertThat(item.getPublishStatus()).isEqualTo("PENDING");
+ }
+
+ @Test
+ void 未选商品建单被拒并点名() {
+ JdPublishTaskCreateRequest request = validRequest(7L);
+ request.setProductIds(List.of());
+ assertThatThrownBy(() -> service.createTask(request, null))
+ .isInstanceOf(BusinessException.class)
+ .hasMessageContaining("请勾选要上架的商品");
+ verify(jdPublishQuotaService, never()).assertWithinQuota(any(), anyInt());
+ verify(fileTaskMapper, never()).insert(any(FileTaskEntity.class));
+ }
+
+ @Test
+ void 超过商品上限建单被拒并点名() {
+ JdPublishTaskCreateRequest request = validRequest(7L);
+ request.setProductIds(java.util.stream.LongStream.rangeClosed(1, 501)
+ .boxed().toList());
+ assertThatThrownBy(() -> service.createTask(request, null))
+ .isInstanceOf(BusinessException.class)
+ .hasMessageContaining("单次上架最多选 500 个");
+ verify(fileTaskMapper, never()).insert(any(FileTaskEntity.class));
+ }
+
+ @Test
+ void 选了他人商品建单被拒并点名() {
+ when(adminUserMapper.selectById(7L)).thenReturn(new AdminUserEntity());
+ when(jdProductMapper.selectBatchIds(List.of(101L)))
+ .thenReturn(List.of(product(101L, 8L, "别人的连衣裙")));
+ JdPublishTaskCreateRequest request = validRequest(7L);
+ request.setProductIds(List.of(101L));
+ assertThatThrownBy(() -> service.createTask(request, null))
+ .isInstanceOf(BusinessException.class)
+ .as("AC-9 归属半边:选他人商品业务码拒绝")
+ .extracting("code")
+ .isEqualTo(403);
+ verify(fileTaskMapper, never()).insert(any(FileTaskEntity.class));
+ verify(jdPublishItemMapper, never()).insert(any(JdPublishItemEntity.class));
+ }
+
+ @Test
+ void 商品缺行建单被拒() {
+ when(adminUserMapper.selectById(7L)).thenReturn(new AdminUserEntity());
+ when(jdProductMapper.selectBatchIds(List.of(101L, 102L))).thenReturn(List.of(product(101L, 7L, "连衣裙A")));
+ assertThatThrownBy(() -> service.createTask(validRequest(7L), null))
+ .isInstanceOf(BusinessException.class)
+ .hasMessageContaining("部分商品不存在");
+ verify(fileTaskMapper, never()).insert(any(FileTaskEntity.class));
+ }
+
+ @Test
+ void 超配额建单被拒且不落任何行() {
+ when(adminUserMapper.selectById(7L)).thenReturn(new AdminUserEntity());
+ org.mockito.Mockito.doThrow(new BusinessException("商品上架数量已达上限:该管理员及其名下员工当前已占用 "
+ + "5000/上限 5000,请清理京东数据库商品或联系管理员调整配额后重试"))
+ .when(jdPublishQuotaService).assertWithinQuota(any(), eq(2));
+ assertThatThrownBy(() -> service.createTask(validRequest(7L), null))
+ .isInstanceOf(BusinessException.class)
+ .hasMessageContaining("商品上架数量已达上限");
+ verify(fileTaskMapper, never()).insert(any(FileTaskEntity.class));
+ verify(jdPublishItemMapper, never()).insert(any(JdPublishItemEntity.class));
+ }
+
+ @Test
+ void 改价规则不识别建单被拒() {
+ JdPublishTaskCreateRequest request = validRequest(7L);
+ PriceRule rule = new PriceRule();
+ rule.setMode("double");
+ rule.setValue(BigDecimal.TEN);
+ request.setPriceRule(rule);
+ assertThatThrownBy(() -> service.createTask(request, null))
+ .isInstanceOf(BusinessException.class)
+ .hasMessageContaining("none/percent/fixed");
+ }
+
+ @Test
+ void 改价规则缺加价值建单被拒() {
+ JdPublishTaskCreateRequest request = validRequest(7L);
+ PriceRule rule = new PriceRule();
+ rule.setMode("fixed");
+ request.setPriceRule(rule);
+ assertThatThrownBy(() -> service.createTask(request, null))
+ .isInstanceOf(BusinessException.class)
+ .hasMessageContaining("必须填写加价值");
+ }
+
+ @Test
+ void 统一改价折算口径() {
+ PriceRule percent = new PriceRule();
+ percent.setMode("percent");
+ percent.setValue(new BigDecimal("10"));
+ assertThat(JdPublishTaskService.finalPriceOf(new BigDecimal("100"), percent))
+ .isEqualByComparingTo("110.00");
+ PriceRule fixed = new PriceRule();
+ fixed.setMode("fixed");
+ fixed.setValue(new BigDecimal("5.5"));
+ assertThat(JdPublishTaskService.finalPriceOf(new BigDecimal("100"), fixed))
+ .isEqualByComparingTo("105.50");
+ assertThat(JdPublishTaskService.finalPriceOf(new BigDecimal("100"), null))
+ .isEqualByComparingTo("100.00");
+ assertThat(JdPublishTaskService.finalPriceOf(null, percent)).isNull();
+ }
+
+ @Test
+ void 明细分批下发只出PENDING行并发预签名URL() {
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(34400L);
+ task.setModuleType("JD_PUBLISH");
+ task.setUserId(7L);
+ task.setStatus("RUNNING");
+ when(fileTaskMapper.selectById(34400L)).thenReturn(task);
+
+ JdPublishItemEntity row = new JdPublishItemEntity();
+ row.setId(1L);
+ row.setTaskId(34400L);
+ row.setProductId(101L);
+ row.setTitle("连衣裙A");
+ row.setCategoryPath("女装 > 连衣裙");
+ row.setPriceRuleJson("{\"mode\":\"percent\",\"value\":10,\"sourcePrice\":100.00,\"finalPrice\":110.00}");
+ row.setStockJson("{\"total\":50}");
+ row.setPublishStatus("PENDING");
+ when(jdPublishItemMapper.selectPublishableItems(34400L, 0L, 20)).thenReturn(List.of(row));
+ when(jdPublishItemMapper.countByPublishStatus(34400L)).thenReturn(List.of());
+ JdProductEntity product = product(101L, 7L, "连衣裙A");
+ product.setAttrJson("{\"key\":\"color\"}");
+ when(jdProductMapper.selectBatchIds(List.of(101L))).thenReturn(List.of(product));
+ when(jdProductSkuMapper.selectList(any())).thenReturn(List.of());
+ when(jdProductImageMapper.selectList(any())).thenReturn(List.of());
+
+ var vo = service.pullItems(34400L, 7L, 0L, null);
+
+ assertThat(vo.getTaskId()).isEqualTo(34400L);
+ assertThat(vo.getItems()).hasSize(1);
+ assertThat(vo.getItems().get(0).getFinalPrice()).isEqualByComparingTo("110.00");
+ assertThat(vo.getItems().get(0).getAttrs()).contains("color");
+ assertThat(vo.isHasMore()).as("默认批大小 20 > 本页 1 行").isFalse();
+ assertThat(vo.getPendingCount()).isZero();
+ }
+
+ @Test
+ void 下发归属校验他人任务403() {
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(34400L);
+ task.setModuleType("JD_PUBLISH");
+ task.setUserId(8L);
+ task.setStatus("RUNNING");
+ when(fileTaskMapper.selectById(34400L)).thenReturn(task);
+ assertThatThrownBy(() -> service.pullItems(34400L, 7L, 0L, null))
+ .isInstanceOf(BusinessException.class)
+ .extracting("code")
+ .isEqualTo(403);
+ }
+
+ @Test
+ void 心跳归属校验不通过不放行全局通道() {
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(34400L);
+ task.setModuleType("JD_PUBLISH");
+ task.setUserId(8L);
+ when(fileTaskMapper.selectById(34400L)).thenReturn(task);
+ assertThatThrownBy(() -> service.heartbeat(34400L, 7L, null))
+ .as("B98-07 同形债预防:任意用户不可给任意任务刷心跳")
+ .isInstanceOf(BusinessException.class)
+ .extracting("code")
+ .isEqualTo(403);
+ verify(taskHeartbeatService, never()).heartbeat(anyLong(), any());
+ }
+
+ @Test
+ void 心跳归属校验通过走全局通道() {
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(34400L);
+ task.setModuleType("JD_PUBLISH");
+ task.setUserId(7L);
+ when(fileTaskMapper.selectById(34400L)).thenReturn(task);
+ com.nanri.aiimage.modules.task.model.vo.TaskHeartbeatVo heartbeatVo =
+ new com.nanri.aiimage.modules.task.model.vo.TaskHeartbeatVo();
+ heartbeatVo.setAlive(true);
+ when(taskHeartbeatService.heartbeat(eq(34400L), any())).thenReturn(heartbeatVo);
+
+ var vo = service.heartbeat(34400L, 7L, null);
+
+ assertThat(vo.isAlive()).isTrue();
+ verify(taskHeartbeatPositionService).record(eq(34400L), any());
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/model/CollectChannelTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/model/CollectChannelTest.java
index c161f62d2..7fee2b5e7 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/model/CollectChannelTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/model/CollectChannelTest.java
@@ -39,9 +39,11 @@ class CollectChannelTest {
*/
@Test
void 本机默认模块清单与defaultFor同源() {
+ // v1.5 起含 JD_PUBLISH(京麦登录态只在用户桌面机 19899 Chrome,铁律 19 同形)。
assertEquals(List.of(CollectRoutingProperties.MODULE_APPEARANCE_PATENT,
CollectRoutingProperties.MODULE_SIMILAR_ASIN,
- CollectRoutingProperties.MODULE_JD_SHOP_COLLECT), CollectChannel.localDefaultModuleTypes());
+ CollectRoutingProperties.MODULE_JD_SHOP_COLLECT,
+ CollectRoutingProperties.MODULE_JD_PUBLISH), CollectChannel.localDefaultModuleTypes());
for (String module : CollectChannel.localDefaultModuleTypes()) {
assertTrue(CollectChannel.defaultFor(module).isLocal(), module + " 在清单里却不被判本机");
}