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

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AuthController = void 0;
const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
const bcryptjs_1 = __importDefault(require("bcryptjs"));
const errorHandler_1 = require("../middleware/errorHandler");
const user_1 = require("../models/user");
const loggerService_1 = require("../services/loggerService");
class AuthController {
    static async login(req, res) {
        try {
            const { username, password } = req.body;
            if (!username || !password) {
                throw new errorHandler_1.AppError('用户名和密码不能为空', 400);
            }
            const user = await user_1.UserModel.getByUsername(username);
            if (!user) {
                loggerService_1.LoggerService.warn('用户登录失败 - 用户不存在', {
                    source: 'auth',
                    module: 'login',
                    details: JSON.stringify({
                        username,
                        ip: req.ip,
                        userAgent: req.get('user-agent')
                    })
                }).catch(err => {
                    console.error('登录失败日志写入失败:', err);
                });
                throw new errorHandler_1.AppError('用户名或密码错误', 401);
            }
            const isPasswordValid = await bcryptjs_1.default.compare(password, user.password);
            if (!isPasswordValid) {
                loggerService_1.LoggerService.warn('用户登录失败 - 密码错误', {
                    source: 'auth',
                    module: 'login',
                    details: JSON.stringify({
                        username,
                        userId: user.id,
                        ip: req.ip,
                        userAgent: req.get('user-agent')
                    })
                }).catch(err => {
                    console.error('登录失败日志写入失败:', err);
                });
                throw new errorHandler_1.AppError('用户名或密码错误', 401);
            }
            const token = jsonwebtoken_1.default.sign({ id: user.id, username: user.username, role: user.role }, process.env.JWT_SECRET || 'mqtt_dashboard_jwt_secret_key_2024', { expiresIn: '7d' });
            loggerService_1.LoggerService.info('用户登录成功', {
                source: 'auth',
                module: 'login',
                details: JSON.stringify({
                    userId: user.id,
                    username: user.username,
                    role: user.role,
                    ip: req.ip,
                    userAgent: req.get('user-agent')
                })
            }).catch(err => {
                console.error('登录成功日志写入失败:', err);
            });
            res.status(200).json({
                success: true,
                message: '登录成功',
                data: {
                    user: {
                        id: user.id,
                        username: user.username,
                        role: user.role,
                        created_at: user.created_at
                    },
                    token
                }
            });
        }
        catch (error) {
            throw error;
        }
    }
    static async getCurrentUser(req, res) {
        try {
            const userId = req.user?.id;
            if (!userId) {
                throw new errorHandler_1.AppError('用户未登录', 401);
            }
            const user = await user_1.UserModel.getById(userId);
            if (!user) {
                throw new errorHandler_1.AppError('用户不存在', 404);
            }
            res.status(200).json({
                success: true,
                message: '获取用户信息成功',
                data: {
                    id: user.id,
                    username: user.username,
                    role: user.role,
                    created_at: user.created_at
                }
            });
        }
        catch (error) {
            throw error;
        }
    }
    static async register(req, res) {
        try {
            const { username, password, role = 'user' } = req.body;
            if (!username || !password) {
                throw new errorHandler_1.AppError('用户名和密码不能为空', 400);
            }
            const existingUser = await user_1.UserModel.getByUsername(username);
            if (existingUser) {
                loggerService_1.LoggerService.warn('用户注册失败 - 用户名已存在', {
                    source: 'auth',
                    module: 'register',
                    details: JSON.stringify({
                        username,
                        ip: req.ip,
                        userAgent: req.get('user-agent')
                    })
                }).catch(err => {
                    console.error('注册失败日志写入失败:', err);
                });
                throw new errorHandler_1.AppError('用户名已存在', 400);
            }
            const user = await user_1.UserModel.create({
                username,
                password,
                role
            });
            const token = jsonwebtoken_1.default.sign({ id: user.id, username: user.username, role: user.role }, process.env.JWT_SECRET || 'mqtt_dashboard_jwt_secret_key_2024', { expiresIn: '7d' });
            loggerService_1.LoggerService.info('用户注册成功', {
                source: 'auth',
                module: 'register',
                details: JSON.stringify({
                    userId: user.id,
                    username: user.username,
                    role: user.role,
                    ip: req.ip,
                    userAgent: req.get('user-agent')
                })
            }).catch(err => {
                console.error('注册成功日志写入失败:', err);
            });
            res.status(201).json({
                success: true,
                message: '注册成功',
                data: {
                    user: {
                        id: user.id,
                        username: user.username,
                        role: user.role,
                        created_at: user.created_at
                    },
                    token
                }
            });
        }
        catch (error) {
            throw error;
        }
    }
    static async refreshToken(req, res) {
        try {
            const userId = req.user?.id;
            if (!userId) {
                throw new errorHandler_1.AppError('用户未登录', 401);
            }
            const user = await user_1.UserModel.getById(userId);
            if (!user) {
                throw new errorHandler_1.AppError('用户不存在', 404);
            }
            const token = jsonwebtoken_1.default.sign({ id: user.id, username: user.username, role: user.role }, process.env.JWT_SECRET || 'mqtt_dashboard_jwt_secret_key_2024', { expiresIn: '7d' });
            res.status(200).json({
                success: true,
                message: '令牌刷新成功',
                data: {
                    token
                }
            });
        }
        catch (error) {
            throw error;
        }
    }
    static async changePassword(req, res) {
        try {
            const userId = req.user?.id;
            if (!userId) {
                throw new errorHandler_1.AppError('用户未登录', 401);
            }
            const { oldPassword, newPassword } = req.body;
            if (!oldPassword || !newPassword) {
                throw new errorHandler_1.AppError('旧密码和新密码不能为空', 400);
            }
            const user = await user_1.UserModel.getById(userId);
            if (!user) {
                throw new errorHandler_1.AppError('用户不存在', 404);
            }
            const isPasswordValid = await bcryptjs_1.default.compare(oldPassword, user.password);
            if (!isPasswordValid) {
                loggerService_1.LoggerService.warn('修改密码失败 - 旧密码错误', {
                    source: 'auth',
                    module: 'change_password',
                    details: JSON.stringify({
                        userId,
                        username: user.username,
                        ip: req.ip,
                        userAgent: req.get('user-agent')
                    })
                }).catch(err => {
                    console.error('修改密码失败日志写入失败:', err);
                });
                throw new errorHandler_1.AppError('旧密码错误', 401);
            }
            await user_1.UserModel.updatePassword(userId, newPassword);
            loggerService_1.LoggerService.info('用户修改密码成功', {
                source: 'auth',
                module: 'change_password',
                details: JSON.stringify({
                    userId,
                    username: user.username,
                    ip: req.ip,
                    userAgent: req.get('user-agent')
                })
            }).catch(err => {
                console.error('修改密码成功日志写入失败:', err);
            });
            res.status(200).json({
                success: true,
                message: '密码修改成功'
            });
        }
        catch (error) {
            throw error;
        }
    }
    static async getUsers(req, res) {
        try {
            const currentUser = req.user;
            if (!currentUser || currentUser.role !== 'admin') {
                throw new errorHandler_1.AppError('权限不足，只有管理员可以访问', 403);
            }
            const users = await user_1.UserModel.getAll();
            const sanitizedUsers = users.map(user => {
                const { password, ...rest } = user;
                return rest;
            });
            res.status(200).json({
                success: true,
                message: '获取用户列表成功',
                data: sanitizedUsers
            });
        }
        catch (error) {
            throw error;
        }
    }
    static async createUser(req, res) {
        try {
            const currentUser = req.user;
            if (!currentUser || currentUser.role !== 'admin') {
                throw new errorHandler_1.AppError('权限不足，只有管理员可以创建用户', 403);
            }
            const { username, password, role, email } = req.body;
            if (!username || !password || !role) {
                throw new errorHandler_1.AppError('用户名、密码和角色不能为空', 400);
            }
            const existingUser = await user_1.UserModel.getByUsername(username);
            if (existingUser) {
                throw new errorHandler_1.AppError('用户名已存在', 400);
            }
            const user = await user_1.UserModel.create({ username, password, role, email });
            const { password: _, ...sanitizedUser } = user;
            res.status(201).json({
                success: true,
                message: '用户创建成功',
                data: sanitizedUser
            });
        }
        catch (error) {
            throw error;
        }
    }
    static async updateUser(req, res) {
        try {
            const currentUser = req.user;
            if (!currentUser || currentUser.role !== 'admin') {
                throw new errorHandler_1.AppError('权限不足，只有管理员可以更新用户', 403);
            }
            const { id } = req.params;
            const { username, role, email } = req.body;
            if (!id) {
                throw new errorHandler_1.AppError('用户ID不能为空', 400);
            }
            const existingUser = await user_1.UserModel.getById(id);
            if (!existingUser) {
                throw new errorHandler_1.AppError('用户不存在', 404);
            }
            const updatedUser = await user_1.UserModel.update(id, { username, role, email });
            if (!updatedUser) {
                throw new errorHandler_1.AppError('用户更新失败', 500);
            }
            const { password: _, ...sanitizedUser } = updatedUser;
            res.status(200).json({
                success: true,
                message: '用户更新成功',
                data: sanitizedUser
            });
        }
        catch (error) {
            throw error;
        }
    }
    static async deleteUser(req, res) {
        try {
            const currentUser = req.user;
            if (!currentUser || currentUser.role !== 'admin') {
                throw new errorHandler_1.AppError('权限不足，只有管理员可以删除用户', 403);
            }
            const { id } = req.params;
            if (!id) {
                throw new errorHandler_1.AppError('用户ID不能为空', 400);
            }
            const existingUser = await user_1.UserModel.getById(id);
            if (!existingUser) {
                throw new errorHandler_1.AppError('用户不存在', 404);
            }
            if (existingUser.username === 'admin') {
                throw new errorHandler_1.AppError('不允许删除超级管理员用户', 400);
            }
            if (existingUser.id === currentUser.id) {
                throw new errorHandler_1.AppError('不允许删除当前登录用户', 400);
            }
            const success = await user_1.UserModel.delete(Number(id));
            if (!success) {
                throw new errorHandler_1.AppError('用户删除失败', 500);
            }
            res.status(200).json({
                success: true,
                message: '用户删除成功'
            });
        }
        catch (error) {
            throw error;
        }
    }
}
exports.AuthController = AuthController;
//# sourceMappingURL=authController.js.map