(data))
if (!created) throw new Error('创建菜单响应异常:缺少菜单数据')
return created
diff --git a/admin-frontend-vue/src/pages/account/user-menu-auth-api.ts b/admin-frontend-vue/src/pages/account/user-menu-auth-api.ts
index a54bad6f6..1511e5057 100644
--- a/admin-frontend-vue/src/pages/account/user-menu-auth-api.ts
+++ b/admin-frontend-vue/src/pages/account/user-menu-auth-api.ts
@@ -18,11 +18,18 @@ export const USER_PERMISSION_COLUMNS_ENDPOINT = '/api/admin/permission-users'
/**
* 拉取可授权菜单树(后台 admin + 前端客户端 app 两类合并,按 sort 排序)。
* grantableOnly:非超管只拿到自己已持有的菜单,范围外的项后端不再下发。
+ * companyId 传 companyTab.requestCompanyId:2026-10-06 起每家公司一套菜单树,同一 column_key 在
+ * 别家有一份**不同 id** 的副本。这一页的授权载荷提交的是 column id,树取错公司就等于
+ * 把别家的 id 授给本公司账号(后端按「id 必须在被授权账号自己的树里」拒 ⇒ 保存必然失败,
+ * 而已授权项因为 id 对不上树根本勾不上,看上去像"这个人一条权限都没有")。
+ * null(非超管、或建号时没指定公司)由后端锁到操作者本公司。
*/
-export async function fetchGrantableMenus(): Promise {
+export async function fetchGrantableMenus(companyId?: number | null): Promise {
+ const query: Record = {}
+ if (companyId != null) query.company_id = companyId
const [adminRes, appRes] = await Promise.all([
- http.get(GRANT_MENUS_ENDPOINT, { params: { menuType: ADMIN_MENU_TYPE, grantableOnly: true } }),
- http.get(GRANT_MENUS_ENDPOINT, { params: { menuType: APP_MENU_TYPE, grantableOnly: true } }),
+ http.get(GRANT_MENUS_ENDPOINT, { params: { ...query, menuType: ADMIN_MENU_TYPE, grantableOnly: true } }),
+ http.get(GRANT_MENUS_ENDPOINT, { params: { ...query, menuType: APP_MENU_TYPE, grantableOnly: true } }),
])
const nodes = [
...parseMenuOptionList(adminRes.data, ADMIN_MENU_TYPE),
@@ -53,8 +60,8 @@ export interface UserMenuAuthData {
checkedIds: number[]
}
-export async function loadUserMenuAuth(userId: number): Promise {
- const [tree, checkedIds] = await Promise.all([fetchGrantableMenus(), fetchUserGrantedColumnIds(userId)])
+export async function loadUserMenuAuth(userId: number, companyId?: number | null): Promise {
+ const [tree, checkedIds] = await Promise.all([fetchGrantableMenus(companyId), fetchUserGrantedColumnIds(userId)])
return { tree, checkedIds }
}
diff --git a/admin-frontend-vue/src/pages/asin/AsinInvalidPage.vue b/admin-frontend-vue/src/pages/asin/AsinInvalidPage.vue
index 29b609ac3..7991fba7b 100644
--- a/admin-frontend-vue/src/pages/asin/AsinInvalidPage.vue
+++ b/admin-frontend-vue/src/pages/asin/AsinInvalidPage.vue
@@ -5,7 +5,6 @@ import { formatDateTime } from '@/utils/datetime'
import { computed, onMounted, reactive, ref, watch } from 'vue'
import { ElMessage } from 'element-plus'
import { useAdminSessionStore } from '@/stores/admin-session'
-import { useCompanyTabStore } from '@/stores/company-tab'
import { createInvalidAsin, deleteInvalidAsin, fetchInvalidAsinPage, updateInvalidAsin } from '../invalidasin/invalid-asin-api.ts'
import type { InvalidAsinItem } from '../invalidasin/invalid-asin-model.ts'
import { invalidAsinDeleteText, invalidAsinLockedGroupId, recordSourceLabel } from '../invalidasin/invalid-asin-model.ts'
@@ -15,7 +14,6 @@ import type { ShopGroupOption } from '../shop/shop-dto.ts'
import OldPagination from '@/components/OldPagination.vue'
const session = useAdminSessionStore()
-const companyTab = useCompanyTabStore()
const loading = ref(false)
const rows = ref([])
const total = ref(0)
@@ -46,7 +44,7 @@ const groupOptions = computed(() => {
async function loadGroups() {
try {
- groups.value = await fetchShopManageGroups(companyTab.requestCompanyId)
+ groups.value = await fetchShopManageGroups()
} catch {
groups.value = []
}
@@ -65,7 +63,6 @@ async function load() {
dataValue: filter.dataValue.trim() || undefined,
brand: filter.brand.trim() || undefined,
groupId: filter.groupId,
- companyId: companyTab.requestCompanyId,
})
rows.value = result.items
total.value = result.total
@@ -163,10 +160,6 @@ watch(isSuperAdmin, () => {
if (isSuperAdmin.value) filter.groupId = null
})
-// 切公司 = 重新取数:列表与分组下拉共用这一个 watch(少一个 = 那半边的 tab 是装饰品)。
-// groupId 必须一起清掉:上一家选中的分组在新一家根本不存在,留着会把切 tab 后的首屏筛成空列表。
-watch(() => companyTab.activeId, () => { filter.groupId = null; void loadGroups(); void load() })
-
onMounted(() => {
loadGroups()
load()
diff --git a/admin-frontend-vue/src/pages/asin/ProductCategoryPage.vue b/admin-frontend-vue/src/pages/asin/ProductCategoryPage.vue
index f7117aba8..f79f3484d 100644
--- a/admin-frontend-vue/src/pages/asin/ProductCategoryPage.vue
+++ b/admin-frontend-vue/src/pages/asin/ProductCategoryPage.vue
@@ -1,7 +1,7 @@
@@ -332,14 +326,14 @@ onMounted(loadTree)
- | 类目 |
- 层级路径 |
- 排序 |
- 来源 |
- 备注 |
- 创建时间 |
- 更新时间 |
- 操作 |
+ 类目 |
+ 层级路径 |
+ 排序 |
+ 来源 |
+ 备注 |
+ 创建时间 |
+ 更新时间 |
+ 操作 |
@@ -598,7 +592,10 @@ h3 {
table-layout: fixed;
}
.category-table-scroll > table {
- min-width: 860px;
+ /* table-layout:fixed 下,没写宽度的列在容器变窄时第一个被压到 0(10-06 截图:层级路径只剩一个字、
+ 备注只剩破折号)。承重的是 thead 里 8 列全部显式 px 定宽;这个下限与它们成对维护,
+ 数值由 tests/align-product-category.test.ts 从 markup 现算比对,改列宽要同时改这里。 */
+ min-width: 1224px;
}
.table-scroll th,
.table-scroll td {
diff --git a/admin-frontend-vue/src/pages/asin/product-category-api.ts b/admin-frontend-vue/src/pages/asin/product-category-api.ts
index d6546f947..acc8e1646 100644
--- a/admin-frontend-vue/src/pages/asin/product-category-api.ts
+++ b/admin-frontend-vue/src/pages/asin/product-category-api.ts
@@ -1,4 +1,5 @@
-/** 商品类目树/搜索适配(任务 78):GET /api/admin/product-categories(+keyword) 与 /product-categories/search。 */
+/** 商品类目树/搜索适配(任务 78):GET /api/admin/product-categories(+keyword) 与 /product-categories/search。
+ * 2026-10-06 起这一页全平台共享:三个取数口都不带 company_id。 */
import { http } from '@/api/http'
import {
parseProductCategoryList,
@@ -11,10 +12,9 @@ import {
export const PRODUCT_CATEGORY_ENDPOINT = '/api/admin/product-categories'
/** 拉取类目树(keyword 非空时由服务端过滤并保留父路径)。 */
-export async function fetchProductCategoryTree(keyword = '', companyId?: number | null): Promise {
+export async function fetchProductCategoryTree(keyword = ''): Promise {
const trimmed = keyword.trim()
const params: Record = trimmed ? { keyword: trimmed } : {}
- if (companyId != null) params.company_id = companyId
const { data } = await http.get(PRODUCT_CATEGORY_ENDPOINT, { params })
return parseProductCategoryList(data)
}
@@ -24,12 +24,10 @@ export async function searchProductCategories(
keyword: string,
page: number,
pageSize: number,
- companyId?: number | null,
): Promise {
const params: Record = { page, page_size: pageSize }
const trimmed = keyword.trim()
if (trimmed) params.keyword = trimmed
- if (companyId != null) params.company_id = companyId
const { data } = await http.get(`${PRODUCT_CATEGORY_ENDPOINT}/search`, { params })
return parseProductCategorySearchPage(data)
}
@@ -47,11 +45,9 @@ export async function fetchProductCategoryChildren(
parentId: number | null,
page: number,
pageSize: number,
- companyId?: number | null,
): Promise {
const params: Record = { page, page_size: pageSize }
if (parentId != null) params.parent_id = parentId
- if (companyId != null) params.company_id = companyId
const { data } = await http.get(`${PRODUCT_CATEGORY_ENDPOINT}/children`, { params })
const parsed = parseProductCategorySearchPage(data)
return { items: parsed.items, total: parsed.total, page: parsed.page, hasMore: parsed.hasMore }
diff --git a/admin-frontend-vue/src/pages/asin/product-category-export.ts b/admin-frontend-vue/src/pages/asin/product-category-export.ts
index 174acd10d..d32663c41 100644
--- a/admin-frontend-vue/src/pages/asin/product-category-export.ts
+++ b/admin-frontend-vue/src/pages/asin/product-category-export.ts
@@ -3,11 +3,10 @@
export const PRODUCT_CATEGORY_EXPORT_ENDPOINT = '/api/admin/product-categories/export'
/** 导出下载地址:浏览器直接访问该 URL 触发流式下载。
- * company_id 与列表同源:导出走的是同一个服务口径,不带它就是把别家类目写进同一份 XLSX。 */
-export function buildProductCategoryExportUrl(keyword: string, companyId?: number | null): string {
+ * 与列表同源:导出走的是同一个服务口径。这一页 2026-10-06 起全平台共享,不带 company_id。 */
+export function buildProductCategoryExportUrl(keyword: string): string {
const params: string[] = []
const trimmed = (keyword || '').trim()
if (trimmed) params.push(`keyword=${encodeURIComponent(trimmed)}`)
- if (companyId != null) params.push(`company_id=${companyId}`)
return params.length ? `${PRODUCT_CATEGORY_EXPORT_ENDPOINT}?${params.join('&')}` : PRODUCT_CATEGORY_EXPORT_ENDPOINT
}
diff --git a/admin-frontend-vue/src/pages/invalidasin/invalid-asin-api.ts b/admin-frontend-vue/src/pages/invalidasin/invalid-asin-api.ts
index e5ee8f67b..639830472 100644
--- a/admin-frontend-vue/src/pages/invalidasin/invalid-asin-api.ts
+++ b/admin-frontend-vue/src/pages/invalidasin/invalid-asin-api.ts
@@ -12,8 +12,6 @@ export interface InvalidAsinQuery {
dataValue?: string
brand?: string
groupId?: number | null
- /** 公司 tab 的值;toQuery 是白名单构造、不点名它,所以由发送口从原始 query 读。 */
- companyId?: number | null
}
function trimOrUndefined(value: unknown): string | undefined {
@@ -31,11 +29,8 @@ function toQuery(query: InvalidAsinQuery): Record {
}
export async function fetchInvalidAsinPage(query: InvalidAsinQuery): Promise {
- // 公司值落在 toQuery 之后、发请求之前的唯一一处:toQuery 是白名单构造(只点名 page/data_value/brand/group_id),
- // 所以这里必须从原始 query 读 companyId——从 toQuery 的结果里读是 undefined,请求照发、参数没有。
- const params = toQuery(query)
- if (query.companyId != null) params.company_id = query.companyId
- const { data } = await http.get(INVALID_ASIN_ENDPOINT, { params })
+ // 这一页 2026-10-06 起全平台共享:请求里不许出现 company_id(后端唯一键退回全局见 V151)。
+ const { data } = await http.get(INVALID_ASIN_ENDPOINT, { params: toQuery(query) })
return parseInvalidAsinPage(data)
}
diff --git a/admin-frontend-vue/src/pages/shop/ShopKeysPage.vue b/admin-frontend-vue/src/pages/shop/ShopKeysPage.vue
index f01f29812..f2db3d304 100644
--- a/admin-frontend-vue/src/pages/shop/ShopKeysPage.vue
+++ b/admin-frontend-vue/src/pages/shop/ShopKeysPage.vue
@@ -2,14 +2,16 @@
import { formatDateTime } from '@/utils/datetime'
/** 店铺密钥管理页 · 像素复刻旧版 admin.html panel-shop-keys(自绘:面板头+新增店铺密钥、序号列、令牌掩码、白名单状态药丸+悬停详情、旧式分页)。
* script 逻辑沿用现有 Vue 实现(编辑留空令牌=沿用);弹窗保留现有组件。 */
-import { computed, onMounted, reactive, ref } from 'vue'
+import { computed, onMounted, reactive, ref, watch } from 'vue'
import { ElMessage } from 'element-plus'
+import { useCompanyTabStore } from '@/stores/company-tab'
import { fetchShopKeyList, submitCreateShopKey, updateShopKey, deleteShopKey, checkShopKeyWhitelist } from './shop-key-api.ts'
import { emptyShopKeyForm, normalizeZiniaoToken, validateProxyUrl } from './shop-key-form-model.ts'
import type { ShopKeyItem } from './shop-dto.ts'
import { whitelistStatusMeta } from './shop-key-model.ts'
import OldPagination from '@/components/OldPagination.vue'
+const companyTab = useCompanyTabStore()
const loading = ref(false)
const rows = ref([])
const total = ref(0)
@@ -56,7 +58,11 @@ function whitelistTooltip(row: ShopKeyItem): string {
async function load() {
loading.value = true
try {
- const result = await fetchShopKeyList({ page: page.value, pageSize: pageSize.value })
+ const result = await fetchShopKeyList({
+ page: page.value,
+ pageSize: pageSize.value,
+ companyId: companyTab.requestCompanyId,
+ })
rows.value = result.items
total.value = result.total
page.value = result.page
@@ -172,6 +178,8 @@ function goJump() {
changePage(Math.min(Math.max(n, 1), totalPages.value))
}
+watch(() => companyTab.activeId, () => { filterKeyword.value = ''; page.value = 1; void load() })
+
onMounted(load)
diff --git a/admin-frontend-vue/src/pages/shop/shop-dto.ts b/admin-frontend-vue/src/pages/shop/shop-dto.ts
index 21998509a..1ceb9b714 100644
--- a/admin-frontend-vue/src/pages/shop/shop-dto.ts
+++ b/admin-frontend-vue/src/pages/shop/shop-dto.ts
@@ -81,10 +81,12 @@ export interface ShopGroupOption {
leaderUsername?: string
}
-/** 店铺密钥列表分页参数(该接口只支持分页)。 */
+/** 店铺密钥列表分页参数(分页 + 公司 tab;归一是白名单构造,不点名 companyId)。 */
export interface ShopKeyListParams {
page: number
pageSize: number
+ /** 公司 tab 的值;normalizeKeyListParams 不点名它,只有 api 层能从原始 params 读到。 */
+ companyId?: number | null
}
/** 店铺列表分页/筛选参数。 */
@@ -100,6 +102,8 @@ export interface ShopManageListParams {
export interface ShopKeyPageQuery {
page: number
pageSize: number
+ /** 下划线形:与后端 @RequestParam(name = "company_id") 逐字对齐。 */
+ company_id?: number
}
export interface ShopManagePageQuery {
diff --git a/admin-frontend-vue/src/pages/shop/shop-key-api.ts b/admin-frontend-vue/src/pages/shop/shop-key-api.ts
index 7e70f858c..b5b7d5493 100644
--- a/admin-frontend-vue/src/pages/shop/shop-key-api.ts
+++ b/admin-frontend-vue/src/pages/shop/shop-key-api.ts
@@ -19,7 +19,11 @@ export const SHOP_KEYS_ENDPOINT = '/api/admin/shop-keys'
export async function fetchShopKeyList(params: Partial = {}): Promise {
const normalized = normalizeKeyListParams(params)
- const { data } = await http.get(SHOP_KEYS_ENDPOINT, { params: toKeyPageQuery(normalized) })
+ // normalizeKeyListParams 与 toKeyPageQuery 都是白名单构造(不点名 companyId),
+ // 所以公司值只能从原始 params 读:写成 normalized.companyId 是 TS 绿、运行时恒 undefined。
+ const query = toKeyPageQuery(normalized)
+ if (params.companyId != null) query.company_id = params.companyId
+ const { data } = await http.get(SHOP_KEYS_ENDPOINT, { params: query })
return parseShopKeyPage(data)
}
diff --git a/admin-frontend-vue/src/router/routes.ts b/admin-frontend-vue/src/router/routes.ts
index 7ca819406..d531718b5 100644
--- a/admin-frontend-vue/src/router/routes.ts
+++ b/admin-frontend-vue/src/router/routes.ts
@@ -19,26 +19,26 @@ export interface AdminPageDef extends AdminPageMeta {
/** 业务域路由注册表(任务 8):首批 account 域;后续按业务域在此登记页面。 */
export const adminPages: AdminPageDef[] = [
{ path: 'account/users', menuKey: 'admin_users', title: '用户管理', companyScoped: true, load: () => import('@/pages/account/UsersPage.vue') },
- { path: 'account/menus', menuKey: 'admin_columns', title: '菜单管理', load: () => import('@/pages/account/MenusPage.vue') },
+ { path: 'account/menus', menuKey: 'admin_columns', title: '菜单管理', companyScoped: true, load: () => import('@/pages/account/MenusPage.vue') },
{ path: 'account/groups', menuKey: 'admin_group_manage', title: '数据权限分组', companyScoped: true, load: () => import('@/pages/account/GroupsPage.vue') },
{ path: 'account/user-secrets', menuKey: 'admin_user_secrets', title: '密钥管理', companyScoped: true, load: () => import('@/pages/account/UserSecretsPage.vue') },
{ path: 'account/user-secret-usage', menuKey: 'admin_user_secret_usage', title: '密钥用量统计', companyScoped: true, load: () => import('@/pages/account/UserSecretUsagePage.vue') },
{ path: 'account/companies', menuKey: 'admin_companies', title: '公司管理', superAdminOnly: true, load: () => import('@/pages/account/CompaniesPage.vue') },
{ path: 'shop-center/duplicate-check', menuKey: 'admin_shop_data_duplicate_check', title: '店铺撞款监控', companyScoped: true, load: () => import('@/pages/tasks/DuplicateCheckPage.vue') },
- { path: 'shop-center/keys', menuKey: 'admin_shop_keys', title: '店铺密钥管理', companyScoped: false, load: () => import('@/pages/shop/ShopKeysPage.vue') },
+ { path: 'shop-center/keys', menuKey: 'admin_shop_keys', title: '店铺密钥管理', companyScoped: true, load: () => import('@/pages/shop/ShopKeysPage.vue') },
{ path: 'shop-center/shops', menuKey: 'admin_shop_manage', title: '店铺管理', companyScoped: true, load: () => import('@/pages/shop/ShopManagePage.vue') },
{ path: 'records/history', menuKey: 'admin_history', title: '生成记录', companyScoped: true, load: () => import('@/pages/records/RecordsHistoryPage.vue') },
- { path: 'records/software-version', menuKey: 'admin_version', title: '软件版本管理', load: () => import('@/pages/records/RecordsSoftwareVersionPage.vue') },
- { path: 'records/tutorial', menuKey: 'admin_tutorial', title: '教程管理', load: () => import('@/pages/records/RecordsTutorialPage.vue') },
+ { path: 'records/software-version', menuKey: 'admin_version', title: '软件版本管理', companyScoped: false, load: () => import('@/pages/records/RecordsSoftwareVersionPage.vue') },
+ { path: 'records/tutorial', menuKey: 'admin_tutorial', title: '教程管理', companyScoped: false, load: () => import('@/pages/records/RecordsTutorialPage.vue') },
{ path: 'records/device-logs', menuKey: 'admin_device_logs', title: '日志管理', companyScoped: true, load: () => import('@/pages/records/DeviceLogsPage.vue') },
{ path: 'task-center/board', menuKey: 'admin_task_center', title: '客户端任务管理', companyScoped: true, load: () => import('@/pages/task-center/TaskCenterBoardPage.vue') },
{ path: 'records/digital-human-version', menuKey: 'digital_human_version', title: '数字人版本管理', load: () => import('@/pages/records/RecordsDigitalHumanVersionPage.vue') },
{ path: 'records/image-video-tasks', menuKey: 'admin_image_video_tasks', title: '视频任务记录', companyScoped: true, load: () => import('@/pages/tasks/ImageVideoTasksPage.vue') },
{ path: 'shop-center/data-tasks', menuKey: 'admin_shop_data_crawl_tasks', title: '店铺数据记录', companyScoped: true, load: () => import('@/pages/tasks/ShopDataTasksPage.vue') },
{ path: 'asin-center/registry', menuKey: 'admin_dedupe_total_data', title: '数据去重总数据', companyScoped: true, load: () => import('@/pages/asin/DedupeRegistryPage.vue') },
- { path: 'asin-center/invalid', menuKey: 'admin_invalid_asin_data', title: '不符合ASIN数据', companyScoped: true, load: () => import('@/pages/asin/AsinInvalidPage.vue') },
+ { path: 'asin-center/invalid', menuKey: 'admin_invalid_asin_data', title: '品牌数据库', companyScoped: false, load: () => import('@/pages/asin/AsinInvalidPage.vue') },
{ path: 'asin-center/query', menuKey: 'admin_query_asin', title: '查询ASIN', companyScoped: true, load: () => import('@/pages/asin/QueryAsinPage.vue') },
- { path: 'asin-center/categories', menuKey: 'admin_product_categories', title: '商品类目', companyScoped: true, load: () => import('@/pages/asin/ProductCategoryPage.vue') },
+ { path: 'asin-center/categories', menuKey: 'admin_product_categories', title: '商品类目', companyScoped: false, load: () => import('@/pages/asin/ProductCategoryPage.vue') },
{ path: 'asin-center/skip-price', menuKey: 'admin_skip_price_asin', title: '最低价ASIN', companyScoped: true, load: () => import('@/pages/asin/SkipPricePage.vue') },
]
diff --git a/admin-frontend-vue/tests/align-operation-guide.test.ts b/admin-frontend-vue/tests/align-operation-guide.test.ts
index 87f3229d4..45709a8e2 100644
--- a/admin-frontend-vue/tests/align-operation-guide.test.ts
+++ b/admin-frontend-vue/tests/align-operation-guide.test.ts
@@ -91,7 +91,7 @@ test('guide_copy_carries_company_tab_note_for_every_scoped_page', () => {
// 新页缺文案仍会红(operationGuideFor 对没登记的 key 返回 null ⇒ assert.ok(g) 当场红,没有兜底可糊)。
const scopedKeys = COMPANY_SCOPED_PAGES.map((p) => p.menuKey)
const need = scopedKeys.filter((k) => k !== EXCEPTED_KEY)
- assert.ok(need.length >= 15, `取样集非空自检:注册表今天有 ${scopedKeys.length} 页进了 tab 范围(批次 1 的 8 页 + 批次 2 的 5 页 + 批次 3 的 2 页 + 批次 4 的 1 页),减去唯一豁免页后只剩 ${need.length} 页`)
+ assert.ok(need.length >= 15, `取样集非空自检:注册表今天有 ${scopedKeys.length} 页进了 tab 范围(批次 1 的 8 页 + 批次 2 剩下的 3 页 + 批次 3 的 2 页 + 批次 4 的 1 页 + 批次 5 的 1 页 + 批次 6 的 1 页),减去唯一豁免页后只剩 ${need.length} 页`)
assert.ok(scopedKeys.includes(EXCEPTED_KEY),
'取样集前提自检:撞款监控已不在 COMPANY_SCOPED_PAGES 里,上面那道豁免就成了空豁免——把它连同 EXCEPTED_KEY 一起删掉')
for (const key of need) {
@@ -101,11 +101,15 @@ test('guide_copy_carries_company_tab_note_for_every_scoped_page', () => {
}
// C 类页(spec §5):它们要的是**另一句**——"这页不参与",不是"会随 tab 变"。
// 分母**取注册表里显式写 companyScoped:false 的页**,不抄名单:漏写一条 ⇒ 这支在自检那句红。
- // 批次 2 之前这里是 2 页(店铺密钥 + 商品类目),商品类目已接上公司口径 ⇒ 今天只剩 admin_shop_keys
- // 一条,所以自检降到 1;再往下掉就是有人把注册表里那条 false 改成不写(不写 = 不参与但没人说)。
+ // 批次 2 之前这里是 2 页(店铺密钥 + 商品类目),商品类目一度接上了公司口径;
+ // 2026-10-06 控制方定案「品牌数据库 / 商品类目 / 教程管理 / 软件版本管理都做成共享的,不区分」,
+ // 于是这一族一度变成 5 页(店铺密钥 + 品牌库 + 商品类目 + 软件版本 + 教程);
+ // 同日批次 5 又把店铺密钥改回按公司区分(V150 给 biz_shop_key 加 company_id),今天剩 4 页。
+ // 后四页是**新登记**的:教程管理与软件版本管理的后端本来就没有公司引用,此前既不在清单也没写 false
+ // =「不参与但没人说」,现在显式写出来,这句文案与下面那条 deepEqual 才盖得到它们。
const scoped = new Set(COMPANY_SCOPED_PAGES.map((p) => p.menuKey))
const cClass = adminPages.filter((p) => p.companyScoped === false).map((p) => p.menuKey)
- assert.ok(cClass.length >= 1, '取样集非空自检:注册表里显式 companyScoped:false 的一条都不剩了——那这句判据就是空跑')
+ assert.ok(cClass.length >= 4, `取样集非空自检:注册表里显式 companyScoped:false 只剩 ${cClass.length} 页——那这句判据就是空跑`)
for (const key of cClass) {
assert.equal(scoped.has(key), false, `${key} 既声明 false 又在清单里,两处口径打架`)
const g = operationGuideFor(key)
diff --git a/admin-frontend-vue/tests/align-product-category.test.ts b/admin-frontend-vue/tests/align-product-category.test.ts
index 23b94db22..892d664c1 100644
--- a/admin-frontend-vue/tests/align-product-category.test.ts
+++ b/admin-frontend-vue/tests/align-product-category.test.ts
@@ -85,3 +85,63 @@ test('align_category_page_tree_and_search_wiring', () => {
assert.match(page, /来源/, '搜索表格补来源列')
assert.match(page, /childCount/, '删除按钮按有子禁用')
})
+
+/**
+ * 列宽算术闸门(2026-10-06 控制方圈出:层级路径整列只剩一个字、备注只剩一个破折号)。
+ * `.table-scroll table` 是 table-layout:fixed —— 首行 th 定宽后,列宽之和一旦超过表格实宽,
+ * 浏览器把各列等比压缩,而没写宽度的 auto 列第一个被压到 0px。旧写法(类目 34% + 两个 auto 列 +
+ * 700px 固定列)在表格宽度 < 1061px 时就是这么塌的;min-width 当时是 860px,比列宽之和还小,
+ * 等于下限自己把塌缩区放进了合法区间。
+ *
+ * 闸门只认三条,其中真正承重的是前两条(浏览器实测,同一份 CSS 与真实 thead 生成的复现页):
+ * 旧写法在表格宽度 1224px 时把 层级路径 与 备注 量成 0px,而 8 列全显式定宽后在 1920/1440/1100/900
+ * 四档没有一列低于 90px —— 也就是"把 min-width 抬到 1224"单独并不能救旧写法,auto 列才是塌的那一根。
+ * 第三条(min-width >= 列宽之和)管的是成对维护:加一列却忘了抬下限会直接红。
+ * 求和从 markup 现算,不是抄常量——把某列从 220px 改成 400px 而忘了同步会直接红。
+ * (注:单元格左右各 12px padding 是加在列宽之外的,所以渲染出的表格自然宽度是"列宽之和 + 24×8 = 1416px",
+ * 与这里比对的 1224 不是同一个数,别混。)
+ */
+function categoryHeaderColumns(page: string): Array<{ label: string; px: number | null }> {
+ const theadBlocks = page.match(/[\s\S]*?<\/thead>/g) ?? []
+ assert.equal(theadBlocks.length, 1, '类目页应只有一个 thead(本闸门按单个表头求列宽之和)')
+ const columns: Array<{ label: string; px: number | null }> = []
+ for (const cell of theadBlocks[0].matchAll(/]*>([^<]*)<\/th>/g)) {
+ const style = cell[0].match(/style="([^"]*)"/)?.[1] ?? ''
+ const px = /width:\s*(\d+)px/.exec(style)?.[1]
+ columns.push({ label: cell[1].trim(), px: px === undefined ? null : Number(px) })
+ }
+ return columns
+}
+
+function categoryTableMinWidth(page: string): number | null {
+ const block = page.match(/\.category-table-scroll\s*>\s*table\s*\{([^}]*)\}/)?.[1] ?? ''
+ const px = /min-width:\s*(\d+)px/.exec(block)?.[1]
+ return px === undefined ? null : Number(px)
+}
+
+test('align_category_fixed_layout_never_leaves_a_column_to_be_squeezed', () => {
+ const page = readSource('src/pages/asin/ProductCategoryPage.vue')
+ // 前提也要钉:这条闸门只在 fixed 布局下成立,改成 auto 布局时它该喊,而不是安静地继续绿。
+ // 窗口用 [^}] 而不是定长字符数:本页 CSS 注释里就写着 "table-layout:fixed 下……" 这句话,
+ // 定长窗口能跨过 } 把注释喂成"前提成立"(变异自证时实测过一次 SURVIVED)。
+ assert.match(page, /\.table-scroll\s+table\s*\{[^}]*table-layout:\s*fixed/, '本闸门的前提:表格是 table-layout:fixed')
+
+ const columns = categoryHeaderColumns(page)
+ assert.equal(columns.length, 8, `表头应有 8 列(与 | 对齐),实际 ${columns.length}:${JSON.stringify(columns)}`)
+ const unwidthed = columns.filter((c) => c.px === null).map((c) => c.label)
+ assert.deepEqual(unwidthed, [], 'fixed 布局下没写宽度的列会在容器变窄时被第一个压到 0px:' + unwidthed.join('/'))
+ assert.equal(/width:\s*\d+%/.test(page.match(/[\s\S]*?<\/thead>/)?.[0] ?? ''), false,
+ '表头不许用百分比:百分比与 px 混排时列宽之和随表格宽度变,下限就无从比对')
+
+ const sum = columns.reduce((acc, c) => acc + (c.px ?? 0), 0)
+ const minWidth = categoryTableMinWidth(page)
+ assert.notEqual(minWidth, null, '.category-table-scroll > table 必须有 px 下限,否则塌缩区又合法了')
+ assert.ok((minWidth ?? 0) >= sum,
+ `min-width(${minWidth}px) 必须 >= 8 列宽度之和(${sum}px):否则表格落在 [min-width, 列宽和] 这一段时列被等比压缩`)
+
+ // 控制方圈出的那两列是这次的直接症状:它们是文字列,宽度下限给死,别被"重新调配比"顺手砍回去。
+ for (const label of ['层级路径', '备注']) {
+ const col = columns.find((c) => c.label === label)
+ assert.ok(col && (col.px ?? 0) >= 120, `${label} 列宽不得低于 120px,实际 ${col?.px ?? '未定义'}px`)
+ }
+})
diff --git a/admin-frontend-vue/tests/align-user-menu-grantable.test.ts b/admin-frontend-vue/tests/align-user-menu-grantable.test.ts
index f38d6bbbd..5c9ae9f7b 100644
--- a/admin-frontend-vue/tests/align-user-menu-grantable.test.ts
+++ b/admin-frontend-vue/tests/align-user-menu-grantable.test.ts
@@ -102,8 +102,18 @@ test('align_user_menu_grantable_wired_end_to_end', () => {
)
assert.match(
controller,
- /permissionMenuService\.list\(requireAdmin\(request\), menuType, grantableOnly\)/,
- '列表接口传入操作者与授权树开关',
+ /permissionMenuService\.resolveScopeCompanyId\(operator, companyId\)/,
+ '列表接口先把请求里的 company_id 过一遍归属判据(非超管带别家当场 403),传下去的是判定结果而不是 tab 原文',
+ )
+ assert.match(
+ controller,
+ /permissionMenuService\.list\(\s*operator, menuType, grantableOnly, scopeCompanyId\s*\)/,
+ '列表接口传入操作者、授权树开关与**已判定**的那一家(2026-10-06 每家公司一套树:授权树取错公司=已授权勾不上)',
+ )
+ assert.doesNotMatch(
+ controller,
+ /menuType, grantableOnly, companyId\s*\)/,
+ '反向钉:不许把 tab 原文直接透传给 list(),否则"前端传什么都不算"这条口径在这一口断掉',
)
const service = readSource(
diff --git a/admin-frontend-vue/tests/company-config-entry-super-only.test.ts b/admin-frontend-vue/tests/company-config-entry-super-only.test.ts
index c4cf3b5fd..bc95ca1d8 100644
--- a/admin-frontend-vue/tests/company-config-entry-super-only.test.ts
+++ b/admin-frontend-vue/tests/company-config-entry-super-only.test.ts
@@ -88,8 +88,10 @@ test('吃公司 tab 的页面集合恰好等于 COMPANY_SCOPED_PAGES 的 pageFil
.filter((rel) => readSource(rel).includes(STORE_USE_TOKEN))
.sort()
const declared = COMPANY_SCOPED_PAGES.flatMap((entry) => entry.pageFiles).sort()
- assert.ok(declared.length >= 16, `清单的 pageFiles 只剩 ${declared.length} 条 ⇒ 分母被删空,深比较会退化成空集自比`)
- assert.ok(consumers.length >= 16, `真实消费者只有 ${consumers.length} 页 ⇒ 扫描谓词(${STORE_USE_TOKEN})或页面文件本身出了问题`)
+ // 分母 15 = 今天注册表的 pageFiles 条数(批次 1 的 8 + 批次 2 剩下的 3 + 批次 3 的 2 + 批次 4 的 1 + 批次 5 的 1;
+ // 品牌库与商品类目 2026-10-06 退回全平台共享后不在其中,见 company-tab-wiring 末尾那条反向钉)。
+ assert.ok(declared.length >= 15, `清单的 pageFiles 只剩 ${declared.length} 条 ⇒ 分母被删空,深比较会退化成空集自比`)
+ assert.ok(consumers.length >= 15, `真实消费者只有 ${consumers.length} 页 ⇒ 扫描谓词(${STORE_USE_TOKEN})或页面文件本身出了问题`)
assert.deepEqual(consumers, declared,
'公司 tab 的消费者与清单对不上:多出来的一页=悄悄给一页不参与隔离的页上了 tab(公司管理就属于这类),'
+ '少掉的一页=清单声明它隔离但页面根本没取值')
diff --git a/admin-frontend-vue/tests/company-super-admin-only.test.ts b/admin-frontend-vue/tests/company-super-admin-only.test.ts
index e1cf5e266..579b81569 100644
--- a/admin-frontend-vue/tests/company-super-admin-only.test.ts
+++ b/admin-frontend-vue/tests/company-super-admin-only.test.ts
@@ -48,9 +48,10 @@ test('剪枝是纯函数且幂等(store 里会反复调用)', () => {
test('不参与 tab 的页必须显式声明 companyScoped: false(spec §5:声明,不是遗漏)', () => {
// 留空和 false 运行时等价,但只有 false 是"读过普查、决定不参与"的证据。
// 名单批次 1 是两页(店铺密钥 + 商品类目);商品类目在批次 2(2026-10-05)接上了公司口径,
- // 今天只剩紫鸟令牌这一页真的是"全平台共享、与公司无关"。
+ // 2026-10-06 控制方定案品牌库/教程管理/软件版本管理一律全平台共享,同日批次 5 又把店铺密钥
+ // 改回按公司区分(V150)⇒ 今天这一族是 4 页,一句「与公司无关」都没写给它们的页不许进这张表。
// 想再往这页上加 false 的对向(把某页改回 false)不用改这里:上面那条双向对账会红。
- for (const key of ['admin_shop_keys']) {
+ for (const key of ['admin_invalid_asin_data', 'admin_product_categories', 'admin_version', 'admin_tutorial']) {
const page = adminPages.find((p) => p.menuKey === key)
assert.ok(page, `注册表里找不到 ${key}`) // 取样非空自检
assert.equal(page.companyScoped, false, `${key} 必须显式写 companyScoped: false,不能留空`)
diff --git a/admin-frontend-vue/tests/company-tab-wiring.test.ts b/admin-frontend-vue/tests/company-tab-wiring.test.ts
index 1702f2c6f..cd50bc1c4 100644
--- a/admin-frontend-vue/tests/company-tab-wiring.test.ts
+++ b/admin-frontend-vue/tests/company-tab-wiring.test.ts
@@ -4,6 +4,7 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs'
import { occurrences, readSource } from './helpers.ts'
import { adminPages } from '../src/router/routes.ts'
import { COMPANY_SCOPED_PAGES, SUPER_ADMIN_ONLY_MENU_KEYS } from '../src/config/company-scope.ts'
+import { companyTabAppliesTo } from '../src/layout/company-tab-model.ts'
const read = (p: string) => {
assert.ok(existsSync(p), `护栏读不到 ${p}:api 文件改名了,清单必须同步(别把用例改成"不存在就跳过")`)
@@ -69,9 +70,12 @@ function escapeRegExp(text: string): string {
}
/**
- * 全部 22 个字面发送口:批次 1 的任务看板 5 处 + 批次 2(控制方 2026-10-05 点名「切 tab 数据还一样」那五页)12 处
+ * 全部 21 个字面发送口:批次 1 的任务看板 5 处 + 批次 2(控制方 2026-10-05 点名「切 tab 数据还一样」那五页)7 处
* + 批次 3(控制方 2026-10-05 点名「店铺撞款监控 店铺数据也要做隔离」那两页)4 处
- * + 批次 4(控制方 2026-10-05 点名「菜单权限和用户管理也要区分公司 tab 的数据」里的用户管理)1 处。
+ * + 批次 4(控制方 2026-10-05 点名「菜单权限和用户管理也要区分公司 tab 的数据」里的用户管理)1 处
+ * + 批次 5(控制方 2026-10-06 点名「店铺密钥管理的数据按照公司区分」)1 处
+ * + 批次 6(控制方 2026-10-06 点名「菜单权限也加字段来区分」)3 处:菜单目录 / 新建菜单 / 用户管理里的授权树。
+ * 批次 2 原 12 处里的品牌库 1 处 + 商品类目 4 处,随 2026-10-06「这两页退回全平台共享」一并摘掉。
*
* `window` 的取法:本轮实扫的 own(到自己那行的距离)+ ≥150 余量,且当同文件还有下一个同名发送口时必须
* `window < next`。own/next 不写死在这里——下面「窗口与真文件对平」那条用例逐处从真文件重算,
@@ -94,15 +98,10 @@ const SEND_POINTS: ReadonlyArray = [
{ menuKey: 'admin_dedupe_total_data', file: 'src/pages/asin/dedupe-total-api.ts', fn: 'fetchDedupeTotalList', line: 'if (params.companyId != null) query.company_id = params.companyId', window: 400, title: 'GET /dedupe-total-data 列表' },
{ menuKey: 'admin_dedupe_total_data', file: 'src/pages/asin/dedupe-total-api.ts', fn: 'fetchDedupeTotalGroups', line: 'http.get(DEDUPE_GROUPS_ENDPOINT, { params: companyId != null ? { company_id: companyId } : {} })', window: 400, title: 'GET /shop-manages/groups 分组候选(与店铺管理同源,两页口径要对得上)' },
{ menuKey: 'admin_dedupe_total_data', file: 'src/pages/asin/dedupe-total-export.ts', fn: 'buildDedupeExportParams', line: 'if (companyId != null) params.company_id = String(companyId)', window: 800, title: 'GET /dedupe-total-data/export 导出' },
- { menuKey: 'admin_invalid_asin_data', file: 'src/pages/invalidasin/invalid-asin-api.ts', fn: 'fetchInvalidAsinPage', line: 'if (query.companyId != null) params.company_id = query.companyId', window: 400, title: 'GET /invalid-asin-data 列表(品牌数据库)' },
{ menuKey: 'admin_query_asin', file: 'src/pages/asin/query-asin-api.ts', fn: 'fetchQueryAsinList', line: 'if (params.companyId != null) query.company_id = params.companyId', window: 400, title: 'GET /query-asins 列表' },
{ menuKey: 'admin_query_asin', file: 'src/pages/asin/query-asin-export.ts', fn: 'buildQueryAsinExportParams', line: 'if (companyId != null) params.company_id = String(companyId)', window: 700, title: 'GET /query-asins/export 导出' },
{ menuKey: 'admin_skip_price_asin', file: 'src/pages/asin/skip-price-api.ts', fn: 'fetchSkipPriceList', line: 'if (params.companyId != null) query.company_id = params.companyId', window: 400, title: 'GET /skip-price-asins 列表(最低价 ASIN)' },
{ menuKey: 'admin_skip_price_asin', file: 'src/pages/asin/skip-price-export.ts', fn: 'buildSkipPriceExportParams', line: 'if (companyId != null) params.company_id = String(companyId)', window: 1000, title: 'GET /skip-price-asins/export 导出(本批新建:原先 href 不带任何参数=恒导全平台)' },
- { menuKey: 'admin_product_categories', file: 'src/pages/asin/product-category-api.ts', fn: 'fetchProductCategoryTree', line: 'if (companyId != null) params.company_id = companyId', window: 450, title: 'GET /product-categories 类目树' },
- { menuKey: 'admin_product_categories', file: 'src/pages/asin/product-category-api.ts', fn: 'searchProductCategories', line: 'if (companyId != null) params.company_id = companyId', window: 450, title: 'GET /product-categories/search 搜索' },
- { menuKey: 'admin_product_categories', file: 'src/pages/asin/product-category-api.ts', fn: 'fetchProductCategoryChildren', line: 'if (companyId != null) params.company_id = companyId', window: 450, title: 'GET /product-categories/children 懒加载子级' },
- { menuKey: 'admin_product_categories', file: 'src/pages/asin/product-category-export.ts', fn: 'buildProductCategoryExportUrl', line: 'if (companyId != null) params.push(`company_id=${companyId}`)', window: 400, title: 'GET /product-categories/export 导出(字符串拼接而非对象,锚整条 push)' },
// ↓ 批次 3 的两页(控制方 2026-10-05 点名「店铺撞款监控 店铺数据也要做隔离」)。
// 撞款三处各锚一个左值名(query/params/itemsQuery),店铺数据记录一处。
{ menuKey: 'admin_shop_data_duplicate_check', file: 'src/pages/tasks/duplicate-console-api.ts', fn: 'fetchDuplicateConsole', line: 'if (companyId != null) query.company_id = companyId', window: 400, title: 'GET /duplicate-check-console 指标/店铺/撞款全集/分组统计' },
@@ -111,6 +110,16 @@ const SEND_POINTS: ReadonlyArray = [
{ menuKey: 'admin_shop_data_crawl_tasks', file: 'src/pages/tasks/shop-data-api.ts', fn: 'fetchShopDataTaskList', line: 'if (companyId != null) query.company_id = companyId', window: 400, title: 'GET /shop-data-crawl-tasks 店铺数据记录列表' },
// ↓ 批次 4(控制方 2026-10-05 点名「菜单权限和用户管理也要区分公司 tab 的数据」)。
{ menuKey: 'admin_users', file: 'src/api/users.ts', fn: 'fetchUserList', line: 'if (params.companyId != null) query.company_id = params.companyId', window: 400, title: 'GET /users 用户列表(后端早就认这个参数,断的是前端没发)' },
+ // ↓ 批次 5(控制方 2026-10-06 点名「店铺密钥管理的数据按照公司区分」)。
+ { menuKey: 'admin_shop_keys', file: 'src/pages/shop/shop-key-api.ts', fn: 'fetchShopKeyList', line: 'if (params.companyId != null) query.company_id = params.companyId', window: 400, title: 'GET /shop-keys 紫鸟令牌列表(不带 company_id 时非超管仍由后端会话裁剪,超管点了 tab 才会变)' },
+ // ↓ 批次 6(控制方 2026-10-06 点名「菜单权限也加字段来区分,现在的默认归到 admin 下」,定案「每家公司一套树」)。
+ // 三处都锚同一串 TASK_CENTER_SEND_LINE,但分属两个文件 ⇒ (文件, 整行) 分组各成一组,钉数与条数仍逐处对平。
+ // 窗口取 300:两处 menu-manage 的 own 是 110/130,而 fetchMenuManageNodes 到 createMenu 那行的 next 是 611
+ // ⇒ 300 够得着自己、够不到隔壁(这三个数由下面「窗口与真文件对平」那条用例逐处从真文件重测,注释过期即红)。
+ // user-menu-auth-api 那处一条发送口喂两个 GET(admin/app 两类各一支,共用同一个 query 展开)⇒ 一函数一钉。
+ { menuKey: 'admin_columns', file: 'src/pages/account/menu-manage-api.ts', fn: 'fetchMenuManageNodes', line: TASK_CENTER_SEND_LINE, window: 300, title: 'GET /permission-menus 目录(超管不带就把两家的同名行混成一排下发)' },
+ { menuKey: 'admin_columns', file: 'src/pages/account/menu-manage-api.ts', fn: 'createMenu', line: TASK_CENTER_SEND_LINE, window: 300, title: 'POST /permission-menus 新建:归属由端点参数决定,前端不从树里猜' },
+ { menuKey: 'admin_users', file: 'src/pages/account/user-menu-auth-api.ts', fn: 'fetchGrantableMenus', line: TASK_CENTER_SEND_LINE, window: 300, title: 'GET /permission-menus?grantableOnly 授权树:一家一套树后取错公司=已授权勾不上、提交必判无效' },
]
/** 任务看板那 5 处(1b ④ 那条用例按文件筛它们,沿用旧名字不漂;表只有一份,不会漂出两个口径)。 */
@@ -206,17 +215,24 @@ const COMPANY_ID_SOURCE_PINS: Readonly>
note: '列表窄了而下拉不窄 = 两页口径对不上,且下拉能选到别家的组',
},
],
- // 批次 2 的五页:取值口钉全部由 SEND_POINTS 现算(一页几处发送口就几条钉),
+ // 批次 2 剩下的三页:取值口钉全部由 SEND_POINTS 现算(一页几处发送口就几条钉),
// 手写一份就会和表漂开——那正是复评 I-1 拆条要避免的形状。
+ // admin_invalid_asin_data / admin_product_categories 两页 2026-10-06 退回全平台共享,
+ // 已不在注册表里 ⇒ 这里的条目一并摘掉(留着是死表项,"不得回流"由文件末尾那条反向钉看守)。
admin_dedupe_total_data: pinsFor('admin_dedupe_total_data'),
- admin_invalid_asin_data: pinsFor('admin_invalid_asin_data'),
admin_query_asin: pinsFor('admin_query_asin'),
admin_skip_price_asin: pinsFor('admin_skip_price_asin'),
- admin_product_categories: pinsFor('admin_product_categories'),
// 批次 3 的两页同样由 SEND_POINTS 现算(撞款控制台三处发送口 = 三条钉)。
admin_shop_data_duplicate_check: pinsFor('admin_shop_data_duplicate_check'),
admin_shop_data_crawl_tasks: pinsFor('admin_shop_data_crawl_tasks'),
admin_users: pinsFor('admin_users'),
+ // 批次 5(店铺密钥)同样由 SEND_POINTS 现算:这一页只有一个发送口(列表),
+ // 新增/编辑/删除/白名单检测四支都不带公司参数——归属由后端从操作者会话推导(writeCompanyId 闸门)。
+ admin_shop_keys: pinsFor('admin_shop_keys'),
+ // 批次 6(菜单权限):菜单目录 + 新建两处,都由 SEND_POINTS 现算。
+ // 编辑/删除/重排三支**故意不带**参数——归属由那一行的 id 与操作者公司共同判定,跨公司写后端 403
+ // (见 docs/ops/menu-company-tree-design-2026-10-06.md §5),给它们发 company_id 反而是第三处口径。
+ admin_columns: pinsFor('admin_columns'),
}
/** 严格判据的分母由本轮实扫得出(修完不许恒绿也不许恒红):求值了几条 shape、其中几条通过。 */
@@ -303,11 +319,13 @@ test('正向:声明 companyScoped 的页,其 api 文件必须真的带 company
// 不许让另一支用例替我证明"这串本来就会被匹配到")。
// ⚠ 身份要说清:下面这几条是对**字面量字符串**求值的探针,只证明判据形状没写坏
// (正样本匹配得出 ⇒ 不恒红;窗口外的负样本不匹配 ⇒ 窗口真有界,删一处不会靠隔壁过关),
- // 任何代码注入都不会让它们红。真覆盖 = 上面 loop 里那 17 条 shape 对真实文件的求值 + 变异自证。
- // ⚠ 分母是本轮实扫的表条数(批次 1 的 5 + 批次 2 的 12 + 批次 3 的 4 + 批次 4 的 1)。这条只防"整表被摘空/被改窄",
- // 逐处脱管由下面两条(对平闸门 + 窗口对平)负责。
- assert.ok(SEND_POINTS.length >= 22,
- `发送口表只剩 ${SEND_POINTS.length} 条(批次 1+2+3+4 实扫 22 条)⇒ 有人把钉从表里摘了,取值口看守成空`)
+ // 任何代码注入都不会让它们红。真覆盖 = 上面 loop 里那批 shape(条数由 strictPinsEvaluated 当场自证)
+ // 对真实文件的求值 + 变异自证。
+ // ⚠ 分母是本轮实扫的表条数(批次 1 的 5 + 批次 2 的 7 + 批次 3 的 4 + 批次 4 的 1 + 批次 5 的 1 + 批次 6 的 3;
+ // 批次 2 原 12 条里的品牌库 1 条 + 商品类目 4 条随 2026-10-06「这两页退回全平台共享」摘掉)。
+ // 这条只防"整表被摘空/被改窄",逐处脱管由下面两条(对平闸门 + 窗口对平)负责。
+ assert.ok(SEND_POINTS.length >= 21,
+ `发送口表只剩 ${SEND_POINTS.length} 条(批次 1+2+3+4+5+6 实扫 21 条)⇒ 有人把钉从表里摘了,取值口看守成空`)
for (const p of SEND_POINTS) {
const shape = pointShape(p)
const compliant = pointCompliant(p)
@@ -330,7 +348,7 @@ test('正向:声明 companyScoped 的页,其 api 文件必须真的带 company
// 这一条杀的是「把 TASK_CENTER_SEND_POINTS 删剩 4 行」——少一条钉就等于少一处看守,而 5 条 shape 谁都不会红。
// 路线 ②(occurrences 计数)在这里只当"钉数与发送口条数对平"的闸门,不当"是哪一处"的判据:
// 计数回答不了"哪三处"(把一处重复写三遍、另一处删掉,计数照样对平),所以主判据仍是路线 ① 的函数名锚 + 有界窗口。
- // 分母按 (文件, 整行) 而不是按文件:批次 2 的 product-category-api.ts 一个文件三处发送口、三处是逐字同一行,
+ // 分母按 (文件, 整行) 而不是按文件:任务看板的 task-center.ts 一个文件三处发送口、三处是逐字同一行,
// 按文件计只钉得出"3 条"这个数,按行计才和 occurrences 同一粒度;三个 *-export.ts 的行各只出现 1 次,同理。
const grouped = new Map()
for (const p of SEND_POINTS) {
@@ -340,7 +358,7 @@ test('正向:声明 companyScoped 的页,其 api 文件必须真的带 company
else grouped.set(key, { file: p.file, line: p.line, pinned: 1 })
}
assert.equal(grouped.size, 17,
- `发送口表按 (文件, 整行) 应聚成 17 组(22 处发送口),现在却有 ${grouped.size} 组 —— 表被改形状了,对平判据失去分母`)
+ `发送口表按 (文件, 整行) 应聚成 17 组(21 处发送口),现在却有 ${grouped.size} 组 —— 表被改形状了,对平判据失去分母`)
for (const g of grouped.values()) {
const actual = occurrences(stripComments(read(g.file)), g.line)
assert.equal(g.pinned, actual,
@@ -357,7 +375,8 @@ test('正向:声明 companyScoped 的页,其 api 文件必须真的带 company
// own = 从 `function (` 的括号后到自己那一行的距离 ⇒ 必须 < window(函数体写长 = 假红,fail-closed 可接受);
// next = 到同文件**下一条同名发送行**开头的距离 ⇒ 存在时必须 > window(否则删一处还有隔壁顶着,这条钉就是摆设)。
// 隔壁的"名字"用的是自己的整行,所以 next 只在同文件有逐字同行的另一处时才有意义:
- // product-category-api.ts 三处同行(next 实测 705/929/无)是这一族唯一的真冲突面,其余 14 处 own 唯一。
+ // product-category-api.ts 那组(三处同行)2026-10-06 随「商品类目退回全平台共享」摘掉了;
+ // 这一族剩下的真冲突面只有任务看板:task-center.ts 三处逐字同行、task-center-model.ts 两处,其余各文件唯一。
for (const p of SEND_POINTS) {
const src = stripComments(read(p.file))
const anchor = 'function ' + p.fn + '('
@@ -477,6 +496,48 @@ test('发送口的第二实参:task-center 五处 http.get 必须把 query 交
}
})
+/**
+ * 1b ④ 的那一半缺口(批次 5 补,2026-10-06 变异自证 M9 实测存活):上面那支按**端点 URL 字面量**锚,
+ * 取样文件只有 `src/api/task-center.ts`。店铺密钥这一页的 GET 写的是 `http.get(SHOP_KEYS_ENDPOINT, { params: query })`
+ * ——端点是模块常量、调用还带泛型,那条正则两头都锚不到。把 `{ params: query }` 整段删掉后,
+ * `if (params.companyId != null) query.company_id = params.companyId` 那一行逐字还在 ⇒ 取值口五判据全绿、
+ * 编译器一声不响、URL 里没有 company_id:正是 1b ④ 当初要杀的那一形,只是换了一个文件。
+ *
+ * 判据换成「整行字面量 + 同文件 GET 总条数对平」:锚整行是因为常量名就是这一处的稳定身份,
+ * 对平是因为只钉一行的话,第二处新 GET 忘了带 params 也照样没人红(与上面「同一 URL 只许一处调用」同理)。
+ */
+const CONSTANT_ENDPOINT_GET_PINS: ReadonlyArray<{ readonly file: string; readonly fn: string; readonly call: string }> = [
+ { file: 'src/pages/shop/shop-key-api.ts', fn: 'fetchShopKeyList', call: 'http.get(SHOP_KEYS_ENDPOINT, { params: query })' },
+]
+
+test('非字面量端点的发送口:query 必须交给带 params 的第二实参,且同文件 GET 条数与登记表对平(1b ④ 的另一半)', () => {
+ assert.ok(CONSTANT_ENDPOINT_GET_PINS.length >= 1, '常量端点登记表为空 ⇒ 这一族的第二实参没人看守')
+ const byFile = new Map()
+ for (const p of CONSTANT_ENDPOINT_GET_PINS) byFile.set(p.file, (byFile.get(p.file) ?? 0) + 1)
+ for (const p of CONSTANT_ENDPOINT_GET_PINS) {
+ const src = stripComments(read(p.file))
+ // ① 判据自证(正样本):登记的那一行本身必须含 params,否则下面的对平是在钉一个坏形状。
+ assert.ok(p.call.includes(', { params'), `登记表里「${p.call}」不含 params 第二实参 ⇒ 这条判据恒红`)
+ // ② 判据自证(负样本):删掉第二实参后必须匹配不出自己,否则"带没带 params"都算过。
+ assert.equal(p.call.replace(', { params: query }', '').includes(p.call), false,
+ `删掉 { params: query } 之后「${p.call}」仍然自匹配 ⇒ 判据只看得到端点,杀不了这一记变异`)
+ // ③ 函数身份:这一处 GET 必须由它自己的函数发出。
+ assert.equal(occurrences(src, `function ${p.fn}(`), 1,
+ `${p.file} 里「function ${p.fn}(」出现 ${occurrences(src, `function ${p.fn}(`)} 次(要求 1):函数改名或被复制,这一行锚对不上是谁发的`)
+ // ④ 真文件求值:这一行必须逐字在场一次。
+ const hits = occurrences(src, p.call)
+ assert.equal(hits, 1,
+ `${p.file} 里带 params 实参的「${p.call}」匹配到 ${hits} 处(要求 1):`
+ + '0 处 = 发送口把 query 丢了(后端收不到 company_id、接口照旧 200、切 tab 一动不动),多于 1 处 = 有第二处同形调用没人钉')
+ }
+ // ⑤ 同文件 GET 总条数对平:新增一处 http.get 而没登记 ⇒ 当场红,不留"新那处还没人管"的默认分支。
+ for (const [file, pinned] of byFile) {
+ const src = stripComments(read(file))
+ const actual = occurrences(src, 'http.get')
+ assert.equal(actual, pinned,
+ `${file} 实扫到 ${actual} 处 http.get,登记表只有 ${pinned} 条 —— 有一处 GET 的第二实参没人看守`)
+ }
+})
test('反向:把 company_id 当查询参数用的取数模块必须被清单认领(防止"筛了但没人知道这页参与")', () => {
const claimed = new Set(COMPANY_SCOPED_PAGES.flatMap((p) => p.apiFiles))
const scanned = requestModules()
@@ -506,7 +567,7 @@ test('反向:把 company_id 当查询参数用的取数模块必须被清单
* 症状回到裁决 1 想避免的那一型。
*
* 判据形状:从 `watch(() => companyTab.activeId, …)` 那**一条语句**取文本(正则在第一个
- * `}` + `)` 处收口 ⇒ 单层,体内再嵌对象字面量会截早;表里这九页今天都没有那种写法,由下面的取样自检兜着)。
+ * `}` + `)` 处收口 ⇒ 单层,体内再嵌对象字面量会截早;表里这十页今天都没有那种写法,由下面的取样自检兜着)。
* 反向钉与正样本同支(全局约束 15,三条前提不成立就是探针失效、当场红,不许静默空跑),**每一对**都各跑一遍:
* ① 合规样本必须匹配得出且含两把 token ⇒ 判据不恒红;
* ② 删掉那一句的样本必须不含 ⇒ 判据能红(变异自证走的就是这一条);
@@ -521,7 +582,7 @@ test('反向:把 company_id 当查询参数用的取数模块必须被清单
const WATCH_ACTIVE_ID = /watch\(\(\)\s*=>\s*companyTab\.activeId\s*,\s*\(\)\s*=>\s*\{([\s\S]*?)\}\s*\)/
/**
- * (文件, 必须出现在 watch 体内的赋值) 九对,同一条 test 里逐对钉(批次 1 两对 + 批次 2 五对 + 批次 3 两对)。
+ * (文件, 必须出现在 watch 体内的赋值) 十对,同一条 test 里逐对钉(批次 1 两对 + 批次 2 三对 + 批次 3 两对 + 批次 4 一对 + 批次 5 一对 + 批次 6 一对)。
* `premise` 是这一对的反向钉前提:这一页的发送口今天还在发 `company_id`,清筛选项才有意义;
* 哪天发送口退回不带参,watch 看守就变成"清了一个没人用的筛选项",必须一起红。
*/
@@ -551,7 +612,8 @@ const WATCH_BODY_PINS: ReadonlyArray<{
{ file: 'src/pages/task-center/task-center-model.ts', shapes: [/company_id\s*=\s*companyId\b/] },
],
},
- // ↓ 批次 2 的五页(控制方 2026-10-05 点名「切 tab 数据还一样」那一批)。
+ // ↓ 批次 2 剩下的三页(控制方 2026-10-05 点名「切 tab 数据还一样」那一批;
+ // 品牌库、商品类目两页 2026-10-06 退回全平台共享,条目一并摘掉)。
// token 在两页上同形(`filter.groupId = null` 出现三次),这**不是**漏洞:判据按 (file, token) 成对求值,
// 每一对都各自去读它自己那一页的源码,别家页缺了这行不会红在这一页,反之这一页删掉了也不会被隔壁顶住
// (负样本 ③「挪到 watch 之外」钉的就是位置)。
@@ -563,14 +625,6 @@ const WATCH_BODY_PINS: ReadonlyArray<{
{ file: 'src/pages/asin/dedupe-total-api.ts', shapes: [/company_id\s*=\s*params\.companyId\b/] },
],
},
- {
- file: 'src/pages/asin/AsinInvalidPage.vue',
- token: 'filter.groupId = null',
- why: '品牌库的分组下拉按公司收窄,留着上一家的 groupId 就是拿一个新一家看不见的组去筛列表',
- premise: [
- { file: 'src/pages/invalidasin/invalid-asin-api.ts', shapes: [/company_id\s*=\s*query\.companyId\b/] },
- ],
- },
{
file: 'src/pages/asin/QueryAsinPage.vue',
token: "filter.groupId = null; filter.shopName = ''",
@@ -588,15 +642,6 @@ const WATCH_BODY_PINS: ReadonlyArray<{
{ file: 'src/pages/asin/skip-price-api.ts', shapes: [/company_id\s*=\s*params\.companyId\b/] },
],
},
- {
- file: 'src/pages/asin/ProductCategoryPage.vue',
- token: 'childrenState.clear()',
- why: '类目树是**懒加载缓存**:childrenState 里存着上一家每个父级的子页与页码,切公司不清它,展开同一父级就'
- + '直接把别家的子类目画出来(这一处根本不发请求,比"筛成空页"更静默)',
- premise: [
- { file: 'src/pages/asin/product-category-api.ts', shapes: [/company_id\s*=\s*companyId\b/] },
- ],
- },
// ↓ 批次 3 的两页(控制方 2026-10-05 点名「店铺撞款监控 店铺数据也要做隔离」)。
// 这两页的 token 一直写到 reload 那两句为止(批次 1/2 的老条目仍只钉清筛选项,不动它们):
// 变异自证发现「删掉 void loadConsole()」当时全绿——清筛选项那半守住了,重新取数那半没人守。
@@ -633,6 +678,28 @@ const WATCH_BODY_PINS: ReadonlyArray<{
{ file: 'src/api/users.ts', shapes: [/company_id\s*=\s*params\.companyId\b/] },
],
},
+ // ↓ 批次 5(控制方 2026-10-06 点名「店铺密钥管理的数据按照公司区分」)。
+ {
+ file: 'src/pages/shop/ShopKeysPage.vue',
+ token: "filterKeyword.value = ''; page.value = 1; void load()",
+ why: '这一页的「备注名 / 紫鸟账号」是客户端过滤(filteredRows 在本页 rows 上筛,不进请求):'
+ + '留着上一家填的关键字,切到新一家就是拿别家的字符串去筛本公司那几行 ⇒ 首屏「暂无符合条件的密钥」而筛选框里还显示着它;'
+ + '页码回 1 是因为新一家的令牌更少,末尾的 void load() 才让切 tab 真的换数据',
+ premise: [
+ { file: 'src/pages/shop/shop-key-api.ts', shapes: [/company_id\s*=\s*params\.companyId\b/] },
+ ],
+ },
+ // ↓ 批次 6(控制方 2026-10-06 点名「菜单权限也加字段来区分」,定案「每家公司一套树」)。
+ {
+ file: 'src/pages/account/MenusPage.vue',
+ token: "filterName.value = ''; filterType.value = ''; page.value = 1; void loadMenus()",
+ why: '菜单名称/类型是客户端筛选(filteredMenuRows 在本页已取的 rows 上筛,不进请求):留着上一家填的值'
+ + '就是拿别家的字符串去筛新一家那一套树 ⇒ 首屏「暂无匹配菜单」,而输入框里还显示着那个值。页码回 1 是因为'
+ + '新一家的行数不同,末尾的 void loadMenus() 才是本页唯一的数据出口',
+ premise: [
+ { file: 'src/pages/account/menu-manage-api.ts', shapes: [/company_id\s*=\s*companyId\b/] },
+ ],
+ },
]
/** 取「`watch(() => companyTab.activeId, () => { … })`」这一条语句的原文;匹配不出返回 null(由调用方判探针失效)。 */
@@ -641,9 +708,9 @@ function watchStatement(source: string): string | null {
return m ? m[0] : null
}
-test('切公司的 watch 体:每对 (file, token) 都要在该页 watch 体内出现(批次 1 两页 + 批次 2 五页 + 批次 3 两页 + 批次 4 一页)', () => {
+test('切公司的 watch 体:每对 (file, token) 都要在该页 watch 体内出现(批次 1 两页 + 批次 2 三页 + 批次 3 两页 + 批次 4 一页 + 批次 5 一页 + 批次 6 一页)', () => {
assert.ok(WATCH_BODY_PINS.length >= 10,
- `watch 体看守只剩 ${WATCH_BODY_PINS.length} 对(批次 1 的店铺管理/任务看板 + 批次 2 的去重库/品牌库/查询ASIN/最低价ASIN/商品类目 + 批次 3 的撞款监控/店铺数据记录 + 批次 4 的用户管理共 10 对)`
+ `watch 体看守只剩 ${WATCH_BODY_PINS.length} 对(批次 1 的店铺管理/任务看板 + 批次 2 的去重库/查询ASIN/最低价ASIN + 批次 3 的撞款监控/店铺数据记录 + 批次 4 的用户管理 + 批次 5 的店铺密钥 + 批次 6 的菜单管理共 10 对)`
+ '⇒ 这一族又退回"只钉少数几页",被摘掉那一页的"切公司不清筛选项"再次没人看守')
const pinnedFiles = new Set(WATCH_BODY_PINS.map((pin) => pin.file))
for (const pin of WATCH_BODY_PINS) {
@@ -810,3 +877,108 @@ test('挂载与单一尺子:tab 条挂在壳层、公司名读 companyName、
assert.match(tabs, /initialize\(\)\.catch\(/,
'组件侧必须 .catch 接住 store 的 rethrow,否则又变回 unhandled rejection')
})
+
+test('渲染范围:tab 条只画在按公司取数的页上,公司管理那排点了没反应的 tab 摘掉', () => {
+ // 2026-10-06 控制方:「公司管理不要有 tab」。10-05 那一轮只钉住了「CompaniesPage 不消费 store」
+ // (company-config-entry-super-only 最后那条),而 tab 条本身挂在壳层 AdminLayout、对全部页都画
+ // ⇒ 界面一个字都没变,同一天被第二次点名。这条补的是**渲染侧**那一半。
+ // 判据取 COMPANY_SCOPED_PAGES 这一张注册表:写黑名单的话,下一个新页默认长出一条装饰 tab。
+ const pageKeys = adminPages.map((p) => p.menuKey)
+ assert.ok(pageKeys.length >= 22, `路由注册表只取到 ${pageKeys.length} 页 ⇒ 分母被删空,下面的差集会假绿`)
+ const scoped = new Set(COMPANY_SCOPED_PAGES.map((p) => p.menuKey))
+ const unscoped = pageKeys.filter((k) => !scoped.has(k))
+ assert.ok(scoped.size >= 15, `注册表只剩 ${scoped.size} 页 ⇒ 正向那半的循环没东西可验`)
+ assert.ok(unscoped.includes('admin_companies'),
+ 'admin_companies 竟在公司 tab 注册表里:与「公司管理仅超管、不做 tab」直接冲突')
+
+ const model = stripComments(readSource('src/layout/company-tab-model.ts'))
+ assert.match(model, /new Set\(COMPANY_SCOPED_PAGES\.map/,
+ 'companyTabAppliesTo 必须从 COMPANY_SCOPED_PAGES 派生,不是另立一张名单')
+ assert.equal(model.includes("'admin_companies'"), false,
+ '渲染判据里不许写死菜单名:那是第二张清单,与注册表迟早漂移')
+
+ // 真值双向:注册表内 ⇒ 画(漏了就是取值口与渲染口分家),注册表外每一页 ⇒ 不画(点了不重取数)
+ for (const key of scoped) assert.equal(companyTabAppliesTo(key), true, `${key} 在注册表里却不画 tab`)
+ for (const key of unscoped) assert.equal(companyTabAppliesTo(key), false, `${key} 没接公司隔离却画着 tab`)
+ assert.equal(companyTabAppliesTo(undefined), false, '没有 menuKey 的开放页(登录页等)默认不画')
+
+ // 组件真把这一条串进了 show:只导出函数不接线=这条护栏恒绿
+ const tabs = stripComments(readSource('src/layout/CompanyTabs.vue'))
+ const showLine = tabs.split('\n').find((line) => line.includes('const show ='))
+ assert.ok(showLine, 'CompanyTabs.vue 找不到 `const show =` 这一行:渲染开关换写法了,先确认它还在不在')
+ assert.ok(showLine.includes('tab.visibleForOperator'), 'show 少了「目录可用」那条')
+ assert.ok(showLine.includes('companyTabAppliesTo(route.meta.menuKey)'),
+ 'show 少了「这一页吃公司」那条 ⇒ 退回全页画 tab,公司管理页头顶又会长出那一排')
+})
+
+/**
+ * 2026-10-06 控制方定案:品牌数据库、商品类目「做成所有公司共享的,不区分」。
+ *
+ * 上面那几条正向判据全是从 {@code COMPANY_SCOPED_PAGES} 派生的,页一退出注册表就自动不再求值 ⇒
+ * 「退出」这件事本身没有看守:谁把 {@code company_id} 重新塞回这三个取数口,全仓用例一支都不会红,
+ * 而后端唯一键已经退回全局(V151),带公司参数的读会把共享库筛窄成「只看这一家」,
+ * 写侧则把一张全平台共享的表按家拆开——两边都是静默改口径,不是报错。所以这一支必须存在。
+ *
+ * 判据只认「剥完注释的代码」:这三份文件现在各自留有一句说明共享口径的注释,
+ * 注释里的 {@code company_id} 三个字面字符不是接线(全局约束 6)。正样本用摘掉之前那三行原文,
+ * 所以下面的 false 是测出来的,不是「正则本来就抓不到」。
+ */
+const SHARED_PAGE_KEYS = ['admin_invalid_asin_data', 'admin_product_categories'] as const
+const SHARED_API_FILES = [
+ 'src/pages/invalidasin/invalid-asin-api.ts',
+ 'src/pages/asin/product-category-api.ts',
+ 'src/pages/asin/product-category-export.ts',
+] as const
+const SHARED_PAGE_FILES = [
+ 'src/pages/asin/AsinInvalidPage.vue',
+ 'src/pages/asin/ProductCategoryPage.vue',
+] as const
+
+/** 公司参数的两种写法:下传用的 snake、形参/字段用的 camel。 */
+const COMPANY_PARAM_TOKEN = /(?:company_id|companyId)/
+
+/** 本次摘掉的三行原发送口(逐字取自改动前的源码),做反向钉的同支正样本。 */
+const FORMER_SEND_LINES = [
+ 'if (query.companyId != null) params.company_id = query.companyId',
+ 'if (companyId != null) params.company_id = companyId',
+ 'if (companyId != null) params.push(`company_id=${companyId}`)',
+]
+
+test('公司维度不得回流:品牌库与商品类目已定案全平台共享,取数口与页面都不许再带公司参数', () => {
+ // 判据自证(全局约束 15:反向钉不许独自成立)——改动前那三行必须抓得到,否则下面的 false 是空判据。
+ for (const line of FORMER_SEND_LINES) {
+ assert.ok(COMPANY_PARAM_TOKEN.test(line), `反向钉判据连原来的发送口「${line}」都匹配不出 ⇒ 这一族恒绿`)
+ }
+ // watch 探针同理:它今天还在 WATCH_BODY_PINS 那十对上起作用,这里再就地复验一次形状,
+ // 免得「页面里没有 watch」是因为正则换了写法而失明。
+ assert.ok(WATCH_ACTIVE_ID.test('watch(() => companyTab.activeId, () => { void load() })'),
+ 'WATCH_ACTIVE_ID 连合规样本都匹配不出 ⇒ 下面「不许再长出 watch」那条恒绿')
+ // 注册表本身非空自证:表被删空时 some() 会对所有 key 返回 false,看着像「都退出了」。
+ assert.ok(COMPANY_SCOPED_PAGES.length >= 15,
+ `注册表只剩 ${COMPANY_SCOPED_PAGES.length} 页 ⇒ 分母被删空,下面的 some() 会假绿`)
+
+ for (const key of SHARED_PAGE_KEYS) {
+ assert.equal(COMPANY_SCOPED_PAGES.some((p) => p.menuKey === key), false,
+ `${key} 又回到 COMPANY_SCOPED_PAGES:2026-10-06 已定案这两页全平台共享,不区分公司`)
+ const page = adminPages.find((p) => p.menuKey === key)
+ assert.ok(page, `${key} 在路由注册表里找不到:菜单名改了,反向钉对不上页`)
+ assert.equal(page.companyScoped, false,
+ `${key} 的 meta.companyScoped 不再是 false:tab 条会画出来,而这一页的取数口没有公司参数 ⇒ 点了没反应)`)
+ }
+
+ for (const file of [...SHARED_API_FILES, ...SHARED_PAGE_FILES]) {
+ const src = stripComments(read(file))
+ assert.equal(COMPANY_PARAM_TOKEN.test(src), false,
+ `${file} 又出现了公司参数:这两页读的是全平台共享的库,带上 company_id 等于把共享口径偷偷改回按家筛`)
+ assert.ok(COMPANY_PARAM_TOKEN.test(`${src}\n${FORMER_SEND_LINES[0]}`),
+ `(同支正样本)${file} 的源码喂进判据后连拼上原发送口都匹配不出 ⇒ 上面那条 false 无从判定`)
+ }
+
+ for (const file of SHARED_PAGE_FILES) {
+ const src = stripComments(read(file))
+ assert.equal(WATCH_ACTIVE_ID.test(src), false,
+ `${file} 又 watch 了 companyTab.activeId:这一页不按公司取数,切 tab 重取数只会把用户正在看的页刷掉`)
+ assert.equal(/useCompanyTabStore|companyTab\.requestCompanyId/.test(src), false,
+ `${file} 重新引回了公司 tab store,而它对应的 tab 条已经摘掉`)
+ }
+})
diff --git a/backend-java/docs/migration-inventory.md b/backend-java/docs/migration-inventory.md
index 55216c2e3..c026f5a03 100644
--- a/backend-java/docs/migration-inventory.md
+++ b/backend-java/docs/migration-inventory.md
@@ -1,16 +1,17 @@
# Flyway 迁移盘点(task-193)
> 生成方式:`src/test/java/com/nanri/aiimage/config/MigrationInventoryTest.java`(只读审计,可重复)。
-> 快照日期:2026-10-01;2026-10-03 随 V142 追加时同步过概览数字与取号起点;2026-10-04 随 V143 同步;2026-10-04 随 V144 同步;2026-10-04 15:1x 随 V145 同步;2026-10-05 随 V146 同步;2026-10-05 23:0x 随 V147 同步。
+> 快照日期:2026-10-01;2026-10-03 随 V142 追加时同步过概览数字与取号起点;2026-10-04 随 V143 同步;2026-10-04 随 V144 同步;2026-10-04 15:1x 随 V145 同步;2026-10-05 随 V146 同步;2026-10-05 23:0x 随 V147 同步;2026-10-06 随 V148 同步(并把 V145/V146/V147 从"待发版"挪进"已应用");2026-10-06 随 V149 同步(菜单树按公司一套;V148 仍未上线,故 V149 与它同批);2026-10-06 随 V150/V151 同步,并删掉未上线的 V148(该号就此退役,见下)。
## 概览
-- 版本化迁移文件数:**146**(`src/main/resources/db/V*.sql`,其中整数版本 145 个 + 小版本 V25_1)
-- 整数版本范围:**V1..V147**,其中 V132/V133 为已退役空号(见下),其余连续
+- 版本化迁移文件数:**149**(`src/main/resources/db/V*.sql`,其中整数版本 148 个 + 小版本 V25_1)
+- 整数版本范围:**V1..V151**,其中 V132/V133/V148 为已退役空号(见下),其余连续
- 历史遗留小版本:**V25_1__shop_manage_group_bind_user.sql**(Flyway 语义 25.1,紧跟在 V25 之后、V26 之前执行,属历史命名,保留)
-- 最新版本:**V147__product_category_company_scope.sql**(上一版 **V146__users_expires_at_admin_expiry.sql**,再上一版 **V145__brand_dedupe_company_scope.sql**)
-- 待下一次 jar 发版执行的三条:`V145__brand_dedupe_company_scope.sql`、`V146__users_expires_at_admin_expiry.sql`、`V147__product_category_company_scope.sql`
-- 已应用:V142(10-03 18:23)、V143(10-04 10:48)、**V144(10-04 13:22)**
+- 最新版本:**V151__rule_tables_shared_across_companies.sql**(上一版 **V150__shop_key_company_scope.sql**,再上一版 **V149__permission_menu_company_tree.sql**)
+- 待下一次 jar 发版执行的三条(按序):`V149__permission_menu_company_tree.sql`、`V150__shop_key_company_scope.sql`、`V151__rule_tables_shared_across_companies.sql`
+- 已应用:V142(10-03 18:23)、V143(10-04 10:48)、**V144(10-04 13:22)**、`V145__brand_dedupe_company_scope.sql`(10-05 13:01)、`V146__users_expires_at_admin_expiry.sql`(10-05 13:01)、**`V147__product_category_company_scope.sql`(10-06 11:03)**
+ - 末段 `flyway_schema_history` 为 2026-10-06 主机A 只读实查(`success` 全 1,最大整数版本 147),不是从 jar 版本推的
- 重复版本:无
- 迁移命名:全部符合 `V<整数>(_<子版本>)?__<描述>.sql`,无空格
@@ -18,11 +19,23 @@
生产 `flyway_schema_history` 末段:V125..V131 之后直接是 **V134__publish_item_free_text_columns**、**V135__dedupe_total_data_wide_columns**(两条 `installed_on` 均为 2026-09-25 20:46:16),库内没有 132/133 记录。
-## V132/V133 空号的来历
+## 空号的来历(V132/V133/V148)
本地曾存在 `V132__web_config_add_is_latest.sql`、`V133__hide_redundant_indexes_invisible.sql`,与另一分支已在生产落库的 V134/V135 冲突。因 Flyway 未开启 `out-of-order`,把任何迁移编到 132/133 会在启动期报 "resolved migration not applied";因此这两条改为 **V136/V137**,132/133 永久退役,不可回填。
-后续新增迁移从 **V148** 起取号(只认"当前最大值 + 1",不要为还没写出来的迁移预留号段——预留会在 1..max 里留洞,`integerVersionsSequentialFromOne` 会红)。V148 的第一件已知待办就是摘掉 `biz_product_category.company_id` 的 DEFAULT(一条 `ALTER … ALTER COLUMN company_id DROP DEFAULT`,禁 MODIFY),前提是同批 jar 已双节点上线且写侧都显式落公司。
+`V148__product_category_builtin_owned_by_company.sql`(把 18 行内置类目的归属从共享哨兵 0 改成厦门米椿花 1)从未上线,2026-10-06 控制方点名「商品类目做成共享的,不区分」⇒ 它的口径被 V151 整体推翻,文件连同 `ProductCategoryMigrationV148Test`、`docs/rollback-V148-product-category-builtin-shared.sql` 一起删除。它与 132/133 的区别要写清:**把新迁移编号写回 148 在 Flyway 语义上是可行的**(生产最大值仍是 147,不存在 out-of-order),这里禁它是共树并发的护栏——148 与 149/150 是同一工作区里另一路会话此刻正在引用的号,被删的 `V148` 文件可能被再次写出,而同号两个文件会让 Flyway 启动期报 "Found more than one migration with version 148" ⇒ 两台 java 同时起不来。宁可让 `integerVersionsSequentialFromOne` 的红字出现在测试里,也不把撞号留到运行期发现。因此这三个号都在 `MigrationInventoryTest.RETIRED_HOLES` 里登记。
+
+后续新增迁移从 **V152** 起取号(只认"当前最大值 + 1",不要为还没写出来的迁移预留号段——预留会在 1..max 里留洞,`integerVersionsSequentialFromOne` 会红;也不要回填上面那三个洞)。原先挂在 V149 名下的"摘 DEFAULT"待办,现在只剩一条元数据操作:
+
+- `ALTER TABLE columns ALTER COLUMN company_id DROP DEFAULT;` —— 前提:V149 那版 jar 两台同版(`PermissionMenuService` 的所有建/改菜单出口都显式写 companyId),旧 jar 已不可能再靠 DEFAULT 兜住插行。
+
+**`biz_product_category.company_id` 的 DEFAULT 由"待摘"改成"必须保留"**(这一条与 V151 同批生效):V151 之后新 jar 的 INSERT 列清单不含 `company_id`,而该列是 `NOT NULL`,全靠 `DEFAULT 1` 满足——此时执行 `DROP DEFAULT` 会让每一次新建类目报 1364。`biz_invalid_asin_data.company_id` 同理(品牌库那条写入失败还会被 `CollectDataInvalidAsinBatchWriter` 吞成 `log.warn` ⇒ 接口返回成功而黑名单静默少一批)。所以这两张表已从 `CompanyDefaultGuard.WATCHED_TABLES` 与探针 SQL 的 IN 列表里同时摘掉(清单与 SQL 由 `CompanyDefaultGuardTest` 双向钉同源),否则哨兵会在每次启动时对着一列"没人读、摘了会炸"的默认值喊 `COMPANY_DEFAULT_STILL_PRESENT`,而巡检把那条签名计进 ALERTS。
+它们真正消失的时点是下一版(两台同版之后):
+
+- `ALTER TABLE biz_invalid_asin_data DROP COLUMN company_id;`
+- `ALTER TABLE biz_product_category DROP COLUMN company_id;`
+
+摘除 DEFAULT 的动作在这两条里"顺带完成"(列没了,默认值随之消失),**仍然禁写成 `MODIFY COLUMN ... NOT NULL`**(重建表会按当时的列默认值物化历史行)。`biz_dedupe_total_data` 与 `biz_shop_key` 不在此列:它们仍然按公司写,DEFAULT 该摘还是要摘,哨兵继续盯。
原先挂在待办里的"V137 冗余索引 DROP"迁移计划取 V139,该号已被 `V139__asin_result_cache.sql` 占用,顺延到 V140;V140 已被品牌补测队列表 `V140__collectdata_brand_recheck.sql` 落用。
diff --git a/backend-java/docs/rollback-V149-permission-menu-company.sql b/backend-java/docs/rollback-V149-permission-menu-company.sql
new file mode 100644
index 000000000..6240f1f86
--- /dev/null
+++ b/backend-java/docs/rollback-V149-permission-menu-company.sql
@@ -0,0 +1,149 @@
+-- =============================================================
+-- 回滚补丁 V149__permission_menu_company_tree(人工执行,故意放在 Flyway 扫描路径之外)
+-- 对应迁移:src/main/resources/db/V149__permission_menu_company_tree.sql
+-- 设计:crawler-plugin/docs/ops/menu-company-tree-design-2026-10-06.md §9
+--
+-- 【为什么不是 V150】src/main/resources/db/ 是 Flyway 扫描路径,任何 V*.sql 都会在应用下次启动时
+-- 自动执行。把回滚编成版本化迁移,等于让"决定回滚"这件事在没有人工执行的情况下自己发生。
+--
+-- 【执行顺序,一步不能换】
+-- 1) 停两台 java(/api 经主机 B 的 clb 打到两台,留一台跑旧 jar 会让回滚中途被写入)
+-- 2) 先跑第 0 段的两个 COUNT,把数记下来 —— 第 3 段判据要用它
+-- 3) 跑本脚本(第 1..7 段)
+-- 4) 删 flyway_schema_history 的 version=149 行(第 8 段;漏掉这步,将来重装时 Flyway
+-- 见"已应用"会跳过 V149,回滚就白做了一半)
+-- 5) 回滚 jar 到与本批不兼容的上一版(即只认 V147 及更早、columns 还没有 company_id 的那版构建;
+-- V148 是已退役空号,不存在对应 jar —— 号位以 docs/migration-inventory.md 为准)
+-- 6) 起应用
+--
+-- 【顺序上的唯一陷阱:必须先重指授权、后删副本】
+-- user_column_permission 的 FK 是 ON DELETE CASCADE:直接 DELETE 副本行会把它名下所有授权
+-- 一起删光 —— 而 V149 之后账号名下"本来就该"挂的是副本行。所以第 2 段先按 column_key 把指针
+-- 挪回公司 1 的源行,第 3 段才敢删副本。这两段写反 = 把 133 只账号的菜单全清掉。
+-- =============================================================
+
+-- ---------- 0. 回滚前取证(只读,先把这两个数抄下来) ----------
+
+-- 0a 副本行数(V149 后应 = 公司数-1 家 × 51)
+SELECT 'V149_ROLLBACK_PRE copy_rows' AS marker, COUNT(*) AS rows_to_delete
+FROM `columns` WHERE company_id <> 1;
+
+-- 0b 挂在副本上的授权数(这些是回滚后必须回到源行的那批)
+SELECT 'V149_ROLLBACK_PRE grants_on_copies' AS marker, COUNT(*) AS grants_to_repoint
+FROM `user_column_permission` g
+JOIN `users` u ON u.id = g.user_id
+JOIN `columns` c ON c.id = g.column_id
+WHERE c.company_id <> 1;
+
+-- ---------- 1. 备份(两张都整表抄,回滚失败时按 <表名>_bak_v149_rollback 反插) ----------
+-- 必须显式建、不要依赖 mysqldump:这两张表小(52+ 行 / 784 行),同库内备份是秒级,
+-- 而"删完才发现判据错"的唯一出路就是这里有原样一份。
+
+CREATE TABLE IF NOT EXISTS `columns_bak_v149_rollback` AS SELECT * FROM `columns`;
+CREATE TABLE IF NOT EXISTS `user_column_permission_bak_v149_rollback` AS SELECT * FROM `user_column_permission`;
+
+-- ---------- 2. 授权指针挪回公司 1 的源行 ----------
+
+-- 2a 先去重:同一账号若同时挂着源行与副本(正常不会有,属 repair 中途态),删副本那一侧,
+-- 留源行那一侧给 2b 判定,避免 2b 撞 PK (user_id, column_id) 报 1062。
+DELETE dup FROM `user_column_permission` dup
+ JOIN `users` u ON u.id = dup.user_id
+ JOIN `columns` copy ON copy.id = dup.column_id AND copy.company_id = u.company_id
+ JOIN `columns` src ON src.id <> copy.id AND src.column_key = copy.column_key AND src.company_id = 1
+ JOIN `user_column_permission` old ON old.user_id = dup.user_id AND old.column_id = src.id;
+
+-- 2b 重指回源行。
+UPDATE `user_column_permission` g
+ JOIN `columns` copy ON copy.id = g.column_id AND copy.company_id <> 1
+ JOIN `columns` src ON src.company_id = 1 AND src.column_key = copy.column_key
+ SET g.column_id = src.id;
+
+-- 2c 闸门:此时绝不允许再有"授权指向非 1 公司的行"。不为 0 就是 2b 漏了行,
+-- 下一步的 CASCADE 会把它们静默删掉 —— 宁可这里报错停下,也不要少一批菜单而没人知道。
+CREATE TEMPORARY TABLE `_v149_rb_gate` (`must_be_zero` INT NOT NULL);
+INSERT INTO `_v149_rb_gate`
+SELECT IF(COUNT(*) = 0, 0, NULL)
+FROM (
+ SELECT g.user_id FROM `user_column_permission` g
+ JOIN `columns` c ON c.id = g.column_id
+ WHERE c.company_id <> 1
+) bad;
+DROP TEMPORARY TABLE `_v149_rb_gate`;
+
+-- ---------- 3. 删副本 ----------
+
+DELETE FROM `columns` WHERE company_id <> 1;
+
+-- ---------- 4. 换回两条全平台唯一键(副本已删,源行本来就唯一 ⇒ 不会因重复失败) ----------
+
+SET @db_name = DATABASE();
+
+SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
+ WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns' AND INDEX_NAME = 'uk_column_key');
+SET @sql := IF(@idx_exists = 0,
+ 'ALTER TABLE `columns` ADD UNIQUE KEY `uk_column_key` (`column_key`)',
+ 'SELECT 1');
+PREPARE stmt FROM @sql;
+EXECUTE stmt;
+DEALLOCATE PREPARE stmt;
+
+SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
+ WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns' AND INDEX_NAME = 'uk_menu_type_route_path');
+SET @sql := IF(@idx_exists = 0,
+ 'ALTER TABLE `columns` ADD UNIQUE KEY `uk_menu_type_route_path` (`menu_type`, `route_path`)',
+ 'SELECT 1');
+PREPARE stmt FROM @sql;
+EXECUTE stmt;
+DEALLOCATE PREPARE stmt;
+
+-- ---------- 5. 摘掉两条按公司的新键 ----------
+
+SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
+ WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns' AND INDEX_NAME = 'uk_company_column_key');
+SET @sql := IF(@idx_exists = 1, 'ALTER TABLE `columns` DROP INDEX `uk_company_column_key`', 'SELECT 1');
+PREPARE stmt FROM @sql;
+EXECUTE stmt;
+DEALLOCATE PREPARE stmt;
+
+SET @idx_exists := (SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
+ WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns'
+ AND INDEX_NAME = 'uk_company_menu_type_route_path');
+SET @sql := IF(@idx_exists = 1, 'ALTER TABLE `columns` DROP INDEX `uk_company_menu_type_route_path`', 'SELECT 1');
+PREPARE stmt FROM @sql;
+EXECUTE stmt;
+DEALLOCATE PREPARE stmt;
+
+-- ---------- 6. 删列 ----------
+
+SET @col_exists := (SELECT COUNT(*) FROM information_schema.COLUMNS
+ WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'columns' AND COLUMN_NAME = 'company_id');
+SET @sql := IF(@col_exists = 1, 'ALTER TABLE `columns` DROP COLUMN `company_id`', 'SELECT 1');
+PREPARE stmt FROM @sql;
+EXECUTE stmt;
+DEALLOCATE PREPARE stmt;
+
+-- ---------- 7. 复验(三条读数抄进回滚记录) ----------
+
+-- 列已删(应 0 行)
+SELECT 'V149_ROLLBACK_POST company_col' AS marker, COUNT(*) AS col_still_there
+FROM information_schema.COLUMNS
+WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'columns' AND COLUMN_NAME = 'company_id';
+
+-- 两条旧键在、两条新键没了(应恰好 4 行且 NON_UNIQUE 全 0)
+SELECT 'V149_ROLLBACK_POST indexes' AS marker, INDEX_NAME,
+ GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) AS cols, NON_UNIQUE
+FROM information_schema.STATISTICS
+WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'columns' AND NON_UNIQUE = 0
+GROUP BY INDEX_NAME, NON_UNIQUE;
+
+SELECT 'V149_ROLLBACK_POST rows' AS marker, COUNT(*) AS rows_now FROM `columns`;
+SELECT 'V149_ROLLBACK_POST grants' AS marker, COUNT(*) AS grants_now FROM `user_column_permission`;
+
+-- ---------- 8. 删 Flyway 历史行(漏掉 = 重装时 V149 被跳过) ----------
+
+DELETE FROM `flyway_schema_history` WHERE `version` = '149';
+
+-- ---------- 9. 回滚后的语义,写明别当 bug ----------
+-- 公司 2 的 2 只账号回到 V149 之前的状态:授权挂在公司 1 的行上,两家共用一棵树。
+-- 跨公司串扰因此重新发生(这本来就是回滚的代价),而 columns 表回到全平台唯一键。
+-- 备份表 columns_bak_v149_rollback / user_column_permission_bak_v149_rollback 确认无误后手工 DROP。
diff --git a/backend-java/docs/rollback-V150-shop-key-company.sql b/backend-java/docs/rollback-V150-shop-key-company.sql
new file mode 100644
index 000000000..50fde1068
--- /dev/null
+++ b/backend-java/docs/rollback-V150-shop-key-company.sql
@@ -0,0 +1,38 @@
+-- 回滚 V150(人工补丁,不放进 src/main/resources/db/——那里是 Flyway 扫描路径,
+-- 任何 V*.sql 都会在应用下次启动时自动执行;把回滚编成版本化迁移等于让"决定回滚"这件事
+-- 在没有人工执行的情况下自己发生。)
+--
+-- 顺序:停两台应用 → 执行本脚本 → DELETE FROM flyway_schema_history WHERE version='150'
+-- → 回滚 jar → 起应用。
+-- 漏掉"删历史行"那步,将来重装带 V150 的 jar 时 Flyway 判定"已应用"直接跳过重建,
+-- 而 Java 侧实体照常读写 company_id ⇒ 运行期 Unknown column。
+--
+-- 【本版本没有唯一键要退】V150 刻意不动 uk_ziniao_token_hash(理由见迁移文件头注释第 4 段:
+-- 同一个紫鸟令牌在两家公司各存一行会被 ZiniaoApiKeyProvider 按令牌并成一条,白名单状态与代理互相顶掉),
+-- 所以这里没有 V147 那种"先加旧键后删新键"的第 1 段,也没有 1062 预检。
+--
+-- ---------- 0. 预检:这一列上到底有几家公司的行 ----------
+-- SELECT company_id, COUNT(*) AS rows_per_company
+-- FROM `biz_shop_key`
+-- GROUP BY company_id
+-- ORDER BY company_id;
+-- -> 只有一行(company_id=1):说明批次上线后没有第 2 家建过密钥,第 1 段 DROP 掉的只是"全 1"这一列,
+-- 损失可忽略。
+-- -> 出现 company_id<>1:第 2 家已经在这一列上登记过自己的令牌归属。此时【不要】DROP COLUMN——
+-- 这张表没有任何账号列,归属删掉就再也分不回去(V150 §2 写明了这个不可逆点)。
+-- 改走第 2 段"只回滚 jar、保留新列"。
+--
+-- ---------- 1. 把列也删掉才解开下面这行(不可逆,先备份) ----------
+-- ALTER TABLE `biz_shop_key` DROP COLUMN `company_id`;
+--
+-- ---------- 2. 默认档:保留新列,只回滚 jar ----------
+-- 旧 jar 的 ShopKeyEntity 没有 companyId 字段,MyBatis-Plus 的 insert 列清单不含它 ⇒
+-- 这一列对旧 jar 是惰性的:不读写就不影响,而 DEFAULT 1 正好把旧 jar 插入的行接住。
+-- 所以真要止损时,这一档比删列安全得多,也是第 0 段查出多家公司时的唯一走法。
+-- (代价:混合窗口里旧 jar 建的密钥会静默归进第 1 家——这与 V150 上线之前没有任何区别,
+-- 不是回滚引入的新问题。)
+--
+-- ALTER TABLE `biz_shop_key` ALTER COLUMN company_id DROP DEFAULT;
+-- ↑ 这一句【不属于回滚】。它是"摘 DEFAULT"那笔前向修复的内容(V150 §6)。
+-- 任何时候都不要写 MODIFY COLUMN ... NOT NULL:重建表会按"当时的列默认值"物化历史行,
+-- 而 V150 没有写回历史行,历史归属的全部依据就是那个默认值。
diff --git a/backend-java/docs/rollback-V151-rule-tables-shared.sql b/backend-java/docs/rollback-V151-rule-tables-shared.sql
new file mode 100644
index 000000000..59ef95268
--- /dev/null
+++ b/backend-java/docs/rollback-V151-rule-tables-shared.sql
@@ -0,0 +1,69 @@
+-- 回滚 V151(人工补丁,不放进 src/main/resources/db/——那里是 Flyway 扫描路径,
+-- 任何 V*.sql 都会在应用下次启动时自动执行;把回滚编成版本化迁移等于让"决定回滚"这件事
+-- 在没有人工执行的情况下自己发生。)
+--
+-- 顺序:停两台应用 → 执行本脚本 → DELETE FROM flyway_schema_history WHERE version='151'
+-- → 回滚 jar(回到仍按公司筛的那版)→ 起应用。
+-- 漏掉"删历史行"那步,将来重装带 V151 的 jar 时 Flyway 判定"已应用"直接跳过,两把公司键不再重建,
+-- 而回滚后的 jar 的读侧谓词是 company_id = X ⇒ 表现为"读得到但写同名值被 IGNORE 掉",不报错。
+--
+-- 回滚方向 = 把两把公司键加回来。加回来之前必须先回滚 jar:
+-- "键按公司、代码不分公司"时,第 2 家能建出与第 1 家同 (company_id 档, 值) 的行——
+-- 而 V151 之后的 jar 根本不写 company_id,两张表的这一列全由 DEFAULT 1 兜 ⇒ 加回公司键
+-- 在数据上是安全的(见第 0 段预检),但只有配回滚后的 jar 才有意义。
+--
+-- ⚠ 本脚本【不】恢复 company_id 列本身:V151 没有删列(列在 V151 之后仍然带着 DEFAULT 1),
+-- 所以回滚也不涉及建列。DROP COLUMN 是下一版的事,那一版的回滚要把列与默认值一起加回来,
+-- 并且必须先确认两张表的历史归属还能不能分清——品牌库能(uploader_user_id 还在),
+-- 类目表不能(这张表没有任何账号列,V147 §2 已写明事后无法反推)。
+
+-- ---------- 0. 预检(必须先跑,返回 0 行才允许第 1、2 段) ----------
+-- SELECT data_value, LEFT(brand, 191) b, COUNT(*) c
+-- FROM `biz_invalid_asin_data`
+-- GROUP BY data_value, b
+-- HAVING COUNT(*) > 1;
+-- -> 期望 0 行。V151 之后全局键在守,所以这一条应当恒为 0;非 0 说明有人在 V151 与本次回滚
+-- 之间手工绕过迁移改过索引,先查 flyway_schema_history 再决定。
+-- SELECT company_id, COUNT(*) c FROM `biz_invalid_asin_data` GROUP BY company_id;
+-- -> 期望只有一档且值为 1(新 jar 的 INSERT 不带这一列,由 DEFAULT 1 兜)。
+-- 出现第二档说明有写入显式带过公司值,加回公司键后这些行会从别家的视图里隐身。
+-- SELECT category_key, COUNT(*) c FROM `biz_product_category` GROUP BY category_key HAVING c > 1;
+-- -> 期望 0 行(同上,V151 之后由全局键保证)。
+-- SELECT SUM(is_builtin = 1 AND company_id <> 0) AS bad_builtin FROM `biz_product_category`;
+-- -> 期望 0。V148 从未上线,内置节点仍挂哨兵 0;非 0 说明有人跑过 V148 的人工版本,
+-- 回滚后这些内置节点在旧 jar 的 company_id IN (0, X) 谓词下会同时出现在每一家的树上。
+
+-- ---------- 1. 品牌数据库:先加公司键、后删全局键(中间任一步至少有一个唯一键在守并发) ----------
+
+ALTER TABLE `biz_invalid_asin_data`
+ ADD UNIQUE KEY `uk_company_value_brand` (`company_id`, `data_value`, `brand`(191)),
+ ALGORITHM = INPLACE, LOCK = NONE;
+ALTER TABLE `biz_invalid_asin_data`
+ DROP INDEX `uk_data_value_brand`,
+ ALGORITHM = INPLACE, LOCK = NONE;
+
+-- ---------- 2. 商品类目:同一形状 ----------
+
+ALTER TABLE `biz_product_category`
+ ADD UNIQUE KEY `uk_company_category_key` (`company_id`, `category_key`),
+ ALGORITHM = INPLACE, LOCK = NONE;
+ALTER TABLE `biz_product_category`
+ DROP INDEX `uk_product_category_key`,
+ ALGORITHM = INPLACE, LOCK = NONE;
+
+-- ---------- 3. biz_dedupe_total_data 不在本脚本范围内 ----------
+-- V151 没有动去重库(它的 uk_company_data_value 一直都在),回滚自然也不动它。
+
+-- ---------- 4. 验证 ----------
+-- SELECT TABLE_NAME, INDEX_NAME,
+-- GROUP_CONCAT(CONCAT(COLUMN_NAME,'@',SEQ_IN_INDEX) ORDER BY SEQ_IN_INDEX) AS cols
+-- FROM information_schema.STATISTICS
+-- WHERE TABLE_SCHEMA = DATABASE()
+-- AND TABLE_NAME IN ('biz_invalid_asin_data','biz_product_category','biz_dedupe_total_data')
+-- AND NON_UNIQUE = 0
+-- GROUP BY TABLE_NAME, INDEX_NAME;
+-- -> 期望回到 V145+V147 之后的形状:
+-- uk_company_value_brand(company_id@1,data_value@2,brand@3)
+-- uk_company_category_key(company_id@1,category_key@2)
+-- uk_company_data_value(company_id@1,data_value@2)
+-- 加三行 PRIMARY(id);uk_data_value_brand / uk_product_category_key 必须【不】在结果里。
diff --git a/backend-java/src/main/java/com/nanri/aiimage/common/service/DataReadScope.java b/backend-java/src/main/java/com/nanri/aiimage/common/service/DataReadScope.java
index 23e13c791..a68528dfa 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/common/service/DataReadScope.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/common/service/DataReadScope.java
@@ -41,37 +41,21 @@ public class DataReadScope {
}
/**
- * 归属已经**物化成 company_id 列**的表(品牌库 biz_invalid_asin_data)用的谓词出口:
- * 返回要筛的公司 id,null = 不筛。
+ * 归属物化成 {@code company_id} 列、且可见集不靠账号/分组的表用的谓词出口。
*
- * 这些表不能走 {@link #readScope} 的账号集合:2026-10-05 生产只读取证,品牌库 14,801 行里
- * {@code uploader_user_id} 非空的有 0 行(实体没这字段、批量 INSERT 的列清单也没带,
- * V145 补的列一直是空的),按账号筛等于把全部历史从每一个公司 tab 里静默删掉。
- * 而 {@code company_id} 那一列虽然是被 DEFAULT 1 盖上去的,对历史却是诚实的:
- * 第 2 家公司 10-04 14:55 才开通,它名下账号历史任务 0 条、去重库上传 0 行,
- * 所以「建号之前存在的行都归第 1 家」是可证的事实,不是猜。
+ * 今天的消费者是「店铺密钥」{@code biz_shop_key}(V150 起每公司一套)。
+ * 品牌库与商品类目不走这里:控制方 2026-10-06 点名这两页"做成所有公司共享的,不区分",
+ * 它们的 {@code company_id} 列只剩 V145/V147 留下的历史值,读写两侧都不引用
+ * (唯一键退回全局见 {@code V151__rule_tables_shared_across_companies.sql})。
+ * 谁要给它们再接一个公司开关,得先推翻那一条定案。
*
- * 非超管返回 null(不筛):他们的可见集本来就锁在自己的分组上,叠一层公司会把
- * 「靠分组可见」的行整批删掉(同 {@code ShopManageController} 的口径)。
- * 超管的 company_id 是视图开关不是安全边界(spec §4),所以这里不需要再校验它属于谁。
- */
- public Long readCompanyId(AdminUserEntity operator, Long requestedCompanyId) {
- if (!SUPER_ADMIN.equals(adminAuthSupport.currentRole(operator))) {
- return null;
- }
- return requestedCompanyId != null && requestedCompanyId > 0 ? requestedCompanyId : null;
- }
-
- /**
- * 第三道门:归属物化成 {@code company_id} 列、且可见集不靠账号/分组的表(商品类目)。
+ * "不靠账号/分组"是这一道门存在的理由:可见集若无账号/分组谓词兜住,返回 null 等于
+ * 把整张表交给每一家(2026-10-06 逐节点复验实测:公司 2 的 admin 读该页得 412 行,
+ * 其中 394 行是公司 1 的资产)。若某页的可见集本来就锁在自己的分组/账号上,走
+ * {@link #readScope} 即可,非超管在这里再叠一层公司会把那些行整批删掉。
*
- * 与 {@link #readCompanyId} 只差非超管那一支。差别不是省事,是那张表没有可以保护的东西:
- * 品牌库的"非超管不筛"靠的是账号/分组谓词兜住可见集,而 {@code biz_product_category}
- * 连账号列都没有(V147 才加的 {@code company_id})。返回 null 在这里等于把整棵树交给每一家——
- * 2026-10-06 逐节点复验实测:公司 2 的 admin 读该页得 412 行,其中 394 行是公司 1 的自建类目。
- *
- * 非超管钉在本公司而不是"带别家就返回空":类目树里没有"空树"这个可用视图——
- * 内置节点(哨兵 0)在任何公司视图里都必须在,否则那一家装不上任何自建子级。
+ * 非超管钉在本公司而不是"带别家就返回空":返回空是一个可用视图而不是错误,
+ * 而 {@code create} 的 {@code parentId = null} / 空清单让那一家能从零自建。
* 请求里带什么都不算,与 {@code readScope} 非超管分支同一口径(tab 不是安全边界)。
*/
public Long readCompanyIdOrOwn(AdminUserEntity operator, Long requestedCompanyId) {
@@ -85,8 +69,11 @@ public class DataReadScope {
* 写侧的行级归属闸门要的值:{@code null} = 平台超管不限,其余账号一律是自己那一家。
*
* 读侧收窄而写侧不收窄,等于"藏起来的行仍然能删"——那是静默删除,不是隔离。
- * 返回值直接交给 service 与行自己的 {@code company_id} 比(不是与 tab 比:
- * 内置行归哨兵 0,任何公司账号都不该改得动它)。
+ * 返回值直接交给 service 与行自己的 {@code company_id} 比(不是与 tab 比)。
+ * 今天的消费者与 {@link #readCompanyIdOrOwn} 同一批(店铺密钥)。
+ * 商品类目已经不走这里:那页的 {@code assertRowWritable}(含按 {@code is_builtin}
+ * 拦内置节点的那一刀)随 2026-10-06「类目全平台共享、谁都能改整棵树」的定案一起删掉了,
+ * 内置节点现在对任何管理员可改可删——这是控制方点名的口径,不是漏改。
*/
public Long writeCompanyId(AdminUserEntity operator) {
return SUPER_ADMIN.equals(adminAuthSupport.currentRole(operator))
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentLlmClient.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentLlmClient.java
index 26ac304be..7b49788b2 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentLlmClient.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentLlmClient.java
@@ -7,6 +7,7 @@ import com.nanri.aiimage.config.AppearancePatentProperties;
import com.nanri.aiimage.config.HttpClientPool;
import com.nanri.aiimage.metrics.ExternalCallMetricsRecorder;
import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentResultRowDto;
+import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentSheetBuilder;
import com.nanri.aiimage.modules.brand.client.BrandCheckClient;
import com.nanri.aiimage.modules.usersecret.service.UserSecretUsageService;
import com.nanri.aiimage.modules.usersecret.support.SecretUsageContext;
@@ -1064,7 +1065,11 @@ public class AppearancePatentLlmClient {
return NO_INFRINGEMENT;
}
if (isBrandQueryFailed(titleRisk)) {
- return BRAND_QUERY_FAILED;
+ // 外观已经判出「无侵权」时别把它整格盖掉:这一行缺的只是商标那一维,
+ // 结论要说「外观无侵权·商标待复核」,用户才不会把已判出的外观结论读成"整单没检测"。
+ return isNoInfringement(appearanceRisk)
+ ? "外观" + normalize(appearanceRisk) + AppearancePatentSheetBuilder.PENDING_REVIEW_SUFFIX
+ : BRAND_QUERY_FAILED;
}
return firstNonBlank(fallbackConclusion, "");
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilder.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilder.java
index e096b1047..d32632cdc 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilder.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilder.java
@@ -51,6 +51,13 @@ public final class AppearancePatentSheetBuilder {
*/
public static final String NO_RESULT_TEXT = "未取得检测结果";
+ /**
+ * 结论列上「外观已判定、商标那一维没核上」的标记。
+ * 放在这里而不是客户端里:结论是这里写的、状态列也是这里判的,
+ * 两处共用一个字面量才不会各写各的(历史上「结论写着查询失败、状态写着成功」就是这么来的)。
+ */
+ public static final String PENDING_REVIEW_SUFFIX = "·商标待复核";
+
private static final String NO_RESULT_REASON = NO_RESULT_TEXT + ":该行没有返回判定,重新运行任务可补检";
public static void buildResultSheet(Workbook workbook, List rows,
@@ -261,12 +268,17 @@ public final class AppearancePatentSheetBuilder {
* 两者都含「侵权」二字;而「商标查询失败」(品牌检测上游查询失败)、「外观识别异常」、
* LLM 技术性失败、空白都表示这一行没得出完整结论,一律判「失败」。
* 历史缺陷:曾按「结论非空即成功」,于是结论列写着"商标查询失败"、状态列却写"成功"。
+ * 带 {@link #PENDING_REVIEW_SUFFIX} 的结论含「侵权」二字,必须排在字面判定之前判掉,
+ * 否则「外观无侵权·商标待复核」会被读成成功。
*/
public static String resolveResultStatus(String conclusion) {
String normalized = conclusion == null ? "" : conclusion.trim();
if (normalized.isBlank() || isTechnicalLlmFailure(normalized)) {
return "失败";
}
+ if (normalized.contains(PENDING_REVIEW_SUFFIX)) {
+ return "失败";
+ }
return normalized.contains("侵权") ? "成功" : "失败";
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/util/CollectDataInvalidAsinBatchWriter.java b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/util/CollectDataInvalidAsinBatchWriter.java
index 3f4b53498..a4f1c4a6d 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/util/CollectDataInvalidAsinBatchWriter.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/util/CollectDataInvalidAsinBatchWriter.java
@@ -1,6 +1,5 @@
package com.nanri.aiimage.modules.collectdata.util;
-import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.collectdata.model.vo.CollectDataResultRowVo;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.entity.InvalidAsinDataEntity;
@@ -16,52 +15,39 @@ import java.util.regex.Pattern;
/**
* invalid ASIN 批量写入器:把不合规 ASIN 行按批次批量 INSERT IGNORE 写入
* biz_invalid_asin_data,替代逐行 insert + 捕获唯一键异常的旧路径。
- * 幂等由唯一键 (company_id, data_value, brand) + INSERT IGNORE 语义保证;批量失败时
+ * 幂等由唯一键 (data_value, brand) + INSERT IGNORE 语义保证;批量失败时
* 跳过该批(记录计数,不中断提交流程),恢复后继续后续批次。
* 空输入、无合法 data_value/brand 的行、null 行均安全跳过,不发起调用。
*
- * 归属(company_id + uploader_user_id)由调用方给任务发起账号,本类负责推公司:
- * 此前实体与 INSERT 列清单都不带这两列,V145 补的 company_id 全靠 DEFAULT 1 盖,
- * 于是第 2 家公司跑货源产生的行会被记成第 1 家,且事后分不开。
+ * 这一张黑名单是全平台共享的,不按公司区分(控制方 2026-10-06 定案)。
+ * {@code uploader_user_id} 只记"哪个账号采出来的",推不出账号也照写:
+ * 少一条黑名单 = 下次同样的品牌再买一次代理,而归属记不上不影响任何人看数据。
*/
@Slf4j
@Component
public class CollectDataInvalidAsinBatchWriter {
- /** 巡检可 grep 的标记:账号已不存在、推不出公司,这批 rejected 品牌整批不写。 */
- static final String OWNER_UNRESOLVED_MARKER = "INVALID_ASIN_OWNER_UNRESOLVED";
-
private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\s+");
private final InvalidAsinDataMapper invalidAsinDataMapper;
- private final CompanyScopeSupport companyScopeSupport;
private final int batchSize;
public CollectDataInvalidAsinBatchWriter(InvalidAsinDataMapper invalidAsinDataMapper,
- CompanyScopeSupport companyScopeSupport,
@Value("${aiimage.collect-data.invalid-asin-batch-size:100}") int batchSize) {
this.invalidAsinDataMapper = invalidAsinDataMapper;
- this.companyScopeSupport = companyScopeSupport;
this.batchSize = Math.max(1, batchSize);
}
/**
* 批量写入并返回实际尝试写入的行数(INSERT IGNORE 忽略重复,幂等)。
*
- * @param uploaderUserId 任务发起账号(biz_file_task.user_id);推不出公司时整批不写并打
- * {@link #OWNER_UNRESOLVED_MARKER}——宁可少记一条黑名单,
- * 也不把行盖成别家公司(那会让另一家的正常品牌被静默过滤)
+ * @param uploaderUserId 任务发起账号(biz_file_task.user_id);可为 null(账号已删),
+ * 只影响这一列记不记得上,不影响写不写得进
*/
public int writeBatch(List rows, Long uploaderUserId) {
if (rows == null || rows.isEmpty()) {
return 0;
}
- Long companyId = companyScopeSupport.companyIdOrNull(uploaderUserId);
- if (companyId == null) {
- log.warn("{} 无法按账号推出处置公司,本批不写入无效品牌表 rows={} userId={}",
- OWNER_UNRESOLVED_MARKER, rows.size(), uploaderUserId);
- return 0;
- }
int written = 0;
for (int start = 0; start < rows.size(); start += batchSize) {
int end = Math.min(start + batchSize, rows.size());
@@ -70,7 +56,6 @@ public class CollectDataInvalidAsinBatchWriter {
for (CollectDataResultRowVo row : batch) {
InvalidAsinDataEntity entity = toEntity(row);
if (entity != null) {
- entity.setCompanyId(companyId);
entity.setUploaderUserId(uploaderUserId);
entities.add(entity);
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java b/backend-java/src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java
index 6903e9a49..134979799 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java
@@ -24,6 +24,10 @@ import java.util.Map;
* 所以这里探的是【清单】而不是单个列名。清单与探针 SQL 的 IN 列表由 {@code CompanyDefaultGuardTest}
* 双向钉同源:只钉"清单里的都在 SQL 里"会漏掉"SQL 里有、清单漏了"那一半,而那一半才是静默的形状。
*
+ * 清单也会随口径缩短:{@code biz_invalid_asin_data} 与 {@code biz_product_category}
+ * 已按 2026-10-06「这两页全平台共享」的定案一起摘掉,理由见 {@link #WATCHED_TABLES}——
+ * 对一张不再分公司写行的表喊"去摘 DEFAULT",会把一个无人报错的遗留列变成一次真故障(1364)。
+ *
* 标记串({@link #ALARM} / {@link #PROBE_FAILED})是纯 ASCII:巡检脚本要在 docker logs 里
* grep 它,中文一旦在容器里变了编码就整条签名失效。
*/
@@ -41,17 +45,31 @@ public class CompanyDefaultGuard {
/**
* 该带 company_id 且历史上可能被塞过 DEFAULT 的表。新增一列就要在这里登记一条——
* 漏登记的后果不是报错,是哨兵对着一个不存在的列一声不响({@link #check} 会把它当探不到处理)。
- * V147 的 {@code biz_product_category} 是第四条:它的 DEFAULT 1 同样只为同批旧 jar 存在,
- * 摘除动作与上面三张同形(一条元数据操作,禁 MODIFY)。
+ *
+ * 登记表里只能放"仍然按公司写"的表,这一条比上一句更容易踩。
+ * {@code biz_invalid_asin_data}(V145)与 {@code biz_product_category}(V147)已经在
+ * 2026-10-06「品牌数据库/商品类目做成所有公司共享」的定案里一并摘掉:它们的 {@code company_id}
+ * 现在没有任何读写路径引用,靠 {@code DEFAULT 1} 满足 {@code NOT NULL}。此时喊
+ * {@code COMPANY_DEFAULT_STILL_PRESENT} 并让人去执行本类给出的 {@code DROP DEFAULT},
+ * 后果不是"修好了"而是每一次写入报 1364——品牌库那条还会被
+ * {@code CollectDataInvalidAsinBatchWriter} 吞成 warn ⇒ 接口成功而黑名单静默少一批。
+ * 这两列的 DEFAULT 由下一版的 {@code DROP COLUMN} 一并带走(见 docs/migration-inventory.md)。
+ *
+ * V147 的 {@code biz_product_category} 曾是第三条、V150 的 {@code biz_shop_key} 是第五条:
+ * 加它们时用的是同一条理由,摘它们时也必须是同一条理由——"这张表还分公司吗"是唯一判据。
+ *
+ * V149 的 {@code columns} 方向相反,是【加进来】的一条:菜单树如今真的按公司写(每家公司一套),
+ * 它的 {@code DEFAULT 1} 只为同批的旧 jar 存在(旧实体没有 companyId,insert 整列跳过会报 1364)。
+ * 新 jar 的每个建/改菜单出口都显式落公司,此后留着默认值的后果是"忘了传公司的行静默归第 1 家",
+ * 与上面那两条"没人读的列"不同 —— 判据仍是同一句:这张表还分公司吗。
*/
static final List WATCHED_TABLES = List.of(
- "users", "biz_invalid_asin_data", "biz_dedupe_total_data", "biz_product_category");
+ "users", "biz_dedupe_total_data", "biz_shop_key", "columns");
private static final String COLUMN_DEFAULT_SQL = """
SELECT TABLE_NAME, COLUMN_DEFAULT FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = DATABASE() AND COLUMN_NAME = 'company_id'
- AND TABLE_NAME IN ('users', 'biz_invalid_asin_data', 'biz_dedupe_total_data',
- 'biz_product_category')
+ AND TABLE_NAME IN ('users', 'biz_dedupe_total_data', 'biz_shop_key', 'columns')
""";
private final CompanyMapper companyMapper;
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/company/service/CompanyService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/company/service/CompanyService.java
index 7aec8146f..643d1ac32 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/company/service/CompanyService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/company/service/CompanyService.java
@@ -7,8 +7,10 @@ import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.dto.CompanySaveRequest;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
+import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.Collection;
@@ -31,6 +33,7 @@ public class CompanyService {
private final CompanyMapper companyMapper;
private final AdminAuthSupport adminAuthSupport;
+ private final PermissionMenuService permissionMenuService;
/** 建号指定的公司必须真实存在且启用:否则账号挂在查不到的公司上,按公司筛选时整体失明。 */
public CompanyEntity requireActive(Long companyId) {
@@ -104,7 +107,14 @@ public class CompanyService {
return company.getCompanyName();
}
- /** 新增公司:只有超管能建,一期也只有超管需要建(开通第二家公司是人工动作)。 */
+ /**
+ * 新增公司:只有超管能建,一期也只有超管需要建(开通第二家公司是人工动作)。
+ *
+ * 事务包住两件事:插公司行 + 给它复制一套菜单树。每家公司一棵树之后,零菜单行的租户
+ * 表现是"那家账号侧边栏全空"且不报错,所以建树不能留成上线后的人工动作;
+ * 复制失败必须连公司行一起回滚,不留半成品。
+ */
+ @Transactional
public CompanyEntity create(AdminUserEntity operator, CompanySaveRequest request) {
ensureSuperAdmin(operator);
String companyName = requireValidName(request.getCompanyName());
@@ -117,6 +127,7 @@ public class CompanyService {
entity.setStatus(status);
entity.setRemark(remark);
companyMapper.insert(entity);
+ permissionMenuService.copyTreeFromTemplate(entity.getId(), operator.getCompanyId());
return entity;
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/controller/InvalidAsinDataController.java b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/controller/InvalidAsinDataController.java
index dd7229f10..5f32070ad 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/controller/InvalidAsinDataController.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/controller/InvalidAsinDataController.java
@@ -3,7 +3,6 @@ package com.nanri.aiimage.modules.invalidasin.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
-import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataCreateRequest;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataUpdateRequest;
import com.nanri.aiimage.modules.invalidasin.model.vo.InvalidAsinDataItemVo;
@@ -39,7 +38,7 @@ import java.security.MessageDigest;
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/admin/invalid-asin-data")
-@Tag(name = "不符合ASIN数据", description = "维护不符合ASIN数据列表,支持增删改查。")
+@Tag(name = "品牌数据库", description = "维护品牌数据库(不符合规则的 ASIN / 品牌)列表,支持增删改查。全平台共享,不按公司区分。")
public class InvalidAsinDataController {
private static final String INVALID_ASIN_DATA_COLUMN_KEY = "admin_invalid_asin_data";
@@ -50,10 +49,9 @@ public class InvalidAsinDataController {
private final InvalidAsinDataService invalidAsinDataService;
private final AdminAuthSupport adminAuthSupport;
private final PermissionMenuService permissionMenuService;
- private final DataReadScope dataReadScope;
@GetMapping
- @Operation(summary = "分页查询不符合ASIN数据", description = "分页查询不符合ASIN数据,支持按 ASIN/品牌 模糊搜索。")
+ @Operation(summary = "分页查询品牌数据库", description = "分页查询品牌数据库(全平台共享,不按公司区分),支持按 ASIN/品牌 模糊搜索。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "查询成功", content = @Content(schema = @Schema(implementation = InvalidAsinDataPageVo.class)))
})
@@ -64,18 +62,14 @@ public class InvalidAsinDataController {
@Parameter(description = "ASIN 模糊搜索") @RequestParam(name = "data_value", required = false) String dataValue,
@Parameter(description = "品牌模糊搜索") @RequestParam(name = "brand", required = false) String brand,
@Parameter(description = "分组 ID") @RequestParam(name = "group_id", required = false) Long groupId,
- @Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
RequestOperator operator = requireInvalidAsinDataAccess(request);
- AdminUserEntity user = operator.user();
- Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId);
return ApiResponse.success(invalidAsinDataService.page(
- page, pageSize, keyword, dataValue, brand, groupId, operator.id(), operator.superAdmin(),
- scopedCompanyId));
+ page, pageSize, keyword, dataValue, brand, groupId, operator.id(), operator.superAdmin()));
}
@PostMapping
- @Operation(summary = "新增不符合ASIN数据", description = "新增一条不符合ASIN数据。")
+ @Operation(summary = "新增品牌数据库记录", description = "新增一条品牌数据库记录(全平台共享)。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "创建成功", content = @Content(schema = @Schema(implementation = InvalidAsinDataItemVo.class))),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "400", description = "参数不合法或数据重复")
@@ -89,7 +83,7 @@ public class InvalidAsinDataController {
}
@PutMapping("/{id}")
- @Operation(summary = "更新不符合ASIN数据", description = "按 ID 更新一条不符合ASIN数据。")
+ @Operation(summary = "更新品牌数据库记录", description = "按 ID 更新一条品牌数据库记录。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "更新成功", content = @Content(schema = @Schema(implementation = InvalidAsinDataItemVo.class))),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "400", description = "参数不合法或数据重复"),
@@ -105,7 +99,7 @@ public class InvalidAsinDataController {
}
@DeleteMapping("/{id}")
- @Operation(summary = "删除不符合ASIN数据", description = "按 ID 删除一条不符合ASIN数据。")
+ @Operation(summary = "删除品牌数据库记录", description = "按 ID 删除一条品牌数据库记录。")
@ApiResponses({
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "200", description = "删除成功"),
@io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "404", description = "数据不存在")
@@ -127,7 +121,7 @@ public class InvalidAsinDataController {
if (!superAdmin && !hasInvalidAsinDataPermission(operator)) {
throw new BusinessException(403, "无权访问品牌数据库");
}
- return new RequestOperator(operator.getId(), superAdmin, operator);
+ return new RequestOperator(operator.getId(), superAdmin);
}
private AdminUserEntity resolveOperator(HttpServletRequest request) {
@@ -170,7 +164,7 @@ public class InvalidAsinDataController {
- private record RequestOperator(Long id, boolean superAdmin, AdminUserEntity user) {
+ private record RequestOperator(Long id, boolean superAdmin) {
}
private boolean isTrustedInternalRequest(String suppliedToken) {
return adminAuthSupport.isTrustedSuppliedToken(suppliedToken);
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/mapper/InvalidAsinDataMapper.java b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/mapper/InvalidAsinDataMapper.java
index b368b4d43..3f4951619 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/mapper/InvalidAsinDataMapper.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/mapper/InvalidAsinDataMapper.java
@@ -12,22 +12,26 @@ import java.util.List;
public interface InvalidAsinDataMapper extends BaseMapper {
/**
- * 批量 INSERT IGNORE:命中唯一键 (company_id, data_value, brand) 的重复行静默跳过,幂等。
+ * 批量 INSERT IGNORE:命中唯一键 (data_value, brand) 的重复行静默跳过,幂等。
* created_at/updated_at 不显式写入:依赖列的 DEFAULT CURRENT_TIMESTAMP。
* 显式传 null 会绕过默认值,在宽松 SQL 模式下落为 '0000-00-00 00:00:00',
* 随后在 NO_ZERO_DATE 模式(生产已启用)下读取即报 Zero date value prohibited。
*
- * company_id 与 uploader_user_id 由调用方填好:company_id 是 NOT NULL,
- * 这一列显式传 null 不会走 DEFAULT 1,而是直接报错(上面 created_at 那段说的正是这类列的
- * "宽松模式才静默"),所以归属推不出来时调用方必须整批不写,而不是塞 null 进来。
+ * 列清单里没有 company_id:品牌数据库全平台共享,归属不参与幂等(控制方 2026-10-06 定案)。
+ * 库里那一列带 {@code DEFAULT 1} 且仍 NOT NULL,所以省略它安全;反过来显式传 null 会直接报错
+ * (上面 created_at 那段说的正是这类列的"宽松模式才静默")。
+ *
+ * uploader_user_id 可空,jdbcType 必须写:任务账号已被删时这一列就是 null,
+ * 不告诉 MyBatis 类型它会抛 "Error setting null parameter",而调用方把异常吞成 log.warn,
+ * 于是整批黑名单静默丢掉。
*/
@Insert("""
""")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/dto/InvalidAsinDataCreateRequest.java b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/dto/InvalidAsinDataCreateRequest.java
index 90eb47dde..3878668a0 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/dto/InvalidAsinDataCreateRequest.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/dto/InvalidAsinDataCreateRequest.java
@@ -7,7 +7,7 @@ import jakarta.validation.constraints.Size;
import lombok.Data;
@Data
-@Schema(description = "不符合ASIN数据新增请求")
+@Schema(description = "品牌数据库新增请求")
public class InvalidAsinDataCreateRequest {
@NotBlank(message = "ASIN 不能为空")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/dto/InvalidAsinDataUpdateRequest.java b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/dto/InvalidAsinDataUpdateRequest.java
index efb25d063..b0d4fd47c 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/dto/InvalidAsinDataUpdateRequest.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/dto/InvalidAsinDataUpdateRequest.java
@@ -6,7 +6,7 @@ import jakarta.validation.constraints.Size;
import lombok.Data;
@Data
-@Schema(description = "不符合ASIN数据更新请求")
+@Schema(description = "品牌数据库更新请求")
public class InvalidAsinDataUpdateRequest {
@NotBlank(message = "ASIN 不能为空")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/entity/InvalidAsinDataEntity.java b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/entity/InvalidAsinDataEntity.java
index 4663bf2a4..24826bd28 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/entity/InvalidAsinDataEntity.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/entity/InvalidAsinDataEntity.java
@@ -9,6 +9,16 @@ import lombok.Data;
import java.time.LocalDateTime;
+/**
+ * 品牌数据库(不符合 ASIN / 品牌黑名单)——全平台共享,不按公司区分(控制方 2026-10-06 定案)。
+ *
+ * 所以这里不声明 {@code company_id} 字段。库里那一列(V145 加的,带 {@code DEFAULT 1})
+ * 暂时还在,但没有任何读写路径引用它:不声明字段 ⇒ SELECT 列清单与 INSERT 都不含它 ⇒ 新 jar 配旧库
+ * (列还在)不会报错。摘列必须等两台都跑上这一版,否则旧 jar 带着这一列来 INSERT/SELECT 会撞
+ * {@code Unknown column},而批量写入器把异常吞成 log.warn——那是静默丢黑名单行。
+ * 唯一键退回全局见 {@code V151__rule_tables_shared_across_companies.sql};摘列本身不在 V151 里
+ * (V151 只退键),它是下一版的待办,取号与理由见 {@code docs/migration-inventory.md}。
+ */
@Data
@TableName("biz_invalid_asin_data")
public class InvalidAsinDataEntity {
@@ -19,11 +29,9 @@ public class InvalidAsinDataEntity {
private String brand;
private Long groupId;
/**
- * 归属公司(company.id)。列由 V145 物化,但**实体与批量 INSERT 的列清单此前都没带它**,
- * 所以 2026-10-05 生产只读取证 14,801 行全是被 DEFAULT 1 盖出来的。写入侧从本版本起显式盖章。
+ * 归属账号:AUTO 行取 task.user_id、MANUAL 行取操作人;V145 之前的历史行为 NULL(无从追溯)。
+ * 这一列只记"谁加的",不参与任何筛选——品牌数据库全平台共享,见类注释。
*/
- private Long companyId;
- /** 归属账号:AUTO 行取 task.user_id、MANUAL 行取操作人;V145 之前的历史行为 NULL(无从追溯)。 */
private Long uploaderUserId;
private String recordSource;
private LocalDateTime createdAt;
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/vo/InvalidAsinDataItemVo.java b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/vo/InvalidAsinDataItemVo.java
index c6d6c29a5..34360b292 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/vo/InvalidAsinDataItemVo.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/vo/InvalidAsinDataItemVo.java
@@ -6,7 +6,7 @@ import lombok.Data;
import java.time.LocalDateTime;
@Data
-@Schema(description = "不符合ASIN数据项")
+@Schema(description = "品牌数据库数据项")
public class InvalidAsinDataItemVo {
@Schema(description = "主键ID")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/vo/InvalidAsinDataPageVo.java b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/vo/InvalidAsinDataPageVo.java
index 4789bfc5c..5990fb925 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/vo/InvalidAsinDataPageVo.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/model/vo/InvalidAsinDataPageVo.java
@@ -6,7 +6,7 @@ import lombok.Data;
import java.util.List;
@Data
-@Schema(description = "不符合ASIN数据分页结果")
+@Schema(description = "品牌数据库分页结果")
public class InvalidAsinDataPageVo {
@Schema(description = "列表")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/service/InvalidAsinDataService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/service/InvalidAsinDataService.java
index 010e44c55..1d3cf03c7 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/service/InvalidAsinDataService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/invalidasin/service/InvalidAsinDataService.java
@@ -2,7 +2,6 @@ package com.nanri.aiimage.modules.invalidasin.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
-import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataCreateRequest;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataUpdateRequest;
@@ -31,10 +30,9 @@ public class InvalidAsinDataService {
private final InvalidAsinDataMapper invalidAsinDataMapper;
private final ShopManageGroupService shopManageGroupService;
- private final CompanyScopeSupport companyScopeSupport;
public InvalidAsinDataPageVo page(long page, long pageSize, String keyword, String dataValue, String brand,
- Long groupId, Long operatorId, boolean superAdmin, Long companyFilterId) {
+ Long groupId, Long operatorId, boolean superAdmin) {
long safePage = Math.max(page, 1);
long safePageSize = Math.min(Math.max(pageSize, 1), 100);
String safeKeyword = keyword == null ? "" : keyword.trim();
@@ -48,9 +46,6 @@ public class InvalidAsinDataService {
.like(!safeDataValue.isEmpty(), InvalidAsinDataEntity::getDataValue, safeDataValue)
.like(!safeBrand.isEmpty(), InvalidAsinDataEntity::getBrand, safeBrand)
.orderByDesc(InvalidAsinDataEntity::getId);
- if (companyFilterId != null) {
- query.eq(InvalidAsinDataEntity::getCompanyId, companyFilterId);
- }
if (!superAdmin) {
Long fixedGroupId = resolveFixedAccessibleGroupId(operatorId);
if (fixedGroupId == null) {
@@ -85,16 +80,13 @@ public class InvalidAsinDataService {
@Transactional
public InvalidAsinDataItemVo create(InvalidAsinDataCreateRequest request, Long operatorId, boolean superAdmin) {
ShopManageGroupEntity group = resolveManualWriteGroup(request.getGroupId(), operatorId, superAdmin);
- // 归属从操作者会话推导,不读请求里的公司:超管在哪个 tab 下建都归他自己那家公司(一期定案口径)。
- Long companyId = companyScopeSupport.requireCompanyId(operatorId);
String dataValue = normalizeRequired(request.getDataValue(), "ASIN 不能为空");
String brand = normalizeRequired(request.getBrand(), "品牌不能为空").toLowerCase(Locale.ROOT);
- ensureUnique(dataValue, null, companyId);
+ ensureUnique(dataValue, null);
InvalidAsinDataEntity entity = new InvalidAsinDataEntity();
entity.setDataValue(dataValue);
entity.setBrand(brand);
entity.setGroupId(group.getId());
- entity.setCompanyId(companyId);
entity.setUploaderUserId(operatorId);
entity.setRecordSource(RECORD_SOURCE_MANUAL);
invalidAsinDataMapper.insert(entity);
@@ -114,7 +106,7 @@ public class InvalidAsinDataService {
}
String dataValue = normalizeRequired(request.getDataValue(), "ASIN 不能为空");
String brand = normalizeRequired(request.getBrand(), "品牌不能为空").toLowerCase(Locale.ROOT);
- ensureUnique(dataValue, id, entity.getCompanyId());
+ ensureUnique(dataValue, id);
entity.setDataValue(dataValue);
entity.setBrand(brand);
String groupName = "";
@@ -153,12 +145,15 @@ public class InvalidAsinDataService {
}
/**
- * 应用层的重复预检必须与 V145 放宽后的唯一键同宽——(company_id, data_value, brand)。
- * 少了公司这一维,第 2 家永远无法新增第 1 家已有的品牌(跨公司误报「ASIN 已存在」)。
+ * 全平台一份黑名单:同一条 ASIN 只要已经被任何一家录过,第二家再录就报「ASIN 已存在」。
+ *
+ * 预检比 {@code data_value} 一个字段,而库里唯一键是 {@code (data_value, brand)} ——预检更严,
+ * 这是改造前就有的口径(同一 ASIN 换品牌重录在页面上看不出区别)。V145 一度给这里叠过公司维度,
+ * 2026-10-06 控制方定案"品牌数据库不区分公司"后摘回全局。不许再把公司加回来:
+ * 那会让同一条 ASIN 在共享列表里长出两行,而这一页没有任何地方告诉操作员它们分属两家。
*/
- private void ensureUnique(String dataValue, Long excludeId, Long companyId) {
+ private void ensureUnique(String dataValue, Long excludeId) {
LambdaQueryWrapper query = new LambdaQueryWrapper()
- .eq(companyId != null, InvalidAsinDataEntity::getCompanyId, companyId)
.eq(InvalidAsinDataEntity::getDataValue, dataValue)
.last("LIMIT 1");
InvalidAsinDataEntity exists = invalidAsinDataMapper.selectOne(query);
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/permission/controller/PermissionMenuController.java b/backend-java/src/main/java/com/nanri/aiimage/modules/permission/controller/PermissionMenuController.java
index 3cf1d6f6d..8eb7d345e 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/permission/controller/PermissionMenuController.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/permission/controller/PermissionMenuController.java
@@ -53,17 +53,29 @@ public class PermissionMenuController {
public ApiResponse> listMenus(HttpServletRequest request,
@Parameter(description = "菜单类型: app/admin") @RequestParam(required = false) String menuType,
@Parameter(description = "授权树语义: true 时非超管只返回自己可授予的菜单")
- @RequestParam(required = false, defaultValue = "false") boolean grantableOnly) {
+ @RequestParam(required = false, defaultValue = "false") boolean grantableOnly,
+ @Parameter(description = "公司 ID:仅站点超管可指定,缺省取操作者本公司")
+ @RequestParam(name = "company_id", required = false) Long companyId) {
// 传入操作者:授权树据此只下发(并把范围外节点标成不可勾选)操作者有权授予的菜单
- return ApiResponse.success(permissionMenuService.list(requireAdmin(request), menuType, grantableOnly));
+ AdminUserEntity operator = requireAdmin(request);
+ // 归属判据只有一条(读写共用):先在这里过一遍,别家公司的 company_id 在取任何数之前就被 403 拒掉,
+ // 传下去的是定下来那一家,而不是 tab 原文。service 内部还会再判一次(幂等),控制器不重算口径。
+ Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
+ return ApiResponse.success(permissionMenuService.list(
+ operator, menuType, grantableOnly, scopeCompanyId));
}
@PostMapping("/permission-menus")
@Operation(summary = "新增菜单权限项")
public ApiResponse createMenu(HttpServletRequest httpRequest,
- @Valid @RequestBody PermissionMenuCreateRequest request) {
+ @Valid @RequestBody PermissionMenuCreateRequest request,
+ @Parameter(description = "建到哪家公司的树:仅站点超管可指定")
+ @RequestParam(name = "company_id", required = false)
+ Long companyId) {
+ AdminUserEntity operator = requireAdmin(httpRequest);
+ Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
return ApiResponse.success("创建成功", permissionMenuService.create(
- requireAdmin(httpRequest), request));
+ operator, scopeCompanyId, request));
}
@PutMapping("/permission-menus/{id}")
@@ -86,7 +98,7 @@ public class PermissionMenuController {
@Operation(summary = "同级菜单拖拽排序")
public ApiResponse reorderColumns(HttpServletRequest httpRequest,
@RequestBody(required = false) Map body) {
- requireAdmin(httpRequest);
+ AdminUserEntity operator = requireAdmin(httpRequest);
Object raw = body == null ? null
: (body.get("ordered_ids") != null ? body.get("ordered_ids") : body.get("orderedIds"));
if (!(raw instanceof List> list)) {
@@ -104,7 +116,8 @@ public class PermissionMenuController {
}
}
}
- permissionMenuService.reorder(ids);
+ // 带上操作者:重排会写兄弟集的 sort_order,每家公司一棵树之后必须先确认锚点行属于他
+ permissionMenuService.reorder(operator, ids);
return ApiResponse.success("排序已保存", null);
}
@@ -142,34 +155,48 @@ public class PermissionMenuController {
@GetMapping("/image-video-task-permissions")
@Operation(summary = "查询视频任务数据权限用户")
public ApiResponse> listImageVideoDataPermissionUsers(
- HttpServletRequest request) {
- return ApiResponse.success(permissionMenuService.listImageVideoDataPermissionUsers(requireAdmin(request)));
+ HttpServletRequest request,
+ @RequestParam(name = "company_id", required = false) Long companyId) {
+ AdminUserEntity operator = requireAdmin(request);
+ Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
+ return ApiResponse.success(permissionMenuService.listImageVideoDataPermissionUsers(
+ operator, scopeCompanyId));
}
@PutMapping("/image-video-task-permissions")
@Operation(summary = "更新视频任务数据权限用户")
public ApiResponse updateImageVideoDataPermissionUsers(
HttpServletRequest request,
+ @RequestParam(name = "company_id", required = false) Long companyId,
@RequestBody(required = false) ImageVideoDataPermissionUpdateRequest body) {
+ AdminUserEntity operator = requireAdmin(request);
+ Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
int grantedCount = permissionMenuService.updateImageVideoDataPermissionUsers(
- requireAdmin(request), body == null ? List.of() : body.getUserIds());
+ operator, scopeCompanyId, body == null ? List.of() : body.getUserIds());
return ApiResponse.success("视频任务权限已更新", grantedCount);
}
@GetMapping("/shop-data-crawl-task-permissions")
@Operation(summary = "查询店铺数据任务数据权限用户")
public ApiResponse> listShopDataCrawlDataPermissionUsers(
- HttpServletRequest request) {
- return ApiResponse.success(permissionMenuService.listShopDataCrawlDataPermissionUsers(requireAdmin(request)));
+ HttpServletRequest request,
+ @RequestParam(name = "company_id", required = false) Long companyId) {
+ AdminUserEntity operator = requireAdmin(request);
+ Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
+ return ApiResponse.success(permissionMenuService.listShopDataCrawlDataPermissionUsers(
+ operator, scopeCompanyId));
}
@PutMapping("/shop-data-crawl-task-permissions")
@Operation(summary = "更新店铺数据任务数据权限用户")
public ApiResponse updateShopDataCrawlDataPermissionUsers(
HttpServletRequest request,
+ @RequestParam(name = "company_id", required = false) Long companyId,
@RequestBody(required = false) ImageVideoDataPermissionUpdateRequest body) {
+ AdminUserEntity operator = requireAdmin(request);
+ Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(operator, companyId);
int grantedCount = permissionMenuService.updateShopDataCrawlDataPermissionUsers(
- requireAdmin(request), body == null ? List.of() : body.getUserIds());
+ operator, scopeCompanyId, body == null ? List.of() : body.getUserIds());
return ApiResponse.success("店铺数据任务权限已更新", grantedCount);
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/permission/model/entity/PermissionMenuEntity.java b/backend-java/src/main/java/com/nanri/aiimage/modules/permission/model/entity/PermissionMenuEntity.java
index fa15ce3b2..27afbae2a 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/permission/model/entity/PermissionMenuEntity.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/permission/model/entity/PermissionMenuEntity.java
@@ -22,6 +22,15 @@ public class PermissionMenuEntity {
private String menuType;
private String routePath;
private Integer sortOrder;
+ /**
+ * 归属公司(V149):菜单字典从"全平台一棵树"改成"每家公司一套树",
+ * {@code column_key} 与 {@code (menu_type, route_path)} 都只在本公司内唯一。
+ *
+ * 写侧一律显式赋值({@code PermissionMenuService} 的 create/update 从操作者或目标行推导),
+ * 不许依赖列上那条临时的 {@code DEFAULT 1}:V149 留 DEFAULT 只为让同批的旧 jar 不报 1364,
+ * 下一版就摘掉;一旦有出口忘了赋值,DEFAULT 会把别家的菜单静默塞进厦门米椿花。
+ */
+ private Long companyId;
private LocalDateTime createdAt;
/**
* 更新时间(V131 新增):由数据库维护(DEFAULT CURRENT_TIMESTAMP + ON UPDATE CURRENT_TIMESTAMP)。
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java b/backend-java/src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java
index fe70eb97f..0e27bb1ca 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java
@@ -11,6 +11,19 @@ import org.springframework.stereotype.Component;
import java.util.List;
import java.util.concurrent.CompletableFuture;
+/**
+ * 菜单字典的建表/种子旁路(生产默认关,见 application.yml 的 aiimage.permission-schema-init.enabled)。
+ *
+ * V149 之后它只维护公司 1 那棵平台默认树:每一条种子语句的 INSERT 列清单都显式写
+ * {@code company_id = 1},判存守卫、认父 JOIN、按 key 的 UPDATE 也一律带 {@code company_id = 1}——
+ * 因为 column_key 如今只在单家公司内唯一,一条裸 {@code WHERE column_key = ...} 在这张表上
+ * 就是"把每一家的同名行都改一遍"(把别家副本的 parent 拍平、或把授权发给别家的行 id)。
+ * 显式写公司还有一层作用:这条通道不再依赖列上那条 {@code DEFAULT 1},
+ * 于是 V152 起摘掉它({@code ALTER TABLE columns ALTER COLUMN company_id DROP DEFAULT})
+ * 不会让这里的建号变成 1364 被 {@code executeQuietly} 吞成"一声不响少一套菜单"。
+ * 别家公司的树不由这里插行——存量公司归 V149 的复制段,新建公司归
+ * {@code PermissionMenuService.copyTreeFromTemplate}({@code CompanyService.create} 同事务调用)。
+ */
@Component
@RequiredArgsConstructor
@Slf4j
@@ -92,17 +105,26 @@ public class PermissionMenuSchemaInitializer {
name VARCHAR(128) NOT NULL COMMENT '菜单标题',
column_key VARCHAR(64) NOT NULL COMMENT '菜单唯一标识',
parent_id INT NULL COMMENT '直接父菜单 ID',
+ company_id BIGINT NOT NULL DEFAULT 1 COMMENT '归属公司:每家公司一套菜单树',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
- UNIQUE KEY uk_column_key (column_key)
+ UNIQUE KEY uk_company_column_key (company_id, column_key)
)
""");
executeQuietly("ALTER TABLE columns ADD COLUMN menu_type VARCHAR(20) NOT NULL DEFAULT 'app' COMMENT '菜单类型: app/admin' AFTER column_key");
executeQuietly("ALTER TABLE columns ADD COLUMN parent_id INT NULL COMMENT '直接父菜单 ID' AFTER id");
executeQuietly("ALTER TABLE columns ADD COLUMN route_path VARCHAR(255) NOT NULL DEFAULT '' COMMENT '菜单路由或页面标识' AFTER menu_type");
executeQuietly("ALTER TABLE columns ADD COLUMN sort_order INT NOT NULL DEFAULT 0 COMMENT '菜单排序' AFTER route_path");
+ executeQuietly("ALTER TABLE columns ADD COLUMN company_id BIGINT NULL COMMENT '归属公司:每家公司一套菜单树'");
+ executeQuietly("UPDATE columns SET company_id = 1 WHERE company_id IS NULL");
+ executeQuietly("ALTER TABLE columns MODIFY COLUMN company_id BIGINT NOT NULL DEFAULT 1 COMMENT '归属公司:每家公司一套菜单树'");
executeQuietly("UPDATE columns SET menu_type = 'app' WHERE menu_type IS NULL OR menu_type = ''");
executeQuietly("UPDATE columns SET sort_order = id WHERE sort_order IS NULL OR sort_order = 0");
- executeQuietly("ALTER TABLE columns ADD UNIQUE KEY uk_menu_type_route_path (menu_type, route_path)");
+ // 两条全局唯一键在"每家公司一套树"之后会把别家同名菜单挡成"标识已存在"。
+ // 先加复合键、再摘旧键(与 V149 第 4/5 段同一顺序:任一步失败都至少还剩一条键守并发)。
+ executeQuietly("ALTER TABLE columns ADD UNIQUE KEY uk_company_column_key (company_id, column_key)");
+ executeQuietly("ALTER TABLE columns ADD UNIQUE KEY uk_company_menu_type_route_path (company_id, menu_type, route_path)");
+ executeQuietly("ALTER TABLE columns DROP INDEX uk_column_key");
+ executeQuietly("ALTER TABLE columns DROP INDEX uk_menu_type_route_path");
ensureDefaultAdminGroups();
ensureDefaultAdminMenus();
boolean shopDataCrawlDataPermissionCreated = ensureShopDataCrawlAdminDefaults();
@@ -126,10 +148,10 @@ public class PermissionMenuSchemaInitializer {
private void ensureDefaultAdminGroups() {
for (DefaultAdminGroup group : DEFAULT_ADMIN_GROUPS) {
executeQuietly("""
- INSERT INTO columns (name, column_key, menu_type, route_path, parent_id, sort_order)
- SELECT '%s', '%s', 'admin', '%s', NULL, %d
+ INSERT INTO columns (company_id, name, column_key, menu_type, route_path, parent_id, sort_order)
+ SELECT 1, '%s', '%s', 'admin', '%s', NULL, %d
WHERE NOT EXISTS (
- SELECT 1 FROM columns WHERE column_key = '%s'
+ SELECT 1 FROM columns WHERE company_id = 1 AND column_key = '%s'
)
""".formatted(group.name(), group.columnKey(), group.routePath(), group.sortOrder(), group.columnKey()));
}
@@ -138,21 +160,21 @@ public class PermissionMenuSchemaInitializer {
private void ensureDefaultAdminMenus() {
for (DefaultAdminMenu menu : DEFAULT_ADMIN_MENUS) {
executeQuietly("""
- INSERT INTO columns (name, column_key, menu_type, route_path, sort_order, parent_id)
- SELECT '%s', '%s', 'admin', '%s', %d, parent.id
+ INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order, parent_id)
+ SELECT 1, '%s', '%s', 'admin', '%s', %d, parent.id
FROM columns parent
- WHERE parent.column_key = '%s'
+ WHERE parent.company_id = 1 AND parent.column_key = '%s'
AND NOT EXISTS (
- SELECT 1 FROM columns WHERE column_key = '%s'
+ SELECT 1 FROM columns WHERE company_id = 1 AND column_key = '%s'
)
""".formatted(menu.name(), menu.columnKey(), menu.routePath(), menu.sortOrder(),
menu.parentKey(), menu.columnKey()));
executeQuietly("""
UPDATE columns child
- JOIN columns parent ON parent.column_key = '%s'
+ JOIN columns parent ON parent.company_id = 1 AND parent.column_key = '%s'
SET child.name = '%s', child.sort_order = %d,
child.parent_id = COALESCE(child.parent_id, parent.id)
- WHERE child.column_key = '%s'
+ WHERE child.company_id = 1 AND child.column_key = '%s'
""".formatted(menu.parentKey(), menu.name(), menu.sortOrder(), menu.columnKey()));
}
}
@@ -160,16 +182,16 @@ public class PermissionMenuSchemaInitializer {
private void ensureDefaultAppMenus() {
for (DefaultAppMenu menu : DEFAULT_APP_MENUS) {
executeQuietly("""
- INSERT INTO columns (name, column_key, menu_type, route_path, sort_order)
- SELECT '%s', '%s', 'app', '%s', %d
+ INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order)
+ SELECT 1, '%s', '%s', 'app', '%s', %d
WHERE NOT EXISTS (
- SELECT 1 FROM columns WHERE column_key = '%s'
+ SELECT 1 FROM columns WHERE company_id = 1 AND column_key = '%s'
)
""".formatted(menu.name(), menu.columnKey(), menu.routePath(), menu.sortOrder(), menu.columnKey()));
executeQuietly("""
UPDATE columns
SET sort_order = %d, route_path = '%s', menu_type = 'app', parent_id = NULL
- WHERE column_key = '%s'
+ WHERE company_id = 1 AND column_key = '%s'
""".formatted(menu.sortOrder(), menu.routePath(), menu.columnKey()));
}
}
@@ -177,55 +199,55 @@ public class PermissionMenuSchemaInitializer {
private void ensureDefaultAppChildMenus() {
// Older migrations used underscore keys for a few app pages. Normalize
// them once so the frontend item key and permission key stay aligned.
- executeQuietly("UPDATE columns SET column_key = 'collect-data' WHERE column_key = 'collect_data'");
- executeQuietly("UPDATE columns SET column_key = 'appearance-patent' WHERE column_key = 'appearance_patent'");
- executeQuietly("UPDATE columns SET column_key = 'similar-asin' WHERE column_key = 'similar_asin'");
+ executeQuietly("UPDATE columns SET column_key = 'collect-data' WHERE company_id = 1 AND column_key = 'collect_data'");
+ executeQuietly("UPDATE columns SET column_key = 'appearance-patent' WHERE company_id = 1 AND column_key = 'appearance_patent'");
+ executeQuietly("UPDATE columns SET column_key = 'similar-asin' WHERE company_id = 1 AND column_key = 'similar_asin'");
for (DefaultAppChildMenu menu : DEFAULT_APP_CHILD_MENUS) {
executeQuietly("""
- INSERT INTO columns (name, column_key, menu_type, route_path, sort_order, parent_id)
- SELECT '%s', '%s', 'app', '%s', %d, parent.id
+ INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order, parent_id)
+ SELECT 1, '%s', '%s', 'app', '%s', %d, parent.id
FROM columns parent
- WHERE parent.column_key = '%s'
+ WHERE parent.company_id = 1 AND parent.column_key = '%s'
AND NOT EXISTS (
- SELECT 1 FROM columns existing WHERE existing.column_key = '%s'
+ SELECT 1 FROM columns existing WHERE existing.company_id = 1 AND existing.column_key = '%s'
)
""".formatted(menu.name(), menu.columnKey(), menu.routePath(), menu.sortOrder(),
menu.parentKey(), menu.columnKey()));
executeQuietly("""
UPDATE columns child
- JOIN columns parent ON parent.column_key = '%s'
+ JOIN columns parent ON parent.company_id = 1 AND parent.column_key = '%s'
SET child.name = '%s', child.menu_type = 'app', child.route_path = '%s',
child.sort_order = %d, child.parent_id = parent.id
- WHERE child.column_key = '%s'
+ WHERE child.company_id = 1 AND child.column_key = '%s'
""".formatted(menu.parentKey(), menu.name(), menu.routePath(), menu.sortOrder(), menu.columnKey()));
}
}
private void ensureInternalDataPermissions() {
executeQuietly("""
- INSERT INTO columns (name, column_key, menu_type, route_path, sort_order)
- SELECT '视频任务数据查看', 'admin_image_video_task_data', 'internal', 'image-video-task-data', 0
+ INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order)
+ SELECT 1, '视频任务数据查看', 'admin_image_video_task_data', 'internal', 'image-video-task-data', 0
WHERE NOT EXISTS (
- SELECT 1 FROM columns WHERE column_key = 'admin_image_video_task_data'
+ SELECT 1 FROM columns WHERE company_id = 1 AND column_key = 'admin_image_video_task_data'
)
""");
}
private boolean ensureShopDataCrawlAdminDefaults() {
executeQuietly("""
- INSERT INTO columns (name, column_key, menu_type, route_path, sort_order, parent_id)
- SELECT '店铺数据记录', 'admin_shop_data_crawl_tasks', 'admin', 'shop-data-crawl-tasks', 82,
- (SELECT id FROM columns WHERE column_key = 'admin_group_shop' LIMIT 1)
+ INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order, parent_id)
+ SELECT 1, '店铺数据记录', 'admin_shop_data_crawl_tasks', 'admin', 'shop-data-crawl-tasks', 82,
+ (SELECT id FROM columns WHERE company_id = 1 AND column_key = 'admin_group_shop' LIMIT 1)
WHERE NOT EXISTS (
- SELECT 1 FROM columns WHERE column_key = 'admin_shop_data_crawl_tasks'
+ SELECT 1 FROM columns WHERE company_id = 1 AND column_key = 'admin_shop_data_crawl_tasks'
)
""");
return executeUpdateQuietly("""
- INSERT INTO columns (name, column_key, menu_type, route_path, sort_order)
- SELECT '店铺数据任务数据查看', 'admin_shop_data_crawl_task_data', 'internal', 'shop-data-crawl-task-data', 0
+ INSERT INTO columns (company_id, name, column_key, menu_type, route_path, sort_order)
+ SELECT 1, '店铺数据任务数据查看', 'admin_shop_data_crawl_task_data', 'internal', 'shop-data-crawl-task-data', 0
WHERE NOT EXISTS (
- SELECT 1 FROM columns WHERE column_key = 'admin_shop_data_crawl_task_data'
+ SELECT 1 FROM columns WHERE company_id = 1 AND column_key = 'admin_shop_data_crawl_task_data'
)
""") > 0;
}
@@ -236,7 +258,8 @@ public class PermissionMenuSchemaInitializer {
SELECT old_perm.user_id, data_col.id
FROM user_column_permission old_perm
INNER JOIN columns old_col ON old_col.id = old_perm.column_id
- INNER JOIN columns data_col ON data_col.column_key = 'admin_shop_data_crawl_task_data'
+ INNER JOIN columns data_col ON data_col.company_id = old_col.company_id
+ AND data_col.column_key = 'admin_shop_data_crawl_task_data'
LEFT JOIN user_column_permission existing
ON existing.user_id = old_perm.user_id
AND existing.column_id = data_col.id
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java
index 3381db8b9..5b1496109 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java
@@ -79,9 +79,24 @@ public class PermissionMenuService {
* 一旦可勾,「勾父覆盖全部后代」就会把树上未展示的范围外菜单一起授出去。
* 保存侧必须配套按操作者范围替换,见
* {@link #updateUserColumnPermissions(AdminUserEntity, Long, UserColumnPermissionUpdateRequest, String, boolean)}。
+ * @param requestedCompanyId V149 目录页的公司 tab:站点超管可指定任意公司的树;非超管传别家 403,
+ * 不传就锁本公司。缺省值不是"全公司"——每家公司一套树之后,跨公司的目录混在一起
+ * 等于让 {@code column_key} 在同一个响应里出现两次,前端按 key 建树会直接长错。
*/
+ public List list(AdminUserEntity operator, String menuType,
+ boolean grantableOnly, Long requestedCompanyId) {
+ Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
+ return listAt(companyId, operator, menuType, grantableOnly);
+ }
+
public List list(AdminUserEntity operator, String menuType, boolean grantableOnly) {
- List menus = loadMenus(menuType);
+ return list(operator, menuType, grantableOnly, null);
+ }
+
+ /** 目录/授权树的唯一出口:{@code companyId} 为非空时只取那一棵树的行,null 仅留给无操作者的内部调用。 */
+ private List listAt(Long companyId, AdminUserEntity operator,
+ String menuType, boolean grantableOnly) {
+ List menus = loadMenus(companyId, menuType);
Set grantableIds = resolveGrantableMenuIds(operator);
List visibleMenus = menus;
if (grantableOnly && grantableIds != null) {
@@ -109,13 +124,68 @@ public class PermissionMenuService {
/**
* 操作者可授予的菜单 id 全集(自身直接授权 + 其后代)。
*
+ * V149 之后按操作者本公司那棵树展开:授权只会指向本公司的行(迁移第 9 段与
+ * 闸门 3 保证),拿全平台目录去展开等于把别家同名菜单的 id 也算进"可授予",
+ * 那是"范围收窄只做在界面上"的同一类事故。
+ *
* @return null 表示不限制(超管或无操作者)
*/
private Set resolveGrantableMenuIds(AdminUserEntity operator) {
if (operator == null || operator.getId() == null || isSuperAdmin(operator)) {
return null;
}
- return expandDescendantIds(new LinkedHashSet<>(loadDirectColumnIds(operator.getId())), loadMenus(null));
+ return expandDescendantIds(new LinkedHashSet<>(loadDirectColumnIds(operator.getId())),
+ loadMenus(operator.getCompanyId(), null));
+ }
+
+ /**
+ * 归属公司的统一判据(设计文档 §2 D2):不传就锁操作者本公司;站点超管可以显式指定
+ * 任意一家(他今天就在替两家公司共 133 只账号配权限),非超管传别家一律 403。
+ *
+ * 读侧与写侧共用这一个方法:分成两个迟早漂移成「读能看别家、写挡不住」或反过来,
+ * 而那正是 09-13「权限自己没掉」那一族事故的形状。
+ *
+ * {@code null} 只可能来自「没有操作者」的历史内部调用与单测夹具,此时不下公司条件、
+ * 退回换列之前的全量目录语义;生产上 {@code users.company_id} 是 NOT NULL,
+ * 真出现无归属账号由列上的约束喊,不在这里编一个默认公司。
+ *
+ * 公开是为了让控制器在收 {@code company_id} 参数的当场就走这道门(把返回值往下传),
+ * 而不是把裸参数扔进来再靠本类内部兜——{@code CompanyIdParamGoesThroughReadScopeTest}
+ * 认的就是这条出口,控制器少接一次就等于"tab 传了但没人用"。
+ */
+ public Long resolveScopeCompanyId(AdminUserEntity operator, Long requestedCompanyId) {
+ if (requestedCompanyId != null && requestedCompanyId <= 0) {
+ throw new BusinessException("company_id 无效");
+ }
+ if (operator == null || operator.getId() == null) {
+ return requestedCompanyId;
+ }
+ Long operatorCompanyId = operator.getCompanyId();
+ if (requestedCompanyId == null) {
+ return operatorCompanyId;
+ }
+ if (requestedCompanyId.equals(operatorCompanyId) || isSuperAdmin(operator)) {
+ return requestedCompanyId;
+ }
+ throw new BusinessException(403, "无权读写其他公司的菜单");
+ }
+
+ /**
+ * 写侧闸门(§5):非超管只能动本公司那棵树里的行。
+ *
+ * 补这道闸门之前 {@link #ensureAdminOperatorIfPresent} 只判 isAdmin,等于任何管理员
+ * 都能改整张字典;每家公司一棵树之后,跨公司改一行会把别家的菜单搬进自己树里
+ * ({@code column_key} 在两家之间不再全局唯一,只有 id 认得出它属于谁)。
+ * 菜单字典是租户配置,改坏它比跨公司读数据更糟——那家所有账号的权限页一起坏。
+ */
+ private void ensureMenuWritable(AdminUserEntity operator, PermissionMenuEntity menu) {
+ if (operator == null || isSuperAdmin(operator)) {
+ return;
+ }
+ Long menuCompanyId = menu == null ? null : menu.getCompanyId();
+ if (!Objects.equals(menuCompanyId, operator.getCompanyId())) {
+ throw new BusinessException(403, "无权修改其他公司的菜单");
+ }
}
/**
@@ -139,13 +209,25 @@ public class PermissionMenuService {
@Transactional
public PermissionMenuItemVo create(PermissionMenuCreateRequest request) {
- return create(null, request);
+ return create(null, null, request);
}
/** Controller-facing variant; the caller may pass the authenticated admin. */
@Transactional
public PermissionMenuItemVo create(AdminUserEntity operator, PermissionMenuCreateRequest request) {
+ return create(operator, null, request);
+ }
+
+ /**
+ * 新增菜单。归属公司由 {@code requestedCompanyId} 决定,缺省取操作者本公司(设计文档 §5):
+ * 站点超管可以替别家建菜单(今天就是他一人在给 133 只账号配权限),非超管只能在自已公司建,
+ * 传别家 403。绝不靠列上的 DEFAULT 1 兜归属——那等于把别家的菜单静默塞进厦门米椿花。
+ */
+ @Transactional
+ public PermissionMenuItemVo create(AdminUserEntity operator, Long requestedCompanyId,
+ PermissionMenuCreateRequest request) {
ensureAdminOperatorIfPresent(operator);
+ Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
if (request == null) {
throw new BusinessException("菜单参数不能为空");
}
@@ -161,9 +243,9 @@ public class PermissionMenuService {
routePath = generateRoutePath(columnKey);
}
Long parentId = normalizeParentId(request.getParentId());
- ensureParentValid(parentId, null, menuType);
- ensureUniqueColumnKey(columnKey, null);
- ensureUniqueRoutePath(menuType, routePath, null);
+ ensureParentValid(companyId, parentId, null, menuType);
+ ensureUniqueColumnKey(companyId, columnKey, null);
+ ensureUniqueRoutePath(companyId, menuType, routePath, null);
PermissionMenuEntity entity = new PermissionMenuEntity();
entity.setName(name);
@@ -171,7 +253,8 @@ public class PermissionMenuService {
entity.setParentId(parentId);
entity.setMenuType(menuType);
entity.setRoutePath(routePath);
- entity.setSortOrder(resolveSortOrder(menuType, request.getSortOrder(), null));
+ entity.setCompanyId(companyId);
+ entity.setSortOrder(resolveSortOrder(companyId, menuType, request.getSortOrder(), null));
permissionMenuMapper.insert(entity);
return toItemVo(getMenuById(entity.getId()));
}
@@ -186,6 +269,10 @@ public class PermissionMenuService {
public PermissionMenuItemVo update(AdminUserEntity operator, Long id, PermissionMenuUpdateRequest request) {
ensureAdminOperatorIfPresent(operator);
PermissionMenuEntity entity = getMenuById(id);
+ // 归属不接收请求参数:改哪棵树由这一行自己属于谁决定,编辑动作只能把行留在原公司。
+ // 让载荷带 company_id 等于开一条"把别家的菜单搬进自己树"的旁路。
+ ensureMenuWritable(operator, entity);
+ Long companyId = entity.getCompanyId();
if (request == null) {
throw new BusinessException("菜单参数不能为空");
}
@@ -201,17 +288,17 @@ public class PermissionMenuService {
routePath = entity.getRoutePath();
}
Long parentId = normalizeParentId(request.getParentId());
- ensureParentValid(parentId, id, menuType);
+ ensureParentValid(companyId, parentId, id, menuType);
ensureMenuTypeChangeAllowed(entity, menuType);
- ensureUniqueColumnKey(columnKey, id);
- ensureUniqueRoutePath(menuType, routePath, id);
+ ensureUniqueColumnKey(companyId, columnKey, id);
+ ensureUniqueRoutePath(companyId, menuType, routePath, id);
entity.setName(name);
entity.setColumnKey(columnKey);
entity.setParentId(parentId);
entity.setMenuType(menuType);
entity.setRoutePath(routePath);
- entity.setSortOrder(resolveSortOrder(menuType, request.getSortOrder(), id));
+ entity.setSortOrder(resolveSortOrder(companyId, menuType, request.getSortOrder(), id));
permissionMenuMapper.updateById(entity);
return toItemVo(getMenuById(id));
}
@@ -229,6 +316,7 @@ public class PermissionMenuService {
public void delete(AdminUserEntity operator, Long id) {
ensureAdminOperatorIfPresent(operator);
PermissionMenuEntity entity = getMenuById(id);
+ ensureMenuWritable(operator, entity);
Long childCount = permissionMenuMapper.selectCount(new LambdaQueryWrapper()
.eq(PermissionMenuEntity::getParentId, entity.getId()));
if (childCount != null && childCount > 0) {
@@ -243,9 +331,12 @@ public class PermissionMenuService {
/**
* 同级菜单拖拽重排:orderedIds 为同一父级下按新顺序排列的菜单 ID 列表。
* 不在列表中的兄弟节点保持原相对顺序追加在末尾,重排块锚定在原最小 sort_order,避免跨级穿插。
+ *
+ * 兄弟集必须按锚点行的公司筛:每家公司一棵树之后,"同级"这个概念本身就带公司口径,
+ * 混进别家的同名分组会让重排把两棵树的 sort_order 交织在一起(表现为两排同名菜单穿插)。
*/
@Transactional
- public void reorder(List orderedIds) {
+ public void reorder(AdminUserEntity operator, List orderedIds) {
if (orderedIds == null || orderedIds.isEmpty()) {
return;
}
@@ -257,9 +348,13 @@ public class PermissionMenuService {
if (anchor == null) {
throw new BusinessException("菜单不存在");
}
+ ensureAdminOperatorIfPresent(operator);
+ ensureMenuWritable(operator, anchor);
+ Long companyId = anchor.getCompanyId();
Long parentId = anchor.getParentId();
String menuType = anchor.getMenuType();
List siblings = permissionMenuMapper.selectList(new LambdaQueryWrapper()
+ .eq(PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getMenuType, menuType)
.eq(PermissionMenuEntity::getParentId, parentId)
.orderByAsc(PermissionMenuEntity::getSortOrder)
@@ -288,6 +383,88 @@ public class PermissionMenuService {
}
}
+ /**
+ * 给新公司复制一套模板菜单树(父子指向按 {@code column_key} 重映射),与 V149 第 6/7 段同一语义:
+ * 那一版补的是当时已经存在的公司,这一版补的是之后新建的公司。
+ *
+ * 没有它,「公司管理 -> 新增公司」就造出一个零菜单行的租户:那家的账号登录后台侧边栏全空、
+ * 授权树一个勾都没有,而且全程不报错。这正是本次要消灭的那类静默失效,
+ * 所以建树必须是建号公司的同一次写入,不能留成"上线后再手工跑一遍 V149 的复制段"。
+ *
+ * 两趟写:第一趟只管插(父先留空,避开插入顺序),第二趟按 key 把父指向落到本公司新行上
+ * ——与 V149 第 7 段同形,两级三层都成立。幂等:目标公司已有的 key 原样保留,重跑只补差集。
+ *
+ * @param companyId 目标(新)公司
+ * @param templateCompanyId 模板树所属公司,由调用方给操作者本公司,这里不编默认值
+ * @return 本次新插入的行数
+ */
+ @Transactional
+ public int copyTreeFromTemplate(Long companyId, Long templateCompanyId) {
+ if (companyId == null || companyId <= 0) {
+ throw new BusinessException("目标公司 id 不能为空");
+ }
+ if (templateCompanyId == null || templateCompanyId <= 0) {
+ throw new BusinessException("当前账号没有所属公司,无法为新公司复制菜单树");
+ }
+ if (companyId.equals(templateCompanyId)) {
+ return 0;
+ }
+ // 角色内在闸门那几行不进副本(D3):它在任何别家的树里都不该存在,
+ // 连行都没有就没人能勾它,比"有一行但看不见"更干净。
+ List template = loadRawMenus(templateCompanyId, null).stream()
+ .filter(menu -> menu.getId() != null && menu.getColumnKey() != null)
+ .filter(menu -> !SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey()))
+ .toList();
+ if (template.isEmpty()) {
+ throw new BusinessException("模板公司没有可复制的菜单树");
+ }
+ Map targetByKey = new HashMap<>();
+ for (PermissionMenuEntity menu : loadRawMenus(companyId, null)) {
+ if (menu.getColumnKey() != null) {
+ targetByKey.put(menu.getColumnKey(), menu);
+ }
+ }
+ Map templateById = new HashMap<>();
+ template.forEach(menu -> templateById.put(menu.getId(), menu));
+ int inserted = 0;
+ for (PermissionMenuEntity source : template) {
+ if (targetByKey.containsKey(source.getColumnKey())) {
+ continue;
+ }
+ PermissionMenuEntity copy = new PermissionMenuEntity();
+ copy.setCompanyId(companyId);
+ copy.setName(source.getName());
+ copy.setColumnKey(source.getColumnKey());
+ copy.setMenuType(source.getMenuType());
+ copy.setRoutePath(source.getRoutePath());
+ copy.setSortOrder(source.getSortOrder());
+ copy.setParentId(null);
+ permissionMenuMapper.insert(copy);
+ targetByKey.put(copy.getColumnKey(), copy);
+ inserted++;
+ }
+ for (PermissionMenuEntity source : template) {
+ PermissionMenuEntity child = targetByKey.get(source.getColumnKey());
+ PermissionMenuEntity templateParent = templateById.get(source.getParentId());
+ if (child == null || child.getId() == null || templateParent == null) {
+ continue;
+ }
+ PermissionMenuEntity parent = targetByKey.get(templateParent.getColumnKey());
+ if (parent == null || parent.getId() == null || parent.getId().equals(child.getId())) {
+ continue;
+ }
+ if (!Objects.equals(child.getParentId(), parent.getId())) {
+ permissionMenuMapper.update(null, new LambdaUpdateWrapper()
+ .eq(PermissionMenuEntity::getId, child.getId())
+ .set(PermissionMenuEntity::getParentId, parent.getId()));
+ child.setParentId(parent.getId());
+ }
+ }
+ log.info("[menu-tree-copy] 新公司菜单树已建 companyId={} template={} rows={}",
+ companyId, templateCompanyId, inserted);
+ return inserted;
+ }
+
/** Returns only persisted direct grant IDs (never recursively expanded). */
public UserColumnIdsVo getUserColumnIds(Long userId, String menuType) {
return getUserColumnIds(null, userId, menuType);
@@ -314,7 +491,9 @@ public class PermissionMenuService {
AdminUserEntity user = getUserById(userId);
ensureTargetAccessible(operator, user);
- List menus = loadMenus(menuType);
+ // 回填集按目标账号所属公司的那棵树取:授权弹窗里勾的是"这个账号家"的菜单行 id,
+ // 操作者是谁都不该改变这一点(超管替德阳配权限时勾出公司 1 的行 id,就是跨公司授权)。
+ List menus = loadMenus(user.getCompanyId(), menuType);
Map menuMap = menus.stream()
.filter(menu -> menu.getId() != null)
.collect(Collectors.toMap(PermissionMenuEntity::getId, Function.identity(), (left, right) -> left));
@@ -351,7 +530,7 @@ public class PermissionMenuService {
boolean includeAncestorGroups) {
AdminUserEntity user = getUserById(userId);
ensureTargetAccessible(operator, user);
- List menus = loadMenus(menuType);
+ List menus = loadMenus(user.getCompanyId(), menuType);
if (isSuperAdmin(user)) {
return toItemVos(menus, menus);
}
@@ -387,7 +566,12 @@ public class PermissionMenuService {
if (isSuperAdmin(user)) {
return true;
}
- List menus = loadMenus(target.getMenuType());
+ // 跨公司的 column_id 一律判「无权限」:本账号的直接授权里出现别家的行,只可能是载荷被
+ // 拼错(或前端缓存了换键之前的旧 id)。方向是拒绝,不是放行——放宽等于让别家的行 id 生效。
+ if (!Objects.equals(target.getCompanyId(), user.getCompanyId())) {
+ return false;
+ }
+ List menus = loadMenus(target.getCompanyId(), target.getMenuType());
return expandDescendantIds(new LinkedHashSet<>(loadDirectColumnIds(userId)), menus)
.contains(columnId);
}
@@ -397,26 +581,40 @@ public class PermissionMenuService {
*
* 权限页此前一律 `selectList(new LambdaQueryWrapper<>())` 整表拉回,而 admin_user
* 含密码哈希等敏感列,每次打开权限页都把全表(含哈希)读进内存(2026-09-15 优化)。
- * 判定用 role/is_admin/created_by_id,展示用 id/username。
+ * 判定用 role/is_admin/created_by_id,展示用 id/username,按公司筛用 company_id
+ * (V149:数据权限行分属各棵树,用户列表必须同一家,否则「勾了人、写到别家的行」
+ * 会静默落空——页面照旧显示已授权,账号却永远拿不到那份数据)。
*/
- private LambdaQueryWrapper grantableUserQuery() {
+ private LambdaQueryWrapper grantableUserQuery(Long companyId) {
return new LambdaQueryWrapper()
.select(AdminUserEntity::getId,
AdminUserEntity::getUsername,
AdminUserEntity::getRole,
AdminUserEntity::getIsAdmin,
- AdminUserEntity::getCreatedById);
+ AdminUserEntity::getCreatedById,
+ AdminUserEntity::getCompanyId)
+ .eq(companyId != null, AdminUserEntity::getCompanyId, companyId);
}
public List listImageVideoDataPermissionUsers(AdminUserEntity operator) {
+ return listImageVideoDataPermissionUsers(operator, null);
+ }
+
+ /**
+ * 「视频任务数据查看」这一项内部数据权限的分公司读口:超管切到哪家公司就解析那棵树的行,
+ * 用户列表同步按那一家筛({@link #grantableUserQuery(Long)})。
+ */
+ public List listImageVideoDataPermissionUsers(AdminUserEntity operator,
+ Long requestedCompanyId) {
ensureSuperAdminOperator(operator);
- PermissionMenuEntity dataPermission = requireImageVideoDataPermission();
+ Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
+ PermissionMenuEntity dataPermission = requireImageVideoDataPermission(companyId);
Set grantedUserIds = userColumnPermissionMapper.selectByColumnId(dataPermission.getId())
.stream()
.map(UserColumnPermissionEntity::getUserId)
.filter(id -> id != null && id > 0)
.collect(Collectors.toSet());
- return adminUserMapper.selectList(grantableUserQuery()
+ return adminUserMapper.selectList(grantableUserQuery(companyId)
.orderByAsc(AdminUserEntity::getUsername)
.orderByAsc(AdminUserEntity::getId))
.stream()
@@ -427,10 +625,22 @@ public class PermissionMenuService {
@Transactional
public int updateImageVideoDataPermissionUsers(AdminUserEntity operator, List userIds) {
+ return updateImageVideoDataPermissionUsers(operator, null, userIds);
+ }
+
+ /**
+ * 整分区替换本公司的那一条内部数据权限授权。别家的账号 id 会落进
+ * 「contains unknown or non-grantable user」——用户列表已经按公司筛过,
+ * 这不是新报错,是既有的那条从严判定现在有了公司口径。
+ */
+ @Transactional
+ public int updateImageVideoDataPermissionUsers(AdminUserEntity operator, Long requestedCompanyId,
+ List userIds) {
ensureSuperAdminOperator(operator);
- PermissionMenuEntity dataPermission = requireImageVideoDataPermission();
+ Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
+ PermissionMenuEntity dataPermission = requireImageVideoDataPermission(companyId);
List requestedIds = normalizeColumnIds(userIds);
- List users = adminUserMapper.selectList(grantableUserQuery());
+ List users = adminUserMapper.selectList(grantableUserQuery(companyId));
Map grantableUsers = users.stream()
.filter(user -> user.getId() != null && !isSuperAdmin(user))
.collect(Collectors.toMap(AdminUserEntity::getId, Function.identity(), (left, right) -> left));
@@ -448,15 +658,22 @@ public class PermissionMenuService {
}
public List listShopDataCrawlDataPermissionUsers(AdminUserEntity operator) {
+ return listShopDataCrawlDataPermissionUsers(operator, null);
+ }
+
+ /** 与视频任务那一路同口径:内部数据权限行与用户列表必须解析到同一家公司。 */
+ public List listShopDataCrawlDataPermissionUsers(AdminUserEntity operator,
+ Long requestedCompanyId) {
ensureSuperAdminOperator(operator, "店铺数据任务");
+ Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
PermissionMenuEntity dataPermission = requireDataPermission(
- SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
+ companyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
Set grantedUserIds = userColumnPermissionMapper.selectByColumnId(dataPermission.getId())
.stream()
.map(UserColumnPermissionEntity::getUserId)
.filter(id -> id != null && id > 0)
.collect(Collectors.toSet());
- return adminUserMapper.selectList(grantableUserQuery()
+ return adminUserMapper.selectList(grantableUserQuery(companyId)
.orderByAsc(AdminUserEntity::getUsername)
.orderByAsc(AdminUserEntity::getId))
.stream()
@@ -467,11 +684,18 @@ public class PermissionMenuService {
@Transactional
public int updateShopDataCrawlDataPermissionUsers(AdminUserEntity operator, List userIds) {
+ return updateShopDataCrawlDataPermissionUsers(operator, null, userIds);
+ }
+
+ @Transactional
+ public int updateShopDataCrawlDataPermissionUsers(AdminUserEntity operator, Long requestedCompanyId,
+ List userIds) {
ensureSuperAdminOperator(operator, "店铺数据任务");
+ Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
PermissionMenuEntity dataPermission = requireDataPermission(
- SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
+ companyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
List requestedIds = normalizeColumnIds(userIds);
- List users = adminUserMapper.selectList(grantableUserQuery());
+ List users = adminUserMapper.selectList(grantableUserQuery(companyId));
Map grantableUsers = users.stream()
.filter(user -> user.getId() != null && !isSuperAdmin(user))
.collect(Collectors.toMap(AdminUserEntity::getId, Function.identity(), (left, right) -> left));
@@ -505,12 +729,15 @@ public class PermissionMenuService {
if (isSuperAdmin(operator)) {
return;
}
+ // 三行都按操作者本公司解析:换键之后同一个 key 每家公司各一行,
+ // 少带条件就是 LIMIT 1 跨公司借位(§4 里最危险的那处静默失效)。
+ Long companyId = operator.getCompanyId();
PermissionMenuEntity taskMenu = requireDataPermission(
- "admin_shop_data_crawl_tasks", "店铺数据任务管理菜单");
+ companyId, "admin_shop_data_crawl_tasks", "店铺数据任务管理菜单");
PermissionMenuEntity duplicateCheckMenu = requireDataPermission(
- "admin_shop_data_duplicate_check", "店铺数据重复检查菜单");
+ companyId, "admin_shop_data_duplicate_check", "店铺数据重复检查菜单");
PermissionMenuEntity dataPermission = requireDataPermission(
- SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
+ companyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY, "店铺数据任务数据");
boolean hasShopDataMenu = hasEffectiveColumnPermission(operator.getId(), taskMenu.getId())
|| hasEffectiveColumnPermission(operator.getId(), duplicateCheckMenu.getId());
if (!hasShopDataMenu || !hasEffectiveColumnPermission(operator.getId(), dataPermission.getId())) {
@@ -532,7 +759,8 @@ public class PermissionMenuService {
if (isSuperAdmin(operator)) {
return;
}
- PermissionMenuEntity menu = requireDataPermission("admin_task_center", "客户端任务管理菜单");
+ PermissionMenuEntity menu = requireDataPermission(
+ operator.getCompanyId(), "admin_task_center", "客户端任务管理菜单");
if (!hasEffectiveColumnPermission(operator.getId(), menu.getId())) {
throw new BusinessException(403, "无权查看客户端任务管理");
}
@@ -549,7 +777,7 @@ public class PermissionMenuService {
if (isSuperAdmin(operator)) {
return true;
}
- List menus = loadMenus(MENU_TYPE_ADMIN);
+ List menus = loadMenus(operator.getCompanyId(), MENU_TYPE_ADMIN);
List wantedIds = menus.stream()
.filter(menu -> menu.getColumnKey() != null && columnKeys.contains(menu.getColumnKey()))
.map(PermissionMenuEntity::getId)
@@ -606,8 +834,11 @@ public class PermissionMenuService {
AdminUserEntity target = getUserById(userId);
ensureTargetAccessible(operator, target);
List requestedIds = request == null ? List.of() : normalizeColumnIds(request.getColumnIds());
+ // 整条链的归属口径 = 目标账号自己那棵树(不是操作者的):超管替德阳配权限时,
+ // 勾选与落库都必须指向德阳的菜单行 id,否则写进去的授权在本公司的树上认不出来。
+ Long targetCompanyId = target.getCompanyId();
// 出口 3(提交授权):超管专属项在这里被剥掉,越权校验与落库都看不到它(剥而不拒)。
- requestedIds = stripSuperAdminOnlyGrantIds(requestedIds, operator);
+ requestedIds = stripSuperAdminOnlyGrantIds(requestedIds, operator, targetCompanyId);
String normalizedType = menuType == null || menuType.isBlank()
? null
: normalizeMenuTypeRequired(menuType);
@@ -616,13 +847,14 @@ public class PermissionMenuService {
if (normalizedType == null) {
if (!requestedIds.isEmpty()) {
Long validCount = permissionMenuMapper.selectCount(new LambdaQueryWrapper()
+ .eq(PermissionMenuEntity::getCompanyId, targetCompanyId)
.in(PermissionMenuEntity::getId, requestedIds));
if (validCount == null || validCount != requestedIds.size()) {
throw new BusinessException("存在无效的菜单权限项");
}
}
} else {
- scopedMenuIds.addAll(loadMenus(normalizedType).stream()
+ scopedMenuIds.addAll(loadMenus(targetCompanyId, normalizedType).stream()
.map(PermissionMenuEntity::getId)
.filter(Objects::nonNull)
.toList());
@@ -633,9 +865,9 @@ public class PermissionMenuService {
Set protectedIds = new LinkedHashSet<>();
if (normalizedType == null) {
- PermissionMenuEntity imageVideoDataPermission = findImageVideoDataPermission();
+ PermissionMenuEntity imageVideoDataPermission = findImageVideoDataPermission(targetCompanyId);
PermissionMenuEntity shopDataCrawlDataPermission =
- findDataPermission(SHOP_DATA_CRAWL_DATA_PERMISSION_KEY);
+ findDataPermission(targetCompanyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY);
if (imageVideoDataPermission != null && imageVideoDataPermission.getId() != null) {
protectedIds.add(imageVideoDataPermission.getId());
}
@@ -686,7 +918,8 @@ public class PermissionMenuService {
userColumnPermissionMapper.insert(entity);
}
if (MENU_TYPE_ADMIN.equals(normalizedType)) {
- autoGrantShopDataDataPermission(userId, finalGrantIds, loadMenus(MENU_TYPE_ADMIN));
+ autoGrantShopDataDataPermission(userId, finalGrantIds,
+ loadMenus(targetCompanyId, MENU_TYPE_ADMIN), targetCompanyId);
}
// 目标管理员的权限被回收后,其直接创建的员工若仍持有超出范围的
@@ -712,13 +945,13 @@ public class PermissionMenuService {
* 只增不删:数据授权的回收仍走超管专用的「数据范围授权」UI。
*/
private void autoGrantShopDataDataPermission(Long userId, Set directGrantIds,
- List adminMenus) {
+ List adminMenus, Long companyId) {
if (directGrantIds.isEmpty() || adminMenus.isEmpty()) {
return;
}
- PermissionMenuEntity taskMenu = findDataPermission("admin_shop_data_crawl_tasks");
- PermissionMenuEntity duplicateCheckMenu = findDataPermission("admin_shop_data_duplicate_check");
- PermissionMenuEntity dataPermission = findDataPermission(SHOP_DATA_CRAWL_DATA_PERMISSION_KEY);
+ PermissionMenuEntity taskMenu = findDataPermission(companyId, "admin_shop_data_crawl_tasks");
+ PermissionMenuEntity duplicateCheckMenu = findDataPermission(companyId, "admin_shop_data_duplicate_check");
+ PermissionMenuEntity dataPermission = findDataPermission(companyId, SHOP_DATA_CRAWL_DATA_PERMISSION_KEY);
if (dataPermission == null || dataPermission.getId() == null) {
return;
}
@@ -755,12 +988,16 @@ public class PermissionMenuService {
if (target == null || target.getId() == null || isSuperAdmin(target)) {
return;
}
+ Long companyId = target.getCompanyId();
Set targetEffectiveIds = expandDescendantIds(
- new LinkedHashSet<>(loadDirectColumnIds(target.getId())), loadMenus(null));
- // 只用到 id:不要为一次级联清理把整表(含密码哈希)拉回
+ new LinkedHashSet<>(loadDirectColumnIds(target.getId())), loadMenus(companyId, null));
+ // 只用到 id:不要为一次级联清理把整表(含密码哈希)拉回。
+ // 下属集要同时按公司筛:这段是批量删除,一旦 created_by 出现跨公司的脏数据,
+ // "越权"判定就会拿 A 家的有效集去删 B 家员工的授权——删多隔离比删少更贵。
List subordinates = adminUserMapper.selectList(new LambdaQueryWrapper()
.select(AdminUserEntity::getId)
- .eq(AdminUserEntity::getCreatedById, target.getId()));
+ .eq(AdminUserEntity::getCreatedById, target.getId())
+ .eq(companyId != null, AdminUserEntity::getCompanyId, companyId));
for (AdminUserEntity subordinate : subordinates) {
Long subordinateId = subordinate.getId();
if (subordinateId == null || subordinateId.equals(target.getId())) {
@@ -782,8 +1019,14 @@ public class PermissionMenuService {
}
}
- private List loadMenus(String menuType) {
- List rows = loadRawMenus(menuType);
+ /**
+ * 目录取数的唯一出口(§4):{@code companyId} 非空时只返回那一棵树的行。
+ * 授权树、有效菜单、可授予全集、越权判定都从这里取数,所以公司收窄改这一处就够一片。
+ *
+ * @param companyId null 只来自「无操作者 / 无归属」的历史与测试路径,此时退回全量目录
+ */
+ private List loadMenus(Long companyId, String menuType) {
+ List rows = loadRawMenus(companyId, menuType);
if (rows == null || rows.isEmpty()) {
return List.of();
}
@@ -794,13 +1037,14 @@ public class PermissionMenuService {
}
/**
- * Fetches every menu (optionally scoped to one type) in insertion order.
- * Sorting happens in {@link #loadMenus(String)} and only for hierarchies
+ * Fetches every menu (optionally scoped to one company and one type) in insertion order.
+ * Sorting happens in {@link #loadMenus(Long, String)} and only for hierarchies
* that actually need one, keeping raw SQL and comparator semantics in sync.
*/
- private List loadRawMenus(String menuType) {
+ private List loadRawMenus(Long companyId, String menuType) {
String normalizedType = normalizeMenuType(menuType);
LambdaQueryWrapper query = new LambdaQueryWrapper()
+ .eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(normalizedType != null, PermissionMenuEntity::getMenuType, normalizedType)
.orderByAsc(PermissionMenuEntity::getSortOrder)
.orderByAsc(PermissionMenuEntity::getId);
@@ -1006,11 +1250,12 @@ public class PermissionMenuService {
* 唯一例外是超管且 menuType 为空的「整树替换」分支:{@code deleteByUserId} 先清空目标整个
* 分区再按提交重插,被剥的这条按既有语义就不会回来——那是该分支本来就有的行为,不是剥离引入的。
*/
- private List stripSuperAdminOnlyGrantIds(List requestedIds, AdminUserEntity operator) {
+ private List stripSuperAdminOnlyGrantIds(List requestedIds, AdminUserEntity operator,
+ Long companyId) {
if (requestedIds.isEmpty()) {
return requestedIds;
}
- Set restricted = superAdminOnlyMenuIds();
+ Set restricted = superAdminOnlyMenuIds(companyId);
if (restricted.isEmpty()) {
return requestedIds;
}
@@ -1029,8 +1274,12 @@ public class PermissionMenuService {
* 一次全量目录查询折出来,绝不按 id 逐条点查:保存权限这个入口上 N 次点查会被日志放大,
* 而 {@code findDataPermission} 每次都是一个 {@code selectOne}。
*/
- private Set superAdminOnlyMenuIds() {
- return loadMenus(null).stream()
+ /**
+ * V149 之后这行闸门菜单只存在于公司 1 的树里(§2 D3:副本不复制它),所以别家公司
+ * 拿到的是空集——那里的提交里本来就不可能有它,剥离逻辑照常走完,不多一条分支。
+ */
+ private Set superAdminOnlyMenuIds(Long companyId) {
+ return loadMenus(companyId, null).stream()
.filter(menu -> SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey()))
.map(PermissionMenuEntity::getId)
.collect(Collectors.toCollection(LinkedHashSet::new));
@@ -1073,12 +1322,12 @@ public class PermissionMenuService {
return !Integer.valueOf(1).equals(user.getIsAdmin());
}
- private PermissionMenuEntity findImageVideoDataPermission() {
- return findDataPermission(IMAGE_VIDEO_DATA_PERMISSION_KEY);
+ private PermissionMenuEntity findImageVideoDataPermission(Long companyId) {
+ return findDataPermission(companyId, IMAGE_VIDEO_DATA_PERMISSION_KEY);
}
- private PermissionMenuEntity requireImageVideoDataPermission() {
- PermissionMenuEntity permission = findImageVideoDataPermission();
+ private PermissionMenuEntity requireImageVideoDataPermission(Long companyId) {
+ PermissionMenuEntity permission = findImageVideoDataPermission(companyId);
if (permission == null || permission.getId() == null) {
throw new BusinessException("视频任务数据权限尚未初始化");
}
@@ -1099,14 +1348,20 @@ public class PermissionMenuService {
}
}
- private PermissionMenuEntity findDataPermission(String columnKey) {
+ /**
+ * 按 key 点查一行菜单。必须带公司:V149 之后同一个 key 在每家公司各有一行,
+ * 少了这个条件就是 {@code LIMIT 1} 跨公司借位——拿到别家的行 id 再往本账号身上写一条
+ * 本公司树里认不出的授权,页面显示"已授权"、权限却永远不生效,且不报任何错。
+ */
+ private PermissionMenuEntity findDataPermission(Long companyId, String columnKey) {
return permissionMenuMapper.selectOne(new LambdaQueryWrapper()
+ .eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getColumnKey, columnKey)
.last("LIMIT 1"));
}
- private PermissionMenuEntity requireDataPermission(String columnKey, String displayName) {
- PermissionMenuEntity permission = findDataPermission(columnKey);
+ private PermissionMenuEntity requireDataPermission(Long companyId, String columnKey, String displayName) {
+ PermissionMenuEntity permission = findDataPermission(companyId, columnKey);
if (permission == null || permission.getId() == null) {
throw new BusinessException(displayName + "权限尚未初始化");
}
@@ -1126,7 +1381,7 @@ public class PermissionMenuService {
return vo;
}
- private void ensureParentValid(Long parentId, Long currentId, String menuType) {
+ private void ensureParentValid(Long companyId, Long parentId, Long currentId, String menuType) {
if (parentId == null) {
return;
}
@@ -1151,6 +1406,11 @@ public class PermissionMenuService {
if (currentId != null && currentId.equals(cursor.getId())) {
throw new BusinessException("父级菜单不能选择自己的子级");
}
+ // fk_columns_parent_id 只保证父行存在,挡不住跨公司挂父(§3.6),同公司判定只能做在这里。
+ // 整条祖先链都判:一个同公司的父、上面挂着别家的分组,落库后这行在两棵树里都渲染不出。
+ if (companyId != null && !companyId.equals(cursor.getCompanyId())) {
+ throw new BusinessException("父级菜单必须与当前菜单属于同一公司");
+ }
Long ancestorId = cursor.getParentId();
if (ancestorId == null) {
break;
@@ -1173,8 +1433,10 @@ public class PermissionMenuService {
}
}
- private void ensureUniqueColumnKey(String columnKey, Long excludeId) {
+ /** 查重范围 = 本公司(与 {@code uk_company_column_key} 同一条键)。不加条件会拿别家的副本误报"已存在"。 */
+ private void ensureUniqueColumnKey(Long companyId, String columnKey, Long excludeId) {
PermissionMenuEntity exists = permissionMenuMapper.selectOne(new LambdaQueryWrapper()
+ .eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getColumnKey, columnKey)
.last("LIMIT 1"));
if (exists != null && (excludeId == null || !excludeId.equals(exists.getId()))) {
@@ -1182,8 +1444,10 @@ public class PermissionMenuService {
}
}
- private void ensureUniqueRoutePath(String menuType, String routePath, Long excludeId) {
+ /** 同上,对应 {@code uk_company_menu_type_route_path}。 */
+ private void ensureUniqueRoutePath(Long companyId, String menuType, String routePath, Long excludeId) {
PermissionMenuEntity exists = permissionMenuMapper.selectOne(new LambdaQueryWrapper()
+ .eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getMenuType, menuType)
.eq(PermissionMenuEntity::getRoutePath, routePath)
.last("LIMIT 1"));
@@ -1297,7 +1561,7 @@ public class PermissionMenuService {
}
private PermissionMenuItemVo toItemVo(PermissionMenuEntity entity) {
- return toItemVos(List.of(entity), loadMenus(entity.getMenuType())).getFirst();
+ return toItemVos(List.of(entity), loadMenus(entity.getCompanyId(), entity.getMenuType())).getFirst();
}
private PermissionMenuItemVo toItemVo(PermissionMenuEntity entity,
@@ -1333,14 +1597,16 @@ public class PermissionMenuService {
/**
* Resolves the default sort order when none is supplied, scoped to the
* menu's own type (parent takes precedence, then hierarchy ancestors).
- * The DB query mirrors {@link #loadMenus(String)} ordering so the last row
- * is the true tail of the type's ordering.
+ * The DB query mirrors {@link #loadMenus(Long, String)} ordering so the last row
+ * is the true tail of the type's ordering, and the same company the new row lands in
+ * (两棵树的 sort_order 各排各的,跨公司取 MAX 会让两排同名菜单交织)。
*/
- private Integer resolveSortOrder(String menuType, Integer sortOrder, Long excludeId) {
+ private Integer resolveSortOrder(Long companyId, String menuType, Integer sortOrder, Long excludeId) {
if (sortOrder != null) {
return sortOrder;
}
PermissionMenuEntity tail = permissionMenuMapper.selectOne(new LambdaQueryWrapper()
+ .eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getMenuType, normalizeMenuType(menuType))
.ne(excludeId != null, PermissionMenuEntity::getId, excludeId)
.orderByDesc(PermissionMenuEntity::getSortOrder)
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/controller/ProductCategoryController.java b/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/controller/ProductCategoryController.java
index ae068b4c0..b0eb8a751 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/controller/ProductCategoryController.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/controller/ProductCategoryController.java
@@ -1,8 +1,6 @@
package com.nanri.aiimage.modules.productcategory.controller;
import com.nanri.aiimage.common.api.ApiResponse;
-import com.nanri.aiimage.common.model.entity.AdminUserEntity;
-import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.common.util.DownloadHeaderUtil;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
@@ -10,7 +8,6 @@ import com.nanri.aiimage.modules.productcategory.model.vo.ProductCategoryItemVo;
import com.nanri.aiimage.modules.productcategory.model.vo.ProductCategoryListVo;
import com.nanri.aiimage.modules.productcategory.service.ProductCategoryService;
import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
@@ -34,24 +31,21 @@ import java.time.format.DateTimeFormatter;
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/admin")
-@Tag(name = "商品类目管理", description = "维护商品类目树")
+@Tag(name = "商品类目管理", description = "维护商品类目树(全平台共享,不按公司区分)")
public class ProductCategoryController {
private static final DateTimeFormatter EXPORT_FILENAME_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss");
private final ProductCategoryService productCategoryService;
private final AdminAuthSupport adminAuthSupport;
- private final DataReadScope dataReadScope;
@GetMapping("/product-categories")
@Operation(summary = "查询商品类目树")
public ApiResponse list(
HttpServletRequest request,
- @RequestParam(value = "keyword", required = false) String keyword,
- @Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId) {
- AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
- Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
- return ApiResponse.success(productCategoryService.list(keyword, scopedCompanyId));
+ @RequestParam(value = "keyword", required = false) String keyword) {
+ adminAuthSupport.requireAdminOrInternal(request);
+ return ApiResponse.success(productCategoryService.list(keyword));
}
@GetMapping("/product-categories/children")
@@ -60,11 +54,9 @@ public class ProductCategoryController {
HttpServletRequest request,
@RequestParam(value = "parent_id", required = false) Long parentId,
@RequestParam(value = "page", defaultValue = "1") Long page,
- @RequestParam(value = "page_size", defaultValue = "20") Long pageSize,
- @Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId) {
- AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
- Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
- return ApiResponse.success(productCategoryService.children(parentId, page, pageSize, scopedCompanyId));
+ @RequestParam(value = "page_size", defaultValue = "20") Long pageSize) {
+ adminAuthSupport.requireAdminOrInternal(request);
+ return ApiResponse.success(productCategoryService.children(parentId, page, pageSize));
}
@GetMapping("/product-categories/search")
@@ -73,22 +65,18 @@ public class ProductCategoryController {
HttpServletRequest request,
@RequestParam(value = "keyword", required = false) String keyword,
@RequestParam(value = "page", defaultValue = "1") Long page,
- @RequestParam(value = "page_size", defaultValue = "20") Long pageSize,
- @Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId) {
- AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
- Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
- return ApiResponse.success(productCategoryService.search(keyword, page, pageSize, scopedCompanyId));
+ @RequestParam(value = "page_size", defaultValue = "20") Long pageSize) {
+ adminAuthSupport.requireAdminOrInternal(request);
+ return ApiResponse.success(productCategoryService.search(keyword, page, pageSize));
}
@GetMapping("/product-categories/export")
@Operation(summary = "导出商品类目")
public ResponseEntity export(
HttpServletRequest request,
- @RequestParam(value = "keyword", required = false) String keyword,
- @Parameter(description = "公司 ID") @RequestParam(name = "company_id", required = false) Long companyId) {
- AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
- Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
- byte[] bytes = productCategoryService.export(keyword, scopedCompanyId);
+ @RequestParam(value = "keyword", required = false) String keyword) {
+ adminAuthSupport.requireAdminOrInternal(request);
+ byte[] bytes = productCategoryService.export(keyword);
String filename = "product-categories-" + LocalDateTime.now().format(EXPORT_FILENAME_FORMATTER) + ".xlsx";
return ResponseEntity.ok()
.header(HttpHeaders.CONTENT_DISPOSITION, DownloadHeaderUtil.contentDisposition(filename))
@@ -102,10 +90,8 @@ public class ProductCategoryController {
public ApiResponse create(
HttpServletRequest request,
@Valid @RequestBody ProductCategorySaveRequest body) {
- // 归属只从会话推(请求体一律不带 company_id):service 里 requireCompanyId 取不到就抛,
- // 不让 V147 的 DEFAULT 1 静默兜住。
- AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
- return ApiResponse.success("创建成功", productCategoryService.create(body, operator.getId()));
+ adminAuthSupport.requireAdminOrInternal(request);
+ return ApiResponse.success("创建成功", productCategoryService.create(body));
}
@PutMapping("/product-category/{id}")
@@ -114,10 +100,8 @@ public class ProductCategoryController {
HttpServletRequest request,
@PathVariable Long id,
@Valid @RequestBody ProductCategorySaveRequest body) {
- // 写侧闸门与读侧同源:读已经收窄到本公司,写不收窄就是"藏起来的行照样能删"。
- AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
- return ApiResponse.success("保存成功",
- productCategoryService.update(id, body, dataReadScope.writeCompanyId(operator)));
+ adminAuthSupport.requireAdminOrInternal(request);
+ return ApiResponse.success("保存成功", productCategoryService.update(id, body));
}
@DeleteMapping("/product-category/{id}")
@@ -125,8 +109,8 @@ public class ProductCategoryController {
public ApiResponse delete(
HttpServletRequest request,
@PathVariable Long id) {
- AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
- productCategoryService.delete(id, dataReadScope.writeCompanyId(operator));
+ adminAuthSupport.requireAdminOrInternal(request);
+ productCategoryService.delete(id);
return ApiResponse.success("删除成功", null);
}
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/model/entity/ProductCategoryEntity.java b/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/model/entity/ProductCategoryEntity.java
index 60094d8c6..56961d683 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/model/entity/ProductCategoryEntity.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/model/entity/ProductCategoryEntity.java
@@ -7,20 +7,19 @@ import lombok.Data;
import java.time.LocalDateTime;
+/**
+ * 商品类目——全平台共享的一棵树,不按公司区分(控制方 2026-10-06 定案)。
+ *
+ * 所以这里不声明 {@code company_id} 字段。库里那一列(V147 加的,带临时 {@code DEFAULT 1})
+ * 暂时还在,但没有任何读写路径引用它:不声明字段 ⇒ MyBatis-Plus 的 SELECT 列清单与 INSERT 都不含它
+ * ⇒ 新 jar 配旧库(列还在)不会报错,摘列则必须等两台都跑上这一版(见 migration-inventory 的下一版待办)。
+ */
@Data
@TableName("biz_product_category")
public class ProductCategoryEntity {
@TableId(type = IdType.AUTO)
private Long id;
- /**
- * 归属公司(V147)。{@code 0} = 平台内置共享节点(不是 company 表里的行),其余是那一家的自建节点。
- *
- * 写侧必须显式盖章:这一列在 V147 里带着临时的 {@code DEFAULT 1}(旧 jar 的实体没这字段),
- * 漏传不会报错、会被静默塞进厦门米椿花。{@code ProductCategoryService.create} 因此走
- * {@code CompanyScopeSupport.requireCompanyId}(取不到就抛),不依赖这一默认值。
- */
- private Long companyId;
private Long parentId;
private String name;
private String categoryKey;
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/service/ProductCategoryService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/service/ProductCategoryService.java
index 9ff53cb2a..4eb874ae2 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/service/ProductCategoryService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/productcategory/service/ProductCategoryService.java
@@ -4,7 +4,6 @@ import cn.hutool.crypto.digest.DigestUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
-import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.productcategory.mapper.ProductCategoryMapper;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
import com.nanri.aiimage.modules.productcategory.model.entity.ProductCategoryEntity;
@@ -28,6 +27,7 @@ import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
+import java.util.function.Function;
@Service
@RequiredArgsConstructor
@@ -35,109 +35,71 @@ public class ProductCategoryService {
private static final DateTimeFormatter EXPORT_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
- /**
- * 内置节点的哨兵归属(V147 回填):它不是公司表里的行,而是"所有公司都看得见、谁都不拥有"的那半棵树。
- *
- * 取 0 是因为 {@code company.id} 从 1 起自增,而 {@code CompanyScopeSupport.requireCompanyId}
- * 对 {@code <= 0} 直接抛 ⇒ 没有任何账号会被登记成 0 号公司,这个值和真实公司永不撞。
- */
- static final long SHARED_BUILTIN_COMPANY_ID = 0L;
-
private final ProductCategoryMapper productCategoryMapper;
- private final CompanyScopeSupport companyScopeSupport;
/**
- * 全平台类目树——不按公司筛,且不许改成按公司筛。
+ * 全平台一棵树——不按公司筛,且不许改成按公司筛(控制方 2026-10-06 定案:商品类目共享、不区分)。
*
- * 唯一的消费者是货源/外观的类目归类({@code SimilarAsinLlmService:215 CategoryTree.load(list())})。
- * 那一侧按公司切会同时改两件事:候选节点变少(分类结果按公司分叉)与 prompt 里的类目表变化(影响 LLM 成本)。
- * 后台的公司 tab 走 {@link #list(String, Long)},两件事别混。
+ * 两个消费者共用它:后台这一页,以及货源/外观的类目归类
+ * ({@code SimilarAsinLlmService:215 CategoryTree.load(list())})。后者若按公司切会同时改两件事:
+ * 候选节点变少(分类结果按公司分叉)与 prompt 里的类目表变化(影响 LLM 成本)。
*/
public ProductCategoryListVo list() {
return list(null);
}
- /** 不筛公司(超管没选 tab 时的口径,与改造前一致)。 */
public ProductCategoryListVo list(String keyword) {
- return list(keyword, null);
- }
-
- /**
- * @param companyId 要收窄到的公司;null = 不筛。内置节点({@value #SHARED_BUILTIN_COMPANY_ID})
- * 在任何公司的视图里都可见,否则第 2 家的类目树会是空的、连一个自建根都挂不上。
- */
- public ProductCategoryListVo list(String keyword, Long companyId) {
- List rows = productCategoryMapper.selectList(applyCompanyScope(
+ List rows = productCategoryMapper.selectList(
new LambdaQueryWrapper()
.orderByAsc(ProductCategoryEntity::getParentId)
.orderByAsc(ProductCategoryEntity::getSortOrder)
- .orderByAsc(ProductCategoryEntity::getId),
- companyId));
+ .orderByAsc(ProductCategoryEntity::getId));
rows = filterRowsByKeyword(rows, keyword);
return buildListVo(rows);
}
public ProductCategoryListVo children(Long parentId, long page, long pageSize) {
- return children(parentId, page, pageSize, null);
- }
-
- public ProductCategoryListVo children(Long parentId, long page, long pageSize, Long companyId) {
long safePage = Math.max(page, 1);
long safePageSize = normalizePageSize(pageSize);
Long normalizedParentId = normalizeParentId(parentId);
- LambdaQueryWrapper countQuery = applyCompanyScope(new LambdaQueryWrapper<>(), companyId);
+ LambdaQueryWrapper countQuery = new LambdaQueryWrapper<>();
applyParentFilter(countQuery, normalizedParentId);
Long total = productCategoryMapper.selectCount(countQuery);
- LambdaQueryWrapper pageQuery = applyCompanyScope(
- new LambdaQueryWrapper()
- .orderByAsc(ProductCategoryEntity::getSortOrder)
- .orderByAsc(ProductCategoryEntity::getId),
- companyId)
+ LambdaQueryWrapper pageQuery = new LambdaQueryWrapper()
+ .orderByAsc(ProductCategoryEntity::getSortOrder)
+ .orderByAsc(ProductCategoryEntity::getId)
.last("LIMIT " + ((safePage - 1) * safePageSize) + ", " + safePageSize);
applyParentFilter(pageQuery, normalizedParentId);
List rows = productCategoryMapper.selectList(pageQuery);
- return buildPageVo(rows, total, safePage, safePageSize, companyId);
+ return buildPageVo(rows, total, safePage, safePageSize);
}
public ProductCategoryListVo search(String keyword, long page, long pageSize) {
- return search(keyword, page, pageSize, null);
- }
-
- public ProductCategoryListVo search(String keyword, long page, long pageSize, Long companyId) {
String normalized = normalizeSearchKeyword(keyword);
if (normalized.isBlank()) {
return emptyPageVo(Math.max(page, 1), normalizePageSize(pageSize));
}
long safePage = Math.max(page, 1);
long safePageSize = normalizePageSize(pageSize);
- Long total = productCategoryMapper.selectCount(buildSearchQuery(normalized, companyId));
- List rows = productCategoryMapper.selectList(buildSearchQuery(normalized, companyId)
+ Long total = productCategoryMapper.selectCount(buildSearchQuery(normalized));
+ List rows = productCategoryMapper.selectList(buildSearchQuery(normalized)
.orderByAsc(ProductCategoryEntity::getParentId)
.orderByAsc(ProductCategoryEntity::getSortOrder)
.orderByAsc(ProductCategoryEntity::getId)
.last("LIMIT " + ((safePage - 1) * safePageSize) + ", " + safePageSize));
- return buildSearchPageVo(rows, total, safePage, safePageSize, companyId);
+ return buildSearchPageVo(rows, total, safePage, safePageSize);
}
- /**
- * 归属由操作者会话推导(请求体/查询参数一律不带 company_id):漏了这一句,新类目就会被
- * V147 的 {@code DEFAULT 1} 静默塞进厦门米椿花——那是"归属失真且不报错",而 {@code requireCompanyId}
- * 取不到公司时是抛,不会返回 null。所以这里不保留不带操作者的重载:留着它等于留着一个
- * "调用方忘了传也照样绿"的出口。
- *
- * @param operatorId 操作者账号 id
- */
+ /** 新建的类目落进全平台共享的那一棵树:谁建的都不记归属,只保证同级不重名。 */
@Transactional
- public ProductCategoryItemVo create(ProductCategorySaveRequest request, Long operatorId) {
+ public ProductCategoryItemVo create(ProductCategorySaveRequest request) {
String name = normalizeRequired(request.getName(), "类目名称不能为空");
Long parentId = normalizeParentId(request.getParentId());
- Long companyId = companyScopeSupport.requireCompanyId(operatorId);
- ensureParentVisible(parentId, null, companyId);
- ensureSiblingNameUnique(parentId, name, null, companyId);
+ ensureParentVisible(parentId, null);
+ ensureSiblingNameUnique(parentId, name, null);
ProductCategoryEntity entity = new ProductCategoryEntity();
- entity.setCompanyId(companyId);
entity.setParentId(parentId);
entity.setName(name);
entity.setCategoryKey(generateCategoryKey(parentId, name));
@@ -148,22 +110,13 @@ public class ProductCategoryService {
return findItem(entity.getId());
}
- /**
- * @param writableCompanyId 行归属闸门({@code DataReadScope.writeCompanyId} 给):
- * {@code null} = 平台超管不限,否则只能动这一家自己的行。
- * 读侧收窄而写侧不收窄="藏起来的行仍然能删",那是静默删除不是隔离。
- */
@Transactional
- public ProductCategoryItemVo update(Long id, ProductCategorySaveRequest request, Long writableCompanyId) {
+ public ProductCategoryItemVo update(Long id, ProductCategorySaveRequest request) {
ProductCategoryEntity entity = getById(id);
- assertRowWritable(entity, writableCompanyId);
String name = normalizeRequired(request.getName(), "类目名称不能为空");
Long parentId = normalizeParentId(request.getParentId());
- // 改行时"生效公司"取行自己的归属,不取 tab:内置行归 0、自建行归那一家,
- // 换父级时不能把行挪到可见集外的节点下面(那会让它从原本看得见它的 tab 里消失)。
- Long companyId = entity.getCompanyId();
- ensureParentVisible(parentId, id, companyId);
- ensureSiblingNameUnique(parentId, name, id, companyId);
+ ensureParentVisible(parentId, id);
+ ensureSiblingNameUnique(parentId, name, id);
entity.setParentId(parentId);
entity.setName(name);
@@ -174,9 +127,8 @@ public class ProductCategoryService {
}
@Transactional
- public void delete(Long id, Long writableCompanyId) {
+ public void delete(Long id) {
ProductCategoryEntity entity = getById(id);
- assertRowWritable(entity, writableCompanyId);
Long childCount = productCategoryMapper.selectCount(new LambdaQueryWrapper()
.eq(ProductCategoryEntity::getParentId, entity.getId()));
if (childCount != null && childCount > 0) {
@@ -185,29 +137,13 @@ public class ProductCategoryService {
productCategoryMapper.deleteById(entity.getId());
}
- /**
- * 行归属闸门。走 {@code assertSameCompany} 而不是在这里比一次:它对本仓所有"按公司写"的闸门
- * 是唯一一份判定,两处各写就会有一处先漂。
- *
- * 内置节点(哨兵 0)在这一支里必然被拒——{@code 0 != 任何真实公司 id},
- * 而"公司账号能改/删平台内置类目"正是这一页最容易出事的一刀:改了它,
- * 所有公司的类目树与货源归类的候选表同一天跟着变。
- */
- private void assertRowWritable(ProductCategoryEntity row, Long writableCompanyId) {
- if (writableCompanyId == null) {
- return;
- }
- companyScopeSupport.assertSameCompany(writableCompanyId, row.getCompanyId(),
- "无权修改该类目:内置类目或别家公司的类目不在本公司的写范围内");
- }
-
private ProductCategoryItemVo findItem(Long id) {
ProductCategoryEntity entity = getById(id);
Long childCount = productCategoryMapper.selectCount(new LambdaQueryWrapper()
.eq(ProductCategoryEntity::getParentId, entity.getId()));
ProductCategoryItemVo item = toItemVo(entity, childCount == null ? 0 : childCount.intValue());
- item.setLevel(resolveLevel(entity));
- item.setPath(resolvePath(entity));
+ item.setLevel(resolveLevel(entity, productCategoryMapper::selectById));
+ item.setPath(resolvePath(entity, productCategoryMapper::selectById));
return item;
}
@@ -236,10 +172,16 @@ public class ProductCategoryService {
return vo;
}
- private ProductCategoryListVo buildPageVo(List rows, Long total, long page, long pageSize, Long companyId) {
- Map childCountById = buildChildCountById(rows, companyId);
+ private ProductCategoryListVo buildPageVo(List rows, Long total, long page, long pageSize) {
+ Map childCountById = buildChildCountById(rows);
+ Map ancestors = loadAncestorIndex(rows);
List items = rows.stream()
- .map(row -> toItemVo(row, childCountById.getOrDefault(row.getId(), 0)))
+ .map(row -> {
+ ProductCategoryItemVo item = toItemVo(row, childCountById.getOrDefault(row.getId(), 0));
+ item.setLevel(resolveLevel(row, ancestors::get));
+ item.setPath(resolvePath(row, ancestors::get));
+ return item;
+ })
.toList();
ProductCategoryListVo vo = new ProductCategoryListVo();
vo.setItems(items);
@@ -251,13 +193,9 @@ public class ProductCategoryService {
return vo;
}
- /** 导出的行集合必须与页面列表同源:都走 {@link #list(String, Long)},否则"tab 里看不见但导出里有"就是第二个真相源。 */
+ /** 导出的行集合必须与页面列表同源:都走 {@link #list(String)},否则"页面里没有但导出里有"就是第二个真相源。 */
public byte[] export(String keyword) {
- return export(keyword, null);
- }
-
- public byte[] export(String keyword, Long companyId) {
- ProductCategoryListVo list = list(keyword, companyId);
+ ProductCategoryListVo list = list(keyword);
List rows = list.getItems() == null ? List.of() : list.getItems();
Map nameById = buildExportNameById(rows);
try (SXSSFWorkbook workbook = new SXSSFWorkbook(100);
@@ -276,13 +214,13 @@ public class ProductCategoryService {
}
}
- private ProductCategoryListVo buildSearchPageVo(List rows, Long total, long page, long pageSize, Long companyId) {
- Map childCountById = buildChildCountById(rows, companyId);
+ private ProductCategoryListVo buildSearchPageVo(List rows, Long total, long page, long pageSize) {
+ Map childCountById = buildChildCountById(rows);
List items = rows.stream()
.map(row -> {
ProductCategoryItemVo item = toItemVo(row, childCountById.getOrDefault(row.getId(), 0));
- item.setLevel(resolveLevel(row));
- item.setPath(resolvePath(row));
+ item.setLevel(resolveLevel(row, productCategoryMapper::selectById));
+ item.setPath(resolvePath(row, productCategoryMapper::selectById));
return item;
})
.toList();
@@ -383,12 +321,8 @@ public class ProductCategoryService {
return time == null ? "" : time.format(EXPORT_TIME_FORMATTER);
}
- /**
- * 列表页的「子类目数」徽章走的是全表聚合(不是内存里那批行),所以它必须和公司视图同源:
- * 不加这一段,第 1 家的父节点上会显示"3 个子类目"而 tab 里只列得出一两个——
- * 数字来自别人的公司,点开却是自己的树。
- */
- private Map buildChildCountById(List rows, Long companyId) {
+ /** 列表页的「子类目数」徽章走全表聚合(不是内存里那批行)——整棵树共享,聚合也就没有"别家的数"这一说。 */
+ private Map buildChildCountById(List rows) {
Map childCountById = new HashMap<>();
if (rows.isEmpty()) {
return childCountById;
@@ -396,9 +330,6 @@ public class ProductCategoryService {
QueryWrapper countQuery = new QueryWrapper()
.select("parent_id", "count(*) AS child_count")
.isNotNull("parent_id");
- if (companyId != null) {
- countQuery.in("company_id", visibleCompanyIds(companyId));
- }
List
+ *
+ * 原先这里还有中间那道 {@code readCompanyId(}:品牌库、商品类目两张物化列表用它在超管身上做
+ * "tab 选哪家"的开关。2026-10-06 控制方定案那两页全平台共享、不区分公司,方法已从
+ * {@code DataReadScope} 删除、全树零消费者,所以这道门连同它的三枚探针一起摘掉——
+ * 判据名单里留一门没有实现者的门,等于给"把公司开关再接回那两张表"预先铺好合规形状。
*/
private static final String READ_OWN_COMPANY_ID_CALL = "readCompanyIdOrOwn(";
+ /**
+ * 第三道正门(10-06 批次 6 补):{@code resolveScopeCompanyId}——菜单字典({@code columns} 每家公司一套树)
+ * 的归属判据。它开在 {@code PermissionMenuService} 上而不是 {@code DataReadScope} 上,理由与 {@code readCompanyIdOrOwn}
+ * 那条"必须是共享方法、不许页里自己写 if"是同一条:读写两侧、{@code loadRawMenus} 的每一个取数、
+ * 建/改/删/排四道写侧闸门全都只从这一个方法拿公司 id,判据分两处迟早漂移成"读能看别家、写挡不住"。
+ *
+ * 与 {@code readCompanyIdOrOwn} 的差别是定案 D2 要求的,不是笔误:超管不传时这道门返回他自己的
+ * 公司(菜单字典没有"混着两家的树一起列"这种视图),非超管传别家时抛 403 而不是静默改成本公司。
+ */
+ private static final String RESOLVE_MENU_SCOPE_CALL = "resolveScopeCompanyId(";
private static final List SCOPE_DOORS =
- List.of(READ_SCOPE_CALL, READ_COMPANY_ID_CALL, READ_OWN_COMPANY_ID_CALL);
+ List.of(READ_SCOPE_CALL, READ_OWN_COMPANY_ID_CALL, RESOLVE_MENU_SCOPE_CALL);
private static final String EXPLICIT_PARAM_NAME = "name = \"company_id\"";
private static final String SNAKE_PARAM = "company_id";
private static final String CAMEL_PARAM = "companyId";
@@ -275,10 +284,11 @@ class CompanyIdParamGoesThroughReadScopeTest {
"if", "for", "while", "switch", "do", "catch", "synchronized", "return", "throw", "else", "try");
/**
- * 断言 D 认的三个被调名:{@code readScope} 是按账号集合给范围的唯一出口,
+ * 断言 D 认的四个被调名:{@code readScope} 是按账号集合给范围的唯一出口,
* {@code resolveScope} 是 Task 11 模板鼓励的"controller 里的私有收口方法"那一形(它内部再去
- * readScope),{@code readCompanyId} 是归属已物化成 {@code company_id} 列那两张表
- * (品牌库、商品类目)的正门(见 {@link #READ_COMPANY_ID_CALL} 的理由)。
+ * readScope),{@code readCompanyIdOrOwn} 是"归属物化成 {@code company_id} 列、可见集不靠账号/分组"
+ * 那一族表(今天只有店铺密钥)的正门(见 {@link #READ_OWN_COMPANY_ID_CALL} 的理由),
+ * {@code resolveScopeCompanyId} 是菜单字典那一棵树一套的归属判据(见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由)。
* 除此之外的调用都不算"把公司参数交给了出口"——尤其 {@code readScope(operator, null)} 里那个 {@code null}。
*/
private static final String RESOLVE_SCOPE_CALL = "resolveScope(";
@@ -288,7 +298,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 那就等于一条会自己漂红的用例。
*/
private static final List SCOPE_CALLEE_NAMES =
- List.of("readScope", "resolveScope", "readCompanyId", "readCompanyIdOrOwn");
+ List.of("readScope", "resolveScope", "readCompanyIdOrOwn", "resolveScopeCompanyId");
private static final Set SCOPE_CALLEES = Set.copyOf(SCOPE_CALLEE_NAMES);
private static final String SCOPE_CALLEE_LABEL = String.join("/", SCOPE_CALLEE_NAMES);
@@ -448,64 +458,20 @@ class CompanyIdParamGoesThroughReadScopeTest {
""";
/**
- * 第二条正门({@code readCompanyId})的正探针:形状逐字抄现网那一支
- * ({@code InvalidAsinDataController.page} —— 先 {@code operator.user()} 把实体取出来,
- * 再 {@code Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId);},
- * 最后把 {@code scopedCompanyId} 交给 service)。
- * 它证明的是"判据不是只认 {@code readScope} 那一族":C 的第 ①/② 步和 D 都必须在这一形上判绿,
- * 否则五页里靠物化列给范围的那两页会红在护栏上,而不是红在真缺陷上。
- */
- private static final String READ_COMPANY_ID_CAUGHT_PROBE = """
- @GetMapping("/probe")
- public String typedDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
- AdminUserEntity user = operator.user();
- Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId);
- return String.valueOf(invalidAsinDataService.page(1, 15, scopedCompanyId));
- }
- """;
-
- /**
- * 第二条正门的裸语句探针(C 第 ① 步在该门上的"能红"证据):
- * {@code scopeCatchFailure} 是对两条门逐条跑那两步的,只在 {@code readScope} 上验过不算验过——
- * 少了这一枚,"第二道门根本没人看守它的返回值"就能悄悄进仓。
- */
- private static final String READ_COMPANY_ID_DISCARD_PROBE = """
- @GetMapping("/probe")
- public String typedDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
- dataReadScope.readCompanyId(user, companyId);
- return "ok";
- }
- """;
-
- /**
- * 第二条正门的负探针(D 在该门上的存在理由):出口调了、结果接住了、也喂给 service 了,
- * 唯独进出口的是 {@code null} —— 与 {@link #SCOPE_PASSED_NULL_PROBE} 同一记刀,只是换了道门。
- * A/B/C 三条前提在自检里逐条钉住为绿,才说明这一刀今天确实只有 D 会喊。
- */
- private static final String READ_COMPANY_ID_PASSED_NULL_PROBE = """
- @GetMapping("/probe")
- public String typedDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
- AdminUserEntity user = operator.user();
- Long scopedCompanyId = dataReadScope.readCompanyId(user, null);
- return String.valueOf(invalidAsinDataService.page(1, 15, scopedCompanyId));
- }
- """;
-
- /**
- * 第三道正门({@code readCompanyIdOrOwn})的正探针:形状抄现网
- * {@code ProductCategoryController.list} —— 门给什么是什么,controller 不自己补。
- * C 的两步与 D 都必须在这一形上判绿,否则类目页红在护栏上而不是红在缺陷上。
+ * 第二道正门({@code readCompanyIdOrOwn})的正探针:形状抄现网
+ * {@code ShopKeyController.list} —— 门给什么是什么,controller 不自己补。
+ * C 的两步与 D 都必须在这一形上判绿,否则密钥页红在护栏上而不是红在缺陷上。
*/
private static final String READ_OWN_COMPANY_ID_CAUGHT_PROBE = """
@GetMapping("/probe")
public String thirdDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
- return String.valueOf(productCategoryService.list(null, scopedCompanyId));
+ return String.valueOf(shopKeyService.list(null, scopedCompanyId));
}
""";
- /** 第三道正门的裸语句探针(C 第 ① 步在该门上的"能红"证据):算完直接丢,等于没筛。 */
+ /** 第二道正门的裸语句探针(C 第 ① 步在该门上的"能红"证据):算完直接丢,等于没筛。 */
private static final String READ_OWN_COMPANY_ID_DISCARD_PROBE = """
@GetMapping("/probe")
public String thirdDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
@@ -514,13 +480,59 @@ class CompanyIdParamGoesThroughReadScopeTest {
}
""";
- /** 第三道正门的负探针(D 在该门上的存在理由):进出口的是 {@code null},tab 恒不动。 */
+ /** 第二道正门的负探针(D 在该门上的存在理由):进出口的是 {@code null},tab 恒不动。 */
private static final String READ_OWN_COMPANY_ID_PASSED_NULL_PROBE = """
@GetMapping("/probe")
public String thirdDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, null);
- return String.valueOf(productCategoryService.list(null, scopedCompanyId));
+ return String.valueOf(shopKeyService.list(null, scopedCompanyId));
+ }
+ """;
+
+ /**
+ * 第三道正门(菜单字典归属判据 {@code resolveScopeCompanyId})的正探针:
+ * 结果接进变量并喂给 {@code list(…)},公司参数本身进了门 —— C 与 D 都必须判它绿,
+ * 否则 {@code PermissionMenuController} 那六支 handler 全是假红。
+ */
+ private static final String MENU_SCOPE_CAUGHT_PROBE = """
+ @GetMapping("/probe")
+ public String menuScopeDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
+ AdminUserEntity user = operator.user();
+ Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(user, companyId);
+ return String.valueOf(permissionMenuService.list(user, "admin", false, scopeCompanyId));
+ }
+ """;
+
+ /** 第三道正门的裸语句探针(C 第 ① 步在该门上的"能红"证据):门调了、403 也发了,结果却没人接。 */
+ private static final String MENU_SCOPE_DISCARD_PROBE = """
+ @GetMapping("/probe")
+ public String menuScopeDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
+ permissionMenuService.resolveScopeCompanyId(user, companyId);
+ return "ok";
+ }
+ """;
+
+ /** 第三道正门的负探针(D 在该门上的存在理由):门里进出的是 {@code null},切了 tab 取的还是操作者本公司。 */
+ private static final String MENU_SCOPE_PASSED_NULL_PROBE = """
+ @GetMapping("/probe")
+ public String menuScopeDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
+ AdminUserEntity user = operator.user();
+ Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(user, null);
+ return String.valueOf(permissionMenuService.list(user, "admin", false, scopeCompanyId));
+ }
+ """;
+
+ /**
+ * 已摘掉那道门的正样本探针(形状抄退回前的 {@code InvalidAsinDataController.page}:
+ * 收 {@code company_id} 参数、体内调 {@code readCompanyId})。它现在应当被 A/C/D 三条同时判红——
+ * 红因必须落在"三条正门都没走"上,而不是"这段源码没被切成 handler"。
+ */
+ private static final String RETIRED_DOOR_WIRED_PROBE = """
+ @GetMapping("/probe")
+ public String retiredDoorWired(@RequestParam(name = "company_id", required = false) Long companyId) {
+ Long scoped = dataReadScope.readCompanyId(user, companyId);
+ return String.valueOf(invalidAsinDataService.page(scoped));
}
""";
@@ -622,16 +634,6 @@ class CompanyIdParamGoesThroughReadScopeTest {
assertThat(scopeProbeReason(SCOPE_TYPE_FORM_PROBE, "SCOPE_TYPE_FORM_PROBE"))
.as("断言 C 自检(第二形):ReadScope s = dataReadScope.readScope(…) 且 s 进了 service.page(…) 的实参 ⇒ 同样要认")
.isNull();
- // 第二条正门必须各自有能红/能绿两向证据:C 的判据是对 SCOPE_DOORS 逐条跑的,
- // 只在 readScope 上验过,就等于没验过 readCompanyId —— 那一道门上的返回值会没人看守。
- assertThat(scopeProbeReason(READ_COMPANY_ID_CAUGHT_PROBE, "READ_COMPANY_ID_CAUGHT_PROBE"))
- .as("断言 C 自检(第二道门·正样本):Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId) "
- + "且它进了 service.page(…) 的实参 ⇒ 该判这一形绿,判红就是护栏假红(现网品牌库/商品类目都是这形)")
- .isNull();
- assertThat(scopeProbeReason(READ_COMPANY_ID_DISCARD_PROBE, "READ_COMPANY_ID_DISCARD_PROBE"))
- .as("断言 C 自检(第二道门·负样本):readCompanyId( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
- .isNotNull()
- .contains("范围算了但没接住");
// 断言 D 的判据自检(两个方向都要,全局约束 15)。负探针要先证明"A/B/C 三条对它都判通过"——
// 这三条前提不成立就说明这段源码本来已经有人看守,D 没有区分度、只是重复劳动。
@@ -662,45 +664,80 @@ class CompanyIdParamGoesThroughReadScopeTest {
.as("断言 D 自检(改名那一族):参数声明叫 orgId、交出去的也是 orgId ⇒ 不许红"
+ "(这条同时钉住\"D 不许硬编码 companyId\":写死了它就会在这一支假红)")
.isNull();
- // 第二道门上的 D:先钉 A/B/C 三条前提对它同样全绿(换了道门不等于换了缺陷形状),再钉 D 必须红。
- String typedNullProbeText = String.join("\n", textsOf(sourceLines(READ_COMPANY_ID_PASSED_NULL_PROBE)));
- assertThat(typedNullProbeText)
- .as("断言 D(第二道门)负样本的前提(断言 A/B):readCompanyId( 在 handler 体内、name = \"company_id\" 也在")
- .contains(READ_COMPANY_ID_CALL)
- .contains(EXPLICIT_PARAM_NAME);
- assertThat(scopeProbeReason(READ_COMPANY_ID_PASSED_NULL_PROBE, "READ_COMPANY_ID_PASSED_NULL_PROBE"))
- .as("断言 D(第二道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 service ⇒ C 判它绿")
- .isNull();
- assertThat(companyIdArgProbeReason(
- READ_COMPANY_ID_PASSED_NULL_PROBE, "READ_COMPANY_ID_PASSED_NULL_PROBE", CAMEL_PARAM))
- .as("断言 D 自检(第二道门·负样本):readCompanyId(user, null) —— 出口调了、门也认了,"
- + "tab 传下来的值仍没进出口 ⇒ 同样必须判红(D 不能只咬 readScope 那一族)")
- .isNotNull()
- .contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
- // 第三道门同样要各自带能红/能绿两向证据:C 与 D 都是对 SCOPE_DOORS 逐条跑的,
- // 少一枚探针就等于那道门上的返回值与入参没人看守(类目页正是走这道门的页)。
+ // 第二道门同样要各自带能红/能绿两向证据:C 与 D 都是对 SCOPE_DOORS 逐条跑的,
+ // 少一枚探针就等于那道门上的返回值与入参没人看守(店铺密钥页正是走这道门的页)。
assertThat(scopeProbeReason(READ_OWN_COMPANY_ID_CAUGHT_PROBE, "READ_OWN_COMPANY_ID_CAUGHT_PROBE"))
- .as("断言 C 自检(第三道门·正样本):Long scopedCompanyId = readCompanyIdOrOwn(user, companyId) "
+ .as("断言 C 自检(第二道门·正样本):Long scopedCompanyId = readCompanyIdOrOwn(user, companyId) "
+ "且它进了 service.list(…) 的实参 ⇒ 判红就是护栏假红")
.isNull();
assertThat(companyIdArgProbeReason(
READ_OWN_COMPANY_ID_CAUGHT_PROBE, "READ_OWN_COMPANY_ID_CAUGHT_PROBE", CAMEL_PARAM))
- .as("断言 D 自检(第三道门·正样本):companyId 真进了 readCompanyIdOrOwn 的实参表 ⇒ 不许红")
+ .as("断言 D 自检(第二道门·正样本):companyId 真进了 readCompanyIdOrOwn 的实参表 ⇒ 不许红")
.isNull();
assertThat(scopeProbeReason(READ_OWN_COMPANY_ID_DISCARD_PROBE, "READ_OWN_COMPANY_ID_DISCARD_PROBE"))
- .as("断言 C 自检(第三道门·负样本):readCompanyIdOrOwn( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
+ .as("断言 C 自检(第二道门·负样本):readCompanyIdOrOwn( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
.isNotNull()
.contains("范围算了但没接住");
assertThat(scopeProbeReason(READ_OWN_COMPANY_ID_PASSED_NULL_PROBE, "READ_OWN_COMPANY_ID_PASSED_NULL_PROBE"))
- .as("断言 D(第三道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 service ⇒ C 判它绿")
+ .as("断言 D(第二道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 service ⇒ C 判它绿")
.isNull();
assertThat(companyIdArgProbeReason(
READ_OWN_COMPANY_ID_PASSED_NULL_PROBE, "READ_OWN_COMPANY_ID_PASSED_NULL_PROBE", CAMEL_PARAM))
- .as("断言 D 自检(第三道门·负样本):readCompanyIdOrOwn(user, null) ⇒ 必须判红")
+ .as("断言 D 自检(第二道门·负样本):readCompanyIdOrOwn(user, null) ⇒ 必须判红")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
+ // 第三道门(菜单字典)同样各自带能红/能绿两向证据:它今天有六个真实消费者
+ // (PermissionMenuController 的目录/新建/两页数据范围授权的读与写),只钉"名单里有这个名字"
+ // 而不验返回值与入参,等于那六支 handler 的 tab 可以随便坏。
+ assertThat(scopeProbeReason(MENU_SCOPE_CAUGHT_PROBE, "MENU_SCOPE_CAUGHT_PROBE"))
+ .as("断言 C 自检(第三道门·正样本):Long scopeCompanyId = resolveScopeCompanyId(user, companyId) "
+ + "且它进了 permissionMenuService.list(…) ⇒ 判红就是护栏假红")
+ .isNull();
+ assertThat(companyIdArgProbeReason(MENU_SCOPE_CAUGHT_PROBE, "MENU_SCOPE_CAUGHT_PROBE", CAMEL_PARAM))
+ .as("断言 D 自检(第三道门·正样本):companyId 真进了 resolveScopeCompanyId 的实参表 ⇒ 不许红")
+ .isNull();
+ assertThat(scopeProbeReason(MENU_SCOPE_DISCARD_PROBE, "MENU_SCOPE_DISCARD_PROBE"))
+ .as("断言 C 自检(第三道门·负样本):resolveScopeCompanyId( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
+ .isNotNull()
+ .contains("范围算了但没接住");
+ assertThat(scopeProbeReason(MENU_SCOPE_PASSED_NULL_PROBE, "MENU_SCOPE_PASSED_NULL_PROBE"))
+ .as("断言 D(第三道门)负样本的前提(断言 C):结果接进 scopeCompanyId 又喂给了 list ⇒ C 判它绿")
+ .isNull();
+ assertThat(companyIdArgProbeReason(
+ MENU_SCOPE_PASSED_NULL_PROBE, "MENU_SCOPE_PASSED_NULL_PROBE", CAMEL_PARAM))
+ .as("断言 D 自检(第三道门·负样本):resolveScopeCompanyId(user, null) ⇒ 必须判红")
+ .isNotNull()
+ .contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
+
+ // 已摘掉的那道门不许再接回(全局约束 15 的"能红"方向)。这一族 handler(品牌库、商品类目)现在定案
+ // 全平台共享、不再收公司参数 ⇒ 它们已不进 A/C/D 的样本,"哪天有人把 ?company_id= 接回这两张表"
+ // 只剩这条探针还在求值,而今天真正拦它的是断言 A:C 与 D 在主循环里都以"体内有正门调用"为前提
+ // ({@link Block#hasScopeCall()}),只调已摘那道门时它们根本不求值 —— 把这层写成注释而不是三条全红,
+ // 是因为下一条要钉的就是"D 的名单里不许提前把 readCompanyId 加回来"。
+ // 前提同样要自证:探针真被切成 1 支收公司 id 参数的 handler、体内一条现存正门都没有、
+ // 但确实调了 readCompanyId( —— 否则"判红"只是"源码没读到"的另一种形状。
+ List retiredDoorBlocks = splitBlocks(sourceLines(RETIRED_DOOR_WIRED_PROBE)).handlers();
+ assertThat(retiredDoorBlocks)
+ .as("已摘门探针切不出 handler ⇒ 下面几条判红断言是空跑")
+ .hasSize(1);
+ Block retiredDoor = retiredDoorBlocks.get(0);
+ assertThat(retiredDoor.takesCompanyParam())
+ .as("已摘门探针没被认成收公司 id 参数(参数形状变了)⇒ A 不会对它求值,这条反向钉没有内容")
+ .isTrue();
+ assertThat(retiredDoor.text())
+ .as("已摘门探针的反面证据:它确实调了 readCompanyId(,这正是定案不许再接回的那一形")
+ .contains("readCompanyId(");
+ assertThat(anyScopeDoor(retiredDoor.text()))
+ .as("断言 A(已摘门):这条 handler 体内一条现存正门都没走过 ⇒ A 必然落进判红分支。"
+ + "这里若为 true,说明探针混进了别的正门调用,A 不再是这一形的守门人,本用例失去内容")
+ .isFalse();
+ assertThat(retiredDoor.companyIdArgFailure())
+ .as("断言 D 对被调名单的看守:readCompanyId 一旦被人加回 SCOPE_CALLEE_NAMES(门还没接回、"
+ + "名单先到),这一形就会被 D 判绿 ⇒ 这条必须保持判红")
+ .isNotNull();
+
// 配对括号取实参表(放宽)的成对证据:两枚正样本必须绿(否则 6 支已接线 handler 假红),
// 一枚"嵌套了但没带公司参数"的样本必须照旧红(否则放宽 = 把 D 关掉)。
assertThat(scopeProbeReason(SCOPE_NESTED_ARG_PROBE, "SCOPE_NESTED_ARG_PROBE"))
@@ -865,6 +902,138 @@ class CompanyIdParamGoesThroughReadScopeTest {
.isEmpty();
}
+ /**
+ * 10-06 定案"全平台共享、不区分公司"的两张表:{@code biz_invalid_asin_data}(品牌数据库)、
+ * {@code biz_product_category}(商品类目)。名单按 module 目录给而不是按 controller——
+ * 这两页的公司维度原先落在 entity 列、mapper 幂等键和 service 谓词上,只盯 controller 会漏掉那三段。
+ *
+ * 为什么不能只靠"退出 {@link #WIRED_PAGE_KEYS}":射程名单管的是"收了公司参数的 handler 必须走正门",
+ * 一页一旦不再收参数就不进样本,A/C/D 三条一起对它停止求值——"哪天有人把 {@code ?company_id=} 接回去"
+ * 恰好只剩这一条反向钉看得见。
+ */
+ private static final List SHARED_TABLES_MUST_STAY_UNSCOPED = List.of(
+ "com/nanri/aiimage/modules/invalidasin",
+ "com/nanri/aiimage/modules/productcategory");
+
+ /** 这两张表的类型名锚:module 目录之外的引用者(自动导入那条写侧路)按它取样。 */
+ private static final List SHARED_TABLE_TYPE_ANCHORS = List.of("InvalidAsinData", "ProductCategory");
+
+ /**
+ * 正样本目录:店铺密钥到今天仍是按公司取数的那一族({@code biz_shop_key},V150)。
+ * 同一把尺子必须在这里量出命中,否则"共享目录零命中"可能只是尺子坏了(全局约束 15)。
+ */
+ private static final String STILL_SCOPED_MODULE_DIR = "com/nanri/aiimage/modules/shopkey";
+
+ private static final String DATA_READ_SCOPE_FILE = "com/nanri/aiimage/common/service/DataReadScope.java";
+
+ /** 公司 token 的尺子:整词大小写不敏感,比 {@code company_id}/{@code companyId} 两种写法都宽(含 {@code CompanyScopeSupport})。 */
+ private static final Pattern ANY_COMPANY_TOKEN = Pattern.compile("(?i)company");
+
+ @Test
+ @DisplayName("品牌库 / 商品类目已定案全平台共享:公司维度不许回流到这两张表的任何一处,出口上也不许再有那条门")
+ void companyDimensionMustNotFlowBackIntoTheTwoSharedTables() throws IOException {
+ // ① 尺子自证:同一把尺子必须在仍按公司取数的目录上量出命中,否则下面"共享目录零命中"全是空断言。
+ List scopedHits = companyTokenLines(STILL_SCOPED_MODULE_DIR);
+ assertThat(scopedHits)
+ .as("公司 token 尺子在仍按公司取数的 %s 上零命中 ⇒ 尺子或取样坏了,后面的反向钉全是空断言",
+ STILL_SCOPED_MODULE_DIR)
+ .isNotEmpty();
+
+ // ② 两张共享表:目录里必须扫得到 .java(目录被改名/挪走也算红,那等于没人看守),且可执行行零公司 token。
+ for (String dir : SHARED_TABLES_MUST_STAY_UNSCOPED) {
+ assertThat(javaFilesUnder(dir))
+ .as("%s 扫不到 .java:目录被改名或挪走了,这条反向钉对它已经不再求值", dir)
+ .isNotEmpty();
+ assertThat(companyTokenLines(dir))
+ .as("品牌数据库 / 商品类目 2026-10-06 定案全平台共享(唯一键退回全局、页面不画公司 tab):"
+ + "这两张表的 entity 列、mapper 幂等键、service 谓词、controller 参数都不许再出现公司维度"
+ + "(只打可执行行,注释里『故意没有这一列』的说明不算)")
+ .isEmpty();
+ }
+
+ // ③ 目录外那几处引用这两张表的消费者同样不许带公司维度;锚本身要自证真取到了人。
+ List consumers = sharedTableConsumerFiles();
+ assertThat(consumers)
+ .as("按类型名锚 %s 在两个 module 目录之外连自动导入那条写侧路都没取到 ⇒ 锚失效,这一族没人看守",
+ SHARED_TABLE_TYPE_ANCHORS)
+ .contains("com/nanri/aiimage/modules/collectdata/util/CollectDataInvalidAsinBatchWriter.java");
+ List consumerHits = new ArrayList<>();
+ for (String rel : consumers) {
+ consumerHits.addAll(companyTokenLinesInFile(MAIN_ROOT.resolve(rel)));
+ }
+ assertThat(consumerHits)
+ .as("引用这两张表的外部消费者里出现了公司维度——自动导入「推不出公司就整批不写」那道闸门已定案放开,"
+ + "把它接回去等于让整批 AUTO 行静默丢失")
+ .isEmpty();
+
+ // ④ 出口这一侧:readCompanyId 是专为这两页的「超管按 tab 选哪家」加的,两页退掉后全树零消费者,已删。
+ // 先钉同一族的 readCompanyIdOrOwn 还读得到,否则 noneMatch 只是"文件读空"的另一种绿。
+ List scopeLines = executableLines(read(MAIN_ROOT.resolve(DATA_READ_SCOPE_FILE)));
+ assertThat(scopeLines)
+ .as("%s 里一行可执行行都没读到 ⇒ 门检查是空断言", DATA_READ_SCOPE_FILE)
+ .isNotEmpty();
+ assertThat(scopeLines.stream().anyMatch(line -> line.contains(READ_OWN_COMPANY_ID_CALL)))
+ .as("DataReadScope 上那条 OrOwn 门读不到了(改名或删除都要一起改这里):先确认这份文件真被扫到,"
+ + "再谈『readCompanyId 不该存在』")
+ .isTrue();
+ assertThat(scopeLines.stream().noneMatch(line -> line.contains("readCompanyId(")))
+ .as("readCompanyId 又回到了 DataReadScope 上:品牌库/商品类目已定案共享,"
+ + "一门没有实现者的正门留在出口名单里,等于给公司开关预先铺好合规形状")
+ .isTrue();
+ }
+
+ /** 某 module 目录(相对 {@code src/main/java},正斜杠)下的全部 {@code .java},按路径排序;目录不存在给空表,由调用方判红。 */
+ private static List javaFilesUnder(String moduleDir) throws IOException {
+ Path root = MAIN_ROOT.resolve(moduleDir);
+ if (!Files.isDirectory(root)) return List.of();
+ try (Stream walk = Files.walk(root)) {
+ return walk.filter(Files::isRegularFile)
+ .filter(p -> p.getFileName().toString().endsWith(".java"))
+ .sorted()
+ .collect(Collectors.toList());
+ }
+ }
+
+ /** 一个目录下所有可执行行上的公司 token,报 {@code 相对路径: 行文本}(不带行号:行号会随无关提交漂,文件名+原文足够定位)。 */
+ private static List companyTokenLines(String moduleDir) throws IOException {
+ List hits = new ArrayList<>();
+ for (Path file : javaFilesUnder(moduleDir)) {
+ hits.addAll(companyTokenLinesInFile(file));
+ }
+ return hits;
+ }
+
+ private static List companyTokenLinesInFile(Path file) {
+ String rel = relativeKey(file);
+ return executableLines(read(file)).stream()
+ .filter(line -> ANY_COMPANY_TOKEN.matcher(line).find())
+ .map(line -> rel + ": " + line)
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * 两个 module 目录之外、可执行行里点到这两张表类型名的 main 文件(相对 {@code src/main/java}、正斜杠、排序)。
+ * 口径同第 1 条:只打可执行行,注释里提一句类名不算引用。
+ */
+ private static List sharedTableConsumerFiles() throws IOException {
+ List consumers = new ArrayList<>();
+ try (Stream walk = Files.walk(MAIN_ROOT)) {
+ List files = walk.filter(Files::isRegularFile)
+ .filter(p -> p.getFileName().toString().endsWith(".java"))
+ .sorted()
+ .collect(Collectors.toList());
+ for (Path file : files) {
+ String rel = relativeKey(file);
+ if (SHARED_TABLES_MUST_STAY_UNSCOPED.stream().anyMatch(rel::startsWith)) continue;
+ if (executableLines(read(file)).stream()
+ .anyMatch(line -> SHARED_TABLE_TYPE_ANCHORS.stream().anyMatch(line::contains))) {
+ consumers.add(rel);
+ }
+ }
+ }
+ return consumers;
+ }
+
/**
* 断言 C 的探针驱动器:先确认这段样本真被切成"1 支收公司 id 参数、体内写了 readScope(" 的 handler,
* 再跑 {@link Block#scopeCatchFailure()}。切不出 handler / 不认公司参数 / 没有 readScope( 这三种
@@ -880,7 +1049,8 @@ class CompanyIdParamGoesThroughReadScopeTest {
.as(probeName + " 的 handler 没被认成收公司 id 参数,断言 C 根本不会触发 ⇒ 探针失效")
.isTrue();
assertThat(anyScopeDoor(handler.text()))
- .as(probeName + " 的 handler 体内两条正门都没走(readScope( / readCompanyId(),断言 C 扫不到它 ⇒ 探针失效")
+ .as(probeName + " 的 handler 体内一条正门都没走(" + String.join(" / ", SCOPE_DOORS)
+ + "),断言 C 扫不到它 ⇒ 探针失效")
.isTrue();
return handler.scopeCatchFailure();
}
@@ -966,7 +1136,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
return line.contains(SNAKE_PARAM) || line.contains(CAMEL_PARAM);
}
- /** 两条正门之一有没有在这段文本里出现过(A/C 的判据都走它,不各写一份)。 */
+ /** 任一条正门有没有在这段文本里出现过(A/C 的判据都走它,不各写一份)。 */
private static boolean anyScopeDoor(String text) {
return SCOPE_DOORS.stream().anyMatch(text::contains);
}
@@ -1294,7 +1464,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
return null;
}
- /** 逐条正门跑"接住 → 交出去"两步:两条门都得走这两步,第二道门不能成为绕过第一道门判据的后门。 */
+ /** 逐条正门跑"接住 → 交出去"两步:三道门都得走这两步,后一道不能成为绕过前一道判据的后门。 */
private static String scopeCatchFailureFor(String src, String door) {
for (int at = src.indexOf(door); at >= 0;
at = src.indexOf(door, at + door.length())) {
@@ -1397,7 +1567,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 与 A/B/C 同一个 handler 窗口)。
* |