feat(phase-2): 京东商品上架后端地基(v1.5 蓝图 docs/ITERATION_PLAN.md §4 Phase 2)——V210 发布明细表 biz_jd_publish_item(号段实核:V207~V209 已按序占用)+JdPublishTaskService 建单/配额/归属/生命周期(建单即落快照行,AC-8 配额闸前置、AC-9 他人商品 403、铁律 27a 改价同源、铁律 19 LOCAL 显式写)+items 分批下发(SQL 侧下推只出 PENDING 行=AC-4 断点服务端半边,图片 jd-products 预签名 GET 新开 presignObjectDownload 出口)+JdPublishIngestService chunk 行级回传(isEnd 按行级真源汇总终态,铁律 31 分档判死口凭据化)+JdPublishStaleTaskService 判死(JdStaleTaskService 同形,60 分钟 aiimage.jd.publish.stale-minutes)+派发三件套(SPI jd-product-publish-run+白名单 JD_PUBLISH+建单响应 queuePayload,铁律 32)+JdPublishTaskHeartbeatSpi override ensureOwnership(B98-07 同形债预防:SPI 轻校验+服务层用户域归属闸,LOCAL 客户端心跳实例域不适用)+registry/EXPECTED_MODULES/清理清单/CollectChannel.LOCAL_DEFAULT_MODULES 四清单同步;激活 JdPublishContractPendingTest 7 支 Pending 契约全绿。判据:点名 12 类 87 例 BUILD SUCCESS(契约 8+建单 14+回传 11+判死 3+schema V210 格+coverage/golden/channel/pull-spi/migration 各格);mvn -o test-compile rc=0;可读棘轮 OssStorageService 1161→1176 行随本笔点名更新(presignObjectDownload +15);LockSkipWitness 分母 30→32、覆盖文件 12→13(JdPublishStaleTaskService 两处留痕,ops 仓同窗更新);快检后端 9.5/用户端 9.6 绿、唯一 fail 红格=后管 readSource 属他窗在飞 align-group-editor 用例 10→13(本笔零后管文件);真机带库整链(V210 实跑)随 Phase 5 发版窗口

