feat: use role-only menu permissions

zzw

23 小时以前 0642bc9c44d1c8277ada33059c4a3e6156335b30

feat: use role-only menu permissions

 HANDOFF.md

@@ -726,3 +726,30 @@
- åŽ†å²æ¼”示派工单可能保留旧 `T_CONTRACTOR` åç§°ï¼Œéžç®¡ç†å‘˜ cj ç”¨æˆ·å¯èƒ½çœ‹ä¸åˆ°è¿™äº›åŽ†å²å•ï¼›`admin` ä¸å—单位过滤影响。
- `.codex-run`、Office é”æ–‡ä»¶ `requirement\~$原始需求.docx` å’Œ `emergency-repair-web/public/新建 æ–‡æœ¬æ–‡æ¡£.txt` å±žæœ¬åœ°è”调或临时文件，不应提交。
- æœ¬è½®ä»£ç å·²æäº¤å¹¶æŽ¨é€å…¬å¸ Git ä»“库 `main` åˆ†æ”¯ï¼Œæäº¤ `757dcb3`；交接文件回填提交记录。后续启动、构建和排错命令沿用第 16 èŠ‚。

## 18. æ”¶å°¾å¿«ç…§ï¼ˆ2026-10-06 å‘¨ä¸€ï¼Œéœ€æ±‚ 20 èœå•æƒé™ç®¡ç†æ”¶å°¾ï¼‰

**本轮完成内容**
- éœ€æ±‚ 20：菜单权限管理取消租户权限和角色权限的双重授权，改为单步设置角色权限。当前用户本身没有租户归属，因此不再设置租户权限。
- æƒé™æ ‘继续展示菜单节点和按钮节点，不按 `menuType` è¿‡æ»¤ï¼›åˆ‡æ¢è§’色后，已保存权限复选框正常反显。
- èœå•æƒé™æŽ¥å£åªä¿ç•™ `roleId` / `roleMenuIds`，删除租户菜单授权及 `/api/system/tenants`。
- ä¿®å¤é›ªèŠ± ID ç»æµè§ˆå™¨ JSON è§£æžåŽç²¾åº¦ä¸¢å¤±çš„问题：后端返回字符串 ID，前端选中态按字符串处理。

**主要文件**
- åŽç«¯ï¼š`emergency-repair-server/src/main/java/com/emergencyrepair/business/dto/Requests.java`、`emergency-repair-server/src/main/java/com/emergencyrepair/system/controller/SystemController.java`、`emergency-repair-server/src/main/java/com/emergencyrepair/system/service/SystemService.java`。
- å‰ç«¯ï¼š`emergency-repair-web/src/views/system/MenuPermission.vue`。

**验证结果**
- åŽç«¯ `mvn -B -DskipTests compile` é€šè¿‡ï¼›å‰ç«¯ `npm run build` é€šè¿‡ã€‚
- æŽ¥å£ï¼š`GET /api/system/menu-permissions?roleId=2106221661022490625` è¿”回字符串型 `roleMenuIds` å…± 14 æ¡ã€‚
- æµè§ˆå™¨ï¼š`node .codex-run/verify-menu-permission.js` è¾“出 `hasTenantPanel: false`、`buttonNodeCount: 76`、`checkedMatchesSaved: true`、`hasError: false`；截图 `.codex-run/menu-permission-verified.png`。
- é¡µé¢ç¡®è®¤æŒ‰é’®èŠ‚点保留，切换角色后权限勾选可正常反显。

**当前运行状态（2026-10-06）**
- å‰ç«¯ `http://localhost:8082`，后端 `http://127.0.0.1:8091`，DM8 `127.0.0.1:5236`，Edge CDP `9222`。
- ç™»å½• `admin / admin123`；数据库 `SYSDBA/SYSDBA`，业务 schema `LX`。
- åŽç«¯æ—¥å¿—：`.codex-run/backend-20261006-menu-permission-fixed.out.log`、`.codex-run/backend-20261006-menu-permission-fixed.err.log`。

