feat(platform): 后管与桌面端菜单按用户平台隔离(2026-11-18 用户口径「隔离下除 admin 外,京东用户只看京东菜单、亚马逊看不了」)——AdminMenuPlatformScope 成为菜单 key→平台归属唯一出处(京东独占 admin_jd_database+app 三件;双侧六件=账号域基础三页+本笔补侧的菜单权限配置/密钥管理/密钥用量统计;未知 key 默认 amazon 与前端 platform-scope 同形;platform null/空白归一 amazon=列 DEFAULT 同口径,不把「没带」读成京东侧全拦),filterMenuVosByPlatform 扁平过滤保留祖先链保组树完整、分组节点按存活子项去留(与前端 filterMenuTreeNodesByPlatform 同形);裁剪只挂三个下发出口(current-user/menus 非站点超管按 users.platform 收窄+登录 VO adminColumns/appColumns 双树=后管+桌面端一起)与逐页门(requireConsolePageAccess 平台门置于 isAdmin 直通之前,越侧 key 一律 403),红线=不动 getUserColumnPermissions 本体(授权编辑读接口与整树替换保存语义不变、授权行保留);current-user 增 platform 键;前端 allowedPlatformsForUser(超管随菜单树分布、其余锁 users.platform 侧、未知/缺省兜底 amazon、交集空仍锁死本人平台)+AdminLayout watch clamp(localStorage 残留另一侧自动归位、当前页在被禁侧跳回本人平台第一可见页、单侧时 tab 条整个隐藏)+platform-tab.syncToAllowed;app 树 37 key 全集核对无平台无关 key(withdraw=取款挂品牌运营工具、erp/purchase 挂后勤工具)。判据:AdminMenuPlatformScopeTest 11+ConsolePageTest +5 平台门+AdminConsoleCurrentUserMenusPlatformTest 3+AuthServicePlatformMenuTest 3+CompanyTest +1 platform 键=43 例绿;前端 platform-menu-filter 9/9(+2)、mount admin-layout-platform-lock 4/4、授权树过滤对齐扩双侧;vue-tsc rc=0;node --test 1937/1938(唯一红=在册 B116-03 ENOENT);vitest mount 184/184;mvn -o test-compile rc=0;快检后端 2 红格=环境假红(缺 Git 工具链 PATH,前置后 30/30 绿)、四面可读棘轮红=PermissionMenuService 1661→1676 行随本笔点名记账(ops 仓同窗);桌面端界面随 appColumns 下发生效,客户端出包另窗

