@befly-addon/admin 1.1.28 → 1.1.30

package/apis/admin/cacheRefresh.ts

@@ -28,7 +28,6 @@ export default {
             try {
                 const apis = await befly.db.getAll({
                     table: 'addon_admin_api',
-                    fields: ['id', 'name', 'path', 'method', 'description', 'addonName', 'addonTitle'],
                     orderBy: ['addonName#ASC', 'path#ASC']
                 });
 
@@ -43,7 +42,6 @@ export default {
             try {
                 const menus = await befly.db.getAll({
                     table: 'addon_admin_menu',
-                    fields: ['id', 'pid', 'name', 'path', 'icon', 'type', 'sort'],
                     orderBy: ['sort#ASC', 'id#ASC']
                 });
 
@@ -66,8 +64,7 @@ export default {
             // 3. 刷新角色权限缓存
             try {
                 const roles = await befly.db.getAll({
-                    table: 'addon_admin_role',
-                    fields: ['id', 'name', 'code', 'menus', 'apis']
+                    table: 'addon_admin_role'
                 });
 
                 // 使用 setBatch 批量缓存所有角色

package/apis/admin/del.ts

@@ -6,18 +6,18 @@
     required: ['id'],
     handler: async (befly, ctx) => {
         // 检查管理员是否存在
-        const admin = await befly.db.getOne({
+        const adminData = await befly.db.getOne({
             table: 'addon_admin_admin',
             where: { id: ctx.body.id }
         });
 
-        if (!admin) {
+        if (!adminData?.id) {
             return befly.tool.No('管理员不存在');
         }
 
         // 不能删除 dev 角色的管理员
-        if (admin.roleCode === 'dev') {
-            return befly.tool.No('不能删除开发者账号');
+        if (adminData.roleCode === 'dev') {
+            return befly.tool.No('不能删除开发管理员');
         }
 
         // 删除管理员

package/apis/admin/detail.ts

@@ -1,51 +1,19 @@
-/**
- * 获取用户信息接口
- *
- * @returns 返回 admin 表的字段（不含 password）以及关联的角色信息（小驼峰格式）:
- *  - id, name, email, phone, roleId, roleCode, state
- *  - lastLoginTime, lastLoginIp
- *  - createdAt, updatedAt
- *  - role: 角色完整信息（包含 menus 和 apis 权限）
- */
-
-export default {
-    name: '获取用户信息',
+export default {
+    name: '获取管理员信息',
     fields: {
         id: '@id'
     },
     handler: async (befly, ctx) => {
-        // 从 JWT token 中获取用户ID
-        const userId = ctx.user?.id;
-
-        if (!userId) {
-            return befly.tool.No('未授权');
-        }
-
-        // 查询用户信息（框架自动转换为小驼峰）
-        const admin = await befly.db.getOne({
+        const adminData = await befly.db.getOne({
             table: 'addon_admin_admin',
-            where: { id: userId }
+            fields: ['!password'],
+            where: { id: ctx.user?.id }
         });
 
-        if (!admin) {
-            return befly.tool.No('用户不存在');
+        if (!adminData?.id) {
+            return befly.tool.No('管理员不存在');
         }
 
-        // 查询角色信息（使用 roleCode 而非 roleId，框架自动转换为小驼峰）
-        let roleInfo = null;
-        if (admin.roleCode) {
-            roleInfo = await befly.db.getOne({
-                table: 'addon_admin_role',
-                where: { code: admin.roleCode }
-            });
-        }
-
-        // 返回用户信息（不包含密码，字段已是小驼峰格式）
-        const { password: _, ...userWithoutPassword } = admin;
-
-        return befly.tool.Yes('获取成功', {
-            ...userWithoutPassword,
-            role: roleInfo
-        });
+        return befly.tool.Yes('查询成功', adminData);
     }
 };

package/apis/admin/ins.ts

@@ -3,28 +3,37 @@
 export default {
     name: '添加管理员',
     fields: adminTable,
-    required: ['username', 'password', 'roleId'],
+    required: ['username', 'password', 'roleCode'],
     handler: async (befly, ctx) => {
         // 检查用户名是否已存在
-        if (ctx.body.username) {
-            const existingByUsername = await befly.db.getOne({
+        const existingByUsername = await befly.db.getOne({
+            table: 'addon_admin_admin',
+            where: { username: ctx.body.username }
+        });
+
+        if (existingByUsername?.id) {
+            return befly.tool.No('用户名已被使用');
+        }
+
+        // 检查昵称是否已存在
+        if (ctx.body.nickname) {
+            const existingByNickname = await befly.db.getOne({
                 table: 'addon_admin_admin',
-                where: { username: ctx.body.username }
+                where: { nickname: ctx.body.nickname }
             });
 
-            if (existingByUsername) {
-                return befly.tool.No('用户名已被使用');
+            if (existingByNickname?.id) {
+                return befly.tool.No('昵称已被使用');
             }
         }
 
         // 查询角色信息
-        const role = await befly.db.getOne({
+        const roleData = await befly.db.getOne({
             table: 'addon_admin_role',
-            where: { id: ctx.body.roleId },
-            columns: ['code']
+            where: { code: ctx.body.roleCode }
         });
 
-        if (!role?.code) {
+        if (!roleData?.id) {
             return befly.tool.No('角色不存在');
         }
 
@@ -38,14 +47,12 @@ export default {
                 username: ctx.body.username,
                 password: hashedPassword,
                 nickname: ctx.body.nickname,
-                roleId: ctx.body.roleId,
-                roleCode: role.code
+                roleCode: ctx.body.roleCode
             }
         });
 
         return befly.tool.Yes('添加成功', {
-            id: adminId,
-            username: ctx.body.username
+            id: adminId
         });
     }
 };

package/apis/admin/list.ts

@@ -1,5 +1,5 @@
 export default {
-    name: '获取管理员列表',
+    name: '查询管理员列表',
     fields: {
         page: '@page',
         limit: '@limit',
@@ -9,8 +9,8 @@
     handler: async (befly, ctx) => {
         const result = await befly.db.getList({
             table: 'addon_admin_admin',
-            page: ctx.body.page || 1,
-            limit: ctx.body.limit || 10,
+            page: ctx.body.page,
+            limit: ctx.body.limit,
             where: {
                 roleCode: {
                     $ne: 'dev'

package/apis/admin/upd.ts

@@ -1,15 +1,11 @@
-/**
- * 更新管理员信息
- */
-
-import adminTable from '../../tables/admin.json';
+import adminTable from '../../tables/admin.json';
 
 export default {
     name: '更新管理员',
-    fields: adminTable,
+    fields: { id: '@id', ...adminTable },
     required: ['id'],
     handler: async (befly, ctx) => {
-        const { id, ...updateData } = ctx.body;
+        const { id, username, nickname, roleCode, ...updateData } = ctx.body;
 
         // 检查管理员是否存在
         const admin = await befly.db.getOne({
@@ -21,10 +17,49 @@ export default {
             return befly.tool.No('管理员不存在');
         }
 
+        // 检查用户名是否已被其他管理员使用
+        if (username && username !== admin.username) {
+            const existingUsername = await befly.db.getOne({
+                table: 'addon_admin_admin',
+                where: { username, id: { $ne: id } }
+            });
+            if (existingUsername?.id) {
+                return befly.tool.No('用户名已被使用');
+            }
+        }
+
+        // 检查昵称是否已被其他管理员使用
+        if (nickname && nickname !== admin.nickname) {
+            const existingNickname = await befly.db.getOne({
+                table: 'addon_admin_admin',
+                where: { nickname, id: { $ne: id } }
+            });
+            if (existingNickname?.id) {
+                return befly.tool.No('昵称已被使用');
+            }
+        }
+
+        // 检查角色是否存在
+        if (roleCode && roleCode !== admin.roleCode) {
+            const role = await befly.db.getOne({
+                table: 'addon_admin_role',
+                where: { code: roleCode }
+            });
+            if (!role?.id) {
+                return befly.tool.No('角色不存在');
+            }
+        }
+
+        // 构建更新数据
+        const dataToUpdate: Record<string, any> = { ...updateData };
+        if (username) dataToUpdate.username = username;
+        if (nickname) dataToUpdate.nickname = nickname;
+        if (roleCode) dataToUpdate.roleCode = roleCode;
+
         // 更新管理员信息
         await befly.db.updData({
             table: 'addon_admin_admin',
-            data: updateData,
+            data: dataToUpdate,
             where: { id }
         });
 

package/apis/api/all.ts

@@ -5,14 +5,18 @@
             // 从缓存获取所有接口
             let allApis = await befly.cache.getApis();
 
-            // 如果缓存不存在，从数据库查询
+            // 如果缓存不存在，从数据库查询并缓存
             if (allApis.length === 0) {
                 const result = await befly.db.getAll({
                     table: 'addon_admin_api',
-                    fields: ['id', 'name', 'path', 'method', 'description', 'addonName', 'addonTitle'],
-                    orderBy: ['addonName#ASC', 'path#ASC']
+                    orderBy: ['id#ASC']
                 });
                 allApis = result.lists;
+
+                // 缓存到 Redis
+                if (allApis.length > 0) {
+                    await befly.cache.cacheApis();
+                }
             }
 
             return befly.tool.Yes('操作成功', { lists: allApis });

package/apis/api/list.ts

@@ -1,7 +1,5 @@
-import type { ApiRoute } from 'befly';
-
 export default {
-    name: '获取接口列表（分页）',
+    name: '获取接口列表',
     fields: {
         page: '@page',
         limit: '@limit',
@@ -10,21 +8,14 @@ export default {
     },
     handler: async (befly, ctx) => {
         try {
-            const { page = 1, limit = 30, keyword = '' } = ctx.body;
-
-            // 构建查询条件
-            const where: Record<string, any> = {};
-            if (keyword) {
-                where.$or = [{ name: { $like: `%${keyword}%` } }, { path: { $like: `%${keyword}%` } }];
-            }
-
             const result = await befly.db.getList({
                 table: 'addon_admin_api',
-                fields: ['id', 'name', 'path', 'method', 'description', 'addon_name', 'addon_title'],
-                where: where,
-                orderBy: ['addon_name#ASC', 'path#ASC'],
-                page: page,
-                limit: limit
+                where: {
+                    $or: ctx.body.keyword ? [{ name$like: `%${ctx.body.keyword}%` }, { path$like: `%${ctx.body.keyword}%` }] : undefined
+                },
+                orderBy: ['id#ASC'],
+                page: ctx.body.page,
+                limit: ctx.body.limit
             });
 
             return befly.tool.Yes('操作成功', result);
@@ -33,4 +24,4 @@ export default {
             return befly.tool.No('获取接口列表失败');
         }
     }
-} as ApiRoute;
+};

package/apis/auth/login.ts

@@ -12,9 +12,14 @@ export default {
             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') || '';
@@ -41,12 +46,20 @@ export default {
             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 }]
-            }
+            where: whereCondition
         });
 
         if (!admin?.id) {
@@ -86,16 +99,6 @@ export default {
         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'
-            }
-        });
-
         // 生成 JWT Token（包含核心身份信息）
         const token = await befly.jwt.sign(
             {

package/apis/dict/all.ts

@@ -1,12 +1,29 @@
 export default {
     name: '获取所有字典',
     handler: async (befly) => {
-        const dicts = await befly.db.getAll({
+        const result = await befly.db.getAll({
             table: 'addon_admin_dict',
-            fields: ['id', 'code', 'name', 'value'],
-            orderBy: ['id#ASC']
+            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'
-    },
+    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('删除成功');
     }
 };

package/apis/dict/detail.ts

@@ -1,22 +1,36 @@
 export default {
     name: '获取字典详情',
-    fields: {
-        id: '@id'
-    },
+    fields: { '@id': true },
+    required: ['id'],
     handler: async (befly, ctx) => {
-        try {
-            const dict = await befly.db.getDetail({
-                table: 'addon_admin_dict',
-                fields: ['id', 'name', 'code', 'value', 'sort', 'pid', 'description', 'state', 'created_at', 'updated_at'],
-                where: {
-                    id: ctx.body.id
+        const dict = await befly.db.getOne({
+            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'
+            ],
+            where: { 'addon_admin_dict.id': ctx.body.id }
+        });
 
-            return befly.tool.Yes('操作成功', dict);
-        } catch (error: any) {
-            befly.logger.error({ err: error }, '获取字典详情失败');
-            return befly.tool.No('操作失败');
+        if (!dict?.id) {
+            return befly.tool.No('字典项不存在');
         }
+
+        return befly.tool.Yes('获取成功', dict);
     }
 };

package/apis/dict/ins.ts

@@ -3,24 +3,42 @@
 export default {
     name: '添加字典',
     fields: adminDictTable,
+    required: ['typeCode', 'key', 'label'],
     handler: async (befly, ctx) => {
-        try {
-            const dictId = await befly.db.insData({
-                table: 'addon_admin_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
-                }
-            });
+        // 验证 typeCode 是否存在
+        const dictType = await befly.db.getOne({
+            table: 'addon_admin_dict_type',
+            where: { code: ctx.body.typeCode }
+        });
 
-            return befly.tool.Yes('操作成功', { id: dictId });
-        } catch (error) {
-            befly.logger.error({ err: error }, '添加字典失败');
-            return befly.tool.No('操作失败');
+        if (!dictType?.id) {
+            return befly.tool.No('字典类型不存在');
         }
+
+        // 检查 typeCode+key 是否已存在
+        const existing = await befly.db.getOne({
+            table: 'addon_admin_dict',
+            where: {
+                typeCode: ctx.body.typeCode,
+                key: ctx.body.key
+            }
+        });
+
+        if (existing?.id) {
+            return befly.tool.No('该类型下已存在相同的键名');
+        }
+
+        const dictId = await befly.db.insData({
+            table: 'addon_admin_dict',
+            data: {
+                typeCode: ctx.body.typeCode,
+                key: ctx.body.key,
+                label: ctx.body.label,
+                sort: ctx.body.sort,
+                remark: ctx.body.remark
+            }
+        });
+
+        return befly.tool.Yes('添加成功', { id: dictId });
     }
 };

package/apis/dict/items.ts

@@ -0,0 +1,27 @@
+export default {
+    name: '获取字典项列表',
+    fields: {
+        typeCode: { type: 'string', label: '类型代码', required: true }
+    },
+    required: ['typeCode'],
+    handler: async (befly, ctx) => {
+        // 验证 typeCode 是否存在
+        const dictType = await befly.db.getOne({
+            table: 'addon_admin_dict_type',
+            where: { code: ctx.body.typeCode }
+        });
+
+        if (!dictType?.id) {
+            return befly.tool.No('字典类型不存在');
+        }
+
+        // 获取该类型下的所有字典项
+        const items = await befly.db.getAll({
+            table: 'addon_admin_dict',
+            where: { typeCode: ctx.body.typeCode },
+            orderBy: ['sort#ASC', 'id#ASC']
+        });
+
+        return befly.tool.Yes('获取成功', items);
+    }
+};

package/apis/dict/list.ts

@@ -3,18 +3,43 @@
     fields: {
         page: '@page',
         limit: '@limit',
-        keyword: '@keyword',
-        state: '@state'
+        typeCode: { type: 'string', label: '类型代码' },
+        keyword: '@keyword'
     },
     handler: async (befly, ctx) => {
+        const where: any = {};
+        if (ctx.body.typeCode) where['addon_admin_dict.typeCode'] = ctx.body.typeCode;
+        if (ctx.body.keyword) {
+            where.$or = [{ 'addon_admin_dict.key$like': `%${ctx.body.keyword}%` }, { 'addon_admin_dict.label$like': `%${ctx.body.keyword}%` }];
+        }
+
         const result = await befly.db.getList({
             table: 'addon_admin_dict',
-            fields: ['id', 'name', 'code', 'value', 'sort', 'pid', 'description', 'state', 'created_at', 'updated_at'],
+            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'
+            ],
+            where: where,
             page: ctx.body.page,
             limit: ctx.body.limit,
-            orderBy: ['sort#ASC', 'id#ASC']
+            orderBy: ['addon_admin_dict.sort#ASC', 'addon_admin_dict.id#ASC']
         });
 
-        return befly.tool.Yes('操作成功', result);
+        return befly.tool.Yes('获取成功', result);
     }
 };