@gingkoo/base-server 0.0.1-alpha.0 → 0.0.1-alpha.1

package/backend/routers/permission.js

@@ -0,0 +1,985 @@
+'use strict';
+const express = require('express');
+const permService = require('../common/services/permission');
+const userService = require('../common/services/user');
+const rolesService = require('../common/services/roles');
+const { permission: permissionConstant } = require('../common/enum');
+
+const permissionService = require('../services/permission');
+const moduleServices = require('../services/module');
+const setting = require('../services/setting');
+const router = express.Router();
+
+function currentUser(req, userid) {
+  for (let v in req) {
+    if (typeof req[v] === 'string') {
+      req[v] = req[v].replace('currentUser', userid);
+    }
+  }
+  return req;
+}
+
+/**
+ * 团队管理模块权限存储 :模块ID
+ * 系统管理模块权限存储 :导航ID
+ * 根据权限类型RES_TYPE决定当前权限管理模块 module为设置左侧模块权限，project为设置项目管理模块内部权限，manage为系统设置的权限管理
+ *
+ */
+
+/* ***********************************系统权限操作********************************************* */
+
+// 根据当前系统用户的角色所有导航功能权限
+router.get('/userPerm', async function (req, res) {
+  let userRoles = await rolesService.getRoleMembers(null, {
+    USER_ID: req.get('X-UserId'),
+    ROLE_TYPE: permissionConstant.ROLE_TYPE.MANAGER,
+  });
+  if (!Array.isArray(userRoles)) return res.sendErr('查询用户角色失败');
+  userRoles = userRoles.map((role) => role.ROLE_ID);
+  let permission = await permissionService.getOperPermissions({
+    OPER_TYPE: permissionConstant.OPER_TYPE.ROLE,
+    OPER_ID: userRoles,
+    RES_KIND: permissionConstant.RES_KIND.API,
+    RES_TYPE: permissionConstant.RES_TYPE.SYSTEM_NAV,
+  });
+  if (!Array.isArray(permission)) return res.sendErr('查询权限失败');
+  let perms = permission.reduce((obj, perm) => {
+    let objNavPerm = [];
+    try {
+      objNavPerm = JSON.parse(perm.PROPS);
+      !Array.isArray(objNavPerm) && (objNavPerm = []);
+    } catch (error) {}
+    if (Array.isArray(obj[perm.RES_RANGE]) && obj[perm.RES_RANGE].length) {
+      objNavPerm = objNavPerm.map((v) => v.feature);
+      obj[perm.RES_RANGE] = obj[perm.RES_RANGE]
+        .map((v) => v.feature)
+        .concat(objNavPerm)
+        .filter((v, i, arr) => arr.indexOf(v) === i)
+        .map((v) => {
+          return {
+            feature: v,
+          };
+        });
+    } else {
+      obj[perm.RES_RANGE] = objNavPerm;
+    }
+    return obj;
+  }, {});
+
+  return res.sendOk(perms);
+});
+
+// 查询用户角色的系统管理权限
+router.get('/rolePermission', async function (req, res) {
+  let roleId = req.query['ROLE_ID'];
+  let permission = await permissionService.getOperPermissions({
+    OPER_TYPE: permissionConstant.OPER_TYPE.ROLE,
+    OPER_ID: roleId,
+    // RES_TYPE: [permissionConstant.RES_TYPE.SYSTEM_MODULE, permissionConstant.RES_TYPE.SYSTEM_NAV],
+  });
+  if (!permission) return res.sendErr('查询失败');
+
+  return res.sendOk(permission);
+});
+
+// 查询所有系统角色成员列表
+router.get('/roleMember', async function (req, res) {
+  let data = await rolesService.getRoleMembers(null, {
+    ROLE_TYPE: permissionConstant.ROLE_TYPE.MANAGER,
+    ...req.query,
+  });
+  if (!Array.isArray(data)) return res.sendErr('查询失败');
+  let result = {};
+  data.forEach((item) => {
+    if (Array.isArray(result[item.ROLE_ID])) {
+      result[item.ROLE_ID].push(item);
+    } else {
+      result[item.ROLE_ID] = [item];
+    }
+  });
+
+  return res.sendOk(result);
+});
+
+// 添加系统角色成员
+router.post('/roleMember', async function (req, res) {
+  let roleMemberFields = ['ROLE_ID', 'USER_ID', 'REMARKS'];
+  let props = {};
+  req.body = currentUser(req.body, req.get('X-UserId'));
+  for (let k in req.body) {
+    if (roleMemberFields.includes(k)) {
+      props[k] = req.body[k];
+    }
+  }
+  let create = await permissionService.addRoleMember({
+    ...props,
+    ROLE_TYPE: permissionConstant.ROLE_TYPE.MANAGER,
+  });
+  if (!create) return res.sendErr('创建失败');
+  return res.sendOk('创建成功');
+});
+
+// 修改系统角色成员
+router.put('/roleMember', async function (req, res) {
+  req.body = currentUser(req.body, req.get('X-UserId'));
+  let filter = {
+    ROLE_ID: req.body['ROLE_ID'],
+    USER_ID: req.body['USER_ID'],
+    ROLE_TYPE: permissionConstant.ROLE_TYPE.MANAGER,
+  };
+  let params = {
+    REMARKS: req.body['REMARKS'],
+  };
+  if (!filter['ROLE_ID'] || !filter['USER_ID']) return res.sendErr('修改失败，缺少参数');
+  let upd = await permissionService.updRoleMemberInfo(filter, params);
+  if (!upd) return res.sendErr('修改失败');
+  return res.sendOk('修改成功');
+});
+
+// 删除系统角色成员信息
+router.delete('/roleMember', async function (req, res) {
+  req.body = currentUser(req.body, req.get('X-UserId'));
+  let filter = {
+    ROLE_ID: req.body['ROLE_ID'],
+    USER_ID: req.body['USER_ID'],
+    ROLE_TYPE: permissionConstant.ROLE_TYPE.MANAGER,
+  };
+  if (!filter['ROLE_ID'] || !filter['USER_ID']) return res.sendErr('删除失败，缺少参数');
+  let option = await permissionService.delRoleMember(filter);
+  if (!option) return res.sendErr('删除失败');
+  return res.sendOk('删除成功');
+});
+
+// 查询系统角色列表
+router.get('/roleList', async function (req, res) {
+  let data = await rolesService.getRoles(permissionConstant.ROLE_TYPE.MANAGER);
+  if (!data) return res.sendErr('查询失败');
+  return res.sendOk(data);
+});
+
+/**
+ * 获取所有系统管理页面模块
+ */
+router.get('/systemPages', async function (req, res) {
+  const module = await setting.getModules('setting');
+  const nav = await setting.getNavs();
+  if (Array.isArray(module) && Array.isArray(nav) && module.length) {
+    res.sendOk({
+      module,
+      nav,
+    });
+    return;
+  }
+  res.sendErr('查询失败');
+});
+
+/**
+ * 用户开启或关闭权限设置
+ * @param ACTION 操作权限的动作，开启或关闭，开启为true，关闭为false
+ * @param OPER_ID 操作对象ID
+ * @param OPER_TYPE 操作对象类型
+ * @param RES_KIND 权限种类 page|api|file
+ * @param RES_TYPE 权限应用类型
+ * @param RES_RANGE 导航ID
+ */
+router.put('/permission', async function (req, res) {
+  let action = req.body['ACTION'];
+  let operId = req.body['OPER_ID'];
+  let operType = req.body['OPER_TYPE'];
+  let resType = req.body['RES_TYPE'];
+  let features = req.body['features'];
+  if (!features || !resType || !operId || !operType) return res.sendErr('缺少参数');
+
+  if (!Array.isArray(features)) return res.sendErr('features参数格式错误');
+
+  let result = false;
+  let pageFilter = {
+    RES_KIND: permissionConstant.RES_KIND.PAGE,
+    RES_TYPE: resType,
+    OPER_ID: operId,
+    OPER_TYPE: operType,
+  };
+
+  let apiFilter = {
+    RES_KIND: permissionConstant.RES_KIND.API,
+    RES_TYPE: resType,
+    OPER_ID: operId,
+    OPER_TYPE: operType,
+  };
+
+  async function apiFun() {
+    let apiFeature = features.filter((v) => v.RES_KIND === permissionConstant.RES_KIND.API);
+    if (!apiFeature.length) return [true];
+    let apiRangeFeature = apiFeature.reduce((obj, v) => {
+      if (Array.isArray(obj[v.RES_RANGE])) {
+        obj[v.RES_RANGE].push({ feature: v.feature || '', api: v.api || '' });
+      } else {
+        obj[v.RES_RANGE] = [{ feature: v.feature || '', api: v.api || '' }];
+      }
+      return obj;
+    }, {});
+    let apiPromiss = Object.keys(apiRangeFeature).map(async (range) => {
+      let operPerm = await permissionService.checkOperPermission(null, null, range, apiFilter);
+      if (!Array.isArray(operPerm)) return false;
+      let permProps = operPerm?.[0]?.PROPS || '[]';
+      try {
+        permProps = JSON.parse(permProps);
+      } catch (error) {}
+      if (!operPerm.length && action) {
+        let params = {
+          ...apiFilter,
+          RES_RANGE: range,
+          PROPS: JSON.stringify(apiRangeFeature[range]),
+        };
+        return permissionService.addOperPermission(params);
+      }
+
+      if (permProps !== null && !Array.isArray(permProps)) return false;
+
+      let oldProps = permProps.map((v) => v.feature);
+      let newFeatures = apiRangeFeature[range].map((v) => v.feature);
+      let newProps = action
+        ? oldProps.concat(newFeatures).filter((v, i, arr) => arr.indexOf(v) === i)
+        : oldProps?.filter((v) => !newFeatures.includes(v));
+
+      let params = {
+        PROPS: JSON.stringify(
+          newProps.map((v) => {
+            return {
+              feature: v,
+            };
+          }),
+        ),
+      };
+      let newFilter = {
+        ...apiFilter,
+        RES_RANGE: range,
+      };
+      return permissionService.updateOperPermRange(newFilter, params);
+    });
+    return await Promise.all(apiPromiss);
+  }
+
+  async function pageFun() {
+    let pageFeature = features.filter((v) => v.RES_KIND === permissionConstant.RES_KIND.PAGE);
+    if (!pageFeature.length) return true;
+    let pagePerm = await permissionService.checkOperPermission(null, null, null, pageFilter);
+    let pageRange = pageFeature
+      .map((v) => v.RES_RANGE)
+      .filter((v) => {
+        if (action) {
+          // 添加查看页面权限，要添加数据，在此过滤下重复数据，然后添加
+          return v && !pagePerm?.[0]?.RES_RANGE?.includes(v);
+        } else {
+          // 取消查看页面权限，这些数据要删除
+          return v && pagePerm?.[0]?.RES_RANGE?.includes(v);
+        }
+      });
+
+    if (!pagePerm.length && action) {
+      // 添加权限，此操作对象没有查看页面的权限
+      let params = {
+        ...pageFilter,
+        RES_RANGE: pageRange.join(','),
+      };
+      return await permissionService.addOperPermission(params);
+    }
+    if (pagePerm[0].RES_RANGE !== null && typeof pagePerm[0].RES_RANGE !== 'string') return false;
+
+    let oldRange = pagePerm[0].RES_RANGE?.split(',') || [];
+    let newRange = action
+      ? oldRange.concat(pageRange)?.join(',')
+      : oldRange.filter((o) => !pageRange.includes(o))?.join(',');
+    return await permissionService.updateOperPermRange(pageFilter, { RES_RANGE: newRange });
+  }
+
+  async function executeFun() {
+    let pageResult = await pageFun();
+    let apiResult = await apiFun();
+    return pageResult && !apiResult.filter((v) => !v).length;
+  }
+
+  result = await executeFun();
+
+  if (!result) return res.sendErr('操作失败');
+  return res.sendOk('操作成功');
+});
+
+/* ***********************************模块权限操作********************************************* */
+
+/**
+ * 模块选择对象
+ * @param type 操作对象类型 部门|团队|用户     dept|groups|user
+ * @param moduleId 操作的模块
+ * @param value 操作对象的值，多选时，字符串或数组
+ * 这个接口只应用于团队管理的权限管理
+ */
+router.put('/module/:moduleId', async function (req, res) {
+  // type  ===>  dept || group || user
+  let type = req.body['type'];
+  let moduleId = req.params['moduleId'];
+  let value = req.body['value'];
+
+  if (typeof value === 'string') {
+    value = value.split(',');
+  }
+  if (!Array.isArray(value)) return res.sendErr('数据格式错误');
+
+  value = value.filter((v) => v);
+
+  async function setModulePermission(operType, operId, moduleId) {
+    // 检查此操作对象是否有当前权限
+    let perms = await permissionService.checkOperPermission(null, null, moduleId, {
+      RES_KIND: 'page',
+      RES_TYPE: permissionConstant.RES_TYPE.MODULE,
+      OPER_ID: operId,
+      OPER_TYPE: operType,
+    });
+    let oper = await permissionService.checkOperPermission(null, null, null, {
+      RES_KIND: 'page',
+      RES_TYPE: permissionConstant.RES_TYPE.MODULE,
+      OPER_ID: operId,
+      OPER_TYPE: operType,
+    });
+    if (!Array.isArray(perms) || !Array.isArray(oper)) return false;
+    let result;
+    if (!perms.length) {
+      // 没有权限，添加
+      result = oper.length
+        ? permissionService.updateOperPermRange(
+            {
+              OPER_TYPE: operType,
+              OPER_ID: operId,
+              RES_KIND: 'page',
+              RES_TYPE: permissionConstant.RES_TYPE.MODULE,
+            },
+            { RES_RANGE: oper?.[0]?.RES_RANGE ? `${oper[0].RES_RANGE},${moduleId}` : moduleId },
+          )
+        : permissionService.addOperPermission({
+            OPER_TYPE: operType,
+            OPER_ID: operId,
+            RES_KIND: 'page',
+            RES_TYPE: permissionConstant.RES_TYPE.MODULE,
+            RES_RANGE: moduleId,
+            REMARKS: '查看模块权限',
+          });
+    }
+    return result;
+  }
+
+  async function cancelModulePermission(operType, operId, range) {
+    let filter = {
+      RES_KIND: 'page',
+      RES_TYPE: permissionConstant.RES_TYPE.MODULE,
+      OPER_TYPE: operType,
+      OPER_ID: operId,
+    };
+    let params = {
+      RES_RANGE: range,
+    };
+    return await permissionService.updateOperPermRange(filter, params);
+  }
+
+  // 配置传来的操作对象
+  await Promise.all(value.map((v) => setModulePermission(type, v, moduleId)));
+
+  // 筛选出需要删除的操作对象权限
+  let moduleOpers = await permissionService.checkOperPermission(null, null, moduleId, {
+    RES_KIND: 'page',
+    RES_TYPE: permissionConstant.RES_TYPE.MODULE,
+  });
+  if (Array.isArray(moduleOpers) && moduleOpers.length) {
+    let delOpers = moduleOpers.reduce((mo, item) => {
+      if (item.OPER_TYPE === type && !value.includes(item.OPER_ID)) {
+        mo.push({
+          OPER_TYPE: item.OPER_TYPE,
+          OPER_ID: item.OPER_ID,
+          RES_RANGE: item.RES_RANGE?.split(',')
+            ?.filter((v) => v !== moduleId)
+            ?.join(','),
+        });
+      }
+      return mo;
+    }, []);
+    delOpers.length &&
+      (await Promise.all(
+        delOpers.map((v) => cancelModulePermission(type, v.OPER_ID, v.RES_RANGE)),
+      ));
+  }
+
+  return res.sendOk('操作成功');
+});
+
+/**
+ * 获取所有模块
+ */
+router.get('/allModules', async function (req, res) {
+  let allModules = await moduleServices.getAllModules();
+  if (!allModules || !Array.isArray(allModules)) return res.sendErr('查询失败');
+  return res.sendOk(allModules);
+});
+
+// 获取部门，团队，用户列表
+router.get('/operList', async function (req, res) {
+  let deptData = await userService.getDeptData();
+  let groupData = await userService.getGroupData();
+  let userData = await userService.getUsers();
+  if (!Array.isArray(deptData) || !Array.isArray(groupData) || !Array.isArray(userData))
+    return res.sendErr('查询失败');
+  return res.sendOk({ deptData, groupData, userData });
+});
+
+// 查询当前操作对象权限
+router.get('/operPerm', async function (req, res) {
+  let userId = req.query['USER_ID'];
+  let userPerms = await permissionService.checkOperPermission('user', userId, null, {
+    RES_KIND: 'page',
+    RES_TYPE: permissionConstant.RES_TYPE.MODULE,
+  });
+  if (!Array.isArray(userPerms) || !userPerms.length) return res.sendErr('查询失败');
+  let modules = userPerms.reduce((mo, perm) => {
+    let ms = perm.RES_RANGE?.split(',').filter((v) => !mo.includes(v));
+    mo = mo.concat(ms);
+    return mo;
+  }, []);
+  return res.sendOk(modules);
+});
+
+/**
+ * 获取模块操作对象
+ */
+router.get('/moduleOpers', async function (req, res) {
+  let data = await permissionService.checkOperPermission(null, null, null, {
+    RES_KIND: 'page',
+    RES_TYPE: permissionConstant.RES_TYPE.MODULE,
+  });
+
+  if (!Array.isArray(data)) return res.sendErr('查询失败');
+  let result = {};
+  data.forEach((item) => {
+    if (typeof item.RES_RANGE === 'string' && item.RES_RANGE) {
+      item.RES_RANGE.split(',').forEach((m) => {
+        if (!result[m]) {
+          result[m] = {
+            dept: [],
+            group: [],
+            user: [],
+          };
+        }
+        if (Array.isArray(result[m][item.OPER_TYPE])) {
+          result[m][item.OPER_TYPE].push(item.OPER_ID);
+        }
+      });
+    }
+  });
+
+  return res.sendOk(result);
+});
+
+router.get('/permissionData', async function (req, res) {
+  let result = [
+    {
+      NAV_ID: '8a72a8ed6ac44a3e8ebfc51ce25672b4',
+      NAV_NAME: '团队信息',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'eba2eb575b8843dfb21c3ce87686c079',
+      NAV_NAME: '团队成员',
+      PERMISSION: [
+        {
+          feature: 'edit',
+          title: '编辑成员',
+          api: 'put:/team/membermanage/modify/${USER_ID},post:/team/membermanage/api/group/leader',
+        },
+        {
+          feature: 'del',
+          title: '删除成员',
+          api: 'put:/team/membermanage/batchdel',
+        },
+      ],
+    },
+    {
+      NAV_ID: 'c089227bd71d42c5a312286f214b582f',
+      NAV_NAME: '用户组',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '新增组成员',
+          api: 'post:/team/usergroup',
+        },
+        {
+          feature: 'del',
+          title: '删除组成员',
+          api: 'delete:/team/usergroup',
+        },
+        {
+          feature: 'edit',
+          title: '编辑组负责人',
+          api: 'post:/team/usergroup/api/usergroup/leader',
+        },
+      ],
+    },
+    {
+      NAV_ID: '050f25df236e4fc0bfd043d2cebd99c6',
+      NAV_NAME: '角色',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '新增角色',
+          api: 'post:/team/roles',
+        },
+        {
+          feature: 'edit',
+          title: '编辑角色',
+          api: 'put:/team/roles/${ROLE_ID}',
+        },
+        {
+          feature: 'del',
+          title: '删除角色',
+          api: 'delete:/team/roles/${ROLE_ID}',
+        },
+      ],
+    },
+    {
+      NAV_ID: 'f78b05ac9d25414bb97a9640bc63ed7d',
+      NAV_NAME: '权限设置',
+      PERMISSION: [
+        {
+          feature: 'edit',
+          title: '配置权限',
+          api: '',
+        },
+      ],
+    },
+
+    {
+      NAV_ID: '36e5f91b49394535ad48399c696d5be7',
+      NAV_NAME: '界面配置',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '添加模块导航',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '编辑模块导航',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除模块导航',
+          api: '',
+        },
+      ],
+    },
+    {
+      NAV_ID: '7a799accc840446eb0677255c2da9f0e',
+      NAV_NAME: '一般配置',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'd0bd026cf645402888dd544d7ada37e6',
+      NAV_NAME: '数据字典',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '新增码值',
+          api: 'post:/space/dict',
+        },
+        {
+          feature: 'edit',
+          title: '编辑码值',
+          api: 'put:/space/dict/${ITEM_ID},post:/space/dict/dictsort',
+        },
+        {
+          feature: 'del',
+          title: '删除码值',
+          api: 'delete:/space/dict/${ITEM_ID}',
+        },
+      ],
+    },
+    {
+      NAV_ID: '3e90ee0760ab4ef2ad6515e0996826e0',
+      NAV_NAME: '安全设置',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: '24de3d1792e748b29e01fd095e27317b',
+      NAV_NAME: 'API',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'e8821c573da448f8b7332fb79f1c7b58',
+      NAV_NAME: '第三方集成',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'f0db4f3fda494828a797f16948602e77',
+      NAV_NAME: '通知',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: '5bb98d2045c44efba9bf6aa979a9f825',
+      NAV_NAME: '自动化规则',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '新建自动化规则',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '编辑自动化规则',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除自动化规则',
+          api: '',
+        },
+      ],
+    },
+    {
+      NAV_ID: '25f6463680d84055b4fe1c97a19725c1',
+      NAV_NAME: '权限设置',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '添加角色成员',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '编辑角色成员,配置权限',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除角色成员',
+          api: '',
+        },
+      ],
+    },
+  ];
+  return res.sendOk(result);
+});
+
+router.get('/projectPermissionData', async function (req, res) {
+  let result = [
+    {
+      NAV_ID: 'issues',
+      NAV_NAME: '工作项',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'taskboard',
+      NAV_NAME: '任务看板',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'item-plan',
+      NAV_NAME: '项目计划',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'requirement',
+      NAV_NAME: '需求',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'modules',
+      NAV_NAME: '模块',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '添加模块数据',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '编辑模块数据',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除模块数据',
+          api: '',
+        },
+      ],
+    },
+    {
+      NAV_ID: 'person-plan',
+      NAV_NAME: '人员计划',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'versions',
+      NAV_NAME: '版本',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '添加版本',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '修改版本信息',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除版本',
+          api: '',
+        },
+      ],
+    },
+    {
+      NAV_ID: 'members',
+      NAV_NAME: '成员',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '添加项目成员',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '修改项目成员',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除项目成员',
+          api: '',
+        },
+      ],
+    },
+    {
+      NAV_ID: 'branch',
+      NAV_NAME: '分支',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '添加分支',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '修改分支信息',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除分支',
+          api: '',
+        },
+        {
+          feature: 'merge',
+          title: '合并分支',
+          api: '',
+        },
+      ],
+    },
+    {
+      NAV_ID: 'project_work',
+      NAV_NAME: '项目文档',
+      PERMISSION: [],
+    },
+    {
+      NAV_ID: 'projectSetting-component',
+      NAV_NAME: '项目组件',
+      PERMISSION: [
+        {
+          feature: 'edit',
+          title: '修改项目组件配置',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '移除项目组件配置',
+          api: '',
+        },
+      ],
+    },
+    {
+      NAV_ID: 'projectSetting-taskboard',
+      NAV_NAME: '任务看板',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '添加面板配置数据',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '编辑面板配置数据',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除面板配置数据',
+          api: '',
+        },
+      ],
+    },
+    {
+      NAV_ID: 'projectSetting-stage',
+      NAV_NAME: '项目阶段',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '添加项目阶段',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '修改项目阶段',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除项目阶段',
+          api: '',
+        },
+      ],
+    },
+    {
+      NAV_ID: 'test',
+      NAV_NAME: '测试数据',
+      PERMISSION: [
+        {
+          feature: 'add',
+          title: '添加项目阶段',
+          api: '',
+        },
+        {
+          feature: 'edit',
+          title: '修改项目阶段',
+          api: '',
+        },
+        {
+          feature: 'del',
+          title: '删除项目阶段',
+          api: '',
+        },
+      ],
+    },
+  ];
+  res.sendOk(result);
+});
+
+// 查询项目角色列表
+router.get('/projectRoleList', async function (req, res) {
+  let data = await rolesService.getRoles(permissionConstant.ROLE_TYPE.PROJECT);
+  if (!data) return res.sendErr('查询失败');
+  return res.sendOk(data);
+});
+
+// 查询项目页面列表
+router.get('/projectNavs', async function (req, res) {
+  let projectNavs = await permService.getModuleNavs('teams-project');
+
+  if (!Array.isArray(projectNavs)) return res.sendErr('查询失败');
+  let module = [
+    {
+      NAV_ID: 'projectPages',
+      NAV_NAME: '项目管理 - 页面列表',
+    },
+    {
+      NAV_ID: 'projectSetting',
+      NAV_NAME: '项目管理 - 项目设置',
+    },
+  ];
+
+  let projectSettingNavs = [
+    {
+      NAV_ID: 'projectSetting-component',
+      NAV_NAME: '项目组件',
+      PARENT_ID: 'projectSetting',
+    },
+    {
+      NAV_ID: 'projectSetting-taskboard',
+      NAV_NAME: '任务看板',
+      PARENT_ID: 'projectSetting',
+    },
+    {
+      NAV_ID: 'projectSetting-stage',
+      NAV_NAME: '项目阶段',
+      PARENT_ID: 'projectSetting',
+    },
+  ];
+
+  let nav = projectNavs.reduce((mo, nav) => {
+    mo.push({
+      ...nav,
+      PARENT_ID: 'projectPages',
+    });
+    return mo;
+  }, projectSettingNavs);
+
+  return res.sendOk({ module, nav });
+});
+
+// 查询当前用户在项目中角色的权限
+router.get('/projectPerm', async function (req, res) {
+  let proId = req.query['PROJECT_ID'];
+  let userId = req.get('X-UserId');
+  if (!proId || !userId) return res.sendErr('查询失败，缺少参数');
+
+  let role = await permService.getUserProjectRole({ PROJECT_ID: proId, USER_ID: userId });
+  if (!role) return res.sendErr('查询项目角色失败');
+
+  // 一个用户在一个项目中只有一个角色
+  if (!Array.isArray(role) || !role[0] || !role[0].MEM_ROLE) return res.sendOk({});
+
+  let permission = await permissionService.getOperPermissions({
+    OPER_TYPE: permissionConstant.OPER_TYPE.ROLE,
+    OPER_ID: role[0].MEM_ROLE,
+    RES_TYPE: permissionConstant.RES_TYPE.PROJECT_NAV,
+  });
+  if (!Array.isArray(permission)) return res.sendErr('查询权限失败');
+  let perms = permission
+    .filter((perm) => perm.RES_KIND === permissionConstant.RES_KIND.API)
+    .reduce((obj, perm) => {
+      let objNavPerm = [];
+      try {
+        objNavPerm = JSON.parse(perm.PROPS);
+        !Array.isArray(objNavPerm) && (objNavPerm = []);
+      } catch (error) {}
+      if (Array.isArray(obj[perm.RES_RANGE]) && obj[perm.RES_RANGE].length) {
+        objNavPerm = objNavPerm.map((v) => v.feature);
+        obj[perm.RES_RANGE] = obj[perm.RES_RANGE]
+          .map((v) => v.feature)
+          .concat(objNavPerm)
+          .filter((v, i, arr) => arr.indexOf(v) === i)
+          .map((v) => {
+            return {
+              feature: v,
+            };
+          });
+      } else {
+        obj[perm.RES_RANGE] = objNavPerm;
+      }
+      return obj;
+    }, {});
+
+  permission
+    .filter((perm) => perm.RES_KIND === permissionConstant.RES_KIND.PAGE)
+    .forEach((perm) => {
+      let pages = (typeof perm['RES_RANGE'] === 'string' && perm['RES_RANGE'].split(',')) || null;
+      Array.isArray(pages) &&
+        pages.forEach((page) => {
+          if (Array.isArray(perms[page])) {
+            perms[page].push({ feature: 'page' });
+          } else {
+            perms[page] = [{ feature: 'page' }];
+          }
+        });
+    });
+
+  return res.sendOk(perms);
+});
+
+module.exports = router;