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 不带这一列)。
-- =============================================================