@befly-addon/admin 1.0.2 → 1.0.4

package/apis/dashboard/environmentInfo.ts

@@ -0,0 +1,46 @@
+/**
+ * 获取运行环境信息
+ */
+
+import { Yes } from 'befly';
+import os from 'node:os';
+
+export default {
+    name: '获取运行环境信息',
+    handler: async (befly, ctx) => {
+        // 获取数据库版本
+        let databaseVersion = 'Unknown';
+        try {
+            const versionResult = await befly.db.query({
+                sql: 'SELECT VERSION() as version',
+                type: 'one'
+            });
+            databaseVersion = versionResult.version || 'Unknown';
+        } catch (error) {
+            // 忽略错误
+        }
+
+        // 获取 Redis 版本
+        let redisVersion = '未配置';
+        if (befly.redis) {
+            try {
+                const info = await befly.redis.info('server');
+                const match = info.match(/redis_version:([^\r\n]+)/);
+                if (match) {
+                    redisVersion = match[1];
+                }
+            } catch (error) {
+                redisVersion = '未知';
+            }
+        }
+
+        return Yes('获取成功', {
+            os: `${os.type()} ${os.arch()}`,
+            server: `${os.platform()} ${os.release()}`,
+            nodeVersion: process.version,
+            database: `MySQL ${databaseVersion}`,
+            cache: `Redis ${redisVersion}`,
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+        });
+    }
+};

package/apis/dashboard/performanceMetrics.ts

@@ -0,0 +1,23 @@
+/**
+ * 获取性能指标
+ */
+
+import { Yes } from 'befly';
+
+export default {
+    name: '获取性能指标',
+    handler: async (befly, ctx) => {
+        // 实际项目中，这些数据应该从监控系统或日志中获取
+        // 这里提供示例数据结构
+        return Yes('获取成功', {
+            avgResponseTime: 125,
+            qps: 856,
+            errorRate: 0.8,
+            activeConnections: 45,
+            slowestApi: {
+                path: '/addon/admin/menuList',
+                time: 450
+            }
+        });
+    }
+};

package/apis/dashboard/permissionStats.ts

@@ -0,0 +1,31 @@
+/**
+ * 获取权限统计信息
+ */
+
+import { Yes } from 'befly';
+
+export default {
+    name: '获取权限统计',
+    handler: async (befly, ctx) => {
+        // 统计菜单数量
+        const menuCount = await befly.db.count({
+            table: 'core_menu'
+        });
+
+        // 统计接口数量
+        const apiCount = await befly.db.count({
+            table: 'core_api'
+        });
+
+        // 统计角色数量
+        const roleCount = await befly.db.count({
+            table: 'core_role'
+        });
+
+        return Yes('获取成功', {
+            menuCount: menuCount,
+            apiCount: apiCount,
+            roleCount: roleCount
+        });
+    }
+};

package/apis/dashboard/serviceStatus.ts

@@ -0,0 +1,81 @@
+/**
+ * 获取服务状态
+ */
+
+import { Yes, Env } from 'befly';
+
+export default {
+    name: '获取服务状态',
+    handler: async (befly, ctx) => {
+        const services = [];
+
+        // 数据库状态
+        try {
+            const startTime = Date.now();
+            await befly.db.query('SELECT 1');
+            const responseTime = Date.now() - startTime;
+            services.push({
+                name: '数据库',
+                status: 'running',
+                responseTime: `${responseTime}ms`
+            });
+        } catch (error) {
+            befly.logger.error('数据库状态检测失败:', error);
+            services.push({
+                name: '数据库',
+                status: 'stopped',
+                responseTime: '-'
+            });
+        }
+
+        // Redis 状态
+        if (Env.REDIS_ENABLE === 1 && befly.redis) {
+            try {
+                const startTime = Date.now();
+                await befly.redis.ping();
+                const responseTime = Date.now() - startTime;
+                services.push({
+                    name: 'Redis',
+                    status: 'running',
+                    responseTime: `${responseTime}ms`
+                });
+            } catch (error) {
+                befly.logger.error('Redis状态检测失败:', error);
+                services.push({
+                    name: 'Redis',
+                    status: 'stopped',
+                    responseTime: '-'
+                });
+            }
+        } else {
+            services.push({
+                name: 'Redis',
+                status: 'stopped',
+                responseTime: '-'
+            });
+        }
+
+        // 文件系统状态
+        services.push({
+            name: '文件系统',
+            status: 'running',
+            responseTime: '-'
+        });
+
+        // 邮件服务状态（示例）
+        services.push({
+            name: '邮件服务',
+            status: 'unconfigured',
+            responseTime: '-'
+        });
+
+        // OSS存储状态（示例）
+        services.push({
+            name: 'OSS存储',
+            status: 'unconfigured',
+            responseTime: '-'
+        });
+
+        return Yes('获取成功', { services });
+    }
+};

