收口(去重库读侧): 按行 company_id 认公司——代导入/上传者已删两族归位

控制方 2026-10-09 截图:admin 在「先锋」tab 代导入的行(company_id=3、
uploader=admin 属公司 1)在先锋 tab 看不见、反而出现在米椿花 tab。读侧
(列表/导出/公司超管)自 V145 起一直按"上传账号"认公司,与写侧(5ccf3c89
起一律显式落 company_id、V154 已摘 DEFAULT)两套口径打架;切换前先把存量
兜底行修对:V156 把组 33/uid=1188(「先锋」,账号已硬删)的 1452 行
company_id 1→3——否则切完它们整批冒给米椿花,且当前正参与米椿花的去重
比对(5ccf3c89 已按 company_id 收窄),先锋自己反而拿不到这批值。

- DataReadScope 新增第五道正门 superAdminScopedCompanyId:与
  superAdminScopedUserIds 同形"只对站点超管收窄",维度从上传账号集换成
  行 company_id;非超管恒 null(不叠那一刀,可见集仍锁在账号/分组上)
- Service applyCompanyScope 由 uploader_user_id IN (成员) 改 eq(company_id);
  company_super_admin 的 wholeCompany 分支同批切换(1206 从此看得到代导入
  行与上传者已删行,例:admin 代导入 14 行 + 组 33 历史 1452 行)
- G2 护栏加第五道门 + 正/负三枚探针;单测新增四条(超管切公司、公司超管
  全公司、门非超管恒 null、service 层 wrapper 两面)

