feat(菜单权限): 每家公司一套菜单树(V149)+ 公司 tab 只在注册表页渲染

本批两件事,加上随本批一起入仓的并行会话在制品:

一、菜单权限按公司隔离(批次 6)
- V149 给 columns 加 company_id:先可空加列(末位、ALGORITHM=INSTANT)→ 回填公司 1 →
  MODIFY 收紧 NOT NULL;三段式缺一即撞 1048。同时建 (company_id, column_key) 复合键、
  把公司 2 的 16 笔授权按 column_key 改指向它自己的副本,三类 menu_type 全复制,
  admin_companies 作为角色内生闸门行不复制(D3)。
- 第三道归属门 PermissionMenuService.resolveScopeCompanyId:站点超管可带 company_id
  读写任意公司,非超管锁本公司、越界 403。它注册进 CompanyIdParamGoesThroughReadScopeTest
  的 SCOPE_DOORS,四条判据与 readScope / readCompanyIdOrOwn 共用——护栏在代码出口,不靠清单。
- 旁路种子 PermissionMenuSchemaInitializer 只种公司 1:31 段种子逐条钉公司,
  按 column_key 点查的 14 段全部带 company_id,否则摘了 DEFAULT 就是跨公司串写。
- CompanyService.create 同一次写入里给新公司复制模板树(D4)。

二、公司 tab 收口(批次 b)
tab 条挂在壳层,对 22 页全画;改为按正列表 companyTabAppliesTo(menuKey) 判定,
只有注册表页渲染。护栏钉在用户看见的那个出口。

三、并行会话在制品(控制方「全部提交」,未单独拆分——见下)
- V150 店铺密钥 biz_shop_key 按公司(readCompanyIdOrOwn + writeCompanyId 两道门)
- V151 品牌库/商品类目推翻为全平台共享:只退唯一键、company_id DEFAULT 保留为
  NOT NULL 承重约束(摘了每条 1364);删掉 ProductCategoryControllerCompanyScopeTest
  那支"按公司隔离"的旧护栏,readCompanyId 方法一并移除
- invalidasin 字段与外观专利合批的连带改动

为什么不拆笔:后端 3891 例 / 0 红、前端 1731 例 / 0 红这两个读数是"合起来的树"的读数,
拆成多笔会让每一笔落到从未一起验过的组合上,而这一版要直接上两台。