This commit is contained in:
2026-11-18 01:28:49 +08:00
parent 24272a910c
commit 2a8bdd7d29
17 changed files with 1038 additions and 24 deletions
@@ -37,13 +37,18 @@ export const JD_APP_MENU_KEYS: readonly string[] = [
'jd-publish',
]
/** 双侧共用菜单(2026-11-17 用户口径「这些亚马逊这边也要有」):三个账号域页面在两个
* 平台 tab 下都显示——同一套组件、按当前 tab 给接口传 platform,各自只看/管各自平台的
* 账号、分组、公司(后端 V206 三表加列,存量默认亚马逊,京东侧数据在编辑弹窗里翻档)。 */
/** 双侧共用菜单(2026-11-17 用户口径「这些亚马逊这边也要有」;2026-11-18 扩双侧):账号域
* 页面在两个平台 tab 下都显示——同一套组件、按当前 tab 给接口传 platform,各自只看/管各自
* 平台的账号、分组、公司(后端 V206 三表加列,存量默认亚马逊,京东侧数据在编辑弹窗里翻档)。
* 2026-11-18 平台隔离落地(「非站点超管只看自己平台侧」)把三个账号域管理页也标双侧:
* 它们是账号域功能而非亚马逊业务,京东侧公司超管被锁单侧后仍要能配菜单权限、管密钥。 */
export const BOTH_PLATFORM_MENU_KEYS: readonly string[] = [
'admin_users',
'admin_group_manage',
'admin_companies',
'admin_columns',
'admin_user_secrets',
'admin_user_secret_usage',
]
/** menuKey → 平台归属清单(唯一判定出口):京东独占(后台或桌面端清单)→ ['jd'];
+26 -5
View File
@@ -6,7 +6,7 @@ import { useAdminSessionStore } from '@/stores/admin-session'
import { joinAdminPath } from '@/config/app'
import { pageTitleOf, topbarUserOf } from '@/layout/topbar-model'
import { allGroupKeys, toSidebarEntries } from '@/layout/menu-mapper'
import { filterMenuTreeByPlatform, visiblePlatformsFor } from '@/layout/platform-menu-filter'
import { filterMenuTreeByPlatform, allowedPlatformsForUser } from '@/layout/platform-menu-filter'
import { PLATFORM_TABS, platformsOfMenuKey } from '@/config/platform-scope'
import { usePlatformTabStore } from '@/stores/platform-tab'
import { firstVisiblePath } from '@/router/helpers'
@@ -41,9 +41,12 @@ const platformTab = usePlatformTabStore()
const menuEntries = computed(() =>
toSidebarEntries(filterMenuTreeByPlatform(session.menuTree, platformTab.active)),
)
const visibleTabIds = computed(() => visiblePlatformsFor(session.menuTree))
const visibleTabDefs = computed(() => PLATFORM_TABS.filter((tab) => visibleTabIds.value.includes(tab.id)))
const showPlatformTabs = computed(() => visibleTabIds.value.length > 1)
// 平台锁定(2026-11-18 用户口径「隔离下除站点超管外,京东用户只看京东菜单、亚马逊看不了」):
// tab 可见性 = 站点超管随菜单树分布;其余用户锁 users.platform 那一侧(后端下发树已按平台
// 裁剪,这里再把 tab 收敛到本人平台,单侧时 tab 条整个隐藏)。
const allowedTabIds = computed(() => allowedPlatformsForUser(session.menuTree, session.user))
const visibleTabDefs = computed(() => PLATFORM_TABS.filter((tab) => allowedTabIds.value.includes(tab.id)))
const showPlatformTabs = computed(() => allowedTabIds.value.length > 1)
// 父菜单默认全展开(2026-11-17 用户口径「父菜单不要默认折叠」)。el-menu 的 default-openeds
// 只在挂载时读一次,平台 tab 切换/菜单树刷新导致 entries 变化后新分组不会自动展开,
// 这里在 entries 变更渲染完成后按当下值命令式补开;用户手动收起的组在 entries 不变期间
@@ -73,13 +76,14 @@ watch(
// 直达 URL/面包屑跳到另一平台的页面时,tab 指示自动跟过去(与侧边栏保持一致)。
// 双侧清单里的页面(账号域三页)两个 tab 都算归属:当前 tab 已含它就不动。
// 跟随目标只在允许集(allowedTabIds)里找:被平台锁定的侧不会成为落点。
watch(
() => route.meta.menuKey as string | undefined,
(menuKey) => {
if (!menuKey) return
const owners = platformsOfMenuKey(menuKey)
if (owners.includes(platformTab.active)) return
const target = owners.find((platform) => visibleTabIds.value.includes(platform))
const target = owners.find((platform) => allowedTabIds.value.includes(platform))
if (target && target !== platformTab.active) {
platformTab.setActive(target)
}
@@ -87,6 +91,23 @@ watch(
{ immediate: true },
)
// 平台锁定的归位(2026-11-18):会话就位/菜单树刷新后允许集收敛时,把残留的另一侧 tab
// (超管在同一浏览器切过,localStorage 落的值)归位本人平台;当前页若在被禁侧一并跳回
// 该侧第一可见页。切 tab 的跳转复用下面 platformTab.active 的 watch(active 被 syncToAllowed
// 改写后同链路生效)。
watch(
allowedTabIds,
(allowed) => {
if (!session.user) return
platformTab.syncToAllowed(allowed)
const menuKey = route.meta.menuKey as string | undefined
if (!menuKey || platformsOfMenuKey(menuKey).includes(platformTab.active)) return
const first = firstVisiblePath(filterMenuTreeByPlatform(session.menuTree, platformTab.active))
if (first) void router.replace(first)
},
{ immediate: true },
)
// 切到另一侧 tab 时当前页多半不在那边:跳到该侧第一个可见页;该侧为空(tab 不可见)则不动。
// 双侧清单里的页面(账号域三页)切 tab 不跳转——页面自己按当前平台过滤数据。
watch(
@@ -1,4 +1,5 @@
import type { AdminMenuNode } from '../types/admin'
import type { AdminMenuNode, AdminUser } from '../types/admin'
import { isSuperAdminRole } from '../types/admin.ts'
import { PLATFORM_TABS, filterMenuTreeNodesByPlatform } from '../config/platform-scope.ts'
import type { PlatformTabId } from '../config/platform-scope.ts'
import { firstVisiblePath } from '../router/helpers.ts'
@@ -25,3 +26,20 @@ export function visiblePlatformsFor(nodes: AdminMenuNode[] | null | undefined):
.filter((tab) => firstVisiblePath(filterMenuTreeByPlatform(nodes, tab.id)) !== '')
.map((tab) => tab.id)
}
/** 登录用户可用的平台 tab(2026-11-18 用户口径「隔离下除站点超管外,京东用户只看京东菜单、
* 亚马逊看不了」):站点超管不限侧、沿用菜单树分布;其余用户锁 users.platform 那一侧
* (未知/缺省按亚马逊存量口径,与后端 AdminMenuPlatformScope.normalize 同形),与「菜单树
* 该侧有可点页面」求交——交集空则仍回落单侧(管理角色必有双侧账号域页,交集实际非空;
* 宁可锁死自己平台也不放开被禁侧)。会话未就位(user 为空)时按可见分布,锁定的收窄
* 由 AdminLayout 的 watch 在 user 就位后再做。 */
export function allowedPlatformsForUser(
nodes: AdminMenuNode[] | null | undefined,
user: Pick<AdminUser, 'role' | 'platform'> | null | undefined,
): PlatformTabId[] {
const visible = visiblePlatformsFor(nodes)
if (!user || isSuperAdminRole(user.role)) return visible
const own: PlatformTabId = user.platform === 'jd' ? 'jd' : 'amazon'
const allowed = visible.filter((id) => id === own)
return allowed.length > 0 ? allowed : [own]
}
@@ -38,5 +38,13 @@ export const usePlatformTabStore = defineStore('platform-tab', {
this.active = id
writeStoredTab(id)
},
/** 平台锁定(2026-11-18 用户口径「非站点超管只看自己平台侧」):允许集收敛时把 active
* 归位——localStorage 残留的另一侧(超管在同一浏览器切过 tab)自动回落本人平台;
* 允许集为空(会话未就位)不动。 */
syncToAllowed(allowed: readonly PlatformTabId[]) {
if (allowed.length > 0 && !allowed.includes(this.active)) {
this.setActive(allowed[0])
}
},
},
})
@@ -2,7 +2,7 @@
"note": "readSource 钉子逐文件基线。两把尺子:pins=落在用例体内的读盘,reads=全文读点总数(含模块级夹具与 helper)。都只许减;pins 下降而 reads 没同步下降=把读盘挪出体内,不算改进。由 tests/source-pin-ratchet.test.ts 生成。",
"totals": {
"files": 262,
"cases": 1832,
"cases": 1837,
"pins": 460,
"reads": 658
},
@@ -58,7 +58,7 @@
"reads": 1
},
"align-group-editor.test.ts": {
"cases": 10,
"cases": 13,
"pins": 2,
"reads": 3
},
@@ -398,7 +398,7 @@
"reads": 7
},
"platform-menu-filter.test.ts": {
"cases": 7,
"cases": 9,
"pins": 0,
"reads": 0
},
@@ -0,0 +1,164 @@
/**
* AdminLayout × 平台锁定(2026-11-18 用户口径「隔离下除站点超管外,京东用户只看京东菜单、
* 亚马逊看不了」)的挂载契约:
* - 京东用户(company_super_admin + platform=jd)即使 localStorage 残留另一侧 tab,挂载后
* active 归位本人平台(syncToAllowed),单侧时平台 tab 条整个隐藏;
* - 站点超管不受限:双平台 tab 照画、active 保持残留值(超管切过的侧照记);
* - 京东用户当前路由落在被禁侧(直达 URL):跳回本人平台第一可见页。
* menuTree 模拟后端裁剪后的下发树(京东用户树里本来就没有亚马逊叶子)。
* 不用 readFileSync(source-pin-ratchet 对台账外新文件带读点即红),全部走真实挂载断言。
*
* 跑法:`npx vitest run tests/mount/admin-layout-platform-lock.mount.test.ts`
*/
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount } from '@vue/test-utils'
import { createPinia, setActivePinia, type Pinia } from 'pinia'
import ElementPlus from 'element-plus'
import { createMemoryHistory, createRouter, type Router } from 'vue-router'
import AdminLayout from '@/layout/AdminLayout.vue'
import { usePlatformTabStore } from '@/stores/platform-tab'
import { useAdminSessionStore } from '@/stores/admin-session'
import { adminPages } from '@/router/routes'
import type { AdminMenuNode } from '@/types/admin'
// AdminLayout 的顶栏/告警子组件各带定时器或远端拉取,与本契约无关,替身化。
vi.mock('@/components/NotificationBell.vue', () => ({ default: { template: '<div class="bell-stub" />' } }))
vi.mock('@/components/ExpiryNotice.vue', () => ({ default: { template: '<div class="expiry-stub" />' } }))
vi.mock('@/layout/OperationGuide.vue', () => ({ default: { template: '<div class="guide-stub" />' } }))
vi.mock('@/layout/CompanyTabs.vue', () => ({ default: { template: '<div class="company-tabs-stub" />' } }))
vi.mock('@/layout/GlobalErrorContainer.vue', () => ({ default: { template: '<div class="error-stub" />' } }))
/** 后端裁剪后下发给京东用户的树形状:双侧账号域六页 + 京东数据库(无任何亚马逊叶子)。 */
const JD_TREE: AdminMenuNode[] = [
{
key: 'admin_group_account',
name: '账号与权限',
children: [
{ key: 'admin_users', name: '用户管理', route: '/account/users' },
{ key: 'admin_group_manage', name: '分组管理', route: '/account/groups' },
{ key: 'admin_columns', name: '菜单权限配置', route: '/account/menus' },
{ key: 'admin_user_secrets', name: '密钥管理', route: '/account/user-secrets' },
{ key: 'admin_user_secret_usage', name: '密钥用量统计', route: '/account/user-secret-usage' },
],
},
{
key: 'admin_group_data',
name: '数据管理',
children: [{ key: 'admin_jd_database', name: '京东数据库', route: '/jd-center/database' }],
},
]
/** 站点超管的树:亚马逊业务页 + 京东页 + 双侧账号域(现状全量形状)。 */
const SUPER_TREE: AdminMenuNode[] = [
{
key: 'admin_group_account',
name: '账号与权限',
children: [{ key: 'admin_users', name: '用户管理', route: '/account/users' }],
},
{
key: 'admin_group_data',
name: '数据管理',
children: [
{ key: 'admin_query_asin', name: '查询ASIN', route: '/asin-center/query' },
{ key: 'admin_jd_database', name: '京东数据库', route: '/jd-center/database' },
],
},
]
let pinia: Pinia
let router: Router
beforeEach(async () => {
vi.clearAllMocks()
window.localStorage.removeItem('admin-platform-tab')
pinia = createPinia()
setActivePinia(pinia)
// adminPages 是相对 /admin-vue/ 的子路径注册表(不带前导斜杠),这里按 memory history
// 补 "/" 建表:路由 meta 带上 menuKey,AdminLayout 的 tab 跟随/replace 判定吃真实 meta。
// component 全部换同步桩——真实页面是懒 import,导航确认会卡在组件 promise 上,
// 而本契约只盯 AdminLayout 的 tab/replace 行为,页面本体无关。
router = createRouter({
history: createMemoryHistory(),
routes: adminPages.map((page) => ({
path: `/${page.path}`,
component: { template: '<div class="page-stub" />' },
meta: { title: page.title, menuKey: page.menuKey },
})),
})
await router.push('/')
await router.isReady()
})
async function mountLayout() {
const wrapper = mount(AdminLayout, { global: { plugins: [pinia, router, ElementPlus] } })
await flushPromises()
return wrapper
}
describe('AdminLayout × 平台锁定(2026-11-18)', () => {
it('京东用户挂载:残留的亚马逊 tab 归位京东侧,tab 条隐藏,侧边栏只画本人平台菜单', async () => {
window.localStorage.setItem('admin-platform-tab', 'amazon')
const session = useAdminSessionStore()
session.user = { id: 10, username: '阿华66', role: 'company_super_admin', platform: 'jd' }
session.menuTree = JD_TREE
session.initialized = true
const wrapper = await mountLayout()
const platformTab = usePlatformTabStore()
expect(platformTab.active).toBe('jd')
expect(wrapper.findAll('.admin-platform-tab').length).toBe(0)
const texts = wrapper.findAll('.admin-menu .el-menu-item').map((item) => item.text())
expect(texts).toContain('京东数据库')
expect(texts).not.toContain('查询ASIN')
// 双侧账号域照画(2026-11-18 扩双侧后含菜单权限配置/密钥管理/密钥用量统计)
expect(texts).toContain('菜单权限配置')
expect(texts).toContain('密钥管理')
wrapper.unmount()
})
it('站点超管挂载:双平台 tab 照画、残留 active 保持(不受平台锁定影响)', async () => {
window.localStorage.setItem('admin-platform-tab', 'jd')
const session = useAdminSessionStore()
session.user = { id: 1, username: 'admin', role: 'super_admin', platform: 'amazon' }
session.menuTree = SUPER_TREE
session.initialized = true
const wrapper = await mountLayout()
const platformTab = usePlatformTabStore()
expect(platformTab.active).toBe('jd')
const tabs = wrapper.findAll('.admin-platform-tab').map((tab) => tab.text())
expect(tabs).toEqual(['亚马逊', '京东'])
expect(tabs[1]).toBe('京东')
wrapper.unmount()
})
it('京东用户直达被禁侧 URL(/asin-center/query):挂载后跳回本人平台第一可见页', async () => {
const session = useAdminSessionStore()
session.user = { id: 10, username: '阿华66', role: 'company_super_admin', platform: 'jd' }
session.menuTree = JD_TREE
session.initialized = true
await router.push('/asin-center/query')
const wrapper = await mountLayout()
expect(router.currentRoute.value.path).toBe('/account/users')
wrapper.unmount()
})
it('亚马逊存量用户(platform 缺省兜底亚马逊):锁亚马逊侧,京东页不可达', async () => {
const session = useAdminSessionStore()
session.user = { id: 8, username: '存量号', role: 'admin' }
session.menuTree = SUPER_TREE
session.initialized = true
const wrapper = await mountLayout()
const platformTab = usePlatformTabStore()
expect(platformTab.active).toBe('amazon')
expect(wrapper.findAll('.admin-platform-tab').length).toBe(0)
wrapper.unmount()
})
})
@@ -8,14 +8,14 @@ import {
PLATFORM_TABS,
platformsOfMenuKey,
} from '../src/config/platform-scope.ts'
import { filterMenuTreeByPlatform, visiblePlatformsFor } from '../src/layout/platform-menu-filter.ts'
import { allowedPlatformsForUser, filterMenuTreeByPlatform, visiblePlatformsFor } from '../src/layout/platform-menu-filter.ts'
import { adminPages } from '../src/router/routes.ts'
/** 2026-11-16 用户定案「亚马逊/京东不混一起」:侧边栏顶部加平台 tab,京东侧=截图圈定
* 数据页(京东数据库/分类管理)。2026-11-17 用户口径「这些亚马逊这边也要有」:账号域三页
* (用户管理/分组管理/公司管理)改为双侧显示(BOTH_PLATFORM_MENU_KEYS),同一组件按当前
* tab 传 platform 过滤各自数据。tab 只做显示分组——菜单可见性仍由 session.menuTree(后端
* 按权限裁剪)决定,这里钉的是「分侧归属」与「空侧隐藏」两条形状。
* 按权限裁剪)决定,这里钉的是「分侧归属」「空侧隐藏」与「登录用户平台锁定」三条形状。
* 辅助定义在所有 test 之前:node:test 的用例回调按声明序执行,挪到文件尾会踩 TDZ。 */
const node = (key: string, name: string, route?: string, children?: AdminMenuNode[]): AdminMenuNode => {
@@ -54,17 +54,18 @@ test('menuKey 平台归属:京东独占即 [jd],双侧清单即两侧,其
for (const key of JD_MENU_KEYS) assert.deepEqual(platformsOfMenuKey(key), ['jd'], key)
for (const key of BOTH_PLATFORM_MENU_KEYS) assert.deepEqual(platformsOfMenuKey(key), ['amazon', 'jd'], key)
assert.deepEqual(platformsOfMenuKey('admin_query_asin'), ['amazon'])
assert.deepEqual(platformsOfMenuKey('admin_columns'), ['amazon'])
assert.deepEqual(platformsOfMenuKey('admin_columns'), ['amazon', 'jd'])
assert.deepEqual(platformsOfMenuKey('admin_group_account'), ['amazon'])
assert.deepEqual(platformsOfMenuKey('admin_jd_unknown_future'), ['amazon'])
assert.deepEqual(platformsOfMenuKey(''), ['amazon'])
})
test('京东 tab:账号与权限只余双侧三项,数据管理只余京东独占页(2026-11-17 分类管理并入京东数据库页后只剩数据库一页);顺序与 route 原样透传', () => {
test('京东 tab:账号与权限只余双侧六项(2026-11-18 平台隔离把三个账号域管理页也标双侧),数据管理只余京东独占页(2026-11-17 分类管理并入京东数据库页后只剩数据库一页);顺序与 route 原样透传', () => {
const filtered = filterMenuTreeByPlatform(TREE, 'jd')
assert.deepEqual(filtered.map((item) => item.key), ['admin_group_account', 'admin_group_data'])
assert.deepEqual(groupChildKeys(filtered, 'admin_group_account'),
['admin_users', 'admin_group_manage', 'admin_companies'])
['admin_columns', 'admin_users', 'admin_group_manage', 'admin_user_secrets',
'admin_user_secret_usage', 'admin_companies'])
// 2026-11-17 晚用户口径「京东分类管理并到京东数据库分类编辑里」:分类管理子菜单
// (V204)下线,京东侧数据管理组只剩京东数据库一页。
assert.deepEqual(groupChildKeys(filtered, 'admin_group_data'), ['admin_jd_database'])
@@ -124,7 +125,8 @@ test('平台 tab 定义与菜单清单钉死(防清单漂移):京东独占
// 2026-11-17 晚分类管理(admin_jd_category_manage)并入京东数据库页后从清单摘除。
assert.deepEqual([...JD_MENU_KEYS], ['admin_jd_database'])
assert.deepEqual([...BOTH_PLATFORM_MENU_KEYS].sort(),
['admin_companies', 'admin_group_manage', 'admin_users'])
['admin_columns', 'admin_companies', 'admin_group_manage', 'admin_user_secret_usage',
'admin_user_secrets', 'admin_users'])
// 桌面端(app)清单与 JD_MENU_KEYS 分列:app 菜单没有 admin 路由,不得混进
// 「与 routes.ts 对撞」的那份(下方护栏用例只扫 JD_MENU_KEYS/BOTH 两份是刻意的)。
assert.deepEqual([...JD_APP_MENU_KEYS].sort(), ['jd-collect', 'jd-publish', 'jd_tools'])
@@ -136,3 +138,34 @@ test('两份清单的每一条都必须在路由注册表登记(同 company-me
assert.ok(registered.has(key), `平台侧菜单 key "${key}" 未在 src/router/routes.ts 登记 menuKey`)
}
})
test('allowedPlatformsForUser:站点超管随菜单树分布;其余用户锁 users.platform 一侧(未知/缺省按亚马逊)', () => {
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'super_admin', platform: 'jd' }), ['amazon', 'jd'],
'站点超管不限侧:双平台 tab 照画')
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'company_super_admin', platform: 'jd' }), ['jd'],
'京东用户锁京东侧:亚马逊 tab 消失(单侧时 tab 条整个隐藏)')
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'admin', platform: 'amazon' }), ['amazon'])
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'normal', platform: undefined }), ['amazon'],
'platform 缺省按亚马逊存量口径(与后端 AdminMenuPlatformScope.normalize 同形)')
assert.deepEqual(allowedPlatformsForUser(TREE, { role: 'company_super_admin', platform: 'weird' }), ['amazon'],
'未知平台值同样兜底亚马逊,不得读成京东侧')
assert.deepEqual(allowedPlatformsForUser(TREE, null), ['amazon', 'jd'],
'会话未就位(user 为空)按可见分布:锁定的收窄由 AdminLayout 在 user 就位后再做')
})
test('allowedPlatformsForUser:菜单树缺本平台页时仍锁死本人平台(宁空侧不放开被禁侧)', () => {
const amazonOnlyTree: AdminMenuNode[] = [
node('admin_group_data', '数据管理', undefined, [
node('admin_dedupe_total_data', '去重数据汇总', '/asin-center/registry'),
]),
]
assert.deepEqual(
allowedPlatformsForUser(amazonOnlyTree, { role: 'company_super_admin', platform: 'amazon' }),
['amazon'],
)
assert.deepEqual(
allowedPlatformsForUser(amazonOnlyTree, { role: 'company_super_admin', platform: 'jd' }),
['jd'],
'交集空回落单侧:管理角色必有双侧账号域页所以实际非空,异常形状下宁可空侧也不放开被禁侧',
)
})
@@ -11,7 +11,7 @@ import { pruneCheckedIdsToTree } from '../src/pages/account/user-menu-auth.ts'
/**
* 授权树按平台过滤(2026-11-17 用户口径「这边也没有去掉亚马逊的」):建号/编辑弹窗的
* 菜单权限树在选「京东」时只留京东侧菜单(京东数据库+双侧账号域三件),亚马逊菜单整枝
* 菜单权限树在选「京东」时只留京东侧菜单(京东数据库+双侧账号域件),亚马逊菜单整枝
* 隐藏;切平台时勾选集收敛进可见树(pruneCheckedIdsToTree),否则京东档账号保存后仍带
* 亚马逊授权,平台分侧被静默架空。
*
@@ -44,10 +44,10 @@ const TREE: MenuOptionNode[] = [
const keysOf = (nodes: MenuOptionNode[]): string[] =>
nodes.map((n) => (n.children?.length ? `${n.key}(${keysOf(n.children).join(',')})` : n.key))
test('京东侧:只剩京东数据库+双侧账号域三件,亚马逊分组整枝消失', () => {
test('京东侧:只剩京东数据库+双侧账号域件(2026-11-18 扩双侧后菜单权限配置也归京东侧),亚马逊分组整枝消失', () => {
const jd = filterMenuTreeNodesByPlatform(TREE, 'jd')
assert.deepEqual(keysOf(jd), [
'admin_group_account(admin_users,admin_group_manage,admin_companies)',
'admin_group_account(admin_users,admin_group_manage,admin_companies,admin_columns)',
'admin_jd_database',
])
})
@@ -0,0 +1,157 @@
package com.nanri.aiimage.common.service;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 后台/桌面端菜单 key → 平台归属的唯一出处(2026-11-18 用户口径「隔离下除站点超管外,
* 京东用户只看京东菜单、亚马逊看不了」)。字面量与 admin-frontend-vue
* {@code src/config/platform-scope.ts} 同源同值:京东独占、双侧共用、其余(未知 key 在内)
* 默认亚马逊——前端对未知 key 也是默认亚马逊,两端口径必须同形。
*
* <p>语义边界:平台裁剪只挂在「菜单下发出口」({@code /api/admin/current-user/menus} 与登录 VO
* 的 adminColumns/appColumns)与逐页门 {@code requireConsolePageAccess};授权管理读/写接口
* (/permission-users/{uid}/column-permissions 与整树替换保存)**不裁**——授权行保留,
* 用户日后翻档(platform 改回另一侧)授权仍在,不因「打开编辑弹窗又保存」被静默清掉。</p>
*
* <p>过滤算法与前端 {@code filterMenuTreeNodesByPlatform} 同形:叶子按 key 归属保留;
* 分组节点自身的 key 不参与平台判定,按「有存活的子项」去留——否则京东侧「账号与权限」
* 这类混合分组(双侧页面 + 亚马逊页混编)会被整组误剪。扁平 VO 过滤会保留被保留节点的
* 祖先链,保证下游 {@code AdminMenuTreeBuilder.build} 组树完整。</p>
*/
public final class AdminMenuPlatformScope {
/** 京东后台独占菜单 key(与前端 JD_MENU_KEYS 逐字一致,用例钉住)。 */
public static final Set<String> JD_MENU_KEYS = Set.of("admin_jd_database");
/** 桌面端(app 树)京东菜单 key(与前端 JD_APP_MENU_KEYS 逐字一致,V209:组行 + 两工具子行)。 */
public static final Set<String> JD_APP_MENU_KEYS = Set.of("jd_tools", "jd-collect", "jd-publish");
/**
* 双侧共用菜单 key(与前端 BOTH_PLATFORM_MENU_KEYS 逐字一致):账号域基础三页 +
* 2026-11-18 用户口径补进的三个账号域管理页(菜单权限配置/密钥管理/密钥用量统计)——
* 它们是账号域功能而非亚马逊业务,京东侧公司超管被锁单侧后仍要能配菜单、管密钥。
*/
public static final Set<String> BOTH_MENU_KEYS = Set.of(
"admin_users", "admin_group_manage", "admin_companies",
"admin_columns", "admin_user_secrets", "admin_user_secret_usage");
private AdminMenuPlatformScope() {
}
/**
* 平台归一:null/空白按 {@code amazon}(与 users.platform 列 DEFAULT 'amazon' 同口径,
* 也与前端 {@code user.platform === 'jd' ? 'jd' : 'amazon'} 同形)——实体没带平台值的
* 账号一律按亚马逊侧放行,不得把「没带」读成「京东侧全拦」。
*/
public static String normalize(String platform) {
return platform == null || platform.isBlank() ? AdminPlatformScope.AMAZON : platform;
}
/**
* menuKey → 平台归属:京东独占(后台或桌面端清单)→ {jd};双侧清单 → {amazon,jd};
* 其余(未知 key 在内)默认 {amazon}。key 缺省(null/空白)同样默认亚马逊,与前端
* {@code platformsOfMenuKey(node.key || '')} 对齐。
*/
public static Set<String> platformsOfMenuKey(String key) {
if (key == null || key.isBlank()) {
return Set.of(AdminPlatformScope.AMAZON);
}
if (JD_MENU_KEYS.contains(key) || JD_APP_MENU_KEYS.contains(key)) {
return Set.of(AdminPlatformScope.JD);
}
if (BOTH_MENU_KEYS.contains(key)) {
return Set.of(AdminPlatformScope.AMAZON, AdminPlatformScope.JD);
}
return Set.of(AdminPlatformScope.AMAZON);
}
/**
* 逐页门用:columnKeys 里是否存在「不归属该平台」的 key。双侧 key 两个平台都放行;
* 空 keys 返回 false(不构成越侧证据,交给原有授权判定处理)。
*/
public static boolean hasCrossPlatformKey(List<String> columnKeys, String platform) {
if (columnKeys == null || columnKeys.isEmpty()) {
return false;
}
String own = normalize(platform);
for (String key : columnKeys) {
if (!platformsOfMenuKey(key).contains(own)) {
return true;
}
}
return false;
}
/**
* 扁平菜单 VO 按平台过滤(下发出口专用):叶子按 key 归属保留;分组节点(有子项者)
* 按存活子项去留;被保留节点的祖先链一并保留,保证组树完整。null/空回空列表。
* 入参不被修改。
*/
public static List<PermissionMenuItemVo> filterMenuVosByPlatform(List<PermissionMenuItemVo> menus,
String platform) {
if (menus == null || menus.isEmpty()) {
return List.of();
}
String own = normalize(platform);
Map<Long, PermissionMenuItemVo> byId = new HashMap<>();
Map<Long, List<PermissionMenuItemVo>> childrenOf = new HashMap<>();
for (PermissionMenuItemVo menu : menus) {
if (menu == null || menu.getId() == null) {
continue;
}
byId.put(menu.getId(), menu);
if (menu.getParentId() != null) {
childrenOf.computeIfAbsent(menu.getParentId(), k -> new ArrayList<>()).add(menu);
}
}
Set<Long> keepIds = new LinkedHashSet<>();
for (PermissionMenuItemVo menu : byId.values()) {
if (subtreeHasPlatformLeaf(menu, childrenOf, own)) {
keepWithAncestors(menu, byId, keepIds);
}
}
if (keepIds.isEmpty()) {
return List.of();
}
List<PermissionMenuItemVo> out = new ArrayList<>();
for (PermissionMenuItemVo menu : menus) {
if (menu != null && menu.getId() != null && keepIds.contains(menu.getId())) {
out.add(menu);
}
}
return List.copyOf(out);
}
/** 叶子:key 归属判定;分组节点:任一子树存活即存活(孤儿/空分组随之被裁)。 */
private static boolean subtreeHasPlatformLeaf(PermissionMenuItemVo menu,
Map<Long, List<PermissionMenuItemVo>> childrenOf,
String platform) {
List<PermissionMenuItemVo> children = childrenOf.get(menu.getId());
if (children == null || children.isEmpty()) {
return platformsOfMenuKey(menu.getColumnKey()).contains(platform);
}
for (PermissionMenuItemVo child : children) {
if (child != null && subtreeHasPlatformLeaf(child, childrenOf, platform)) {
return true;
}
}
return false;
}
private static void keepWithAncestors(PermissionMenuItemVo menu,
Map<Long, PermissionMenuItemVo> byId,
Set<Long> keepIds) {
PermissionMenuItemVo current = menu;
while (current != null && current.getId() != null && keepIds.add(current.getId())) {
Long parent = current.getParentId();
current = parent == null ? null : byId.get(parent);
}
}
}
@@ -3,7 +3,9 @@ package com.nanri.aiimage.modules.admin.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.security.AccountExpiryService;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.AdminMenuPlatformScope;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
@@ -76,6 +78,9 @@ public class AdminConsoleController {
// 所以这些键要与既有 companyId/companyName 的形状一致(前端 || '' 兜底)
item.put("companyId", operator.getCompanyId());
item.put("companyName", companyService.nameOrEmpty(operator.getCompanyId()));
// 所属平台(V206):前端据它把平台 tab 锁到本人一侧(2026-11-18 用户口径「隔离下
// 非站点超管只看自己平台侧」);站点超管前端不限侧,此值对它只是标记。
item.put("platform", operator.getPlatform());
// 到期续费提醒(V146):只反映自身 expires_at,不级联——续费是账号自己的事。
// expiresAt 为 yyyy-MM-dd HH:mm 或 null;daysToExpire 为剩余整天数或 null。
item.put("expiresAt", operator.getExpiresAt() == null ? null
@@ -93,6 +98,13 @@ public class AdminConsoleController {
List<PermissionMenuItemVo> menus = permissionMenuService.getUserColumnPermissions(
operator, operator.getId(), PermissionMenuService.MENU_TYPE_ADMIN, true);
menus = AdminMenuTreeBuilder.filterByMenuType(menus, PermissionMenuService.MENU_TYPE_ADMIN);
// 平台隔离(2026-11-18 用户口径「除站点超管外,京东用户只看京东菜单、亚马逊看不了」):
// 非站点超管按自身 users.platform 收窄下发树(京东用户只留京东侧+双侧账号域,其余
// 默认亚马逊侧裁掉;路由守卫随树拦截直达 URL)。只裁下发出口——授权管理读/写接口不裁,
// 整树替换保存语义不变,授权行保留(AdminMenuPlatformScope 类注释)。
if (!DeviceSessionPolicy.isSuperAdmin(operator.getRole(), operator.getIsAdmin(), operator.getCreatedById())) {
menus = AdminMenuPlatformScope.filterMenuVosByPlatform(menus, operator.getPlatform());
}
List<Map<String, Object>> items = AdminMenuTreeBuilder.toMapList(AdminMenuTreeBuilder.build(menus));
return ApiResponse.success(Map.of("items", items));
}
@@ -10,8 +10,10 @@ import com.nanri.aiimage.modules.auth.model.dto.LoginRequest;
import com.nanri.aiimage.modules.auth.model.entity.LoginUserEntity;
import com.nanri.aiimage.modules.auth.model.vo.LoginResultVo;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.common.service.AdminMenuPlatformScope;
import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import io.jsonwebtoken.Claims;
import lombok.RequiredArgsConstructor;
@@ -23,6 +25,7 @@ import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.nanri.aiimage.common.security.JwtService;
@@ -279,8 +282,19 @@ public class AuthService {
vo.setDeviceId(deviceId);
vo.setToken(token);
vo.setExpiresIn(jwtService.ttlSeconds());
vo.setAppColumns(permissionMenuService.getUserColumnPermissions(user.getId(), PermissionMenuService.MENU_TYPE_APP));
vo.setAdminColumns(permissionMenuService.getUserColumnPermissions(user.getId(), PermissionMenuService.MENU_TYPE_ADMIN));
// 平台隔离(2026-11-18 用户口径「后管+桌面端一起」):非站点超管按 users.platform 收窄
// 登录下发菜单——adminColumns(后管)与 appColumns(桌面端)一并裁,京东用户的桌面端
// 只见京东工具;站点超管不限侧全量。只裁下发出口,授权行不动(AdminMenuPlatformScope 类注释)。
List<PermissionMenuItemVo> appColumns = permissionMenuService.getUserColumnPermissions(
user.getId(), PermissionMenuService.MENU_TYPE_APP);
List<PermissionMenuItemVo> adminColumns = permissionMenuService.getUserColumnPermissions(
user.getId(), PermissionMenuService.MENU_TYPE_ADMIN);
if (!DeviceSessionPolicy.isSuperAdmin(user.getRole(), user.getIsAdmin(), user.getCreatedById())) {
appColumns = AdminMenuPlatformScope.filterMenuVosByPlatform(appColumns, user.getPlatform());
adminColumns = AdminMenuPlatformScope.filterMenuVosByPlatform(adminColumns, user.getPlatform());
}
vo.setAppColumns(appColumns);
vo.setAdminColumns(adminColumns);
return vo;
}
@@ -11,6 +11,7 @@ import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuCreateReques
import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuUpdateRequest;
import com.nanri.aiimage.modules.permission.model.dto.UserColumnPermissionUpdateRequest;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.AdminMenuPlatformScope;
import com.nanri.aiimage.modules.permission.model.entity.PermissionMenuEntity;
import com.nanri.aiimage.modules.permission.model.entity.UserColumnPermissionEntity;
import com.nanri.aiimage.modules.permission.model.vo.ImageVideoDataPermissionUserVo;
@@ -777,9 +778,23 @@ public class PermissionMenuService {
* <p>入口放开不等于逐页放开。现网 46 个普通账号持有后台菜单授权(只读实查 2026-10-06),若逐页门只看入口,它们顺手就能读到同公司的密钥页与扣次数的 ASIN 查询页——勾菜单的人本意是给一页,不是给全部。
* 判据与 {@link #hasAnyAdminMenu} 同一套(本公司树 + 直接授权递归展开),所以勾父分组
* 覆盖后代的语义在这里照样成立。</p>
*
* <p>2026-11-18 平台隔离:管理员角色链的「恒可进」收窄为「恒可进<b>本人平台侧</b>」——
* 非站点超管传入越侧 key 一律 403(见方法体平台门),下发树裁剪之外的第二道防线。</p>
*/
public void requireConsolePageAccess(AdminUserEntity operator, String denialMessage, String... columnKeys) {
if (operator == null || isAdmin(operator)) {
if (operator == null) {
return;
}
// 平台门(2026-11-18 用户口径「隔离下非站点超管只看自己平台侧」):与下发树裁剪同口径——
// 站点超管直通之外,其余角色(含公司超管/管理员,故须放在 isAdmin 直通之前)传入的页面
// key 必须归属自身 users.platform;双侧 key 两平台都放行,越侧直调一律 403。
if (!DeviceSessionPolicy.isSuperAdmin(operator.getRole(), operator.getIsAdmin(), operator.getCreatedById())
&& columnKeys != null && columnKeys.length > 0
&& AdminMenuPlatformScope.hasCrossPlatformKey(List.of(columnKeys), operator.getPlatform())) {
throw new BusinessException(403, denialMessage);
}
if (isAdmin(operator)) {
return;
}
if (columnKeys != null && columnKeys.length > 0
@@ -0,0 +1,176 @@
package com.nanri.aiimage.common.service;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 菜单 key → 平台归属唯一出处(2026-11-18 用户口径「隔离下除站点超管外,京东用户只看京东
* 菜单、亚马逊看不了」)。三份清单必须与 admin-frontend-vue {@code src/config/platform-scope.ts}
* 逐字同值:{@code JD_MENU_KEYS} / {@code JD_APP_MENU_KEYS} / {@code BOTH_PLATFORM_MENU_KEYS}。
* 把任一清单改回旧形状(双侧少三页、京东缺 key)、把「未知 key 默认亚马逊」改掉、或把
* 平台裁剪挂回 {@code PermissionMenuService.getUserColumnPermissions} 本体(授权编辑读接口
* 会被误裁,整树替换保存即丢授权行)都必须变红。
*/
class AdminMenuPlatformScopeTest {
// ------------------------------------------------------------ 清单字面量
@Test
@DisplayName("京东独占(后台)清单逐字:admin_jd_database")
void jdAdminMenuKeysArePinnedVerbatim() {
assertThat(AdminMenuPlatformScope.JD_MENU_KEYS).containsExactly("admin_jd_database");
}
@Test
@DisplayName("桌面端京东清单逐字:jd_tools 组行 + jd-collect / jd-publish")
void jdAppMenuKeysArePinnedVerbatim() {
assertThat(AdminMenuPlatformScope.JD_APP_MENU_KEYS)
.containsExactlyInAnyOrder("jd_tools", "jd-collect", "jd-publish");
}
@Test
@DisplayName("双侧清单逐字:账号域基础三页 + 2026-11-18 补进的三个账号域管理页")
void bothPlatformMenuKeysArePinnedVerbatim() {
assertThat(AdminMenuPlatformScope.BOTH_MENU_KEYS).containsExactlyInAnyOrder(
"admin_users", "admin_group_manage", "admin_companies",
"admin_columns", "admin_user_secrets", "admin_user_secret_usage");
}
// ------------------------------------------------------------ key 归属判定
@Test
@DisplayName("key 归属判定:京东清单 → jd;双侧 → 双平台;未知/缺省 → amazon")
void platformsOfMenuKeyFollowsTheThreeLists() {
assertThat(AdminMenuPlatformScope.platformsOfMenuKey("admin_jd_database")).containsExactly("jd");
assertThat(AdminMenuPlatformScope.platformsOfMenuKey("jd_tools")).containsExactly("jd");
assertThat(AdminMenuPlatformScope.platformsOfMenuKey("admin_users"))
.containsExactlyInAnyOrder("amazon", "jd");
assertThat(AdminMenuPlatformScope.platformsOfMenuKey("admin_columns"))
.containsExactlyInAnyOrder("amazon", "jd");
// 未知 key 与缺省 key 一律默认亚马逊——与前端 platformsOfMenuKey(node.key || '') 同形
assertThat(AdminMenuPlatformScope.platformsOfMenuKey("admin_brand_gating")).containsExactly("amazon");
assertThat(AdminMenuPlatformScope.platformsOfMenuKey(null)).containsExactly("amazon");
assertThat(AdminMenuPlatformScope.platformsOfMenuKey("")).containsExactly("amazon");
}
@Test
@DisplayName("平台归一:null/空白按 amazon(列 DEFAULT 同口径),不得把「没带」读成京东侧全拦")
void nullPlatformNormalizesToAmazon() {
assertThat(AdminMenuPlatformScope.normalize(null)).isEqualTo("amazon");
assertThat(AdminMenuPlatformScope.normalize(" ")).isEqualTo("amazon");
assertThat(AdminMenuPlatformScope.normalize("jd")).isEqualTo("jd");
}
// ------------------------------------------------------------ 逐页门越侧判定
@Test
@DisplayName("越侧判定:jd 用户传亚马逊 key 判越侧;amazon 用户传亚马逊 key 不判")
void crossPlatformKeyFollowsOperatorPlatform() {
assertThat(AdminMenuPlatformScope.hasCrossPlatformKey(
List.of("admin_shop_manage", "admin_query_asin"), "jd")).isTrue();
assertThat(AdminMenuPlatformScope.hasCrossPlatformKey(
List.of("admin_shop_manage"), "amazon")).isFalse();
// 双侧 key 与京东 key 对 jd 用户都放行
assertThat(AdminMenuPlatformScope.hasCrossPlatformKey(
List.of("admin_jd_database", "admin_users"), "jd")).isFalse();
// null 平台按 amazon:亚马逊 key 不越侧
assertThat(AdminMenuPlatformScope.hasCrossPlatformKey(
List.of("admin_shop_manage"), (String) null)).isFalse();
}
// ------------------------------------------------------------ 扁平 VO 过滤
@Test
@DisplayName("jd 平台过滤:京东叶子+双侧叶子保留,亚马逊叶子与无存活子项的分组裁掉")
void jdPlatformKeepsJdAndBothLeavesWithAncestorChain() {
List<PermissionMenuItemVo> menus = List.of(
vo(1L, "group-account", null), // 账号与权限分组(双侧叶子挂它下面)
vo(2L, "admin_users", 1L), // 双侧叶子
vo(3L, "admin_columns", 1L), // 双侧叶子(2026-11-18 补双侧)
vo(4L, "group-brand", null), // 亚马逊侧分组(子叶全亚马逊 → 整组裁掉)
vo(5L, "admin_brand_gating", 4L), // 亚马逊叶子
vo(6L, "admin_jd_database", null), // 京东叶子(根级)
vo(7L, "group-unknown", null), // 只挂未知 key 的分组
vo(8L, "admin_unknown_menu", 7L)); // 未知 key 默认亚马逊 → group-unknown 整组裁掉
List<PermissionMenuItemVo> kept = AdminMenuPlatformScope.filterMenuVosByPlatform(menus, "jd");
assertThat(ids(kept)).containsExactlyInAnyOrder(1L, 2L, 3L, 6L);
}
@Test
@DisplayName("amazon 平台过滤:亚马逊叶子+双侧叶子保留,京东叶子裁掉")
void amazonPlatformKeepsAmazonAndBothLeaves() {
List<PermissionMenuItemVo> menus = List.of(
vo(1L, "group-account", null),
vo(2L, "admin_users", 1L),
vo(5L, "admin_brand_gating", null),
vo(6L, "admin_jd_database", null));
List<PermissionMenuItemVo> kept = AdminMenuPlatformScope.filterMenuVosByPlatform(menus, "amazon");
assertThat(ids(kept)).containsExactlyInAnyOrder(1L, 2L, 5L);
}
@Test
@DisplayName("过滤保留祖先链:京东叶子挂亚马逊分组下时,分组随存活子项保留")
void ancestorChainSurvivesForKeptLeafUnderMixedGroup() {
List<PermissionMenuItemVo> menus = List.of(
vo(1L, "group-mixed", null),
vo(5L, "admin_brand_gating", 1L),
vo(6L, "admin_jd_database", 1L));
List<PermissionMenuItemVo> kept = AdminMenuPlatformScope.filterMenuVosByPlatform(menus, "jd");
// 叶子 6 存活 → 分组 1 必须保留(否则 AdminMenuTreeBuilder.build 组树丢父)
assertThat(ids(kept)).containsExactlyInAnyOrder(1L, 6L);
}
@Test
@DisplayName("null 平台按 amazon 过滤;null/空输入回空列表;入参不被修改")
void nullPlatformFiltersAsAmazonAndInputsUntouched() {
List<PermissionMenuItemVo> menus = List.of(
vo(5L, "admin_brand_gating", null),
vo(6L, "admin_jd_database", null));
List<PermissionMenuItemVo> kept = AdminMenuPlatformScope.filterMenuVosByPlatform(menus, null);
assertThat(ids(kept)).containsExactly(5L);
assertThat(AdminMenuPlatformScope.filterMenuVosByPlatform(null, "jd")).isEmpty();
assertThat(AdminMenuPlatformScope.filterMenuVosByPlatform(List.of(), "jd")).isEmpty();
}
@Test
@DisplayName("全被裁光时回空列表(下游组树即空,前端该侧无可点页面)")
void fullyFilteredPlatformReturnsEmptyList() {
List<PermissionMenuItemVo> menus = List.of(
vo(5L, "admin_brand_gating", null),
vo(6L, "admin_jd_database", null));
// amazon 平台下把京东叶子也喂进过滤场景不存在(下发树按用户授权来),
// 这里钉纯函数语义:没有任何存活叶子的输入回空。
List<PermissionMenuItemVo> jdOnly = List.of(vo(6L, "admin_jd_database", null));
assertThat(ids(AdminMenuPlatformScope.filterMenuVosByPlatform(jdOnly, "amazon"))).isEmpty();
assertThat(menus).hasSize(2);
}
private List<Long> ids(List<PermissionMenuItemVo> menus) {
return menus.stream().map(PermissionMenuItemVo::getId).toList();
}
private PermissionMenuItemVo vo(Long id, String columnKey, Long parentId) {
PermissionMenuItemVo item = new PermissionMenuItemVo();
item.setId(id);
item.setColumnKey(columnKey);
item.setName(columnKey);
item.setParentId(parentId);
item.setMenuType("admin");
return item;
}
}
@@ -128,4 +128,23 @@ class AdminConsoleCurrentUserCompanyTest {
.containsEntry("expiresAt", null)
.containsEntry("daysToExpire", null);
}
/**
* 平台隔离(2026-11-18 用户口径):前端 {@code allowedPlatformsForUser} 直接读
* {@code session.user.platform} 把平台 tab 锁到本人一侧,没有映射层——键名拼错的表现是
* 「京东用户照样切到亚马逊 tab」(值 undefined 走 'amazon' 兜底),只能由用例盯着。
*/
@Test
@DisplayName("current-user 带 platform 键(V206 字面量 amazon|jd 原样透传)")
void currentUserCarriesPlatformKeyVerbatim() {
operator.setPlatform("jd");
assertThat(item()).containsEntry("platform", "jd");
operator.setPlatform("amazon");
assertThat(item()).containsEntry("platform", "amazon");
operator.setPlatform(null);
assertThat(item()).containsEntry("platform", null);
}
}
@@ -0,0 +1,144 @@
package com.nanri.aiimage.modules.admin.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* {@code GET /api/admin/current-user/menus} 的平台裁剪(2026-11-18 用户口径「隔离下除站点
* 超管外,京东用户只看京东菜单、亚马逊看不了」):非站点超管按 users.platform 收窄下发树
* ——jd 用户只留京东叶子与双侧账号域叶子(及其祖先分组),亚马逊业务页不再下发,前端
* 路由守卫随树拦截直达 URL。把裁剪挪走(非超管重新下发全量)或挪进
* {@code PermissionMenuService.getUserColumnPermissions} 本体(授权编辑读接口被误裁)都即红。
*/
class AdminConsoleCurrentUserMenusPlatformTest {
private AdminAuthSupport adminAuthSupport;
private PermissionMenuService permissionMenuService;
private AdminConsoleController controller;
private HttpServletRequest request;
private AdminUserEntity operator;
@BeforeEach
void setUp() {
adminAuthSupport = mock(AdminAuthSupport.class);
permissionMenuService = mock(PermissionMenuService.class);
controller = new AdminConsoleController(adminAuthSupport, permissionMenuService,
mock(CompanyService.class));
request = mock(HttpServletRequest.class);
operator = new AdminUserEntity();
operator.setId(10L);
operator.setCompanyId(5L);
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(operator);
when(permissionMenuService.getUserColumnPermissions(any(), anyLong(), eq("admin"), eq(true)))
.thenReturn(fullCatalog());
when(permissionMenuService.getUserColumnPermissions(any(), anyLong(), eq("admin"), eq(false)))
.thenReturn(fullCatalog());
}
@SuppressWarnings("unchecked")
private List<Map<String, Object>> items() {
ApiResponse<Map<String, Object>> response = controller.currentUserMenus(request);
return (List<Map<String, Object>>) response.getData().get("items");
}
/** 扁平 VO 收集整棵响应树里出现过的 key(含分组)。 */
private void collectKeys(List<Map<String, Object>> nodes, List<String> out) {
for (Map<String, Object> node : nodes) {
out.add((String) node.get("key"));
Object children = node.get("children");
if (children instanceof List<?> list) {
@SuppressWarnings("unchecked")
List<Map<String, Object>> subs = (List<Map<String, Object>>) (List<?>) list;
collectKeys(subs, out);
}
}
}
@Test
@DisplayName("jd 公司超管:下发树无亚马逊叶子,京东叶子与双侧账号域照发(含祖先分组)")
void jdOperatorGetsJdAndBothMenusOnly() {
operator.setRole("company_super_admin");
operator.setIsAdmin(1);
operator.setPlatform("jd");
List<String> keys = new java.util.ArrayList<>();
collectKeys(items(), keys);
assertThat(keys).contains("admin_jd_database", "admin_users", "admin_group_manage",
"admin_columns", "admin_user_secrets", "admin_user_secret_usage");
assertThat(keys).doesNotContain("admin_brand_gating", "admin_query_asin");
assertThat(keys).contains("group-account");
}
@Test
@DisplayName("amazon 存量用户(platform=null 按 amazon 兜底):亚马逊叶子照发,京东叶子裁掉")
void amazonOperatorKeepsAmazonMenus() {
operator.setRole("admin");
operator.setIsAdmin(1);
operator.setPlatform(null);
List<String> keys = new java.util.ArrayList<>();
collectKeys(items(), keys);
assertThat(keys).contains("admin_brand_gating", "admin_users");
assertThat(keys).doesNotContain("admin_jd_database");
}
@Test
@DisplayName("站点超管:不裁剪,双平台全量原样下发")
void superAdminGetsEverything() {
operator.setRole("super_admin");
operator.setIsAdmin(1);
operator.setPlatform("jd");
List<String> keys = new java.util.ArrayList<>();
collectKeys(items(), keys);
assertThat(keys).contains("admin_jd_database", "admin_brand_gating", "admin_query_asin",
"admin_users");
}
/** 夹具:分组 + 亚马逊两页 + 京东一页 + 双侧账号域全份(含 2026-11-18 补双侧的三页)。 */
private List<PermissionMenuItemVo> fullCatalog() {
return List.of(
vo(100L, "group-account", null),
vo(101L, "admin_users", 100L),
vo(102L, "admin_group_manage", 100L),
vo(103L, "admin_columns", 100L),
vo(104L, "admin_user_secrets", 100L),
vo(105L, "admin_user_secret_usage", 100L),
vo(106L, "group-brand", null),
vo(107L, "admin_brand_gating", 106L),
vo(108L, "admin_query_asin", null),
vo(109L, "admin_jd_database", null));
}
private PermissionMenuItemVo vo(Long id, String columnKey, Long parentId) {
PermissionMenuItemVo item = new PermissionMenuItemVo();
item.setId(id);
item.setColumnKey(columnKey);
item.setName(columnKey);
item.setParentId(parentId);
item.setMenuType("admin");
item.setSortOrder(id.intValue());
return item;
}
}
@@ -0,0 +1,170 @@
package com.nanri.aiimage.modules.auth.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.security.AccountExpiryService;
import com.nanri.aiimage.common.security.AuthProperties;
import com.nanri.aiimage.common.security.JwtService;
import com.nanri.aiimage.modules.auth.mapper.LoginUserMapper;
import com.nanri.aiimage.modules.auth.model.dto.LoginRequest;
import com.nanri.aiimage.modules.auth.model.entity.LoginUserEntity;
import com.nanri.aiimage.modules.auth.model.vo.LoginResultVo;
import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* 登录 VO 的平台裁剪(2026-11-18 用户口径「后管+桌面端一起」):非站点超管登录返回的
* adminColumns(后管菜单树)与 appColumns(桌面端工具菜单)按 users.platform 收窄——
* 京东用户的桌面端只见京东工具(jd_tools 组),亚马逊工具不再下发;站点超管双平台全量。
* 裁剪只挂登录下发出口,授权行不动;把它挪进 getUserColumnPermissions 本体(授权编辑读
* 接口被误裁)或去掉(登录响应重新带全量)都即红。
*/
class AuthServicePlatformMenuTest {
private LoginUserMapper loginUserMapper;
private PermissionMenuService permissionMenuService;
private AuthService service;
/** 惰性 answer 引用:login() 求值时才读,测试体里先设置再登录。 */
private LoginUserEntity currentUser;
@BeforeAll
static void initMybatisPlusTableInfo() {
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
LoginUserEntity.class);
}
@BeforeEach
void setUp() {
loginUserMapper = mock(LoginUserMapper.class);
WerkzeugPasswordEncoder passwordEncoder = mock(WerkzeugPasswordEncoder.class);
JwtService jwtService = mock(JwtService.class);
permissionMenuService = mock(PermissionMenuService.class);
AuthProperties authProperties = mock(AuthProperties.class);
when(authProperties.isSingleDeviceEnabled()).thenReturn(true);
when(jwtService.ttlSeconds()).thenReturn(604800L);
when(jwtService.issue(anyLong(), anyString(), anyString(), anyLong())).thenReturn("jwt-token");
when(loginUserMapper.selectOne(any())).thenAnswer(invocation -> currentUser);
when(passwordEncoder.matches("pwd", "hash")).thenReturn(true);
when(permissionMenuService.getUserColumnPermissions(anyLong(), eq("admin")))
.thenReturn(adminCatalog());
when(permissionMenuService.getUserColumnPermissions(anyLong(), eq("app")))
.thenReturn(appCatalog());
service = new AuthService(loginUserMapper, passwordEncoder, jwtService,
permissionMenuService, authProperties, mock(CompanyService.class),
mock(AccountExpiryService.class));
}
private LoginResultVo login() {
LoginRequest request = new LoginRequest();
request.setUsername("u7");
request.setPassword("pwd");
request.setDeviceId("devA");
return service.login(request);
}
@Test
@DisplayName("jd 用户登录:adminColumns 只剩京东+双侧叶子,appColumns 只剩京东工具")
void jdUserLoginGetsJdSidedColumnsOnly() {
currentUser = user("company_super_admin", "jd");
LoginResultVo vo = login();
assertThat(vo.getAdminColumns())
.extracting(PermissionMenuItemVo::getColumnKey)
.contains("admin_jd_database", "admin_users", "admin_columns")
.doesNotContain("admin_brand_gating");
assertThat(vo.getAppColumns())
.extracting(PermissionMenuItemVo::getColumnKey)
.contains("jd_tools", "jd-collect", "jd-publish")
.doesNotContain("pricing", "query-asin", "wb");
}
@Test
@DisplayName("amazon 存量用户(platform=null 兜底):亚马逊列照发,京东列裁掉")
void amazonUserLoginKeepsAmazonColumns() {
currentUser = user("admin", null);
LoginResultVo vo = login();
assertThat(vo.getAdminColumns())
.extracting(PermissionMenuItemVo::getColumnKey)
.contains("admin_brand_gating", "admin_users")
.doesNotContain("admin_jd_database");
assertThat(vo.getAppColumns())
.extracting(PermissionMenuItemVo::getColumnKey)
.contains("pricing", "query-asin")
.doesNotContain("jd_tools");
}
@Test
@DisplayName("站点超管登录:双平台全量,不裁剪")
void superAdminLoginGetsEverything() {
currentUser = user("super_admin", "jd");
LoginResultVo vo = login();
assertThat(vo.getAdminColumns()).extracting(PermissionMenuItemVo::getColumnKey)
.contains("admin_jd_database", "admin_brand_gating");
assertThat(vo.getAppColumns()).extracting(PermissionMenuItemVo::getColumnKey)
.contains("jd_tools", "pricing");
}
private LoginUserEntity user(String role, String platform) {
LoginUserEntity user = new LoginUserEntity();
user.setId(7L);
user.setUsername("u7");
user.setPasswordHash("hash");
user.setIsAdmin("super_admin".equals(role) || "admin".equals(role)
|| "company_super_admin".equals(role) ? 1 : 0);
user.setRole(role);
user.setPlatform(platform);
user.setMachine("devA");
return user;
}
private List<PermissionMenuItemVo> adminCatalog() {
return List.of(
vo(101L, "admin_users", null, "admin"),
vo(102L, "admin_columns", null, "admin"),
vo(107L, "admin_brand_gating", null, "admin"),
vo(109L, "admin_jd_database", null, "admin"));
}
private List<PermissionMenuItemVo> appCatalog() {
return List.of(
vo(201L, "jd_tools", null, "app"),
vo(202L, "jd-collect", 201L, "app"),
vo(203L, "jd-publish", 201L, "app"),
vo(210L, "pricing", null, "app"),
vo(211L, "query-asin", null, "app"),
vo(212L, "wb", null, "app"));
}
private PermissionMenuItemVo vo(Long id, String columnKey, Long parentId, String menuType) {
PermissionMenuItemVo item = new PermissionMenuItemVo();
item.setId(id);
item.setColumnKey(columnKey);
item.setName(columnKey);
item.setParentId(parentId);
item.setMenuType(menuType);
item.setSortOrder(id.intValue());
return item;
}
}
@@ -158,6 +158,64 @@ class PermissionMenuServiceConsolePageTest {
.doesNotThrowAnyException();
}
// ---------------------------------------------------------- 平台门(2026-11-18)
/**
* 平台隔离(2026-11-18 用户口径「隔离下非站点超管只看自己平台侧」):管理员角色链的
* 「恒可进」收窄为「恒可进本人平台侧」——jd 用户直调亚马逊页面门一律 403,即便角色链
* 本可直通。把平台门挪回 isAdmin 直通之后(公司超管/管理员重新越侧)即红。
*/
@Test
void jdCompanySuperAdminIsDeniedAmazonPageDoor() {
AdminUserEntity operator = user(9L, "company_super_admin");
operator.setPlatform("jd");
BusinessException ex = catchThrowableOfType(() -> service.requireConsolePageAccess(
operator, "无权访问店铺管理", "admin_shop_manage"), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
}
@Test
void jdCompanySuperAdminPassesJdPageDoor() {
AdminUserEntity operator = user(9L, "company_super_admin");
operator.setPlatform("jd");
assertThatCode(() -> service.requireConsolePageAccess(
operator, "无权访问京东数据库", "admin_jd_database")).doesNotThrowAnyException();
}
/** 普通账号同理:授权解决「有没有这一页」,平台门解决「这一页归不归我的平台」。 */
@Test
void jdNormalAccountHoldingAmazonGrantIsStillDenied() {
grants(7L, SHOP_PAGE_ID);
AdminUserEntity operator = user(7L, "normal");
operator.setPlatform("jd");
BusinessException ex = catchThrowableOfType(() -> service.requireConsolePageAccess(
operator, "无权访问店铺管理", "admin_shop_manage"), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
}
/** 站点超管不受平台约束:双平台全通。 */
@Test
void superAdminIsNotPlatformConfined() {
AdminUserEntity operator = user(1L, "super_admin");
operator.setPlatform("jd");
assertThatCode(() -> service.requireConsolePageAccess(
operator, "无权访问店铺管理", "admin_shop_manage")).doesNotThrowAnyException();
}
/** 存量回归:platform 缺省(null→amazon)的账号调亚马逊页面门照旧放行。 */
@Test
void amazonPlatformOperatorKeepsExistingPageDoorBehavior() {
assertThatCode(() -> service.requireConsolePageAccess(
user(9L, "company_super_admin"), "无权访问店铺管理", "admin_shop_manage"))
.doesNotThrowAnyException();
}
// ---------------------------------------------------------------- 下发侧剪枝
@Test