befly 3.17.0 → 3.17.3

package/apis/dashboard/performanceMetrics.js

@@ -0,0 +1,20 @@
+export default {
+    name: "获取性能指标",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        return befly.tool.Yes("获取成功", {
+            avgResponseTime: 125,
+            qps: 856,
+            errorRate: 0.8,
+            activeConnections: 45,
+            slowestApi: {
+                path: "/api/core/menu/list",
+                time: 450
+            }
+        });
+    }
+};

package/apis/dashboard/permissionStats.js

@@ -0,0 +1,27 @@
+export default {
+    name: "获取权限统计",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        const menuCount = await befly.mysql.getCount({
+            table: "beflyMenu"
+        });
+
+        const apiCount = await befly.mysql.getCount({
+            table: "beflyApi"
+        });
+
+        const roleCount = await befly.mysql.getCount({
+            table: "beflyRole"
+        });
+
+        return befly.tool.Yes("获取成功", {
+            menuCount: menuCount.data,
+            apiCount: apiCount.data,
+            roleCount: roleCount.data
+        });
+    }
+};

package/apis/dashboard/serviceStatus.js

@@ -0,0 +1,75 @@
+export default {
+    name: "获取服务状态",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        const services = [];
+
+        try {
+            const startTime = Date.now();
+            await befly.mysql.execute("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: "-"
+            });
+        }
+
+        if (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: "-"
+        });
+
+        services.push({
+            name: "OSS存储",
+            status: "unconfigured",
+            responseTime: "-"
+        });
+
+        return befly.tool.Yes("获取成功", { services: services });
+    }
+};

package/apis/dashboard/systemInfo.js

@@ -0,0 +1,19 @@
+export default {
+    name: "获取系统信息",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        const startTime = Date.now() - Math.floor(process.uptime() * 1000);
+        const uptime = Math.floor(process.uptime() * 1000);
+        const environment = process.env.RUN_MODE || "development";
+
+        return befly.tool.Yes("获取成功", {
+            environment: environment,
+            startTime: startTime,
+            uptime: uptime
+        });
+    }
+};

package/apis/dashboard/systemOverview.js

@@ -0,0 +1,30 @@
+export default {
+    name: "获取系统概览数据",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        const menuCount = await befly.mysql.getCount({
+            table: "beflyMenu",
+            where: { state: 1 }
+        });
+
+        const roleCount = await befly.mysql.getCount({
+            table: "beflyRole",
+            where: { state: 1 }
+        });
+
+        const apiCount = await befly.mysql.getCount({
+            table: "beflyApi",
+            where: { state: 1 }
+        });
+
+        return befly.tool.Yes("获取成功", {
+            menuCount: menuCount.data,
+            roleCount: roleCount.data,
+            apiCount: apiCount.data
+        });
+    }
+};

package/apis/dashboard/systemResources.js

