feat(菜单权限): 每家公司一套菜单树(V149)+ 公司 tab 只在注册表页渲染

本批两件事,加上随本批一起入仓的并行会话在制品:

一、菜单权限按公司隔离(批次 6)
- V149 给 columns 加 company_id:先可空加列(末位、ALGORITHM=INSTANT)→ 回填公司 1 →
  MODIFY 收紧 NOT NULL;三段式缺一即撞 1048。同时建 (company_id, column_key) 复合键、
  把公司 2 的 16 笔授权按 column_key 改指向它自己的副本,三类 menu_type 全复制,
  admin_companies 作为角色内生闸门行不复制(D3)。
- 第三道归属门 PermissionMenuService.resolveScopeCompanyId:站点超管可带 company_id
  读写任意公司,非超管锁本公司、越界 403。它注册进 CompanyIdParamGoesThroughReadScopeTest
  的 SCOPE_DOORS,四条判据与 readScope / readCompanyIdOrOwn 共用——护栏在代码出口,不靠清单。
- 旁路种子 PermissionMenuSchemaInitializer 只种公司 1:31 段种子逐条钉公司,
  按 column_key 点查的 14 段全部带 company_id,否则摘了 DEFAULT 就是跨公司串写。
- CompanyService.create 同一次写入里给新公司复制模板树(D4)。

二、公司 tab 收口(批次 b)
tab 条挂在壳层,对 22 页全画;改为按正列表 companyTabAppliesTo(menuKey) 判定,
只有注册表页渲染。护栏钉在用户看见的那个出口。

三、并行会话在制品(控制方「全部提交」,未单独拆分——见下)
- V150 店铺密钥 biz_shop_key 按公司(readCompanyIdOrOwn + writeCompanyId 两道门)
- V151 品牌库/商品类目推翻为全平台共享:只退唯一键、company_id DEFAULT 保留为
  NOT NULL 承重约束(摘了每条 1364);删掉 ProductCategoryControllerCompanyScopeTest
  那支"按公司隔离"的旧护栏,readCompanyId 方法一并移除
- invalidasin 字段与外观专利合批的连带改动

为什么不拆笔:后端 3891 例 / 0 红、前端 1731 例 / 0 红这两个读数是"合起来的树"的读数,
拆成多笔会让每一笔落到从未一起验过的组合上,而这一版要直接上两台。

回滚脚本在 backend-java/docs/rollback-V149/V150/V151-*.sql,不放进 Flyway 扫描路径。
设计记录:docs/ops/menu-company-tree-design-2026-10-06.md
This commit is contained in:
2026-10-06 17:17:14 +08:00
parent e635fa8dcd
commit b7acfc0eef
84 changed files with 5118 additions and 1421 deletions
@@ -41,37 +41,21 @@ public class DataReadScope {
}
/**
* 归属已经**物化成 company_id 列**的表(品牌库 biz_invalid_asin_data)用的谓词出口:
* 返回要筛的公司 id,null = 不筛。
* 归属物化成 {@code company_id} 列、<b>且可见集不靠账号/分组</b>的表用的谓词出口。
*
* <p>这些表不能走 {@link #readScope} 的账号集合:2026-10-05 生产只读取证,品牌库 14,801 行里
* {@code uploader_user_id} 非空的有 <b>0</b> 行(实体没这字段、批量 INSERT 的列清单也没带,
* V145 补的列一直是空的),按账号筛等于把全部历史从每一个公司 tab 里静默删掉。
* 而 {@code company_id} 那一列虽然是被 DEFAULT 1 盖上去的,对历史却是诚实的:
* 第 2 家公司 10-04 14:55 才开通,它名下账号历史任务 0 条、去重库上传 0 行,
* 所以「建号之前存在的行都归第 1 家」是可证的事实,不是猜。</p>
* <p>今天的消费者是「店铺密钥」{@code biz_shop_key}(V150 起每公司一套)。
* <b>品牌库与商品类目不走这里</b>:控制方 2026-10-06 点名这两页"做成所有公司共享的,不区分",
* 它们的 {@code company_id} 列只剩 V145/V147 留下的历史值,读写两侧都不引用
* (唯一键退回全局见 {@code V151__rule_tables_shared_across_companies.sql})。
* 谁要给它们再接一个公司开关,得先推翻那一条定案。</p>
*
* <p>非超管返回 null(不筛):他们的可见集本来就锁在自己的分组上,叠一层公司会把
* 「靠分组可见」的行整批删掉(同 {@code ShopManageController} 的口径)。
* 超管的 company_id 是视图开关不是安全边界(spec §4),所以这里不需要再校验它属于谁。</p>
*/
public Long readCompanyId(AdminUserEntity operator, Long requestedCompanyId) {
if (!SUPER_ADMIN.equals(adminAuthSupport.currentRole(operator))) {
return null;
}
return requestedCompanyId != null && requestedCompanyId > 0 ? requestedCompanyId : null;
}
/**
* 第三道门:归属物化成 {@code company_id} 列、<b>且可见集不靠账号/分组</b>的表(商品类目)。
* <p>"不靠账号/分组"是这一道门存在的理由:可见集若无账号/分组谓词兜住,返回 null 等于
* 把整张表交给每一家(2026-10-06 逐节点复验实测:公司 2 的 admin 读该页得 412 行,
* 其中 394 行是公司 1 的资产)。若某页的可见集本来就锁在自己的分组/账号上,走
* {@link #readScope} 即可,非超管在这里再叠一层公司会把那些行整批删掉。</p>
*
* <p>与 {@link #readCompanyId} 只差非超管那一支。差别不是省事,是那张表没有可以保护的东西:
* 品牌库的"非超管不筛"靠的是账号/分组谓词兜住可见集,而 {@code biz_product_category}
* 连账号列都没有(V147 才加的 {@code company_id})。返回 null 在这里等于把整棵树交给每一家——
* 2026-10-06 逐节点复验实测:公司 2 的 admin 读该页得 412 行,其中 394 行是公司 1 的自建类目。</p>
*
* <p>非超管<b>钉在本公司</b>而不是"带别家就返回空":类目树里没有"空树"这个可用视图——
* 内置节点(哨兵 0)在任何公司视图里都必须在,否则那一家装不上任何自建子级。
* <p>非超管<b>钉在本公司</b>而不是"带别家就返回空":返回空是一个<b>可用视图</b>而不是错误,
* 而 {@code create} 的 {@code parentId = null} / 空清单让那一家能从零自建。
* 请求里带什么都不算,与 {@code readScope} 非超管分支同一口径(tab 不是安全边界)。</p>
*/
public Long readCompanyIdOrOwn(AdminUserEntity operator, Long requestedCompanyId) {
@@ -85,8 +69,11 @@ public class DataReadScope {
* 写侧的行级归属闸门要的值:{@code null} = 平台超管不限,其余账号一律是自己那一家。
*
* <p>读侧收窄而写侧不收窄,等于"藏起来的行仍然能删"——那是静默删除,不是隔离。
* 返回值直接交给 service 与<b>行自己的</b> {@code company_id} 比(不是与 tab 比:
* 内置行归哨兵 0,任何公司账号都不该改得动它)。</p>
* 返回值直接交给 service 与<b>行自己的</b> {@code company_id} 比(不是与 tab 比)。
* 今天的消费者与 {@link #readCompanyIdOrOwn} 同一批(店铺密钥)。
* <b>商品类目已经不走这里</b>:那页的 {@code assertRowWritable}(含按 {@code is_builtin}
* 拦内置节点的那一刀)随 2026-10-06「类目全平台共享、谁都能改整棵树」的定案一起删掉了,
* 内置节点现在对任何管理员可改可删——这是控制方点名的口径,不是漏改。</p>
*/
public Long writeCompanyId(AdminUserEntity operator) {
return SUPER_ADMIN.equals(adminAuthSupport.currentRole(operator))
@@ -7,6 +7,7 @@ import com.nanri.aiimage.config.AppearancePatentProperties;
import com.nanri.aiimage.config.HttpClientPool;
import com.nanri.aiimage.metrics.ExternalCallMetricsRecorder;
import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentResultRowDto;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentSheetBuilder;
import com.nanri.aiimage.modules.brand.client.BrandCheckClient;
import com.nanri.aiimage.modules.usersecret.service.UserSecretUsageService;
import com.nanri.aiimage.modules.usersecret.support.SecretUsageContext;
@@ -1064,7 +1065,11 @@ public class AppearancePatentLlmClient {
return NO_INFRINGEMENT;
}
if (isBrandQueryFailed(titleRisk)) {
return BRAND_QUERY_FAILED;
// 外观已经判出「无侵权」时别把它整格盖掉:这一行缺的只是商标那一维,
// 结论要说「外观无侵权·商标待复核」,用户才不会把已判出的外观结论读成"整单没检测"。
return isNoInfringement(appearanceRisk)
? "外观" + normalize(appearanceRisk) + AppearancePatentSheetBuilder.PENDING_REVIEW_SUFFIX
: BRAND_QUERY_FAILED;
}
return firstNonBlank(fallbackConclusion, "");
}
@@ -51,6 +51,13 @@ public final class AppearancePatentSheetBuilder {
*/
public static final String NO_RESULT_TEXT = "未取得检测结果";
/**
* 结论列上「外观已判定、商标那一维没核上」的标记。
* <p>放在这里而不是客户端里:结论是这里写的、状态列也是这里判的,
* 两处共用一个字面量才不会各写各的(历史上「结论写着查询失败、状态写着成功」就是这么来的)。
*/
public static final String PENDING_REVIEW_SUFFIX = "·商标待复核";
private static final String NO_RESULT_REASON = NO_RESULT_TEXT + ":该行没有返回判定,重新运行任务可补检";
public static void buildResultSheet(Workbook workbook, List<AppearancePatentParsedRowVo> rows,
@@ -261,12 +268,17 @@ public final class AppearancePatentSheetBuilder {
* 两者都含「侵权」二字;而「商标查询失败」(品牌检测上游查询失败)、「外观识别异常」、
* LLM 技术性失败、空白都表示这一行没得出完整结论,一律判「失败」。
* 历史缺陷:曾按「结论非空即成功」,于是结论列写着"商标查询失败"、状态列却写"成功"。
* 带 {@link #PENDING_REVIEW_SUFFIX} 的结论含「侵权」二字,必须排在字面判定之前判掉,
* 否则「外观无侵权·商标待复核」会被读成成功。
*/
public static String resolveResultStatus(String conclusion) {
String normalized = conclusion == null ? "" : conclusion.trim();
if (normalized.isBlank() || isTechnicalLlmFailure(normalized)) {
return "失败";
}
if (normalized.contains(PENDING_REVIEW_SUFFIX)) {
return "失败";
}
return normalized.contains("侵权") ? "成功" : "失败";
}
@@ -1,6 +1,5 @@
package com.nanri.aiimage.modules.collectdata.util;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.collectdata.model.vo.CollectDataResultRowVo;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.entity.InvalidAsinDataEntity;
@@ -16,52 +15,39 @@ import java.util.regex.Pattern;
/**
* invalid ASIN 批量写入器:把不合规 ASIN 行按批次批量 INSERT IGNORE 写入
* biz_invalid_asin_data,替代逐行 insert + 捕获唯一键异常的旧路径。
* 幂等由唯一键 (company_id, data_value, brand) + INSERT IGNORE 语义保证;批量失败时
* 幂等由唯一键 (data_value, brand) + INSERT IGNORE 语义保证;批量失败时
* 跳过该批(记录计数,不中断提交流程),恢复后继续后续批次。
* 空输入、无合法 data_value/brand 的行、null 行均安全跳过,不发起调用。
*
* <p>归属(company_id + uploader_user_id)由调用方给任务发起账号,本类负责推公司:
* 此前实体与 INSERT 列清单都不带这两列,V145 补的 company_id 全靠 DEFAULT 1 盖,
* 于是第 2 家公司跑货源产生的行会被记成第 1 家,且事后分不开。</p>
* <p>这一张黑名单是<b>全平台共享的,不按公司区分</b>(控制方 2026-10-06 定案)。
* {@code uploader_user_id} 只记"哪个账号采出来的",推不出账号也照写:
* 少一条黑名单 = 下次同样的品牌再买一次代理,而归属记不上不影响任何人看数据。</p>
*/
@Slf4j
@Component
public class CollectDataInvalidAsinBatchWriter {
/** 巡检可 grep 的标记:账号已不存在、推不出公司,这批 rejected 品牌整批不写。 */
static final String OWNER_UNRESOLVED_MARKER = "INVALID_ASIN_OWNER_UNRESOLVED";
private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\s+");
private final InvalidAsinDataMapper invalidAsinDataMapper;
private final CompanyScopeSupport companyScopeSupport;
private final int batchSize;
public CollectDataInvalidAsinBatchWriter(InvalidAsinDataMapper invalidAsinDataMapper,
CompanyScopeSupport companyScopeSupport,
@Value("${aiimage.collect-data.invalid-asin-batch-size:100}") int batchSize) {
this.invalidAsinDataMapper = invalidAsinDataMapper;
this.companyScopeSupport = companyScopeSupport;
this.batchSize = Math.max(1, batchSize);
}
/**
* 批量写入并返回实际尝试写入的行数(INSERT IGNORE 忽略重复,幂等)。
*
* @param uploaderUserId 任务发起账号(biz_file_task.user_id);推不出公司时整批不写并打
* {@link #OWNER_UNRESOLVED_MARKER}——宁可少记一条黑名单,
* 也不把行盖成别家公司(那会让另一家的正常品牌被静默过滤)
* @param uploaderUserId 任务发起账号(biz_file_task.user_id);可为 null(账号已删),
* 只影响这一列记不记得上,不影响写不写得进
*/
public int writeBatch(List<CollectDataResultRowVo> rows, Long uploaderUserId) {
if (rows == null || rows.isEmpty()) {
return 0;
}
Long companyId = companyScopeSupport.companyIdOrNull(uploaderUserId);
if (companyId == null) {
log.warn("{} 无法按账号推出处置公司,本批不写入无效品牌表 rows={} userId={}",
OWNER_UNRESOLVED_MARKER, rows.size(), uploaderUserId);
return 0;
}
int written = 0;
for (int start = 0; start < rows.size(); start += batchSize) {
int end = Math.min(start + batchSize, rows.size());
@@ -70,7 +56,6 @@ public class CollectDataInvalidAsinBatchWriter {
for (CollectDataResultRowVo row : batch) {
InvalidAsinDataEntity entity = toEntity(row);
if (entity != null) {
entity.setCompanyId(companyId);
entity.setUploaderUserId(uploaderUserId);
entities.add(entity);
}
@@ -24,6 +24,10 @@ import java.util.Map;
* 所以这里探的是【清单】而不是单个列名。清单与探针 SQL 的 IN 列表由 {@code CompanyDefaultGuardTest}
* 双向钉同源:只钉"清单里的都在 SQL 里"会漏掉"SQL 里有、清单漏了"那一半,而那一半才是静默的形状。</p>
*
* <p>清单也会随口径<b>缩短</b>:{@code biz_invalid_asin_data} 与 {@code biz_product_category}
* 已按 2026-10-06「这两页全平台共享」的定案一起摘掉,理由见 {@link #WATCHED_TABLES}——
* 对一张不再分公司写行的表喊"去摘 DEFAULT",会把一个无人报错的遗留列变成一次真故障(1364)。</p>
*
* <p>标记串({@link #ALARM} / {@link #PROBE_FAILED})是纯 ASCII:巡检脚本要在 docker logs 里
* grep 它,中文一旦在容器里变了编码就整条签名失效。</p>
*/
@@ -41,17 +45,31 @@ public class CompanyDefaultGuard {
/**
* 该带 company_id 且历史上可能被塞过 DEFAULT 的表。新增一列就要在这里登记一条——
* 漏登记的后果不是报错,是哨兵对着一个不存在的列一声不响({@link #check} 会把它当探不到处理)。
* V147 的 {@code biz_product_category} 是第四条:它的 DEFAULT 1 同样只为同批旧 jar 存在,
* 摘除动作与上面三张同形(一条元数据操作,禁 MODIFY)。
*
* <p><b>登记表里只能放"仍然按公司写"的表</b>,这一条比上一句更容易踩。
* {@code biz_invalid_asin_data}(V145)与 {@code biz_product_category}(V147)已经在
* 2026-10-06「品牌数据库/商品类目做成所有公司共享」的定案里一并摘掉:它们的 {@code company_id}
* 现在没有任何读写路径引用,靠 {@code DEFAULT 1} 满足 {@code NOT NULL}。此时喊
* {@code COMPANY_DEFAULT_STILL_PRESENT} 并让人去执行本类给出的 {@code DROP DEFAULT},
* 后果不是"修好了"而是每一次写入报 1364——品牌库那条还会被
* {@code CollectDataInvalidAsinBatchWriter} 吞成 warn ⇒ 接口成功而黑名单静默少一批。
* 这两列的 DEFAULT 由下一版的 {@code DROP COLUMN} 一并带走(见 docs/migration-inventory.md)。</p>
*
* <p>V147 的 {@code biz_product_category} 曾是第三条、V150 的 {@code biz_shop_key} 是第五条:
* 加它们时用的是同一条理由,摘它们时也必须是同一条理由——"这张表还分公司吗"是唯一判据。</p>
*
* <p>V149 的 {@code columns} 方向相反,是【加进来】的一条:菜单树如今真的按公司写(每家公司一套),
* 它的 {@code DEFAULT 1} 只为同批的旧 jar 存在(旧实体没有 companyId,insert 整列跳过会报 1364)。
* 新 jar 的每个建/改菜单出口都显式落公司,此后留着默认值的后果是"忘了传公司的行静默归第 1 家",
* 与上面那两条"没人读的列"不同 —— 判据仍是同一句:这张表还分公司吗。</p>
*/
static final List<String> WATCHED_TABLES = List.of(
"users", "biz_invalid_asin_data", "biz_dedupe_total_data", "biz_product_category");
"users", "biz_dedupe_total_data", "biz_shop_key", "columns");
private static final String COLUMN_DEFAULT_SQL = """
SELECT TABLE_NAME, COLUMN_DEFAULT FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = DATABASE() AND COLUMN_NAME = 'company_id'
AND TABLE_NAME IN ('users', 'biz_invalid_asin_data', 'biz_dedupe_total_data',
'biz_product_category')
AND TABLE_NAME IN ('users', 'biz_dedupe_total_data', 'biz_shop_key', 'columns')
""";
private final CompanyMapper companyMapper;
@@ -7,8 +7,10 @@ import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.dto.CompanySaveRequest;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.Collection;
@@ -31,6 +33,7 @@ public class CompanyService {
private final CompanyMapper companyMapper;
private final AdminAuthSupport adminAuthSupport;
private final PermissionMenuService permissionMenuService;
/** 建号指定的公司必须真实存在且启用:否则账号挂在查不到的公司上,按公司筛选时整体失明。 */
public CompanyEntity requireActive(Long companyId) {
@@ -104,7 +107,14 @@ public class CompanyService {
return company.getCompanyName();
}
/** 新增公司:只有超管能建,一期也只有超管需要建(开通第二家公司是人工动作)。 */
/**
* 新增公司:只有超管能建,一期也只有超管需要建(开通第二家公司是人工动作)。
*
* <p>事务包住两件事:插公司行 + 给它复制一套菜单树。每家公司一棵树之后,零菜单行的租户
* 表现是"那家账号侧边栏全空"且不报错,所以建树不能留成上线后的人工动作;
* 复制失败必须连公司行一起回滚,不留半成品。</p>
*/
@Transactional
public CompanyEntity create(AdminUserEntity operator, CompanySaveRequest request) {
ensureSuperAdmin(operator);
String companyName = requireValidName(request.getCompanyName());
@@ -117,6 +127,7 @@ public class CompanyService {
entity.setStatus(status);
entity.setRemark(remark);
companyMapper.insert(entity);
permissionMenuService.copyTreeFromTemplate(entity.getId(), operator.getCompanyId());
return entity;
}
@@ -3,7 +3,6 @@ package com.nanri.aiimage.modules.invalidasin.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataCreateRequest;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataUpdateRequest;
import com.nanri.aiimage.modules.invalidasin.model.vo.InvalidAsinDataItemVo;
@@ -39,7 +38,7 @@ import java.security.MessageDigest;
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/admin/invalid-asin-data")
@Tag(name = "不符合ASIN数据", description = "维护不符合ASIN数据列表,支持增删改查。")
@Tag(name = "品牌数据库", description = "维护品牌数据库(不符合规则的 ASIN / 品牌)列表,支持增删改查。全平台共享,不按公司区分。")
public class InvalidAsinDataController {
private static final String INVALID_ASIN_DATA_COLUMN_KEY = "admin_invalid_asin_data";
@@ -50,10 +49,9 @@ public class InvalidAsinDataController {
private final InvalidAsinDataService invalidAsinDataService;
private final AdminAuthSupport adminAuthSupport;
private final PermissionMenuService permissionMenuService;
private final DataReadScope dataReadScope;
@GetMapping
@Operation(summary = "分页查询不符合ASIN数据", description = "分页查询不符合ASIN数据,支持按 ASIN/品牌 模糊搜索。")
@Operation(summary = "分页查询品牌数据库", description = "分页查询品牌数据库(全平台共享,不按公司区分),支持按 ASIN/品牌 模糊搜索。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "查询成功", content = @Content(schema = @Schema(implementation = InvalidAsinDataPageVo.class)))
})
@@ -64,18 +62,14 @@ public class InvalidAsinDataController {
@Parameter(description = "ASIN 模糊搜索") @RequestParam(name = "data_value", required = false) String dataValue,
@Parameter(description = "品牌模糊搜索") @RequestParam(name = "brand", required = false) String brand,
@Parameter(description = "分组 ID") @RequestParam(name = "group_id", required = false) Long groupId,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
RequestOperator operator = requireInvalidAsinDataAccess(request);
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId);
return ApiResponse.success(invalidAsinDataService.page(
page, pageSize, keyword, dataValue, brand, groupId, operator.id(), operator.superAdmin(),
scopedCompanyId));
page, pageSize, keyword, dataValue, brand, groupId, operator.id(), operator.superAdmin()));
}
@PostMapping
@Operation(summary = "新增不符合ASIN数据", description = "新增一条不符合ASIN数据。")
@Operation(summary = "新增品牌数据库记录", description = "新增一条品牌数据库记录(全平台共享)。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "创建成功", content = @Content(schema = @Schema(implementation = InvalidAsinDataItemVo.class))),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "400", description = "参数不合法或数据重复")
@@ -89,7 +83,7 @@ public class InvalidAsinDataController {
}
@PutMapping("/{id}")
@Operation(summary = "更新不符合ASIN数据", description = "按 ID 更新一条不符合ASIN数据。")
@Operation(summary = "更新品牌数据库记录", description = "按 ID 更新一条品牌数据库记录。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "更新成功", content = @Content(schema = @Schema(implementation = InvalidAsinDataItemVo.class))),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "400", description = "参数不合法或数据重复"),
@@ -105,7 +99,7 @@ public class InvalidAsinDataController {
}
@DeleteMapping("/{id}")
@Operation(summary = "删除不符合ASIN数据", description = "按 ID 删除一条不符合ASIN数据。")
@Operation(summary = "删除品牌数据库记录", description = "按 ID 删除一条品牌数据库记录。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "删除成功"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "404", description = "数据不存在")
@@ -127,7 +121,7 @@ public class InvalidAsinDataController {
if (!superAdmin && !hasInvalidAsinDataPermission(operator)) {
throw new BusinessException(403, "无权访问品牌数据库");
}
return new RequestOperator(operator.getId(), superAdmin, operator);
return new RequestOperator(operator.getId(), superAdmin);
}
private AdminUserEntity resolveOperator(HttpServletRequest request) {
@@ -170,7 +164,7 @@ public class InvalidAsinDataController {
private record RequestOperator(Long id, boolean superAdmin, AdminUserEntity user) {
private record RequestOperator(Long id, boolean superAdmin) {
}
private boolean isTrustedInternalRequest(String suppliedToken) {
return adminAuthSupport.isTrustedSuppliedToken(suppliedToken);
@@ -12,22 +12,26 @@ import java.util.List;
public interface InvalidAsinDataMapper extends BaseMapper<InvalidAsinDataEntity> {
/**
* 批量 INSERT IGNORE:命中唯一键 (company_id, data_value, brand) 的重复行静默跳过,幂等。
* 批量 INSERT IGNORE:命中唯一键 (data_value, brand) 的重复行静默跳过,幂等。
* created_at/updated_at 不显式写入:依赖列的 DEFAULT CURRENT_TIMESTAMP。
* 显式传 null 会绕过默认值,在宽松 SQL 模式下落为 '0000-00-00 00:00:00',
* 随后在 NO_ZERO_DATE 模式(生产已启用)下读取即报 Zero date value prohibited。
*
* <p>company_id 与 uploader_user_id 由调用方填好:company_id 是 NOT NULL,
* 这一列显式传 null 不会走 DEFAULT 1,而是直接报错(上面 created_at 那段说的正是这类列的
* "宽松模式才静默"),所以归属推不出来时调用方必须整批不写,而不是塞 null 进来。</p>
* <p>列清单里<b>没有</b> company_id:品牌数据库全平台共享,归属不参与幂等(控制方 2026-10-06 定案)。
* 库里那一列带 {@code DEFAULT 1} 且仍 NOT NULL,所以省略它安全;反过来<b>显式传 null 会直接报错</b>
* (上面 created_at 那段说的正是这类列的"宽松模式才静默")。</p>
*
* <p>uploader_user_id 可空,jdbcType 必须写:任务账号已被删时这一列就是 null,
* 不告诉 MyBatis 类型它会抛 "Error setting null parameter",而调用方把异常吞成 log.warn,
* 于是整批黑名单静默丢掉。</p>
*/
@Insert("""
<script>
INSERT IGNORE INTO biz_invalid_asin_data
(data_value, brand, record_source, company_id, uploader_user_id)
(data_value, brand, record_source, uploader_user_id)
VALUES
<foreach collection="rows" item="row" separator=",">
(#{row.dataValue}, #{row.brand}, #{row.recordSource}, #{row.companyId}, #{row.uploaderUserId})
(#{row.dataValue}, #{row.brand}, #{row.recordSource}, #{row.uploaderUserId,jdbcType=BIGINT})
</foreach>
</script>
""")
@@ -7,7 +7,7 @@ import jakarta.validation.constraints.Size;
import lombok.Data;
@Data
@Schema(description = "不符合ASIN数据新增请求")
@Schema(description = "品牌数据库新增请求")
public class InvalidAsinDataCreateRequest {
@NotBlank(message = "ASIN 不能为空")
@@ -6,7 +6,7 @@ import jakarta.validation.constraints.Size;
import lombok.Data;
@Data
@Schema(description = "不符合ASIN数据更新请求")
@Schema(description = "品牌数据库更新请求")
public class InvalidAsinDataUpdateRequest {
@NotBlank(message = "ASIN 不能为空")
@@ -9,6 +9,16 @@ import lombok.Data;
import java.time.LocalDateTime;
/**
* 品牌数据库(不符合 ASIN / 品牌黑名单)——<b>全平台共享,不按公司区分</b>(控制方 2026-10-06 定案)。
*
* <p>所以这里<b>不声明</b> {@code company_id} 字段。库里那一列(V145 加的,带 {@code DEFAULT 1})
* 暂时还在,但没有任何读写路径引用它:不声明字段 ⇒ SELECT 列清单与 INSERT 都不含它 ⇒ 新 jar 配旧库
* (列还在)不会报错。摘列必须等两台都跑上这一版,否则旧 jar 带着这一列来 INSERT/SELECT 会撞
* {@code Unknown column},而批量写入器把异常吞成 log.warn——那是静默丢黑名单行。
* 唯一键退回全局见 {@code V151__rule_tables_shared_across_companies.sql};<b>摘列本身不在 V151 里</b>
* (V151 只退键),它是下一版的待办,取号与理由见 {@code docs/migration-inventory.md}。</p>
*/
@Data
@TableName("biz_invalid_asin_data")
public class InvalidAsinDataEntity {
@@ -19,11 +29,9 @@ public class InvalidAsinDataEntity {
private String brand;
private Long groupId;
/**
* 归属公司(company.id)。列由 V145 物化,但**实体与批量 INSERT 的列清单此前都没带它**,
* 所以 2026-10-05 生产只读取证 14,801 行全是被 DEFAULT 1 盖出来的。写入侧从本版本起显式盖章。
* 归属账号:AUTO 行取 task.user_id、MANUAL 行取操作人;V145 之前的历史行为 NULL(无从追溯)。
* 这一列只记"谁加的",不参与任何筛选——品牌数据库全平台共享,见类注释。
*/
private Long companyId;
/** 归属账号:AUTO 行取 task.user_id、MANUAL 行取操作人;V145 之前的历史行为 NULL(无从追溯)。 */
private Long uploaderUserId;
private String recordSource;
private LocalDateTime createdAt;
@@ -6,7 +6,7 @@ import lombok.Data;
import java.time.LocalDateTime;
@Data
@Schema(description = "不符合ASIN数据项")
@Schema(description = "品牌数据库数据项")
public class InvalidAsinDataItemVo {
@Schema(description = "主键ID")
@@ -6,7 +6,7 @@ import lombok.Data;
import java.util.List;
@Data
@Schema(description = "不符合ASIN数据分页结果")
@Schema(description = "品牌数据库分页结果")
public class InvalidAsinDataPageVo {
@Schema(description = "列表")
@@ -2,7 +2,6 @@ package com.nanri.aiimage.modules.invalidasin.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataCreateRequest;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataUpdateRequest;
@@ -31,10 +30,9 @@ public class InvalidAsinDataService {
private final InvalidAsinDataMapper invalidAsinDataMapper;
private final ShopManageGroupService shopManageGroupService;
private final CompanyScopeSupport companyScopeSupport;
public InvalidAsinDataPageVo page(long page, long pageSize, String keyword, String dataValue, String brand,
Long groupId, Long operatorId, boolean superAdmin, Long companyFilterId) {
Long groupId, Long operatorId, boolean superAdmin) {
long safePage = Math.max(page, 1);
long safePageSize = Math.min(Math.max(pageSize, 1), 100);
String safeKeyword = keyword == null ? "" : keyword.trim();
@@ -48,9 +46,6 @@ public class InvalidAsinDataService {
.like(!safeDataValue.isEmpty(), InvalidAsinDataEntity::getDataValue, safeDataValue)
.like(!safeBrand.isEmpty(), InvalidAsinDataEntity::getBrand, safeBrand)
.orderByDesc(InvalidAsinDataEntity::getId);
if (companyFilterId != null) {
query.eq(InvalidAsinDataEntity::getCompanyId, companyFilterId);
}
if (!superAdmin) {
Long fixedGroupId = resolveFixedAccessibleGroupId(operatorId);
if (fixedGroupId == null) {
@@ -85,16 +80,13 @@ public class InvalidAsinDataService {
@Transactional
public InvalidAsinDataItemVo create(InvalidAsinDataCreateRequest request, Long operatorId, boolean superAdmin) {
ShopManageGroupEntity group = resolveManualWriteGroup(request.getGroupId(), operatorId, superAdmin);
// 归属从操作者会话推导,不读请求里的公司:超管在哪个 tab 下建都归他自己那家公司(一期定案口径)。
Long companyId = companyScopeSupport.requireCompanyId(operatorId);
String dataValue = normalizeRequired(request.getDataValue(), "ASIN 不能为空");
String brand = normalizeRequired(request.getBrand(), "品牌不能为空").toLowerCase(Locale.ROOT);
ensureUnique(dataValue, null, companyId);
ensureUnique(dataValue, null);
InvalidAsinDataEntity entity = new InvalidAsinDataEntity();
entity.setDataValue(dataValue);
entity.setBrand(brand);
entity.setGroupId(group.getId());
entity.setCompanyId(companyId);
entity.setUploaderUserId(operatorId);
entity.setRecordSource(RECORD_SOURCE_MANUAL);
invalidAsinDataMapper.insert(entity);
@@ -114,7 +106,7 @@ public class InvalidAsinDataService {
}
String dataValue = normalizeRequired(request.getDataValue(), "ASIN 不能为空");
String brand = normalizeRequired(request.getBrand(), "品牌不能为空").toLowerCase(Locale.ROOT);
ensureUnique(dataValue, id, entity.getCompanyId());
ensureUnique(dataValue, id);
entity.setDataValue(dataValue);
entity.setBrand(brand);
String groupName = "";
@@ -153,12 +145,15 @@ public class InvalidAsinDataService {
}
/**
* 应用层的重复预检必须与 V145 放宽后的唯一键同宽——(company_id, data_value, brand)。
* 少了公司这一维,第 2 家永远无法新增第 1 家已有的品牌(跨公司误报「ASIN 已存在」)。
* 全平台一份黑名单:同一条 ASIN 只要已经被任何一家录过,第二家再录就报「ASIN 已存在」。
*
* <p>预检比 {@code data_value} 一个字段,而库里唯一键是 {@code (data_value, brand)} ——预检更严,
* 这是改造前就有的口径(同一 ASIN 换品牌重录在页面上看不出区别)。V145 一度给这里叠过公司维度,
* 2026-10-06 控制方定案"品牌数据库不区分公司"后摘回全局。<b>不许再把公司加回来</b>:
* 那会让同一条 ASIN 在共享列表里长出两行,而这一页没有任何地方告诉操作员它们分属两家。</p>
*/
private void ensureUnique(String dataValue, Long excludeId, Long companyId) {
private void ensureUnique(String dataValue, Long excludeId) {
LambdaQueryWrapper<InvalidAsinDataEntity> query = new LambdaQueryWrapper<InvalidAsinDataEntity>()
.eq(companyId != null, InvalidAsinDataEntity::getCompanyId, companyId)
.eq(InvalidAsinDataEntity::getDataValue, dataValue)
.last("LIMIT 1");
InvalidAsinDataEntity exists = invalidAsinDataMapper.selectOne(query);
@@ -53,17 +53,29 @@ public class PermissionMenuController {
public ApiResponse<List<PermissionMenuItemVo>> listMenus(HttpServletRequest request,
@Parameter(description = "菜单类型: app/admin") @RequestParam(required = false) String menuType,
@Parameter(description = "授权树语义: true 时非超管只返回自己可授予的菜单")
@RequestParam(required = false, defaultValue = "false") boolean grantableOnly) {
@RequestParam(required = false, defaultValue = "false") boolean grantableOnly,
@Parameter(description = "公司 ID:仅站点超管可指定,缺省取操作者本公司")
@RequestParam(name = "company_id", required = false) Long companyId) {
// 传入操作者:授权树据此只下发(并把范围外节点标成不可勾选)操作者有权授予的菜单
return ApiResponse.success(permissionMenuService.list(requireAdmin(request), menuType, grantableOnly));
AdminUserEntity operator = requireAdmin(request);
// 归属判据只有一条(读写共用):先在这里过一遍,别家公司的 company_id 在取任何数之前就被 403 拒掉,
// 传下去的是定下来那一家,而不是 tab 原文。service 内部还会再判一次(幂等),控制器不重算口径。
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
return ApiResponse.success(permissionMenuService.list(
operator, menuType, grantableOnly, scopeCompanyId));
}
@PostMapping("/permission-menus")
@Operation(summary = "新增菜单权限项")
public ApiResponse<PermissionMenuItemVo> createMenu(HttpServletRequest httpRequest,
@Valid @RequestBody PermissionMenuCreateRequest request) {
@Valid @RequestBody PermissionMenuCreateRequest request,
@Parameter(description = "建到哪家公司的树:仅站点超管可指定")
@RequestParam(name = "company_id", required = false)
Long companyId) {
AdminUserEntity operator = requireAdmin(httpRequest);
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
return ApiResponse.success("创建成功", permissionMenuService.create(
requireAdmin(httpRequest), request));
operator, scopeCompanyId, request));
}
@PutMapping("/permission-menus/{id}")
@@ -86,7 +98,7 @@ public class PermissionMenuController {
@Operation(summary = "同级菜单拖拽排序")
public ApiResponse<Void> reorderColumns(HttpServletRequest httpRequest,
@RequestBody(required = false) Map<String, Object> body) {
requireAdmin(httpRequest);
AdminUserEntity operator = requireAdmin(httpRequest);
Object raw = body == null ? null
: (body.get("ordered_ids") != null ? body.get("ordered_ids") : body.get("orderedIds"));
if (!(raw instanceof List<?> list)) {
@@ -104,7 +116,8 @@ public class PermissionMenuController {
}
}
}
permissionMenuService.reorder(ids);
// 带上操作者:重排会写兄弟集的 sort_order,每家公司一棵树之后必须先确认锚点行属于他
permissionMenuService.reorder(operator, ids);
return ApiResponse.success("排序已保存", null);
}
@@ -142,34 +155,48 @@ public class PermissionMenuController {
@GetMapping("/image-video-task-permissions")
@Operation(summary = "查询视频任务数据权限用户")
public ApiResponse<List<ImageVideoDataPermissionUserVo>> listImageVideoDataPermissionUsers(
HttpServletRequest request) {
return ApiResponse.success(permissionMenuService.listImageVideoDataPermissionUsers(requireAdmin(request)));
HttpServletRequest request,
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = requireAdmin(request);
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
return ApiResponse.success(permissionMenuService.listImageVideoDataPermissionUsers(
operator, scopeCompanyId));
}
@PutMapping("/image-video-task-permissions")
@Operation(summary = "更新视频任务数据权限用户")
public ApiResponse<Integer> updateImageVideoDataPermissionUsers(
HttpServletRequest request,
@RequestParam(name = "company_id", required = false) Long companyId,
@RequestBody(required = false) ImageVideoDataPermissionUpdateRequest body) {
AdminUserEntity operator = requireAdmin(request);
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
int grantedCount = permissionMenuService.updateImageVideoDataPermissionUsers(
requireAdmin(request), body == null ? List.of() : body.getUserIds());
operator, scopeCompanyId, body == null ? List.of() : body.getUserIds());
return ApiResponse.success("视频任务权限已更新", grantedCount);
}
@GetMapping("/shop-data-crawl-task-permissions")
@Operation(summary = "查询店铺数据任务数据权限用户")
public ApiResponse<List<ImageVideoDataPermissionUserVo>> listShopDataCrawlDataPermissionUsers(
HttpServletRequest request) {
return ApiResponse.success(permissionMenuService.listShopDataCrawlDataPermissionUsers(requireAdmin(request)));
HttpServletRequest request,
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = requireAdmin(request);
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
return ApiResponse.success(permissionMenuService.listShopDataCrawlDataPermissionUsers(
operator, scopeCompanyId));
}
@PutMapping("/shop-data-crawl-task-permissions")
@Operation(summary = "更新店铺数据任务数据权限用户")
public ApiResponse<Integer> updateShopDataCrawlDataPermissionUsers(
HttpServletRequest request,
@RequestParam(name = "company_id", required = false) Long companyId,
@RequestBody(required = false) ImageVideoDataPermissionUpdateRequest body) {
AdminUserEntity operator = requireAdmin(request);
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
int grantedCount = permissionMenuService.updateShopDataCrawlDataPermissionUsers(
requireAdmin(request), body == null ? List.of() : body.getUserIds());
operator, scopeCompanyId, body == null ? List.of() : body.getUserIds());
return ApiResponse.success("店铺数据任务权限已更新", grantedCount);
}
@@ -22,6 +22,15 @@ public class PermissionMenuEntity {
private String menuType;
private String routePath;
private Integer sortOrder;
/**
* 归属公司(V149):菜单字典从"全平台一棵树"改成"每家公司一套树",
* {@code column_key} 与 {@code (menu_type, route_path)} 都只在本公司内唯一。
*
* <p>写侧一律显式赋值({@code PermissionMenuService} 的 create/update 从操作者或目标行推导),
* 不许依赖列上那条临时的 {@code DEFAULT 1}:V149 留 DEFAULT 只为让同批的旧 jar 不报 1364,
* 下一版就摘掉;一旦有出口忘了赋值,DEFAULT 会把别家的菜单静默塞进厦门米椿花。</p>
*/
private Long companyId;
private LocalDateTime createdAt;
/**
* 更新时间(V131 新增):由数据库维护(DEFAULT CURRENT_TIMESTAMP + ON UPDATE CURRENT_TIMESTAMP)。
@@ -11,6 +11,19 @@ import org.springframework.stereotype.Component;
import java.util.List;
import java.util.concurrent.CompletableFuture;
/**
* 菜单字典的建表/种子旁路(生产默认关,见 application.yml 的 aiimage.permission-schema-init.enabled)。
*
* <p>V149 之后它只维护<b>公司 1 那棵平台默认树</b>:每一条种子语句的 INSERT 列清单都显式写
* {@code company_id = 1},判存守卫、认父 JOIN、按 key 的 UPDATE 也一律带 {@code company_id = 1}——
* 因为 column_key 如今只在单家公司内唯一,一条裸 {@code WHERE column_key = ...} 在这张表上
* 就是"把每一家的同名行都改一遍"(把别家副本的 parent 拍平、或把授权发给别家的行 id)。
* 显式写公司还有一层作用:这条通道不再依赖列上那条 {@code DEFAULT 1},
* 于是 V152 起摘掉它({@code ALTER TABLE columns ALTER COLUMN company_id DROP DEFAULT})
* 不会让这里的建号变成 1364 被 {@code executeQuietly} 吞成"一声不响少一套菜单"。
* 别家公司的树不由这里插行——存量公司归 V149 的复制段,新建公司归
* {@code PermissionMenuService.copyTreeFromTemplate}({@code CompanyService.create} 同事务调用)。</p>
*/
@Component
@RequiredArgsConstructor
@Slf4j
@@ -92,17 +105,26 @@ public class PermissionMenuSchemaInitializer {
name VARCHAR(128) NOT NULL COMMENT '菜单标题',
column_key VARCHAR(64) NOT NULL COMMENT '菜单唯一标识',
parent_id INT NULL COMMENT '直接父菜单 ID',
company_id BIGINT NOT NULL DEFAULT 1 COMMENT '归属公司:每家公司一套菜单树',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE KEY uk_column_key (column_key)
UNIQUE KEY uk_company_column_key (company_id, column_key)
)
""");
executeQuietly("ALTER TABLE columns ADD COLUMN menu_type VARCHAR(20) NOT NULL DEFAULT 'app' COMMENT '菜单类型: app/admin' AFTER column_key");
executeQuietly("ALTER TABLE columns ADD COLUMN parent_id INT NULL COMMENT '直接父菜单 ID' AFTER id");
executeQuietly("ALTER TABLE columns ADD COLUMN route_path VARCHAR(255) NOT NULL DEFAULT '' COMMENT '菜单路由或页面标识' AFTER menu_type");
executeQuietly("ALTER TABLE columns ADD COLUMN sort_order INT NOT NULL DEFAULT 0 COMMENT '菜单排序' AFTER route_path");
executeQuietly("ALTER TABLE columns ADD COLUMN company_id BIGINT NULL COMMENT '归属公司:每家公司一套菜单树'");
executeQuietly("UPDATE columns SET company_id = 1 WHERE company_id IS NULL");
executeQuietly("ALTER TABLE columns MODIFY COLUMN company_id BIGINT NOT NULL DEFAULT 1 COMMENT '归属公司:每家公司一套菜单树'");
executeQuietly("UPDATE columns SET menu_type = 'app' WHERE menu_type IS NULL OR menu_type = ''");
executeQuietly("UPDATE columns SET sort_order = id WHERE sort_order IS NULL OR sort_order = 0");
executeQuietly("ALTER TABLE columns ADD UNIQUE KEY uk_menu_type_route_path (menu_type, route_path)");
// 两条全局唯一键在"每家公司一套树"之后会把别家同名菜单挡成"标识已存在"。
// 先加复合键、再摘旧键(与 V149 第 4/5 段同一顺序:任一步失败都至少还剩一条键守并发)。
executeQuietly("ALTER TABLE columns ADD UNIQUE KEY uk_company_column_key (company_id, column_key)");
executeQuietly("ALTER TABLE columns ADD UNIQUE KEY uk_company_menu_type_route_path (company_id, menu_type, route_path)");
executeQuietly("ALTER TABLE columns DROP INDEX uk_column_key");
executeQuietly("ALTER TABLE columns DROP INDEX uk_menu_type_route_path");
ensureDefaultAdminGroups();
ensureDefaultAdminMenus();
boolean shopDataCrawlDataPermissionCreated = ensureShopDataCrawlAdminDefaults();
@@ -126,10 +148,10 @@ public class PermissionMenuSchemaInitializer {
private void ensureDefaultAdminGroups() {
for (DefaultAdminGroup group : DEFAULT_ADMIN_GROUPS) {
executeQuietly("""
INSERT INTO columns (name, column_key, menu_type, route_path, parent_id, sort_order)
SELECT '%s', '%s', 'admin', '%s', NULL, %d
INSERT INTO columns (company_id, name, column_key, menu_type, route_path, parent_id, sort_order)
SELECT 1, '%s', '%s', 'admin', '%s', NULL, %d
WHERE NOT EXISTS (
SELECT 1 FROM columns WHERE column_key = '%s'
SELECT 1 FROM columns WHERE company_id = 1 AND column_key = '%s'
)
""".formatted(group.name(), group.columnKey(), group.routePath(), group.sortOrder(), group.columnKey()));
}
@@ -138,21 +160,21 @@ public class PermissionMenuSchemaInitializer {
private void ensureDefaultAdminMenus() {
for (DefaultAdminMenu menu : DEFAULT_ADMIN_MENUS) {
executeQuietly("""
INSERT INTO columns (name, column_key, menu_type, route_path, sort_order, parent_id)
SELECT '%s', '%s', 'admin', '%s', %d, parent.id
INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order, parent_id)
SELECT 1, '%s', '%s', 'admin', '%s', %d, parent.id
FROM columns parent
WHERE parent.column_key = '%s'
WHERE parent.company_id = 1 AND parent.column_key = '%s'
AND NOT EXISTS (
SELECT 1 FROM columns WHERE column_key = '%s'
SELECT 1 FROM columns WHERE company_id = 1 AND column_key = '%s'
)
""".formatted(menu.name(), menu.columnKey(), menu.routePath(), menu.sortOrder(),
menu.parentKey(), menu.columnKey()));
executeQuietly("""
UPDATE columns child
JOIN columns parent ON parent.column_key = '%s'
JOIN columns parent ON parent.company_id = 1 AND parent.column_key = '%s'
SET child.name = '%s', child.sort_order = %d,
child.parent_id = COALESCE(child.parent_id, parent.id)
WHERE child.column_key = '%s'
WHERE child.company_id = 1 AND child.column_key = '%s'
""".formatted(menu.parentKey(), menu.name(), menu.sortOrder(), menu.columnKey()));
}
}
@@ -160,16 +182,16 @@ public class PermissionMenuSchemaInitializer {
private void ensureDefaultAppMenus() {
for (DefaultAppMenu menu : DEFAULT_APP_MENUS) {
executeQuietly("""
INSERT INTO columns (name, column_key, menu_type, route_path, sort_order)
SELECT '%s', '%s', 'app', '%s', %d
INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order)
SELECT 1, '%s', '%s', 'app', '%s', %d
WHERE NOT EXISTS (
SELECT 1 FROM columns WHERE column_key = '%s'
SELECT 1 FROM columns WHERE company_id = 1 AND column_key = '%s'
)
""".formatted(menu.name(), menu.columnKey(), menu.routePath(), menu.sortOrder(), menu.columnKey()));
executeQuietly("""
UPDATE columns
SET sort_order = %d, route_path = '%s', menu_type = 'app', parent_id = NULL
WHERE column_key = '%s'
WHERE company_id = 1 AND column_key = '%s'
""".formatted(menu.sortOrder(), menu.routePath(), menu.columnKey()));
}
}
@@ -177,55 +199,55 @@ public class PermissionMenuSchemaInitializer {
private void ensureDefaultAppChildMenus() {
// Older migrations used underscore keys for a few app pages. Normalize
// them once so the frontend item key and permission key stay aligned.
executeQuietly("UPDATE columns SET column_key = 'collect-data' WHERE column_key = 'collect_data'");
executeQuietly("UPDATE columns SET column_key = 'appearance-patent' WHERE column_key = 'appearance_patent'");
executeQuietly("UPDATE columns SET column_key = 'similar-asin' WHERE column_key = 'similar_asin'");
executeQuietly("UPDATE columns SET column_key = 'collect-data' WHERE company_id = 1 AND column_key = 'collect_data'");
executeQuietly("UPDATE columns SET column_key = 'appearance-patent' WHERE company_id = 1 AND column_key = 'appearance_patent'");
executeQuietly("UPDATE columns SET column_key = 'similar-asin' WHERE company_id = 1 AND column_key = 'similar_asin'");
for (DefaultAppChildMenu menu : DEFAULT_APP_CHILD_MENUS) {
executeQuietly("""
INSERT INTO columns (name, column_key, menu_type, route_path, sort_order, parent_id)
SELECT '%s', '%s', 'app', '%s', %d, parent.id
INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order, parent_id)
SELECT 1, '%s', '%s', 'app', '%s', %d, parent.id
FROM columns parent
WHERE parent.column_key = '%s'
WHERE parent.company_id = 1 AND parent.column_key = '%s'
AND NOT EXISTS (
SELECT 1 FROM columns existing WHERE existing.column_key = '%s'
SELECT 1 FROM columns existing WHERE existing.company_id = 1 AND existing.column_key = '%s'
)
""".formatted(menu.name(), menu.columnKey(), menu.routePath(), menu.sortOrder(),
menu.parentKey(), menu.columnKey()));
executeQuietly("""
UPDATE columns child
JOIN columns parent ON parent.column_key = '%s'
JOIN columns parent ON parent.company_id = 1 AND parent.column_key = '%s'
SET child.name = '%s', child.menu_type = 'app', child.route_path = '%s',
child.sort_order = %d, child.parent_id = parent.id
WHERE child.column_key = '%s'
WHERE child.company_id = 1 AND child.column_key = '%s'
""".formatted(menu.parentKey(), menu.name(), menu.routePath(), menu.sortOrder(), menu.columnKey()));
}
}
private void ensureInternalDataPermissions() {
executeQuietly("""
INSERT INTO columns (name, column_key, menu_type, route_path, sort_order)
SELECT '视频任务数据查看', 'admin_image_video_task_data', 'internal', 'image-video-task-data', 0
INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order)
SELECT 1, '视频任务数据查看', 'admin_image_video_task_data', 'internal', 'image-video-task-data', 0
WHERE NOT EXISTS (
SELECT 1 FROM columns WHERE column_key = 'admin_image_video_task_data'
SELECT 1 FROM columns WHERE company_id = 1 AND column_key = 'admin_image_video_task_data'
)
""");
}
private boolean ensureShopDataCrawlAdminDefaults() {
executeQuietly("""
INSERT INTO columns (name, column_key, menu_type, route_path, sort_order, parent_id)
SELECT '店铺数据记录', 'admin_shop_data_crawl_tasks', 'admin', 'shop-data-crawl-tasks', 82,
(SELECT id FROM columns WHERE column_key = 'admin_group_shop' LIMIT 1)
INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order, parent_id)
SELECT 1, '店铺数据记录', 'admin_shop_data_crawl_tasks', 'admin', 'shop-data-crawl-tasks', 82,
(SELECT id FROM columns WHERE company_id = 1 AND column_key = 'admin_group_shop' LIMIT 1)
WHERE NOT EXISTS (
SELECT 1 FROM columns WHERE column_key = 'admin_shop_data_crawl_tasks'
SELECT 1 FROM columns WHERE company_id = 1 AND column_key = 'admin_shop_data_crawl_tasks'
)
""");
return executeUpdateQuietly("""
INSERT INTO columns (name, column_key, menu_type, route_path, sort_order)
SELECT '店铺数据任务数据查看', 'admin_shop_data_crawl_task_data', 'internal', 'shop-data-crawl-task-data', 0
INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order)
SELECT 1, '店铺数据任务数据查看', 'admin_shop_data_crawl_task_data', 'internal', 'shop-data-crawl-task-data', 0
WHERE NOT EXISTS (
SELECT 1 FROM columns WHERE column_key = 'admin_shop_data_crawl_task_data'
SELECT 1 FROM columns WHERE company_id = 1 AND column_key = 'admin_shop_data_crawl_task_data'
)
""") > 0;
}
@@ -236,7 +258,8 @@ public class PermissionMenuSchemaInitializer {
SELECT old_perm.user_id, data_col.id
FROM user_column_permission old_perm
INNER JOIN columns old_col ON old_col.id = old_perm.column_id
INNER JOIN columns data_col ON data_col.column_key = 'admin_shop_data_crawl_task_data'
INNER JOIN columns data_col ON data_col.company_id = old_col.company_id
AND data_col.column_key = 'admin_shop_data_crawl_task_data'
LEFT JOIN user_column_permission existing
ON existing.user_id = old_perm.user_id
AND existing.column_id = data_col.id
@@ -79,9 +79,24 @@ public class PermissionMenuService {
* 一旦可勾,「勾父覆盖全部后代」就会把树上未展示的范围外菜单一起授出去。
* 保存侧必须配套按操作者范围替换,见
* {@link #updateUserColumnPermissions(AdminUserEntity, Long, UserColumnPermissionUpdateRequest, String, boolean)}。
* @param requestedCompanyId V149 目录页的公司 tab:站点超管可指定任意公司的树;非超管传别家 403,
* 不传就锁本公司。缺省值不是"全公司"——每家公司一套树之后,跨公司的目录混在一起
* 等于让 {@code column_key} 在同一个响应里出现两次,前端按 key 建树会直接长错。
*/
public List<PermissionMenuItemVo> list(AdminUserEntity operator, String menuType,
boolean grantableOnly, Long requestedCompanyId) {
Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
return listAt(companyId, operator, menuType, grantableOnly);
}
public List<PermissionMenuItemVo> list(AdminUserEntity operator, String menuType, boolean grantableOnly) {
List<PermissionMenuEntity> menus = loadMenus(menuType);
return list(operator, menuType, grantableOnly, null);
}
/** 目录/授权树的唯一出口:{@code companyId} 为非空时只取那一棵树的行,null 仅留给无操作者的内部调用。 */
private List<PermissionMenuItemVo> listAt(Long companyId, AdminUserEntity operator,
String menuType, boolean grantableOnly) {
List<PermissionMenuEntity> menus = loadMenus(companyId, menuType);
Set<Long> grantableIds = resolveGrantableMenuIds(operator);
List<PermissionMenuEntity> visibleMenus = menus;
if (grantableOnly && grantableIds != null) {
@@ -109,13 +124,68 @@ public class PermissionMenuService {
/**
* 操作者可授予的菜单 id 全集(自身直接授权 + 其后代)。
*
* <p>V149 之后按<b>操作者本公司</b>那棵树展开:授权只会指向本公司的行(迁移第 9 段与
* 闸门 3 保证),拿全平台目录去展开等于把别家同名菜单的 id 也算进"可授予",
* 那是"范围收窄只做在界面上"的同一类事故。</p>
*
* @return null 表示不限制(超管或无操作者)
*/
private Set<Long> resolveGrantableMenuIds(AdminUserEntity operator) {
if (operator == null || operator.getId() == null || isSuperAdmin(operator)) {
return null;
}
return expandDescendantIds(new LinkedHashSet<>(loadDirectColumnIds(operator.getId())), loadMenus(null));
return expandDescendantIds(new LinkedHashSet<>(loadDirectColumnIds(operator.getId())),
loadMenus(operator.getCompanyId(), null));
}
/**
* 归属公司的统一判据(设计文档 §2 D2):不传就锁操作者本公司;站点超管可以显式指定
* 任意一家(他今天就在替两家公司共 133 只账号配权限),非超管传别家一律 403。
*
* <p>读侧与写侧共用这一个方法:分成两个迟早漂移成「读能看别家、写挡不住」或反过来,
* 而那正是 09-13「权限自己没掉」那一族事故的形状。</p>
*
* <p>{@code null} 只可能来自「没有操作者」的历史内部调用与单测夹具,此时不下公司条件、
* 退回换列之前的全量目录语义;生产上 {@code users.company_id} 是 NOT NULL,
* 真出现无归属账号由列上的约束喊,不在这里编一个默认公司。</p>
*
* <p>公开是为了让控制器在收 {@code company_id} 参数的当场就走这道门(把返回值往下传),
* 而不是把裸参数扔进来再靠本类内部兜——{@code CompanyIdParamGoesThroughReadScopeTest}
* 认的就是这条出口,控制器少接一次就等于"tab 传了但没人用"。</p>
*/
public Long resolveScopeCompanyId(AdminUserEntity operator, Long requestedCompanyId) {
if (requestedCompanyId != null && requestedCompanyId <= 0) {
throw new BusinessException("company_id 无效");
}
if (operator == null || operator.getId() == null) {
return requestedCompanyId;
}
Long operatorCompanyId = operator.getCompanyId();
if (requestedCompanyId == null) {
return operatorCompanyId;
}
if (requestedCompanyId.equals(operatorCompanyId) || isSuperAdmin(operator)) {
return requestedCompanyId;
}
throw new BusinessException(403, "无权读写其他公司的菜单");
}
/**
* 写侧闸门(§5):非超管只能动<b>本公司那棵树</b>里的行。
*
* <p>补这道闸门之前 {@link #ensureAdminOperatorIfPresent} 只判 isAdmin,等于任何管理员
* 都能改整张字典;每家公司一棵树之后,跨公司改一行会把别家的菜单搬进自己树里
* ({@code column_key} 在两家之间不再全局唯一,只有 id 认得出它属于谁)。
* 菜单字典是租户配置,改坏它比跨公司读数据更糟——那家所有账号的权限页一起坏。</p>
*/
private void ensureMenuWritable(AdminUserEntity operator, PermissionMenuEntity menu) {
if (operator == null || isSuperAdmin(operator)) {
return;
}
Long menuCompanyId = menu == null ? null : menu.getCompanyId();
if (!Objects.equals(menuCompanyId, operator.getCompanyId())) {
throw new BusinessException(403, "无权修改其他公司的菜单");
}
}
/**
@@ -139,13 +209,25 @@ public class PermissionMenuService {
@Transactional
public PermissionMenuItemVo create(PermissionMenuCreateRequest request) {
return create(null, request);
return create(null, null, request);
}
/** Controller-facing variant; the caller may pass the authenticated admin. */
@Transactional
public PermissionMenuItemVo create(AdminUserEntity operator, PermissionMenuCreateRequest request) {
return create(operator, null, request);
}
/**
* 新增菜单。归属公司由 {@code requestedCompanyId} 决定,缺省取操作者本公司(设计文档 §5):
* 站点超管可以替别家建菜单(今天就是他一人在给 133 只账号配权限),非超管只能在自已公司建,
* 传别家 403。<b>绝不靠列上的 DEFAULT 1 兜归属</b>——那等于把别家的菜单静默塞进厦门米椿花。
*/
@Transactional
public PermissionMenuItemVo create(AdminUserEntity operator, Long requestedCompanyId,
PermissionMenuCreateRequest request) {
ensureAdminOperatorIfPresent(operator);
Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
if (request == null) {
throw new BusinessException("菜单参数不能为空");
}
@@ -161,9 +243,9 @@ public class PermissionMenuService {
routePath = generateRoutePath(columnKey);
}
Long parentId = normalizeParentId(request.getParentId());
ensureParentValid(parentId, null, menuType);
ensureUniqueColumnKey(columnKey, null);
ensureUniqueRoutePath(menuType, routePath, null);
ensureParentValid(companyId, parentId, null, menuType);
ensureUniqueColumnKey(companyId, columnKey, null);
ensureUniqueRoutePath(companyId, menuType, routePath, null);
PermissionMenuEntity entity = new PermissionMenuEntity();
entity.setName(name);
@@ -171,7 +253,8 @@ public class PermissionMenuService {
entity.setParentId(parentId);
entity.setMenuType(menuType);
entity.setRoutePath(routePath);
entity.setSortOrder(resolveSortOrder(menuType, request.getSortOrder(), null));
entity.setCompanyId(companyId);
entity.setSortOrder(resolveSortOrder(companyId, menuType, request.getSortOrder(), null));
permissionMenuMapper.insert(entity);
return toItemVo(getMenuById(entity.getId()));
}
@@ -186,6 +269,10 @@ public class PermissionMenuService {
public PermissionMenuItemVo update(AdminUserEntity operator, Long id, PermissionMenuUpdateRequest request) {
ensureAdminOperatorIfPresent(operator);
PermissionMenuEntity entity = getMenuById(id);
// 归属不接收请求参数:改哪棵树由<b>这一行自己属于谁</b>决定,编辑动作只能把行留在原公司。
// 让载荷带 company_id 等于开一条"把别家的菜单搬进自己树"的旁路。
ensureMenuWritable(operator, entity);
Long companyId = entity.getCompanyId();
if (request == null) {
throw new BusinessException("菜单参数不能为空");
}
@@ -201,17 +288,17 @@ public class PermissionMenuService {
routePath = entity.getRoutePath();
}
Long parentId = normalizeParentId(request.getParentId());
ensureParentValid(parentId, id, menuType);
ensureParentValid(companyId, parentId, id, menuType);
ensureMenuTypeChangeAllowed(entity, menuType);
ensureUniqueColumnKey(columnKey, id);
ensureUniqueRoutePath(menuType, routePath, id);
ensureUniqueColumnKey(companyId, columnKey, id);
ensureUniqueRoutePath(companyId, menuType, routePath, id);
entity.setName(name);
entity.setColumnKey(columnKey);
entity.setParentId(parentId);
entity.setMenuType(menuType);
entity.setRoutePath(routePath);
entity.setSortOrder(resolveSortOrder(menuType, request.getSortOrder(), id));
entity.setSortOrder(resolveSortOrder(companyId, menuType, request.getSortOrder(), id));
permissionMenuMapper.updateById(entity);
return toItemVo(getMenuById(id));
}
@@ -229,6 +316,7 @@ public class PermissionMenuService {
public void delete(AdminUserEntity operator, Long id) {
ensureAdminOperatorIfPresent(operator);
PermissionMenuEntity entity = getMenuById(id);
ensureMenuWritable(operator, entity);
Long childCount = permissionMenuMapper.selectCount(new LambdaQueryWrapper<PermissionMenuEntity>()
.eq(PermissionMenuEntity::getParentId, entity.getId()));
if (childCount != null && childCount > 0) {
@@ -243,9 +331,12 @@ public class PermissionMenuService {
/**
* 同级菜单拖拽重排:orderedIds 为同一父级下按新顺序排列的菜单 ID 列表。
* 不在列表中的兄弟节点保持原相对顺序追加在末尾,重排块锚定在原最小 sort_order,避免跨级穿插。
*
* <p>兄弟集必须按<b>锚点行的公司</b>筛:每家公司一棵树之后,"同级"这个概念本身就带公司口径,
* 混进别家的同名分组会让重排把两棵树的 sort_order 交织在一起(表现为两排同名菜单穿插)。</p>
*/
@Transactional
public void reorder(List<Long> orderedIds) {
public void reorder(AdminUserEntity operator, List<Long> orderedIds) {
if (orderedIds == null || orderedIds.isEmpty()) {
return;
}
@@ -257,9 +348,13 @@ public class PermissionMenuService {
if (anchor == null) {
throw new BusinessException("菜单不存在");
}
ensureAdminOperatorIfPresent(operator);
ensureMenuWritable(operator, anchor);
Long companyId = anchor.getCompanyId();
Long parentId = anchor.getParentId();
String menuType = anchor.getMenuType();
List<PermissionMenuEntity> siblings = permissionMenuMapper.selectList(new LambdaQueryWrapper<PermissionMenuEntity>()
.eq(PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getMenuType, menuType)
.eq(PermissionMenuEntity::getParentId, parentId)
.orderByAsc(PermissionMenuEntity::getSortOrder)
@@ -288,6 +383,88 @@ public class PermissionMenuService {
}
}
/**
* 给新公司复制一套模板菜单树(父子指向按 {@code column_key} 重映射),与 V149 第 6/7 段同一语义:
* 那一版补的是<b>当时已经存在</b>的公司,这一版补的是之后新建的公司。
*
* <p>没有它,「公司管理 -> 新增公司」就造出一个零菜单行的租户:那家的账号登录后台侧边栏全空、
* 授权树一个勾都没有,而且全程不报错。这正是本次要消灭的那类静默失效,
* 所以建树必须是建号公司的同一次写入,不能留成"上线后再手工跑一遍 V149 的复制段"。</p>
*
* <p>两趟写:第一趟只管插(父先留空,避开插入顺序),第二趟按 key 把父指向落到本公司新行上
* ——与 V149 第 7 段同形,两级三层都成立。幂等:目标公司已有的 key 原样保留,重跑只补差集。</p>
*
* @param companyId 目标(新)公司
* @param templateCompanyId 模板树所属公司,由调用方给操作者本公司,这里不编默认值
* @return 本次新插入的行数
*/
@Transactional
public int copyTreeFromTemplate(Long companyId, Long templateCompanyId) {
if (companyId == null || companyId <= 0) {
throw new BusinessException("目标公司 id 不能为空");
}
if (templateCompanyId == null || templateCompanyId <= 0) {
throw new BusinessException("当前账号没有所属公司,无法为新公司复制菜单树");
}
if (companyId.equals(templateCompanyId)) {
return 0;
}
// 角色内在闸门那几行不进副本(D3):它在任何别家的树里都不该存在,
// 连行都没有就没人能勾它,比"有一行但看不见"更干净。
List<PermissionMenuEntity> template = loadRawMenus(templateCompanyId, null).stream()
.filter(menu -> menu.getId() != null && menu.getColumnKey() != null)
.filter(menu -> !SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey()))
.toList();
if (template.isEmpty()) {
throw new BusinessException("模板公司没有可复制的菜单树");
}
Map<String, PermissionMenuEntity> targetByKey = new HashMap<>();
for (PermissionMenuEntity menu : loadRawMenus(companyId, null)) {
if (menu.getColumnKey() != null) {
targetByKey.put(menu.getColumnKey(), menu);
}
}
Map<Long, PermissionMenuEntity> templateById = new HashMap<>();
template.forEach(menu -> templateById.put(menu.getId(), menu));
int inserted = 0;
for (PermissionMenuEntity source : template) {
if (targetByKey.containsKey(source.getColumnKey())) {
continue;
}
PermissionMenuEntity copy = new PermissionMenuEntity();
copy.setCompanyId(companyId);
copy.setName(source.getName());
copy.setColumnKey(source.getColumnKey());
copy.setMenuType(source.getMenuType());
copy.setRoutePath(source.getRoutePath());
copy.setSortOrder(source.getSortOrder());
copy.setParentId(null);
permissionMenuMapper.insert(copy);
targetByKey.put(copy.getColumnKey(), copy);
inserted++;
}
for (PermissionMenuEntity source : template) {
PermissionMenuEntity child = targetByKey.get(source.getColumnKey());
PermissionMenuEntity templateParent = templateById.get(source.getParentId());
if (child == null || child.getId() == null || templateParent == null) {
continue;
}
PermissionMenuEntity parent = targetByKey.get(templateParent.getColumnKey());
if (parent == null || parent.getId() == null || parent.getId().equals(child.getId())) {
continue;
}
if (!Objects.equals(child.getParentId(), parent.getId())) {
permissionMenuMapper.update(null, new LambdaUpdateWrapper<PermissionMenuEntity>()
.eq(PermissionMenuEntity::getId, child.getId())
.set(PermissionMenuEntity::getParentId, parent.getId()));
child.setParentId(parent.getId());
}
}
log.info("[menu-tree-copy] 新公司菜单树已建 companyId={} template={} rows={}",
companyId, templateCompanyId, inserted);
return inserted;
}
/** Returns only persisted direct grant IDs (never recursively expanded). */
public UserColumnIdsVo getUserColumnIds(Long userId, String menuType) {
return getUserColumnIds(null, userId, menuType);
@@ -314,7 +491,9 @@ public class PermissionMenuService {
AdminUserEntity user = getUserById(userId);
ensureTargetAccessible(operator, user);
List<PermissionMenuEntity> menus = loadMenus(menuType);
// 回填集按<b>目标账号所属公司</b>的那棵树取:授权弹窗里勾的是"这个账号家"的菜单行 id,
// 操作者是谁都不该改变这一点(超管替德阳配权限时勾出公司 1 的行 id,就是跨公司授权)。
List<PermissionMenuEntity> menus = loadMenus(user.getCompanyId(), menuType);
Map<Long, PermissionMenuEntity> menuMap = menus.stream()
.filter(menu -> menu.getId() != null)
.collect(Collectors.toMap(PermissionMenuEntity::getId, Function.identity(), (left, right) -> left));
@@ -351,7 +530,7 @@ public class PermissionMenuService {
boolean includeAncestorGroups) {
AdminUserEntity user = getUserById(userId);
ensureTargetAccessible(operator, user);
List<PermissionMenuEntity> menus = loadMenus(menuType);
List<PermissionMenuEntity> menus = loadMenus(user.getCompanyId(), menuType);
if (isSuperAdmin(user)) {
return toItemVos(menus, menus);
}
@@ -387,7 +566,12 @@ public class PermissionMenuService {
if (isSuperAdmin(user)) {
return true;
}
List<PermissionMenuEntity> menus = loadMenus(target.getMenuType());
// 跨公司的 column_id 一律判「无权限」:本账号的直接授权里出现别家的行,只可能是载荷被
// 拼错(或前端缓存了换键之前的旧 id)。方向是拒绝,不是放行——放宽等于让别家的行 id 生效。
if (!Objects.equals(target.getCompanyId(), user.getCompanyId())) {
return false;
}
List<PermissionMenuEntity> menus = loadMenus(target.getCompanyId(), target.getMenuType());
return expandDescendantIds(new LinkedHashSet<>(loadDirectColumnIds(userId)), menus)
.contains(columnId);
}
@@ -397,26 +581,40 @@ public class PermissionMenuService {
*
* <p>权限页此前一律 `selectList(new LambdaQueryWrapper<>())` 整表拉回,而 admin_user
* 含密码哈希等敏感列,每次打开权限页都把全表(含哈希)读进内存(2026-09-15 优化)。
* 判定用 role/is_admin/created_by_id,展示用 id/username。
* 判定用 role/is_admin/created_by_id,展示用 id/username,按公司筛用 company_id
* (V149:数据权限行分属各棵树,用户列表必须同一家,否则「勾了人、写到别家的行」
* 会静默落空——页面照旧显示已授权,账号却永远拿不到那份数据)。
*/
private LambdaQueryWrapper<AdminUserEntity> grantableUserQuery() {
private LambdaQueryWrapper<AdminUserEntity> grantableUserQuery(Long companyId) {
return new LambdaQueryWrapper<AdminUserEntity>()
.select(AdminUserEntity::getId,
AdminUserEntity::getUsername,
AdminUserEntity::getRole,
AdminUserEntity::getIsAdmin,
AdminUserEntity::getCreatedById);
AdminUserEntity::getCreatedById,
AdminUserEntity::getCompanyId)
.eq(companyId != null, AdminUserEntity::getCompanyId, companyId);
}
public List<ImageVideoDataPermissionUserVo> listImageVideoDataPermissionUsers(AdminUserEntity operator) {
return listImageVideoDataPermissionUsers(operator, null);
}
/**
* 「视频任务数据查看」这一项内部数据权限的分公司读口:超管切到哪家公司就解析那棵树的行,
* 用户列表同步按那一家筛({@link #grantableUserQuery(Long)})。
*/
public List<ImageVideoDataPermissionUserVo> listImageVideoDataPermissionUsers(AdminUserEntity operator,
Long requestedCompanyId) {
ensureSuperAdminOperator(operator);
PermissionMenuEntity dataPermission = requireImageVideoDataPermission();
Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
PermissionMenuEntity dataPermission = requireImageVideoDataPermission(companyId);
Set<Long> grantedUserIds = userColumnPermissionMapper.selectByColumnId(dataPermission.getId())
.stream()
.map(UserColumnPermissionEntity::getUserId)
.filter(id -> id != null && id > 0)
.collect(Collectors.toSet());
return adminUserMapper.selectList(grantableUserQuery()
return adminUserMapper.selectList(grantableUserQuery(companyId)
.orderByAsc(AdminUserEntity::getUsername)
.orderByAsc(AdminUserEntity::getId))
.stream()
@@ -427,10 +625,22 @@ public class PermissionMenuService {
@Transactional
public int updateImageVideoDataPermissionUsers(AdminUserEntity operator, List<Long> userIds) {
return updateImageVideoDataPermissionUsers(operator, null, userIds);
}
/**
* 整分区替换本公司的那一条内部数据权限授权。别家的账号 id 会落进
* 「contains unknown or non-grantable user」——用户列表已经按公司筛过,
* 这不是新报错,是既有的那条从严判定现在有了公司口径。
*/
@Transactional
public int updateImageVideoDataPermissionUsers(AdminUserEntity operator, Long requestedCompanyId,
List<Long> userIds) {
ensureSuperAdminOperator(operator);
PermissionMenuEntity dataPermission = requireImageVideoDataPermission();
Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
PermissionMenuEntity dataPermission = requireImageVideoDataPermission(companyId);
List<Long> requestedIds = normalizeColumnIds(userIds);
List<AdminUserEntity> users = adminUserMapper.selectList(grantableUserQuery());
List<AdminUserEntity> users = adminUserMapper.selectList(grantableUserQuery(companyId));
Map<Long, AdminUserEntity> grantableUsers = users.stream()
.filter(user -> user.getId() != null && !isSuperAdmin(user))
.collect(Collectors.toMap(AdminUserEntity::getId, Function.identity(), (left, right) -> left));
@@ -448,15 +658,22 @@ public class PermissionMenuService {
}
public List<ImageVideoDataPermissionUserVo> listShopDataCrawlDataPermissionUsers(AdminUserEntity operator) {
return listShopDataCrawlDataPermissionUsers(operator, null);
}
/** 与视频任务那一路同口径:内部数据权限行与用户列表必须解析到同一家公司。 */
public List<ImageVideoDataPermissionUserVo> listShopDataCrawlDataPermissionUsers(AdminUserEntity operator,
Long requestedCompanyId) {
ensureSuperAdminOperator(operator, "店铺数据任务");
Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
PermissionMenuEntity dataPermission = requireDataPermission(
SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
companyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
Set<Long> grantedUserIds = userColumnPermissionMapper.selectByColumnId(dataPermission.getId())
.stream()
.map(UserColumnPermissionEntity::getUserId)
.filter(id -> id != null && id > 0)
.collect(Collectors.toSet());
return adminUserMapper.selectList(grantableUserQuery()
return adminUserMapper.selectList(grantableUserQuery(companyId)
.orderByAsc(AdminUserEntity::getUsername)
.orderByAsc(AdminUserEntity::getId))
.stream()
@@ -467,11 +684,18 @@ public class PermissionMenuService {
@Transactional
public int updateShopDataCrawlDataPermissionUsers(AdminUserEntity operator, List<Long> userIds) {
return updateShopDataCrawlDataPermissionUsers(operator, null, userIds);
}
@Transactional
public int updateShopDataCrawlDataPermissionUsers(AdminUserEntity operator, Long requestedCompanyId,
List<Long> userIds) {
ensureSuperAdminOperator(operator, "店铺数据任务");
Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
PermissionMenuEntity dataPermission = requireDataPermission(
SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
companyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
List<Long> requestedIds = normalizeColumnIds(userIds);
List<AdminUserEntity> users = adminUserMapper.selectList(grantableUserQuery());
List<AdminUserEntity> users = adminUserMapper.selectList(grantableUserQuery(companyId));
Map<Long, AdminUserEntity> grantableUsers = users.stream()
.filter(user -> user.getId() != null && !isSuperAdmin(user))
.collect(Collectors.toMap(AdminUserEntity::getId, Function.identity(), (left, right) -> left));
@@ -505,12 +729,15 @@ public class PermissionMenuService {
if (isSuperAdmin(operator)) {
return;
}
// 三行都按操作者本公司解析:换键之后同一个 key 每家公司各一行,
// 少带条件就是 LIMIT 1 跨公司借位(§4 里最危险的那处静默失效)。
Long companyId = operator.getCompanyId();
PermissionMenuEntity taskMenu = requireDataPermission(
"admin_shop_data_crawl_tasks", "店铺数据任务管理菜单");
companyId, "admin_shop_data_crawl_tasks", "店铺数据任务管理菜单");
PermissionMenuEntity duplicateCheckMenu = requireDataPermission(
"admin_shop_data_duplicate_check", "店铺数据重复检查菜单");
companyId, "admin_shop_data_duplicate_check", "店铺数据重复检查菜单");
PermissionMenuEntity dataPermission = requireDataPermission(
SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
companyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
boolean hasShopDataMenu = hasEffectiveColumnPermission(operator.getId(), taskMenu.getId())
|| hasEffectiveColumnPermission(operator.getId(), duplicateCheckMenu.getId());
if (!hasShopDataMenu || !hasEffectiveColumnPermission(operator.getId(), dataPermission.getId())) {
@@ -532,7 +759,8 @@ public class PermissionMenuService {
if (isSuperAdmin(operator)) {
return;
}
PermissionMenuEntity menu = requireDataPermission("admin_task_center", "客户端任务管理菜单");
PermissionMenuEntity menu = requireDataPermission(
operator.getCompanyId(), "admin_task_center", "客户端任务管理菜单");
if (!hasEffectiveColumnPermission(operator.getId(), menu.getId())) {
throw new BusinessException(403, "无权查看客户端任务管理");
}
@@ -549,7 +777,7 @@ public class PermissionMenuService {
if (isSuperAdmin(operator)) {
return true;
}
List<PermissionMenuEntity> menus = loadMenus(MENU_TYPE_ADMIN);
List<PermissionMenuEntity> menus = loadMenus(operator.getCompanyId(), MENU_TYPE_ADMIN);
List<Long> wantedIds = menus.stream()
.filter(menu -> menu.getColumnKey() != null && columnKeys.contains(menu.getColumnKey()))
.map(PermissionMenuEntity::getId)
@@ -606,8 +834,11 @@ public class PermissionMenuService {
AdminUserEntity target = getUserById(userId);
ensureTargetAccessible(operator, target);
List<Long> requestedIds = request == null ? List.of() : normalizeColumnIds(request.getColumnIds());
// 整条链的归属口径 = 目标账号<b>自己那棵树</b>(不是操作者的):超管替德阳配权限时,
// 勾选与落库都必须指向德阳的菜单行 id,否则写进去的授权在本公司的树上认不出来。
Long targetCompanyId = target.getCompanyId();
// 出口 3(提交授权):超管专属项在这里被剥掉,越权校验与落库都看不到它(剥而不拒)。
requestedIds = stripSuperAdminOnlyGrantIds(requestedIds, operator);
requestedIds = stripSuperAdminOnlyGrantIds(requestedIds, operator, targetCompanyId);
String normalizedType = menuType == null || menuType.isBlank()
? null
: normalizeMenuTypeRequired(menuType);
@@ -616,13 +847,14 @@ public class PermissionMenuService {
if (normalizedType == null) {
if (!requestedIds.isEmpty()) {
Long validCount = permissionMenuMapper.selectCount(new LambdaQueryWrapper<PermissionMenuEntity>()
.eq(PermissionMenuEntity::getCompanyId, targetCompanyId)
.in(PermissionMenuEntity::getId, requestedIds));
if (validCount == null || validCount != requestedIds.size()) {
throw new BusinessException("存在无效的菜单权限项");
}
}
} else {
scopedMenuIds.addAll(loadMenus(normalizedType).stream()
scopedMenuIds.addAll(loadMenus(targetCompanyId, normalizedType).stream()
.map(PermissionMenuEntity::getId)
.filter(Objects::nonNull)
.toList());
@@ -633,9 +865,9 @@ public class PermissionMenuService {
Set<Long> protectedIds = new LinkedHashSet<>();
if (normalizedType == null) {
PermissionMenuEntity imageVideoDataPermission = findImageVideoDataPermission();
PermissionMenuEntity imageVideoDataPermission = findImageVideoDataPermission(targetCompanyId);
PermissionMenuEntity shopDataCrawlDataPermission =
findDataPermission(SHOP_DATA_CRAWL_DATA_PERMISSION_KEY);
findDataPermission(targetCompanyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY);
if (imageVideoDataPermission != null && imageVideoDataPermission.getId() != null) {
protectedIds.add(imageVideoDataPermission.getId());
}
@@ -686,7 +918,8 @@ public class PermissionMenuService {
userColumnPermissionMapper.insert(entity);
}
if (MENU_TYPE_ADMIN.equals(normalizedType)) {
autoGrantShopDataDataPermission(userId, finalGrantIds, loadMenus(MENU_TYPE_ADMIN));
autoGrantShopDataDataPermission(userId, finalGrantIds,
loadMenus(targetCompanyId, MENU_TYPE_ADMIN), targetCompanyId);
}
// 目标管理员的权限被回收后,其直接创建的员工若仍持有超出范围的
@@ -712,13 +945,13 @@ public class PermissionMenuService {
* 只增不删:数据授权的回收仍走超管专用的「数据范围授权」UI。
*/
private void autoGrantShopDataDataPermission(Long userId, Set<Long> directGrantIds,
List<PermissionMenuEntity> adminMenus) {
List<PermissionMenuEntity> adminMenus, Long companyId) {
if (directGrantIds.isEmpty() || adminMenus.isEmpty()) {
return;
}
PermissionMenuEntity taskMenu = findDataPermission("admin_shop_data_crawl_tasks");
PermissionMenuEntity duplicateCheckMenu = findDataPermission("admin_shop_data_duplicate_check");
PermissionMenuEntity dataPermission = findDataPermission(SHOP_DATA_CRAWL_DATA_PERMISSION_KEY);
PermissionMenuEntity taskMenu = findDataPermission(companyId, "admin_shop_data_crawl_tasks");
PermissionMenuEntity duplicateCheckMenu = findDataPermission(companyId, "admin_shop_data_duplicate_check");
PermissionMenuEntity dataPermission = findDataPermission(companyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY);
if (dataPermission == null || dataPermission.getId() == null) {
return;
}
@@ -755,12 +988,16 @@ public class PermissionMenuService {
if (target == null || target.getId() == null || isSuperAdmin(target)) {
return;
}
Long companyId = target.getCompanyId();
Set<Long> targetEffectiveIds = expandDescendantIds(
new LinkedHashSet<>(loadDirectColumnIds(target.getId())), loadMenus(null));
// 只用到 id:不要为一次级联清理把整表(含密码哈希)拉回
new LinkedHashSet<>(loadDirectColumnIds(target.getId())), loadMenus(companyId, null));
// 只用到 id:不要为一次级联清理把整表(含密码哈希)拉回。
// 下属集要同时按公司筛:这段是批量删除,一旦 created_by 出现跨公司的脏数据,
// "越权"判定就会拿 A 家的有效集去删 B 家员工的授权——删多隔离比删少更贵。
List<AdminUserEntity> subordinates = adminUserMapper.selectList(new LambdaQueryWrapper<AdminUserEntity>()
.select(AdminUserEntity::getId)
.eq(AdminUserEntity::getCreatedById, target.getId()));
.eq(AdminUserEntity::getCreatedById, target.getId())
.eq(companyId != null, AdminUserEntity::getCompanyId, companyId));
for (AdminUserEntity subordinate : subordinates) {
Long subordinateId = subordinate.getId();
if (subordinateId == null || subordinateId.equals(target.getId())) {
@@ -782,8 +1019,14 @@ public class PermissionMenuService {
}
}
private List<PermissionMenuEntity> loadMenus(String menuType) {
List<PermissionMenuEntity> rows = loadRawMenus(menuType);
/**
* 目录取数的唯一出口(§4):{@code companyId} 非空时只返回那一棵树的行。
* 授权树、有效菜单、可授予全集、越权判定都从这里取数,所以公司收窄改这一处就够一片。
*
* @param companyId null 只来自「无操作者 / 无归属」的历史与测试路径,此时退回全量目录
*/
private List<PermissionMenuEntity> loadMenus(Long companyId, String menuType) {
List<PermissionMenuEntity> rows = loadRawMenus(companyId, menuType);
if (rows == null || rows.isEmpty()) {
return List.of();
}
@@ -794,13 +1037,14 @@ public class PermissionMenuService {
}
/**
* Fetches every menu (optionally scoped to one type) in insertion order.
* Sorting happens in {@link #loadMenus(String)} and only for hierarchies
* Fetches every menu (optionally scoped to one company and one type) in insertion order.
* Sorting happens in {@link #loadMenus(Long, String)} and only for hierarchies
* that actually need one, keeping raw SQL and comparator semantics in sync.
*/
private List<PermissionMenuEntity> loadRawMenus(String menuType) {
private List<PermissionMenuEntity> loadRawMenus(Long companyId, String menuType) {
String normalizedType = normalizeMenuType(menuType);
LambdaQueryWrapper<PermissionMenuEntity> query = new LambdaQueryWrapper<PermissionMenuEntity>()
.eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(normalizedType != null, PermissionMenuEntity::getMenuType, normalizedType)
.orderByAsc(PermissionMenuEntity::getSortOrder)
.orderByAsc(PermissionMenuEntity::getId);
@@ -1006,11 +1250,12 @@ public class PermissionMenuService {
* 唯一例外是超管且 menuType 为空的「整树替换」分支:{@code deleteByUserId} 先清空目标整个
* 分区再按提交重插,被剥的这条按既有语义就不会回来——那是该分支本来就有的行为,不是剥离引入的。
*/
private List<Long> stripSuperAdminOnlyGrantIds(List<Long> requestedIds, AdminUserEntity operator) {
private List<Long> stripSuperAdminOnlyGrantIds(List<Long> requestedIds, AdminUserEntity operator,
Long companyId) {
if (requestedIds.isEmpty()) {
return requestedIds;
}
Set<Long> restricted = superAdminOnlyMenuIds();
Set<Long> restricted = superAdminOnlyMenuIds(companyId);
if (restricted.isEmpty()) {
return requestedIds;
}
@@ -1029,8 +1274,12 @@ public class PermissionMenuService {
* <p>一次全量目录查询折出来,绝不按 id 逐条点查:保存权限这个入口上 N 次点查会被日志放大,
* 而 {@code findDataPermission} 每次都是一个 {@code selectOne}。</p>
*/
private Set<Long> superAdminOnlyMenuIds() {
return loadMenus(null).stream()
/**
* <p>V149 之后这行闸门菜单只存在于公司 1 的树里(§2 D3:副本不复制它),所以别家公司
* 拿到的是空集——那里的提交里本来就不可能有它,剥离逻辑照常走完,不多一条分支。</p>
*/
private Set<Long> superAdminOnlyMenuIds(Long companyId) {
return loadMenus(companyId, null).stream()
.filter(menu -> SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey()))
.map(PermissionMenuEntity::getId)
.collect(Collectors.toCollection(LinkedHashSet::new));
@@ -1073,12 +1322,12 @@ public class PermissionMenuService {
return !Integer.valueOf(1).equals(user.getIsAdmin());
}
private PermissionMenuEntity findImageVideoDataPermission() {
return findDataPermission(IMAGE_VIDEO_DATA_PERMISSION_KEY);
private PermissionMenuEntity findImageVideoDataPermission(Long companyId) {
return findDataPermission(companyId, IMAGE_VIDEO_DATA_PERMISSION_KEY);
}
private PermissionMenuEntity requireImageVideoDataPermission() {
PermissionMenuEntity permission = findImageVideoDataPermission();
private PermissionMenuEntity requireImageVideoDataPermission(Long companyId) {
PermissionMenuEntity permission = findImageVideoDataPermission(companyId);
if (permission == null || permission.getId() == null) {
throw new BusinessException("视频任务数据权限尚未初始化");
}
@@ -1099,14 +1348,20 @@ public class PermissionMenuService {
}
}
private PermissionMenuEntity findDataPermission(String columnKey) {
/**
* 按 key 点查一行菜单。<b>必须带公司</b>:V149 之后同一个 key 在每家公司各有一行,
* 少了这个条件就是 {@code LIMIT 1} 跨公司借位——拿到别家的行 id 再往本账号身上写一条
* 本公司树里认不出的授权,页面显示"已授权"、权限却永远不生效,且不报任何错。
*/
private PermissionMenuEntity findDataPermission(Long companyId, String columnKey) {
return permissionMenuMapper.selectOne(new LambdaQueryWrapper<PermissionMenuEntity>()
.eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getColumnKey, columnKey)
.last("LIMIT 1"));
}
private PermissionMenuEntity requireDataPermission(String columnKey, String displayName) {
PermissionMenuEntity permission = findDataPermission(columnKey);
private PermissionMenuEntity requireDataPermission(Long companyId, String columnKey, String displayName) {
PermissionMenuEntity permission = findDataPermission(companyId, columnKey);
if (permission == null || permission.getId() == null) {
throw new BusinessException(displayName + "权限尚未初始化");
}
@@ -1126,7 +1381,7 @@ public class PermissionMenuService {
return vo;
}
private void ensureParentValid(Long parentId, Long currentId, String menuType) {
private void ensureParentValid(Long companyId, Long parentId, Long currentId, String menuType) {
if (parentId == null) {
return;
}
@@ -1151,6 +1406,11 @@ public class PermissionMenuService {
if (currentId != null && currentId.equals(cursor.getId())) {
throw new BusinessException("父级菜单不能选择自己的子级");
}
// fk_columns_parent_id 只保证父行存在,挡不住跨公司挂父(§3.6),同公司判定只能做在这里。
// 整条祖先链都判:一个同公司的父、上面挂着别家的分组,落库后这行在两棵树里都渲染不出。
if (companyId != null && !companyId.equals(cursor.getCompanyId())) {
throw new BusinessException("父级菜单必须与当前菜单属于同一公司");
}
Long ancestorId = cursor.getParentId();
if (ancestorId == null) {
break;
@@ -1173,8 +1433,10 @@ public class PermissionMenuService {
}
}
private void ensureUniqueColumnKey(String columnKey, Long excludeId) {
/** 查重范围 = 本公司(与 {@code uk_company_column_key} 同一条键)。不加条件会拿别家的副本误报"已存在"。 */
private void ensureUniqueColumnKey(Long companyId, String columnKey, Long excludeId) {
PermissionMenuEntity exists = permissionMenuMapper.selectOne(new LambdaQueryWrapper<PermissionMenuEntity>()
.eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getColumnKey, columnKey)
.last("LIMIT 1"));
if (exists != null && (excludeId == null || !excludeId.equals(exists.getId()))) {
@@ -1182,8 +1444,10 @@ public class PermissionMenuService {
}
}
private void ensureUniqueRoutePath(String menuType, String routePath, Long excludeId) {
/** 同上,对应 {@code uk_company_menu_type_route_path}。 */
private void ensureUniqueRoutePath(Long companyId, String menuType, String routePath, Long excludeId) {
PermissionMenuEntity exists = permissionMenuMapper.selectOne(new LambdaQueryWrapper<PermissionMenuEntity>()
.eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getMenuType, menuType)
.eq(PermissionMenuEntity::getRoutePath, routePath)
.last("LIMIT 1"));
@@ -1297,7 +1561,7 @@ public class PermissionMenuService {
}
private PermissionMenuItemVo toItemVo(PermissionMenuEntity entity) {
return toItemVos(List.of(entity), loadMenus(entity.getMenuType())).getFirst();
return toItemVos(List.of(entity), loadMenus(entity.getCompanyId(), entity.getMenuType())).getFirst();
}
private PermissionMenuItemVo toItemVo(PermissionMenuEntity entity,
@@ -1333,14 +1597,16 @@ public class PermissionMenuService {
/**
* Resolves the default sort order when none is supplied, scoped to the
* menu's own type (parent takes precedence, then hierarchy ancestors).
* The DB query mirrors {@link #loadMenus(String)} ordering so the last row
* is the true tail of the type's ordering.
* The DB query mirrors {@link #loadMenus(Long, String)} ordering so the last row
* is the true tail of the type's ordering, and the same company the new row lands in
* (两棵树的 sort_order 各排各的,跨公司取 MAX 会让两排同名菜单交织)。
*/
private Integer resolveSortOrder(String menuType, Integer sortOrder, Long excludeId) {
private Integer resolveSortOrder(Long companyId, String menuType, Integer sortOrder, Long excludeId) {
if (sortOrder != null) {
return sortOrder;
}
PermissionMenuEntity tail = permissionMenuMapper.selectOne(new LambdaQueryWrapper<PermissionMenuEntity>()
.eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getMenuType, normalizeMenuType(menuType))
.ne(excludeId != null, PermissionMenuEntity::getId, excludeId)
.orderByDesc(PermissionMenuEntity::getSortOrder)
@@ -1,8 +1,6 @@
package com.nanri.aiimage.modules.productcategory.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.common.util.DownloadHeaderUtil;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
@@ -10,7 +8,6 @@ import com.nanri.aiimage.modules.productcategory.model.vo.ProductCategoryItemVo;
import com.nanri.aiimage.modules.productcategory.model.vo.ProductCategoryListVo;
import com.nanri.aiimage.modules.productcategory.service.ProductCategoryService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
@@ -34,24 +31,21 @@ import java.time.format.DateTimeFormatter;
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/admin")
@Tag(name = "商品类目管理", description = "维护商品类目树")
@Tag(name = "商品类目管理", description = "维护商品类目树(全平台共享,不按公司区分)")
public class ProductCategoryController {
private static final DateTimeFormatter EXPORT_FILENAME_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss");
private final ProductCategoryService productCategoryService;
private final AdminAuthSupport adminAuthSupport;
private final DataReadScope dataReadScope;
@GetMapping("/product-categories")
@Operation(summary = "查询商品类目树")
public ApiResponse<ProductCategoryListVo> list(
HttpServletRequest request,
@RequestParam(value = "keyword", required = false) String keyword,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
return ApiResponse.success(productCategoryService.list(keyword, scopedCompanyId));
@RequestParam(value = "keyword", required = false) String keyword) {
adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success(productCategoryService.list(keyword));
}
@GetMapping("/product-categories/children")
@@ -60,11 +54,9 @@ public class ProductCategoryController {
HttpServletRequest request,
@RequestParam(value = "parent_id", required = false) Long parentId,
@RequestParam(value = "page", defaultValue = "1") Long page,
@RequestParam(value = "page_size", defaultValue = "20") Long pageSize,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
return ApiResponse.success(productCategoryService.children(parentId, page, pageSize, scopedCompanyId));
@RequestParam(value = "page_size", defaultValue = "20") Long pageSize) {
adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success(productCategoryService.children(parentId, page, pageSize));
}
@GetMapping("/product-categories/search")
@@ -73,22 +65,18 @@ public class ProductCategoryController {
HttpServletRequest request,
@RequestParam(value = "keyword", required = false) String keyword,
@RequestParam(value = "page", defaultValue = "1") Long page,
@RequestParam(value = "page_size", defaultValue = "20") Long pageSize,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
return ApiResponse.success(productCategoryService.search(keyword, page, pageSize, scopedCompanyId));
@RequestParam(value = "page_size", defaultValue = "20") Long pageSize) {
adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success(productCategoryService.search(keyword, page, pageSize));
}
@GetMapping("/product-categories/export")
@Operation(summary = "导出商品类目")
public ResponseEntity<byte[]> export(
HttpServletRequest request,
@RequestParam(value = "keyword", required = false) String keyword,
@Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
byte[] bytes = productCategoryService.export(keyword, scopedCompanyId);
@RequestParam(value = "keyword", required = false) String keyword) {
adminAuthSupport.requireAdminOrInternal(request);
byte[] bytes = productCategoryService.export(keyword);
String filename = "product-categories-" + LocalDateTime.now().format(EXPORT_FILENAME_FORMATTER) + ".xlsx";
return ResponseEntity.ok()
.header(HttpHeaders.CONTENT_DISPOSITION, DownloadHeaderUtil.contentDisposition(filename))
@@ -102,10 +90,8 @@ public class ProductCategoryController {
public ApiResponse<ProductCategoryItemVo> create(
HttpServletRequest request,
@Valid @RequestBody ProductCategorySaveRequest body) {
// 归属只从会话推(请求体一律不带 company_id):service 里 requireCompanyId 取不到就抛,
// 不让 V147 的 DEFAULT 1 静默兜住。
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("创建成功", productCategoryService.create(body, operator.getId()));
adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("创建成功", productCategoryService.create(body));
}
@PutMapping("/product-category/{id}")
@@ -114,10 +100,8 @@ public class ProductCategoryController {
HttpServletRequest request,
@PathVariable Long id,
@Valid @RequestBody ProductCategorySaveRequest body) {
// 写侧闸门与读侧同源:读已经收窄到本公司,写不收窄就是"藏起来的行照样能删"。
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("保存成功",
productCategoryService.update(id, body, dataReadScope.writeCompanyId(operator)));
adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("保存成功", productCategoryService.update(id, body));
}
@DeleteMapping("/product-category/{id}")
@@ -125,8 +109,8 @@ public class ProductCategoryController {
public ApiResponse<Void> delete(
HttpServletRequest request,
@PathVariable Long id) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
productCategoryService.delete(id, dataReadScope.writeCompanyId(operator));
adminAuthSupport.requireAdminOrInternal(request);
productCategoryService.delete(id);
return ApiResponse.success("删除成功", null);
}
}
@@ -7,20 +7,19 @@ import lombok.Data;
import java.time.LocalDateTime;
/**
* 商品类目——<b>全平台共享的一棵树,不按公司区分</b>(控制方 2026-10-06 定案)。
*
* <p>所以这里<b>不声明</b> {@code company_id} 字段。库里那一列(V147 加的,带临时 {@code DEFAULT 1})
* 暂时还在,但没有任何读写路径引用它:不声明字段 ⇒ MyBatis-Plus 的 SELECT 列清单与 INSERT 都不含它
* ⇒ 新 jar 配旧库(列还在)不会报错,摘列则必须等两台都跑上这一版(见 migration-inventory 的下一版待办)。</p>
*/
@Data
@TableName("biz_product_category")
public class ProductCategoryEntity {
@TableId(type = IdType.AUTO)
private Long id;
/**
* 归属公司(V147)。{@code 0} = 平台内置共享节点(不是 company 表里的行),其余是那一家的自建节点。
*
* <p>写侧必须显式盖章:这一列在 V147 里带着<b>临时</b>的 {@code DEFAULT 1}(旧 jar 的实体没这字段),
* 漏传不会报错、会被静默塞进厦门米椿花。{@code ProductCategoryService.create} 因此走
* {@code CompanyScopeSupport.requireCompanyId}(取不到就抛),不依赖这一默认值。</p>
*/
private Long companyId;
private Long parentId;
private String name;
private String categoryKey;
@@ -4,7 +4,6 @@ import cn.hutool.crypto.digest.DigestUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.productcategory.mapper.ProductCategoryMapper;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
import com.nanri.aiimage.modules.productcategory.model.entity.ProductCategoryEntity;
@@ -28,6 +27,7 @@ import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
@Service
@RequiredArgsConstructor
@@ -35,109 +35,71 @@ public class ProductCategoryService {
private static final DateTimeFormatter EXPORT_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
/**
* 内置节点的哨兵归属(V147 回填):它不是公司表里的行,而是"所有公司都看得见、谁都不拥有"的那半棵树。
*
* <p>取 0 是因为 {@code company.id} 从 1 起自增,而 {@code CompanyScopeSupport.requireCompanyId}
* 对 {@code <= 0} 直接抛 ⇒ 没有任何账号会被登记成 0 号公司,这个值和真实公司永不撞。</p>
*/
static final long SHARED_BUILTIN_COMPANY_ID = 0L;
private final ProductCategoryMapper productCategoryMapper;
private final CompanyScopeSupport companyScopeSupport;
/**
* 全平台类目树——<b>不按公司筛,且不许改成按公司筛</b>。
* 全平台一棵树——<b>不按公司筛,且不许改成按公司筛</b>(控制方 2026-10-06 定案:商品类目共享、不区分)。
*
* <p>唯一的消费者是货源/外观的类目归类({@code SimilarAsinLlmService:215 CategoryTree.load(list())})。
* 那一侧按公司切会同时改两件事:候选节点变少(分类结果按公司分叉)与 prompt 里的类目表变化(影响 LLM 成本)。
* 后台的公司 tab 走 {@link #list(String, Long)},两件事别混。</p>
* <p>两个消费者共用它:后台这一页,以及货源/外观的类目归类
* ({@code SimilarAsinLlmService:215 CategoryTree.load(list())})。后者若按公司切会同时改两件事:
* 候选节点变少(分类结果按公司分叉)与 prompt 里的类目表变化(影响 LLM 成本)。</p>
*/
public ProductCategoryListVo list() {
return list(null);
}
/** 不筛公司(超管没选 tab 时的口径,与改造前一致)。 */
public ProductCategoryListVo list(String keyword) {
return list(keyword, null);
}
/**
* @param companyId 要收窄到的公司;null = 不筛。内置节点({@value #SHARED_BUILTIN_COMPANY_ID})
* 在任何公司的视图里都可见,否则第 2 家的类目树会是空的、连一个自建根都挂不上。
*/
public ProductCategoryListVo list(String keyword, Long companyId) {
List<ProductCategoryEntity> rows = productCategoryMapper.selectList(applyCompanyScope(
List<ProductCategoryEntity> rows = productCategoryMapper.selectList(
new LambdaQueryWrapper<ProductCategoryEntity>()
.orderByAsc(ProductCategoryEntity::getParentId)
.orderByAsc(ProductCategoryEntity::getSortOrder)
.orderByAsc(ProductCategoryEntity::getId),
companyId));
.orderByAsc(ProductCategoryEntity::getId));
rows = filterRowsByKeyword(rows, keyword);
return buildListVo(rows);
}
public ProductCategoryListVo children(Long parentId, long page, long pageSize) {
return children(parentId, page, pageSize, null);
}
public ProductCategoryListVo children(Long parentId, long page, long pageSize, Long companyId) {
long safePage = Math.max(page, 1);
long safePageSize = normalizePageSize(pageSize);
Long normalizedParentId = normalizeParentId(parentId);
LambdaQueryWrapper<ProductCategoryEntity> countQuery = applyCompanyScope(new LambdaQueryWrapper<>(), companyId);
LambdaQueryWrapper<ProductCategoryEntity> countQuery = new LambdaQueryWrapper<>();
applyParentFilter(countQuery, normalizedParentId);
Long total = productCategoryMapper.selectCount(countQuery);
LambdaQueryWrapper<ProductCategoryEntity> pageQuery = applyCompanyScope(
new LambdaQueryWrapper<ProductCategoryEntity>()
.orderByAsc(ProductCategoryEntity::getSortOrder)
.orderByAsc(ProductCategoryEntity::getId),
companyId)
LambdaQueryWrapper<ProductCategoryEntity> pageQuery = new LambdaQueryWrapper<ProductCategoryEntity>()
.orderByAsc(ProductCategoryEntity::getSortOrder)
.orderByAsc(ProductCategoryEntity::getId)
.last("LIMIT " + ((safePage - 1) * safePageSize) + ", " + safePageSize);
applyParentFilter(pageQuery, normalizedParentId);
List<ProductCategoryEntity> rows = productCategoryMapper.selectList(pageQuery);
return buildPageVo(rows, total, safePage, safePageSize, companyId);
return buildPageVo(rows, total, safePage, safePageSize);
}
public ProductCategoryListVo search(String keyword, long page, long pageSize) {
return search(keyword, page, pageSize, null);
}
public ProductCategoryListVo search(String keyword, long page, long pageSize, Long companyId) {
String normalized = normalizeSearchKeyword(keyword);
if (normalized.isBlank()) {
return emptyPageVo(Math.max(page, 1), normalizePageSize(pageSize));
}
long safePage = Math.max(page, 1);
long safePageSize = normalizePageSize(pageSize);
Long total = productCategoryMapper.selectCount(buildSearchQuery(normalized, companyId));
List<ProductCategoryEntity> rows = productCategoryMapper.selectList(buildSearchQuery(normalized, companyId)
Long total = productCategoryMapper.selectCount(buildSearchQuery(normalized));
List<ProductCategoryEntity> rows = productCategoryMapper.selectList(buildSearchQuery(normalized)
.orderByAsc(ProductCategoryEntity::getParentId)
.orderByAsc(ProductCategoryEntity::getSortOrder)
.orderByAsc(ProductCategoryEntity::getId)
.last("LIMIT " + ((safePage - 1) * safePageSize) + ", " + safePageSize));
return buildSearchPageVo(rows, total, safePage, safePageSize, companyId);
return buildSearchPageVo(rows, total, safePage, safePageSize);
}
/**
* 归属由<b>操作者会话</b>推导(请求体/查询参数一律不带 company_id):漏了这一句,新类目就会被
* V147 的 {@code DEFAULT 1} 静默塞进厦门米椿花——那是"归属失真且不报错",而 {@code requireCompanyId}
* 取不到公司时是抛,不会返回 null。所以这里<b>不保留</b>不带操作者的重载:留着它等于留着一个
* "调用方忘了传也照样绿"的出口。
*
* @param operatorId 操作者账号 id
*/
/** 新建的类目落进全平台共享的那一棵树:谁建的都不记归属,只保证同级不重名。 */
@Transactional
public ProductCategoryItemVo create(ProductCategorySaveRequest request, Long operatorId) {
public ProductCategoryItemVo create(ProductCategorySaveRequest request) {
String name = normalizeRequired(request.getName(), "类目名称不能为空");
Long parentId = normalizeParentId(request.getParentId());
Long companyId = companyScopeSupport.requireCompanyId(operatorId);
ensureParentVisible(parentId, null, companyId);
ensureSiblingNameUnique(parentId, name, null, companyId);
ensureParentVisible(parentId, null);
ensureSiblingNameUnique(parentId, name, null);
ProductCategoryEntity entity = new ProductCategoryEntity();
entity.setCompanyId(companyId);
entity.setParentId(parentId);
entity.setName(name);
entity.setCategoryKey(generateCategoryKey(parentId, name));
@@ -148,22 +110,13 @@ public class ProductCategoryService {
return findItem(entity.getId());
}
/**
* @param writableCompanyId 行归属闸门({@code DataReadScope.writeCompanyId} 给):
* {@code null} = 平台超管不限,否则只能动这一家自己的行。
* 读侧收窄而写侧不收窄="藏起来的行仍然能删",那是静默删除不是隔离。
*/
@Transactional
public ProductCategoryItemVo update(Long id, ProductCategorySaveRequest request, Long writableCompanyId) {
public ProductCategoryItemVo update(Long id, ProductCategorySaveRequest request) {
ProductCategoryEntity entity = getById(id);
assertRowWritable(entity, writableCompanyId);
String name = normalizeRequired(request.getName(), "类目名称不能为空");
Long parentId = normalizeParentId(request.getParentId());
// 改行时"生效公司"取行自己的归属,不取 tab:内置行归 0、自建行归那一家,
// 换父级时不能把行挪到可见集外的节点下面(那会让它从原本看得见它的 tab 里消失)。
Long companyId = entity.getCompanyId();
ensureParentVisible(parentId, id, companyId);
ensureSiblingNameUnique(parentId, name, id, companyId);
ensureParentVisible(parentId, id);
ensureSiblingNameUnique(parentId, name, id);
entity.setParentId(parentId);
entity.setName(name);
@@ -174,9 +127,8 @@ public class ProductCategoryService {
}
@Transactional
public void delete(Long id, Long writableCompanyId) {
public void delete(Long id) {
ProductCategoryEntity entity = getById(id);
assertRowWritable(entity, writableCompanyId);
Long childCount = productCategoryMapper.selectCount(new LambdaQueryWrapper<ProductCategoryEntity>()
.eq(ProductCategoryEntity::getParentId, entity.getId()));
if (childCount != null && childCount > 0) {
@@ -185,29 +137,13 @@ public class ProductCategoryService {
productCategoryMapper.deleteById(entity.getId());
}
/**
* 行归属闸门。走 {@code assertSameCompany} 而不是在这里比一次:它对本仓所有"按公司写"的闸门
* 是唯一一份判定,两处各写就会有一处先漂。
*
* <p>内置节点(哨兵 0)在这一支里必然被拒——{@code 0 != 任何真实公司 id},
* 而"公司账号能改/删平台内置类目"正是这一页最容易出事的一刀:改了它,
* 所有公司的类目树与货源归类的候选表同一天跟着变。</p>
*/
private void assertRowWritable(ProductCategoryEntity row, Long writableCompanyId) {
if (writableCompanyId == null) {
return;
}
companyScopeSupport.assertSameCompany(writableCompanyId, row.getCompanyId(),
"无权修改该类目:内置类目或别家公司的类目不在本公司的写范围内");
}
private ProductCategoryItemVo findItem(Long id) {
ProductCategoryEntity entity = getById(id);
Long childCount = productCategoryMapper.selectCount(new LambdaQueryWrapper<ProductCategoryEntity>()
.eq(ProductCategoryEntity::getParentId, entity.getId()));
ProductCategoryItemVo item = toItemVo(entity, childCount == null ? 0 : childCount.intValue());
item.setLevel(resolveLevel(entity));
item.setPath(resolvePath(entity));
item.setLevel(resolveLevel(entity, productCategoryMapper::selectById));
item.setPath(resolvePath(entity, productCategoryMapper::selectById));
return item;
}
@@ -236,10 +172,16 @@ public class ProductCategoryService {
return vo;
}
private ProductCategoryListVo buildPageVo(List<ProductCategoryEntity> rows, Long total, long page, long pageSize, Long companyId) {
Map<Long, Integer> childCountById = buildChildCountById(rows, companyId);
private ProductCategoryListVo buildPageVo(List<ProductCategoryEntity> rows, Long total, long page, long pageSize) {
Map<Long, Integer> childCountById = buildChildCountById(rows);
Map<Long, ProductCategoryEntity> ancestors = loadAncestorIndex(rows);
List<ProductCategoryItemVo> items = rows.stream()
.map(row -> toItemVo(row, childCountById.getOrDefault(row.getId(), 0)))
.map(row -> {
ProductCategoryItemVo item = toItemVo(row, childCountById.getOrDefault(row.getId(), 0));
item.setLevel(resolveLevel(row, ancestors::get));
item.setPath(resolvePath(row, ancestors::get));
return item;
})
.toList();
ProductCategoryListVo vo = new ProductCategoryListVo();
vo.setItems(items);
@@ -251,13 +193,9 @@ public class ProductCategoryService {
return vo;
}
/** 导出的行集合必须与页面列表同源:都走 {@link #list(String, Long)},否则"tab 里看不见但导出里有"就是第二个真相源。 */
/** 导出的行集合必须与页面列表同源:都走 {@link #list(String)},否则"页面里没有但导出里有"就是第二个真相源。 */
public byte[] export(String keyword) {
return export(keyword, null);
}
public byte[] export(String keyword, Long companyId) {
ProductCategoryListVo list = list(keyword, companyId);
ProductCategoryListVo list = list(keyword);
List<ProductCategoryItemVo> rows = list.getItems() == null ? List.of() : list.getItems();
Map<Long, String> nameById = buildExportNameById(rows);
try (SXSSFWorkbook workbook = new SXSSFWorkbook(100);
@@ -276,13 +214,13 @@ public class ProductCategoryService {
}
}
private ProductCategoryListVo buildSearchPageVo(List<ProductCategoryEntity> rows, Long total, long page, long pageSize, Long companyId) {
Map<Long, Integer> childCountById = buildChildCountById(rows, companyId);
private ProductCategoryListVo buildSearchPageVo(List<ProductCategoryEntity> rows, Long total, long page, long pageSize) {
Map<Long, Integer> childCountById = buildChildCountById(rows);
List<ProductCategoryItemVo> items = rows.stream()
.map(row -> {
ProductCategoryItemVo item = toItemVo(row, childCountById.getOrDefault(row.getId(), 0));
item.setLevel(resolveLevel(row));
item.setPath(resolvePath(row));
item.setLevel(resolveLevel(row, productCategoryMapper::selectById));
item.setPath(resolvePath(row, productCategoryMapper::selectById));
return item;
})
.toList();
@@ -383,12 +321,8 @@ public class ProductCategoryService {
return time == null ? "" : time.format(EXPORT_TIME_FORMATTER);
}
/**
* 列表页的「子类目数」徽章走的是<b>全表聚合</b>(不是内存里那批行),所以它必须和公司视图同源:
* 不加这一段,第 1 家的父节点上会显示"3 个子类目"而 tab 里只列得出一两个——
* 数字来自别人的公司,点开却是自己的树。
*/
private Map<Long, Integer> buildChildCountById(List<ProductCategoryEntity> rows, Long companyId) {
/** 列表页的「子类目数」徽章走全表聚合(不是内存里那批行)——整棵树共享,聚合也就没有"别家的数"这一说。 */
private Map<Long, Integer> buildChildCountById(List<ProductCategoryEntity> rows) {
Map<Long, Integer> childCountById = new HashMap<>();
if (rows.isEmpty()) {
return childCountById;
@@ -396,9 +330,6 @@ public class ProductCategoryService {
QueryWrapper<ProductCategoryEntity> countQuery = new QueryWrapper<ProductCategoryEntity>()
.select("parent_id", "count(*) AS child_count")
.isNotNull("parent_id");
if (companyId != null) {
countQuery.in("company_id", visibleCompanyIds(companyId));
}
List<Map<String, Object>> countRows = productCategoryMapper.selectMaps(countQuery.groupBy("parent_id"));
for (Map<String, Object> countRow : countRows) {
Object parentId = countRow.get("parent_id");
@@ -420,39 +351,19 @@ public class ProductCategoryService {
}
/**
* 关键字命中三条列任一即算命中,但<b>整条 OR 必须包起来再 AND 公司</b>:MyBatis-Plus 的
* {@code or()} 只改"下一个连接符",直接在这串后面 {@code .in(company_id, ...)} 会拼成
* {@code name LIKE ? OR key LIKE ? OR (desc LIKE ? AND company_id IN ...)} —— SQL 里 AND 结合更紧,
* 结果前两条列命中的行<b>不受公司约束</b>,这一页的筛选就成了假的(且不报错)。
* 关键字命中三条列任一即算命中,整条 OR 必须包起来:MyBatis-Plus 的 {@code or()} 只改
* "下一个连接符",直接在这串后面再 AND 别的条件会拼成
* {@code name LIKE ? OR key LIKE ? OR (desc LIKE ? AND ...)} —— SQL 里 AND 结合更紧,
* 前两条列命中的行不受那个条件约束(且不报错)。
*/
private LambdaQueryWrapper<ProductCategoryEntity> buildSearchQuery(String keyword, Long companyId) {
LambdaQueryWrapper<ProductCategoryEntity> query = new LambdaQueryWrapper<ProductCategoryEntity>()
private LambdaQueryWrapper<ProductCategoryEntity> buildSearchQuery(String keyword) {
return new LambdaQueryWrapper<ProductCategoryEntity>()
.and(group -> group
.like(ProductCategoryEntity::getName, keyword)
.or()
.like(ProductCategoryEntity::getCategoryKey, keyword)
.or()
.like(ProductCategoryEntity::getDescription, keyword));
return applyCompanyScope(query, companyId);
}
/**
* 公司视图的唯一落点:null = 不筛(超管没选 tab、非超管、以及 {@link #list()} 那棵给 LLM 的全局树);
* 否则 {@code company_id IN (0, X)} —— 哨兵 0 那批内置节点在任何公司视图里都必须在,
* 不然第 2 家的类目页是一棵空树,它自建不出任何子级(父级只能挂在这批上面)。
*/
private LambdaQueryWrapper<ProductCategoryEntity> applyCompanyScope(
LambdaQueryWrapper<ProductCategoryEntity> query, Long companyId) {
if (companyId != null) {
query.in(ProductCategoryEntity::getCompanyId, visibleCompanyIds(companyId));
}
return query;
}
private List<Long> visibleCompanyIds(Long companyId) {
return companyId == SHARED_BUILTIN_COMPANY_ID
? List.of(SHARED_BUILTIN_COMPANY_ID)
: List.of(SHARED_BUILTIN_COMPANY_ID, companyId);
}
private List<ProductCategoryEntity> filterRowsByKeyword(List<ProductCategoryEntity> rows, String keyword) {
@@ -570,12 +481,43 @@ public class ProductCategoryService {
return vo;
}
private int resolveLevel(ProductCategoryEntity entity) {
/**
* 一次分页里所有行的父链索引:按层批量取,最多 depth 次 {@code selectBatchIds}。
*
* <p>「层级路径」这一列在懒加载通路上曾经是恒空的——{@code /children} 走
* {@link #buildPageVo},它过去只填 {@link #toItemVo}、不设 {@code level}/{@code path},
* 于是前端 {@code path || name} 回退成类目名,那一列画的是「类目」列的副本。补上它就要走父链,
* 而一页最多 100 行、每行按层点查一次,形状是 N+1;这张表只有 412 行所以今天量不出来,
* 但按行按层点查这个形状不该留在这里。</p>
*/
private Map<Long, ProductCategoryEntity> loadAncestorIndex(List<ProductCategoryEntity> rows) {
Map<Long, ProductCategoryEntity> index = new HashMap<>();
Set<Long> pending = new HashSet<>();
for (ProductCategoryEntity row : rows) {
if (row.getParentId() != null) {
pending.add(row.getParentId());
}
}
while (!pending.isEmpty()) {
List<Long> ids = List.copyOf(pending);
pending.clear();
for (ProductCategoryEntity parent : productCategoryMapper.selectBatchIds(ids)) {
if (index.put(parent.getId(), parent) == null
&& parent.getParentId() != null
&& !index.containsKey(parent.getParentId())) {
pending.add(parent.getParentId());
}
}
}
return index;
}
private int resolveLevel(ProductCategoryEntity entity, Function<Long, ProductCategoryEntity> lookup) {
int level = 0;
ProductCategoryEntity cursor = entity;
Set<Long> visited = new HashSet<>();
while (cursor != null && cursor.getParentId() != null && visited.add(cursor.getId())) {
ProductCategoryEntity parent = productCategoryMapper.selectById(cursor.getParentId());
ProductCategoryEntity parent = lookup.apply(cursor.getParentId());
if (parent == null) {
break;
}
@@ -585,13 +527,13 @@ public class ProductCategoryService {
return level;
}
private String resolvePath(ProductCategoryEntity entity) {
private String resolvePath(ProductCategoryEntity entity, Function<Long, ProductCategoryEntity> lookup) {
List<String> names = new ArrayList<>();
ProductCategoryEntity cursor = entity;
Set<Long> visited = new HashSet<>();
while (cursor != null && cursor.getId() != null && visited.add(cursor.getId())) {
names.add(cursor.getName());
cursor = cursor.getParentId() == null ? null : productCategoryMapper.selectById(cursor.getParentId());
cursor = cursor.getParentId() == null ? null : lookup.apply(cursor.getParentId());
}
List<String> ordered = new ArrayList<>();
for (int i = names.size() - 1; i >= 0; i--) {
@@ -608,14 +550,8 @@ public class ProductCategoryService {
return entity;
}
/**
* 父级必须"存在且在这一公司的可见集里"。
*
* <p>只查存在性是不够的:把行的 parent_id 指到别家公司的节点上,这一行就从原本看得见它的
* tab 里消失(读侧按父级子树裁),而 {@code parent_id} 没有外键、库里一声不响。
* companyId 为 null 时不校验——那是改造前/内部调用的口径,不是"允许跨公司挂"。</p>
*/
private void ensureParentVisible(Long parentId, Long currentId, Long companyId) {
/** 父级必须存在,且不能把自己挂到自己的子级下面({@code parent_id} 没有外键,库里一声不响)。 */
private void ensureParentVisible(Long parentId, Long currentId) {
if (parentId == null) {
return;
}
@@ -626,9 +562,6 @@ public class ProductCategoryService {
if (parent == null) {
throw new BusinessException("父级类目不存在");
}
if (companyId != null && !visibleCompanyIds(companyId).contains(parent.getCompanyId())) {
throw new BusinessException(403, "父级类目不属于当前公司");
}
Set<Long> visited = new HashSet<>();
Long cursor = parent.getParentId();
while (cursor != null) {
@@ -644,16 +577,12 @@ public class ProductCategoryService {
}
/**
* 同级重名检查的范围 = 这一家的<b>可见集</b>(自建 + 内置),不是只查自建。
*
* <p>只查自建会让第 2 家在内置父级"护肤品"下建出一个也叫"面霜"的节点,和内置的那个
* 同层同名——页面上一排两个"面霜",而货源归类按名字回填时不知道落到哪一个。
* 反过来,跨家的同名要放行:那正是 {@code uk_company_category_key} 换掉全平台唯一键要解决的问题。</p>
* 同级重名检查的范围 = <b>全平台那一棵树</b>:同层同名必须拦,否则页面上一排两个"面霜",
* 货源归类按名字回填时不知道落到哪一个。
*/
private void ensureSiblingNameUnique(Long parentId, String name, Long excludeId, Long companyId) {
private void ensureSiblingNameUnique(Long parentId, String name, Long excludeId) {
LambdaQueryWrapper<ProductCategoryEntity> query = new LambdaQueryWrapper<ProductCategoryEntity>()
.eq(ProductCategoryEntity::getName, name);
applyCompanyScope(query, companyId);
if (parentId == null) {
query.isNull(ProductCategoryEntity::getParentId);
} else {
@@ -1,7 +1,9 @@
package com.nanri.aiimage.modules.shopkey.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyCreateRequest;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyUpdateRequest;
import com.nanri.aiimage.modules.shopkey.model.vo.ShopKeyItemVo;
@@ -34,22 +36,27 @@ public class ShopKeyController {
private final ShopKeyService shopKeyService;
private final AdminAuthSupport adminAuthSupport;
private final DataReadScope dataReadScope;
@GetMapping
@Operation(summary = "分页查询店铺密钥", description = "分页查询店铺密钥列表。")
@Operation(summary = "分页查询店铺密钥", description = "分页查询店铺密钥列表。company_id 只收窄可见集、不放大:"
+ "超管按 tab 指定的公司读,非超管一律锁本公司(越界公司为空页)。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "查询成功", content = @Content(schema = @Schema(implementation = ShopKeyPageVo.class)))
})
public ApiResponse<ShopKeyPageVo> page(
HttpServletRequest request,
@Parameter(description = "页码") @RequestParam(defaultValue = "1") Long page,
@Parameter(description = "每页数量") @RequestParam(defaultValue = "15") Long pageSize) {
adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success(shopKeyService.page(page, pageSize));
@Parameter(description = "每页数量") @RequestParam(defaultValue = "15") Long pageSize,
@Parameter(description = "按公司筛选(仅超管生效;非超管一律按会话公司裁剪)")
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
return ApiResponse.success(shopKeyService.page(page, pageSize, scopedCompanyId));
}
@PostMapping
@Operation(summary = "新增店铺密钥", description = "新增一条店铺密钥记录。")
@Operation(summary = "新增店铺密钥", description = "新增一条店铺密钥记录。归属由操作者会话推导,请求体不带 company_id。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "创建成功", content = @Content(schema = @Schema(implementation = ShopKeyItemVo.class))),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "400", description = "参数不合法")
@@ -57,51 +64,55 @@ public class ShopKeyController {
public ApiResponse<ShopKeyItemVo> create(
HttpServletRequest request,
@Valid @RequestBody ShopKeyCreateRequest body) {
adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("创建成功", shopKeyService.create(body));
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("创建成功", shopKeyService.create(body, operator.getId()));
}
@PutMapping("/{id}")
@Operation(summary = "更新店铺密钥", description = "按 ID 更新一条店铺密钥记录。")
@Operation(summary = "更新店铺密钥", description = "按 ID 更新一条店铺密钥记录。别家公司的密钥不在本公司的写范围内。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "更新成功", content = @Content(schema = @Schema(implementation = ShopKeyItemVo.class))),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "400", description = "参数不合法"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "403", description = "跨公司写操作被拒"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "404", description = "记录不存在")
})
public ApiResponse<ShopKeyItemVo> update(
HttpServletRequest request,
@Parameter(description = "主键ID", required = true) @PathVariable Long id,
@Valid @RequestBody ShopKeyUpdateRequest body) {
adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("更新成功", shopKeyService.update(id, body));
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("更新成功", shopKeyService.update(id, body, dataReadScope.writeCompanyId(operator)));
}
@DeleteMapping("/{id}")
@Operation(summary = "删除店铺密钥", description = "按 ID 删除一条店铺密钥记录。")
@Operation(summary = "删除店铺密钥", description = "按 ID 删除一条店铺密钥记录。别家公司的密钥不在本公司的写范围内。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "删除成功"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "403", description = "跨公司写操作被拒"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "404", description = "记录不存在")
})
public ApiResponse<Void> delete(
HttpServletRequest request,
@Parameter(description = "主键ID", required = true) @PathVariable Long id) {
adminAuthSupport.requireAdminOrInternal(request);
shopKeyService.delete(id);
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
shopKeyService.delete(id, dataReadScope.writeCompanyId(operator));
return ApiResponse.success("删除成功", null);
}
@PostMapping("/{id}/check-whitelist")
@Operation(summary = "手动检测 IP 白名单",
description = "绕过缓存真实请求一次紫鸟接口,重置自动重试次数。"
+ "白名单放行需紫鸟公司侧授权,自动重试达上限后会停止重试,授权后可用此接口重新验证。")
+ "白名单放行需紫鸟公司侧授权,自动重试达上限后会停止重试,授权后可用此接口重新验证。"
+ "别家公司的密钥同样不能替它发起出网检测。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "检测完成", content = @Content(schema = @Schema(implementation = ShopKeyItemVo.class))),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "403", description = "跨公司写操作被拒"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "404", description = "记录不存在")
})
public ApiResponse<ShopKeyItemVo> checkWhitelist(
HttpServletRequest request,
@Parameter(description = "主键ID", required = true) @PathVariable Long id) {
adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("检测完成", shopKeyService.checkWhitelist(id));
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
return ApiResponse.success("检测完成", shopKeyService.checkWhitelist(id, dataReadScope.writeCompanyId(operator)));
}
}
@@ -15,6 +15,8 @@ public class ShopKeyEntity {
@TableId(type = IdType.AUTO)
private Long id;
/** 归属公司(company.id)。V150 加的列,历史行的值来自当时的列默认值 1,本表无账号列故事后不可反推。 */
private Long companyId;
private String remarkName;
private String ziniaoAccountName;
private String ziniaoToken;
@@ -15,6 +15,14 @@ import java.util.List;
/**
* shop_key 表对紫鸟侧的只读/回写适配器:把紫鸟需要的字段暴露给 ziniao 模块,
* 使 ziniao 不再直接引用 shopkey 的 Mapper 与 Entity(打破模块循环依赖)。
*
* <p><b>这里的 listAll/count 恒为全平台,刻意不跟着 V150 的 company_id 收窄。</b>
* 它的消费者是店铺索引刷新({@code ZiniaoShopIndexService},游标 scopeKey 就是 "global")
* 和令牌轮询({@code ZiniaoAuthService#getScanApiKeys})——那是<b>运行时令牌池</b>,
* 一个后台定时任务没有"当前公司"这个上下文,也没有可以筛的目标:按公司筛它,
* 等于让第二家公司的紫鸟店铺永远进不了索引,而这一页的隔离要收窄的是
* <b>谁能看见/改动这把握在紫鸟那边的令牌</b>(管理面),不是"这把令牌替谁出网"(用量面)。
* 想要用量面也隔离,得先给索引刷新建每公司一份的游标与索引行,那是另一期工程。</p>
*/
@Service
@RequiredArgsConstructor
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.shopkey.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.shopkey.mapper.ShopKeyMapper;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyCreateRequest;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyUpdateRequest;
@@ -36,12 +37,17 @@ public class ShopKeyService {
private final ZiniaoShopIndexService ziniaoShopIndexService;
private final ZiniaoApiKeyProvider ziniaoApiKeyProvider;
private final ZiniaoAuthService ziniaoAuthService;
private final CompanyScopeSupport companyScopeSupport;
public ShopKeyPageVo page(long page, long pageSize) {
/**
* @param companyId 读范围公司:由 {@code DataReadScope.readCompanyIdOrOwn} 判定后传下来,
* {@code null} 只可能来自平台超管「不筛」的判定,调用方不许在这里补默认值。
*/
public ShopKeyPageVo page(long page, long pageSize, Long companyId) {
long safePage = Math.max(page, 1);
long safePageSize = Math.min(Math.max(pageSize, 1), 100);
LambdaQueryWrapper<ShopKeyEntity> query = new LambdaQueryWrapper<ShopKeyEntity>()
.orderByDesc(ShopKeyEntity::getId);
LambdaQueryWrapper<ShopKeyEntity> query = applyCompanyScope(
new LambdaQueryWrapper<ShopKeyEntity>().orderByDesc(ShopKeyEntity::getId), companyId);
Long total = shopKeyMapper.selectCount(query);
List<ShopKeyItemVo> items = shopKeyMapper.selectList(query.last("LIMIT " + ((safePage - 1) * safePageSize) + ", " + safePageSize))
.stream()
@@ -55,13 +61,19 @@ public class ShopKeyService {
return vo;
}
/**
* 归属由<b>操作者会话</b>推导(请求体一律不带 company_id):漏了这一句,新密钥就会被 V150 的
* {@code DEFAULT 1} 静默塞进第 1 家——那是"归属失真且不报错",而 {@code requireCompanyId}
* 取不到公司时是抛,不会返回 null。所以这里<b>不保留</b>不带操作者的重载。
*/
@Transactional
public ShopKeyItemVo create(ShopKeyCreateRequest request) {
public ShopKeyItemVo create(ShopKeyCreateRequest request, Long operatorId) {
String ziniaoAccountName = normalizeRequired(request.getZiniaoAccountName(), "紫鸟账号名称不能为空");
String ziniaoToken = normalizeToken(request.getZiniaoToken());
String ziniaoTokenHash = hashToken(ziniaoToken);
ensureTokenAvailable(ziniaoTokenHash, null);
ShopKeyEntity entity = new ShopKeyEntity();
entity.setCompanyId(companyScopeSupport.requireCompanyId(operatorId));
entity.setRemarkName(normalizeOptional(request.getRemarkName()));
entity.setZiniaoAccountName(ziniaoAccountName);
entity.setZiniaoToken(ziniaoToken);
@@ -72,12 +84,12 @@ public class ShopKeyService {
insertOrThrowDuplicateToken(entity);
ziniaoApiKeyProvider.invalidateProxyUrlCache();
triggerShopIndexRefresh();
return toItemVo(getById(entity.getId()));
return toItemVo(loadRow(entity.getId()));
}
@Transactional
public ShopKeyItemVo update(Long id, ShopKeyUpdateRequest request) {
ShopKeyEntity entity = getById(id);
public ShopKeyItemVo update(Long id, ShopKeyUpdateRequest request, Long writableCompanyId) {
ShopKeyEntity entity = getById(id, writableCompanyId);
String ziniaoAccountName = normalizeRequired(request.getZiniaoAccountName(), "紫鸟账号名称不能为空");
String ziniaoToken = normalizeToken(request.getZiniaoToken());
String ziniaoTokenHash = hashToken(ziniaoToken);
@@ -105,12 +117,12 @@ public class ShopKeyService {
updateOrThrowDuplicateToken(entity);
ziniaoApiKeyProvider.invalidateProxyUrlCache();
triggerShopIndexRefresh();
return toItemVo(getById(id));
return toItemVo(getById(id, writableCompanyId));
}
@Transactional
public void delete(Long id) {
ShopKeyEntity entity = getById(id);
public void delete(Long id, Long writableCompanyId) {
ShopKeyEntity entity = getById(id, writableCompanyId);
shopKeyMapper.deleteById(entity.getId());
ziniaoApiKeyProvider.invalidateProxyUrlCache();
triggerShopIndexRefresh();
@@ -125,8 +137,8 @@ public class ShopKeyService {
* 挂在事务上等于把连接池的连接按上游 RTT 扣住,多次点击即可耗尽池——这正是本仓
* 「事务内含外部 IO」要避免的形态。
*/
public ShopKeyItemVo checkWhitelist(Long id) {
ShopKeyEntity entity = getById(id);
public ShopKeyItemVo checkWhitelist(Long id, Long writableCompanyId) {
ShopKeyEntity entity = getById(id, writableCompanyId);
ziniaoApiKeyProvider.invalidateProxyUrlCache();
try {
ziniaoAuthService.probeApiKeyUpstream(entity.getZiniaoToken());
@@ -145,7 +157,7 @@ public class ShopKeyService {
id, entity.getZiniaoAccountName(), ex.getMessage());
}
}
return toItemVo(getById(id));
return toItemVo(getById(id, writableCompanyId));
}
private void updateWhitelistState(Long id, String status, String message, int failCount) {
@@ -157,7 +169,18 @@ public class ShopKeyService {
.set(ShopKeyEntity::getIpWhitelistFailCount, failCount));
}
private ShopKeyEntity getById(Long id) {
private ShopKeyEntity getById(Long id, Long writableCompanyId) {
ShopKeyEntity entity = loadRow(id);
assertRowWritable(entity, writableCompanyId);
return entity;
}
/**
* 不带归属闸门的裸读取:只给两条已经由别的方式确定范围的路径用——
* {@code create} 刚写完自己那一行(归属是它自己落的),以及 {@link #getById} 的内部复用。
* 其余入口一律走 {@link #getById(Long, Long)},别在这里加"顺手读一行"的口子。
*/
private ShopKeyEntity loadRow(Long id) {
ShopKeyEntity entity = shopKeyMapper.selectById(id);
if (entity == null) {
throw new BusinessException("店铺密钥不存在");
@@ -165,6 +188,30 @@ public class ShopKeyService {
return entity;
}
/**
* 行级归属闸门:{@code null} = 平台超管不限。读侧已经收窄而写侧不收窄,等于"藏起来的密钥照样能改能删"。
* 比较的是<b>行自己的</b> {@code company_id},不是 tab 的值。
*/
private void assertRowWritable(ShopKeyEntity row, Long writableCompanyId) {
if (writableCompanyId == null) {
return;
}
companyScopeSupport.assertSameCompany(writableCompanyId, row.getCompanyId(),
"无权操作该密钥:别家公司的紫鸟令牌不在本公司的写范围内");
}
/**
* 公司读范围:{@code null} 侧(平台超管「不筛」)原样不加条件。
* <b>不许在它上面补一个默认公司</b>——那会让超管切到第 2 家时看到的还是第 1 家的令牌。
*/
private LambdaQueryWrapper<ShopKeyEntity> applyCompanyScope(
LambdaQueryWrapper<ShopKeyEntity> query, Long companyId) {
if (companyId != null) {
query.eq(ShopKeyEntity::getCompanyId, companyId);
}
return query;
}
private String normalizeRequired(String value, String message) {
String normalized = value == null ? "" : value.trim();
if (normalized.isEmpty()) {
@@ -248,6 +295,12 @@ public class ShopKeyService {
}
}
/**
* 令牌查重<b>跨公司全局</b>做,不按 {@code companyId} 收窄——这与 V150 刻意不动
* {@code uk_ziniao_token_hash} 是同一条决定的两面:同一个紫鸟令牌在两家公司各存一行,
* 物理上是同一把握在紫鸟那边的账号被登记两次,而 {@code ZiniaoApiKeyProvider} 按令牌聚合,
* 两行会并成一条、代理地址与白名单失败次数互相顶掉。数据库那把唯一键也根本不允许它发生。
*/
private void ensureTokenAvailable(String tokenHash, Long currentId) {
ShopKeyEntity existing = shopKeyMapper.selectOne(new LambdaQueryWrapper<ShopKeyEntity>()
.eq(ShopKeyEntity::getZiniaoTokenHash, tokenHash)
@@ -0,0 +1,240 @@
-- =============================================================
-- 迁移 V149__permission_menu_company_tree
-- 模板:docs/flyway-migration-template.md
-- 设计:crawler-plugin/docs/ops/menu-company-tree-design-2026-10-06.md
-- 需求:2026-10-06「菜单权限也加字段来区分,现在的默认归到 admin 下」,控制方选「每家公司一套菜单树」
--
-- 1. 变更目的:把 columns 从"全平台一棵菜单字典"改成"每家公司一套树",并把存量全部归厦门米椿花(id=1)。
-- 今天这张表一个归属列都没有,两条唯一键都是全平台口径:
-- - uk_column_key(column_key) ⇒ 第 2 家公司连"和别家同名"的菜单都建不出来(不是看不到,是建不出);
-- - uk_menu_type_route_path(menu_type, route_path) ⇒ 同上,路径也不允许复用;
-- 而读侧 findDataPermission 这类"按 column_key 点查 + LIMIT 1"(PermissionMenuService:1102)在换键后
-- 会在同名的多行里借位拿到别家的行——所以这一版必须"加列 + 换键 + 复制 + 重指授权"同批做完,
-- 只做加列等于把静默串扰装进生产。
--
-- 2. 口径:
-- - 存量 52 行一律归公司 1(厦门米椿花)= 控制方说的"默认归到 admin 下"。
-- - 三种 menu_type 全复制(admin 26 / app 24 / internal 2):客户端账号同样分属两家公司,
-- 只复制 admin 会留半棵共享树,app 侧的权限键集合还是全平台一份。
-- - 【唯一例外】admin_companies(id 109)不复制:它是角色内在闸门
-- (Java 的 SUPER_ADMIN_ONLY_KEYS / 前端 SUPER_ADMIN_ONLY_MENU_KEYS 同一值),本来就"非超管看不见、
-- 谁也授不出去",别家的树里没有这行比"有一行但被三道出口剪掉"更干净。
-- - 公司 2 那 16 笔授权按 column_key 重指向本公司副本。不留成人工动作:否则德阳的 2 只账号
-- 一上线就掉光菜单,"隐藏"就变成了静默删除。
-- - 复制对 company 表里【所有】id<>1 的公司做(含 status=0 的停用公司):一行菜单不构成任何成本,
-- 而"启用一家公司还要先补树"会让启用动作多一个能被忘掉的步骤。
--
-- 3. 影响表与数据量(2026-10-06 主机A 业务库只读实查,不是估的):
-- columns = 52 行(admin 26:id 4..109|app 24:id 1..96|internal 2:id 69、95)
-- company = 2 家(1 厦门米椿花、2 德阳)⇒ 复制段新增 51 行/家,本批共 +51 行
-- user_column_permission = 784 笔 / 133 账号(公司1 131人768笔|公司2 2人16笔)⇒ 重指段最多改 16 行
-- 同 column_key 重复行 = 0 ⇒ 新唯一键是旧键的严格放宽,换键不会因重复失败
-- users / company / 其余业务表 0 改动
--
-- 4. 锁表风险:低。52 行的字典表,任何形态的 DDL 都在毫秒级;两条加唯一键仍按规矩钉
-- ALGORITHM = INPLACE, LOCK = NONE。唯一的 COPY 是第 3 段那条 MODIFY ... NOT NULL(52 行,V143 同形)。
-- 加列一律走【末位追加】(不写 AFTER):非末位加列能不能 INSTANT 取决于生产 MySQL 的小版本,
-- 把这一条押在版本语义上,代价是发版窗口里第 1 段直接报 1846;而这一列的位置没有任何语义(读写都按列名)。
-- 不碰 biz_task_file_job 等锁热点表。索引字节预算(utf8mb4 + DYNAMIC,上限 3072):
-- uk_company_column_key = 8 + 64*4 = 264
-- uk_company_menu_type_route_path = 8 + 20*4 + 255*4 = 1108
-- 【不加 idx_columns_company】两条新唯一键的最左前缀就是 company_id,52 行的表再单开列索引
-- 就是 V139 那轮清理掉的冗余索引形状。
--
-- 5. 换键顺序:先 ADD 新键,再 DROP 旧键,最后才插副本。倒过来写下的话第 6 段会撞 1062
-- (旧键 uk_column_key 还在全局口径上守着一家一份)。中间任一步失败都至少还有一个唯一键在守并发。
--
-- 6. 回滚步骤:人工补丁 backend-java/docs/rollback-V149-permission-menu-company.sql(在 Flyway 扫描路径之外,
-- 不写成 V150——版本化回滚等于让"决定回滚"这件事在没有人工执行的情况下自己发生)。
-- 顺序:停两台应用 → 跑脚本 → 删 flyway_schema_history 的 version=149 行 → 回滚 jar → 起应用。
--
-- 7. 上线窗口:随 jar 双节点同窗口发布(迁移在首台启动期执行,第二台见"已应用"即跳过),
-- 金丝雀过了立刻补第二台,把混合版本窗口压到分钟级。窗口内旧 jar 的后果清单见设计文档 §7,
-- 三条都是"难看/保守拒绝",不是跨公司放行。
-- DEFAULT 1 是【临时】的,唯一存在理由是同批的旧 jar:它的 PermissionMenuEntity 没有 companyId 字段,
-- MyBatis-Plus 的 insert 会整列跳过,严格模式下报 1364,打到旧节点的"新增菜单"会全失败。
-- 摘除动作与前四张表同一版做(下一版一条元数据操作 ALTER TABLE `columns` ALTER COLUMN company_id DROP DEFAULT,
-- 与 biz_product_category 那条一起;禁写成 MODIFY,重建会按当时的列默认值物化历史行),
-- 在摘掉之前由启动期 CompanyDefaultGuard 盯住(WATCHED_TABLES 已加 columns),
-- 巡检按 COMPANY_DEFAULT_STILL_PRESENT 这条 ASCII 签名 grep——"漏摘"由代码喊,不靠人记得。
--
-- 【可重跑性】MySQL 的 DDL 不进事务。本迁移若在换键或复制段失败,前面的加列与回填已落库;
-- 按「补数据 → flyway repair → 重启」恢复时 Flyway 从第一条语句重跑整个文件,所以每条 DDL
-- 都先查 information_schema 再 PREPARE,回填 UPDATE 带 company_id IS NULL 限定,复制段带 NOT EXISTS 守卫,
-- 重映射段带 parent_id IS NULL 限定,重指段带"行还挂在别家"限定 ⇒ 重跑逐条是 no-op。
-- 末了四道自检闸门(临时表 must_be_zero NOT NULL,V143 那个"让约束替我喊"的家族):残留不为 0 就抛 1048
-- 让迁移失败,而不是留一棵静默分叉的树——尤其闸门 1,它专防"NOT EXISTS 守卫把该插的行挡掉"这种
-- 一声不响少一整家树的形状(PermissionMenuSchemaInitializer 那批裸 column_key 守卫就是同一形态)。
-- =============================================================
SET @db_name = DATABASE();
-- ---------- 1. 加列(末位 + INSTANT,先可空:第 2 段的回填才有行可写) ----------
SET @col_exists := (SELECT COUNT(*) FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns' AND COLUMN_NAME = 'company_id');
SET @sql := IF(@col_exists = 0,
'ALTER TABLE `columns` ADD COLUMN `company_id` bigint NULL COMMENT ''归属公司(company.id):每家公司一套菜单树;V149'', ALGORITHM = INSTANT',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 2. 存量 52 行全部归厦门米椿花 ----------
-- WHERE 限定 NULL ⇒ 重跑是 no-op,也不会覆盖任何人工指定过公司的行。
UPDATE `columns` SET `company_id` = 1 WHERE `company_id` IS NULL;
-- ---------- 3. 收成 NOT NULL(这一句同时是回填自检闸门) ----------
-- 第 2 段若漏掉任何一行,这里抛 1048 让迁移失败:NULL 意味着这一行在任何公司的树上都不出现,
-- 而按 key 点查会把它当"没有这个菜单"。DEFAULT 1 的临时性与摘除时机见头部第 7 段。
-- 这里的 MODIFY 是【建列时】定形状(52 行,毫秒级 COPY);摘 DEFAULT 那一版禁写 MODIFY,两者不是一回事。
ALTER TABLE `columns`
MODIFY COLUMN `company_id` bigint NOT NULL DEFAULT 1 COMMENT '归属公司(company.id):每家公司一套菜单树;V149(DEFAULT 1 待下一版摘除)';
-- ---------- 4. 两条唯一键按公司放宽:先 ADD 新键 ----------
-- 新键是旧键的严格放宽(旧键全平台唯一 ⇒ 新键必唯一),所以这两步不可能因重复而失败。
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns' AND INDEX_NAME = 'uk_company_column_key');
SET @sql := IF(@idx_exists = 0,
'ALTER TABLE `columns` ADD UNIQUE KEY `uk_company_column_key` (`company_id`, `column_key`), ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns'
AND INDEX_NAME = 'uk_company_menu_type_route_path');
SET @sql := IF(@idx_exists = 0,
'ALTER TABLE `columns` ADD UNIQUE KEY `uk_company_menu_type_route_path` (`company_id`, `menu_type`, `route_path`), ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 5. 再 DROP 旧键(顺序不能反,见头部第 5 段) ----------
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns' AND INDEX_NAME = 'uk_column_key');
SET @sql := IF(@idx_exists = 1,
'ALTER TABLE `columns` DROP INDEX `uk_column_key`, ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns' AND INDEX_NAME = 'uk_menu_type_route_path');
SET @sql := IF(@idx_exists = 1,
'ALTER TABLE `columns` DROP INDEX `uk_menu_type_route_path`, ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 6. 给 id<>1 的公司复制整棵树(parent_id 先留 NULL,第 7 段按 key 重映射) ----------
-- 驱动集是「company 全表 × 公司 1 的字典行」,不是硬编码公司 2:第三家公司开通时不用再改迁移。
-- 父指向不能照抄源行的 parent_id——那是全局 id,会跨公司挂到厦门米椿花的分组上;而外键
-- fk_columns_parent_id 只保证父行【存在】,挡不住挂到别家,所以这里宁可先留 NULL 再按 key 认父。
INSERT INTO `columns` (`company_id`, `name`, `column_key`, `menu_type`, `route_path`, `sort_order`, `parent_id`, `created_at`)
SELECT co.id, src.name, src.column_key, src.menu_type, src.route_path, src.sort_order, NULL, src.created_at
FROM `company` co
JOIN `columns` src ON src.company_id = 1
WHERE co.id <> 1
AND src.column_key <> 'admin_companies'
AND NOT EXISTS (
SELECT 1 FROM `columns` cp
WHERE cp.company_id = co.id AND cp.column_key = src.column_key
);
-- ---------- 7. 副本认父:沿 (company_id, column_key) 把父指向换成同公司副本 ----------
-- 与插入顺序无关(源行父指向先落 NULL,join 命中才写),重跑时已认过父的行 parent_id 非 NULL ⇒ no-op;
-- 源行本身是根的行 join 不到 sp ⇒ 一行不动,永久保持 NULL。
UPDATE `columns` copy
JOIN `columns` src ON src.company_id = 1 AND src.column_key = copy.column_key
JOIN `columns` sp ON sp.id = src.parent_id
JOIN `columns` pcopy ON pcopy.company_id = copy.company_id AND pcopy.column_key = sp.column_key
SET copy.parent_id = pcopy.id
WHERE copy.company_id <> 1
AND copy.parent_id IS NULL;
-- ---------- 8. 先把"源行 + 副本"并存的重复授权摘掉(今天 0 行,为 repair 重跑准备) ----------
-- 第 9 段是把指针从源行改到副本,若某账号同时挂着这两笔,改完会撞 PK (user_id, column_id) 报 1062。
-- 删副本那一侧、留源行那一侧给第 9 段去重指 ⇒ 结果只有一笔且指向本公司行。
DELETE dup FROM `user_column_permission` dup
JOIN `users` u ON u.id = dup.user_id
JOIN `columns` copy ON copy.id = dup.column_id AND copy.company_id = u.company_id
JOIN `columns` src ON src.id <> copy.id AND src.column_key = copy.column_key AND src.company_id = 1
JOIN `user_column_permission` old ON old.user_id = dup.user_id AND old.column_id = src.id
WHERE u.company_id <> 1;
-- ---------- 9. 存量授权重指向本公司副本(控制方 D1 定案:不留人工动作) ----------
-- 驱动条件"行还挂在公司 1 而账号不属于公司 1"⇒ 重跑时第 9 段一行都选不出来,是 no-op。
-- 按 column_key 认行而不是按 id 猜:这正是"每家公司一套树"之后唯一还站得住的对应关系。
UPDATE `user_column_permission` g
JOIN `users` u ON u.id = g.user_id
JOIN `columns` src ON src.id = g.column_id AND src.company_id = 1
JOIN `columns` copy ON copy.company_id = u.company_id AND copy.column_key = src.column_key
SET g.column_id = copy.id
WHERE u.company_id <> 1;
-- ---------- 10. 四道自检闸门:不为 0 就抛 1048(列 must_be_zero NOT NULL) ----------
CREATE TEMPORARY TABLE IF NOT EXISTS `_v149_gate` (`must_be_zero` INT NOT NULL);
-- 闸门 1:每一家公司的树都必须和公司 1 一样齐(除角色内在闸门那一行)。
-- 这一道专防复制段被 NOT EXISTS 守卫"一声不响少一整家树"——少树的后果不是报错,
-- 是那家公司的账号有效菜单为空、侧边栏空白,而按 key 点查会判成"这个菜单不存在"。
INSERT INTO `_v149_gate`
SELECT IF(COUNT(*) = 0, 0, NULL)
FROM `company` co
JOIN `columns` src ON src.company_id = 1 AND src.column_key <> 'admin_companies'
LEFT JOIN `columns` cp ON cp.company_id = co.id AND cp.column_key = src.column_key
WHERE co.id <> 1 AND cp.id IS NULL;
-- 闸门 2:父指向绝不跨公司(第 7 段没认上父、或源行本来就挂着别家父时会不为 0)。
INSERT INTO `_v149_gate`
SELECT IF(COUNT(*) = 0, 0, NULL)
FROM (
SELECT c.id
FROM `columns` c
JOIN `columns` p ON p.id = c.parent_id
WHERE c.company_id <> p.company_id
) bad;
-- 闸门 3:授权绝不指向别家的行(第 9 段漏一行,那家公司就 permanently 少一个菜单)。
INSERT INTO `_v149_gate`
SELECT IF(COUNT(*) = 0, 0, NULL)
FROM (
SELECT g.user_id
FROM `user_column_permission` g
JOIN `users` u ON u.id = g.user_id
JOIN `columns` c ON c.id = g.column_id
WHERE c.company_id <> u.company_id
) bad;
-- 闸门 4:company_id 不为 NULL。第 3 段的 MODIFY 已经挡过一次,这一道是给
-- "有人在 V149 之后手工插过不带公司的行"留的复验位——重跑整个文件时它才会响。
INSERT INTO `_v149_gate`
SELECT IF(COUNT(*) = 0, 0, NULL)
FROM (SELECT id FROM `columns` WHERE `company_id` IS NULL OR `company_id` <= 0) bad;
DROP TEMPORARY TABLE `_v149_gate`;
-- ---------- 验证(上线后人工只读复跑,不进迁移) ----------
-- ① 各家行数应相等且 = 公司 1 的 52 - 1 = 51:
-- SELECT company_id, menu_type, COUNT(*) FROM columns GROUP BY company_id, menu_type;
-- ② 跨公司授权残留 0:
-- SELECT COUNT(*) FROM user_column_permission g JOIN users u ON u.id=g.user_id
-- JOIN columns c ON c.id=g.column_id WHERE c.company_id <> u.company_id;
-- ③ 两条旧键已摘、两条新键在:
-- SELECT INDEX_NAME, GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX), NON_UNIQUE
-- FROM information_schema.STATISTICS WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME='columns'
-- GROUP BY INDEX_NAME, NON_UNIQUE;
@@ -0,0 +1,122 @@
-- =============================================================
-- 迁移 V150__shop_key_company_scope
-- 模板:docs/flyway-migration-template.md
-- 需求:2026-10-06「店铺密钥管理的数据按照公司区分」
-- 口径参照:V147__product_category_company_scope.sql(同为"表里一个归属列都没有"的那一类)
--
-- 1. 变更目的:把「店铺密钥管理」biz_shop_key 从"全平台共享的一池紫鸟令牌"改成"每公司一池"。
-- 现状是这张表零归属列(列全集见 V5 + V76 + V82 + V89 + V114,共 12 列,没有 company_id,
-- 也没有任何账号/分组列),而 ShopKeyService.page() 的 LambdaQueryWrapper 除 orderByDesc(id)
-- 之外没有任何 where ⇒ 拿到 admin_shop_keys 这个菜单的任意管理员,读的是同一份全表,
-- 且 ShopKeyItemVo 把 ziniaoToken 原文整列返回、页面把它挂在 title 属性上(悬停即得全文)。
-- 所以这一页今天漏的不是"多看几行",是**别家公司的紫鸟令牌原文**。
--
-- 2. 影响表与数据量:只动 biz_shop_key 一张表,只加一列。
-- 【行数今天没有实查,这一条不许当成已知】本仓的口径是"上线前有人实跑一遍验证 SQL",
-- 取证命令(主机A 业务库只读):
-- SELECT COUNT(*) AS total,
-- SUM(created_at >= '2026-10-04 14:55:00') AS after_company_2_opened
-- FROM biz_shop_key;
-- 为什么必须是 14:55 这个时刻:第二家公司(company.id=2)是 10-04 14:55 开通的(V145 头注释 2 段),
-- 而这一页的写侧闸门是随本批 jar 才装上的 ⇒ **从 14:55 到本次发布之间,第 2 家管理员建的密钥
-- 会落在 DEFAULT 1 上,归进厦门米椿花,事后无从反推**(这张表没有账号列,V145 给品牌库补
-- uploader_user_id 的那个锚点在这里补不出来:历史行的"由谁产生"根本没记过)。
-- 这一段的处置与 V145 一致:不猜、不编,把窗口压短(本批尽快上线),并让
-- after_company_2_opened 在迁移前跑一次——它是非 0 时必须在发布说明里点名"这些行的归属不可追回"。
--
-- 3. 锁表风险:低。
-- ADD COLUMN 走 ALGORITHM = INSTANT 且【不加 AFTER】:非末位列加列在 InnoDB 里要重建聚簇记录,
-- 钉死 INSTANT 之后,万一某个前提不成立,MySQL 直接报 1846 而不是悄悄退化成 COPY——
-- 宁可迁移失败走 repair 重跑,也不要一次没人预期的整表重建(首例 V145 第 3 段)。
-- 全文【没有一条 UPDATE】:历史行的 1 由加列时记录的默认值给出,不需要回填,
-- 所以也就没有 V145 那条"派生值哨兵"要防的写回缺口——但摘 DEFAULT 时仍要重跑验证 SQL 第 2 条,
-- 理由见第 6 段。
-- 不碰 users / company / biz_shop_manage / biz_task_file_job。
--
-- 4. 唯一键【刻意不动】:uk_ziniao_token_hash(V89:20)保持全平台唯一。
-- 【为什么不学 V145/V147 把它按公司放宽】那两个键管的是"同一张表里两家公司都要有名字叫 X 的行"
-- (同名类、同名 ASIN 规则),把它们按公司放宽是隔离的前提;而这里的键管的是**一把握在紫鸟那边的
-- 令牌字符串**本身:同一个令牌在两家公司各存一行,物理上是同一个紫鸟账号被登记了两次,
-- 白名单状态、代理地址、连续失败次数会各自漂移,而 ZiniaoApiKeyProvider.listApiKeyAccounts()
-- 是按令牌聚合的(LinkedHashMap 以 token 为键),两行会并成一条 ApiKeyAccount、
-- resolveProxyUrl 取"第一个非空代理"、resolveIpWhitelistFailCount 取 max ⇒ 一家改了代理,
-- 另一家的出口跟着变。这不是"看不到",是"两行互相顶掉成一行",保持全局唯一才是对的。
-- 【代价,写清】第 2 家管理员提交一把第 1 家已经登记过的令牌,会拿到"紫鸟令牌已存在,不能重复维护"。
-- 这句报错确实说出了"别家有这一条",但能撞出这句话的前提是他已经握着这把握在紫鸟那边的令牌原文,
-- 保密性在那一刻已经没有了 ⇒ 不构成跨租户泄露。
--
-- 5. 回滚步骤:人工补丁 backend-java/docs/rollback-V150-shop-key-company.sql(在 Flyway 扫描路径之外,
-- 不写成 V151——版本化回滚等于让"决定回滚"这件事在没有人工执行的情况下自己发生)。
-- 顺序:停两台应用 → 跑脚本 → 删 flyway_schema_history 的 version=150 行 → 回滚 jar → 起应用。
--
-- 6. 上线窗口:随 jar 双节点同窗口发布,金丝雀过了立刻补第二台,把混合版本窗口压到分钟级。
-- DEFAULT 1 是【临时】的,唯一存在理由是同批的旧 jar:它的 ShopKeyEntity 没有 companyId 字段,
-- MyBatis-Plus 的 insert 会整列跳过,严格模式下报 1364(旧 jar 的 create 会当场 500,
-- 不像 V145 那样被 catch 成 log.warn 静默丢——但"新增密钥这一页在混合窗口里坏掉"同样不可接受)。
-- 摘除动作与前三张同形,是一条纯元数据操作:
-- ALTER TABLE biz_shop_key ALTER COLUMN company_id DROP DEFAULT;
-- 【禁写成 MODIFY COLUMN ... NOT NULL】——那会重建表,而重建时"历史上没有这一列的行"会按
-- 【当时】的列默认值物化:默认刚被摘掉,历史归属就没了依据。本迁移没有写回历史行(第 3 段),
-- 所以摘 DEFAULT 之前必须先重跑下面第 2 条验证 SQL 确认 company_id 全 = 1。
-- 在摘掉之前,启动期 CompanyDefaultGuard 的 WATCHED_TABLES 与探针 SQL 的 IN 列表已把本表一并登记
-- (公司数 > 1 且这一列还带 DEFAULT 就打 COMPANY_DEFAULT_STILL_PRESENT,巡检按这条 ASCII 签名 grep
-- ⇒ "漏摘"由代码喊,不靠人记得)。
-- 【下一笔的取号】本表这条与 docs/migration-inventory.md 里那条同形待办(`columns` 的 DROP DEFAULT,
-- 原先挂在 V149 名下,现登记在「后续新增迁移从 V152 起取号」那一段)应合并成一版发出:
-- 两条都是纯元数据、前提各自独立,任一前提没成立就单独顺延,不要把待办拆散成两个理由。
-- 【不要再往里加 biz_product_category / biz_invalid_asin_data】那两张表的 DEFAULT 由"待摘"改成
-- "必须保留"(10-06 复验后改成共享口径,V151 的 INSERT 列清单不含 company_id,靠 DEFAULT 满足 NOT NULL;
-- 此时执行 DROP DEFAULT 会让每一次新建报 1364)。它们真正消失的时点是下一版直接 DROP COLUMN。
--
-- 【可重跑性】MySQL 的 DDL 不进事务。按「补数据 → flyway repair → 重启」恢复时 Flyway 从第一条
-- 语句重跑整个文件,所以加列先查 information_schema 再 PREPARE。写法首例见 V143 全文件、V145 的加列段。
-- =============================================================
SET @db_name = DATABASE();
-- ---------- 1. 加列(末位 + INSTANT) ----------
SET @col_exists := (SELECT COUNT(*) FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_shop_key' AND COLUMN_NAME = 'company_id');
SET @sql := IF(@col_exists = 0,
'ALTER TABLE `biz_shop_key` ADD COLUMN `company_id` bigint NOT NULL DEFAULT 1 COMMENT ''归属公司(company.id):本表无账号列,历史行由本默认值给出,不可反推;V150'', ALGORITHM = INSTANT',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 2. 本迁移刻意不做的事 ----------
-- · 不加二级索引:biz_shop_key 是"一个紫鸟账号一行"量级的小表,读路径 WHERE company_id = ? 的
-- 选择性再高也扫不出可感知的差别,而 uk_ziniao_token_hash 之外再挂一个单列索引就是 V139 那轮
-- 清理掉的冗余索引形状。真有慢日志再单独立项(本库的瓶颈是锁不是索引)。
-- · 不加 created_by_id:V145 给品牌库补 uploader_user_id 的理由是"归属只能靠账号反推",
-- 而本表的归属从本版本起由 ShopKeyService.create 显式落 company_id,反推这条路用不上;
-- 留一列没有消费者的审计位,只是给下一次"要不要用它"的争论留个口子。
-- · 不动 uk_ziniao_token_hash(理由见头注释第 4 段)。
-- =============================================================
-- 验证 SQL(迁移后在库上执行,不许只看启动日志的 Successfully applied)
-- SHOW COLUMNS FROM `biz_shop_key` LIKE 'company_id';
-- -> 期望 Null = NO,Default = 1(混合窗口要求带 DEFAULT;摘 DEFAULT 的那一版之后 Default 必须变 NULL)
--
-- SELECT COUNT(*) AS total, SUM(company_id IS NULL) AS null_company,
-- SUM(company_id NOT IN (1)) AS not_company_1
-- FROM `biz_shop_key`;
-- -> 期望 null_company = 0;not_company_1 = 0 表示历史行确实全在第 1 家
-- -> 【派生值哨兵】本迁移没有写回历史行,这里的 1 全部来自加列时记录的默认值。
-- 摘 DEFAULT 的那笔迁移必须【重跑这一条】:一旦某次表重建按"摘掉之后的默认值"物化历史行,
-- not_company_1 会立刻跳出来。
-- -> 与迁移前那次取证对齐:total 必须等于迁移前的 total(INSTANT 加列不该改变行数)。
--
-- 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_shop_key' AND NON_UNIQUE = 0
-- GROUP BY TABLE_NAME, INDEX_NAME;
-- -> 期望恰好两行:PRIMARY(id) 与 uk_ziniao_token_hash(ziniao_token_hash);
-- 这一条是"第 4 段确实没动唯一键"的证据,不是"应该没动"的信念
--
-- SELECT COUNT(*) FROM information_schema.COLUMNS
-- WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'biz_shop_key'
-- AND COLUMN_NAME = 'company_id' AND COLUMN_DEFAULT IS NOT NULL;
-- -> 本版本发布后期望 1(DEFAULT 1 还在,由 CompanyDefaultGuard 喊);摘 DEFAULT 的那一版之后必须变 0
-- =============================================================
@@ -0,0 +1,181 @@
-- =============================================================
-- 迁移 V151__rule_tables_shared_across_companies
-- 模板:docs/flyway-migration-template.md
-- 需求:2026-10-06 控制方点名「品牌数据库做成所有公司共享的,不区分了」「商品类目也都是做成共享的,不区分」
-- 前版:V145(品牌库+去重库按公司一套)、V147(商品类目按公司一棵树)——本文件只退这两张表的唯一键
--
-- 1. 变更目的:把「品牌数据库」biz_invalid_asin_data 与「商品类目」biz_product_category 的
-- 唯一键从"公司+值"退回【全平台】键,与同一批 jar 里已经摘掉公司谓词的读写侧对齐。
-- 不退这一刀的后果不是"看不到",是"写不进去":新代码的 INSERT 列清单已不含 company_id,
-- 严格模式下这一列由 DEFAULT 1 兜住,所以旧键 (company_id, ...) 在功能上"暂时还能用"——
-- 但它把第 2 家公司将来手工建的同名类目/手工加的同名品牌挡在同一行里,
-- 而这一版之后系统里根本不存在"哪一家"这个概念,键里留着公司维度就是一把没有对照物的锁。
--
-- 2. 口径:两张表都退回 V145/V147 之前的形状,键名也复用当时的名字,让"回滚到 V94/V50 时代"
-- 这件事在 SHOW INDEX 里一眼可辨:
-- biz_invalid_asin_data uk_company_value_brand(company_id,data_value,brand(191))
-- -> uk_data_value_brand(data_value,brand(191))
-- biz_product_category uk_company_category_key(company_id,category_key)
-- -> uk_product_category_key(category_key)
-- 【biz_dedupe_total_data 不动】:「去重数据汇总」仍是每公司一套(控制方点名"本次只改品牌数据库"),
-- 它的 uk_company_data_value 与哨兵登记都保持原样。
--
-- 3. 影响表与数据量(2026-10-06 主机A 业务库只读实查,不是估的):
-- biz_invalid_asin_data = 15,056 行,SUM(company_id <> 1) = 0
-- biz_product_category = 412 行(内置 18 = company_id 0、自定义 394 = company_id 1)
-- 按 category_key 分组的重复组 = 0 组
-- V147 上线(10-06 11:03)后的新写入 = 0 行
-- 【两张表能退键的理由不一样,别混着抄】
-- 品牌库:现行唯一键的第一列在库里恒为 1 ⇒ 目标键 (data_value, brand 前 191 字符)
-- 与现行键判的是同一件事,所以只要这个前提还在,ADD UNIQUE 就不可能撞 1062。
-- 文末「验证」段要证的前提只有一条:SUM(company_id <> 1) 仍然是 0(10-06 实查是 0)。
-- 类目表:归属有两档(0 与 1),同一个 category_key 理论上可以一档一行,现行键拦不住,
-- 所以"重复组 = 0"必须实测,「验证」段那条 GROUP BY 是承重的、不是走过场。
-- ⇒ 这两条预检在发版前都要【重跑】:10-06 的数字是快照,不是恒真。
-- company / users / columns 与其余业务表一律不动。
--
-- 4. 锁表风险:低,但两表的形态不同,分开说。
-- biz_invalid_asin_data 15,056 行 / 约 4.5 MB:建 uk_data_value_brand 要扫描并排序全表,
-- 钉 ALGORITHM = INPLACE, LOCK = NONE ⇒ 建索引期间并发 DML 可以进(同 V145 第 3 段的做法)。
-- biz_product_category 412 行:任何形态都在毫秒级,仍然钉同一对子句,不给"顺手退化成交换锁"留机会。
-- DROP INDEX 只吃一下元数据锁。
-- 两条 ADD UNIQUE 都排在对应的 DROP 之前:中间任一步失败时【至少还有一个唯一键在守并发】,
-- 而失败的表象是 Flyway 迁移报错、应用起不来,不是"键没了、重复行静默进库"。
-- 索引字节预算(utf8mb4 + DYNAMIC,上限 3072):
-- uk_data_value_brand = 128*4 + 191*4 = 1276
-- uk_product_category_key = 128*4 = 512
-- 【不用前缀索引迁就长度】(V135:6-9 的结论照搬):data_value 走全列、只有 brand 因为是 TEXT
-- 才必须带 (191),这与 V94 原键完全同形,退回去不改变任何一列的判重宽度。
-- 不碰 biz_task_file_job 等锁热点表。
--
-- 5. 回滚步骤:人工补丁 backend-java/docs/rollback-V151-rule-tables-shared.sql
-- (在 Flyway 扫描路径之外,不写成 V152——版本化回滚等于让"决定回滚"这件事在没有人工执行
-- 的情况下自己发生)。回滚方向是把两把公司键加回来:今天两张表的 company_id 只有一个值
-- (品牌库全是 1、类目是 0/1 两档),所以回滚不会撞 1062;但 jar 必须先回到带公司谓词的那版,
-- 否则"键按公司、代码不分公司"会让第 2 家建出与第 1 家同键的行。
-- 顺序:停两台应用 → 跑脚本 → 删 flyway_schema_history 的 version=151 行 → 回滚 jar → 起应用。
--
-- 6. 上线窗口:随 jar 双节点同窗口发布,金丝雀过了立刻补第二台,把混合版本窗口压到分钟级。
-- 【为什么本文件不 DROP COLUMN,尽管控制方要的是"删掉 company_id 列"】
-- 线上那版 jar 的读写两侧都带着 company_id:InvalidAsinDataMapper 的 INSERT 列清单点名这一列,
-- ProductCategoryEntity 带 companyId 字段(MyBatis-Plus 的 SELECT 列清单也含它)。
-- 这两句合起来的后果是"删列与换键同批"必然在混合窗口里打断旧 jar——而且打断得很难看:
-- 旧 jar 的 INSERT ... (company_id, ...) -> 1054 Unknown column,而
-- CollectDataInvalidAsinBatchWriter 把批量写失败 catch 成 log.warn 后跳过整批,接口照样返回成功
-- ⇒ 品牌黑名单静默少一批(这正是 V145 头注释为 DEFAULT 写下的那条禁令的反方向:
-- 一次迁移只解决一个可回滚的理由,别把"能静默丢数"的那一刀和换键捆在一起)。
-- 所以拆两步:本文件退键(旧 jar 配新库仍然全绿——键只是变严,数据本来就不冲突),
-- 下一版(两台同版确认后)再出
-- ALTER TABLE biz_invalid_asin_data DROP COLUMN company_id;
-- ALTER TABLE biz_product_category DROP COLUMN company_id;
-- 并同步把 CompanyDefaultGuard 的清单再清一遍。uploader_user_id 保留:它是"由谁产生"的审计锚点,
-- 与归属公司无关,摘了就把 10-05 起 AUTO 行的来源信息一起删掉。
-- 【DEFAULT 1 在本版之后从"待摘"变成"必须保留",这点必须写清,否则会有人照哨兵的提示去摘它】
-- 新 jar 的 INSERT 不带 company_id,靠 DEFAULT 1 满足 NOT NULL;此时执行
-- ALTER TABLE ... ALTER COLUMN company_id DROP DEFAULT 会让每一次写入报 1364(品牌库那条
-- 同样被 writer 吞成 warn ⇒ 静默丢数)。因此本版把这两张表从 WATCHED_TABLES 与探针 SQL 的
-- IN 列表里同时摘掉(清单与 SQL 由 CompanyDefaultGuardTest 双向钉同源),"摘 DEFAULT"这条
-- 待办由"改天要执行"改成"等 DROP COLUMN 那一版一起消失"。
-- biz_dedupe_total_data 与 biz_shop_key 不在此列:它们仍然按公司写,DEFAULT 仍是要摘的。
--
-- 【可重跑性】MySQL 的 DDL 不进事务。本迁移若在 DROP 段失败,前面的 ADD 已落库;
-- 按「补数据 → flyway repair → 重启」恢复时 Flyway 从第一条语句重跑整个文件,所以四条 DDL
-- 都先查 information_schema 再 PREPARE。写法首例见 V145 的加列/换键段、V147 全文件。
-- =============================================================
SET @db_name = DATABASE();
-- ---------- 1. 品牌数据库:先加全局键 ----------
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_invalid_asin_data' AND INDEX_NAME = 'uk_data_value_brand');
SET @sql := IF(@idx_exists = 0,
'ALTER TABLE `biz_invalid_asin_data` ADD UNIQUE KEY `uk_data_value_brand` (`data_value`, `brand`(191)), ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 2. 品牌数据库:再摘公司键 ----------
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_invalid_asin_data' AND INDEX_NAME = 'uk_company_value_brand');
SET @sql := IF(@idx_exists > 0,
'ALTER TABLE `biz_invalid_asin_data` DROP INDEX `uk_company_value_brand`, 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_product_category' AND INDEX_NAME = 'uk_product_category_key');
SET @sql := IF(@idx_exists = 0,
'ALTER TABLE `biz_product_category` ADD UNIQUE KEY `uk_product_category_key` (`category_key`), ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 4. 商品类目:再摘公司键 ----------
SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_product_category' AND INDEX_NAME = 'uk_company_category_key');
SET @sql := IF(@idx_exists > 0,
'ALTER TABLE `biz_product_category` DROP INDEX `uk_company_category_key`, ALGORITHM = INPLACE, LOCK = NONE',
'SELECT 1');
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- ---------- 5. 本迁移刻意不做的事 ----------
-- · 不 DROP COLUMN、不 DROP DEFAULT:理由见第 6 段(旧 jar 会撞 1054/1364,且失败被 writer 吞成 warn)。
-- · 不动 biz_dedupe_total_data:去重库仍每公司一套。
-- · 不加二级索引:两张表读侧已不按公司筛,company_id 的选择性在本版之后没有消费者,索引只是维护成本。
-- · 不回填 group_id:14,000+ 行 AUTO 的 group_id 为 NULL 是既成事实,非超管的可见集仍由
-- record_source = 'MANUAL' AND group_id = 固定组 这条谓词决定(与 V145/V151 无关,本文件不碰读侧)。
-- =============================================================
-- 验证 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 IN ('biz_invalid_asin_data','biz_product_category','biz_dedupe_total_data')
-- AND NON_UNIQUE = 0
-- GROUP BY TABLE_NAME, INDEX_NAME;
-- -> 期望恰好六行:PRIMARY(id) x3,加
-- biz_invalid_asin_data.uk_data_value_brand(data_value@1,brand@2)
-- biz_product_category.uk_product_category_key(category_key@1)
-- biz_dedupe_total_data.uk_company_data_value(company_id@1,data_value@2) <- 这条【必须还在】
-- -> uk_company_value_brand / uk_company_category_key 必须【不】在结果里;
-- uk_company_data_value 若在结果里【消失】了,说明本文件误伤了去重库。
--
-- SELECT COUNT(*) AS dup_brand_rows FROM (
-- SELECT data_value FROM biz_invalid_asin_data
-- GROUP BY data_value, LEFT(brand, 191) HAVING COUNT(*) > 1 LIMIT 1
-- ) t;
-- SELECT COUNT(*) AS dup_category_keys FROM (
-- SELECT category_key FROM biz_product_category GROUP BY category_key HAVING COUNT(*) > 1 LIMIT 1
-- ) t;
-- -> 两条都期望 0(本文件能建起严格键的前提)。发版前【重跑】这两条:10-06 的 0 组是快照。
--
-- SELECT COUNT(*) AS total FROM biz_invalid_asin_data;
-- SELECT COUNT(*) AS total, SUM(is_builtin = 1) AS builtin FROM biz_product_category;
-- -> 期望与迁移前一致(15,056 上下、412 / 18):本文件只换键,不增删行。
--
-- INSERT IGNORE 在退回全局键后(事务内跑完回滚,只插 ZZTEST 前缀):
-- START TRANSACTION;
-- INSERT INTO `biz_invalid_asin_data` (data_value, brand, record_source) VALUES ('ZZTESTKEY000001', 'zztestbrand', 'MANUAL');
-- INSERT INTO `biz_invalid_asin_data` (data_value, brand, record_source) VALUES ('ZZTESTKEY000001', 'zztestbrand', 'MANUAL');
-- SELECT COUNT(*) AS one_row FROM `biz_invalid_asin_data` WHERE data_value = 'ZZTESTKEY000001';
-- ROLLBACK;
-- -> 期望 one_row = 1:同名值第二次被 IGNORE 掉 = 键真的回到全平台一档。
-- 第二次也进去(=2)说明新键没建成,第 1 段被跳过了。
--
-- SHOW COLUMNS FROM `biz_invalid_asin_data` LIKE 'company_id';
-- SHOW COLUMNS FROM `biz_product_category` LIKE 'company_id';
-- -> 期望两条都仍是 Null = NO、Default = 1。本版【故意留着】:新 jar 的 INSERT 靠它满足 NOT NULL。
-- 它们变成"列不存在"的那一版才是 DROP DEFAULT 该一起消失的时候。
-- =============================================================
@@ -112,15 +112,20 @@ import org.junit.jupiter.api.Test;
* D 的代价与射程一并交代:非 {@code Long} 型公司参数取不到绑定名,判红并报形状;而"handler 之外的私有
* 收口方法里把公司参数硬写成 {@code null}"这一族 D 看不见——块边界止于该 handler 自己的闭括号
* (第 7 条),{@code AdminImageVideoTaskController.scopeOf} 正是它,那一处是<b>故意</b>传 null 的。</li>
* <li><b>几条正门,一套判据</b>(批次 2/3 新增;10-06 复验后加第三道)。{@code DataReadScope} 现在有三个出口:
* <li><b>几条正门,一套判据</b>(批次 2/3 新增;10-06 复验后加第二道,批次 6 加第三道)。出口现在有三个:
* {@code readScope(} 按账号集合给范围(去重库、查询 ASIN、最低价 ASIN、历史、视频),
* {@code readCompanyId(} 给"归属已物化成 {@code company_id} 列"的表(品牌库、商品类目——
* 那两张表的 {@code uploader_user_id} 在生产是 0 行非空,按账号筛等于把全部历史从每个公司 tab 里
* 静默删掉,理由写在 {@code DataReadScope#readCompanyId} 的注释里)。两条门共用 A/B/C/D 四条判据:
* {@code readCompanyIdOrOwn(} 给"归属物化成 {@code company_id} 列、可见集又不靠账号/分组"的表
* (今天只有店铺密钥,V150 起每公司一套),{@code resolveScopeCompanyId(} 给菜单字典那一棵树一套
* (V149 起,读写共用同一判据,见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由)。
* 三道门共用 A/B/C/D 四条判据:
* {@link #SCOPE_DOORS} 供 A 与 C 逐条跑,{@link #SCOPE_CALLEE_NAMES} 供 D 认被调名,
* <b>名单只写一次</b>(红因消息与自检断言咬的是拼出来的同一个标签,两处各写一遍会随哈希顺序漂红)。
* 每条门各自带能红/能绿两向探针(全局约束 15 那把尺子):只在 {@code readScope} 上验过,
* 等于第二道门上的返回值与入参没人看守。</li>
* 等于第二道门上的返回值与入参没人看守;第三道门(菜单字典)的三枚 {@code MENU_SCOPE_*} 探针同理。
* <p>批次 2 时这里还有<b>中间</b>那道 {@code readCompanyId(},服务品牌库 {@code biz_invalid_asin_data}
* 与商品类目 {@code biz_product_category} 两张物化列表。10-06 控制方把这两页定成全平台共享,
* 方法随之删除 ⇒ 门也从名单一起摘掉:名单里留一门没有实现者的门,等于给"把公司开关再接回那两张表"
* 预先铺好合规形状。这一族现在由 {@link #SHARED_TABLES_MUST_STAY_UNSCOPED} 反向钉住。</p></li>
* <li><b>取实参表按配对括号,不按单层括号正则</b>(10-05 批次 2/3 实跑)。原先 C 的第 ② 步与 D 都用
* {@code ([\w$]*)\s*\(([^()]*)\)},实参表里只要还有一次方法调用就整条看不见。而第 7 条把块边界钉死在
* handler 自己的闭括号上、断言 A 因此要求正门调用必须内联,两支约束合起来把合规接线逼成了
@@ -171,29 +176,35 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 不钉这一条的话,"取样集非空"自检可以由任何一支别的 handler 满足,而这两页哪天改了
* mapping 注解 / 换了参数形状就会静默脱离射程——分母由本轮自己造,等于没有分母。
*
* <p>10-05 批次 2/3(去重库、品牌库、查询ASIN、最低价ASIN、商品类目)把样本面扩到了
* {@link #READ_COMPANY_ID_CALL} 那条正门上,所以这里补两条同样口径的射程下限:
* 那五页哪天改了参数形状,静默脱离的是这一页的 tab,不是这条用例。</p>
* <p>10-05 批次 2/3 把样本面扩到当时那条按物化列给范围的正门({@code readCompanyId})上,
* 并补了两条同样口径的射程下限(品牌库、商品类目)。10-06 那两页定案全平台共享、门随之删除,
* 这两条下限一起摘掉——剩下的六页哪天改了参数形状,静默脱离的是它自己的 tab,不是这条用例。</p>
*/
private static final String SCOPE_CAUGHT_HISTORY_KEY =
"com/nanri/aiimage/modules/imagehistory/controller/ImageHistoryController.java#@GetMapping(\"/history\")";
private static final String SCOPE_CAUGHT_VIDEO_KEY =
"com/nanri/aiimage/modules/imagevideo/controller/AdminImageVideoTaskController.java#@GetMapping";
private static final String SCOPE_CAUGHT_INVALID_ASIN_KEY =
"com/nanri/aiimage/modules/invalidasin/controller/InvalidAsinDataController.java#@GetMapping";
private static final String SCOPE_CAUGHT_PRODUCT_CATEGORY_KEY =
"com/nanri/aiimage/modules/productcategory/controller/ProductCategoryController.java#@GetMapping(\"/product-categories\")";
private static final String SCOPE_CAUGHT_DEDUPE_KEY =
"com/nanri/aiimage/modules/dedupe/controller/DedupeTotalDataController.java#@GetMapping";
private static final String SCOPE_CAUGHT_QUERY_ASIN_KEY =
"com/nanri/aiimage/modules/shopkey/controller/QueryAsinController.java#@GetMapping";
private static final String SCOPE_CAUGHT_SKIP_PRICE_ASIN_KEY =
"com/nanri/aiimage/modules/shopkey/controller/SkipPriceAsinController.java#@GetMapping";
/**
* V150(10-06「店铺密钥管理的数据按照公司区分」)接的第八支:这一页的正门是
* {@code readCompanyIdOrOwn}(表里没有账号列,只有 V150 新加的 {@code company_id})。
*/
private static final String SCOPE_CAUGHT_SHOP_KEY_KEY =
"com/nanri/aiimage/modules/shopkey/controller/ShopKeyController.java#@GetMapping";
/**
* 射程下限的<b>唯一一份</b>名单:C 与 D 两条射程断言共用它,不许各写一份(两处各写就会有一处先漂)。
* 这七支是"切 tab 数据还是一样"这次报障正对着的页面 —— 用户报的五页(去重库、品牌库、最低价ASIN、
* 商品类目、查询ASIN)加批次 1 已接线的两页(图片历史、图片视频任务)。
* 这六支是"切 tab 数据还是一样"这次报障正对着的页面里<b>今天仍按公司取数</b>的那些:
* 批次 1 的两页(图片历史、图片视频任务)+ 批次 2 剩下三页(去重库、查询ASIN、最低价ASIN)
* + V150 的店铺密钥。
* <p>品牌库、商品类目 2026-10-06 定案退回全平台共享({@link #SHARED_TABLES_MUST_STAY_UNSCOPED}),
* 它们的公司参数已从 controller 上摘掉,留在这里只会让 {@code contains(...)} 恒红——
* "不得回流"改由那一条反向钉看守,不靠射程名单。</p>
*/
private static final List<String> WIRED_PAGE_KEYS = List.of(
SCOPE_CAUGHT_HISTORY_KEY,
@@ -201,38 +212,36 @@ class CompanyIdParamGoesThroughReadScopeTest {
SCOPE_CAUGHT_DEDUPE_KEY,
SCOPE_CAUGHT_QUERY_ASIN_KEY,
SCOPE_CAUGHT_SKIP_PRICE_ASIN_KEY,
SCOPE_CAUGHT_INVALID_ASIN_KEY,
SCOPE_CAUGHT_PRODUCT_CATEGORY_KEY);
SCOPE_CAUGHT_SHOP_KEY_KEY);
private static final String READ_SCOPE_CALL = "readScope(";
/**
* 第二个被认可的正门(10-05 批次 2/3):{@code DataReadScope.readCompanyId(operator, companyId)}。
* 第二道正门(10-06 复验后补):{@code readCompanyIdOrOwn}。
*
* <p>它存在的理由不是省事:品牌库 {@code biz_invalid_asin_data} 实测 14,801 行里
* {@code uploader_user_id} 非空 <b>0</b> 行(实体没这字段、批量 INSERT 的列清单也没带,V145 补的列
* 一直是空的),走 {@code readScope} 那批账号集合等于把全部历史从每一个公司 tab 里静默删掉;
* 商品类目 {@code biz_product_category} 更是连账号列都没有(V147 才加的 company_id)。
* 这两页的归属是<b>物化列</b>,正门必须按列给。</p>
*
* <p>几条正门是并列的<b>白名单</b>而不是新的自由口径:判据 A/C/D 与 {@code readScope} 逐字共用,
* 只是把"出现过 readScope("换成"出现过任一正门"," companyId 进了 readScope 的实参表"换成
* "进了任一正门的实参表"。页里自己写 {@code if (companyId != null) ...} 那一族
* 依然红——名单只加在 {@code DataReadScope} 上,加不在页上。</p>
*/
private static final String READ_COMPANY_ID_CALL = "readCompanyId(";
/**
* 第三道正门(10-06 复验后补):{@code readCompanyIdOrOwn}。
*
* <p>它补的是 {@code readCompanyId} 在非超管那一支的洞:品牌库的"非超管不筛"靠账号/分组谓词兜底,
* 商品类目既没有账号列也没有分组可见集,返回 null 就是"每一家都读到整棵树"——
* 2026-10-06 逐节点复验实测公司 2 的 admin 在该页读到 412 行(含公司 1 的 394 个自建类目)。</p>
* <p>它补的是"归属物化成 {@code company_id} 列、且可见集不靠账号/分组"那一族表:今天的消费者是
* 店铺密钥 {@code biz_shop_key}(V150 起每公司一套),表里没有账号列,返回 null 等于把整张表交给每一家。</p>
*
* <p>入名单的前提是它仍然只是 {@code DataReadScope} 上的一个方法,不是页里自己写的 if:
* 第三条门若开在 controller 里,这一页的判据就没人看守了。</p>
* 第二条门若开在 controller 里,这一页的判据就没人看守了。</p>
*
* <p>原先这里还有中间那道 {@code readCompanyId(}:品牌库、商品类目两张物化列表用它在超管身上做
* "tab 选哪家"的开关。2026-10-06 控制方定案那两页全平台共享、不区分公司,方法已从
* {@code DataReadScope} 删除、全树零消费者,所以这道门连同它的三枚探针一起摘掉——
* 判据名单里留一门没有实现者的门,等于给"把公司开关再接回那两张表"预先铺好合规形状。</p>
*/
private static final String READ_OWN_COMPANY_ID_CALL = "readCompanyIdOrOwn(";
/**
* 第三道正门(10-06 批次 6 补):{@code resolveScopeCompanyId}——菜单字典({@code columns} 每家公司一套树)
* 的归属判据。它开在 {@code PermissionMenuService} 上而不是 {@code DataReadScope} 上,理由与 {@code readCompanyIdOrOwn}
* 那条"必须是共享方法、不许页里自己写 if"是同一条:读写两侧、{@code loadRawMenus} 的每一个取数、
* 建/改/删/排四道写侧闸门全都只从这一个方法拿公司 id,判据分两处迟早漂移成"读能看别家、写挡不住"。
*
* <p>与 {@code readCompanyIdOrOwn} 的差别是定案 D2 要求的,不是笔误:超管<b>不传</b>时这道门返回他自己的
* 公司(菜单字典没有"混着两家的树一起列"这种视图),非超管<b>传别家</b>时抛 403 而不是静默改成本公司。</p>
*/
private static final String RESOLVE_MENU_SCOPE_CALL = "resolveScopeCompanyId(";
private static final List<String> SCOPE_DOORS =
List.of(READ_SCOPE_CALL, READ_COMPANY_ID_CALL, READ_OWN_COMPANY_ID_CALL);
List.of(READ_SCOPE_CALL, READ_OWN_COMPANY_ID_CALL, RESOLVE_MENU_SCOPE_CALL);
private static final String EXPLICIT_PARAM_NAME = "name = \"company_id\"";
private static final String SNAKE_PARAM = "company_id";
private static final String CAMEL_PARAM = "companyId";
@@ -275,10 +284,11 @@ class CompanyIdParamGoesThroughReadScopeTest {
"if", "for", "while", "switch", "do", "catch", "synchronized", "return", "throw", "else", "try");
/**
* 断言 D 认的三个被调名:{@code readScope} 是按账号集合给范围的唯一出口,
* 断言 D 认的四个被调名:{@code readScope} 是按账号集合给范围的唯一出口,
* {@code resolveScope} 是 Task 11 模板鼓励的"controller 里的私有收口方法"那一形(它内部再去
* readScope),{@code readCompanyId} 是归属已物化成 {@code company_id} 列那两张表
* (品牌库、商品类目)的正门(见 {@link #READ_COMPANY_ID_CALL} 的理由)。
* readScope),{@code readCompanyIdOrOwn} 是"归属物化成 {@code company_id} 列、可见集不靠账号/分组"
* 那一族表(今天只有店铺密钥)的正门(见 {@link #READ_OWN_COMPANY_ID_CALL} 的理由),
* {@code resolveScopeCompanyId} 是菜单字典那一棵树一套的归属判据(见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由)。
* 除此之外的调用都不算"把公司参数交给了出口"——尤其 {@code readScope(operator, null)} 里那个 {@code null}。
*/
private static final String RESOLVE_SCOPE_CALL = "resolveScope(";
@@ -288,7 +298,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 那就等于一条会自己漂红的用例。
*/
private static final List<String> SCOPE_CALLEE_NAMES =
List.of("readScope", "resolveScope", "readCompanyId", "readCompanyIdOrOwn");
List.of("readScope", "resolveScope", "readCompanyIdOrOwn", "resolveScopeCompanyId");
private static final Set<String> SCOPE_CALLEES = Set.copyOf(SCOPE_CALLEE_NAMES);
private static final String SCOPE_CALLEE_LABEL = String.join("/", SCOPE_CALLEE_NAMES);
@@ -448,64 +458,20 @@ class CompanyIdParamGoesThroughReadScopeTest {
""";
/**
* 第二条正门({@code readCompanyId})的<b>正探针</b>:形状逐字抄现网那一支
* ({@code InvalidAsinDataController.page} —— 先 {@code operator.user()} 把实体取出来,
* 再 {@code Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId);},
* 最后把 {@code scopedCompanyId} 交给 service)。
* <p>它证明的是"判据不是只认 {@code readScope} 那一族":C 的第 ①/② 步和 D 都必须在这一形上判绿,
* 否则五页里靠物化列给范围的那两页会红在护栏上,而不是红在真缺陷上。</p>
*/
private static final String READ_COMPANY_ID_CAUGHT_PROBE = """
@GetMapping("/probe")
public String typedDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId);
return String.valueOf(invalidAsinDataService.page(1, 15, scopedCompanyId));
}
""";
/**
* 第二条正门的<b>裸语句探针</b>(C 第 ① 步在该门上的"能红"证据):
* {@code scopeCatchFailure} 是对两条门<b>逐条</b>跑那两步的,只在 {@code readScope} 上验过不算验过——
* 少了这一枚,"第二道门根本没人看守它的返回值"就能悄悄进仓。
*/
private static final String READ_COMPANY_ID_DISCARD_PROBE = """
@GetMapping("/probe")
public String typedDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
dataReadScope.readCompanyId(user, companyId);
return "ok";
}
""";
/**
* 第二条正门的<b>负探针</b>(D 在该门上的存在理由):出口调了、结果接住了、也喂给 service 了,
* 唯独进出口的是 {@code null} —— 与 {@link #SCOPE_PASSED_NULL_PROBE} 同一记刀,只是换了道门。
* A/B/C 三条前提在自检里逐条钉住为绿,才说明这一刀今天确实只有 D 会喊。
*/
private static final String READ_COMPANY_ID_PASSED_NULL_PROBE = """
@GetMapping("/probe")
public String typedDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyId(user, null);
return String.valueOf(invalidAsinDataService.page(1, 15, scopedCompanyId));
}
""";
/**
* 第三道正门({@code readCompanyIdOrOwn})的<b>正探针</b>:形状抄现网
* {@code ProductCategoryController.list} —— 门给什么是什么,controller 不自己补。
* C 的两步与 D 都必须在这一形上判绿,否则类目页红在护栏上而不是红在缺陷上。
* 第二道正门({@code readCompanyIdOrOwn})的<b>正探针</b>:形状抄现网
* {@code ShopKeyController.list} —— 门给什么是什么,controller 不自己补。
* C 的两步与 D 都必须在这一形上判绿,否则密钥页红在护栏上而不是红在缺陷上。
*/
private static final String READ_OWN_COMPANY_ID_CAUGHT_PROBE = """
@GetMapping("/probe")
public String thirdDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
return String.valueOf(productCategoryService.list(null, scopedCompanyId));
return String.valueOf(shopKeyService.list(null, scopedCompanyId));
}
""";
/** 第三道正门的<b>裸语句探针</b>(C 第 ① 步在该门上的"能红"证据):算完直接丢,等于没筛。 */
/** 第二道正门的<b>裸语句探针</b>(C 第 ① 步在该门上的"能红"证据):算完直接丢,等于没筛。 */
private static final String READ_OWN_COMPANY_ID_DISCARD_PROBE = """
@GetMapping("/probe")
public String thirdDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
@@ -514,13 +480,59 @@ class CompanyIdParamGoesThroughReadScopeTest {
}
""";
/** 第三道正门的<b>负探针</b>(D 在该门上的存在理由):进出口的是 {@code null},tab 恒不动。 */
/** 第二道正门的<b>负探针</b>(D 在该门上的存在理由):进出口的是 {@code null},tab 恒不动。 */
private static final String READ_OWN_COMPANY_ID_PASSED_NULL_PROBE = """
@GetMapping("/probe")
public String thirdDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, null);
return String.valueOf(productCategoryService.list(null, scopedCompanyId));
return String.valueOf(shopKeyService.list(null, scopedCompanyId));
}
""";
/**
* 第三道正门(菜单字典归属判据 {@code resolveScopeCompanyId})的<b>正探针</b>:
* 结果接进变量并喂给 {@code list(…)},公司参数本身进了门 —— C 与 D 都必须判它绿,
* 否则 {@code PermissionMenuController} 那六支 handler 全是假红。
*/
private static final String MENU_SCOPE_CAUGHT_PROBE = """
@GetMapping("/probe")
public String menuScopeDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(user, companyId);
return String.valueOf(permissionMenuService.list(user, "admin", false, scopeCompanyId));
}
""";
/** 第三道正门的<b>裸语句探针</b>(C 第 ① 步在该门上的"能红"证据):门调了、403 也发了,结果却没人接。 */
private static final String MENU_SCOPE_DISCARD_PROBE = """
@GetMapping("/probe")
public String menuScopeDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
permissionMenuService.resolveScopeCompanyId(user, companyId);
return "ok";
}
""";
/** 第三道正门的<b>负探针</b>(D 在该门上的存在理由):门里进出的是 {@code null},切了 tab 取的还是操作者本公司。 */
private static final String MENU_SCOPE_PASSED_NULL_PROBE = """
@GetMapping("/probe")
public String menuScopeDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(user, null);
return String.valueOf(permissionMenuService.list(user, "admin", false, scopeCompanyId));
}
""";
/**
* 已摘掉那道门的<b>正样本探针</b>(形状抄退回前的 {@code InvalidAsinDataController.page}:
* 收 {@code company_id} 参数、体内调 {@code readCompanyId})。它现在应当被 A/C/D 三条同时判红——
* 红因必须落在"三条正门都没走"上,而不是"这段源码没被切成 handler"。
*/
private static final String RETIRED_DOOR_WIRED_PROBE = """
@GetMapping("/probe")
public String retiredDoorWired(@RequestParam(name = "company_id", required = false) Long companyId) {
Long scoped = dataReadScope.readCompanyId(user, companyId);
return String.valueOf(invalidAsinDataService.page(scoped));
}
""";
@@ -622,16 +634,6 @@ class CompanyIdParamGoesThroughReadScopeTest {
assertThat(scopeProbeReason(SCOPE_TYPE_FORM_PROBE, "SCOPE_TYPE_FORM_PROBE"))
.as("断言 C 自检(第二形):ReadScope s = dataReadScope.readScope(…) 且 s 进了 service.page(…) 的实参 ⇒ 同样要认")
.isNull();
// 第二条正门必须<b>各自</b>有能红/能绿两向证据:C 的判据是对 SCOPE_DOORS 逐条跑的,
// 只在 readScope 上验过,就等于没验过 readCompanyId —— 那一道门上的返回值会没人看守。
assertThat(scopeProbeReason(READ_COMPANY_ID_CAUGHT_PROBE, "READ_COMPANY_ID_CAUGHT_PROBE"))
.as("断言 C 自检(第二道门·正样本):Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId) "
+ "且它进了 service.page(…) 的实参 ⇒ 该判这一形绿,判红就是护栏假红(现网品牌库/商品类目都是这形)")
.isNull();
assertThat(scopeProbeReason(READ_COMPANY_ID_DISCARD_PROBE, "READ_COMPANY_ID_DISCARD_PROBE"))
.as("断言 C 自检(第二道门·负样本):readCompanyId( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
.isNotNull()
.contains("范围算了但没接住");
// 断言 D 的判据自检(两个方向都要,全局约束 15)。负探针要先证明"A/B/C 三条对它都判通过"——
// 这三条前提不成立就说明这段源码本来已经有人看守,D 没有区分度、只是重复劳动。
@@ -662,45 +664,80 @@ class CompanyIdParamGoesThroughReadScopeTest {
.as("断言 D 自检(改名那一族):参数声明叫 orgId、交出去的也是 orgId ⇒ 不许红"
+ "(这条同时钉住\"D 不许硬编码 companyId\":写死了它就会在这一支假红)")
.isNull();
// 第二道门上的 D:先钉 A/B/C 三条前提对它同样全绿(换了道门不等于换了缺陷形状),再钉 D 必须红。
String typedNullProbeText = String.join("\n", textsOf(sourceLines(READ_COMPANY_ID_PASSED_NULL_PROBE)));
assertThat(typedNullProbeText)
.as("断言 D(第二道门)负样本的前提(断言 A/B):readCompanyId( 在 handler 体内、name = \"company_id\" 也在")
.contains(READ_COMPANY_ID_CALL)
.contains(EXPLICIT_PARAM_NAME);
assertThat(scopeProbeReason(READ_COMPANY_ID_PASSED_NULL_PROBE, "READ_COMPANY_ID_PASSED_NULL_PROBE"))
.as("断言 D(第二道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 service ⇒ C 判它绿")
.isNull();
assertThat(companyIdArgProbeReason(
READ_COMPANY_ID_PASSED_NULL_PROBE, "READ_COMPANY_ID_PASSED_NULL_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第二道门·负样本):readCompanyId(user, null) —— 出口调了、门也认了,"
+ "tab 传下来的值仍没进出口 ⇒ 同样必须判红(D 不能只咬 readScope 那一族)")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 第三道门同样要各自带能红/能绿两向证据:C 与 D 都是对 SCOPE_DOORS 逐条跑的,
// 少一枚探针就等于那道门上的返回值与入参没人看守(类目页正是走这道门的页)。
// 第二道门同样要各自带能红/能绿两向证据:C 与 D 都是对 SCOPE_DOORS 逐条跑的,
// 少一枚探针就等于那道门上的返回值与入参没人看守(店铺密钥页正是走这道门的页)。
assertThat(scopeProbeReason(READ_OWN_COMPANY_ID_CAUGHT_PROBE, "READ_OWN_COMPANY_ID_CAUGHT_PROBE"))
.as("断言 C 自检(第三道门·正样本):Long scopedCompanyId = readCompanyIdOrOwn(user, companyId) "
.as("断言 C 自检(第二道门·正样本):Long scopedCompanyId = readCompanyIdOrOwn(user, companyId) "
+ "且它进了 service.list(…) 的实参 ⇒ 判红就是护栏假红")
.isNull();
assertThat(companyIdArgProbeReason(
READ_OWN_COMPANY_ID_CAUGHT_PROBE, "READ_OWN_COMPANY_ID_CAUGHT_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第三道门·正样本):companyId 真进了 readCompanyIdOrOwn 的实参表 ⇒ 不许红")
.as("断言 D 自检(第二道门·正样本):companyId 真进了 readCompanyIdOrOwn 的实参表 ⇒ 不许红")
.isNull();
assertThat(scopeProbeReason(READ_OWN_COMPANY_ID_DISCARD_PROBE, "READ_OWN_COMPANY_ID_DISCARD_PROBE"))
.as("断言 C 自检(第三道门·负样本):readCompanyIdOrOwn( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
.as("断言 C 自检(第二道门·负样本):readCompanyIdOrOwn( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
.isNotNull()
.contains("范围算了但没接住");
assertThat(scopeProbeReason(READ_OWN_COMPANY_ID_PASSED_NULL_PROBE, "READ_OWN_COMPANY_ID_PASSED_NULL_PROBE"))
.as("断言 D(第三道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 service ⇒ C 判它绿")
.as("断言 D(第二道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 service ⇒ C 判它绿")
.isNull();
assertThat(companyIdArgProbeReason(
READ_OWN_COMPANY_ID_PASSED_NULL_PROBE, "READ_OWN_COMPANY_ID_PASSED_NULL_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第三道门·负样本):readCompanyIdOrOwn(user, null) ⇒ 必须判红")
.as("断言 D 自检(第二道门·负样本):readCompanyIdOrOwn(user, null) ⇒ 必须判红")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 第三道门(菜单字典)同样各自带能红/能绿两向证据:它今天有六个真实消费者
// (PermissionMenuController 的目录/新建/两页数据范围授权的读与写),只钉"名单里有这个名字"
// 而不验返回值与入参,等于那六支 handler 的 tab 可以随便坏。
assertThat(scopeProbeReason(MENU_SCOPE_CAUGHT_PROBE, "MENU_SCOPE_CAUGHT_PROBE"))
.as("断言 C 自检(第三道门·正样本):Long scopeCompanyId = resolveScopeCompanyId(user, companyId) "
+ "且它进了 permissionMenuService.list(…) ⇒ 判红就是护栏假红")
.isNull();
assertThat(companyIdArgProbeReason(MENU_SCOPE_CAUGHT_PROBE, "MENU_SCOPE_CAUGHT_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第三道门·正样本):companyId 真进了 resolveScopeCompanyId 的实参表 ⇒ 不许红")
.isNull();
assertThat(scopeProbeReason(MENU_SCOPE_DISCARD_PROBE, "MENU_SCOPE_DISCARD_PROBE"))
.as("断言 C 自检(第三道门·负样本):resolveScopeCompanyId( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
.isNotNull()
.contains("范围算了但没接住");
assertThat(scopeProbeReason(MENU_SCOPE_PASSED_NULL_PROBE, "MENU_SCOPE_PASSED_NULL_PROBE"))
.as("断言 D(第三道门)负样本的前提(断言 C):结果接进 scopeCompanyId 又喂给了 list ⇒ C 判它绿")
.isNull();
assertThat(companyIdArgProbeReason(
MENU_SCOPE_PASSED_NULL_PROBE, "MENU_SCOPE_PASSED_NULL_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第三道门·负样本):resolveScopeCompanyId(user, null) ⇒ 必须判红")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 已摘掉的那道门不许再接回(全局约束 15 的"能红"方向)。这一族 handler(品牌库、商品类目)现在定案
// 全平台共享、不再收公司参数 ⇒ 它们已不进 A/C/D 的样本,"哪天有人把 ?company_id= 接回这两张表"
// 只剩这条探针还在求值,而今天真正拦它的是断言 A:C 与 D 在主循环里都以"体内有正门调用"为前提
// ({@link Block#hasScopeCall()}),只调已摘那道门时它们根本不求值 —— 把这层写成注释而不是三条全红,
// 是因为下一条要钉的就是"D 的名单里不许提前把 readCompanyId 加回来"。
// 前提同样要自证:探针真被切成 1 支收公司 id 参数的 handler、体内一条现存正门都没有、
// 但确实调了 readCompanyId( —— 否则"判红"只是"源码没读到"的另一种形状。
List<Block> retiredDoorBlocks = splitBlocks(sourceLines(RETIRED_DOOR_WIRED_PROBE)).handlers();
assertThat(retiredDoorBlocks)
.as("已摘门探针切不出 handler ⇒ 下面几条判红断言是空跑")
.hasSize(1);
Block retiredDoor = retiredDoorBlocks.get(0);
assertThat(retiredDoor.takesCompanyParam())
.as("已摘门探针没被认成收公司 id 参数(参数形状变了)⇒ A 不会对它求值,这条反向钉没有内容")
.isTrue();
assertThat(retiredDoor.text())
.as("已摘门探针的反面证据:它确实调了 readCompanyId(,这正是定案不许再接回的那一形")
.contains("readCompanyId(");
assertThat(anyScopeDoor(retiredDoor.text()))
.as("断言 A(已摘门):这条 handler 体内一条现存正门都没走过 ⇒ A 必然落进判红分支。"
+ "这里若为 true,说明探针混进了别的正门调用,A 不再是这一形的守门人,本用例失去内容")
.isFalse();
assertThat(retiredDoor.companyIdArgFailure())
.as("断言 D 对被调名单的看守:readCompanyId 一旦被人加回 SCOPE_CALLEE_NAMES(门还没接回、"
+ "名单先到),这一形就会被 D 判绿 ⇒ 这条必须保持判红")
.isNotNull();
// 配对括号取实参表(放宽)的成对证据:两枚正样本必须绿(否则 6 支已接线 handler 假红),
// 一枚"嵌套了但没带公司参数"的样本必须照旧红(否则放宽 = 把 D 关掉)。
assertThat(scopeProbeReason(SCOPE_NESTED_ARG_PROBE, "SCOPE_NESTED_ARG_PROBE"))
@@ -865,6 +902,138 @@ class CompanyIdParamGoesThroughReadScopeTest {
.isEmpty();
}
/**
* 10-06 定案"全平台共享、不区分公司"的两张表:{@code biz_invalid_asin_data}(品牌数据库)、
* {@code biz_product_category}(商品类目)。名单按 <b>module 目录</b>给而不是按 controller——
* 这两页的公司维度原先落在 entity 列、mapper 幂等键和 service 谓词上,只盯 controller 会漏掉那三段。
*
* <p>为什么不能只靠"退出 {@link #WIRED_PAGE_KEYS}":射程名单管的是"收了公司参数的 handler 必须走正门",
* 一页一旦不再收参数就不进样本,A/C/D 三条一起对它停止求值——"哪天有人把 {@code ?company_id=} 接回去"
* 恰好只剩这一条反向钉看得见。</p>
*/
private static final List<String> SHARED_TABLES_MUST_STAY_UNSCOPED = List.of(
"com/nanri/aiimage/modules/invalidasin",
"com/nanri/aiimage/modules/productcategory");
/** 这两张表的类型名锚:module 目录之外的引用者(自动导入那条写侧路)按它取样。 */
private static final List<String> SHARED_TABLE_TYPE_ANCHORS = List.of("InvalidAsinData", "ProductCategory");
/**
* 正样本目录:店铺密钥到今天仍是按公司取数的那一族({@code biz_shop_key},V150)。
* 同一把尺子必须在这里量出命中,否则"共享目录零命中"可能只是尺子坏了(全局约束 15)。
*/
private static final String STILL_SCOPED_MODULE_DIR = "com/nanri/aiimage/modules/shopkey";
private static final String DATA_READ_SCOPE_FILE = "com/nanri/aiimage/common/service/DataReadScope.java";
/** 公司 token 的尺子:整词大小写不敏感,比 {@code company_id}/{@code companyId} 两种写法都宽(含 {@code CompanyScopeSupport})。 */
private static final Pattern ANY_COMPANY_TOKEN = Pattern.compile("(?i)company");
@Test
@DisplayName("品牌库 / 商品类目已定案全平台共享:公司维度不许回流到这两张表的任何一处,出口上也不许再有那条门")
void companyDimensionMustNotFlowBackIntoTheTwoSharedTables() throws IOException {
// ① 尺子自证:同一把尺子必须在仍按公司取数的目录上量出命中,否则下面"共享目录零命中"全是空断言。
List<String> scopedHits = companyTokenLines(STILL_SCOPED_MODULE_DIR);
assertThat(scopedHits)
.as("公司 token 尺子在仍按公司取数的 %s 上零命中 ⇒ 尺子或取样坏了,后面的反向钉全是空断言",
STILL_SCOPED_MODULE_DIR)
.isNotEmpty();
// ② 两张共享表:目录里必须扫得到 .java(目录被改名/挪走也算红,那等于没人看守),且可执行行零公司 token。
for (String dir : SHARED_TABLES_MUST_STAY_UNSCOPED) {
assertThat(javaFilesUnder(dir))
.as("%s 扫不到 .java:目录被改名或挪走了,这条反向钉对它已经不再求值", dir)
.isNotEmpty();
assertThat(companyTokenLines(dir))
.as("品牌数据库 / 商品类目 2026-10-06 定案全平台共享(唯一键退回全局、页面不画公司 tab):"
+ "这两张表的 entity 列、mapper 幂等键、service 谓词、controller 参数都不许再出现公司维度"
+ "(只打可执行行,注释里『故意没有这一列』的说明不算)")
.isEmpty();
}
// ③ 目录外那几处引用这两张表的消费者同样不许带公司维度;锚本身要自证真取到了人。
List<String> consumers = sharedTableConsumerFiles();
assertThat(consumers)
.as("按类型名锚 %s 在两个 module 目录之外连自动导入那条写侧路都没取到 ⇒ 锚失效,这一族没人看守",
SHARED_TABLE_TYPE_ANCHORS)
.contains("com/nanri/aiimage/modules/collectdata/util/CollectDataInvalidAsinBatchWriter.java");
List<String> consumerHits = new ArrayList<>();
for (String rel : consumers) {
consumerHits.addAll(companyTokenLinesInFile(MAIN_ROOT.resolve(rel)));
}
assertThat(consumerHits)
.as("引用这两张表的外部消费者里出现了公司维度——自动导入「推不出公司就整批不写」那道闸门已定案放开,"
+ "把它接回去等于让整批 AUTO 行静默丢失")
.isEmpty();
// ④ 出口这一侧:readCompanyId 是专为这两页的「超管按 tab 选哪家」加的,两页退掉后全树零消费者,已删。
// 先钉同一族的 readCompanyIdOrOwn 还读得到,否则 noneMatch 只是"文件读空"的另一种绿。
List<String> scopeLines = executableLines(read(MAIN_ROOT.resolve(DATA_READ_SCOPE_FILE)));
assertThat(scopeLines)
.as("%s 里一行可执行行都没读到 ⇒ 门检查是空断言", DATA_READ_SCOPE_FILE)
.isNotEmpty();
assertThat(scopeLines.stream().anyMatch(line -> line.contains(READ_OWN_COMPANY_ID_CALL)))
.as("DataReadScope 上那条 OrOwn 门读不到了(改名或删除都要一起改这里):先确认这份文件真被扫到,"
+ "再谈『readCompanyId 不该存在』")
.isTrue();
assertThat(scopeLines.stream().noneMatch(line -> line.contains("readCompanyId(")))
.as("readCompanyId 又回到了 DataReadScope 上:品牌库/商品类目已定案共享,"
+ "一门没有实现者的正门留在出口名单里,等于给公司开关预先铺好合规形状")
.isTrue();
}
/** 某 module 目录(相对 {@code src/main/java},正斜杠)下的全部 {@code .java},按路径排序;目录不存在给空表,由调用方判红。 */
private static List<Path> javaFilesUnder(String moduleDir) throws IOException {
Path root = MAIN_ROOT.resolve(moduleDir);
if (!Files.isDirectory(root)) return List.of();
try (Stream<Path> walk = Files.walk(root)) {
return walk.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".java"))
.sorted()
.collect(Collectors.toList());
}
}
/** 一个目录下所有可执行行上的公司 token,报 {@code 相对路径: 行文本}(不带行号:行号会随无关提交漂,文件名+原文足够定位)。 */
private static List<String> companyTokenLines(String moduleDir) throws IOException {
List<String> hits = new ArrayList<>();
for (Path file : javaFilesUnder(moduleDir)) {
hits.addAll(companyTokenLinesInFile(file));
}
return hits;
}
private static List<String> companyTokenLinesInFile(Path file) {
String rel = relativeKey(file);
return executableLines(read(file)).stream()
.filter(line -> ANY_COMPANY_TOKEN.matcher(line).find())
.map(line -> rel + ": " + line)
.collect(Collectors.toList());
}
/**
* 两个 module 目录之外、可执行行里点到这两张表类型名的 main 文件(相对 {@code src/main/java}、正斜杠、排序)。
* 口径同第 1 条:只打可执行行,注释里提一句类名不算引用。
*/
private static List<String> sharedTableConsumerFiles() throws IOException {
List<String> consumers = new ArrayList<>();
try (Stream<Path> walk = Files.walk(MAIN_ROOT)) {
List<Path> files = walk.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".java"))
.sorted()
.collect(Collectors.toList());
for (Path file : files) {
String rel = relativeKey(file);
if (SHARED_TABLES_MUST_STAY_UNSCOPED.stream().anyMatch(rel::startsWith)) continue;
if (executableLines(read(file)).stream()
.anyMatch(line -> SHARED_TABLE_TYPE_ANCHORS.stream().anyMatch(line::contains))) {
consumers.add(rel);
}
}
}
return consumers;
}
/**
* 断言 C 的探针驱动器:先确认这段样本真被切成"1 支收公司 id 参数、体内写了 readScope(" 的 handler,
* 再跑 {@link Block#scopeCatchFailure()}。切不出 handler / 不认公司参数 / 没有 readScope( 这三种
@@ -880,7 +1049,8 @@ class CompanyIdParamGoesThroughReadScopeTest {
.as(probeName + " 的 handler 没被认成收公司 id 参数,断言 C 根本不会触发 ⇒ 探针失效")
.isTrue();
assertThat(anyScopeDoor(handler.text()))
.as(probeName + " 的 handler 体内两条正门都没走(readScope( / readCompanyId(),断言 C 扫不到它 ⇒ 探针失效")
.as(probeName + " 的 handler 体内一条正门都没走(" + String.join(" / ", SCOPE_DOORS)
+ "),断言 C 扫不到它 ⇒ 探针失效")
.isTrue();
return handler.scopeCatchFailure();
}
@@ -966,7 +1136,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
return line.contains(SNAKE_PARAM) || line.contains(CAMEL_PARAM);
}
/** 两条正门之一有没有在这段文本里出现过(A/C 的判据都走它,不各写一份)。 */
/** 任一条正门有没有在这段文本里出现过(A/C 的判据都走它,不各写一份)。 */
private static boolean anyScopeDoor(String text) {
return SCOPE_DOORS.stream().anyMatch(text::contains);
}
@@ -1294,7 +1464,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
return null;
}
/** 逐条正门跑"接住 → 交出去"两步:两条门都得走这两步,第二道门不能成为绕过第一道门判据的后门。 */
/** 逐条正门跑"接住 → 交出去"两步:三道门都得走这两步,后一道不能成为绕过前一道判据的后门。 */
private static String scopeCatchFailureFor(String src, String door) {
for (int at = src.indexOf(door); at >= 0;
at = src.indexOf(door, at + door.length())) {
@@ -1397,7 +1567,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 与 A/B/C 同一个 handler 窗口)。
* <ul>
* <li>{@code dataReadScope.readScope(operator, companyId)} ⇒ 绿;</li>
* <li>{@code dataReadScope.readCompanyId(user, companyId)}(第二条正门)⇒ 绿;</li>
* <li>{@code dataReadScope.readCompanyIdOrOwn(user, companyId)}(第二条正门)⇒ 绿;</li>
* <li>{@code resolveScope(request, companyId)}(私有收口方法内部再去 readScope)⇒ 绿;</li>
* <li>{@code readScope(operator, normalizeCompany(companyId))} ⇒ <b>绿</b>:嵌套写法自 10-05
* 批次 2/3 起算消费(第 13 条:旧单层正则在这一形上判红,而那正是断言 A 逼出来的形状),
@@ -119,42 +119,22 @@ class DataReadScopeTest {
.isInstanceOf(com.nanri.aiimage.common.exception.BusinessException.class);
}
// ---- 第二条正门:归属已物化成 company_id 列的表(品牌库、商品类目)----
// 这一道门的语义与 readScope 相反方向:返回的是"要筛哪个公司",null = 不筛。
// 非超管一律 null(他们的可见集本来就锁在自己的分组上,再叠一层公司会把"靠分组可见"的行整批删掉,
// 见 DataReadScope#readCompanyId 的注释)。这三条若不写,把 `return null` 改成
// `return companyScope.requireCompanyId(operator)` 不会让任何现有用例变红——而那一改的后果是
// 品牌库里靠分组可见的历史行从每个非超管账号下消失。
// ---- 第二道正门 readCompanyIdOrOwn:归属已物化成 company_id 列、且可见集不靠账号/分组的表 ----
// 语义与 readScope 相反方向:返回的是"要筛哪个公司",null = 不筛。今天的消费者是店铺密钥
// biz_shop_key(V150 起每公司一套,表里没有账号列)。
//
// 这里原先还有一道 readCompanyId:为品牌库/商品类目那两个"物化列 + 非超管靠分组可见"的表而写,
// 非超管一律返回 null(叠一层公司会把靠分组可见的行整批删掉)。2026-10-06 控制方定案那两页
// 全平台共享、不区分公司,方法已从 DataReadScope 删除、全树零消费者,这三条用例一起摘掉。
// "不许再接回"由 CompanyIdParamGoesThroughReadScopeTest#companyDimensionMustNotFlowBackIntoTheTwoSharedTables
// 反向钉(它同时钉住出口上没有这道门),不靠这里留一份无人调用的行为规格。
// 这一道门与 readScope 只差非超管那一支,而那一支正是 10-06 逐节点复验抓到的洞:表里连账号列都没有,
// 非超管返回 null=把整张表交给每一家(实测公司 2 的 admin 读到 412 行、其中 394 行是公司 1 的数据)。
// 这三条若不写,把 `requireCompanyId` 改回 `return null` 不会让任何现有用例变红。
@Test
@DisplayName("第二道门:超管选公司 = 原样给回那一列的筛值")
void readCompanyIdForSuperAdminReturnsTheTab() {
assertThat(dataReadScope.readCompanyId(user(1L, "super_admin", 1L), 2L)).isEqualTo(2L);
}
@Test
@DisplayName("第二道门:超管不选 / 选 0 / 选负数都归一化成「不筛」,不是去查 0 号公司")
void readCompanyIdForSuperAdminNormalisesMissingAndNonPositive() {
assertThat(dataReadScope.readCompanyId(user(1L, "super_admin", 1L), null)).isNull();
assertThat(dataReadScope.readCompanyId(user(1L, "super_admin", 1L), 0L)).isNull();
assertThat(dataReadScope.readCompanyId(user(1L, "super_admin", 1L), -3L)).isNull();
}
@Test
@DisplayName("第二道门:非超管一律 null,别家的 tab 也不炸、也不筛")
void readCompanyIdForNonSuperAdminAlwaysMeansNoFilter() {
assertThat(dataReadScope.readCompanyId(user(5L, "admin", 2L), 2L)).isNull();
assertThat(dataReadScope.readCompanyId(user(5L, "admin", 2L), 7L)).isNull();
assertThat(dataReadScope.readCompanyId(user(5L, "admin", 2L), null)).isNull();
}
// ---- 第三道门 readCompanyIdOrOwn:归属物化列、且可见集不靠账号/分组的表(商品类目)----
// 与第二道门只差非超管那一支,而那一支正是 10-06 逐节点复验抓到的洞:biz_product_category 连账号列
// 都没有,非超管返回 null=把整棵树交给每一家(实测公司 2 的 admin 读到 412 行、其中 394 行是公司 1
// 的自建类目)。这三条若不写,把 `requireCompanyId` 改回 `return null` 不会让任何现有用例变红。
@Test
@DisplayName("第三道门:超管仍按 tab 走(tab 是视图开关,不是安全边界)")
@DisplayName("第二道门:超管仍按 tab 走(tab 是视图开关,不是安全边界)")
void readOwnDoorForSuperAdminFollowsTheTab() {
assertThat(dataReadScope.readCompanyIdOrOwn(user(1L, "super_admin", 1L), 2L)).isEqualTo(2L);
assertThat(dataReadScope.readCompanyIdOrOwn(user(1L, "super_admin", 1L), null)).isNull();
@@ -163,18 +143,18 @@ class DataReadScopeTest {
}
@Test
@DisplayName("第三道门:非超管钉本公司,带别家的 tab 也不越权、也不返回空")
@DisplayName("第二道门:非超管钉本公司,带别家的 tab 也不越权、也不返回空")
void readOwnDoorPinsNonSuperAdminToItsOwnCompany() {
when(companyScope.requireCompanyId(any(AdminUserEntity.class))).thenReturn(2L);
assertThat(dataReadScope.readCompanyIdOrOwn(user(5L, "admin", 2L), 2L)).isEqualTo(2L);
// 传 7(别家)必须还是 2:类目树没有"空树"这个可用视图,返回空集等于把那一家自己的自建项也删掉。
// 传 7(别家)必须还是 2:这类表没有"空视图"这个可用状态,返回空集等于把那一家自己的数据也删掉。
assertThat(dataReadScope.readCompanyIdOrOwn(user(5L, "admin", 2L), 7L)).isEqualTo(2L);
assertThat(dataReadScope.readCompanyIdOrOwn(user(5L, "admin", 2L), null)).isEqualTo(2L);
}
/** 「公司超级管理员」在这三道门里都按非超管处理——它不是 super_admin,这一支若漂了就是整家公司越权。 */
/** 「公司超级管理员」在这两道门里都按非超管处理——它不是 super_admin,这一支若漂了就是整家公司越权。 */
@Test
@DisplayName("第三道门:company_super_admin 按非超管钉本公司,不当站点超管")
@DisplayName("第二道门:company_super_admin 按非超管钉本公司,不当站点超管")
void readOwnDoorTreatsCompanySuperAdminAsNonSuperAdmin() {
when(companyScope.requireCompanyId(any(AdminUserEntity.class))).thenReturn(2L);
assertThat(dataReadScope.readCompanyIdOrOwn(user(9L, "company_super_admin", 2L), null)).isEqualTo(2L);
@@ -326,18 +326,56 @@ class CompanyScopeMigrationV145Test {
}
/**
* 破坏点:头注释喊了哨兵,哨兵却没探这两列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
* 破坏点:头注释喊了哨兵,哨兵却没探这一列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
* 这条把文档承诺与代码实现对齐(§10 护栏 1 的可执行部分)。
*
* <p>2026-10-06 口径变更后,本用例的"对齐对象"从 V145 的头注释移到了 V151 的头注释——
* 那一笔才是现在的说法。两张表在这里分道:{@code biz_dedupe_total_data} 仍每公司一套,
* DEFAULT 的倒计时还在;{@code biz_invalid_asin_data} 随「全平台共享」定案<b>退出</b>哨兵清单,
* 它的 DEFAULT 从"待摘"翻转成 {@code NOT NULL} 的承重约束(新 jar 的 INSERT 不带这一列,
* 靠默认值填)。所以这一支既要钉它真的不在了,也要钉"不在"这件事在版本化的迁移注释里有据可查——
* 否则下一个人会照本文件头注释的旧承诺去执行 {@code DROP DEFAULT},把每次写入变成 1364。</p>
*/
@Test
void startupSentinelActuallyWatchesTheTwoNewColumns() throws IOException {
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
String text = raw(guard);
void startupSentinelStillWatchesDedupeAndV151RecordsWhyTheSharedOneLeft() throws IOException {
Path guardFile = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guardFile), "启动期 DEFAULT 哨兵应存在:" + guardFile);
String text = raw(guardFile);
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep docker logs)");
assertTrue(text.contains("'" + INVALID + "'"), "哨兵要探品牌库的 company_id,否则 V145 的 DEFAULT 没人盯");
assertTrue(text.contains("'" + DEDUPE + "'"), "哨兵要探去重库的 company_id");
assertTrue(text.contains("COLUMN_DEFAULT"), "哨兵应真的读列元数据,而不是靠猜");
List<String> watched = probeTables(text);
assertTrue(watched.contains(DEDUPE), "去重库仍按公司:它的 DEFAULT 必须还有人盯");
assertFalse(watched.contains(INVALID),
"品牌库已按「全平台共享」退出哨兵清单,哨兵不该再对它喊 DROP DEFAULT");
String sharedKeyMigration = raw(sharedKeyMigrationFile());
assertTrue(sharedKeyMigration.contains(INVALID),
"V151 的头注释要点名品牌库(它就是为这两张表退键而存在的)");
assertTrue(sharedKeyMigration.contains("1364") && sharedKeyMigration.contains("DROP DEFAULT"),
"退出哨兵的理由必须写在换键那一笔里:不写清 1364,"
+ "本文件头注释那条旧承诺就会让人去摘一个现在摘不得的默认值");
}
/** 取哨兵探针 SQL 的 {@code TABLE_NAME IN ('a', 'b')} 段;只认这一段,别把 {@code 'company_id'} 也算进来。 */
private static List<String> probeTables(String guardSource) {
Matcher inList = Pattern.compile("TABLE_NAME\\s+IN\\s*\\(([^)]*)\\)").matcher(guardSource);
assertTrue(inList.find(), "哨兵源码里没有 TABLE_NAME IN (…) 这一段,取不到清单");
List<String> tables = new ArrayList<>();
Matcher quoted = Pattern.compile("'([^']+)'").matcher(inList.group(1));
while (quoted.find()) {
tables.add(quoted.group(1));
}
assertFalse(tables.isEmpty(), "IN 列表解析出 0 张表 ⇒ contains/assertFalse 两条都会恒真或恒假");
return tables;
}
private static Path sharedKeyMigrationFile() throws IOException {
List<Path> hits = versionFiles().stream()
.filter(p -> p.getFileName().toString().startsWith("V151__"))
.toList();
assertEquals(1, hits.size(), "V151(两张共享表退回全局唯一键)应存在且只有一个:" + hits);
return hits.get(0);
}
/** 破坏点:盘点文档没跟着改,下一个人按"取号起点"取号就撞号。 */
@@ -0,0 +1,553 @@
package com.nanri.aiimage.config;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* V149({@code columns} 从"全平台一棵菜单字典"改成"每家公司一套树")的文件审计。
* 设计:crawler-plugin/docs/ops/menu-company-tree-design-2026-10-06.md;
* 定案三条:D1 同笔迁移重指存量授权、D2 站点超管可带 company_id、D3 不复制 admin_companies。
*
* <p>本仓 pom 无 H2、无 testcontainers,迁移跑不起来,所以文件审计是唯一能守住的层——
* 与 {@link CompanyScopeMigrationV145Test} / {@link ProductCategoryMigrationV147Test} 同口径:
* 断言打在剥掉注释后的可执行 SQL 上,注释里的内容另用 {@link #rawMigration()} 单独钉。</p>
*
* <p>这一版和 V145/V147 最大的不同:它不是"加一列",而是<b>加列 + 换键 + 复制 + 重指授权</b>四件事
* 同批。只做前三件,第 2 家的账号一上线就掉光菜单(隐藏=静默删除);只做加列,
* {@code findDataPermission} 这类"按 column_key 点查 + LIMIT 1"会在同名多行里借位拿到别家的行。
* 所以下面每条破坏点都在问"这四件是不是真的都做完了、而且顺序对"。</p>
*/
class MenuTreeCompanyMigrationV149Test {
private static final Path ROOT = Path.of(System.getProperty("user.dir"));
private static final Path DB_DIR = ROOT.resolve("src/main/resources/db");
private static final String COLUMNS = "columns";
private static final String GRANTS = "user_column_permission";
/** 角色内在闸门那一行:设计定案 D3——唯一不复制的菜单。 */
private static final String GATE_KEY = "admin_companies";
// ---------------------------------------------------------------- 取文件
private static List<Path> versionFiles() throws IOException {
try (Stream<Path> s = Files.list(DB_DIR)) {
return s.filter(p -> p.getFileName().toString().matches("^V\\d+(?:_\\d+)?__.*\\.sql$"))
.sorted()
.toList();
}
}
private static int versionOf(Path p) {
Matcher m = Pattern.compile("^V(\\d+)(?:_\\d+)?__").matcher(p.getFileName().toString());
return m.find() ? Integer.parseInt(m.group(1)) : -1;
}
private static Path migration() throws IOException {
List<Path> hits = versionFiles().stream()
.filter(p -> p.getFileName().toString().startsWith("V149__"))
.toList();
assertFalse(hits.isEmpty(), "缺少 V149__*.sql:菜单树还没按公司分棵");
assertEquals(1, hits.size(), "V149 只允许一个迁移文件(撞号会让两台 java 同时起不来)");
return hits.get(0);
}
private static String raw(Path file) throws IOException {
return Files.readString(file, StandardCharsets.UTF_8);
}
private static String rawMigration() throws IOException {
return raw(migration());
}
private static String statements() throws IOException {
return normalize(stripComments(rawMigration()));
}
// ------------------------------------------------------------ SQL 预处理
// 与 CompanyScopeMigrationV145Test 逐字同实现:注释里的 -- 与字符串里的 -- 是两件事,
// 另写一版简化实现会让断言打在残缺 SQL 上。
private static String stripComments(String sql) {
StringBuilder out = new StringBuilder(sql.length());
int i = 0;
while (i < sql.length()) {
char c = sql.charAt(i);
if (c == '\'') {
int end = i + 1;
while (end < sql.length()) {
if (sql.charAt(end) == '\'') {
if (end + 1 < sql.length() && sql.charAt(end + 1) == '\'') {
end += 2;
continue;
}
break;
}
end++;
}
out.append(sql, i, Math.min(end + 1, sql.length()));
i = end + 1;
continue;
}
if (c == '-' && i + 1 < sql.length() && sql.charAt(i + 1) == '-') {
while (i < sql.length() && sql.charAt(i) != '\n') {
i++;
}
continue;
}
if (c == '/' && i + 1 < sql.length() && sql.charAt(i + 1) == '*') {
int end = sql.indexOf("*/", i + 2);
i = end < 0 ? sql.length() : end + 2;
continue;
}
out.append(c);
i++;
}
return out.toString();
}
private static String normalize(String sql) {
return sql.replaceAll("\\s+", " ").trim();
}
private static long count(String haystack, String needle) {
long n = 0;
int i = haystack.indexOf(needle);
while (i >= 0) {
n++;
i = haystack.indexOf(needle, i + needle.length());
}
return n;
}
/** 抽出所有形如 {@code ALTER TABLE `x`} 的表名,用于"只动这几张表"的判据。 */
private static List<String> alteredTables(String sql) {
List<String> hits = new ArrayList<>();
Matcher m = Pattern.compile("ALTER TABLE `([a-z_]+)`").matcher(sql);
while (m.find()) {
hits.add(m.group(1));
}
return hits;
}
/**
* 把旁路种子类的源切成"一条种子语句 = 一段":每个 {@code executeQuietly(} /
* {@code executeUpdateQuietly(} 的起点到下一个标记的起点。
* 只在<b>注释已剥、空白已归一</b>的源上切,所以类注释里那句"裸 {@code WHERE column_key = ...}"
* 不会被当成一条种子喂给判据。
*/
private static List<String> seedStatements(String normalizedSource) {
Matcher m = Pattern.compile("execute(?:Update)?Quietly\\(").matcher(normalizedSource);
List<Integer> starts = new ArrayList<>();
List<Integer> bodies = new ArrayList<>();
while (m.find()) {
starts.add(m.start());
bodies.add(m.end());
}
List<String> regions = new ArrayList<>();
for (int i = 0; i < bodies.size(); i++) {
int to = i + 1 < starts.size() ? starts.get(i + 1) : normalizedSource.length();
regions.add(normalizedSource.substring(bodies.get(i), to));
}
return regions;
}
/**
* 一把尺子:一段种子语句里凡按 {@code column_key} 认菜单的(写比较的,不是列清单里那个列名),
* 就必须在同一段里钉住 {@code company_id}。返回"按 key 认菜单却没钉公司"的那些段。
*/
private static List<String> keyLookupsWithoutCompany(List<String> regions) {
List<String> offenders = new ArrayList<>();
for (String region : regions) {
if (region.contains("column_key =") && !region.contains("company_id")) {
offenders.add(region);
}
}
return offenders;
}
// ------------------------------------------------------------------ 用例
/** 破坏点:取到已应用的号(原地改=两台都起不来),或者根本没落盘。 */
@Test
void migrationIsVersionedOneFourNine() throws IOException {
Path file = migration();
assertEquals(149, versionOf(file), "本迁移必须是 V149");
assertTrue(file.getFileName().toString().matches("^V149__[A-Za-z0-9_.-]+\\.sql$"),
"命名应 V149__<snake 描述>.sql:" + file.getFileName());
}
/**
* 破坏点:三段式少任何一段。少回填 ⇒ 第 3 段的 MODIFY 把存量行撞成 1048;
* 少 MODIFY ⇒ 列可空,"没有归属的行"在任何公司的树上都不出现,而按 key 点查会判成"这个菜单不存在"。
* 加列必须走<b>末位</b>(不许出现 {@code AFTER}):非末位加列能不能 INSTANT 取决于生产 MySQL 小版本,
* 押错了是发版窗口第 1 段直接 1846,而这一列的位置没有任何语义。
*/
@Test
void companyColumnIsAppendedBackfilledThenTightened() throws IOException {
String sql = statements();
assertTrue(sql.contains("ALTER TABLE `columns` ADD COLUMN `company_id` bigint NULL COMMENT"),
"第 1 段应先加成可空:" + sql);
assertEquals(1, count(sql, "ALGORITHM = INSTANT"), "只有加列这一条走 INSTANT");
assertEquals(0, count(sql, " AFTER "), "末位加列才配得上 ALGORITHM = INSTANT,不许写 AFTER");
assertTrue(sql.contains("UPDATE `columns` SET `company_id` = 1 WHERE `company_id` IS NULL;"),
"存量归第 1 家必须带 IS NULL 限定(重跑才是 no-op,也不覆盖人工指定过的行)");
assertTrue(sql.contains("ALTER TABLE `columns` MODIFY COLUMN `company_id` bigint NOT NULL DEFAULT 1"),
"第 3 段收成 NOT NULL DEFAULT 1,它同时是回填没跑全的自检闸门(1048)");
assertEquals(1, count(sql, "MODIFY COLUMN `company_id`"), "MODIFY 只许出现在建列定形状这一处");
}
/**
* 破坏点:新键没把 company_id 放第一位,或旧键还在。
* 旧键 {@code uk_column_key} 不摘,第 2 家公司连"和别家同名"的菜单都建不出来——
* 那不是看不到,是建不出,整套改造白做;而先 DROP 后 ADD 的写法会让中间态裸奔,
* 且复制段直接撞旧键的全局唯一(1062)。
*/
@Test
void uniqueKeysAreReplacedNotLayeredAndInThatOrder() throws IOException {
String sql = statements();
assertTrue(sql.contains("ADD UNIQUE KEY `uk_company_column_key` (`company_id`, `column_key`)"), sql);
assertTrue(sql.contains("ADD UNIQUE KEY `uk_company_menu_type_route_path` (`company_id`, `menu_type`, `route_path`)"), sql);
assertTrue(sql.contains("DROP INDEX `uk_column_key`"), "旧的全局键必须摘,否则第二棵树建不出来");
assertTrue(sql.contains("DROP INDEX `uk_menu_type_route_path`"), "路径的全局键同理");
assertTrue(sql.indexOf("ADD UNIQUE KEY `uk_company_column_key`") < sql.indexOf("DROP INDEX `uk_column_key`"),
"顺序必须是先 ADD 后 DROP:中间任一步失败都还剩一个唯一键在守并发");
assertTrue(sql.indexOf("ADD UNIQUE KEY `uk_company_menu_type_route_path`") < sql.indexOf("DROP INDEX `uk_menu_type_route_path`"));
// 复制段(第 6 段)排在两条旧键摘掉之后,否则它撞的就是旧键。
assertTrue(sql.indexOf("DROP INDEX `uk_column_key`") < sql.indexOf("INSERT INTO `columns`"),
"换键必须早于复制段");
assertEquals(4, count(sql, "ALGORITHM = INPLACE, LOCK = NONE"),
"四条索引操作都要钉 INPLACE+LOCK=NONE,否则 MySQL 可以选 COPY 锁写");
}
/**
* 破坏点:驱动集硬编码"公司 2"。第三家开通时就得再发一版迁移。
* 破坏点 2:把 {@code admin_companies} 也复制了——它是角色内在闸门(Java 的 SUPER_ADMIN_ONLY_KEYS
* 与前端 SUPER_ADMIN_ONLY_MENU_KEYS 同值),别家树里有这一行只会多一个"谁也授不出去"的摆设。
*/
@Test
void copyIsDrivenByTheCompanyTableAndSkipsTheRoleIntrinsicGate() throws IOException {
String sql = statements();
assertTrue(sql.contains("FROM `company` co"), "复制段的驱动集应是 company 全表,不是写死一个公司 id");
assertTrue(sql.contains("JOIN `columns` src ON src.company_id = 1"), "源树固定取公司 1");
assertTrue(sql.contains("WHERE co.id <> 1"), "对【所有】非 1 的公司做(含 status=0,少一家树就少一次启用检查)");
assertTrue(sql.contains("AND src.column_key <> 'admin_companies'"),
"定案 D3:admin_companies 不复制");
assertTrue(sql.contains("AND NOT EXISTS ("), "复制段必须幂等(repair 重跑不插第二份)");
assertEquals(1, count(sql, "INSERT INTO `columns`"), "本迁移只有一条插菜单行的语句");
}
/**
* 破坏点:副本照抄源行的 parent_id。那是全局 id,会把别家的子页面挂到厦门米椿花的分组下——
* 而 {@code fk_columns_parent_id} 只保证父行【存在】,挡不住跨公司挂父,库侧不会喊。
* 所以插入时父必须留 NULL,再按 (company_id, column_key) 认父。
*/
@Test
void copiesReparentByColumnKeyNeverById() throws IOException {
String sql = statements();
assertTrue(sql.contains("SELECT co.id, src.name, src.column_key, src.menu_type, src.route_path, src.sort_order, NULL, src.created_at"),
"插入段的 parent 位置必须是字面 NULL:" + sql);
assertTrue(sql.contains("JOIN `columns` pcopy ON pcopy.company_id = copy.company_id AND pcopy.column_key = sp.column_key"),
"认父要沿 (company_id, column_key) 走");
assertTrue(sql.contains("SET copy.parent_id = pcopy.id"));
assertTrue(sql.contains("AND copy.parent_id IS NULL"), "重跑时已认过父的行不再改动");
assertEquals(1, count(sql, "SET copy.parent_id"), "认父只有一条语句");
}
/**
* 破坏点:第 8 段(去重)没跑就先重指。同一账号若同时挂着源行与副本,重指会撞
* {@code (user_id, column_id)} 主键报 1062 —— 而这条只在 repair 重跑那种中途态才可能出现,
* 所以它必须写在重指之前,而不是"反正今天 0 行"。
*/
@Test
void duplicateGrantsArePrunedBeforeTheRepoint() throws IOException {
String sql = statements();
assertTrue(sql.contains("DELETE dup FROM `user_column_permission` dup"), "缺第 8 段的重指在重跑时会撞 1062");
assertTrue(sql.indexOf("DELETE dup FROM") < sql.indexOf("UPDATE `user_column_permission` g"),
"去重必须排在重指之前");
assertEquals(1, count(sql, "DELETE dup FROM"), "去重只删副本那一侧,且只此一处");
}
/**
* 破坏点(定案 D1 的核心):只复制树不重指授权。存量 784 笔里公司 2 那 16 笔仍挂在
* 公司 1 的行上,而读侧改成"只认本公司"之后,德阳的 2 只账号一上线掉光菜单——
* 这是"隐藏=静默删除"的同一类事故,所以它必须是同笔迁移的动作而不是发布后的人工待办。
*/
@Test
void existingGrantsAreRepointedToTheOwnCompanyCopy() throws IOException {
String sql = statements();
assertTrue(sql.contains("UPDATE `user_column_permission` g"), "第 9 段:存量授权重指向本公司副本");
assertTrue(sql.contains("JOIN `columns` copy ON copy.company_id = u.company_id AND copy.column_key = src.column_key"),
"认行按 column_key,不按 id 猜");
assertTrue(sql.contains("SET g.column_id = copy.id"));
assertTrue(sql.contains("WHERE u.company_id <> 1"),
"驱动条件限定在\"不属于公司 1\",重跑时这一行都选不出来=no-op");
assertEquals(1, count(sql, "SET g.column_id"), "改授权指针只有一条语句");
}
/**
* 破坏点:残留没让它响。四道闸门(临时表 must_be_zero NOT NULL,V143 那个"让约束替我喊"的家族)
* 缺任何一道,对应的失效形状都是"树少一棵 / 父挂错家 / 授权挂别家 / 冒出无归属行"——
* 四条全都不报错,只是某家公司侧边栏空白或按 key 点查判成"菜单不存在"。
*/
@Test
void fourGatesFailTheMigrationOnAnyResidual() throws IOException {
String sql = statements();
assertTrue(sql.contains("CREATE TEMPORARY TABLE IF NOT EXISTS `_v149_gate` (`must_be_zero` INT NOT NULL)"),
"闸门表必须是 NOT NULL 的一列——插 NULL 才抛 1048");
assertEquals(4, count(sql, "INSERT INTO `_v149_gate`"), "四道闸门:齐套性/跨公司父/跨公司授权/无归属行");
assertEquals(4, count(sql, "SELECT IF(COUNT(*) = 0, 0, NULL)"),
"每道都必须是\"计数为 0 才插得进去\"的形状,写成了 SELECT 就永远不为 0");
assertEquals(1, count(sql, "DROP TEMPORARY TABLE `_v149_gate`"), "闸门表用完要删");
// 逐道点名,防"四道其实都探同一件事"
assertTrue(sql.contains("LEFT JOIN `columns` cp ON cp.company_id = co.id AND cp.column_key = src.column_key"),
"闸门 1 要按公司逐行核对齐套");
assertTrue(sql.contains("WHERE c.company_id <> p.company_id"), "闸门 2 探跨公司父");
assertTrue(sql.contains("WHERE c.company_id <> u.company_id"), "闸门 3 探跨公司授权");
assertTrue(sql.contains("WHERE `company_id` IS NULL OR `company_id` <= 0"), "闸门 4 探无归属行");
}
/**
* 破坏点:写成裸 ALTER(不可重跑)。MySQL 的 DDL 不进事务,repair + 重启会从第一条语句重跑整个文件,
* 裸 ALTER 在恢复路径上必撞 1060/1050。
* 计数由本轮扫描得出、不自挑:五条条件 DDL(1 加列 + 2 加键 + 2 摘键)各配一份元数据判断与 PREPARE;
* 唯一不守卫的那条是 MODIFY——它在已 NOT NULL 的列上重跑不报错,属于天生幂等。
*/
@Test
void everyConditionalDdlIsGuardedByInformationSchema() throws IOException {
String sql = statements();
long alters = count(sql, "ALTER TABLE");
assertEquals(6, alters, "本迁移应有 6 条 ALTER(5 条件 + 1 条 MODIFY),实际 " + alters);
assertEquals(alters - 1, count(sql, "PREPARE stmt FROM @sql"), "五条条件 DDL 都要走 PREPARE");
assertEquals(alters - 1, count(sql, "DEALLOCATE PREPARE stmt"), "PREPARE 名复用前必须 DEALLOCATE");
assertEquals(alters - 1, count(sql, "information_schema"), "每条条件 DDL 各自要一次元数据存在性判断");
assertEquals(1, count(sql, "MODIFY COLUMN"), "不守卫的那一条只能是 MODIFY");
}
/** 破坏点:顺手改了 users / company,或建了持久表(菜单树的归属改造只该动这两张表)。 */
@Test
void touchesOnlyTheMenuCatalogAndItsGrants() throws IOException {
String sql = statements();
assertTrue(alteredTables(sql).stream().allMatch(COLUMNS::equals),
"所有 ALTER 都只能打在 columns 上,实际动到了 " + alteredTables(sql));
assertFalse(sql.contains("ALTER TABLE `users`"), "users.company_id 归 V143/V144 管,本迁移只读它");
assertFalse(sql.contains("ALTER TABLE `company`"), "company 表结构不动");
assertFalse(sql.replace("CREATE TEMPORARY TABLE", "").contains("CREATE TABLE"),
"除闸门临时表外不建持久表");
assertTrue(sql.contains("UPDATE `user_column_permission`"), "授权重指是本迁移的第二张写表");
assertEquals(0, count(sql, "DELETE FROM `users`"), "绝不删账号");
}
/** 破坏点:影响面是估的、DEFAULT 的倒计时没人接。锁表结论与摘 DEFAULT 的时点都只有配上实查数才站得住。 */
@Test
void headerCarriesMeasuredVolumesAndTheDefaultCountdown() throws IOException {
String raw = rawMigration();
assertTrue(raw.contains("52 行"), "columns 行数必须是生产实查值");
assertTrue(raw.contains("784") && raw.contains("133"), "授权笔数/账号数必须是生产实查值(重指段的分母)");
assertTrue(raw.contains("admin_companies"), "头注释要写明那一行不复制的理由,否则后人以为漏了");
assertTrue(raw.contains("1048"), "MODIFY 兼作回填自检闸门这件事要写进注释");
assertTrue(raw.contains("1364"), "DEFAULT 1 是为同批旧 jar 存在(旧实体没这列,insert 整列跳过会报它)");
assertTrue(raw.contains("COMPANY_DEFAULT_STILL_PRESENT"),
"摘 DEFAULT 的倒计时由启动期哨兵喊,头注释要点名那条 ASCII 签名");
assertTrue(raw.contains("ALTER COLUMN company_id DROP DEFAULT"),
"要给出摘除的安全写法(纯元数据),否则后人会照 V143 用 MODIFY 重建表");
assertTrue(raw.contains("禁写成 MODIFY"), "下一版摘 DEFAULT 禁 MODIFY 这条要写在文件里");
assertTrue(raw.contains("从第一条语句重跑整个文件"), "可重跑性是恢复路径的前提,注释要写明");
}
/** 破坏点:验证段没核对"各家齐不齐"和"授权还挂不挂在别家"。这两条是上线当晚唯一能证伪的读数。 */
@Test
void shipsPostDeployVerificationSql() throws IOException {
String raw = rawMigration();
assertTrue(raw.contains("SELECT company_id, menu_type, COUNT(*) FROM columns GROUP BY company_id, menu_type"),
"验证 SQL 要按公司×类型数行数");
assertTrue(raw.contains("WHERE c.company_id <> u.company_id"), "验证 SQL 要复验跨公司授权残留");
assertTrue(raw.contains("information_schema.STATISTICS"), "验证 SQL 要复验两条旧键已摘、两条新键在");
}
/**
* 破坏点:回滚被编成版本化迁移(Flyway 扫描路径里的 V*.sql 会在下次启动自动执行),
* 或者回滚把"删副本"排在"重指授权"之前。
*
* <p>后者是这一版独有的陷阱:{@code user_column_permission} 的外键是 ON DELETE CASCADE,
* 先删副本会把它名下授权一起删光——而 V149 之后账号名下"本来就该"挂的是副本行。
* 写反的读数不是报错,是 133 只账号的菜单被清空。</p>
*/
@Test
void rollbackRepointsGrantsBeforeDeletingTheCopiesAndStaysUnversioned() throws IOException {
Pattern writesHistoryTable = Pattern.compile(
"\\b(DELETE|UPDATE|INSERT|TRUNCATE|ALTER|DROP)\\b[^;]*\\bflyway_schema_history\\b",
Pattern.CASE_INSENSITIVE);
for (Path file : versionFiles()) {
String executable = normalize(stripComments(raw(file)));
assertFalse(writesHistoryTable.matcher(executable).find(),
"回滚不许编成版本化迁移:" + file.getFileName() + " 的执行段写了 flyway_schema_history");
}
Path rollback = ROOT.resolve("docs/rollback-V149-permission-menu-company.sql");
assertTrue(Files.isRegularFile(rollback), "回滚人工补丁必须存在:" + rollback);
String whole = raw(rollback);
assertTrue(whole.contains("flyway_schema_history"), "回滚必须删本版本历史行(漏掉=重装时 Flyway 跳过 V149)");
String executable = normalize(stripComments(whole));
assertTrue(executable.contains("SET g.column_id = src.id"), "回滚要先把授权指针挪回公司 1 的源行");
assertTrue(executable.contains("DELETE FROM `columns` WHERE company_id <> 1"), "再删副本");
assertTrue(executable.indexOf("SET g.column_id = src.id") < executable.indexOf("DELETE FROM `columns`"),
"顺序不能反:FK 是 ON DELETE CASCADE,先删副本等于清空 133 只账号的菜单");
assertTrue(whole.contains("ON DELETE CASCADE"), "注释要写明为什么这个顺序是陷阱");
assertTrue(executable.contains("ADD UNIQUE KEY `uk_column_key` (`column_key`)"), "回滚要把两条全平台旧键加回来");
assertTrue(executable.contains("ADD UNIQUE KEY `uk_menu_type_route_path` (`menu_type`, `route_path`)"));
assertTrue(executable.contains("DROP INDEX `uk_company_column_key`"), "并摘掉两条按公司的新键");
assertTrue(executable.contains("DROP INDEX `uk_company_menu_type_route_path`"));
assertTrue(executable.indexOf("ADD UNIQUE KEY `uk_column_key`") < executable.indexOf("DROP INDEX `uk_company_column_key`"),
"回滚同样是先 ADD 后 DROP:中间态必须还剩一个唯一键");
assertTrue(executable.contains("CREATE TEMPORARY TABLE `_v149_rb_gate`"),
"重指与删除之间要有闸门:漏一行就会被 CASCADE 静默吞掉");
assertTrue(executable.contains("CREATE TABLE IF NOT EXISTS `columns_bak_v149_rollback`"),
"删副本前必须整表留底");
}
/**
* 破坏点:头注释喊了哨兵,哨兵却没探这一列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
* 这条把文档承诺与代码实现对齐(V145 同类用例的同口径)。
*/
@Test
void startupSentinelActuallyWatchesTheMenuColumn() throws IOException {
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
String text = raw(guard);
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep docker logs)");
assertTrue(text.contains("\"columns\""), "哨兵要探 columns.company_id,否则 V149 的 DEFAULT 没人盯");
assertTrue(text.contains("'columns'"), "探针 SQL 的 IN 列表也要含它,只进清单是假盯");
assertTrue(text.contains("COLUMN_DEFAULT"), "哨兵应真的读列元数据,而不是靠猜");
}
/**
* 破坏点:旁路种子(启动期自建表/键的那个初始化器)还按换列之前的全局口径建键。
* 它一旦被执行,新库就会带着 {@code uk_column_key} 起来 ⇒ 第二家公司的树建不出来,
* 而 V149 的 DROP 只在存量库跑过——这条是"不得回流"的反向钉。
*/
@Test
void schemaInitializerKeepsTheCompanyScopedKeys() throws IOException {
Path initializer = ROOT.resolve(
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java");
String text = raw(initializer);
assertTrue(text.contains("UNIQUE KEY uk_company_column_key (company_id, column_key)"),
"建表要直接带复合键");
assertFalse(text.contains("ADD UNIQUE KEY uk_column_key"), "不得再建全局 column_key 键");
assertFalse(text.contains("ADD UNIQUE KEY uk_menu_type_route_path"), "不得再建全局 (menu_type, route_path) 键");
assertFalse(text.contains("company_id BIGINT NULL COMMENT '归属公司:每家公司一套菜单树' AFTER"),
"加列同样是末位追加,INSTANT 不押版本");
assertTrue(text.contains("UPDATE columns SET company_id = 1 WHERE company_id IS NULL"),
"种子路径也要把存量收成 NOT NULL 三段式的第 2 段");
}
/**
* 破坏点:旁路种子(生产默认关,但新库/本地/那条 `permission-schema-init.enabled=true` 的通道会跑)
* 建出来的行没钉公司。V149 之后 {@code column_key} <b>只在单家公司内唯一</b>,这条通道里一句裸
* {@code WHERE column_key = ...} 就是"把每一家的同名行都改一遍"——别家副本的 parent 被拍平、
* 初始授权发给别家的行 id;而 {@code executeQuietly} 把 1048/1062 吞成一行 debug 日志,
* 表现是"某一家一声不响少一套菜单"。
*
* <p>另一层:这里显式写 {@code company_id} 之后,这条通道就不再依赖列上那条 {@code DEFAULT 1},
* 于是待办里那句 {@code ALTER TABLE columns ALTER COLUMN company_id DROP DEFAULT} 落地时
* 不会把这里的建号变成 1364。所以本用例同时钉"列清单带公司"与"投影是真常量 1"。</p>
*
* <p>形状与 {@code PermissionCompanyMenuHiddenTest} 同一套:先证明取样集非空、
* 再证明这把尺子认得出已知的一条违规(否则上面的 0 命中是恒绿)。</p>
*/
@Test
void schemaInitializerSeedsEveryRowIntoTheTemplateCompany() throws IOException {
String src = normalize(stripComments(raw(ROOT.resolve(
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java"))));
List<String> regions = seedStatements(src);
List<String> keyLookups = regions.stream().filter(r -> r.contains("column_key =")).toList();
assertTrue(regions.size() >= 25, "种子语句取样集太小,扫描器多半没切开:" + regions.size());
assertTrue(keyLookups.size() >= 12,
"按 column_key 认菜单的种子语句取样集太小(换键后这类语句只会更多,不会更少):" + keyLookups.size());
assertEquals(count(src, "INSERT INTO columns ("), count(src, "INSERT INTO columns (company_id,"),
"每条 INSERT 的列清单都要显式带 company_id,不许再让列 DEFAULT 兜");
assertTrue(count(src, "INSERT INTO columns (company_id,") >= 6,
"取样集自检:这条通道本就要种 4 个分组 + 18 条菜单 + 2 条 internal,INSERT 语句不该只剩几条");
assertEquals(count(src, "INSERT INTO columns (company_id,"), count(src, "SELECT 1, "),
"每条种子 INSERT 的投影都必须是常量 1(模板公司):换成别的数字就是在往别家插平台默认行");
assertEquals(1, count(src, "data_col.company_id = old_col.company_id"),
"初始授权必须把 data_col 收在 old_col 同一家,否则老账号拿到别家的数据权限行 id");
assertTrue(keyLookupsWithoutCompany(regions).isEmpty(),
"这些种子语句按 column_key 认菜单却没钉公司,等于对每一家各改一遍:" + keyLookupsWithoutCompany(regions));
String scoped = " ( SELECT 1, 'x', 'admin_users' FROM columns WHERE company_id = 1 AND column_key = 'admin_users' ) ";
String bare = " ( SELECT 1, 'x', 'admin_users' FROM columns WHERE column_key = 'admin_users' ) ";
assertEquals(List.of(bare), keyLookupsWithoutCompany(List.of(scoped, bare)),
"尺子自检:一条没钉公司的已知违规必须被抓到,同时已钉公司的那条不许误报");
}
/**
* 破坏点:读侧或写侧编一个"没带公司就回落公司 1"的临时分支。
* 定案是路线甲(V149 与 jar 同批双台),混合窗口里旧 jar 靠列上的 DEFAULT 兜,不需要 Java 侧兜——
* 而 Java 侧一旦有兜底,"忘了传公司"就从 1048/403 变成静默归到第 1 家。
*
* <p>断言形状:先确认扫描器抓得到锚点(0 命中=尺子坏了),再要求三种兜底写法各 0 命中。</p>
*/
@Test
void serviceHasNoFallbackBranchToTheDefaultCompany() throws IOException {
String src = raw(ROOT.resolve(
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java"));
assertTrue(src.contains("resolveScopeCompanyId"), "扫描器要能命中归属判据本身,否则下面的 0 命中不作数");
assertEquals(0, count(src, "? 1L"), "不许出现 `x == null ? 1L` 这种回落默认公司");
assertEquals(0, Pattern.compile("\\?\\s*1L\\b").matcher(src).results().count(), "同上,容空格拉写");
assertFalse(src.contains("COMPANY_DEFAULT"), "不许在本类里另立默认公司常量");
}
/**
* 破坏点:目录取数留下"不带公司"的重载。生产上 operator 恒有 companyId,走不到无参那条,
* 于是"跨公司混树"这条路永远只对新代码开放——按方法名精确匹配,不接受 {@code loadMenus(} 这种含二参的宽匹配。
*
* <p>判据用"括号里既无逗号也无嵌套括号"来认单参调用;抓不住的形状是 {@code loadMenus(resolve(a, b))}
* 这种把唯一实参写成调用式的写法。下面那条阳性对照(喂一条已知违规)证明这把尺子不是恒绿的。</p>
*/
@Test
void menuLoadingAlwaysCarriesACompany() throws IOException {
String src = raw(ROOT.resolve(
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java"));
for (String method : List.of("loadMenus", "loadRawMenus")) {
Pattern singleArg = Pattern.compile(method + "\\([^(),]*\\)");
assertEquals(1, Pattern.compile("List<PermissionMenuEntity> " + method + "\\(").matcher(src).results().count(),
method + " 只允许一个声明");
assertEquals(0, singleArg.matcher(src).results().count(),
method + " 不许有单参调用/重载:每个取数点都要显式带公司");
assertEquals(1, singleArg.matcher("List<PermissionMenuEntity> rows = " + method + "(companyId);")
.results().count(), "尺子自检:已知的一条单参调用必须被抓到,否则上面的 0 命中不作数");
}
}
/** 破坏点:盘点文档没跟着改,下一个人按"取号起点"取号就撞号。 */
@Test
void inventoryDocTracksV149() throws IOException {
String text = raw(ROOT.resolve("docs/migration-inventory.md"));
assertTrue(text.contains(migration().getFileName().toString()), "盘点文档应记录 V149 文件名");
assertTrue(text.contains("V152"), "盘点文档应记下新的取号起点(V150/V151 已被同批占用)");
// 取号起点是否真等于"当前最大值 + 1"由 MigrationInventoryTest 派生判定,这里不重复钉死字面号。
}
/** 自检:本用例集扫的是真文件,且 normalize 后仍能命中关键串(0 命中的断言是恒绿的)。 */
@Test
void scannedSignaturesAreActuallyPresent() throws IOException {
String sql = statements();
assertTrue(sql.length() > 1000, "剥注释后的 SQL 太短,说明预处理把内容吃掉了:" + sql.length());
assertTrue(count(sql, "ALTER TABLE") > 0 && count(sql, "information_schema") > 0
&& count(sql, "INSERT INTO `columns`") > 0,
"关键签名 0 命中=预处理或文件路径坏了,本类的断言全部不可信");
}
}
@@ -68,13 +68,24 @@ class MigrationInventoryTest {
}
/**
* 已在生产 flyway_schema_history 中占位、但本地文件被改名让位的版本号。
* 生产 131 之后直接装了 134/135(2026-09-25 20:46:16),132/133 从未落库;
* 而 Flyway 未开 out-of-order,把新迁移编号改回 132/133 会导致启动期
* "resolved migration not applied" 失败,所以这个洞只能永久保留、不能回填。
* 后果:新迁移只能取当前最大值之上的号(详见 docs/migration-inventory.md)。
* 不许再被占用的整数版本洞。两条来历不同,得分开记:
*
* <p><b>132/133</b>:已在生产 {@code flyway_schema_history} 中占位、但本地文件被改名让位的版本号。
* 生产 131 之后直接装了 134/135(2026-09-25 20:46:16),132/133 从未落库;而 Flyway 未开
* out-of-order,把新迁移编号改回 132/133 会导致启动期 "resolved migration not applied" 失败,
* 所以这个洞只能永久保留、不能回填。</p>
*
* <p><b>148</b>:{@code V148__product_category_builtin_owned_by_company.sql}(内置类目归还厦门米椿花)
* 从未上线,2026-10-06 控制方点名「商品类目做成共享的,不区分」⇒ 这一版的口径被整体推翻,
* 文件连同 {@code ProductCategoryMigrationV148Test} 与 rollback 补丁一起删掉。
* 与 132/133 不同,把新迁移编号写回 148 在 Flyway 语义上【是】可行的(生产最大值仍是 147)——
* 这里禁它是共树并发的护栏:那一版是另一路会话此刻正在引用的号,删掉的文件可能被再次写出,
* 而同号两个文件会让 Flyway 启动期报 "Found more than one migration with version 148",
* 后果是两台 java 同时起不来。宁可让本用例红,也不把撞号留到运行期发现。</p>
*
* <p>共同后果:新迁移只能取当前最大值之上的号(详见 docs/migration-inventory.md)。</p>
*/
private static final Set<Integer> RETIRED_HOLES = Set.of(132, 133);
private static final Set<Integer> RETIRED_HOLES = Set.of(132, 133, 148);
@Test
void integerVersionsSequentialFromOne() throws IOException {
@@ -6,6 +6,7 @@ import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -231,19 +232,69 @@ class ProductCategoryMigrationV147Test {
}
/**
* 破坏点:V147 的 DEFAULT 1 没进启动期哨兵清单 ⇒ "下一次记得摘"这件事没人喊,
* 而巡检按 {@code COMPANY_DEFAULT_STILL_PRESENT} 这条 ASCII 签名 grep docker logs。
* 破坏点(2026-10-06 起方向相反):类目表随「商品类目做成所有公司共享」的定案<b>退出</b>了启动期
* 哨兵清单,而它现在仍带 {@code DEFAULT 1}——这一列从"待摘的风险"翻转成了 {@code NOT NULL} 的
* 承重约束:新 jar 的 INSERT/UPDATE 列清单都不带 company_id,靠默认值填。
*
* <p>所以这一支钉的是"哨兵必须不再对它喊"。清单与探针 SQL 的 IN 列表<b>两侧都要钉</b>:
* 只摘一侧会重演本类要避免的那两种静默形状——清单里还在、IN 里没有 ⇒ 每次启动报"探不到"的 WARN;
* IN 里还在、清单里没有 ⇒ 查到了却没人判定,而 {@code CompanyDefaultGuardTest} 的双向同源钉
* 会红在那一张"仍按公司"的表上,不会红在这里。</p>
*
* <p>另一半:退出这件事必须在版本化的迁移注释里有据可查。只改代码不改说法,下一个人会照
* 本文件头注释(V147 那一版写的是"记得摘 DEFAULT")或 {@code CompanyDefaultGuard} 给出的
* {@code DROP DEFAULT} 语句去执行,代价是每次写入 1364,而且这张表的失败会直接顶到管理员面前。</p>
*/
@Test
void startupSentinelWatchesTheProductCategoryColumn() throws IOException {
void startupSentinelHasStoppedWatchingTheProductCategoryColumn() throws IOException {
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
String text = raw(guard);
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep)");
assertTrue(text.contains("'" + TABLE + "'"),
"探针 SQL 的 IN 列表要含 " + TABLE + "(不在 IN 里就查不到这一列,哨兵等于没探)");
assertTrue(text.contains("\"" + TABLE + "\""),
"WATCHED_TABLES 清单要含 " + TABLE + "(查到了却不在清单里,就没人去喊那条签名)");
assertFalse(probeInList(text).contains(TABLE),
"探针 SQL 的 IN 列表不许再有 " + TABLE + ":查到了就等于还要人摘 DEFAULT");
assertFalse(watchedTables(text).contains(TABLE),
"WATCHED_TABLES 清单不许再有 " + TABLE + ":清单才是判定走不走的那一侧");
Path v151 = sharedKeyMigrationFile();
String note = raw(v151);
assertTrue(note.contains(TABLE), "退键那一笔要点名类目表:" + v151.getFileName());
assertTrue(note.contains("DROP DEFAULT") && note.contains("1364"),
"必须写明\"这一版的 DEFAULT 摘不得\"及其后果,否则 V147 头注释那条旧承诺仍然会被执行");
}
/** 取探针 SQL 的 {@code TABLE_NAME IN ('a', 'b')} 段(单引号)。 */
private static List<String> probeInList(String guardSource) {
Matcher inList = Pattern.compile("TABLE_NAME\\s+IN\\s*\\(([^)]*)\\)").matcher(guardSource);
assertTrue(inList.find(), "哨兵源码里没有 TABLE_NAME IN (…) 这一段,取不到清单");
return quotedValues(inList.group(1), "'([^']+)'");
}
/** 取 {@code WATCHED_TABLES = List.of("a", "b")} 那批双引号表名。 */
private static List<String> watchedTables(String guardSource) {
Matcher list = Pattern.compile("WATCHED_TABLES\\s*=\\s*List\\.of\\(([^)]*)\\)").matcher(guardSource);
assertTrue(list.find(), "取不到 WATCHED_TABLES 清单:哨兵源码的形状变了,本用例的尺子要跟着改");
return quotedValues(list.group(1), "\"([^\"]+)\"");
}
/** 解析不出任何一条就当场判红:0 命中会让上面那两条 {@code assertFalse} 恒真。 */
private static List<String> quotedValues(String segment, String quotePattern) {
List<String> values = new ArrayList<>();
Matcher quoted = Pattern.compile(quotePattern).matcher(segment);
while (quoted.find()) {
values.add(quoted.group(1));
}
assertFalse(values.isEmpty(), "从源码段里解析出 0 个表名 ⇒ 这段断言是恒绿的:" + segment);
return values;
}
private static Path sharedKeyMigrationFile() throws IOException {
List<Path> hits = versionFiles().stream()
.filter(p -> p.getFileName().toString().startsWith("V151__"))
.toList();
assertEquals(1, hits.size(), "V151(两张共享表退回全局唯一键)应存在且只有一个:" + hits);
return hits.get(0);
}
/**
@@ -0,0 +1,296 @@
package com.nanri.aiimage.config;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* V150({@code biz_shop_key} 加 company_id)的文件审计。
* 需求:2026-10-06 控制方点名「店铺密钥管理的数据按照公司区分」;设计见迁移文件头 §1–§6。
*
* <p>为什么必须单独有一支:本仓 pom 无 H2、无 testcontainers,迁移跑不起来,文件审计是唯一能守住的那层
* (与 {@link ProductCategoryMigrationV147Test}、{@link CompanyScopeMigrationV145Test} 同口径)。
* V150 的三条关键决定全都"错了不报错":</p>
* <ol>
* <li>历史归属靠加列时记录的 {@code DEFAULT 1},而不是回填——写成可空列或补一条 UPDATE 都改成另一种语义;</li>
* <li>唯一键 {@code uk_ziniao_token_hash} <b>刻意保持全局</b>(不像 V145/V147 那样按公司放宽),
* 谁"顺手把它按公司放宽"就会让同一个令牌在两家公司各存一行、被 {@code ZiniaoApiKeyProvider}
* 按令牌并成一条,白名单状态与代理地址互相顶掉;</li>
* <li>回滚的默认档是<b>保留新列、只回 jar</b>,删列那一步留在注释里由人工解开(这张表没有账号列,
* 列一删归属就再也分不回去)。</li>
* </ol>
*
* <p>{@code stripComments}/{@code normalize} 逐字沿用 {@link CompanyScopeMigrationV145Test} 那一份实现:
* 注释里的 {@code --} 与字符串字面量里的 {@code --} 是两件事,另写一版简化实现会让断言打在残缺 SQL 上。</p>
*/
class ShopKeyMigrationV150Test {
private static final Path ROOT = Path.of(System.getProperty("user.dir"));
private static final Path DB_DIR = ROOT.resolve("src/main/resources/db");
private static final String TABLE = "biz_shop_key";
private static final String GLOBAL_UNIQUE_KEY = "uk_ziniao_token_hash";
// ---------------------------------------------------------------- 取文件
private static List<Path> versionFiles() throws IOException {
try (Stream<Path> s = Files.list(DB_DIR)) {
return s.filter(p -> p.getFileName().toString().matches("^V\\d+(?:_\\d+)?__.*\\.sql$"))
.sorted()
.toList();
}
}
private static Path migration() throws IOException {
List<Path> hits = versionFiles().stream()
.filter(p -> p.getFileName().toString().startsWith("V150__"))
.toList();
assertEquals(1, hits.size(),
"V150 必须恰好一个迁移文件,实际 " + hits.size() + " 个(0 个=密钥表还没归属列;2 个=撞号,Flyway 启动即失败)");
return hits.get(0);
}
private static String raw(Path file) throws IOException {
return Files.readString(file, StandardCharsets.UTF_8);
}
private static String statements() throws IOException {
return normalize(stripComments(raw(migration())));
}
// ------------------------------------------------------------ SQL 预处理
// 与 CompanyScopeMigrationV145Test / ProductCategoryMigrationV147Test 逐字同实现,理由见类注释。
private static String stripComments(String sql) {
StringBuilder out = new StringBuilder(sql.length());
int i = 0;
while (i < sql.length()) {
char c = sql.charAt(i);
if (c == '\'') {
int end = i + 1;
while (end < sql.length()) {
if (sql.charAt(end) == '\'') {
if (end + 1 < sql.length() && sql.charAt(end + 1) == '\'') {
end += 2;
continue;
}
break;
}
end++;
}
out.append(sql, i, Math.min(end + 1, sql.length()));
i = end + 1;
continue;
}
if (c == '-' && i + 1 < sql.length() && sql.charAt(i + 1) == '-') {
while (i < sql.length() && sql.charAt(i) != '\n') {
i++;
}
continue;
}
if (c == '/' && i + 1 < sql.length() && sql.charAt(i + 1) == '*') {
int end = sql.indexOf("*/", i + 2);
i = end < 0 ? sql.length() : end + 2;
continue;
}
out.append(c);
i++;
}
return out.toString();
}
private static String normalize(String sql) {
return sql.replaceAll("\\s+", " ").trim();
}
// ------------------------------------------------------------------ 用例
/** 破坏点:取到已应用的号(原地改=两台都起不来),或把这一版编成 V152(V150 就被跳开,归属列永远不加)。 */
@Test
void migrationIsVersionedOneFiveZero() throws IOException {
Path file = migration();
Matcher m = Pattern.compile("^V(\\d+)(?:_\\d+)?__").matcher(file.getFileName().toString());
assertTrue(m.find(), "文件名应能抽出整数版本:" + file.getFileName());
assertEquals(150, Integer.parseInt(m.group(1)), "本迁移必须是 V150(V149 之后的下一号)");
assertTrue(file.getFileName().toString().matches("^V150__[A-Za-z0-9_.-]+\\.sql$"),
"命名应 V150__<snake 描述>.sql:" + file.getFileName());
}
/**
* 破坏点 ①:加成可空 ⇒ 混合窗口里旧 jar 写进来的密钥行 {@code company_id} 为 NULL,
* 而 {@code applyCompanyScope} 的 null 分支是「不裁剪」,这些行会同时出现在每一家的 tab 上。
* 破坏点 ②:写 {@code MODIFY COLUMN} ⇒ 重建表并按"当时的列默认值"物化历史行,而本迁移没写回历史行,
* 历史归属的全部依据就是加列那一刻记录的默认值(§6)。
* 破坏点 ③:加 {@code AFTER} ⇒ 非末位列在 InnoDB 里要重建聚簇记录,INSTANT 的前提没了。
* {@code DEFAULT 1} 必须<b>在场</b>:它是同批旧 jar 唯一能插进这张表的通道,摘它的是下一版。
*/
@Test
void addsANotNullCompanyColumnWithInstantAndNeverModify() throws IOException {
String sql = statements();
assertTrue(sql.contains("ALTER TABLE `" + TABLE + "` ADD COLUMN `company_id` bigint NOT NULL DEFAULT 1"),
TABLE + " 应一次到位加成 NOT NULL DEFAULT 1(DEFAULT 只为同批旧 jar 存在,摘除是下一版)");
assertTrue(sql.contains("ALGORITHM = INSTANT"),
"加列必须钉 INSTANT:前提不成立时 MySQL 直接报 1846,而不是悄悄退化成 COPY(§3)");
assertFalse(sql.toUpperCase().contains(" AFTER "), "不许写 AFTER:非末位列加列会触发整表重建(§3)");
assertFalse(sql.contains("MODIFY COLUMN"), "禁 MODIFY COLUMN——它会重建表并按当时的默认值物化历史行(§6)");
assertFalse(sql.contains("ALTER TABLE `" + TABLE + "` DROP COLUMN"), "本版本不删列:归属一旦删掉就再也分不出是第几家公司(§2)");
}
/**
* 列注释里那句「历史行由本默认值给出,不可反推」是这一列存在理由的一半:
* 它跟着 schema 走,将来接手的人不必翻迁移文件就知道第 1 家的行里混着窗口期的别家数据。
*/
@Test
void columnCommentCarriesTheProvenanceLimitation() throws IOException {
String sql = statements();
assertTrue(sql.contains("本表无账号列"), "列注释要写明「本表无账号列」,否则后来人会试图按创建人反推归属");
assertTrue(sql.contains("不可反推"), "列注释要写明历史归属「不可反推」,这是 §2 那个不可追回窗口的落点");
}
/**
* 破坏点:有人"顺手"补一条回填 UPDATE(这张表没有账号列,任何"按人回填"都是编数据);
* 或者加了 created_by_id / 二级索引,把"刻意不做的事"做成了既成事实。
* 计数取 0 而不是「不超过 1」:§2 的口径是历史行的 1 来自默认值,一条 DML 都不该有。
*/
@Test
void writesNoDmlAtAllAndAddsNoIndex() throws IOException {
String sql = statements();
Matcher d = Pattern.compile("\\b(UPDATE|INSERT|DELETE|REPLACE)\\b", Pattern.CASE_INSENSITIVE).matcher(sql);
int hits = 0;
while (d.find()) {
hits++;
}
assertEquals(0, hits, TABLE + " 的可执行段一条 DML 都不该有,实际命中 " + hits + " 条 DML 关键字");
assertFalse(sql.contains("created_by_id"), "本版本不加 created_by_id:归属从本版本起由 service 显式落,反推那条路用不上(§2)");
assertEquals(0, count(sql, "ADD INDEX") + count(sql, "ADD KEY"),
"本版本不加二级索引:这张表是「一个紫鸟账号一行」量级,多挂一个单列索引就是 V139 那轮清掉的冗余形状");
}
/**
* 唯一键必须一动不动(§4)。这是本迁移与 V145/V147 最大的口径差别,所以钉成"可执行段里
* 没有任何索引动作",而不是"索引动作少"——放宽那一步一旦发生,运行期的表现是两行并成一行、
* 代理与白名单状态跨公司互相顶掉,不会有任何报错。
*/
@Test
void uniqueKeyStaysGlobalAndTheReasonTravelsWithTheFile() throws IOException {
String sql = statements();
assertEquals(0, count(sql, "DROP INDEX") + count(sql, "ADD UNIQUE KEY"),
"本版本不许动任何索引:uk_ziniao_token_hash 刻意保持全平台唯一(§4)");
assertFalse(sql.contains(GLOBAL_UNIQUE_KEY),
"可执行段里不该出现 " + GLOBAL_UNIQUE_KEY + "(它只应出现在解释为什么不动的注释里)");
String whole = raw(migration());
assertTrue(whole.contains(GLOBAL_UNIQUE_KEY), "「为什么不动唯一键」的理由必须写在迁移文件里,而不是只写在评审意见里");
assertTrue(whole.contains("ZiniaoApiKeyProvider"), "理由的关键环是令牌聚合那一步:注释要点名 ZiniaoApiKeyProvider");
}
/**
* 破坏点:删掉存在性守卫 ⇒ DDL 不进事务,中途失败后按「repair → 重启」重跑会撞 1060(重复列)而彻底起不来。
* 计数取 1 而不是「大于 0」:本文件的可执行段恰好查一次 information_schema(只查列),
* 多一次说明有人加了没登记的索引/键动作,少一次就是守卫没了。
*/
@Test
void addColumnIsGuardedByExistenceCheckAndReRunnable() throws IOException {
String sql = statements();
assertEquals(1, count(sql, "information_schema"),
"可执行段应查 1 次 information_schema(列存在性),实际次数见消息");
assertTrue(sql.contains("TABLE_NAME = '" + TABLE + "'"), "加列的守卫要按本表查");
assertTrue(sql.contains("COLUMN_NAME = 'company_id'"), "加列的守卫要按列名查");
assertTrue(count(sql, "PREPARE stmt FROM @sql") == 1 && count(sql, "EXECUTE stmt") == 1
&& count(sql, "DEALLOCATE PREPARE stmt") == 1,
"条件 DDL 必须走 PREPARE/EXECUTE 并收口(MySQL 不能在 IF 里直接写 DDL)");
}
/**
* 行数今天没实查(§2 写明),取证命令与不可追回窗口必须留在文件里。
* 这一支钉的是"取证责任没被写成既成事实":文件里出现"行数已确认"这类话就是把它编完了。
*/
@Test
void unprobedRowCountStaysAnExplicitDebtWithTheProbeQuery() throws IOException {
String whole = raw(migration());
assertTrue(whole.contains("SELECT COUNT(*) AS total"),
"§2 要带上可实跑的取证 SQL,而不是只留一句「上线前查一下」");
assertTrue(whole.contains("2026-10-04 14:55"), "不可追回窗口的锚点是第二家公司开通时刻,必须在文件里");
assertTrue(whole.contains("没有实查") || whole.contains("未实查"), "行数没查过这件事必须写在文件里,不许读成已知");
}
/**
* 回滚是人工补丁,且在 Flyway 扫描路径之外。
*
* <p>本迁移的回滚默认档<b>一条 SQL 都不执行</b>:这张表没有账号列,删列就删掉了唯一的归属依据,
* 所以 {@code DROP COLUMN} 留在注释里由人工解开,止损走"保留新列、只回 jar"那一档
* (新列对旧 jar 是惰性的,{@code DEFAULT 1} 正好把旧 jar 插入的行接住)。
* {@link CompanyScopeMigrationV145Test#rollbackStaysOutOfFlywayScanAndCoversTheHistoryRow} 按全目录
* 钉"回滚不得版本化",本类只钉本迁移这一支的内容。</p>
*/
@Test
void rollbackIsAHumanPatchThatDefaultsToKeepingTheColumn() throws IOException {
Path doc = ROOT.resolve("docs/rollback-V150-shop-key-company.sql");
assertTrue(Files.isRegularFile(doc), "V150 的人工回滚补丁必须存在:" + doc);
String whole = raw(doc);
assertTrue(whole.contains("flyway_schema_history"), "回滚必须写明删 version='150' 的历史行");
assertTrue(whole.contains("'150'"), "回滚补丁要点名本版本号,后来人才知道删的是哪一行");
String executable = normalize(stripComments(whole));
assertTrue(executable.isEmpty(),
"默认档不执行任何 SQL(删列是不可逆动作,必须留在注释里由人工解开),实际可执行段:" + executable);
assertTrue(whole.contains("DROP COLUMN"), "删列那一步要在文件里,只是不许默认可执行");
}
/**
* 破坏点:V150 的 DEFAULT 1 没进启动期哨兵清单 ⇒ "下一次记得摘"这件事没人喊,
* 而巡检按 {@code COMPANY_DEFAULT_STILL_PRESENT} 这条 ASCII 签名 grep docker logs。
*/
@Test
void startupSentinelWatchesTheShopKeyColumn() throws IOException {
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
String text = raw(guard);
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep)");
assertTrue(text.contains("'" + TABLE + "'"),
"探针 SQL 的 IN 列表要含 " + TABLE + "(不在 IN 里就查不到这一列,哨兵等于没探)");
assertTrue(text.contains("\"" + TABLE + "\""),
"WATCHED_TABLES 清单要含 " + TABLE + "(查到了却不在清单里,就没人去喊那条签名)");
}
/** 破坏点:盘点文档没跟着改 ⇒ 下一个人按"取号起点"取号就撞号,或按"最新版本"漏掉本文件。 */
@Test
void inventoryDocTracksTheShopKeyFile() throws IOException {
Path doc = ROOT.resolve("docs/migration-inventory.md");
String text = raw(doc);
assertTrue(text.contains(migration().getFileName().toString()),
"盘点文档应逐字保留本迁移文件名:" + migration().getFileName());
assertTrue(text.contains("V147__product_category_company_scope.sql"),
"盘点文档应同时保留更早的文件名:只钉最新一条会重演「推进概览时把旧条目挤掉」那一次回归");
}
/** 自检:本用例集扫的是真文件,且 normalize 后仍能命中关键串(0 命中的断言是恒绿的)。 */
@Test
void scannedSignaturesAreActuallyPresent() throws IOException {
String sql = statements();
assertTrue(sql.length() > 120, "剥注释后的 SQL 太短,说明预处理把内容吃掉了:" + sql.length());
assertTrue(count(sql, "ALTER TABLE") >= 1 && count(sql, "information_schema") > 0,
"关键签名 0 命中=预处理或文件路径坏了,本类的断言全部不可信");
String rollbackExecutable = normalize(stripComments(raw(ROOT.resolve("docs/rollback-V150-shop-key-company.sql"))));
assertTrue(raw(ROOT.resolve("docs/rollback-V150-shop-key-company.sql")).contains("--"),
"回滚补丁若一条注释都没有,上面那条「可执行段为空」就成了恒真断言");
assertTrue(rollbackExecutable.isEmpty(), "回滚补丁的可执行段应当确实为空");
}
private static int count(String haystack, String needle) {
int n = 0, i = haystack.indexOf(needle);
while (i >= 0) {
n++;
i = haystack.indexOf(needle, i + needle.length());
}
return n;
}
}
@@ -62,6 +62,23 @@ class AppearancePatentLlmClientTest {
assertThat(client.buildConclusion("无侵权", "无侵权", "")).isEqualTo("无侵权");
}
/**
* 商标维度查询失败、外观已判定:结论必须带着外观结论并标出「商标待复核」,
* 不能整格写「商标查询失败」把已判出的外观结论盖掉 —— 用户据此以为整单没检测,
* 而实际上只有商标那一维没核上。
*/
@Test
void conclusionKeepsAppearanceVerdictWhenBrandQueryFailed() {
assertThat(client.buildConclusion("商标查询失败", "无侵权", ""))
.isEqualTo("外观无侵权·商标待复核");
// 外观也没判出来时不编造结论:维持原文案
assertThat(client.buildConclusion("商标查询失败", "外观识别异常", ""))
.isEqualTo("商标查询失败");
assertThat(client.buildConclusion("商标查询失败", "", "")).isEqualTo("商标查询失败");
// 外观已判侵权:保守结论优先,且不引入新词形(分组传播按「侵权」精确命中)
assertThat(client.buildConclusion("商标查询失败", "侵权", "")).isEqualTo("侵权");
}
@Test
void skipBrandCheckWhenLlmTitleIsNone() throws Exception {
BrandCheckClient brandCheckClient = mock(BrandCheckClient.class);
@@ -285,8 +285,9 @@ class AppearancePatentSheetBuilderTest {
}
/**
* 结论列写「商标查询失败」时状态列必须判失败:
* 结论列没给出完整判定时状态列必须判失败:
* 历史缺陷是按「结论非空即成功」推状态,于是结论写着"商标查询失败"、状态却写"成功",自相矛盾。
* 两种没判完整的形状都要覆盖:外观也没判定(整格查询失败)、外观已判定但商标待复核。
*/
@Test
void test_sheet_builder_brand_query_failed_row_status_failed() throws Exception {
@@ -295,14 +296,26 @@ class AppearancePatentSheetBuilderTest {
AppearancePatentResultRowDto r = resultRow("2_1", "B01A", "US");
r.setTitleRisk("商标查询失败");
r.setAppearanceRisk("无侵权");
r.setConclusion("商标查询失败");
AppearancePatentSheetBuilder.buildResultSheet(wb, List.of(p), Map.of(
AppearancePatentSheetBuilder.rowKey(r), r));
r.setConclusion("外观无侵权·商标待复核");
AppearancePatentParsedRowVo p2 = parsedRow("2_2", "B01B", "US", "t", "", "");
AppearancePatentResultRowDto r2 = resultRow("2_2", "B01B", "US");
r2.setTitleRisk("商标查询失败");
r2.setAppearanceRisk("外观识别异常");
r2.setConclusion("商标查询失败");
AppearancePatentSheetBuilder.buildResultSheet(wb, List.of(p, p2), Map.of(
AppearancePatentSheetBuilder.rowKey(r), r,
AppearancePatentSheetBuilder.rowKey(r2), r2));
Row data = wb.getSheet("外观专利检测结果").getRow(1);
assertEquals("商标查询失败", data.getCell(9).getStringCellValue(), "标题维度保留查询失败文案");
assertEquals("商标查询失败", data.getCell(11).getStringCellValue(), "结论列保留查询失败文案");
assertEquals("无侵权", data.getCell(10).getStringCellValue(), "外观维度保留已判定结论");
assertEquals("外观无侵权·商标待复核", data.getCell(11).getStringCellValue(),
"结论列带上外观判定与待复核标记");
assertEquals("失败", data.getCell(12).getStringCellValue(), "商标没成功 → 状态失败");
Row both = wb.getSheet("外观专利检测结果").getRow(2);
assertEquals("商标查询失败", both.getCell(11).getStringCellValue(), "外观也没判定 → 结论仍是查询失败");
assertEquals("失败", both.getCell(12).getStringCellValue(), "两维都没判完整 → 状态失败");
}
}
@@ -318,6 +331,8 @@ class AppearancePatentSheetBuilderTest {
assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus("LLM http 503: overloaded"));
assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus(" "));
assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus(null));
// 「含侵权二字即成功」这条判据不能把带待复核标记的结论读成成功
assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus("外观无侵权·商标待复核"));
}
@Test
@@ -1,6 +1,5 @@
package com.nanri.aiimage.modules.collectdata.util;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.collectdata.model.vo.CollectDataResultRowVo;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.entity.InvalidAsinDataEntity;
@@ -12,6 +11,7 @@ import java.util.ArrayList;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.Mockito.doThrow;
@@ -28,28 +28,24 @@ import static org.mockito.Mockito.when;
* data_value 的批次不发起任何 insertBatchIgnore 调用;远程失败降级记录
* 计数(跳过写入),可恢复后继续,不抛出中断整个提交流程的异常。
*
* <p>归属那一笔(10-05 批次 3):实体与 INSERT 列清单此前都不带 company_id/uploader_user_id,
* V145 补的列全靠 DEFAULT 1 盖 ⇒ 第 2 家公司跑货源产生的行被记成第 1 家。写入器现在按
* 调用方给的任务发起账号推公司,<b>推不出公司就整批不写</b>(宁可少一条黑名单,也不把行盖成
* 别家公司 —— 那会让另一家的正常品牌被静默过滤)。</p>
* <p>归属那一笔的现网口径(控制方 2026-10-06 定案):这张黑名单<b>全平台共享、不按公司区分</b>,
* 写入器不再推公司、实体上也没有 company_id 可写({@code InvalidAsinDataServiceTest} 与
* {@code CompanyIdParamGoesThroughReadScopeTest} 分别钉住"预检不带公司列"和"这一族不许回流")。
* 10-05 那版"推不出公司就整批不写"的闸门一并放开:{@code uploader_user_id} 只记"哪个账号采出来的",
* 推不出账号照写 —— 少一条黑名单 = 下次同样的品牌再买一次代理费。</p>
*/
class CollectDataInvalidAsinBatchWriterTest {
/** 任务发起账号(biz_file_task.user_id)。 */
/** 任务发起账号(biz_file_task.user_id):只落 uploader_user_id 这一列,不参与可见性。 */
private static final Long UPLOADER = 7L;
/** 该账号归属的公司 —— 必须与 UPLOADER 不同值,否则断言分不清写进去的是哪个。 */
private static final Long UPLOADER_COMPANY = 2L;
private InvalidAsinDataMapper invalidAsinDataMapper;
private CompanyScopeSupport companyScopeSupport;
private CollectDataInvalidAsinBatchWriter writer;
@BeforeEach
void setUp() {
invalidAsinDataMapper = mock(InvalidAsinDataMapper.class);
companyScopeSupport = mock(CompanyScopeSupport.class);
when(companyScopeSupport.companyIdOrNull(UPLOADER)).thenReturn(UPLOADER_COMPANY);
writer = new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, companyScopeSupport, 10);
writer = new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, 10);
}
@Test
@@ -151,7 +147,7 @@ class CollectDataInvalidAsinBatchWriterTest {
when(invalidAsinDataMapper.insertBatchIgnore(anyList())).thenAnswer(
invocation -> ((List<?>) invocation.getArgument(0)).size());
CollectDataInvalidAsinBatchWriter smallWriter =
new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, companyScopeSupport, 3);
new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, 3);
List<CollectDataResultRowVo> rows = new ArrayList<>();
for (int i = 0; i < 10; i++) {
rows.add(row("B" + String.format("%09d", i + 1), "brand"));
@@ -211,12 +207,10 @@ class CollectDataInvalidAsinBatchWriterTest {
}
@Test
void test_batch_3_asin_normal_ownership_is_stamped_on_every_row() {
// 归属由任务发起账号推:每一行都带 company_id + uploader_user_id,
// 而不是留空让 DEFAULT 1 去盖(那会把第 2 家的行记成第 1 家,事后分不开)。
void test_batch_3_asin_normal_uploader_is_stamped_on_every_row() {
// uploader_user_id 每行都从调用方给的任务发起账号落,不留空(空了事后追不到是哪次采集采出来的)。
when(invalidAsinDataMapper.insertBatchIgnore(anyList())).thenAnswer(
invocation -> ((List<?>) invocation.getArgument(0)).size());
when(companyScopeSupport.companyIdOrNull(UPLOADER)).thenReturn(UPLOADER_COMPANY);
writer.writeBatch(List.of(row("B000000001", "nike"), row("B000000002", "zara")), UPLOADER);
@@ -225,21 +219,27 @@ class CollectDataInvalidAsinBatchWriterTest {
List<InvalidAsinDataEntity> entities = captor.getValue();
assertEquals(2, entities.size());
for (InvalidAsinDataEntity entity : entities) {
assertEquals(UPLOADER_COMPANY, entity.getCompanyId(), "company_id 来自发起账号,不是 DEFAULT");
assertEquals(UPLOADER, entity.getUploaderUserId(), "uploader_user_id 一并落,处置可回溯到人");
}
}
@Test
void test_batch_3_asin_invalid_owner_unresolved_skips_whole_batch() {
// 推不出公司(账号已删/没有公司):整批不写、返回 0、一次 insertBatchIgnore 都不发。
// 这一族的替代方案是"照常写、让 DEFAULT 盖一家",那是静默串数据,必须判红。
when(companyScopeSupport.companyIdOrNull(UPLOADER)).thenReturn(null);
void test_shared_asin_normal_unresolved_uploader_still_writes() {
// 10-06 定案「放开:照样写入」的钉子。账号已删/推不出归属时整批照写,只是那一列留空——
// 黑名单是全平台共享的,可见性不看这两列。原口径「推不出就整批不写」的后果是少一条黑名单 =
// 下次同样的品牌再买一次代理,那是为了一个不参与读过滤的列丢真实的降本数据。
when(invalidAsinDataMapper.insertBatchIgnore(anyList())).thenAnswer(
invocation -> ((List<?>) invocation.getArgument(0)).size());
int written = writer.writeBatch(List.of(row("B000000001", "nike"), row("B000000002", "zara")), UPLOADER);
int written = writer.writeBatch(List.of(row("B000000001", "nike"), row("B000000002", "zara")), null);
assertEquals(0, written, "归属推不出 ⇒ 一行都不写");
verify(invalidAsinDataMapper, never()).insertBatchIgnore(anyList());
assertEquals(2, written, "推不出发起账号也整批写入");
ArgumentCaptor<List<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass(List.class);
verify(invalidAsinDataMapper).insertBatchIgnore(captor.capture());
assertEquals(2, captor.getValue().size());
for (InvalidAsinDataEntity entity : captor.getValue()) {
assertNull(entity.getUploaderUserId(), "那一列留空即可,不许因此少写一行");
}
}
private static CollectDataResultRowVo row(String asin, String brand) {
@@ -36,10 +36,15 @@ import static org.mockito.Mockito.when;
* 还没摘,此后每个没显式传公司的写入都会被静默塞进默认那家——不报错、不丢数据,只在后台列表里
* 表现成"这条数据怎么在别家公司"。所以必须用代码在启动期喊出来,而不是写在注释里等人记得。</p>
*
* <p>V145 之后盯的是【一张清单】(users + 两张规则库 + V147 的 biz_product_category),不是一列:
* 漏登记的那张表等于没人盯,所以"探不到列"也要出声(见
* <p>V145 之后盯的是【一张清单】,不是一列:漏登记的那张表等于没人盯,所以"探不到列"也要出声(见
* {@link #unwatchedTableIsAnnouncedInsteadOfLookingClean})。清单与探针 SQL 的 IN 列表双向同源由
* {@link #watchedTablesMatchTheProbeSql} 钉住。</p>
*
* <p>清单也会随口径<b>缩短</b>:{@code biz_invalid_asin_data}(V145)与 {@code biz_product_category}
* (V147)已按 2026-10-06「品牌数据库/商品类目做成所有公司共享」的定案一并摘掉登记。这两列的
* {@code DEFAULT 1} 于是从"待摘的风险"翻转成"<b>承重</b>约束"——列还在库里,写入路径不再传公司,
* {@code NOT NULL} 就靠它填。此时哨兵再喊"去摘 DEFAULT",后果不是修好了而是每次写入 1364,
* 由 {@link #sharedTablesStayOutOfTheWatchList} 反向钉住不许回流。</p>
*/
class CompanyDefaultGuardTest {
@@ -125,7 +130,7 @@ class CompanyDefaultGuardTest {
@DisplayName("第二家公司已开通、users 的 DEFAULT 还在:打 ERROR 并带上哨兵标记")
void secondCompanyWithDefaultStillOnShoutsError() {
companies(2);
probeReturns("users=1", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users=1", "biz_dedupe_total_data=null");
guard.check();
@@ -136,18 +141,15 @@ class CompanyDefaultGuardTest {
}
@Test
@DisplayName("V145 的两张规则库带 DEFAULT:两张都要点出来,不许只报第一条")
void ruleTablesAreWatchedToo() {
@DisplayName("biz_dedupe_total_data 仍按公司:DEFAULT 还在必须点出来,不许因为它是清单第二条就漏掉")
void dedupeTableIsStillWatched() {
companies(2);
probeReturns("users=null",
"biz_invalid_asin_data=1",
"biz_dedupe_total_data=1");
probeReturns("users=null", "biz_dedupe_total_data=1");
guard.check();
assertThat(messageAt(Level.ERROR))
.contains(CompanyDefaultGuard.ALARM)
.contains("biz_invalid_asin_data.company_id DEFAULT=1")
.contains("biz_dedupe_total_data.company_id DEFAULT=1");
}
@@ -155,7 +157,7 @@ class CompanyDefaultGuardTest {
@DisplayName("给出的修复语句必须是 ALTER COLUMN ... DROP DEFAULT:MODIFY 会重建表、把派生归属洗掉")
void fixHintIsTheMetadataOnlyForm() {
companies(2);
probeReturns("users=null", "biz_invalid_asin_data=null", "biz_dedupe_total_data=1");
probeReturns("users=null", "biz_dedupe_total_data=1");
guard.check();
@@ -176,10 +178,10 @@ class CompanyDefaultGuardTest {
}
@Test
@DisplayName("三张表的 DEFAULT 都已摘掉:一声不响")
@DisplayName("清单里每一条的 DEFAULT 都已摘掉:一声不响")
void droppedDefaultKeepsQuiet() {
companies(3);
probeReturns("users=null", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users=null", "biz_dedupe_total_data=null");
guard.check();
@@ -191,7 +193,7 @@ class CompanyDefaultGuardTest {
@DisplayName("DEFAULT 是空串也按「已摘除」处理,别把空值读成还在")
void blankDefaultCountsAsDropped() {
companies(2);
probeReturns("users= ", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users= ", "biz_dedupe_total_data=null");
guard.check();
@@ -243,26 +245,46 @@ class CompanyDefaultGuardTest {
}
}
/**
* 反向钉,形状与 {@link #shopKeyTableIsWatchedToo} 相反。{@code biz_invalid_asin_data}(V145)
* 与 {@code biz_product_category}(V147)按 2026-10-06「这两页做成所有公司共享」的定案一起摘了登记,
* 但<b>列和 {@code DEFAULT 1} 都还在库里</b>——它们如今是 {@code NOT NULL} 的承重约束
* (写入路径不再传公司,全靠默认值填这一列)。
*
* <p>所以这一支演的是"探针<b>真的</b>把 {@code DEFAULT=1} 端上桌,哨兵必须一声不响"。
* 谁把这两张表加回 {@code WATCHED_TABLES}(那等于指挥运维去执行本类给出的 {@code DROP DEFAULT},
* 代价是每次写入 1364;品牌库那条还会被 {@code CollectDataInvalidAsinBatchWriter} 吞成 warn ⇒
* 接口报成功而黑名单静默少一批),就会在这里红。</p>
*
* <p>用 {@code probeReturnsOnly} 而不是 {@code probeReturns}:后者只按清单建行,未登记的表根本
* 进不了结果集——那样"哨兵没喊"是空转转出来的,不是判出来的。四张仍登记的表逐个给 {@code null},
* 既是这一支的正样本(少给一条就会撞 WARN 而红,说明"没喊"不是因为什么都没探到)。</p>
*/
@Test
@DisplayName("V147 的 biz_product_category 也在盯的清单里:摘 DEFAULT 那一步不许把它落下")
void productCategoryTableIsWatchedToo() {
@DisplayName("两张共享表故意不在清单里:探针端出 DEFAULT=1 也不许喊")
void sharedTablesStayOutOfTheWatchList() {
companies(2);
probeReturns("biz_product_category=1");
probeReturnsOnly("users=null",
"biz_dedupe_total_data=null",
"biz_shop_key=null",
"columns=null",
"biz_invalid_asin_data=1",
"biz_product_category=1");
guard.check();
assertThat(messageAt(Level.ERROR))
.contains(CompanyDefaultGuard.ALARM)
.contains("biz_product_category.company_id DEFAULT=1")
.contains("ALTER TABLE biz_product_category ALTER COLUMN company_id DROP DEFAULT")
.doesNotContain("MODIFY");
assertThat(CompanyDefaultGuard.WATCHED_TABLES)
.as("摘登记是定案的一部分:加回清单就等于让哨兵去喊一次真故障")
.doesNotContain("biz_invalid_asin_data", "biz_product_category");
assertThat(messageAt(Level.ERROR)).isEmpty();
assertThat(messageAt(Level.WARN)).isEmpty();
}
@Test
@DisplayName("探的是清单里这几张表的 company_id 列,表名列名写错就等于没探")
void probeReadsTheRightColumns() {
companies(2);
probeReturns("users=null", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users=null", "biz_dedupe_total_data=null");
guard.check();
@@ -277,6 +299,26 @@ class CompanyDefaultGuardTest {
}
}
/**
* V150 的 {@code biz_shop_key}:这一列的 DEFAULT 1 与前三张同形(只为同批旧 jar 存在),
* 而这张表<b>没有账号列</b>,历史归属的全部依据就是加列那一刻记录的默认值——
* 所以"摘 DEFAULT"这一步必须由哨兵盯着,漏摘的代价是第 2 家管理员新建的密钥静默归进第 1 家。
*/
@Test
@DisplayName("V150 的 biz_shop_key 也在盯的清单里:摘 DEFAULT 那一步不许把它落下")
void shopKeyTableIsWatchedToo() {
companies(2);
probeReturns("biz_shop_key=1");
guard.check();
assertThat(messageAt(Level.ERROR))
.contains(CompanyDefaultGuard.ALARM)
.contains("biz_shop_key.company_id DEFAULT=1")
.contains("ALTER TABLE biz_shop_key ALTER COLUMN company_id DROP DEFAULT")
.doesNotContain("MODIFY");
}
/**
* 双向钉同源。只钉"清单里的都在 SQL 里"会漏掉另一侧:有人往 SQL 的 IN 列表加了一张表、
* 却没加进 {@code WATCHED_TABLES},那么 {@link #check} 的逐表循环根本不会走到它——
@@ -307,7 +349,7 @@ class CompanyDefaultGuardTest {
private String probeSqlText() {
companies(2);
probeReturns("users=null", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users=null", "biz_dedupe_total_data=null");
guard.check();
ArgumentCaptor<String> sql = ArgumentCaptor.forClass(String.class);
verify(jdbcTemplate).queryForList(sql.capture());
@@ -9,17 +9,21 @@ import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.dto.CompanySaveRequest;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@@ -37,6 +41,7 @@ class CompanyServiceDirectoryTest {
private CompanyMapper companyMapper;
private AdminAuthSupport adminAuthSupport;
private PermissionMenuService permissionMenuService;
private CompanyService companyService;
@BeforeEach
@@ -46,7 +51,8 @@ class CompanyServiceDirectoryTest {
new MapperBuilderAssistant(new MybatisConfiguration(), ""), CompanyEntity.class);
companyMapper = mock(CompanyMapper.class);
adminAuthSupport = mock(AdminAuthSupport.class);
companyService = new CompanyService(companyMapper, adminAuthSupport);
permissionMenuService = mock(PermissionMenuService.class);
companyService = new CompanyService(companyMapper, adminAuthSupport, permissionMenuService);
}
private AdminUserEntity operator(String role, Long companyId) {
@@ -184,6 +190,44 @@ class CompanyServiceDirectoryTest {
assertThat(capturedSelectCount().getParamNameValuePairs()).containsValue("福州数富");
}
/**
* 设计文档 §2 D4 的那一行调用:每家公司一棵树之后,「新增公司」必须同批把菜单树建出来。
*
* <p>零菜单行的租户<b>全程不报错</b>——那家账号登录侧边栏全空、授权树一个勾都没有,
* 症状长得像"这个公司还没开通"。所以这一钉守的是 {@code create()} 里那次调用本身
* ({@code copyTreeFromTemplate} 的内部形状由 PermissionMenuServiceCompanyScopeTest 那三条盖),
* 而不是复制逻辑写得多对。</p>
*/
@Test
@DisplayName("超管新建公司:插行之后同一次写入里给它复制一套菜单树,模板取操作者本公司")
void createSeedsTheNewCompanyMenuTreeAfterInsert() {
when(companyMapper.selectCount(any())).thenReturn(0L);
// 真库里 insert 会回填自增 id;不模拟这一步就只能断出 copyTreeFromTemplate(null, …)。
when(companyMapper.insert(any(CompanyEntity.class))).thenAnswer(invocation -> {
invocation.getArgument(0, CompanyEntity.class).setId(77L);
return 1;
});
companyService.create(operator("super_admin", 5L), request("福州数富", null, null));
InOrder order = inOrder(companyMapper, permissionMenuService);
order.verify(companyMapper).insert(any(CompanyEntity.class));
// 模板公司取操作者的 5L 而不是硬编码 1L:厦门米椿花不再是"唯一有树的那家"以后,
// 抄公司 1 在眼下照样能跑,第三家开通时就把三家拴成一棵——那正是 §7 路线乙被否决的形状。
order.verify(permissionMenuService).copyTreeFromTemplate(77L, 5L);
}
@Test
@DisplayName("建公司被拒时不建树:重名那笔先抛,不许留下一套挂在不存在公司上的菜单")
void rejectedCreateDoesNotSeedMenuTree() {
when(companyMapper.selectCount(any())).thenReturn(1L);
assertThatThrownBy(() -> companyService.create(operator("super_admin", 1L), request("厦门米椿花", null, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("已存在");
verify(permissionMenuService, never()).copyTreeFromTemplate(any(), any());
}
@Test
@DisplayName("公司名超过列宽 128 时先拒,别把 1406 抛成 500")
void createRejectsNameLongerThanColumn() {
@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
@@ -41,7 +42,8 @@ class CompanyServiceNameLookupTest {
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), CompanyEntity.class);
companyMapper = mock(CompanyMapper.class);
companyService = new CompanyService(companyMapper, mock(AdminAuthSupport.class));
companyService = new CompanyService(companyMapper, mock(AdminAuthSupport.class),
mock(PermissionMenuService.class));
}
private CompanyEntity company(Long id, String name, int status) {
@@ -4,6 +4,7 @@ import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
@@ -49,7 +50,7 @@ class CompanyServiceRequireActiveTest {
}
private CompanyService service(CompanyMapper mapper) {
return new CompanyService(mapper, mock(AdminAuthSupport.class));
return new CompanyService(mapper, mock(AdminAuthSupport.class), mock(PermissionMenuService.class));
}
private CompanyEntity company(Long id, Integer status) {
@@ -1,10 +1,10 @@
package com.nanri.aiimage.modules.invalidasin.controller;
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.modules.invalidasin.model.vo.InvalidAsinDataPageVo;
import com.nanri.aiimage.modules.invalidasin.service.InvalidAsinDataService;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.junit.jupiter.api.BeforeEach;
@@ -20,13 +20,21 @@ import java.util.List;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;
/**
* 鉴权那一半(内网代理换真人、直连不许伪造 super_admin)+ 「全平台共享」的现网口径。
*
* <p>10-06 定案品牌数据库不区分公司:这里原先另有两条钉「tab 传什么都不算」的
* (超管不选 tab ⇒ 交给 service 的筛值是 null、非超管传别家 ⇒ 收窄成 null),它们吃的都是
* controller 上那个 {@code company_id} 形参,形参已随定案摘掉,两条一起删除。
* "公司维度不许回流"由 {@code CompanyIdParamGoesThroughReadScopeTest} 按 module 目录反向钉,
* 不靠本文件(这里连可断言的参数都没有了)。</p>
*/
@ExtendWith(MockitoExtension.class)
class InvalidAsinDataControllerTest {
@@ -36,8 +44,6 @@ class InvalidAsinDataControllerTest {
private AdminAuthSupport adminAuthSupport;
@Mock
private PermissionMenuService permissionMenuService;
@Mock
private com.nanri.aiimage.common.service.DataReadScope dataReadScope;
@InjectMocks
private InvalidAsinDataController controller;
@@ -60,13 +66,12 @@ class InvalidAsinDataControllerTest {
when(adminAuthSupport.currentRole(operator)).thenReturn(null);
when(permissionMenuService.getUserColumnPermissions(7L, "admin"))
.thenReturn(List.of(invalidAsinDataPermission()));
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 7L, false, null))
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 7L, false))
.thenReturn(new InvalidAsinDataPageVo());
when(dataReadScope.readCompanyId(operator, null)).thenReturn(null);
controller.page(1L, 15L, "", "", "", 3L, null, request);
controller.page(1L, 15L, "", "", "", 3L, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 7L, false, null);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 7L, false);
}
@Test
@@ -76,7 +81,7 @@ class InvalidAsinDataControllerTest {
request.addParameter("superAdmin", "true");
when(adminAuthSupport.requireUser(request)).thenThrow(new BusinessException(401, "未登录"));
assertThrows(BusinessException.class, () -> controller.page(1L, 15L, "", "", "", 3L, null, request));
assertThrows(BusinessException.class, () -> controller.page(1L, 15L, "", "", "", 3L, request));
verifyNoInteractions(invalidAsinDataService);
verify(permissionMenuService, never()).requireUserOperator(any());
@@ -89,52 +94,15 @@ class InvalidAsinDataControllerTest {
AdminUserEntity operator = user(1L, "super_admin");
when(adminAuthSupport.requireUser(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("super_admin");
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 1L, true, 2L))
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 1L, true))
.thenReturn(new InvalidAsinDataPageVo());
when(dataReadScope.readCompanyId(operator, 2L)).thenReturn(2L);
controller.page(1L, 15L, "", "", "", 3L, 2L, request);
controller.page(1L, 15L, "", "", "", 3L, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 1L, true, 2L);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 1L, true);
verify(permissionMenuService, never()).getUserColumnPermissions(eq(1L), eq("admin"));
}
@Test
void superAdminWithoutCompanyTabStaysUnfiltered() {
// 反向钉:tab 没传公司(companyId=null)⇒ 交给 service 的筛值必须是 null(= 不筛)。
// 哪天有人把它硬写成某个默认公司,全量视图会静默变成一家的视图。
MockHttpServletRequest request = new MockHttpServletRequest();
AdminUserEntity operator = user(1L, "super_admin");
when(adminAuthSupport.requireUser(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("super_admin");
when(dataReadScope.readCompanyId(operator, null)).thenReturn(null);
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 1L, true, null))
.thenReturn(new InvalidAsinDataPageVo());
controller.page(1L, 15L, "", "", "", 3L, null, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 1L, true, null);
}
@Test
void forgedCompanyTabForNonSuperAdminIsNarrowedToItsOwnCompany() {
// 非超管传别人的公司 id:出口给的是 null(不筛)而不是那家 —— 这页的隔离靠分组权限,
// 叠公司会把「靠分组可见」的行整批删掉。钉住"传什么都不算"的现网口径。
MockHttpServletRequest request = new MockHttpServletRequest();
AdminUserEntity operator = user(9L, "admin");
when(adminAuthSupport.requireUser(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("admin");
when(permissionMenuService.getUserColumnPermissions(9L, "admin"))
.thenReturn(List.of(invalidAsinDataPermission()));
when(dataReadScope.readCompanyId(operator, 5L)).thenReturn(null);
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 9L, false, null))
.thenReturn(new InvalidAsinDataPageVo());
controller.page(1L, 15L, "", "", "", 3L, 5L, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 9L, false, null);
}
private AdminUserEntity user(Long id, String role) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
@@ -4,7 +4,6 @@ import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataCreateRequest;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataUpdateRequest;
@@ -40,16 +39,10 @@ import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class InvalidAsinDataServiceTest {
/** 操作者 7L 所属公司。故意取 2 不取 1:DEFAULT 1 那家也能通过"非空"这一断言,取 2 才钉得住"真从会话来"。 */
private static final Long OPERATOR_COMPANY_ID = 2L;
@Mock
private InvalidAsinDataMapper invalidAsinDataMapper;
@Mock
private ShopManageGroupService shopManageGroupService;
/** 归属从操作者会话推导(create 里那唯一一处 requireCompanyId):不 mock 就是构造注入不到、整个 service 空指针。 */
@Mock
private CompanyScopeSupport companyScopeSupport;
@InjectMocks
private InvalidAsinDataService service;
@@ -63,7 +56,6 @@ class InvalidAsinDataServiceTest {
ShopManageGroupEntity group = group(9L, "group-a");
InvalidAsinDataEntity saved = data(91L, "MANUAL", 9L);
when(companyScopeSupport.requireCompanyId(7L)).thenReturn(OPERATOR_COMPANY_ID);
when(shopManageGroupService.listAccessibleGroupIds(7L, false)).thenReturn(Set.of(12L, 9L));
when(shopManageGroupService.getAccessibleById(9L, 7L, false)).thenReturn(group);
when(invalidAsinDataMapper.selectOne(any())).thenReturn(null);
@@ -83,21 +75,23 @@ class InvalidAsinDataServiceTest {
assertEquals("MANUAL", captor.getValue().getRecordSource());
assertEquals("group-a", item.getGroupName());
assertEquals("MANUAL", item.getRecordSource());
// 写侧归属:MANUAL 行的 company_id 必须真从操作者会话推导。V146 已摘掉该列的 DEFAULT 1,
// 没人推导就是 NULL —— 而 NULL 行在 readCompanyId 谓词下对所有公司 tab 都不可见(静默删除),
// 比"归属错一家"更难发现。
assertEquals(OPERATOR_COMPANY_ID, captor.getValue().getCompanyId());
assertEquals(7L, captor.getValue().getUploaderUserId());
// 重复预检必须与 V145 放宽后的唯一键 (company_id, data_value, brand) 同宽:少公司这一维,
// 第 2 家永远无法新增第 1 家已有的品牌(跨公司误报「ASIN 已存在」)。
// 重复预检与 V151 退回后的全局唯一键 (data_value, brand) 同宽。
// 这是反向钉(2026-10-06 定案「品牌数据库全平台共享,不区分」):预检再带上 company_id 的话,
// 键是全局的而预检是按家的 ⇒ 同一 ASIN 在第 2 家能插进去,撞库时报 1062 而不是「ASIN 已存在」,
// 用户看到的是一句 500。所以这里钉的是"谓词里没有公司维度",不是"没有正样本"。
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> unique =
ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectOne(unique.capture());
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""),
InvalidAsinDataEntity.class);
assertTrue(unique.getValue().getSqlSegment().contains("company_id"));
assertTrue(unique.getValue().getParamNameValuePairs().containsValue(OPERATOR_COMPANY_ID));
String uniqueSql = unique.getValue().getSqlSegment();
assertTrue(uniqueSql.contains("data_value"), "预检判据整段没了:换了写法,下面的排他就是空断言");
assertFalse(uniqueSql.contains("company_id"),
"ensureUnique 又带上了 company_id:唯一键已退回全局(V151),按家预检会让重复行撞 1062 而不是报「ASIN 已存在」");
assertFalse(uniqueSql.contains("group_id"),
"ensureUnique 又按分组预检了:全局键里没有分组这一维,同形状会漏判");
}
@Test
@@ -109,7 +103,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of(manual));
when(shopManageGroupService.buildGroupNameMap(any())).thenReturn(Map.of(9L, "group-a"));
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", 10L, 7L, false, null);
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", 10L, 7L, false);
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectCount(captor.capture());
@@ -133,7 +127,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of(automatic, orphan));
when(shopManageGroupService.buildGroupNameMap(any())).thenReturn(Map.of());
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", null, 1L, true, null);
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", null, 1L, true);
assertEquals(2, page.getItems().size());
assertEquals("AUTO", page.getItems().getFirst().getRecordSource());
@@ -147,7 +141,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectCount(any())).thenReturn(0L);
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, "", "", "", 9L, 1L, true, null);
service.page(1, 15, "", "", "", 9L, 1L, true);
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectCount(captor.capture());
@@ -164,7 +158,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectCount(any())).thenReturn(0L);
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, "", "B01", "acme", null, 1L, true, null);
service.page(1, 15, "", "B01", "acme", null, 1L, true);
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectCount(captor.capture());
@@ -141,8 +141,18 @@ class PermissionCompanyMenuHiddenTest {
return code.substring(from, end);
}
/**
* 每一处引用受控集的出口都要点名数到(原名 {@code threeExitsAllReferenceTheSuperAdminOnlySet})。
*
* <p>V149(每家公司一套菜单树,定案 D3)冒出第四处出口:{@code copyTreeFromTemplate} 给新公司复制
* 模板树时<b>不许</b>把 {@code admin_companies} 那一行复制过去——它是角色内在闸门,公司 2 的树里
* 根本没有这行才干净。按 {@code docs/plans/19-company-tab.md} 那条交代("要加第四处出口 = 未批准的
* 行为变化,须自带一记变异"),这一记已经跑了:变异点 {@code copyTree clones the role-intrinsic gate row}
* 被 {@code PermissionMenuServiceCompanyScopeTest} 的「建树:三种 menu_type 全复制、闸门行不复制」打死,
* 详见 {@code docs/ops/menu-company-tree-design-2026-10-06.md} §8。</p>
*/
@Test
void threeExitsAllReferenceTheSuperAdminOnlySet() throws IOException {
void everyExitReferencesTheSuperAdminOnlySet() throws IOException {
String text = source();
assertThat(text).contains("SUPER_ADMIN_ONLY_KEYS");
List<String> code = executableCodeLines(text);
@@ -151,30 +161,31 @@ class PermissionCompanyMenuHiddenTest {
// 注释必须真被滤掉了:javadoc 里那四处 SUPER_ADMIN_ONLY_KEYS 链接一旦混进取样集,上面的计数就又回到"数得出但没数代码"。
assertThat(code).as("扫描取样集自检: 注释行必须已被剔除")
.noneMatch(line -> line.contains("{@link") || line.trim().startsWith("*"));
assertThat(code).as("扫描取样集自检: 三处出口都落在 toItemVos/落库这条链上,扫描必须扫得到它")
assertThat(code).as("扫描取样集自检: 出口 1/2 落在 toItemVos/落库这条链上,扫描必须扫得到它")
.filteredOn(line -> line.contains("toItemVos(")).isNotEmpty();
// 三个出口各自都要引用它,而且只数代码:漏一个就留一条旁路(授权树能看见 / 当前用户菜单能带出 / 提交能写回)。
// 四个出口各自都要引用它,而且只数代码:漏一个就留一条旁路(授权树能看见 / 当前用户菜单能带出 /
// 提交能写回 / 新公司能拿到一行本该只在公司 1 树里存在的闸门菜单)。
// 旧写法是"SUPER_ADMIN_ONLY_KEYS 在整份文本里出现 ≥4 次",可 1 处定义 + 4 处 javadoc 就凑得满(三处过滤器全删仍剩 5 次),
// 三处过滤器全删(或移进注释 / if (false) / 死分支)它照样绿 —— 变异 R10 就是这一记。
// 现在逐口钉:负向("不是受控项才留下")= 出口 1 的 list(operator, menuType, grantableOnly)
// 与出口 2 的 getUserColumnPermissions(...) 各一条;正向("是受控项才进剥离集")
// = 出口 3 用来反解受控 id 的 superAdminOnlyMenuIds() 一条。行号会漂,所以只点方法名。
// 将来真要加第四处出口时,连同这三条期望一起改(当前口径:恰三处出口,不许多也不许少)。
// 现在逐口钉:负向("不是受控项才留下")= 出口 1 的 list(operator, menuType, grantableOnly)、
// 出口 2 的 getUserColumnPermissions(...)、出口 4 的 copyTreeFromTemplate(...) 各一条;
// 正向("是受控项才进剥离集")= 出口 3 用来反解受控 id 的 superAdminOnlyMenuIds() 一条。行号会漂,所以只点方法名。
// 将来真要加第五处出口时,连同这三条期望一起改(当前口径:恰四处出口,不许多也不许少)。
List<String> negative = code.stream().filter(line -> line.contains(NEGATIVE_FILTER)).toList();
List<String> positive = code.stream()
.filter(line -> line.contains(POSITIVE_FILTER))
.filter(line -> !line.contains(NEGATIVE_FILTER))
.toList();
assertThat(negative)
.as("出口 1(授权树)+ 出口 2(当前用户菜单)各一条负向过滤,少一条就是一条旁路")
.hasSize(2);
.as("出口 1(授权树)+ 出口 2(当前用户菜单)+ 出口 4(给新公司复制树)各一条负向过滤,少一条就是一条旁路")
.hasSize(3);
assertThat(positive)
.as("出口 3(提交剥离)的正向反解恰好一条")
.hasSize(1);
assertThat(code.stream().filter(line -> line.contains(GUARD_SET)).toList())
.as("1 处定义 + 3 处出口,全都得落在可执行行上")
.hasSizeGreaterThanOrEqualTo(4);
.as("1 处定义 + 4 处出口,全都得落在可执行行上")
.hasSizeGreaterThanOrEqualTo(5);
}
@Test
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.permission.controller;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.permission.model.dto.ImageVideoDataPermissionUpdateRequest;
import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuCreateRequest;
import com.nanri.aiimage.modules.permission.model.dto.UserColumnPermissionUpdateRequest;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.model.vo.ImageVideoDataPermissionUserVo;
@@ -15,10 +16,10 @@ import org.junit.jupiter.api.io.TempDir;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
@@ -30,6 +31,12 @@ import static org.mockito.Mockito.when;
class PermissionMenuControllerTest {
/**
* 归属判据的返回值替身:与测试里传进去的 {@code 7L} 不同,这样"下游收到的是判据的结果"
* 这一条才有内容——若控制器仍传原文,verify 会拿 7L 与 99L 对不上而红。
*/
private static final Long RESOLVED_COMPANY = 99L;
@Test
void effectivePermissionEndpointAllowsAuthenticatedNormalUserToReadSelf() {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
@@ -125,12 +132,16 @@ class PermissionMenuControllerTest {
when(request.getHeader("X-Internal-Token")).thenReturn("shared-token");
when(request.getParameter("operatorId")).thenReturn("12");
when(service.requireAdminOperator(12L)).thenReturn(operator);
when(service.list(operator, "app", false)).thenReturn(List.of());
// 归属判据给什么,下游就查什么:这里故意返回与入参 7L 不同的 99L,
// 于是"控制器把 tab 原文往下传"和"控制器把判据的结果往下传"两种写法给不出同一个绿。
when(service.resolveScopeCompanyId(operator, 7L)).thenReturn(RESOLVED_COMPANY);
when(service.list(operator, "app", false, RESOLVED_COMPANY)).thenReturn(List.of());
controller.listMenus(request, "app", false);
controller.listMenus(request, "app", false, 7L);
verify(service).requireAdminOperator(12L);
verify(service).list(operator, "app", false);
verify(service).resolveScopeCompanyId(operator, 7L);
verify(service).list(operator, "app", false, RESOLVED_COMPANY);
verify(request, never()).getParameter("superAdmin");
}
@@ -146,10 +157,11 @@ class PermissionMenuControllerTest {
when(authSupport.requireAdmin(request)).thenThrow(authFailure);
when(request.getHeader("X-Internal-Token")).thenReturn("wrong-token");
assertThatThrownBy(() -> controller.listMenus(request, "app", false))
assertThatThrownBy(() -> controller.listMenus(request, "app", false, 7L))
.isSameAs(authFailure);
verify(service, never()).requireAdminOperator(anyLong());
verify(service, never()).list(any(AdminUserEntity.class), eq("app"), eq(false));
// 只 verify 某一组形参的 never() 会随控制器换签名一起失效,这里要的是「一次服务调用都没发生」。
verifyNoInteractions(service);
}
@Test
@@ -167,17 +179,20 @@ class PermissionMenuControllerTest {
body.setUserIds(List.of(20L));
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(service.listImageVideoDataPermissionUsers(operator)).thenReturn(List.of(permissionUser));
when(service.updateImageVideoDataPermissionUsers(operator, List.of(20L))).thenReturn(1);
when(service.resolveScopeCompanyId(operator, 7L)).thenReturn(RESOLVED_COMPANY);
when(service.listImageVideoDataPermissionUsers(operator, RESOLVED_COMPANY)).thenReturn(List.of(permissionUser));
when(service.updateImageVideoDataPermissionUsers(operator, RESOLVED_COMPANY, List.of(20L))).thenReturn(1);
var listResponse = controller.listImageVideoDataPermissionUsers(request);
var updateResponse = controller.updateImageVideoDataPermissionUsers(request, body);
var listResponse = controller.listImageVideoDataPermissionUsers(request, 7L);
var updateResponse = controller.updateImageVideoDataPermissionUsers(request, 7L, body);
assertThat(listResponse.getData()).containsExactly(permissionUser);
assertThat(updateResponse.getData()).isEqualTo(1);
verify(authSupport, times(2)).requireAdmin(request);
verify(service).listImageVideoDataPermissionUsers(operator);
verify(service).updateImageVideoDataPermissionUsers(operator, List.of(20L));
// 两页数据范围授权本批只做到后端:读与写都先过判据、再按判据那一家取数(界面还没接 tab)。
verify(service, times(2)).resolveScopeCompanyId(operator, 7L);
verify(service).listImageVideoDataPermissionUsers(operator, RESOLVED_COMPANY);
verify(service).updateImageVideoDataPermissionUsers(operator, RESOLVED_COMPANY, List.of(20L));
}
@Test
@@ -195,16 +210,73 @@ class PermissionMenuControllerTest {
body.setUserIds(List.of(20L));
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(service.listShopDataCrawlDataPermissionUsers(operator)).thenReturn(List.of(permissionUser));
when(service.updateShopDataCrawlDataPermissionUsers(operator, List.of(20L))).thenReturn(1);
when(service.resolveScopeCompanyId(operator, 7L)).thenReturn(RESOLVED_COMPANY);
when(service.listShopDataCrawlDataPermissionUsers(operator, RESOLVED_COMPANY)).thenReturn(List.of(permissionUser));
when(service.updateShopDataCrawlDataPermissionUsers(operator, RESOLVED_COMPANY, List.of(20L))).thenReturn(1);
var listResponse = controller.listShopDataCrawlDataPermissionUsers(request);
var updateResponse = controller.updateShopDataCrawlDataPermissionUsers(request, body);
var listResponse = controller.listShopDataCrawlDataPermissionUsers(request, 7L);
var updateResponse = controller.updateShopDataCrawlDataPermissionUsers(request, 7L, body);
assertThat(listResponse.getData()).containsExactly(permissionUser);
assertThat(updateResponse.getData()).isEqualTo(1);
verify(authSupport, times(2)).requireAdmin(request);
verify(service).listShopDataCrawlDataPermissionUsers(operator);
verify(service).updateShopDataCrawlDataPermissionUsers(operator, List.of(20L));
verify(service, times(2)).resolveScopeCompanyId(operator, 7L);
verify(service).listShopDataCrawlDataPermissionUsers(operator, RESOLVED_COMPANY);
verify(service).updateShopDataCrawlDataPermissionUsers(operator, RESOLVED_COMPANY, List.of(20L));
}
/**
* {@code company_id} 必须先交给归属判据、再由判据的结果决定建到哪家:控制器自己兜一个默认公司,
* 等于把「站超管指定别家」这条需求做成假的,而且缺省值会在前端没带参数时静默变成「只看公司 1」。
*/
@Test
void createMenuForwardsCompanyIdAndReorderForwardsOperator() {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService service = mock(PermissionMenuService.class);
HttpServletRequest request = mock(HttpServletRequest.class);
PermissionMenuController controller = new PermissionMenuController(authSupport, service);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(1L);
operator.setRole("super_admin");
operator.setCompanyId(7L);
PermissionMenuCreateRequest createRequest = new PermissionMenuCreateRequest();
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(service.resolveScopeCompanyId(operator, 7L)).thenReturn(RESOLVED_COMPANY);
controller.createMenu(request, createRequest, 7L);
controller.reorderColumns(request, Map.of("ordered_ids", List.of(2L, 1L)));
verify(service).resolveScopeCompanyId(operator, 7L);
verify(service).create(operator, RESOLVED_COMPANY, createRequest);
// 排序原先只有 ids 没有操作者,公司闸门就无处可查;换签名后必须确认操作者真到了 service。
verify(service).reorder(operator, List.of(2L, 1L));
}
/**
* 前端没带 {@code company_id} 时,控制器把 {@code null} 原样交给判据,自己一个字都不编:
* "那一家到底是哪家"由 {@code resolveScopeCompanyId} 定(非超管=本公司,超管=本公司那棵树),
* 下游拿到的是它的返回值而不是 {@code null},这样"缺省到底查了哪家"在两条断言里都留得下痕迹。
*/
@Test
void absentCompanyIdGoesToTheScopeDoorInsteadOfAnInventedDefault() {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService service = mock(PermissionMenuService.class);
HttpServletRequest request = mock(HttpServletRequest.class);
PermissionMenuController controller = new PermissionMenuController(authSupport, service);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(1L);
operator.setRole("admin");
operator.setCompanyId(7L);
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(service.resolveScopeCompanyId(operator, null)).thenReturn(7L);
controller.listMenus(request, "admin", false, null);
controller.listImageVideoDataPermissionUsers(request, null);
controller.listShopDataCrawlDataPermissionUsers(request, null);
verify(service, times(3)).resolveScopeCompanyId(operator, null);
verify(service).list(operator, "admin", false, 7L);
verify(service).listImageVideoDataPermissionUsers(operator, 7L);
verify(service).listShopDataCrawlDataPermissionUsers(operator, 7L);
}
}
@@ -0,0 +1,536 @@
package com.nanri.aiimage.modules.permission.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.mapper.PermissionMenuMapper;
import com.nanri.aiimage.modules.permission.mapper.UserColumnPermissionMapper;
import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuCreateRequest;
import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuUpdateRequest;
import com.nanri.aiimage.modules.permission.model.dto.UserColumnPermissionUpdateRequest;
import com.nanri.aiimage.modules.permission.model.entity.PermissionMenuEntity;
import com.nanri.aiimage.modules.permission.model.entity.UserColumnPermissionEntity;
import com.nanri.aiimage.modules.permission.model.vo.ImageVideoDataPermissionUserVo;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.stubbing.Answer;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.clearInvocations;
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.when;
/**
* V149「每家公司一套菜单树」之后的归属判定(设计文档 §5、定案 D1/D2/D3)。
*
* <p>这些用例的共同写法是<b>让 mock 装作一间真库</b>:带了 {@code company_id} 条件就只回本公司的行,
* 没带就把别家那行也交出来。于是"少写一个公司条件"不会表现为一行代码没被覆盖,而表现为
* 返回值里冒出别家的 id —— 断言打在结果上,而不是打在"源码里有没有那一句"上。</p>
*
* <p>为什么值得这么绕:这一族的失效全是静默的。按 key 点查少一个条件就是 {@code LIMIT 1}
* 跨公司借位(页面显示已授权、账号永远拿不到那份权限);读侧不收窄就是两家的同名菜单混进同一个
* 响应(前端按 key 建树直接长错形)。两者都不抛异常、都不进巡检。</p>
*/
class PermissionMenuServiceCompanyScopeTest {
private static final long COMPANY_A = 1L;
private static final long COMPANY_B = 2L;
private static final Set<Object> KNOWN_COMPANIES = Set.of(COMPANY_A, COMPANY_B);
private static final String IMAGE_VIDEO_KEY = "admin_image_video_task_data";
private PermissionMenuMapper menuMapper;
private UserColumnPermissionMapper permissionMapper;
private AdminUserMapper userMapper;
private PermissionMenuService service;
/** lambda 条件要渲染成 SQL 才往 paramNameValuePairs 落值,而渲染依赖 TableInfo 缓存。 */
@BeforeAll
static void initMybatisPlusTableInfo() {
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, PermissionMenuEntity.class);
TableInfoHelper.initTableInfo(assistant, AdminUserEntity.class);
}
@BeforeEach
void setUp() {
menuMapper = mock(PermissionMenuMapper.class);
permissionMapper = mock(UserColumnPermissionMapper.class);
userMapper = mock(AdminUserMapper.class);
service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
}
// --------------------------------------------------------------- 夹具
private static PermissionMenuEntity menu(long id, long companyId, String columnKey,
String menuType, Long parentId, int sortOrder) {
PermissionMenuEntity entity = new PermissionMenuEntity();
entity.setId(id);
entity.setCompanyId(companyId);
entity.setName(columnKey);
entity.setColumnKey(columnKey);
entity.setMenuType(menuType);
entity.setRoutePath("/" + columnKey);
entity.setParentId(parentId);
entity.setSortOrder(sortOrder);
return entity;
}
private static AdminUserEntity user(long id, String role, Long companyId) {
AdminUserEntity entity = new AdminUserEntity();
entity.setId(id);
entity.setUsername("u" + id);
entity.setRole(role);
entity.setCompanyId(companyId);
return entity;
}
private static UserColumnPermissionEntity grant(long userId, long columnId) {
UserColumnPermissionEntity entity = new UserColumnPermissionEntity();
entity.setUserId(userId);
entity.setColumnId(columnId);
return entity;
}
/** 先摸一次 getSqlSegment():MP 只在条件渲染时把值写进 paramNameValuePairs。 */
private static List<Object> params(LambdaQueryWrapper<?> query) {
assertThat(query.getSqlSegment()).isNotNull();
return new ArrayList<>(query.getParamNameValuePairs().values());
}
private static List<Object> params(LambdaUpdateWrapper<?> update) {
assertThat(update.getSqlSegment()).isNotNull();
return new ArrayList<>(update.getParamNameValuePairs().values());
}
/** 这条查询有没有按公司筛过——用"参数里出现了任一已知公司 id"来读,不认列名字符串。 */
private static boolean filteredByAnyCompany(LambdaQueryWrapper<?> query) {
return params(query).stream().anyMatch(KNOWN_COMPANIES::contains);
}
/**
* 一间真库:带公司条件只回那一家,不带就把两家都回出来(=借位)。
* 用例因此同时咬得住"条件漏了"(结果多出别家)与"条件写死了别家"(结果少了本该有的)。
*/
private static List<PermissionMenuEntity> fakeDbRows(List<PermissionMenuEntity> all,
LambdaQueryWrapper<PermissionMenuEntity> query) {
if (!filteredByAnyCompany(query)) {
return new ArrayList<>(all);
}
List<Object> values = params(query);
List<PermissionMenuEntity> hits = new ArrayList<>();
for (PermissionMenuEntity row : all) {
if (values.contains(row.getCompanyId())) {
hits.add(row);
}
}
return hits;
}
private static Answer<List<PermissionMenuEntity>> menusFromFakeDb(List<PermissionMenuEntity> all) {
return invocation -> fakeDbRows(all, invocation.getArgument(0));
}
/** 账号侧同一间真库:{@code grantableUserQuery} 少了公司条件就会把别家的人一起列进来。 */
private static List<AdminUserEntity> fakeDbUsers(List<AdminUserEntity> all,
LambdaQueryWrapper<AdminUserEntity> query) {
if (!filteredByAnyCompany(query)) {
return new ArrayList<>(all);
}
List<Object> values = params(query);
List<AdminUserEntity> hits = new ArrayList<>();
for (AdminUserEntity row : all) {
if (values.contains(row.getCompanyId())) {
hits.add(row);
}
}
return hits;
}
/**
* 两家公司各有一套同名 key 的树(A 家 id 个位/十位、B 家 id 1xx),
* 外加一条只在 A 家存在的角色内在闸门行 {@code admin_companies}。
*/
private List<PermissionMenuEntity> twoTrees() {
return new ArrayList<>(List.of(
menu(9, COMPANY_A, "admin_group_data", "admin", null, 5),
menu(10, COMPANY_A, "collect-data", "admin", 9L, 10),
menu(109, COMPANY_A, "admin_companies", "admin", null, 200),
menu(111, COMPANY_B, "admin_group_data", "admin", null, 5),
menu(110, COMPANY_B, "collect-data", "admin", 111L, 10)));
}
// ------------------------------------------------------------------ 用例
@Test
@DisplayName("非超管取菜单目录时,每一次取数都带他自己那一家")
void everyMenuQueryCarriesTheOperatorsCompany() {
when(userMapper.selectById(20L)).thenReturn(user(20L, "admin", COMPANY_B));
when(permissionMapper.selectByUserId(20L)).thenReturn(List.of());
when(menuMapper.selectList(any())).thenReturn(List.of());
service.list(user(20L, "admin", COMPANY_B), "admin", false);
ArgumentCaptor<LambdaQueryWrapper<PermissionMenuEntity>> captor =
ArgumentCaptor.forClass(LambdaQueryWrapper.class);
// 目录取数 + 可授予集合展开,两次都必须带公司;少任一次=别家的行混进同一个响应。
verify(menuMapper, atLeast(2)).selectList(captor.capture());
for (LambdaQueryWrapper<PermissionMenuEntity> query : captor.getAllValues()) {
assertThat(params(query)).contains(COMPANY_B);
}
}
@Test
@DisplayName("定案 D2:站点超管可以指定任意一家,非超管指定别家一律 403 且不落到任何查询")
void onlyTheSiteSuperAdminMayCrossCompanies() {
when(menuMapper.selectList(any())).thenReturn(List.of());
service.list(user(1L, "super_admin", COMPANY_A), "admin", false, COMPANY_B);
ArgumentCaptor<LambdaQueryWrapper<PermissionMenuEntity>> captor =
ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(menuMapper).selectList(captor.capture());
assertThat(params(captor.getValue())).contains(COMPANY_B);
clearInvocations(menuMapper);
assertThatThrownBy(() -> service.list(user(20L, "admin", COMPANY_B), "admin", false, COMPANY_A))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("其他公司");
verify(menuMapper, never()).selectList(any());
}
@Test
@DisplayName("company_id 传 0 或负数是在查询之前就拒掉,不是拿去点查一轮")
void nonPositiveCompanyIdIsRejectedBeforeAnyQuery() {
assertThatThrownBy(() -> service.list(user(1L, "super_admin", COMPANY_A), "admin", false, 0L))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("company_id 无效");
assertThatThrownBy(() -> service.list(user(1L, "super_admin", COMPANY_A), "admin", false, -3L))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("company_id 无效");
verify(menuMapper, never()).selectList(any());
}
@Test
@DisplayName("内部数据权限行与可授权用户列表必须解析到同一家:少一个条件就把别家的人列进来")
void dataPermissionLookupAndUserListResolveToTheSameCompany() {
List<PermissionMenuEntity> all = List.of(
menu(75, COMPANY_A, IMAGE_VIDEO_KEY, "admin", null, 10),
menu(975, COMPANY_B, IMAGE_VIDEO_KEY, "admin", null, 10));
// selectOne 同真库:带公司条件命中本公司行;漏条件就 LIMIT 1 借位到 A 家那行。
when(menuMapper.selectOne(any())).thenAnswer(invocation ->
fakeDbRows(all, (LambdaQueryWrapper<PermissionMenuEntity>) invocation.getArgument(0)).get(0));
when(permissionMapper.selectByColumnId(75L)).thenReturn(List.of(grant(300L, 75L)));
when(permissionMapper.selectByColumnId(975L)).thenReturn(List.of(grant(400L, 975L)));
when(userMapper.selectList(any())).thenAnswer(invocation -> fakeDbUsers(
List.of(user(300L, "admin", COMPANY_A), user(400L, "admin", COMPANY_B)),
invocation.getArgument(0)));
List<ImageVideoDataPermissionUserVo> visible =
service.listImageVideoDataPermissionUsers(user(1L, "super_admin", COMPANY_B));
assertThat(visible).extracting(ImageVideoDataPermissionUserVo::getId).containsExactly(400L);
assertThat(visible).extracting(ImageVideoDataPermissionUserVo::isGranted).containsExactly(true);
}
@Test
@DisplayName("跨公司挂父被拒:外键只保证父行存在,挡不住挂到别家的分组上")
void crossCompanyParentIsRejected() {
PermissionMenuCreateRequest request = new PermissionMenuCreateRequest();
request.setName("新页面");
request.setColumnKey("brand-new");
request.setMenuType("admin");
request.setRoutePath("/brand-new");
request.setParentId(9L);
when(menuMapper.selectById(9L)).thenReturn(menu(9, COMPANY_A, "admin_group_data", "admin", null, 5));
assertThatThrownBy(() -> service.create(user(20L, "admin", COMPANY_B), null, request))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("同一公司");
verify(menuMapper, never()).insert(any(PermissionMenuEntity.class));
}
@Test
@DisplayName("整条祖先链都要同一家:父是同公司、上面挂着别家的分组也一样拒")
void crossCompanyAncestorIsRejected() {
PermissionMenuCreateRequest request = new PermissionMenuCreateRequest();
request.setName("新页面");
request.setColumnKey("brand-new");
request.setMenuType("admin");
request.setRoutePath("/brand-new");
request.setParentId(50L);
when(menuMapper.selectById(50L)).thenReturn(menu(50, COMPANY_B, "b-group", "admin", 9L, 5));
when(menuMapper.selectById(9L)).thenReturn(menu(9, COMPANY_A, "admin_group_data", "admin", null, 5));
assertThatThrownBy(() -> service.create(user(20L, "admin", COMPANY_B), null, request))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("同一公司");
verify(menuMapper, never()).insert(any(PermissionMenuEntity.class));
}
@Test
@DisplayName("同名 key 在别家已存在不算重复:查重范围=本公司(与 uk_company_column_key 同一条键)")
void sameColumnKeyInAnotherCompanyDoesNotBlockMyCreate() {
when(menuMapper.selectOne(any())).thenAnswer(invocation -> {
LambdaQueryWrapper<PermissionMenuEntity> query = invocation.getArgument(0);
// 带公司条件:B 家没有 collect-data ⇒ null;漏了条件:A 家那行就成"重复"。
return params(query).contains(COMPANY_B)
? null
: menu(10, COMPANY_A, "collect-data", "admin", 9L, 10);
});
when(menuMapper.insert(any(PermissionMenuEntity.class))).thenAnswer(invocation -> {
invocation.getArgument(0, PermissionMenuEntity.class).setId(777L);
return 1;
});
when(menuMapper.selectById(777L)).thenReturn(menu(777, COMPANY_B, "collect-data", "admin", null, 11));
PermissionMenuCreateRequest request = new PermissionMenuCreateRequest();
request.setName("德阳的采集页");
request.setColumnKey("collect-data");
request.setMenuType("admin");
request.setRoutePath("/collect-data");
request.setSortOrder(11);
assertThat(service.create(user(20L, "admin", COMPANY_B), null, request).getId()).isEqualTo(777L);
ArgumentCaptor<PermissionMenuEntity> captor = ArgumentCaptor.forClass(PermissionMenuEntity.class);
verify(menuMapper).insert(captor.capture());
assertThat(captor.getValue().getCompanyId()).isEqualTo(COMPANY_B);
assertThat(captor.getValue().getColumnKey()).isEqualTo("collect-data");
}
@Test
@DisplayName("改/删/排别家的菜单一律 403,而且改之前就被拒,不会先读后写地留痕")
void writesToAnotherCompanysMenuAreForbidden() {
when(menuMapper.selectById(10L)).thenReturn(menu(10, COMPANY_A, "collect-data", "admin", 9L, 10));
PermissionMenuUpdateRequest update = new PermissionMenuUpdateRequest();
update.setName("改名");
update.setColumnKey("collect-data");
update.setMenuType("admin");
update.setRoutePath("/collect-data");
assertThatThrownBy(() -> service.update(user(20L, "admin", COMPANY_B), 10L, update))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("其他公司");
assertThatThrownBy(() -> service.delete(user(20L, "admin", COMPANY_B), 10L))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("其他公司");
assertThatThrownBy(() -> service.reorder(user(20L, "admin", COMPANY_B), List.of(10L, 11L)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("其他公司");
verify(menuMapper, never()).updateById(any(PermissionMenuEntity.class));
verify(menuMapper, never()).deleteById(anyLong());
verify(permissionMapper, never()).deleteByColumnId(any());
}
@Test
@DisplayName("同级重排的兄弟集按锚点行的公司筛:少了它会把两棵树的 sort_order 织在一起")
void reorderSiblingsAreCompanyScoped() {
// 锚点 111 属 B 家;A 家有一排同名兄弟(id 210/211、分组 212)——漏了公司条件就会一起进 siblings。
when(menuMapper.selectById(111L)).thenReturn(menu(111, COMPANY_B, "brand-check", "admin", 112L, 40));
when(menuMapper.selectList(any())).thenAnswer(menusFromFakeDb(List.of(
menu(110, COMPANY_B, "collect-data", "admin", 112L, 30),
menu(111, COMPANY_B, "brand-check", "admin", 112L, 40),
menu(210, COMPANY_A, "collect-data", "admin", 212L, 10),
menu(211, COMPANY_A, "brand-check", "admin", 212L, 20))));
service.reorder(user(20L, "admin", COMPANY_B), List.of(111L, 110L));
ArgumentCaptor<LambdaQueryWrapper<PermissionMenuEntity>> siblings =
ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(menuMapper).selectList(siblings.capture());
assertThat(params(siblings.getValue())).contains(COMPANY_B);
// 交换 B 家这两行的顺序必然产生两次写入;关键是写入的 id 只能是 B 家那两个。
ArgumentCaptor<LambdaUpdateWrapper<PermissionMenuEntity>> updates =
ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
verify(menuMapper, times(2)).update(nullable(PermissionMenuEntity.class), updates.capture());
for (LambdaUpdateWrapper<PermissionMenuEntity> update : updates.getAllValues()) {
assertThat(params(update)).containsAnyOf(110L, 111L);
assertThat(params(update)).doesNotContain(210L, 211L);
}
}
@Test
@DisplayName("给用户提交的授权 id 必须在【该用户自己】的树里:别家的行 id 报无效,不落库")
void grantIsBoundToTheTargetUsersOwnTree() {
when(userMapper.selectById(400L)).thenReturn(user(400L, "normal", COMPANY_B));
// A 家的 id 10 与 B 家的 id 110:本公司只认后者 ⇒ 带公司条件 count=1,漏条件 count=2。
when(menuMapper.selectCount(any())).thenAnswer(invocation ->
params((LambdaQueryWrapper<PermissionMenuEntity>) invocation.getArgument(0))
.contains(COMPANY_B) ? 1L : 2L);
when(menuMapper.selectList(any())).thenReturn(List.of());
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(10L, 110L));
assertThatThrownBy(() -> service.updateUserColumnPermissions(
user(1L, "super_admin", COMPANY_A), 400L, request, null))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("无效的菜单权限项");
verify(permissionMapper, never()).insert(any(UserColumnPermissionEntity.class));
verify(permissionMapper, never()).deleteByUserId(anyLong());
}
@Test
@DisplayName("回填集与有效菜单都只认目标账号那棵树:挂在别家行上的旧授权不复活")
void effectiveMenusOnlyComeFromTheUsersOwnTree() {
when(userMapper.selectById(400L)).thenReturn(user(400L, "normal", COMPANY_B));
when(permissionMapper.selectByUserId(400L)).thenReturn(List.of(grant(400L, 10L)));
when(menuMapper.selectList(any())).thenAnswer(menusFromFakeDb(twoTrees()));
assertThat(service.getUserColumnPermissions(user(1L, "super_admin", COMPANY_A), 400L, "admin"))
.isEmpty();
assertThat(service.getUserColumnIds(user(1L, "super_admin", COMPANY_A), 400L, "admin").getColumnIds())
.isEmpty();
// 同一个人换成 A 家的账号,同一笔授权就该生效——证明上面那两条空是因为公司,不是因为查不到行。
when(userMapper.selectById(400L)).thenReturn(user(400L, "normal", COMPANY_A));
assertThat(service.getUserColumnPermissions(user(1L, "super_admin", COMPANY_A), 400L, "admin"))
.extracting(PermissionMenuItemVo::getId).containsExactly(10L);
}
@Test
@DisplayName("权限判定遇到别家的 column_id 判「无权限」,方向是拒不是放")
void hasEffectiveColumnPermissionDeniesForeignColumnId() {
when(userMapper.selectById(400L)).thenReturn(user(400L, "normal", COMPANY_B));
when(menuMapper.selectById(10L)).thenReturn(menu(10, COMPANY_A, "collect-data", "admin", 9L, 10));
when(permissionMapper.selectByUserId(400L)).thenReturn(List.of(grant(400L, 10L)));
assertThat(service.hasEffectiveColumnPermission(400L, 10L)).isFalse();
// 拒在展开之前:一条目录查询都不该发生。
verify(menuMapper, never()).selectList(any());
}
@Test
@DisplayName("建树:三种 menu_type 全复制、闸门行不复制、父子指向按 key 落到本公司新行")
void copyTreeClonesEveryTypeAndRemapsParentsByKey() {
List<PermissionMenuEntity> template = new ArrayList<>(List.of(
menu(1, COMPANY_A, "app-collect", "app", null, 10),
menu(2, COMPANY_A, "app-child", "app", 1L, 20),
menu(3, COMPANY_A, "admin-group", "admin", null, 30),
menu(4, COMPANY_A, "admin-page", "admin", 3L, 40),
menu(5, COMPANY_A, "internal-thing", "internal", null, 50),
menu(109, COMPANY_A, "admin_companies", "admin", null, 60)));
List<PermissionMenuEntity> created = new ArrayList<>();
when(menuMapper.selectList(any())).thenAnswer(invocation -> {
LambdaQueryWrapper<PermissionMenuEntity> query = invocation.getArgument(0);
return params(query).contains(COMPANY_B)
? new ArrayList<>(created) : new ArrayList<>(template);
});
when(menuMapper.insert(any(PermissionMenuEntity.class))).thenAnswer(invocation -> {
PermissionMenuEntity row = invocation.getArgument(0);
row.setId(500L + created.size());
created.add(row);
return 1;
});
int inserted = service.copyTreeFromTemplate(COMPANY_B, COMPANY_A);
assertThat(inserted).isEqualTo(5);
assertThat(created).extracting(PermissionMenuEntity::getColumnKey)
.doesNotContain("admin_companies")
.containsExactlyInAnyOrder("app-collect", "app-child", "admin-group", "admin-page", "internal-thing");
assertThat(created).allSatisfy(row -> {
assertThat(row.getCompanyId()).isEqualTo(COMPANY_B);
assertThat(row.getMenuType()).isIn("app", "admin", "internal");
});
// 第二趟认父:父指向必须落在本公司新行上,绝不能是模板那排的全局 id。
Set<Long> copyIds = new LinkedHashSet<>();
created.forEach(row -> copyIds.add(row.getId()));
PermissionMenuEntity child = created.stream()
.filter(row -> "app-child".equals(row.getColumnKey())).findFirst().orElseThrow();
PermissionMenuEntity group = created.stream()
.filter(row -> "app-collect".equals(row.getColumnKey())).findFirst().orElseThrow();
assertThat(child.getParentId()).isEqualTo(group.getId());
assertThat(copyIds).contains(child.getParentId());
assertThat(child.getParentId()).isNotEqualTo(1L);
}
@Test
@DisplayName("建树可重跑:目标公司已有的 key 原样保留,第二次一行都不插")
void copyTreeIsIdempotentOnRerun() {
List<PermissionMenuEntity> template = new ArrayList<>(List.of(
menu(1, COMPANY_A, "app-collect", "app", null, 10),
menu(3, COMPANY_A, "admin-group", "admin", null, 30)));
List<PermissionMenuEntity> existing = new ArrayList<>(List.of(
menu(900, COMPANY_B, "app-collect", "app", null, 10),
menu(901, COMPANY_B, "admin-group", "admin", null, 30)));
when(menuMapper.selectList(any())).thenAnswer(invocation -> {
LambdaQueryWrapper<PermissionMenuEntity> query = invocation.getArgument(0);
return params(query).contains(COMPANY_B)
? new ArrayList<>(existing) : new ArrayList<>(template);
});
assertThat(service.copyTreeFromTemplate(COMPANY_B, COMPANY_A)).isZero();
verify(menuMapper, never()).insert(any(PermissionMenuEntity.class));
verify(menuMapper, never()).update(any(), any());
}
@Test
@DisplayName("建树不许靠默认值兜:模板公司缺失或操作者没归属都直接拒")
void copyTreeRefusesInsteadOfInventingADefaultCompany() {
when(menuMapper.selectList(any())).thenReturn(List.of());
assertThatThrownBy(() -> service.copyTreeFromTemplate(COMPANY_B, COMPANY_A))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("没有可复制的菜单树");
assertThatThrownBy(() -> service.copyTreeFromTemplate(COMPANY_B, null))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("没有所属公司");
assertThatThrownBy(() -> service.copyTreeFromTemplate(null, COMPANY_A))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("目标公司");
verify(menuMapper, never()).insert(any(PermissionMenuEntity.class));
// 给"自己"复制是条无意义的写入:早返回 0,一条查询都不发。
clearInvocations(menuMapper);
assertThat(service.copyTreeFromTemplate(COMPANY_A, COMPANY_A)).isZero();
verify(menuMapper, never()).selectList(any());
}
@Test
@DisplayName("判据要能咬住实现:不带公司条件时,夹具必须把别家的行也交出来")
void fakeDatabaseStubActuallyBites() {
// 自证尺子不是恒绿的:这些用例全部依赖「少一个 .eq(companyId) ⇒ 结果多出别家行」这个性质。
// 若夹具改成无脑只回本公司,上面那批断言就一条都咬不动了。
List<PermissionMenuEntity> all = twoTrees();
LambdaQueryWrapper<PermissionMenuEntity> withoutCompany =
new LambdaQueryWrapper<PermissionMenuEntity>().orderByAsc(PermissionMenuEntity::getSortOrder);
assertThat(filteredByAnyCompany(withoutCompany)).isFalse();
assertThat(fakeDbRows(all, withoutCompany)).extracting(PermissionMenuEntity::getId)
.contains(10L, 110L);
LambdaQueryWrapper<PermissionMenuEntity> withCompany =
new LambdaQueryWrapper<PermissionMenuEntity>().eq(PermissionMenuEntity::getCompanyId, COMPANY_B);
assertThat(filteredByAnyCompany(withCompany)).isTrue();
assertThat(fakeDbRows(all, withCompany)).extracting(PermissionMenuEntity::getId)
.containsExactlyInAnyOrder(110L, 111L)
.doesNotContain(10L, 109L);
}
}
@@ -1,158 +0,0 @@
package com.nanri.aiimage.modules.productcategory.controller;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
import com.nanri.aiimage.modules.productcategory.service.ProductCategoryService;
import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.mock.web.MockHttpServletRequest;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 「商品类目」controller 的正门接线(护栏 G2 断言 A 要求这些调用内联在 handler 块里,
* 本文件钉的是内联之后的<b>语义</b>:tab 的值确实进了出口、出口的结果确实交给了 service)。
*
* <p>G2 只看形状(有没有调、结果有没有被当实参用),看不见"把 service 那侧的实参改成 null"
* 这一记 —— 那一记由本文件的 {@code verify(service).list("面霜", 2L)} 负责。</p>
*/
@ExtendWith(MockitoExtension.class)
class ProductCategoryControllerCompanyScopeTest {
private static final Long OPERATOR_ID = 1L;
private static final Long COMPANY_ID = 2L;
@Mock
private ProductCategoryService productCategoryService;
@Mock
private AdminAuthSupport adminAuthSupport;
@Mock
private DataReadScope dataReadScope;
private ProductCategoryController controller() {
return new ProductCategoryController(productCategoryService, adminAuthSupport, dataReadScope);
}
@Test
@DisplayName("列表:tab 的公司 id 交给 readCompanyIdOrOwn,出口给什么 service 就用什么")
void listPassesTheTabValueThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
controller().list(request, "面霜", COMPANY_ID);
verify(dataReadScope).readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID));
verify(productCategoryService).list("面霜", COMPANY_ID);
}
@Test
@DisplayName("列表:非超管由出口判成\"不筛\",controller 不许自己补一个公司 id 进去")
void listUsesTheDoorsVerdictForNonSuperAdmin() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(null);
controller().list(request, "面霜", COMPANY_ID);
verify(productCategoryService).list("面霜", null);
}
@Test
@DisplayName("children / search / export 三支同样走出口,漏一支就是那一处的 tab 仍是装饰")
void everyReadEndpointGoesThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
// export 的返回要真喂给 ResponseEntity.contentLength(bytes.length):mock 给 null 会 NPE 在断言之前的装配里。
when(productCategoryService.export("面霜", COMPANY_ID)).thenReturn(new byte[0]);
ProductCategoryController controller = controller();
controller.children(request, 10L, 1L, 20L, COMPANY_ID);
controller.search(request, "面霜", 1L, 20L, COMPANY_ID);
controller.export(request, "面霜", COMPANY_ID);
verify(productCategoryService).children(10L, 1L, 20L, COMPANY_ID);
verify(productCategoryService).search("面霜", 1L, 20L, COMPANY_ID);
verify(productCategoryService).export("面霜", COMPANY_ID);
verify(dataReadScope, times(3))
.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID));
}
/** 写侧口径(一期定案):归属由后端从操作者会话推导,请求体不带 company_id,controller 也不读 tab。 */
@Test
@DisplayName("新增:只把操作者 id 交给 service,公司由 service 从会话推导")
void createPassesOnlyTheOperator() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
ProductCategorySaveRequest body = new ProductCategorySaveRequest();
body.setName("面霜套装");
body.setParentId(10L);
controller().create(request, body);
ArgumentCaptor<Long> operatorId = ArgumentCaptor.forClass(Long.class);
verify(productCategoryService).create(eq(body), operatorId.capture());
assertEquals(OPERATOR_ID, operatorId.getValue());
verifyNoInteractions(dataReadScope);
}
/** 写侧闸门(10-06 逐节点复验后补):读侧已经收窄,写侧不收窄="藏起来的行照样能删"。 */
@Test
@DisplayName("更新/删除:把 writeCompanyId 的判定原样交给 service,controller 不自己补公司 id")
void writeEndpointsPassTheRowOwnershipGate() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(COMPANY_ID);
ProductCategorySaveRequest body = new ProductCategorySaveRequest();
body.setName("面霜改名");
ProductCategoryController controller = controller();
controller.update(request, 300L, body);
controller.delete(request, 300L);
verify(productCategoryService).update(300L, body, COMPANY_ID);
verify(productCategoryService).delete(300L, COMPANY_ID);
}
/** 反向钉:闸门给 null(平台超管)时必须原样传 null——顺手补一个公司 id 会把超管锁死在本公司。 */
@Test
@DisplayName("更新:闸门判超管(null)时把 null 传下去,不补任何公司 id")
void writeGateKeepsTheSuperAdminVerdict() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(null);
ProductCategorySaveRequest body = new ProductCategorySaveRequest();
body.setName("内置类目改名");
controller().update(request, 10L, body);
verify(productCategoryService).update(10L, body, null);
}
private MockHttpServletRequest login() {
MockHttpServletRequest request = new MockHttpServletRequest();
request.addHeader("X-Internal-Token", "irrelevant-here");
return request;
}
private AdminUserEntity user() {
AdminUserEntity user = new AdminUserEntity();
user.setId(OPERATOR_ID);
user.setRole("super_admin");
return user;
}
}
@@ -4,8 +4,6 @@ import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.productcategory.mapper.ProductCategoryMapper;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
import com.nanri.aiimage.modules.productcategory.model.entity.ProductCategoryEntity;
@@ -20,16 +18,15 @@ import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@@ -37,32 +34,34 @@ import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 「商品类目」按公司视图的那几条不变量(V147 / 需求 2026-10-05「切 tab 数据还一样」)。
* 「商品类目」这棵树的公司口径(控制方 2026-10-06 定案:全平台共享、不区分公司,
* 写侧同样是「谁都能改整棵树」)。
*
* <p>这一页的归属是<b>物化列</b>而不是账号集合,所以判据形状与 readScope 那一族不同:
* 可见集 = {@code company_id IN (0, X)},其中 0 是内置节点的哨兵。两支最容易静默坏掉的形状
* 都由本文件钉住:① 哨兵那半不许丢(丢了第 2 家是一棵空树,连自建根都挂不上);
* ② 给 LLM 用的那棵全局树不许被顺手加上公司谓词(加了货源归类的候选就按公司分叉)。</p>
* <p>类名里的 CompanyScope 是有意保留的:这一页确实按公司切过(V147 加列、V148 取消共享哨兵 0、
* 内置行归还第 1 家)。本文件现在钉的是<b>反向</b>不变量——四条读通路真正渲染出来的 SQL 里一个
* {@code company_id} 都不许出现。原先那族「{@code company_id = 这一家}、不许带哨兵 0」的单值谓词钉子,
* 以及跨公司 403、"公司账号改不动内置节点"那两道写侧闸门,随定案一起作废:现在没有归属值可比,
* 也没有"别人的行"这一说。</p>
*
* <p>为什么留 SQL 层的钉子,而不只靠源码文本扫描({@code CompanyIdParamGoesThroughReadScopeTest}
* 已按 module 目录反向钉过一遍):那把尺子读的是 Java 源码里的公司 token,谓词若来自这两个文件之外
* (mapper XML、公共分页/租户拦截器)它看不见;这里读的是 MyBatis-Plus 真正拼出来的那一段。</p>
*/
@ExtendWith(MockitoExtension.class)
class ProductCategoryCompanyScopeTest {
private static final long BUILTIN = 0L;
private static final Long OPERATOR_ID = 7L;
/** 故意取 2:DEFAULT 1 那一家通不过"值等于会话公司"这种断言,取 2 才钉得住"真从会话推导"。 */
private static final Long COMPANY_ID = 2L;
private static final Long BUILTIN_PARENT_ID = 10L;
/** 原来的"内置根"在定案后只是同一棵树上的一个普通节点,不再带归属含义。 */
private static final Long PARENT_ID = 10L;
@Mock
private ProductCategoryMapper productCategoryMapper;
@Mock
private CompanyScopeSupport companyScopeSupport;
private ProductCategoryService service;
@BeforeAll
static void initTableInfo() {
// Lambda 条件要解析列名,没有 TableInfo 时 getSqlSegment() 里根本不会出现 company_id。
// Lambda 条件要解析列名。没有 TableInfo 时 getSqlSegment() 里一个列名都不会出现,
// "不含 company_id"就变成恒真的空断言。
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""),
ProductCategoryEntity.class);
@@ -70,281 +69,112 @@ class ProductCategoryCompanyScopeTest {
@BeforeEach
void setUp() {
service = new ProductCategoryService(productCategoryMapper, companyScopeSupport);
}
@Test
@DisplayName("公司视图带哨兵 0:可见集是 (0, 该公司),只查自建会让第 2 家连自建根都挂不上")
void companyViewIncludesTheBuiltinSentinel() {
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(1L, null, "护肤品", BUILTIN)));
service.list(null, COMPANY_ID);
LambdaQueryWrapper<ProductCategoryEntity> query = capturedListWrapper();
assertTrue(query.getSqlSegment().contains("company_id IN"), query.getSqlSegment());
Map<String, Object> params = paramsOf(query);
assertTrue(params.containsValue(BUILTIN), "哨兵 0 必须留在可见集里:" + params);
assertTrue(params.containsValue(COMPANY_ID), "公司谓词丢了 tab 就是装饰:" + params);
service = new ProductCategoryService(productCategoryMapper);
}
/**
* 反向钉(新维度不许顺手回流到别的通路):{@link ProductCategoryService#list()} 唯一的消费者是
* 货源/外观的类目归类({@code SimilarAsinLlmService} 读的是全局树)。给它加公司谓词会让同一个
* "面霜"有 N 个 category_key、LLM 分类结果按公司分叉,那是成本不只是口径。
* 四条读通路(全局树、带关键字的树、分页 children、搜索)逐条渲染后汇总比对。
* 三条锚(ORDER BY / parent_id / LIKE)先自证"确实扫到了真 SQL",否则末尾那条否证是空断言。
*/
@Test
@DisplayName("给 LLM 用的全局树不带公司谓词:按公司切会让归类结果按公司分叉")
void globalTreeForTheLlmConsumerStaysUnscoped() {
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(1L, null, "护肤品", BUILTIN)));
@DisplayName("四条读通路渲染出的 SQL 里都没有 company_id:全局树、分页 children、搜索")
@SuppressWarnings("unchecked")
void noReadPathRendersACompanyPredicate() {
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(20L, PARENT_ID, "面霜")));
when(productCategoryMapper.selectCount(any())).thenReturn(1L);
when(productCategoryMapper.selectMaps(any())).thenReturn(List.of());
when(productCategoryMapper.selectBatchIds(any())).thenReturn(List.of(row(PARENT_ID, null, "护肤品")));
service.list();
service.list("面霜");
service.children(PARENT_ID, 1, 20);
service.search("面霜", 1, 20);
LambdaQueryWrapper<ProductCategoryEntity> query = capturedListWrapper();
String sql = query.getSqlSegment();
// 两条一起才算非恒真:只看"不含 company_id"时,一条空 segment(列名解析不到、wrapper 根本没拼)
// 也会通过,那条断言就变成恒绿。先证明 wrapper 真渲染了东西,再证明它一个实参都没带。
assertTrue(sql.contains("ORDER BY"), "wrapper 根本没渲染,下面的否证是空话:" + sql);
assertFalse(sql.contains("company_id"),
"无参 list() 被接上了公司谓词 —— 货源归类的候选树随之按公司分叉:" + sql);
assertTrue(query.getParamNameValuePairs().isEmpty(),
"全局树带出了实参(说明有谓词被塞进来):" + query.getParamNameValuePairs());
}
ArgumentCaptor<Wrapper<ProductCategoryEntity>> pageQueries = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectList(pageQueries.capture());
ArgumentCaptor<Wrapper<ProductCategoryEntity>> countQueries = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectCount(countQueries.capture());
// 「子类目数」徽章走全表聚合:它要是被加上公司谓词,数字就会和点开的那棵树不一致。
ArgumentCaptor<Wrapper<ProductCategoryEntity>> badgeQueries = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectMaps(badgeQueries.capture());
@Test
@DisplayName("搜索的公司谓词必须在整条 OR 之外:AND 结合更紧会让前两列命中不受公司约束")
void searchKeepsTheOrGroupWrappedBeforeTheCompanyPredicate() {
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.selectList(any())).thenReturn(List.of());
service.search("面霜", 1, 20, COMPANY_ID);
List<LambdaQueryWrapper<ProductCategoryEntity>> queries = capturedSearchWrappers();
for (LambdaQueryWrapper<ProductCategoryEntity> query : queries) {
String sql = query.getSqlSegment();
assertTrue(sql.contains(") AND company_id IN"),
"OR 组没有被包起来再 AND 公司(前两个 like 命中的行会跨公司):" + sql);
Map<String, Object> params = paramsOf(query);
assertTrue(params.containsValue("%面霜%"), sql);
assertTrue(params.containsValue(COMPANY_ID), sql);
List<Wrapper<ProductCategoryEntity>> queries = new ArrayList<>();
queries.addAll(pageQueries.getAllValues());
queries.addAll(countQueries.getAllValues());
queries.addAll(badgeQueries.getAllValues());
List<String> rendered = new ArrayList<>();
for (Wrapper<ProductCategoryEntity> query : queries) {
rendered.add(query.getSqlSegment());
}
assertEquals(2, queries.size(), "count 与 list 两条查询都要带公司谓词");
assertFalse(rendered.isEmpty(), "一条查询都没捕到:读通路的形状变了,后面的断言全是空话");
assertTrue(rendered.stream().anyMatch(sql -> sql.contains("ORDER BY")),
"捕到的全是没渲染的空调用(列名解析失败时 getSqlSegment() 给空串):" + rendered);
assertTrue(rendered.stream().anyMatch(sql -> sql.contains("parent_id")),
"分页 children 与徽章那几条查询没进样本(parent_id 谓词形状变了):" + rendered);
assertTrue(rendered.stream().anyMatch(sql -> sql.contains("LIKE")),
"搜索那条没进样本,「搜索那一支的过滤形状」没人看守:" + rendered);
assertFalse(rendered.stream().anyMatch(sql -> sql.contains("company_id")),
"有读通路又按公司筛了(2026-10-06 定案:全平台共享一棵树):" + rendered);
}
@Test
@DisplayName("分页 children 的 count 与 list 两条查询同源,且子类目数徽章也按可见集聚合")
void childrenScopeCountListAndChildBadgeTogether() {
@DisplayName("分页 children 补 level/path:父级按层批量取,那一列不再是类目名的副本")
void childrenPageCarriesPathAndLevel() {
when(productCategoryMapper.selectCount(any())).thenReturn(1L);
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(20L, BUILTIN_PARENT_ID, "面霜", COMPANY_ID)));
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(20L, PARENT_ID, "面霜")));
when(productCategoryMapper.selectMaps(any())).thenReturn(List.of());
when(productCategoryMapper.selectBatchIds(any())).thenReturn(List.of(row(PARENT_ID, null, "护肤品")));
service.children(BUILTIN_PARENT_ID, 1, 20, COMPANY_ID);
ProductCategoryListVo vo = service.children(null, 1, 20);
ArgumentCaptor<Wrapper<ProductCategoryEntity>> countCaptor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectCount(countCaptor.capture());
assertTrue(countCaptor.getValue().getSqlSegment().contains("company_id IN"));
LambdaQueryWrapper<ProductCategoryEntity> pageQuery = capturedListWrapper();
assertTrue(pageQuery.getSqlSegment().contains("company_id IN"));
assertTrue(pageQuery.getSqlSegment().contains("parent_id"));
// 「子类目数」徽章走全表聚合:不加公司谓词就会把别家子节点数算进来,数字与点开看到的树不一致。
ArgumentCaptor<Wrapper<ProductCategoryEntity>> badgeCaptor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectMaps(badgeCaptor.capture());
assertTrue(badgeCaptor.getValue().getSqlSegment().contains("company_id IN"),
badgeCaptor.getValue().getSqlSegment());
}
@Test
@DisplayName("新增:归属从操作者会话推导,不靠 V147 那个临时 DEFAULT 1")
void createStampsTheOperatorsCompany() {
when(companyScopeSupport.requireCompanyId(OPERATOR_ID)).thenReturn(COMPANY_ID);
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.insert(any(ProductCategoryEntity.class))).thenAnswer(call -> {
call.getArgument(0, ProductCategoryEntity.class).setId(500L);
return 1;
});
when(productCategoryMapper.selectById(500L)).thenReturn(row(500L, BUILTIN_PARENT_ID, "面霜套装", COMPANY_ID));
service.create(saveRequest("面霜套装", BUILTIN_PARENT_ID), OPERATOR_ID);
ArgumentCaptor<ProductCategoryEntity> inserted = ArgumentCaptor.forClass(ProductCategoryEntity.class);
verify(productCategoryMapper).insert(inserted.capture());
assertEquals(COMPANY_ID, inserted.getValue().getCompanyId());
assertFalse(Boolean.TRUE.equals(inserted.getValue().getIsBuiltin()));
assertTrue(inserted.getValue().getCategoryKey().startsWith("custom_"));
// 同级重名预检的范围 = 可见集(自建 + 内置):漏了它,第 2 家能在内置"护肤品"下再建一个同名"面霜",
// 页面一排两个而货源归类不知落到哪个;反过来跨家同名必须放行(那正是 uk_company_category_key 要解的)。
// 第 0 条=同级重名预检;findItem 里那条「子类目数」聚合不在本断言射程内(它按 parent_id 数,
// 不带公司谓词——那是详情返回值的计数,与列表可见集两回事)。
LambdaQueryWrapper<ProductCategoryEntity> sibling = countWrappers().get(0);
assertTrue(sibling.getSqlSegment().contains("company_id IN"), sibling.getSqlSegment());
Map<String, Object> params = paramsOf(sibling);
assertTrue(params.containsValue(BUILTIN), "重名检查漏了内置那一半:" + params);
assertTrue(params.containsValue(COMPANY_ID), "重名检查漏了这一家自己:" + params);
}
@Test
@DisplayName("新增:父级挂在别家公司名下要 403,不能静默把行挪出可见集")
void createRejectsParentOwnedByAnotherCompany() {
Long foreignParentId = 77L;
when(companyScopeSupport.requireCompanyId(OPERATOR_ID)).thenReturn(COMPANY_ID);
when(productCategoryMapper.selectById(foreignParentId))
.thenReturn(row(foreignParentId, null, "别家的根", 3L));
BusinessException exception = assertThrows(BusinessException.class,
() -> service.create(saveRequest("面霜套装", foreignParentId), OPERATOR_ID));
assertEquals(403, exception.getCode());
verify(productCategoryMapper, never()).insert(any(ProductCategoryEntity.class));
}
@Test
@DisplayName("新增:内置节点(哨兵 0)当父级放行,否则第 2 家永远建不出子级")
void createAcceptsTheSharedBuiltinParent() {
when(companyScopeSupport.requireCompanyId(OPERATOR_ID)).thenReturn(COMPANY_ID);
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.insert(any(ProductCategoryEntity.class))).thenAnswer(call -> {
call.getArgument(0, ProductCategoryEntity.class).setId(501L);
return 1;
});
when(productCategoryMapper.selectById(501L)).thenReturn(row(501L, BUILTIN_PARENT_ID, "自建子级", COMPANY_ID));
service.create(saveRequest("自建子级", BUILTIN_PARENT_ID), OPERATOR_ID);
ArgumentCaptor<ProductCategoryEntity> inserted = ArgumentCaptor.forClass(ProductCategoryEntity.class);
verify(productCategoryMapper).insert(inserted.capture());
assertEquals(COMPANY_ID, inserted.getValue().getCompanyId());
assertEquals(BUILTIN_PARENT_ID, inserted.getValue().getParentId());
}
@Test
@DisplayName("更新时按行自己的归属判可见集:内置行归 0、自建行归那一家,都不取 tab")
void updateUsesTheRowsOwnCompanyNotTheTab() {
ProductCategoryEntity custom = row(300L, BUILTIN_PARENT_ID, "面霜", COMPANY_ID);
when(productCategoryMapper.selectById(300L)).thenReturn(custom);
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.updateById(any(ProductCategoryEntity.class))).thenReturn(1);
service.update(300L, saveRequest("面霜改名", BUILTIN_PARENT_ID), COMPANY_ID);
LambdaQueryWrapper<ProductCategoryEntity> sibling = countWrappers().get(0);
assertTrue(sibling.getSqlSegment().contains("company_id IN"), sibling.getSqlSegment());
Map<String, Object> params = paramsOf(sibling);
assertTrue(params.containsValue(COMPANY_ID), params.toString());
assertFalse(params.containsValue(3L),
"把行挪到可见集外的节点下面会让它从原本看得见它的 tab 里消失:" + params);
}
// ---- 写侧行归属闸门(10-06 逐节点复验后补)----
// 读侧已经把这一页收窄到本公司,写侧不收窄="藏起来的行照样能改名/删除",那是静默删除不是隔离。
// assertSameCompany 自己的判定由 CompanyScopeSupportTest 钉(本仓唯一一份),这里只钉"service 有没有
// 把这一刀落在正确的两个值上、被拒之后还写不写库"——所以桩按真方法的语义给:只有配对不对才抛。
@Test
@DisplayName("更新别家公司的行:闸门 403 且 updateById 一次都不跑")
void updateRejectsARowOwnedByAnotherCompany() {
Long foreignCompanyId = 3L;
when(productCategoryMapper.selectById(300L)).thenReturn(row(300L, null, "别家的根", foreignCompanyId));
stubSameCompanyJudgment();
BusinessException exception = assertThrows(BusinessException.class,
() -> service.update(300L, saveRequest("改名", null), COMPANY_ID));
assertEquals(403, exception.getCode());
verify(productCategoryMapper, never()).updateById(any(ProductCategoryEntity.class));
// 断言闸门拿到的是<b>行自己的</b>归属而不是 tab 之外的什么值:喂错第二个实参,这一刀形同没落。
verify(companyScopeSupport).assertSameCompany(eq(COMPANY_ID), eq(foreignCompanyId), any());
}
@Test
@DisplayName("更新内置节点(哨兵 0):公司账号一律拒,改了它所有公司的树与货源归类同一天跟着变")
void updateRejectsTheSharedBuiltinRow() {
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
stubSameCompanyJudgment();
BusinessException exception = assertThrows(BusinessException.class,
() -> service.update(BUILTIN_PARENT_ID, saveRequest("护肤品改名", null), COMPANY_ID));
assertEquals(403, exception.getCode());
verify(productCategoryMapper, never()).updateById(any(ProductCategoryEntity.class));
}
@Test
@DisplayName("更新:本公司自己的行放行(闸门不该把这一页的正常编辑也拦死)")
void updateAcceptsTheRowsOwnCompany() {
when(productCategoryMapper.selectById(300L)).thenReturn(row(300L, null, "面霜", COMPANY_ID));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.updateById(any(ProductCategoryEntity.class))).thenReturn(1);
stubSameCompanyJudgment();
service.update(300L, saveRequest("面霜改名", null), COMPANY_ID);
verify(productCategoryMapper).updateById(any(ProductCategoryEntity.class));
}
/** 反向钉(多隔离那一向):闸门判 null = 平台超管不限,顺手补一个公司 id 会把超管锁死在本公司。 */
@Test
@DisplayName("更新:超管口径(null)不调用行归属闸门,内置节点照样能改")
void superAdminUpdateSkipsTheRowGate() {
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.updateById(any(ProductCategoryEntity.class))).thenReturn(1);
service.update(BUILTIN_PARENT_ID, saveRequest("护肤品改名", null), null);
verify(productCategoryMapper).updateById(any(ProductCategoryEntity.class));
verifyNoInteractions(companyScopeSupport);
}
@Test
@DisplayName("删除:闸门在数子级之前,别家的行连「有几个子节点」都不去查")
void deleteRejectsARowOwnedByAnotherCompany() {
Long foreignCompanyId = 3L;
when(productCategoryMapper.selectById(400L)).thenReturn(row(400L, null, "别家的叶子", foreignCompanyId));
stubSameCompanyJudgment();
BusinessException exception = assertThrows(BusinessException.class,
() -> service.delete(400L, COMPANY_ID));
assertEquals(403, exception.getCode());
verify(productCategoryMapper, never()).deleteById(anyLong());
verify(productCategoryMapper, never()).selectCount(any());
}
@Test
@DisplayName("删除:本公司自己的行放行并真删")
void deleteAcceptsTheRowsOwnCompany() {
when(productCategoryMapper.selectById(401L)).thenReturn(row(401L, null, "自建叶子", COMPANY_ID));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
stubSameCompanyJudgment();
service.delete(401L, COMPANY_ID);
verify(productCategoryMapper).deleteById(401L);
assertEquals("护肤品 / 面霜", vo.getItems().get(0).getPath());
assertEquals(1, vo.getItems().get(0).getLevel());
// 父级取的是批量那一条,不是每行一次 selectById。
ArgumentCaptor<List<Long>> ids = ArgumentCaptor.forClass(List.class);
verify(productCategoryMapper).selectBatchIds(ids.capture());
assertEquals(List.of(PARENT_ID), ids.getValue());
verify(productCategoryMapper, never()).selectById(anyLong());
}
/**
* 把 {@code assertSameCompany} 按<b>真方法的语义</b>桩上(第一参 ≠ 第二参才抛 403)。
* 不这么写的话 Mockito 对 void 方法默认"什么都不做",三条拒绝用例会因为错误的理由恒绿。
* 同级重名预检的判据只剩 {@code (name, parent_id)}。这一条是这一族里唯一还可能被"顺手加回去"的形状——
* 归属列整个删了,但只要有人把列加回来,{@code .eq(ProductCategoryEntity::getCompanyId, …)} 就能写,
* 而那一记不报错:第 2 家能建出与第 1 家同名的同级节点,两棵树各长一份。
*/
private void stubSameCompanyJudgment() {
org.mockito.Mockito.doAnswer(call -> {
Long operatorCompanyId = call.getArgument(0);
Long rowCompanyId = call.getArgument(1);
if (rowCompanyId == null || !rowCompanyId.equals(operatorCompanyId)) {
throw new BusinessException(403, call.getArgument(2, String.class));
}
return null;
}).when(companyScopeSupport).assertSameCompany(any(), any(), any());
@Test
@DisplayName("同级重名预检只看 name 与 parent_id:全平台共享后没有归属这一维可比")
@SuppressWarnings("unchecked")
void createSiblingUniquenessChecksNameAndParentOnly() {
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.insert(any(ProductCategoryEntity.class))).thenAnswer(call -> {
call.getArgument(0, ProductCategoryEntity.class).setId(300L);
return 1;
});
when(productCategoryMapper.selectById(300L)).thenReturn(row(300L, null, "面霜套装"));
service.create(saveRequest("面霜套装", null));
ArgumentCaptor<Wrapper<ProductCategoryEntity>> counts = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectCount(counts.capture());
LambdaQueryWrapper<ProductCategoryEntity> uniqueness =
(LambdaQueryWrapper<ProductCategoryEntity>) counts.getAllValues().get(0);
String sql = uniqueness.getSqlSegment();
// 实参表是惰性填充的:不先求值 segment,getParamNameValuePairs() 是空 map(正反两断言会双双恒真)。
Map<String, Object> params = uniqueness.getParamNameValuePairs();
assertTrue(sql.contains("name ="), "重名预检整段没了,下面的排他就是空断言:" + sql);
assertTrue(sql.contains("parent_id IS NULL"), "同级这一维没了,重名预检退成了全表比对:" + sql);
assertFalse(sql.contains("company_id"), "重名预检又按公司切了:" + sql);
assertTrue(params.containsValue("面霜套装"), params.toString());
}
@Test
@DisplayName("空关键字的直接搜索返回空页,不探库")
void blankKeywordSearchShortCircuits() {
ProductCategoryListVo vo = service.search(" ", 1, 20);
assertEquals(0L, vo.getTotal());
assertTrue(vo.getItems().isEmpty());
verifyNoInteractions(productCategoryMapper);
}
private ProductCategorySaveRequest saveRequest(String name, Long parentId) {
@@ -354,64 +184,14 @@ class ProductCategoryCompanyScopeTest {
return request;
}
private static ProductCategoryEntity row(Long id, Long parentId, String name, Long companyId) {
private static ProductCategoryEntity row(Long id, Long parentId, String name) {
ProductCategoryEntity entity = new ProductCategoryEntity();
entity.setId(id);
entity.setParentId(parentId);
entity.setName(name);
entity.setCategoryKey("cat_" + id);
entity.setSortOrder(100);
entity.setCompanyId(companyId);
entity.setIsBuiltin(companyId == BUILTIN);
entity.setIsBuiltin(false);
return entity;
}
@SuppressWarnings("unchecked")
private LambdaQueryWrapper<ProductCategoryEntity> capturedListWrapper() {
ArgumentCaptor<Wrapper<ProductCategoryEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectList(captor.capture());
return (LambdaQueryWrapper<ProductCategoryEntity>) captor.getValue();
}
/** create/update 之后 selectCount 至少两条(重名预检 + 详情里的子类目数),按调用顺序取。 */
@SuppressWarnings("unchecked")
private List<LambdaQueryWrapper<ProductCategoryEntity>> countWrappers() {
ArgumentCaptor<Wrapper<ProductCategoryEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectCount(captor.capture());
return captor.getAllValues().stream()
.map(wrapper -> (LambdaQueryWrapper<ProductCategoryEntity>) wrapper)
.toList();
}
/**
* MyBatis-Plus 的实参表是<b>惰性</b>填充的:不先求值 {@code getSqlSegment()},
* {@code getParamNameValuePairs()} 是个空 map——那会让"含 0"与"不含 3"两个方向的断言同时恒真。
* 读参数一律走这里,别在测试里各自记得。
*/
private static Map<String, Object> paramsOf(LambdaQueryWrapper<ProductCategoryEntity> query) {
query.getSqlSegment();
return query.getParamNameValuePairs();
}
@SuppressWarnings("unchecked")
private List<LambdaQueryWrapper<ProductCategoryEntity>> capturedSearchWrappers() {
ArgumentCaptor<Wrapper<ProductCategoryEntity>> count = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectCount(count.capture());
ArgumentCaptor<Wrapper<ProductCategoryEntity>> list = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectList(list.capture());
return List.of((LambdaQueryWrapper<ProductCategoryEntity>) count.getValue(),
(LambdaQueryWrapper<ProductCategoryEntity>) list.getValue());
}
@Test
@DisplayName("空关键字的直接搜索返回空页,不探库")
void blankKeywordSearchShortCircuits() {
ProductCategoryListVo vo = service.search(" ", 1, 20, COMPANY_ID);
assertEquals(0L, vo.getTotal());
verify(productCategoryMapper, never()).selectCount(any());
verify(productCategoryMapper, never()).selectMaps(any());
// CompanyScopeSupport 有 (Long) 与 (AdminUserEntity) 两形:any() 会撞上重载歧义(javac 直接拒绝)。
verify(companyScopeSupport, never()).requireCompanyId(anyLong());
}
}
@@ -0,0 +1,167 @@
package com.nanri.aiimage.modules.shopkey.controller;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyCreateRequest;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyUpdateRequest;
import com.nanri.aiimage.modules.shopkey.service.ShopKeyService;
import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.mock.web.MockHttpServletRequest;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 「店铺密钥管理」controller 的正门接线(护栏 G2 断言 A 要求正门调用内联在 handler 块里,
* 本文件钉的是内联之后的<b>语义</b>:tab 的值确实进了出口、出口的结果确实交给了 service)。
*
* <p>G2 只看形状(有没有调、结果有没有被当实参用),看不见"把 service 那侧的实参改成 null"
* 这一记 —— 那一记由本文件的 {@code verify(service).page(1L, 15L, 2L)} 负责。</p>
*
* <p>口径参照 {@code ProductCategoryControllerCompanyScopeTest}:同一套"出口给什么就用什么"的两向钉,
* 少任何一向都会放开一类静默失效(正向量不到「出口被绕过」,反向量不到「controller 自己补公司 id」)。</p>
*/
@ExtendWith(MockitoExtension.class)
class ShopKeyControllerCompanyScopeTest {
private static final Long OPERATOR_ID = 11L;
private static final Long COMPANY_ID = 2L;
@Mock
private ShopKeyService shopKeyService;
@Mock
private AdminAuthSupport adminAuthSupport;
@Mock
private DataReadScope dataReadScope;
private ShopKeyController controller() {
return new ShopKeyController(shopKeyService, adminAuthSupport, dataReadScope);
}
@Test
@DisplayName("列表:tab 的公司 id 交给 readCompanyIdOrOwn,出口给什么 service 就用什么")
void pagePassesTheTabValueThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, COMPANY_ID);
verify(dataReadScope).readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID));
verify(shopKeyService).page(1L, 15L, COMPANY_ID);
}
/**
* 反向钉:超管走"不筛"时出口返回 null,controller 必须原样把 null 传下去。
* 这里"顺手补一个公司 id"的后果是超管切到第 2 家以外时列表永远是第 2 家——
* 与本文件第一支同为正门语义的两半,缺任何一半都放行一次静默改口径。
*/
@Test
@DisplayName("列表:出口判超管(null)时把 null 传下去,不补任何公司 id")
void pageKeepsTheDoorsUnfilteredVerdict() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(null);
controller().page(request, 1L, 15L, COMPANY_ID);
verify(shopKeyService).page(1L, 15L, null);
}
/**
* 非超管带别家的 company_id 时,出口返回的是<b>会话那一家</b>(readCompanyIdOrOwn 的语义),
* controller 不许拿请求里的值再自己判一次——那正是"tab 不是安全边界"被写反的形状。
*/
@Test
@DisplayName("列表:出口按会话收窄后,交给 service 的是收窄值而不是请求里的值")
void pageUsesTheNarrowedValueNotTheRequestedOne() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(99L))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, 99L);
verify(shopKeyService).page(1L, 15L, COMPANY_ID);
}
@Test
@DisplayName("更新/删除/白名单检测:把 writeCompanyId 的判定原样交给 service,controller 不自己补公司 id")
void writeEndpointsPassTheRowOwnershipGate() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(COMPANY_ID);
ShopKeyUpdateRequest body = new ShopKeyUpdateRequest();
body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a");
ShopKeyController controller = controller();
controller.update(request, 300L, body);
controller.delete(request, 300L);
controller.checkWhitelist(request, 300L);
verify(shopKeyService).update(300L, body, COMPANY_ID);
verify(shopKeyService).delete(300L, COMPANY_ID);
verify(shopKeyService).checkWhitelist(300L, COMPANY_ID);
verify(dataReadScope, times(3)).writeCompanyId(any(AdminUserEntity.class));
}
@Test
@DisplayName("写侧:闸门判超管(null)时把 null 传下去,否则超管被锁死在本公司")
void writeGateKeepsTheSuperAdminVerdict() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(null);
ShopKeyUpdateRequest body = new ShopKeyUpdateRequest();
body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a");
controller().update(request, 300L, body);
verify(shopKeyService).update(300L, body, null);
}
/**
* 写侧口径(一期定案):归属由后端从操作者会话推导,请求体不带 company_id,
* 所以 create 这一支<b>不许</b>碰任何读门——碰了就是"建号归谁由前端说了算"。
*/
@Test
@DisplayName("新增:只把操作者 id 交给 service,公司由 service 从会话推导")
void createPassesOnlyTheOperator() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
ShopKeyCreateRequest body = new ShopKeyCreateRequest();
body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a");
body.setRemarkName("备注");
controller().create(request, body);
ArgumentCaptor<Long> operatorId = ArgumentCaptor.forClass(Long.class);
verify(shopKeyService).create(eq(body), operatorId.capture());
assertEquals(OPERATOR_ID, operatorId.getValue());
verifyNoInteractions(dataReadScope);
}
private MockHttpServletRequest login() {
return new MockHttpServletRequest();
}
private AdminUserEntity user() {
AdminUserEntity user = new AdminUserEntity();
user.setId(OPERATOR_ID);
user.setRole("super_admin");
return user;
}
}
@@ -0,0 +1,345 @@
package com.nanri.aiimage.modules.shopkey.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.modules.shopkey.mapper.ShopKeyMapper;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyCreateRequest;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyUpdateRequest;
import com.nanri.aiimage.modules.shopkey.model.entity.ShopKeyEntity;
import com.nanri.aiimage.modules.ziniao.service.ZiniaoApiKeyProvider;
import com.nanri.aiimage.modules.ziniao.service.ZiniaoAuthService;
import com.nanri.aiimage.modules.ziniao.service.ZiniaoShopIndexService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* V150「店铺密钥管理按公司区分」的 service 侧闸门。
*
* <p>钉的是三件事,每一件都对应一种"接口 200、页面看不出来"的静默形状:</p>
* <ol>
* <li>读范围:{@code companyId} 非空时查询条件里必须真的出现 {@code company_id =},为空时一个条件都不许加。
* 只钉正向等于放行"永远筛第 1 家",只钉反向等于放行"超管被锁死在本公司"。</li>
* <li>写归属:{@code create} 的 {@code company_id} 由<b>操作者会话</b>推导,取不到公司时必须抛而不是落 null
* 让 {@code DEFAULT 1} 静默兜住——那正是本仓一期点名要消灭的"归属失真且不报错"。</li>
* <li>写闸门:跨公司的行必须被 {@code assertSameCompany} 拦下,且拦下之后<b>后面的动作一个都不许发生</b>
* ({@code updateById}/{@code deleteById}/出网探测)。读侧已经收窄而写侧不收窄="藏起来的密钥照样能删"。</li>
* </ol>
*
* <p>{@code CompanyScopeSupport} 用<b>真实现</b>(只 mock 它的 {@code AdminUserMapper}):
* {@code requireCompanyId} 的抛与 {@code assertSameCompany} 的比较都是本文件要验的语义,
* mock 掉等于把闸门本身换成"永远通过"的桩。</p>
*/
@ExtendWith(MockitoExtension.class)
class ShopKeyServiceCompanyScopeTest {
private static final Long OPERATOR_ID = 11L;
private static final Long OWN_COMPANY = 2L;
private static final Long OTHER_COMPANY = 1L;
private static final long ROW_ID = 300L;
@Mock
private ShopKeyMapper shopKeyMapper;
@Mock
private ZiniaoShopIndexService ziniaoShopIndexService;
@Mock
private ZiniaoApiKeyProvider ziniaoApiKeyProvider;
@Mock
private ZiniaoAuthService ziniaoAuthService;
@Mock
private AdminUserMapper adminUserMapper;
private ShopKeyService service;
@BeforeEach
@SuppressWarnings({"unchecked", "rawtypes"})
void setUp() {
// LambdaQueryWrapper 要把 ShopKeyEntity::getCompanyId 解析成列名,靠的是 MP 解析过的 TableInfo;
// 不先 initTableInfo 时断言打在"根本没渲染出来"的空串上,那是一枝恒绿的假断言。
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), ShopKeyEntity.class);
service = new ShopKeyService(shopKeyMapper, ziniaoShopIndexService, ziniaoApiKeyProvider,
ziniaoAuthService, new CompanyScopeSupport(adminUserMapper));
}
// -------------------------------------------------------------- 读范围
@Test
@DisplayName("V150 加的列就是代码读写的那一列:companyId → company_id")
void entityMapsCompanyIdToTheColumnTheMigrationAdds() {
TableInfo tableInfo = TableInfoHelper.getTableInfo(ShopKeyEntity.class);
assertThat(tableInfo.getTableName()).isEqualTo("biz_shop_key");
assertThat(tableInfo.getFieldList().stream()
.filter(field -> "companyId".equals(field.getProperty()))
.map(TableFieldInfo::getColumn)
.collect(Collectors.toList()))
.as("实体必须有 companyId 字段且解析到 company_id:列名对不上时 WHERE 与 INSERT 一起打到不存在的列")
.containsExactly("company_id");
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void readScopeAddsTheCompanyCondition() {
stubPageQueries();
service.page(1L, 15L, OWN_COMPANY);
LambdaQueryWrapper<ShopKeyEntity> query = capturedCountQuery();
// 钉成等值而不是 contains("company"):把条件写成 company_id IS NOT NULL 也含 "company",
// 而那种写法在第 2 家的 tab 上会把第 1 家的行一起放出来。
assertThat(query.getSqlSegment()).contains("company_id =");
assertThat(query.getParamNameValuePairs()).containsValue(OWN_COMPANY);
}
@Test
void readScopeNullMeansUnfilteredAndNothingIsSubstituted() {
stubPageQueries();
service.page(1L, 15L, null);
// 与上一条对照才有意义:null 是超管「不筛」的判定,这里补一个默认公司就把超管锁死在本公司,
// 而"切 tab 数字不动"的报障会重新出现。
LambdaQueryWrapper<ShopKeyEntity> query = capturedCountQuery();
assertThat(query.getSqlSegment()).doesNotContain("company_id");
assertThat(query.getParamNameValuePairs()).isEmpty();
}
// -------------------------------------------------------------- 写归属
@Test
void createAttributesTheRowToTheOperatorCompanyNotToTheRequestBody() {
stubInsertAndReload(ROW_ID, OWN_COMPANY);
when(adminUserMapper.selectById(OPERATOR_ID)).thenReturn(operatorInCompany(OWN_COMPANY));
service.create(createRequest(), OPERATOR_ID);
ArgumentCaptor<ShopKeyEntity> inserted = ArgumentCaptor.forClass(ShopKeyEntity.class);
verify(shopKeyMapper).insert(inserted.capture());
assertThat(inserted.getValue().getCompanyId()).isEqualTo(OWN_COMPANY);
}
/**
* 请求体里根本没有 company_id 这个字段(一期定案:归属由后端从会话推导)。
* 这一支钉的是"别给 DTO 加一个 company_id 就完事"——加了之后前端传什么算什么,
* 而 {@code ShopKeyController.create} 不读任何门,归属就成了可写字段。
*/
@Test
@DisplayName("请求体不许带归属字段:create/update 两个 DTO 都不该有 companyId")
void requestDtoCarriesNoCompanyField() {
for (Class<?> dto : List.of(ShopKeyCreateRequest.class, ShopKeyUpdateRequest.class)) {
List<String> fields = Arrays.stream(dto.getDeclaredFields())
.map(field -> field.getName())
.collect(Collectors.toList());
assertThat(fields)
.as(dto.getSimpleName() + " 一旦出现 companyId,归属就从「后端按会话推导」变成「前端说了算」")
.doesNotContain("companyId")
.doesNotContain("company_id");
}
}
@Test
@DisplayName("操作者没有所属公司:抛,且一行都不许落库(不许让 DEFAULT 1 静默兜住)")
void createRefusesWhenTheOperatorHasNoCompany() {
when(adminUserMapper.selectById(OPERATOR_ID)).thenReturn(operatorInCompany(null));
assertThatThrownBy(() -> service.create(createRequest(), OPERATOR_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("没有所属公司");
verify(shopKeyMapper, never()).insert(any(ShopKeyEntity.class));
}
// -------------------------------------------------------------- 写闸门
@Test
@DisplayName("更新别家公司的密钥:403 且 updateById 一次都不许发生")
void updateRefusesAnotherCompanysRow() {
stubSelectById(row(ROW_ID, OTHER_COMPANY));
assertThatThrownBy(() -> service.update(ROW_ID, updateRequest(), OWN_COMPANY))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("别家公司的紫鸟令牌");
verify(shopKeyMapper, never()).updateById(any(ShopKeyEntity.class));
}
@Test
@DisplayName("删除别家公司的密钥:403 且 deleteById 一次都不许发生")
void deleteRefusesAnotherCompanysRow() {
stubSelectById(row(ROW_ID, OTHER_COMPANY));
assertThatThrownBy(() -> service.delete(ROW_ID, OWN_COMPANY))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("别家公司的紫鸟令牌");
verify(shopKeyMapper, never()).deleteById(anyLong());
}
/**
* 手动白名单检测会<b>真的出网</b>(打一次紫鸟接口):跨公司拦不住的话,代价不只是"看到别家的行",
* 而是用别家的令牌消耗别家的上游配额、并把别家那行的失败计数改着玩。
*/
@Test
@DisplayName("检测别家公司密钥的白名单:403 且一次出网探测都不发")
void whitelistProbeRefusesAnotherCompanysRow() {
stubSelectById(row(ROW_ID, OTHER_COMPANY));
assertThatThrownBy(() -> service.checkWhitelist(ROW_ID, OWN_COMPANY))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("别家公司的紫鸟令牌");
verify(ziniaoAuthService, never()).probeApiKeyUpstream(anyString());
}
@Test
@DisplayName("同公司的行照常放行:闸门不是把这一页整个锁死")
void sameCompanyRowIsStillWritable() {
ShopKeyEntity existing = row(ROW_ID, OWN_COMPANY);
stubSelectById(existing);
service.delete(ROW_ID, OWN_COMPANY);
verify(shopKeyMapper).deleteById(ROW_ID);
}
@Test
@DisplayName("超管闸门给 null:别家的行也照删(写侧口径与读侧同源,不另立规矩)")
void superAdminGatePassesEveryRow() {
stubSelectById(row(ROW_ID, OTHER_COMPANY));
service.delete(ROW_ID, null);
verify(shopKeyMapper).deleteById(ROW_ID);
}
@Test
@DisplayName("行上没有归属(历史脏行):按跨公司处理拦下,不当成「谁的都不是」放过去")
void rowWithoutCompanyIsTreatedAsForeign() {
stubSelectById(row(ROW_ID, null));
assertThatThrownBy(() -> service.delete(ROW_ID, OWN_COMPANY))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("别家公司的紫鸟令牌");
verify(shopKeyMapper, never()).deleteById(anyLong());
}
// ------------------------------------------------------ 令牌查重的范围
/**
* 令牌查重<b>刻意保持跨公司全局</b>(迁移文件头 §4:同一个令牌在两家公司各存一行会被
* {@code ZiniaoApiKeyProvider} 按令牌并成一条,白名单状态与代理地址互相顶掉)。
*
* <p>这一支是对那条决定的<b>反向钉</b>:将来有人"顺手"把 {@code ensureTokenAvailable} 按
* {@code companyId} 收窄,数据库那把全局唯一键照样会撞 1062,而 service 侧的友好报错先没了 ——
* 症状变成"新增密钥偶发 500"。所以这里钉的是查重的谓词里<b>不许出现 company_id</b>。</p>
*/
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void tokenDedupePredicateStaysGlobal() {
when(adminUserMapper.selectById(OPERATOR_ID)).thenReturn(operatorInCompany(OWN_COMPANY));
when(shopKeyMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(null);
stubInsertAndReload(ROW_ID, OWN_COMPANY);
service.create(createRequest(), OPERATOR_ID);
ArgumentCaptor<LambdaQueryWrapper> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(shopKeyMapper).selectOne(captor.capture());
LambdaQueryWrapper<ShopKeyEntity> query = captor.getValue();
assertThat(query.getSqlSegment()).contains("ziniao_token_hash =");
assertThat(query.getSqlSegment()).doesNotContain("company_id");
}
// ---------------------------------------------------------------- 桩
@SuppressWarnings({"unchecked", "rawtypes"})
private void stubPageQueries() {
when(shopKeyMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(0L);
when(shopKeyMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(List.of());
}
@SuppressWarnings({"unchecked", "rawtypes"})
private LambdaQueryWrapper<ShopKeyEntity> capturedCountQuery() {
ArgumentCaptor<LambdaQueryWrapper> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(shopKeyMapper).selectCount(captor.capture());
return captor.getValue();
}
private void stubSelectById(ShopKeyEntity row) {
when(shopKeyMapper.selectById(ROW_ID)).thenReturn(row);
}
/**
* MP 的真 insert 会把自增主键回填进实体;mock 不会,所以这里用 thenAnswer 补那一步——
* 少了它,{@code create} 结尾的 {@code loadRow(entity.getId())} 会拿着 null 去查,
* 于是"归属落对了"这条断言红在"店铺密钥不存在"上,报的是错原因。
*/
private ShopKeyEntity stubInsertAndReload(Long id, Long companyId) {
ShopKeyEntity stored = row(id, companyId);
when(shopKeyMapper.insert(any(ShopKeyEntity.class))).thenAnswer(invocation -> {
ShopKeyEntity entity = invocation.getArgument(0);
entity.setId(id);
return 1;
});
when(shopKeyMapper.selectById(id)).thenReturn(stored);
return stored;
}
private static ShopKeyEntity row(Long id, Long companyId) {
ShopKeyEntity entity = new ShopKeyEntity();
entity.setId(id);
entity.setCompanyId(companyId);
entity.setZiniaoAccountName("ziniao-account");
entity.setZiniaoToken("old-token");
entity.setZiniaoTokenHash("old-hash");
entity.setIpWhitelistStatus("UNKNOWN");
entity.setIpWhitelistFailCount(0);
return entity;
}
private static AdminUserEntity operatorInCompany(Long companyId) {
AdminUserEntity user = new AdminUserEntity();
user.setId(OPERATOR_ID);
user.setCompanyId(companyId);
return user;
}
private static ShopKeyCreateRequest createRequest() {
ShopKeyCreateRequest request = new ShopKeyCreateRequest();
request.setZiniaoAccountName("ziniao-account");
request.setZiniaoToken("new-token");
return request;
}
private static ShopKeyUpdateRequest updateRequest() {
ShopKeyUpdateRequest request = new ShopKeyUpdateRequest();
request.setZiniaoAccountName("ziniao-account");
request.setZiniaoToken("new-token");
return request;
}
}
@@ -75,8 +75,7 @@ public class SimilarAsinLlmLocalVerify {
// 生产真实类目数据(导出自 biz_product_category),spy 类目服务按 parentId 过滤。
List<com.nanri.aiimage.modules.productcategory.model.entity.ProductCategoryEntity> categories = loadCategories(objectMapper);
ProductCategoryService categoryService = Mockito.spy(new ProductCategoryService(
Mockito.mock(com.nanri.aiimage.modules.productcategory.mapper.ProductCategoryMapper.class),
Mockito.mock(com.nanri.aiimage.common.service.CompanyScopeSupport.class)));
Mockito.mock(com.nanri.aiimage.modules.productcategory.mapper.ProductCategoryMapper.class)));
Mockito.doAnswer(invocation -> {
Long parentId = invocation.getArgument(0);
List<com.nanri.aiimage.modules.productcategory.model.vo.ProductCategoryItemVo> items = categories.stream()