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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AuthLogController = void 0;
const authLog_1 = require("../models/authLog");
const helpers_1 = require("../utils/helpers");
class AuthLogController {
    static async getAllAuthLogs(req, res) {
        try {
            const page = Number(req.query.page) || 1;
            const limit = Number(req.query.limit) || 20;
            const offset = (page - 1) * limit;
            const authLogs = await authLog_1.AuthLogModel.getAll(limit, offset);
            const total = await authLog_1.AuthLogModel.getCount();
            res.status(200).json({
                success: true,
                data: authLogs,
                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 getAuthLogById(req, res) {
        try {
            const { id } = req.params;
            if (!id || isNaN(Number(id))) {
                res.status(400).json({
                    success: false,
                    message: '无效的ID'
                });
                return;
            }
            const authLog = await authLog_1.AuthLogModel.getById(Number(id));
            if (!authLog) {
                res.status(404).json({
                    success: false,
                    message: '认证日志不存在'
                });
                return;
            }
            res.status(200).json({
                success: true,
                data: authLog
            });
        }
        catch (error) {
            console.error('获取认证日志失败:', error);
            res.status(500).json({
                success: false,
                message: '获取认证日志失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async getAuthLogsByClientId(req, res) {
        try {
            const { clientid } = req.params;
            const page = Number(req.query.page) || 1;
            const limit = Number(req.query.limit) || 20;
            const offset = (page - 1) * limit;
            const clientidStr = (0, helpers_1.toString)(clientid);
            if (!clientidStr) {
                res.status(400).json({
                    success: false,
                    message: '客户端ID不能为空'
                });
                return;
            }
            const authLogs = await authLog_1.AuthLogModel.getByClientid(clientidStr, limit, offset);
            const total = await authLog_1.AuthLogModel.getCountByClientid(clientidStr);
            res.status(200).json({
                success: true,
                data: authLogs,
                pagination: {
                    page,
                    limit,
                    total,
                    pages: Math.ceil(total / limit)
                }
            });
        }
        catch (error) {
            console.error('根据客户端ID获取认证日志失败:', error);
            res.status(500).json({
                success: false,
                message: '根据客户端ID获取认证日志失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async getAuthLogsByUsername(req, res) {
        try {
            const { username } = req.params;
            const page = Number(req.query.page) || 1;
            const limit = Number(req.query.limit) || 20;
            const offset = (page - 1) * limit;
            const usernameStr = (0, helpers_1.toString)(username);
            if (!usernameStr) {
                res.status(400).json({
                    success: false,
                    message: '用户名不能为空'
                });
                return;
            }
            const authLogs = await authLog_1.AuthLogModel.getByUsername(usernameStr, limit, offset);
            const total = await authLog_1.AuthLogModel.getCountByUsername(usernameStr);
            res.status(200).json({
                success: true,
                data: authLogs,
                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 getAuthLogsByIpAddress(req, res) {
        try {
            const { ipAddress } = req.params;
            const page = Number(req.query.page) || 1;
            const limit = Number(req.query.limit) || 20;
            const offset = (page - 1) * limit;
            const ipAddressStr = (0, helpers_1.toString)(ipAddress);
            if (!ipAddressStr) {
                res.status(400).json({
                    success: false,
                    message: 'IP地址不能为空'
                });
                return;
            }
            const authLogs = await authLog_1.AuthLogModel.getByIpAddress(ipAddressStr, limit, offset);
            const total = await authLog_1.AuthLogModel.getCountByIpAddress(ipAddressStr);
            res.status(200).json({
                success: true,
                data: authLogs,
                pagination: {
                    page,
                    limit,
                    total,
                    pages: Math.ceil(total / limit)
                }
            });
        }
        catch (error) {
            console.error('根据IP地址获取认证日志失败:', error);
            res.status(500).json({
                success: false,
                message: '根据IP地址获取认证日志失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async getAuthLogsByOperationType(req, res) {
        try {
            const { operationType } = req.params;
            const page = Number(req.query.page) || 1;
            const limit = Number(req.query.limit) || 20;
            const offset = (page - 1) * limit;
            const operationTypeStr = (0, helpers_1.toString)(operationType);
            if (!operationTypeStr) {
                res.status(400).json({
                    success: false,
                    message: '操作类型不能为空'
                });
                return;
            }
            if (!['connect', 'publish', 'subscribe', 'disconnect'].includes(operationTypeStr)) {
                res.status(400).json({
                    success: false,
                    message: '操作类型必须是connect、publish、subscribe或disconnect之一'
                });
                return;
            }
            const authLogs = await authLog_1.AuthLogModel.getByOperationType(operationTypeStr, limit, offset);
            const total = await authLog_1.AuthLogModel.getCountByOperationType(operationTypeStr);
            res.status(200).json({
                success: true,
                data: authLogs,
                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 getAuthLogsByResult(req, res) {
        try {
            const result = (0, helpers_1.toString)(req.params.result);
            const page = Number(req.query.page) || 1;
            const limit = Number(req.query.limit) || 20;
            const offset = (page - 1) * limit;
            if (!result) {
                res.status(400).json({
                    success: false,
                    message: '结果不能为空'
                });
                return;
            }
            if (!['success', 'failure'].includes(result)) {
                res.status(400).json({
                    success: false,
                    message: '结果必须是success或failure之一'
                });
                return;
            }
            const authLogs = await authLog_1.AuthLogModel.getByResult(result, limit, offset);
            const total = await authLog_1.AuthLogModel.getCountByResult(result);
            res.status(200).json({
                success: true,
                data: authLogs,
                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 getAuthLogsByTimeRange(req, res) {
        try {
            const { start_time, end_time } = req.query;
            const page = Number(req.query.page) || 1;
            const limit = Number(req.query.limit) || 20;
            const offset = (page - 1) * limit;
            if (!start_time || !end_time) {
                res.status(400).json({
                    success: false,
                    message: '开始时间和结束时间不能为空'
                });
                return;
            }
            const startDate = new Date(start_time);
            const endDate = new Date(end_time);
            if (isNaN(startDate.getTime()) || isNaN(endDate.getTime())) {
                res.status(400).json({
                    success: false,
                    message: '无效的时间格式'
                });
                return;
            }
            if (startDate >= endDate) {
                res.status(400).json({
                    success: false,
                    message: '开始时间必须早于结束时间'
                });
                return;
            }
            const authLogs = await authLog_1.AuthLogModel.getByTimeRange(startDate, endDate, limit, offset);
            const total = await authLog_1.AuthLogModel.getCountByTimeRange(startDate, endDate);
            res.status(200).json({
                success: true,
                data: authLogs,
                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 getAuthLogsByMultipleConditions(req, res) {
        try {
            const { clientid, username, ip_address, operation_type, result, start_time, end_time } = req.query;
            const page = Number(req.query.page) || 1;
            const limit = Number(req.query.limit) || 20;
            const offset = (page - 1) * limit;
            const conditions = {};
            if (clientid !== undefined && clientid !== '')
                conditions.clientid = clientid;
            if (username !== undefined && username !== '')
                conditions.username = username;
            if (ip_address !== undefined && ip_address !== '')
                conditions.ip_address = ip_address;
            if (operation_type !== undefined && operation_type !== '') {
                if (!['connect', 'publish', 'subscribe', 'disconnect'].includes(operation_type)) {
                    res.status(400).json({
                        success: false,
                        message: '操作类型必须是connect、publish、subscribe或disconnect之一'
                    });
                    return;
                }
                conditions.operation_type = operation_type;
            }
            if (result !== undefined && result !== '') {
                if (!['success', 'failure'].includes(result)) {
                    res.status(400).json({
                        success: false,
                        message: '结果必须是success或failure之一'
                    });
                    return;
                }
                conditions.result = result;
            }
            let startDate, endDate;
            if (start_time && end_time) {
                startDate = new Date(start_time);
                endDate = new Date(end_time);
                if (isNaN(startDate.getTime()) || isNaN(endDate.getTime())) {
                    res.status(400).json({
                        success: false,
                        message: '无效的时间格式'
                    });
                    return;
                }
                if (startDate >= endDate) {
                    res.status(400).json({
                        success: false,
                        message: '开始时间必须早于结束时间'
                    });
                    return;
                }
            }
            const fuzzyFields = ['clientid', 'username', 'ip_address'];
            const authLogs = await authLog_1.AuthLogModel.getByMultipleConditions(conditions, startDate, endDate, limit, offset, fuzzyFields);
            const total = await authLog_1.AuthLogModel.getCountByMultipleConditions(conditions, startDate, endDate, fuzzyFields);
            res.status(200).json({
                success: true,
                data: authLogs,
                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 getAuthLogStats(req, res) {
        try {
            const stats = await authLog_1.AuthLogModel.getFullStats();
            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 : '未知错误'
            });
        }
    }
    static async getRecentAuthLogs(req, res) {
        try {
            const limit = Number(req.query.limit) || 10;
            if (limit > 100) {
                res.status(400).json({
                    success: false,
                    message: '限制数量不能超过100'
                });
                return;
            }
            const authLogs = await authLog_1.AuthLogModel.getRecent(limit);
            res.status(200).json({
                success: true,
                data: authLogs,
                message: '获取最近认证日志成功'
            });
        }
        catch (error) {
            console.error('获取最近认证日志失败:', error);
            res.status(500).json({
                success: false,
                message: '获取最近认证日志失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
    static async cleanupOldAuthLogs(req, res) {
        try {
            const { days } = req.query;
            let daysToDelete = days;
            if (!daysToDelete && req.body && req.body.days) {
                daysToDelete = req.body.days;
            }
            if (!daysToDelete || isNaN(Number(daysToDelete)) || Number(daysToDelete) < 1) {
                res.status(400).json({
                    success: false,
                    message: '请提供有效的天数（大于0的数字）'
                });
                return;
            }
            const deletedCount = await authLog_1.AuthLogModel.cleanupOldLogs(Number(daysToDelete));
            res.status(200).json({
                success: true,
                data: { deletedCount },
                message: `成功清理${deletedCount}条${daysToDelete}天前的认证日志`
            });
        }
        catch (error) {
            console.error('清理旧认证日志失败:', error);
            res.status(500).json({
                success: false,
                message: '清理旧认证日志失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    }
}
exports.AuthLogController = AuthLogController;
//# sourceMappingURL=authLogController.js.map