@@ -0,0 +1,106 @@
+import fs from "node:fs";
+import os from "node:os";
+import { promisify } from "node:util";
+
+export default {
+    name: "获取系统资源",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        const cpus = os.cpus();
+        const cpuCount = cpus.length;
+
+        const startMeasure = cpus.map((cpu) => {
+            let total = 0;
+            for (const value of Object.values(cpu.times)) {
+                total += value;
+            }
+            return {
+                idle: cpu.times.idle,
+                total: total
+            };
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        const endCpus = os.cpus();
+        const endMeasure = endCpus.map((cpu) => {
+            let total = 0;
+            for (const value of Object.values(cpu.times)) {
+                total += value;
+            }
+            return {
+                idle: cpu.times.idle,
+                total: total
+            };
+        });
+
+        let totalIdle = 0;
+        let totalTick = 0;
+        for (let i = 0; i < startMeasure.length; i++) {
+            const end = endMeasure[i];
+            if (!end) {
+                continue;
+            }
+            const idleDiff = end.idle - startMeasure[i].idle;
+            const totalDiff = end.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;
+
+        let diskPercentage = 0;
+        let diskUsed = 0;
+        let diskTotal = 0;
+
+        try {
+            if (fs.statfs) {
+                const statfsAsync = promisify(fs.statfs);
+                const stats = await statfsAsync(process.cwd());
+
+                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 {
+                befly.logger.warn("fs.statfs 不可用，无法获取磁盘信息");
+            }
+        } catch (error) {
+            befly.logger.warn("获取磁盘信息失败", { err: error });
+            diskPercentage = 0;
+            diskUsed = 0;
+            diskTotal = 0;
+        }
+
+        return befly.tool.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.js

@@ -0,0 +1,23 @@
+export default {
+    name: "获取所有字典",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        const result = await befly.mysql.getAll({
+            table: "beflyDict",
+            joins: [
+                {
+                    table: "beflyDictType",
+                    on: "beflyDict.typeCode = beflyDictType.code"
+                }
+            ],
+            fields: ["beflyDict.id", "beflyDict.typeCode", "beflyDict.key", "beflyDict.label", "beflyDict.sort", "beflyDict.remark", "beflyDict.createdAt", "beflyDict.updatedAt", "beflyDictType.name AS typeName"],
+            orderBy: ["beflyDict.sort#ASC", "beflyDict.id#ASC"]
+        });
+
+        return befly.tool.Yes("获取成功", result.data);
+    }
+};

package/apis/dict/del.js

@@ -0,0 +1,16 @@
+export default {
+    name: "删除字典",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: { id: { name: "ID", input: "integer", min: 1, max: null } },
+    required: ["id"],
+    handler: async (befly, ctx) => {
+        await befly.mysql.delData({
+            table: "beflyDict",
+            where: { id: ctx.body.id }
+        });
+
+        return befly.tool.Yes("删除成功");
+    }
+};

package/apis/dict/detail.js

@@ -0,0 +1,27 @@
+export default {
+    name: "获取字典详情",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: { id: { name: "ID", input: "integer", min: 1, max: null } },
+    required: ["id"],
+    handler: async (befly, ctx) => {
+        const dict = await befly.mysql.getOne({
+            table: "beflyDict",
+            joins: [
+                {
+                    table: "beflyDictType",
+                    on: "beflyDict.typeCode = beflyDictType.code"
+                }
+            ],
+            fields: ["beflyDict.id", "beflyDict.typeCode", "beflyDict.key", "beflyDict.label", "beflyDict.sort", "beflyDict.remark", "beflyDict.createdAt", "beflyDict.updatedAt", "beflyDictType.name AS typeName"],
+            where: { "beflyDict.id": ctx.body.id }
+        });
+
+        if (!dict.data || !dict.data.id) {
+            return befly.tool.No("字典项不存在");
+        }
+
+        return befly.tool.Yes("获取成功", dict.data);
+    }
+};

package/apis/dict/ins.js

@@ -0,0 +1,51 @@
+import adminDictTable from "../../tables/dict.json";
+
+export default {
+    name: "添加字典",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {
+        typeCode: adminDictTable.typeCode,
+        key: adminDictTable.key,
+        label: adminDictTable.label,
+        sort: adminDictTable.sort,
+        remark: adminDictTable.remark
+    },
+    required: ["typeCode", "key", "label"],
+    handler: async (befly, ctx) => {
+        const dictType = await befly.mysql.getOne({
+            table: "beflyDictType",
+            where: { code: ctx.body.typeCode }
+        });
+
+        if (!dictType.data || !dictType.data.id) {
+            return befly.tool.No("字典类型不存在");
+        }
+
+        const existing = await befly.mysql.getOne({
+            table: "beflyDict",
+            where: {
+                typeCode: ctx.body.typeCode,
+                key: ctx.body.key
+            }
+        });
+
+        if (existing.data && existing.data.id) {
+            return befly.tool.No("该类型下已存在相同的键名");
+        }
+
+        const dictId = await befly.mysql.insData({
+            table: "beflyDict",
+            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.data });
+    }
+};

package/apis/dict/items.js

@@ -0,0 +1,30 @@
+import dictTable from "../../tables/dict.json";
+
+export default {
+    name: "获取字典项列表",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {
+        typeCode: dictTable.typeCode
+    },
+    required: ["typeCode"],
+    handler: async (befly, ctx) => {
+        const dictType = await befly.mysql.getOne({
+            table: "beflyDictType",
+            where: { code: ctx.body.typeCode }
+        });
+
+        if (!dictType.data || !dictType.data.id) {
+            return befly.tool.No("字典类型不存在");
+        }
+
+        const items = await befly.mysql.getAll({
+            table: "beflyDict",
+            where: { typeCode: ctx.body.typeCode },
+            orderBy: ["sort#ASC", "id#ASC"]
+        });
+
+        return befly.tool.Yes("获取成功", items.data);
+    }
+};

package/apis/dict/list.js

@@ -0,0 +1,36 @@
+import dictTable from "../../tables/dict.json";
+
+export default {
+    name: "获取字典列表",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {
+        page: { name: "页码", input: "integer", min: 1, max: 9999 },
+        limit: { name: "每页数量", input: "integer", min: 1, max: 100 },
+        typeCode: dictTable.typeCode,
+        keyword: { name: "关键词", input: "string", min: 0, max: 50 }
+    },
+    required: [],
+    handler: async (befly, ctx) => {
+        const result = await befly.mysql.getList({
+            table: "beflyDict",
+            joins: [
+                {
+                    table: "beflyDictType",
+                    on: "beflyDict.typeCode = beflyDictType.code"
+                }
+            ],
+            fields: ["beflyDict.id", "beflyDict.typeCode", "beflyDict.key", "beflyDict.label", "beflyDict.sort", "beflyDict.remark", "beflyDict.createdAt", "beflyDict.updatedAt", "beflyDictType.name AS typeName"],
+            where: {
+                "beflyDict.typeCode": ctx.body.typeCode,
+                $or: [{ "beflyDict.key$like": `%${ctx.body.keyword}%` }, { "beflyDict.label$like": `%${ctx.body.keyword}%` }]
+            },
+            page: ctx.body.page,
+            limit: ctx.body.limit,
+            orderBy: ["beflyDict.sort#ASC", "beflyDict.id#ASC"]
+        });
+
+        return befly.tool.Yes("获取成功", result.data);
+    }
+};

package/apis/dict/upd.js

@@ -0,0 +1,74 @@
+import adminDictTable from "../../tables/dict.json";
+
+export default {
+    name: "更新字典",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {
+        id: { name: "ID", input: "integer", min: 1, max: null },
+        typeCode: adminDictTable.typeCode,
+        key: adminDictTable.key,
+        label: adminDictTable.label,
+        sort: adminDictTable.sort,
+        remark: adminDictTable.remark
+    },
+    required: ["id"],
+    handler: async (befly, ctx) => {
+        const id = ctx.body.id;
+        const typeCode = ctx.body.typeCode;
+        const key = ctx.body.key;
+        const label = ctx.body.label;
+        const sort = ctx.body.sort;
+        const remark = ctx.body.remark;
+
+        if (typeCode) {
+            const dictType = await befly.mysql.getOne({
+                table: "beflyDictType",
+                where: { code: typeCode }
+            });
+
+            if (!dictType.data || !dictType.data.id) {
+                return befly.tool.No("字典类型不存在");
+            }
+        }
+
+        if (typeCode || key) {
+            const current = await befly.mysql.getOne({
+                table: "beflyDict",
+                where: { id: id }
+            });
+
+            const checkTypeCode = typeCode || (current.data ? current.data.typeCode : undefined);
+            const checkKey = key || (current.data ? current.data.key : undefined);
+
+            const existing = await befly.mysql.getOne({
+                table: "beflyDict",
+                where: {
+                    typeCode: checkTypeCode,
+                    key: checkKey,
+                    id$ne: id
+                }
+            });
+
+            if (existing.data && existing.data.id) {
+                return befly.tool.No("该类型下已存在相同的键名");
+            }
+        }
+
+        const updateData = {};
+        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.mysql.updData({
+            table: "beflyDict",
+            data: updateData,
+            where: { id: id }
+        });
+
+        return befly.tool.Yes("更新成功");
+    }
+};

package/apis/dictType/all.js

@@ -0,0 +1,16 @@
+export default {
+    name: "获取所有字典类型",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        const result = await befly.mysql.getAll({
+            table: "beflyDictType",
+            orderBy: ["sort#ASC", "id#ASC"]
+        });
+
+        return befly.tool.Yes("操作成功", { lists: result.data.lists });
+    }
+};

package/apis/dictType/del.js

@@ -0,0 +1,38 @@
+export default {
+    name: "删除字典类型",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: { id: { name: "ID", input: "integer", min: 1, max: null } },
+    required: ["id"],
+    handler: async (befly, ctx) => {
+        const id = ctx.body.id;
+
+        const dictType = await befly.mysql.getOne({
+            table: "beflyDictType",
+            where: { id: id }
+        });
+
+        if (!dictType.data || !dictType.data.code) {
+            return befly.tool.No("字典类型不存在");
+        }
+
+        const dictItems = await befly.mysql.getOne({
+            table: "beflyDict",
+            where: {
+                typeCode: dictType.data.code
+            }
+        });
+
+        if (dictItems.data && dictItems.data.id) {
+            return befly.tool.No("该类型下存在字典项，无法删除");
+        }
+
+        await befly.mysql.delData({
+            table: "beflyDictType",
+            where: { id: id }
+        });
+
+        return befly.tool.Yes("删除成功");
+    }
+};

package/apis/dictType/detail.js

@@ -0,0 +1,20 @@
+export default {
+    name: "字典类型详情",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: { id: { name: "ID", input: "integer", min: 1, max: null } },
+    required: ["id"],
+    handler: async (befly, ctx) => {
+        const detail = await befly.mysql.getOne({
+            table: "beflyDictType",
+            where: { id: ctx.body.id }
+        });
+
+        if (!detail.data || !detail.data.id) {
+            return befly.tool.No("字典类型不存在");
+        }
+
+        return befly.tool.Yes("获取成功", detail.data);
+    }
+};

package/apis/dictType/ins.js

@@ -0,0 +1,37 @@
+import dictTypeTable from "../../tables/dictType.json";
+
+export default {
+    name: "添加字典类型",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {
+        code: dictTypeTable.code,
+        name: dictTypeTable.name,
+        description: dictTypeTable.description,
+        sort: dictTypeTable.sort
+    },
+    required: ["code", "name"],
+    handler: async (befly, ctx) => {
+        const existing = await befly.mysql.getOne({
+            table: "beflyDictType",
+            where: { code: ctx.body.code }
+        });
+
+        if (existing.data && existing.data.id) {
+            return befly.tool.No("类型代码已存在");
+        }
+
+        const typeId = await befly.mysql.insData({
+            table: "beflyDictType",
+            data: {
+                code: ctx.body.code,
+                name: ctx.body.name,
+                description: ctx.body.description,
+                sort: ctx.body.sort
+            }
+        });
+
+        return befly.tool.Yes("添加成功", { id: typeId.data });
+    }
+};

package/apis/dictType/list.js

@@ -0,0 +1,26 @@
+export default {
+    name: "获取字典类型列表",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {
+        page: { name: "页码", input: "integer", min: 1, max: 9999 },
+        limit: { name: "每页数量", input: "integer", min: 1, max: 100 },
+        keyword: { name: "关键词", input: "string", min: 0, max: 50 },
+        state: { name: "状态", input: "integer", min: 0, max: 2 }
+    },
+    required: [],
+    handler: async (befly, ctx) => {
+        const result = await befly.mysql.getList({
+            table: "beflyDictType",
+            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.data);
+    }
+};