回滚脚本在 backend-java/docs/rollback-V149/V150/V151-*.sql,不放进 Flyway 扫描路径。
设计记录:docs/ops/menu-company-tree-design-2026-10-06.md
This commit is contained in:
2026-10-06 17:17:14 +08:00
parent e635fa8dcd
commit b7acfc0eef
84 changed files with 5118 additions and 1421 deletions
@@ -53,17 +53,29 @@ public class PermissionMenuController {
public ApiResponse<List<PermissionMenuItemVo>> 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<PermissionMenuItemVo> 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<Void> reorderColumns(HttpServletRequest httpRequest,
@RequestBody(required = false) Map<String, Object> 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<List<ImageVideoDataPermissionUserVo>> 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<Integer> 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<List<ImageVideoDataPermissionUserVo>> 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<Integer> 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);
}
@@ -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)} 都只在本公司内唯一。
*
* <p>写侧一律显式赋值({@code PermissionMenuService} 的 create/update 从操作者或目标行推导),
* 不许依赖列上那条临时的 {@code DEFAULT 1}:V149 留 DEFAULT 只为让同批的旧 jar 不报 1364,
* 下一版就摘掉;一旦有出口忘了赋值,DEFAULT 会把别家的菜单静默塞进厦门米椿花。</p>
*/
private Long companyId;
private LocalDateTime createdAt;
/**
* 更新时间(V131 新增):由数据库维护(DEFAULT CURRENT_TIMESTAMP + ON UPDATE CURRENT_TIMESTAMP)。
@@ -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)。
*
* <p>V149 之后它只维护<b>公司 1 那棵平台默认树</b>:每一条种子语句的 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} 同事务调用)。</p>
*/
@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
@@ -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<PermissionMenuItemVo> list(AdminUserEntity operator, String menuType,
boolean grantableOnly, Long requestedCompanyId) {
Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
return listAt(companyId, operator, menuType, grantableOnly);
}
public List<PermissionMenuItemVo> list(AdminUserEntity operator, String menuType, boolean grantableOnly) {
List<PermissionMenuEntity> menus = loadMenus(menuType);
return list(operator, menuType, grantableOnly, null);
}
/** 目录/授权树的唯一出口:{@code companyId} 为非空时只取那一棵树的行,null 仅留给无操作者的内部调用。 */
private List<PermissionMenuItemVo> listAt(Long companyId, AdminUserEntity operator,
String menuType, boolean grantableOnly) {
List<PermissionMenuEntity> menus = loadMenus(companyId, menuType);
Set<Long> grantableIds = resolveGrantableMenuIds(operator);
List<PermissionMenuEntity> visibleMenus = menus;
if (grantableOnly && grantableIds != null) {
@@ -109,13 +124,68 @@ public class PermissionMenuService {
/**
* 操作者可授予的菜单 id 全集(自身直接授权 + 其后代)。
*
* <p>V149 之后按<b>操作者本公司</b>那棵树展开:授权只会指向本公司的行(迁移第 9 段与
* 闸门 3 保证),拿全平台目录去展开等于把别家同名菜单的 id 也算进"可授予",
* 那是"范围收窄只做在界面上"的同一类事故。</p>
*
* @return null 表示不限制(超管或无操作者)
*/
private Set<Long> 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。
*
* <p>读侧与写侧共用这一个方法:分成两个迟早漂移成「读能看别家、写挡不住」或反过来,
* 而那正是 09-13「权限自己没掉」那一族事故的形状。</p>
*
* <p>{@code null} 只可能来自「没有操作者」的历史内部调用与单测夹具,此时不下公司条件、
* 退回换列之前的全量目录语义;生产上 {@code users.company_id} 是 NOT NULL,
* 真出现无归属账号由列上的约束喊,不在这里编一个默认公司。</p>
*
* <p>公开是为了让控制器在收 {@code company_id} 参数的当场就走这道门(把返回值往下传),
* 而不是把裸参数扔进来再靠本类内部兜——{@code CompanyIdParamGoesThroughReadScopeTest}
* 认的就是这条出口,控制器少接一次就等于"tab 传了但没人用"。</p>
*/
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):非超管只能动<b>本公司那棵树</b>里的行。
*
* <p>补这道闸门之前 {@link #ensureAdminOperatorIfPresent} 只判 isAdmin,等于任何管理员
* 都能改整张字典;每家公司一棵树之后,跨公司改一行会把别家的菜单搬进自己树里
* ({@code column_key} 在两家之间不再全局唯一,只有 id 认得出它属于谁)。
* 菜单字典是租户配置,改坏它比跨公司读数据更糟——那家所有账号的权限页一起坏。</p>
*/
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。<b>绝不靠列上的 DEFAULT 1 兜归属</b>——那等于把别家的菜单静默塞进厦门米椿花。
*/
@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);
// 归属不接收请求参数:改哪棵树由<b>这一行自己属于谁</b>决定,编辑动作只能把行留在原公司。
// 让载荷带 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<PermissionMenuEntity>()
.eq(PermissionMenuEntity::getParentId, entity.getId()));
if (childCount != null && childCount > 0) {
@@ -243,9 +331,12 @@ public class PermissionMenuService {
/**
* 同级菜单拖拽重排:orderedIds 为同一父级下按新顺序排列的菜单 ID 列表。
* 不在列表中的兄弟节点保持原相对顺序追加在末尾,重排块锚定在原最小 sort_order,避免跨级穿插。
*
* <p>兄弟集必须按<b>锚点行的公司</b>筛:每家公司一棵树之后,"同级"这个概念本身就带公司口径,
* 混进别家的同名分组会让重排把两棵树的 sort_order 交织在一起(表现为两排同名菜单穿插)。</p>
*/
@Transactional
public void reorder(List<Long> orderedIds) {
public void reorder(AdminUserEntity operator, List<Long> 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<PermissionMenuEntity> siblings = permissionMenuMapper.selectList(new LambdaQueryWrapper<PermissionMenuEntity>()
.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 段同一语义:
* 那一版补的是<b>当时已经存在</b>的公司,这一版补的是之后新建的公司。
*
* <p>没有它,「公司管理 -> 新增公司」就造出一个零菜单行的租户:那家的账号登录后台侧边栏全空、
* 授权树一个勾都没有,而且全程不报错。这正是本次要消灭的那类静默失效,
* 所以建树必须是建号公司的同一次写入,不能留成"上线后再手工跑一遍 V149 的复制段"。</p>
*
* <p>两趟写:第一趟只管插(父先留空,避开插入顺序),第二趟按 key 把父指向落到本公司新行上
* ——与 V149 第 7 段同形,两级三层都成立。幂等:目标公司已有的 key 原样保留,重跑只补差集。</p>
*
* @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<PermissionMenuEntity> 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<String, PermissionMenuEntity> targetByKey = new HashMap<>();
for (PermissionMenuEntity menu : loadRawMenus(companyId, null)) {
if (menu.getColumnKey() != null) {
targetByKey.put(menu.getColumnKey(), menu);
}
}
Map<Long, PermissionMenuEntity> 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<PermissionMenuEntity>()
.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<PermissionMenuEntity> menus = loadMenus(menuType);
// 回填集按<b>目标账号所属公司</b>的那棵树取:授权弹窗里勾的是"这个账号家"的菜单行 id,
// 操作者是谁都不该改变这一点(超管替德阳配权限时勾出公司 1 的行 id,就是跨公司授权)。
List<PermissionMenuEntity> menus = loadMenus(user.getCompanyId(), menuType);
Map<Long, PermissionMenuEntity> 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<PermissionMenuEntity> menus = loadMenus(menuType);
List<PermissionMenuEntity> 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<PermissionMenuEntity> menus = loadMenus(target.getMenuType());
// 跨公司的 column_id 一律判「无权限」:本账号的直接授权里出现别家的行,只可能是载荷被
// 拼错(或前端缓存了换键之前的旧 id)。方向是拒绝,不是放行——放宽等于让别家的行 id 生效。
if (!Objects.equals(target.getCompanyId(), user.getCompanyId())) {
return false;
}
List<PermissionMenuEntity> menus = loadMenus(target.getCompanyId(), target.getMenuType());
return expandDescendantIds(new LinkedHashSet<>(loadDirectColumnIds(userId)), menus)
.contains(columnId);
}
@@ -397,26 +581,40 @@ public class PermissionMenuService {
*
* <p>权限页此前一律 `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<AdminUserEntity> grantableUserQuery() {
private LambdaQueryWrapper<AdminUserEntity> grantableUserQuery(Long companyId) {
return new LambdaQueryWrapper<AdminUserEntity>()
.select(AdminUserEntity::getId,
AdminUserEntity::getUsername,
AdminUserEntity::getRole,
AdminUserEntity::getIsAdmin,
AdminUserEntity::getCreatedById);
AdminUserEntity::getCreatedById,
AdminUserEntity::getCompanyId)
.eq(companyId != null, AdminUserEntity::getCompanyId, companyId);
}
public List<ImageVideoDataPermissionUserVo> listImageVideoDataPermissionUsers(AdminUserEntity operator) {
return listImageVideoDataPermissionUsers(operator, null);
}
/**
* 「视频任务数据查看」这一项内部数据权限的分公司读口:超管切到哪家公司就解析那棵树的行,
* 用户列表同步按那一家筛({@link #grantableUserQuery(Long)})。
*/
public List<ImageVideoDataPermissionUserVo> listImageVideoDataPermissionUsers(AdminUserEntity operator,
Long requestedCompanyId) {
ensureSuperAdminOperator(operator);
PermissionMenuEntity dataPermission = requireImageVideoDataPermission();
Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
PermissionMenuEntity dataPermission = requireImageVideoDataPermission(companyId);
Set<Long> 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<Long> userIds) {
return updateImageVideoDataPermissionUsers(operator, null, userIds);
}
/**
* 整分区替换本公司的那一条内部数据权限授权。别家的账号 id 会落进
* 「contains unknown or non-grantable user」——用户列表已经按公司筛过,
* 这不是新报错,是既有的那条从严判定现在有了公司口径。
*/
@Transactional
public int updateImageVideoDataPermissionUsers(AdminUserEntity operator, Long requestedCompanyId,
List<Long> userIds) {
ensureSuperAdminOperator(operator);
PermissionMenuEntity dataPermission = requireImageVideoDataPermission();
Long companyId = resolveScopeCompanyId(operator, requestedCompanyId);
PermissionMenuEntity dataPermission = requireImageVideoDataPermission(companyId);
List<Long> requestedIds = normalizeColumnIds(userIds);
List<AdminUserEntity> users = adminUserMapper.selectList(grantableUserQuery());
List<AdminUserEntity> users = adminUserMapper.selectList(grantableUserQuery(companyId));
Map<Long, AdminUserEntity> 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<ImageVideoDataPermissionUserVo> listShopDataCrawlDataPermissionUsers(AdminUserEntity operator) {
return listShopDataCrawlDataPermissionUsers(operator, null);
}
/** 与视频任务那一路同口径:内部数据权限行与用户列表必须解析到同一家公司。 */
public List<ImageVideoDataPermissionUserVo> 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<Long> 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<Long> userIds) {
return updateShopDataCrawlDataPermissionUsers(operator, null, userIds);
}
@Transactional
public int updateShopDataCrawlDataPermissionUsers(AdminUserEntity operator, Long requestedCompanyId,
List<Long> 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<Long> requestedIds = normalizeColumnIds(userIds);
List<AdminUserEntity> users = adminUserMapper.selectList(grantableUserQuery());
List<AdminUserEntity> users = adminUserMapper.selectList(grantableUserQuery(companyId));
Map<Long, AdminUserEntity> 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<PermissionMenuEntity> menus = loadMenus(MENU_TYPE_ADMIN);
List<PermissionMenuEntity> menus = loadMenus(operator.getCompanyId(), MENU_TYPE_ADMIN);
List<Long> 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<Long> requestedIds = request == null ? List.of() : normalizeColumnIds(request.getColumnIds());
// 整条链的归属口径 = 目标账号<b>自己那棵树</b>(不是操作者的):超管替德阳配权限时,
// 勾选与落库都必须指向德阳的菜单行 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<PermissionMenuEntity>()
.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<Long> 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<Long> directGrantIds,
List<PermissionMenuEntity> adminMenus) {
List<PermissionMenuEntity> 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<Long> targetEffectiveIds = expandDescendantIds(
new LinkedHashSet<>(loadDirectColumnIds(target.getId())), loadMenus(null));
// 只用到 id:不要为一次级联清理把整表(含密码哈希)拉回
new LinkedHashSet<>(loadDirectColumnIds(target.getId())), loadMenus(companyId, null));
// 只用到 id:不要为一次级联清理把整表(含密码哈希)拉回。
// 下属集要同时按公司筛:这段是批量删除,一旦 created_by 出现跨公司的脏数据,
// "越权"判定就会拿 A 家的有效集去删 B 家员工的授权——删多隔离比删少更贵。
List<AdminUserEntity> subordinates = adminUserMapper.selectList(new LambdaQueryWrapper<AdminUserEntity>()
.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<PermissionMenuEntity> loadMenus(String menuType) {
List<PermissionMenuEntity> rows = loadRawMenus(menuType);
/**
* 目录取数的唯一出口(§4):{@code companyId} 非空时只返回那一棵树的行。
* 授权树、有效菜单、可授予全集、越权判定都从这里取数,所以公司收窄改这一处就够一片。
*
* @param companyId null 只来自「无操作者 / 无归属」的历史与测试路径,此时退回全量目录
*/
private List<PermissionMenuEntity> loadMenus(Long companyId, String menuType) {
List<PermissionMenuEntity> 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<PermissionMenuEntity> loadRawMenus(String menuType) {
private List<PermissionMenuEntity> loadRawMenus(Long companyId, String menuType) {
String normalizedType = normalizeMenuType(menuType);
LambdaQueryWrapper<PermissionMenuEntity> query = new LambdaQueryWrapper<PermissionMenuEntity>()
.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<Long> stripSuperAdminOnlyGrantIds(List<Long> requestedIds, AdminUserEntity operator) {
private List<Long> stripSuperAdminOnlyGrantIds(List<Long> requestedIds, AdminUserEntity operator,
Long companyId) {
if (requestedIds.isEmpty()) {
return requestedIds;
}
Set<Long> restricted = superAdminOnlyMenuIds();
Set<Long> restricted = superAdminOnlyMenuIds(companyId);
if (restricted.isEmpty()) {
return requestedIds;
}
@@ -1029,8 +1274,12 @@ public class PermissionMenuService {
* <p>一次全量目录查询折出来,绝不按 id 逐条点查:保存权限这个入口上 N 次点查会被日志放大,
* 而 {@code findDataPermission} 每次都是一个 {@code selectOne}。</p>
*/
private Set<Long> superAdminOnlyMenuIds() {
return loadMenus(null).stream()
/**
* <p>V149 之后这行闸门菜单只存在于公司 1 的树里(§2 D3:副本不复制它),所以别家公司
* 拿到的是空集——那里的提交里本来就不可能有它,剥离逻辑照常走完,不多一条分支。</p>
*/
private Set<Long> 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 点查一行菜单。<b>必须带公司</b>:V149 之后同一个 key 在每家公司各有一行,
* 少了这个条件就是 {@code LIMIT 1} 跨公司借位——拿到别家的行 id 再往本账号身上写一条
* 本公司树里认不出的授权,页面显示"已授权"、权限却永远不生效,且不报任何错。
*/
private PermissionMenuEntity findDataPermission(Long companyId, String columnKey) {
return permissionMenuMapper.selectOne(new LambdaQueryWrapper<PermissionMenuEntity>()
.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<PermissionMenuEntity>()
.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<PermissionMenuEntity>()
.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<PermissionMenuEntity>()
.eq(companyId != null, PermissionMenuEntity::getCompanyId, companyId)
.eq(PermissionMenuEntity::getMenuType, normalizeMenuType(menuType))
.ne(excludeId != null, PermissionMenuEntity::getId, excludeId)
.orderByDesc(PermissionMenuEntity::getSortOrder)