380 lines
12 KiB
JavaScript
380 lines
12 KiB
JavaScript
import express from 'express';
|
|
import bcrypt from 'bcrypt';
|
|
import { getDB, getUser, createUser, deleteUser as deleteUserFromDB, getAllUsers, updateUserPassword } from '../services/mongodb.js';
|
|
import { basicAuthMiddleware, createSession, invalidateSession, invalidateUserSessions } from '../middlewares/auth.js';
|
|
import { adminAuthMiddleware } from '../middlewares/adminAuth.js';
|
|
import { combineFingerprint } from '../utils/fingerprint.js';
|
|
|
|
const router = express.Router();
|
|
|
|
// Endpoint de registro (público)
|
|
router.post('/register', async (req, res) => {
|
|
try {
|
|
const db = getDB();
|
|
if (!db) {
|
|
return res.status(500).json({ error: 'MongoDB no está disponible' });
|
|
}
|
|
|
|
const { username, password, email, planId } = req.body;
|
|
|
|
if (!username || !password) {
|
|
return res.status(400).json({ error: 'username y password son requeridos' });
|
|
}
|
|
|
|
if (username.length < 3) {
|
|
return res.status(400).json({ error: 'El nombre de usuario debe tener al menos 3 caracteres' });
|
|
}
|
|
|
|
if (password.length < 6) {
|
|
return res.status(400).json({ error: 'La contraseña debe tener al menos 6 caracteres' });
|
|
}
|
|
|
|
// Validar email si se proporciona
|
|
if (email) {
|
|
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
|
|
if (!emailRegex.test(email)) {
|
|
return res.status(400).json({ error: 'Email no válido' });
|
|
}
|
|
}
|
|
|
|
// Verificar si el usuario ya existe
|
|
const existingUser = await getUser(username);
|
|
if (existingUser) {
|
|
return res.status(409).json({ error: 'El usuario ya existe' });
|
|
}
|
|
|
|
// Verificar si es plan de pago y si Stripe está disponible
|
|
const selectedPlanId = planId || 'free';
|
|
const isPaidPlan = selectedPlanId !== 'free';
|
|
|
|
if (isPaidPlan) {
|
|
// Para planes de pago, verificar que Stripe esté configurado
|
|
const { getStripeClient } = await import('../services/stripe.js');
|
|
const stripeClient = getStripeClient();
|
|
|
|
if (!stripeClient) {
|
|
return res.status(503).json({
|
|
error: 'El sistema de pagos no está disponible actualmente',
|
|
message: 'No se pueden procesar planes de pago en este momento. Por favor, intenta con el plan gratuito o contacta con soporte.'
|
|
});
|
|
}
|
|
}
|
|
|
|
// Hashear contraseña y crear usuario
|
|
const passwordHash = await bcrypt.hash(password, 10);
|
|
await createUser({
|
|
username,
|
|
passwordHash,
|
|
email: email || null,
|
|
role: 'user',
|
|
// Si es plan de pago, marcar como pendiente hasta que se complete el pago
|
|
status: isPaidPlan ? 'pending_payment' : 'active',
|
|
});
|
|
|
|
// Crear suscripción inicial
|
|
const { updateUserSubscription } = await import('../services/mongodb.js');
|
|
await updateUserSubscription(username, {
|
|
planId: selectedPlanId,
|
|
status: isPaidPlan ? 'pending' : 'active',
|
|
currentPeriodStart: new Date(),
|
|
currentPeriodEnd: null,
|
|
cancelAtPeriodEnd: false,
|
|
});
|
|
|
|
console.log(`✅ Usuario registrado: ${username} (${selectedPlanId}) - Estado: ${isPaidPlan ? 'pending_payment' : 'active'}`);
|
|
res.json({
|
|
success: true,
|
|
message: 'Usuario creado correctamente',
|
|
username,
|
|
planId: selectedPlanId,
|
|
requiresPayment: isPaidPlan,
|
|
});
|
|
} catch (error) {
|
|
console.error('Error registrando usuario:', error);
|
|
// Manejar error de duplicado
|
|
if (error.code === 11000) {
|
|
return res.status(409).json({ error: 'El usuario ya existe' });
|
|
}
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Endpoint de login (público)
|
|
router.post('/login', async (req, res) => {
|
|
try {
|
|
const db = getDB();
|
|
if (!db) {
|
|
return res.status(500).json({ error: 'MongoDB no está disponible' });
|
|
}
|
|
|
|
const { username, password, fingerprint: clientFingerprint, deviceInfo: clientDeviceInfo } = req.body;
|
|
|
|
if (!username || !password) {
|
|
return res.status(400).json({ error: 'username y password son requeridos' });
|
|
}
|
|
|
|
// Buscar usuario en MongoDB
|
|
const user = await getUser(username);
|
|
|
|
if (!user) {
|
|
return res.status(401).json({ error: 'Invalid credentials', message: 'Usuario o contraseña incorrectos' });
|
|
}
|
|
|
|
// Obtener hash de la contraseña
|
|
const passwordHash = user.passwordHash;
|
|
|
|
if (!passwordHash) {
|
|
return res.status(401).json({ error: 'Invalid credentials', message: 'Usuario o contraseña incorrectos' });
|
|
}
|
|
|
|
// Verificar contraseña
|
|
const match = await bcrypt.compare(password, passwordHash);
|
|
|
|
if (!match) {
|
|
return res.status(401).json({ error: 'Invalid credentials', message: 'Usuario o contraseña incorrectos' });
|
|
}
|
|
|
|
// Verificar estado del usuario
|
|
if (user.status === 'pending_payment') {
|
|
return res.status(403).json({
|
|
error: 'Payment pending',
|
|
message: 'Tu cuenta está pendiente de pago. Por favor, completa el proceso de pago para activar tu cuenta.',
|
|
status: 'pending_payment'
|
|
});
|
|
}
|
|
|
|
if (user.status === 'suspended' || user.status === 'disabled') {
|
|
return res.status(403).json({
|
|
error: 'Account suspended',
|
|
message: 'Tu cuenta ha sido suspendida. Contacta con soporte.',
|
|
status: user.status
|
|
});
|
|
}
|
|
|
|
// Generar fingerprint del dispositivo
|
|
const { fingerprint, deviceInfo } = combineFingerprint(clientFingerprint, clientDeviceInfo, req);
|
|
|
|
// Crear sesión/token con fingerprint
|
|
const token = await createSession(username, fingerprint, deviceInfo);
|
|
|
|
// Obtener rol del usuario
|
|
const userRole = user.role || 'user';
|
|
|
|
console.log(`✅ Login exitoso: ${username} (${userRole})`);
|
|
res.json({
|
|
success: true,
|
|
token,
|
|
username,
|
|
role: userRole,
|
|
message: 'Login exitoso'
|
|
});
|
|
} catch (error) {
|
|
console.error('Error en login:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Endpoint de logout (requiere autenticación)
|
|
router.post('/logout', basicAuthMiddleware, async (req, res) => {
|
|
try {
|
|
const token = req.token;
|
|
|
|
if (token) {
|
|
await invalidateSession(token);
|
|
console.log(`✅ Logout exitoso: ${req.user.username}`);
|
|
}
|
|
|
|
res.json({ success: true, message: 'Logout exitoso' });
|
|
} catch (error) {
|
|
console.error('Error en logout:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Verificar token (para validar si la sesión sigue activa)
|
|
router.get('/me', basicAuthMiddleware, async (req, res) => {
|
|
try {
|
|
const user = await getUser(req.user.username);
|
|
res.json({
|
|
success: true,
|
|
username: req.user.username,
|
|
role: user?.role || 'user',
|
|
authenticated: true
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Cambiar contraseña de usuario
|
|
router.post('/change-password', basicAuthMiddleware, async (req, res) => {
|
|
try {
|
|
const db = getDB();
|
|
if (!db) {
|
|
return res.status(500).json({ error: 'MongoDB no está disponible' });
|
|
}
|
|
|
|
const { currentPassword, newPassword } = req.body;
|
|
const username = req.user.username;
|
|
|
|
if (!currentPassword || !newPassword) {
|
|
return res.status(400).json({ error: 'currentPassword y newPassword son requeridos' });
|
|
}
|
|
|
|
if (newPassword.length < 6) {
|
|
return res.status(400).json({ error: 'La nueva contraseña debe tener al menos 6 caracteres' });
|
|
}
|
|
|
|
const user = await getUser(username);
|
|
|
|
if (!user || !user.passwordHash) {
|
|
return res.status(404).json({ error: 'Usuario no encontrado' });
|
|
}
|
|
|
|
// Verificar contraseña actual
|
|
const match = await bcrypt.compare(currentPassword, user.passwordHash);
|
|
if (!match) {
|
|
return res.status(401).json({ error: 'Contraseña actual incorrecta' });
|
|
}
|
|
|
|
// Hashear nueva contraseña y actualizar
|
|
const newPasswordHash = await bcrypt.hash(newPassword, 10);
|
|
await updateUserPassword(username, newPasswordHash);
|
|
|
|
// Invalidar todas las sesiones del usuario (requiere nuevo login)
|
|
await invalidateUserSessions(username);
|
|
|
|
console.log(`✅ Contraseña actualizada para usuario: ${username} (todas las sesiones invalidadas)`);
|
|
res.json({ success: true, message: 'Contraseña actualizada correctamente. Por favor, inicia sesión nuevamente.' });
|
|
} catch (error) {
|
|
console.error('Error cambiando contraseña:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Obtener lista de usuarios (requiere autenticación, admin ve todos, user ve solo suyo)
|
|
router.get('/', basicAuthMiddleware, async (req, res) => {
|
|
try {
|
|
const db = getDB();
|
|
if (!db) {
|
|
return res.status(500).json({ error: 'MongoDB no está disponible' });
|
|
}
|
|
|
|
const users = await getAllUsers(req.user.username);
|
|
|
|
// Convertir ObjectId a string y formatear fechas
|
|
const formattedUsers = users.map(user => {
|
|
const formatted = { ...user };
|
|
formatted._id = user._id?.toString();
|
|
if (user.createdAt && typeof user.createdAt === 'object') {
|
|
formatted.createdAt = user.createdAt.toISOString();
|
|
}
|
|
if (user.updatedAt && typeof user.updatedAt === 'object') {
|
|
formatted.updatedAt = user.updatedAt.toISOString();
|
|
}
|
|
return formatted;
|
|
});
|
|
|
|
// Ordenar por fecha de creación (más recientes primero)
|
|
formattedUsers.sort((a, b) => {
|
|
const dateA = a.createdAt ? new Date(a.createdAt).getTime() : 0;
|
|
const dateB = b.createdAt ? new Date(b.createdAt).getTime() : 0;
|
|
return dateB - dateA;
|
|
});
|
|
|
|
res.json({ users: formattedUsers, total: formattedUsers.length });
|
|
} catch (error) {
|
|
console.error('Error obteniendo usuarios:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Crear nuevo usuario (requiere autenticación admin)
|
|
router.post('/', basicAuthMiddleware, adminAuthMiddleware, async (req, res) => {
|
|
try {
|
|
const db = getDB();
|
|
if (!db) {
|
|
return res.status(500).json({ error: 'MongoDB no está disponible' });
|
|
}
|
|
|
|
const { username, password } = req.body;
|
|
|
|
if (!username || !password) {
|
|
return res.status(400).json({ error: 'username y password son requeridos' });
|
|
}
|
|
|
|
if (username.length < 3) {
|
|
return res.status(400).json({ error: 'El nombre de usuario debe tener al menos 3 caracteres' });
|
|
}
|
|
|
|
if (password.length < 6) {
|
|
return res.status(400).json({ error: 'La contraseña debe tener al menos 6 caracteres' });
|
|
}
|
|
|
|
// Verificar si el usuario ya existe
|
|
const existingUser = await getUser(username);
|
|
if (existingUser) {
|
|
return res.status(409).json({ error: 'El usuario ya existe' });
|
|
}
|
|
|
|
// Hashear contraseña y crear usuario
|
|
const passwordHash = await bcrypt.hash(password, 10);
|
|
await createUser({
|
|
username,
|
|
passwordHash,
|
|
createdBy: req.user.username,
|
|
});
|
|
|
|
console.log(`✅ Usuario creado: ${username} por ${req.user.username}`);
|
|
res.json({ success: true, message: 'Usuario creado correctamente', username });
|
|
} catch (error) {
|
|
console.error('Error creando usuario:', error);
|
|
// Manejar error de duplicado
|
|
if (error.code === 11000) {
|
|
return res.status(409).json({ error: 'El usuario ya existe' });
|
|
}
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Eliminar usuario (requiere autenticación admin)
|
|
router.delete('/:username', basicAuthMiddleware, adminAuthMiddleware, async (req, res) => {
|
|
try {
|
|
const db = getDB();
|
|
if (!db) {
|
|
return res.status(500).json({ error: 'MongoDB no está disponible' });
|
|
}
|
|
|
|
const { username } = req.params;
|
|
const currentUser = req.user.username;
|
|
|
|
// No permitir eliminar el propio usuario
|
|
if (username === currentUser) {
|
|
return res.status(400).json({ error: 'No puedes eliminar tu propio usuario' });
|
|
}
|
|
|
|
// Verificar si el usuario existe
|
|
const user = await getUser(username);
|
|
if (!user) {
|
|
return res.status(404).json({ error: 'Usuario no encontrado' });
|
|
}
|
|
|
|
// Eliminar usuario y sus sesiones
|
|
await deleteUserFromDB(username);
|
|
await invalidateUserSessions(username);
|
|
|
|
// También eliminar sus workers
|
|
const workersCollection = db.collection('workers');
|
|
await workersCollection.deleteOne({ username });
|
|
|
|
console.log(`✅ Usuario eliminado: ${username} por ${currentUser}`);
|
|
res.json({ success: true, message: `Usuario ${username} eliminado correctamente` });
|
|
} catch (error) {
|
|
console.error('Error eliminando usuario:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
export default router;
|
|
|