352 lines
8.9 KiB
JavaScript
352 lines
8.9 KiB
JavaScript
const { UsersAuth, UserProfile } = require('../models');
|
|
const bcrypt = require('bcrypt');
|
|
const jwt = require('jsonwebtoken');
|
|
const crypto = require('crypto');
|
|
|
|
// JWT Secret - nên lưu trong environment variable
|
|
const JWT_SECRET = process.env.JWT_SECRET || 'sena-secret-key-2026';
|
|
const JWT_EXPIRES_IN = '24h';
|
|
|
|
/**
|
|
* Auth Controller - Xác thực và phân quyền
|
|
*/
|
|
class AuthController {
|
|
/**
|
|
* Login - Xác thực người dùng
|
|
*/
|
|
async login(req, res, next) {
|
|
try {
|
|
const { username, password } = req.body;
|
|
|
|
// Validate input
|
|
if (!username || !password) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: 'Username và password là bắt buộc',
|
|
});
|
|
}
|
|
|
|
// Tìm user theo username hoặc email
|
|
const user = await UsersAuth.findOne({
|
|
where: {
|
|
[require('sequelize').Op.or]: [
|
|
{ username: username },
|
|
{ email: username },
|
|
],
|
|
},
|
|
include: [{
|
|
model: UserProfile,
|
|
as: 'profile',
|
|
}],
|
|
});
|
|
|
|
if (!user) {
|
|
return res.status(401).json({
|
|
success: false,
|
|
message: 'Username hoặc password không đúng',
|
|
});
|
|
}
|
|
|
|
// Kiểm tra tài khoản có bị khóa không
|
|
if (user.is_locked) {
|
|
if (user.locked_until && new Date() < new Date(user.locked_until)) {
|
|
return res.status(403).json({
|
|
success: false,
|
|
message: 'Tài khoản bị khóa đến ' + user.locked_until,
|
|
});
|
|
} else {
|
|
// Mở khóa nếu hết thời gian khóa
|
|
await user.update({
|
|
is_locked: false,
|
|
locked_until: null,
|
|
failed_login_attempts: 0
|
|
});
|
|
}
|
|
}
|
|
|
|
// Kiểm tra tài khoản có active không
|
|
if (!user.is_active) {
|
|
return res.status(403).json({
|
|
success: false,
|
|
message: 'Tài khoản đã bị vô hiệu hóa',
|
|
});
|
|
}
|
|
|
|
// Verify password
|
|
const passwordMatch = await bcrypt.compare(password + user.salt, user.password_hash);
|
|
|
|
if (!passwordMatch) {
|
|
// Tăng số lần đăng nhập thất bại
|
|
const failedAttempts = user.failed_login_attempts + 1;
|
|
const updates = { failed_login_attempts: failedAttempts };
|
|
|
|
// Khóa tài khoản sau 5 lần thất bại
|
|
if (failedAttempts >= 5) {
|
|
updates.is_locked = true;
|
|
updates.locked_until = new Date(Date.now() + 30 * 60 * 1000); // Khóa 30 phút
|
|
}
|
|
|
|
await user.update(updates);
|
|
|
|
return res.status(401).json({
|
|
success: false,
|
|
message: 'Username hoặc password không đúng',
|
|
attemptsLeft: Math.max(0, 5 - failedAttempts),
|
|
});
|
|
}
|
|
|
|
// Đăng nhập thành công - Reset failed attempts
|
|
const sessionId = crypto.randomUUID();
|
|
const clientIp = req.ip || req.connection.remoteAddress;
|
|
|
|
await user.update({
|
|
failed_login_attempts: 0,
|
|
login_count: user.login_count + 1,
|
|
last_login: new Date(),
|
|
last_login_ip: clientIp,
|
|
current_session_id: sessionId,
|
|
});
|
|
|
|
// Tạo JWT token
|
|
const token = jwt.sign(
|
|
{
|
|
userId: user.id,
|
|
username: user.username,
|
|
email: user.email,
|
|
sessionId: sessionId,
|
|
},
|
|
JWT_SECRET,
|
|
{ expiresIn: JWT_EXPIRES_IN }
|
|
);
|
|
|
|
// Return success response
|
|
res.json({
|
|
success: true,
|
|
message: 'Đăng nhập thành công',
|
|
data: {
|
|
token,
|
|
user: {
|
|
id: user.id,
|
|
username: user.username,
|
|
email: user.email,
|
|
profile: user.profile,
|
|
last_login: user.last_login,
|
|
login_count: user.login_count,
|
|
},
|
|
},
|
|
});
|
|
} catch (error) {
|
|
next(error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register - Tạo tài khoản mới
|
|
*/
|
|
async register(req, res, next) {
|
|
try {
|
|
const { username, email, password, full_name, phone, school_id } = req.body;
|
|
|
|
// Validate input
|
|
if (!username || !email || !password) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: 'Username, email và password là bắt buộc',
|
|
});
|
|
}
|
|
|
|
// Kiểm tra username đã tồn tại
|
|
const existingUser = await UsersAuth.findOne({
|
|
where: {
|
|
[require('sequelize').Op.or]: [
|
|
{ username },
|
|
{ email },
|
|
],
|
|
},
|
|
});
|
|
|
|
if (existingUser) {
|
|
return res.status(409).json({
|
|
success: false,
|
|
message: 'Username hoặc email đã tồn tại',
|
|
});
|
|
}
|
|
|
|
// Hash password
|
|
const salt = crypto.randomBytes(16).toString('hex');
|
|
const passwordHash = await bcrypt.hash(password + salt, 10);
|
|
|
|
// Tạo user mới
|
|
const newUser = await UsersAuth.create({
|
|
username,
|
|
email,
|
|
password_hash: passwordHash,
|
|
salt,
|
|
qr_secret: crypto.randomBytes(32).toString('hex'),
|
|
});
|
|
|
|
// Tạo profile nếu có thông tin
|
|
if (full_name || phone || school_id) {
|
|
await UserProfile.create({
|
|
user_id: newUser.id,
|
|
full_name: full_name || username,
|
|
phone,
|
|
school_id,
|
|
});
|
|
}
|
|
|
|
res.status(201).json({
|
|
success: true,
|
|
message: 'Đăng ký tài khoản thành công',
|
|
data: {
|
|
id: newUser.id,
|
|
username: newUser.username,
|
|
email: newUser.email,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
next(error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify Token - Xác thực JWT token
|
|
*/
|
|
async verifyToken(req, res, next) {
|
|
try {
|
|
const token = req.headers.authorization?.replace('Bearer ', '');
|
|
|
|
if (!token) {
|
|
return res.status(401).json({
|
|
success: false,
|
|
message: 'Token không được cung cấp',
|
|
});
|
|
}
|
|
|
|
const decoded = jwt.verify(token, JWT_SECRET);
|
|
|
|
// Kiểm tra user còn tồn tại và session hợp lệ
|
|
const user = await UsersAuth.findByPk(decoded.userId, {
|
|
include: [{
|
|
model: UserProfile,
|
|
as: 'profile',
|
|
}],
|
|
});
|
|
|
|
if (!user || !user.is_active) {
|
|
return res.status(401).json({
|
|
success: false,
|
|
message: 'Token không hợp lệ hoặc tài khoản đã bị vô hiệu hóa',
|
|
});
|
|
}
|
|
|
|
if (user.current_session_id !== decoded.sessionId) {
|
|
return res.status(401).json({
|
|
success: false,
|
|
message: 'Phiên đăng nhập đã hết hạn',
|
|
});
|
|
}
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Token hợp lệ',
|
|
data: {
|
|
user: {
|
|
id: user.id,
|
|
username: user.username,
|
|
email: user.email,
|
|
profile: user.profile,
|
|
},
|
|
},
|
|
});
|
|
} catch (error) {
|
|
if (error.name === 'JsonWebTokenError' || error.name === 'TokenExpiredError') {
|
|
return res.status(401).json({
|
|
success: false,
|
|
message: 'Token không hợp lệ hoặc đã hết hạn',
|
|
});
|
|
}
|
|
next(error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Logout - Đăng xuất
|
|
*/
|
|
async logout(req, res, next) {
|
|
try {
|
|
const token = req.headers.authorization?.replace('Bearer ', '');
|
|
|
|
if (!token) {
|
|
return res.status(401).json({
|
|
success: false,
|
|
message: 'Token không được cung cấp',
|
|
});
|
|
}
|
|
|
|
const decoded = jwt.verify(token, JWT_SECRET);
|
|
|
|
// Xóa session hiện tại
|
|
await UsersAuth.update(
|
|
{ current_session_id: null },
|
|
{ where: { id: decoded.userId } }
|
|
);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Đăng xuất thành công',
|
|
});
|
|
} catch (error) {
|
|
next(error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get current user info from token
|
|
*/
|
|
async me(req, res, next) {
|
|
try {
|
|
const token = req.headers.authorization?.replace('Bearer ', '');
|
|
|
|
if (!token) {
|
|
return res.status(401).json({
|
|
success: false,
|
|
message: 'Token không được cung cấp',
|
|
});
|
|
}
|
|
|
|
const decoded = jwt.verify(token, JWT_SECRET);
|
|
|
|
const user = await UsersAuth.findByPk(decoded.userId, {
|
|
include: [{
|
|
model: UserProfile,
|
|
as: 'profile',
|
|
}],
|
|
attributes: { exclude: ['password_hash', 'salt', 'qr_secret'] },
|
|
});
|
|
|
|
if (!user) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: 'User không tồn tại',
|
|
});
|
|
}
|
|
|
|
res.json({
|
|
success: true,
|
|
data: user,
|
|
});
|
|
} catch (error) {
|
|
if (error.name === 'JsonWebTokenError' || error.name === 'TokenExpiredError') {
|
|
return res.status(401).json({
|
|
success: false,
|
|
message: 'Token không hợp lệ hoặc đã hết hạn',
|
|
});
|
|
}
|
|
next(error);
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = new AuthController();
|