@befly-addon/admin 1.1.29 → 1.1.31

package/apis/auth/login.ts

@@ -1,100 +1,103 @@
-import { UAParser } from 'ua-parser-js';
+import { UAParser } from "ua-parser-js";
 
-import adminTable from '../../tables/admin.json';
+import adminTable from "../../tables/admin.json";
 
 export default {
-    name: '管理员登录',
+    name: "管理员登录",
     auth: false,
     fields: {
         account: {
-            name: '账号',
-            type: 'string',
+            name: "账号",
+            type: "string",
             min: 3,
             max: 100
         },
-        password: adminTable.password
+        password: adminTable.password,
+        loginType: {
+            name: "登录类型",
+            type: "string",
+            regexp: "^(username|email|phone)$"
+        }
     },
-    required: ['account', 'password'],
+    required: ["account", "password", "loginType"],
     handler: async (befly, ctx) => {
         // 解析 User-Agent
-        const userAgent = ctx.req.headers.get('user-agent') || '';
+        const userAgent = ctx.req.headers.get("user-agent") || "";
         const uaResult = UAParser(userAgent);
 
         // 日志数据（公共部分）
         const logData = {
             adminId: 0,
             username: ctx.body.account,
-            nickname: '',
-            ip: ctx.ip || 'unknown',
+            nickname: "",
+            ip: ctx.ip || "unknown",
             userAgent: userAgent.substring(0, 500),
-            browserName: uaResult.browser.name || '',
-            browserVersion: uaResult.browser.version || '',
-            osName: uaResult.os.name || '',
-            osVersion: uaResult.os.version || '',
-            deviceType: uaResult.device.type || 'desktop',
-            deviceVendor: uaResult.device.vendor || '',
-            deviceModel: uaResult.device.model || '',
-            engineName: uaResult.engine.name || '',
-            cpuArchitecture: uaResult.cpu.architecture || '',
+            browserName: uaResult.browser.name || "",
+            browserVersion: uaResult.browser.version || "",
+            osName: uaResult.os.name || "",
+            osVersion: uaResult.os.version || "",
+            deviceType: uaResult.device.type || "desktop",
+            deviceVendor: uaResult.device.vendor || "",
+            deviceModel: uaResult.device.model || "",
+            engineName: uaResult.engine.name || "",
+            cpuArchitecture: uaResult.cpu.architecture || "",
             loginTime: Date.now(),
             loginResult: 0,
-            failReason: ''
+            failReason: ""
         };
 
-        // 查询管理员（account 匹配 username 或 email）
+        // 根据登录类型构建查询条件
+        const whereCondition: Record<string, any> = {};
+        if (ctx.body.loginType === "username") {
+            whereCondition.username = ctx.body.account;
+        } else if (ctx.body.loginType === "email") {
+            whereCondition.email = ctx.body.account;
+        } else if (ctx.body.loginType === "phone") {
+            whereCondition.phone = ctx.body.account;
+        }
+
+        // 查询管理员
         const admin = await befly.db.getOne({
-            table: 'addon_admin_admin',
-            where: {
-                $or: [{ username: ctx.body.account }, { email: ctx.body.account }]
-            }
+            table: "addon_admin_admin",
+            where: whereCondition
         });
 
         if (!admin?.id) {
-            logData.failReason = '账号不存在';
-            await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
-            return befly.tool.No('账号或密码错误');
+            logData.failReason = "账号不存在";
+            await befly.db.insData({ table: "addon_admin_login_log", data: logData });
+            return befly.tool.No("账号或密码错误");
         }
 
         // 更新日志数据（已找到用户）
         logData.adminId = admin.id;
         logData.username = admin.username;
-        logData.nickname = admin.nickname || '';
+        logData.nickname = admin.nickname || "";
 
         // 验证密码
         try {
             const isValid = await befly.cipher.verifyPassword(ctx.body.password, admin.password);
             if (!isValid) {
-                logData.failReason = '密码错误';
-                await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
-                return befly.tool.No('账号或密码错误');
+                logData.failReason = "密码错误";
+                await befly.db.insData({ table: "addon_admin_login_log", data: logData });
+                return befly.tool.No("账号或密码错误");
             }
         } catch (error: any) {
-            befly.logger.error({ err: error }, '密码验证失败');
-            logData.failReason = '密码格式错误';
-            await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
-            return befly.tool.No('密码格式错误，请重新设置密码');
+            befly.logger.error({ err: error }, "密码验证失败");
+            logData.failReason = "密码格式错误";
+            await befly.db.insData({ table: "addon_admin_login_log", data: logData });
+            return befly.tool.No("密码格式错误，请重新设置密码");
         }
 
         // 检查账号状态（state=1 表示正常，state=2 表示禁用）
         if (admin.state === 2) {
-            logData.failReason = '账号已被禁用';
-            await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
-            return befly.tool.No('账号已被禁用');
+            logData.failReason = "账号已被禁用";
+            await befly.db.insData({ table: "addon_admin_login_log", data: logData });
+            return befly.tool.No("账号已被禁用");
         }
 
         // 登录成功，记录日志
         logData.loginResult = 1;
-        await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
-
-        // 更新最后登录信息
-        await befly.db.updData({
-            table: 'addon_admin_admin',
-            where: { id: admin.id },
-            data: {
-                lastLoginTime: Date.now(),
-                lastLoginIp: ctx.ip || 'unknown'
-            }
-        });
+        await befly.db.insData({ table: "addon_admin_login_log", data: logData });
 
         // 生成 JWT Token（包含核心身份信息）
         const token = await befly.jwt.sign(
@@ -105,14 +108,14 @@ export default {
                 roleType: admin.roleType
             },
             {
-                expiresIn: '30d'
+                expiresIn: "30d"
             }
         );
 
         // 返回用户信息（不包含密码）
         const { password: _, ...userWithoutPassword } = admin;
 
-        return befly.tool.Yes('登录成功', {
+        return befly.tool.Yes("登录成功", {
             token: token,
             userInfo: userWithoutPassword
         });

package/apis/auth/sendSmsCode.ts

@@ -1,12 +1,12 @@
-import adminTable from '../../tables/admin.json';
+import adminTable from "../../tables/admin.json";
 
 export default {
-    name: '发送短信验证码',
+    name: "发送短信验证码",
     auth: false,
     fields: {
         phone: adminTable.phone
     },
-    required: ['phone'],
+    required: ["phone"],
     handler: async (befly, ctx) => {
         // 生成6位数验证码
         const code = Math.floor(100000 + Math.random() * 900000).toString();
@@ -19,12 +19,12 @@ export default {
         // 如果项目没有 Redis,也可以存储到数据库中
         if (befly.redis) {
             const key = `sms_code:${ctx.body.phone}`;
-            await befly.redis.set(key, code, 'EX', 300); // 5分钟过期
+            await befly.redis.set(key, code, "EX", 300); // 5分钟过期
         }
 
         // 开发环境下返回验证码(生产环境应该删除)
-        const isDev = befly.config.nodeEnv === 'development';
+        const isDev = befly.config.nodeEnv === "development";
 
-        return befly.tool.Yes('验证码已发送', isDev ? { code } : null);
+        return befly.tool.Yes("验证码已发送", isDev ? { code } : null);
     }
 };

package/apis/dashboard/configStatus.ts

@@ -1,23 +1,23 @@
-export default {
-    name: '获取配置状态',
-    handler: async (befly, ctx) => {
+export default {
+    name: "获取配置状态",
+    handler: async (befly) => {
         const status = {
-            database: { status: 'ok', latency: 0 },
-            redis: { status: 'ok', latency: 0 },
-            fileSystem: { status: 'ok' },
-            email: { status: 'warning', message: '未配置' },
-            oss: { status: 'warning', message: '未配置' }
+            database: { status: "ok", latency: 0 },
+            redis: { status: "ok", latency: 0 },
+            fileSystem: { status: "ok" },
+            email: { status: "warning", message: "未配置" },
+            oss: { status: "warning", message: "未配置" }
         };
 
         // 检查数据库连接
         try {
             const startTime = Date.now();
-            await befly.db.query('SELECT 1');
+            await befly.db.query("SELECT 1");
             status.database.latency = Date.now() - startTime;
-            status.database.status = 'ok';
-        } catch (error) {
-            status.database.status = 'error';
-            status.database.message = '连接失败';
+            status.database.status = "ok";
+        } catch {
+            status.database.status = "error";
+            status.database.message = "连接失败";
         }
 
         // 检查 Redis 连接
@@ -25,12 +25,12 @@
             const startTime = Date.now();
             await befly.redis.ping();
             status.redis.latency = Date.now() - startTime;
-            status.redis.status = 'ok';
-        } catch (error) {
-            status.redis.status = 'error';
-            status.redis.message = '连接失败';
+            status.redis.status = "ok";
+        } catch {
+            status.redis.status = "error";
+            status.redis.message = "连接失败";
         }
 
-        return befly.tool.Yes('获取成功', status);
+        return befly.tool.Yes("获取成功", status);
     }
 };

package/apis/dashboard/environmentInfo.ts

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

package/apis/dashboard/performanceMetrics.ts

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

package/apis/dashboard/permissionStats.ts

@@ -1,22 +1,22 @@
-export default {
-    name: '获取权限统计',
-    handler: async (befly, ctx) => {
+export default {
+    name: "获取权限统计",
+    handler: async (befly) => {
         // 统计菜单数量
         const menuCount = await befly.db.count({
-            table: 'addon_admin_menu'
+            table: "addon_admin_menu"
         });
 
         // 统计接口数量
         const apiCount = await befly.db.count({
-            table: 'addon_admin_api'
+            table: "addon_admin_api"
         });
 
         // 统计角色数量
         const roleCount = await befly.db.count({
-            table: 'addon_admin_role'
+            table: "addon_admin_role"
         });
 
-        return befly.tool.Yes('获取成功', {
+        return befly.tool.Yes("获取成功", {
             menuCount: menuCount,
             apiCount: apiCount,
             roleCount: roleCount

package/apis/dashboard/serviceStatus.ts

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

package/apis/dashboard/systemInfo.ts

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

package/apis/dashboard/systemOverview.ts

@@ -1,23 +1,23 @@
-export default {
-    name: '获取系统概览数据',
-    handler: async (befly, ctx) => {
+export default {
+    name: "获取系统概览数据",
+    handler: async (befly) => {
         // 权限统计
         const menuCount = await befly.db.getCount({
-            table: 'addon_admin_menu',
+            table: "addon_admin_menu",
             where: { state: 1 }
         });
 
         const roleCount = await befly.db.getCount({
-            table: 'addon_admin_role',
+            table: "addon_admin_role",
             where: { state: 1 }
         });
 
         const apiCount = await befly.db.getCount({
-            table: 'addon_admin_api',
+            table: "addon_admin_api",
             where: { state: 1 }
         });
 
-        return befly.tool.Yes('获取成功', {
+        return befly.tool.Yes("获取成功", {
             menuCount,
             roleCount,
             apiCount

package/apis/dashboard/systemResources.ts

@@ -1,12 +1,12 @@
-import os from 'node:os';
-import fs from 'node:fs';
-import { promisify } from 'node:util';
+import fs from "node:fs";
+import os from "node:os";
+import { promisify } from "node:util";
 
 export default {
-    name: '获取系统资源',
+    name: "获取系统资源",
     auth: true,
     fields: {},
-    handler: async (befly, ctx) => {
+    handler: async (befly) => {
         // CPU 使用率
         const cpus = os.cpus();
         const cpuCount = cpus.length; // 逻辑核心数（包括超线程）
@@ -84,17 +84,17 @@ export default {
                 }
             } else {
                 // statfs 不可用，返回默认值
-                befly.logger.warn('fs.statfs 不可用，无法获取磁盘信息');
+                befly.logger.warn("fs.statfs 不可用，无法获取磁盘信息");
             }
         } catch (error) {
-            befly.logger.warn({ err: error }, '获取磁盘信息失败');
+            befly.logger.warn({ err: error }, "获取磁盘信息失败");
             // 获取失败时返回 0
             diskPercentage = 0;
             diskUsed = 0;
             diskTotal = 0;
         }
 
-        return befly.tool.Yes('获取成功', {
+        return befly.tool.Yes("获取成功", {
             cpu: {
                 usage: cpuUsage,
                 cores: cpuCount

package/apis/dict/all.ts

@@ -1,12 +1,29 @@
-export default {
-    name: '获取所有字典',
+export default {
+    name: "获取所有字典",
     handler: async (befly) => {
-        const dicts = await befly.db.getAll({
-            table: 'addon_admin_dict',
-            fields: ['id', 'code', 'name', 'value'],
-            orderBy: ['id#ASC']
+        const result = await befly.db.getAll({
+            table: "addon_admin_dict",
+            joins: [
+                {
+                    table: "addon_admin_dict_type",
+                    on: "addon_admin_dict.type_code = addon_admin_dict_type.code"
+                }
+            ],
+            fields: [
+                //
+                "addon_admin_dict.id",
+                "addon_admin_dict.typeCode",
+                "addon_admin_dict.key",
+                "addon_admin_dict.label",
+                "addon_admin_dict.sort",
+                "addon_admin_dict.remark",
+                "addon_admin_dict.createdAt",
+                "addon_admin_dict.updatedAt",
+                "addon_admin_dict_type.name AS typeName"
+            ],
+            orderBy: ["addon_admin_dict.sort#ASC", "addon_admin_dict.id#ASC"]
         });
 
-        return befly.tool.Yes('操作成功', { lists: dicts.lists });
+        return befly.tool.Yes("获取成功", result);
     }
 };

package/apis/dict/del.ts

@@ -1,21 +1,13 @@
-export default {
-    name: '删除字典',
-    fields: {
-        id: '@id'
-    },
+export default {
+    name: "删除字典",
+    fields: { "@id": true },
+    required: ["id"],
     handler: async (befly, ctx) => {
-        try {
-            await befly.db.delData({
-                table: 'addon_admin_dict',
-                where: {
-                    id: ctx.body.id
-                }
-            });
+        await befly.db.delData({
+            table: "addon_admin_dict",
+            where: { id: ctx.body.id }
+        });
 
-            return befly.tool.Yes('操作成功');
-        } catch (error) {
-            befly.logger.error({ err: error }, '删除字典失败');
-            return befly.tool.No('操作失败');
-        }
+        return befly.tool.Yes("删除成功");
     }
 };