This commit is contained in:
2026-11-18 00:31:53 +08:00
parent f4bde32f83
commit 24272a910c
31 changed files with 2435 additions and 26 deletions
@@ -73,7 +73,14 @@ public final class TaskModuleRegistry {
// 照常按天清理(商品行在 biz_jd_product 独立保留,不被清);Phase 2 判死登记定型:
// JdStaleTaskService 自带 @Scheduled(60 分钟超时线,selfScheduledStaleCheck=true,
// 同 publish/collect-data 先例),京麦登录态失效判死由回传侧经它落终态。
new Module("JD_SHOP_COLLECT", "京东店铺采集", false, true, false, true, Optional.empty())
new Module("JD_SHOP_COLLECT", "京东店铺采集", false, true, false, true, Optional.empty()),
// v1.5 京东商品上架(蓝图 docs/ITERATION_PLAN.md §4 Phase 2):resultFileJob=false——
// 不出 Excel 结果文件,行级结果落 biz_jd_publish_item(V210),行状态由客户端 chunk
// 回传推进;ageCleanup=true——任务行照常按天清理(发布明细行独立保留不随清,溯源);
// selfScheduledStaleCheck=true——JdPublishStaleTaskService 自带 @Scheduled(发布逐商品
// 页面自动化节奏慢,60 分钟超时线自管,同 JD_SHOP_COLLECT 先例);submitSecret=empty——
// 发布由桌面机已登录京麦的 Chrome 直连执行,无代理无 LLM(铁律 27c 登记结论)。
new Module("JD_PUBLISH", "京东上架", false, true, false, true, Optional.empty())
);
private TaskModuleRegistry() {
@@ -28,6 +28,9 @@ public class CollectRoutingProperties {
/** 京东店铺采集模块名(v1.4;紫鸟只在本机 Windows,默认通道必须 LOCAL,铁律 19 同形)。 */
public static final String MODULE_JD_SHOP_COLLECT = "JD_SHOP_COLLECT";
/** 京东商品上架模块名(v1.5;京麦登录态在用户桌面机 19899 Chrome profile,默认通道必须 LOCAL,铁律 19 同形)。 */
public static final String MODULE_JD_PUBLISH = "JD_PUBLISH";
/** LOCAL 通道的任务在 PENDING 超过多少分钟后允许 Linux 兜底认领。 */
private long linuxFallbackMinutes = 30L;
@@ -803,6 +803,21 @@ public class OssStorageService {
return buildDownloadPublicUrl(location.objectKey(), location.bucket());
}
/**
* 指定桶对象的下载预签名 GET URL(公开出口):内网写入、公网签名({@link #applyDownloadHost}
* 换 download-endpoint,SigV4 只对服务端收到的 host 验签、签名保持不变)。
*
* <p>调用方(v1.5 京东发布明细下发)持有的是对象 key 与桶名——jd-products 是私有桶,
* {@code generateFreshDownloadUrl} 的公开直链不适用,必须走签名;上传侧对应
* {@link #presignObjectUpload}(presign PUT 直传),读写两向对称。</p>
*/
public String presignObjectDownload(String bucket, String objectKey, int expirySeconds) {
if (bucket == null || bucket.isBlank() || objectKey == null || objectKey.isBlank()) {
throw new IllegalArgumentException("presign download requires bucket and objectKey");
}
return applyDownloadHost(presignDownloadUrl(objectKey, bucket, expirySeconds));
}
private void uploadFile(File file, String bucket, String objectKey) {
if (file == null || !file.isFile()) {
throw new IllegalArgumentException("upload file must exist");
@@ -0,0 +1,137 @@
package com.nanri.aiimage.modules.jd.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.jd.model.dto.JdPublishChunkRequest;
import com.nanri.aiimage.modules.jd.model.dto.JdPublishTaskCreateRequest;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishChunkVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishItemsPageVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishProgressVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishTaskVo;
import com.nanri.aiimage.modules.jd.service.JdPublishIngestService;
import com.nanri.aiimage.modules.jd.service.JdPublishTaskService;
import com.nanri.aiimage.modules.task.model.dto.TaskHeartbeatRequest;
import com.nanri.aiimage.modules.task.model.vo.TaskHeartbeatVo;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
* 京东商品上架任务面(v1.5 Phase 2,蓝图 docs/ITERATION_PLAN.md §3)。
*
* <p>五个入口:建单(用户端登录用户,uid 按会话身份回填;响应体带 queuePayload 供页面
* {@code api.enqueue_json} 推送,DELETE_BRAND 同形)、激活(页面推送前 PENDING→RUNNING)、
* 明细分批下发(客户端按游标拉 PENDING 行)、行级回传(本机执行器直调,判死口凭据化)、
* 心跳(归属校验前置——B98-07 同形债预防:用户域校验在闸门处按可信 uid 对比任务 owner)。
* 全局 {@code /api/tasks/{taskId}/heartbeat} 同时可用,本端点只是给执行器一个模块内聚的 URL。</p>
*/
@RestController
@RequiredArgsConstructor
@Slf4j
@RequestMapping("/api/jd-publish")
@Tag(name = "京东商品上架", description = "京东数据库存量商品 → 京麦店铺发布:建单 → 本机已登录京麦的 Chrome 逐商品发布 → 行级回传落明细。")
public class JdPublishController {
private final JdPublishTaskService publishTaskService;
private final JdPublishIngestService ingestService;
private final AdminAuthSupport adminAuthSupport;
@PostMapping("/tasks")
@Operation(summary = "创建京东商品上架任务", description = "勾选京东数据库商品(归属校验)+可选统一改价规则建单;"
+ "任务落 PENDING、执行通道显式 LOCAL(本机已登录京麦的 Chrome 执行)、明细快照行随建单落库。"
+ "响应体带 queuePayload(type=jd-product-publish-run),页面原样投 api.enqueue_json。")
public ApiResponse<JdPublishTaskVo> createTask(@Valid @RequestBody JdPublishTaskCreateRequest request,
HttpServletRequest httpRequest) {
// uid 不由请求体说了算:解析不出会话身份就 401(fail-closed,与采集建单同口径)。
request.setUserId(adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(publishTaskService.createTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@PostMapping("/tasks/{taskId}/activate")
@Operation(summary = "激活京东上架任务", description = "页面把 jd-product-publish-run 载荷推给本机客户端前调用:"
+ "PENDING→RUNNING 条件更新。漏掉这一步,客户端第一个回传会被「任务不在运行中(PENDING)」拒收"
+ "(2026-11-14 采集链真机实录同形)。")
public ApiResponse<Void> activate(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
publishTaskService.activateTask(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId));
return ApiResponse.success(null);
}
@GetMapping("/tasks/{taskId}/items")
@Operation(summary = "分批下发发布明细", description = "按游标分批返回未发布(PENDING)行的发布数据"
+ "(标题/最终价/库存/SKU/属性/图片预签名 GET URL/categoryPath)——派发载荷只带 taskId+改价规则,"
+ "明细按需拉取(载荷尺寸可控、断点友好)。已回传行被状态谓词跳过,断点重连不重发。")
public ApiResponse<JdPublishItemsPageVo> items(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@Parameter(description = "游标(上一页最后一行 id;首页传 0 或省略)", required = false, example = "0")
@RequestParam(value = "cursor", required = false) Long cursor,
@Parameter(description = "批大小(默认 20,上限 100)", required = false, example = "20")
@RequestParam(value = "limit", required = false) Integer limit,
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.pullItems(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId), cursor, limit));
}
@GetMapping("/tasks/{taskId}/progress")
@Operation(summary = "查询京东上架进度", description = "任务状态 + 行级分组计数(待发布/发布中/成功/失败)。"
+ "归属校验与建单同口径:uid 按会话身份回填,任务 owner 与 uid 不一致即 403。")
public ApiResponse<JdPublishProgressVo> progress(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.queryProgress(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId)));
}
@PostMapping("/tasks/{taskId}/chunk")
@Operation(summary = "提交行级发布结果回传", description = "执行器按批次回传行级状态(PUBLISHING/SUCCESS/FAILED"
+ " +真实失败原因 + wareId);isEnd=true 任务按行级状态汇总落终态。error 字段按铁律 31 分档"
+ "(京麦登录态失效整单 FAILED;非致命只记录)——判定只信 X-Internal-Token,匿名一律拒绝判死。")
public ApiResponse<JdPublishChunkVo> submitChunk(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@RequestBody JdPublishChunkRequest request,
HttpServletRequest httpRequest) {
// 判死口凭据化(JdCollectController.submitChunk 同口径):error 上报是唯一能触发整单
// 判死的入口,匿名一律拒绝判死;行级结果落库不要求内部令牌(采集端按任务拉单)。
boolean trustedErrorReporter = adminAuthSupport.isTrustedInternalToken(httpRequest);
return ApiResponse.success(ingestService.submitChunk(taskId, request, trustedErrorReporter));
}
@PostMapping("/tasks/{taskId}/heartbeat")
@Operation(summary = "上报发布心跳", description = "沿用全局任务心跳语义:任务终态时回 alive=false,"
+ "执行端下一跳收手。归属校验前置:uid 与任务 owner 不一致即 403(B98-07 同形债预防——"
+ "任意用户不可给任意任务刷心跳续命)。处理位置一并记入心跳位置表供判死文案使用。")
public ApiResponse<TaskHeartbeatVo> heartbeat(
@Parameter(description = "任务 ID", required = true, example = "34400")
@PathVariable Long taskId,
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
@RequestBody(required = false) TaskHeartbeatRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.heartbeat(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId), request));
}
}
@@ -0,0 +1,35 @@
package com.nanri.aiimage.modules.jd.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
* 京东商品上架发布明细(biz_jd_publish_item,V210)数据访问口。
*
* <p>行级状态推进({@code updateById}/条件更新)走 MyBatis-Plus 既有通道;分批下发与
* 状态聚合两条具名 SQL 落 {@code mapper/jd/JdPublishItemMapper.xml}(铁律 1)。</p>
*/
@Mapper
public interface JdPublishItemMapper extends BaseMapper<JdPublishItemEntity> {
/**
* 明细分批下发页(断点友好,铁律 20 SQL 侧下推):只出<b>未发布</b>(PENDING)行,
* 按 id 升序、{@code id > cursor} 之后取 {@code limit} 行——已回传的行(SUCCESS/FAILED/
* PUBLISHING)被状态谓词天然跳过,客户端断点重连时把 cursor 置 0 也不会重发已发布商品
* (AC-4 服务端半边)。{@code cursor}/{@code limit} 必须是服务侧钳制后的值。
*/
List<JdPublishItemEntity> selectPublishableItems(@Param("taskId") Long taskId,
@Param("cursor") long cursor,
@Param("limit") int limit);
/**
* 行级状态聚合(进度与终态汇总共用):按 publish_status 分组计数。
* 行数上界=该任务商品行数(建单口钳 500),无分页问题。
*/
List<Map<String, Object>> countByPublishStatus(@Param("taskId") Long taskId);
}
@@ -0,0 +1,56 @@
package com.nanri.aiimage.modules.jd.model.dto;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import java.util.List;
/**
* 京东发布行级回传请求(v1.5 蓝图 §3:POST /api/jd-publish/tasks/{taskId}/chunk)。
*
* <p>顶层键集 {@code batchId / items / isEnd}(外加 {@code error} 失败上报);行内键集
* {@code itemId / productId / publishStatus / publishError / jdWareId}。行状态是唯一
* 行级真源({@code biz_jd_publish_item.publish_status});{@code error} 按铁律 31 分档
* (京麦登录态失效→整单 FAILED,代理/LLM 凭据致命词→{@code CredentialFatalClassifier},
* 其余技术性故障只记录不判死)——判定只信 X-Internal-Token(匿名 error 一律拒绝判死,
* 照 JdCollectController.submitChunk 同口径)。</p>
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public class JdPublishChunkRequest {
/** 批次号(客户端生成,溯源用)。 */
private String batchId;
/** 本批行级结果。 */
private List<ItemResult> items;
/** true=本任务全部行已回传,任务按行级状态汇总落终态。 */
private Boolean isEnd;
/**
* 客户端失败上报(非空时按铁律 31 分档;可信判定单一出口 X-Internal-Token)。
*/
private String error;
/** 单行回传结果。 */
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class ItemResult {
/** 明细行 id(items 下发时的 itemId;productId 作为对撞锚点)。 */
private Long itemId;
/** 商品行 id(uk_task_product 定位锚点)。 */
private Long productId;
/** 行级状态:PUBLISHING / SUCCESS / FAILED。 */
private String publishStatus;
/** 行级失败真实原因(FAILED 行必填,R6 单行失败隔离)。 */
private String publishError;
/** 京麦发布成功回执的商品 id(SUCCESS 行回传)。 */
private String jdWareId;
}
}
@@ -0,0 +1,40 @@
package com.nanri.aiimage.modules.jd.model.dto;
import lombok.Data;
import java.util.List;
/**
* 京东商品上架建单请求(v1.5 蓝图 §3 建单契约)。
*
* <p>用户在用户端「京东工具台 → 商品上架」页选自定义分类(消费 {@code GET /api/jd-collect/groups},
* B113-01 分类口唯一,AC-9)→ 分页拉该分类下归属自己的商品 → 勾选 → 可选统一改价规则 → 提交建单。
* 服务端按 productIds 落 {@code biz_jd_publish_item} 快照行;{@code request_json} 整体进
* {@code biz_file_task} 供兜底拉取回读({@code readCreateRequest} 同形)。</p>
*/
@Data
public class JdPublishTaskCreateRequest {
/** 提交人 uid(Controller 侧按会话身份回填,请求体自带值不采信)。 */
private Long userId;
/** 自定义分类 id(biz_jd_product_group.id,记录与展示用;商品勾选集才是发布范围)。 */
private Long categoryId;
/** 要上架的商品行 id 集(biz_jd_product.id,必填非空;全部必须归属当前用户,AC-9 归属半边)。 */
private List<Long> productIds;
/** 统一改价规则(可选;null=按原价,mode=none)。 */
private PriceRule priceRule;
/** 统一改价规则:none 原价 / percent 加价百分比(value=百分数) / fixed 固定加价(value=金额)。 */
@Data
public static class PriceRule {
/** none / percent / fixed(空缺省按 none 处理)。 */
private String mode;
/** percent 的百分数或 fixed 的加价金额;mode=none 时忽略。 */
private java.math.BigDecimal value;
}
}
@@ -0,0 +1,58 @@
package com.nanri.aiimage.modules.jd.model.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 京东商品上架发布明细行({@code biz_jd_publish_item},V210,v1.5 蓝图 §3)。
*
* <p>每任务每商品一行(唯一键 {@code uk_task_product}):建单即按 {@code biz_jd_product}
* 快照落行(商品库有 ageCleanup 清理语义,发布记录不随商品删除丢失溯源);行级状态机
* {@code PENDING → PUBLISHING → SUCCESS/FAILED} 由客户端 chunk 回传逐行推进——服务端
* 不预测发布结果,行状态的唯一写入口是 {@code JdPublishIngestService}(单客户端串行
* 回传,无并发竞争)。任务级行为复用 {@code biz_file_task}(module_type=JD_PUBLISH),
* 本表只承载行级明细与快照。</p>
*/
@Data
@TableName("biz_jd_publish_item")
public class JdPublishItemEntity {
@TableId(type = IdType.AUTO)
private Long id;
/** 任务行 id(biz_file_task.id,module_type=JD_PUBLISH)。 */
private Long taskId;
/** 物化归属分公司(owner 的 users.company_id;读不出落 NULL 不回填,铁律 30)。 */
private Long companyId;
/** 任务 owner uid(biz_file_task.user_id 投影)。 */
private Long userId;
/** 商品行 id(biz_jd_product.id)。 */
private Long productId;
/** 京东商品编码快照。 */
private String productCode;
/** 来源店铺名快照。 */
private String shopName;
/** 商品标题快照。 */
private String title;
/** 京麦类目路径快照(A &gt; B &gt; C)。 */
private String categoryPath;
/** 改价快照 JSON({"mode","value","sourcePrice","finalPrice"},finalPrice=主档价按规则折算)。 */
private String priceRuleJson;
/** 库存快照 JSON({"total":n})。 */
private String stockJson;
/** 行级状态机:PENDING/PUBLISHING/SUCCESS/FAILED(客户端 chunk 回传推进)。 */
private String publishStatus;
/** 行级失败真实原因(客户端回传原文,R6 单行失败隔离)。 */
private String publishError;
/** 京麦发布成功回执的商品 id(wareId,AC-3 真机核对锚点)。 */
private String jdWareId;
/** 主图 objectKey 快照(biz_jd_product_image MAIN 档 sortNo 最小行)。 */
private String mainImageObjectKey;
/** 建单落行时刻。 */
private LocalDateTime createdAt;
/** 最近回传/复位时刻。 */
private LocalDateTime updatedAt;
}
@@ -0,0 +1,19 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
/**
* 京东发布行级回传响应(v1.5):已接受行数 + 未发布余量;任务落终态时带终态状态。
*/
@Data
public class JdPublishChunkVo {
/** 本批接受行数。 */
private int acceptedCount;
/** 该任务剩余未发布(PENDING)行数。 */
private long pendingCount;
/** 任务终态状态(isEnd=true 且落了终态时回填;非终态回 null)。 */
private String taskStatus;
}
@@ -0,0 +1,93 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
import java.math.BigDecimal;
import java.util.List;
/**
* 明细分批下发的单商品发布载荷(v1.5 蓝图 §3:标题/最终价/库存/SKU/属性/图片/categoryPath)。
*
* <p>图片按 objectKey 发预签名 GET URL(jd-products 桶既有 presign 模式复用,蓝图 §3);
* 属性 {@code attrs} 是采集链原样透传的 key/label/value 三元组 JSON(服务端不裁剪不转写);
* SKU 行价已按统一改价规则折算({@code finalPrice}),执行器直接填表不再二次计算。</p>
*/
@Data
public class JdPublishItemPayloadVo {
/** 明细行 id(biz_jd_publish_item.id,客户端回传 chunk 时定位行)。 */
private Long itemId;
/** 商品行 id(biz_jd_product.id)。 */
private Long productId;
private String productCode;
/** 商品标题快照(发布页标题栏)。 */
private String title;
/** 京麦类目路径快照(A &gt; B &gt; C,授权树内定位节点)。 */
private String categoryPath;
/** 主档源价(biz_jd_product.priceMin 快照)。 */
private BigDecimal sourcePrice;
/** 主档最终价(源价 ± 改价规则折算)。 */
private BigDecimal finalPrice;
/** 库存总数快照。 */
private Integer stockTotal;
/** 商品属性全集(原始 key/label/value 三元组 JSON 原样透传)。 */
private String attrs;
/** SKU 矩阵(销售属性组合行,价已按规则折算)。 */
private List<SkuVo> skus;
/** 主图(预签名 GET URL,sortNo 升序)。 */
private List<ImageView> mainImages;
/** 销售属性图(attrName 维度,预签名 GET URL)。 */
private List<ImageView> attrImages;
/** 详情长图(预签名 GET URL,sortNo 升序,直铺详情编辑器)。 */
private List<ImageView> detailImages;
/** SKU 矩阵行。 */
@Data
public static class SkuVo {
private String skuId;
private String skuName;
/** SKU 源价(采集快照)。 */
private BigDecimal sourcePrice;
/** SKU 最终价(源价 ± 改价规则折算)。 */
private BigDecimal finalPrice;
private Integer stock;
/** 销售属性组合 JSON([{"name":"颜色","value":"上衣"},…])。 */
private String saleAttrsJson;
private Integer sortNo;
}
/** 图片下发视图(objectKey 留档 + 预签名 GET URL 直取)。 */
@Data
public static class ImageView {
/** 自有桶对象 key(留档;URL 过期时可凭它重签)。 */
private String objectKey;
/** 预签名 GET URL(客户端执行器直接下载/上传京麦)。 */
private String url;
/** 销售属性名(ATTR 档专用)。 */
private String attrName;
private Integer sortNo;
}
}
@@ -0,0 +1,30 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
import java.util.List;
/**
* 明细分批下发页(v1.5 蓝图 §3:GET /api/jd-publish/tasks/{taskId}/items)。
*
* <p>游标语义:{@code nextCursor}=本页最后一行 id,客户端带它取下一页;{@code hasMore}
* 由「本页取满批大小」判定(SQL 侧 {@code id > cursor AND publish_status='PENDING'}
* 下推,铁律 20——已回传行被状态谓词跳过,断点重连 cursor 归零也不会重发)。</p>
*/
@Data
public class JdPublishItemsPageVo {
private Long taskId;
/** 本页明细行。 */
private List<JdPublishItemPayloadVo> items;
/** 下一页游标(本页最后一行 id;空页时保持请求 cursor)。 */
private Long nextCursor;
/** true=可能还有下一页(本页取满批大小)。 */
private boolean hasMore;
/** 该任务剩余未发布行数(PENDING 计数,进度参考)。 */
private long pendingCount;
}
@@ -0,0 +1,41 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 京东发布任务进度(v1.5 用户端实时面板数据源,R7)。
*
* <p>行级分组计数(PENDING/PUBLISHING/SUCCESS/FAILED)来自 {@code biz_jd_publish_item}
* 聚合 SQL;任务级状态/终态原因来自 {@code biz_file_task}。归属校验按 {@code (taskId, userId)}
* (铁律 11):管理员代客时 userId 与任务 owner 不一致一律拒。</p>
*/
@Data
public class JdPublishProgressVo {
private Long taskId;
/** 任务状态(biz_file_task.status)。 */
private String status;
/** 终态原因(error_message;非终态为 null)。 */
private String message;
/** 总行数(该任务商品明细行数)。 */
private long totalCount;
/** 待发布行数。 */
private long pendingCount;
/** 发布中行数。 */
private long publishingCount;
/** 成功行数。 */
private long successCount;
/** 失败行数。 */
private long failedCount;
private LocalDateTime updatedAt;
}
@@ -0,0 +1,27 @@
package com.nanri.aiimage.modules.jd.model.vo;
import lombok.Data;
import java.util.Map;
/**
* 京东商品上架建单响应(v1.5 蓝图 §3)。
*
* <p>{@code queuePayload} 是页面推送载体(DELETE_BRAND {@code delete-brand-run} 同形先例):
* 建单成功后用户端页面 JS 把它原样投进 {@code api.enqueue_json}——载荷 type 与
* {@code JdPublishTaskPullSpiImpl.QUEUE_TYPE} 逐字同值(铁律 32 第三件:enqueue 页面推送;
* 兜底拉取线由 SPI 组装同形载荷,两处漂移任务永不执行)。</p>
*/
@Data
public class JdPublishTaskVo {
private Long taskId;
private String taskNo;
/** 执行通道(建单显式写 LOCAL,铁律 19:京麦登录态只在用户桌面机)。 */
private String collectChannel;
/** 页面推送载荷:{"type":"jd-product-publish-run","data":{"taskId":n,"priceRule":{...}}}。 */
private Map<String, Object> queuePayload;
}
@@ -0,0 +1,226 @@
package com.nanri.aiimage.modules.jd.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.task.TaskStatuses;
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.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.support.TaskFailureLedger;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
* 京东发布行级回传(v1.5 蓝图 §3 chunk 通道:POST /api/jd-publish/tasks/{taskId}/chunk)。
*
* <p>行状态是唯一行级真源({@code biz_jd_publish_item.publish_status},uk_task_product 定位);
* {@code isEnd=true} 时按行级状态汇总任务终态(失败行 &gt; 0 ⇒ 任务 FAILED、其余 SUCCESS,
* successFileCount/failedFileCount 落真实行数——R6 单行失败隔离、任务终态汇总成败数)。
* CAS 只认 RUNNING(铁律 14:已终态的任务不改写;可重入)。</p>
*
* <p>{@code error} 上报按铁律 31 分档(判死口凭据化,匿名一律拒绝判死——照
* {@code JdCollectController#submitChunk} 同口径):京麦登录态失效 →
* {@link JdPublishStaleTaskService#terminalizeOnJdLoginFatal}(词表复用
* {@code JdStaleTaskService#isJdLoginStateFailure},京东域两链同一族);代理/LLM 凭据
* 致命词 → {@code CredentialFatalTaskCloser};其余技术性故障只记录不判死。</p>
*/
@Service
@RequiredArgsConstructor
@Slf4j
public class JdPublishIngestService {
private static final String LOG_TAG = "jd-publish";
private static final String STATUS_RUNNING = TaskStatuses.FileTask.RUNNING;
/** chunk 可写回的行级状态(PENDING 是建单初值,不接受回传写回)。 */
private static final Set<String> WRITABLE_STATUSES =
Set.of(JdPublishTaskService.ITEM_PUBLISHING, JdPublishTaskService.ITEM_SUCCESS,
JdPublishTaskService.ITEM_FAILED);
/** publish_error 列宽(V210 VARCHAR(1024)),超长截断不炸批。 */
private static final int MAX_ERROR_LENGTH = 1024;
private final FileTaskMapper fileTaskMapper;
private final JdPublishItemMapper jdPublishItemMapper;
private final JdPublishStaleTaskService staleTaskService;
private final TaskProgressSnapshotService taskProgressSnapshotService;
public JdPublishChunkVo submitChunk(Long taskId, JdPublishChunkRequest request, boolean trustedErrorReporter) {
if (taskId == null || taskId <= 0) {
throw new BusinessException("任务 ID 不合法");
}
if (request == null) {
throw new BusinessException("回传体为空");
}
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !TaskFinalizeSupport.belongsToModule(JdPublishTaskService.MODULE_TYPE, task.getModuleType())) {
throw new BusinessException("任务不存在: " + taskId);
}
if (TaskStatuses.FileTask.TERMINAL.contains(task.getStatus())) {
throw new BusinessException("任务已结束(" + task.getStatus() + "),不再接受回传");
}
if (request.getError() != null && !request.getError().isBlank()) {
return handleErrorReport(task, request.getError(), trustedErrorReporter);
}
if (!STATUS_RUNNING.equals(task.getStatus())) {
// PENDING 拒收(页面推送漏 activate 时客户端第一个回传在此被拒,2026-11-14 同形实录)。
throw new BusinessException("任务不在运行中(" + task.getStatus() + "),请先激活任务再回传");
}
int accepted = 0;
if (request.getItems() != null) {
for (ItemResult item : request.getItems()) {
accepted += applyRowResult(taskId, item);
}
}
JdPublishChunkVo vo = new JdPublishChunkVo();
vo.setAcceptedCount(accepted);
vo.setPendingCount(statusCounts(taskId).getOrDefault(JdPublishTaskService.ITEM_PENDING, 0L));
if (Boolean.TRUE.equals(request.getIsEnd())) {
vo.setTaskStatus(summarizeTerminal(taskId));
}
log.info("[{}] chunk 回传 taskId={} batchId={} accepted={} pending={} isEnd={}",
LOG_TAG, taskId, request.getBatchId(), accepted, vo.getPendingCount(),
Boolean.TRUE.equals(request.getIsEnd()));
return vo;
}
/** 行级结果落库:按 uk_task_product(task_id + product_id)定位,单行失败不炸批。 */
private int applyRowResult(Long taskId, ItemResult item) {
if (item == null || item.getProductId() == null) {
return 0;
}
String status = item.getPublishStatus() == null ? null : item.getPublishStatus().trim().toUpperCase();
if (status == null || !WRITABLE_STATUSES.contains(status)) {
log.warn("[{}] 回传行状态不识别,跳过 taskId={} productId={} status={}",
LOG_TAG, taskId, item.getProductId(), item.getPublishStatus());
return 0;
}
LambdaUpdateWrapper<JdPublishItemEntity> wrapper = new LambdaUpdateWrapper<JdPublishItemEntity>()
.eq(JdPublishItemEntity::getTaskId, taskId)
.eq(JdPublishItemEntity::getProductId, item.getProductId())
.set(JdPublishItemEntity::getPublishStatus, status)
.set(JdPublishItemEntity::getPublishError,
JdPublishTaskService.ITEM_FAILED.equals(status)
? truncate(item.getPublishError()) : null)
.set(JdPublishItemEntity::getJdWareId, item.getJdWareId())
.set(JdPublishItemEntity::getUpdatedAt, LocalDateTime.now());
int updated = jdPublishItemMapper.update(null, wrapper);
if (updated == 0) {
log.warn("[{}] 回传行未命中明细行(商品不在本任务?)taskId={} productId={}",
LOG_TAG, taskId, item.getProductId());
}
return updated;
}
/** 铁律 31 分档判死口:只信 X-Internal-Token,匿名 error 一律拒绝判死(不碰状态)。 */
private JdPublishChunkVo handleErrorReport(FileTaskEntity task, String error, boolean trustedErrorReporter) {
JdPublishChunkVo vo = new JdPublishChunkVo();
vo.setAcceptedCount(0);
vo.setPendingCount(statusCounts(task.getId()).getOrDefault(JdPublishTaskService.ITEM_PENDING, 0L));
if (!trustedErrorReporter) {
log.warn("[{}] 匿名 error 上报拒绝判死 taskId={} err={}", LOG_TAG, task.getId(), abbreviate(error));
return vo;
}
// 京东域凭据词(京麦登录态)先判——采集/发布共用 19899 同一 profile,同一族同一判据。
if (JdStaleTaskService.isJdLoginStateFailure(error)) {
staleTaskService.terminalizeOnJdLoginFatal(task, error);
vo.setTaskStatus(TaskStatuses.FileTask.FAILED);
return vo;
}
// 代理/LLM 凭据致命词 → 公共判定档(发布面无代理无 LLM 消费,客户端报什么分什么档)。
boolean closed = new CredentialFatalTaskCloser(LOG_TAG, fileTaskMapper, null)
.closeIfFatal(task, error);
if (closed) {
vo.setTaskStatus(TaskStatuses.FileTask.FAILED);
return vo;
}
log.warn("[{}] 非致命失败上报,只记录不判死 taskId={} err={}", LOG_TAG, task.getId(), abbreviate(error));
return vo;
}
/** isEnd 终态汇总:按行级真源聚合落任务终态(R6),CAS 只认 RUNNING(铁律 14)。 */
private String summarizeTerminal(Long taskId) {
Map<String, Long> counts = statusCounts(taskId);
long success = counts.getOrDefault(JdPublishTaskService.ITEM_SUCCESS, 0L);
long failed = counts.getOrDefault(JdPublishTaskService.ITEM_FAILED, 0L);
long unpublished = counts.getOrDefault(JdPublishTaskService.ITEM_PENDING, 0L)
+ counts.getOrDefault(JdPublishTaskService.ITEM_PUBLISHING, 0L);
boolean anyFailed = failed > 0;
String status = anyFailed ? TaskStatuses.FileTask.FAILED : TaskStatuses.FileTask.SUCCESS;
StringBuilder reason = new StringBuilder("发布完成:成功 ").append(success).append(" 行,失败 ")
.append(failed).append(" 行");
if (unpublished > 0) {
reason.append(",未发布 ").append(unpublished).append(" 行");
}
LocalDateTime now = LocalDateTime.now();
int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getId, taskId)
.eq(FileTaskEntity::getModuleType, JdPublishTaskService.MODULE_TYPE)
.eq(FileTaskEntity::getStatus, STATUS_RUNNING)
.set(FileTaskEntity::getStatus, status)
.set(FileTaskEntity::getSuccessFileCount, success)
.set(FileTaskEntity::getFailedFileCount, failed)
.set(FileTaskEntity::getErrorMessage, anyFailed ? reason.toString() : null)
.set(FileTaskEntity::getFailureCategory, anyFailed ? TaskFailureLedger.categoryOf(reason.toString()) : null)
.set(FileTaskEntity::getUpdatedAt, now)
.set(FileTaskEntity::getFinishedAt, now));
if (updated > 0) {
taskProgressSnapshotService.markTerminal(taskId, JdPublishTaskService.MODULE_TYPE, status,
anyFailed ? reason.toString() : null);
log.info("[{}] 任务落终态 {} taskId={}", LOG_TAG, status, taskId);
}
return status;
}
/** 行级状态聚合(XML 具名 SQL):status → 行数。 */
private Map<String, Long> statusCounts(Long taskId) {
Map<String, Long> counts = new LinkedHashMap<>();
for (Map<String, Object> 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;
}
private String truncate(String value) {
if (value == null) {
return null;
}
String trimmed = value.trim();
return trimmed.length() <= MAX_ERROR_LENGTH ? trimmed : trimmed.substring(0, MAX_ERROR_LENGTH);
}
private String abbreviate(String value) {
if (value == null) {
return "";
}
return value.length() <= 200 ? value : value.substring(0, 200) + "…";
}
/** 供测试确认行级形状(按任务取全部明细行)。 */
public java.util.List<JdPublishItemEntity> findItemRows(Long taskId) {
return jdPublishItemMapper.selectList(new LambdaQueryWrapper<JdPublishItemEntity>()
.eq(JdPublishItemEntity::getTaskId, taskId)
.orderByAsc(JdPublishItemEntity::getId));
}
}
@@ -0,0 +1,156 @@
package com.nanri.aiimage.modules.jd.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.common.task.LockSkipWitness;
import com.nanri.aiimage.common.task.TaskStatuses;
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 com.nanri.aiimage.modules.task.service.support.TaskFailureLedger;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
/**
* 京东商品上架判活(v1.5 蓝图 §4 Phase 2,形状照 {@code JdStaleTaskService} 同形)。
*
* <p>两件事,登记形态不同:① <b>心跳超时兜底判死</b>——自带 {@code @Scheduled} 巡检
* (注册表 {@code selfScheduledStaleCheck=true},同 JD_SHOP_COLLECT 先例:发布是逐商品页面
* 自动化,节奏比采集还慢,60 分钟超时线({@code aiimage.jd.publish.stale-minutes},按发布
* 时长重估)并入 2 分钟集中巡检线没有额外收益,自管判死时延即可);② <b>京麦登录态失效
* 判死</b>——客户端在回传 {@code error} 里报「京麦未登录 / 登录态失效」时由回传侧
* ({@code JdPublishIngestService})调 {@link #terminalizeOnJdLoginFatal} 整单落终态
* (铁律 31:凭据不可自愈 ⇒ 行失败 + 整单终态,让心跳对采集端回 {@code alive=false} 收手),
* 判死出口集中在本类。</p>
*
* <p>「京麦登录态」词表是京东域两链共用的同一族凭据词(采集/发布共用 19899 同一 profile,
* 登录态失效的形状相同)——判据直接复用 {@code JdStaleTaskService#isJdLoginStateFailure},
* 不另抄一份词表(两份词表各改各的就是分叉判据);代理/LLM 凭据致命词的分档不在本类——
* 那是 {@code CredentialFatalClassifier} 的公共词表,回传侧直接用。</p>
*/
@Service
@RequiredArgsConstructor
@Slf4j
public class JdPublishStaleTaskService {
public static final String MODULE_TYPE = JdPublishTaskService.MODULE_TYPE;
private static final String STATUS_RUNNING = TaskStatuses.FileTask.RUNNING;
private static final String STATUS_FAILED = TaskStatuses.FileTask.FAILED;
private static final String LOG_TAG = "jd-publish";
private final FileTaskMapper fileTaskMapper;
private final TaskDistributedLockService taskDistributedLockService;
private final DistributedJobLockService distributedJobLockService;
private final StaleTaskHeartbeatPolicy staleTaskHeartbeatPolicy;
private final TaskProgressSnapshotService taskProgressSnapshotService;
/** 心跳超时线(分钟),按发布时长重估(蓝图 §3);下限钳 1。 */
@Value("${aiimage.jd.publish.stale-minutes:60}")
private long staleMinutes;
/** 心跳超时兜底判死(自带调度;分布式锁保证 A/B 双实例单跑;秒位 45 与采集面 40 错开)。 */
@Scheduled(cron = "${aiimage.jd.publish.stale-check-cron:45 */2 * * * *}")
public void finalizeStaleTasks() {
DistributedJobLockService.LockHandle lock =
distributedJobLockService.tryLock("jd-publish:stale-check", java.time.Duration.ofMinutes(10));
if (lock == null) {
LockSkipWitness.abandoned("jd-publish:stale-check");
return;
}
try (lock) {
long minutes = Math.max(1L, staleMinutes);
LocalDateTime threshold = LocalDateTime.now().minusMinutes(minutes);
List<FileTaskEntity> candidates = fileTaskMapper.selectList(new LambdaQueryWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getModuleType, MODULE_TYPE)
.eq(FileTaskEntity::getStatus, STATUS_RUNNING)
.lt(FileTaskEntity::getUpdatedAt, threshold)
.last("limit 200"));
for (FileTaskEntity task : candidates) {
if (staleTaskHeartbeatPolicy.isStillQueuedBeforeFirstHeartbeat(
task.getId(), 0L, task.getUpdatedAt(), LocalDateTime.now())) {
// 首次心跳之前不判死:任务还在客户端队列排队,updated_at 停在认领时刻不是卡死证据。
log.info("[{}] 未收到首次心跳、排队宽限内暂不判死 taskId={} updatedAt={} timeoutMinutes={}",
LOG_TAG, task.getId(), task.getUpdatedAt(), minutes);
continue;
}
TaskDistributedLockService.LockHandle taskLock =
taskDistributedLockService.acquire(MODULE_TYPE, task.getId(), 0L);
if (taskLock == null) {
LockSkipWitness.recordAbandoned("jd-publish:stale-finalize", MODULE_TYPE, task.getId());
continue;
}
try (taskLock) {
failStale(task, minutes);
}
}
}
}
private void failStale(FileTaskEntity task, long minutes) {
String reason = "京东上架心跳超时超过 " + minutes + " 分钟,任务已自动失败";
int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getId, task.getId())
.eq(FileTaskEntity::getModuleType, MODULE_TYPE)
.eq(FileTaskEntity::getStatus, STATUS_RUNNING)
.set(FileTaskEntity::getStatus, STATUS_FAILED)
.set(FileTaskEntity::getErrorMessage, reason)
.set(FileTaskEntity::getFailureCategory, TaskFailureLedger.categoryOf(reason))
.set(FileTaskEntity::getUpdatedAt, LocalDateTime.now())
.set(FileTaskEntity::getFinishedAt, LocalDateTime.now()));
if (updated > 0) {
taskProgressSnapshotService.markTerminal(task.getId(), MODULE_TYPE, STATUS_FAILED, reason);
log.warn("[{}] 心跳超时改判死 taskId={} updatedAt={} timeoutMinutes={}",
LOG_TAG, task.getId(), task.getUpdatedAt(), minutes);
}
}
/**
* 京麦登录态失效整单判死(铁律 31):CAS RUNNING→FAILED,终态文案点名「京麦未登录」与
* 「登录态失效」并给动作句(不写「稍后重试」)。已终态的任务 CAS 自然不命中,可重入。
*
* @return true=本次真的把任务写成了终态
*/
public boolean terminalizeOnJdLoginFatal(FileTaskEntity task, String rawError) {
if (task == null || task.getId() == null) {
return false;
}
String message = terminalLoginMessage(rawError);
int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getId, task.getId())
.eq(FileTaskEntity::getModuleType, MODULE_TYPE)
.eq(FileTaskEntity::getStatus, STATUS_RUNNING)
.set(FileTaskEntity::getStatus, STATUS_FAILED)
.set(FileTaskEntity::getSuccessFileCount, 0)
.set(FileTaskEntity::getFailedFileCount, 1)
.set(FileTaskEntity::getErrorMessage, message)
.set(FileTaskEntity::getFailureCategory, TaskFailureLedger.categoryOf(message))
.set(FileTaskEntity::getUpdatedAt, LocalDateTime.now())
.set(FileTaskEntity::getFinishedAt, LocalDateTime.now()));
if (updated > 0) {
taskProgressSnapshotService.markTerminal(task.getId(), MODULE_TYPE, STATUS_FAILED, message);
log.warn("[{}] 京麦登录态失效,任务落终态 FAILED taskId={} err={}", LOG_TAG, task.getId(), message);
}
return updated > 0;
}
/** 终态文案:生产者原文 + 点名两句判据词(「京麦未登录」「登录态失效」都在,AC-5 口径)+ 动作句。 */
static String terminalLoginMessage(String rawError) {
String raw = rawError == null ? "" : rawError.trim();
StringBuilder message = new StringBuilder();
if (!raw.isEmpty()) {
message.append(raw).append(";");
}
message.append("京麦未登录(登录态失效),请在客户端重新登录京麦后重试");
return message.toString();
}
}
@@ -0,0 +1,59 @@
package com.nanri.aiimage.modules.jd.service;
import com.nanri.aiimage.modules.task.model.dto.TaskHeartbeatRequest;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.spi.TaskModuleHeartbeatSpi;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* 京东商品上架的心跳 SPI 接线(v1.5,形状照 {@code JdCollectTaskHeartbeatSpi} 同形)。
*
* <p>京东模块没有独立的任务缓存(进度由全局心跳位置表、{@code biz_jd_publish_item}
* 行级真源与 {@code biz_task_progress_snapshot} 承载),所以 {@link #touchHeartbeat} 是
* 语义上的空实现——挂这个 Bean 的目的:① 心跳契约测试按注册表校验每个 moduleType 都有
* SPI,缺了会红;② 显式声明 {@code heartbeatNeedsFullTaskEntity()=false},心跳热路径不捞
* {@code request_json}/{@code result_json} 整行(AC-19 同款省钱口径);③ <b>override
* {@link #ensureOwnership}</b>——B98-07 同形债预防(采集面 JdCollectTaskHeartbeatSpi 未
* override,任意用户可给任意京东任务刷心跳续命,在册 P3)。</p>
*
* <p><b>为什么不在 SPI 里做实例域拒绝</b>:publish/shop-data-crawl 的任务由服务端 worker
* 执行、心跳来自执行线程自身(认领实例),按 {@code owner_instance_id} 拒绝安全;京东发布
* 是 LOCAL 单机任务、心跳来自用户桌面机客户端——公网入口可能落到 A/B 任一实例,按实例域
* 拒绝会把「心跳落到非认领实例」误杀成断连。用户域归属校验落在
* {@code JdPublishController#heartbeat}(可信 uid 只在会话层拿得到),本 override 做
* 任务在飞的轻校验并留审核痕迹。</p>
*/
@Slf4j
@Component
public class JdPublishTaskHeartbeatSpi implements TaskModuleHeartbeatSpi {
@Override
public String moduleType() {
return JdPublishTaskService.MODULE_TYPE;
}
@Override
public void touchHeartbeat(Long taskId, TaskHeartbeatRequest request) {
// 京东发布无模块缓存可刷:行级进度由 chunk 回传侧写,心跳只走 task 侧的通用通道。
}
/**
* B98-07 同形债预防(override=债已接,不是漏接):任务为空或模块不归属即拒绝;
* 实例域判据刻意不做(LOCAL 客户端心跳会落任一实例,见类注释)——用户域归属校验
* 在控制器层按可信 uid 执行。
*/
@Override
public void ensureOwnership(FileTaskEntity task, String operation) {
if (task == null || task.getId() == null
|| !JdPublishTaskService.MODULE_TYPE.equals(task.getModuleType())) {
throw new IllegalArgumentException("心跳目标不是京东上架任务 taskId="
+ (task == null ? null : task.getId()) + " operation=" + operation);
}
}
@Override
public boolean heartbeatNeedsFullTaskEntity() {
return false;
}
}
@@ -0,0 +1,46 @@
package com.nanri.aiimage.modules.jd.service;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.spi.ClientTaskPullSpi;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Map;
/**
* 京东商品上架的客户端兜底拉取实现(v1.5,铁律 32 派发三件套第一件)。
*
* <p>页面推送缺失(只建单没推送 / 推送前关页面 / 纯浏览器打开)时任务会停在 PENDING,
* {@code TaskClientPullService} 认领后由本实现组装可直接入队的载荷。载荷组装单一出处=
* {@link JdPublishTaskService#buildQueuePayload}(建单响应体与兜底拉取共用),type 与
* 客户端分发键逐字同值 <b>jd-product-publish-run</b>({@code QUEUE_TYPE})——
* 两处漂移任务客户端不识别(铁律 32:领了任务却「未知任务类型」)。</p>
*
* <p>明细(标题/价格/SKU/图片预签名)不在派发载荷里——载荷只带 taskId+改价规则
* (蓝图 §3:载荷尺寸可控、断点友好),客户端拿到后按游标分批拉
* {@code GET /api/jd-publish/tasks/{taskId}/items}。</p>
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class JdPublishTaskPullSpiImpl implements ClientTaskPullSpi {
/** 与客户端 amazon/jd/publish 的 QUEUE_TYPE 逐字同值(改这里必须同轮改客户端)。 */
public static final String QUEUE_TYPE = "jd-product-publish-run";
private final JdPublishTaskService publishTaskService;
@Override
public String moduleType() {
return JdPublishTaskService.MODULE_TYPE;
}
@Override
public Map<String, Object> buildQueuePayload(FileTaskEntity task) {
// 载荷组装单一出处:与建单响应的 queuePayload 同源(铁律 32 三件同值判据)。
Map<String, Object> payload = publishTaskService.buildQueuePayload(task);
log.info("[jd-publish] 兜底载荷已组装 taskId={}", task.getId());
return payload;
}
}
@@ -0,0 +1,537 @@
package com.nanri.aiimage.modules.jd.service;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
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.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.config.CollectRoutingProperties;
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.JdProductImageEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdProductSkuEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishItemPayloadVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishItemsPageVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishProgressVo;
import com.nanri.aiimage.modules.jd.model.vo.JdPublishTaskVo;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.CollectChannel;
import com.nanri.aiimage.modules.task.model.dto.TaskHeartbeatRequest;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.vo.TaskHeartbeatVo;
import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.ArrayList;
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.function.Function;
import java.util.stream.Collectors;
/**
* 京东商品上架建单(v1.5 蓝图 docs/ITERATION_PLAN.md §4 Phase 2:建单/配额/归属/生命周期/明细下发)。
*
* <p>形状照 {@code JdCollectTaskService} 同形:Mapper {@code insert} +
* taskNo={@code MODULE_TYPE-Snowflake} + 载荷整体进 {@code request_json}。京东发布特有:
* ① 执行通道恒 {@code LOCAL} 且<b>建单显式写库</b>(铁律 19:京麦登录态只在用户桌面机
* 19899 Chrome profile,执行方没有"界面选 ONLINE"的自由度);② 建单口<b>不接</b>
* {@code requireSubmitSecret}——发布由桌面机已登录京麦的 Chrome 直连执行,无代理无 LLM
* ({@code TaskModuleRegistry} 登记 {@code Optional.empty()},铁律 27c 登记结论);
* ③ 建单前置闸门按铁律 27b 排在一切昂贵动作前:未选商品 / 选了他人商品(AC-9 归属,
* 业务码 403)/ 超配额(AC-8,{@code JdPublishQuotaService#assertWithinQuota} 原语接线)
* 逐条点名拒绝;④ 建单即按商品快照落 {@code biz_jd_publish_item} 行(V210,商品库有
* 清理语义,发布记录不随商品删除丢失溯源)。</p>
*
* <p>建单成功页面推送与兜底拉取共用同一份载荷组装 {@link #buildQueuePayload}:
* type=<b>jd-product-publish-run</b>(与 {@link JdPublishTaskPullSpiImpl#QUEUE_TYPE}
* 逐字同值,铁律 32 第三件——两处漂移任务永不执行)。</p>
*/
@Service
@RequiredArgsConstructor
@Slf4j
public class JdPublishTaskService {
public static final String MODULE_TYPE = CollectRoutingProperties.MODULE_JD_PUBLISH;
private static final String STATUS_PENDING = TaskStatuses.FileTask.PENDING;
private static final String STATUS_RUNNING = TaskStatuses.FileTask.RUNNING;
/** 行级状态词表(V210 publish_status 列,与客户端 chunk 回传同词表)。 */
public static final String ITEM_PENDING = "PENDING";
public static final String ITEM_PUBLISHING = "PUBLISHING";
public static final String ITEM_SUCCESS = "SUCCESS";
public static final String ITEM_FAILED = "FAILED";
/** 单任务商品勾选上限(防 request_json/明细行膨胀;建单口拦注定失败的输入)。 */
private static final int MAX_PRODUCT_IDS = 500;
/** items 下发批大小上限(服务侧钳制,防一次拉满 500 行把载荷撑爆)。 */
private static final int MAX_ITEMS_BATCH = 100;
/** 图片预签名 GET 有效期(秒):发布一批跑得久,24h 同 InternalAudio 先例。 */
private static final int IMAGE_PRESIGN_EXPIRY_SECONDS = 86_400;
private final FileTaskMapper fileTaskMapper;
private final JdProductMapper jdProductMapper;
private final JdProductImageMapper jdProductImageMapper;
private final JdProductSkuMapper jdProductSkuMapper;
private final JdPublishItemMapper jdPublishItemMapper;
private final JdPublishQuotaService jdPublishQuotaService;
private final AdminUserMapper adminUserMapper;
private final OssStorageService ossStorageService;
private final ObjectMapper objectMapper;
private final TaskHeartbeatService taskHeartbeatService;
private final TaskHeartbeatPositionService taskHeartbeatPositionService;
/** 下发批大小出厂值(aiimage.jd.publish.items-batch-size,服务侧钳制上限 100)。 */
@Value("${aiimage.jd.publish.items-batch-size:20}")
private int itemsBatchSize = 20;
/** jd-products 独立桶(V194 同源配置,商品图/详情长图都在这里,铁律 17)。 */
@Value("${aiimage.jd.oss.bucket:jd-products}")
private String bucket;
public JdPublishTaskVo createTask(JdPublishTaskCreateRequest request, String deviceId) {
validate(request);
// AC-8 配额闸:前置在一切昂贵动作前(铁律 27b),超配额当场业务码拒绝并点名额度文案。
AdminUserEntity operator = adminUserMapper.selectById(request.getUserId());
jdPublishQuotaService.assertWithinQuota(operator, request.getProductIds().size());
// AC-9 归属半边:按主键批量取商品行(建单勾选集上界 500,非取页分页),存在性
// 与归属一起 fail-closed——缺行与选了他人商品都当场拒,不让一半商品静默混进任务。
List<JdProductEntity> products = jdProductMapper.selectBatchIds(request.getProductIds());
if (products.size() != request.getProductIds().size()) {
throw new BusinessException("部分商品不存在或已从京东数据库清理,请刷新后重新勾选");
}
for (JdProductEntity product : products) {
if (!Objects.equals(product.getUserId(), request.getUserId())) {
throw new BusinessException(403, "勾选的商品不属于当前账号,不能上架他人数据库的商品");
}
}
LocalDateTime now = LocalDateTime.now();
FileTaskEntity task = new FileTaskEntity();
task.setTaskNo(MODULE_TYPE + "-" + IdUtil.getSnowflakeNextIdStr());
task.setModuleType(MODULE_TYPE);
task.setTaskMode("PYTHON_QUEUE");
// 铁律 19:建单入口显式写通道。京东发布只能在本机已登录京麦的 Chrome 执行。
task.setCollectChannel(CollectChannel.LOCAL.name());
task.setStatus(STATUS_PENDING);
task.setSourceFileCount(request.getProductIds().size());
task.setSuccessFileCount(0);
task.setFailedFileCount(0);
task.setCreatedBy("user:" + request.getUserId());
task.setUserId(request.getUserId());
task.setDeviceId(AdminAuthSupport.normalizeDeviceId(deviceId));
task.setCreatedAt(now);
task.setUpdatedAt(now);
try {
task.setRequestJson(objectMapper.writeValueAsString(request));
task.setResultJson("{}");
} catch (Exception ex) {
throw new BusinessException("序列化建单载荷失败", ex);
}
fileTaskMapper.insert(task);
// 建单即落明细快照行(蓝图 §3):标题/类目/价格折算/库存/店铺/编码随行固化,
// 商品行被清理后发布记录仍可溯源;uk_task_product 防同任务重复勾选落两行。
Map<Long, String> 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)——页面把载荷推给本机客户端<b>之前</b>调用。
*
* <p>形状照 {@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<FileTaskEntity>()
.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<JdPublishItemEntity> rows = jdPublishItemMapper.selectPublishableItems(taskId, safeCursor, safeLimit);
// 页内商品行批量取(attrs 原样透传),不逐行 selectById。
Map<Long, JdProductEntity> 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<String, Long> 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<String, Object> buildQueuePayload(FileTaskEntity task) {
JdPublishTaskCreateRequest create = readCreateRequest(task);
Map<String, Object> 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 同形债预防,用户域半边):归属校验在调全局心跳通道<b>之前</b>——
* 可信 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<JdPublishItemEntity> findItemRows(Long taskId) {
return jdPublishItemMapper.selectList(new LambdaQueryWrapper<JdPublishItemEntity>()
.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<String, Object> 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<String, Object> 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<String, Object> value) {
try {
return objectMapper.writeValueAsString(value);
} catch (Exception ex) {
throw new BusinessException("序列化快照列失败", ex);
}
}
/** MAIN 档主图 objectKey(每商品取 sortNo 最小行);图片行缺失/无 key 的商品不落主图列。 */
private Map<Long, String> loadMainImageObjectKeys(List<JdProductEntity> products) {
List<Long> productIds = products.stream().map(JdProductEntity::getId).toList();
List<JdProductImageEntity> images = jdProductImageMapper.selectList(
new LambdaQueryWrapper<JdProductImageEntity>()
.in(JdProductImageEntity::getProductId, productIds)
.eq(JdProductImageEntity::getImageType, "MAIN")
.orderByAsc(JdProductImageEntity::getSortNo, JdProductImageEntity::getId));
Map<Long, String> 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<String, Long> aggregateStatusCounts(Long taskId) {
Map<String, Long> counts = new LinkedHashMap<>();
for (Map<String, Object> 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<String, Object> 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<String, Object> 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<JdPublishItemPayloadVo.SkuVo> loadSkuPayloads(Long productId, PriceRule rule) {
List<JdProductSkuEntity> skus = jdProductSkuMapper.selectList(
new LambdaQueryWrapper<JdProductSkuEntity>()
.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<JdPublishItemPayloadVo.ImageView> loadImagePayloads(Long productId, String imageType) {
List<JdProductImageEntity> images = jdProductImageMapper.selectList(
new LambdaQueryWrapper<JdProductImageEntity>()
.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();
}
}
@@ -13,7 +13,7 @@ import java.util.Locale;
* 只剩兜底窗口,不再决定执行方。
*
* <p>列可空,且**不回填**:空值按模块默认解释,外观专利/相似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<String> 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} 的模块清单。
@@ -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
# 前先确认客户端版本带兜底拉取线程。
@@ -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 专用),
@@ -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)';
@@ -0,0 +1,31 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nanri.aiimage.modules.jd.mapper.JdPublishItemMapper">
<!-- 京东商品上架发布明细(V210,v1.5):SQL 全部落 XML(铁律 1)。
行级状态推进(chunk 回传)走 MyBatis-Plus 条件更新(Mapper 层),本文件只承载
分批下发与状态聚合两条读侧具名 SQL。 -->
<!-- 明细分批下发页(断点友好,铁律 20 SQL 侧下推):过滤谓词必须在 SQL 段——
按 task_id 等值 + publish_status='PENDING' + id > cursor 下推后 LIMIT,
不得把已取页拉回 Java 再 filter(先 limit 后过滤会饿死另一批,铁律 20 同形)。
状态谓词同时是断点真源:已回传行(SUCCESS/FAILED/PUBLISHING)天然不进下一页,
客户端断点重连 cursor 归零也不会重发已发布商品(AC-4 服务端半边)。 -->
<select id="selectPublishableItems" resultType="com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity">
SELECT *
FROM biz_jd_publish_item
WHERE task_id = #{taskId}
AND publish_status = 'PENDING'
AND id &gt; #{cursor}
ORDER BY id ASC
LIMIT #{limit}
</select>
<!-- 行级状态聚合(进度展示与 isEnd 终态汇总共用):按 publish_status 分组计数。
行数上界=该任务商品行数(建单口钳 500),无分页问题。 -->
<select id="countByPublishStatus" resultType="java.util.Map">
SELECT publish_status AS publishStatus, COUNT(*) AS cnt
FROM biz_jd_publish_item
WHERE task_id = #{taskId}
GROUP BY publish_status
</select>
</mapper>
@@ -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() {
@@ -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<String> 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 这里先红。 */
@@ -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)。
*
* <p><b>Pending-to-Active 机制</b>:标 {@code @Disabled("Pending Phase 2")} 的方法是 Phase 2
* (后端地基:V208+ 迁移 / JdPublishController / JdPublishTaskService / 派发三件套)落地后才
* 能跑绿的契约,实现合入的同一个 Phase 里必须移除注解跑绿——蓝图对应 Phase 的【待激活验收
* 测试】栏登记了这份清单。唯一不 skip 的方法 {@link #京东分类读取口全仓唯一_B11301绊线()} 是
* <b>立即生效</b>的存量绊线:B113-01 拍板「分类选项唯一来源 GET /api/jd-collect/groups」,
* 任何面(含本迭代新增的发布面)都不许开第二个京东分类读取口。
* <p><b>Pending-to-Active 机制</b>:Phase 0 预置时标 {@code @Disabled("Pending Phase 2")} 的
* 7 支已在 Phase 2(后端地基:V210 迁移 / JdPublishController / JdPublishTaskService /
* 派发三件套)落地时移除注解正式激活(蓝图 Phase 2【待激活验收测试】清单)。
* {@link #京东分类读取口全仓唯一_B11301绊线()} 是<b>立即生效</b>的存量绊线:B113-01 拍板
* 「分类选项唯一来源 GET /api/jd-collect/groups」,任何面(含本迭代新增的发布面)都不许开
* 第二个京东分类读取口。
*
* <p>Pending 方法全部写成<b>源码绊线</b>(读源文件断言关键形状),不 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);
@@ -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"));
@@ -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<LambdaUpdateWrapper> 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<LambdaUpdateWrapper> 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<LambdaUpdateWrapper> 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<LambdaUpdateWrapper> 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("任务不存在");
}
}
@@ -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<LambdaUpdateWrapper> 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();
}
}
@@ -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<FileTaskEntity> 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<JdPublishItemEntity> 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());
}
}
@@ -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 + " 在清单里却不被判本机");
}