DedupeTotalDataController 的换门接线已随 2a4d15b8(文案批)入库。
影响面(生产只读实查):切后米椿花 tab −14 行、先锋 tab +14+1452 行;
公司超管仅 1206 一个账号。全量 4209 测绿。
This commit is contained in:
2026-10-09 19:48:11 +08:00
parent 282ad7be9f
commit 7c6761bc74
10 changed files with 370 additions and 58 deletions
+1 -1
View File
@@ -25,7 +25,7 @@
`V148__product_category_builtin_owned_by_company.sql`(把 18 行内置类目的归属从共享哨兵 0 改成厦门米椿花 1)从未上线,2026-10-06 控制方点名「商品类目做成共享的,不区分」⇒ 它的口径被 V151 整体推翻,文件连同 `ProductCategoryMigrationV148Test`、`docs/rollback-V148-product-category-builtin-shared.sql` 一起删除。它与 132/133 的区别要写清:**把新迁移编号写回 148 在 Flyway 语义上是可行的**(生产最大值仍是 147,不存在 out-of-order),这里禁它是共树并发的护栏——148 与 149/150 是同一工作区里另一路会话此刻正在引用的号,被删的 `V148` 文件可能被再次写出,而同号两个文件会让 Flyway 启动期报 "Found more than one migration with version 148" ⇒ 两台 java 同时起不来。宁可让 `integerVersionsSequentialFromOne` 的红字出现在测试里,也不把撞号留到运行期发现。因此这三个号都在 `MigrationInventoryTest.RETIRED_HOLES` 里登记。 `V148__product_category_builtin_owned_by_company.sql`(把 18 行内置类目的归属从共享哨兵 0 改成厦门米椿花 1)从未上线,2026-10-06 控制方点名「商品类目做成共享的,不区分」⇒ 它的口径被 V151 整体推翻,文件连同 `ProductCategoryMigrationV148Test`、`docs/rollback-V148-product-category-builtin-shared.sql` 一起删除。它与 132/133 的区别要写清:**把新迁移编号写回 148 在 Flyway 语义上是可行的**(生产最大值仍是 147,不存在 out-of-order),这里禁它是共树并发的护栏——148 与 149/150 是同一工作区里另一路会话此刻正在引用的号,被删的 `V148` 文件可能被再次写出,而同号两个文件会让 Flyway 启动期报 "Found more than one migration with version 148" ⇒ 两台 java 同时起不来。宁可让 `integerVersionsSequentialFromOne` 的红字出现在测试里,也不把撞号留到运行期发现。因此这三个号都在 `MigrationInventoryTest.RETIRED_HOLES` 里登记。
后续新增迁移从 **V156** 起取号(V155 已被 `users_disabled_at` 占用:给 users 加一列可空停用时刻,回滚见 `docs/rollback-V155-users-disabled-at.sql`;V154 已被 `biz_dedupe_total_data_company_id_drop_default` 占用:只摘一列的默认值,回滚见 `docs/rollback-V154-dedupe-company-id-drop-default.sql`。只认"当前最大值 + 1",不要为还没写出来的迁移预留号段——预留会在 1..max 里留洞,`integerVersionsSequentialFromOne` 会红;也不要回填上面那三个洞)。原先挂在 V149 名下的"摘 DEFAULT"待办,`columns` 那条已与 `biz_shop_key` 合并成 **V152** 发出(V150 头注释第 6 段要求"合并成一版发出";发布前的只读取证:`columns` 154 行按公司 52/51/51、`biz_shop_key` 16 行全 company_id=1 且无 NULL,两列 COLUMN_DEFAULT 都是 1)。摘 DEFAULT 这一族到此摘完,最后一条是 **V154**: 后续新增迁移从 **V157** 起取号(V156 已被 `dedupe_total_data_pioneer_backfill` 占用:把组 33/uid=1188「先锋」名下账号已删的 1452 行 `company_id` 从兜底 1 回填到 3,配套读侧按行 company_id 收窄的 JAR 同批上线,回滚见 `docs/rollback-V156-dedupe-pioneer-backfill.sql`;V155 已被 `users_disabled_at` 占用:给 users 加一列可空停用时刻,回滚见 `docs/rollback-V155-users-disabled-at.sql`;V154 已被 `biz_dedupe_total_data_company_id_drop_default` 占用:只摘一列的默认值,回滚见 `docs/rollback-V154-dedupe-company-id-drop-default.sql`。只认"当前最大值 + 1",不要为还没写出来的迁移预留号段——预留会在 1..max 里留洞,`integerVersionsSequentialFromOne` 会红;也不要回填上面那三个洞)。原先挂在 V149 名下的"摘 DEFAULT"待办,`columns` 那条已与 `biz_shop_key` 合并成 **V152** 发出(V150 头注释第 6 段要求"合并成一版发出";发布前的只读取证:`columns` 154 行按公司 52/51/51、`biz_shop_key` 16 行全 company_id=1 且无 NULL,两列 COLUMN_DEFAULT 都是 1)。摘 DEFAULT 这一族到此摘完,最后一条是 **V154**:
- `ALTER TABLE biz_dedupe_total_data ALTER COLUMN company_id DROP DEFAULT;` —— 已作为 **V154** 发出。V152 当年把它留在门外的前提是"先修写侧、上线并验证真实导入之后才谈摘",2026-10-09 只读探针(运维仓 `scripts/_probe_dedupe_default.py`,主机A,零写入)逐条对上:哨兵四张表里只剩这张仍带 DEFAULT 1(users / biz_shop_key / columns 的 COLUMN_DEFAULT 均为空);归属分布 company_id=1 共 546,344 行、=3 共 8,125 行,**没有 0 也没有 NULL**;孤儿归属 0 行;写侧显式落值那版上线后真实导入 29,555 行(2026-10-07 09:48:38 → 2026-10-08 23:57:51)。⚠ 本表批量导入走 `INSERT IGNORE`:在生产 sql_mode(实查含 STRICT_TRANS_TABLES)下省略该列不会撞 1364,而是被降级成 warning 并落成隐式默认 **0**——0 不属于任何公司,行插得进去但对所有公司隐形,比"静默归第 1 家"更难发现。⇒ **顺序必须是先上带 Java 闸门的 jar,再让本迁移随同一版生效**;闸门=`DedupeTotalDataService.requireCompanyAttribution`(接在 create 与 insertImportBatch 两条写通道上),用例 `DedupeTotalDataWriteAttributionTest` 4 例,其中接线钉按行首语句数调用点==2(避开 javadoc 同名提及那个坑)。 - `ALTER TABLE biz_dedupe_total_data ALTER COLUMN company_id DROP DEFAULT;` —— 已作为 **V154** 发出。V152 当年把它留在门外的前提是"先修写侧、上线并验证真实导入之后才谈摘",2026-10-09 只读探针(运维仓 `scripts/_probe_dedupe_default.py`,主机A,零写入)逐条对上:哨兵四张表里只剩这张仍带 DEFAULT 1(users / biz_shop_key / columns 的 COLUMN_DEFAULT 均为空);归属分布 company_id=1 共 546,344 行、=3 共 8,125 行,**没有 0 也没有 NULL**;孤儿归属 0 行;写侧显式落值那版上线后真实导入 29,555 行(2026-10-07 09:48:38 → 2026-10-08 23:57:51)。⚠ 本表批量导入走 `INSERT IGNORE`:在生产 sql_mode(实查含 STRICT_TRANS_TABLES)下省略该列不会撞 1364,而是被降级成 warning 并落成隐式默认 **0**——0 不属于任何公司,行插得进去但对所有公司隐形,比"静默归第 1 家"更难发现。⇒ **顺序必须是先上带 Java 闸门的 jar,再让本迁移随同一版生效**;闸门=`DedupeTotalDataService.requireCompanyAttribution`(接在 create 与 insertImportBatch 两条写通道上),用例 `DedupeTotalDataWriteAttributionTest` 4 例,其中接线钉按行首语句数调用点==2(避开 javadoc 同名提及那个坑)。
@@ -0,0 +1,31 @@
-- 回滚 V156(人工补丁,不放进 src/main/resources/db/——那里是 Flyway 扫描路径,
-- 任何 V*.sql 都会在应用下次启动时自动执行;把回滚编成版本化迁移等于让"决定回滚"这件事
-- 在没有人工执行的情况下自己发生)。
--
-- 触发场景:V156 把组 33/uid=1188(「先锋」)的 1452 行 company_id 从 1 回填到 3。
-- 只有一种情况需要回滚本数据:控制方改判这 1452 行不属于先锋-团队。
-- 仅仅"读侧切换的 jar 有问题要回滚"【不需要】动数据——旧读侧按上传账号认公司,
-- 对这批 uploader 已删的行本来就不显示(company_id 是 1 还是 3 都看不见),
-- 但**去重比对**(39de5035 已按 company_id)会跟着数据走:回滚数据 = 米椿花去重
-- 重新吃到这 1452 个先锋 ASIN、先锋丢值,所以数据回滚必须与 jar 回滚同批做,
-- 且回滚前先确认"改判"是真的(不是又一次误判归属)。
--
-- 执行顺序(两台都要,中间不停服会混版):
-- 1) 停两台应用(docker stop java-server)
-- 2) 在 aiimage 库执行下面的反向 UPDATE
-- 3) DELETE FROM flyway_schema_history WHERE version = '156';
-- 4) 回滚 jar 到上一版(读侧按上传账号的版本)
-- 5) 起两台,确认 health=200
-- 6) 复查:
-- SELECT company_id, COUNT(*) FROM biz_dedupe_total_data
-- WHERE uploader_user_id = 1188 GROUP BY company_id;
-- 期望回到一行:1 | 1452。
--
-- 反向判据与 V156 原文一一对应(uploader_user_id=1188 AND group_id=33),
-- company_id=3 限定保证重跑是 no-op;只回滚这一个精确集,不扩大射程。
UPDATE `biz_dedupe_total_data`
SET `company_id` = 1
WHERE `uploader_user_id` = 1188
AND `group_id` = 33
AND `company_id` = 3;
@@ -47,6 +47,27 @@ public class DataReadScope {
: null; : null;
} }
/**
* 公司 tab 的<b>行级</b>归属收窄:{@code null} = 不筛,正数 = 该表按行自己的 {@code company_id} 列筛。
*
* <p>与 {@link #superAdminScopedUserIds} 平行(同样只在站点超管身上收窄、其余一律 {@code null}),
* 区别是收窄维度:那个给的是"上传账号集合",这个给的是"行归属的公司 id"。适用于把归属
* <b>物化到行上</b>的表——去重库 {@code biz_dedupe_total_data}(V145 加列、写侧 39de5035 起
* 一律显式落值、V154 摘 DEFAULT)。该表此前按上传账号推导公司,2026-10-09 控制方截图暴露出
* 两类错归:超管代导入的行(company_id=操作 tab 的公司、uploader=超管自己)在目标公司的 tab
* 看不见、却出现在超管自己那一家;上传账号被硬删的行(JOIN 不上任何成员集)在每一个 tab 都
* 看不见。写侧与库唯一键(uk_company_data_value)都已经是 company_id 口径,读侧在此对齐。</p>
*
* <p>非超管仍返回 {@code null}(不叠这一层),纪律与 {@code readScope} 非超管分支一致:
* 非超管的可见集锁在自己的账号/分组上,公司维度由会话独家决定;在这一层再加一刀
* company_id 会把"靠分组可见、而行列值尚未一致"的历史行静默删掉。</p>
*/
public Long superAdminScopedCompanyId(AdminUserEntity operator, Long requestedCompanyId) {
return isPlatformSuperAdmin(operator)
? (requestedCompanyId != null && requestedCompanyId > 0 ? requestedCompanyId : null)
: null;
}
public ReadScope readScope(AdminUserEntity operator, Long requestedCompanyId) { public ReadScope readScope(AdminUserEntity operator, Long requestedCompanyId) {
Long companyId = requestedCompanyId != null && requestedCompanyId > 0 ? requestedCompanyId : null; Long companyId = requestedCompanyId != null && requestedCompanyId > 0 ? requestedCompanyId : null;
if (isPlatformSuperAdmin(operator)) { if (isPlatformSuperAdmin(operator)) {
@@ -172,12 +172,12 @@ public class DedupeTotalDataService {
/** /**
* @param lastId keyset 游标(上一页返回的 nextLastId);非空时忽略 page 偏移, * @param lastId keyset 游标(上一页返回的 nextLastId);非空时忽略 page 偏移,
* 直接按 id 倒序取"比它小"的一页,避免深分页 offset 扫索引的代价 * 直接按 id 倒序取"比它小"的一页,避免深分页 offset 扫索引的代价
* @param companyMemberIds 公司 tab 收窄后的成员账号集({@code DataReadScope} 给出); * @param scopedCompanyId 公司 tab 收窄后的公司 id({@code DataReadScope#superAdminScopedCompanyId} 给出);
* null = 不筛(超管没选公司 / 非超管走会话范围) * null = 不筛(超管没选公司 / 非超管走会话范围)
*/ */
public DedupeTotalDataPageVo page(long page, long pageSize, String keyword, String username, public DedupeTotalDataPageVo page(long page, long pageSize, String keyword, String username,
LocalDate startDate, LocalDate endDate, Long groupId, String country, LocalDate startDate, LocalDate endDate, Long groupId, String country,
Long lastId, Long operatorId, List<Long> companyMemberIds) { Long lastId, Long operatorId, Long scopedCompanyId) {
if (startDate != null && endDate != null && startDate.isAfter(endDate)) { if (startDate != null && endDate != null && startDate.isAfter(endDate)) {
throw new BusinessException("开始日期不能晚于结束日期"); throw new BusinessException("开始日期不能晚于结束日期");
} }
@@ -202,7 +202,7 @@ public class DedupeTotalDataService {
endDate == null ? null : endDate.plusDays(1).atStartOfDay()) endDate == null ? null : endDate.plusDays(1).atStartOfDay())
.orderByDesc(DedupeTotalDataEntity::getId); .orderByDesc(DedupeTotalDataEntity::getId);
applyGroupScope(query, scope, groupId); applyGroupScope(query, scope, groupId);
applyCompanyScope(query, companyMemberIds); applyCompanyScope(query, scopedCompanyId);
Long total = dedupeTotalDataMapper.selectCount(query); Long total = dedupeTotalDataMapper.selectCount(query);
boolean keyset = lastId != null && lastId > 0; boolean keyset = lastId != null && lastId > 0;
if (keyset) { if (keyset) {
@@ -275,7 +275,7 @@ public class DedupeTotalDataService {
Long groupId, Long groupId,
String country, String country,
Long operatorId, Long operatorId,
List<Long> companyMemberIds) { Long scopedCompanyId) {
if (outputStream == null) { if (outputStream == null) {
throw new BusinessException("导出输出流不能为空"); throw new BusinessException("导出输出流不能为空");
} }
@@ -285,7 +285,7 @@ public class DedupeTotalDataService {
String safeUsername = username == null ? "" : username.trim(); String safeUsername = username == null ? "" : username.trim();
AccessScope scope = resolveAccessScope(operatorId); AccessScope scope = resolveAccessScope(operatorId);
buildExportWorkbook(outputStream, safeUsername, startDate, endDate, groupId, country, scope, false, buildExportWorkbook(outputStream, safeUsername, startDate, endDate, groupId, country, scope, false,
companyMemberIds); scopedCompanyId);
} }
public void writeMonthlyZipExport(OutputStream outputStream, public void writeMonthlyZipExport(OutputStream outputStream,
@@ -314,12 +314,12 @@ public class DedupeTotalDataService {
Long groupId, Long groupId,
String country, String country,
Long operatorId, Long operatorId,
List<Long> companyMemberIds) { Long scopedCompanyId) {
if (outputStream == null) { if (outputStream == null) {
throw new BusinessException("导出文件写入失败,请稍后重试"); throw new BusinessException("导出文件写入失败,请稍后重试");
} }
if (startDate == null || endDate == null || YearMonth.from(startDate).equals(YearMonth.from(endDate))) { if (startDate == null || endDate == null || YearMonth.from(startDate).equals(YearMonth.from(endDate))) {
writeExport(outputStream, username, startDate, endDate, groupId, country, operatorId, companyMemberIds); writeExport(outputStream, username, startDate, endDate, groupId, country, operatorId, scopedCompanyId);
return; return;
} }
if (startDate.isAfter(endDate)) { if (startDate.isAfter(endDate)) {
@@ -343,7 +343,7 @@ public class DedupeTotalDataService {
LocalDate entryEndDate = endDate.isBefore(monthEnd) ? endDate : monthEnd; LocalDate entryEndDate = endDate.isBefore(monthEnd) ? endDate : monthEnd;
zipOutputStream.putNextEntry(new ZipEntry(monthlyExportEntryName(currentMonth))); zipOutputStream.putNextEntry(new ZipEntry(monthlyExportEntryName(currentMonth)));
buildExportWorkbook(zipOutputStream, safeUsername, entryStartDate, entryEndDate, buildExportWorkbook(zipOutputStream, safeUsername, entryStartDate, entryEndDate,
groupId, safeCountry, scope, groupPrevalidated, companyMemberIds); groupId, safeCountry, scope, groupPrevalidated, scopedCompanyId);
zipOutputStream.closeEntry(); zipOutputStream.closeEntry();
currentMonth = currentMonth.plusMonths(1); currentMonth = currentMonth.plusMonths(1);
} }
@@ -373,7 +373,7 @@ public class DedupeTotalDataService {
String country, String country,
AccessScope scope, AccessScope scope,
boolean groupPrevalidated, boolean groupPrevalidated,
List<Long> companyMemberIds) { Long scopedCompanyId) {
try (SXSSFWorkbook workbook = new SXSSFWorkbook(100)) { try (SXSSFWorkbook workbook = new SXSSFWorkbook(100)) {
Sheet sheet = workbook.createSheet("DedupeTotalData"); Sheet sheet = workbook.createSheet("DedupeTotalData");
Row header = sheet.createRow(0); Row header = sheet.createRow(0);
@@ -387,7 +387,7 @@ public class DedupeTotalDataService {
int rowIndex = 1; int rowIndex = 1;
while (true) { while (true) {
LambdaQueryWrapper<DedupeTotalDataEntity> pageQuery = buildExportQuery( LambdaQueryWrapper<DedupeTotalDataEntity> pageQuery = buildExportQuery(
username, startDate, endDate, groupId, country, scope, groupPrevalidated, companyMemberIds); username, startDate, endDate, groupId, country, scope, groupPrevalidated, scopedCompanyId);
if (lastId != null) { if (lastId != null) {
pageQuery.lt(DedupeTotalDataEntity::getId, lastId); pageQuery.lt(DedupeTotalDataEntity::getId, lastId);
} }
@@ -445,7 +445,7 @@ public class DedupeTotalDataService {
String country, String country,
AccessScope scope, AccessScope scope,
boolean groupPrevalidated, boolean groupPrevalidated,
List<Long> companyMemberIds) { Long scopedCompanyId) {
String safeUsername = username == null ? "" : username.trim(); String safeUsername = username == null ? "" : username.trim();
String safeCountry = country == null ? "" : country.trim(); String safeCountry = country == null ? "" : country.trim();
LambdaQueryWrapper<DedupeTotalDataEntity> query = new LambdaQueryWrapper<DedupeTotalDataEntity>() LambdaQueryWrapper<DedupeTotalDataEntity> query = new LambdaQueryWrapper<DedupeTotalDataEntity>()
@@ -459,7 +459,7 @@ public class DedupeTotalDataService {
endDate == null ? null : endDate.plusDays(1).atStartOfDay()) endDate == null ? null : endDate.plusDays(1).atStartOfDay())
.orderByDesc(DedupeTotalDataEntity::getId); .orderByDesc(DedupeTotalDataEntity::getId);
applyGroupScope(query, scope, groupId, groupPrevalidated); applyGroupScope(query, scope, groupId, groupPrevalidated);
applyCompanyScope(query, companyMemberIds); applyCompanyScope(query, scopedCompanyId);
return query; return query;
} }
@@ -1258,7 +1258,7 @@ public class DedupeTotalDataService {
private AccessScope resolveAccessScope(Long operatorId) { private AccessScope resolveAccessScope(Long operatorId) {
AdminUserEntity operator = getOperator(operatorId); AdminUserEntity operator = getOperator(operatorId);
if (isSuperAdmin(operator)) { if (isSuperAdmin(operator)) {
return new AccessScope(true, Set.of(), Set.of(), false); return new AccessScope(true, Set.of(), Set.of(), false, null);
} }
if ("company_super_admin".equals(operator.getRole() == null if ("company_super_admin".equals(operator.getRole() == null
? "" : operator.getRole().trim().toLowerCase(Locale.ROOT))) { ? "" : operator.getRole().trim().toLowerCase(Locale.ROOT))) {
@@ -1273,7 +1273,8 @@ public class DedupeTotalDataService {
// allUsers 与 groupIds 两样,读侧才走 wholeCompany 那一支。这里留空集的表现是 // allUsers 与 groupIds 两样,读侧才走 wholeCompany 那一支。这里留空集的表现是
// 「下拉选得到自己公司的分组、提交必 403」,而 403 是 HTTP 状态不是中文文案。 // 「下拉选得到自己公司的分组、提交必 403」,而 403 是 HTTP 状态不是中文文案。
Set<Long> companyGroupIds = shopManageGroupService.listCompanyGroupIds(List.copyOf(companyUserIds)); Set<Long> companyGroupIds = shopManageGroupService.listCompanyGroupIds(List.copyOf(companyUserIds));
return new AccessScope(false, companyGroupIds, Set.copyOf(companyUserIds), true); return new AccessScope(false, companyGroupIds, Set.copyOf(companyUserIds), true,
operator.getCompanyId());
} }
List<Long> accessibleGroupIds = shopManageGroupMapper.selectAccessibleGroupIds(operator.getId()); List<Long> accessibleGroupIds = shopManageGroupMapper.selectAccessibleGroupIds(operator.getId());
LinkedHashSet<Long> visibleUserIds = new LinkedHashSet<>(); LinkedHashSet<Long> visibleUserIds = new LinkedHashSet<>();
@@ -1296,7 +1297,8 @@ public class DedupeTotalDataService {
false, false,
Set.copyOf(accessibleGroupIds == null ? List.of() : accessibleGroupIds), Set.copyOf(accessibleGroupIds == null ? List.of() : accessibleGroupIds),
Set.copyOf(visibleUserIds), Set.copyOf(visibleUserIds),
false); false,
null);
} }
private void applyGroupScope(LambdaQueryWrapper<DedupeTotalDataEntity> query, private void applyGroupScope(LambdaQueryWrapper<DedupeTotalDataEntity> query,
@@ -1317,8 +1319,16 @@ public class DedupeTotalDataService {
return; return;
} }
if (scope.wholeCompany()) { if (scope.wholeCompany()) {
// 公司超管:整家公司成员上传的行全可见,不再按 group_id 切 // 公司超管:整家公司名下的行全可见,不再按 group_id 切。
query.in(DedupeTotalDataEntity::getUploaderUserId, scope.userIds()); // 2026-10-09 与 tab 收窄同批从"成员上传"切到行 company_id:原口径漏
// 「代导入行」(uploader 不属本公司)与「上传账号已删的行」(JOIN 不上成员集),
// 先锋公司超管(uid=1206)对这两族一行都看不到。companyId 空属异常态
// (company_super_admin 必挂公司),给不可能命中的条件而不是"不筛"。
if (scope.companyId() == null) {
query.eq(DedupeTotalDataEntity::getId, -1L);
return;
}
query.eq(DedupeTotalDataEntity::getCompanyId, scope.companyId());
return; return;
} }
query.and(wrapper -> { query.and(wrapper -> {
@@ -1332,24 +1342,22 @@ public class DedupeTotalDataService {
} }
/** /**
* 公司 tab 收窄:本表按「上传账号」认公司——{@code uploader_user_id} 是 NOT NULL(V75 先回灌再收紧), * 公司 tab 收窄:按行自己的 {@code company_id} 筛(V145 物化的列、uk_company_data_value 的第一列)。
* 且有 idx_uploader_user_id_id 可走点查。
* *
* <p>不按 V145 加的 company_id 筛:那一列对 V145 之前的历史行全部是 DEFAULT 兜的 1,没有区分力。 * <p>2026-10-09 从"按上传账号推导"切到这里(控制方截图为证:超管 admin 在「先锋」tab 代导入的
* 写侧现已显式落值(create 与 insertBatchIgnore 都带 company_id),但读侧一旦改用它,历史行会整批归到 * 行 uploader=admin,读侧整批出现在 admin 自己那一家、目标 tab 反而看不到)。切换的历史行风险
* 公司 1——所以那列只供写入留存与 uk_company_data_value 使用,读侧口径维持按上传账号推导。</p> * 已逐项处置:V145 第 2 段迁移当时就按上传账号反推过一遍(非公司 1 账号的行 company_id 已是真值);
* 写侧自 39de5035 起 create/insertBatchIgnore/导入一律显式落值、V154 已摘 DEFAULT,漏传即报错
* 而不会兜进公司 1;剩余一批"上传账号被硬删、归属兜成 1"的历史行(组 33「先锋」,1452 行)
* 由 V156 回填到真实归属。切换后本表读、写、去重比对、唯一键四侧同一口径。</p>
* *
* <p>空集给一条不可能命中的条件而不是"不筛":tab 选了这家公司却看得到全平台,比看不到更坏。</p> * <p>{@code null} = 不筛(超管没选公司 / 非超管走会话范围)。</p>
*/ */
private void applyCompanyScope(LambdaQueryWrapper<DedupeTotalDataEntity> query, List<Long> companyMemberIds) { private void applyCompanyScope(LambdaQueryWrapper<DedupeTotalDataEntity> query, Long scopedCompanyId) {
if (companyMemberIds == null) { if (scopedCompanyId == null) {
return; return;
} }
if (companyMemberIds.isEmpty()) { query.eq(DedupeTotalDataEntity::getCompanyId, scopedCompanyId);
query.eq(DedupeTotalDataEntity::getId, -1L);
return;
}
query.in(DedupeTotalDataEntity::getUploaderUserId, companyMemberIds);
} }
private ShopManageGroupEntity resolveWritableGroup(Long groupId, AdminUserEntity operator) { private ShopManageGroupEntity resolveWritableGroup(Long groupId, AdminUserEntity operator) {
@@ -1524,9 +1532,13 @@ public class DedupeTotalDataService {
/** /**
* @param allUsers 超管直通 * @param allUsers 超管直通
* @param wholeCompany 公司超管:不做分组维度裁剪,userIds = 本公司全体成员, * @param wholeCompany 公司超管:不做分组维度裁剪,查询条件退化为 company_id = companyId
* 查询条件退化为 uploader_user_id IN (成员)——公司超管的"组"就是整家公司 * (2026-10-09 起按行归属列;见 {@code applyGroupScope} 该分支的切换理由)。
* 公司超管的"组"就是整家公司;userIds 仅剩写侧闸门(ensureRecordAccess 的
* group_id IS NULL 那一支)在用
* @param companyId 公司超管所属公司;仅 wholeCompany=true 时有值
*/ */
record AccessScope(boolean allUsers, Set<Long> groupIds, Set<Long> userIds, boolean wholeCompany) { record AccessScope(boolean allUsers, Set<Long> groupIds, Set<Long> userIds, boolean wholeCompany,
Long companyId) {
} }
} }
@@ -0,0 +1,74 @@
-- =============================================================
-- 迁移 V156__dedupe_total_data_pioneer_backfill
-- 模板:docs/flyway-migration-template.md
-- 需求:2026-10-09 控制方截图「admin 代导入的行应该在『先锋』tab 下」牵出的存量归属回填。
-- 同批 JAR 把去重库读侧(列表/导出/公司超管)从"按上传账号认公司"切到"按行
-- company_id 认公司"——切换前必须把本文件这一批"账号已删、归属兜成公司 1"的行先修对,
-- 否则切完它们会整批出现在厦门米椿花 tab 下(比今天"谁都看不见"更坏)。
--
-- 1. 变更目的:把组 33「先锋」名下、上传账号已被硬删(uid=1188「先峰」)的 1452 行
-- biz_dedupe_total_data 的 company_id 从兜底值 1(厦门米椿花)回填到 3(先锋-团队)。
--
-- 归属判据(2026-10-09 主机A 业务库只读实查,不是推断):
-- · 组 33 名为「先锋」,创建于 2026-10-03 16:06(**早于公司 3 开通的 10-05 00:27**,
-- 多公司一期前"先锋"团队就在用系统);
-- · 上传账号 1188 用户名「先峰」—— V153 头注释(10-08 客户「先锋-团队」定档那单)
-- 已把「id=33 那行、其组长账号 uid=1188 已被硬删」与先锋团队绑定为同一语境;
-- · 该批行全部由 1188 在 2026-10-05 14:40 ~ 23:23 导入(公司 3 开通当天),
-- 组 33 与 1188 在 biz_dedupe_total_data 里严格同一批(双向差集均为 0 行);
-- · 该批数据只存在于本表:biz_query_asin / biz_shop_manage / biz_skip_price_asin /
-- biz_invalid_asin_data 里挂组 33 的行数全部为 0;
-- · 内容为 UK 1427 行 + DE 25 行,与先锋做英/德站点吻合。
-- 本文件**不碰** biz_shop_manage_group 的 company_id(组 33/34 保持 NULL):
-- V153 第 1 段明文定案「孤儿推不出归属,硬塞一个公司号就是归属失真」——组表那两行
-- 不参与任何读写判据(列表按组长收窄、NULL 在唯一索引里不互相挡),保持现状。
--
-- 为什么现在做(不做会怎样):写侧"五处收口"(39de5035,10-09 17:57)已把去重执行 /
-- 导入预检 / 手工新增重名 / 删除导入 / 采集结果过滤统一改按 company_id 收窄——这 1452 行
-- 当前正以 company_id=1 参与**厦门米椿花**的去重比对(米椿花采集结果里这些 ASIN 会被
-- 误判「已存在」而过滤掉),同时先锋自己去重时拿不到这 1452 个值;本批读侧切换后还会
-- 在米椿花 tab 整批可见。回填到 3 一次性解决三面。
--
-- 2. 影响表与数据量:只有 `biz_dedupe_total_data`,WHERE 命中 **1452 行**(实查)。
-- 唯一键预检:这批行迁到 company 3 后与公司 3 现存值(8139 行)**零交集**——
-- `JOIN ... ON a.data_value = b.data_value AND b.company_id = 3 WHERE a.group_id = 33`
-- 返回 0 行,`uk_company_data_value` 不会撞键。company 1 侧是本行移除、不涉唯一键。
-- 表 55 万行,本文件只有这一条 UPDATE,无任何 DDL、无列变更、无索引变更。
--
-- 3. 锁表风险:低。WHERE 由 `uploader_user_id = 1188`(有 idx_uploader_user_id_id 前缀)
-- 落点查,叠 `group_id = 33 AND company_id = 1` 过滤,扫描面是"该账号名下的行",
-- 不是全表;命中的 1452 行做一次 UPDATE(行锁,毫秒级)。不 JOIN 大表、不写回其他列
-- (updated_at 由 ON UPDATE 自行维护,属预期)。重跑是 no-op(见第 4 段幂等限定)。
--
-- 4. 幂等:`AND company_id = 1` 重跑零命中。MySQL 的 DML 进事务,失败自动回滚,无需 repair。
--
-- 5. 验证 SQL(迁移后跑,不许只看启动日志的 Successfully applied):
-- SELECT company_id, COUNT(*) FROM biz_dedupe_total_data
-- WHERE uploader_user_id = 1188 GROUP BY company_id;
-- -> 期望只剩一行:3 | 1452
-- SELECT COUNT(*) FROM biz_dedupe_total_data WHERE group_id = 33 AND company_id = 1;
-- -> 期望 0(全部迁走)
-- SELECT COUNT(*) FROM biz_dedupe_total_data d JOIN users u ON u.id = d.uploader_user_id
-- WHERE u.company_id <> d.company_id;
-- -> 期望 14(2026-10-09 19:12 admin 代导入那批,company_id=3 正确但 uploader 归属
-- 公司 1——那是"上传者≠数据归属"的合法形态,读侧已按公司列收窄,不是脏数据;
-- 迁移前该值为 14+1452=1466)
--
-- 6. 回滚步骤:反向 UPDATE(人工执行,不写成版本化回滚——V145 同款纪律):
-- UPDATE biz_dedupe_total_data SET company_id = 1
-- WHERE uploader_user_id = 1188 AND group_id = 33 AND company_id = 3;
-- 注意:回滚必须与 JAR 回滚同批——读侧按 company_id 的 JAR 在跑时就回滚数据,
-- 1452 行会立刻整批出现在米椿花 tab 且参与米椿花的去重比对。
--
-- 7. 上线窗口:随 V156 所属 JAR 双节点同窗执行(Flyway 只在先到的一台上跑)。
-- 业务低峰即可,无长事务等待;与读侧切换的 JAR 必须同批——只上迁移不上 JAR,
-- 1452 行在旧读侧(按账号)依旧谁都看不见(无害但不完整);只上 JAR 不上迁移,
-- 米椿花 tab 会多出 1452 行别家数据(有害),所以先到的一台跑完迁移、第二台
-- 启动前数据已就位,混合窗口内安全。
-- =============================================================
UPDATE `biz_dedupe_total_data`
SET `company_id` = 3
WHERE `uploader_user_id` = 1188
AND `group_id` = 33
AND `company_id` = 1;
@@ -113,20 +113,22 @@ import org.junit.jupiter.api.Test;
* D 的代价与射程一并交代:非 {@code Long} 型公司参数取不到绑定名,判红并报形状;而"handler 之外的私有 * D 的代价与射程一并交代:非 {@code Long} 型公司参数取不到绑定名,判红并报形状;而"handler 之外的私有
* 收口方法里把公司参数硬写成 {@code null}"这一族 D 看不见——块边界止于该 handler 自己的闭括号 * 收口方法里把公司参数硬写成 {@code null}"这一族 D 看不见——块边界止于该 handler 自己的闭括号
* (第 7 条),{@code AdminImageVideoTaskController.scopeOf} 正是它,那一处是<b>故意</b>传 null 的。</li> * (第 7 条),{@code AdminImageVideoTaskController.scopeOf} 正是它,那一处是<b>故意</b>传 null 的。</li>
* <li><b>几条正门,一套判据</b>(批次 2/3 新增;10-06 复验后加第二道,批次 6 加第三道,10-07 三期加第四道)。 * <li><b>几条正门,一套判据</b>(批次 2/3 新增;10-06 复验后加第二道,批次 6 加第三道,10-07 三期加第四道,
* 出口现在有四个: * 10-09 去重库口径切换加第五道)。出口现在有五个:
* {@code readScope(} 按账号集合给范围(去重库、查询 ASIN、最低价 ASIN、历史、视频), * {@code readScope(} 按账号集合给范围(查询 ASIN、最低价 ASIN、历史、视频、店铺管理、设备日志等),
* {@code readCompanyIdOrOwn(} 给"归属物化成 {@code company_id} 列、可见集又不靠账号/分组"的表 * {@code readCompanyIdOrOwn(} 给"归属物化成 {@code company_id} 列、可见集又不靠账号/分组"的表
* (今天只有店铺密钥,V150 起每公司一套),{@code resolveScopeCompanyId(} 给菜单字典那一棵树一套 * (今天只有店铺密钥,V150 起每公司一套),{@code resolveScopeCompanyId(} 给菜单字典那一棵树一套
* (V149 起,读写共用同一判据,见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由), * (V149 起,读写共用同一判据,见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由),
* {@code superAdminScopedUserIds(} 给看板那一族"只在站点超管身上收窄"的形状 * {@code superAdminScopedUserIds(} 给看板那一族"只在站点超管身上收窄"的形状
* (见 {@link #SUPER_SCOPED_USER_IDS_CALL} 的理由)。 * (见 {@link #SUPER_SCOPED_USER_IDS_CALL} 的理由),
* 四道门共用 A/B/C/D 四条判据: * {@code superAdminScopedCompanyId(} 给去重库"同样只对超管收窄、但维度是行 company_id"的形状
* (见 {@link #SUPER_SCOPED_COMPANY_ID_CALL} 的理由)。
* 五道门共用 A/B/C/D 四条判据:
* {@link #SCOPE_DOORS} 供 A 与 C 逐条跑,{@link #SCOPE_CALLEE_NAMES} 供 D 认被调名, * {@link #SCOPE_DOORS} 供 A 与 C 逐条跑,{@link #SCOPE_CALLEE_NAMES} 供 D 认被调名,
* <b>名单只写一次</b>(红因消息与自检断言咬的是拼出来的同一个标签,两处各写一遍会随哈希顺序漂红)。 * <b>名单只写一次</b>(红因消息与自检断言咬的是拼出来的同一个标签,两处各写一遍会随哈希顺序漂红)。
* 每条门各自带能红/能绿两向探针(全局约束 15 那把尺子):只在 {@code readScope} 上验过, * 每条门各自带能红/能绿两向探针(全局约束 15 那把尺子):只在 {@code readScope} 上验过,
* 等于第二道门上的返回值与入参没人看守;第三道门(菜单字典)的三枚 {@code MENU_SCOPE_*} 探针同理, * 等于第二道门上的返回值与入参没人看守;第三道门(菜单字典)的三枚 {@code MENU_SCOPE_*} 探针同理,
* 第四道门的三枚 {@code SUPER_SCOPED_*} 也是照这一条补的。 * 第四、五道门的三枚 {@code SUPER_SCOPED_*} 也是照这一条补的。</li>
* <p>批次 2 时这里还有<b>中间</b>那道 {@code readCompanyId(},服务品牌库 {@code biz_invalid_asin_data} * <p>批次 2 时这里还有<b>中间</b>那道 {@code readCompanyId(},服务品牌库 {@code biz_invalid_asin_data}
* 与商品类目 {@code biz_product_category} 两张物化列表。10-06 控制方把这两页定成全平台共享, * 与商品类目 {@code biz_product_category} 两张物化列表。10-06 控制方把这两页定成全平台共享,
* 方法随之删除 ⇒ 门也从名单一起摘掉:名单里留一门没有实现者的门,等于给"把公司开关再接回那两张表" * 方法随之删除 ⇒ 门也从名单一起摘掉:名单里留一门没有实现者的门,等于给"把公司开关再接回那两张表"
@@ -257,8 +259,20 @@ class CompanyIdParamGoesThroughReadScopeTest {
* (全局约束 15),所以正/负两向证据在下面各给一遍。</p> * (全局约束 15),所以正/负两向证据在下面各给一遍。</p>
*/ */
private static final String SUPER_SCOPED_USER_IDS_CALL = "superAdminScopedUserIds("; private static final String SUPER_SCOPED_USER_IDS_CALL = "superAdminScopedUserIds(";
/**
* 第五道正门(2026-10-09 去重库读侧口径切换):{@code superAdminScopedCompanyId}。与第四道门同形,
* 收窄维度从"上传账号集合"换成"行归属的公司 id"——去重库的归属自 V145 起物化在
* {@code company_id} 列上(写侧 39de5035 起一律显式落值、V154 摘 DEFAULT),继续按上传账号推导时
* 超管代导入的行会整体归错家(控制方截图:admin 在「先锋」tab 导入的行在先锋 tab 看不见)。
*
* <p>入名单的前提与第二、三、四道门同一条:它只是 {@code DataReadScope} 上的一个方法,
* 不是页里自己写的 if。不加它的话 A 会把去重库那两支合规 handler 判红;只加名字不配探针的话,
* 这道门上的返回值与入参没人看守(全局约束 15),所以正/负两向证据在下面各给一遍。</p>
*/
private static final String SUPER_SCOPED_COMPANY_ID_CALL = "superAdminScopedCompanyId(";
private static final List<String> SCOPE_DOORS = private static final List<String> SCOPE_DOORS =
List.of(READ_SCOPE_CALL, READ_OWN_COMPANY_ID_CALL, RESOLVE_MENU_SCOPE_CALL, SUPER_SCOPED_USER_IDS_CALL); List.of(READ_SCOPE_CALL, READ_OWN_COMPANY_ID_CALL, RESOLVE_MENU_SCOPE_CALL, SUPER_SCOPED_USER_IDS_CALL,
SUPER_SCOPED_COMPANY_ID_CALL);
private static final String EXPLICIT_PARAM_NAME = "name = \"company_id\""; private static final String EXPLICIT_PARAM_NAME = "name = \"company_id\"";
private static final String SNAKE_PARAM = "company_id"; private static final String SNAKE_PARAM = "company_id";
private static final String CAMEL_PARAM = "companyId"; private static final String CAMEL_PARAM = "companyId";
@@ -318,7 +332,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
*/ */
private static final List<String> SCOPE_CALLEE_NAMES = private static final List<String> SCOPE_CALLEE_NAMES =
List.of("readScope", "resolveScope", "readCompanyIdOrOwn", "resolveScopeCompanyId", List.of("readScope", "resolveScope", "readCompanyIdOrOwn", "resolveScopeCompanyId",
"superAdminScopedUserIds"); "superAdminScopedUserIds", "superAdminScopedCompanyId");
private static final Set<String> SCOPE_CALLEES = Set.copyOf(SCOPE_CALLEE_NAMES); private static final Set<String> SCOPE_CALLEES = Set.copyOf(SCOPE_CALLEE_NAMES);
private static final String SCOPE_CALLEE_LABEL = String.join("/", SCOPE_CALLEE_NAMES); private static final String SCOPE_CALLEE_LABEL = String.join("/", SCOPE_CALLEE_NAMES);
@@ -575,6 +589,38 @@ class CompanyIdParamGoesThroughReadScopeTest {
} }
"""; """;
/**
* 第五道正门的<b>正探针</b>(形状逐字抄现网 {@code DedupeTotalDataController.page}):
* 结果接进变量、又作为实参交给 {@code page(…)},公司参数本身进了门 ⇒ C 与 D 都必须判绿。
*/
private static final String SUPER_SCOPED_COMPANY_CAUGHT_PROBE = """
@GetMapping("/probe")
public String superScopedCompanyDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = session.operator();
Long scopedCompanyId = dataReadScope.superAdminScopedCompanyId(operator, companyId);
return String.valueOf(dedupeTotalDataService.page(1L, 15L, null, null, null, null, null, null, null, operatorId, scopedCompanyId));
}
""";
/** 第五道正门的<b>裸语句探针</b>(C 在该门上的"能红"证据):门调了,公司 id 当场丢掉。 */
private static final String SUPER_SCOPED_COMPANY_DISCARD_PROBE = """
@GetMapping("/probe")
public String superScopedCompanyDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
dataReadScope.superAdminScopedCompanyId(operator, companyId);
return "ok";
}
""";
/** 第五道正门的<b>负探针</b>(D 在该门上的存在理由):切了 tab,传进门里的还是 {@code null}。 */
private static final String SUPER_SCOPED_COMPANY_PASSED_NULL_PROBE = """
@GetMapping("/probe")
public String superScopedCompanyDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = session.operator();
Long scopedCompanyId = dataReadScope.superAdminScopedCompanyId(operator, null);
return String.valueOf(dedupeTotalDataService.page(1L, 15L, null, null, null, null, null, null, null, operatorId, scopedCompanyId));
}
""";
/** /**
* 已摘掉那道门的<b>正样本探针</b>(形状抄退回前的 {@code InvalidAsinDataController.page}: * 已摘掉那道门的<b>正样本探针</b>(形状抄退回前的 {@code InvalidAsinDataController.page}:
* 收 {@code company_id} 参数、体内调 {@code readCompanyId})。它现在应当被 A/C/D 三条同时判红—— * 收 {@code company_id} 参数、体内调 {@code readCompanyId})。它现在应当被 A/C/D 三条同时判红——
@@ -787,6 +833,31 @@ class CompanyIdParamGoesThroughReadScopeTest {
.isNotNull() .isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表"); .contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 第五道门(去重库按行 company_id 收窄)同样两向取证:它今天有两个真实消费者
// (DedupeTotalDataController 的 page 与 export)。只把名字加进 SCOPE_DOORS 而不验
// 返回值与入参,这道门就是"名单里有、没人守"——scopedCompanyId 哪天被丢掉或传成 null,
// C 与 D 都不求值,切 tab 又变装饰品。
assertThat(scopeProbeReason(SUPER_SCOPED_COMPANY_CAUGHT_PROBE, "SUPER_SCOPED_COMPANY_CAUGHT_PROBE"))
.as("断言 C 自检(第五道门·正样本):Long scopedCompanyId = superAdminScopedCompanyId(operator, companyId) "
+ "且它进了 page(…) 的实参 ⇒ 判红就是护栏假红")
.isNull();
assertThat(companyIdArgProbeReason(
SUPER_SCOPED_COMPANY_CAUGHT_PROBE, "SUPER_SCOPED_COMPANY_CAUGHT_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第五道门·正样本):companyId 真进了 superAdminScopedCompanyId 的实参表 ⇒ 不许红")
.isNull();
assertThat(scopeProbeReason(SUPER_SCOPED_COMPANY_DISCARD_PROBE, "SUPER_SCOPED_COMPANY_DISCARD_PROBE"))
.as("断言 C 自检(第五道门·负样本):superAdminScopedCompanyId( 写成裸语句、公司 id 当场丢掉 ⇒ 必须判红")
.isNotNull()
.contains("范围算了但没接住");
assertThat(scopeProbeReason(SUPER_SCOPED_COMPANY_PASSED_NULL_PROBE, "SUPER_SCOPED_COMPANY_PASSED_NULL_PROBE"))
.as("断言 D(第五道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 page ⇒ C 判它绿")
.isNull();
assertThat(companyIdArgProbeReason(
SUPER_SCOPED_COMPANY_PASSED_NULL_PROBE, "SUPER_SCOPED_COMPANY_PASSED_NULL_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第五道门·负样本):superAdminScopedCompanyId(operator, null) ⇒ 必须判红")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 已摘掉的那道门不许再接回(全局约束 15 的"能红"方向)。这一族 handler(品牌库、商品类目)现在定案 // 已摘掉的那道门不许再接回(全局约束 15 的"能红"方向)。这一族 handler(品牌库、商品类目)现在定案
// 全平台共享、不再收公司参数 ⇒ 它们已不进 A/C/D 的样本,"哪天有人把 ?company_id= 接回这两张表" // 全平台共享、不再收公司参数 ⇒ 它们已不进 A/C/D 的样本,"哪天有人把 ?company_id= 接回这两张表"
// 只剩这条探针还在求值,而今天真正拦它的是断言 A:C 与 D 在主循环里都以"体内有正门调用"为前提 // 只剩这条探针还在求值,而今天真正拦它的是断言 A:C 与 D 在主循环里都以"体内有正门调用"为前提
@@ -161,6 +161,34 @@ class DataReadScopeTest {
assertThat(dataReadScope.readCompanyIdOrOwn(user(9L, "company_super_admin", 2L), 7L)).isEqualTo(2L); assertThat(dataReadScope.readCompanyIdOrOwn(user(9L, "company_super_admin", 2L), 7L)).isEqualTo(2L);
} }
// ---- 第五道正门 superAdminScopedCompanyId(2026-10-09 去重库读侧口径切换)----
// 与第四道门 superAdminScopedUserIds 同形"只在站点超管身上收窄",区别是收窄维度:
// 那个给"上传账号集合",这个给"行归属的公司 id"(行把归属物化在 company_id 列上的表用)。
// 与非超管相关的关键差异(对照第二道门 readCompanyIdOrOwn):非超管<b>返回 null</b>(不叠),
// 绝不 pin own——去重库非超管的可见集锁在账号/分组上,叠一刀公司会把"靠分组可见"的行静默删掉。
@Test
@DisplayName("第五道门:超管按 tab 走,0/负数与非空归一化成「没选公司」")
void superScopedCompanyIdFollowsTheTabForSuperAdmin() {
assertThat(dataReadScope.superAdminScopedCompanyId(user(1L, "super_admin", 1L), 2L)).isEqualTo(2L);
assertThat(dataReadScope.superAdminScopedCompanyId(user(1L, "super_admin", 1L), null)).isNull();
assertThat(dataReadScope.superAdminScopedCompanyId(user(1L, "super_admin", 1L), 0L)).isNull();
assertThat(dataReadScope.superAdminScopedCompanyId(user(1L, "super_admin", 1L), -3L)).isNull();
verifyNoInteractions(companyScope);
}
@Test
@DisplayName("第五道门:非超管一律 null(不叠公司谓词),与第二道门 pin 本公司是两回事")
void superScopedCompanyIdLeavesNonSuperAdminUnscoped() {
// 传 2(本公司)/ 7(别家)/ null 都必须 null,且不许去查公司归属
// (readCompanyIdOrOwn 在老位置会返回 own——那一道门管的是"可见集不靠账号/分组"的表,别抄错门)。
assertThat(dataReadScope.superAdminScopedCompanyId(user(5L, "admin", 2L), 2L)).isNull();
assertThat(dataReadScope.superAdminScopedCompanyId(user(5L, "admin", 2L), 7L)).isNull();
assertThat(dataReadScope.superAdminScopedCompanyId(user(5L, "admin", 2L), null)).isNull();
assertThat(dataReadScope.superAdminScopedCompanyId(user(9L, "company_super_admin", 2L), 2L)).isNull();
verifyNoInteractions(companyScope);
}
// ---- 写侧闸门 writeCompanyId:读收窄而写不收窄="藏起来的行照样能删" ---- // ---- 写侧闸门 writeCompanyId:读收窄而写不收窄="藏起来的行照样能删" ----
@Test @Test
@@ -3,7 +3,6 @@ package com.nanri.aiimage.modules.dedupe.controller;
import com.nanri.aiimage.common.exception.BusinessException; import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport; import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope; import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.common.service.ReadScope;
import com.nanri.aiimage.modules.dedupe.service.DedupeTotalDataService; import com.nanri.aiimage.modules.dedupe.service.DedupeTotalDataService;
import com.nanri.aiimage.common.model.entity.AdminUserEntity; import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService; import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
@@ -46,12 +45,13 @@ class DedupeTotalDataControllerTest {
HttpServletRequest request = mock(HttpServletRequest.class); HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController( DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService, dataReadScope); service, authSupport, permissionMenuService, dataReadScope);
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
AdminUserEntity operator = new AdminUserEntity(); AdminUserEntity operator = new AdminUserEntity();
operator.setId(8L); operator.setId(8L);
operator.setRole("super_admin"); operator.setRole("super_admin");
when(authSupport.requireUser(request)).thenReturn(operator); when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin"); when(authSupport.currentRole(operator)).thenReturn("super_admin");
// 未选公司 ⇒ 门给 null(Mockito 对包装 Long 的默认返回值是 0L,必须显式桩)
when(dataReadScope.superAdminScopedCompanyId(any(), any())).thenReturn(null);
doAnswer(invocation -> { doAnswer(invocation -> {
OutputStream outputStream = invocation.getArgument(0); OutputStream outputStream = invocation.getArgument(0);
outputStream.write(new byte[]{1, 2, 3}); outputStream.write(new byte[]{1, 2, 3});
@@ -111,12 +111,13 @@ class DedupeTotalDataControllerTest {
HttpServletRequest request = mock(HttpServletRequest.class); HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController( DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService, dataReadScope); service, authSupport, permissionMenuService, dataReadScope);
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
AdminUserEntity operator = new AdminUserEntity(); AdminUserEntity operator = new AdminUserEntity();
operator.setId(8L); operator.setId(8L);
operator.setRole("super_admin"); operator.setRole("super_admin");
when(authSupport.requireUser(request)).thenReturn(operator); when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin"); when(authSupport.currentRole(operator)).thenReturn("super_admin");
// 未选公司 ⇒ 门给 null(Mockito 对包装 Long 的默认返回值是 0L,必须显式桩)
when(dataReadScope.superAdminScopedCompanyId(any(), any())).thenReturn(null);
ResponseEntity<StreamingResponseBody> response = controller.export( ResponseEntity<StreamingResponseBody> response = controller.export(
"member", "member",
@@ -157,12 +158,13 @@ class DedupeTotalDataControllerTest {
HttpServletRequest request = mock(HttpServletRequest.class); HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController( DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService, dataReadScope); service, authSupport, permissionMenuService, dataReadScope);
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
AdminUserEntity operator = new AdminUserEntity(); AdminUserEntity operator = new AdminUserEntity();
operator.setId(8L); operator.setId(8L);
operator.setRole("super_admin"); operator.setRole("super_admin");
when(authSupport.requireUser(request)).thenReturn(operator); when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin"); when(authSupport.currentRole(operator)).thenReturn("super_admin");
// 未选公司 ⇒ 门给 null(Mockito 对包装 Long 的默认返回值是 0L,必须显式桩)
when(dataReadScope.superAdminScopedCompanyId(any(), any())).thenReturn(null);
doAnswer(invocation -> { doAnswer(invocation -> {
OutputStream outputStream = invocation.getArgument(0); OutputStream outputStream = invocation.getArgument(0);
outputStream.write(new byte[]{4, 5}); outputStream.write(new byte[]{4, 5});
@@ -215,7 +217,6 @@ class DedupeTotalDataControllerTest {
HttpServletRequest request = mock(HttpServletRequest.class); HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController( DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService, dataReadScope); service, authSupport, permissionMenuService, dataReadScope);
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
BusinessException exception = assertThrows(BusinessException.class, () -> controller.export( BusinessException exception = assertThrows(BusinessException.class, () -> controller.export(
"member", "member",
@@ -231,9 +232,10 @@ class DedupeTotalDataControllerTest {
} }
@Test @Test
void companyTabNarrowsSuperAdminToListOfMemberAccounts() { void companyTabNarrowsSuperAdminToRequestedCompanyId() {
// 超管点公司 tab ⇒ 成员集必须一路传到 service 的最后一个实参。 // 超管点公司 tab ⇒ 门给出的公司 id 必须一路传到 service 的最后一个实参。
// 这一记盯的是"参数收了、readScope 也调了、结果却喂了 null"那种假接线(tab 恒不动的现网形状)。 // 这一记盯的是"参数收了、门也调了、结果却喂了 null"那种假接线(tab 恒不动的现网形状)。
// 2026-10-09 口径切换:尾参从"成员账号集"换成"公司 id"(行按 company_id 列筛)。
DedupeTotalDataService service = mock(DedupeTotalDataService.class); DedupeTotalDataService service = mock(DedupeTotalDataService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class); AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class); PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
@@ -246,19 +248,19 @@ class DedupeTotalDataControllerTest {
operator.setRole("super_admin"); operator.setRole("super_admin");
when(authSupport.requireUser(request)).thenReturn(operator); when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin"); when(authSupport.currentRole(operator)).thenReturn("super_admin");
when(dataReadScope.readScope(operator, 2L)).thenReturn(ReadScope.users(List.of(11L, 12L))); when(dataReadScope.superAdminScopedCompanyId(operator, 2L)).thenReturn(2L);
controller.page(1L, 15L, null, "member", null, null, null, null, null, 2L, request); controller.page(1L, 15L, null, "member", null, null, null, null, null, 2L, request);
verify(service).page(eq(1L), eq(15L), isNull(), eq("member"), verify(service).page(eq(1L), eq(15L), isNull(), eq("member"),
isNull(), isNull(), isNull(), isNull(), isNull(), eq(8L), eq(List.of(11L, 12L))); isNull(), isNull(), isNull(), isNull(), isNull(), eq(8L), eq(2L));
} }
@Test @Test
void nonSuperAdminStaysUnfilteredEvenWhenCompanyTabIsSent() { void nonSuperAdminStaysUnfilteredEvenWhenCompanyTabIsSent() {
// 非超管:刻意<b>不</b>按公司收窄。他的可见集里含"靠分组权限可见"的行, // 非超管:刻意<b>不</b>按公司收窄(门对非超管恒返回 null,规则在 DataReadScope 内)。
// 叠一层账号 IN 会把那批行静默删掉(口径同 ShopManageController)。 // 他的可见集里含"靠分组权限可见"的行,叠一层公司谓词会把那批行静默删掉
// 这条是反向钉:哪天有人给非超管也加上成员集,这里必须红。 // (口径同 ShopManageController)。这条是反向钉:哪天有人给非超管也加上公司值,这里必须红。
DedupeTotalDataService service = mock(DedupeTotalDataService.class); DedupeTotalDataService service = mock(DedupeTotalDataService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class); AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class); PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
@@ -274,11 +276,14 @@ class DedupeTotalDataControllerTest {
PermissionMenuItemVo granted = new PermissionMenuItemVo(); PermissionMenuItemVo granted = new PermissionMenuItemVo();
granted.setColumnKey("admin_dedupe_total_data"); granted.setColumnKey("admin_dedupe_total_data");
when(permissionMenuService.getUserColumnPermissions(9L, "admin")).thenReturn(List.of(granted)); when(permissionMenuService.getUserColumnPermissions(9L, "admin")).thenReturn(List.of(granted));
// 门对非超管恒返回 null(此处用桩复现该语义;Mockito 对包装 Long 的默认值是 0L)
when(dataReadScope.superAdminScopedCompanyId(operator, 2L)).thenReturn(null);
controller.page(1L, 15L, null, null, null, null, null, null, null, 2L, request); controller.page(1L, 15L, null, null, null, null, null, null, null, 2L, request);
// 门被调(tab 值确实交给了唯一出口),但非超管由门内规则折成 null ⇒ service 不叠公司条件
verify(dataReadScope).superAdminScopedCompanyId(operator, 2L);
verify(service).page(eq(1L), eq(15L), isNull(), isNull(), verify(service).page(eq(1L), eq(15L), isNull(), isNull(),
isNull(), isNull(), isNull(), isNull(), isNull(), eq(9L), isNull()); isNull(), isNull(), isNull(), isNull(), isNull(), eq(9L), isNull());
verify(dataReadScope, never()).readScope(any(), any());
} }
} }
@@ -1,5 +1,8 @@
package com.nanri.aiimage.modules.dedupe.service; package com.nanri.aiimage.modules.dedupe.service;
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.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper; import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.mapper.ShopManageGroupMapper; import com.nanri.aiimage.common.mapper.ShopManageGroupMapper;
@@ -7,10 +10,13 @@ import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.model.entity.ShopManageGroupEntity; import com.nanri.aiimage.common.model.entity.ShopManageGroupEntity;
import com.nanri.aiimage.common.service.CompanyScopeSupport; import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.dedupe.mapper.DedupeTotalDataMapper; import com.nanri.aiimage.modules.dedupe.mapper.DedupeTotalDataMapper;
import com.nanri.aiimage.modules.dedupe.model.entity.DedupeTotalDataEntity;
import com.nanri.aiimage.modules.shopkey.service.ShopManageGroupService; import com.nanri.aiimage.modules.shopkey.service.ShopManageGroupService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
@@ -23,6 +29,10 @@ import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
/** /**
@@ -130,4 +140,36 @@ class DedupeTotalDataCompanySuperAdminGroupAccessTest {
.isInstanceOf(BusinessException.class) .isInstanceOf(BusinessException.class)
.hasMessage("请选择分组"); .hasMessage("请选择分组");
} }
@Test
@DisplayName("读列表按行归属收窄:company_id = 本公司,不再叠「成员上传」(代导入/上传者已删两族不再漏)")
@SuppressWarnings({"rawtypes", "unchecked"})
void pageNarrowsCompanySuperAdminByRowCompanyId() {
// 2026-10-09 口径切换(wholeCompany 分支):原条件 uploader_user_id IN (本公司成员)
// 会整批漏掉两类行——超管代导入的行(uploader=超管,不属本公司)与上传账号被硬删的行
// (JOIN 不上任何成员集)。先锋公司超管(uid=1206)对 admin 代导入的 14 行与组 33 的
// 1452 行历史数据一行都看不到,切到行 company_id 后可见。
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""),
DedupeTotalDataEntity.class);
stubCompanySuperAdmin();
when(shopManageGroupService.listCompanyGroupIds(List.of(OPERATOR_ID)))
.thenReturn(Set.of(OWN_COMPANY_GROUP_ID));
when(dedupeTotalDataMapper.selectCount(any())).thenReturn(0L);
when(dedupeTotalDataMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, "", "", null, null, null, null, null, OPERATOR_ID, null);
ArgumentCaptor<LambdaQueryWrapper<DedupeTotalDataEntity>> captor =
ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(dedupeTotalDataMapper).selectCount(captor.capture());
LambdaQueryWrapper<DedupeTotalDataEntity> query = captor.getValue();
query.getSqlSegment();
assertTrue(query.getSqlSegment().contains("company_id"),
"公司超管必须按行 company_id 看全公司: " + query.getSqlSegment());
assertTrue(query.getParamNameValuePairs().containsValue(OWN_COMPANY_ID),
"company_id 收窄值必须是本公司: " + query.getParamNameValuePairs());
assertFalse(query.getSqlSegment().contains("uploader_user_id"),
"不许回退成「成员上传」口径(会漏代导入/上传者已删两族): " + query.getSqlSegment());
}
} }
@@ -266,6 +266,34 @@ class DedupeTotalDataServiceTest {
assertTrue(query.getCustomSqlSegment().contains("FIND_IN_SET")); assertTrue(query.getCustomSqlSegment().contains("FIND_IN_SET"));
} }
@Test
@SuppressWarnings({"rawtypes", "unchecked"})
void pageNarrowsSuperAdminByRowCompanyId() {
// 2026-10-09 口径切换:超管切公司 tab 后按行自己的 company_id 筛(原按上传账号集合)。
// 这条钉的是 applyCompanyScope 的那一刀:删掉 eq(company_id,…),切 tab 就成装饰品;
// 反向(又冒回 uploader_user_id)则 admin 代导入的行会重新归错家。
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""),
DedupeTotalDataEntity.class);
when(adminUserMapper.selectById(1L)).thenReturn(user(1L, "super_admin", "root"));
when(dedupeTotalDataMapper.selectCount(any())).thenReturn(0L);
when(dedupeTotalDataMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, "", "", null, null, null, null, null, 1L, 2L);
ArgumentCaptor<LambdaQueryWrapper<DedupeTotalDataEntity>> queryCaptor =
ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(dedupeTotalDataMapper).selectCount(queryCaptor.capture());
LambdaQueryWrapper<DedupeTotalDataEntity> query = queryCaptor.getValue();
query.getSqlSegment();
assertTrue(query.getSqlSegment().contains("company_id"),
"超管切公司后必须按行 company_id 收窄: " + query.getSqlSegment());
assertTrue(query.getParamNameValuePairs().containsValue(2L),
"company_id 收窄值必须是 tab 传下来的 2: " + query.getParamNameValuePairs());
assertFalse(query.getSqlSegment().contains("uploader_user_id"),
"不许再按上传账号收窄: " + query.getSqlSegment());
}
@Test @Test
void concurrentDuplicateDuringImportIsSkipped() throws Exception { void concurrentDuplicateDuringImportIsSkipped() throws Exception {
when(adminUserMapper.selectById(23L)).thenReturn(user(23L, "normal", "member-a")); when(adminUserMapper.selectById(23L)).thenReturn(user(23L, "normal", "member-a"));
@@ -382,7 +410,7 @@ class DedupeTotalDataServiceTest {
when(dedupeTotalDataMapper.delete(any())).thenReturn(1); when(dedupeTotalDataMapper.delete(any())).thenReturn(1);
service.deleteBatchByDataValues(List.of("B012345678"), service.deleteBatchByDataValues(List.of("B012345678"),
new DedupeTotalDataService.AccessScope(true, java.util.Set.of(), java.util.Set.of(), false), new DedupeTotalDataService.AccessScope(true, java.util.Set.of(), java.util.Set.of(), false, null),
null, 3L); null, 3L);
ArgumentCaptor<LambdaQueryWrapper<DedupeTotalDataEntity>> captor = ArgumentCaptor<LambdaQueryWrapper<DedupeTotalDataEntity>> captor =