package/apis/dashboard/systemInfo.ts

@@ -0,0 +1,25 @@
+/**
+ * 获取系统信息
+ */
+
+import { Yes, Env } from 'befly';
+
+export default {
+    name: '获取系统信息',
+    handler: async (befly, ctx) => {
+        // 系统启动时间（从进程启动时间计算）
+        const startTime = Date.now() - Math.floor(process.uptime() * 1000);
+
+        // 运行时长（毫秒）
+        const uptime = Math.floor(process.uptime() * 1000);
+
+        // 环境
+        const environment = Env.NODE_ENV || 'development';
+
+        return Yes('获取成功', {
+            environment: environment,
+            startTime: startTime,
+            uptime: uptime
+        });
+    }
+};

package/apis/dashboard/systemOverview.ts

@@ -0,0 +1,32 @@
+/**
+ * 获取系统概览数据
+ */
+
+import { Yes } from 'befly';
+
+export default {
+    name: '获取系统概览数据',
+    handler: async (befly, ctx) => {
+        // 权限统计
+        const menuCount = await befly.db.getCount({
+            table: 'core_menu',
+            where: { state: 1 }
+        });
+
+        const roleCount = await befly.db.getCount({
+            table: 'core_role',
+            where: { state: 1 }
+        });
+
+        const apiCount = await befly.db.getCount({
+            table: 'core_api',
+            where: { state: 1 }
+        });
+
+        return Yes('获取成功', {
+            menuCount,
+            roleCount,
+            apiCount
+        });
+    }
+};

package/apis/dashboard/systemResources.ts

