@befly-addon/admin 1.1.29 → 1.1.31

package/apis/menu/all.ts

@@ -1,4 +1,4 @@
-/**
+/**
  * 获取当前用户的菜单权限
  * 说明：
  * 1. 从 Redis 缓存读取所有菜单（如果缓存不存在则从数据库查询并缓存）
@@ -8,27 +8,25 @@
  */
 
 export default {
-    name: '获取用户菜单',
+    name: "获取用户菜单",
     handler: async (befly, ctx) => {
         try {
             // 2. 查询角色信息获取菜单权限（使用 roleCode 而非 roleId）
             const role = await befly.db.getOne({
-                table: 'addon_admin_role',
+                table: "addon_admin_role",
                 where: { code: ctx.user.roleCode }
             });
 
-            if (!role) {
-                return befly.tool.No('角色不存在', { lists: [] });
+            if (!role?.id) {
+                return befly.tool.No("角色不存在", { lists: [] });
             }
 
-            // 3. 解析菜单ID列表（逗号分隔的字符串）
-            const menuIds = role.menus
-                .split(',')
-                .map((id: string) => parseInt(id.trim()))
-                .filter((id: number) => !isNaN(id));
+            // 3. 解析菜单ID列表（数组，数据库字段已改为 array 存储）
+            const rawMenuIds = Array.isArray(role.menus) ? role.menus : [];
+            const menuIds = rawMenuIds.map((id: any) => Number(id)).filter((id: number) => Number.isFinite(id));
 
             if (menuIds.length === 0) {
-                return befly.tool.Yes('菜单为空', { lists: [] });
+                return befly.tool.Yes("菜单为空", { lists: [] });
             }
 
             // 4. 从缓存获取所有菜单
@@ -37,26 +35,25 @@ export default {
             // 如果缓存不存在，从数据库查询
             if (allMenus.length === 0) {
                 const result = await befly.db.getAll({
-                    table: 'addon_admin_menu',
-                    fields: ['id', 'pid', 'name', 'path', 'sort'],
-                    orderBy: ['sort#ASC', 'id#ASC']
+                    table: "addon_admin_menu",
+                    orderBy: ["sort#ASC", "id#ASC"]
                 });
                 allMenus = result.lists;
             }
 
             if (allMenus.length === 0) {
-                return befly.tool.Yes('菜单为空', { lists: [] });
+                return befly.tool.Yes("菜单为空", { lists: [] });
             }
 
             // 5. 根据角色权限过滤菜单
-            const menuIdSet = new Set(menuIds.map(String)); // 转为字符串 Set 方便比较
-            const authorizedMenus = allMenus.filter((menu: any) => menuIdSet.has(String(menu.id)));
+            const menuIdSet = new Set<number>(menuIds);
+            const authorizedMenus = allMenus.filter((menu: any) => menuIdSet.has(Number(menu.id)));
 
             // 6. 返回一维数组（由前端构建树形结构）
-            return befly.tool.Yes('获取菜单成功', { lists: authorizedMenus });
+            return befly.tool.Yes("获取菜单成功", { lists: authorizedMenus });
         } catch (error: any) {
-            befly.logger.error({ err: error }, '获取用户菜单失败');
-            return befly.tool.No('获取菜单失败');
+            befly.logger.error({ err: error }, "获取用户菜单失败");
+            return befly.tool.No("获取菜单失败");
         }
     }
 };

package/apis/menu/list.ts

@@ -1,23 +1,22 @@
-export default {
-    name: '获取菜单列表',
+export default {
+    name: "获取菜单列表",
     fields: {
-        page: '@page',
-        limit: '@limit',
-        keyword: '@keyword',
-        state: '@state'
+        page: "@page",
+        limit: "@limit",
+        keyword: "@keyword",
+        state: "@state"
     },
-    handler: async (befly, ctx) => {
+    handler: async (befly) => {
         try {
             const menus = await befly.db.getAll({
-                table: 'addon_admin_menu',
-                fields: ['*'],
-                orderBy: ['sort#ASC', 'id#ASC']
+                table: "addon_admin_menu",
+                orderBy: ["sort#ASC", "id#ASC"]
             });
 
-            return befly.tool.Yes('操作成功', { lists: menus.lists });
+            return befly.tool.Yes("操作成功", { lists: menus.lists });
         } catch (error) {
-            befly.logger.error({ err: error }, '获取菜单列表失败');
-            return befly.tool.No('操作失败');
+            befly.logger.error({ err: error }, "获取菜单列表失败");
+            return befly.tool.No("操作失败");
         }
     }
 };

package/apis/operateLog/list.ts

@@ -1,19 +1,19 @@
 export default {
-    name: '获取操作日志列表',
+    name: "获取操作日志列表",
     fields: {
-        page: '@page',
-        limit: '@limit',
-        keyword: '@keyword',
-        state: '@state'
+        page: "@page",
+        limit: "@limit",
+        keyword: "@keyword",
+        state: "@state"
     },
     handler: async (befly, ctx) => {
         const result = await befly.db.getList({
-            table: 'addon_admin_operate_log',
-            page: ctx.body.page || 1,
-            limit: ctx.body.limit || 30,
-            orderBy: ['operateTime#DESC']
+            table: "addon_admin_operate_log",
+            page: ctx.body.page,
+            limit: ctx.body.limit,
+            orderBy: ["operateTime#DESC"]
         });
 
-        return befly.tool.Yes('获取成功', result);
+        return befly.tool.Yes("获取成功", result);
     }
 };

package/apis/role/all.ts

@@ -1,16 +1,16 @@
-export default {
-    name: '获取所有角色',
-    handler: async (befly, ctx) => {
+export default {
+    name: "获取所有角色",
+    handler: async (befly) => {
         const roles = await befly.db.getAll({
-            table: 'addon_admin_role',
+            table: "addon_admin_role",
             where: {
                 code: {
-                    $ne: 'dev'
+                    $ne: "dev"
                 }
             },
-            orderBy: ['sort#ASC', 'id#ASC']
+            orderBy: ["sort#ASC", "id#ASC"]
         });
 
-        return befly.tool.Yes('操作成功', { lists: roles.lists, total: roles.total });
+        return befly.tool.Yes("操作成功", { lists: roles.lists, total: roles.total });
     }
 };

package/apis/role/apiSave.ts

@@ -1,36 +1,34 @@
-import adminRoleTable from '../../tables/role.json';
+import adminRoleTable from "../../tables/role.json";
 
 export default {
-    name: '保存角色接口权限',
+    name: "保存角色接口权限",
     fields: {
+        roleCode: adminRoleTable.code,
         apiIds: adminRoleTable.apis
     },
     handler: async (befly, ctx) => {
         // 查询角色是否存在
         const role = await befly.db.getOne({
-            table: 'addon_admin_role',
-            where: { id: ctx.body.roleId }
+            table: "addon_admin_role",
+            where: { code: ctx.body.roleCode }
         });
 
-        if (!role) {
-            return befly.tool.No('角色不存在');
+        if (!role?.id) {
+            return befly.tool.No("角色不存在");
         }
 
-        // 将数组转为逗号分隔的字符串存储
-        const apiIdsStr = Array.isArray(ctx.body.apiIds) ? ctx.body.apiIds.join(',') : '';
-
-        // 更新角色的接口权限
+        // 直接使用数组，数据库会自动处理存储
         await befly.db.updData({
-            table: 'addon_admin_role',
-            where: { id: ctx.body.roleId },
+            table: "addon_admin_role",
+            where: { code: ctx.body.roleCode },
             data: {
-                apis: apiIdsStr
+                apis: ctx.body.apiIds
             }
         });
 
-        // 增量更新 Redis 缓存
-        await befly.cache.cacheRolePermissions(befly, role.code, apiIdsStr);
+        // 增量刷新 Redis 权限缓存
+        await befly.cache.refreshRoleApiPermissions(role.code, ctx.body.apiIds || []);
 
-        return befly.tool.Yes('操作成功');
+        return befly.tool.Yes("操作成功");
     }
 };

package/apis/role/apis.ts

@@ -0,0 +1,24 @@
+import adminRoleTable from "../../tables/role.json";
+
+export default {
+    name: "获取角色接口权限",
+    fields: {
+        roleCode: adminRoleTable.code
+    },
+    handler: async (befly, ctx) => {
+        // 查询角色信息
+        const role = await befly.db.getOne({
+            table: "addon_admin_role",
+            where: { code: ctx.body.roleCode }
+        });
+
+        if (!role?.id) {
+            return befly.tool.No("角色不存在");
+        }
+
+        // 数据库自动将 array_number_string 转换为数组
+        const apiIds = role.apis || [];
+
+        return befly.tool.Yes("操作成功", { apiIds });
+    }
+};

package/apis/role/del.ts

@@ -1,41 +1,49 @@
-export default {
-    name: '删除角色',
+export default {
+    name: "删除角色",
     fields: {
-        id: '@id'
+        id: "@id"
     },
     handler: async (befly, ctx) => {
         try {
             // 检查是否有用户使用此角色（使用 getList 代替 getAll）
-            const adminList = await befly.db.getList({
-                table: 'addon_admin_admin',
-                where: { roleId: ctx.body.id }
+            const role = await befly.db.getOne({
+                table: "addon_admin_role",
+                where: { id: ctx.body.id },
+                fields: ["code"]
             });
 
-            if (adminList.total > 0) {
-                return befly.tool.No('该角色已分配给用户，无法删除');
+            if (!role?.code) {
+                return befly.tool.No("角色不存在");
             }
 
-            // 获取角色信息（用于删除缓存）
-            const role = await befly.db.getDetail({
-                table: 'addon_admin_role',
-                where: { id: ctx.body.id }
+            // 禁止删除系统角色
+            const systemRoles = ["dev", "user", "admin", "guest"];
+            if (systemRoles.includes(role.code)) {
+                return befly.tool.No(`系统角色 [${role.code}] 不允许删除`);
+            }
+
+            const adminList = await befly.db.getList({
+                table: "addon_admin_admin",
+                where: { roleCode: role.code }
             });
 
+            if (adminList.total > 0) {
+                return befly.tool.No("该角色已分配给用户，无法删除");
+            }
+
             // 删除角色
             await befly.db.delData({
-                table: 'addon_admin_role',
+                table: "addon_admin_role",
                 where: { id: ctx.body.id }
             });
 
             // 删除角色权限缓存
-            if (role?.code) {
-                await befly.cache.deleteRolePermissions(befly, role.code);
-            }
+            await befly.cache.deleteRolePermissions(role.code);
 
-            return befly.tool.Yes('操作成功');
+            return befly.tool.Yes("操作成功");
         } catch (error: any) {
-            befly.logger.error({ err: error }, '删除角色失败');
-            return befly.tool.No('操作失败');
+            befly.logger.error({ err: error }, "删除角色失败");
+            return befly.tool.No("操作失败");
         }
     }
 };

package/apis/role/detail.ts

@@ -1,19 +1,18 @@
-export default {
-    name: '获取用户角色',
+export default {
+    name: "获取用户角色",
     fields: {
-        id: '@id'
+        id: "@id"
     },
     handler: async (befly, ctx) => {
         let roleInfo = null;
-        if (ctx.body.id && ctx.user.roleType === 'admin') {
+        if (ctx.body.id && ctx.user.roleType === "admin") {
             roleInfo = await befly.db.getOne({
-                table: 'addon_admin_role',
+                table: "addon_admin_role",
                 where: { code: ctx.body.id }
             });
         }
 
-        return befly.tool.Yes('操作成功', {
-            roleId: ctx.body.id,
+        return befly.tool.Yes("操作成功", {
             roleCode: ctx.body.id,
             role: roleInfo
         });

package/apis/role/ins.ts

@@ -1,35 +1,35 @@
-import adminRoleTable from '../../tables/role.json';
+import adminRoleTable from "../../tables/role.json";
 
 export default {
-    name: '创建角色',
+    name: "创建角色",
     fields: adminRoleTable,
     handler: async (befly, ctx) => {
         // 检查角色代码是否已存在
         const existing = await befly.db.getOne({
-            table: 'addon_admin_role',
+            table: "addon_admin_role",
             where: { code: ctx.body.code }
         });
 
         if (existing) {
-            return befly.tool.No('角色代码已存在');
+            return befly.tool.No("角色代码已存在");
         }
 
         const roleId = await befly.db.insData({
-            table: 'addon_admin_role',
+            table: "addon_admin_role",
             data: {
                 name: ctx.body.name,
                 code: ctx.body.code,
                 description: ctx.body.description,
-                menus: ctx.body.menus || '',
-                apis: ctx.body.apis || '',
+                menus: ctx.body.menus || [],
+                apis: ctx.body.apis || [],
                 sort: ctx.body.sort
                 // state 由框架自动设置为 1
             }
         });
 
-        // 增量缓存角色权限到 Redis Set
-        await befly.cache.cacheRolePermissions(befly, ctx.body.code, ctx.body.apis || '');
+        // 增量刷新角色权限缓存
+        await befly.cache.refreshRoleApiPermissions(ctx.body.code, ctx.body.apis || []);
 
-        return befly.tool.Yes('操作成功', { id: roleId });
+        return befly.tool.Yes("操作成功", { id: roleId });
     }
 };

package/apis/role/list.ts

@@ -1,23 +1,23 @@
-export default {
-    name: '获取角色列表',
+export default {
+    name: "获取角色列表",
     fields: {
-        page: '@page',
-        limit: '@limit',
-        keyword: '@keyword',
-        state: '@state'
+        page: "@page",
+        limit: "@limit",
+        keyword: "@keyword",
+        state: "@state"
     },
-    handler: async (befly, ctx) => {
+    handler: async (befly) => {
         const roles = await befly.db.getList({
             limit: 30,
-            table: 'addon_admin_role',
+            table: "addon_admin_role",
             where: {
                 code: {
-                    $ne: 'dev'
+                    $ne: "dev"
                 }
             },
-            orderBy: ['sort#ASC', 'id#ASC']
+            orderBy: ["sort#ASC", "id#ASC"]
         });
 
-        return befly.tool.Yes('操作成功', roles);
+        return befly.tool.Yes("操作成功", roles);
     }
 };

package/apis/role/menuSave.ts

@@ -1,33 +1,31 @@
-import adminRoleTable from '../../tables/role.json';
+import adminRoleTable from "../../tables/role.json";
 
 export default {
-    name: '保存角色菜单权限',
+    name: "保存角色菜单权限",
     fields: {
+        roleCode: adminRoleTable.code,
         menuIds: adminRoleTable.menus
     },
     handler: async (befly, ctx) => {
         // 查询角色是否存在
         const role = await befly.db.getOne({
-            table: 'addon_admin_role',
-            where: { id: ctx.body.roleId }
+            table: "addon_admin_role",
+            where: { code: ctx.body.roleCode }
         });
 
-        if (!role) {
-            return befly.tool.No('角色不存在');
+        if (!role?.id) {
+            return befly.tool.No("角色不存在");
         }
 
-        // 将数组转为逗号分隔的字符串存储
-        const menuIdsStr = Array.isArray(ctx.body.menuIds) ? ctx.body.menuIds.join(',') : '';
-
-        // 更新角色的菜单权限
+        // 直接使用数组，数据库会自动处理存储
         await befly.db.updData({
-            table: 'addon_admin_role',
-            where: { id: ctx.body.roleId },
+            table: "addon_admin_role",
+            where: { code: ctx.body.roleCode },
             data: {
-                menus: menuIdsStr
+                menus: ctx.body.menuIds
             }
         });
 
-        return befly.tool.Yes('操作成功');
+        return befly.tool.Yes("操作成功");
     }
 };

package/apis/role/menus.ts

@@ -0,0 +1,24 @@
+import adminRoleTable from "../../tables/role.json";
+
+export default {
+    name: "获取角色菜单权限",
+    fields: {
+        roleCode: adminRoleTable.code
+    },
+    handler: async (befly, ctx) => {
+        // 查询角色信息
+        const role = await befly.db.getOne({
+            table: "addon_admin_role",
+            where: { code: ctx.body.roleCode }
+        });
+
+        if (!role?.id) {
+            return befly.tool.No("角色不存在");
+        }
+
+        // 数据库自动将 array_number_string 转换为数组
+        const menuIds = role.menus || [];
+
+        return befly.tool.Yes("操作成功", menuIds);
+    }
+};

package/apis/role/save.ts

@@ -1,44 +1,43 @@
-export default {
-    name: '角色保存',
+export default {
+    name: "角色保存",
     fields: {
         roleCode: {
-            name: '角色编码',
-            type: 'string',
+            name: "角色编码",
+            type: "string",
             min: 2,
             max: 50,
-            regexp: '^[a-zA-Z0-9_]+$'
+            regexp: "^[a-zA-Z0-9_]+$"
         }
     },
     handler: async (befly, ctx) => {
         try {
             // 查询角色是否存在（使用 roleCode 而非 roleId）
             const role = await befly.db.getOne({
-                table: 'addon_admin_role',
+                table: "addon_admin_role",
                 where: { code: ctx.body.roleCode }
             });
 
-            if (!role) {
-                return befly.tool.No('角色不存在');
+            if (!role?.id) {
+                return befly.tool.No("角色不存在");
             }
 
             // 根据角色编码判断角色类型（硬编码规则）
-            const roleType = role.code === 'dev' || role.code === 'admin' ? 'admin' : 'user';
+            const roleType = role.code === "dev" || role.code === "admin" ? "admin" : "user";
 
-            // 更新管理员的角色ID、角色编码和角色类型
+            // 更新管理员的角色编码和角色类型
             await befly.db.updData({
-                table: 'addon_admin_admin',
+                table: "addon_admin_admin",
                 where: { id: ctx.body.adminId },
                 data: {
-                    roleId: role.id,
                     roleCode: role.code,
                     roleType: roleType
                 }
             });
 
-            return befly.tool.Yes('操作成功');
+            return befly.tool.Yes("操作成功");
         } catch (error: any) {
-            befly.logger.error({ err: error }, '保存用户角色失败');
-            return befly.tool.No('操作失败');
+            befly.logger.error({ err: error }, "保存用户角色失败");
+            return befly.tool.No("操作失败");
         }
     }
 };

package/apis/role/upd.ts

@@ -1,12 +1,12 @@
-import adminRoleTable from '../../tables/role.json';
+import adminRoleTable from "../../tables/role.json";
 
 export default {
-    name: '更新角色',
+    name: "更新角色",
     fields: adminRoleTable,
     handler: async (befly, ctx) => {
         // 检查角色代码是否被其他角色占用
         const existing = await befly.db.getList({
-            table: 'addon_admin_role',
+            table: "addon_admin_role",
             where: {
                 code: ctx.body.code,
                 id$ne: ctx.body.id
@@ -14,26 +14,26 @@ export default {
         });
 
         if (existing.total > 0) {
-            return befly.tool.No('角色代码已被其他角色使用');
+            return befly.tool.No("角色代码已被其他角色使用");
         }
 
         await befly.db.updData({
-            table: 'addon_admin_role',
+            table: "addon_admin_role",
             where: { id: ctx.body.id },
             data: {
                 name: ctx.body.name,
                 code: ctx.body.code,
                 description: ctx.body.description,
-                menus: ctx.body.menus || '',
-                apis: ctx.body.apis || '',
+                menus: ctx.body.menus || [],
+                apis: ctx.body.apis || [],
                 sort: ctx.body.sort
                 // state 字段不在此处更新，需要禁用/启用时单独处理
             }
         });
 
-        // 增量更新角色权限缓存（先删除再重建）
-        await befly.cache.cacheRolePermissions(befly, ctx.body.code, ctx.body.apis || '');
+        // 增量刷新角色权限缓存
+        await befly.cache.refreshRoleApiPermissions(ctx.body.code, ctx.body.apis || []);
 
-        return befly.tool.Yes('操作成功');
+        return befly.tool.Yes("操作成功");
     }
 };

package/apis/sysConfig/all.ts

@@ -1,12 +1,11 @@
 export default {
-    name: '获取所有系统配置',
-    handler: async (befly, ctx) => {
+    name: "获取所有系统配置",
+    handler: async (befly) => {
         const result = await befly.db.getAll({
-            table: 'addon_admin_sys_config',
-            fields: ['*'],
-            orderBy: ['id#ASC']
+            table: "addon_admin_sys_config",
+            orderBy: ["id#ASC"]
         });
 
-        return befly.tool.Yes('操作成功', { lists: result.lists });
+        return befly.tool.Yes("操作成功", { lists: result.lists });
     }
 };