@befly-addon/admin 1.1.29 → 1.1.31

package/apis/dict/detail.ts

@@ -1,22 +1,36 @@
-export default {
-    name: '获取字典详情',
-    fields: {
-        id: '@id'
-    },
+export default {
+    name: "获取字典详情",
+    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

@@ -1,26 +1,44 @@
-import adminDictTable from '../../tables/dict.json';
+import adminDictTable from "../../tables/dict.json";
 
 export default {
-    name: '添加字典',
+    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

@@ -1,20 +1,45 @@
-export default {
-    name: '获取字典列表',
+export default {
+    name: "获取字典列表",
     fields: {
-        page: '@page',
-        limit: '@limit',
-        keyword: '@keyword',
-        state: '@state'
+        page: "@page",
+        limit: "@limit",
+        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'],
+            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: 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);
     }
 };

package/apis/dict/upd.ts

@@ -1,30 +1,64 @@
-import adminDictTable from '../../tables/dict.json';
+import adminDictTable from "../../tables/dict.json";
 
 export default {
-    name: '更新字典',
-    fields: adminDictTable,
+    name: "更新字典",
+    fields: {
+        ...adminDictTable,
+        "@id": true
+    },
+    required: ["id"],
     handler: async (befly, ctx) => {
-        try {
-            await befly.db.updData({
-                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,
-                    state: ctx.body.state
-                },
+        const { id, typeCode, key, label, sort, remark } = ctx.body;
+
+        // 如果更新了 typeCode，验证其是否存在
+        if (typeCode) {
+            const dictType = await befly.db.getOne({
+                table: "addon_admin_dict_type",
+                where: { code: typeCode }
+            });
+
+            if (!dictType?.id) {
+                return befly.tool.No("字典类型不存在");
+            }
+        }
+
+        // 如果更新了 typeCode 或 key，检查唯一性
+        if (typeCode || key) {
+            const current = await befly.db.getOne({
+                table: "addon_admin_dict",
+                where: { id: id }
+            });
+
+            const checkTypeCode = typeCode || current?.typeCode;
+            const checkKey = key || current?.key;
+
+            const existing = await befly.db.getOne({
+                table: "addon_admin_dict",
                 where: {
-                    id: ctx.body.id
+                    typeCode: checkTypeCode,
+                    key: checkKey,
+                    id$ne: id
                 }
             });
 
-            return befly.tool.Yes('操作成功');
-        } catch (error) {
-            befly.logger.error({ err: error }, '更新字典失败');
-            return befly.tool.No('操作失败');
+            if (existing?.id) {
+                return befly.tool.No("该类型下已存在相同的键名");
+            }
         }
+
+        const updateData: Record<string, any> = {};
+        if (typeCode !== undefined) updateData.typeCode = typeCode;
+        if (key !== undefined) updateData.key = key;
+        if (label !== undefined) updateData.label = label;
+        if (sort !== undefined) updateData.sort = sort;
+        if (remark !== undefined) updateData.remark = remark;
+
+        await befly.db.updData({
+            table: "addon_admin_dict",
+            data: updateData,
+            where: { id: id }
+        });
+
+        return befly.tool.Yes("更新成功");
     }
 };

package/apis/dictType/all.ts

@@ -0,0 +1,11 @@
+export default {
+    name: "获取所有字典类型",
+    handler: async (befly) => {
+        const result = await befly.db.getAll({
+            table: "addon_admin_dict_type",
+            orderBy: ["sort#ASC", "id#ASC"]
+        });
+
+        return befly.tool.Yes("操作成功", { lists: result.lists });
+    }
+};

package/apis/dictType/del.ts

@@ -0,0 +1,32 @@
+export default {
+    name: "删除字典类型",
+    fields: { "@id": true },
+    required: ["id"],
+    handler: async (befly, ctx) => {
+        const { id } = ctx.body;
+
+        // 检查是否有字典项引用此类型
+        const dictItems = await befly.db.getOne({
+            table: "addon_admin_dict",
+            where: {
+                typeCode: (
+                    await befly.db.getOne({
+                        table: "addon_admin_dict_type",
+                        where: { id: id }
+                    })
+                )?.code
+            }
+        });
+
+        if (dictItems?.id) {
+            return befly.tool.No("该类型下存在字典项，无法删除");
+        }
+
+        await befly.db.delData({
+            table: "addon_admin_dict_type",
+            where: { id: id }
+        });
+
+        return befly.tool.Yes("删除成功");
+    }
+};

package/apis/dictType/detail.ts

@@ -0,0 +1,17 @@
+export default {
+    name: "字典类型详情",
+    fields: { "@id": true },
+    required: ["id"],
+    handler: async (befly, ctx) => {
+        const detail = await befly.db.getDetail({
+            table: "addon_admin_dict_type",
+            where: { id: ctx.body.id }
+        });
+
+        if (!detail?.id) {
+            return befly.tool.No("字典类型不存在");
+        }
+
+        return befly.tool.Yes("获取成功", detail);
+    }
+};

package/apis/dictType/ins.ts

@@ -0,0 +1,30 @@
+import dictTypeTable from "../../tables/dictType.json";
+
+export default {
+    name: "添加字典类型",
+    fields: dictTypeTable,
+    required: ["code", "name"],
+    handler: async (befly, ctx) => {
+        // 检查代码是否已存在
+        const existing = await befly.db.getOne({
+            table: "addon_admin_dict_type",
+            where: { code: ctx.body.code }
+        });
+
+        if (existing?.id) {
+            return befly.tool.No("类型代码已存在");
+        }
+
+        const typeId = await befly.db.insData({
+            table: "addon_admin_dict_type",
+            data: {
+                code: ctx.body.code,
+                name: ctx.body.name,
+                description: ctx.body.description,
+                sort: ctx.body.sort
+            }
+        });
+
+        return befly.tool.Yes("添加成功", { id: typeId });
+    }
+};

package/apis/dictType/list.ts

@@ -0,0 +1,22 @@
+export default {
+    name: "获取字典类型列表",
+    fields: {
+        page: "@page",
+        limit: "@limit",
+        keyword: "@keyword",
+        state: "@state"
+    },
+    handler: async (befly, ctx) => {
+        const result = await befly.db.getList({
+            table: "addon_admin_dict_type",
+            where: {
+                name$like: ctx.body.keyword ? `%${ctx.body.keyword}%` : undefined
+            },
+            orderBy: ["sort#ASC", "id#ASC"],
+            page: ctx.body.page,
+            limit: ctx.body.limit
+        });
+
+        return befly.tool.Yes("操作成功", result);
+    }
+};

package/apis/dictType/upd.ts

@@ -0,0 +1,42 @@
+import dictTypeTable from "../../tables/dictType.json";
+
+export default {
+    name: "更新字典类型",
+    fields: {
+        ...dictTypeTable,
+        "@id": true
+    },
+    required: ["id"],
+    handler: async (befly, ctx) => {
+        const { id, code, name, description, sort } = ctx.body;
+
+        // 如果更新了 code，需要检查是否已被使用
+        if (code) {
+            const existing = await befly.db.getOne({
+                table: "addon_admin_dict_type",
+                where: {
+                    code: code,
+                    id$ne: id
+                }
+            });
+
+            if (existing?.id) {
+                return befly.tool.No("类型代码已被使用");
+            }
+        }
+
+        const updateData: Record<string, any> = {};
+        if (code !== undefined) updateData.code = code;
+        if (name !== undefined) updateData.name = name;
+        if (description !== undefined) updateData.description = description;
+        if (sort !== undefined) updateData.sort = sort;
+
+        await befly.db.updData({
+            table: "addon_admin_dict_type",
+            data: updateData,
+            where: { id: id }
+        });
+
+        return befly.tool.Yes("更新成功");
+    }
+};

package/apis/email/config.ts

@@ -1,13 +1,13 @@
 export default {
-    name: '获取邮件配置',
-    handler: async (befly, ctx) => {
+    name: "获取邮件配置",
+    handler: async (befly) => {
         if (!(befly as any).addon_admin_email) {
-            return befly.tool.No('邮件插件未加载，请检查配置');
+            return befly.tool.No("邮件插件未加载，请检查配置");
         }
 
         const config = (befly as any).addon_admin_email.getConfig();
 
-        return befly.tool.Yes('获取成功', {
+        return befly.tool.Yes("获取成功", {
             host: config.host,
             port: config.port,
             secure: config.secure,

package/apis/email/logList.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_email_log',
-            page: ctx.body.page || 1,
-            limit: ctx.body.limit || 30,
-            orderBy: ['sendTime#DESC']
+            table: "addon_admin_email_log",
+            page: ctx.body.page,
+            limit: ctx.body.limit,
+            orderBy: ["sendTime#DESC"]
         });
 
-        return befly.tool.Yes('获取成功', result);
+        return befly.tool.Yes("获取成功", result);
     }
 };

package/apis/email/send.ts

@@ -1,28 +1,28 @@
-import emailLogTable from '../../tables/emailLog.json';
+import emailLogTable from "../../tables/emailLog.json";
 
 export default {
-    name: '发送邮件',
+    name: "发送邮件",
     fields: {
         to: emailLogTable.toEmail,
         subject: emailLogTable.subject,
         content: {
-            name: '邮件内容',
-            type: 'string',
+            name: "邮件内容",
+            type: "string",
             min: 1,
             max: 50000
         },
         cc: emailLogTable.ccEmail,
         bcc: emailLogTable.bccEmail,
         isHtml: {
-            name: '是否HTML',
-            type: 'boolean',
+            name: "是否HTML",
+            type: "boolean",
             default: true
         }
     },
-    required: ['to', 'subject', 'content'],
+    required: ["to", "subject", "content"],
     handler: async (befly, ctx) => {
         if (!(befly as any).addon_admin_email) {
-            return befly.tool.No('邮件插件未加载，请检查配置');
+            return befly.tool.No("邮件插件未加载，请检查配置");
         }
 
         const startTime = Date.now();
@@ -40,30 +40,30 @@ export default {
         // 记录邮件发送日志
         try {
             await befly.db.insData({
-                table: 'addon_admin_email_log',
+                table: "addon_admin_email_log",
                 data: {
                     adminId: ctx.user?.id || 0,
-                    username: ctx.user?.username || '',
-                    nickname: ctx.user?.nickname || '',
+                    username: ctx.user?.username || "",
+                    nickname: ctx.user?.nickname || "",
                     toEmail: ctx.body.to,
                     subject: ctx.body.subject,
                     content: ctx.body.content,
-                    ccEmail: ctx.body.cc || '',
-                    bccEmail: ctx.body.bcc || '',
+                    ccEmail: ctx.body.cc || "",
+                    bccEmail: ctx.body.bcc || "",
                     sendTime: startTime,
                     sendResult: result.success ? 1 : 0,
-                    messageId: result.messageId || '',
-                    failReason: result.error || ''
+                    messageId: result.messageId || "",
+                    failReason: result.error || ""
                 }
             });
         } catch (logError: any) {
-            befly.logger.error({ err: logError }, '记录邮件日志失败');
+            befly.logger.error({ err: logError }, "记录邮件日志失败");
         }
 
         if (result.success) {
-            return befly.tool.Yes('发送成功', { messageId: result.messageId });
+            return befly.tool.Yes("发送成功", { messageId: result.messageId });
         }
 
-        return befly.tool.No(result.error || '发送失败');
+        return befly.tool.No(result.error || "发送失败");
     }
 };

package/apis/email/verify.ts

@@ -1,16 +1,16 @@
 export default {
-    name: '验证邮件配置',
-    handler: async (befly, ctx) => {
+    name: "验证邮件配置",
+    handler: async (befly) => {
         if (!(befly as any).addon_admin_email) {
-            return befly.tool.No('邮件插件未加载，请检查配置');
+            return befly.tool.No("邮件插件未加载，请检查配置");
         }
 
         const isValid = await (befly as any).addon_admin_email.verify();
 
         if (isValid) {
-            return befly.tool.Yes('邮件服务配置正常');
+            return befly.tool.Yes("邮件服务配置正常");
         }
 
-        return befly.tool.No('邮件服务配置异常，请检查 SMTP 设置');
+        return befly.tool.No("邮件服务配置异常，请检查 SMTP 设置");
     }
 };

package/apis/loginLog/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_login_log',
-            page: ctx.body.page || 1,
-            limit: ctx.body.limit || 30,
-            orderBy: ['loginTime#DESC']
+            table: "addon_admin_login_log",
+            page: ctx.body.page,
+            limit: ctx.body.limit,
+            orderBy: ["loginTime#DESC"]
         });
 
-        return befly.tool.Yes('获取成功', result);
+        return befly.tool.Yes("获取成功", result);
     }
 };