Compare commits

...

5 Commits

Author SHA1 Message Date
huangzd1997 3a49f5f8d1 fix(鉴权): 请求身份全量改走会话出口;公开默认 JWT 密钥从出厂件里摘掉
三件事都属"失败很安静"那一类:

1) 请求自带 user_id 当范围条件。cp-item2 只收了会改状态/花钱的出口,其余 28 支控制器
   (进度/列表/详情,本支 18 支、另 10 支因与租户判定收口同文件而随 cp-item3 那笔)照旧把
   "这单是谁的"交给调用方自报:A 传 B 的 user_id 就读到 B 的进度,
   接口 200、日志无声。现在 190 支取请求身份的 handler 只经一个出口(写类 require/resolve、
   读类 resolve),护栏 RequestSuppliedIdentityOutletTest 钉分母 126 写 + 63 读 + 1 豁免
   (内部代理通道 InternalUserProxyController Get /user-proxy 按内部令牌放行)。DTO 形态
   (控制器把整个 @RequestBody 递给 service)靠"该 DTO 是否声明 userId 字段"的索引识别,
   少了这层判据会漏掉一半;进度类 28 支另由 ProgressQueryOwnershipOutletTest 单独钉。
   桌面执行器 4.0.44 不带凭据是既定事实,[ownership-anonymous] 按 URI 计数留证据,
   哪一支的匿名计数归零才允许把它从 resolve 换成 require。
2) 默认 JWT 密钥。application.yml 原本写的是
   `${AIIMAGE_JWT_SECRET:please-change-this-secret-…}`,那个兜底默认值就是 2026-10-07
   现网取证到的东西:两台都跑 profile server 且 env 里没有这个键,于是 JwtService 的启动闸门
   看到的是公开字面量(非空)——既不拒绝启动也不告警,签出来的 token 任何读过源码的人都能伪造
   (含超管)。现在占位符不带默认值、AuthProperties 缺省空串、isInsecure 同时认空串与该字面量,
   server profile 缺密钥直接拒绝启动(宁可起不来)。JwtSecretFallbackGuardrailTest 五例钉
   "资源文件里不许再出现那个字面量"与"两形都算不安全"。
   发版顺序是硬约束:先在 A/B 两台 .env 配好与对方一致的 AIIMAGE_JWT_SECRET,再上新 jar;
   轮换会把所有 web 会话退出登录。
3) 菜单写侧的无操作者重载(create/update/delete)删掉——三道闸门对 operator==null 的处置是
   return(放行),src/main 里没人调用它们,但这条路在,下一支控制器接上去就是静默的跨公司改删。
   读侧 list(String menuType) 是登录态自读与内部代理用的,故意保留,并被点名只许 1 处。

TaskProgressOwnershipSupport / SimilarAsinTaskLightControllerTest / ResultSuccessTimingContractTest
是 handler 加上 HttpServletRequest 之后的既有契约用例订正;SourceScan 补 withoutComments/methodBody
两支取文助手(源码守卫的匹配面必须剥注释,否则 javadoc 里提一句就能把"必须存在"那形喂绿)。

变异自证:RequestSuppliedIdentityOutletTest 4/4(M1 删参数形出口、M2 删 DTO 形出口、
M3 出口只写进注释、M4 isBound 恒真);JwtSecretFallbackGuardrailTest 4/4(J1 恢复 yml 默认值、
J2 恢复 AuthProperties 默认值、J3 闸门退回只判 isBlank、J4 isInsecure 恒真);
MenuWriteOutletOperatorTest 4/4。
2026-10-07 20:01:32 +08:00
huangzd1997 b8792d05c0 test(任务骨架): 把"还欠多少重复"钉成棘轮,并订正 3.6k 这个数
架构评审里给的「任务生命周期约 3.6k 行冗余」经逐行差分不成立:骨架 TaskFinalizeSupport
早已存在,9 支 *TaskService 里 7 支已委托,跨文件逐字重复只有 208 行;真正改不动的是
16 个文件里 130 处手抄的「模块归属谓词」——它决定漏一行还是多放行一行,两处口径各自成立,
不是能机械合并的副本。

本支不重写那 130 处,只把债务钉住:谓词出现次数 ≤130、文件数==16、委托数 ≥7,
只许降不许升;每条断言带"能红"自检。
2026-10-07 20:01:32 +08:00
huangzd1997 e7857466e9 fix(前端): 店铺数据抓取派发即裁剪,五页共用同一守卫
代理按提取次数计费:这页把整批匹配行合进 pendingQueue 后从不清空匹配表,再点一次
「启动」就把同一批店铺再抓一遍——真花钱。查 ASIN/跟价/删除品牌/提款在 10-04 已按同一形
修过,这页当时漏了。

- BrandShopDataCrawlTab.startQueue 走共享的 pruneRows:匹配表换成 remaining、
  removed 进 pendingQueue、随即 saveMatched()+saveQueueState(),并把提示统一成
  dispatchedPruneNotice(说清"再点启动只跑剩余");
- 新增 tests/dispatch-loop-must-prune.test.ts:按函数体判「有自动接续开关 + 有派发」
  的页面是否裁行,五页全覆盖,另配三份合成夹具(裸奔必须被判不安全、只有人工删行的
  不许算合规、接好线的必须绿),判据自身不会恒绿。

「派发循环整体下沉服务端」这条前提经核不成立:拉取开关默认关是设计使然,且每轮派发参数
(紫鸟版本/国家序列/定时点)从不落库,服务端自行重派会花掉用户的次数,故留在客户端。
前端 node --test 全量 414 例 / 42 红:本批新增的 dispatch-loop-must-prune.test.ts 单跑 4 例全绿;
那 42 红是本机 node_modules 为空(缺 axios/vue),在干净 HEAD 上同样红。
2026-10-07 20:01:31 +08:00
huangzd1997 569c76f216 refactor(租户): 站点超管判定收成唯一静态出口,看板补第四道门
"super_admin 才算平台超管"这句判断此前在 src/main 里被手抄过 19 遍,2026-10-07 定的
「company_super_admin 在业务数据面同权、只在管理动作收窄」要落地就得一次改到每一处,
漏一处的表现是某一页静默 403 或静默多放行,两边都不报错。现在口径只在
DeviceSessionPolicy.isSuper 比一次:

- 出口做成静态谓词而不是 AdminAuthSupport 实例方法——那 18 支测试里 mock 的是
  AdminAuthSupport,新增实例方法不会被桩到,默认 false 会把范围静默改窄;
- 12 个文件的 15 处调用点改为 DeviceSessionPolicy.isSuper(currentRole(...)),
  DataReadScope/AdminAuthSupport 只留一个委托包装;
- 「客户端任务管理」五个 handler 的成员集计算折进 DataReadScope.superAdminScopedUserIds,
  并在 CompanyIdParamGoesThroughReadScopeTest 里补成第四道门(正反探针各一,
  判据不会因"抽进私有方法"而失明);
- 护栏 SuperAdminPredicateSingleOutletTest 双向钉:出口定义==1、包装==1、调用点==16,
  且 banned 掉实例方法形状(自检断言保证它真能红)。

今天口径仍只认 super_admin,这一层是接缝不是开关。Java 全量在本批收口后的那棵树实测 4032 例
0 红 7 skip(7 支是要本地凭据/夹具的回放与实况探测类,历来 skip)。

一并落在这支的文件(同一文件只能进一次提交,故与同批的归属收口混装):ImageVideo/InvalidAsin/
AdminDeviceLog/AdminTaskCenter/DedupeTotalData/AdminShopDataCrawlTasks/AdminShopDataDuplicateCheck/
QueryAsin/ShopManage/SkipPriceAsin 这 10 支控制器的请求身份改走会话出口见 cp-item7 的说明;
PermissionMenuService 还删掉了 create/update/delete 三个"operator 传 null 即跳过归属闸门"的
无操作者写重载(src/main 无人调用),判据在 MenuWriteOutletOperatorTest。
2026-10-07 20:01:30 +08:00
huangzd1997 0ab379b2d7 fix(鉴权): 任务归属身份从会话推导,user_id 与不符即 403
客户端任务接口原先把"这单是谁的"交给调用方自报:请求体/查询串带 user_id,服务端拿它当范围
条件。身份应只信会话(JWT),桌面执行器与内部代理通道也不例外:

- AdminAuthSupport 增加 mayActForOtherUsers / resolveOwnershipUserId /
  requireOwnershipUserId / bindOwnershipUserId:会话身份与请求 user_id 不一致直接 403,
  只有平台超管与被授权管理员能代他人;
- 上架(PublishController/PublishTaskService)先接:user_id 缺失即 401,
  仅两个桌面执行器端点允许留空;外观专利/相似 ASIN 的归属谓词补上
  Objects.equals(userId, task.getUserId()),不再只比 moduleType;
- AdminApiGuardFilter 把入口口径与新helper 对齐,护栏测试 AdminAuthSupportOwnershipTest +
  PublishOwnershipGuardrailTest 双向钉(放行面与拒绝面都有样本)。