@@ -0,0 +1,119 @@
+/**
+ * 获取系统资源使用情况
+ */
+
+import os from 'node:os';
+import fs from 'node:fs';
+import { Yes } from 'befly';
+import { promisify } from 'node:util';
+
+export default {
+    name: '获取系统资源',
+    auth: true,
+    fields: {},
+    handler: async (befly, ctx) => {
+        // CPU 使用率
+        const cpus = os.cpus();
+        const cpuCount = cpus.length; // 逻辑核心数（包括超线程）
+
+        // 计算 CPU 使用率（需要两次采样）
+        // 第一次采样
+        const startMeasure = cpus.map((cpu) => {
+            let total = 0;
+            for (const type in cpu.times) {
+                total += cpu.times[type];
+            }
+            return {
+                idle: cpu.times.idle,
+                total
+            };
+        });
+
+        // 等待 100ms
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        // 第二次采样
+        const endCpus = os.cpus();
+        const endMeasure = endCpus.map((cpu) => {
+            let total = 0;
+            for (const type in cpu.times) {
+                total += cpu.times[type];
+            }
+            return {
+                idle: cpu.times.idle,
+                total
+            };
+        });
+
+        // 计算平均 CPU 使用率
+        let totalIdle = 0;
+        let totalTick = 0;
+        for (let i = 0; i < startMeasure.length; i++) {
+            const idleDiff = endMeasure[i].idle - startMeasure[i].idle;
+            const totalDiff = endMeasure[i].total - startMeasure[i].total;
+            totalIdle += idleDiff;
+            totalTick += totalDiff;
+        }
+
+        const cpuUsage = totalTick > 0 ? Math.round(((totalTick - totalIdle) / totalTick) * 100) : 0;
+
+        // 内存使用率
+        const totalMem = os.totalmem();
+        const freeMem = os.freemem();
+        const usedMem = totalMem - freeMem;
+        const memoryPercentage = totalMem > 0 ? Math.round((usedMem / totalMem) * 100) : 0;
+
+        // 磁盘使用率（使用 fs.statfs 获取当前工作目录所在磁盘）
+        let diskPercentage = 0;
+        let diskUsed = 0;
+        let diskTotal = 0;
+
+        try {
+            // 检查是否有 statfs 方法（Node.js 19+ 或 Bun）
+            if (fs.statfs) {
+                const statfsAsync = promisify(fs.statfs);
+                const stats = await statfsAsync(process.cwd());
+
+                // 计算磁盘使用情况
+                // bsize: 文件系统块大小
+                // blocks: 总块数
+                // bfree: 可用块数
+                const totalSpace = stats.blocks * stats.bsize;
+                const freeSpace = stats.bfree * stats.bsize;
+                const usedSpace = totalSpace - freeSpace;
+
+                if (totalSpace > 0) {
+                    diskTotal = Math.round(totalSpace / 1024 / 1024 / 1024);
+                    diskUsed = Math.round(usedSpace / 1024 / 1024 / 1024);
+                    diskPercentage = Math.round((usedSpace / totalSpace) * 100);
+                }
+            } else {
+                // statfs 不可用，返回默认值
+                befly.logger.warn('fs.statfs 不可用，无法获取磁盘信息');
+            }
+        } catch (error) {
+            befly.logger.warn('获取磁盘信息失败', error);
+            // 获取失败时返回 0
+            diskPercentage = 0;
+            diskUsed = 0;
+            diskTotal = 0;
+        }
+
+        return Yes('获取成功', {
+            cpu: {
+                usage: cpuUsage,
+                cores: cpuCount
+            },
+            memory: {
+                used: (usedMem / 1024 / 1024 / 1024).toFixed(1),
+                total: (totalMem / 1024 / 1024 / 1024).toFixed(1),
+                percentage: memoryPercentage
+            },
+            disk: {
+                used: diskUsed,
+                total: diskTotal,
+                percentage: diskPercentage
+            }
+        });
+    }
+};

package/apis/dict/all.ts

