feat(jd): 京东数据库公共化——数据不区分公司、分组全平台一份(2026-11-15 用户定案)

This commit is contained in:
2026-11-15 20:26:55 +08:00
parent b9b66bcb0b
commit 91cf5dfaf7
20 changed files with 508 additions and 415 deletions
@@ -57,10 +57,13 @@ import java.util.List;
* 非超管菜单权限(column_key/route_path 双匹配)。菜单行由 V196 只插 columns 不预授权
* ⇒ 默认仅 super_admin 可见可访问,其余角色由超管在权限页手工勾授后才放行。</p>
*
* <p>公司隔离正门是 {@code readCompanyIdOrOwn}(同外观专利只读页/店铺密钥的表形状:
* 归属物化在行 company_id 列、可见集不靠账号/分组)——超管显式传才收窄、不传全量;
* 非超管强制本公司(忽略请求传参)。{@code superAdminScopedCompanyId} 对非超管返回 null
* =按行 company_id 列查询时把整张表交给每一家(该方法 javadoc 点名的越权形状),不走那道门。</p>
* <p><b>公司口径(2026-11-15 用户定案「京东数据库不区分公司、属于公共的」)</b>:行上的
* company_id 只剩「哪家公司客户端同步的」来源标记,不再构成可见性边界——读侧全公共;
* 唯一保留的公司维度是<b>站点超管</b>的公司 tab 筛选({@code superAdminScopedCompanyId}:
* 超管显式传 company_id 才收窄,非超管传什么都不收),也就是「管理员没有这个筛选、
* 超管可以筛选管理员」。详情与写侧(编辑/删除)没有公司维度:任何拿到本页菜单权限的
* 管理员对全部公共行可编辑可删除(同商品类目「谁都能改」的 2026-10-06 定案形状),
* 请求里的 company_id 传参已随公共化从写侧端点摘除。</p>
*
* <p>导出端点已随 2026-11-15 客户口径「导出也不用」整段下线(控制器/服务/mapper 参数一起删);
* {@code sale_status} 查询参数同窗撤掉(商品状态筛选框已从前端下线)。DB 列
@@ -70,7 +73,7 @@ import java.util.List;
@RequiredArgsConstructor
@Slf4j
@RequestMapping("/api/admin/jd-products")
@Tag(name = "京东数据库", description = "后管京东店铺商品库:分页查询、详情、编辑与删除,按分公司隔离。")
@Tag(name = "京东数据库", description = "后管京东店铺商品库:分页查询、详情、编辑与删除。数据全平台公共,仅超管可按公司(同步来源)筛选。")
public class AdminJdProductController {
private static final String COLUMN_KEY = "admin_jd_database";
@@ -84,8 +87,8 @@ public class AdminJdProductController {
private final DataReadScope dataReadScope;
@GetMapping
@Operation(summary = "分页查询京东数据库商品", description = "按分公司隔离分页查询同步落表的京东商品;"
+ "company_id 只对站点超管生效(显式传才收窄,不传全量),非超管强制本公司。")
@Operation(summary = "分页查询京东数据库商品", description = "公共库分页查询同步落表的京东商品;"
+ "company_id 只对站点超管生效(显式传才收窄=按同步来源公司筛),非超管传什么都不收(全量)。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "查询成功", content = @Content(schema = @Schema(implementation = JdProductPageVo.class)))
})
@@ -105,39 +108,36 @@ public class AdminJdProductController {
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
// 公司隔离正门是 readCompanyIdOrOwn(同外观专利只读页口径):超管显式传才收窄、
// 不传全量;非超管强制本公司(忽略请求传参)。
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
// 公司维度只剩超管的公司 tab 筛选(superAdminScopedCompanyId):超管显式传才收窄,
// 非超管传什么都不收——公共库对每一家管理员都是同一份全量。
Long scopedCompanyId = dataReadScope.superAdminScopedCompanyId(user, companyId);
return ApiResponse.success(jdProductQueryService.page(page, pageSize, scopedCompanyId, shopName,
productCode, titleKeyword, category, groupId, syncedFrom, syncedTo));
}
@GetMapping("/categories")
@Operation(summary = "类目筛选下拉数据源", description = "本公司已落库行 DISTINCT 的 category_path"
+ "(京麦末级类目名)+ 行数,按类目名排序;company_id 只对站点超管生效(显式传才收窄,"
+ "不传全量),非超管强制本公司。")
@Operation(summary = "类目筛选下拉数据源", description = "已落库行 DISTINCT 的 category_path"
+ "(京麦末级类目名)+ 行数,按类目名排序;company_id 只对站点超管生效(显式传才收窄="
+ "选项集与超管当前公司 tab 的行集同源),非超管传什么都不收(全量)。")
public ApiResponse<List<JdProductCategoryVo>> categories(
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
// 类目下拉与列表同走 readCompanyIdOrOwn 正门:选项集永远和页签能看到的公司行集同源。
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
// 类目下拉与列表同走超管筛选口径:选项集永远和当前请求能看到的行集同源。
Long scopedCompanyId = dataReadScope.superAdminScopedCompanyId(user, companyId);
return ApiResponse.success(jdProductQueryService.categories(scopedCompanyId));
}
@GetMapping("/{id}")
@Operation(summary = "商品详情", description = "主字段全量 + attr_json 属性分组(契约形状不识别时落空分组"
+ "并把原文放 attrJsonRaw 兜底,AC-7 未识别属性不丢弃)+ 已转存图片(100% 自有域名,AC-4)。"
+ "公司隔离与列表同门:越界 id 按不存在拒绝。")
+ "公共库无公司维度:按 id 直取,越界 id 按不存在拒绝。")
public ApiResponse<JdProductDetailVo> detail(
@Parameter(description = "商品行 id") @PathVariable("id") Long id,
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
// 详情同样过公司隔离正门:超管不传 company_id = 全量可见;非超管恒为本公司(服务按它收口)。
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, null);
return ApiResponse.success(jdProductQueryService.detail(id, scopedCompanyId));
requireJdAccess(request);
return ApiResponse.success(jdProductQueryService.detail(id));
}
@PutMapping("/{id}")
@@ -148,16 +148,13 @@ public class AdminJdProductController {
public ApiResponse<JdProductDetailVo> update(
@Parameter(description = "商品行 id") @PathVariable("id") Long id,
@Valid @RequestBody JdProductUpdateRequest body,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
Long updatedId = jdProductUpdateService.update(id, body, scopedCompanyId);
log.info("[jd-product] 编辑商品 operatorId={} companyId={} id={} title={}",
operator.id(), scopedCompanyId, updatedId, body.getTitle());
Long updatedId = jdProductUpdateService.update(id, body);
log.info("[jd-product] 编辑商品 operatorId={} id={} title={}",
operator.id(), updatedId, body.getTitle());
// 返回刷新后的详情(前端保存后直接回填抽屉),复用详情同一查询出口。
return ApiResponse.success(jdProductQueryService.detail(updatedId, scopedCompanyId));
return ApiResponse.success(jdProductQueryService.detail(updatedId));
}
@DeleteMapping("/{id}")
@@ -166,31 +163,25 @@ public class AdminJdProductController {
+ "任何对象删不掉就整批拒绝、一行库行都不动。越界 id 按不存在拒绝。")
public ApiResponse<JdProductDeleteVo> delete(
@Parameter(description = "商品行 id") @PathVariable("id") Long id,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
JdProductDeleteVo vo = jdProductDeleteService.delete(List.of(id), scopedCompanyId);
JdProductDeleteVo vo = jdProductDeleteService.delete(List.of(id));
// 管理端破坏性动作必须留痕:谁、删了哪些行、桶里清了几个对象(同分组删除口径)。
log.info("[jd-product] 删除商品 operatorId={} companyId={} id={} deleted={} objectsDeleted={}",
operator.id(), scopedCompanyId, id, vo.getDeleted(), vo.getObjectsDeleted());
log.info("[jd-product] 删除商品 operatorId={} id={} deleted={} objectsDeleted={}",
operator.id(), id, vo.getDeleted(), vo.getObjectsDeleted());
return ApiResponse.success(vo);
}
@PostMapping("/batch-delete")
@Operation(summary = "批量删除京东商品", description = "与单行删除同一出口(先删桶对象、全成功才删库行);"
+ "单次最多 200 个,id 里有一行不存在或不属于当前公司则整批拒绝(不做部分删除)。")
+ "单次最多 200 个,id 里有一行不存在则整批拒绝(不做部分删除)。")
public ApiResponse<JdProductDeleteVo> batchDelete(
@Valid @RequestBody JdProductBatchDeleteRequest body,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
JdProductDeleteVo vo = jdProductDeleteService.delete(body.getIds(), scopedCompanyId);
log.info("[jd-product] 批量删除商品 operatorId={} companyId={} requested={} deleted={} objectsDeleted={} kept={}",
operator.id(), scopedCompanyId, body.getIds().size(), vo.getDeleted(),
JdProductDeleteVo vo = jdProductDeleteService.delete(body.getIds());
log.info("[jd-product] 批量删除商品 operatorId={} requested={} deleted={} objectsDeleted={} kept={}",
operator.id(), body.getIds().size(), vo.getDeleted(),
vo.getObjectsDeleted(), vo.getObjectsKept());
return ApiResponse.success(vo);
}
@@ -5,7 +5,6 @@ import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.jd.model.dto.JdProductGroupSaveRequest;
import com.nanri.aiimage.modules.jd.model.vo.JdProductGroupVo;
import com.nanri.aiimage.modules.jd.service.JdProductGroupService;
@@ -24,7 +23,6 @@ import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
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;
import java.util.List;
@@ -32,19 +30,20 @@ import java.util.List;
/**
* 后管「京东数据库」分组管理(v1.4 Phase 5,R4):新建 / 改名 / 删除 / 下拉列表。
*
* <p>京东数据库专属分组(不是店铺管理的分组集):按公司隔离(唯一键
* {@code uk_company_group_name});删除分组不删商品——商品行 {@code group_id} 置 NULL
* (AC-8,事务两步落 {@code JdProductGroupService})。</p>
* <p>京东数据库专属分组(不是店铺管理的分组集):<b>2026-11-15 用户定案公共化</b>——
* 与品牌数据库(亚马逊)的分组同形状,全平台一份、不分公司(唯一键 {@code uk_group_name},
* V200 退键);删除分组不删商品——商品行 {@code group_id} 置 NULL(AC-8,事务两步落
* {@code JdProductGroupService})。实体上遗留的 company_id 列只是历史归属标记,读写两侧
* 都不再引用,新行按 DEFAULT 0 落「平台公共」。</p>
*
* <p>鉴权与 {@code AdminJdProductController} 同款私有闸(同一 column_key/route_path):
* 普通授权用户可读写分组(AC-9),默认仅 super_admin;公司隔离正门同样是
* {@code readCompanyIdOrOwn}——超管显式传才收窄,非超管强制本公司。</p>
* 普通授权用户可读写分组(AC-9),默认仅 super_admin。</p>
*/
@RestController
@RequiredArgsConstructor
@Slf4j
@RequestMapping("/api/admin/jd-product-groups")
@Tag(name = "京东数据库分组", description = "京东商品自定义分组管理:按公司隔离的列表/新建/改名/删除,删除不删商品(脱组)。")
@Tag(name = "京东数据库分组", description = "京东商品自定义分组管理:全平台一份(公共库),列表/新建/改名/删除,删除不删商品(脱组)。")
public class AdminJdProductGroupController {
private static final String COLUMN_KEY = "admin_jd_database";
@@ -53,49 +52,35 @@ public class AdminJdProductGroupController {
private final JdProductGroupService jdProductGroupService;
private final AdminAuthSupport adminAuthSupport;
private final PermissionMenuService permissionMenuService;
private final DataReadScope dataReadScope;
@GetMapping
@Operation(summary = "分组列表(含组内商品数)", description = "按公司隔离返回全部分组,按 sort_order, id 升序;"
+ "company_id 只对站点超管生效(显式传才收窄,不传全量),非超管强制本公司。"
@Operation(summary = "分组列表(含组内商品数)", description = "全平台全部分组,按 sort_order, id 升序;"
+ "productCount 为读侧现算列(分组下拉展示用)。")
public ApiResponse<List<JdProductGroupVo>> list(
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
return ApiResponse.success(jdProductGroupService.list(scopedCompanyId));
public ApiResponse<List<JdProductGroupVo>> list(HttpServletRequest request) {
requireJdAccess(request);
return ApiResponse.success(jdProductGroupService.list());
}
@PostMapping
@Operation(summary = "新建分组", description = "同公司重名按业务错误拒绝(409),不落库;"
+ "归属公司走公司隔离正门(站点超管必须显式传 company_id)。")
@Operation(summary = "新建分组", description = "重名按业务错误拒绝(409),不落库;公共库无公司归属。")
public ApiResponse<Long> create(
@Valid @RequestBody JdProductGroupSaveRequest body,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
// 超管不传 company_id 时 scopedCompanyId 为空 ⇒ 服务侧拒绝(分组必须归属一家公司)。
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
Long id = jdProductGroupService.create(scopedCompanyId, body.getName(), body.getSortOrder());
log.info("[jd-product-group] 新建分组 operatorId={} companyId={} groupId={}",
operator.id(), scopedCompanyId, id);
Long id = jdProductGroupService.create(body.getName(), body.getSortOrder());
log.info("[jd-product-group] 新建分组 operatorId={} groupId={}", operator.id(), id);
return ApiResponse.success(id);
}
@PutMapping("/{id}")
@Operation(summary = "分组改名/改排序", description = "越界 id(不属于本公司)按不存在拒绝;"
+ "改成本公司已有名字按业务错误拒绝(409)。")
@Operation(summary = "分组改名/改排序", description = "越界 id(不存在)按不存在拒绝;"
+ "改成已有名字按业务错误拒绝(409)。")
public ApiResponse<Boolean> rename(
@Parameter(description = "分组 id") @PathVariable("id") Long id,
@Valid @RequestBody JdProductGroupSaveRequest body,
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, null);
jdProductGroupService.rename(id, scopedCompanyId, body.getName(), body.getSortOrder());
jdProductGroupService.rename(id, body.getName(), body.getSortOrder());
log.info("[jd-product-group] 分组改名 operatorId={} groupId={}", operator.id(), id);
return ApiResponse.success(Boolean.TRUE);
}
@@ -107,9 +92,7 @@ public class AdminJdProductGroupController {
@Parameter(description = "分组 id") @PathVariable("id") Long id,
HttpServletRequest request) {
RequestOperator operator = requireJdAccess(request);
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, null);
int detached = jdProductGroupService.delete(id, scopedCompanyId);
int detached = jdProductGroupService.delete(id);
// 管理端破坏性动作必须留痕:谁、删了哪个分组、脱组了多少商品。
log.info("[jd-product-group] 删除分组 operatorId={} groupId={} detached={}",
operator.id(), id, detached);
@@ -10,9 +10,10 @@ import java.time.LocalDateTime;
/**
* 京东商品自定义分组({@code biz_jd_product_group},V195,v1.4)。
*
* <p>京东数据库专属分组(R4):按公司隔离(唯一键 {@code uk_company_group_name}),
* 可新建/改名/删除;删除分组不删商品——商品行 {@code group_id} 置 NULL(AC-8)。
* 简单单表 CRUD 走 BaseMapper + wrapper(SqlLayering 惯例),无 XML。</p>
* <p>京东数据库专属分组(R4):<b>2026-11-15 起全平台一份</b>(唯一键 {@code uk_group_name},
* V200 退掉按公司的 {@code uk_company_group_name});可新建/改名/删除;删除分组不删商品——
* 商品行 {@code group_id} 置 NULL(AC-8)。简单单表 CRUD 走 BaseMapper + wrapper
* (SqlLayering 惯例),无 XML。</p>
*/
@Data
@TableName("biz_jd_product_group")
@@ -20,9 +21,9 @@ public class JdProductGroupEntity {
@TableId(type = IdType.AUTO)
private Long id;
/** 归属分公司(分组按公司隔离,R4)。 */
/** 历史归属公司(V195~V199 按公司隔离时代遗留,公共化后读写两侧不再引用;新行 DEFAULT 0=平台公共)。 */
private Long companyId;
/** 分组名(同公司内唯一)。 */
/** 分组名(全平台唯一)。 */
private String name;
/** 下拉展示顺序。 */
private Integer sortOrder;
@@ -34,9 +34,12 @@ import java.util.Set;
* {@code biz_jd_product_image} 里有没有别的商品引用它;有就保留,计入 {@code objectsKept}。</li>
* <li><b>只删自己前缀内的 key</b>:key 不以 {@code aiimage.jd.oss.key-prefix} 开头的行只留 WARN、
* 不动手(防早期脏数据把删除扩到别的桶前缀上),计入 {@code objectsSkipped}。</li>
* <li><b>归属先判、整批拒绝</b>:id 里有一行不存在或不属于当前公司 ⇒ 整批不删(不做部分删除,
* 也不泄露越界行的存在性),文案点明"本次未删除任何数据"。</li>
* <li><b>存在先判、整批拒绝</b>:id 里有一行不存在 ⇒ 整批不删(不做部分删除),
* 文案点明"本次未删除任何数据"。</li>
* </ul>
*
* <p>公共库无公司维度(2026-11-15 用户定案「京东数据库不区分公司」):删除按 id 直判存在性,
* 不再按行 company_id 收口。</p>
*/
@Service
@RequiredArgsConstructor
@@ -68,10 +71,10 @@ public class JdProductDeleteService {
@Value("${aiimage.jd.oss.key-prefix:jd-products/}")
private String keyPrefix;
/** 删除给定商品(含 SKU、图片登记行与桶内对象);见类注释的三条边界。 */
public JdProductDeleteVo delete(List<Long> requestedIds, Long scopedCompanyId) {
/** 删除给定商品(含 SKU、图片登记行与桶内对象);见类注释的三条边界。公共库无公司维度(2026-11-15 用户定案)。 */
public JdProductDeleteVo delete(List<Long> requestedIds) {
List<Long> ids = normalizeIds(requestedIds);
List<JdProductEntity> scopedRows = requireScopedRows(ids, scopedCompanyId);
List<JdProductEntity> scopedRows = requireExistingRows(ids);
List<JdProductImageEntity> images = imageRowsOf(ids);
Set<String> ownedKeys = new LinkedHashSet<>();
Set<String> foreignKeys = new LinkedHashSet<>();
@@ -103,8 +106,8 @@ public class JdProductDeleteService {
vo.setObjectsDeleted(purged);
vo.setObjectsKept(ownedKeys.size() - purged);
vo.setObjectsSkipped(foreignKeys.size());
log.info("[{}] 删除完成 companyId={} productIds={} deleted={} images={} objectsDeleted={} kept={} skipped={}",
LOG_TAG, scopedCompanyId, ids, deleted, images.size(), purged, vo.getObjectsKept(),
log.info("[{}] 删除完成 productIds={} deleted={} images={} objectsDeleted={} kept={} skipped={}",
LOG_TAG, ids, deleted, images.size(), purged, vo.getObjectsKept(),
foreignKeys.size());
return vo;
}
@@ -130,15 +133,13 @@ public class JdProductDeleteService {
return new ArrayList<>(unique);
}
/** 归属闸:行必须都在(且都在当前公司可见面内),否则整批拒绝——不做部分删除。返回归属校验通过的行(供删除成功后登记忽略三元组)。 */
private List<JdProductEntity> requireScopedRows(List<Long> ids, Long scopedCompanyId) {
boolean scoped = scopedCompanyId != null && scopedCompanyId > 0;
/** 存在闸:行必须都在,否则整批拒绝——不做部分删除。返回实读到的行(供删除成功后登记忽略三元组)。 */
private List<JdProductEntity> requireExistingRows(List<Long> ids) {
List<JdProductEntity> rows = jdProductMapper.selectList(new LambdaQueryWrapper<JdProductEntity>()
.in(JdProductEntity::getId, ids)
.eq(scoped, JdProductEntity::getCompanyId, scopedCompanyId));
.in(JdProductEntity::getId, ids));
if (rows.size() != ids.size()) {
throw new BusinessException("有 " + (ids.size() - rows.size())
+ " 个商品不存在或不属于当前公司,请刷新后重试(本次未删除任何数据)");
+ " 个商品不存在,请刷新后重试(本次未删除任何数据)");
}
return rows;
}
@@ -21,17 +21,14 @@ import java.util.List;
* <p>分组表是简单单表,CRUD 全走 BaseMapper + wrapper(SqlLayering 惯例,无 XML)。
* 业务规则:</p>
* <ul>
* <li><b>按公司隔离</b>:所有读写都带 {@code companyId} 面;越界 id(行不存在或
* {@code company_id} 与传入公司不符)一律按「分组不存在」拒绝,不泄露存在性。</li>
* <li><b>同公司重名拒绝</b>(唯一键 {@code uk_company_group_name}):先查后插给可读的
* <li><b>全平台一份(2026-11-15 用户定案「分组和亚马逊功能一样」=与品牌数据库的
* 全平台共享同形状)</b>:读写都不带公司维度;实体遗留的 {@code company_id} 列只是
* V195~V199 按公司隔离时代的历史值,新行由 DEFAULT 0 落「平台公共」。</li>
* <li><b>全局重名拒绝</b>(唯一键 {@code uk_group_name},V200 退键):先查后插给可读的
* 409 业务错误,不拿 DB 异常撞 500;改名时排除自身再查。</li>
* <li><b>删除两步一事务</b>(AC-8):先把该组商品 {@code biz_jd_product.group_id} 置 NULL
* (商品不删,脱组即成「未分组」),再删分组行——同一事务,失败一起回滚。</li>
* </ul>
*
* <p>{@code companyId} 由控制器经 {@code DataReadScope#readCompanyIdOrOwn} 算好传入:
* {@code null} = 超管没选公司(rename/delete 放行、create 没有「没选公司」语义——
* 分组必须归属一家公司,直接拒绝),正数=该公司(非超管恒为自己的公司)。</p>
*/
@Service
@RequiredArgsConstructor
@@ -45,10 +42,8 @@ public class JdProductGroupService {
* {@code productCount} 用 {@code JdProductMapper} BaseMapper selectCount wrapper
* 按 {@code group_id} 统计(分组下拉展示用)。
*/
public List<JdProductGroupVo> list(Long scopedCompanyId) {
public List<JdProductGroupVo> list() {
LambdaQueryWrapper<JdProductGroupEntity> query = new LambdaQueryWrapper<JdProductGroupEntity>()
.eq(scopedCompanyId != null && scopedCompanyId > 0,
JdProductGroupEntity::getCompanyId, scopedCompanyId)
.orderByAsc(JdProductGroupEntity::getSortOrder)
.orderByAsc(JdProductGroupEntity::getId);
List<JdProductGroupVo> items = new ArrayList<>();
@@ -65,15 +60,11 @@ public class JdProductGroupService {
return items;
}
/** 新建分组:同公司重名(trim 后)按 409 业务错误拒绝,不落库。 */
public Long create(Long scopedCompanyId, String name, Integer sortOrder) {
if (scopedCompanyId == null || scopedCompanyId <= 0) {
throw new BusinessException(400, "创建分组必须指定公司");
}
/** 新建分组:重名(trim 后)按 409 业务错误拒绝,不落库;company_id 不写(DB DEFAULT 0=平台公共)。 */
public Long create(String name, Integer sortOrder) {
String safeName = requireName(name);
requireNameFree(scopedCompanyId, safeName, null);
requireNameFree(safeName, null);
JdProductGroupEntity group = new JdProductGroupEntity();
group.setCompanyId(scopedCompanyId);
group.setName(safeName);
group.setSortOrder(sortOrder == null ? 0 : sortOrder);
jdProductGroupMapper.insert(group);
@@ -81,10 +72,10 @@ public class JdProductGroupService {
}
/** 改名/改排序:越界 id 拒绝,重名(排除自身)拒绝。 */
public void rename(Long id, Long scopedCompanyId, String name, Integer sortOrder) {
public void rename(Long id, String name, Integer sortOrder) {
String safeName = requireName(name);
JdProductGroupEntity group = requireOwnedGroup(id, scopedCompanyId);
requireNameFree(group.getCompanyId(), safeName, group.getId());
JdProductGroupEntity group = requireExistingGroup(id);
requireNameFree(safeName, group.getId());
group.setName(safeName);
if (sortOrder != null) {
group.setSortOrder(sortOrder);
@@ -99,11 +90,10 @@ public class JdProductGroupService {
* @return 实际脱组的商品行数(前端拿它做「已解挂 N 个商品」的反馈,不猜)
*/
@Transactional
public int delete(Long id, Long scopedCompanyId) {
JdProductGroupEntity group = requireOwnedGroup(id, scopedCompanyId);
public int delete(Long id) {
JdProductGroupEntity group = requireExistingGroup(id);
int detached = jdProductMapper.update(null, new LambdaUpdateWrapper<JdProductEntity>()
.set(JdProductEntity::getGroupId, null)
.eq(JdProductEntity::getCompanyId, group.getCompanyId())
.eq(JdProductEntity::getGroupId, group.getId()));
jdProductGroupMapper.deleteById(group.getId());
return detached;
@@ -119,31 +109,25 @@ public class JdProductGroupService {
return name.trim();
}
/**
* 分组行归属校验:不存在 / 公司不符(越界 id)一律按「分组不存在」拒绝——
* 越界探测拿到的与 id 不存在是同一种响应,不泄露跨公司行的存在性。
* {@code scopedCompanyId} 为空=超管没选公司、跨公司放行。
*/
private JdProductGroupEntity requireOwnedGroup(Long id, Long scopedCompanyId) {
/** 分组行存在校验:不存在一律按「分组不存在」拒绝。 */
private JdProductGroupEntity requireExistingGroup(Long id) {
if (id == null || id <= 0) {
throw new BusinessException("分组不存在");
}
JdProductGroupEntity group = jdProductGroupMapper.selectById(id);
if (group == null || (scopedCompanyId != null && scopedCompanyId > 0
&& !scopedCompanyId.equals(group.getCompanyId()))) {
if (group == null) {
throw new BusinessException("分组不存在");
}
return group;
}
/** 同公司重名拒绝(409):{@code excludeId} 非空=改名时排除自身。 */
private void requireNameFree(Long companyId, String name, Long excludeId) {
/** 全局重名拒绝(409):{@code excludeId} 非空=改名时排除自身。 */
private void requireNameFree(String name, Long excludeId) {
Long count = jdProductGroupMapper.selectCount(new LambdaQueryWrapper<JdProductGroupEntity>()
.eq(JdProductGroupEntity::getCompanyId, companyId)
.eq(JdProductGroupEntity::getName, name)
.ne(excludeId != null, JdProductGroupEntity::getId, excludeId));
if (count != null && count > 0) {
throw new BusinessException(409, "同公司下已存在同名分组:" + name);
throw new BusinessException(409, "已存在同名分组:" + name);
}
}
}
@@ -35,9 +35,10 @@ import java.util.Map;
* 先例:{@code page} 上限 {@link #MAX_PAGE}、{@code page_size} 上限 {@link #MAX_PAGE_SIZE},
* {@code page=Long.MAX_VALUE} 不会把乘积顶成负数生成 {@code LIMIT -N} 的 500 错。</p>
*
* <p><b>公司隔离</b>:{@code scopedCompanyId} 由控制器经 {@code DataReadScope#readCompanyIdOrOwn}
* 算好传入——{@code null} = 超管没选公司、查全量;正数 = 只查该公司(非超管恒为自己的公司)。
* 详情同样按它收口:行 {@code company_id} 与公司隔离范围不符按不存在拒绝(不泄露跨公司行的存在性)。</p>
* <p><b>公司口径(2026-11-15 公共化)</b>:{@code scopedCompanyId} 由控制器经
* {@code DataReadScope#superAdminScopedCompanyId} 算好传入——只有站点超管显式传 company_id
* (公司 tab 筛选)才是正数,其余请求(含全部非超管)恒为 {@code null} = 全量;详情没有
* 公司维度,按 id 直取。</p>
*
* <p><b>详情 attr_json 解析(AC-7 未识别属性不丢弃)</b>:客户端实拍契约
* {@code {"tabs":[{"tab":"...","attrs":[{key,label,value}]}],"images":[...],"productCode":"..."}}——
@@ -106,8 +107,9 @@ public class JdProductQueryService {
/**
* 类目筛选下拉数据源(2026-11-15 用户口径「京麦的类目也要同步过来后台」):
* 本公司已落库行 distinct 的 {@code category_path}(=京麦末级类目名,契约 §2.3 E3)
* + 各自行数,按类目名排序。公司隔离与分页同门(控制器经 {@code readCompanyIdOrOwn} 传入)。
* 已落库行 distinct 的 {@code category_path}(=京麦末级类目名,契约 §2.3 E3)
* + 各自行数,按类目名排序。公司口径与分页同门(控制器经 {@code superAdminScopedCompanyId} 传入,
* {@code null} = 全量公共选项集)。
*/
public List<JdProductCategoryVo> categories(Long scopedCompanyId) {
Long companyId = scopedCompanyId != null && scopedCompanyId > 0 ? scopedCompanyId : null;
@@ -117,17 +119,16 @@ public class JdProductQueryService {
/**
* 商品详情(主字段全量 + attr_json 解析 + 已转存图片)。
*
* <p>公司隔离与分页同门:{@code scopedCompanyId} 非空且与行 {@code company_id} 不符时按
* 不存在拒绝——不泄露跨公司行的存在性(越界 id 探测拿到的与 id 不存在是同一种响应)。
* attr_json 非契约形状/解析异常时不抛 500:落空 {@code attrGroups}、原文进
* {@code attrJsonRaw} 兜底(AC-7)。</p>
* <p>公共库无公司维度(2026-11-15 用户定案「京东数据库不区分公司」):按 id 直取,
* 越界 id 按不存在拒绝。attr_json 非契约形状/解析异常时不抛 500:落空 {@code attrGroups}、
* 原文进 {@code attrJsonRaw} 兜底(AC-7)。</p>
*/
public JdProductDetailVo detail(Long id, Long scopedCompanyId) {
public JdProductDetailVo detail(Long id) {
if (id == null || id <= 0) {
throw new BusinessException("商品不存在");
}
JdProductEntity row = jdProductMapper.selectById(id);
if (row == null || !companyVisible(row.getCompanyId(), scopedCompanyId)) {
if (row == null) {
throw new BusinessException("商品不存在");
}
JdProductDetailVo vo = new JdProductDetailVo();
@@ -181,14 +182,6 @@ public class JdProductQueryService {
trimToNull(category), safeGroupId, syncedFrom, syncedTo);
}
/** 超管不选公司(scopedCompanyId=null)=全量可见;正数=只看该公司。 */
private static boolean companyVisible(Long rowCompanyId, Long scopedCompanyId) {
if (scopedCompanyId == null || scopedCompanyId <= 0) {
return true;
}
return scopedCompanyId.equals(rowCompanyId);
}
// ---------------------------------------------------------------- 列表/详情搬运
/** 行值原样搬运(读侧不加工),groupName 由 {@link #fillGroupNames} 批量补齐。 */
@@ -35,9 +35,9 @@ import java.util.Set;
* <p>三条块语义:</p>
* <ul>
* <li><b>主字段全量提交</b>:标题/品牌/类目/货号/价格区间/总库存/状态/分组按请求体覆写;
* 分组 id 归属必须与商品行同公司(防跨公司挂组)。保存即置 {@code manual_locked=1}(V199
* 人工编辑锁)——采集回传的 upsert / 图片与 SKU 登记 / 覆盖清理对锁定的行全部跳过,
* 人工值不被重爬覆盖。</li>
* 分组 id 必须真实存在(分组 2026-11-15 起全平台一份,无公司维度)。保存即置
* {@code manual_locked=1}(V199 人工编辑锁)——采集回传的 upsert / 图片与 SKU 登记 /
* 覆盖清理对锁定的行全部跳过,人工值不被重爬覆盖。</li>
* <li><b>可选块缺省不动</b>:{@code attrGroups} 缺省不动属性;提交时只重建 attr_json 的
* {@code tabs} 段、<b>保留原 JSON 其它顶层键</b>(images/productCode 等,铁律 30 形状:
* 不整份覆写别人的键);原文解析不出(attrJsonRaw 兜底行)则明确拒绝,不让编辑静默丢原文。
@@ -80,15 +80,15 @@ public class JdProductUpdateService {
/**
* 编辑保存,返回商品行 id(控制器用它回读刷新后的详情 VO)。
*
* <p>公司隔离与详情同门:行 company_id 与范围不符按不存在拒绝(不泄露越界行存在性)。</p>
* <p>公共库无公司维度(2026-11-15 用户定案):任何拿到本页菜单权限的管理员可编辑全部行。</p>
*/
@Transactional(rollbackFor = Exception.class)
public Long update(Long id, JdProductUpdateRequest body, Long scopedCompanyId) {
public Long update(Long id, JdProductUpdateRequest body) {
if (id == null || id <= 0) {
throw new BusinessException("商品不存在");
}
JdProductEntity row = jdProductMapper.selectById(id);
if (row == null || !companyVisible(row.getCompanyId(), scopedCompanyId)) {
if (row == null) {
throw new BusinessException("商品不存在");
}
validateBody(body);
@@ -96,8 +96,8 @@ public class JdProductUpdateService {
Long groupId = body.getGroupId();
if (groupId != null) {
JdProductGroupEntity group = jdProductGroupMapper.selectById(groupId);
if (group == null || !row.getCompanyId().equals(group.getCompanyId())) {
throw new BusinessException("分组不存在或不属于当前公司,请刷新分组后重试");
if (group == null) {
throw new BusinessException("分组不存在,请刷新分组后重试");
}
}
@@ -186,14 +186,6 @@ public class JdProductUpdateService {
}
}
/** 超管不选公司(scopedCompanyId=null)=全量可编辑;正数=只可编辑该公司行。 */
private static boolean companyVisible(Long rowCompanyId, Long scopedCompanyId) {
if (scopedCompanyId == null || scopedCompanyId <= 0) {
return true;
}
return scopedCompanyId.equals(rowCompanyId);
}
// ---------- 属性重建(只重建 tabs 段,其余顶层键保留) ----------
/**
@@ -0,0 +1,163 @@
-- =============================================================
-- 迁移 V200__jd_product_group_shared_across_companies
-- 需求:2026-11-15 用户定案「京东数据库不区分公司、属于公共的」「分组就是和亚马逊功能一样」
-- 前版:V195(京东分组表按公司一套,uk_company_group_name)
--
-- 1. 变更目的:把「京东数据库」分组 biz_jd_product_group 的唯一键从"公司+名"退回【全平台】
-- 键,与同批 jar 里已经摘掉公司谓词的读写侧对齐(分组挂到 AdminJdProductGroupController /
-- JdProductGroupService,读写两侧都不再引用 company_id)。不退这一刀的后果不是"看不到",
-- 是"写不进去":新代码的 INSERT 不带 company_id(实体字段不再赋值),旧键 (company_id, name)
-- 在功能上"暂时还能用"——但它把第 2 家公司将来建的同名分组挡在同一行里,而这一版之后
-- 系统里根本不存在"哪一家的分组"这个概念,键里留着公司维度就是一把没有对照物的锁。
--
-- 2. 口径:
-- uk_company_group_name(company_id, name) -> uk_group_name(name)
-- 键名复用 V151__rule_tables_shared_across_companies 的退键纪律(先加全局键、再摘公司键,
-- 中间任一步失败时至少还有一个唯一键在守并发)。
-- 同名组归并:V195 上线(2026-11-14)以来各公司可建同名组;退全局键前必须先归并——
-- 每个分组名保留最小 id 一行,其余行的商品(biz_jd_product.group_id)改挂到保留行,
-- 再删除多余组行。临时表 _v200_group_map(old_id, keep_id) 只记"要删的行"。
-- 【company_id 列不 DROP】(V151 第 6 段同一理由):上一版 jar 的读写两侧还带着
-- company_id(实体字段 + insert 列清单),删列与换键同批必然在混合窗口里打断旧 jar。
-- 本版只把 DEFAULT 补上(NOT NULL DEFAULT 0):新 jar 的 INSERT 不带这一列,
-- 靠 DEFAULT 0 落「平台公共」;历史行保留原公司号,只作"哪家客户端同步的"溯源标记。
-- 【CompanyDefaultGuard 不登记本表】:该哨兵只盯"仍然按公司写"的表;本表自本版起
-- 读写两侧都不分公司,喊"去摘 DEFAULT"会让人把唯一能兜住 NOT NULL 的默认值摘掉(1364)。
--
-- 3. 影响表与数据量:分组行数=公司数×用户自建组数(十级量级),归并扫描毫秒级;
-- 商品侧 UPDATE 只动 group_id 指向被归并行的那部分(通常 0 行)。任何形态都在毫秒级,
-- ADD UNIQUE 仍钉 ALGORITHM = INPLACE, LOCK = NONE,不给"顺手退化成交换锁"留机会。
--
-- 4. 可重跑性:归并段只在 uk_company_group_name 仍存在时执行;四条 DDL 都先查
-- information_schema 再 PREPARE(V145 首例写法),重跑逐条 no-op。
--
-- 5. 回滚(人工补丁,写成注释以免落在 Flyway 扫描路径里被当迁移执行):
-- ALTER TABLE biz_jd_product_group ADD UNIQUE KEY uk_company_group_name (company_id, name);
-- ALTER TABLE biz_jd_product_group DROP INDEX uk_group_name;
-- ALTER TABLE biz_jd_product_group MODIFY COLUMN company_id BIGINT NOT NULL
-- COMMENT '归属分公司(分组按公司隔离,R4)';
-- (jar 必须先回到带公司谓词的那版,否则"键按公司、代码不分公司"会让第 2 家建出
-- 与第 1 家同键的行;归并掉的组行不可自动找回,回滚前先备份。)
-- =============================================================
SET @db_name = DATABASE();
-- ---------- 1. 同名组归并(只在公司键仍在时执行;每组保留最小 id) ----------
SET @v200_old_uk := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_jd_product_group' AND INDEX_NAME = 'uk_company_group_name');
CREATE TEMPORARY TABLE IF NOT EXISTS _v200_group_map (
old_id BIGINT NOT NULL PRIMARY KEY,
keep_id BIGINT NOT NULL
) ENGINE = InnoDB;
-- 重复执行前先清空(Flyway 重跑整个文件时临时表可能已存在)。
DELETE FROM _v200_group_map;
-- 每个分组名保留最小 id;其余行进归并映射。
INSERT INTO _v200_group_map (old_id, keep_id)
SELECT g.id, keep.first_id
FROM biz_jd_product_group g
JOIN (
SELECT name, MIN(id) AS first_id
FROM biz_jd_product_group
GROUP BY name
HAVING COUNT(*) > 1
) dup ON dup.name = g.name
JOIN (
SELECT name, MIN(id) AS first_id
FROM biz_jd_product_group
GROUP BY name
) keep ON keep.name = g.name
WHERE g.id <> keep.first_id
AND @v200_old_uk > 0;
-- 商品改挂保留组(只动指向被归并行的 group_id)。
UPDATE biz_jd_product p
JOIN _v200_group_map m ON p.group_id = m.old_id
SET p.group_id = m.keep_id;
-- 删除被归并的组行。
DELETE g FROM biz_jd_product_group g
JOIN _v200_group_map m ON g.id = m.old_id;
DROP TEMPORARY TABLE IF EXISTS _v200_group_map;
-- ---------- 2. 分组表:先加全局键 ----------
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_jd_product_group' AND INDEX_NAME = 'uk_group_name');
SET @sql := IF(@idx_exists = 0,
'ALTER TABLE `biz_jd_product_group` ADD UNIQUE KEY `uk_group_name` (`name`), ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 3. 分组表:再摘公司键 ----------
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_jd_product_group' AND INDEX_NAME = 'uk_company_group_name');
SET @sql := IF(@idx_exists > 0,
'ALTER TABLE `biz_jd_product_group` DROP INDEX `uk_company_group_name`, ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 4. 摘按公司取全量的二级索引(读侧已不按 company_id 筛) ----------
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_jd_product_group' AND INDEX_NAME = 'idx_company');
SET @sql := IF(@idx_exists > 0,
'ALTER TABLE `biz_jd_product_group` DROP INDEX `idx_company`, ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 5. company_id 补 DEFAULT 0(新 INSERT 不带这一列,靠它满足 NOT NULL) ----------
SET @col_default := (SELECT COLUMN_DEFAULT FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_jd_product_group' AND COLUMN_NAME = 'company_id');
SET @v200_needs_default := (@col_default IS NULL OR (@col_default <> '0' AND @col_default <> 'NULL'));
SET @sql := IF(@v200_needs_default,
'ALTER TABLE `biz_jd_product_group` MODIFY COLUMN `company_id` BIGINT NOT NULL DEFAULT 0 COMMENT ''历史归属公司(V195~V199 按公司隔离时代遗留;2026-11-15 公共化后读写两侧不再引用,新行 0=平台公共)''',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- =============================================================
-- 验证 SQL(迁移后在库上执行,必须有人实跑,不许只看启动日志的 Successfully applied)
--
-- SELECT TABLE_NAME, INDEX_NAME, GROUP_CONCAT(CONCAT(COLUMN_NAME,'@',SEQ_IN_INDEX) ORDER BY SEQ_IN_INDEX) AS cols
-- FROM information_schema.STATISTICS
-- WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'biz_jd_product_group' AND NON_UNIQUE = 0
-- GROUP BY TABLE_NAME, INDEX_NAME;
-- -> 期望恰好两行:PRIMARY(id)、uk_group_name(name@1);
-- uk_company_group_name / idx_company 必须不在结果里。
--
-- SELECT COUNT(*) AS dup_group_names FROM (
-- SELECT name FROM biz_jd_product_group GROUP BY name HAVING COUNT(*) > 1 LIMIT 1
-- ) t;
-- -> 期望 0(第 2 步 ADD UNIQUE 能建起的前提)。
--
-- SELECT COUNT(*) AS orphan_group_products FROM biz_jd_product p
-- LEFT JOIN biz_jd_product_group g ON g.id = p.group_id
-- WHERE p.group_id IS NOT NULL AND g.id IS NULL;
-- -> 期望 0:归并后没有商品还挂着已删除的组行。
--
-- SHOW COLUMNS FROM biz_jd_product_group LIKE 'company_id';
-- -> 期望 Null = NO、Default = 0。本版【故意保留列】:旧 jar 的读写两侧还引用它。
--
-- INSERT IGNORE 在退回全局键后(事务内跑完回滚,只插 ZZTEST 前缀):
-- START TRANSACTION;
-- INSERT INTO biz_jd_product_group (name) VALUES ('ZZTESTGROUP0001');
-- INSERT INTO biz_jd_product_group (name) VALUES ('ZZTESTGROUP0001');
-- SELECT COUNT(*) AS one_row FROM biz_jd_product_group WHERE name = 'ZZTESTGROUP0001';
-- ROLLBACK;
-- -> 期望 one_row = 1:同名第二次被 IGNORE 掉 = 键真的回到全平台一档,且
-- company_id 由 DEFAULT 0 兜住(新 INSERT 不带这一列)。
-- =============================================================
@@ -48,14 +48,16 @@ import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* v1.4 Phase 5:后管「京东数据库」只读接口(列表/详情)与分组管理入口。
*
* <p>结构判据(照 {@code AdminAppearancePatentCleanItemsControllerTest} 双形态):
* 端点只读、鉴权 seam、公司隔离正门、snake 参数带默认值、SQL 只落 XML;
* 行为样本:mock HttpServletRequest 把 company 参数交给 readCompanyIdOrOwn 并装进 200 信封、
* 端点只读、鉴权 seam、公司口径(读侧只剩超管筛选 superAdminScopedCompanyId,公共库不走
* readCompanyIdOrOwn)、snake 参数带默认值、SQL 只落 XML;
* 行为样本:mock HttpServletRequest 把 company 参数交给 superAdminScopedCompanyId 并装进 200 信封、
* 分页钳制 offset/limit(page=Long.MAX_VALUE 不得负,铁律 15)、详情 attr_json
* tabs→attrGroups 解析与非法形状兜底(AC-7)。
* 导出端点与 sale_status 筛选参数已随 2026-11-15 客户口径整段下线(反向钉住防回潜)。</p>
@@ -109,13 +111,14 @@ class AdminJdProductControllerTest {
}
@Test
void 公司隔离走readCompanyIdOrOwn() throws IOException {
void 公司口径只剩超管筛选_公共库不走readCompanyIdOrOwn() throws IOException {
String source = stripComments(Files.readString(CONTROLLER));
assertTrue(source.contains("DataReadScope"), "公司隔离唯一出口是 DataReadScope");
assertTrue(source.contains("readCompanyIdOrOwn"),
"读侧必须走 readCompanyIdOrOwn:超管显式传才收窄,非超管强制本公司");
assertFalse(source.contains("superAdminScopedCompanyId"),
"不得走 superAdminScopedCompanyId:它对非超管返回 null=按行 company_id 查询时把整张表交给每一家");
assertTrue(source.contains("DataReadScope"), "公司维度唯一出口是 DataReadScope");
assertTrue(source.contains("superAdminScopedCompanyId"),
"读侧(列表/类目)必须走 superAdminScopedCompanyId:只有站点超管显式传 company_id 才收窄"
+ "(公司 tab 筛选管理员),其余请求全量(2026-11-15 用户定案「京东数据库不区分公司、属于公共的」)");
assertFalse(source.contains("readCompanyIdOrOwn"),
"不得走 readCompanyIdOrOwn:它对非超管强制本公司,公共库对每一家管理员都是同一份全量");
}
@Test
@@ -169,7 +172,7 @@ class AdminJdProductControllerTest {
// ===================== 行为样本 =====================
@Test
void 控制器把公司参数交给readCompanyIdOrOwn并把结果装进200信封() {
void 控制器把公司参数交给superAdminScopedCompanyId并把结果装进200信封() {
JdProductQueryService queryService = mock(JdProductQueryService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
@@ -183,8 +186,8 @@ class AdminJdProductControllerTest {
HttpServletRequest request = mock(HttpServletRequest.class);
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
// 超管显式传 company_id=5 ⇒ 正门把 5 交出来(不传时正门给 null=全量,同一行为样本家族)。
when(dataReadScope.readCompanyIdOrOwn(operator, 5L)).thenReturn(5L);
// 超管显式传 company_id=5 ⇒ 超管筛选把 5 交出来(不传时给 null=全量,同一行为样本家族)。
when(dataReadScope.superAdminScopedCompanyId(operator, 5L)).thenReturn(5L);
JdProductPageVo pageVo = new JdProductPageVo();
pageVo.setItems(List.of());
pageVo.setTotal(0L);
@@ -195,14 +198,14 @@ class AdminJdProductControllerTest {
ApiResponse<JdProductPageVo> response = controller.page(1L, 20L, null, null, null, null, null,
null, null, 5L, request);
verify(dataReadScope).readCompanyIdOrOwn(operator, 5L);
verify(dataReadScope).superAdminScopedCompanyId(operator, 5L);
verify(queryService).page(1L, 20L, 5L, null, null, null, null, null, null, null);
assertEquals(Boolean.TRUE, response.isSuccess(), "拒绝走 403 业务码,放行必须是 success 信封(B80-03)");
assertEquals(pageVo, response.getData());
}
@Test
void 类目下拉端点走同一正门并回选项集() {
void 类目下拉端点走同一超管筛选口径并回选项集() {
JdProductQueryService queryService = mock(JdProductQueryService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
@@ -215,8 +218,7 @@ class AdminJdProductControllerTest {
HttpServletRequest request = mock(HttpServletRequest.class);
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
// 非超管正门强制本公司:即使请求带别的 company_id 也按返回值收口(同一行为样本家族)。
when(dataReadScope.readCompanyIdOrOwn(operator, 5L)).thenReturn(5L);
when(dataReadScope.superAdminScopedCompanyId(operator, 5L)).thenReturn(5L);
JdProductCategoryVo row = new JdProductCategoryVo();
row.setName("艺考形体服");
row.setProductCount(85L);
@@ -224,7 +226,7 @@ class AdminJdProductControllerTest {
ApiResponse<List<JdProductCategoryVo>> response = controller.categories(5L, request);
verify(dataReadScope).readCompanyIdOrOwn(operator, 5L);
verify(dataReadScope).superAdminScopedCompanyId(operator, 5L);
verify(queryService).categories(5L);
assertEquals(Boolean.TRUE, response.isSuccess(), "类目下拉与列表同一鉴权正门(200 信封)");
assertEquals("艺考形体服", response.getData().get(0).getName(), "选项=已落库行的末级类目名");
@@ -232,7 +234,7 @@ class AdminJdProductControllerTest {
}
@Test
void 控制器详情走同一鉴权正门并回详情() {
void 控制器详情走同一鉴权正门并回详情且不问公司() {
JdProductQueryService queryService = mock(JdProductQueryService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
@@ -245,22 +247,21 @@ class AdminJdProductControllerTest {
HttpServletRequest request = mock(HttpServletRequest.class);
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
// 详情不收 company 参数:超管不传=全量可见;非超管由正门强制本公司(服务按返回值收口)。
when(dataReadScope.readCompanyIdOrOwn(operator, null)).thenReturn(null);
JdProductDetailVo detailVo = new JdProductDetailVo();
detailVo.setId(11L);
when(queryService.detail(11L, null)).thenReturn(detailVo);
when(queryService.detail(11L)).thenReturn(detailVo);
ApiResponse<JdProductDetailVo> response = controller.detail(11L, request);
verify(dataReadScope).readCompanyIdOrOwn(operator, null);
verify(queryService).detail(11L, null);
// 公共库详情没有公司维度:DataReadScope 不参与(防有人把公司收口接回来)。
verifyNoInteractions(dataReadScope);
verify(queryService).detail(11L);
assertEquals(Boolean.TRUE, response.isSuccess());
assertEquals(detailVo, response.getData());
}
@Test
void 删除端点走同一正门并把服务回执装进200信封() {
void 删除端点按公共库直判存在并把服务回执装进200信封() {
JdProductQueryService queryService = mock(JdProductQueryService.class);
JdProductDeleteService deleteService = mock(JdProductDeleteService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
@@ -274,17 +275,17 @@ class AdminJdProductControllerTest {
HttpServletRequest request = mock(HttpServletRequest.class);
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
when(dataReadScope.readCompanyIdOrOwn(operator, 5L)).thenReturn(5L);
JdProductDeleteVo receipt = new JdProductDeleteVo();
receipt.setDeleted(1);
receipt.setObjectsDeleted(9);
receipt.setObjectsKept(2);
when(deleteService.delete(List.of(11L), 5L)).thenReturn(receipt);
when(deleteService.delete(List.of(11L))).thenReturn(receipt);
ApiResponse<JdProductDeleteVo> response = controller.delete(11L, 5L, request);
ApiResponse<JdProductDeleteVo> response = controller.delete(11L, request);
verify(dataReadScope).readCompanyIdOrOwn(operator, 5L);
verify(deleteService).delete(List.of(11L), 5L);
// 公共库写侧没有公司维度:不收 company_id、DataReadScope 不参与。
verifyNoInteractions(dataReadScope);
verify(deleteService).delete(List.of(11L));
assertEquals(Boolean.TRUE, response.isSuccess());
assertEquals(9, response.getData().getObjectsDeleted());
}
@@ -304,14 +305,13 @@ class AdminJdProductControllerTest {
HttpServletRequest request = mock(HttpServletRequest.class);
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
when(dataReadScope.readCompanyIdOrOwn(operator, null)).thenReturn(5L);
when(deleteService.delete(List.of(11L, 12L), 5L))
.thenThrow(new BusinessException("有 1 个商品不存在或不属于当前公司,请刷新后重试(本次未删除任何数据)"));
when(deleteService.delete(List.of(11L, 12L)))
.thenThrow(new BusinessException("有 1 个商品不存在,请刷新后重试(本次未删除任何数据)"));
JdProductBatchDeleteRequest body = new JdProductBatchDeleteRequest();
body.setIds(List.of(11L, 12L));
BusinessException ex = assertThrows(BusinessException.class,
() -> controller.batchDelete(body, null, request));
() -> controller.batchDelete(body, request));
assertTrue(ex.getMessage().contains("本次未删除任何数据"), "整批拒绝的语义必须到界面");
}
@@ -402,7 +402,7 @@ class AdminJdProductControllerTest {
image.setHeight(800);
when(imageMapper.selectList(any())).thenReturn(List.of(image));
JdProductDetailVo vo = service.detail(11L, 5L);
JdProductDetailVo vo = service.detail(11L);
assertEquals(2, vo.getAttrGroups().size(), "tabs 数组逐个映射成 attrGroups(groupName=tab 字段)");
assertEquals("商品基本信息", vo.getAttrGroups().get(0).getGroupName());
@@ -433,7 +433,7 @@ class AdminJdProductControllerTest {
JdProductEntity broken = productEntity(11L);
broken.setAttrJson("{\"tabs\": [broken");
when(mapper.selectById(11L)).thenReturn(broken);
JdProductDetailVo brokenVo = service.detail(11L, 5L);
JdProductDetailVo brokenVo = service.detail(11L);
assertTrue(brokenVo.getAttrGroups().isEmpty(), "解析异常落空 attrGroups,不抛 500(AC-7)");
assertEquals("{\"tabs\": [broken", brokenVo.getAttrJsonRaw(), "原文进 attrJsonRaw 兜底展示");
@@ -441,7 +441,7 @@ class AdminJdProductControllerTest {
JdProductEntity foreign = productEntity(11L);
foreign.setAttrJson("{\"attrs\":[{\"key\":\"x\",\"value\":\"y\"}]}");
when(mapper.selectById(11L)).thenReturn(foreign);
JdProductDetailVo foreignVo = service.detail(11L, 5L);
JdProductDetailVo foreignVo = service.detail(11L);
assertTrue(foreignVo.getAttrGroups().isEmpty(), "非契约形状落空 attrGroups");
assertEquals("{\"attrs\":[{\"key\":\"x\",\"value\":\"y\"}]}", foreignVo.getAttrJsonRaw(),
"未识别属性不丢弃:原文兜底透出(AC-7)");
@@ -450,7 +450,7 @@ class AdminJdProductControllerTest {
JdProductEntity blank = productEntity(11L);
blank.setAttrJson(null);
when(mapper.selectById(11L)).thenReturn(blank);
JdProductDetailVo blankVo = service.detail(11L, 5L);
JdProductDetailVo blankVo = service.detail(11L);
assertTrue(blankVo.getAttrGroups().isEmpty());
assertNull(blankVo.getAttrJsonRaw());
}
@@ -482,7 +482,7 @@ class AdminJdProductControllerTest {
brokenJson.setSaleAttrsJson("[{\"name\":");
when(skuMapper.selectList(any())).thenReturn(List.of(first, brokenJson));
JdProductDetailVo vo = service.detail(11L, 5L);
JdProductDetailVo vo = service.detail(11L);
assertEquals(2, vo.getSkus().size(), "京麦那 12 行矩阵按入库行下发(抽屉渲染的唯一来源)");
JdProductDetailVo.SkuVo sku = vo.getSkus().get(0);
@@ -499,23 +499,24 @@ class AdminJdProductControllerTest {
}
@Test
void 详情公司越界按不存在拒绝() {
void 详情按公共库直取_缺失按不存在拒绝() {
JdProductMapper mapper = mock(JdProductMapper.class);
JdProductQueryService service = new JdProductQueryService(mapper, mock(JdProductImageMapper.class),
mock(com.nanri.aiimage.modules.jd.mapper.JdProductSkuMapper.class),
mock(com.nanri.aiimage.modules.jd.mapper.JdProductGroupMapper.class));
// 公共库(2026-11-15 用户定案):详情没有公司维度,别家公司时代的行照样可读。
JdProductEntity row = productEntity(11L);
row.setCompanyId(6L);
when(mapper.selectById(11L)).thenReturn(row);
assertNotNull(service.detail(11L));
// 非超管(scopedCompanyId=5):行属公司 6 ⇒ 按「商品不存在」拒绝,不泄露跨公司行的存在性。
BusinessException ex = assertThrows(BusinessException.class, () -> service.detail(11L, 5L));
// 行不存在 ⇒ 按「商品不存在」拒绝。
when(mapper.selectById(11L)).thenReturn(null);
BusinessException ex = assertThrows(BusinessException.class, () -> service.detail(11L));
assertTrue(ex.getMessage().contains("商品不存在"));
// 超管不选公司(null)=全量可见。
assertNotNull(service.detail(11L, null));
// id 非法同样拒绝。
assertThrows(BusinessException.class, () -> service.detail(0L, null));
assertThrows(BusinessException.class, () -> service.detail(0L));
}
@Test
@@ -37,9 +37,10 @@ import static org.mockito.Mockito.when;
* 京东商品删除编排判据(用户口径「后台删除数据的时候也要把桶对应的文件删除」)。
*
* <p>钉四件事:①<b>先删桶、全成功才删库行</b>——桶失败时库行删除出口必须零调用
* (库行先消失就再没人知道该删哪些 key,对象成永久孤儿);②共用对象不删(同公司
* 同内容同 key,删一个商品的图不能把别的商品搞裂图);③归属先判、越界整批拒绝
* (不做部分删除);④前缀外的 key 不动手(只留 WARN),防脏数据把删除扩到别的桶前缀。</p>
* (库行先消失就再没人知道该删哪些 key,对象成永久孤儿);②共用对象不删(同内容同 key,
* 删一个商品的图不能把别的商品搞裂图);③存在先判、缺失整批拒绝(不做部分删除);
* ④前缀外的 key 不动手(只留 WARN),防脏数据把删除扩到别的桶前缀。
* 公共库无公司维度(2026-11-15 用户定案):删除按 id 直判存在性,不再按 company_id 收口。</p>
*/
@ExtendWith(MockitoExtension.class)
class JdProductDeleteServiceTest {
@@ -93,7 +94,7 @@ class JdProductDeleteServiceTest {
@Test
void 先删桶_全成功才删库行() {
givenOwnedRows(List.of(11L));
// selectList 依次被调:①商品归属闸 ②图片行取数 ③共用性回查(mock 不看 wrapper 条件,
// selectList 依次被调:①商品存在闸 ②图片行取数 ③共用性回查(mock 不看 wrapper 条件,
// 所以回查那次显式给空——没人引用这张图,才能真的删)。
when(jdProductMapper.selectList(any())).thenReturn(List.of(productRow(11L)));
when(jdProductImageMapper.selectList(any()))
@@ -101,7 +102,7 @@ class JdProductDeleteServiceTest {
.thenReturn(List.of());
when(jdProductRowDeleteService.deleteRows(List.of(11L))).thenReturn(1);
JdProductDeleteVo vo = service.delete(List.of(11L), COMPANY_ID);
JdProductDeleteVo vo = service.delete(List.of(11L));
// 顺序:removeObject 先于 deleteRows。
var inOrder = org.mockito.Mockito.inOrder(ossStorageService, jdProductRowDeleteService);
@@ -120,7 +121,7 @@ class JdProductDeleteServiceTest {
doThrow(new RuntimeException("oss 5xx"))
.when(ossStorageService).removeObject(anyString(), anyString());
assertThatThrownBy(() -> service.delete(List.of(11L), COMPANY_ID))
assertThatThrownBy(() -> service.delete(List.of(11L)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("本次未删除任何数据");
@@ -130,14 +131,14 @@ class JdProductDeleteServiceTest {
@Test
void 被其他商品共用的对象保留不删() {
givenOwnedRows(List.of(11L));
// selectList 依次被调:①商品归属闸 ②图片行取数 ③按 key 反查别的商品的共用性回查
// selectList 依次被调:①商品存在闸 ②图片行取数 ③按 key 反查别的商品的共用性回查
//(回查返回 99 号商品也引用同一 key ⇒ 保留)。
when(jdProductImageMapper.selectList(any()))
.thenReturn(List.of(image(11L, "jd-products/5/shared.jpg")))
.thenReturn(List.of(image(99L, "jd-products/5/shared.jpg")));
when(jdProductRowDeleteService.deleteRows(List.of(11L))).thenReturn(1);
JdProductDeleteVo vo = service.delete(List.of(11L), COMPANY_ID);
JdProductDeleteVo vo = service.delete(List.of(11L));
verify(ossStorageService, never()).removeObject(anyString(), anyString());
assertThat(vo.getObjectsDeleted()).isZero();
@@ -147,17 +148,22 @@ class JdProductDeleteServiceTest {
@Test
@SuppressWarnings("unchecked")
void 越界或缺失的行整批拒绝_不做部分删除() {
// 请求 2 行,归属闸只找到 1 行(另一行不存在/不属于本公司)。
void 存在闸不分公司_缺失的行整批拒绝_不做部分删除() {
// 公共库(2026-11-15 用户定案):存在闸 wrapper 不带 company_id 谓词,任何公司的行都可删。
// 请求 2 行,存在闸只找到 1 行(另一行不存在)⇒ 整批拒绝。
JdProductEntity row = new JdProductEntity();
row.setId(11L);
row.setCompanyId(COMPANY_ID);
when(jdProductMapper.selectList(any(Wrapper.class))).thenReturn(List.of(row));
assertThatThrownBy(() -> service.delete(List.of(11L, 12L), COMPANY_ID))
assertThatThrownBy(() -> service.delete(List.of(11L, 12L)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("本次未删除任何数据");
ArgumentCaptor<Wrapper<JdProductEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(jdProductMapper).selectList(captor.capture());
assertThat(captor.getValue().getSqlSegment()).doesNotContain("company_id");
verify(ossStorageService, never()).removeObject(anyString(), anyString());
verify(jdProductRowDeleteService, never()).deleteRows(any());
}
@@ -169,7 +175,7 @@ class JdProductDeleteServiceTest {
image(11L, "nanri-ai-images/legacy.jpg")));
when(jdProductRowDeleteService.deleteRows(List.of(11L))).thenReturn(1);
JdProductDeleteVo vo = service.delete(List.of(11L), COMPANY_ID);
JdProductDeleteVo vo = service.delete(List.of(11L));
verify(ossStorageService, never()).removeObject(anyString(), anyString());
assertThat(vo.getObjectsSkipped()).isEqualTo(1);
@@ -178,10 +184,10 @@ class JdProductDeleteServiceTest {
@Test
void 空清单与超上限都在入口拒绝() {
assertThatThrownBy(() -> service.delete(List.of(), COMPANY_ID))
assertThatThrownBy(() -> service.delete(List.of()))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("请先选择");
assertThatThrownBy(() -> service.delete(null, COMPANY_ID))
assertThatThrownBy(() -> service.delete(null))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("请先选择");
@@ -189,28 +195,11 @@ class JdProductDeleteServiceTest {
for (long id = 1; id <= JdProductDeleteService.MAX_BATCH + 1; id++) {
tooMany.add(id);
}
assertThatThrownBy(() -> service.delete(tooMany, COMPANY_ID))
assertThatThrownBy(() -> service.delete(tooMany))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("200");
verify(jdProductMapper, times(0)).selectList(any());
verify(jdProductRowDeleteService, never()).deleteRows(any());
}
@Test
@SuppressWarnings("unchecked")
void 非超管按本公司收口_越公司行不可见() {
// scopedCompanyId=5:归属闸 wrapper 带 company_id=5 ⇒ 别家行查不到 ⇒ 整批拒绝。
JdProductEntity row = new JdProductEntity();
row.setId(11L);
row.setCompanyId(6L);
when(jdProductMapper.selectList(any(Wrapper.class))).thenReturn(List.of());
assertThatThrownBy(() -> service.delete(List.of(11L), COMPANY_ID))
.isInstanceOf(BusinessException.class);
ArgumentCaptor<Wrapper<JdProductEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(jdProductMapper).selectList(captor.capture());
assertThat(captor.getValue().getSqlSegment()).contains("company_id");
}
}
@@ -11,7 +11,7 @@ import com.nanri.aiimage.modules.jd.model.entity.JdProductGroupEntity;
import com.nanri.aiimage.modules.jd.model.vo.JdProductGroupVo;
import com.nanri.aiimage.testutil.UpdateWrapperProbe;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
@@ -35,9 +35,10 @@ import static org.mockito.Mockito.when;
/**
* v1.4 Phase 5(R4/AC-8/AC-9):京东商品自定义分组业务规则。
*
* <p>判据:同公司重名拒绝不落库(409)、删除先把商品 group_id 置 NULL 再删分组行
* (事务两步,AC-8)、越公司 id 操作按不存在拒绝(不泄露存在性)、productCount
* 读侧现算统计(分组下拉展示用)。</p>
* <p>判据(2026-11-15 用户定案「分组和亚马逊功能一样」=全平台一份,V200 退键后的服务形状):
* 全局重名拒绝不落库(409)、删除先把商品 group_id 置 NULL 再删分组行(事务两步,AC-8,
* 且脱组谓词不带 company_id)、越界 id 操作按不存在拒绝、company_id 列读写两侧都不再引用
* (新行不带公司,DB DEFAULT 0 兜底)、productCount 读侧现算统计(分组下拉展示用)。</p>
*/
class JdProductGroupServiceTest {
@@ -45,29 +46,30 @@ class JdProductGroupServiceTest {
private final JdProductMapper productMapper = mock(JdProductMapper.class);
private final JdProductGroupService service = new JdProductGroupService(groupMapper, productMapper);
@BeforeEach
void initTableInfo() {
@BeforeAll
static void initTableInfo() {
// 探针要读 LambdaUpdateWrapper 的 SET/WHERE 段:裸单测 JVM 里 lambda 列缓存不初始化就解析不了,
// AccountExpiryServiceTest 同款(无 GlobalConfig 下 underCamel=false,列名归一由探针兜)。
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
JdProductEntity.class);
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, JdProductEntity.class);
TableInfoHelper.initTableInfo(assistant, JdProductGroupEntity.class);
}
// ===================== 新建 =====================
@Test
void 新建同公司重名拒绝且不落库() {
void 新建重名拒绝且不落库() {
when(groupMapper.selectCount(any())).thenReturn(1L);
BusinessException ex = assertThrows(BusinessException.class,
() -> service.create(5L, " 秋冬款 ", 2));
() -> service.create(" 秋冬款 ", 2));
assertEquals(409, ex.getCode(), "重名冲突=409(语义正确的资源冲突码,仓内 DeviceLogService 有先例)");
assertTrue(ex.getMessage().contains("同名分组"), "重名必须给可读文案,不拿 DB 唯一键异常撞 500");
verify(groupMapper, never()).insert(any(JdProductGroupEntity.class));
}
@Test
void 新建成功落公司归属与归一名() {
void 新建成功落归一名与排序且不带公司() {
when(groupMapper.selectCount(any())).thenReturn(0L);
when(groupMapper.insert(any(JdProductGroupEntity.class))).thenAnswer(invocation -> {
JdProductGroupEntity group = invocation.getArgument(0);
@@ -75,25 +77,21 @@ class JdProductGroupServiceTest {
return 1;
});
Long id = service.create(5L, " 秋冬款 ", 2);
Long id = service.create(" 秋冬款 ", 2);
assertEquals(9L, id);
ArgumentCaptor<JdProductGroupEntity> captor = ArgumentCaptor.forClass(JdProductGroupEntity.class);
verify(groupMapper).insert(captor.capture());
JdProductGroupEntity saved = captor.getValue();
assertEquals(5L, saved.getCompanyId(), "归属公司来自隔离正门的 scopedCompanyId,不是请求体");
assertNull(saved.getCompanyId(), "公共库新行不带公司(实体字段不赋值,DB DEFAULT 0=平台公共)");
assertEquals("秋冬款", saved.getName(), "名字 trim 后落库");
assertEquals(2, saved.getSortOrder());
}
@Test
void 新建缺公司或空名直接拒绝() {
// 超管没选公司(scopedCompanyId=null)=分组没有归属公司,直接拒绝。
BusinessException noCompany = assertThrows(BusinessException.class,
() -> service.create(null, "秋冬款", null));
assertEquals(400, noCompany.getCode());
void 新建空名直接拒绝() {
BusinessException blankName = assertThrows(BusinessException.class,
() -> service.create(5L, " ", null));
() -> service.create(" ", null));
assertEquals(400, blankName.getCode());
verifyNoInteractions(groupMapper);
}
@@ -102,7 +100,7 @@ class JdProductGroupServiceTest {
void 新建排序缺省归零() {
when(groupMapper.selectCount(any())).thenReturn(0L);
service.create(5L, "默认排序", null);
service.create("默认排序", null);
ArgumentCaptor<JdProductGroupEntity> captor = ArgumentCaptor.forClass(JdProductGroupEntity.class);
verify(groupMapper).insert(captor.capture());
@@ -112,34 +110,32 @@ class JdProductGroupServiceTest {
// ===================== 改名 =====================
@Test
void 改名越公司id按不存在拒绝() {
JdProductGroupEntity group = groupEntity(1L, 6L, "别家的组");
when(groupMapper.selectById(1L)).thenReturn(group);
void 改名不存在按不存在拒绝() {
when(groupMapper.selectById(1L)).thenReturn(null);
BusinessException ex = assertThrows(BusinessException.class,
() -> service.rename(1L, 5L, "新名字", null));
assertTrue(ex.getMessage().contains("分组不存在"),
"越界 id 与 id 不存在是同一种响应,不泄露跨公司行的存在性");
() -> service.rename(1L, "新名字", null));
assertTrue(ex.getMessage().contains("分组不存在"));
verify(groupMapper, never()).updateById(any(JdProductGroupEntity.class));
}
@Test
void 改名重名拒绝且不落库() {
when(groupMapper.selectById(1L)).thenReturn(groupEntity(1L, 5L, "旧名"));
when(groupMapper.selectById(1L)).thenReturn(groupEntity(1L, "旧名"));
when(groupMapper.selectCount(any())).thenReturn(1L);
BusinessException ex = assertThrows(BusinessException.class,
() -> service.rename(1L, 5L, "已有名", 3));
() -> service.rename(1L, "已有名", 3));
assertEquals(409, ex.getCode());
verify(groupMapper, never()).updateById(any(JdProductGroupEntity.class));
}
@Test
void 改名成功带归一名与排序() {
when(groupMapper.selectById(1L)).thenReturn(groupEntity(1L, 5L, "旧名"));
when(groupMapper.selectById(1L)).thenReturn(groupEntity(1L, "旧名"));
when(groupMapper.selectCount(any())).thenReturn(0L);
service.rename(1L, 5L, " 新名 ", 7);
service.rename(1L, " 新名 ", 7);
ArgumentCaptor<JdProductGroupEntity> captor = ArgumentCaptor.forClass(JdProductGroupEntity.class);
verify(groupMapper).updateById(captor.capture());
@@ -149,10 +145,10 @@ class JdProductGroupServiceTest {
@Test
void 改名排序不传保持原值() {
when(groupMapper.selectById(1L)).thenReturn(groupEntity(1L, 5L, "旧名"));
when(groupMapper.selectById(1L)).thenReturn(groupEntity(1L, "旧名"));
when(groupMapper.selectCount(any())).thenReturn(0L);
service.rename(1L, 5L, "只改名", null);
service.rename(1L, "只改名", null);
ArgumentCaptor<JdProductGroupEntity> captor = ArgumentCaptor.forClass(JdProductGroupEntity.class);
verify(groupMapper).updateById(captor.capture());
@@ -163,29 +159,31 @@ class JdProductGroupServiceTest {
@Test
void 删除先把商品组置NULL再删分组行() {
when(groupMapper.selectById(1L)).thenReturn(groupEntity(1L, 5L, "秋冬款"));
when(groupMapper.selectById(1L)).thenReturn(groupEntity(1L, "秋冬款"));
when(productMapper.update(any(), any(Wrapper.class))).thenReturn(3);
int detached = service.delete(1L, 5L);
int detached = service.delete(1L);
assertEquals(3, detached, "返回实际脱组的商品行数(前端拿它做反馈,不猜)");
ArgumentCaptor<Wrapper<JdProductEntity>> wrapperCaptor = ArgumentCaptor.forClass(Wrapper.class);
verify(productMapper).update(any(), wrapperCaptor.capture());
// 置 NULL 语义必须落在 SET group_id=NULL(商品保留,脱组即「未分组」),且限定本公司该组。
// 置 NULL 语义必须落在 SET group_id=NULL(商品保留,脱组即「未分组」)。
var setValues = UpdateWrapperProbe.setValues(wrapperCaptor.getValue());
assertTrue(setValues.containsKey("group_id") && setValues.get("group_id") == null,
"删除分组必须把商品 group_id 置 NULL(SET group_id=NULL),不是删商品行:实得 " + setValues);
// 公共库:脱组谓词只限定该组,不带 company_id。
var whereEq = UpdateWrapperProbe.whereEq(wrapperCaptor.getValue());
assertEquals(5L, ((Number) whereEq.get("company_id")).longValue(), "脱组必须限定本公司");
assertEquals(1L, ((Number) whereEq.get("group_id")).longValue(), "脱组必须限定该组");
assertTrue(!whereEq.containsKey("company_id"),
"分组公共化后脱组谓词不得再带 company_id:实得 " + whereEq);
verify(groupMapper).deleteById(1L);
}
@Test
void 删除越公司id拒绝且一个字节都不写() {
when(groupMapper.selectById(1L)).thenReturn(groupEntity(1L, 6L, "别家的组"));
void 删除不存在拒绝且一个字节都不写() {
when(groupMapper.selectById(1L)).thenReturn(null);
assertThrows(BusinessException.class, () -> service.delete(1L, 5L));
assertThrows(BusinessException.class, () -> service.delete(1L));
verifyNoInteractions(productMapper);
verify(groupMapper, never()).deleteById(anyLong());
}
@@ -194,22 +192,23 @@ class JdProductGroupServiceTest {
void 删除分组不存在直接拒绝() {
when(groupMapper.selectById(404L)).thenReturn(null);
assertThrows(BusinessException.class, () -> service.delete(404L, null));
assertThrows(BusinessException.class, () -> service.delete(404L));
verifyNoInteractions(productMapper);
}
// ===================== 列表(productCount 统计) =====================
@Test
void 列表按排序返回且productCount现算() {
JdProductGroupEntity first = groupEntity(2L, 5L, "晚出厂");
@SuppressWarnings("unchecked")
void 列表全平台一份不带公司谓词且productCount现算() {
JdProductGroupEntity first = groupEntity(2L, "晚出厂");
first.setSortOrder(0);
JdProductGroupEntity second = groupEntity(1L, 5L, "早出厂");
JdProductGroupEntity second = groupEntity(1L, "早出厂");
second.setSortOrder(1);
when(groupMapper.selectList(any())).thenReturn(List.of(first, second));
when(productMapper.selectCount(any())).thenReturn(12L, 0L);
List<JdProductGroupVo> items = service.list(5L);
List<JdProductGroupVo> items = service.list();
assertEquals(2, items.size());
assertEquals("晚出厂", items.get(0).getName(), "selectList 的排序由 wrapper 决定,服务不重排");
@@ -218,24 +217,20 @@ class JdProductGroupServiceTest {
assertEquals(1, items.get(1).getSortOrder());
verify(productMapper, times(2)).selectCount(any());
assertNotNull(items.get(0).getCreatedAt());
}
@Test
void 列表超管不选公司查全量() {
when(groupMapper.selectList(any())).thenReturn(List.of());
List<JdProductGroupVo> items = service.list(null);
assertTrue(items.isEmpty());
verify(groupMapper).selectList(any());
// 公共库:列表 wrapper 不带 company_id 谓词(历史行的 company_id 只是溯源标记)。
ArgumentCaptor<Wrapper<JdProductGroupEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(groupMapper).selectList(captor.capture());
assertTrue(!captor.getValue().getSqlSegment().contains("company_id"),
"分组列表不得再按公司过滤(2026-11-15 公共化):实得 " + captor.getValue().getSqlSegment());
}
// ---------------------------------------------------------------- 助手
private static JdProductGroupEntity groupEntity(long id, long companyId, String name) {
private static JdProductGroupEntity groupEntity(long id, String name) {
JdProductGroupEntity group = new JdProductGroupEntity();
group.setId(id);
group.setCompanyId(companyId);
group.setCompanyId(5L);
group.setName(name);
group.setSortOrder(3);
group.setCreatedAt(LocalDateTime.of(2026, 11, 14, 10, 0));
@@ -42,9 +42,9 @@ import static org.mockito.Mockito.when;
/**
* 后管「编辑京东商品」编排判据(PUT /api/admin/jd-products/{id},2026-11-15 用户口径)。
*
* <p>钉六件事:①归属闸(越界 id 按不存在拒绝,零写);②主字段全量保存即置人工编辑锁
* <p>钉六件事:①存在闸(行不存在按不存在拒绝,零写;公共库无公司维度);②主字段全量保存即置人工编辑锁
* {@code manual_locked=1}(V199——没有这个锁,编辑会被下一次采集 upsert 覆盖回去);
* ③分组归属校验(跨公司挂组拒绝);④属性重建只覆写 attr_json 的 {@code tabs} 段、
* ③分组存在校验(分组 2026-11-15 起全平台一份,挂组只认存在性);④属性重建只覆写 attr_json 的 {@code tabs} 段、
* images/productCode 等其它顶层键原样保留(铁律 30 形状),原文形状不识别时拒绝而不是静默重写;
* ⑤SKU 按 (productId, skuId) 匹配改价改库存,缺失 skuId 拒绝;⑥删图=先删桶、共用对象保留、
* image_count 按表实数刷新。</p>
@@ -124,18 +124,19 @@ class JdProductUpdateServiceTest {
// ---------- 判据 ----------
@Test
void 归属闸_越界或不存在按不存在拒绝且零写() {
void 行不存在按不存在拒绝_公共库跨公司行可编辑() {
// 公共库(2026-11-15 用户定案):行存在即可编辑,company_id 只是同步来源标记。
JdProductEntity otherCompany = productRow();
otherCompany.setCompanyId(99L);
when(jdProductMapper.selectById(PRODUCT_ID)).thenReturn(otherCompany);
when(jdProductMapper.update(isNull(), any(Wrapper.class))).thenReturn(1);
assertThat(service.update(PRODUCT_ID, mainFieldsOnly())).isEqualTo(PRODUCT_ID);
assertThatThrownBy(() -> service.update(PRODUCT_ID, mainFieldsOnly(), COMPANY_ID))
// 行不存在 ⇒ 按不存在拒绝,零写。
when(jdProductMapper.selectById(PRODUCT_ID)).thenReturn(null);
assertThatThrownBy(() -> service.update(PRODUCT_ID, mainFieldsOnly()))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("商品不存在");
verify(jdProductMapper, never()).update(isNull(), any(Wrapper.class));
assertThatThrownBy(() -> service.update(PRODUCT_ID, mainFieldsOnly(), COMPANY_ID))
.isInstanceOf(BusinessException.class);
}
@Test
@@ -143,7 +144,7 @@ class JdProductUpdateServiceTest {
givenOwnedRow();
when(jdProductMapper.update(isNull(), any(Wrapper.class))).thenReturn(1);
Long id = service.update(PRODUCT_ID, mainFieldsOnly(), COMPANY_ID);
Long id = service.update(PRODUCT_ID, mainFieldsOnly());
assertThat(id).isEqualTo(PRODUCT_ID);
Map<String, Object> values = capturedSetValues();
@@ -159,19 +160,27 @@ class JdProductUpdateServiceTest {
}
@Test
void 分组必须属于本公司() {
void 分组必须存在_公共组无公司维度() {
givenOwnedRow();
JdProductUpdateRequest body = mainFieldsOnly();
body.setGroupId(7L);
// 分组 2026-11-15 起全平台一份:别家时代建的组(company_id=99)照样能挂。
JdProductGroupEntity group = new JdProductGroupEntity();
group.setId(7L);
group.setCompanyId(99L);
when(jdProductGroupMapper.selectById(7L)).thenReturn(group);
when(jdProductMapper.update(isNull(), any(Wrapper.class))).thenReturn(1);
assertThat(service.update(PRODUCT_ID, body)).isEqualTo(PRODUCT_ID);
assertThatThrownBy(() -> service.update(PRODUCT_ID, body, COMPANY_ID))
// 分组不存在 ⇒ 拒绝且零写。
JdProductUpdateRequest ghost = mainFieldsOnly();
ghost.setGroupId(404L);
when(jdProductGroupMapper.selectById(404L)).thenReturn(null);
assertThatThrownBy(() -> service.update(PRODUCT_ID, ghost))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("分组不存在或不属于当前公司");
verify(jdProductMapper, never()).update(isNull(), any(Wrapper.class));
.hasMessageContaining("分组不存在");
// update 只剩成功挂组那 1 次:ghost 分支零写点(同用例前半段已成功写过一次,不能按 never 数)。
verify(jdProductMapper, org.mockito.Mockito.times(1)).update(isNull(), any(Wrapper.class));
}
@Test
@@ -188,7 +197,7 @@ class JdProductUpdateServiceTest {
group.setAttrs(List.of(attr));
body.setAttrGroups(List.of(group));
service.update(PRODUCT_ID, body, COMPANY_ID);
service.update(PRODUCT_ID, body);
Map<String, Object> values = capturedSetValues();
// 新 JSON 里有重建后的 tabs(新属性值落进去了),且 images/productCode 原样保留(铁律 30)
@@ -206,7 +215,7 @@ class JdProductUpdateServiceTest {
JdProductUpdateRequest body = mainFieldsOnly();
body.setAttrGroups(List.of(new JdProductUpdateRequest.AttrGroupDto()));
assertThatThrownBy(() -> service.update(PRODUCT_ID, body, COMPANY_ID))
assertThatThrownBy(() -> service.update(PRODUCT_ID, body))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("属性原文形状不识别");
verify(jdProductMapper, never()).update(isNull(), any(Wrapper.class));
@@ -228,7 +237,7 @@ class JdProductUpdateServiceTest {
edit.setPrice(new BigDecimal("199.00"));
edit.setStock(88);
body.setSkus(List.of(edit));
service.update(PRODUCT_ID, body, COMPANY_ID);
service.update(PRODUCT_ID, body);
ArgumentCaptor<Wrapper<JdProductSkuEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(jdProductSkuMapper).update(isNull(), captor.capture());
@@ -242,7 +251,7 @@ class JdProductUpdateServiceTest {
ghost.setSkuId("ghost-sku");
ghost.setPrice(BigDecimal.ONE);
bad.setSkus(List.of(ghost));
assertThatThrownBy(() -> service.update(PRODUCT_ID, bad, COMPANY_ID))
assertThatThrownBy(() -> service.update(PRODUCT_ID, bad))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("SKU 行不存在");
}
@@ -266,14 +275,14 @@ class JdProductUpdateServiceTest {
JdProductUpdateRequest body = mainFieldsOnly();
body.setDeleteImageIds(List.of(1L, 2L));
assertThatThrownBy(() -> service.update(PRODUCT_ID, body, COMPANY_ID))
assertThatThrownBy(() -> service.update(PRODUCT_ID, body))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("本次未删除任何数据");
// 修正归属:只删 1L;同 key 被别的商品引用 ⇒ 对象保留、只删登记行、计数刷新
JdProductUpdateRequest fixed = mainFieldsOnly();
fixed.setDeleteImageIds(List.of(1L));
service.update(PRODUCT_ID, fixed, COMPANY_ID);
service.update(PRODUCT_ID, fixed);
verify(ossStorageService, never()).removeObject(eq("jd-products"), eq("jd-products/5/aaa.jpg"));
verify(jdProductImageMapper).delete(any(Wrapper.class));
@@ -288,13 +297,13 @@ class JdProductUpdateServiceTest {
JdProductUpdateRequest badPrice = mainFieldsOnly();
badPrice.setPriceMin(new BigDecimal("100"));
badPrice.setPriceMax(new BigDecimal("50"));
assertThatThrownBy(() -> service.update(PRODUCT_ID, badPrice, COMPANY_ID))
assertThatThrownBy(() -> service.update(PRODUCT_ID, badPrice))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("价格区间下限不能大于上限");
JdProductUpdateRequest badStock = mainFieldsOnly();
badStock.setStockTotal(-1);
assertThatThrownBy(() -> service.update(PRODUCT_ID, badStock, COMPANY_ID))
assertThatThrownBy(() -> service.update(PRODUCT_ID, badStock))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("总库存不能为负数");
verify(jdProductMapper, never()).update(isNull(), any(Wrapper.class));