MQTTvue/mqtt-vue-dashboard/server/dist/controllers/clientAclController.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ClientAclController = void 0;
const clientAcl_1 = require("../models/clientAcl");
const helpers_1 = require("../utils/helpers");
class ClientAclController {
    static async getAllClientAcl(req, res) {
        try {
            const page = Number(req.query.page) || 1;
            const limit = Number(req.query.limit) || 20;
            const offset = (page - 1) * limit;
            const clientAcls = await clientAcl_1.ClientAclModel.getAll(limit, offset);
            const total = await clientAcl_1.ClientAclModel.getCount();
            res.status(200).json({
                success: true,
                data: clientAcls,
                pagination: {
                    page,
                    limit,
                    total,
                    pages: Math.ceil(total / limit)
                }
            });
        }
        catch (error) {
            console.error('获取客户端授权规则列表失败:', error);
            res.status(500).json({
                success: false,
                message: '获取客户端授权规则列表失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async getClientAclById(req, res) {
        try {
            const { id } = req.params;
            if (!id || isNaN(Number(id))) {
                res.status(400).json({
                    success: false,
                    message: '无效的ID'
                });
                return;
            }
            const clientAcl = await clientAcl_1.ClientAclModel.getById(Number(id));
            if (!clientAcl) {
                res.status(404).json({
                    success: false,
                    message: '客户端授权规则不存在'
                });
                return;
            }
            res.status(200).json({
                success: true,
                data: clientAcl
            });
        }
        catch (error) {
            console.error('获取客户端授权规则失败:', error);
            res.status(500).json({
                success: false,
                message: '获取客户端授权规则失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async getClientAclByUsername(req, res) {
        try {
            const { username } = req.params;
            const usernameStr = (0, helpers_1.toString)(username);
            if (!usernameStr) {
                res.status(400).json({
                    success: false,
                    message: '用户名不能为空'
                });
                return;
            }
            const clientAcls = await clientAcl_1.ClientAclModel.getByUsername(usernameStr);
            res.status(200).json({
                success: true,
                data: clientAcls
            });
        }
        catch (error) {
            console.error('根据用户名获取授权规则失败:', error);
            res.status(500).json({
                success: false,
                message: '根据用户名获取授权规则失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async getClientAclByTopic(req, res) {
        try {
            const { topic } = req.params;
            const topicStr = (0, helpers_1.toString)(topic);
            if (!topicStr) {
                res.status(400).json({
                    success: false,
                    message: '主题不能为空'
                });
                return;
            }
            const clientAcls = await clientAcl_1.ClientAclModel.getByTopic(topicStr);
            res.status(200).json({
                success: true,
                data: clientAcls
            });
        }
        catch (error) {
            console.error('根据主题获取授权规则失败:', error);
            res.status(500).json({
                success: false,
                message: '根据主题获取授权规则失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async createClientAcl(req, res) {
        try {
            const { clientid, username, topic, action, permission, priority, description } = req.body;
            if (!username || !topic || !action || !permission) {
                res.status(400).json({
                    success: false,
                    message: '用户名、主题、操作和权限不能为空'
                });
                return;
            }
            if (!['publish', 'subscribe', 'pubsub'].includes(action)) {
                res.status(400).json({
                    success: false,
                    message: '操作必须是publish、subscribe或pubsub之一'
                });
                return;
            }
            if (!['allow', 'deny'].includes(permission)) {
                res.status(400).json({
                    success: false,
                    message: '权限必须是allow或deny之一'
                });
                return;
            }
            const newClientAcl = await clientAcl_1.ClientAclModel.create({
                clientid: clientid || null,
                username,
                topic,
                action,
                permission,
                priority: priority || 0,
                description: description || null
            });
            res.status(201).json({
                success: true,
                data: newClientAcl,
                message: '客户端授权规则创建成功'
            });
        }
        catch (error) {
            console.error('创建客户端授权规则失败:', error);
            res.status(500).json({
                success: false,
                message: '创建客户端授权规则失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async updateClientAcl(req, res) {
        try {
            const { id } = req.params;
            const { username, topic, action, permission, priority, description } = req.body;
            if (!id || isNaN(Number(id))) {
                res.status(400).json({
                    success: false,
                    message: '无效的ID'
                });
                return;
            }
            const existingClientAcl = await clientAcl_1.ClientAclModel.getById(Number(id));
            if (!existingClientAcl) {
                res.status(404).json({
                    success: false,
                    message: '客户端授权规则不存在'
                });
                return;
            }
            if (action && !['publish', 'subscribe', 'pubsub'].includes(action)) {
                res.status(400).json({
                    success: false,
                    message: '操作必须是publish、subscribe或pubsub之一'
                });
                return;
            }
            if (permission && !['allow', 'deny'].includes(permission)) {
                res.status(400).json({
                    success: false,
                    message: '权限必须是allow或deny之一'
                });
                return;
            }
            const updatedClientAcl = await clientAcl_1.ClientAclModel.update(Number(id), {
                username,
                topic,
                action,
                permission,
                priority,
                description
            });
            res.status(200).json({
                success: true,
                data: updatedClientAcl,
                message: '客户端授权规则更新成功'
            });
        }
        catch (error) {
            console.error('更新客户端授权规则失败:', error);
            res.status(500).json({
                success: false,
                message: '更新客户端授权规则失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async deleteClientAcl(req, res) {
        try {
            const { id } = req.params;
            if (!id || isNaN(Number(id))) {
                res.status(400).json({
                    success: false,
                    message: '无效的ID'
                });
                return;
            }
            const existingClientAcl = await clientAcl_1.ClientAclModel.getById(Number(id));
            if (!existingClientAcl) {
                res.status(404).json({
                    success: false,
                    message: '客户端授权规则不存在'
                });
                return;
            }
            await clientAcl_1.ClientAclModel.delete(Number(id));
            res.status(200).json({
                success: true,
                message: '客户端授权规则删除成功'
            });
        }
        catch (error) {
            console.error('删除客户端授权规则失败:', error);
            res.status(500).json({
                success: false,
                message: '删除客户端授权规则失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async deleteMultipleClientAcl(req, res) {
        try {
            const { ids } = req.body;
            if (!ids || !Array.isArray(ids) || ids.length === 0) {
                res.status(400).json({
                    success: false,
                    message: '请提供有效的ID列表'
                });
                return;
            }
            const validIds = ids.filter(id => !isNaN(Number(id)));
            if (validIds.length !== ids.length) {
                res.status(400).json({
                    success: false,
                    message: 'ID列表包含无效的ID'
                });
                return;
            }
            await clientAcl_1.ClientAclModel.deleteMultiple(validIds.map(id => Number(id)));
            res.status(200).json({
                success: true,
                message: `成功删除${validIds.length}条客户端授权规则`
            });
        }
        catch (error) {
            console.error('批量删除客户端授权规则失败:', error);
            res.status(500).json({
                success: false,
                message: '批量删除客户端授权规则失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async getClientAclByUsernameAndAction(req, res) {
        try {
            const { username, action } = req.params;
            const usernameStr = (0, helpers_1.toString)(username);
            const actionStr = (0, helpers_1.toString)(action);
            if (!usernameStr || !actionStr) {
                res.status(400).json({
                    success: false,
                    message: '用户名和操作类型不能为空'
                });
                return;
            }
            if (!['publish', 'subscribe', 'pubsub'].includes(actionStr)) {
                res.status(400).json({
                    success: false,
                    message: '操作必须是publish、subscribe或pubsub之一'
                });
                return;
            }
            const clientAcls = await clientAcl_1.ClientAclModel.getByUsernameAndAction(usernameStr, actionStr);
            res.status(200).json({
                success: true,
                data: clientAcls
            });
        }
        catch (error) {
            console.error('根据用户名和操作类型获取授权规则失败:', error);
            res.status(500).json({
                success: false,
                message: '根据用户名和操作类型获取授权规则失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async checkUserPermission(req, res) {
        try {
            const { username, topic, action } = req.body;
            if (!username || !topic || !action) {
                res.status(400).json({
                    success: false,
                    message: '用户名、主题和操作类型不能为空'
                });
                return;
            }
            if (!['publish', 'subscribe'].includes(action)) {
                res.status(400).json({
                    success: false,
                    message: '操作必须是publish或subscribe之一'
                });
                return;
            }
            const hasPermission = await clientAcl_1.ClientAclModel.checkPermission(username, topic, action);
            res.status(200).json({
                success: true,
                data: {
                    username,
                    topic,
                    action,
                    hasPermission
                },
                message: `用户${hasPermission ? '有' : '没有'}权限${action === 'publish' ? '发布到' : '订阅'}主题${topic}`
            });
        }
        catch (error) {
            console.error('检查用户权限失败:', error);
            res.status(500).json({
                success: false,
                message: '检查用户权限失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async getClientAclStats(req, res) {
        try {
            const stats = await clientAcl_1.ClientAclModel.getPermissionStats();
            res.status(200).json({
                success: true,
                data: stats,
                message: '获取客户端授权统计信息成功'
            });
        }
        catch (error) {
            console.error('获取客户端授权统计信息失败:', error);
            res.status(500).json({
                success: false,
                message: '获取客户端授权统计信息失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
}
exports.ClientAclController = ClientAclController;
//# sourceMappingURL=clientAclController.js.map