fix(鉴权): 到期级联改标量聚合,后台入口按菜单授权放开

三件事同源于 10-06「非默认公司账号进不了数富后台」这条事故链,四种死法在界面上长得一样。

1) AccountExpiryService 读本公司公司超管的 expires_at 时把单列投影成实体列表再遍历——
   MyBatis 对所选列全为 NULL 的行交出的是 null 元素,而"没设到期"是绝大多数公司的常态,
   于是只要有一个永不过期的公司超管,该公司所有账号的登录与每个鉴权请求全部 500。
   改成 mapper 侧一条 MIN(expires_at) 标量聚合;AuthChainQueryShapeTest 扫鉴权链路的
   "单列投影"形状——这个判据落在 mock 边界外,单测挡不住,只能做源码扫描。

2) 后台入口放开:requireConsoleOperator = 管理员角色链 或 本公司树里 >=1 条后台菜单授权
   (探针是带 company_id 条件的标量 COUNT,与下发口径一致,否则进得来而菜单树是空的)。
   逐页另设 requireConsolePageAccess 锚住本页 key,勾父分组覆盖后代的既有语义照旧。
   管理类 10 支控制器继续 requireAdmin,并且出口 2 不再把这些页下发给普通账号——
   下发出去就是一排点了必 403 的死链。内部令牌通道绕过到期与会话校验,不随入口放宽。
   护栏 ConsoleWideningGuardrailTest 双向钉:管理页不得被授权打开、入口落点恰好那 13 支。

3) 前端:后端失败一律 HTTP 200 + success=false,登录页从未解包,所以"什么都不提示"。
   补 login-feedback 归一文案(技术串不外露、兜底不再伪装成用户名或密码错误),
   并修 isLoginLocation 拿路由内路径比 location.pathname——生产实际是 /admin-vue/login,
   那条"已在登录页就别整页重刷"的守卫一次都没生效过。