同族的进度类模块(原先仍以请求体 user_id 为范围)在 cp-item7 一次接完;这一支只管会改状态/花钱的出口。
另外 resolveOwnershipUserId 的 [ownership-anonymous] 日志按 URI 限流也在这支——桌面执行器 4.0.44
不带凭据,只有分得清是哪个端点在打匿名请求,才敢逐支把它们从 resolve 换成 require。
2026-10-07 20:01:10 +08:00
63 changed files with 2931 additions and 412 deletions
@@ -21,6 +21,8 @@ import org.springframework.beans.factory.annotation.Value;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Slf4j
@Component
@@ -159,7 +161,7 @@ public class AdminAuthSupport {
return grants != null && grants > 0;
}
/** 计算当前用户的管理角色:super_admin / admin / null。 */
/** 计算当前用户的管理角色:super_admin / company_super_admin / admin / null(老数据 role 为空时按 is_admin + created_by_id 推断)。 */
public String currentRole(AdminUserEntity user) {
if (user == null) {
return null;
@@ -193,6 +195,93 @@ public class AdminAuthSupport {
}
}
/**
* 该身份能否代他人操作数据:三个管理角色(super_admin / company_super_admin / admin)的本职
* 就是按客户查任务,参与归属绑定只会挡掉正当功能。
*
* <p>2026-10-07 口径:company_super_admin 与 super_admin 在业务数据面逻辑一致,差别只在管理动作。
* 因此这里按"有管理角色即豁免"判定,不逐个列角色名——上一版只列了 admin/super_admin,
* 公司超管在网页端按客户查任务会被自己的守卫挡成 403。</p>
*/
public boolean mayActForOtherUsers(AdminUserEntity identity) {
return currentRole(identity) != null;
}
/**
* 归属用户 id 以<b>会话身份</b>为准,请求参数退化为兼容性输入。
*
* <p>解析得出身份时:参数缺省就用会话 id("省略 user_id 时由 taskId 反查"从此不再是无归属通道);
* 参数与会话不一致直接 403(数据归属不再由请求参数说了算);管理角色豁免。
* 解析不出身份时原样返回参数——桌面客户端不带凭据也不带 operatorId,这条给它们留滚动窗口,
* "必须带凭据"那一步由 aiimage.security.user-tool-guard-enabled 开关控制。</p>
*/
public Long resolveOwnershipUserId(HttpServletRequest request, Long requestedUserId) {
AdminUserEntity identity;
try {
identity = requireUserOrInternal(request);
} catch (BusinessException noIdentity) {
logAnonymousOwnershipFallback(request, requestedUserId);
return requestedUserId;
}
return bindOwnershipUserId(identity, requestedUserId);
}
/** 匿名兜底日志的节流窗口(每个 uri 一分钟内只打一条)。 */
private static final long ANONYMOUS_FALLBACK_LOG_INTERVAL_MILLIS = 60_000L;
private static final Map<String, Long> LAST_ANONYMOUS_FALLBACK_AT = new ConcurrentHashMap<>();
/**
* 记下「这一笔归属判定是靠请求参数过的」——它就是匿名执行器通道<b>还在被哪条端点用</b>的
* 直接计数,也是 {@code PublishController.items} 那类端点能不能从 resolve 翻成 require 的唯一现网证据。
*
* <p>节流必须按 uri 分桶:全局一分钟一条的话,39 条新接上的写类端点会互相挤掉,
* 归零判据就只剩下"猜"——那正是 2026-10-02 通知放大事故的反面(那次是不节流刷屏,这次是不能不节流)。</p>
*
* <p>翻 require 的前置条件不是日期而是<b>这条 uri 的日志归零</b>:客户端 4.0.45 起才会给自家 Java
* 调用带上登录 JWT({@code crawler_core/user_token.py} 的请求钩子仍未出厂),现在翻会把已装机的
* 执行器整批打成 401。</p>
*/
private void logAnonymousOwnershipFallback(HttpServletRequest request, Long requestedUserId) {
String uri = request.getRequestURI();
long now = System.currentTimeMillis();
Long previous = LAST_ANONYMOUS_FALLBACK_AT.get(uri);
if (previous != null && now - previous < ANONYMOUS_FALLBACK_LOG_INTERVAL_MILLIS) {
return;
}
if (previous == null) {
if (LAST_ANONYMOUS_FALLBACK_AT.putIfAbsent(uri, now) != null) {
return;
}
} else if (!LAST_ANONYMOUS_FALLBACK_AT.replace(uri, previous, now)) {
return;
}
log.warn("[ownership-anonymous] 无身份,按参数定归属 uri={} user_id={}", uri, requestedUserId);
}
/**
* {@link #resolveOwnershipUserId} 的 fail-closed 版本:解析不出身份就是 401。
*
* <p>只用于<b>已取证没有匿名调用方</b>的端点——调用方一律是带 JWT 的网页端/后台,
* 桌面执行器不碰它们。这类端点此前 user_id 可选或不传,匿名请求即可读写他人任务;
* 改用本方法后"没登录"和"冒名"都拿不到数据,且不影响真正带凭据的执行器接口。</p>
*/
public Long requireOwnershipUserId(HttpServletRequest request, Long requestedUserId) {
return bindOwnershipUserId(requireUserOrInternal(request), requestedUserId);
}
private Long bindOwnershipUserId(AdminUserEntity identity, Long requestedUserId) {
if (mayActForOtherUsers(identity)) {
return requestedUserId;
}
if (requestedUserId == null) {
return identity.getId();
}
if (!requestedUserId.equals(identity.getId())) {
throw new BusinessException(403, "无权访问该 user_id 的数据:登录账号与请求参数不一致,请重新登录");
}
return requestedUserId;
}
/**
* Flask 传统后台用 session 登录、无法签发 Java JWT,只能凭共享密钥
* (显式配置或每个用户的本地 token 文件)标识已认证管理员。这里仍会
@@ -9,7 +9,8 @@ import org.springframework.stereotype.Component;
@ConfigurationProperties(prefix = "aiimage.auth")
public class AuthProperties {
private String jwtSecret = "please-change-this-secret-please-rotate-at-least-32-bytes";
/** 空串=未配置。非 server profile 才会退回内置默认密钥(见 JwtService.signingKey)。 */
private String jwtSecret = "";
private long jwtTtlHours = 168L;
private String cookieName = "aiimage_token";
private boolean cookieSecure = false;
@@ -22,11 +22,14 @@ public final class DeviceSessionPolicy {
private DeviceSessionPolicy() {
}
/** {@code super_admin} 的字面量在 src/main 只允许出现在这一处;比较口径见 {@link #isSuper(String)}。 */
public static final String SUPER_ADMIN = "super_admin";
/** 计算用户管理角色:super_admin / company_super_admin / admin / null(含老数据 role 为空时按 created_by_id 推断)。 */
public static String resolveRole(String role, Integer isAdmin, Long createdById) {
String storedRole = role == null ? "" : role.trim().toLowerCase();
if ("super_admin".equals(storedRole)) {
return "super_admin";
if (SUPER_ADMIN.equals(storedRole)) {
return SUPER_ADMIN;
}
if ("company_super_admin".equals(storedRole)) {
// 公司超级管理员(2026-10-05):单家公司内的最高账号,数据只看本公司,由站点
@@ -38,14 +41,31 @@ public final class DeviceSessionPolicy {
}
boolean isAdminFlag = isAdmin != null && isAdmin == 1;
if (storedRole.isEmpty() && isAdminFlag) {
return createdById == null ? "super_admin" : "admin";
return createdById == null ? SUPER_ADMIN : "admin";
}
return null;
}
/**
* 站点超管判定的<b>唯一</b>出口:角色字符串只在这里比一次。
*
* <p>此前这句判断在 {@code src/main} 里被重写过 19 遍(16 处 {@code "super_admin".equals(currentRole(x))}
* 加 3 处连老数据推断一起手抄的副本)。重写本身不是 bug,它是<b>改不动</b>才是 bug:
* 2026-10-07 定的「{@code company_super_admin} 在业务数据面与 {@code super_admin} 同权、
* 只在管理动作上收窄」要落地,就得一次改到这 19 处里的每一处——漏一处的表现是某一页
* 静默 403 或静默多放行,两边都不报错。</p>
*
* <p>今天的口径仍是<b>只认 super_admin</b>:这一层是接缝,不是已经切换的开关。
* 要把公司超管放进来,改这一个方法(以及 {@code DataReadScope} 里那个同名的包装),别改调用方
* (护栏 {@code SuperAdminPredicateSingleOutletTest} 会逐文件扫回来)。</p>
*/
public static boolean isSuper(String resolvedRole) {
return SUPER_ADMIN.equals(resolvedRole);
}
/** 是否超级管理员(互踢的唯一豁免角色)。 */
public static boolean isSuperAdmin(String role, Integer isAdmin, Long createdById) {
return "super_admin".equals(resolveRole(role, isAdmin, createdById));
return isSuper(resolveRole(role, isAdmin, createdById));
}
/** 从 JWT claims 中提取签名的设备号;缺失返回空串。 */
@@ -39,13 +39,21 @@ public class JwtService {
@jakarta.annotation.PostConstruct
void requireSecretInServerProfile() {
boolean serverProfile = activeProfiles != null && activeProfiles.contains("server");
if (serverProfile && (props.getJwtSecret() == null || props.getJwtSecret().isBlank())) {
if (serverProfile && isInsecure(props.getJwtSecret())) {
throw new IllegalStateException(
"server profile 下必须配置 aiimage.auth.jwt-secret(环境变量 AIIMAGE_JWT_SECRET)——"
+ "缺失时会回退到公开的默认密钥,token 可被任意伪造");
}
}
/**
* 未配置(空)与「配置成了那个公开字面量」是同一件事:后者正是 application.yml 的
* 占位符默认值顶上来的,只判 isBlank() 拦不住 env 丢失那一种情况。
*/
static boolean isInsecure(String secret) {
return secret == null || secret.isBlank() || INSECURE_DEFAULT_SECRET.equals(secret);
}
private SecretKey signingKey() {
SecretKey key = cachedKey;
if (key == null) {
@@ -49,26 +49,6 @@ public class CompanyScopeSupport {
return companyId;
}
/**
* 后台自动写入路径(货源 chunk 回传、品牌补测调度器)专用的宽容版:账号已经不存在时返回 null,
* 而不是像 {@link #requireCompanyId(Long)} 那样抛。
*
* <p>这两个入口的锚点是 {@code biz_file_task.user_id},而账号是**物理删**的:2026-10-05 生产只读
* 取证,2026-06 以来的 716 条任务里 108 条的 user_id 在 users 里查不到(货源 174 条里 2 条)。
* 在这里抛等于让整单采集提交失败——比归属失真更糟。调用方拿到 null 必须记一条可巡检的日志、
* 并放弃这批写入,不许把 null 传进实体让 DEFAULT 1 静默兜住。</p>
*/
public Long companyIdOrNull(Long userId) {
if (userId == null || userId <= 0) {
return null;
}
AdminUserEntity user = adminUserMapper.selectById(userId);
if (user == null || user.getCompanyId() == null || user.getCompanyId() <= 0) {
return null;
}
return user.getCompanyId();
}
/** 行级归属闸门:跨公司写/删的第一道,消息由调用方给(前端按它显示,别在这里编文案)。 */
public void assertSameCompany(Long operatorCompanyId, Long rowCompanyId, String deniedMessage) {
if (rowCompanyId == null || !rowCompanyId.equals(operatorCompanyId)) {
@@ -2,6 +2,7 @@ package com.nanri.aiimage.common.service;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.modules.permission.support.UserDataScopeSupport;
import java.util.List;
import lombok.RequiredArgsConstructor;
@@ -17,15 +18,38 @@ import org.springframework.stereotype.Service;
@RequiredArgsConstructor
public class DataReadScope {
private static final String SUPER_ADMIN = "super_admin";
private final CompanyScopeSupport companyScope;
private final AdminAuthSupport adminAuthSupport;
private final UserDataScopeSupport userDataScopeSupport;
/**
* 业务层用的角色判定包装,口径落在 {@link DeviceSessionPolicy#isSuper(String)};
* 本类内部三处收窄分支都走这个包装,不再各比一次(先改包装体,别改分支)。
*/
public boolean isPlatformSuperAdmin(AdminUserEntity operator) {
return DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
}
/**
* 公司 tab 的可见账号集:<b>只对站点超管收窄</b>,其余账号返回 {@code null}(= 不叠这一层)。
*
* <p>{@code null} 不是"没算出来",而是这条纪律的形状:非超管的可见集里含「靠分组可见」的行,
* 而分组行没有账号列可推公司,给它叠 {@code created_by_id IN (成员)} 会把那批行从每一个 tab 里
* <b>静默删掉</b>(不报错、不 403);它的公司维度本来就由会话独家决定(spec §4)。</p>
*
* <p>此前这个三元表达式在 {@code AdminTaskCenterController} 里逐字重复了 5 次、在
* {@code ShopManageController} 重复了 1 次。收敛成一处是因为它是安全谓词的一部分:
* 一处漏改的表现是某个 tab 突然看得到别家的行,而它不会红。</p>
*/
public List<Long> superAdminScopedUserIds(AdminUserEntity operator, Long requestedCompanyId) {
return isPlatformSuperAdmin(operator)
? readScope(operator, requestedCompanyId).userIdsOr(null)
: null;
}
public ReadScope readScope(AdminUserEntity operator, Long requestedCompanyId) {
Long companyId = requestedCompanyId != null && requestedCompanyId > 0 ? requestedCompanyId : null;
if (SUPER_ADMIN.equals(adminAuthSupport.currentRole(operator))) {
if (isPlatformSuperAdmin(operator)) {
if (companyId == null) {
return ReadScope.unfiltered();
}
@@ -59,7 +83,7 @@ public class DataReadScope {
* 请求里带什么都不算,与 {@code readScope} 非超管分支同一口径(tab 不是安全边界)。</p>
*/
public Long readCompanyIdOrOwn(AdminUserEntity operator, Long requestedCompanyId) {
if (SUPER_ADMIN.equals(adminAuthSupport.currentRole(operator))) {
if (isPlatformSuperAdmin(operator)) {
return requestedCompanyId != null && requestedCompanyId > 0 ? requestedCompanyId : null;
}
return companyScope.requireCompanyId(operator);
@@ -76,7 +100,7 @@ public class DataReadScope {
* 内置节点现在对任何管理员可改可删——这是控制方点名的口径,不是漏改。</p>
*/
public Long writeCompanyId(AdminUserEntity operator) {
return SUPER_ADMIN.equals(adminAuthSupport.currentRole(operator))
return isPlatformSuperAdmin(operator)
? null
: companyScope.requireCompanyId(operator);
}
@@ -94,6 +94,12 @@ public class AdminApiGuardFilter extends OncePerRequestFilter {
// /api/tasks/{taskId}/interrupted 仅凭 taskId 即可把 RUNNING 任务置为 FAILED,
// 匿名遍历 taskId 就能批量打断线上任务
"/api/tasks",
// 2026-10-07 补:上架此前完全在守卫范围之外——12 个端点没有一个出现在兜底名单里,
// 控制器也不调 require*。取证:网页端 activate 三兄弟根本不传 user_id
// (frontend-vue/src/shared/api/types/modules/publish.ts),桌面执行器只调
// items 与 result(app_client/amazon/add_product.py:973,1048),所以带 JWT 的
// 请求一旦被解析出身份就得按会话归属对齐,匿名执行器路径行为不变。
"/api/publish",
};
/**
@@ -239,10 +245,9 @@ public class AdminApiGuardFilter extends OncePerRequestFilter {
}
}
/** 管理员/超管本来就是代客操作的(后台按客户查任务是常态),不参与绑定。 */
/** 管理角色本来就是代客操作的(后台按客户查任务是常态),不参与绑定。 */
private boolean mayActForOtherUsers(AdminUserEntity identity) {
String role = adminAuthSupport.currentRole(identity);
return "admin".equals(role) || "super_admin".equals(role);
return adminAuthSupport.mayActForOtherUsers(identity);
}
private void writeFailure(HttpServletResponse response, Integer code, String message) throws IOException {
@@ -51,6 +51,7 @@ public class AppearancePatentController {
@Operation(summary = "解析 Excel 并创建任务", description = "解析上传后的 Excel 文件,提取 id、ASIN、国家、URL、标题等字段。返回给前端的数据只包含整数 id 和 n_1 行;n_2、n_3 等子行会保存在 OSS 解析载荷中,用于最终结果补齐。创建后的任务状态为 PENDING,不会自动推送 Python。")
public ApiResponse<AppearancePatentParseVo> parse(@Valid @RequestBody AppearancePatentParseRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(service.parseAndCreateTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -59,7 +60,9 @@ public class AppearancePatentController {
@Operation(summary = "查询外观专利检测总览", description = "查询当前用户的运行中、成功、失败和已结束任务数量。页面进入时请求一次即可,不需要持续轮询。")
public ApiResponse<AppearancePatentDashboardVo> dashboard(
@Parameter(description = "当前用户 ID,用于隔离不同用户的任务和历史记录。", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.dashboard(userId));
}
@@ -69,7 +72,9 @@ public class AppearancePatentController {
@Parameter(description = "当前用户 ID,用于查询该用户自己的历史记录。", required = true, example = "1")
@RequestParam("user_id") Long userId,
@Parameter(description = "历史记录条数,默认 50,最大 100", example = "50")
@RequestParam(value = "limit", required = false, defaultValue = "50") Integer limit) {
@RequestParam(value = "limit", required = false, defaultValue = "50") Integer limit,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
// 上限钳制(2026-09):文档写"最大 100"但此前无实际校验
int safeLimit = limit == null ? 100 : Math.min(Math.max(1, limit), 100);
return ApiResponse.success(service.history(userId, safeLimit));
@@ -77,19 +82,22 @@ public class AppearancePatentController {
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量查询任务进度", description = "前端只对活跃任务调用该接口,建议 6 秒一次。接口只返回轻量任务状态,不返回明细结果。")
public ApiResponse<AppearancePatentTaskBatchVo> progress(@Valid @RequestBody AppearancePatentTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<AppearancePatentTaskBatchVo> progress(@Valid @RequestBody AppearancePatentTaskBatchRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(service.progressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(service.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(service.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@PostMapping("/tasks/{taskId}/activate")
@@ -98,7 +106,9 @@ public class AppearancePatentController {
@Parameter(description = "外观专利检测任务 ID,即解析接口返回的 taskId。", required = true, example = "3938")
@PathVariable Long taskId,
@Parameter(description = "当前用户 ID,必须与创建任务的用户一致。", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.activateTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -122,7 +132,9 @@ public class AppearancePatentController {
@Parameter(description = "外观专利检测任务 ID。", required = true, example = "3938")
@PathVariable Long taskId,
@Parameter(description = "当前用户 ID,必须与创建任务的用户一致。", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -133,7 +145,9 @@ public class AppearancePatentController {
@Parameter(description = "历史结果记录 ID,即 history 接口返回的 resultId。", required = true, example = "1001")
@PathVariable Long resultId,
@Parameter(description = "当前用户 ID。", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -144,7 +158,9 @@ public class AppearancePatentController {
@Parameter(description = "结果记录 ID", required = true, example = "1001")
@PathVariable Long resultId,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String url = service.resolveResultDownloadUrl(resultId, userId);
if (url == null || url.isBlank()) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "暂无可下载结果");
@@ -287,7 +287,7 @@ public class AppearancePatentTaskService {
@Transactional
public void activateTask(Long taskId, Long userId) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || userId != null && !Objects.equals(userId, task.getUserId())) {
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !Objects.equals(userId, task.getUserId())) {
throw new BusinessException("任务不存在");
}
// 2026-09-30 起外观专利已整体迁移 Linux 后台执行(无浏览器抓取):
@@ -3158,7 +3158,7 @@ public class AppearancePatentTaskService {
public AppearancePatentParsedPayloadDto queuePayload(Long taskId, Long userId) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || userId != null && !Objects.equals(userId, task.getUserId())) {
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !Objects.equals(userId, task.getUserId())) {
throw new BusinessException("任务不存在");
}
ensureTaskOwnedByCurrentInstance(task, "queue payload");
@@ -47,6 +47,7 @@ public class CollectDataController {
@Operation(summary = "解析 Excel 并创建任务", description = "解析上传后的 Excel 文件,按行入库到 biz_collect_data_item,并保存任务筛选条件。任务初始状态为 PENDING。")
public ApiResponse<CollectDataParseVo> parse(@Valid @RequestBody CollectDataParseRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(service.parseAndCreateTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -57,7 +58,9 @@ public class CollectDataController {
@Parameter(description = "采集任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.activateTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -70,7 +73,9 @@ public class CollectDataController {
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId,
@Parameter(description = "失败原因")
@RequestParam(value = "error", required = false) String error) {
@RequestParam(value = "error", required = false) String error,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.failTask(taskId, userId, error);
return ApiResponse.success(null);
}
@@ -85,7 +90,9 @@ public class CollectDataController {
@Parameter(description = "页码,从 1 开始", example = "1")
@RequestParam(value = "page", required = false, defaultValue = "1") Integer page,
@Parameter(description = "每页条数,默认 50,最大 200", example = "50")
@RequestParam(value = "page_size", required = false, defaultValue = "50") Integer pageSize) {
@RequestParam(value = "page_size", required = false, defaultValue = "50") Integer pageSize,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.getItemsPage(taskId, userId, page, pageSize));
}
@@ -102,7 +109,9 @@ public class CollectDataController {
@Operation(summary = "查询采集任务总览")
public ApiResponse<CollectDataDashboardVo> dashboard(
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.dashboard(userId));
}
@@ -112,25 +121,30 @@ public class CollectDataController {
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId,
@Parameter(description = "返回数量上限,默认 50,最大 100", example = "50")
@RequestParam(value = "limit", required = false, defaultValue = "50") Integer limit) {
@RequestParam(value = "limit", required = false, defaultValue = "50") Integer limit,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.history(userId, limit));
}
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量查询任务进度")
public ApiResponse<CollectDataTaskBatchVo> progressBatch(@Valid @RequestBody CollectDataTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<CollectDataTaskBatchVo> progressBatch(@Valid @RequestBody CollectDataTaskBatchRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(service.progressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(service.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(service.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@DeleteMapping("/tasks/{taskId}")
@@ -139,7 +153,9 @@ public class CollectDataController {
@Parameter(description = "采集任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -150,7 +166,9 @@ public class CollectDataController {
@Parameter(description = "结果记录 ID", required = true, example = "1001")
@PathVariable Long resultId,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -159,14 +177,18 @@ public class CollectDataController {
@Operation(summary = "查询国家处理顺序", description = "返回当前用户保存的国家代码列表,顺序即处理顺序。")
public ApiResponse<CollectDataCountryPreferenceVo> getCountryPreference(
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.getCountryPreference(userId));
}
@PutMapping("/country-preference")
@Operation(summary = "保存国家处理顺序", description = "保存当前用户的国家勾选与处理顺序。")
public ApiResponse<CollectDataCountryPreferenceVo> saveCountryPreference(
@Valid @RequestBody CollectDataCountryPreferenceSaveRequest request) {
@Valid @RequestBody CollectDataCountryPreferenceSaveRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(service.saveCountryPreference(request));
}
}
@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.dto.CompanySaveRequest;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
@@ -201,7 +202,7 @@ public class CompanyService {
}
private void ensureSuperAdmin(AdminUserEntity operator) {
if (!"super_admin".equals(adminAuthSupport.currentRole(operator))) {
if (!DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator))) {
throw new BusinessException(403, "只有超级管理员可以查看或修改公司配置");
}
}
@@ -5,6 +5,7 @@ import com.nanri.aiimage.modules.convert.model.dto.ConvertRunRequest;
import com.nanri.aiimage.modules.convert.model.vo.ConvertHistoryVo;
import com.nanri.aiimage.modules.convert.model.vo.ConvertRunVo;
import com.nanri.aiimage.modules.convert.service.ConvertRunService;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.enums.ParameterIn;
@@ -14,6 +15,7 @@ import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
@@ -34,6 +36,7 @@ import java.net.URI;
public class ConvertRunController {
private final ConvertRunService convertRunService;
private final AdminAuthSupport adminAuthSupport;
@PostMapping("/run")
@Operation(
@@ -58,7 +61,9 @@ public class ConvertRunController {
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "400", description = "请求参数不合法或模板不存在"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "500", description = "执行格式转换失败")
})
public ApiResponse<ConvertRunVo> run(@Valid @RequestBody ConvertRunRequest request) {
public ApiResponse<ConvertRunVo> run(@Valid @RequestBody ConvertRunRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(convertRunService.run(request));
}
@@ -69,7 +74,9 @@ public class ConvertRunController {
})
public ApiResponse<ConvertHistoryVo> history(
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
ConvertHistoryVo vo = new ConvertHistoryVo();
vo.setItems(convertRunService.listHistory(userId));
return ApiResponse.success(vo);
@@ -84,7 +91,9 @@ public class ConvertRunController {
public ApiResponse<Void> deleteHistory(
@Parameter(description = "格式转换结果记录 ID", required = true) @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
convertRunService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -98,7 +107,9 @@ public class ConvertRunController {
public ResponseEntity<Void> download(
@Parameter(description = "格式转换结果记录 ID", required = true) @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String downloadUrl = convertRunService.getResultDownloadUrl(resultId, userId);
return ResponseEntity.status(302)
.location(URI.create(downloadUrl))
@@ -6,6 +6,7 @@ import com.nanri.aiimage.modules.dedupe.model.vo.DedupeHistoryVo;
import com.nanri.aiimage.modules.dedupe.model.vo.DedupeRunProgressVo;
import com.nanri.aiimage.modules.dedupe.model.vo.DedupeRunVo;
import com.nanri.aiimage.modules.dedupe.service.DedupeRunService;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.enums.ParameterIn;
@@ -15,6 +16,7 @@ import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
@@ -35,6 +37,7 @@ import java.net.URI;
public class DedupeRunController {
private final DedupeRunService dedupeRunService;
private final AdminAuthSupport adminAuthSupport;
@PostMapping("/run")
@Operation(
@@ -61,7 +64,9 @@ public class DedupeRunController {
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "400", description = "请求参数不合法或缺少必要字段"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "500", description = "提交数据去重任务失败")
})
public ApiResponse<DedupeRunProgressVo> run(@Valid @RequestBody DedupeRunRequest request) {
public ApiResponse<DedupeRunProgressVo> run(@Valid @RequestBody DedupeRunRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(dedupeRunService.submitRun(request));
}
@@ -88,7 +93,9 @@ public class DedupeRunController {
})
public ApiResponse<DedupeHistoryVo> history(
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
DedupeHistoryVo vo = new DedupeHistoryVo();
vo.setItems(dedupeRunService.listHistory(userId));
return ApiResponse.success(vo);
@@ -103,7 +110,9 @@ public class DedupeRunController {
public ApiResponse<Void> deleteHistory(
@Parameter(description = "去重结果记录 ID", required = true) @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
dedupeRunService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -117,7 +126,9 @@ public class DedupeRunController {
public ResponseEntity<Void> download(
@Parameter(description = "去重结果记录 ID", required = true) @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String downloadUrl = dedupeRunService.getResultDownloadUrl(resultId, userId);
return ResponseEntity.status(302)
.location(URI.create(downloadUrl))
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.dedupe.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.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.common.util.DownloadHeaderUtil;
import com.nanri.aiimage.modules.dedupe.model.dto.DedupeTotalDataCreateRequest;
@@ -237,7 +238,7 @@ public class DedupeTotalDataController {
if (operator == null || operator.getId() == null || operator.getId() <= 0) {
throw new BusinessException(403, "无权访问数据去重总数据");
}
boolean superAdmin = "super_admin".equals(adminAuthSupport.currentRole(operator));
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
if (!superAdmin && !hasDedupeTotalDataPermission(operator)) {
throw new BusinessException(403, "无权访问数据去重总数据");
}
@@ -5,6 +5,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.NodeSharedStore;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.util.ExcelStreamReader;
import com.nanri.aiimage.modules.dedupe.mapper.DedupeTotalDataMapper;
import com.nanri.aiimage.modules.dedupe.model.dto.DedupeTotalDataCreateRequest;
@@ -1342,9 +1343,8 @@ public class DedupeTotalDataService {
}
private boolean isSuperAdmin(AdminUserEntity user) {
String role = user.getRole() == null ? "" : user.getRole().trim().toLowerCase(Locale.ROOT);
return "super_admin".equals(role)
|| (role.isEmpty() && Integer.valueOf(1).equals(user.getIsAdmin()) && user.getCreatedById() == null);
return user != null
&& DeviceSessionPolicy.isSuperAdmin(user.getRole(), user.getIsAdmin(), user.getCreatedById());
}
private void ensureRecordAccess(DedupeTotalDataEntity entity, AccessScope scope) {
@@ -60,6 +60,7 @@ public class DeleteBrandRunController {
})
public ApiResponse<DeleteBrandRunVo> run(@Valid @RequestBody DeleteBrandRunRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(deleteBrandRunService.run(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -68,7 +69,9 @@ public class DeleteBrandRunController {
@Operation(summary = "查询删除品牌历史", description = "按 user_id 查询删除品牌历史。")
public ApiResponse<DeleteBrandHistoryVo> history(
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(deleteBrandRunService.listHistory(userId));
}
@@ -77,7 +80,9 @@ public class DeleteBrandRunController {
public ApiResponse<Void> deleteHistory(
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
deleteBrandRunService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -91,27 +96,32 @@ public class DeleteBrandRunController {
@PostMapping("/tasks/batch")
@Operation(summary = "批量获取删除品牌任务详情", description = "合并多个 taskId 的详情查询,减少轮询期对 DB/Redis 的压力。")
public ApiResponse<DeleteBrandTaskBatchVo> getTasksBatch(@Valid @RequestBody DeleteBrandTaskBatchRequest request) {
// 归属过滤:/tasks/batch 同样按 userId 过滤(此前无校验,遍历 taskId 即可读他人任务详情)
public ApiResponse<DeleteBrandTaskBatchVo> getTasksBatch(@Valid @RequestBody DeleteBrandTaskBatchRequest request,
HttpServletRequest httpRequest) {
// 归属以会话身份为准:user_id 由请求体说了算时,遍历 taskId 即可读他人任务详情
return ApiResponse.success(deleteBrandRunService.getTaskDetails(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量获取删除品牌任务进度摘要", description = "仅返回任务基础状态和行进度摘要,用于前端轮询降载。")
public ApiResponse<DeleteBrandTaskBatchVo> getTaskProgressBatch(@Valid @RequestBody DeleteBrandTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<DeleteBrandTaskBatchVo> getTaskProgressBatch(@Valid @RequestBody DeleteBrandTaskBatchRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(deleteBrandRunService.getTaskProgress(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(deleteBrandRunService.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(deleteBrandRunService.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@GetMapping("/tasks/{taskId}/deletion-status")
@@ -119,7 +129,9 @@ public class DeleteBrandRunController {
public ApiResponse<DeleteBrandTaskDeletionStatusVo> getTaskDeletionStatus(
@PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(deleteBrandRunService.getTaskDeletionStatus(taskId, userId));
}
@@ -171,7 +183,9 @@ public class DeleteBrandRunController {
public ResponseEntity<Void> downloadResult(
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String url = deleteBrandRunService.resolveResultDownloadUrl(resultId, userId);
if (url == null || url.isBlank()) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "结果无可下载");
@@ -4,6 +4,7 @@ import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.devicelog.model.entity.DeviceLogConfigEntity;
import com.nanri.aiimage.modules.devicelog.model.entity.DeviceLogFileEntity;
@@ -164,7 +165,7 @@ public class AdminDeviceLogController {
*/
private AdminUserEntity requireSuperAdmin(HttpServletRequest request) {
AdminUserEntity user = adminAuthSupport.requireAdmin(request);
if (!"super_admin".equals(adminAuthSupport.currentRole(user))) {
if (!DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(user))) {
log.warn("[device-log] 非超管访问日志管理被拒 userId={} username={}",
user.getId(), user.getUsername());
throw new BusinessException(403, "仅超级管理员可访问日志管理");
@@ -39,7 +39,9 @@ public class ImageHistoryController {
@RequestParam(name = "user_id", required = false) Long userId,
@RequestParam(name = "time_start", required = false) String timeStart,
@RequestParam(name = "time_end", required = false) String timeEnd,
@RequestParam(name = "company_id", required = false) Long companyId) {
@RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
if (!permissionMenuService.hasAnyAdminMenu(operator, List.of("admin_history"))) {
throw new BusinessException(403, "无权访问生成记录模块");
@@ -87,7 +87,9 @@ public class AdminImageVideoTaskController {
@RequestParam(name = "submitted_from", required = false) String submittedFrom,
@RequestParam(name = "submitted_to", required = false) String submittedTo,
@RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
HttpServletRequest request,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
AdminUserEntity operator = requireOperator(request);
// 既有语义保留:显式传 user_id 时按那一个人筛;公司 tab 叠在它上面(交集)。
List<Long> base = userId != null && userId > 0 ? List.of(userId) : null;
@@ -4,6 +4,7 @@ import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.modules.imagevideo.model.dto.DouyinCopyRequest;
import com.nanri.aiimage.modules.imagevideo.model.dto.ImageVideoSecretSaveRequest;
import com.nanri.aiimage.modules.imagevideo.model.dto.ImageVideoVoiceCloneRequest;
@@ -47,7 +48,9 @@ public class ImageVideoController {
@GetMapping("/secrets")
@Operation(summary = "查询视频密钥配置状态")
public ApiResponse<ImageVideoSecretStatusVo> secretStatus(@RequestParam("user_id") Long userId,
HttpServletRequest request) {
HttpServletRequest request,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(imageVideoSecretService.status(resolveSelfUserId(request, userId)));
}
@@ -55,6 +58,7 @@ public class ImageVideoController {
@Operation(summary = "保存视频密钥配置")
public ApiResponse<ImageVideoSecretStatusVo> saveSecrets(@Valid @RequestBody ImageVideoSecretSaveRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
resolveSelfUserId(httpRequest, request.getUserId());
return ApiResponse.success(imageVideoSecretService.save(request));
}
@@ -69,7 +73,7 @@ public class ImageVideoController {
if (requestedUserId == null || requestedUserId <= 0) {
throw new BusinessException("用户 id 不合法");
}
boolean superAdmin = "super_admin".equals(adminAuthSupport.currentRole(me));
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(me));
if (!superAdmin && !requestedUserId.equals(me.getId())) {
throw new BusinessException(403, "只能操作自己的视频密钥配置");
}
@@ -78,19 +82,25 @@ public class ImageVideoController {
@PostMapping("/douyin-copy")
@Operation(summary = "抖音文案识别和仿写")
public ApiResponse<ImageVideoAsyncTaskVo> douyinCopy(@Valid @RequestBody DouyinCopyRequest request) {
public ApiResponse<ImageVideoAsyncTaskVo> douyinCopy(@Valid @RequestBody DouyinCopyRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(imageVideoAsyncTaskService.submitDouyinCopy(request));
}
@PostMapping("/workflow/run")
@Operation(summary = "提交图生/复刻视频工作流")
public ApiResponse<ImageVideoAsyncTaskVo> runWorkflow(@Valid @RequestBody ImageVideoWorkflowRunRequest request) {
public ApiResponse<ImageVideoAsyncTaskVo> runWorkflow(@Valid @RequestBody ImageVideoWorkflowRunRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(imageVideoAsyncTaskService.submitWorkflow(request));
}
@PostMapping("/workflow/result")
@Operation(summary = "查询图生/复刻视频工作流异步结果")
public ApiResponse<ImageVideoAsyncTaskVo> workflowResult(@Valid @RequestBody ImageVideoWorkflowResultRequest request) {
public ApiResponse<ImageVideoAsyncTaskVo> workflowResult(@Valid @RequestBody ImageVideoWorkflowResultRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(imageVideoAsyncTaskService.submitWorkflowResult(request));
}
@@ -102,25 +112,33 @@ public class ImageVideoController {
@PostMapping("/voice/list")
@Operation(summary = "查看音色")
public ApiResponse<ImageVideoAsyncTaskVo> listVoices(@Valid @RequestBody ImageVideoVoiceListRequest request) {
public ApiResponse<ImageVideoAsyncTaskVo> listVoices(@Valid @RequestBody ImageVideoVoiceListRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(imageVideoAsyncTaskService.submitVoiceList(request));
}
@PostMapping("/voice/delete")
@Operation(summary = "删除音色")
public ApiResponse<ImageVideoAsyncTaskVo> deleteVoice(@Valid @RequestBody ImageVideoVoiceDeleteRequest request) {
public ApiResponse<ImageVideoAsyncTaskVo> deleteVoice(@Valid @RequestBody ImageVideoVoiceDeleteRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(imageVideoAsyncTaskService.submitVoiceDelete(request));
}
@PostMapping("/voice/clone")
@Operation(summary = "音色克隆")
public ApiResponse<ImageVideoAsyncTaskVo> cloneVoice(@Valid @RequestBody ImageVideoVoiceCloneRequest request) {
public ApiResponse<ImageVideoAsyncTaskVo> cloneVoice(@Valid @RequestBody ImageVideoVoiceCloneRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(imageVideoAsyncTaskService.submitVoiceClone(request));
}
@PostMapping("/voice/synthesis")
@Operation(summary = "语音合成")
public ApiResponse<ImageVideoAsyncTaskVo> synthesizeVoice(@Valid @RequestBody ImageVideoVoiceSynthesisRequest request) {
public ApiResponse<ImageVideoAsyncTaskVo> synthesizeVoice(@Valid @RequestBody ImageVideoVoiceSynthesisRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(imageVideoAsyncTaskService.submitVoiceSynthesis(request));
}
@@ -128,7 +146,9 @@ public class ImageVideoController {
@Operation(summary = "查询图生视频异步任务")
public ApiResponse<ImageVideoAsyncTaskVo> getTask(
@PathVariable Long taskId,
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(imageVideoAsyncTaskService.getTask(taskId, userId));
}
}
@@ -3,6 +3,7 @@ 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.security.DeviceSessionPolicy;
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;
@@ -123,7 +124,7 @@ public class InvalidAsinDataController {
if (operator == null || operator.getId() == null || operator.getId() <= 0) {
throw new BusinessException(403, "无权访问品牌数据库");
}
boolean superAdmin = "super_admin".equals(adminAuthSupport.currentRole(operator));
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
if (!superAdmin && !hasInvalidAsinDataPermission(operator)) {
throw new BusinessException(403, "无权访问品牌数据库");
}
@@ -66,7 +66,9 @@ public class PatrolDeleteController {
@Operation(summary = "查询备选店铺列表", description = "返回当前用户在巡店删除模块中已保存的备选店铺。")
public ApiResponse<List<ProductRiskCandidateVo>> listCandidates(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(patrolDeleteResolveService.listCandidates(userId));
}
@@ -87,7 +89,9 @@ public class PatrolDeleteController {
"shop_name": "郭亚芳"
}
""")))
@Valid @RequestBody ProductRiskCandidateAddRequest request) {
@Valid @RequestBody ProductRiskCandidateAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(patrolDeleteResolveService.addCandidate(request));
}
@@ -97,7 +101,9 @@ public class PatrolDeleteController {
@Parameter(description = "备选店铺记录主键", example = "10")
@PathVariable Long id,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
patrolDeleteResolveService.deleteCandidate(userId, id);
return ApiResponse.success(null);
}
@@ -106,14 +112,18 @@ public class PatrolDeleteController {
@Operation(summary = "查询删除条件", description = "返回当前用户保存的巡店删除条件。")
public ApiResponse<List<PatrolDeleteConditionVo>> listConditions(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(patrolDeleteResolveService.listConditions(userId));
}
@PostMapping("/conditions")
@Operation(summary = "新增删除条件", description = "保存一条当前用户可复用的巡店删除条件。")
public ApiResponse<PatrolDeleteConditionVo> addCondition(
@Valid @RequestBody PatrolDeleteConditionAddRequest request) {
@Valid @RequestBody PatrolDeleteConditionAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(patrolDeleteResolveService.addCondition(request));
}
@@ -123,7 +133,9 @@ public class PatrolDeleteController {
@Parameter(description = "删除条件主键", example = "10")
@PathVariable Long id,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
patrolDeleteResolveService.deleteCondition(userId, id);
return ApiResponse.success(null);
}
@@ -148,7 +160,9 @@ public class PatrolDeleteController {
]
}
""")))
@Valid @RequestBody ProductRiskMatchShopsRequest request) {
@Valid @RequestBody ProductRiskMatchShopsRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(patrolDeleteResolveService.matchShops(request));
}
@@ -156,7 +170,9 @@ public class PatrolDeleteController {
@Operation(summary = "查询统计看板", description = "返回备选店铺数、已处理任务数、成功任务数和失败任务数。")
public ApiResponse<ProductRiskDashboardVo> dashboard(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(patrolDeleteTaskService.dashboard(userId));
}
@@ -166,25 +182,30 @@ public class PatrolDeleteController {
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId,
@Parameter(description = "历史记录条数,默认 30,最大 100", example = "30")
@RequestParam(value = "limit", required = false) Integer limit) {
@RequestParam(value = "limit", required = false) Integer limit,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(patrolDeleteTaskService.listHistory(userId, limit));
}
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量查询巡店删除任务进度", description = "仅返回任务状态和店铺结果摘要,用于前端轮询降载。")
public ApiResponse<PatrolDeleteTaskBatchVo> taskProgressBatch(@Valid @RequestBody PatrolDeleteTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<PatrolDeleteTaskBatchVo> taskProgressBatch(@Valid @RequestBody PatrolDeleteTaskBatchRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(patrolDeleteTaskService.getTaskProgressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(patrolDeleteTaskService.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(patrolDeleteTaskService.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@PostMapping("/tasks")
@@ -235,6 +256,7 @@ public class PatrolDeleteController {
""")))
@Valid @RequestBody PatrolDeleteCreateTaskRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(patrolDeleteTaskService.createTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -373,7 +395,9 @@ public class PatrolDeleteController {
@Parameter(description = "结果记录主键", example = "4599")
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String url = patrolDeleteTaskService.resolveResultDownloadUrl(resultId, userId);
if (url == null || url.isBlank()) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "暂无可下载结果");
@@ -393,7 +417,9 @@ public class PatrolDeleteController {
@Parameter(description = "任务主键", example = "3089")
@PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
patrolDeleteTaskService.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -404,7 +430,9 @@ public class PatrolDeleteController {
@Parameter(description = "结果记录主键", example = "4599")
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
patrolDeleteTaskService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -4,6 +4,7 @@ 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.mapper.AdminUserMapper;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
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;
@@ -222,17 +223,6 @@ public class PermissionMenuService {
return typeById;
}
@Transactional
public PermissionMenuItemVo create(PermissionMenuCreateRequest 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 只账号配权限),非超管只能在自已公司建,
@@ -274,11 +264,6 @@ public class PermissionMenuService {
return toItemVo(getMenuById(entity.getId()));
}
@Transactional
public PermissionMenuItemVo update(Long id, PermissionMenuUpdateRequest request) {
return update(null, id, request);
}
/** Controller-facing variant; validates a parent change against the full ancestor chain. */
@Transactional
public PermissionMenuItemVo update(AdminUserEntity operator, Long id, PermissionMenuUpdateRequest request) {
@@ -318,11 +303,6 @@ public class PermissionMenuService {
return toItemVo(getMenuById(id));
}
@Transactional
public void delete(Long id) {
delete(null, id);
}
/**
* Deletes a leaf menu only. Refusing a parent deletion prevents orphaned
* hierarchy rows and makes the direct-grant meaning deterministic.
@@ -827,11 +807,6 @@ public class PermissionMenuService {
return wantedIds.stream().anyMatch(effective::contains);
}
@Transactional
public void updateUserColumnPermissions(Long userId, UserColumnPermissionUpdateRequest request) {
updateUserColumnPermissions(null, userId, request);
}
/**
* Replaces direct grants. A non-super admin may only grant effective menus
* that the operator already has, and only to themself or a directly-created
@@ -1335,16 +1310,8 @@ public class PermissionMenuService {
}
private boolean isSuperAdmin(AdminUserEntity user) {
if (user == null) {
return false;
}
String role = normalizeRole(user.getRole());
if ("super_admin".equals(role)) {
return true;
}
return role.isEmpty()
&& Integer.valueOf(1).equals(user.getIsAdmin())
&& user.getCreatedById() == null;
return user != null
&& DeviceSessionPolicy.isSuperAdmin(user.getRole(), user.getIsAdmin(), user.getCreatedById());
}
private boolean isNormalUser(AdminUserEntity user) {
@@ -77,13 +77,17 @@ public class PriceTrackController {
@Operation(summary = "查询备选店铺列表", description = "返回当前用户在跟价模块中保存的备选店铺。")
public ApiResponse<List<PriceTrackCandidateVo>> listCandidates(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(priceTrackService.listCandidates(userId));
}
@PostMapping("/candidates")
@Operation(summary = "新增备选店铺", description = "新增一条备选店铺记录,供后续匹配和创建任务使用。")
public ApiResponse<PriceTrackCandidateVo> addCandidate(@Valid @RequestBody PriceTrackCandidateAddRequest request) {
public ApiResponse<PriceTrackCandidateVo> addCandidate(@Valid @RequestBody PriceTrackCandidateAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(priceTrackService.addCandidate(request));
}
@@ -92,7 +96,9 @@ public class PriceTrackController {
public ApiResponse<Void> deleteCandidate(
@Parameter(description = "备选店铺记录主键", example = "10") @PathVariable Long id,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
priceTrackService.deleteCandidate(userId, id);
return ApiResponse.success(null);
}
@@ -101,20 +107,26 @@ public class PriceTrackController {
@Operation(summary = "查询国家处理顺序", description = "返回当前用户保存的国家代码列表,顺序即跟价任务处理顺序。")
public ApiResponse<PriceTrackCountryPreferenceVo> getCountryPreference(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(priceTrackService.getCountryPreference(userId));
}
@PutMapping("/country-preference")
@Operation(summary = "保存国家处理顺序", description = "保存当前用户在跟价模块中的国家勾选和处理顺序。")
public ApiResponse<PriceTrackCountryPreferenceVo> saveCountryPreference(
@Valid @RequestBody PriceTrackCountryPreferenceSaveRequest request) {
@Valid @RequestBody PriceTrackCountryPreferenceSaveRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(priceTrackService.saveCountryPreference(request));
}
@PostMapping("/match-shops")
@Operation(summary = "批量匹配店铺", description = "按店铺名查询紫鸟索引,返回 shopId、platform、companyName、matchStatus 等信息。")
public ApiResponse<PriceTrackMatchShopsVo> matchShops(@Valid @RequestBody PriceTrackMatchShopsRequest request) {
public ApiResponse<PriceTrackMatchShopsVo> matchShops(@Valid @RequestBody PriceTrackMatchShopsRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(priceTrackService.matchShops(request));
}
@@ -167,7 +179,9 @@ public class PriceTrackController {
@Operation(summary = "统计看板", description = "返回备选店铺数、已结束任务数、成功任务数和失败任务数。")
public ApiResponse<PriceTrackDashboardVo> dashboard(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(priceTrackTaskService.dashboard(userId));
}
@@ -175,7 +189,9 @@ public class PriceTrackController {
@Operation(summary = "处理记录列表", description = "返回当前用户跟价模块下各店铺结果记录,包含运行中和历史记录。")
public ApiResponse<PriceTrackHistoryVo> history(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(priceTrackTaskService.listHistory(userId));
}
@@ -184,7 +200,9 @@ public class PriceTrackController {
public ApiResponse<Void> deleteHistory(
@Parameter(description = "结果行主键 biz_file_result.id", example = "1001") @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
priceTrackTaskService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -193,6 +211,7 @@ public class PriceTrackController {
@Operation(summary = "创建跟价任务", description = "落库 RUNNING 任务和各店铺占位结果,返回 taskId 和初始 items 快照。")
public ApiResponse<PriceTrackCreateTaskVo> createTask(@Valid @RequestBody PriceTrackCreateTaskRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(priceTrackTaskService.createTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -202,14 +221,18 @@ public class PriceTrackController {
public ApiResponse<Void> markDispatchFailed(
@PathVariable Long taskId,
@RequestParam("user_id") Long userId,
@Valid @RequestBody PriceTrackDispatchFailedRequest request) {
@Valid @RequestBody PriceTrackDispatchFailedRequest request,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
priceTrackTaskService.markDispatchFailed(taskId, userId, request.getErrorMessage());
return ApiResponse.success(null);
}
@PostMapping("/loop-runs")
@Operation(summary = "创建跟价循环任务", description = "创建整批店铺的多轮循环主任务。")
public ApiResponse<PriceTrackLoopRunVo> createLoopRun(@Valid @RequestBody PriceTrackLoopRunCreateRequest request) {
public ApiResponse<PriceTrackLoopRunVo> createLoopRun(@Valid @RequestBody PriceTrackLoopRunCreateRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(priceTrackLoopRunService.createLoopRun(request));
}
@@ -217,7 +240,9 @@ public class PriceTrackController {
@Operation(summary = "查询跟价循环任务", description = "返回循环任务当前状态与进度。")
public ApiResponse<PriceTrackLoopRunVo> getLoopRun(
@PathVariable Long loopRunId,
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(priceTrackLoopRunService.getLoopRun(loopRunId, userId));
}
@@ -225,7 +250,9 @@ public class PriceTrackController {
@Operation(summary = "获取循环任务下一条派发信息", description = "当前无活跃子任务时调用,返回下一条应该创建并入队的子任务请求。")
public ApiResponse<PriceTrackLoopRunDispatchVo> dispatchNext(
@PathVariable Long loopRunId,
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(priceTrackLoopRunService.dispatchNext(loopRunId, userId));
}
@@ -234,7 +261,9 @@ public class PriceTrackController {
public ApiResponse<PriceTrackLoopRunVo> childFinished(
@PathVariable Long loopRunId,
@RequestParam("user_id") Long userId,
@Valid @RequestBody PriceTrackLoopRunChildFinishedRequest request) {
@Valid @RequestBody PriceTrackLoopRunChildFinishedRequest request,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(priceTrackLoopRunService.childFinished(loopRunId, userId, request));
}
@@ -242,7 +271,9 @@ public class PriceTrackController {
@Operation(summary = "停止循环任务", description = "请求停止循环;若无活跃子任务则立即停止,否则等待当前子任务完成后收尾。")
public ApiResponse<PriceTrackLoopRunVo> stopLoopRun(
@PathVariable Long loopRunId,
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(priceTrackLoopRunService.requestStop(loopRunId, userId));
}
@@ -251,7 +282,9 @@ public class PriceTrackController {
public ApiResponse<Void> deleteTask(
@Parameter(description = "任务主键 biz_file_task.id", example = "200") @PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
priceTrackTaskService.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -262,33 +295,40 @@ public class PriceTrackController {
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId,
@Parameter(name = "shop_name", description = "店铺名称", required = true, in = ParameterIn.QUERY, example = "某某店铺")
@RequestParam("shop_name") String shopName) {
@RequestParam("shop_name") String shopName,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(priceTrackTaskService.deletePendingShopResult(userId, shopName));
}
@PostMapping("/tasks/batch")
@Operation(summary = "批量查询任务详情", description = "按 taskIds 返回任务概要和各店铺结果,供前端查询使用。")
public ApiResponse<PriceTrackTaskBatchVo> tasksBatch(@Valid @RequestBody PriceTrackTaskBatchRequest request) {
// 归属过滤:/tasks/batch 同样按 userId 过滤(此前无校验,遍历 taskId 即可读他人任务详情)
public ApiResponse<PriceTrackTaskBatchVo> tasksBatch(@Valid @RequestBody PriceTrackTaskBatchRequest request,
HttpServletRequest httpRequest) {
// 归属以会话身份为准:user_id 由请求体说了算时,遍历 taskId 即可读他人任务详情
return ApiResponse.success(priceTrackTaskService.getTaskDetailsBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量查询任务进度摘要", description = "仅返回任务状态、时间和错误等轻量信息,供前端轮询降载。")
public ApiResponse<PriceTrackTaskBatchVo> taskProgressBatch(@Valid @RequestBody PriceTrackTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<PriceTrackTaskBatchVo> taskProgressBatch(@Valid @RequestBody PriceTrackTaskBatchRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(priceTrackTaskService.getTaskProgressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(priceTrackTaskService.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(priceTrackTaskService.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@PostMapping("/tasks/{taskId}/result")
@@ -319,7 +359,9 @@ public class PriceTrackController {
public ResponseEntity<Void> downloadResult(
@Parameter(description = "结果记录主键 biz_file_result.id", example = "1001") @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String url = priceTrackTaskService.resolveResultDownloadUrl(resultId, userId);
if (url == null || url.isBlank()) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "暂无可下载结果");
@@ -69,13 +69,17 @@ public class ProductRiskResolveController {
@Operation(summary = "查询备选店铺列表", description = "返回当前用户在商品风险模块中已保存的备选店铺。")
public ApiResponse<List<ProductRiskCandidateVo>> listCandidates(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(productRiskResolveService.listCandidates(userId));
}
@PostMapping("/candidates")
@Operation(summary = "新增备选店铺", description = "将店铺名写入用户备选表,用于前端勾选和匹配流程。")
public ApiResponse<ProductRiskCandidateVo> addCandidate(@Valid @RequestBody ProductRiskCandidateAddRequest request) {
public ApiResponse<ProductRiskCandidateVo> addCandidate(@Valid @RequestBody ProductRiskCandidateAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(productRiskResolveService.addCandidate(request));
}
@@ -84,7 +88,9 @@ public class ProductRiskResolveController {
public ApiResponse<Void> deleteCandidate(
@Parameter(description = "备选店铺记录主键", example = "10") @PathVariable Long id,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
productRiskResolveService.deleteCandidate(userId, id);
return ApiResponse.success(null);
}
@@ -93,20 +99,26 @@ public class ProductRiskResolveController {
@Operation(summary = "查询国家处理顺序", description = "返回当前用户保存的国家代码列表,顺序即处理顺序。")
public ApiResponse<ProductRiskCountryPreferenceVo> getCountryPreference(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(productRiskResolveService.getCountryPreference(userId));
}
@PutMapping("/country-preference")
@Operation(summary = "保存国家处理顺序", description = "保存当前用户的国家勾选与处理顺序。")
public ApiResponse<ProductRiskCountryPreferenceVo> saveCountryPreference(
@Valid @RequestBody ProductRiskCountryPreferenceSaveRequest request) {
@Valid @RequestBody ProductRiskCountryPreferenceSaveRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(productRiskResolveService.saveCountryPreference(request));
}
@PostMapping("/match-shops")
@Operation(summary = "批量匹配店铺", description = "按店名查询紫鸟索引,返回 shopId、platform、companyName、matchStatus 等。")
public ApiResponse<ProductRiskMatchShopsVo> matchShops(@Valid @RequestBody ProductRiskMatchShopsRequest request) {
public ApiResponse<ProductRiskMatchShopsVo> matchShops(@Valid @RequestBody ProductRiskMatchShopsRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(productRiskResolveService.matchShops(request));
}
@@ -114,7 +126,9 @@ public class ProductRiskResolveController {
@Operation(summary = "统计看板", description = "返回候选店铺数量、已结束任务数、成功任务数和失败任务数。")
public ApiResponse<ProductRiskDashboardVo> dashboard(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(productRiskTaskService.dashboard(userId));
}
@@ -122,7 +136,9 @@ public class ProductRiskResolveController {
@Operation(summary = "处理记录列表", description = "返回当前用户商品风险模块下各店结果行,含运行中与历史记录。")
public ApiResponse<ProductRiskHistoryVo> history(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(productRiskTaskService.listHistory(userId));
}
@@ -131,7 +147,9 @@ public class ProductRiskResolveController {
public ApiResponse<Void> deleteHistory(
@Parameter(description = "结果行主键 biz_file_result.id", example = "1001") @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
productRiskTaskService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -140,6 +158,7 @@ public class ProductRiskResolveController {
@Operation(summary = "创建商品风险处理任务", description = "落库 RUNNING 任务及各店占位结果,返回 taskId 与 items。")
public ApiResponse<ProductRiskCreateTaskVo> createTask(@Valid @RequestBody ProductRiskCreateTaskRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(productRiskTaskService.createTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -149,7 +168,9 @@ public class ProductRiskResolveController {
public ApiResponse<Void> deleteTask(
@Parameter(description = "任务主键 biz_file_task.id", example = "200") @PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
productRiskTaskService.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -160,33 +181,40 @@ public class ProductRiskResolveController {
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId,
@Parameter(name = "shop_name", description = "店铺名称", required = true, in = ParameterIn.QUERY, example = "某某店铺")
@RequestParam("shop_name") String shopName) {
@RequestParam("shop_name") String shopName,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(productRiskTaskService.deletePendingShopResult(userId, shopName));
}
@PostMapping("/tasks/batch")
@Operation(summary = "批量查询任务详情", description = "按 taskIds 返回任务概览与各店结果,供前端轮询使用。")
public ApiResponse<ProductRiskTaskBatchVo> tasksBatch(@Valid @RequestBody ProductRiskTaskBatchRequest request) {
// 归属过滤:/tasks/batch 同样按 userId 过滤(此前无校验,遍历 taskId 即可读他人任务详情)
public ApiResponse<ProductRiskTaskBatchVo> tasksBatch(@Valid @RequestBody ProductRiskTaskBatchRequest request,
HttpServletRequest httpRequest) {
// 归属以会话身份为准:user_id 由请求体说了算时,遍历 taskId 即可读他人任务详情
return ApiResponse.success(productRiskTaskService.getTaskDetailsBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量查询任务进度摘要", description = "仅返回任务状态、时间和错误等轻量信息,供前端轮询降载。")
public ApiResponse<ProductRiskTaskBatchVo> taskProgressBatch(@Valid @RequestBody ProductRiskTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<ProductRiskTaskBatchVo> taskProgressBatch(@Valid @RequestBody ProductRiskTaskBatchRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(productRiskTaskService.getTaskProgressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(productRiskTaskService.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(productRiskTaskService.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@PostMapping("/tasks/{taskId}/result")
@@ -266,7 +294,9 @@ public class ProductRiskResolveController {
public ResponseEntity<Void> downloadResult(
@Parameter(description = "结果行主键 biz_file_result.id", example = "1001") @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String url;
try {
url = productRiskTaskService.resolveResultDownloadUrl(resultId, userId);
@@ -44,25 +44,28 @@ public class PublishController {
description = "按文件名(去扩展名)先匹配已管理店铺,再查询紫鸟索引;解析每个非空 Sheet。源文件前五列表头必须依次为 id、ASIN、国家、品牌、价格,第六列及以后不解析;状态、同步状态、同步国家由 Python 回传并写入最终结果文件。匹配并解析成功的文件为 PENDING,失败文件为 FAILED;只要存在可处理文件,任务为 PENDING,否则任务为 FAILED。")
public ApiResponse<PublishParseVo> parse(@Valid @RequestBody PublishParseRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(publishTaskService.parseAndCreateTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@PostMapping("/tasks/{taskId}/activate")
@Operation(summary = "激活上架任务", description = "按 taskId 激活上架任务,将状态从 PENDING 修改为 RUNNING。user_id 可省略;如传入则校验任务归属。文件仍需通过单文件激活接口逐个激活。")
@Operation(summary = "激活上架任务", description = "按 taskId 激活上架任务,将状态从 PENDING 修改为 RUNNING。user_id 可省略,省略时按当前登录身份归属;与登录账号不一致即拒绝(管理角色可代客操作)。文件仍需通过单文件激活接口逐个激活。")
public ApiResponse<Void> activateTask(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId) {
publishTaskService.activateTask(taskId, userId);
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
publishTaskService.activateTask(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId));
return ApiResponse.success(null);
}
@PostMapping("/tasks/{taskId}/files/{fileId}/activate")
@Operation(
summary = "激活任务中的单个文件",
description = "前端派发 Python 队列前调用。taskId 和 fileId 用于定位文件,user_id 可省略;如传入则校验任务归属。同一任务同一时间只允许一个 RUNNING 文件;重复激活当前 RUNNING 文件为幂等操作。"
description = "前端派发 Python 队列前调用。taskId 和 fileId 用于定位文件,user_id 可省略,省略时按当前登录身份归属;与登录账号不一致即拒绝(管理角色可代客操作)。同一任务同一时间只允许一个 RUNNING 文件;重复激活当前 RUNNING 文件为幂等操作。"
+ "店铺互斥按 (发起方设备, 店铺) 判定:同一台机器上同一店铺只允许一个任务在跑(该机器上该店铺只有一个紫鸟浏览器会话,并发会互相切换国家);不同设备各自持有独立会话,允许同一店铺并行跑不同国家。"
+ "设备号取自 JWT 签名的 deviceId claim,缺失时退回按店铺全局互斥。")
public ApiResponse<Void> activateFile(
@@ -70,29 +73,33 @@ public class PublishController {
@PathVariable Long taskId,
@Parameter(description = "任务内文件 ID", required = true, example = "9101")
@PathVariable Long fileId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest request) {
publishTaskService.activateFile(taskId, fileId, userId, adminAuthSupport.currentDeviceId(request));
HttpServletRequest httpRequest) {
publishTaskService.activateFile(taskId, fileId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId),
adminAuthSupport.currentDeviceId(httpRequest));
return ApiResponse.success(null);
}
@GetMapping("/tasks/{taskId}/items")
@Operation(
summary = "按文件分页获取上架原始数据,供 Python 拉取",
description = "Python 只需提供 taskId、file_id、page 和 page_size;后端按 taskId 反查任务所属用户并返回原 Excel 行序数据,同时携带店铺信息、发布国家和同步国家。user_id 仅作为旧客户端的可选归属校验。页码从 1 开始,每页最多 200 行。")
description = "Python 只需提供 taskId、file_id、page 和 page_size;后端按 taskId 反查任务所属用户并返回原 Excel 行序数据,同时携带店铺信息、发布国家和同步国家。user_id 仅作为旧客户端的可选归属校验:不带凭据的执行器照旧按 taskId 取数,带 JWT 的请求必须与登录身份一致。页码从 1 开始,每页最多 200 行。")
public ApiResponse<PublishItemsPageVo> items(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
@Parameter(description = "任务内文件 ID", required = true, example = "9101")
@RequestParam("file_id") Long fileId,
@Parameter(description = "页码,从 1 开始", example = "1")
@RequestParam(value = "page", defaultValue = "1") Integer page,
@Parameter(description = "每页条数,默认 50,最大 200", example = "50")
@RequestParam(value = "page_size", defaultValue = "50") Integer pageSize) {
return ApiResponse.success(publishTaskService.getItemsPage(taskId, userId, fileId, page, pageSize));
@RequestParam(value = "page_size", defaultValue = "50") Integer pageSize,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.getItemsPage(taskId,
adminAuthSupport.resolveOwnershipUserId(httpRequest, userId), fileId, page, pageSize));
}
@GetMapping("/tasks/{taskId}")
@@ -100,26 +107,30 @@ public class PublishController {
public ApiResponse<PublishTaskDetailVo> task(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId) {
return ApiResponse.success(publishTaskService.getTaskDetail(taskId, userId));
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.getTaskDetail(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId)));
}
@PostMapping("/tasks/progress/batch")
@Operation(
summary = "批量获取任务、文件进度和最终结果",
description = "按 task_ids 批量返回任务、文件进度和最终结果。task_ids 会过滤空值和非正数、去重并最多处理前 50 个;user_id 可省略,省略时按任务 ID 查询,传入时仅返回该用户的任务,未找到的 ID 放入 missingTaskIds。")
description = "按 task_ids 批量返回任务、文件进度和最终结果。task_ids 会过滤空值和非正数、去重并最多处理前 50 个;必须携带登录身份(网页端/后台);user_id 可省略,省略时按当前登录身份过滤,未找到的 ID 放入 missingTaskIds。")
public ApiResponse<PublishTaskBatchVo> progressBatch(
@Valid @RequestBody PublishTaskBatchRequest request) {
@Valid @RequestBody PublishTaskBatchRequest request, HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(publishTaskService.getTaskProgress(request.getUserId(), request.getTaskIds()));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。user_id 可省略,传入时仅返回该用户的任务。")
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。必须携带登录身份(网页端/后台);user_id 可省略,省略时按当前登录身份过滤。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(
@Valid @RequestBody TaskProgressLightRequest request) {
@Valid @RequestBody TaskProgressLightRequest request, HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(publishTaskService.progressLight(request.getUserId(), request.getTaskIds()));
}
@@ -130,7 +141,9 @@ public class PublishController {
public ApiResponse<Void> submitResult(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Valid @RequestBody PublishSubmitResultRequest request) {
@Valid @RequestBody PublishSubmitResultRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
publishTaskService.submitResult(taskId, request);
return ApiResponse.success(null);
}
@@ -138,31 +151,37 @@ public class PublishController {
@GetMapping("/dashboard")
@Operation(summary = "获取上架任务总览", description = "返回当前用户各状态任务数量和最近任务详情。")
public ApiResponse<PublishDashboardVo> dashboard(
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
return ApiResponse.success(publishTaskService.dashboard(userId));
@Parameter(description = "当前登录用户 ID;服务端按会话身份校验,与登录账号不一致即拒绝", required = true, example = "1")
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.dashboard(
adminAuthSupport.requireOwnershipUserId(httpRequest, userId)));
}
@GetMapping("/history")
@Operation(summary = "获取上架任务历史", description = "按创建时间倒序返回当前用户的任务详情,最多返回 100 条。")
public ApiResponse<PublishHistoryVo> history(
@Parameter(description = "当前用户 ID", required = true, example = "1")
@Parameter(description = "当前登录用户 ID;服务端按会话身份校验,与登录账号不一致即拒绝", required = true, example = "1")
@RequestParam("user_id") Long userId,
@Parameter(description = "返回数量上限,默认 50,最大 100", example = "50")
@RequestParam(value = "limit", defaultValue = "50") Integer limit) {
@RequestParam(value = "limit", defaultValue = "50") Integer limit,
HttpServletRequest httpRequest) {
// 上限钳制(2026-09):文档写"最多返回 100 条"但此前无实际校验
int safeLimit = limit == null ? 100 : Math.min(Math.max(1, limit), 100);
return ApiResponse.success(publishTaskService.history(userId, safeLimit));
return ApiResponse.success(publishTaskService.history(
adminAuthSupport.requireOwnershipUserId(httpRequest, userId), safeLimit));
}
@DeleteMapping("/tasks/{taskId}")
@Operation(summary = "删除上架任务", description = "按 taskId 删除任务、文件明细、解析行、结果记录和关联结果文件 Job。user_id 可省略;如传入则校验任务归属。")
@Operation(summary = "删除上架任务", description = "按 taskId 删除任务、文件明细、解析行、结果记录和关联结果文件 Job。user_id 可省略,省略时按当前登录身份归属;与登录账号不一致即拒绝(管理角色可代客操作)。")
public ApiResponse<Void> deleteTask(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId) {
publishTaskService.deleteTask(taskId, userId);
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
publishTaskService.deleteTask(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId));
return ApiResponse.success(null);
}
@@ -171,9 +190,11 @@ public class PublishController {
public ApiResponse<Void> deleteHistory(
@Parameter(description = "上架结果记录 ID", required = true, example = "9201")
@PathVariable Long resultId,
@Parameter(description = "结果所属用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
publishTaskService.deleteHistory(resultId, userId);
@Parameter(description = "结果所属用户 ID;必须与登录账号一致(管理角色可代客操作)", required = true, example = "1")
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
publishTaskService.deleteHistory(resultId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId));
return ApiResponse.success(null);
}
}
@@ -1356,6 +1356,10 @@ public class PublishTaskService {
if (taskId == null || taskId <= 0) {
throw new BusinessException("taskId 不合法");
}
// user_id 为空**不**等于跳过归属校验:这里留空只允许出现在桌面执行器的两个端点上
// (GET /tasks/{id}/items 与 POST /tasks/{id}/result,它们带 X-Internal-Token 但不带 operatorId,
// 服务端解析不出身份)。其余端点一律由 PublishController 用 requireOwnershipUserId 传入会话身份,
// 缺失即 401、冒名即 403。
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType())
|| (userId != null && !userId.equals(task.getUserId()))) {
@@ -64,7 +64,9 @@ public class QueryAsinTaskController {
@Operation(summary = "查询备选店铺列表", description = "返回当前用户在查询 ASIN 模块中已保存的备选店铺。")
public ApiResponse<List<ProductRiskCandidateVo>> listCandidates(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(queryAsinResolveService.listCandidates(userId));
}
@@ -85,7 +87,9 @@ public class QueryAsinTaskController {
"shop_name": "郭亚芳"
}
""")))
@Valid @RequestBody ProductRiskCandidateAddRequest request) {
@Valid @RequestBody ProductRiskCandidateAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(queryAsinResolveService.addCandidate(request));
}
@@ -95,7 +99,9 @@ public class QueryAsinTaskController {
@Parameter(description = "备选店铺记录主键", example = "10")
@PathVariable Long id,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
queryAsinResolveService.deleteCandidate(userId, id);
return ApiResponse.success(null);
}
@@ -120,7 +126,9 @@ public class QueryAsinTaskController {
]
}
""")))
@Valid @RequestBody ProductRiskMatchShopsRequest request) {
@Valid @RequestBody ProductRiskMatchShopsRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(queryAsinResolveService.matchShops(request));
}
@@ -128,7 +136,9 @@ public class QueryAsinTaskController {
@Operation(summary = "查询统计看板", description = "返回备选店铺数、已处理任务数、成功任务数和失败任务数。")
public ApiResponse<ProductRiskDashboardVo> dashboard(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(queryAsinTaskService.dashboard(userId));
}
@@ -136,25 +146,30 @@ public class QueryAsinTaskController {
@Operation(summary = "查询任务记录", description = "返回当前用户在查询 ASIN 模块中的当前任务和历史任务记录。")
public ApiResponse<QueryAsinHistoryVo> history(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(queryAsinTaskService.listHistory(userId));
}
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量查询查询 ASIN 任务进度", description = "仅返回任务状态和店铺结果摘要,用于前端轮询降载。")
public ApiResponse<QueryAsinTaskBatchVo> taskProgressBatch(@Valid @RequestBody QueryAsinTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<QueryAsinTaskBatchVo> taskProgressBatch(@Valid @RequestBody QueryAsinTaskBatchRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(queryAsinTaskService.getTaskProgressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(queryAsinTaskService.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(queryAsinTaskService.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@PostMapping("/tasks")
@@ -196,6 +211,7 @@ public class QueryAsinTaskController {
""")))
@Valid @RequestBody QueryAsinCreateTaskRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(queryAsinTaskService.createTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -282,7 +298,9 @@ public class QueryAsinTaskController {
@Parameter(description = "结果记录主键", example = "4599")
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String url = queryAsinTaskService.resolveResultDownloadUrl(resultId, userId);
if (url == null || url.isBlank()) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "暂无可下载结果");
@@ -302,7 +320,9 @@ public class QueryAsinTaskController {
@Parameter(description = "任务主键", example = "3089")
@PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
queryAsinTaskService.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -313,7 +333,9 @@ public class QueryAsinTaskController {
@Parameter(description = "结果记录主键", example = "4599")
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
queryAsinTaskService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -5,6 +5,7 @@ import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.util.DownloadHeaderUtil;
import com.nanri.aiimage.config.HttpClientPool;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
@@ -96,7 +97,7 @@ public class AdminShopDataCrawlTasksController {
int safePage = Math.max(1, parseInt(page, 1, "page 参数不合法"));
int safePageSize = Math.min(PAGE_SIZE_MAX,
Math.max(10, parseInt(pageSize, PAGE_SIZE_DEFAULT, "page_size 参数不合法")));
boolean superAdmin = "super_admin".equals(adminAuthSupport.currentRole(operator));
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
// 成员集就地算,且只在超管这一支算(口径同最低价ASIN/查询ASIN);null = 不筛=今天的超管全量。
List<Long> companyMemberIds = superAdmin
? dataReadScope.readScope(operator, companyId).userIdsOr(null)
@@ -61,7 +61,9 @@ public class ShopDataCrawlTaskController {
public ApiResponse<List<ProductRiskCandidateVo>> candidates(
@Parameter(name = "user_id", description = "当前用户 ID,店铺数据按用户隔离", required = true,
in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(resolveService.listCandidates(userId));
}
@@ -71,7 +73,9 @@ public class ShopDataCrawlTaskController {
description = "先校验店铺已在后台管理中维护且能够命中紫鸟店铺索引,再添加到当前用户的管理区;重复添加时返回已有记录。",
responses = @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "添加成功"))
public ApiResponse<ProductRiskCandidateVo> addCandidate(
@Valid @RequestBody ProductRiskCandidateAddRequest request) {
@Valid @RequestBody ProductRiskCandidateAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(resolveService.addCandidate(request));
}
@@ -85,7 +89,9 @@ public class ShopDataCrawlTaskController {
@PathVariable Long id,
@Parameter(name = "user_id", description = "当前用户 ID,用于校验记录归属", required = true,
in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
resolveService.deleteCandidate(userId, id);
return ApiResponse.success(null);
}
@@ -98,7 +104,9 @@ public class ShopDataCrawlTaskController {
public ApiResponse<ProductRiskCountryPreferenceVo> countryPreference(
@Parameter(name = "user_id", description = "当前用户 ID", required = true,
in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(resolveService.getCountryPreference(userId));
}
@@ -108,7 +116,9 @@ public class ShopDataCrawlTaskController {
description = "保存当前用户勾选并排序后的国家列表。支持 DE、FR、ES、IT、UK,至少选择 1 个且不能重复。",
responses = @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "保存成功"))
public ApiResponse<ProductRiskCountryPreferenceVo> saveCountryPreference(
@Valid @RequestBody ProductRiskCountryPreferenceSaveRequest request) {
@Valid @RequestBody ProductRiskCountryPreferenceSaveRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(resolveService.saveCountryPreference(request));
}
@@ -118,7 +128,9 @@ public class ShopDataCrawlTaskController {
description = "店铺名称规范化、去重后逐一匹配。先确认店铺已在后台管理中维护,再查询紫鸟店铺索引,返回店铺 ID、平台、公司名称和匹配状态。",
responses = @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "匹配完成"))
public ApiResponse<ProductRiskMatchShopsVo> matchShops(
@Valid @RequestBody ProductRiskMatchShopsRequest request) {
@Valid @RequestBody ProductRiskMatchShopsRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(resolveService.matchShops(request));
}
@@ -130,7 +142,9 @@ public class ShopDataCrawlTaskController {
public ApiResponse<ProductRiskDashboardVo> dashboard(
@Parameter(name = "user_id", description = "当前用户 ID", required = true,
in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(taskService.dashboard(userId));
}
@@ -146,7 +160,9 @@ public class ShopDataCrawlTaskController {
@Parameter(name = "page", description = "页号,从 1 开始", in = ParameterIn.QUERY, example = "1")
@RequestParam(value = "page", defaultValue = "1") int page,
@Parameter(name = "limit", description = "每页条数,最大 100;默认 100 与旧版返回最近 100 条的行为一致", in = ParameterIn.QUERY, example = "20")
@RequestParam(value = "limit", defaultValue = "100") int limit) {
@RequestParam(value = "limit", defaultValue = "100") int limit,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(taskService.listHistory(userId, page, limit));
}
@@ -156,19 +172,21 @@ public class ShopDataCrawlTaskController {
description = "供前端轮询任务队列。对有效正数 taskId 去重后最多查询前 50 个;不存在、无结果或非本模块的任务写入 missingTaskIds。",
responses = @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "查询成功"))
public ApiResponse<ShopDataCrawlTaskBatchVo> progress(
@Valid @RequestBody ShopDataCrawlTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
@Valid @RequestBody ShopDataCrawlTaskBatchRequest request, HttpServletRequest httpRequest) {
return ApiResponse.success(taskService.getTaskProgressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(taskService.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(taskService.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@PostMapping("/tasks")
@@ -179,6 +197,7 @@ public class ShopDataCrawlTaskController {
public ApiResponse<ShopDataCrawlCreateTaskVo> createTask(
@Valid @RequestBody ShopDataCrawlCreateTaskRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(taskService.createTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -285,7 +304,9 @@ public class ShopDataCrawlTaskController {
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID,用于校验结果归属", required = true,
in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String url = taskService.resolveResultDownloadUrl(resultId, userId);
if (url == null || url.isBlank()) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "暂无可下载结果");
@@ -309,7 +330,9 @@ public class ShopDataCrawlTaskController {
@PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前用户 ID,用于校验任务归属", required = true,
in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
taskService.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -324,7 +347,9 @@ public class ShopDataCrawlTaskController {
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID,用于校验结果归属", required = true,
in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
taskService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -4,6 +4,7 @@ import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.util.DownloadHeaderUtil;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
@@ -298,7 +299,7 @@ public class AdminShopDataDuplicateCheckController {
}
}
permissionMenuService.requireShopDataCrawlTaskAccess(operator);
boolean superAdmin = "super_admin".equals(adminAuthSupport.currentRole(operator));
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
return new RequestOperator(operator, superAdmin);
}
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.shopkey.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.util.DownloadHeaderUtil;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.shopkey.model.dto.QueryAsinCountryUpdateRequest;
import com.nanri.aiimage.modules.shopkey.model.dto.QueryAsinCreateRequest;
@@ -185,6 +186,6 @@ public class QueryAsinController {
}
private boolean isSuper(AdminUserEntity operator) {
return "super_admin".equals(adminAuthSupport.currentRole(operator));
return DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
}
}
@@ -2,6 +2,7 @@ package com.nanri.aiimage.modules.shopkey.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopManageCreateRequest;
@@ -64,7 +65,7 @@ public class ShopManageController {
}
private boolean isSuper(AdminUserEntity operator) {
return "super_admin".equals(adminAuthSupport.currentRole(operator));
return DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
}
@GetMapping
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.shopkey.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.util.DownloadHeaderUtil;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.shopkey.model.dto.SkipPriceAsinCountryUpdateRequest;
import com.nanri.aiimage.modules.shopkey.model.dto.SkipPriceAsinCreateRequest;
@@ -202,6 +203,6 @@ public class SkipPriceAsinController {
}
private boolean isSuper(AdminUserEntity operator) {
return "super_admin".equals(adminAuthSupport.currentRole(operator));
return DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
}
}
@@ -64,13 +64,17 @@ public class ShopMatchController {
@Operation(summary = "查询候选店铺", description = "返回当前用户在匹配店铺模块下保存的候选店铺列表。")
public ApiResponse<List<ProductRiskCandidateVo>> listCandidates(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(shopMatchResolveService.listCandidates(userId));
}
@PostMapping("/candidates")
@Operation(summary = "新增候选店铺", description = "新增一条候选店铺记录,供前端后续匹配与创建任务使用。")
public ApiResponse<ProductRiskCandidateVo> addCandidate(@Valid @RequestBody ProductRiskCandidateAddRequest request) {
public ApiResponse<ProductRiskCandidateVo> addCandidate(@Valid @RequestBody ProductRiskCandidateAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(shopMatchResolveService.addCandidate(request));
}
@@ -79,7 +83,9 @@ public class ShopMatchController {
public ApiResponse<Void> deleteCandidate(
@Parameter(description = "候选店铺记录主键", example = "10") @PathVariable Long id,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
shopMatchResolveService.deleteCandidate(userId, id);
return ApiResponse.success(null);
}
@@ -88,19 +94,25 @@ public class ShopMatchController {
@Operation(summary = "查询国家配置顺序", description = "返回当前用户保存的国家勾选与执行顺序。")
public ApiResponse<ProductRiskCountryPreferenceVo> getCountryPreference(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(shopMatchResolveService.getCountryPreference(userId));
}
@PutMapping("/country-preference")
@Operation(summary = "保存国家配置顺序", description = "保存当前用户在匹配店铺模块中的国家勾选与执行顺序。")
public ApiResponse<ProductRiskCountryPreferenceVo> saveCountryPreference(@Valid @RequestBody ProductRiskCountryPreferenceSaveRequest request) {
public ApiResponse<ProductRiskCountryPreferenceVo> saveCountryPreference(@Valid @RequestBody ProductRiskCountryPreferenceSaveRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(shopMatchResolveService.saveCountryPreference(request));
}
@PostMapping("/match-shops")
@Operation(summary = "批量匹配店铺", description = "按店铺名批量匹配紫鸟索引,返回店铺 ID、平台、公司与匹配状态。")
public ApiResponse<ProductRiskMatchShopsVo> matchShops(@Valid @RequestBody ProductRiskMatchShopsRequest request) {
public ApiResponse<ProductRiskMatchShopsVo> matchShops(@Valid @RequestBody ProductRiskMatchShopsRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(shopMatchResolveService.matchShops(request));
}
@@ -108,7 +120,9 @@ public class ShopMatchController {
@Operation(summary = "统计看板", description = "返回候选店铺数、已结束任务数、成功数和失败数。")
public ApiResponse<ProductRiskDashboardVo> dashboard(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(shopMatchTaskService.dashboard(userId));
}
@@ -116,7 +130,9 @@ public class ShopMatchController {
@Operation(summary = "查询任务记录", description = "返回当前用户的运行中与历史任务记录。")
public ApiResponse<ProductRiskHistoryVo> history(
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(shopMatchTaskService.listHistory(userId));
}
@@ -125,7 +141,9 @@ public class ShopMatchController {
public ApiResponse<Void> deleteHistory(
@Parameter(description = "结果记录主键", example = "1001") @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
shopMatchTaskService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -134,6 +152,7 @@ public class ShopMatchController {
@Operation(summary = "创建匹配店铺任务", description = "创建任务与各店铺占位结果,支持立即执行或多时间点定时执行。")
public ApiResponse<ShopMatchCreateTaskVo> createTask(@Valid @RequestBody ShopMatchCreateTaskRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(shopMatchTaskService.createTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -143,7 +162,9 @@ public class ShopMatchController {
public ApiResponse<Void> deleteTask(
@Parameter(description = "任务主键", example = "200") @PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
shopMatchTaskService.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -153,7 +174,9 @@ public class ShopMatchController {
public ApiResponse<Void> activateTask(
@Parameter(description = "任务主键", example = "200") @PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1") @RequestParam("user_id") Long userId,
@Parameter(name = "stage_index", description = "阶段下标,从 0 开始", required = true, in = ParameterIn.QUERY, example = "0") @RequestParam("stage_index") Integer stageIndex) {
@Parameter(name = "stage_index", description = "阶段下标,从 0 开始", required = true, in = ParameterIn.QUERY, example = "0") @RequestParam("stage_index") Integer stageIndex,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
shopMatchTaskService.activateTask(taskId, userId, stageIndex);
return ApiResponse.success(null);
}
@@ -185,32 +208,42 @@ public class ShopMatchController {
public ApiResponse<Void> completeStage(
@Parameter(description = "任务主键", example = "200") @PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1") @RequestParam("user_id") Long userId,
@Valid @RequestBody ShopMatchStageCompleteRequest request) {
@Valid @RequestBody ShopMatchStageCompleteRequest request,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
shopMatchTaskService.completeStage(taskId, userId, request);
return ApiResponse.success(null);
}
@PostMapping("/tasks/batch")
@Operation(summary = "批量查询任务详情", description = "供前端轮询任务状态与阶段进度使用。")
public ApiResponse<ProductRiskTaskBatchVo> tasksBatch(@Valid @RequestBody ProductRiskTaskBatchRequest request) {
// 归属过滤:/tasks/batch 同样按 userId 过滤(此前无校验,遍历 taskId 即可读他人任务详情)
public ApiResponse<ProductRiskTaskBatchVo> tasksBatch(@Valid @RequestBody ProductRiskTaskBatchRequest request,
HttpServletRequest httpRequest) {
// 归属以会话身份为准:user_id 由请求体说了算时,遍历 taskId 即可读他人任务详情
return ApiResponse.success(shopMatchTaskService.getTaskDetailsBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量查询任务进度摘要", description = "仅返回任务状态、阶段信息与时间等轻量字段,供前端轮询降载。")
public ApiResponse<ProductRiskTaskBatchVo> taskProgressBatch(@Valid @RequestBody ProductRiskTaskBatchRequest request) {
return ApiResponse.success(shopMatchTaskService.getTaskProgressBatch(request.getTaskIds()));
public ApiResponse<ProductRiskTaskBatchVo> taskProgressBatch(@Valid @RequestBody ProductRiskTaskBatchRequest request,
HttpServletRequest httpRequest) {
// 这一支此前连归属过滤都没有(taskIds 直接进 service),与同族 progress/batch 不同形。
return ApiResponse.success(shopMatchTaskService.getTaskProgressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(shopMatchTaskService.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(shopMatchTaskService.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@PostMapping("/tasks/{taskId}/result")
@@ -229,7 +262,9 @@ public class ShopMatchController {
@Operation(summary = "下载结果文件", description = "按结果记录 302 重定向到后端已生成的 Excel 直链。")
public ResponseEntity<Void> downloadResult(
@Parameter(description = "结果记录主键", example = "1001") @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1") @RequestParam("user_id") Long userId) {
@Parameter(name = "user_id", description = "当前用户 ID", required = true, in = ParameterIn.QUERY, example = "1") @RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String url = shopMatchTaskService.resolveResultDownloadUrl(resultId, userId);
if (url == null || url.isBlank()) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "No downloadable result");
@@ -58,14 +58,18 @@ public class SimilarAsinController {
@Operation(summary = "查询货源查询筛选条件")
public ApiResponse<List<SimilarAsinFilterConditionVo>> listFilterConditions(
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.listFilterConditions(userId));
}
@PostMapping("/filter-conditions")
@Operation(summary = "保存货源查询筛选条件")
public ApiResponse<SimilarAsinFilterConditionVo> addFilterCondition(
@Valid @RequestBody SimilarAsinFilterConditionAddRequest request) {
@Valid @RequestBody SimilarAsinFilterConditionAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(service.addFilterCondition(request));
}
@@ -75,7 +79,9 @@ public class SimilarAsinController {
@Parameter(description = "筛选条件主键", example = "10")
@PathVariable Long id,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.deleteFilterCondition(userId, id);
return ApiResponse.success(null);
}
@@ -87,6 +93,7 @@ public class SimilarAsinController {
)
public ApiResponse<SimilarAsinParseVo> parse(@Valid @RequestBody SimilarAsinParseRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(service.parseAndCreateTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -100,7 +107,9 @@ public class SimilarAsinController {
@Parameter(description = "货源查询任务 ID", required = true, example = "7004")
@PathVariable Long taskId,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.parsedPayload(taskId, userId));
}
@@ -108,7 +117,9 @@ public class SimilarAsinController {
@Operation(summary = "查询相似 ASIN 检测总览", description = "查询当前用户的运行中、成功、失败和已结束任务数量。")
public ApiResponse<SimilarAsinDashboardVo> dashboard(
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.dashboard(userId));
}
@@ -118,26 +129,31 @@ public class SimilarAsinController {
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId,
@Parameter(description = "历史记录条数,默认 50,最大 100", example = "50")
@RequestParam(value = "limit", required = false, defaultValue = "50") Integer limit) {
@RequestParam(value = "limit", required = false, defaultValue = "50") Integer limit,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.history(userId, limit));
}
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量查询任务进度", description = "前端仅对活跃任务轮询该接口,返回轻量任务状态。")
public ApiResponse<SimilarAsinTaskBatchVo> progress(@Valid @RequestBody SimilarAsinTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<SimilarAsinTaskBatchVo> progress(@Valid @RequestBody SimilarAsinTaskBatchRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(service.progressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileReady/updatedAt),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<SimilarAsinTaskLightBatchVo> progressLight(@Valid @RequestBody SimilarAsinTaskLightRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<SimilarAsinTaskLightBatchVo> progressLight(@Valid @RequestBody SimilarAsinTaskLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(service.progressLight(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/{taskId}/activate")
@@ -146,7 +162,9 @@ public class SimilarAsinController {
@Parameter(description = "相似 ASIN 检测任务 ID", required = true, example = "3938")
@PathVariable Long taskId,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.activateTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -173,7 +191,9 @@ public class SimilarAsinController {
@Parameter(description = "相似 ASIN 检测任务 ID", required = true, example = "3938")
@PathVariable Long taskId,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -184,7 +204,9 @@ public class SimilarAsinController {
@Parameter(description = "历史结果记录 ID", required = true, example = "1001")
@PathVariable Long resultId,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
service.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -195,7 +217,9 @@ public class SimilarAsinController {
@Parameter(description = "结果记录 ID", required = true, example = "1001")
@PathVariable Long resultId,
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
ResultDownloadInfo download = service.resolveResultDownloadInfo(resultId, userId);
if (download.url() == null || download.url().isBlank()) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "暂无可下载结果");
@@ -543,7 +543,7 @@ public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
public void activateTask(Long taskId, Long userId) {
try (TaskDistributedLockService.LockHandle ignored = ownershipSupport().requireTaskLock(taskId, TASK_LOCK_WAIT_MILLIS)) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || userId != null && !Objects.equals(userId, task.getUserId())) {
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !Objects.equals(userId, task.getUserId())) {
throw new BusinessException("任务不存在");
}
ownershipSupport().ensureTaskOwnedByCurrentInstance(task, "activate");
@@ -1726,7 +1726,7 @@ public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
public SimilarAsinParsedPayloadDto parsedPayload(Long taskId, Long userId) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || userId != null && !Objects.equals(userId, task.getUserId())) {
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !Objects.equals(userId, task.getUserId())) {
throw new BusinessException("任务不存在");
}
ownershipSupport().ensureTaskOwnedByCurrentInstance(task, "parsed payload");
@@ -5,6 +5,7 @@ import com.nanri.aiimage.modules.split.model.dto.SplitRunRequest;
import com.nanri.aiimage.modules.split.model.vo.SplitHistoryVo;
import com.nanri.aiimage.modules.split.model.vo.SplitRunVo;
import com.nanri.aiimage.modules.split.service.SplitRunService;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.enums.ParameterIn;
@@ -14,6 +15,7 @@ import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
@@ -34,6 +36,7 @@ import java.net.URI;
public class SplitRunController {
private final SplitRunService splitRunService;
private final AdminAuthSupport adminAuthSupport;
@PostMapping("/run")
@Operation(
@@ -56,7 +59,9 @@ public class SplitRunController {
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "400", description = "请求参数不合法或拆分模式错误"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "500", description = "执行数据拆分失败")
})
public ApiResponse<SplitRunVo> run(@Valid @RequestBody SplitRunRequest request) {
public ApiResponse<SplitRunVo> run(@Valid @RequestBody SplitRunRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(splitRunService.run(request));
}
@@ -67,7 +72,9 @@ public class SplitRunController {
})
public ApiResponse<SplitHistoryVo> history(
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
SplitHistoryVo vo = new SplitHistoryVo();
vo.setItems(splitRunService.listHistory(userId));
return ApiResponse.success(vo);
@@ -82,7 +89,9 @@ public class SplitRunController {
public ApiResponse<Void> deleteHistory(
@Parameter(description = "数据拆分结果记录 ID", required = true) @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
splitRunService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -96,7 +105,9 @@ public class SplitRunController {
public ResponseEntity<Void> download(
@Parameter(description = "数据拆分结果记录 ID", required = true) @PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID", required = true, in = ParameterIn.QUERY)
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String downloadUrl = splitRunService.getResultDownloadUrl(resultId, userId);
return ResponseEntity.status(302)
.location(URI.create(downloadUrl))
@@ -16,9 +16,10 @@ import java.util.List;
* 服务端此前不做任何归属校验 —— 匿名遍历自增 taskId 即可读取他人任务的状态、
* 错误信息与结果文件状态。
*
* <p>渐进式收紧:<b>仅在调用方传入 userId 时过滤</b>,未传则保持原行为。
* 这样不会因前端/客户端某一处漏传就把结果过滤成空(表现为「任务进度全部消失」),
* 待各端都完成传参后再改为强制校验。
* <p>归属口径(2026-10-07 收口):这里的 {@code userId} <b>不再直接来自请求体</b>——28 支轮询 handler
* 一律先过 {@code AdminAuthSupport#requireOwnershipUserId}(解析不出会话身份即 401,普通账号带别人的
* id 即 403)。所以 {@code userId == null} 现在只有一种来源:已认证的 admin / 超管(出口对管理角色
* 原样返回参数,后台按客户看任务是本职)。把它当成"匿名也走得通"来依赖就是回归:那正是收口前的洞。
*/
@Slf4j
@Component
@@ -32,16 +32,13 @@ import java.util.List;
* <p>仅超管默认可见;管理员需超管在「用户管理 → 菜单权限」授权 {@code admin_task_center}
* 后才能访问。数据范围 = 本人 + 本组用户 + 自己管理的成员(超管不裁剪)。</p>
*
* <p>公司 tab(spec §4):五个端点各收一个可选 {@code company_id},都在 handler 体内过唯一出口
* {@link DataReadScope#readScope} 算成员集,再交给 {@code TaskCenterScopeService.resolve} 与既有口径
* 求交——一处收窄,五个出口天然同宽(详情走 {@code scope.visible()},用的就是同一条集合)。
* 那一行之所以在五个 handler 里各写一遍而不是抽进私有方法:护栏
* {@code CompanyIdParamGoesThroughReadScopeTest} 的断言 A 认的是「这支 handler 体内出现过 readScope(」,
* 抽走之后**只有 A 会红**(且因为 A 是 fail-fast,只点名第一支);C 根本不响——它的门槛就是「体内含
* readScope(」,体内没了就连评估都不评估;D 绿——它认 {@code resolveScope(},而 {@code companyId} 正好
* 还在那条私有委托的实参表里。所以逐字重复买到的是「A 这一记看守在每支 handler 上各站一次」,
* 不是三重红:别把它当成「C/D 也兜着」而去试 A 拦得住之外的形状(2026-10-05 复评 I-2 订正,
* 原话「抽走即三只都红」与 MUT-A 的实测读数 2 tests / 1 failure 不符)。</p>
* <p>公司 tab(spec §4):五个端点各收一个可选 {@code company_id},都在 handler 体内过一次唯一出口
* {@link DataReadScope#superAdminScopedUserIds} 算成员集,再交给 {@code TaskCenterScopeService.resolve}
* 与既有口径求交——一处收窄,五个出口天然同宽(详情走 {@code scope.visible()},用的就是同一条集合)。
* 此前这一行在五个 handler 里逐字重复(当时的护栏断言 A 只认「体内出现过 {@code readScope(}」,抽走即红),
* 2026-10-07 三期把 {@code superAdminScopedUserIds} 补进 {@code SCOPE_DOORS} 之后,那道理由不再成立:
* 判据跟着出口走,而不是让出口迁就判据(见 {@code CompanyIdParamGoesThroughReadScopeTest}
* 里 {@code SUPER_SCOPED_*} 三枚探针)。</p>
*/
@RestController
@RequiredArgsConstructor
@@ -65,9 +62,8 @@ public class AdminTaskCenterController {
@Parameter(description = "公司 ID(超管 tab;不传=不筛)")
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = authorizedOperator(request);
boolean superAdmin = isSuper(operator);
Long operatorId = operator.getId();
List<Long> companyUserIds = superAdmin ? dataReadScope.readScope(operator, companyId).userIdsOr(null) : null;
List<Long> companyUserIds = dataReadScope.superAdminScopedUserIds(operator, companyId);
TaskCenterScopeService.ScopeContext scope = resolveScope(operatorId, companyUserIds);
return ApiResponse.success(queryService.overview(scope));
}
@@ -80,9 +76,8 @@ public class AdminTaskCenterController {
@Parameter(description = "公司 ID(超管 tab;不传=不筛)")
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = authorizedOperator(request);
boolean superAdmin = isSuper(operator);
Long operatorId = operator.getId();
List<Long> companyUserIds = superAdmin ? dataReadScope.readScope(operator, companyId).userIdsOr(null) : null;
List<Long> companyUserIds = dataReadScope.superAdminScopedUserIds(operator, companyId);
TaskCenterScopeService.ScopeContext scope = resolveScope(operatorId, companyUserIds);
return ApiResponse.success(queryService.shopOptions(scope));
}
@@ -98,9 +93,8 @@ public class AdminTaskCenterController {
@Parameter(description = "公司 ID(超管 tab;不传=不筛)")
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = authorizedOperator(request);
boolean superAdmin = isSuper(operator);
Long operatorId = operator.getId();
List<Long> companyUserIds = superAdmin ? dataReadScope.readScope(operator, companyId).userIdsOr(null) : null;
List<Long> companyUserIds = dataReadScope.superAdminScopedUserIds(operator, companyId);
TaskCenterScopeService.ScopeContext scope = resolveScope(operatorId, companyUserIds);
return ApiResponse.success(queryService.tasks(scope, query));
}
@@ -114,9 +108,8 @@ public class AdminTaskCenterController {
@Parameter(description = "公司 ID(超管 tab;不传=不筛)")
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = authorizedOperator(request);
boolean superAdmin = isSuper(operator);
Long operatorId = operator.getId();
List<Long> companyUserIds = superAdmin ? dataReadScope.readScope(operator, companyId).userIdsOr(null) : null;
List<Long> companyUserIds = dataReadScope.superAdminScopedUserIds(operator, companyId);
TaskCenterScopeService.ScopeContext scope = resolveScope(operatorId, companyUserIds);
TaskCenterTaskDetailVo detail = queryService.detail(scope, taskNo);
if (detail == null) {
@@ -138,9 +131,8 @@ public class AdminTaskCenterController {
@Parameter(description = "公司 ID(超管 tab;不传=不筛)")
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = authorizedOperator(request);
boolean superAdmin = isSuper(operator);
Long operatorId = operator.getId();
List<Long> companyUserIds = superAdmin ? dataReadScope.readScope(operator, companyId).userIdsOr(null) : null;
List<Long> companyUserIds = dataReadScope.superAdminScopedUserIds(operator, companyId);
TaskCenterScopeService.ScopeContext scope = resolveScope(operatorId, companyUserIds);
return ApiResponse.success(variantService.variantTasks(scope, status, taskType, page, pageSize));
}
@@ -154,18 +146,9 @@ public class AdminTaskCenterController {
}
/**
* 是否站点超管——用的是 {@code AdminAuthSupport.currentRole}(与 {@code DataReadScope} 内部同一把尺子,
* 含「role 为空 + isAdmin=1 + createdById 为空」的历史超管推断),不是这里新造的判定。
* 只有超管才按公司 tab 收窄:非超管的可见集里含「靠分组可见」的行,给它叠成员集会把那批行
* 从每一个 tab 里静默删掉;它的公司维度本来就由会话独家决定(spec §4)。
*/
private boolean isSuper(AdminUserEntity operator) {
return "super_admin".equals(adminAuthSupport.currentRole(operator));
}
/**
* 五个端点共用的收窄出口:{@code companyUserIds} 必须是 handler 体内 {@code readScope} 算出来的那个值
* ({@code null} = 不收窄),不许在这一层重新取公司值——那样护栏 A/C/D 看见的就不是这条链了。
* 五个端点共用的收窄出口:{@code companyUserIds} 必须是 handler 体内
* {@link DataReadScope#superAdminScopedUserIds} 算出来的那个值({@code null} = 不收窄),
* 不许在这一层重新取公司值——那样护栏 A/C/D 看见的就不是这条链了。
*/
private TaskCenterScopeService.ScopeContext resolveScope(Long operatorId, List<Long> companyUserIds) {
return scopeService.resolve(operatorId, companyUserIds);
@@ -2,6 +2,7 @@ package com.nanri.aiimage.modules.taskcenter.service;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.mapper.ShopManageGroupMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
@@ -104,9 +105,8 @@ public class TaskCenterScopeService {
}
private boolean isSuperAdmin(AdminUserEntity user) {
String role = user.getRole() == null ? "" : user.getRole().trim().toLowerCase(Locale.ROOT);
return "super_admin".equals(role)
|| (role.isEmpty() && Integer.valueOf(1).equals(user.getIsAdmin()) && user.getCreatedById() == null);
return user != null
&& DeviceSessionPolicy.isSuperAdmin(user.getRole(), user.getIsAdmin(), user.getCreatedById());
}
/** 公司超管判定(老数据 role 为空不参与:公司超管是新角色,只认显式取值)。 */
@@ -34,7 +34,9 @@ public class InternalUserSecretUsageController {
@Operation(summary = "上报用户密钥调用计次",
description = "按 userId + module 累加当日调用次数;模块非法返回 success=false。")
public ApiResponse<Map<String, Object>> report(HttpServletRequest request,
@RequestBody UserSecretUsageReportRequest body) {
@RequestBody UserSecretUsageReportRequest body,
HttpServletRequest httpRequest) {
body.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, body.getUserId()));
if (!adminAuthSupport.isTrustedInternalToken(request)) {
log.warn("[internal-usage] 拒绝未携带可信内部令牌的计次上报 userId={} remoteAddr={}",
body == null ? null : body.getUserId(), request.getRemoteAddr());
@@ -7,6 +7,7 @@ import com.nanri.aiimage.modules.admin.spi.UserSecretCleanupPort;
import com.nanri.aiimage.common.security.ShopCredentialCryptoService;
import com.nanri.aiimage.config.UserSecretProperties;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.service.ReadScope;
import com.nanri.aiimage.modules.notification.service.NotificationDispatchService;
import com.nanri.aiimage.modules.notification.service.NotificationService;
@@ -205,7 +206,7 @@ public class UserApiSecretService implements UserSecretCleanupPort {
/** 数据权限:超管可操作全部;其余管理员只能操作自己数据权限范围内的用户。 */
private void requireVisibleUser(AdminUserEntity operator, Long userId) {
if (operator != null && "super_admin".equals(adminAuthSupport.currentRole(operator))) {
if (operator != null && DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator))) {
return;
}
Long operatorId = operator == null ? null : operator.getId();
@@ -326,7 +327,7 @@ public class UserApiSecretService implements UserSecretCleanupPort {
long pageSize = safeQuery.getPageSize() == null || safeQuery.getPageSize() < 1
? 15L : Math.min(safeQuery.getPageSize(), 100L);
boolean superAdmin = "super_admin".equals(adminAuthSupport.currentRole(operator));
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
Long requestedGroupId = safeQuery.getGroupId();
// 组隔离(主管锁定自己带的分组、超管按 group_id 筛)叠上公司 tab:两条维度取**交集**,
// 公司 tab 只能收窄,绝不放大分组看不到的行;范围本身由 controller 经唯一出口算好交下来。
@@ -419,7 +420,7 @@ public class UserApiSecretService implements UserSecretCleanupPort {
* ({@link ReadScope#userIdsOr}),留着是为了让 service 不依赖出口的内部 ⇒ <b>勿把它当成第二次判公司</b>。
*/
List<Long> scopedUserIds(AdminUserEntity operator, Long requestedGroupId, ReadScope companyScope) {
boolean superAdmin = "super_admin".equals(adminAuthSupport.currentRole(operator));
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
List<Long> base = null;
if (superAdmin) {
if (requestedGroupId != null && requestedGroupId > 0) {
@@ -2,6 +2,7 @@ package com.nanri.aiimage.modules.usersecret.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.service.ReadScope;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
@@ -99,7 +100,7 @@ public class UserSecretUsageService {
long pageSize = safeQuery.getPageSize() == null || safeQuery.getPageSize() < 1
? 15L : Math.min(safeQuery.getPageSize(), 100L);
boolean superAdmin = "super_admin".equals(adminAuthSupport.currentRole(operator));
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
Long requestedGroupId = safeQuery.getGroupId();
// 组隔离(主管锁定自己带的分组、超管按 group_id 筛)叠上公司 tab:取**交集**,公司 tab 只收窄。
List<Long> scopedUserIds = scopedUserIds(operator, requestedGroupId, companyScope);
@@ -224,7 +225,7 @@ public class UserSecretUsageService {
* ({@link ReadScope#userIdsOr}),留着是为了让 service 不依赖出口的内部 ⇒ <b>勿把它当成第二次判公司</b>。
*/
List<Long> scopedUserIds(AdminUserEntity operator, Long requestedGroupId, ReadScope companyScope) {
boolean superAdmin = "super_admin".equals(adminAuthSupport.currentRole(operator));
boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
List<Long> base = null;
if (superAdmin) {
if (requestedGroupId != null && requestedGroupId > 0) {
@@ -60,13 +60,17 @@ public class WithdrawTaskController {
@Operation(summary = "查询取款备选店铺", description = "按当前用户查询已保存的取款备选店铺列表,用于前端勾选后进行匹配和创建取款任务。")
public ApiResponse<List<ProductRiskCandidateVo>> listCandidates(
@Parameter(name = "user_id", description = "当前登录用户 ID,数据按用户隔离。", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(withdrawResolveService.listCandidates(userId));
}
@PostMapping("/candidates")
@Operation(summary = "新增取款备选店铺", description = "新增一个待处理店铺名到当前用户的取款备选列表;同一用户下店铺名会规范化去重。")
public ApiResponse<ProductRiskCandidateVo> addCandidate(@Valid @RequestBody ProductRiskCandidateAddRequest request) {
public ApiResponse<ProductRiskCandidateVo> addCandidate(@Valid @RequestBody ProductRiskCandidateAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(withdrawResolveService.addCandidate(request));
}
@@ -76,21 +80,27 @@ public class WithdrawTaskController {
@Parameter(description = "备选店铺记录主键,即 candidates 接口返回的 id。", required = true, example = "100")
@PathVariable Long id,
@Parameter(name = "user_id", description = "当前登录用户 ID。", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
withdrawResolveService.deleteCandidate(userId, id);
return ApiResponse.success(null);
}
@PostMapping("/candidates/clear")
@Operation(summary = "批量清空取款备选店铺", description = "按店铺名批量删除当前用户的备选记录;通常在店铺成功推送到 Python 队列后清理已匹配数据。")
public ApiResponse<Void> clearCandidates(@Valid @RequestBody WithdrawCandidateClearRequest request) {
public ApiResponse<Void> clearCandidates(@Valid @RequestBody WithdrawCandidateClearRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
withdrawResolveService.deleteCandidatesByShopNames(request.getUserId(), request.getShopNames());
return ApiResponse.success(null);
}
@PostMapping("/match-shops")
@Operation(summary = "匹配取款店铺", description = "根据店铺名称批量查询紫鸟索引,返回店铺 ID、平台、公司名、匹配状态等信息;只有 matched=true 的店铺可创建任务。")
public ApiResponse<ProductRiskMatchShopsVo> matchShops(@Valid @RequestBody ProductRiskMatchShopsRequest request) {
public ApiResponse<ProductRiskMatchShopsVo> matchShops(@Valid @RequestBody ProductRiskMatchShopsRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(withdrawResolveService.matchShops(request));
}
@@ -98,7 +108,9 @@ public class WithdrawTaskController {
@Operation(summary = "查询取款看板统计", description = "返回当前用户的备选店铺数量、已结束任务数、成功任务数、失败任务数。")
public ApiResponse<ProductRiskDashboardVo> dashboard(
@Parameter(name = "user_id", description = "当前登录用户 ID。", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(withdrawTaskService.dashboard(userId));
}
@@ -106,31 +118,37 @@ public class WithdrawTaskController {
@Operation(summary = "查询取款任务记录", description = "查询当前用户取款模块的运行中和历史结果记录,包含任务状态、下载地址、店铺结果和明细行。")
public ApiResponse<WithdrawHistoryVo> history(
@Parameter(name = "user_id", description = "当前登录用户 ID。", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(withdrawTaskService.listHistory(userId));
}
@PostMapping("/tasks/progress/batch")
@Operation(summary = "批量查询取款任务进度", description = "前端轮询使用。按任务 ID 批量查询轻量进度和结果快照;不存在的任务 ID 会返回在 missingTaskIds 中。")
public ApiResponse<WithdrawTaskBatchVo> taskProgressBatch(@Valid @RequestBody WithdrawTaskBatchRequest request) {
// 归属过滤:只查询属于该用户的任务(userId 未传时保持原行为,兼容未升级调用方)
public ApiResponse<WithdrawTaskBatchVo> taskProgressBatch(@Valid @RequestBody WithdrawTaskBatchRequest request,
HttpServletRequest httpRequest) {
return ApiResponse.success(withdrawTaskService.getTaskProgressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request) {
// 透传 userId:此前传 null = 不过滤归属,匿名遍历 taskId 即可读他人任务状态(2026-09 审查)
return ApiResponse.success(withdrawTaskService.progressLight(request.getTaskIds(), request.getUserId()));
public ApiResponse<TaskProgressLightBatchVo> progressLight(@Valid @RequestBody TaskProgressLightRequest request,
HttpServletRequest httpRequest) {
// user_id 不再由请求体说了算:解析不出会话身份就 401(fail-closed,2026-10-07 收口)
return ApiResponse.success(withdrawTaskService.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
@PostMapping("/tasks")
@Operation(summary = "创建取款任务", description = "为一批已匹配店铺创建一个取款任务,写入任务记录和店铺结果占位记录,并返回 taskId 及初始店铺快照。")
public ApiResponse<WithdrawCreateTaskVo> createTask(@Valid @RequestBody WithdrawCreateTaskRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(withdrawTaskService.createTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@@ -154,7 +172,9 @@ public class WithdrawTaskController {
@Parameter(description = "结果记录 ID,即 history/items 中的 resultId。", required = true, example = "1001")
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID。", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
String url = withdrawTaskService.resolveResultDownloadUrl(resultId, userId);
if (url == null || url.isBlank()) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "暂无可下载结果");
@@ -174,7 +194,9 @@ public class WithdrawTaskController {
@Parameter(description = "取款任务 ID。", required = true, example = "200")
@PathVariable Long taskId,
@Parameter(name = "user_id", description = "当前登录用户 ID。", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
withdrawTaskService.deleteTask(taskId, userId);
return ApiResponse.success(null);
}
@@ -185,7 +207,9 @@ public class WithdrawTaskController {
@Parameter(description = "结果记录 ID,即 history/items 中的 resultId。", required = true, example = "1001")
@PathVariable Long resultId,
@Parameter(name = "user_id", description = "当前登录用户 ID。", required = true, in = ParameterIn.QUERY, example = "1")
@RequestParam("user_id") Long userId) {
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
withdrawTaskService.deleteHistory(resultId, userId);
return ApiResponse.success(null);
}
@@ -98,7 +98,9 @@ public class ZiniaoAuthController {
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "打开链接生成成功", content = @Content(schema = @Schema(implementation = ZiniaoOpenShopVo.class)))
})
public ApiResponse<ZiniaoOpenShopVo> openShop(HttpServletRequest request,
@Valid @RequestBody ZiniaoOpenShopRequest openShopRequest) {
@Valid @RequestBody ZiniaoOpenShopRequest openShopRequest,
HttpServletRequest httpRequest) {
openShopRequest.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, openShopRequest.getUserId()));
// 该接口返回员工级店铺登录令牌:匿名可达等于可接管任意员工卖家后台,必须管理员鉴权
adminAuthSupport.requireAdmin(request);
return ApiResponse.success(ziniaoAuthService.openShop(openShopRequest));
@@ -485,7 +485,9 @@ aiimage:
internal-token-previous: ${AIIMAGE_INTERNAL_TOKEN_PREVIOUS:}
internal-token-file: ${AIIMAGE_INTERNAL_TOKEN_FILE:}
auth:
jwt-secret: ${AIIMAGE_JWT_SECRET:please-change-this-secret-please-rotate-at-least-32-bytes}
# 占位符不许带默认值:带上的话「env 丢了」在 Java 侧读到的是那个公开字面量而不是空串,
# JwtService 的 server profile 启动闸门就永远不触发(静默用公开密钥签 token)。
jwt-secret: ${AIIMAGE_JWT_SECRET:}
jwt-ttl-hours: ${AIIMAGE_AUTH_JWT_TTL_HOURS:168}
cookie-name: ${AIIMAGE_AUTH_COOKIE_NAME:aiimage_token}
cookie-secure: ${AIIMAGE_AUTH_COOKIE_SECURE:false}
@@ -0,0 +1,221 @@
package com.nanri.aiimage.common.security;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import io.jsonwebtoken.Claims;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.test.util.ReflectionTestUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowableOfType;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* 归属用户 id 由会话推导(2026-10-07)的六面判定。
*
* <p>背景:用户态工具接口把"这批数据属于谁"完全交给请求参数 {@code user_id},
* 前端从 localStorage 取一个数字填进去,改这个数字就能读别人的任务。
* {@link AdminAuthSupport#resolveOwnershipUserId} 与 {@link AdminAuthSupport#requireOwnershipUserId}
* 把这层关系反过来:先认会话身份,参数只是兼容性输入。</p>
*
* <p>两个变体的分工必须是可证的,否则"fail-closed"只是一句注释:
* resolve 给还带不动凭据的存量客户端留窗口(解析不出身份就原样返回),
* require 只用在已取证**没有匿名调用方**的端点上(解析不出身份即 401)。</p>
*/
class AdminAuthSupportOwnershipTest {
private static final String INTERNAL_TOKEN = "internal-token-value";
// ---------- 会话身份优先:参数缺省 / 一致 / 冒名 ----------
@Test
void sessionIdentityFillsInOmittedUserId() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), null)).isEqualTo(7L);
}
@Test
void matchingUserIdIsPassedThroughUnchanged() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), 7L)).isEqualTo(7L);
}
@Test
void foreignUserIdIsRejectedWith403NotSilentlyTrusted() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
BusinessException ex = catchThrowableOfType(
() -> support.resolveOwnershipUserId(jwtRequest("t"), 8L), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).contains("user_id");
}
/** 冒名在 require 变体上是同一个结果:不能因为"这个端点要求登录"就漏掉归属比对。 */
@Test
void requireVariantRejectsForeignUserIdToo() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
BusinessException ex = catchThrowableOfType(
() -> support.requireOwnershipUserId(jwtRequest("t"), 8L), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
}
// ---------- 管理角色豁免:但不得替它凭空造一个归属 ----------
@Test
void adminMayActForAnotherUser() {
AdminAuthSupport support = withJwtUser(user(1L, "admin", 1, 1L));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), 8L)).isEqualTo(8L);
}
/**
* 公司超管与超管在业务数据面逻辑一致(2026-10-07 口径)。
* 上一版豁免逐个列角色名,漏了 company_super_admin,公司超管在网页端按客户查任务被自己的守卫挡成 403。
*/
@Test
void companySuperAdminIsExemptedToo() {
AdminAuthSupport support = withJwtUser(user(2L, "company_super_admin", 0, 1L));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), 8L)).isEqualTo(8L);
assertThat(support.mayActForOtherUsers(user(2L, "company_super_admin", 0, 1L))).isTrue();
}
/** 管理角色不传 user_id 时保持"不预设范围",而不是悄悄换成它自己的 id(后台默认看全量)。 */
@Test
void adminOmittingUserIdGetsNoImplicitOwner() {
AdminAuthSupport support = withJwtUser(user(1L, "super_admin", 1, null));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), null)).isNull();
}
@Test
void ordinaryRoleIsNotExemptedFromBinding() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 1, 1L));
assertThat(support.mayActForOtherUsers(user(7L, "normal", 1, 1L))).isFalse();
assertThat(support.mayActForOtherUsers(null)).isFalse();
}
// ---------- 两个变体的分界线:解析不出身份时 ----------
/** 存量桌面客户端不带凭据:resolve 必须原样返回,否则线上集采/跟价整条 401。 */
@Test
void resolveKeepsRequestParamWhenNoIdentityResolves() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
assertThat(support.resolveOwnershipUserId(new MockHttpServletRequest("GET", "/api/publish/tasks/1/items"), 8L))
.isEqualTo(8L);
}
/** require 正相反:没登录就没有"归属"可谈,直接 401。 */
@Test
void requireRejectsAnonymousWith401() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
BusinessException ex = catchThrowableOfType(
() -> support.requireOwnershipUserId(new MockHttpServletRequest("GET", "/api/publish/dashboard"), 8L),
BusinessException.class);
assertThat(ex.getCode()).isEqualTo(401);
}
// ---------- 内部令牌不是冒名通行证 ----------
/**
* X-Internal-Token + operatorId 解析得出身份后按该身份绑定:令牌是硬编码在分发包里的静态密钥,
* 证明得了"走了内部通道",证明不了"这个 user_id 是谁"。
*/
@Test
void internalOperatorIsBoundToItsOwnIdentity() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(3L)).thenReturn(user(3L, "normal", 0, null));
AdminAuthSupport support = internalTokenSupport(userMapper);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/tasks/1/items");
request.addHeader("X-Internal-Token", INTERNAL_TOKEN);
request.setParameter("operatorId", "3");
BusinessException ex = catchThrowableOfType(
() -> support.resolveOwnershipUserId(request, 8L), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
}
/** 纯令牌(不带 JWT、不带 operatorId)解析不出身份 —— 这条形状是存量客户端的实际形态,必须零影响。 */
@Test
void internalTokenWithoutOperatorIdStaysUnbound() {
AdminAuthSupport support = internalTokenSupport(defaultMapper());
MockHttpServletRequest request = new MockHttpServletRequest("POST", "/api/publish/tasks/1/result");
request.addHeader("X-Internal-Token", INTERNAL_TOKEN);
assertThat(support.resolveOwnershipUserId(request, 8L)).isEqualTo(8L);
}
@Test
void untrustedTokenIsNotAnInternalIdentity() {
AdminAuthSupport support = internalTokenSupport(defaultMapper());
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/dashboard");
request.addHeader("X-Internal-Token", "guessed-token");
assertThat(support.resolveOwnershipUserId(request, 8L)).isEqualTo(8L);
BusinessException ex = catchThrowableOfType(
() -> support.requireOwnershipUserId(request, 8L), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(401);
}
// ---------- 夹具 ----------
private AdminUserMapper defaultMapper() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(any())).thenReturn(null);
return userMapper;
}
/** 只装内部令牌通道:JWT 一律解析失败,用来单独验操作者身份那半条链。 */
private AdminAuthSupport internalTokenSupport(AdminUserMapper userMapper) {
JwtService jwtService = mock(JwtService.class);
when(jwtService.parse(any())).thenReturn(null);
AdminAuthSupport support = new AdminAuthSupport(
jwtService, userMapper, mock(AuthProperties.class), mock(AccountExpiryService.class));
ReflectionTestUtils.setField(support, "internalToken", INTERNAL_TOKEN);
ReflectionTestUtils.setField(support, "internalTokenFile", "");
return support;
}
private AdminAuthSupport withJwtUser(AdminUserEntity user) {
JwtService jwtService = mock(JwtService.class);
Claims claims = mock(Claims.class);
when(claims.getSubject()).thenReturn(String.valueOf(user.getId()));
when(jwtService.parse("t")).thenReturn(claims);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(user.getId())).thenReturn(user);
AuthProperties props = mock(AuthProperties.class);
when(props.isSingleDeviceEnabled()).thenReturn(false);
return new AdminAuthSupport(jwtService, userMapper, props, mock(AccountExpiryService.class));
}
private MockHttpServletRequest jwtRequest(String token) {
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/dashboard");
request.addHeader(HttpHeaders.AUTHORIZATION, "Bearer " + token);
return request;
}
private AdminUserEntity user(Long id, String role, int isAdmin, Long createdById) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setUsername("u" + id);
user.setRole(role);
user.setIsAdmin(isAdmin);
user.setCreatedById(createdById);
return user;
}
}
@@ -0,0 +1,146 @@
package com.nanri.aiimage.common.security;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
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 org.junit.jupiter.api.Test;
import org.springframework.test.util.ReflectionTestUtils;
/**
* 「JWT 密钥不许悄悄回退到公开默认值」这一族的绊线(2026-10-07 架构三期,缺陷 (f) 收口)。
*
* <p>改之前的形状不是「没做检查」而是「检查够不着」:{@code JwtService} 早在 2026-09 就加了
* 「server profile 未配置密钥即拒绝启动」,判据是 {@code isBlank()};而 application.yml 写的是
* {@code ${AIIMAGE_JWT_SECRET:please-change-this-...}} —— 占位符自带默认值,env 丢失时
* {@code getJwtSecret()} 拿到的是那个<b>公开字面量</b>而不是空串,闸门于是不触发,
* 全站继续用一把写在源码里的密钥签 token(任何人可伪造)。同一条链路 2026-09-14 已经在
* 主机 A 的 15126 Flask 上挂过一次:真实用户 token 全 401,用默认密钥自签的反而 200。</p>
*
* <p>现在的口径:默认值从占位符里摘掉 ⇒ 未配置就是空串 ⇒ 闸门真能拦住;并且闸门改成
* 「空 或 等于那把公开密钥」都不许启动,这样即使有人在别的 profile 文件里把字面量抄回来,
* server profile 仍然起不来。非 server profile(本地开发/测试)保持宽松,否则无法启动。</p>
*/
class JwtSecretFallbackGuardrailTest {
private static final String PUBLIC_SECRET =
"please-change-this-secret-please-rotate-at-least-32-bytes";
/** 占位符的正确形状:冒号后必须什么都没有。 */
private static final Pattern JWT_PLACEHOLDER =
Pattern.compile("\\$\\{AIIMAGE_JWT_SECRET:([^}]*)\\}");
@Test
void noResourceFileShipsThePublicSecretAsADefault() {
List<String> offenders = new ArrayList<>();
for (Path file : resources()) {
String name = file.getFileName().toString();
if (!name.endsWith(".yml") && !name.endsWith(".yaml") && !name.endsWith(".properties")) {
continue;
}
String text = read(file);
Matcher m = JWT_PLACEHOLDER.matcher(text);
while (m.find()) {
if (!m.group(1).isEmpty()) {
offenders.add(name + " 占位符带了默认值 →" + m.group(1));
}
}
if (text.contains(PUBLIC_SECRET)) {
offenders.add(name + " 直接写入了那把公开密钥");
}
}
assertThat(offenders)
.as("resources 里 AIIMAGE_JWT_SECRET 的兜底值 —— 有兜底值时 server profile 的启动闸门就够不着")
.isEmpty();
// 反向:占位符本身还得在,否则「摘掉默认值」会变成「整行删掉」,配置通道就断了
assertThat(resources().stream().map(this::read).anyMatch(t -> t.contains("${AIIMAGE_JWT_SECRET:}")))
.as("必须仍从 AIIMAGE_JWT_SECRET 读取").isTrue();
}
@Test
void unconfiguredPropertiesYieldABlankSecret() {
// 这条是「闸门够得着」的前提:字段默认值一旦还是那把公开密钥,yml 摘干净也没用
assertThat(new AuthProperties().getJwtSecret()).as("AuthProperties 的字段默认值").isBlank();
}
@Test
void theBlankAndThePublicLiteralAreBothInsecureWhileARealKeyIsNot() {
assertThat(JwtService.isInsecure(null)).isTrue();
assertThat(JwtService.isInsecure("")).isTrue();
assertThat(JwtService.isInsecure(" ")).as("空白串").isTrue();
assertThat(JwtService.isInsecure(PUBLIC_SECRET)).as("公开默认值必须算不安全").isTrue();
assertThat(JwtService.isInsecure(PUBLIC_SECRET + "x")).as("差一个字符就不是那把公开密钥").isFalse();
assertThat(JwtService.isInsecure("a-real-rotated-secret-of-plenty-of-length-32plus")).isFalse();
}
@Test
void serverProfileRefusesToStartOnEitherInsecureShape() {
for (String secret : List.of("", PUBLIC_SECRET)) {
assertThatThrownBy(() -> bootWith("server", secret))
.as("server profile + jwt-secret=[" + secret + "]")
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("AIIMAGE_JWT_SECRET");
}
assertThatCode(() -> bootWith("server", "a-real-rotated-secret-of-plenty-of-length-32plus"))
.as("server profile + 真密钥:不许误伤正常启动").doesNotThrowAnyException();
}
/** 本地/测试 profile 保持宽松:否则每个开发机和每例集成测试都起不来,只会被绕过。 */
@Test
void nonServerProfileStillBootsWithoutASecret() {
assertThatCode(() -> bootWith("local", "")).doesNotThrowAnyException();
assertThatCode(() -> bootWith("", PUBLIC_SECRET)).doesNotThrowAnyException();
}
// ---- 夹具 ----
private static void bootWith(String activeProfile, String jwtSecret) {
AuthProperties props = new AuthProperties();
props.setJwtSecret(jwtSecret);
JwtService service = new JwtService(props);
ReflectionTestUtils.setField(service, "activeProfiles", activeProfile);
service.requireSecretInServerProfile();
}
private static List<Path> resources() {
Path dir = mainRoot().resolve("main").resolve("resources");
if (!Files.isDirectory(dir)) {
dir = Path.of("src", "main", "resources");
}
List<Path> out = new ArrayList<>();
try (Stream<Path> stream = Files.walk(dir, 2)) {
stream.filter(Files::isRegularFile).forEach(out::add);
} catch (IOException e) {
throw new IllegalStateException("遍历 resources 失败: " + dir, e);
}
assertThat(out).as("resources 文件数过少说明扫描根走错了").hasSizeGreaterThan(5);
return out;
}
private String read(Path file) {
try {
return Files.readString(file, StandardCharsets.UTF_8);
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
/** src 目录(test 类与 main 同级,surefire 的 cwd 是模块根)。 */
private static Path mainRoot() {
Path here = Path.of("").toAbsolutePath();
Path direct = here.resolve("src");
if (Files.isDirectory(direct)) {
return direct;
}
return here.resolve("backend-java").resolve("src");
}
}
@@ -0,0 +1,334 @@
package com.nanri.aiimage.common.security;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.modules.queryasin.controller.QueryAsinTaskController;
import com.nanri.aiimage.modules.queryasin.service.QueryAsinResolveService;
import com.nanri.aiimage.modules.queryasin.service.QueryAsinTaskService;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.dto.TaskProgressLightRequest;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.service.TaskProgressOwnershipSupport;
import com.nanri.aiimage.testutil.SourceScan;
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 org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
/**
* 「轮询类端点的归属只能由会话说了算」这一族的绊线(2026-10-07 架构三期,缺陷 (d) 收口)。
*
* <p>改之前的形状:12 个模块的 {@code /tasks/progress/batch} + {@code /tasks/progress/light} 与
* 4 个模块的 {@code /tasks/batch}(共 28 支 handler)里,归属用的 {@code user_id} <b>全部取自请求体</b>。
* 请求体里的 id 不是身份,是参数——它有两种坏用法,而且都不报错:</p>
* <ol>
* <li>带上<b>别人的</b> user_id:{@code filterOwnedTaskIds} 与 {@code TaskProgressLightAssembler}
* 都是 {@code user_id = ?} 的正向匹配 ⇒ 匹配的就是别人那一堆任务,越权读命中;</li>
* <li>不带 user_id:{@code filterOwnedTaskIds} 见 null 原样返回、assembler 见 null 不加条件 ⇒
* 匿名遍历自增 taskId 就能读他人任务的状态、错误信息与结果文件就绪标记。</li>
* </ol>
*
* <p>现在的口径:这 28 支一律把请求体 id 交给 {@link AdminAuthSupport#requireOwnershipUserId}
* (解析不出会话身份即 401),网页端恒带 JWT({@code frontend-vue/src/shared/api/http.ts} 的
* cookie + Bearer 两路),而这批端点的调用方<b>只有网页端</b>——桌面执行器不轮询进度
* (2026-10-07 全树 grep:{@code app_client} 里 0 个 {@code tasks/progress} 调用点,只有我自己那支
* live 冒烟脚本)。管理身份仍看得到全部(出口对管理角色返回原参数=不加归属条件),所以后台没被挡。</p>
*
* <p>每支判据都带能红/能绿两向探针,且判据打在<b>剥掉注释的源码</b>上:本类的分母与计数都是
* 「必须等于 N」那一形,吃原文的话谁在注释里提一句 {@code requireOwnershipUserId(} 就能把它喂饱。</p>
*/
class ProgressQueryOwnershipOutletTest {
/** 这一族的全部宿主:12 个模块控制器。少一支就是有人把端点挪去了别处,多一支就是新开了页。 */
private static final List<String> FAMILY_CONTROLLERS = List.of(
"modules/appearancepatent/controller/AppearancePatentController.java",
"modules/collectdata/controller/CollectDataController.java",
"modules/deletebrand/controller/DeleteBrandRunController.java",
"modules/patroldelete/controller/PatrolDeleteController.java",
"modules/pricetrack/controller/PriceTrackController.java",
"modules/productrisk/controller/ProductRiskResolveController.java",
"modules/publish/controller/PublishController.java",
"modules/queryasin/controller/QueryAsinTaskController.java",
"modules/shopdatacrawl/controller/ShopDataCrawlTaskController.java",
"modules/shopmatch/controller/ShopMatchController.java",
"modules/similarasin/controller/SimilarAsinController.java",
"modules/withdraw/controller/WithdrawTaskController.java");
private static final String OUTLET = "requireOwnershipUserId(httpRequest, request.getUserId()";
private static final String WRITE_BACK = "request.setUserId(adminAuthSupport." + OUTLET + "))";
private static final String BODY_USER_ID = "request.getUserId()";
/**
* {@link #nullMeansAuthenticatedAdminWhileAnyUserIdFilters} 走的是真 {@code LambdaQueryWrapper},
* 而纯单测没有 Spring 启动去建 TableInfo 缓存 ⇒ 列名解析会抛 "can not find lambda cache"。
* 同 {@code CompanyScopeSupportTest} 的既有做法:手工注册实体。
*/
@BeforeAll
static void initMybatisPlusTableInfo() {
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
FileTaskEntity.class);
}
@Test
void everyPollingHandlerBindsTheBodyUserIdToTheSession() {
List<String> offenders = new ArrayList<>();
int handlers = 0;
for (String rel : FAMILY_CONTROLLERS) {
String source = SourceScan.withoutComments(read(mainRoot().resolve(rel)));
for (String mapping : List.of("/tasks/progress/batch", "/tasks/progress/light", "/tasks/batch")) {
for (String segment : handlerSegments(source, mapping)) {
handlers++;
if (!isBoundToSession(segment)) {
offenders.add(rel + " " + mapping + " → " + segment.replace('\n', ' ').trim());
}
}
}
}
// 分母先钉死:28 = 12 progress/batch + 12 progress/light + 4 tasks/batch。
// 扫描坏掉(切不出 handler)与「真的没人漏接」在这一步就会分岔,不会一起恒绿。
assertThat(handlers).as("轮询族 handler 总数").isEqualTo(28);
assertThat(offenders)
.as("归属仍取自请求体(没走会话出口)的 handler")
.isEmpty();
}
@Test
void eachMappingKeepsItsOwnDenominator() {
// 三条分母各钉一个数:整批漏接与某一族整批消失是两种不同的事故,红因要能分开说。
assertThat(countHandlers("/tasks/progress/batch")).as("progress/batch 端点数").isEqualTo(12);
assertThat(countHandlers("/tasks/progress/light")).as("progress/light 端点数").isEqualTo(12);
assertThat(countHandlers("/tasks/batch")).as("tasks/batch(任务详情批量)端点数").isEqualTo(4);
}
/**
* 出口绑定的<b>值</b>必须真的进到查询里,而不是绑完丢掉。
*
* <p>这一支是 {@link #everyPollingHandlerBindsTheBodyUserIdToTheSession} 抓不到的那一形:
* 文本上 {@code requireOwnershipUserId(} 还在(甚至结果被赋给一个没人读的局部变量),
* 但传给 service 的仍是请求体原值 ⇒ 归属等于没改。这里用真 MockMvc 走一遍 HTTP,
* 打桩出口返回一个与请求体不同的 id(4242 ≠ 7),要求 service 收到的必须是 4242。</p>
*/
@Test
void theBoundUserIdIsWhatActuallyReachesTheQuery() throws Exception {
QueryAsinTaskService taskService = mock(QueryAsinTaskService.class);
AdminAuthSupport auth = mock(AdminAuthSupport.class);
when(auth.requireOwnershipUserId(any(), eq(7L))).thenReturn(4242L);
MockMvc mockMvc = MockMvcBuilders.standaloneSetup(new QueryAsinTaskController(
mock(QueryAsinResolveService.class), taskService,
new TaskProgressOwnershipSupport(null), auth)).build();
mockMvc.perform(post("/api/query-asin/tasks/progress/light")
.contentType(MediaType.APPLICATION_JSON)
.content(new ObjectMapper().writeValueAsString(
new TaskProgressLightRequest(List.of(3938L), 7L))))
.andExpect(status().isOk());
verify(taskService).progressLight(List.of(3938L), 4242L);
}
/**
* 判据本身要能红:三种坏形状必须判不通过,两种好形状必须判通过。
*
* <p>缺了负样本,{@link #isBoundToSession} 写成 {@code return true} 也会一路绿。</p>
*/
@Test
void theBindingPredicateIsNotVacuous() {
String unboundInline = """
@PostMapping("/tasks/progress/batch")
public ApiResponse<Void> x(@RequestBody R request) {
return ApiResponse.success(service.progressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(), request.getUserId())));
}
""";
String noFilterAtAll = """
@PostMapping("/tasks/progress/batch")
public ApiResponse<Void> x(@RequestBody R request) {
return ApiResponse.success(service.getTaskProgressBatch(request.getTaskIds()));
}
""";
String boundButDiscarded = """
@PostMapping("/tasks/progress/light")
public ApiResponse<Void> x(@RequestBody R request, HttpServletRequest httpRequest) {
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId());
return ApiResponse.success(service.progressLight(request.getTaskIds(), request.getUserId()));
}
""";
for (String bad : List.of(unboundInline, noFilterAtAll, boundButDiscarded)) {
assertThat(isBoundToSession(bad)).as("坏形状必须判不通过:" + bad.trim()).isFalse();
}
String goodInline = """
@PostMapping("/tasks/progress/batch")
public ApiResponse<Void> x(@RequestBody R request, HttpServletRequest httpRequest) {
return ApiResponse.success(service.progressBatch(progressOwnershipSupport
.filterOwnedTaskIds(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()))));
}
""";
assertThat(isBoundToSession(goodInline)).as("内联写法(族内 22 支的形状)").isTrue();
String goodWriteBack = """
@PostMapping("/tasks/progress/light")
public ApiResponse<Void> x(@RequestBody R request, HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(service.progressLight(request.getUserId(), request.getTaskIds()));
}
""";
assertThat(isBoundToSession(goodWriteBack)).as("写回 DTO 再取用的写法(Publish 那两支的形状)").isTrue();
// 注释里提一句出口名,不许把判据喂饱(本类扫的是剥完注释的源码)
assertThat(isBoundToSession(SourceScan.withoutComments("""
@PostMapping("/tasks/progress/light")
public ApiResponse<Void> x(@RequestBody R request) {
// adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()) 早就接上了
return ApiResponse.success(service.progressLight(request.getTaskIds(), request.getUserId()));
}
"""))).as("注释不得算作已接线").isFalse();
}
/**
* 放宽只剩一条通路:null=已认证的管理身份,不是匿名。
*
* <p>{@code filterOwnedTaskIds} 见 null 原样返回、{@code TaskProgressLightAssembler} 见 null 不加
* 条件,这两处<b>故意</b>留给管理角色(后台按客户看任务是本职)。收口之后它们只可能由
* {@link AdminAuthSupport#requireOwnershipUserId} 交出 null(出口对管理角色返回原参数),
* 匿名请求在出口就 401。这里钉住这条通路的两个方向:null 不过滤、非 null 必须过滤掉别人的 id。</p>
*/
@Test
void nullMeansAuthenticatedAdminWhileAnyUserIdFilters() {
FileTaskMapper mapper = mock(FileTaskMapper.class);
when(mapper.selectList(any())).thenReturn(List.of(task(3938L)));
TaskProgressOwnershipSupport support = new TaskProgressOwnershipSupport(mapper);
// null(管理身份):原样返回,且不发 SQL —— 否则后台每一页轮询都多打一次任务表
List<Long> all = List.of(3938L, 3939L);
assertThat(support.filterOwnedTaskIds(all, null)).isEqualTo(all);
verify(mapper, never()).selectList(any());
// 非 null:只有真属于它的 id 留下,别人的被剔掉
assertThat(support.filterOwnedTaskIds(List.of(3938L, 3939L), 7L)).containsExactly(3938L);
// 光看返回值抓不到「打了 SQL 但没带归属条件」——mock 的 selectList 是无条件回桩的。
// 所以必须把 wrapper 抓出来,钉住 user_id 这一列和会话推出来的那个值。
ArgumentCaptor<LambdaQueryWrapper<FileTaskEntity>> captor =
ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(mapper).selectList(captor.capture());
captor.getValue().getSqlSegment(); // MP 惯例:先求值一次才铺出参数
assertThat(captor.getValue().getSqlSegment()).contains("user_id");
assertThat(captor.getValue().getParamNameValuePairs().values()).contains(7L);
}
// ---- 判据 ----
/** 一支 handler 的归属是不是从会话来的(两种合规写法见 {@link #theBindingPredicateIsNotVacuous})。 */
private static boolean isBoundToSession(String handlerSegment) {
if (!handlerSegment.contains("HttpServletRequest httpRequest")) {
return false;
}
int outlet = count(handlerSegment, OUTLET);
int uses = count(handlerSegment, BODY_USER_ID);
if (outlet == 0) {
return false;
}
if (uses == outlet) {
return true; // 内联:每一次取 body id 都在出口实参里
}
return handlerSegment.contains(WRITE_BACK) && uses == 2 * outlet; // 写回 DTO 后复用
}
private static int countHandlers(String mapping) {
int n = 0;
for (String rel : FAMILY_CONTROLLERS) {
n += handlerSegments(SourceScan.withoutComments(read(mainRoot().resolve(rel))), mapping).size();
}
return n;
}
/** 从 {@code @PostMapping("<mapping>")} 起,按大括号配平取到该方法收尾(含签名,签名里有 httpRequest 参数)。 */
private static List<String> handlerSegments(String source, String mapping) {
String anchor = "@PostMapping(\"" + mapping + "\")";
List<String> out = new ArrayList<>();
for (int i = source.indexOf(anchor); i >= 0; i = source.indexOf(anchor, i + anchor.length())) {
int body = source.indexOf('{', i);
int end = matchBraces(source, body);
if (end < 0) {
continue;
}
out.add(source.substring(i, end + 1));
}
return out;
}
private static int matchBraces(String source, int open) {
if (open < 0) {
return -1;
}
int depth = 0;
for (int i = open; i < source.length(); i++) {
char c = source.charAt(i);
if (c == '{') {
depth++;
} else if (c == '}' && --depth == 0) {
return i;
}
}
return -1;
}
private static FileTaskEntity task(Long id) {
FileTaskEntity entity = new FileTaskEntity();
entity.setId(id);
return entity;
}
private static int count(String text, String needle) {
int n = 0;
for (int i = text.indexOf(needle); i >= 0; i = text.indexOf(needle, i + needle.length())) {
n++;
}
return n;
}
private static Path mainRoot() {
Path here = Path.of("").toAbsolutePath();
Path direct = here.resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(direct)) {
return direct;
}
Path nested = here.resolve("backend-java").resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(nested)) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 源码目录(cwd=" + here + ")");
}
private static String read(Path file) {
if (!Files.isRegularFile(file)) {
fail("找不到 " + file + " —— 本族有控制器被改名/挪走了,护栏要红在这里而不是跳过");
}
try {
return Files.readString(file, StandardCharsets.UTF_8);
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
}
@@ -0,0 +1,298 @@
package com.nanri.aiimage.common.security;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import com.nanri.aiimage.testutil.SourceScan;
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.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
/**
* 「操作者身份不许由请求参数说了算」的全族绊线(2026-10-07 架构三期,缺陷 (d)/(g) 收口)。
*
* <p>收口前的形状:模块控制器里 <b>190 支</b> handler 把 {@code user_id}(query 参数、请求体字段,
* 或"控制器把带 userId 的 DTO 整个交给 service")直接当身份交给下游做归属比对。请求参数不是身份,
* 它有两种坏用法,而且都不报错:</p>
* <ol>
* <li>带<b>别人的</b> user_id ⇒ 归属比对拿它去匹配别人的行,越权读/越权改(删除历史行、
* 停止别人的循环跟价、清空别人的备选店铺);</li>
* <li>不带 ⇒ 归属条件多半写成 {@code userId != null && ...},匿名请求即"不加过滤"。</li>
* </ol>
*
* <p>现在的口径:这类 handler 一律先把请求里的 id 交给 {@code resolveOwnershipUserId} /
* {@code requireOwnershipUserId}。前者对<b>已认证</b>调用方做校验(缺省用会话 id、不一致 403、
* 管理角色豁免),对解析不出身份的调用方原样透传并计入 {@code [ownership-anonymous]};
* fail-closed 的 require 只用在已取证"没有匿名调用方"的进度轮询族(见
* {@link ProgressQueryOwnershipOutletTest})——桌面执行器 4.0.44 出厂版还不带登录 JWT,
* 把写类端点一起翻成 require 会把执行器整批打成 401,所以这一步走的是日志归零再翻。</p>
*
* <p>扫描一律打在 {@link SourceScan#withoutComments} 剥掉注释的源码上,且判据是"必须存在/等于 N"
* 那一形:不剥注释的话,谁在 {@code @Operation} 描述或行尾注释里提一句出口名,就能把护栏喂饱。
* 分母(写 126 / 读 63,另有 1 支在册豁免)同样钉死,扫描器坏掉与"真的没人漏接"不会一起恒绿。
* 这 190 支里有 39 支是 DTO 形态——只 grep 文本上的 {@code getUserId()} 会把它们整批看漏,
* 所以 {@link #dtoTypesWithUserId()} 必须先建一遍"哪些请求类声明了 userId 字段"的索引。</p>
*/
class RequestSuppliedIdentityOutletTest {
/** 一支 handler 只要从请求里取身份,就必须落到这三个出口之一(第三个是各控制器的本人 id 取法)。 */
private static final List<String> OUTLETS = List.of(
"resolveOwnershipUserId(httpRequest",
"requireOwnershipUserId(httpRequest",
"currentUserId(httpRequest");
private static final Pattern MAPPING =
Pattern.compile("@(Post|Put|Delete|Patch|Get|RequestMapping)Mapping(?:\\(([^)]*)\\))?");
private static final Pattern PARAM_UID = Pattern.compile(
"@RequestParam\\(\\s*(?:(?:value|name)\\s*=\\s*)?\"(?:user_id|userId)\"[^)]*\\)"
+ "\\s+(?:@[^,)]+\\s+)*Long\\s+\\w+");
private static final List<String> WRITE_VERBS = List.of("Post", "Put", "Delete", "Patch");
/** Spring 的 @RequestBody(前面是 @,不含 swagger 那个纯文档注解)里的 DTO 类型名。 */
private static final Pattern BODY_DTO =
Pattern.compile("@RequestBody\\s+(?:@[^,)]+\\s+)*([A-Z]\\w*)\\s+\\w+");
/** 自带 userId 字段的请求 DTO:控制器只是把它转交下去,真正读 userId 的是 service。 */
private static final Set<String> DTO_TYPES_WITH_USER_ID = dtoTypesWithUserId();
/**
* 登记在册的豁免:命中 {@code X-Internal-Token} 才可达的服务间查询(方法体内 fail-closed 401),
* 参数是"被查询的用户"而不是"操作者",套归属出口反而会把 Flask 后台的查询打成空值。
*
* <p>这一条必须<b>同时</b>满足:出现在豁免表里、且现在仍然没有接出口。哪天有人把它接上了,
* {@link #allowlistEntriesAreStillNeeded()} 会红,要求把这条从这里删掉——豁免表只许变小。</p>
*/
private static final List<String> ALLOWED_WITHOUT_OUTLET = List.of(
"modules/usersecret/controller/InternalUserProxyController.java Get /user-proxy");
@Test
void everyHandlerReadingARequestSuppliedUserIdRoutesItThroughAnOutlet() {
List<String> violations = new ArrayList<>();
Scan scan = scanAll();
for (String entry : scan.unbound()) {
if (!ALLOWED_WITHOUT_OUTLET.contains(entry)) {
violations.add(entry);
}
}
assertThat(violations)
.as("身份仍取自请求参数(没走会话出口)的 handler —— 带别人的 user_id 就能越权读写")
.isEmpty();
}
@Test
void theScanCoversBothVerbsWithPinnedDenominators() {
Scan scan = scanAll();
// 28 支进度轮询走 require,其余写类/读类走 resolve;两边都算"已接出口"。
assertThat(scan.boundWrite()).as("取请求身份且已接出口的写类 handler 数").isEqualTo(126);
assertThat(scan.boundRead()).as("取请求身份且已接出口的读类 handler 数").isEqualTo(63);
assertThat(scan.unbound()).as("取请求身份但未接出口的 handler:只剩豁免那一条")
.containsExactlyElementsOf(ALLOWED_WITHOUT_OUTLET);
}
/** 豁免不是永久产权:条目自己失效(端点已接上出口或已下线)就必须从表里删掉。 */
@Test
void allowlistEntriesAreStillNeeded() {
Scan scan = scanAll();
assertThat(scan.unbound())
.as("豁免表里的每一条必须仍然处于未接出口状态")
.containsExactlyElementsOf(ALLOWED_WITHOUT_OUTLET);
}
/**
* 判据本身要能红:没接出口的必须被判出来,接上的、以及只在注释里提一句的都不许算数。
*
* <p>缺这一支,{@link #scanAll} 的"已接出口"写成恒真也会一路绿。</p>
*/
@Test
void theOutletDetectionIsNotVacuous() {
String unbound = """
@GetMapping("/dashboard")
public ApiResponse<Void> dashboard(@RequestParam("user_id") Long userId) {
return ApiResponse.success(service.dashboard(userId));
}
""";
assertThat(isBound(unbound)).as("裸转发请求里的 user_id 必须判为未接出口").isFalse();
assertThat(readsRequestIdentity(unbound)).isTrue();
String boundResolve = """
@GetMapping("/dashboard")
public ApiResponse<Void> dashboard(@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
userId = adminAuthSupport.resolveOwnershipUserId(httpRequest, userId);
return ApiResponse.success(service.dashboard(userId));
}
""";
assertThat(isBound(boundResolve)).as("resolve 写法(写类/读类收口后的形状)").isTrue();
String boundRequire = """
@PostMapping("/tasks/progress/light")
public ApiResponse<Void> light(@RequestBody R request, HttpServletRequest httpRequest) {
return ApiResponse.success(service.progressLight(request.getTaskIds(),
adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId())));
}
""";
assertThat(isBound(boundRequire)).as("require 写法(进度轮询族)").isTrue();
// 注释里把出口名写全,也不许把判据喂饱——这正是本类扫剥注释源码的理由
String commentOnly = SourceScan.withoutComments("""
@GetMapping("/history")
public ApiResponse<Void> history(@RequestParam("user_id") Long userId) {
// adminAuthSupport.resolveOwnershipUserId(httpRequest, userId) 已经接好了
return ApiResponse.success(service.history(userId));
}
""");
assertThat(isBound(commentOnly)).as("注释不得算作已接出口").isFalse();
assertThat(readsRequestIdentity(commentOnly)).as("但请求里的身份仍要被扫出来,否则漏网端点隐身").isTrue();
}
/** DTO 形态:控制器不显式取 getUserId(),而是把 request 整个交给 service,由 service 读里面的 userId。 */
@Test
void dtoCarryingHandlersAreCountedToo() {
String dtoHandler = """
@PostMapping("/candidates")
public ApiResponse<Void> add(@RequestBody ProductRiskCandidateAddRequest request) {
withdrawResolveService.addCandidate(request);
}
""";
// 文本上没有 getUserId(),靠的是「DTO 里声明了 userId 字段」这一层;
// 识别不出来的话,新建的 DTO 型端点会整批隐身在本护栏之外
assertThat(readsRequestIdentity(dtoHandler))
.as("ProductRiskCandidateAddRequest 带 userId 字段,改造前就该被扫出来")
.isTrue();
String boundDto = """
@PostMapping("/candidates")
public ApiResponse<Void> add(@RequestBody ProductRiskCandidateAddRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
withdrawResolveService.addCandidate(request);
}
""";
assertThat(readsRequestIdentity(boundDto)).isTrue();
assertThat(isBound(boundDto)).isTrue();
}
// ---- 扫描 ----
private record Scan(List<String> unbound, int boundWrite, int boundRead) {
}
private static Scan scanAll() {
List<String> unbound = new ArrayList<>();
int boundWrite = 0;
int boundRead = 0;
Path controllers = mainRoot().resolve("modules");
List<Path> files = new ArrayList<>();
try (Stream<Path> stream = Files.walk(controllers)) {
stream.filter(p -> p.getFileName().toString().endsWith("Controller.java")).forEach(files::add);
} catch (IOException e) {
throw new IllegalStateException("遍历模块控制器失败", e);
}
assertThat(files).as("模块控制器数量少于 20 说明扫描根走错了").hasSizeGreaterThan(20);
for (Path file : files) {
String source = SourceScan.withoutComments(read(file));
String rel = mainRoot().relativize(file).toString().replace('\\', '/');
Matcher current = MAPPING.matcher(source);
List<int[]> anchors = new ArrayList<>();
List<String> verbs = new ArrayList<>();
List<String> paths = new ArrayList<>();
while (current.find()) {
if ("RequestMapping".equals(current.group(1))) {
continue; // 类级前缀不是 handler
}
anchors.add(new int[]{current.start(), current.end()});
verbs.add(current.group(1));
Matcher vm = Pattern.compile("\"([^\"]+)\"").matcher(current.group(2) == null ? "" : current.group(2));
paths.add(vm.find() ? vm.group(1) : "");
}
for (int i = 0; i < anchors.size(); i++) {
int from = anchors.get(i)[0];
int to = i + 1 < anchors.size() ? anchors.get(i + 1)[0] : source.length();
String region = source.substring(from, to);
if (!readsRequestIdentity(region)) {
continue;
}
if (isBound(region)) {
if (WRITE_VERBS.contains(verbs.get(i))) {
boundWrite++;
} else {
boundRead++;
}
} else {
unbound.add(rel + " " + verbs.get(i) + " " + paths.get(i));
}
}
}
return new Scan(unbound, boundWrite, boundRead);
}
private static boolean readsRequestIdentity(String region) {
if (PARAM_UID.matcher(region).find() || region.contains(".getUserId()")) {
return true;
}
// 只看文本上的 getUserId() 会漏掉「控制器把 DTO 整个交给 service」那一形——
// 新建端点正是这个形状,漏了它本类就成了「只保护已收口的」。
Matcher dto = BODY_DTO.matcher(region);
while (dto.find()) {
if (DTO_TYPES_WITH_USER_ID.contains(dto.group(1))) {
return true;
}
}
return false;
}
private static Set<String> dtoTypesWithUserId() {
List<Path> files = new ArrayList<>();
try (Stream<Path> stream = Files.walk(mainRoot())) {
stream.filter(p -> p.getFileName().toString().endsWith(".java")).forEach(files::add);
} catch (IOException e) {
throw new IllegalStateException("遍历源码求 DTO 索引失败", e);
}
Set<String> out = new java.util.HashSet<>();
Pattern field = Pattern.compile("private\\s+Long\\s+userId\\b");
for (Path file : files) {
try {
String text = SourceScan.withoutComments(Files.readString(file, StandardCharsets.UTF_8));
if (field.matcher(text).find()) {
String name = file.getFileName().toString();
out.add(name.substring(0, name.length() - ".java".length()));
}
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
assertThat(out).as("带 userId 的请求/实体类索引不应为空(空=扫描根走错了)").isNotEmpty();
return out;
}
private static boolean isBound(String region) {
return OUTLETS.stream().anyMatch(region::contains);
}
private static Path mainRoot() {
Path here = Path.of("").toAbsolutePath();
Path direct = here.resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(direct)) {
return direct;
}
return here.resolve("backend-java").resolve("src/main/java/com/nanri/aiimage");
}
private static String read(Path file) {
if (!Files.isRegularFile(file)) {
fail("找不到 " + file + " —— 扫描根不对,护栏的分母会静默变成 0");
}
try {
return Files.readString(file, StandardCharsets.UTF_8);
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
}
@@ -0,0 +1,267 @@
package com.nanri.aiimage.common.security;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
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.Pattern;
import java.util.stream.Stream;
import com.nanri.aiimage.testutil.SourceScan;
import org.junit.jupiter.api.Test;
/**
* 「谁是站点超管」只剩一处定义的绊线(2026-10-07 多公司改造三期)。
*
* <p>改之前的形状:这句判定在 {@code src/main} 里被重抄了 <b>19</b> 遍 —— 16 处
* {@code "super_admin".equals(adminAuthSupport.currentRole(x))}(含 4 个 {@code isSuper} 私有副本),
* 外加 3 处连「role 为空 + is_admin=1 + created_by_id 为空」的老数据推断一起手抄的副本
* ({@code DedupeTotalDataService} / {@code TaskCenterScopeService} / {@code PermissionMenuService})。</p>
*
* <p>重复本身不是缺陷,<b>改不动</b>才是:2026-10-07 定案「{@code company_super_admin} 在业务数据面与
* {@code super_admin} 同权、只在管理动作上收窄」要落地,就得一次改到这 19 处里的每一处。漏一处的表现是
* 某一页静默 403 或静默多放行,两边都不报错、不红。所以现在把口径钉成:</p>
*
* <ol>
* <li>角色比较只允许发生在 {@link DeviceSessionPolicy#isSuper(String)} 这一处,调用方一律写成
* {@code DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(x))};</li>
* <li>出口<b>不许多挂一个名字</b>:上一轮把它做成 {@code AdminAuthSupport} 的实例方法,
* 18 支护栏/业务用例打桩的是 {@code currentRole} 这把既有接缝,同一个 mock 上的新方法桩不到,
* 表现是 31 failures + 17 errors 全是"静默少放行"那一形(见 {@link #outletIsNotAMethodOnTheAuthSupportMock});</li>
* <li>老数据推断只允许存在于定义处 {@link DeviceSessionPolicy};</li>
* <li>公司 tab 的收窄三元式收成 {@code DataReadScope#superAdminScopedUserIds},
* {@code AdminTaskCenterController} 那 5 处逐字重复不再存在。</li>
* </ol>
*
* <p>每支都带"切片非空"自检:负向断言的同一把正则必须能抓到老形状,否则恒绿等于没护栏。</p>
*/
class SuperAdminPredicateSingleOutletTest {
/** 老形状:解析完角色之后又自己比字面量(字面量或私有常量两种写法都算)。 */
private static final Pattern ROLE_LITERAL = Pattern.compile(
"(?:\"super_admin\"|SUPER_ADMIN)\\.equals\\(\\s*adminAuthSupport\\.currentRole\\(");
/** 老形状:私有方法里把「role 为空 + is_admin=1 + created_by_id 为空」的推断整段手抄。 */
private static final Pattern PRIVATE_SUPERADMIN_COPY = Pattern.compile(
"private\\s+boolean\\s+isSuperAdmin\\s*\\([^)]*\\)\\s*\\{[^}]*\"super_admin\"",
Pattern.DOTALL);
@Test
void nobodyRewritesTheSuperAdminLiteralAfterResolvingRole() {
List<String> hits = new ArrayList<>();
for (Path file : mainSources()) {
String text = read(file);
var m = ROLE_LITERAL.matcher(text);
while (m.find()) {
hits.add(file.getFileName() + ": " + m.group());
}
}
assertThat(hits)
.as("src/main 里自己比较 super_admin 字面量的位置(应全部改走 DeviceSessionPolicy#isSuper)")
.isEmpty();
}
@Test
void theLiteralPatternIsNotVacuous() {
// 自检:上一支的正则必须真能抓到老形状,否则「0 命中」与「没扫到」同形。
// 两个样本就是本轮删掉的真实代码(16 处里的两种写法)。
assertThat(ROLE_LITERAL.matcher(
"if (\"super_admin\".equals(adminAuthSupport.currentRole(operator))) {").find()).isTrue();
assertThat(ROLE_LITERAL.matcher(
"return SUPER_ADMIN.equals(adminAuthSupport.currentRole(operator)) ? null : own;").find()).isTrue();
assertThat(ROLE_LITERAL.matcher(
"boolean superAdmin = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));").find())
.as("改走出口之后不得再被当成命中").isFalse();
}
@Test
void legacyRoleInferenceIsNotHandCopiedInPrivateMethods() {
List<String> copiers = new ArrayList<>();
for (Path file : mainSources()) {
String text = read(file);
var m = PRIVATE_SUPERADMIN_COPY.matcher(text);
while (m.find()) {
copiers.add(file.getFileName() + " 仍在自己比 role/is_admin");
}
}
assertThat(copiers)
.as("手抄「role 为空 + is_admin=1 + created_by_id 为空」推断的私有方法,一条都不许剩")
.isEmpty();
// 同一把尺子必须抓得到本轮删掉的真实副本,否则上一支恒绿
assertThat(PRIVATE_SUPERADMIN_COPY.matcher("""
private boolean isSuperAdmin(AdminUserEntity user) {
String role = user.getRole() == null ? "" : user.getRole().trim();
return "super_admin".equals(role);
}
""").find()).isTrue();
}
@Test
void superAdminOutletIsOneStaticPredicateAndSixteenCallSites() {
int definitions = 0;
int callSites = 0;
int wrappers = 0;
for (Path file : mainSources()) {
String text = read(file);
definitions += count(text, "public static boolean isSuper(");
callSites += count(text, "DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(");
wrappers += count(text, "public boolean isPlatformSuperAdmin(");
}
// 比字符串的那一处只有一份,它在 DeviceSessionPolicy;第三个定义点就是分叉的开始
assertThat(definitions)
.as("超管比较口径的定义处(DeviceSessionPolicy#isSuper)")
.isEqualTo(1);
assertThat(wrappers)
.as("业务层包装 isPlatformSuperAdmin 的定义处(只允许 DataReadScope 一个)")
.isEqualTo(1);
assertThat(callSites)
.as("走出口的调用点数:15 个业务调用方 + DataReadScope 包装体(新增调用要一起改这个数字,别改回字面量)")
.isEqualTo(16);
// 自检:这三把尺子的锚点必须真落在预期的文件里,否则"恰好也是 N"可能是扫错地方凑出来的
assertThat(read(mainRoot().resolve("common/security/DeviceSessionPolicy.java")))
.contains("public static boolean isSuper(String resolvedRole)");
assertThat(read(mainRoot().resolve("common/service/DataReadScope.java")))
.contains("public boolean isPlatformSuperAdmin(AdminUserEntity operator)");
}
/**
* 出口不得再做成 {@code AdminAuthSupport} 的实例方法。
*
* <p>这一支钉的是上一轮真实踩到的坑:把 19 处调用改成 {@code adminAuthSupport.isPlatformSuperAdmin(x)}
* 之后,测试里 {@code @Mock AdminAuthSupport} 的该方法是<b>未被打桩</b>的,Mockito 默认返回 false,
* 于是"超管放行"的分支在测试与线上同时静默变窄 —— 31 failures + 17 errors。
* 口径本身没错,错在把接缝挂到一把已有桩覆盖不到的方法上。改回来只需要动定义处,调用方不动。</p>
*/
@Test
void outletIsNotAMethodOnTheAuthSupportMock() {
String banned = "adminAuthSupport.isPlatformSuperAdmin(";
List<String> hits = new ArrayList<>();
for (Path file : mainSources()) {
String text = read(file);
for (int i = text.indexOf(banned); i >= 0; i = text.indexOf(banned, i + banned.length())) {
hits.add(file.getFileName() + ": " + text.substring(i, i + banned.length()));
}
}
assertThat(hits)
.as("超管出口不得挂在 AdminAuthSupport 实例方法上(护栏用例打桩的是 currentRole)")
.isEmpty();
}
@Test
void taskCenterTabsUseTheSingleScopedOutletInsteadOfFiveCopies() {
String controller = read(mainRoot().resolve(
"modules/taskcenter/controller/AdminTaskCenterController.java"));
assertThat(count(controller, "dataReadScope.superAdminScopedUserIds(operator, companyId)"))
.as("看板 5 个端点都走同一个收窄出口")
.isEqualTo(5);
assertThat(controller)
.as("逐字重复的三元式与私有 isSuper 副本不得回流")
.doesNotContain("superAdmin ? dataReadScope.readScope(")
.doesNotContain("isSuper(");
}
@Test
void theThreeLegacyCopiesNowDelegate() {
for (String rel : List.of("modules/dedupe/service/DedupeTotalDataService.java",
"modules/taskcenter/service/TaskCenterScopeService.java",
"modules/permission/service/PermissionMenuService.java")) {
String text = read(mainRoot().resolve(rel));
assertThat(text)
.as(rel + " 必须转调 DeviceSessionPolicy,而不是自己比字面量")
.contains("DeviceSessionPolicy.isSuperAdmin(user.getRole(), user.getIsAdmin(), user.getCreatedById())");
}
}
private static int count(String text, String needle) {
int n = 0;
for (int i = text.indexOf(needle); i >= 0; i = text.indexOf(needle, i + needle.length())) {
n++;
}
return n;
}
private static List<Path> mainSources() {
Path root = mainRoot();
try (Stream<Path> walk = Files.walk(root)) {
List<Path> files = walk.filter(p -> p.toString().endsWith(".java")).toList();
// 扫描本身失效的形态是"目录在但一个文件都没扫到",那会让上面几支全部恒绿
assertThat(files).as("src/main 扫到的 .java 数").hasSizeGreaterThan(400);
return files;
} catch (IOException e) {
throw new IllegalStateException("扫描失败: " + root, e);
}
}
private static Path mainRoot() {
Path here = Path.of("").toAbsolutePath();
Path direct = here.resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(direct)) {
return direct;
}
Path nested = here.resolve("backend-java").resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(nested)) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 源码目录(cwd=" + here + ")");
}
private static String read(Path file) {
if (!Files.isRegularFile(file)) {
fail("找不到 " + file + " —— 用例依赖以 backend-java 为工作目录运行,别让扫描静默通过");
}
try {
// 判据一律打在「剥掉注释的代码」上:本类的 ROLE_LITERAL / PRIVATE_SUPERADMIN_COPY 是
// "必须不存在"那一形(注释里提一句就假红),而 superAdminOutletIsOneStaticPredicate…
// 与 theThreeLegacyCopiesNowDelegate 是"必须存在/次数等于 N"那一形(javadoc 里提一句
// 就喂饱 ⇒ 假绿,等于护栏没写)。两个方向一起吃原文,留哪个都是雷。
return SourceScan.withoutComments(Files.readString(file, StandardCharsets.UTF_8));
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
/**
* 负对照:剥注释这件事本身必须能红能绿。
*
* <p>上一轮就栽在"前提被自己的注释喂饱"上(护栏 javadoc 里抄了被扫的字面量,
* 于是"必须存在"的断言恒真)。这里把两种形状都过一遍:字面量只在注释里 ⇒ 0 命中;
* 落到真代码上 ⇒ 1 命中。少了后一半,剥注释写错成"整行都删"也能一路绿。</p>
*/
@Test
void commentTextFeedsNeitherShape() {
String proseOnly = """
class C {
/** 老形状别再写: "super_admin".equals(adminAuthSupport.currentRole(operator)) */
// private boolean isSuperAdmin(AdminUserEntity u) { return "super_admin".equals(r); }
void h() {
boolean b = DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator));
}
}
""";
String code = SourceScan.withoutComments(proseOnly);
assertThat(ROLE_LITERAL.matcher(code).find())
.as("注释里的字面量不得算命中(否则「必须不存在」那一形会假红)").isFalse();
assertThat(PRIVATE_SUPERADMIN_COPY.matcher(code).find()).isFalse();
assertThat(count(code, "DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole("))
.as("注释被剥掉之后真代码必须还剩下来(否则计数恒 0,护栏假绿)").isEqualTo(1);
String realCode = """
class C {
void h() {
if ("super_admin".equals(adminAuthSupport.currentRole(operator))) { }
}
}
""";
assertThat(ROLE_LITERAL.matcher(SourceScan.withoutComments(realCode)).find())
.as("同一把正则必须抓得到真代码").isTrue();
// 字符串字面量里的 // 不是注释:口径写坏了会把整行吃掉,这里钉住
assertThat(SourceScan.withoutComments("String u = \"https://a\"; // tail").contains("https://a"))
.isTrue();
}
}
@@ -14,6 +14,7 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import com.nanri.aiimage.testutil.SourceScan;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@@ -112,16 +113,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 复验后加第二道,批次 6 加第三道)。出口现在有三个:
* <li><b>几条正门,一套判据</b>(批次 2/3 新增;10-06 复验后加第二道,批次 6 加第三道,10-07 三期加第四道)。
* 出口现在有四个:
* {@code readScope(} 按账号集合给范围(去重库、查询 ASIN、最低价 ASIN、历史、视频),
* {@code readCompanyIdOrOwn(} 给"归属物化成 {@code company_id} 列、可见集又不靠账号/分组"的表
* (今天只有店铺密钥,V150 起每公司一套),{@code resolveScopeCompanyId(} 给菜单字典那一棵树一套
* (V149 起,读写共用同一判据,见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由)。
* 三道门共用 A/B/C/D 四条判据:
* (V149 起,读写共用同一判据,见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由),
* {@code superAdminScopedUserIds(} 给看板那一族"只在站点超管身上收窄"的形状
* (见 {@link #SUPER_SCOPED_USER_IDS_CALL} 的理由)。
* 四道门共用 A/B/C/D 四条判据:
* {@link #SCOPE_DOORS} 供 A 与 C 逐条跑,{@link #SCOPE_CALLEE_NAMES} 供 D 认被调名,
* <b>名单只写一次</b>(红因消息与自检断言咬的是拼出来的同一个标签,两处各写一遍会随哈希顺序漂红)。
* 每条门各自带能红/能绿两向探针(全局约束 15 那把尺子):只在 {@code readScope} 上验过,
* 等于第二道门上的返回值与入参没人看守;第三道门(菜单字典)的三枚 {@code MENU_SCOPE_*} 探针同理。
* 等于第二道门上的返回值与入参没人看守;第三道门(菜单字典)的三枚 {@code MENU_SCOPE_*} 探针同理,
* 第四道门的三枚 {@code SUPER_SCOPED_*} 也是照这一条补的。
* <p>批次 2 时这里还有<b>中间</b>那道 {@code readCompanyId(},服务品牌库 {@code biz_invalid_asin_data}
* 与商品类目 {@code biz_product_category} 两张物化列表。10-06 控制方把这两页定成全平台共享,
* 方法随之删除 ⇒ 门也从名单一起摘掉:名单里留一门没有实现者的门,等于给"把公司开关再接回那两张表"
@@ -240,8 +245,20 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 公司(菜单字典没有"混着两家的树一起列"这种视图),非超管<b>传别家</b>时抛 403 而不是静默改成本公司。</p>
*/
private static final String RESOLVE_MENU_SCOPE_CALL = "resolveScopeCompanyId(";
/**
* 第四道正门(10-07 三期收口补):{@code superAdminScopedUserIds}。它补的是
* {@code AdminTaskCenterController} 那一族「看板五个 tab 只在站点超管身上收窄」的形状 ——
* 此前那五个 handler 体内各写一遍 {@code superAdmin ? readScope(user, companyId).userIdsOr(null) : null},
* 三元式与 {@code userIdsOr(null)} 都在页里;收成一个方法之后判据整体搬进了
* {@code DataReadScope},所以 handler 体内不再有 {@code readScope(}。
*
* <p>这道门开在 {@code DataReadScope} 上、不是 controller 里的 if,前提与第二、三门同一条。
* 不加它的话 A 会把这五支合规 handler 判红;只加名字不配探针的话,这道门上的返回值与入参没人看守
* (全局约束 15),所以正/负两向证据在下面各给一遍。</p>
*/
private static final String SUPER_SCOPED_USER_IDS_CALL = "superAdminScopedUserIds(";
private static final List<String> SCOPE_DOORS =
List.of(READ_SCOPE_CALL, READ_OWN_COMPANY_ID_CALL, RESOLVE_MENU_SCOPE_CALL);
List.of(READ_SCOPE_CALL, READ_OWN_COMPANY_ID_CALL, RESOLVE_MENU_SCOPE_CALL, SUPER_SCOPED_USER_IDS_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";
@@ -284,11 +301,13 @@ 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 readCompanyIdOrOwn} 是"归属物化成 {@code company_id} 列、可见集不靠账号/分组"
* 那一族表(今天只有店铺密钥)的正门(见 {@link #READ_OWN_COMPANY_ID_CALL} 的理由),
* {@code resolveScopeCompanyId} 是菜单字典那一棵树一套的归属判据(见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由)。
* {@code resolveScopeCompanyId} 是菜单字典那一棵树一套的归属判据(见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由),
* {@code superAdminScopedUserIds} 是看板那一族"只在站点超管身上收窄"的正门
* (见 {@link #SUPER_SCOPED_USER_IDS_CALL} 的理由)。
* 除此之外的调用都不算"把公司参数交给了出口"——尤其 {@code readScope(operator, null)} 里那个 {@code null}。
*/
private static final String RESOLVE_SCOPE_CALL = "resolveScope(";
@@ -298,7 +317,8 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 那就等于一条会自己漂红的用例。
*/
private static final List<String> SCOPE_CALLEE_NAMES =
List.of("readScope", "resolveScope", "readCompanyIdOrOwn", "resolveScopeCompanyId");
List.of("readScope", "resolveScope", "readCompanyIdOrOwn", "resolveScopeCompanyId",
"superAdminScopedUserIds");
private static final Set<String> SCOPE_CALLEES = Set.copyOf(SCOPE_CALLEE_NAMES);
private static final String SCOPE_CALLEE_LABEL = String.join("/", SCOPE_CALLEE_NAMES);
@@ -523,10 +543,42 @@ class CompanyIdParamGoesThroughReadScopeTest {
}
""";
/**
* 第四道正门的<b>正探针</b>(形状逐字抄现网 {@code AdminTaskCenterController.overview}):
* 结果接进变量、又作为实参交给 {@code resolveScope(…)},公司参数本身进了门 ⇒ C 与 D 都必须判绿。
*/
private static final String SUPER_SCOPED_CAUGHT_PROBE = """
@GetMapping("/probe")
public String superScopedDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = session.operator();
List<Long> companyUserIds = dataReadScope.superAdminScopedUserIds(operator, companyId);
return String.valueOf(taskCenterScopeService.resolve(resolveScope(operatorId, companyUserIds)));
}
""";
/** 第四道正门的<b>裸语句探针</b>(C 在该门上的"能红"证据):门调了,收窄集当场丢掉。 */
private static final String SUPER_SCOPED_DISCARD_PROBE = """
@GetMapping("/probe")
public String superScopedDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
dataReadScope.superAdminScopedUserIds(operator, companyId);
return "ok";
}
""";
/** 第四道正门的<b>负探针</b>(D 在该门上的存在理由):切了 tab,传进门里的还是 {@code null}。 */
private static final String SUPER_SCOPED_PASSED_NULL_PROBE = """
@GetMapping("/probe")
public String superScopedDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = session.operator();
List<Long> companyUserIds = dataReadScope.superAdminScopedUserIds(operator, null);
return String.valueOf(taskCenterScopeService.resolve(resolveScope(operatorId, companyUserIds)));
}
""";
/**
* 已摘掉那道门的<b>正样本探针</b>(形状抄退回前的 {@code InvalidAsinDataController.page}:
* 收 {@code company_id} 参数、体内调 {@code readCompanyId})。它现在应当被 A/C/D 三条同时判红——
* 红因必须落在"三条正门都没走"上,而不是"这段源码没被切成 handler"。
* 红因必须落在"一条正门都没走"上,而不是"这段源码没被切成 handler"。
*/
private static final String RETIRED_DOOR_WIRED_PROBE = """
@GetMapping("/probe")
@@ -711,6 +763,30 @@ class CompanyIdParamGoesThroughReadScopeTest {
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 第四道门(看板超管收窄集)也两向取证:它今天有五个真实消费者(AdminTaskCenterController 的
// overview / shop-options / tasks / tasks-detail / variant-tasks)。只把名字加进 SCOPE_DOORS
// 而不验返回值与入参,这道门就是"名单里有、没人守"——上一轮 A 之所以红,正是因为名单先到、
// 探针没到,这道门上的 companyUserIds 哪天被丢掉或传成 null,C 与 D 都不求值。
assertThat(scopeProbeReason(SUPER_SCOPED_CAUGHT_PROBE, "SUPER_SCOPED_CAUGHT_PROBE"))
.as("断言 C 自检(第四道门·正样本):List<Long> companyUserIds = superAdminScopedUserIds(operator, companyId) "
+ "且它进了 resolveScope(…) 的实参 ⇒ 判红就是护栏假红")
.isNull();
assertThat(companyIdArgProbeReason(SUPER_SCOPED_CAUGHT_PROBE, "SUPER_SCOPED_CAUGHT_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第四道门·正样本):companyId 真进了 superAdminScopedUserIds 的实参表 ⇒ 不许红")
.isNull();
assertThat(scopeProbeReason(SUPER_SCOPED_DISCARD_PROBE, "SUPER_SCOPED_DISCARD_PROBE"))
.as("断言 C 自检(第四道门·负样本):superAdminScopedUserIds( 写成裸语句、收窄集当场丢掉 ⇒ 必须判红")
.isNotNull()
.contains("范围算了但没接住");
assertThat(scopeProbeReason(SUPER_SCOPED_PASSED_NULL_PROBE, "SUPER_SCOPED_PASSED_NULL_PROBE"))
.as("断言 D(第四道门)负样本的前提(断言 C):结果接进 companyUserIds 又喂给了 resolveScope ⇒ C 判它绿")
.isNull();
assertThat(companyIdArgProbeReason(
SUPER_SCOPED_PASSED_NULL_PROBE, "SUPER_SCOPED_PASSED_NULL_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第四道门·负样本):superAdminScopedUserIds(operator, null) ⇒ 必须判红")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 已摘掉的那道门不许再接回(全局约束 15 的"能红"方向)。这一族 handler(品牌库、商品类目)现在定案
// 全平台共享、不再收公司参数 ⇒ 它们已不进 A/C/D 的样本,"哪天有人把 ?company_id= 接回这两张表"
// 只剩这条探针还在求值,而今天真正拦它的是断言 A:C 与 D 在主循环里都以"体内有正门调用"为前提
@@ -1643,7 +1719,9 @@ class CompanyIdParamGoesThroughReadScopeTest {
private static String read(Path path) {
try {
return new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
// 尾随注释也要剥:{@link #sourceLines} 只丢整行注释,`service.list(…); // readScope( 已接`
// 这种一行里"代码 + 注释"的形状会同时喂 A/C(注释里的门名让 A 判绿=假绿)。
return SourceScan.withoutComments(new String(Files.readAllBytes(path), StandardCharsets.UTF_8));
} catch (IOException e) {
throw new IllegalStateException("读不到 " + path, e);
}
@@ -0,0 +1,169 @@
package com.nanri.aiimage.common.task;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
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.stream.Stream;
import com.nanri.aiimage.testutil.SourceScan;
import org.junit.jupiter.api.Test;
/**
* 任务面「生命周期骨架」的账(2026-10-07 架构三期,第 5 项)。
*
* <p>评审时那句「~3.6k 行冗余」是我自己给的,实跑之后<b>不成立</b>,这里换成量出来的数:
* 九个 {@code *TaskService} 归一化后共 15,295 行,跨文件<b>逐字</b>相同的 8 行窗口只覆盖 208 行
* (按页 0.4%–6.8% 不等)。所以"抽骨架"不是去重——那是一场重写,而骨架<b>早就抽过了</b>:
* {@code TaskFinalizeSupport}(loadTaskForExecution / loadTaskMapByIds / markResultFailed /
* acquireTaskLockOrThrow / selectTasksByIdsInBatches)今天被 14 个 {@code *TaskService} 中的 7 个委托,
* 类注释里还点名留了三处非同构变体(PriceTrack 要求缓存行 requestJson 非空、ShopMatch 带新旧复活防护、
* Withdraw 先按 limit(50) 归一化 id)。剩下的重复不是行,是<b>同一条安全谓词被手抄的遍数</b>:
* 「这一行是不是这个模块的」{@code !MODULE_TYPE.equals(x.getModuleType())} 在 <b>16</b> 个文件里写了
* <b>130</b> 遍。第 3 项那个超管判定是同一缺陷的小一号版本(19 遍),那个已经收口成出口,这个还没有。</p>
*
* <p>抄本身不是 bug,<b>改不动</b>才是:归属谓词漏一处的表现是某一页的检查静默变成"谁都能读",
* 不报错、不 403。今天动它要一次改到 16 个文件,代价太大,所以这里先把<b>遍数钉成棘轮</b>:
* 只许降不许升。升了就是在新增第十七处手写归属——那种新增应当接进 {@code TaskFinalizeSupport}
* 或新的归属出口,而不是把这个数字调大。</p>
*
* <p>两条判据各带自检:锚点必须真能抓到这一形,否则"16 个文件 / 130 处"的 0 命中与扫不到同形。</p>
*/
class TaskLifecycleDebtRatchetTest {
private static final String MODULE_OWNERSHIP = "!MODULE_TYPE.equals(";
@Test
void handWrittenModuleOwnershipIsPinnedAtOneHundredThirtyAndCannotGrow() {
int occurrences = 0;
List<String> files = new ArrayList<>();
for (Path file : mainSources()) {
int n = count(read(file), MODULE_OWNERSHIP);
if (n > 0) {
occurrences += n;
files.add(file.getFileName().toString());
}
}
// 自检:分母本身要说得出数("扫到 16 个文件"与"扫描坏了返回空"是两种红法,别混)
assertThat(files).as("手写模块归属谓词的文件数").hasSize(16);
// 自检:锚点必须真抓得到这一形,否则上一条与下面那条棘轮都是恒绿
assertThat(count("if (task == null || !MODULE_TYPE.equals(task.getModuleType())) {", MODULE_OWNERSHIP))
.as("锚点自检:这一形抓不到,棘轮等于没写").isEqualTo(1);
assertThat(occurrences)
.as("src/main 里手抄的模块归属谓词遍数(棘轮:只许降。要降就把它接进 TaskFinalizeSupport)")
.isLessThanOrEqualTo(130);
}
@Test
void lifecycleHelpersAreAlreadySharedSoDoNotAddASecondCopy() {
String support = read(mainRoot().resolve("modules/task/service/TaskFinalizeSupport.java"));
assertThat(support).as("骨架必须是静态工具,否则各页还是要自己 new 一份")
.contains("public final class TaskFinalizeSupport");
for (String helper : List.of("loadTaskForExecution", "loadTaskMapByIds", "markResultFailed",
"acquireTaskLockOrThrow", "selectTasksByIdsInBatches")) {
assertThat(support)
.as("骨架里那个叫 %s 的零件不见了:各页会退回本地再抄一遍", helper)
.contains(helper + "(");
}
// 委托面:*TaskService 里走骨架的页数只许升不许降。掉下 7 就说明有人又开始本地抄。
int delegating = 0;
for (Path file : mainSources()) {
String name = file.getFileName().toString();
if (name.endsWith("TaskService.java") && read(file).contains("TaskFinalizeSupport.")) {
delegating++;
}
}
assertThat(delegating)
.as("委托给 TaskFinalizeSupport 的 *TaskService 数(实测 7:PatrolDelete/PriceTrack/ProductRisk/"
+ "QueryAsin/ShopDataCrawl/ShopMatch/Withdraw)")
.isGreaterThanOrEqualTo(7);
}
private static int count(String text, String needle) {
int n = 0;
for (int i = text.indexOf(needle); i >= 0; i = text.indexOf(needle, i + needle.length())) {
n++;
}
return n;
}
private static List<Path> mainSources() {
Path root = mainRoot();
try (Stream<Path> walk = Files.walk(root)) {
List<Path> files = walk.filter(p -> p.toString().endsWith(".java")).toList();
assertThat(files).as("src/main 扫到的 .java 数").hasSizeGreaterThan(400);
return files;
} catch (IOException e) {
throw new IllegalStateException("扫描失败: " + root, e);
}
}
private static Path mainRoot() {
Path here = Path.of("").toAbsolutePath();
Path direct = here.resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(direct)) {
return direct;
}
Path nested = here.resolve("backend-java").resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(nested)) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 源码目录(cwd=" + here + ")");
}
private static String read(Path file) {
if (!Files.isRegularFile(file)) {
fail("找不到 " + file + " —— 用例依赖以 backend-java 为工作目录运行,别让扫描静默通过");
}
try {
// 判据打在「剥掉注释的代码」上:本类的三种形状里,棘轮/委托数/骨架零件都是
// "必须存在或次数等于 N"那一形 —— 吃原文的话,TaskFinalizeSupport 的类注释只要还写着
// 「loadTaskForExecution」这几个名字,方法被删断言照样绿(假绿=护栏没写)。
// 2026-10-07 实测:src/main 全部锚点 raw 与 stripped 同数(130/16、7),所以剥注释不改账。
return SourceScan.withoutComments(Files.readString(file, StandardCharsets.UTF_8));
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
/**
* 负对照:剥注释这件事本身要能红能绿。
*
* <p>缺了后一半,{@code withoutComments} 写坏成"整行都删"也会一路绿;缺了前一半,
* 有人把骨架零件改名而在类注释里留一句说明,"零件不见了"就变成假红。</p>
*/
@Test
void commentTextFeedsNeitherShape() {
String proseOnly = SourceScan.withoutComments("""
/** 骨架里有 loadTaskForExecution( 与 TaskFinalizeSupport. 这些名字,只是文档。 */
class C {
// if (task == null || !MODULE_TYPE.equals(task.getModuleType())) { }
void h() { }
}
""");
assertThat(count(proseOnly, MODULE_OWNERSHIP))
.as("注释里的归属谓词不得算命中(棘轮分母会被文档喂大)").isZero();
assertThat(proseOnly).doesNotContain("loadTaskForExecution(").doesNotContain("TaskFinalizeSupport.");
assertThat(proseOnly).as("剥注释不许把代码骨架一起吃掉(类声明还在)")
.contains("class C").contains("void h()");
String realCode = SourceScan.withoutComments("""
class C {
void h() {
if (task == null || !MODULE_TYPE.equals(task.getModuleType())) { throw new BizException(); }
}
}
""");
assertThat(count(realCode, MODULE_OWNERSHIP))
.as("同一把尺子必须抓得到真代码,否则「0 命中」与「扫不到」同形").isEqualTo(1);
// 字符串字面量里的 // 不算注释:口径写坏了会把整行吃掉,这里钉住
assertThat(SourceScan.withoutComments("String u = \"https://a\"; // tail").contains("https://a"))
.isTrue();
}
}
@@ -425,7 +425,9 @@ class AdminApiGuardFilterTest {
void adminJwtMayActForAnotherUser() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any())).thenReturn(user(1L, "admin"));
when(authSupport.currentRole(any())).thenReturn("admin");
// 豁免判定只有一个出口(AdminAuthSupport.mayActForOtherUsers),守卫不再自己抄一份角色名单:
// 上一版这里 stub currentRole,改成委托后如果谁把两处又写回各判各的,这两支会一起红。
when(authSupport.mayActForOtherUsers(any())).thenReturn(true);
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/query-asin/tasks/detail");
request.setParameter("user_id", "8");
@@ -435,6 +437,7 @@ class AdminApiGuardFilterTest {
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNotNull();
verify(authSupport).mayActForOtherUsers(any());
}
/** 桌面端不带 JWT、也就没有身份可绑:这条约束对存量匿名客户端零影响。 */
@@ -556,7 +559,7 @@ class AdminApiGuardFilterTest {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.isTrustedInternalToken(any())).thenReturn(true);
when(authSupport.requireUserOrInternal(any())).thenReturn(user(1L, "admin"));
when(authSupport.currentRole(any())).thenReturn("admin");
when(authSupport.mayActForOtherUsers(any())).thenReturn(true);
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/query-asin/tasks/detail");
request.setParameter("user_id", "8");
@@ -568,6 +571,63 @@ class AdminApiGuardFilterTest {
assertThat(chain.getRequest()).isNotNull();
}
// ---- /api/publish 纳入绑定(2026-10-07)----
// 取证:网页端调 publish 的 activate 三兄弟时**根本不传 user_id**
// (frontend-vue/src/shared/api/types/modules/publish.ts:180,189),桌面执行器只调
// items 与 result(app_client/amazon/add_product.py:973,1048)。此前 publish 一个都不在
// 守卫名单里,控制器也不 require*,匿名请求即可激活/删除任意任务。
@Test
void publishJwtCannotReadAnotherUsersItems() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any())).thenReturn(user(7L, "normal"));
when(authSupport.mayActForOtherUsers(any())).thenReturn(false);
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/tasks/9001/items");
request.setParameter("user_id", "8");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).as("带 JWT 却填别人的 user_id 必须挡下").isNull();
JsonNode body = objectMapper.readTree(response.getContentAsString());
assertThat(body.path("code").asInt()).isEqualTo(403);
}
/** 不带凭据的执行器(X-Internal-Token、无 operatorId、无 user_id)解析不出身份,绑定不触发。 */
@Test
void publishExecutorRequestWithoutIdentityIsNotBound() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.isTrustedInternalToken(any())).thenReturn(true);
when(authSupport.requireUserOrInternal(any())).thenThrow(new BusinessException(401, "未登录"));
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/tasks/9001/items");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNotNull();
assertThat(response.getContentAsString()).isEmpty();
}
/** 前缀边界:/publishing-tools 这类同前缀名字不能被卷进来。 */
@Test
void publishLikeOtherPathsAreNotSweptIn() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publishing-tools/list");
request.setParameter("user_id", "8");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNotNull();
verify(authSupport, never()).requireUserOrInternal(any());
}
private AdminUserEntity user(Long id, String role) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
@@ -0,0 +1,108 @@
package com.nanri.aiimage.modules.permission.service;
import com.nanri.aiimage.testutil.SourceScan;
import org.junit.jupiter.api.Test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 菜单写侧的「操作者只能是真人」护栏。
*
* <p>2026-10-07 数富AI 架构评审收口时发现:{@code PermissionMenuService} 上有四个不带操作者的重载
* ({@code create(request)}/{@code update(id, request)}/{@code delete(id)}/
* {@code updateUserColumnPermissions(userId, request)}),它们一律把 {@code operator = null}
* 递给闸门,而三道闸门对 null 的处置都是 {@code return}(放行)。今天 src/main 里没人调用它们,
* 但"调用方传 null 就等于跳过归属校验"这条路只要存在,下一支控制器接上去就是静默的跨公司改删——
* 表现是别家菜单少一行,两边都不报错。</p>
*
* <p>本批把四个无操作者<b>写</b>出口删掉(删出口胜过写注释),并把它钉住:
* 写方法各自只剩"第一个参数是操作者"的那一种形状,文件里不再出现把 null 当操作者递进去的委托。
* <b>读侧的 {@code list(String menuType)} 故意保留</b>:它是登录态自读与内部代理用的
* 无 tab 目录查询,{@code PermissionCompanyMenuHiddenTest} 已经把它当作口径钉过,
* 删它等于改语义而不是收口子,所以这里只做点名,不许扩大。</p>
*/
class MenuWriteOutletOperatorTest {
private static final String SRC = SourceScan.withoutComments(
SourceScan.sourceText("PermissionMenuService.java"));
/**
* 把 null 当操作者递进写方法:{@code delete(null, id);}/{@code return create(null, null, request);}
*
* <p>左边必须排掉 {@code .}:MyBatis-Plus 的 {@code mapper.update(null, wrapper)} 第一个参数是
* entity 而不是操作者,撞上来就是假红(这个文件里真有两处)。同一条理由要求判据是"裸调用"。</p>
*/
private static final Pattern ANONYMOUS_WRITE_DELEGATION = Pattern.compile(
"(?<![A-Za-z0-9_.])(?:create|update|delete|updateUserColumnPermissions)\\s*\\(\\s*null\\b");
@Test
void noWriteMethodIsDelegatedWithANullOperator() {
assertThat(ANONYMOUS_WRITE_DELEGATION.matcher(SRC).find())
.as("菜单写侧不许再有「operator 传 null」的委托;读侧那条走 "
+ "anonymousReadIsStillTheSingleNullOperatorPath")
.isFalse();
}
@Test
void anonymousReadOutletIsStillExactlyOneAndNamed() {
// 保留不等于放开:唯一的 null 操作者路径必须是 list(String),多的一个都不许有。
Matcher read = Pattern.compile("\\blist\\s*\\(\\s*null\\b").matcher(SRC);
int hits = 0;
while (read.find()) {
hits++;
}
assertThat(hits).as("无操作者的目录读只许 1 处").isEqualTo(1);
assertThat(SourceScan.methodBody(SRC, "list"))
.as("那 1 处必须还在 list(String menuType) 里,挪进写方法就红")
.contains("return list(null, menuType, false);");
}
@Test
void eachWriteEntryPointKeepsItsSingleOperatorFirstShape() {
assertThat(count(SRC, "public PermissionMenuItemVo create("))
.as("新增菜单只留 (operator, requestedCompanyId, request) 一种形状").isEqualTo(1);
assertThat(count(SRC, "public PermissionMenuItemVo update("))
.as("编辑菜单只留 (operator, id, request) 一种形状").isEqualTo(1);
assertThat(count(SRC, "public void delete("))
.as("删除菜单只留 (operator, id) 一种形状").isEqualTo(1);
assertThat(count(SRC, "public void updateUserColumnPermissions("))
.as("授权落库三种形状都必须以 operator 开头").isEqualTo(3);
assertThat(count(SRC, "public void reorder(")).isEqualTo(1);
}
/**
* 上面三支都是「不存在」与「等于 N」两形,都会被恒绿的扫描器喂出来:正则写错、剥注释把整段
* 吃掉、sourceText 抓到另一份同名文件,读数一样是绿的。所以每条判据都配一次"能红"取样。
*/
@Test
void thePatternsFireOnTheShapesTheyClaimToCatch() {
assertThat(ANONYMOUS_WRITE_DELEGATION
.matcher(" public void delete(Long id) {\n delete(null, id);\n }").find())
.as("匿名写委托的判据必须抓得到 delete(null, id)")
.isTrue();
assertThat(ANONYMOUS_WRITE_DELEGATION.matcher(" permissionMenuMapper.update(null, wrapper);")
.find())
.as("MyBatis 的 update(null, wrapper) 不是操作者,不许被抓成假红")
.isFalse();
assertThat(count(" public void delete(AdminUserEntity operator, Long id) {\n"
+ " public void delete(Long id) {\n", "public void delete("))
.as("签名计数必须真数得出重载,两个就报两个")
.isEqualTo(2);
assertThat(count(SRC, "public void delete("))
.as("取样自检与本文件对照:本文件只剩一种形状")
.isEqualTo(1);
}
private static int count(String haystack, String needle) {
int n = 0;
int i = haystack.indexOf(needle);
while (i >= 0) {
n++;
i = haystack.indexOf(needle, i + needle.length());
}
return n;
}
}
@@ -62,7 +62,7 @@ class PermissionMenuServiceTest {
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(2L));
service.updateUserColumnPermissions(7L, request);
service.updateUserColumnPermissions(null, 7L, request);
ArgumentCaptor<UserColumnPermissionEntity> captor = ArgumentCaptor.forClass(UserColumnPermissionEntity.class);
verify(permissionMapper, times(2)).insert(captor.capture());
@@ -84,7 +84,7 @@ class PermissionMenuServiceTest {
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(75L));
service.updateUserColumnPermissions(8L, request);
service.updateUserColumnPermissions(null, 8L, request);
verify(permissionMapper, times(0)).insert(any(UserColumnPermissionEntity.class));
}
@@ -102,7 +102,7 @@ class PermissionMenuServiceTest {
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(2L));
service.updateUserColumnPermissions(7L, request);
service.updateUserColumnPermissions(null, 7L, request);
ArgumentCaptor<UserColumnPermissionEntity> captor = ArgumentCaptor.forClass(UserColumnPermissionEntity.class);
verify(permissionMapper, times(3)).insert(captor.capture());
@@ -346,7 +346,7 @@ class PermissionMenuServiceTest {
when(menuMapper.selectById(7L)).thenReturn(parent);
PermissionMenuCreateRequest request = createRequest(7L, "app");
assertThatThrownBy(() -> service.create(request))
assertThatThrownBy(() -> service.create(user(1L, "super_admin", 1), null, request))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("同一类型");
verify(menuMapper, never()).insert(any(PermissionMenuEntity.class));
@@ -373,7 +373,7 @@ class PermissionMenuServiceTest {
request.setRoutePath("changed");
request.setParentId(2L);
assertThatThrownBy(() -> service.update(1L, request))
assertThatThrownBy(() -> service.update(user(1L, "super_admin", 1), 1L, request))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("自己的子级");
verify(menuMapper, never()).updateById(any(PermissionMenuEntity.class));
@@ -394,7 +394,7 @@ class PermissionMenuServiceTest {
request.setMenuType("admin");
request.setRoutePath("changed");
assertThatThrownBy(() -> service.update(1L, request))
assertThatThrownBy(() -> service.update(user(1L, "super_admin", 1), 1L, request))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("子菜单");
verify(menuMapper, never()).updateById(any(PermissionMenuEntity.class));
@@ -410,7 +410,7 @@ class PermissionMenuServiceTest {
when(menuMapper.selectById(1L)).thenReturn(menu(1L, null, "app", 1));
when(menuMapper.selectCount(any())).thenReturn(1L);
assertThatThrownBy(() -> service.delete(1L))
assertThatThrownBy(() -> service.delete(user(1L, "super_admin", 1), 1L))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("子菜单");
verify(menuMapper, never()).deleteById(any(Long.class));
@@ -658,7 +658,7 @@ class PermissionMenuServiceTest {
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(1L));
service.updateUserColumnPermissions(9L, request);
service.updateUserColumnPermissions(null, 9L, request);
ArgumentCaptor<UserColumnPermissionEntity> captor = ArgumentCaptor.forClass(UserColumnPermissionEntity.class);
verify(permissionMapper).insert(captor.capture());
@@ -1144,7 +1144,7 @@ class PermissionMenuServiceTest {
request.setColumnKey("new_admin_menu");
request.setRoutePath("new-admin-menu");
service.create(request);
service.create(user(1L, "super_admin", 1), null, request);
ArgumentCaptor<PermissionMenuEntity> inserted = ArgumentCaptor.forClass(PermissionMenuEntity.class);
verify(menuMapper).insert(inserted.capture());
@@ -1169,7 +1169,7 @@ class PermissionMenuServiceTest {
request.setMenuType("admin");
// 不传 columnKey / routePath:由后台自动生成。
service.create(request);
service.create(user(1L, "super_admin", 1), null, request);
ArgumentCaptor<PermissionMenuEntity> inserted = ArgumentCaptor.forClass(PermissionMenuEntity.class);
verify(menuMapper).insert(inserted.capture());
@@ -1195,7 +1195,7 @@ class PermissionMenuServiceTest {
request.setMenuType("admin");
// 不传 columnKey / routePath:保持原值。
service.update(1L, request);
service.update(user(1L, "super_admin", 1), 1L, request);
ArgumentCaptor<PermissionMenuEntity> updated = ArgumentCaptor.forClass(PermissionMenuEntity.class);
verify(menuMapper).updateById(updated.capture());
@@ -0,0 +1,134 @@
package com.nanri.aiimage.modules.publish.controller;
import com.nanri.aiimage.testutil.SourceScan;
import org.junit.jupiter.api.Test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 上架(publish)归属绑定的绊线(2026-10-07)。
*
* <p>publish 此前的形状:12 个端点没有一个在兜底守卫名单里,控制器不调 require*,
* {@code user_id} 要么可选要么由前端从 localStorage 取——也就是"数据属于谁"完全由请求说了算。
* 本轮收口后的形状必须是可证的,否则下次有人"顺手"改回参数判定不会有任何东西变红:</p>
*
* <ol>
* <li>带 user_id 的端点分母钉死(查询参数 8 个 + 请求体 4 个 = 12 个走会话推导)。
* 其中 10 个走 {@code requireOwnershipUserId}(解析不出登录身份即 401,网页端/后台专用),
* 2 个走 {@code resolveOwnershipUserId}——只有执行器可达的 {@code items}(取数)和
* {@code result}(回传):桌面端只带 X-Internal-Token、不带 operatorId,给它俩加 require
* 等于把上架整条链路挡在 401。resolve 对匿名请求是原样透传,对带凭据的请求仍然冒名即 403。</li>
* <li>"null 即跳过归属校验"这个形状在服务层只能剩 1 处(publish 的 requireTaskRecord,
* 为执行器留的口子),外观专利与货源的 4 处已改为无条件比对。</li>
* </ol>
*
* <p>数字判据一律打在 {@link SourceScan#withoutComments} 上:javadoc 里提一句 {@code requireOwnershipUserId}
* 就能把"次数等于 N"喂成假绿。只有"豁免必须写明理由"那支刻意吃原文,因为它要钉的就是注释本身。</p>
*/
class PublishOwnershipGuardrailTest {
private static final Pattern QUERY_USER_ID = Pattern.compile(
"@RequestParam\\(\\s*(?:value\\s*=\\s*)?\"user_id\"[^)]*\\)\\s+Long\\s+\\w+");
@Test
void everyUserIdCarryingPublishEndpointIsDerivedFromSession() {
String controller = SourceScan.withoutComments(SourceScan.sourceText("PublishController.java"));
Matcher query = QUERY_USER_ID.matcher(controller);
int queryBindings = 0;
while (query.find()) {
queryBindings++;
}
assertThat(queryBindings)
.as("publish 控制器里 user_id 查询参数绑定数")
.isEqualTo(8);
// 请求体里带 user_id 的四个:parse / progress/batch / progress/light / result
long bodyBindings = Stream.of("PublishParseRequest request",
"PublishTaskBatchRequest request",
"TaskProgressLightRequest request",
"PublishSubmitResultRequest request")
.filter(controller::contains)
.count();
assertThat(bodyBindings).as("publish 控制器里请求体带 user_id 的端点数").isEqualTo(4);
int require = count(controller, "adminAuthSupport.requireOwnershipUserId(");
int resolve = count(controller, "adminAuthSupport.resolveOwnershipUserId(");
assertThat(require)
.as("requireOwnershipUserId 调用数(网页端/后台专用,解析不出身份即 401)")
.isEqualTo(10);
assertThat(resolve)
.as("resolveOwnershipUserId 调用数(执行器可达的两条:items 取数、result 回传)")
.isEqualTo(2);
assertThat(require + resolve)
.as("12 个带归属的端点必须逐个接上会话推导,一个都不能只靠请求参数")
.isEqualTo(queryBindings + bodyBindings);
}
/**
* 执行器回传端点是刻意的例外:给它加 require 等于把上架整条链路挡在 401。
*
* <p>反向钉必须配一条正向取样,否则"方法体切不到"和"方法体真的没调用"这两种情况都是绿的。</p>
*/
@Test
void resultSubmissionStaysReachableWithoutLoginIdentity() {
String controller = SourceScan.withoutComments(SourceScan.sourceText("PublishController.java"));
String body = SourceScan.methodBody(controller, "submitResult");
assertThat(body)
.as("submitResult 只能走透传的 resolve(带凭据时依旧校验归属,匿名执行器不被 401)")
.contains("adminAuthSupport.resolveOwnershipUserId(");
assertThat(body)
.as("给 submitResult 加 require 会把无登录身份的桌面执行器挡在 401")
.doesNotContain("requireOwnershipUserId");
}
/** 同理,items 是执行器唯一的取数口,也只能透传、不能 require。 */
@Test
void executorReadPathStaysReachableWithoutLoginIdentity() {
String controller = SourceScan.withoutComments(SourceScan.sourceText("PublishController.java"));
String body = SourceScan.methodBody(controller, "items");
assertThat(body).contains("adminAuthSupport.resolveOwnershipUserId(");
assertThat(body).doesNotContain("requireOwnershipUserId");
}
/**
* "userId != null 才校验归属"在服务层只剩一处出口,且那一处必须带写明理由的注释
* (匿名执行器 items/result 走 requireTaskRecord)。
*/
@Test
void nullSkipsOwnershipCheckOnlyOnTheExecutorReadPath() {
String publishService = SourceScan.sourceText("PublishTaskService.java");
String publishCode = SourceScan.withoutComments(publishService);
String appearanceCode = SourceScan.withoutComments(SourceScan.sourceText("AppearancePatentTaskService.java"));
String similarAsinCode = SourceScan.withoutComments(SourceScan.sourceText("SimilarAsinTaskService.java"));
assertThat(count(appearanceCode, "userId != null && !Objects.equals(userId, task.getUserId())"))
.as("外观专利的两处条件归属校验必须已改成无条件比对")
.isZero();
assertThat(count(similarAsinCode, "userId != null && !Objects.equals(userId, task.getUserId())"))
.as("货源的两处条件归属校验必须已改成无条件比对")
.isZero();
assertThat(count(publishCode, "userId != null && !userId.equals(task.getUserId())"))
.as("publish 保留的那一处是唯一登记在册的口子,多一处就是有人新开了免校验通道")
.isEqualTo(1);
assertThat(publishService)
.as("保留口子必须写明它只服务于哪个匿名执行器路径(这支刻意扫原文:要钉的就是注释)")
.contains("GET /tasks/{id}/items 与 POST /tasks/{id}/result");
}
private static int count(String haystack, String needle) {
int index = 0;
int total = 0;
while ((index = haystack.indexOf(needle, index)) >= 0) {
total++;
index += needle.length();
}
return total;
}
}
@@ -35,6 +35,23 @@ class SimilarAsinTaskLightControllerTest {
private SimilarAsinTaskService service;
private MockMvc mockMvc;
/**
* 进度端点从 2026-10-07 起把 body 里的 user_id 交给 {@code AdminAuthSupport#requireOwnershipUserId}
* 绑到会话身份上(fail-closed)。这一支用例测的是<b>轻量响应的字段形状</b>,不是归属,
* 所以这里给一把"参数与会话一致"的回显桩:原样返回第二个入参,等于已认证用户带着自己的 id。
*
* <p>⚠️ 别把它换成 {@code new AdminAuthSupport(...)} 的真身,也别删掉:真身会走 JWT 解析 ⇒ 用例
* 变成鉴权用例;返回 null 则归属被放宽,恰好把这一支要钉的"绑定值要传下去"糊掉。
* 归属接线本身由 {@code ProgressQueryOwnershipOutletTest} 钉。</p>
*/
private static com.nanri.aiimage.common.security.AdminAuthSupport sessionBoundAuth() {
com.nanri.aiimage.common.security.AdminAuthSupport auth =
mock(com.nanri.aiimage.common.security.AdminAuthSupport.class);
when(auth.requireOwnershipUserId(any(), any()))
.thenAnswer(invocation -> invocation.getArgument(1));
return auth;
}
private SimilarAsinTaskLightBatchVo lightBatch(SimilarAsinTaskLightVo... items) {
SimilarAsinTaskLightBatchVo vo = new SimilarAsinTaskLightBatchVo();
vo.getItems().addAll(List.of(items));
@@ -57,7 +74,7 @@ class SimilarAsinTaskLightControllerTest {
// 归属过滤:请求不带 userId 时 filterOwnedTaskIds 直接返回原列表(不会触碰 mapper),
// 故这里传 null mapper 即可,无需 mock
mockMvc = MockMvcBuilders.standaloneSetup(
new SimilarAsinController(service, new TaskProgressOwnershipSupport(null), null)).build();
new SimilarAsinController(service, new TaskProgressOwnershipSupport(null), sessionBoundAuth())).build();
}
@Test
@@ -117,7 +134,7 @@ class SimilarAsinTaskLightControllerTest {
// 归属过滤:请求不带 userId 时 filterOwnedTaskIds 直接返回原列表(不会触碰 mapper),
// 故这里传 null mapper 即可,无需 mock
mockMvc = MockMvcBuilders.standaloneSetup(
new SimilarAsinController(service, new TaskProgressOwnershipSupport(null), null)).build();
new SimilarAsinController(service, new TaskProgressOwnershipSupport(null), sessionBoundAuth())).build();
mockMvc.perform(post("/api/similar-asin/tasks/progress/batch")
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(request)))
@@ -2,6 +2,7 @@ package com.nanri.aiimage.modules.task.contract;
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.modules.appearancepatent.controller.AppearancePatentController;
import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentSubmitResultRequest;
import com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService;
@@ -16,6 +17,7 @@ import com.nanri.aiimage.modules.similarasin.controller.SimilarAsinController;
import com.nanri.aiimage.modules.similarasin.model.dto.SimilarAsinSubmitResultRequest;
import com.nanri.aiimage.modules.similarasin.service.SimilarAsinTaskService;
import com.nanri.aiimage.modules.task.service.TaskProgressOwnershipSupport;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -107,10 +109,11 @@ class ResultSuccessTimingContractTest {
doAnswer(invocation -> null)
.when(publishTaskService).submitResult(eq(TASK_ID), any(PublishSubmitResultRequest.class));
// 第二个构造参数是 AdminAuthSupport(activateFile 取设备号用),本用例只测 submitResult,
// 不经过该依赖,故传 null(同文件其它 controller 用例亦有传 null 的先例)。
ApiResponse<Void> response = new PublishController(publishTaskService, null)
.submitResult(TASK_ID, new PublishSubmitResultRequest());
// 第二个构造参数是 AdminAuthSupport:submitResult 现在要把请求体里的 user_id 交给会话出口,
// 桩返回 null 即「按会话身份改写归属」,本用例只测「service 提交成功后才回 success」。
AdminAuthSupport adminAuthSupport = mock(AdminAuthSupport.class);
ApiResponse<Void> response = new PublishController(publishTaskService, adminAuthSupport)
.submitResult(TASK_ID, new PublishSubmitResultRequest(), mock(HttpServletRequest.class));
assertTrue(response.isSuccess(), "success=true");
verify(publishTaskService).submitResult(eq(TASK_ID), any(PublishSubmitResultRequest.class));
@@ -28,6 +28,79 @@ public final class SourceScan {
"src/main/java 下找不到 " + fileName + " —— 文件改名/挪目录了,护栏要红在这里"));
}
/**
* 剥掉注释,<b>偏移不变</b>:注释字符换成空格、换行原样保留,所以 {@link #methodBody} 这类
* 按位置切片的助手在剥前剥后切出同一段。
*
* <p>为什么护栏必须打在它上面:源码守卫的两种断言都会被<b>文字</b>喂到——
* 「必须不存在」那一形会被注释里提一句顶红(假红,还能忍),
* 「必须存在/次数等于 N」那一形会被 javadoc 里提一句<b>喂饱</b>(假绿,等于护栏没写)。
* 2026-10-07 实测:{@code AdminTaskCenterController} 的类注释里有 1 处 {@code readScope(},
* 整份原文 {@code readScope(} 数=1、剥完=0——文件级判据吃原文就会读出这种数。</p>
*
* <p>口径:{@code //} 到行尾、{@code /* … *}{@code /} 整段、字符串与字符字面量里的斜杠不算注释、
* 三个双引号的文本块按字面量整段保留。</p>
*/
public static String withoutComments(String java) {
StringBuilder out = new StringBuilder(java.length());
int i = 0;
int n = java.length();
while (i < n) {
char c = java.charAt(i);
char next = i + 1 < n ? java.charAt(i + 1) : '\0';
if (c == '/' && next == '/') {
while (i < n && java.charAt(i) != '\n') {
out.append(' ');
i++;
}
} else if (c == '/' && next == '*') {
out.append(" ");
i += 2;
while (i < n) {
if (java.charAt(i) == '*' && i + 1 < n && java.charAt(i + 1) == '/') {
out.append(" ");
i += 2;
break;
}
out.append(java.charAt(i) == '\n' ? '\n' : ' ');
i++;
}
} else if (java.startsWith("\"\"\"", i)) {
out.append("\"\"\"");
i += 3;
while (i < n && !java.startsWith("\"\"\"", i)) {
out.append(java.charAt(i));
i++;
}
out.append("\"\"\"");
i += 3;
} else if (c == '"' || c == '\'') {
out.append(c);
i++;
while (i < n) {
if (java.charAt(i) == '\\' && i + 1 < n) {
out.append(java.charAt(i)).append(java.charAt(i + 1));
i += 2;
continue;
}
if (java.charAt(i) == '\n') {
break;
}
out.append(java.charAt(i));
boolean closing = java.charAt(i) == c;
i++;
if (closing) {
break;
}
}
} else {
out.append(c);
i++;
}
}
return out.toString();
}
/** 大括号配平切出「某个方法」的源码:<b>从它的签名行往前一直含到注解</b>,到方法收尾的 `}` 为止。
*
* <p>两条它必须自己防住的坑,都写在用例里过:</p>
@@ -142,6 +142,7 @@ import { createCategorizedTimers } from '@/shared/utils/categorized-timers'
import { saveUrlWithProgress } from '@/shared/utils/download-progress'
import { taskStatusClass, taskStatusText } from '@/shared/utils/task-status-text'
import { checkQueuePayload } from '@/shared/dispatch-guard'
import { dispatchedPruneNotice, pruneRows } from '@/shared/utils/dispatch-row-prune'
import { passGuard } from '@/shared/dispatch-guard-ui'
import { mergeHistoryItems } from '@/shared/merge-history-items'
import {
@@ -577,9 +578,14 @@ function startQueue() {
const runnable = matchedRunnableItems.value
if (!runnable.length) { ElMessage.warning('请先匹配可用店铺'); return }
autoQueueEnabled.value = true
pendingQueue.value = mergeItems(pendingQueue.value, runnable)
// 派发即裁剪:整批行留在匹配表里的话,再点一次「启动」就把同一批店铺再抓一遍
// (代理按提取次数计费)。查 ASIN 页 10-04 已按同一形修过,这页当时漏了。
const { remaining, removed } = pruneRows(matchedItems.value, runnable, rowKey)
matchedItems.value = remaining
saveMatched()
pendingQueue.value = mergeItems(pendingQueue.value, removed)
saveQueueState()
queueStatus.value = `已加入 ${runnable.length} 条店铺`
queueStatus.value = dispatchedPruneNotice(removed.length, remaining.length)
void processQueue()
}
@@ -0,0 +1,146 @@
import { test } from 'node:test'
import assert from 'node:assert/strict'
import { readFileSync, readdirSync } from 'node:fs'
import { fileURLToPath } from 'node:url'
import { dirname, join } from 'node:path'
/**
* 「浏览器侧派发循环必须裁剪已派发行」的棘轮守卫(2026-10-07 架构三期,第 4 项)。
*
* 这五页的自动接续跑在浏览器标签页里(`autoQueueEnabled` + while 循环 + 逐行 createTask/enqueue_json)。
* 服务端那套兜底拉取(`/api/tasks/pull-pending`)今天对它们不开:module-types 只配了
* SIMILAR_ASIN 与 COLLECT_DATA,两个开关默认 false,而且这几页每次启动带的 ziniao_version /
* 国家序列 / 定时点从没落库,服务端拿不到"下一家该带什么参数"。所以"标签页关掉就断"是现状,
* 而**在标签页活着的时候把同一批店铺买两遍**是今天唯一能确定修掉的那一半。
*
* 计费口径:代理按提取次数计费,重复派发就是重复花钱(见 dispatch-row-prune.ts 开头那段)。
*
* 为什么不能只 grep 整份文件里有没有 removeMatchedRow:店铺数据抓取页就有一个
* `removeMatchedRow()`(用户手点「移除」用),派发路径一次都没调它 —— 文件级 grep 会把这页
* 判成合规。所以判据落在**函数体**上:要么"启动那支"(写了 autoQueueEnabled.value = true)里
* 接了 pruneRows,要么"派发那支"(写了 enqueue_json / createXxxTask)里逐行删。
*/
const PAGES_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'pages', 'brand', 'components')
function sourceOf(page: string) {
return readFileSync(join(PAGES_DIR, page), 'utf8')
}
/** 按顶层 function 声明切函数体(形状抄 query-asin-dispatch-prune.test.ts 的 functionBody,改成一次切完)。 */
function functionBodies(source: string) {
const starts: number[] = []
const re = /^(?:async )?function [A-Za-z_$][\w$]*\(/gm
let m: RegExpExecArray | null
while ((m = re.exec(source)) !== null) starts.push(m.index)
return starts.map((start, i) => source.slice(start, i + 1 < starts.length ? starts[i + 1] : source.length))
}
const DISPATCH = /enqueue_json|create[A-Za-z]*Task\(/
const STOPS = /autoQueueEnabled\.value = true/
const PRUNES = /pruneRows\(|removeMatchedRowsLocally\(/
interface PageVerdict {
page: string
hasQueueSwitch: boolean
dispatches: boolean
/** 派发那支或启动那支里出现了裁剪 ⇒ 才算受保护 */
pruned: boolean
}
function judge(page: string, source: string): PageVerdict {
const bodies = functionBodies(source)
const hasQueueSwitch = source.includes('autoQueueEnabled = ref(false)')
const dispatches = bodies.some((body) => DISPATCH.test(body))
const protectedByStart = bodies.some((body) => STOPS.test(body) && /pruneRows\(/.test(body))
const protectedByLoop = bodies.some((body) => DISPATCH.test(body) && PRUNES.test(body))
return { page, hasQueueSwitch, dispatches, pruned: protectedByStart || protectedByLoop }
}
const GUARDED_PAGES = [
'BrandProductRiskTab.vue',
'BrandQueryAsinTab.vue',
'BrandShopDataCrawlTab.vue',
'BrandShopMatchTab.vue',
'BrandWithdrawTab.vue',
]
test('判据不是恒绿:一份"有开关、有派发、不裁剪"的样本必须被判成裸奔', () => {
const naked = `
const autoQueueEnabled = ref(false)
async function startQueue() {
autoQueueEnabled.value = true
await processQueue()
}
async function processQueue() {
const api = getPywebviewApi()
await api.enqueue_json(payload)
}`
const verdict = judge('naked.vue', naked)
assert.equal(verdict.hasQueueSwitch, true, '样本没被认成"有自动接续开关"')
assert.equal(verdict.dispatches, true, '样本没被认成"会派发"')
assert.equal(verdict.pruned, false, '样本没裁剪却被判合规 ⇒ 这条守卫等于没写')
// 反向:同一份样本只在"用户手点移除"那支里删行,不许算合规(店铺数据抓取页的真实形状)
const manualOnly = `
const autoQueueEnabled = ref(false)
async function startQueue() {
autoQueueEnabled.value = true
await processQueue()
}
async function processQueue() {
await api.enqueue_json(payload)
}
function removeMatchedRow(item) {
removeMatchedRowsLocally([item])
}`
assert.equal(judge('manual-only.vue', manualOnly).pruned, false,
'把删除挂在用户手点的按钮上不该免掉派发路径的裁剪')
// 再反向:真接了 pruneRows 的必须判绿,否则下一支断言是恒红
const wired = `
const autoQueueEnabled = ref(false)
async function startQueue() {
autoQueueEnabled.value = true
const { remaining, removed } = pruneRows(matchedItems.value, runnable, rowKey)
matchedItems.value = remaining
await processQueue()
}
async function processQueue() {
await api.enqueue_json(payload)
}`
assert.equal(judge('wired.vue', wired).pruned, true, '合规形状被判红 ⇒ 下面的断言会把人逼着改判据')
})
test('五页里带自动接续开关的恰好是这五页,一页都不许多', () => {
const found = readdirSync(PAGES_DIR)
.filter((name) => /^Brand.*Tab\.vue$/.test(name))
.map((name) => judge(name, sourceOf(name)))
.filter((v) => v.hasQueueSwitch && v.dispatches)
.map((v) => v.page)
.sort()
// 名单漂了(新页接了自动接续、或某页把开关拆了)要在这里先响,别等到下一支按老名单跑
assert.deepEqual(found, GUARDED_PAGES, '受本页看守的页面名单变了')
})
test('每一页的派发路径都必须裁掉已交出的行', () => {
const naked = GUARDED_PAGES
.map((name) => judge(name, sourceOf(name)))
.filter((v) => !v.pruned)
.map((v) => v.page)
assert.deepEqual(naked, [], '这些页再点一次启动会把同一批店铺再买一遍')
})
test('店铺数据抓取页:裁剪必须写在启动那支里、且在 processQueue 之前', () => {
const bodies = functionBodies(sourceOf('BrandShopDataCrawlTab.vue'))
const starter = bodies.find((body) => body.startsWith('function startQueue()'))
assert.ok(starter, '没找到 startQueue —— 启动入口改名了,本页看守不到它')
assert.match(
starter,
/const \{ remaining, removed \} = pruneRows\(matchedItems\.value, runnable, rowKey\)[\s\S]{0,120}?matchedItems\.value = remaining\b[\s\S]{0,240}?saveMatched\(\)[\s\S]{0,240}?void processQueue\(\)/,
'匹配表必须被换成 pruneRows 的 remaining、要持久化、且这些都发生在 processQueue 之前',
)
assert.ok(starter.includes('dispatchedPruneNotice('), '派发后没给"再点启动只跑剩余"的统一提示')
assert.ok(!starter.includes('已加入 ${runnable.length} 条店铺'),
'旧文案还在:说明队列里合进去的是 runnable(含未派发行),而不是被裁出来的 removed')
})