**接手注意**
- ä¸è¦æäº¤ `.codex-run`、Office é”æ–‡ä»¶æˆ– `emergency-repair-web/public/新建 æ–‡æœ¬æ–‡æ¡£.txt`。
- æœ¬è½®ä»£ç ä¸Žäº¤æŽ¥è®°å½•ä¸€å¹¶æäº¤å¹¶æŽ¨é€å…¬å¸ Git ä»“库 `main` åˆ†æ”¯ã€‚

 emergency-repair-server/src/main/java/com/emergencyrepair/business/dto/Requests.java

@@ -108,9 +108,7 @@
    @Data
    public static class MenuPermissionRequest {
        private Long roleId;
        private Long tenantId;
        private List<Long> roleMenuIds = new ArrayList<>();
        private List<Long> tenantMenuIds = new ArrayList<>();
    }
    @Data
    public static class UserRoleRequest {

 emergency-repair-server/src/main/java/com/emergencyrepair/system/controller/SystemController.java

@@ -281,22 +281,16 @@
    }

    @GetMapping("/menu-permissions")
    public Result<Map<String, Object>> menuPermissions(@RequestParam(required = false) Long roleId,
                                                       @RequestParam(required = false) Long tenantId) {
        return Result.ok(systemService.menuPermissions(roleId, tenantId));
    public Result<Map<String, Object>> menuPermissions(@RequestParam(required = false) Long roleId) {
        return Result.ok(systemService.menuPermissions(roleId));
    }

    @PostMapping("/menu-permissions")
    public Result<Void> saveMenuPermissions(@RequestBody Requests.MenuPermissionRequest request) {
        systemService.saveMenuPermissions(request.getRoleId(), request.getTenantId(),
                request.getRoleMenuIds(), request.getTenantMenuIds());
        systemService.saveMenuPermissions(request.getRoleId(), request.getRoleMenuIds());
        return Result.ok();
    }

    @GetMapping("/tenants")
    public Result<List<Map<String, Object>>> tenants() {
        return Result.ok(systemService.tenants());
    }

    @GetMapping("/three-member")
    public Result<Map<String, Object>> threeMember() {

 emergency-repair-server/src/main/java/com/emergencyrepair/system/service/SystemService.java

@@ -566,47 +566,32 @@
        baseEquipmentMapper.deleteById(id);
    }

    public List<Map<String, Object>> tenants() {
        return Collections.singletonList(row("id", 1L, "name", "临抢修租户"));
    }

    public Map<String, Object> menuPermissions(Long roleId, Long tenantId) {
        List<Long> roleMenuIds = roleMenuMapper.selectList(Wrappers.<SysRoleMenu>lambdaQuery()
                        .eq(roleId != null, SysRoleMenu::getRoleId, roleId))
                .stream().map(SysRoleMenu::getMenuId).collect(Collectors.toList());
        List<Long> tenantMenuIds = tenantMenuMapper.selectList(Wrappers.<SysTenantMenu>lambdaQuery()
                        .eq(tenantId != null, SysTenantMenu::getTenantId, tenantId))
                .stream().map(SysTenantMenu::getMenuId).collect(Collectors.toList());
        List<Long> effective = roleMenuIds.stream().filter(tenantMenuIds::contains).collect(Collectors.toList());
    public Map<String, Object> menuPermissions(Long roleId) {
        if (roleId == null) {
            throw new BusinessException("请选择角色");
        }
        List<String> roleMenuIds = roleMenuMapper.selectList(Wrappers.<SysRoleMenu>lambdaQuery()
                        .eq(SysRoleMenu::getRoleId, roleId))
                .stream().map(SysRoleMenu::getMenuId).map(String::valueOf).collect(Collectors.toList());
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("roleMenuIds", roleMenuIds);
        result.put("tenantMenuIds", tenantMenuIds);
        result.put("effectiveMenuIds", effective);
        result.put("effectiveMenuIds", roleMenuIds);
        return result;
    }

    @Transactional
    public void saveMenuPermissions(Long roleId, Long tenantId, List<Long> roleMenuIds, List<Long> tenantMenuIds) {
        if (roleId == null || tenantId == null) {
            throw new BusinessException("请选择角色和租户");
    public void saveMenuPermissions(Long roleId, List<Long> roleMenuIds) {
        if (roleId == null) {
            throw new BusinessException("请选择角色");
        }
        roleMenuMapper.delete(Wrappers.<SysRoleMenu>lambdaQuery().eq(SysRoleMenu::getRoleId, roleId));
        tenantMenuMapper.delete(Wrappers.<SysTenantMenu>lambdaQuery().eq(SysTenantMenu::getTenantId, tenantId));
        List<Long> effectiveRoleMenuIds = expandWithAncestors(roleMenuIds);
        List<Long> effectiveTenantMenuIds = expandWithAncestors(tenantMenuIds);
        for (Long menuId : effectiveRoleMenuIds) {
            SysRoleMenu relation = new SysRoleMenu();
            relation.setRoleId(roleId);
            relation.setMenuId(menuId);
            relation.setCreateTime(LocalDateTime.now());
            roleMenuMapper.insert(relation);
        }
        for (Long menuId : effectiveTenantMenuIds) {
            SysTenantMenu relation = new SysTenantMenu();
            relation.setTenantId(tenantId);
            relation.setMenuId(menuId);
            relation.setCreateTime(LocalDateTime.now());
            tenantMenuMapper.insert(relation);
        }
    }

@@ -888,18 +873,7 @@
        Set<Long> roleMenuIds = new LinkedHashSet<>(roleMenuMapper.selectList(Wrappers.<SysRoleMenu>lambdaQuery()
                        .in(SysRoleMenu::getRoleId, roleIds))
                .stream().map(SysRoleMenu::getMenuId).collect(Collectors.toList()));
        Set<Long> tenantMenuIds = new LinkedHashSet<>(tenantMenuMapper.selectList(Wrappers.<SysTenantMenu>lambdaQuery()
                        .eq(SysTenantMenu::getTenantId, 1L))
                .stream().map(SysTenantMenu::getMenuId).collect(Collectors.toList()));
        if (tenantMenuIds.isEmpty()) {
            result.addAll(roleMenuIds);
        } else {
            for (Long menuId : roleMenuIds) {
                if (tenantMenuIds.contains(menuId)) {
                    result.add(menuId);
                }
            }
        }
        result.addAll(roleMenuIds);
        return result;
    }


 emergency-repair-web/src/views/system/MenuPermission.vue

@@ -1,64 +1,63 @@
<template>
  <div class="page">
    <div class="page-title">
      <div><h2>菜单权限管理</h2><p>同一菜单必须同时获得租户授权和角色授权，用户才能访问；第一版 admin ç›´æŽ¥æ˜¾ç¤ºå…¨éƒ¨èœå•</p></div>
      <div><h2>菜单权限管理</h2><p>按角色设置菜单和按钮权限，保存后切换角色会自动反显。</p></div>
    </div>
    <div class="toolbar">
      <span>租户</span>
      <el-select v-model="tenantId" style="width:220px" @change="loadPermissions"><el-option v-for="item in tenants" :key="item.id" :label="item.name" :value="item.id"></el-option></el-select>
      <span>角色</span>
      <el-select v-model="roleId" style="width:220px" @change="loadPermissions"><el-option v-for="item in roles" :key="item.id" :label="item.name" :value="item.id"></el-option></el-select>
      <el-select v-model="roleId" style="width:260px" @change="loadPermissions"><el-option v-for="item in roles" :key="item.id" :label="item.name" :value="item.id"></el-option></el-select>
      <div class="spacer"></div>
      <el-tag type="success">最终可用菜单：{{ effectiveCount }} ä¸ª</el-tag>
      <el-button type="primary" :loading="saving" @click="save">保存双授权</el-button>
      <el-tag type="success">已选权限：{{ selectedRoleIds.length }} ä¸ª</el-tag>
      <el-button type="primary" :loading="saving" @click="save">保存角色权限</el-button>
    </div>
    <div class="permission-grid">
      <section class="permission-panel">
        <div class="panel-head"><h3>租户菜单授权</h3><el-checkbox v-model="tenantCheckAll" @change="checkAll('tenant')">全选</el-checkbox></div>
        <el-tree ref="tenantTree" :data="menus" node-key="id" show-checkbox default-expand-all :render-content="renderContent" :props="{ label: 'name', children: 'children' }" @check="syncCheckAllState('tenant')"></el-tree>
      </section>
      <section class="permission-panel">
        <div class="panel-head"><h3>角色菜单授权</h3><el-checkbox v-model="roleCheckAll" @change="checkAll('role')">全选</el-checkbox></div>
        <el-tree ref="roleTree" :data="menus" node-key="id" show-checkbox default-expand-all :render-content="renderContent" :props="{ label: 'name', children: 'children' }" @check="syncCheckAllState('role')"></el-tree>
      </section>
      <section class="permission-panel intersection-panel">
        <div class="panel-head"><h3>交集预览</h3></div>
        <div class="intersection-list"><el-tag v-for="item in effectiveMenus" :key="item.id" size="small">{{ item.name }}</el-tag></div>
      </section>
    </div>
    <section class="permission-panel">
      <div class="panel-head"><h3>角色菜单及按钮权限</h3><el-checkbox v-model="roleCheckAll" @change="checkAll">全选</el-checkbox></div>
      <el-tree ref="roleTree" :data="menus" node-key="id" show-checkbox default-expand-all :render-content="renderContent" :props="{ label: 'name', children: 'children' }" @check="syncCheckAllState"></el-tree>
    </section>
  </div>
</template>
<script>
import api from '@/api'
export default {
  name: 'MenuPermission',
  data() { return { menus: [], flatMenus: [], roles: [], tenants: [], tenantId: 1, roleId: null, saving: false, tenantCheckAll: false, roleCheckAll: false, selectedTenantIds: [], selectedRoleIds: [] } },
  data() {
    return {
      menus: [],
      flatMenus: [],
      roles: [],
      roleId: null,
      saving: false,
      roleCheckAll: false,
      selectedRoleIds: []
    }
  },
  computed: {
    allMenuIds() { return this.flatMenus.map(item => String(item.id)) },
    parentMenuIds() { const ids = new Set(); this.flatMenus.forEach(item => ids.add(String(item.pid))); return ids },
    leafMenuIds() { return this.flatMenus.filter(item => !this.parentMenuIds.has(String(item.id))).map(item => String(item.id)) },
    effectiveCount() { return this.effectiveMenus.length },
    effectiveMenus() { return this.flatMenus.filter(item => this.selectedTenantIds.map(String).includes(String(item.id)) && this.selectedRoleIds.map(String).includes(String(item.id))) }
    allMenuIds() { return this.flatMenus.map(item => String(item.id)) }
  },
  created() { this.loadBase() },
  methods: {
    loadBase() {
      Promise.all([api.get('/system/menu/tree'), api.get('/system/menu/list'), api.get('/system/roles'), api.get('/system/tenants')]).then(([tree, flat, roles, tenants]) => {
        this.menus = tree.data || []; this.flatMenus = flat.data || []; this.roles = roles.data || []; this.tenants = tenants.data || []
      Promise.all([api.get('/system/menu/tree'), api.get('/system/menu/list'), api.get('/system/roles')]).then(([tree, flat, roles]) => {
        this.menus = tree.data || []
        this.flatMenus = flat.data || []
        this.roles = roles.data || []
        if (!this.roleId && this.roles.length) this.roleId = this.roles[0].id
        this.$nextTick(this.loadPermissions)
      })
    },
    loadPermissions() {
      if (!this.roleId || !this.tenantId) return
      api.get('/system/menu-permissions', { params: { roleId: this.roleId, tenantId: this.tenantId } }).then(res => {
      if (!this.roleId) {
        this.selectedRoleIds = []
        this.roleCheckAll = false
        if (this.$refs.roleTree) this.$refs.roleTree.setCheckedKeys([])
        return
      }
      api.get('/system/menu-permissions', { params: { roleId: this.roleId } }).then(res => {
        const data = res.data || {}
        this.selectedTenantIds = data.tenantMenuIds || []
        this.selectedRoleIds = data.roleMenuIds || []
        this.selectedRoleIds = (data.roleMenuIds || []).map(String)
        this.$nextTick(() => {
          this.$refs.tenantTree.setCheckedKeys(this.leafKeys(this.selectedTenantIds))
          this.$refs.roleTree.setCheckedKeys(this.leafKeys(this.selectedRoleIds))
          this.syncCheckAllState('tenant'); this.syncCheckAllState('role')
          this.$refs.roleTree.setCheckedKeys(this.displayCheckedKeys(this.selectedRoleIds))
          this.syncCheckAllState()
        })
      })
    },
@@ -66,21 +65,51 @@
      const label = data.menuType === 2 ? data.name + ' [按钮 ' + (data.permissions || '') + ']' : data.name
      return h('span', { class: { 'perm-button-node': data.menuType === 2 } }, label)
    },
    leafKeys(ids) { const leafIds = new Set(this.leafMenuIds); return (ids || []).map(String).filter(id => leafIds.has(id)) },
    displayCheckedKeys(ids) {
      const selected = new Set((ids || []).map(String))
      const children = {}
      const menuIds = new Set(this.flatMenus.map(item => String(item.id)))
      this.flatMenus.forEach(item => {
        const id = String(item.id)
        const pid = item.pid == null ? '0' : String(item.pid)
        if (!children[pid]) children[pid] = []
        children[pid].push(id)
      })
      const result = []
      const collectFullySelected = id => {
        if (!selected.has(id)) return false
        const childIds = children[id] || []
        if (!childIds.length) {
          result.push(id)
          return true
        }
        const allChildrenSelected = childIds.map(collectFullySelected).every(Boolean)
        if (allChildrenSelected) result.push(id)
        return allChildrenSelected
      }
      this.flatMenus.filter(item => item.pid == null || String(item.pid) === '0' || !menuIds.has(String(item.pid))).forEach(item => collectFullySelected(String(item.id)))
      return result
    },
    checkedMenuIds(ref) { return [...new Set([...(ref.getCheckedKeys(false) || []), ...(ref.getHalfCheckedKeys() || [])].map(String))] },
    syncCheckAllState(target) { const ref = target === 'tenant' ? this.$refs.tenantTree : this.$refs.roleTree; if (!ref) return; const checked = this.checkedMenuIds(ref).length === this.allMenuIds.length; if (target === 'tenant') this.tenantCheckAll = checked; if (target === 'role') this.roleCheckAll = checked },
    checkAll(target) {
      const checked = target === 'tenant' ? this.tenantCheckAll : this.roleCheckAll
      const ref = target === 'tenant' ? this.$refs.tenantTree : this.$refs.roleTree
      ref.setCheckedKeys(checked ? this.allMenuIds : [])
      this.$nextTick(() => this.syncCheckAllState(target))
    syncCheckAllState() {
      const ref = this.$refs.roleTree
      if (!ref) return
      this.roleCheckAll = this.checkedMenuIds(ref).length === this.allMenuIds.length
    },
    checkAll() {
      this.$refs.roleTree.setCheckedKeys(this.roleCheckAll ? this.allMenuIds : [])
      this.$nextTick(this.syncCheckAllState)
    },
    save() {
      const tenantMenuIds = this.checkedMenuIds(this.$refs.tenantTree)
      if (!this.roleId) {
        this.$message.warning('请先选择角色')
        return
      }
      const roleMenuIds = this.checkedMenuIds(this.$refs.roleTree)
      this.saving = true
      api.post('/system/menu-permissions', { tenantId: this.tenantId, roleId: this.roleId, tenantMenuIds, roleMenuIds }).then(() => {
        this.selectedTenantIds = tenantMenuIds; this.selectedRoleIds = roleMenuIds; this.$message.success('菜单权限已保存')
      api.post('/system/menu-permissions', { roleId: this.roleId, roleMenuIds }).then(() => {
        this.selectedRoleIds = roleMenuIds
        this.$message.success('角色菜单权限已保存')
      }).finally(() => { this.saving = false })
    }
  }
@@ -89,10 +118,23 @@
<style scoped>
::v-deep .perm-button-node { color: #b8791f; }

.permission-grid { display: grid; grid-template-columns: 1fr 1fr 320px; gap: 12px; }
.permission-panel { min-height: calc(100vh - 220px); padding: 14px; border: 1px solid #dce4ec; border-radius: 4px; background: #fff; overflow: auto; }
.panel-head { display: flex; align-items: center; justify-content: space-between; margin-bottom: 12px; }
.panel-head h3 { margin: 0; color: #31465d; font-size: 15px; }
.intersection-list { display: flex; flex-wrap: wrap; gap: 6px; }
@media (max-width: 1100px) { .permission-grid { grid-template-columns: 1fr; } }
.permission-panel {
  min-height: calc(100vh - 220px);
  padding: 14px;
  border: 1px solid #dce4ec;
  border-radius: 4px;
  background: #fff;
  overflow: auto;
}
.panel-head {
  display: flex;
  align-items: center;
  justify-content: space-between;
  margin-bottom: 12px;
}
.panel-head h3 {
  margin: 0;
  color: #31465d;
  font-size: 15px;
}
</style>

 requirement/½»½ÓÎļþ_2026.10.3.md

@@ -504,3 +504,33 @@
- éžç®¡ç†å‘˜å®Œå·¥å¡«æŠ¥çš„单位匹配目前按 `DEPT_NAME`，不是 `DEPT_ID`；若出现同名部门，应改为 ID ç²¾ç¡®åŒ¹é…ã€‚
- åŽ†å²æ¼”示派工单可能仍保存旧 `T_CONTRACTOR` åç§°ï¼Œéžç®¡ç†å‘˜ cj ç”¨æˆ·å¯èƒ½çœ‹ä¸åˆ°ï¼›`admin` ä¸å—单位过滤影响。
- `.codex-run`、Office é”æ–‡ä»¶ä»¥åŠ `emergency-repair-web/public/新建 æ–‡æœ¬æ–‡æ¡£.txt` æ˜¯æœ¬åœ°è”调或临时文件，不应提交。

## åäºŒã€2026-10-06 è”调收尾（需求 20）

| åºå· | éœ€æ±‚ | çŠ¶æ€ | å®žçŽ°ä¸ŽéªŒè¯ |
| --- | --- | --- | --- |
| 20 | èœå•æƒé™ç®¡ç†å–消租户权限，仅保留角色权限；权限复选框反显 | å·²å®Œæˆ | æƒé™æ ‘保留菜单和按钮节点；角色切换后正常反显，接口仅处理 `roleId` / `roleMenuIds` |

### 12.1 ä¸»è¦å˜æ›´æ–‡ä»¶

后端：

- `emergency-repair-server/src/main/java/com/emergencyrepair/business/dto/Requests.java`
- `emergency-repair-server/src/main/java/com/emergencyrepair/system/controller/SystemController.java`
- `emergency-repair-server/src/main/java/com/emergencyrepair/system/service/SystemService.java`

前端：

- `emergency-repair-web/src/views/system/MenuPermission.vue`

### 12.2 éªŒè¯ç»“æžœ

- åŽç«¯ `mvn -B -DskipTests compile` é€šè¿‡ï¼›å‰ç«¯ `npm run build` é€šè¿‡ã€‚
- `GET /api/system/menu-permissions?roleId=2106221661022490625` è¿”回字符串型 `roleMenuIds` å…± 14 æ¡ï¼Œé¿å…æµè§ˆå™¨è§£æžé›ªèŠ± ID æ—¶ä¸¢å¤±ç²¾åº¦ã€‚
- `node .codex-run/verify-menu-permission.js` è¾“出 `hasTenantPanel: false`、`buttonNodeCount: 76`、`checkedMatchesSaved: true`、`hasError: false`。
- é¡µé¢ä¿ç•™æŒ‰é’®èŠ‚点，角色切换后权限树复选框反显正常；截图 `.codex-run/menu-permission-verified.png`。

### 12.3 æŽ¥æ‰‹æ³¨æ„

- æœ¬è½®ä»£ç ä¸Žäº¤æŽ¥è®°å½•ä¸€å¹¶æäº¤å¹¶æŽ¨é€å…¬å¸ Git ä»“库 `main` åˆ†æ”¯ã€‚
- `.codex-run`、Office é”æ–‡ä»¶åŠ `emergency-repair-web/public/新建 æ–‡æœ¬æ–‡æ¡£.txt` ä»ä¸ºæœ¬åœ°ä¸´æ—¶æ–‡ä»¶ï¼Œä¸åº”提交。