@@ -0,0 +1,25 @@
+import { Yes, No } from 'befly';
+
+/**
+ * 获取所有字典（不分页）
+ */
+export default {
+    name: '获取所有字典',
+    handler: async (befly, ctx) => {
+        try {
+            const dicts = await befly.db.getAll({
+                table: 'core_dict',
+                fields: ['id', 'name', 'code', 'value', 'sort', 'pid', 'description', 'state', 'created_at', 'updated_at'],
+                orderBy: [
+                    { field: 'sort', direction: 'ASC' },
+                    { field: 'id', direction: 'ASC' }
+                ]
+            });
+
+            return Yes('操作成功', dicts);
+        } catch (error) {
+            befly.logger.error('获取所有字典失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/dict/del.ts

@@ -0,0 +1,19 @@
+import { Field, Yes, No } from 'befly';
+export default {
+    name: '删除字典',
+    handler: async (befly, ctx) => {
+        try {
+            await befly.db.delData({
+                table: 'core_dict',
+                where: {
+                    id: ctx.body.id
+                }
+            });
+
+            return Yes('操作成功');
+        } catch (error) {
+            befly.logger.error('删除字典失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/dict/detail.ts

@@ -0,0 +1,21 @@
+import { Yes, No } from 'befly';
+
+export default {
+    name: '获取字典详情',
+    handler: async (befly, ctx) => {
+        try {
+            const dict = await befly.db.getDetail({
+                table: 'core_dict',
+                fields: ['id', 'name', 'code', 'value', 'sort', 'pid', 'description', 'state', 'created_at', 'updated_at'],
+                where: {
+                    id: ctx.body.id
+                }
+            });
+
+            return Yes('操作成功', dict);
+        } catch (error) {
+            befly.logger.error('获取字典详情失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/dict/ins.ts

@@ -0,0 +1,27 @@
+import { Yes, No } from 'befly';
+import adminDictTable from '../../tables/dict.json';
+
+export default {
+    name: '添加字典',
+    fields: adminDictTable,
+    handler: async (befly, ctx) => {
+        try {
+            const dictId = await befly.db.insData({
+                table: 'core_dict',
+                data: {
+                    name: ctx.body.name,
+                    code: ctx.body.code,
+                    value: ctx.body.value,
+                    sort: ctx.body.sort,
+                    pid: ctx.body.pid,
+                    description: ctx.body.description
+                }
+            });
+
+            return Yes('操作成功', { id: dictId });
+        } catch (error) {
+            befly.logger.error('添加字典失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/dict/list.ts

@@ -0,0 +1,18 @@
+import { Yes, No } from 'befly';
+export default {
+    name: '获取字典列表',
+    handler: async (befly, ctx) => {
+        const result = await befly.db.getList({
+            table: 'core_dict',
+            fields: ['id', 'name', 'code', 'value', 'sort', 'pid', 'description', 'state', 'created_at', 'updated_at'],
+            page: ctx.body.page,
+            limit: ctx.body.limit,
+            orderBy: [
+                { field: 'sort', direction: 'ASC' },
+                { field: 'id', direction: 'ASC' }
+            ]
+        });
+
+        return Yes('操作成功', result);
+    }
+};

package/apis/dict/upd.ts

@@ -0,0 +1,31 @@
+import { Yes, No } from 'befly';
+import adminDictTable from '../../tables/dict.json';
+
+export default {
+    name: '更新字典',
+    fields: adminDictTable,
+    handler: async (befly, ctx) => {
+        try {
+            await befly.db.updData({
+                table: 'core_dict',
+                data: {
+                    name: ctx.body.name,
+                    code: ctx.body.code,
+                    value: ctx.body.value,
+                    sort: ctx.body.sort,
+                    pid: ctx.body.pid,
+                    description: ctx.body.description,
+                    state: ctx.body.state
+                },
+                where: {
+                    id: ctx.body.id
+                }
+            });
+
+            return Yes('操作成功');
+        } catch (error) {
+            befly.logger.error('更新字典失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/menu/all.ts

@@ -0,0 +1,68 @@
+/**
+ * 获取当前用户的菜单权限
+ * 说明：
+ * 1. 从 Redis 缓存读取所有菜单（如果缓存不存在则从数据库查询并缓存）
+ * 2. 根据当前登录用户的角色过滤可访问的菜单
+ * 3. 返回一维数组（由前端构建树形结构）
+ * 4. 仅返回状态为启用的菜单
+ */
+
+import { Yes, No } from 'befly';
+
+export default {
+    name: '获取用户菜单',
+    handler: async (befly, ctx) => {
+        try {
+            // 2. 查询角色信息获取菜单权限（使用 roleCode 而非 roleId）
+            const role = await befly.db.getOne({
+                table: 'core_role',
+                where: { code: ctx.user.roleCode }
+            });
+
+            if (!role) {
+                return No('角色不存在', []);
+            }
+
+            // 3. 解析菜单ID列表（逗号分隔的字符串）
+            const menuIds = role.menus
+                .split(',')
+                .map((id: string) => parseInt(id.trim()))
+                .filter((id: number) => !isNaN(id));
+
+            if (menuIds.length === 0) {
+                return Yes('菜单为空', []);
+            }
+
+            // 4. 从 Redis 缓存读取所有菜单
+            let allMenus = await befly.redis.getObject<any[]>('menus:all');
+
+            // 如果缓存不存在，从数据库查询并缓存
+            if (!allMenus || allMenus.length === 0) {
+                befly.logger.info('菜单缓存未命中，从数据库查询');
+                allMenus = await befly.db.getAll({
+                    table: 'core_menu',
+                    fields: ['id', 'pid', 'name', 'path', 'icon', 'type', 'sort'],
+                    orderBy: ['sort#ASC', 'id#ASC']
+                });
+
+                // 回写缓存
+                if (allMenus.length > 0) {
+                    await befly.redis.setObject('menus:all', allMenus);
+                    befly.logger.info(`已缓存 ${allMenus.length} 个菜单到 Redis`);
+                }
+            } else {
+                befly.logger.debug(`从 Redis 缓存读取 ${allMenus.length} 个菜单`);
+            }
+
+            // 5. 根据角色权限过滤菜单
+            const menuIdSet = new Set(menuIds.map(String)); // 转为字符串 Set 方便比较
+            const authorizedMenus = allMenus.filter((menu: any) => menuIdSet.has(String(menu.id)));
+
+            // 6. 返回一维数组（由前端构建树形结构）
+            return Yes('获取菜单成功', authorizedMenus);
+        } catch (error) {
+            befly.logger.error('获取用户菜单失败:', error);
+            return No('获取菜单失败');
+        }
+    }
+};

package/apis/menu/del.ts

@@ -0,0 +1,37 @@
+/**
+ * 删除菜单
+ */
+
+import { Yes, No } from 'befly';
+
+export default {
+    name: '删除菜单',
+    handler: async (befly, ctx) => {
+        try {
+            // 检查是否有子菜单（使用 getList 代替 getAll）
+            const childrenList = await befly.db.getList({
+                table: 'core_menu',
+                where: { pid: ctx.body.id }
+            });
+
+            if (childrenList.total > 0) {
+                return No('该菜单下有子菜单，无法删除');
+            }
+
+            // 删除菜单
+            await befly.db.delData({
+                table: 'core_menu',
+                where: { id: ctx.body.id }
+            });
+
+            // 注意：菜单权限现在存储在 role.menus 字段中
+            // 如果需要从角色权限中移除此菜单，需要额外处理
+            // 这里暂时不处理，由管理员在角色管理界面手动调整
+
+            return Yes('操作成功');
+        } catch (error) {
+            befly.logger.error('删除菜单失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/menu/ins.ts

@@ -0,0 +1,20 @@
+import { Yes, No } from 'befly';
+import adminMenuTable from '../../tables/menu.json';
+
+export default {
+    name: '创建菜单',
+    fields: adminMenuTable,
+    handler: async (befly, ctx) => {
+        try {
+            const menuId = await befly.db.insData({
+                table: 'core_menu',
+                data: ctx.body
+            });
+
+            return Yes('操作成功', { id: menuId });
+        } catch (error) {
+            befly.logger.error('创建菜单失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/menu/list.ts

@@ -0,0 +1,21 @@
+import { Yes, No } from 'befly';
+export default {
+    name: '获取菜单列表',
+    handler: async (befly, ctx) => {
+        try {
+            const menus = await befly.db.getAll({
+                table: 'core_menu',
+                fields: ['id', 'name', 'path', 'icon', 'sort', 'pid', 'type', 'state', 'created_at', 'updated_at'],
+                orderBy: [
+                    { field: 'sort', direction: 'ASC' },
+                    { field: 'id', direction: 'ASC' }
+                ]
+            });
+
+            return Yes('操作成功', menus);
+        } catch (error) {
+            befly.logger.error('获取菜单列表失败:', error);
+            return No('操作失败');
+        }
+    }
+};