验证:后端 mvn -o -B test 3924 例 0 红(457 支类);前端 node --test 1738 例 0 红;
vue-tsc --noEmit rc=0;入口探针 SQL 已在生产库只读三档空跑(本公司 1 / 错公司 0 / 无授权 0)。
This commit is contained in:
2026-10-07 00:18:35 +08:00
parent b0444f0903
commit 34113aff8b
32 changed files with 1369 additions and 76 deletions
+14 -2
View File
@@ -1,4 +1,5 @@
/** API 响应解包与错误归一化(任务 22):纯函数,无框架依赖。 */ /** API 响应解包与错误归一化(任务 22):纯函数,无框架依赖(只借 config/app 的 base 常量)。 */
import { joinAdminPath } from '../config/app.ts'
export const REQUEST_FALLBACK_MESSAGE = '网络异常,请稍后重试' export const REQUEST_FALLBACK_MESSAGE = '网络异常,请稍后重试'
@@ -78,11 +79,22 @@ export function loginRedirectTarget(location: { pathname: string; search: string
/** 登录页统一入口;401 一律跳此路径。 */ /** 登录页统一入口;401 一律跳此路径。 */
export const LOGIN_PATH = '/login' export const LOGIN_PATH = '/login'
/**
* 浏览器地址栏里的登录页形态。
*
* <p>LOGIN_PATH 是路由内的相对路径(axios 的 url 也用它比较),而 `window.location.pathname`
* 带 History base,生产实际值是 `/admin-vue/login`。少这一条,"已经在登录页就别再跳"
* 的守卫在真机上一次都没生效过:2026-10-06 那次登录失败,拦截器把整页重刷成
* `/admin-vue/login?redirect=…`,连刚填的用户名和错误原因一起没了。</p>
*/
export const LOGIN_LOCATION_PATH = joinAdminPath('login')
/** 当前 pathname 是否处于登录页(去掉可能携带的查询串后比较)。 */ /** 当前 pathname 是否处于登录页(去掉可能携带的查询串后比较)。 */
export function isLoginLocation(pathname: string): boolean { export function isLoginLocation(pathname: string): boolean {
if (typeof pathname !== 'string') return false if (typeof pathname !== 'string') return false
const queryAt = pathname.indexOf('?') const queryAt = pathname.indexOf('?')
return (queryAt >= 0 ? pathname.slice(0, queryAt) : pathname) === LOGIN_PATH const path = queryAt >= 0 ? pathname.slice(0, queryAt) : pathname
return path === LOGIN_PATH || path === LOGIN_LOCATION_PATH || path === `${LOGIN_LOCATION_PATH}/`
} }
/** 把请求 URL(相对或绝对)规整为相对路径,便于与登录入口比较。 */ /** 把请求 URL(相对或绝对)规整为相对路径,便于与登录入口比较。 */
@@ -4,6 +4,7 @@ import { computed, onMounted, ref } from 'vue'
import { useRoute, useRouter } from 'vue-router' import { useRoute, useRouter } from 'vue-router'
import { http } from '@/api/http' import { http } from '@/api/http'
import { joinAdminPath } from '@/config/app' import { joinAdminPath } from '@/config/app'
import { loginErrorText, unwrapLoginResponse } from './login-feedback'
import { useAdminSessionStore } from '@/stores/admin-session' import { useAdminSessionStore } from '@/stores/admin-session'
const route = useRoute() const route = useRoute()
@@ -59,13 +60,19 @@ async function submit() {
loading.value = true loading.value = true
try { try {
const did = deviceId() const did = deviceId()
await http.post<unknown>('/login', { username: user, password: password.value, deviceId: did }) const { data } = await http.post<unknown>('/login', {
username: user,
password: password.value,
deviceId: did,
})
// 后端失败是 HTTP 200 + success=false,不解包就等于没提示
unwrapLoginResponse(data)
session.$reset() session.$reset()
await session.initialize() await session.initialize()
const target = safeRedirect(route.query.redirect) const target = safeRedirect(route.query.redirect)
await router.replace(target) await router.replace(target)
} catch (error) { } catch (error) {
errorMessage.value = error instanceof Error && error.message ? error.message : '用户名或密码错误' errorMessage.value = loginErrorText(error)
loading.value = false loading.value = false
} }
} }
@@ -0,0 +1,31 @@
/** 登录失败反馈(纯逻辑):把「Java 的 HTTP 200 + success=false」和各类传输层错误都归一成一句能给人看的文案。 */
import { REQUEST_FALLBACK_MESSAGE, requestErrorMessage, unwrap } from '../../api/envelope.ts'
/** 没有可展示原因时的兜底文案(不再伪装成「用户名或密码错误」)。 */
export const LOGIN_FALLBACK_MESSAGE = '登录失败,请稍后重试'
/**
* 解包登录响应:后端所有失败(密码错、账号到期、失败次数锁定、缺少设备ID)都是 HTTP 200 +
* `success:false`,axios 视为成功。不经过这里,登录页就拿不到失败原因——于是"什么都不提示"。
*/
export function unwrapLoginResponse(payload: unknown): void {
unwrap<unknown>(payload)
}
/** 传输层/网关的技术串,对用户没有信息量;命中则换成兜底文案。 */
function isTechnicalText(text: string): boolean {
if (/^request failed with status code \d+$/i.test(text)) return true
if (/^(network error|err_network|timeout of \d+ms exceeded)/i.test(text)) return true
// nginx / 网关的 HTML 错误页:axios 未解析时会把整页原样交出来
return text.startsWith('<')
}
/** 登录失败可展示文案:优先服务端原因,缺省回兜底。 */
export function loginErrorText(error: unknown): string {
const message = requestErrorMessage(error).trim()
// 通用兜底串意味着"没有拿到任何服务端原因",登录页要换成登录语境的文案
if (!message || message === REQUEST_FALLBACK_MESSAGE || isTechnicalText(message)) {
return LOGIN_FALLBACK_MESSAGE
}
return message
}
@@ -0,0 +1,120 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { missingImports, readSource } from './helpers.ts'
import {
isLoginLocation,
shouldRedirectForbidden,
shouldRedirectUnauthorized,
} from '../src/api/envelope.ts'
import {
LOGIN_FALLBACK_MESSAGE,
loginErrorText,
unwrapLoginResponse,
} from '../src/pages/login/login-feedback.ts'
/**
* 登录失败必须有提示(2026-10-06)。
*
* 两个各自独立的"吞掉提示"出口:
* 1. Java 的登录失败一律 HTTP 200 + `success:false`(GlobalExceptionHandler 把 BusinessException
* 编成 ApiResponse.fail),axios 视为成功 → 登录页不解包就永远走不到 catch,`errorMessage` 恒空;
* 2. 紧接着 `session.initialize()` 打 current-user 拿到 401/403,拦截器整页
* `window.location.assign('/admin-vue/login?...')` —— 页面重刷,错误文案连同已填用户名一起没了。
* 守卫本该拦下"已经在登录页"的跳转,但它只比过路由内的 `/login`,而真实 pathname 是 `/admin-vue/login`。
*/
/** 线上真实的登录失败响应体(Java:success/message/data/code,HTTP 200)。 */
const FAIL_BODIES: Array<{ name: string; body: unknown; reason: string }> = [
{
name: '密码错',
body: { success: false, message: '用户名或密码错误', data: null, code: null },
reason: '用户名或密码错误',
},
{
name: '撞库锁定',
body: { success: false, message: '登录失败次数过多,请 12 分钟后再试', data: null, code: null },
reason: '登录失败次数过多,请 12 分钟后再试',
},
{
name: '账号到期',
body: { success: false, message: '账号已于 2026-10-01 到期,请联系管理员续费', data: null, code: 403 },
reason: '账号已于 2026-10-01 到期,请联系管理员续费',
},
{
name: '正常账号无后台权限',
body: { success: false, message: '需要管理员权限', data: null, code: 403 },
reason: '需要管理员权限',
},
]
test('解包登录响应:每一种 HTTP 200 失败都要抛出服务端原因', () => {
for (const { name, body, reason } of FAIL_BODIES) {
assert.throws(() => unwrapLoginResponse(body), (error: unknown) => {
assert.ok(error instanceof Error, `${name} 应抛出 Error`)
assert.equal(error.message, reason, `${name} 要把服务端文案原样带出来`)
return true
})
}
})
test('解包登录响应:成功体不得抛错(否则上面四支会恒真)', () => {
assert.doesNotThrow(() => unwrapLoginResponse({
success: true,
message: '登录成功',
data: { userId: 1201, token: 'jwt', role: 'admin' },
code: null,
}))
})
test('服务端原因空时也有文案,不出现空提示', () => {
assert.throws(() => unwrapLoginResponse({ success: false, message: '', data: null }))
assert.equal(loginErrorText(new Error('')), LOGIN_FALLBACK_MESSAGE)
assert.equal(loginErrorText(undefined), LOGIN_FALLBACK_MESSAGE)
})
test('传输层技术串不外露:状态码串/网络错/HTML 错误页一律回兜底', () => {
const cases: Array<[unknown, string]> = [
[new Error('Request failed with status code 500'), LOGIN_FALLBACK_MESSAGE],
[{ response: { data: { success: false, message: '服务器内部错误,请稍后重试' } } }, '服务器内部错误,请稍后重试'],
[new Error('Network Error'), LOGIN_FALLBACK_MESSAGE],
[new Error('Timeout of 30000ms exceeded.'), LOGIN_FALLBACK_MESSAGE],
[{ response: { data: '<html><body>502 Bad Gateway</body></html>' } }, LOGIN_FALLBACK_MESSAGE],
]
for (const [error, expected] of cases) {
assert.equal(loginErrorText(error), expected)
}
})
test('登录页上的会话引导失败不再整页重刷:这是"啥都没提示"的那一步', () => {
for (const pathname of ['/admin-vue/login', '/admin-vue/login?redirect=%2Fadmin-vue%2Faccount%2Fusers']) {
assert.equal(isLoginLocation(pathname), true, `${pathname} 应在登录页判定内`)
for (const url of ['/api/admin/current-user', '/api/admin/current-user/menus']) {
assert.equal(
shouldRedirectUnauthorized(pathname, url),
false,
`${pathname} 上 ${url} 的 401 不许再跳(跳了就是把提示刷没)`,
)
}
}
})
test('收窄到登录页之外一律照旧:业务页 401 仍跳、引导端点 403 仍跳', () => {
assert.equal(shouldRedirectUnauthorized('/admin-vue/account/users', '/api/admin/current-user'), true)
assert.equal(shouldRedirectUnauthorized('/admin-vue/', '/api/admin/current-user'), true)
// 10-04 那条 403 分流没动:只有会话引导端点的 403 按"进不了后台"处理
assert.equal(shouldRedirectForbidden('/api/admin/current-user'), true)
assert.equal(shouldRedirectForbidden('/api/admin/companies'), false)
// 相邻路径不许被误判成登录页(尾斜杠才算,/admin-vue/login-x 不算)
assert.equal(isLoginLocation('/admin-vue/login-x'), false)
assert.equal(isLoginLocation('/admin-vue/account/login'), false)
})
test('登录页接线:解包 + 归一文案,且不得保留「用户名或密码错误」兜底', () => {
const page = readSource('src/pages/login/LoginPage.vue')
assert.match(page, /http\.post<unknown>\('\/login'/, '断言对象必须是那条登录请求')
assert.match(page, /unwrapLoginResponse\(data\)/, '失败体必须解包,否则永远走不到 catch')
assert.match(page, /errorMessage\.value = loginErrorText\(error\)/)
assert.doesNotMatch(page, /errorMessage\.value = error instanceof Error/, '不得再用 instanceof 当失败判据')
assert.doesNotMatch(page, /:\s*'用户名或密码错误'/, '任何异常都显示"用户名或密码错误"是在伪造原因')
assert.deepEqual(missingImports('src/pages/login/LoginPage.vue'), [])
})
+3 -1
View File
@@ -58,7 +58,9 @@ test('test_task_026_unauthorized_redirect_invalid_input_rejected', () => {
assert.equal(shouldRedirectUnauthorized(undefined as unknown as string, undefined), true) assert.equal(shouldRedirectUnauthorized(undefined as unknown as string, undefined), true)
assert.equal(shouldRedirectUnauthorized(null as unknown as string, null as unknown as string), true) assert.equal(shouldRedirectUnauthorized(null as unknown as string, null as unknown as string), true)
assert.equal(isAuthEndpointRequest(42 as unknown as string), false) assert.equal(isAuthEndpointRequest(42 as unknown as string), false)
assert.equal(isLoginLocation('/admin-vue/login'), false) // 2026-10-06 更正:浏览器地址栏带 History base,登录页的真实 pathname 就是 /admin-vue/login,
// 原先钉成 false 让"已在登录页就不再整页跳转"这条守卫在真机上一次都没生效。
assert.equal(isLoginLocation('/admin-vue/login'), true)
}) })
test('test_task_026_unauthorized_redirect_dependency_failure_returns_actionable_message', () => { test('test_task_026_unauthorized_redirect_dependency_failure_returns_actionable_message', () => {
@@ -3,7 +3,52 @@ package com.nanri.aiimage.common.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity; import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.time.LocalDateTime;
@Mapper @Mapper
public interface AdminUserMapper extends BaseMapper<AdminUserEntity> { public interface AdminUserMapper extends BaseMapper<AdminUserEntity> {
/**
* 本公司「公司超级管理员」里最早的到期时间;返回 null = 本公司无此约束(没有公司超管,
* 或它们全部永不过期)。到期级联判据见 {@code AccountExpiryService}。
*
* <p>刻意用聚合标量而不是 {@code selectList(.select(expiresAt))}:MyBatis 对「所选列全为
* NULL」的行返回 null 元素,一家公司只要有任意一个公司超管没设到期,那条列表里就混着 null,
* 遍历时解引用即 NPE,而这里正是每次登录与每个鉴权请求都要走的读出口。MIN 忽略 NULL,
* 无行时结果集仍是单行单列,直接映射成 null。</p>
*/
@Select("""
SELECT MIN(expires_at)
FROM users
WHERE role = 'company_super_admin'
AND company_id = #{companyId}
""")
LocalDateTime selectCompanySuperAdminEarliestExpiry(@Param("companyId") Long companyId);
/**
* 该账号在<b>本公司那棵树</b>里被授了几条后台(menu_type='admin')菜单;>0 即允许进管理后台。
*
* <p>刻意用标量 COUNT 而不是 {@code selectList(.select(columnId))}:与上面那条同样的投影陷阱
* (见 {@code AuthChainQueryShapeTest}),而这里是每个后台入口请求都要走的鉴权读。</p>
*
* <p>必须带 {@code cm.company_id} 条件:每家公司一套树之后,{@code column_id} 指向别家树的
* 残留授权行会让账号"进得了后台、菜单树却是空的"——入口门与 {@code getUserColumnPermissions}
* 的下发集要用同一个公司口径,否则两处各判一次就留下静默死链。</p>
*/
@Select("""
<script>
SELECT COUNT(1)
FROM user_column_permission ucp
JOIN columns cm ON cm.id = ucp.column_id
WHERE ucp.user_id = #{userId}
AND cm.menu_type = 'admin'
<if test="companyId != null">
AND cm.company_id = #{companyId}
</if>
</script>
""")
Long countAdminMenuGrants(@Param("userId") Long userId, @Param("companyId") Long companyId);
} }
@@ -1,6 +1,5 @@
package com.nanri.aiimage.common.security; package com.nanri.aiimage.common.security;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nanri.aiimage.common.exception.BusinessException; import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper; import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.mapper.ShopManageGroupMapper; import com.nanri.aiimage.common.mapper.ShopManageGroupMapper;
@@ -11,7 +10,6 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.util.List;
/** /**
* 账号到期(expires_at,V146)的级联判定与拦截。 * 账号到期(expires_at,V146)的级联判定与拦截。
@@ -113,15 +111,7 @@ public class AccountExpiryService {
if (companyId == null || companyId <= 0) { if (companyId == null || companyId <= 0) {
return null; return null;
} }
List<AdminUserEntity> csas = adminUserMapper.selectList(new LambdaQueryWrapper<AdminUserEntity>() return adminUserMapper.selectCompanySuperAdminEarliestExpiry(companyId);
.select(AdminUserEntity::getExpiresAt)
.eq(AdminUserEntity::getRole, "company_super_admin")
.eq(AdminUserEntity::getCompanyId, companyId));
LocalDateTime earliest = null;
for (AdminUserEntity csa : csas) {
earliest = min(earliest, csa.getExpiresAt());
}
return earliest;
} }
/** 组级:该用户所属分组(成员表)的组长(created_by_id/user_id)若是管理员,取其最早 expires_at。 */ /** 组级:该用户所属分组(成员表)的组长(created_by_id/user_id)若是管理员,取其最早 expires_at。 */
@@ -114,6 +114,51 @@ public class AdminAuthSupport {
return user; return user;
} }
/**
* 后台入口门:管理员角色恒可进;普通账号持有本公司任意后台菜单授权也可进。
*
* <p>2026-10-06 放开。此前"进后台"与"有管理员角色"绑死,超管在权限页给普通账号勾了
* 后台菜单也照样 403——授权动作做了,门没跟着开,界面上表现为点了没反应。放开只针对
* <b>入口</b>:每一页仍由该页自己的门把关({@code PermissionMenuService.requireConsolePageAccess}
* 按该页菜单键判定),管理类出口(用户/菜单/分组/密钥/公司/版本)一律继续走
* {@link #requireAdmin},不在这里放宽。</p>
*/
public AdminUserEntity requireConsoleOperator(HttpServletRequest request) {
AdminUserEntity user = requireUser(request);
if (!isConsoleOperator(user)) {
throw new BusinessException(403, "需要管理员权限");
}
return user;
}
/** JWT 优先走入口门;内部令牌通道仍要求管理员角色——它绕过到期与会话校验,不随入口一起放宽。 */
public AdminUserEntity requireConsoleOperatorOrInternal(HttpServletRequest request) {
try {
return requireConsoleOperator(request);
} catch (BusinessException authFailure) {
AdminUserEntity internalOperator = resolveInternalOperator(request, true);
if (internalOperator != null) {
return internalOperator;
}
throw authFailure;
}
}
/** 入口判定:角色链(super_admin / admin / company_super_admin)或本公司任意一条后台菜单授权。 */
public boolean isConsoleOperator(AdminUserEntity user) {
if (user == null) {
return false;
}
if (currentRole(user) != null) {
return true;
}
if (user.getId() == null || user.getId() <= 0) {
return false;
}
Long grants = adminUserMapper.countAdminMenuGrants(user.getId(), user.getCompanyId());
return grants != null && grants > 0;
}
/** 计算当前用户的管理角色:super_admin / admin / null。 */ /** 计算当前用户的管理角色:super_admin / admin / null。 */
public String currentRole(AdminUserEntity user) { public String currentRole(AdminUserEntity user) {
if (user == null) { if (user == null) {
@@ -67,7 +67,7 @@ public class AdminConsoleController {
@GetMapping("/api/admin/current-user") @GetMapping("/api/admin/current-user")
@Operation(summary = "获取当前管理员信息") @Operation(summary = "获取当前管理员信息")
public ApiResponse<Map<String, Object>> currentUser(HttpServletRequest request) { public ApiResponse<Map<String, Object>> currentUser(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
Map<String, Object> item = new LinkedHashMap<>(); Map<String, Object> item = new LinkedHashMap<>();
item.put("id", operator.getId()); item.put("id", operator.getId());
item.put("username", operator.getUsername() == null ? "" : operator.getUsername()); item.put("username", operator.getUsername() == null ? "" : operator.getUsername());
@@ -87,7 +87,7 @@ public class AdminConsoleController {
@GetMapping("/api/admin/current-user/menus") @GetMapping("/api/admin/current-user/menus")
@Operation(summary = "当前登录管理员的可见后台菜单树") @Operation(summary = "当前登录管理员的可见后台菜单树")
public ApiResponse<Map<String, Object>> currentUserMenus(HttpServletRequest request) { public ApiResponse<Map<String, Object>> currentUserMenus(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
// 补全祖先分组:部分授权用户(只授权了子页面)也要看到「一级分组 + 子页面」层级, // 补全祖先分组:部分授权用户(只授权了子页面)也要看到「一级分组 + 子页面」层级,
// 与超管的菜单组织顺序一致;分组节点无页面路由,不构成权限扩展。 // 与超管的菜单组织顺序一致;分组节点无页面路由,不构成权限扩展。
List<PermissionMenuItemVo> menus = permissionMenuService.getUserColumnPermissions( List<PermissionMenuItemVo> menus = permissionMenuService.getUserColumnPermissions(
@@ -40,7 +40,7 @@ public class ImageHistoryController {
@RequestParam(name = "time_start", required = false) String timeStart, @RequestParam(name = "time_start", required = false) String timeStart,
@RequestParam(name = "time_end", required = false) String timeEnd, @RequestParam(name = "time_end", required = false) String timeEnd,
@RequestParam(name = "company_id", required = false) Long companyId) { @RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
if (!permissionMenuService.hasAnyAdminMenu(operator, List.of("admin_history"))) { if (!permissionMenuService.hasAnyAdminMenu(operator, List.of("admin_history"))) {
throw new BusinessException(403, "无权访问生成记录模块"); throw new BusinessException(403, "无权访问生成记录模块");
} }
@@ -54,7 +54,7 @@ public class ImageHistoryController {
@DeleteMapping("/history") @DeleteMapping("/history")
@Operation(summary = "清空全部生成记录") @Operation(summary = "清空全部生成记录")
public ApiResponse<Long> clearHistory(HttpServletRequest request) { public ApiResponse<Long> clearHistory(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
if (!permissionMenuService.hasAnyAdminMenu(operator, List.of("admin_history"))) { if (!permissionMenuService.hasAnyAdminMenu(operator, List.of("admin_history"))) {
throw new BusinessException(403, "无权访问生成记录模块"); throw new BusinessException(403, "无权访问生成记录模块");
} }
@@ -66,6 +66,14 @@ public class AdminImageVideoTaskController {
private final ImageVideoAdminTaskService adminTaskService; private final ImageVideoAdminTaskService adminTaskService;
private final AdminAuthSupport adminAuthSupport; private final AdminAuthSupport adminAuthSupport;
private final DataReadScope dataReadScope; private final DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 过「视频任务记录」这一页的门:管理员角色行为不变,普通账号须被授了该菜单(2026-10-06 入口放开)。 */
private AdminUserEntity requireOperator(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问视频任务记录", "admin_image_video_tasks");
return operator;
}
@GetMapping @GetMapping
@Operation(summary = "分页查询图生视频任务", description = "管理端按用户/任务状态/提交时间等条件分页查询近 3 天的工作流任务") @Operation(summary = "分页查询图生视频任务", description = "管理端按用户/任务状态/提交时间等条件分页查询近 3 天的工作流任务")
@@ -80,7 +88,7 @@ public class AdminImageVideoTaskController {
@RequestParam(name = "submitted_to", required = false) String submittedTo, @RequestParam(name = "submitted_to", required = false) String submittedTo,
@RequestParam(name = "company_id", required = false) Long companyId, @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) { HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = requireOperator(request);
// 既有语义保留:显式传 user_id 时按那一个人筛;公司 tab 叠在它上面(交集)。 // 既有语义保留:显式传 user_id 时按那一个人筛;公司 tab 叠在它上面(交集)。
List<Long> base = userId != null && userId > 0 ? List.of(userId) : null; List<Long> base = userId != null && userId > 0 ? List.of(userId) : null;
List<Long> scoped = dataReadScope.readScope(operator, companyId).userIdsOr(base); List<Long> scoped = dataReadScope.readScope(operator, companyId).userIdsOr(base);
@@ -100,7 +108,7 @@ public class AdminImageVideoTaskController {
@GetMapping("/{taskId}") @GetMapping("/{taskId}")
@Operation(summary = "查询图生视频任务详情", description = "返回单个任务详情(含脱敏后的请求参数与结果 JSON)") @Operation(summary = "查询图生视频任务详情", description = "返回单个任务详情(含脱敏后的请求参数与结果 JSON)")
public ApiResponse<Map<String, Object>> detail(@PathVariable Long taskId, HttpServletRequest request) { public ApiResponse<Map<String, Object>> detail(@PathVariable Long taskId, HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = requireOperator(request);
return ApiResponse.success(adminTaskService.detail(taskId, scopeOf(operator))); return ApiResponse.success(adminTaskService.detail(taskId, scopeOf(operator)));
} }
@@ -108,7 +116,7 @@ public class AdminImageVideoTaskController {
@Operation(summary = "批量打包下载视频", description = "按任务+视频下标批量打包 zip;部分失败通过响应头 X-Archive-Error-Count 提示") @Operation(summary = "批量打包下载视频", description = "按任务+视频下标批量打包 zip;部分失败通过响应头 X-Archive-Error-Count 提示")
public ResponseEntity<StreamingResponseBody> downloadZip(@RequestBody(required = false) Map<String, Object> body, public ResponseEntity<StreamingResponseBody> downloadZip(@RequestBody(required = false) Map<String, Object> body,
HttpServletRequest request) { HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = requireOperator(request);
List<VideoSelection> selections = parseSelections(body); List<VideoSelection> selections = parseSelections(body);
ZipBundle bundle = adminTaskService.buildZip(selections, scopeOf(operator)); ZipBundle bundle = adminTaskService.buildZip(selections, scopeOf(operator));
String filename = "video-tasks-" + LocalDateTime.now().format(ZIP_FILENAME_FORMATTER) + ".zip"; String filename = "video-tasks-" + LocalDateTime.now().format(ZIP_FILENAME_FORMATTER) + ".zip";
@@ -82,7 +82,9 @@ public class AdminNotificationController {
} }
private Long currentAdminId(HttpServletRequest request) { private Long currentAdminId(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdmin(request); // 通知是"自己看自己的"(userId 由会话推导),后台的铃铛在每个进得来后台的人面前都会轮询,
// 所以出口跟着入口门走;留 requireAdmin 会让刚放开的普通账号每 30s 吃一次 403。
AdminUserEntity operator = adminAuthSupport.requireConsoleOperator(request);
return operator.getId(); return operator.getId();
} }
} }
@@ -55,6 +55,21 @@ public class PermissionMenuService {
* 与前端 src/config/company-scope.ts 的 SUPER_ADMIN_ONLY_MENU_KEYS 必须同值,由 Task 7 的跨端用例钉住。 */ * 与前端 src/config/company-scope.ts 的 SUPER_ADMIN_ONLY_MENU_KEYS 必须同值,由 Task 7 的跨端用例钉住。 */
private static final Set<String> SUPER_ADMIN_ONLY_KEYS = Set.of("admin_companies"); private static final Set<String> SUPER_ADMIN_ONLY_KEYS = Set.of("admin_companies");
/**
* 管理/平台配置类菜单:出口仍是 {@code requireAdmin}(用户、菜单、分组、密钥、公司、版本、教程、
* 日志),普通账号即使被勾了也用不了。
*
* <p>2026-10-06 入口放开后必须与下发集一起剪:现网实查有 13 个普通账号带着 {@code admin_users}、
* 11 个带 {@code admin_user_secrets}、9 个带 {@code admin_version} 的授权行,只在出口拦而照常下发
* 侧边栏,等于给刚放进来的人画一排必 403 的死链(显示比权限宽)。剪掉只是不再显示,
* 授权行本身不动——这些账号本来就进不去那些页。</p>
*/
private static final Set<String> ADMIN_ONLY_MENU_KEYS = Set.of(
"admin_users", "admin_columns", "admin_group_manage",
"admin_user_secrets", "admin_user_secret_usage",
"admin_version", "digital_human_version", "admin_tutorial",
"admin_device_logs");
private final PermissionMenuMapper permissionMenuMapper; private final PermissionMenuMapper permissionMenuMapper;
private final UserColumnPermissionMapper userColumnPermissionMapper; private final UserColumnPermissionMapper userColumnPermissionMapper;
private final AdminUserMapper adminUserMapper; private final AdminUserMapper adminUserMapper;
@@ -549,6 +564,9 @@ public class PermissionMenuService {
// 换成剪过的集合会让只勾了子页面的用户解析不出父分组,等于把「用户管理」一起弄红。 // 换成剪过的集合会让只勾了子页面的用户解析不出父分组,等于把「用户管理」一起弄红。
List<PermissionMenuEntity> visibleMenus = effectiveMenus.stream() List<PermissionMenuEntity> visibleMenus = effectiveMenus.stream()
.filter(menu -> !SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey())) .filter(menu -> !SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey()))
// 出口 2 的第二道剪枝(与上一行同一批语义):管理/平台页对普通账号不下发——
// 它们的后端出口仍是 requireAdmin,下发出去就是一条点了必 403 的死链。
.filter(menu -> isAdmin(user) || !ADMIN_ONLY_MENU_KEYS.contains(menu.getColumnKey()))
.toList(); .toList();
return toItemVos(visibleMenus, menus); return toItemVos(visibleMenus, menus);
} }
@@ -722,7 +740,8 @@ public class PermissionMenuService {
* 不应再被 403 拒绝。</p> * 不应再被 403 拒绝。</p>
*/ */
public void requireShopDataCrawlTaskAccess(AdminUserEntity operator) { public void requireShopDataCrawlTaskAccess(AdminUserEntity operator) {
ensureAdminOperatorIfPresent(operator); // 不再前置判"是不是管理员角色":2026-10-06 入口放开后,那道角色门会把下面按授权判的门
// 变成普通账号永远走不到的死代码(菜单勾了、页里仍然 403)。真正的门就是下面那三行授权命中。
if (operator == null || operator.getId() == null || operator.getId() <= 0) { if (operator == null || operator.getId() == null || operator.getId() <= 0) {
throw new BusinessException(403, "需要管理员权限"); throw new BusinessException(403, "需要管理员权限");
} }
@@ -752,7 +771,6 @@ public class PermissionMenuService {
* 授权记录即拒绝,因此新菜单默认只有超管可见。</p> * 授权记录即拒绝,因此新菜单默认只有超管可见。</p>
*/ */
public void requireClientTaskCenterAccess(AdminUserEntity operator) { public void requireClientTaskCenterAccess(AdminUserEntity operator) {
ensureAdminOperatorIfPresent(operator);
if (operator == null || operator.getId() == null || operator.getId() <= 0) { if (operator == null || operator.getId() == null || operator.getId() <= 0) {
throw new BusinessException(403, "需要管理员权限"); throw new BusinessException(403, "需要管理员权限");
} }
@@ -766,6 +784,25 @@ public class PermissionMenuService {
} }
} }
/**
* 后台页面门(2026-10-06):管理员角色链行为不变恒可进;普通账号必须持有<b>这一页</b>的后台菜单
* 授权才放行。
*
* <p>入口放开不等于逐页放开。现网 46 个普通账号持有后台菜单授权(只读实查 2026-10-06),若逐页门只看入口,它们顺手就能读到同公司的密钥页与扣次数的 ASIN 查询页——勾菜单的人本意是给一页,不是给全部。
* 判据与 {@link #hasAnyAdminMenu} 同一套(本公司树 + 直接授权递归展开),所以勾父分组
* 覆盖后代的语义在这里照样成立。</p>
*/
public void requireConsolePageAccess(AdminUserEntity operator, String denialMessage, String... columnKeys) {
if (operator == null || isAdmin(operator)) {
return;
}
if (columnKeys != null && columnKeys.length > 0
&& hasAnyAdminMenu(operator, List.of(columnKeys))) {
return;
}
throw new BusinessException(403, denialMessage);
}
/** /**
* 判断操作者是否可见任一所给后台菜单(按 column_key,限定 admin 菜单类型)。 * 判断操作者是否可见任一所给后台菜单(按 column_key,限定 admin 菜单类型)。
* 超管直通;其余取直接授权递归展开后的有效菜单做交集。 * 超管直通;其余取直接授权递归展开后的有效菜单做交集。
@@ -1,6 +1,7 @@
package com.nanri.aiimage.modules.productcategory.controller; package com.nanri.aiimage.modules.productcategory.controller;
import com.nanri.aiimage.common.api.ApiResponse; import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.util.DownloadHeaderUtil; import com.nanri.aiimage.common.util.DownloadHeaderUtil;
import com.nanri.aiimage.common.security.AdminAuthSupport; import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest; import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
@@ -38,13 +39,20 @@ public class ProductCategoryController {
private final ProductCategoryService productCategoryService; private final ProductCategoryService productCategoryService;
private final AdminAuthSupport adminAuthSupport; private final AdminAuthSupport adminAuthSupport;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 过「商品类目」这一页的门:管理员角色行为不变,普通账号须被授了该菜单(2026-10-06 入口放开)。 */
private void requireOperator(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问商品类目", "admin_product_categories");
}
@GetMapping("/product-categories") @GetMapping("/product-categories")
@Operation(summary = "查询商品类目树") @Operation(summary = "查询商品类目树")
public ApiResponse<ProductCategoryListVo> list( public ApiResponse<ProductCategoryListVo> list(
HttpServletRequest request, HttpServletRequest request,
@RequestParam(value = "keyword", required = false) String keyword) { @RequestParam(value = "keyword", required = false) String keyword) {
adminAuthSupport.requireAdminOrInternal(request); requireOperator(request);
return ApiResponse.success(productCategoryService.list(keyword)); return ApiResponse.success(productCategoryService.list(keyword));
} }
@@ -55,7 +63,7 @@ public class ProductCategoryController {
@RequestParam(value = "parent_id", required = false) Long parentId, @RequestParam(value = "parent_id", required = false) Long parentId,
@RequestParam(value = "page", defaultValue = "1") Long page, @RequestParam(value = "page", defaultValue = "1") Long page,
@RequestParam(value = "page_size", defaultValue = "20") Long pageSize) { @RequestParam(value = "page_size", defaultValue = "20") Long pageSize) {
adminAuthSupport.requireAdminOrInternal(request); requireOperator(request);
return ApiResponse.success(productCategoryService.children(parentId, page, pageSize)); return ApiResponse.success(productCategoryService.children(parentId, page, pageSize));
} }
@@ -66,7 +74,7 @@ public class ProductCategoryController {
@RequestParam(value = "keyword", required = false) String keyword, @RequestParam(value = "keyword", required = false) String keyword,
@RequestParam(value = "page", defaultValue = "1") Long page, @RequestParam(value = "page", defaultValue = "1") Long page,
@RequestParam(value = "page_size", defaultValue = "20") Long pageSize) { @RequestParam(value = "page_size", defaultValue = "20") Long pageSize) {
adminAuthSupport.requireAdminOrInternal(request); requireOperator(request);
return ApiResponse.success(productCategoryService.search(keyword, page, pageSize)); return ApiResponse.success(productCategoryService.search(keyword, page, pageSize));
} }
@@ -75,7 +83,7 @@ public class ProductCategoryController {
public ResponseEntity<byte[]> export( public ResponseEntity<byte[]> export(
HttpServletRequest request, HttpServletRequest request,
@RequestParam(value = "keyword", required = false) String keyword) { @RequestParam(value = "keyword", required = false) String keyword) {
adminAuthSupport.requireAdminOrInternal(request); requireOperator(request);
byte[] bytes = productCategoryService.export(keyword); byte[] bytes = productCategoryService.export(keyword);
String filename = "product-categories-" + LocalDateTime.now().format(EXPORT_FILENAME_FORMATTER) + ".xlsx"; String filename = "product-categories-" + LocalDateTime.now().format(EXPORT_FILENAME_FORMATTER) + ".xlsx";
return ResponseEntity.ok() return ResponseEntity.ok()
@@ -90,7 +98,7 @@ public class ProductCategoryController {
public ApiResponse<ProductCategoryItemVo> create( public ApiResponse<ProductCategoryItemVo> create(
HttpServletRequest request, HttpServletRequest request,
@Valid @RequestBody ProductCategorySaveRequest body) { @Valid @RequestBody ProductCategorySaveRequest body) {
adminAuthSupport.requireAdminOrInternal(request); requireOperator(request);
return ApiResponse.success("创建成功", productCategoryService.create(body)); return ApiResponse.success("创建成功", productCategoryService.create(body));
} }
@@ -100,7 +108,7 @@ public class ProductCategoryController {
HttpServletRequest request, HttpServletRequest request,
@PathVariable Long id, @PathVariable Long id,
@Valid @RequestBody ProductCategorySaveRequest body) { @Valid @RequestBody ProductCategorySaveRequest body) {
adminAuthSupport.requireAdminOrInternal(request); requireOperator(request);
return ApiResponse.success("保存成功", productCategoryService.update(id, body)); return ApiResponse.success("保存成功", productCategoryService.update(id, body));
} }
@@ -109,7 +117,7 @@ public class ProductCategoryController {
public ApiResponse<Void> delete( public ApiResponse<Void> delete(
HttpServletRequest request, HttpServletRequest request,
@PathVariable Long id) { @PathVariable Long id) {
adminAuthSupport.requireAdminOrInternal(request); requireOperator(request);
productCategoryService.delete(id); productCategoryService.delete(id);
return ApiResponse.success("删除成功", null); return ApiResponse.success("删除成功", null);
} }
@@ -79,7 +79,9 @@ public class AdminShopDataCrawlTaskController {
private void requireShopDataCrawlTaskAccess(HttpServletRequest request) { private void requireShopDataCrawlTaskAccess(HttpServletRequest request) {
AdminUserEntity operator; AdminUserEntity operator;
try { try {
operator = adminAuthSupport.requireAdmin(request); // 入口门随 2026-10-06 的放开一起换:普通账号能否进这一页由下面
// permissionMenuService.requireShopDataCrawlTaskAccess 按授权判定,这里不再抢跑判角色。
operator = adminAuthSupport.requireConsoleOperator(request);
} catch (BusinessException authFailure) { } catch (BusinessException authFailure) {
operator = resolveInternalOperator(request); operator = resolveInternalOperator(request);
if (operator == null) { if (operator == null) {
@@ -280,7 +280,9 @@ public class AdminShopDataCrawlTasksController {
private AdminUserEntity requireShopDataCrawlTaskAccess(HttpServletRequest request) { private AdminUserEntity requireShopDataCrawlTaskAccess(HttpServletRequest request) {
AdminUserEntity operator; AdminUserEntity operator;
try { try {
operator = adminAuthSupport.requireAdmin(request); // 入口门随 2026-10-06 的放开一起换:普通账号能否进这一页由下面
// permissionMenuService.requireShopDataCrawlTaskAccess 按授权判定,这里不再抢跑判角色。
operator = adminAuthSupport.requireConsoleOperator(request);
} catch (BusinessException authFailure) { } catch (BusinessException authFailure) {
operator = resolveInternalOperator(request); operator = resolveInternalOperator(request);
if (operator == null) { if (operator == null) {
@@ -289,7 +289,8 @@ public class AdminShopDataDuplicateCheckController {
private RequestOperator requireDuplicateCheckAccess(HttpServletRequest request) { private RequestOperator requireDuplicateCheckAccess(HttpServletRequest request) {
AdminUserEntity operator; AdminUserEntity operator;
try { try {
operator = adminAuthSupport.requireAdmin(request); // 入口门随 2026-10-06 的放开一起换:这一页能不能进由下面按授权判定,这里不再抢跑判角色。
operator = adminAuthSupport.requireConsoleOperator(request);
} catch (BusinessException authFailure) { } catch (BusinessException authFailure) {
operator = resolveInternalOperator(request); operator = resolveInternalOperator(request);
if (operator == null) { if (operator == null) {
@@ -45,10 +45,14 @@ public class QueryAsinController {
private final QueryAsinService queryAsinService; private final QueryAsinService queryAsinService;
private final AdminAuthSupport adminAuthSupport; private final AdminAuthSupport adminAuthSupport;
private final com.nanri.aiimage.common.service.DataReadScope dataReadScope; private final com.nanri.aiimage.common.service.DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 解析当前操作者(JWT 或内部令牌通道),权限与数据范围一律以该身份为准。 */ /** 解析当前操作者(JWT 或内部令牌通道),权限与数据范围一律以该身份为准。 */
private AdminUserEntity requireOperator(HttpServletRequest request) { private AdminUserEntity requireOperator(HttpServletRequest request) {
return adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
// 查询 ASIN 是扣次数的出口:入口放开后仍要按这一页的菜单授权把关,不能让人顺手烧别家的额度。
permissionMenuService.requireConsolePageAccess(operator, "无权访问查询ASIN", "admin_query_asin");
return operator;
} }
@GetMapping @GetMapping
@@ -37,6 +37,17 @@ public class ShopKeyController {
private final ShopKeyService shopKeyService; private final ShopKeyService shopKeyService;
private final AdminAuthSupport adminAuthSupport; private final AdminAuthSupport adminAuthSupport;
private final DataReadScope dataReadScope; private final DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/**
* 解析当前操作者并过「店铺密钥管理」这一页的门:管理员角色行为不变,普通账号须被授了该菜单。
* 密钥是每家公司的敏感配置,入口放开不能顺手把它对全体进后台的人打开。
*/
private AdminUserEntity requireOperator(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问店铺密钥管理", "admin_shop_keys");
return operator;
}
@GetMapping @GetMapping
@Operation(summary = "分页查询店铺密钥", description = "分页查询店铺密钥列表。company_id 只收窄可见集、不放大:" @Operation(summary = "分页查询店铺密钥", description = "分页查询店铺密钥列表。company_id 只收窄可见集、不放大:"
@@ -50,7 +61,7 @@ public class ShopKeyController {
@Parameter(description = "每页数量") @RequestParam(defaultValue = "15") Long pageSize, @Parameter(description = "每页数量") @RequestParam(defaultValue = "15") Long pageSize,
@Parameter(description = "按公司筛选(仅超管生效;非超管一律按会话公司裁剪)") @Parameter(description = "按公司筛选(仅超管生效;非超管一律按会话公司裁剪)")
@RequestParam(name = "company_id", required = false) Long companyId) { @RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = requireOperator(request);
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId); Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
return ApiResponse.success(shopKeyService.page(page, pageSize, scopedCompanyId)); return ApiResponse.success(shopKeyService.page(page, pageSize, scopedCompanyId));
} }
@@ -64,7 +75,7 @@ public class ShopKeyController {
public ApiResponse<ShopKeyItemVo> create( public ApiResponse<ShopKeyItemVo> create(
HttpServletRequest request, HttpServletRequest request,
@Valid @RequestBody ShopKeyCreateRequest body) { @Valid @RequestBody ShopKeyCreateRequest body) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = requireOperator(request);
return ApiResponse.success("创建成功", shopKeyService.create(body, operator.getId())); return ApiResponse.success("创建成功", shopKeyService.create(body, operator.getId()));
} }
@@ -80,7 +91,7 @@ public class ShopKeyController {
HttpServletRequest request, HttpServletRequest request,
@Parameter(description = "主键ID", required = true) @PathVariable Long id, @Parameter(description = "主键ID", required = true) @PathVariable Long id,
@Valid @RequestBody ShopKeyUpdateRequest body) { @Valid @RequestBody ShopKeyUpdateRequest body) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = requireOperator(request);
return ApiResponse.success("更新成功", shopKeyService.update(id, body, dataReadScope.writeCompanyId(operator))); return ApiResponse.success("更新成功", shopKeyService.update(id, body, dataReadScope.writeCompanyId(operator)));
} }
@@ -94,7 +105,7 @@ public class ShopKeyController {
public ApiResponse<Void> delete( public ApiResponse<Void> delete(
HttpServletRequest request, HttpServletRequest request,
@Parameter(description = "主键ID", required = true) @PathVariable Long id) { @Parameter(description = "主键ID", required = true) @PathVariable Long id) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = requireOperator(request);
shopKeyService.delete(id, dataReadScope.writeCompanyId(operator)); shopKeyService.delete(id, dataReadScope.writeCompanyId(operator));
return ApiResponse.success("删除成功", null); return ApiResponse.success("删除成功", null);
} }
@@ -112,7 +123,7 @@ public class ShopKeyController {
public ApiResponse<ShopKeyItemVo> checkWhitelist( public ApiResponse<ShopKeyItemVo> checkWhitelist(
HttpServletRequest request, HttpServletRequest request,
@Parameter(description = "主键ID", required = true) @PathVariable Long id) { @Parameter(description = "主键ID", required = true) @PathVariable Long id) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = requireOperator(request);
return ApiResponse.success("检测完成", shopKeyService.checkWhitelist(id, dataReadScope.writeCompanyId(operator))); return ApiResponse.success("检测完成", shopKeyService.checkWhitelist(id, dataReadScope.writeCompanyId(operator)));
} }
} }
@@ -49,10 +49,18 @@ public class ShopManageController {
private final ShopManageGroupService shopManageGroupService; private final ShopManageGroupService shopManageGroupService;
private final AdminAuthSupport adminAuthSupport; private final AdminAuthSupport adminAuthSupport;
private final DataReadScope dataReadScope; private final DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 解析当前操作者(JWT 或内部令牌通道),数据范围一律以该身份为准,不信任调用方传入的 operatorId/superAdmin。 */ /**
* 解析当前操作者(JWT 或内部令牌通道),数据范围一律以该身份为准,不信任调用方传入的 operatorId/superAdmin。
*
* <p>2026-10-06:入口门放开后补这一页自己的门——管理员角色行为不变,普通账号必须被授了
* 「店铺管理」菜单才读得到店铺与分组。</p>
*/
private AdminUserEntity requireOperator(HttpServletRequest request) { private AdminUserEntity requireOperator(HttpServletRequest request) {
return adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问店铺管理", "admin_shop_manage");
return operator;
} }
private boolean isSuper(AdminUserEntity operator) { private boolean isSuper(AdminUserEntity operator) {
@@ -46,10 +46,13 @@ public class SkipPriceAsinController {
private final SkipPriceAsinService skipPriceAsinService; private final SkipPriceAsinService skipPriceAsinService;
private final AdminAuthSupport adminAuthSupport; private final AdminAuthSupport adminAuthSupport;
private final com.nanri.aiimage.common.service.DataReadScope dataReadScope; private final com.nanri.aiimage.common.service.DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 解析当前操作者(JWT 或内部令牌通道),权限与数据范围一律以该身份为准。 */ /** 解析当前操作者(JWT 或内部令牌通道),权限与数据范围一律以该身份为准。 */
private AdminUserEntity requireOperator(HttpServletRequest request) { private AdminUserEntity requireOperator(HttpServletRequest request) {
return adminAuthSupport.requireAdminOrInternal(request); AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问最低价ASIN", "admin_skip_price_asin");
return operator;
} }
@GetMapping @GetMapping
@@ -147,7 +147,8 @@ public class AdminTaskCenterController {
/** 会话闸门(登录态 + 菜单权限),五个端点同一把;service 只认算好的 operatorId。 */ /** 会话闸门(登录态 + 菜单权限),五个端点同一把;service 只认算好的 operatorId。 */
private AdminUserEntity authorizedOperator(HttpServletRequest request) { private AdminUserEntity authorizedOperator(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request); // 入口门换成"管理员角色或持有后台授权",是否能看到这一页仍由下一行的菜单授权判定。
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireClientTaskCenterAccess(operator); permissionMenuService.requireClientTaskCenterAccess(operator);
return operator; return operator;
} }
@@ -42,7 +42,7 @@ class AccountExpiryServiceTest {
groupMapper = mock(ShopManageGroupMapper.class); groupMapper = mock(ShopManageGroupMapper.class);
service = new AccountExpiryService(adminUserMapper, groupMapper); service = new AccountExpiryService(adminUserMapper, groupMapper);
// 默认:无公司超管、无组长、无创建人约束 // 默认:无公司超管、无组长、无创建人约束
when(adminUserMapper.selectList(any())).thenReturn(List.of()); when(adminUserMapper.selectCompanySuperAdminEarliestExpiry(any())).thenReturn(null);
when(adminUserMapper.selectById(any(Long.class))).thenReturn(null); when(adminUserMapper.selectById(any(Long.class))).thenReturn(null);
when(groupMapper.selectLeaderIdsByMemberUserId(any())).thenReturn(List.of()); when(groupMapper.selectLeaderIdsByMemberUserId(any())).thenReturn(List.of());
} }
@@ -70,11 +70,7 @@ class AccountExpiryServiceTest {
@Test @Test
void companySuperAdminExpiryCapsEveryoneInTheCompany() { void companySuperAdminExpiryCapsEveryoneInTheCompany() {
LocalDateTime companyExpiry = LocalDateTime.now().plusDays(2); LocalDateTime companyExpiry = LocalDateTime.now().plusDays(2);
AdminUserEntity csa = new AdminUserEntity(); when(adminUserMapper.selectCompanySuperAdminEarliestExpiry(1L)).thenReturn(companyExpiry);
csa.setId(9L);
csa.setRole("company_super_admin");
csa.setExpiresAt(companyExpiry);
when(adminUserMapper.selectList(any())).thenReturn(List.of(csa));
// 普通账号(自身无到期)被公司超管的到期拉进去 // 普通账号(自身无到期)被公司超管的到期拉进去
assertThat(service.effectiveExpiresAt(entity(3L, "normal", null, 1L, null))).isEqualTo(companyExpiry); assertThat(service.effectiveExpiresAt(entity(3L, "normal", null, 1L, null))).isEqualTo(companyExpiry);
@@ -82,26 +78,27 @@ class AccountExpiryServiceTest {
assertThat(service.effectiveExpiresAt(entity(2L, "admin", null, 1L, null))).isEqualTo(companyExpiry); assertThat(service.effectiveExpiresAt(entity(2L, "admin", null, 1L, null))).isEqualTo(companyExpiry);
} }
/**
* 生产现形(2026-10-06 先锋-团队 / company_id=3):本公司有公司超管、但它们全部没设到期。
* 这一档必须既不构成约束、也不抛——曾经这里读的是「单列实体投影」,MyBatis 对所选列全为 NULL 的
* 行返回 null 元素,遍历解引用即 NPE,而本方法是每次登录与每个鉴权请求的必经出口 ⇒ 该公司
* 全部账号表现为「登录不了」。判据已改成 mapper 里的 MIN(expires_at) 标量,见 {@code AdminUserMapper}。
*/
@Test @Test
void companySuperAdminWithoutExpiryLeavesCompanyUnaffected() { void companySuperAdminWithoutExpiryLeavesCompanyUnaffected() {
AdminUserEntity csa = new AdminUserEntity(); when(adminUserMapper.selectCompanySuperAdminEarliestExpiry(1L)).thenReturn(null);
csa.setId(9L);
csa.setRole("company_super_admin");
csa.setExpiresAt(null);
when(adminUserMapper.selectList(any())).thenReturn(List.of(csa));
assertThatCode(() -> service.assertLoginAllowed(entity(3L, "normal", null, 1L, null)))
.doesNotThrowAnyException();
assertThat(service.effectiveExpiresAt(entity(3L, "normal", null, 1L, null))).isNull(); assertThat(service.effectiveExpiresAt(entity(3L, "normal", null, 1L, null))).isNull();
assertThat(service.effectiveExpiresAt(entity(2L, "admin", null, 1L, null))).isNull();
} }
@Test @Test
void earliestConstraintWinsOverOwnExpiry() { void earliestConstraintWinsOverOwnExpiry() {
LocalDateTime own = LocalDateTime.now().plusDays(10); LocalDateTime own = LocalDateTime.now().plusDays(10);
LocalDateTime company = LocalDateTime.now().plusDays(1); LocalDateTime company = LocalDateTime.now().plusDays(1);
AdminUserEntity csa = new AdminUserEntity(); when(adminUserMapper.selectCompanySuperAdminEarliestExpiry(1L)).thenReturn(company);
csa.setId(9L);
csa.setRole("company_super_admin");
csa.setExpiresAt(company);
when(adminUserMapper.selectList(any())).thenReturn(List.of(csa));
assertThat(service.effectiveExpiresAt(entity(3L, "normal", null, 1L, own))).isEqualTo(company); assertThat(service.effectiveExpiresAt(entity(3L, "normal", null, 1L, own))).isEqualTo(company);
} }
@@ -0,0 +1,184 @@
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.catchThrowableOfType;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
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 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 jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.Test;
import org.springframework.test.util.ReflectionTestUtils;
/**
* 后台入口门(2026-10-06 放开):普通账号凭本公司的后台菜单授权进后台。
*
* <p>放开的只是<b>入口</b>(current-user / current-user/menus 这类"我能不能进后台"的出口)。
* 逐页的门在 {@code PermissionMenuService.requireConsolePageAccess},管理类出口
* (用户/菜单/分组/密钥/公司/版本)继续走 {@link AdminAuthSupport#requireAdmin}。
* 内部令牌通道更是一条都不放宽——它绕过到期与会话校验。</p>
*/
class AdminAuthSupportConsoleEntryTest {
@Test
void normalAccountHoldingAnAdminMenuGrantEntersTheConsole() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.countAdminMenuGrants(7L, 3L)).thenReturn(1L);
AdminAuthSupport support = support(user(7L, "normal", 0, 3L), userMapper);
assertThatCode(() -> support.requireConsoleOperator(requestWithBearer("t")))
.as("超管在权限页给它勾了后台菜单,就该进得来")
.doesNotThrowAnyException();
}
@Test
void normalAccountWithoutAnyGrantIsStillRejected() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.countAdminMenuGrants(7L, 3L)).thenReturn(0L);
AdminAuthSupport support = support(user(7L, "normal", 0, 3L), userMapper);
BusinessException ex = catchThrowableOfType(
() -> support.requireConsoleOperator(requestWithBearer("t")), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).isEqualTo("需要管理员权限");
}
/** 授权行的归属公司必须是操作者自己那棵树:别家树里的残留授权不能替本账号开门。 */
@Test
void grantProbeIsScopedToTheOperatorsOwnCompany() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.countAdminMenuGrants(anyLong(), any())).thenReturn(9L);
AdminAuthSupport support = support(user(7L, "normal", 0, 2L), userMapper);
support.requireConsoleOperator(requestWithBearer("t"));
verify(userMapper).countAdminMenuGrants(7L, 2L);
}
@Test
void adminRolesEnterWithoutAnyGrantLookup() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
AdminAuthSupport support = support(user(8L, "admin", 1, 1L), userMapper);
assertThatCode(() -> support.requireConsoleOperator(requestWithBearer("t"))).doesNotThrowAnyException();
verify(userMapper, never()).countAdminMenuGrants(anyLong(), any());
}
@Test
void companySuperAdminEntersWithoutAnyGrantLookup() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
AdminAuthSupport support = support(user(9L, "company_super_admin", 1, 1L), userMapper);
assertThatCode(() -> support.requireConsoleOperator(requestWithBearer("t"))).doesNotThrowAnyException();
verify(userMapper, never()).countAdminMenuGrants(anyLong(), any());
}
/** 内部令牌通道换不来入口:它不做到期与会话校验,只能凭管理员角色用。 */
@Test
void internalTokenChannelStillRejectsNormalOperator() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(7L)).thenReturn(user(7L, "normal", 0, 3L));
// 授权一条不少:这道门必须照样拒。若内部通道也改成"看授权",客户端凭这条通道
// 就能替任意普通账号读到后台(它同时绕过到期拦截)。
when(userMapper.countAdminMenuGrants(7L, 3L)).thenReturn(4L);
AdminAuthSupport support = tokenSupport(userMapper, "tok");
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getHeader("X-Internal-Token")).thenReturn("tok");
when(request.getParameter("operatorId")).thenReturn("7");
BusinessException ex = catchThrowableOfType(
() -> support.requireConsoleOperatorOrInternal(request), BusinessException.class);
assertThat(ex).as("内部令牌 + 普通账号 operatorId 不得返回用户").isNotNull();
// 冒出来的是 JWT 侧的"未登录",不是放行——内部分支自己把普通角色判成了"没有这个人"
assertThat(ex.getCode()).isEqualTo(401);
verify(userMapper, never()).countAdminMenuGrants(any(), any());
}
@Test
void internalTokenChannelStillAdmitsAdminOperator() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(8L)).thenReturn(user(8L, "admin", 1, 1L));
AdminAuthSupport support = tokenSupport(userMapper, "tok");
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getHeader("X-Internal-Token")).thenReturn("tok");
when(request.getParameter("operatorId")).thenReturn("8");
assertThat(support.requireConsoleOperatorOrInternal(request).getId()).isEqualTo(8L);
}
/** 没登录仍然是 401,不能被入口门改写成 403(前端的整页跳转判据靠这个码)。 */
@Test
void anonymousRequestStaysUnauthorized() {
AdminAuthSupport support = new AdminAuthSupport(mock(JwtService.class), mock(AdminUserMapper.class),
mock(AuthProperties.class), mock(AccountExpiryService.class));
HttpServletRequest request = mock(HttpServletRequest.class);
BusinessException ex = catchThrowableOfType(
() -> support.requireConsoleOperator(request), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(401);
}
/** 探针返回 null(库里根本没有授权行)时按"没有授权"处理,不能当成放行。 */
@Test
void nullGrantCountIsTreatedAsNoGrant() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.countAdminMenuGrants(any(), any())).thenReturn(null);
AdminAuthSupport support = support(user(7L, "normal", 0, 3L), userMapper);
assertThat(support.isConsoleOperator(user(7L, "normal", 0, 3L))).isFalse();
}
private AdminAuthSupport support(AdminUserEntity user, AdminUserMapper userMapper) {
JwtService jwtService = mock(JwtService.class);
AuthProperties props = mock(AuthProperties.class);
Claims claims = mock(Claims.class);
when(claims.getSubject()).thenReturn(String.valueOf(user.getId()));
when(claims.get("deviceId")).thenReturn("devA");
when(jwtService.parse("t")).thenReturn(claims);
when(userMapper.selectById(user.getId())).thenReturn(user);
when(props.isSingleDeviceEnabled()).thenReturn(false);
return new AdminAuthSupport(jwtService, userMapper, props, mock(AccountExpiryService.class));
}
private AdminAuthSupport tokenSupport(AdminUserMapper userMapper, String token) {
AdminAuthSupport support = new AdminAuthSupport(mock(JwtService.class), userMapper,
mock(AuthProperties.class), mock(AccountExpiryService.class));
ReflectionTestUtils.setField(support, "internalToken", token);
ReflectionTestUtils.setField(support, "internalTokenPrevious", "");
ReflectionTestUtils.setField(support, "internalTokenFile", "");
return support;
}
private HttpServletRequest requestWithBearer(String token) {
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getHeader(org.springframework.http.HttpHeaders.AUTHORIZATION)).thenReturn("Bearer " + token);
return request;
}
private AdminUserEntity user(Long id, String role, int isAdmin, Long companyId) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setUsername("u" + id);
user.setRole(role);
user.setIsAdmin(isAdmin);
user.setCreatedById(1L);
user.setCompanyId(companyId);
user.setMachine("devA");
return user;
}
}
@@ -0,0 +1,140 @@
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.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
/**
* 鉴权链路上的 mapper 读出口不得把「可空列」投影成实体列表再遍历。
*
* <p>MyBatis 对<b>所选列全为 NULL</b> 的行返回 null 元素({@code returnInstanceForEmptyRow} 默认关)。
* 于是 {@code selectList(wrapper.select(Entity::getNullableColumn))} 拿到的 List 里混着 null,
* 一句 {@code row.getX()} 就是 NPE。这个形状出过一次事故(2026-10-06):{@code AccountExpiryService}
* 读本公司公司超管的 {@code expires_at},而"没设到期"恰是绝大多数公司的常态 ⇒ 一家公司只要有一个
* 永不过期的公司超管,该公司<b>所有账号</b>的登录与每个鉴权请求全部 500,前端表现为「登录不了」。</p>
*
* <p>单测挡不住它:mock 会如实交出「带 id 的实体」,而真库交出的是 null 元素——判据落在 mock 边界外,
* 用例恒绿。所以这条做成源码扫描,规则本身走 {@link #authChainReadsCompanyCascadeAsScalarAggregate()}
* 那类可实跑断言。</p>
*/
class AuthChainQueryShapeTest {
/** 只有一列的 {@code .select(Entity::getX)} —— 两列以上就不会出现"整行皆空"。 */
private static final Pattern SINGLE_COLUMN_PROJECTION =
Pattern.compile("\\.select\\(\\s*[A-Za-z]\\w*::get[A-Za-z]\\w*\\s*\\)");
/** 扫描面:登录与会话鉴权走过的包(这里抛异常 = 用户登录不了,不是某个页面少几行)。 */
private static final String[] SCANNED_DIRS = {
"src/main/java/com/nanri/aiimage/common/security",
"src/main/java/com/nanri/aiimage/modules/auth",
};
@Test
void authChainNeverProjectsASingleColumnIntoAnEntityList() throws IOException {
List<Path> files = scannedSources();
List<String> offenders = files.stream()
.filter(p -> SINGLE_COLUMN_PROJECTION.matcher(read(p)).find())
.map(p -> p.getFileName().toString())
.collect(Collectors.toList());
assertThat(offenders)
.as("把单个可空列投影成实体列表的文件:整行皆 NULL 时 MyBatis 给的是 null 元素,"
+ "遍历即 NPE,而它在鉴权链路上(改成标量聚合或按主键取全行)")
.isEmpty();
}
/** 取样集非空自检:扫描一旦 0 命中,上面那条就恒绿,等于没护栏。 */
@Test
void scannedSurfaceIsActuallyTheAuthChain() throws IOException {
List<String> names = scannedSources().stream()
.map(p -> p.getFileName().toString())
.collect(Collectors.toList());
assertThat(names)
.as("这两处才是登录与每个鉴权请求走过的代码,扫描面漏了它们上面那条就是空转")
.contains("AccountExpiryService.java", "AdminAuthSupport.java", "AuthService.java");
}
/**
* 公司级到期级联的读出口形状:mapper 侧一条 {@code MIN(expires_at)} 标量。
* 只钉"Service 不再这么写"不够——回流成 {@code selectList} 之前,多半是先有人把 mapper
* 的聚合改成"取全部行自己比",所以把 SQL 本身也钉住。
*/
@Test
void authChainReadsCompanyCascadeAsScalarAggregate() throws IOException {
String service = read(sourceNamed("AccountExpiryService.java"));
assertThat(service).contains("selectCompanySuperAdminEarliestExpiry(");
assertThat(service).doesNotContain("selectList(");
String mapper = read(sourceNamed("AdminUserMapper.java"));
Matcher method = Pattern.compile(
"LocalDateTime selectCompanySuperAdminEarliestExpiry\\([\\s\\S]{0,400}").matcher(mapper);
assertThat(method.find()).as("mapper 里那个标量方法还在").isTrue();
assertThat(mapper).contains("MIN(expires_at)");
// 判据必须仍锁死在"本公司 + 公司超管",扩到全站会把别家的到期算进这家
assertThat(mapper).contains("role = 'company_super_admin'");
assertThat(mapper).contains("company_id = #{companyId}");
}
private static List<Path> scannedSources() throws IOException {
Path module = moduleRoot();
List<Path> files = new java.util.ArrayList<>();
for (String dir : SCANNED_DIRS) {
Path root = module.resolve(dir);
if (!Files.isDirectory(root)) {
fail("找不到 " + root + " —— 用例依赖以 backend-java 为工作目录运行,别让守卫静默通过");
}
try (Stream<Path> walk = Files.walk(root)) {
walk.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".java"))
.forEach(files::add);
}
}
return files;
}
private static Path sourceNamed(String fileName) throws IOException {
Path module = moduleRoot();
for (String dir : SCANNED_DIRS) {
Path candidate = module.resolve(dir).resolve(fileName);
if (Files.isRegularFile(candidate)) {
return candidate;
}
}
Path mapper = module.resolve("src/main/java/com/nanri/aiimage/common/mapper").resolve(fileName);
if (Files.isRegularFile(mapper)) {
return mapper;
}
throw new IllegalStateException("找不到 " + fileName);
}
/** surefire 的工作目录是模块目录;从仓库根或 IDE 跑时退到 backend-java/。 */
private static Path moduleRoot() {
Path here = Path.of("").toAbsolutePath();
if (Files.isDirectory(here.resolve("src/main/java"))) {
return here;
}
Path nested = here.resolve("backend-java");
if (Files.isDirectory(nested.resolve("src/main/java"))) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 模块目录(cwd=" + here + ")");
}
private static String read(Path file) {
try {
return Files.readString(file, StandardCharsets.UTF_8);
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
}
@@ -0,0 +1,320 @@
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.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
/**
* 后台入口放开(2026-10-06)的三向绊线:入口门只长在"该页自己有门"的控制器上。
*
* <p>这次改动的形状是:{@code current-user/menus} 这道<b>入口</b>从"必须是管理员角色"改成
* "管理员角色 <b>或</b> 本公司树里至少有一条后台菜单授权",而每一页另有一道<b>页面门</b>
* ({@code PermissionMenuService.requireConsolePageAccess},判据是<b>这一页</b>的授权)。
* 两层分开是刻意的:只放开入口 = 把密钥页、扣次数的 ASIN 查询页一并送给了勾了一页的账号。</p>
*
* <p>所以这个类钉三件事,缺一件就是"显示宽于权限"或"权限宽于显示":</p>
* <ol>
* <li>管理/平台类 10 个控制器(用户、菜单、公司、密钥、版本、教程、设备日志、紫鸟授权)
* <b>仍走 requireAdmin</b> 且<b>没有</b> requireConsoleOperator —— 正向挡"授权能进管理页",
* 反向挡"顺手把 requireAdmin 删了导致谁都进不去"。</li>
* <li>用了入口门的控制器<b>恰好</b>是那 14 个:多一个就是有人把新页面接进了"有授权就能进"的通道,
* 少一个就是有人回滚了某页。分母钉死,不靠抽样。</li>
* <li>带页面门的 6 个控制器,那一行里必须出现<b>本页的 column_key</b>;不带的 8 个必须逐个登记
* 它靠什么把关(服务门 / 自己的 hasAnyAdminMenu / 只按 uid 取自己的数据)——
* "没页面门"必须是已知豁免,不能是漏了。</li>
* </ol>
*
* <p>另外两支钉实现细节:{@code PermissionMenuService} 那两个服务门里不得再残留
* {@code ensureAdminOperatorIfPresent}(它会让下面的授权判定变成普通账号永远走不到的死代码),
* 以及入口探针 {@code countAdminMenuGrants} 必须是标量 {@code COUNT(1)}
* (单列投影会让"整行皆 NULL"变成 List 里的 null 元素,鉴权链路上出过一次事故,
* 见 {@link AuthChainQueryShapeTest})。</p>
*
* <p>每支都带"取样集非空 / 切片截到了方法体"自检:扫描扫不到东西就恒绿,等于没护栏。</p>
*/
class ConsoleWideningGuardrailTest {
/** 管理/平台类页面:只能由管理员角色链进,菜单授权一律无效。 */
private static final List<String> ADMIN_ONLY_CONTROLLERS = List.of(
"modules/admin/controller/AdminUserController.java",
"modules/permission/controller/PermissionMenuController.java",
"modules/company/controller/CompanyController.java",
"modules/usersecret/controller/AdminUserApiSecretController.java",
"modules/usersecret/controller/AdminUserSecretUsageController.java",
"modules/softwareversion/controller/SoftwareVersionAdminController.java",
"modules/digitalhuman/controller/DigitalHumanVersionController.java",
"modules/tutorial/controller/TutorialAdminController.java",
"modules/devicelog/controller/AdminDeviceLogController.java",
"modules/ziniao/controller/ZiniaoAuthController.java");
/** 允许使用新入口门的全部控制器(多一个少一个都算有人改了这次的边界)。 */
private static final Set<String> ENTRY_DOOR_CONTROLLERS = Set.of(
"modules/admin/controller/AdminConsoleController.java",
"modules/imagehistory/controller/ImageHistoryController.java",
"modules/imagevideo/controller/AdminImageVideoTaskController.java",
"modules/notification/controller/AdminNotificationController.java",
"modules/productcategory/controller/ProductCategoryController.java",
"modules/shopdatacrawl/controller/AdminShopDataCrawlTaskController.java",
"modules/shopdatacrawl/controller/AdminShopDataCrawlTasksController.java",
"modules/shopduplicatecheck/controller/AdminShopDataDuplicateCheckController.java",
"modules/shopkey/controller/QueryAsinController.java",
"modules/shopkey/controller/ShopKeyController.java",
"modules/shopkey/controller/ShopManageController.java",
"modules/shopkey/controller/SkipPriceAsinController.java",
"modules/taskcenter/controller/AdminTaskCenterController.java");
/** 页面门:控制器 → 它自己那一页的 column_key。 */
private static final Map<String, String> PAGE_DOOR_KEYS = pageDoorKeys();
/** 有入口门但<b>没有</b> requireConsolePageAccess 的控制器 → 它靠什么把关(豁免登记)。 */
private static final Map<String, String> NO_PAGE_DOOR_EXEMPTIONS = noPageDoorExemptions();
private static Map<String, String> pageDoorKeys() {
Map<String, String> keys = new LinkedHashMap<>();
keys.put("modules/shopkey/controller/ShopManageController.java", "admin_shop_manage");
keys.put("modules/shopkey/controller/ShopKeyController.java", "admin_shop_keys");
keys.put("modules/shopkey/controller/QueryAsinController.java", "admin_query_asin");
keys.put("modules/shopkey/controller/SkipPriceAsinController.java", "admin_skip_price_asin");
keys.put("modules/productcategory/controller/ProductCategoryController.java", "admin_product_categories");
keys.put("modules/imagevideo/controller/AdminImageVideoTaskController.java", "admin_image_video_tasks");
return keys;
}
private static Map<String, String> noPageDoorExemptions() {
Map<String, String> exemptions = new LinkedHashMap<>();
// 这两支只回"我自己"的数据:一份是当前用户与他的菜单树(下发侧自己按角色剪枝),
// 一份是按 uid 取的通知——值就是那一行可执行锚点,不是描述文字
exemptions.put("modules/admin/controller/AdminConsoleController.java", "getUserColumnPermissions(");
exemptions.put("modules/notification/controller/AdminNotificationController.java", "return operator.getId();");
// 其余三支各自有专门的服务门 / 页内判定
exemptions.put("modules/imagehistory/controller/ImageHistoryController.java", "admin_history");
exemptions.put("modules/shopdatacrawl/controller/AdminShopDataCrawlTaskController.java",
"requireShopDataCrawlTaskAccess(");
exemptions.put("modules/shopdatacrawl/controller/AdminShopDataCrawlTasksController.java",
"requireShopDataCrawlTaskAccess(");
exemptions.put("modules/shopduplicatecheck/controller/AdminShopDataDuplicateCheckController.java",
"requireShopDataCrawlTaskAccess(");
exemptions.put("modules/taskcenter/controller/AdminTaskCenterController.java",
"requireClientTaskCenterAccess(");
return exemptions;
}
/** 出口 1(正向):管理类页面不得被菜单授权打开。 */
@Test
void adminOnlyPagesKeepTheRoleGateAndGainNoGrantDoor() throws IOException {
for (String rel : ADMIN_ONLY_CONTROLLERS) {
String source = read(mainSource(rel));
List<String> gateLines = executableLinesContaining(source, "requireAdmin");
assertThat(gateLines)
.as(rel + " 必须仍由 requireAdmin 把关:删了它 = 管理员也进不去(反向杀)")
.isNotEmpty();
assertThat(executableLinesContaining(source, "requireConsoleOperator"))
.as(rel + " 不得改用入口门:那等于" +
"勾一条菜单授权就能进用户管理/密钥管理(正向杀)")
.isEmpty();
}
}
/** 出口 2:入口门的落点恰好是登记过的那 13 支,分母从全树反推,不抽样。 */
@Test
void entryDoorSitesAreExactlyTheRegisteredControllers() throws IOException {
List<Path> controllers = allControllers();
Set<String> users = new LinkedHashSet<>();
for (Path p : controllers) {
if (!executableLinesContaining(read(p), "requireConsoleOperator").isEmpty()) {
users.add(relative(p));
}
}
assertThat(users)
.as("用了入口门的控制器集合必须与登记一致;多出的一支没人给它配页面门,"
+ "少的一支是有人把某页回滚成了 requireAdmin")
.containsExactlyInAnyOrderElementsOf(ENTRY_DOOR_CONTROLLERS);
}
/** 出口 3(正向杀):带页面门的每一支,那一行必须锚住<b>本页</b>的 key。 */
@Test
void eachWidenedPageDoorCarriesItsOwnMenuKey() throws IOException {
for (Map.Entry<String, String> e : PAGE_DOOR_KEYS.entrySet()) {
List<String> lines = executableLinesContaining(read(mainSource(e.getKey())), "requireConsolePageAccess");
assertThat(lines)
.as(e.getKey() + " 必须真的调页面门")
.isNotEmpty();
assertThat(lines)
.as(e.getKey() + " 的页面门必须判本页的 key(写成别的 key = 这页对普通账号永远 403)")
.anyMatch(line -> line.contains("\"" + e.getValue() + "\""));
}
}
/** 出口 3 的另一半:有入口门却没有页面门的,只能是需要逐个登记的豁免,不得是"忘了加"。 */
@Test
void controllersWithoutAPageDoorAreRegisteredExemptions() throws IOException {
List<String> missing = new ArrayList<>();
for (String rel : ENTRY_DOOR_CONTROLLERS) {
String source = read(mainSource(rel));
if (executableLinesContaining(source, "requireConsolePageAccess").isEmpty()) {
missing.add(rel);
}
}
assertThat(missing)
.as("未登记:有入口门、没有页面门、豁免表里也没有它")
.containsExactlyInAnyOrderElementsOf(NO_PAGE_DOOR_EXEMPTIONS.keySet());
for (Map.Entry<String, String> e : NO_PAGE_DOOR_EXEMPTIONS.entrySet()) {
String source = read(mainSource(e.getKey()));
String witness = e.getValue();
List<String> lines = executableLinesContaining(source, witness);
assertThat(lines)
.as(e.getKey() + " 的豁免理由(" + witness + ")必须真的在代码里,而不是只在注释里")
.isNotEmpty();
}
}
/** 页面门与入口门都不得被"先判管理员角色"抢跑,否则下面的授权判定变死代码。 */
@Test
void serviceDoorsJudgeByGrantNotByRole() throws IOException {
String service = read(mainSource("modules/permission/service/PermissionMenuService.java"));
String shopData = methodSlice(service, "public void requireShopDataCrawlTaskAccess(");
assertThat(shopData).as("切片必须截到方法体,否则下面的" +
" doesNotContain 会因为切到空串而恒绿").contains("无权查看店铺数据任务");
assertThat(shopData).doesNotContain("ensureAdminOperatorIfPresent");
assertThat(shopData).contains("hasEffectiveColumnPermission");
String taskCenter = methodSlice(service, "public void requireClientTaskCenterAccess(");
assertThat(taskCenter).contains("无权查看客户端任务管理");
assertThat(taskCenter).doesNotContain("ensureAdminOperatorIfPresent");
assertThat(taskCenter).contains("hasEffectiveColumnPermission");
String pageDoor = methodSlice(service, "public void requireConsolePageAccess(");
assertThat(pageDoor).contains("hasAnyAdminMenu");
// 页面门对管理员角色链恒放行(不改存量行为),普通账号才落到授权判定
assertThat(pageDoor).contains("isAdmin(operator)");
// 同一文件里 ensureAdminOperatorIfPresent 仍在别处使用 ⇒ 上面的"不再出现"是真的切片判定,
// 不是有人把这个方法整个删掉后两不找
assertThat(executableLinesContaining(service, "ensureAdminOperatorIfPresent(")).isNotEmpty();
}
/** 入口探针必须是标量 COUNT:单列投影在鉴权链路上出过一次全站 500。 */
@Test
void entryGrantProbeStaysAScalarCount() throws IOException {
String mapper = read(mainSource("common/mapper/AdminUserMapper.java"));
int at = mapper.indexOf("Long countAdminMenuGrants(");
assertThat(at).as("入口探针方法还在").isGreaterThan(0);
String head = mapper.substring(Math.max(0, at - 400), at);
assertThat(head).contains("SELECT COUNT(1)");
assertThat(head).doesNotContain(".select(");
// 探针必须仍限定本公司:否则别家公司的授权能给这条账号开门
assertThat(head).contains("cm.company_id");
assertThat(head).contains("ucp.user_id = #{userId}");
assertThat(head).contains("cm.menu_type = 'admin'");
assertThat(mapper.substring(at)).contains("@Param(\"companyId\")");
}
/** 自检:扫描面与两个分母都必须是实打实的非空,且页面门/豁免恰好铺满入口门清单。 */
@Test
void scannedSurfaceIsNotEmptyAndRegistersEverySite() throws IOException {
assertThat(allControllers()).as("一个控制器都没扫到 = 路径写错了,上面全是空转").isNotEmpty();
assertThat(ENTRY_DOOR_CONTROLLERS).hasSize(13);
assertThat(NO_PAGE_DOOR_EXEMPTIONS.keySet()).containsAll(
ENTRY_DOOR_CONTROLLERS.stream()
.filter(rel -> !PAGE_DOOR_KEYS.containsKey(rel))
.collect(Collectors.toSet()));
assertThat(PAGE_DOOR_KEYS).hasSize(6);
// 管理类清单必须真能扫到 requireAdmin,否则"没有 requireConsoleOperator"是扫了个空文件
for (String rel : ADMIN_ONLY_CONTROLLERS) {
assertThat(executableLinesContaining(read(mainSource(rel)), "requireAdmin"))
.as(rel + " 取样后仍要有可执行的 requireAdmin 调用").isNotEmpty();
}
}
// ---------- 取样 ----------
private static List<Path> allControllers() throws IOException {
Path root = mainRoot().resolve("modules");
try (Stream<Path> walk = Files.walk(root)) {
return walk
.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith("Controller.java"))
.sorted()
.collect(Collectors.toList());
}
}
/**
* 可执行行:跳过注释行与 javadoc,避免"在注释里写了一句 requireAdmin"被当成锚点。
* 同时把 {@code * } 开头的续行排除掉——本类的说明文字里有这些方法名。
*/
private static List<String> executableLinesContaining(String source, String needle) {
return source.lines()
.map(String::trim)
.filter(line -> !line.startsWith("//") && !line.startsWith("*")
&& !line.startsWith("/*") && !line.startsWith("*/"))
.filter(line -> line.contains(needle))
.collect(Collectors.toList());
}
/** 从签名开始截到下一个同缩进的成员声明,取的就是那一支方法体(含其上方的注解)。 */
private static String methodSlice(String source, String signature) {
int start = source.indexOf(signature);
if (start < 0) {
fail("找不到 " + signature + " —— 方法被改名或这次改动没落进这个文件");
}
int next = source.indexOf("\n public ", start + signature.length());
int nextPrivate = source.indexOf("\n private ", start + signature.length());
int end = source.length();
if (next >= 0) {
end = Math.min(end, next);
}
if (nextPrivate >= 0) {
end = Math.min(end, nextPrivate);
}
return source.substring(start, end);
}
private static Path mainSource(String relative) {
Path file = mainRoot().resolve(relative);
if (!Files.isRegularFile(file)) {
fail("找不到 " + file + " —— 用例依赖以 backend-java 为工作目录运行,别让扫描静默通过");
}
return file;
}
private static String relative(Path file) {
return mainRoot().relativize(file).toString().replace('\\', '/');
}
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) {
try {
return Files.readString(file, StandardCharsets.UTF_8);
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
}
@@ -45,7 +45,7 @@ class AdminConsoleCurrentUserCompanyTest {
operator.setUsername("op"); operator.setUsername("op");
operator.setRole("admin"); operator.setRole("admin");
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(operator); when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("admin"); when(adminAuthSupport.currentRole(operator)).thenReturn("admin");
} }
@@ -31,7 +31,7 @@ class AdminNotificationControllerTest {
@Test @Test
void listAndSummaryUseOperatorIdAndAdminAudience() { void listAndSummaryUseOperatorIdAndAdminAudience() {
when(adminAuthSupport.requireAdmin(request)).thenReturn(admin(24L)); when(adminAuthSupport.requireConsoleOperator(request)).thenReturn(admin(24L));
controller.summary(request); controller.summary(request);
controller.page(request, 1L, 20L, false, "余额", NotificationService.CATEGORY_CONFIG_ERROR, controller.page(request, 1L, 20L, false, "余额", NotificationService.CATEGORY_CONFIG_ERROR,
@@ -52,7 +52,7 @@ class AdminNotificationControllerTest {
@Test @Test
void readMarkingStaysWithinOwnAdminAudienceRows() { void readMarkingStaysWithinOwnAdminAudienceRows() {
when(adminAuthSupport.requireAdmin(request)).thenReturn(admin(1L)); when(adminAuthSupport.requireConsoleOperator(request)).thenReturn(admin(1L));
controller.markRead(request, 18L); controller.markRead(request, 18L);
controller.markAllRead(request); controller.markAllRead(request);
@@ -0,0 +1,308 @@
package com.nanri.aiimage.modules.permission.service;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
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.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.mapper.PermissionMenuMapper;
import com.nanri.aiimage.modules.permission.mapper.UserColumnPermissionMapper;
import com.nanri.aiimage.modules.permission.model.entity.PermissionMenuEntity;
import com.nanri.aiimage.modules.permission.model.entity.UserColumnPermissionEntity;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* 后台页面门(2026-10-06)与入口放开后的菜单下发。
*
* <p>入口放开不等于整站放开:现网 44 个普通账号带着「店铺管理」授权,若逐页门只看入口,
* 它们顺手就能读同公司的密钥页、烧同公司的扣次数额度。
* {@link PermissionMenuService#requireConsolePageAccess} 就是那一页自己的门。</p>
*
* <p>另一半在下发侧:管理/平台页({@code ADMIN_ONLY_MENU_KEYS})的后端出口仍是 requireAdmin,
* 对普通账号继续下发这些菜单,等于给刚放进来的人画一排点了必 403 的死链。</p>
*/
class PermissionMenuServiceConsolePageTest {
private static final Long GROUP_ID = 200L;
private static final Long SHOP_PAGE_ID = 201L;
private static final Long USER_PAGE_ID = 202L;
private static final Long SECRET_PAGE_ID = 203L;
private static final Long TASK_CENTER_ID = 302L;
private static final Long SHOP_DATA_MENU_ID = 300L;
private static final Long SHOP_DATA_CHECK_ID = 303L;
private static final Long SHOP_DATA_KEY_ID = 301L;
private PermissionMenuMapper menuMapper;
private UserColumnPermissionMapper permissionMapper;
private AdminUserMapper userMapper;
private PermissionMenuService service;
/**
* wrapper 的 lambda 条件要有 TableInfo 才解析得出列名({@code getSqlSegment()} 同理)。
* 纯单测没有 Spring/MyBatis 启动过程,不初始化就会抛 {@code can not find lambda cache}。
*/
@BeforeAll
static void initMybatisPlusTableInfo() {
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, AdminUserEntity.class);
TableInfoHelper.initTableInfo(assistant, PermissionMenuEntity.class);
TableInfoHelper.initTableInfo(assistant, UserColumnPermissionEntity.class);
}
@BeforeEach
void setUp() {
menuMapper = mock(PermissionMenuMapper.class);
permissionMapper = mock(UserColumnPermissionMapper.class);
userMapper = mock(AdminUserMapper.class);
service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(menuMapper.selectList(any())).thenReturn(catalog());
when(menuMapper.selectById(any())).thenAnswer(invocation ->
catalog().stream().filter(item -> item.getId().equals(invocation.getArgument(0)))
.findFirst().orElse(null));
// 与真库同形:requireDataPermission 走 selectOne,条件里带着本公司 + 那个 column_key。
// wrapper 的参数是**惰性**绑定的:不求值 getSqlSegment() 时 paramNameValuePairs 是空 map,
// 照空 map 过滤会让"命中"与"没命中"两支断言同时通过(夹具自己变成恒真)。
when(menuMapper.selectOne(any())).thenAnswer(invocation -> {
Collection<Object> params = params(invocation.getArgument(0));
return catalog().stream()
.filter(item -> params.contains(item.getColumnKey()) && params.contains(item.getCompanyId()))
.findFirst().orElse(null);
});
when(userMapper.selectById(any())).thenAnswer(invocation -> user((Long) invocation.getArgument(0)));
}
// ---------------------------------------------------------------- 逐页门
@Test
void adminRolePassesEveryPageDoorWithoutLookingAtGrants() {
assertThatCode(() -> service.requireConsolePageAccess(user(8L, "admin"), "无权访问店铺管理", "admin_shop_manage"))
.doesNotThrowAnyException();
verify(menuMapper, never()).selectList(any());
verify(permissionMapper, never()).selectByUserId(any());
}
@Test
void companySuperAdminAndSuperAdminPassPageDoorWithoutGrants() {
assertThatCode(() -> service.requireConsolePageAccess(
user(9L, "company_super_admin"), "无权访问店铺管理", "admin_shop_manage"))
.doesNotThrowAnyException();
assertThatCode(() -> service.requireConsolePageAccess(
user(1L, "super_admin"), "无权访问店铺管理", "admin_shop_manage"))
.doesNotThrowAnyException();
}
@Test
void normalAccountHoldingThisPagesGrantPasses() {
grants(7L, SHOP_PAGE_ID);
assertThatCode(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权访问店铺管理", "admin_shop_manage")).doesNotThrowAnyException();
}
/** 相反的一半:勾了别的页换不来这一页——否则"入口放开"就变成"整站放开"。 */
@Test
void normalAccountHoldingAnotherPageGrantIsDeniedThisPage() {
grants(7L, SECRET_PAGE_ID);
BusinessException ex = catchThrowableOfType(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权访问店铺管理", "admin_shop_manage"), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).isEqualTo("无权访问店铺管理");
}
/** 勾父分组覆盖后代是授权页的既有语义,这一页的门必须照认。 */
@Test
void parentGroupGrantCoversTheChildPageDoor() {
grants(7L, GROUP_ID);
assertThatCode(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权访问店铺管理", "admin_shop_manage")).doesNotThrowAnyException();
}
@Test
void normalAccountWithoutAnyGrantIsDenied() {
grants(7L);
BusinessException ex = catchThrowableOfType(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权访问店铺管理", "admin_shop_manage"), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
}
/** 多个键是"任一命中",不是"全部命中"。 */
@Test
void anyOfSeveralKeysOpensTheDoor() {
grants(7L, SECRET_PAGE_ID);
assertThatCode(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权", "admin_shop_manage", "admin_user_secrets"))
.doesNotThrowAnyException();
}
// ---------------------------------------------------------------- 下发侧剪枝
@Test
void managementMenusAreNotPushedDownToNormalAccounts() {
grants(7L, USER_PAGE_ID, SECRET_PAGE_ID, SHOP_PAGE_ID);
List<PermissionMenuItemVo> items = service.getUserColumnPermissions(null, 7L, "admin", false);
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.as("店铺管理是数据页:普通账号被授了就照下发")
.contains("admin_shop_manage");
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.as("用户管理/密钥管理的后端出口仍是 requireAdmin,下发出去就是死链")
.doesNotContain("admin_users", "admin_user_secrets");
}
/** 相反的一半:管理员角色照旧拿到管理页——放开普通账号不能顺手把管理员的菜单弄红。 */
@Test
void managementMenusStayVisibleForAdminRoles() {
when(userMapper.selectById(8L)).thenReturn(user(8L, "admin"));
grants(8L, USER_PAGE_ID, SECRET_PAGE_ID, SHOP_PAGE_ID);
List<PermissionMenuItemVo> items = service.getUserColumnPermissions(
user(8L, "admin"), 8L, "admin", false);
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.contains("admin_users", "admin_user_secrets", "admin_shop_manage");
}
@Test
void superAdminStillGetsTheWholeTree() {
when(userMapper.selectById(1L)).thenReturn(user(1L, "super_admin"));
List<PermissionMenuItemVo> items = service.getUserColumnPermissions(null, 1L, "admin", false);
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.contains("admin_users", "admin_user_secrets", "admin_shop_manage");
}
// ----------------------------------------------------- 店铺数据/客户端任务的授权门
/** 这两道门此前第一句就判角色,普通账号即便被勾了菜单也永远走不到下面的授权命中(死代码)。 */
@Test
void shopDataDoorAdmitsNormalAccountHoldingTheGrants() {
grants(7L, SHOP_DATA_MENU_ID, SHOP_DATA_KEY_ID);
assertThatCode(() -> service.requireShopDataCrawlTaskAccess(user(7L, "normal")))
.doesNotThrowAnyException();
}
@Test
void shopDataDoorStillDeniesNormalAccountWithoutTheGrants() {
grants(7L, SHOP_PAGE_ID);
BusinessException ex = catchThrowableOfType(
() -> service.requireShopDataCrawlTaskAccess(user(7L, "normal")), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).isEqualTo("无权查看店铺数据任务");
}
@Test
void clientTaskDoorAdmitsNormalAccountHoldingThatMenu() {
grants(7L, TASK_CENTER_ID);
assertThatCode(() -> service.requireClientTaskCenterAccess(user(7L, "normal")))
.doesNotThrowAnyException();
}
@Test
void clientTaskDoorStillDeniesNormalAccountWithoutIt() {
grants(7L, SHOP_PAGE_ID);
BusinessException ex = catchThrowableOfType(
() -> service.requireClientTaskCenterAccess(user(7L, "normal")), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).isEqualTo("无权查看客户端任务管理");
}
// ---------------------------------------------------------------- 夹具
private void grants(Long userId, Long... columnIds) {
List<UserColumnPermissionEntity> rows = new ArrayList<>();
for (Long columnId : columnIds) {
UserColumnPermissionEntity row = new UserColumnPermissionEntity();
row.setUserId(userId);
row.setColumnId(columnId);
rows.add(row);
}
when(permissionMapper.selectByUserId(userId)).thenReturn(rows);
}
/** 取出 wrapper 上的绑定值;MP 是惰性绑定,不求值 SQL 段时那个 map 是空的。 */
private static Collection<Object> params(LambdaQueryWrapper<PermissionMenuEntity> query) {
String segment = query.getSqlSegment();
Collection<Object> values = query.getParamNameValuePairs().values();
if (values.isEmpty()) {
throw new IllegalStateException("夹具读不到 wrapper 条件(segment=" + segment
+ ")——空 map 会让命中/不命中两支断言同时通过");
}
return values;
}
private List<PermissionMenuEntity> catalog() {
return List.of(
menu(GROUP_ID, "admin_group_shop", null),
menu(SHOP_PAGE_ID, "admin_shop_manage", GROUP_ID),
menu(USER_PAGE_ID, "admin_users", null),
menu(SECRET_PAGE_ID, "admin_user_secrets", null),
menu(TASK_CENTER_ID, "admin_task_center", null),
// 店铺数据那道门要同时命中「可见菜单」与内部数据权限
menu(SHOP_DATA_MENU_ID, "admin_shop_data_crawl_tasks", null),
menu(SHOP_DATA_CHECK_ID, "admin_shop_data_duplicate_check", null),
menu(SHOP_DATA_KEY_ID, "admin_shop_data_crawl_task_data", null));
}
private PermissionMenuEntity menu(Long id, String columnKey, Long parentId) {
PermissionMenuEntity entity = new PermissionMenuEntity();
entity.setId(id);
entity.setColumnKey(columnKey);
entity.setName(columnKey);
entity.setParentId(parentId);
entity.setMenuType("admin");
entity.setCompanyId(1L);
entity.setSortOrder(id.intValue());
return entity;
}
/** 缺省按普通账号建:夹具里 7L/8L/1L 这些 id 的角色由显式重载覆盖。 */
private AdminUserEntity user(Long id) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setUsername("u" + id);
user.setRole("normal");
user.setIsAdmin(0);
user.setCreatedById(1L);
user.setCompanyId(1L);
return user;
}
private AdminUserEntity user(Long id, String role) {
AdminUserEntity user = user(id);
user.setRole(role);
user.setIsAdmin("normal".equals(role) ? 0 : 1);
return user;
}
}
@@ -25,7 +25,7 @@ class AdminShopDataCrawlTaskControllerTest {
AdminShopDataCrawlTaskController controller = new AdminShopDataCrawlTaskController( AdminShopDataCrawlTaskController controller = new AdminShopDataCrawlTaskController(
taskService, authSupport, permissionService); taskService, authSupport, permissionService);
AdminUserEntity operator = admin(8L); AdminUserEntity operator = admin(8L);
when(authSupport.requireAdmin(request)).thenReturn(operator); when(authSupport.requireConsoleOperator(request)).thenReturn(operator);
controller.deleteHistory(101L, request); controller.deleteHistory(101L, request);
@@ -43,7 +43,7 @@ class AdminShopDataCrawlTaskControllerTest {
taskService, authSupport, permissionService); taskService, authSupport, permissionService);
when(authSupport.isTrustedSuppliedToken("shared-token")).thenReturn(true); when(authSupport.isTrustedSuppliedToken("shared-token")).thenReturn(true);
AdminUserEntity operator = admin(8L); AdminUserEntity operator = admin(8L);
when(authSupport.requireAdmin(request)).thenThrow(new BusinessException(401, "not logged in")); when(authSupport.requireConsoleOperator(request)).thenThrow(new BusinessException(401, "not logged in"));
when(request.getHeader("X-Internal-Token")).thenReturn("shared-token"); when(request.getHeader("X-Internal-Token")).thenReturn("shared-token");
when(request.getParameter("operatorId")).thenReturn("8"); when(request.getParameter("operatorId")).thenReturn("8");
when(permissionService.requireAdminOperator(8L)).thenReturn(operator); when(permissionService.requireAdminOperator(8L)).thenReturn(operator);
@@ -65,7 +65,7 @@ class AdminShopDataCrawlTaskControllerTest {
taskService, authSupport, permissionService); taskService, authSupport, permissionService);
AdminUserEntity operator = admin(8L); AdminUserEntity operator = admin(8L);
BusinessException denied = new BusinessException(403, "no data permission"); BusinessException denied = new BusinessException(403, "no data permission");
when(authSupport.requireAdmin(request)).thenReturn(operator); when(authSupport.requireConsoleOperator(request)).thenReturn(operator);
org.mockito.Mockito.doThrow(denied) org.mockito.Mockito.doThrow(denied)
.when(permissionService).requireShopDataCrawlTaskAccess(operator); .when(permissionService).requireShopDataCrawlTaskAccess(operator);
@@ -45,16 +45,18 @@ class ShopKeyControllerCompanyScopeTest {
private AdminAuthSupport adminAuthSupport; private AdminAuthSupport adminAuthSupport;
@Mock @Mock
private DataReadScope dataReadScope; private DataReadScope dataReadScope;
@Mock
private com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
private ShopKeyController controller() { private ShopKeyController controller() {
return new ShopKeyController(shopKeyService, adminAuthSupport, dataReadScope); return new ShopKeyController(shopKeyService, adminAuthSupport, dataReadScope, permissionMenuService);
} }
@Test @Test
@DisplayName("列表:tab 的公司 id 交给 readCompanyIdOrOwn,出口给什么 service 就用什么") @DisplayName("列表:tab 的公司 id 交给 readCompanyIdOrOwn,出口给什么 service 就用什么")
void pagePassesTheTabValueThroughTheDoor() { void pagePassesTheTabValueThroughTheDoor() {
HttpServletRequest request = login(); HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user()); when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID); when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, COMPANY_ID); controller().page(request, 1L, 15L, COMPANY_ID);
@@ -72,7 +74,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("列表:出口判超管(null)时把 null 传下去,不补任何公司 id") @DisplayName("列表:出口判超管(null)时把 null 传下去,不补任何公司 id")
void pageKeepsTheDoorsUnfilteredVerdict() { void pageKeepsTheDoorsUnfilteredVerdict() {
HttpServletRequest request = login(); HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user()); when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(null); when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(null);
controller().page(request, 1L, 15L, COMPANY_ID); controller().page(request, 1L, 15L, COMPANY_ID);
@@ -88,7 +90,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("列表:出口按会话收窄后,交给 service 的是收窄值而不是请求里的值") @DisplayName("列表:出口按会话收窄后,交给 service 的是收窄值而不是请求里的值")
void pageUsesTheNarrowedValueNotTheRequestedOne() { void pageUsesTheNarrowedValueNotTheRequestedOne() {
HttpServletRequest request = login(); HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user()); when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(99L))).thenReturn(COMPANY_ID); when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(99L))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, 99L); controller().page(request, 1L, 15L, 99L);
@@ -100,7 +102,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("更新/删除/白名单检测:把 writeCompanyId 的判定原样交给 service,controller 不自己补公司 id") @DisplayName("更新/删除/白名单检测:把 writeCompanyId 的判定原样交给 service,controller 不自己补公司 id")
void writeEndpointsPassTheRowOwnershipGate() { void writeEndpointsPassTheRowOwnershipGate() {
HttpServletRequest request = login(); HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user()); when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(COMPANY_ID); when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(COMPANY_ID);
ShopKeyUpdateRequest body = new ShopKeyUpdateRequest(); ShopKeyUpdateRequest body = new ShopKeyUpdateRequest();
body.setZiniaoAccountName("ziniao-a"); body.setZiniaoAccountName("ziniao-a");
@@ -121,7 +123,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("写侧:闸门判超管(null)时把 null 传下去,否则超管被锁死在本公司") @DisplayName("写侧:闸门判超管(null)时把 null 传下去,否则超管被锁死在本公司")
void writeGateKeepsTheSuperAdminVerdict() { void writeGateKeepsTheSuperAdminVerdict() {
HttpServletRequest request = login(); HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user()); when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(null); when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(null);
ShopKeyUpdateRequest body = new ShopKeyUpdateRequest(); ShopKeyUpdateRequest body = new ShopKeyUpdateRequest();
body.setZiniaoAccountName("ziniao-a"); body.setZiniaoAccountName("ziniao-a");
@@ -140,7 +142,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("新增:只把操作者 id 交给 service,公司由 service 从会话推导") @DisplayName("新增:只把操作者 id 交给 service,公司由 service 从会话推导")
void createPassesOnlyTheOperator() { void createPassesOnlyTheOperator() {
HttpServletRequest request = login(); HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user()); when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
ShopKeyCreateRequest body = new ShopKeyCreateRequest(); ShopKeyCreateRequest body = new ShopKeyCreateRequest();
body.setZiniaoAccountName("ziniao-a"); body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a"); body.setZiniaoToken("token-a");
@@ -32,10 +32,13 @@ class ShopManageCredentialAuthTest {
private final ShopManageGroupService shopManageGroupService = mock(ShopManageGroupService.class); private final ShopManageGroupService shopManageGroupService = mock(ShopManageGroupService.class);
private final AdminAuthSupport adminAuthSupport = mock(AdminAuthSupport.class); private final AdminAuthSupport adminAuthSupport = mock(AdminAuthSupport.class);
private final DataReadScope dataReadScope = mock(DataReadScope.class); private final DataReadScope dataReadScope = mock(DataReadScope.class);
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService =
mock(com.nanri.aiimage.modules.permission.service.PermissionMenuService.class);
private final HttpServletRequest request = mock(HttpServletRequest.class); private final HttpServletRequest request = mock(HttpServletRequest.class);
private ShopManageController newController() { private ShopManageController newController() {
return new ShopManageController(shopManageService, shopManageGroupService, adminAuthSupport, dataReadScope); return new ShopManageController(shopManageService, shopManageGroupService, adminAuthSupport,
dataReadScope, permissionMenuService);
} }
@Test @Test