876 lines
27 KiB
JavaScript
876 lines
27 KiB
JavaScript
import express from 'express';
|
||
import cors from 'cors';
|
||
import { WebSocketServer } from 'ws';
|
||
import { createServer } from 'http';
|
||
import { fileURLToPath } from 'url';
|
||
import { dirname, join } from 'path';
|
||
import { readFileSync, writeFileSync, existsSync, statSync } from 'fs';
|
||
import { watch } from 'chokidar';
|
||
import yaml from 'yaml';
|
||
import redis from 'redis';
|
||
import webpush from 'web-push';
|
||
|
||
const __filename = fileURLToPath(import.meta.url);
|
||
const __dirname = dirname(__filename);
|
||
// En Docker, usar PROJECT_ROOT de env, sino usar ruta relativa
|
||
const PROJECT_ROOT = process.env.PROJECT_ROOT || join(__dirname, '../..');
|
||
|
||
const app = express();
|
||
const server = createServer(app);
|
||
const wss = new WebSocketServer({ server, path: '/ws' });
|
||
|
||
app.use(cors());
|
||
app.use(express.json());
|
||
|
||
// Configuración
|
||
const CONFIG_PATH = join(PROJECT_ROOT, 'config.yaml');
|
||
const WORKERS_PATH = join(PROJECT_ROOT, 'workers.json');
|
||
const PUSH_SUBSCRIPTIONS_PATH = join(PROJECT_ROOT, 'push-subscriptions.json');
|
||
|
||
// Inicializar VAPID keys para Web Push
|
||
let vapidKeys = null;
|
||
const VAPID_KEYS_PATH = join(PROJECT_ROOT, 'vapid-keys.json');
|
||
|
||
function initVAPIDKeys() {
|
||
try {
|
||
if (existsSync(VAPID_KEYS_PATH)) {
|
||
vapidKeys = JSON.parse(readFileSync(VAPID_KEYS_PATH, 'utf8'));
|
||
console.log('✅ VAPID keys cargadas desde archivo');
|
||
} else {
|
||
// Generar nuevas VAPID keys
|
||
vapidKeys = webpush.generateVAPIDKeys();
|
||
writeFileSync(VAPID_KEYS_PATH, JSON.stringify(vapidKeys, null, 2), 'utf8');
|
||
console.log('✅ Nuevas VAPID keys generadas y guardadas');
|
||
}
|
||
|
||
// Configurar web-push con las VAPID keys
|
||
webpush.setVapidDetails(
|
||
'mailto:admin@pribyte.cloud', // Contacto (puedes cambiarlo)
|
||
vapidKeys.publicKey,
|
||
vapidKeys.privateKey
|
||
);
|
||
} catch (error) {
|
||
console.error('Error inicializando VAPID keys:', error.message);
|
||
}
|
||
}
|
||
|
||
// Inicializar VAPID keys al arrancar
|
||
initVAPIDKeys();
|
||
|
||
// Función para obtener la ruta del log (en Docker puede estar en /data/logs)
|
||
function getLogPath() {
|
||
const logsDirPath = join(PROJECT_ROOT, 'logs', 'monitor.log');
|
||
const rootLogPath = join(PROJECT_ROOT, 'monitor.log');
|
||
|
||
if (existsSync(logsDirPath)) {
|
||
return logsDirPath;
|
||
}
|
||
return rootLogPath;
|
||
}
|
||
|
||
const LOG_PATH = getLogPath();
|
||
|
||
let redisClient = null;
|
||
let config = null;
|
||
|
||
// Inicializar Redis si está configurado
|
||
async function initRedis() {
|
||
try {
|
||
config = yaml.parse(readFileSync(CONFIG_PATH, 'utf8'));
|
||
const cacheConfig = config?.cache;
|
||
|
||
if (cacheConfig?.type === 'redis') {
|
||
const redisConfig = cacheConfig.redis;
|
||
// En Docker, usar el nombre del servicio si no se especifica host
|
||
const redisHost = process.env.REDIS_HOST || redisConfig.host || 'localhost';
|
||
redisClient = redis.createClient({
|
||
socket: {
|
||
host: redisHost,
|
||
port: redisConfig.port || 6379,
|
||
},
|
||
password: redisConfig.password || undefined,
|
||
database: redisConfig.db || 0,
|
||
});
|
||
|
||
redisClient.on('error', (err) => console.error('Redis Client Error', err));
|
||
await redisClient.connect();
|
||
console.log('✅ Conectado a Redis');
|
||
|
||
// Inicializar claves conocidas para evitar notificar artículos existentes
|
||
try {
|
||
const initialKeys = await redisClient.keys('notified:*');
|
||
notifiedArticleKeys = new Set(initialKeys);
|
||
console.log(`📋 ${notifiedArticleKeys.size} artículos ya notificados detectados`);
|
||
} catch (error) {
|
||
console.error('Error inicializando claves de artículos:', error.message);
|
||
}
|
||
} else {
|
||
console.log('ℹ️ Redis no configurado, usando modo memoria');
|
||
}
|
||
} catch (error) {
|
||
console.error('Error inicializando Redis:', error.message);
|
||
}
|
||
}
|
||
|
||
// Broadcast a todos los clientes WebSocket
|
||
function broadcast(data) {
|
||
wss.clients.forEach((client) => {
|
||
if (client.readyState === 1) { // WebSocket.OPEN
|
||
client.send(JSON.stringify(data));
|
||
}
|
||
});
|
||
}
|
||
|
||
// Leer archivo JSON de forma segura
|
||
function readJSON(path, defaultValue = {}) {
|
||
try {
|
||
if (existsSync(path)) {
|
||
return JSON.parse(readFileSync(path, 'utf8'));
|
||
}
|
||
return defaultValue;
|
||
} catch (error) {
|
||
console.error(`Error leyendo ${path}:`, error.message);
|
||
return defaultValue;
|
||
}
|
||
}
|
||
|
||
// Escribir archivo JSON
|
||
function writeJSON(path, data) {
|
||
try {
|
||
writeFileSync(path, JSON.stringify(data, null, 2), 'utf8');
|
||
return true;
|
||
} catch (error) {
|
||
console.error(`Error escribiendo ${path}:`, error.message);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Obtener artículos notificados desde Redis
|
||
async function getNotifiedArticles() {
|
||
if (!redisClient) {
|
||
return [];
|
||
}
|
||
|
||
try {
|
||
const keys = await redisClient.keys('notified:*');
|
||
const articles = [];
|
||
|
||
for (const key of keys) {
|
||
const parts = key.split(':');
|
||
if (parts.length >= 3) {
|
||
const platform = parts[1];
|
||
const id = parts.slice(2).join(':');
|
||
const ttl = await redisClient.ttl(key);
|
||
const value = await redisClient.get(key);
|
||
|
||
// Intentar parsear como JSON (nuevo formato con toda la info)
|
||
let articleData = {};
|
||
try {
|
||
if (value && value !== '1') {
|
||
articleData = JSON.parse(value);
|
||
}
|
||
} catch (e) {
|
||
// Si no es JSON válido, usar valor por defecto
|
||
}
|
||
|
||
articles.push({
|
||
platform: articleData.platform || platform,
|
||
id: articleData.id || id,
|
||
title: articleData.title || null,
|
||
description: articleData.description || null,
|
||
price: articleData.price || null,
|
||
currency: articleData.currency || null,
|
||
location: articleData.location || null,
|
||
allows_shipping: articleData.allows_shipping !== undefined ? articleData.allows_shipping : null,
|
||
url: articleData.url || null,
|
||
images: articleData.images || [],
|
||
modified_at: articleData.modified_at || null,
|
||
notifiedAt: Date.now() - (7 * 24 * 60 * 60 - ttl) * 1000,
|
||
expiresAt: Date.now() + ttl * 1000,
|
||
});
|
||
}
|
||
}
|
||
|
||
return articles;
|
||
} catch (error) {
|
||
console.error('Error obteniendo artículos de Redis:', error.message);
|
||
return [];
|
||
}
|
||
}
|
||
|
||
// API Routes
|
||
|
||
// Obtener favoritos desde Redis
|
||
async function getFavorites() {
|
||
if (!redisClient) {
|
||
return [];
|
||
}
|
||
|
||
try {
|
||
const keys = await redisClient.keys('notified:*');
|
||
const favorites = [];
|
||
|
||
for (const key of keys) {
|
||
const value = await redisClient.get(key);
|
||
if (value) {
|
||
try {
|
||
const articleData = JSON.parse(value);
|
||
if (articleData.is_favorite === true) {
|
||
favorites.push(articleData);
|
||
}
|
||
} catch (e) {
|
||
// Si no es JSON válido, ignorar
|
||
}
|
||
}
|
||
}
|
||
|
||
return favorites;
|
||
} catch (error) {
|
||
console.error('Error obteniendo favoritos de Redis:', error.message);
|
||
return [];
|
||
}
|
||
}
|
||
|
||
// Obtener estadísticas
|
||
app.get('/api/stats', async (req, res) => {
|
||
try {
|
||
const workers = readJSON(WORKERS_PATH, { items: [] });
|
||
const favorites = await getFavorites();
|
||
const notifiedArticles = await getNotifiedArticles();
|
||
|
||
const stats = {
|
||
totalWorkers: workers.items?.length || 0,
|
||
activeWorkers: (workers.items || []).filter(w => !workers.disabled?.includes(w.name)).length,
|
||
totalFavorites: favorites.length,
|
||
totalNotified: notifiedArticles.length,
|
||
platforms: {
|
||
wallapop: notifiedArticles.filter(a => a.platform === 'wallapop').length,
|
||
vinted: notifiedArticles.filter(a => a.platform === 'vinted').length,
|
||
},
|
||
};
|
||
|
||
res.json(stats);
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Obtener workers
|
||
app.get('/api/workers', (req, res) => {
|
||
try {
|
||
const workers = readJSON(WORKERS_PATH, { items: [], general: {}, disabled: [] });
|
||
res.json(workers);
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Actualizar workers
|
||
app.put('/api/workers', (req, res) => {
|
||
try {
|
||
const workers = req.body;
|
||
if (writeJSON(WORKERS_PATH, workers)) {
|
||
broadcast({ type: 'workers_updated', data: workers });
|
||
res.json({ success: true });
|
||
} else {
|
||
res.status(500).json({ error: 'Error guardando workers' });
|
||
}
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Obtener favoritos
|
||
app.get('/api/favorites', async (req, res) => {
|
||
try {
|
||
const favorites = await getFavorites();
|
||
res.json(favorites);
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Añadir favorito
|
||
app.post('/api/favorites', async (req, res) => {
|
||
try {
|
||
if (!redisClient) {
|
||
return res.status(500).json({ error: 'Redis no está disponible' });
|
||
}
|
||
|
||
const { platform, id } = req.body;
|
||
if (!platform || !id) {
|
||
return res.status(400).json({ error: 'platform e id son requeridos' });
|
||
}
|
||
|
||
const key = `notified:${platform}:${id}`;
|
||
const value = await redisClient.get(key);
|
||
|
||
if (!value) {
|
||
return res.status(404).json({ error: 'Artículo no encontrado' });
|
||
}
|
||
|
||
try {
|
||
const articleData = JSON.parse(value);
|
||
articleData.is_favorite = true;
|
||
// Mantener el TTL existente
|
||
const ttl = await redisClient.ttl(key);
|
||
if (ttl > 0) {
|
||
await redisClient.setex(key, ttl, JSON.stringify(articleData));
|
||
} else {
|
||
await redisClient.set(key, JSON.stringify(articleData));
|
||
}
|
||
|
||
const favorites = await getFavorites();
|
||
broadcast({ type: 'favorites_updated', data: favorites });
|
||
res.json({ success: true, favorites });
|
||
} catch (e) {
|
||
res.status(500).json({ error: 'Error procesando artículo' });
|
||
}
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Eliminar favorito
|
||
app.delete('/api/favorites/:platform/:id', async (req, res) => {
|
||
try {
|
||
if (!redisClient) {
|
||
return res.status(500).json({ error: 'Redis no está disponible' });
|
||
}
|
||
|
||
const { platform, id } = req.params;
|
||
const key = `notified:${platform}:${id}`;
|
||
const value = await redisClient.get(key);
|
||
|
||
if (!value) {
|
||
return res.status(404).json({ error: 'Artículo no encontrado' });
|
||
}
|
||
|
||
try {
|
||
const articleData = JSON.parse(value);
|
||
articleData.is_favorite = false;
|
||
// Mantener el TTL existente
|
||
const ttl = await redisClient.ttl(key);
|
||
if (ttl > 0) {
|
||
await redisClient.setex(key, ttl, JSON.stringify(articleData));
|
||
} else {
|
||
await redisClient.set(key, JSON.stringify(articleData));
|
||
}
|
||
|
||
const favorites = await getFavorites();
|
||
broadcast({ type: 'favorites_updated', data: favorites });
|
||
res.json({ success: true, favorites });
|
||
} catch (e) {
|
||
res.status(500).json({ error: 'Error procesando artículo' });
|
||
}
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Limpiar toda la caché de Redis
|
||
app.delete('/api/cache', async (req, res) => {
|
||
try {
|
||
if (!redisClient) {
|
||
return res.status(500).json({ error: 'Redis no está disponible' });
|
||
}
|
||
|
||
// Obtener todas las claves que empiezan con 'notified:'
|
||
const keys = await redisClient.keys('notified:*');
|
||
|
||
if (!keys || keys.length === 0) {
|
||
return res.json({
|
||
success: true,
|
||
message: 'Cache ya está vacío',
|
||
count: 0
|
||
});
|
||
}
|
||
|
||
// Eliminar todas las claves
|
||
const count = keys.length;
|
||
for (const key of keys) {
|
||
await redisClient.del(key);
|
||
}
|
||
|
||
// Notificar a los clientes WebSocket
|
||
broadcast({
|
||
type: 'cache_cleared',
|
||
data: { count, timestamp: Date.now() }
|
||
});
|
||
|
||
// También actualizar favoritos (debería estar vacío ahora)
|
||
const favorites = await getFavorites();
|
||
broadcast({ type: 'favorites_updated', data: favorites });
|
||
|
||
res.json({
|
||
success: true,
|
||
message: `Cache limpiado: ${count} artículos eliminados`,
|
||
count
|
||
});
|
||
} catch (error) {
|
||
console.error('Error limpiando cache de Redis:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Obtener artículos notificados
|
||
app.get('/api/articles', async (req, res) => {
|
||
try {
|
||
const articles = await getNotifiedArticles();
|
||
const limit = parseInt(req.query.limit) || 100;
|
||
const offset = parseInt(req.query.offset) || 0;
|
||
|
||
const sorted = articles.sort((a, b) => b.notifiedAt - a.notifiedAt);
|
||
const paginated = sorted.slice(offset, offset + limit);
|
||
|
||
res.json({
|
||
articles: paginated,
|
||
total: articles.length,
|
||
limit,
|
||
offset,
|
||
});
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Buscar artículos en Redis
|
||
app.get('/api/articles/search', async (req, res) => {
|
||
try {
|
||
const query = req.query.q || '';
|
||
if (!query.trim()) {
|
||
return res.json({ articles: [], total: 0 });
|
||
}
|
||
|
||
const searchTerm = query.toLowerCase().trim();
|
||
const allArticles = await getNotifiedArticles();
|
||
|
||
// Filtrar artículos que coincidan con la búsqueda
|
||
const filtered = allArticles.filter(article => {
|
||
// Buscar en título
|
||
const title = (article.title || '').toLowerCase();
|
||
if (title.includes(searchTerm)) return true;
|
||
|
||
// Buscar en descripción
|
||
const description = (article.description || '').toLowerCase();
|
||
if (description.includes(searchTerm)) return true;
|
||
|
||
// Buscar en localidad
|
||
const location = (article.location || '').toLowerCase();
|
||
if (location.includes(searchTerm)) return true;
|
||
|
||
// Buscar en precio (como número o texto)
|
||
const price = String(article.price || '').toLowerCase();
|
||
if (price.includes(searchTerm)) return true;
|
||
|
||
// Buscar en plataforma
|
||
const platform = (article.platform || '').toLowerCase();
|
||
if (platform.includes(searchTerm)) return true;
|
||
|
||
// Buscar en ID
|
||
const id = String(article.id || '').toLowerCase();
|
||
if (id.includes(searchTerm)) return true;
|
||
|
||
return false;
|
||
});
|
||
|
||
// Ordenar por fecha de notificación (más recientes primero)
|
||
const sorted = filtered.sort((a, b) => b.notifiedAt - a.notifiedAt);
|
||
|
||
res.json({
|
||
articles: sorted,
|
||
total: sorted.length,
|
||
query: query,
|
||
});
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Obtener logs (últimas líneas o nuevas líneas desde un número de línea)
|
||
app.get('/api/logs', (req, res) => {
|
||
try {
|
||
// Intentar múltiples ubicaciones posibles
|
||
let logFile = LOG_PATH;
|
||
if (!existsSync(logFile)) {
|
||
// Intentar en el directorio de logs
|
||
const altPath = join(PROJECT_ROOT, 'logs', 'monitor.log');
|
||
if (existsSync(altPath)) {
|
||
logFile = altPath;
|
||
} else {
|
||
return res.json({ logs: [], totalLines: 0, lastLineNumber: 0 });
|
||
}
|
||
}
|
||
|
||
// Verificar que no sea un directorio
|
||
try {
|
||
const stats = statSync(logFile);
|
||
if (stats.isDirectory()) {
|
||
return res.json({ logs: ['Error: monitor.log es un directorio. Por favor, elimínalo y reinicia.'], totalLines: 0, lastLineNumber: 0 });
|
||
}
|
||
} catch (e) {
|
||
return res.json({ logs: [], totalLines: 0, lastLineNumber: 0 });
|
||
}
|
||
|
||
const logsContent = readFileSync(logFile, 'utf8');
|
||
const allLines = logsContent.split('\n').filter(l => l.trim());
|
||
const totalLines = allLines.length;
|
||
|
||
// Si se proporciona since (número de línea desde el que empezar), devolver solo las nuevas
|
||
const sinceLine = parseInt(req.query.since) || 0;
|
||
|
||
if (sinceLine > 0 && sinceLine < totalLines) {
|
||
// Devolver solo las líneas nuevas después de sinceLine
|
||
const newLines = allLines.slice(sinceLine);
|
||
return res.json({
|
||
logs: newLines,
|
||
totalLines: totalLines,
|
||
lastLineNumber: totalLines - 1 // Índice de la última línea
|
||
});
|
||
} else {
|
||
// Carga inicial: devolver las últimas líneas
|
||
const limit = parseInt(req.query.limit) || 500;
|
||
const lastLines = allLines.slice(-limit);
|
||
return res.json({
|
||
logs: lastLines,
|
||
totalLines: totalLines,
|
||
lastLineNumber: totalLines - 1 // Índice de la última línea
|
||
});
|
||
}
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Obtener configuración
|
||
app.get('/api/config', (req, res) => {
|
||
try {
|
||
if (!config) {
|
||
config = yaml.parse(readFileSync(CONFIG_PATH, 'utf8'));
|
||
}
|
||
// No enviar token por seguridad
|
||
const safeConfig = { ...config };
|
||
if (safeConfig.telegram_token) {
|
||
safeConfig.telegram_token = '***';
|
||
}
|
||
res.json(safeConfig);
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Obtener threads/topics de Telegram
|
||
app.get('/api/telegram/threads', async (req, res) => {
|
||
try {
|
||
if (!config) {
|
||
config = yaml.parse(readFileSync(CONFIG_PATH, 'utf8'));
|
||
}
|
||
|
||
const token = config?.telegram_token;
|
||
const channel = config?.telegram_channel;
|
||
|
||
if (!token || !channel) {
|
||
return res.status(400).json({ error: 'Token o canal de Telegram no configurados' });
|
||
}
|
||
|
||
// Convertir el canal a chat_id si es necesario
|
||
let chatId = channel;
|
||
if (channel.startsWith('@')) {
|
||
// Para canales con @, necesitamos obtener el chat_id primero
|
||
const getChatUrl = `https://api.telegram.org/bot${token}/getChat?chat_id=${encodeURIComponent(channel)}`;
|
||
const chatResponse = await fetch(getChatUrl);
|
||
const chatData = await chatResponse.json();
|
||
|
||
if (!chatData.ok) {
|
||
return res.status(400).json({ error: `Error obteniendo chat: ${chatData.description || 'Chat no encontrado'}` });
|
||
}
|
||
|
||
chatId = chatData.result.id;
|
||
}
|
||
|
||
// Intentar obtener forum topics
|
||
const forumTopicsUrl = `https://api.telegram.org/bot${token}/getForumTopics?chat_id=${chatId}&limit=100`;
|
||
const topicsResponse = await fetch(forumTopicsUrl);
|
||
const topicsData = await topicsResponse.json();
|
||
|
||
if (topicsData.ok && topicsData.result?.topics) {
|
||
const threads = topicsData.result.topics.map(topic => ({
|
||
id: topic.message_thread_id,
|
||
name: topic.name || `Thread ${topic.message_thread_id}`,
|
||
icon_color: topic.icon_color,
|
||
icon_custom_emoji_id: topic.icon_custom_emoji_id,
|
||
}));
|
||
|
||
return res.json({ threads, success: true });
|
||
} else {
|
||
// Si no hay forum topics, devolver un mensaje informativo
|
||
return res.json({
|
||
threads: [],
|
||
success: false,
|
||
message: 'El chat no tiene forum topics habilitados o no se pudieron obtener. Puedes obtener el Thread ID manualmente copiando el enlace del tema.',
|
||
info: 'Para obtener el Thread ID manualmente: 1. Haz clic derecho en el tema/hilo en Telegram 2. Selecciona "Copiar enlace del tema" 3. El número al final de la URL es el Thread ID (ej: t.me/c/1234567890/8 → Thread ID = 8)'
|
||
});
|
||
}
|
||
} catch (error) {
|
||
console.error('Error obteniendo threads de Telegram:', error.message);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Obtener suscripciones push guardadas
|
||
function getPushSubscriptions() {
|
||
return readJSON(PUSH_SUBSCRIPTIONS_PATH, []);
|
||
}
|
||
|
||
// Guardar suscripciones push
|
||
function savePushSubscriptions(subscriptions) {
|
||
return writeJSON(PUSH_SUBSCRIPTIONS_PATH, subscriptions);
|
||
}
|
||
|
||
// API Routes para Push Notifications
|
||
|
||
// Obtener clave pública VAPID
|
||
app.get('/api/push/public-key', (req, res) => {
|
||
if (!vapidKeys || !vapidKeys.publicKey) {
|
||
return res.status(500).json({ error: 'VAPID keys no están configuradas' });
|
||
}
|
||
res.json({ publicKey: vapidKeys.publicKey });
|
||
});
|
||
|
||
// Suscribirse a notificaciones push
|
||
app.post('/api/push/subscribe', async (req, res) => {
|
||
try {
|
||
const subscription = req.body;
|
||
|
||
if (!subscription || !subscription.endpoint) {
|
||
return res.status(400).json({ error: 'Suscripción inválida' });
|
||
}
|
||
|
||
const subscriptions = getPushSubscriptions();
|
||
|
||
// Verificar si ya existe esta suscripción
|
||
const existingIndex = subscriptions.findIndex(
|
||
sub => sub.endpoint === subscription.endpoint
|
||
);
|
||
|
||
if (existingIndex >= 0) {
|
||
subscriptions[existingIndex] = subscription;
|
||
} else {
|
||
subscriptions.push(subscription);
|
||
}
|
||
|
||
savePushSubscriptions(subscriptions);
|
||
console.log(`✅ Nueva suscripción push guardada. Total: ${subscriptions.length}`);
|
||
|
||
res.json({ success: true, totalSubscriptions: subscriptions.length });
|
||
} catch (error) {
|
||
console.error('Error guardando suscripción push:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Cancelar suscripción push
|
||
app.post('/api/push/unsubscribe', async (req, res) => {
|
||
try {
|
||
const subscription = req.body;
|
||
|
||
if (!subscription || !subscription.endpoint) {
|
||
return res.status(400).json({ error: 'Suscripción inválida' });
|
||
}
|
||
|
||
const subscriptions = getPushSubscriptions();
|
||
const filtered = subscriptions.filter(
|
||
sub => sub.endpoint !== subscription.endpoint
|
||
);
|
||
|
||
savePushSubscriptions(filtered);
|
||
console.log(`✅ Suscripción push cancelada. Total: ${filtered.length}`);
|
||
|
||
res.json({ success: true, totalSubscriptions: filtered.length });
|
||
} catch (error) {
|
||
console.error('Error cancelando suscripción push:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Enviar notificación push a todas las suscripciones
|
||
async function sendPushNotifications(notificationData) {
|
||
const subscriptions = getPushSubscriptions();
|
||
|
||
if (subscriptions.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const payload = JSON.stringify(notificationData);
|
||
const promises = subscriptions.map(async (subscription) => {
|
||
try {
|
||
await webpush.sendNotification(subscription, payload);
|
||
console.log('✅ Notificación push enviada');
|
||
} catch (error) {
|
||
console.error('Error enviando notificación push:', error);
|
||
|
||
// Si la suscripción es inválida (404, 410), eliminarla
|
||
if (error.statusCode === 404 || error.statusCode === 410) {
|
||
const updatedSubscriptions = getPushSubscriptions().filter(
|
||
sub => sub.endpoint !== subscription.endpoint
|
||
);
|
||
savePushSubscriptions(updatedSubscriptions);
|
||
console.log(`Suscripción inválida eliminada. Total: ${updatedSubscriptions.length}`);
|
||
}
|
||
}
|
||
});
|
||
|
||
await Promise.allSettled(promises);
|
||
}
|
||
|
||
// WebSocket connection
|
||
wss.on('connection', (ws) => {
|
||
console.log('Cliente WebSocket conectado');
|
||
|
||
ws.on('close', () => {
|
||
console.log('Cliente WebSocket desconectado');
|
||
});
|
||
|
||
ws.on('error', (error) => {
|
||
console.error('Error WebSocket:', error);
|
||
});
|
||
});
|
||
|
||
// Determinar la ruta del log para el watcher
|
||
let watchLogPath = LOG_PATH;
|
||
if (!existsSync(watchLogPath)) {
|
||
const altPath = join(PROJECT_ROOT, 'logs', 'monitor.log');
|
||
if (existsSync(altPath)) {
|
||
watchLogPath = altPath;
|
||
}
|
||
}
|
||
|
||
// Watch files for changes (ya no vigilamos logs porque usa polling)
|
||
const watcher = watch([WORKERS_PATH].filter(p => existsSync(p)), {
|
||
persistent: true,
|
||
ignoreInitial: true,
|
||
});
|
||
|
||
watcher.on('change', async (path) => {
|
||
console.log(`Archivo cambiado: ${path}`);
|
||
if (path === WORKERS_PATH) {
|
||
const workers = readJSON(WORKERS_PATH);
|
||
broadcast({ type: 'workers_updated', data: workers });
|
||
}
|
||
});
|
||
|
||
// Rastrear artículos ya notificados para detectar nuevos
|
||
let notifiedArticleKeys = new Set();
|
||
let articlesCheckInterval = null;
|
||
|
||
// Función para detectar y enviar artículos nuevos
|
||
async function checkForNewArticles() {
|
||
if (!redisClient) {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const currentKeys = await redisClient.keys('notified:*');
|
||
const currentKeysSet = new Set(currentKeys);
|
||
|
||
// Encontrar claves nuevas
|
||
const newKeys = currentKeys.filter(key => !notifiedArticleKeys.has(key));
|
||
|
||
if (newKeys.length > 0) {
|
||
// Obtener los artículos nuevos
|
||
const newArticles = [];
|
||
for (const key of newKeys) {
|
||
try {
|
||
const value = await redisClient.get(key);
|
||
if (value) {
|
||
// Intentar parsear como JSON
|
||
let articleData = {};
|
||
try {
|
||
articleData = JSON.parse(value);
|
||
} catch (e) {
|
||
// Si no es JSON válido, extraer información de la key
|
||
const parts = key.split(':');
|
||
if (parts.length >= 3) {
|
||
articleData = {
|
||
platform: parts[1],
|
||
id: parts.slice(2).join(':'),
|
||
};
|
||
}
|
||
}
|
||
|
||
// Añadir información adicional si está disponible
|
||
if (articleData.platform && articleData.id) {
|
||
newArticles.push({
|
||
platform: articleData.platform || 'unknown',
|
||
id: articleData.id || 'unknown',
|
||
title: articleData.title || null,
|
||
price: articleData.price || null,
|
||
currency: articleData.currency || '€',
|
||
url: articleData.url || null,
|
||
images: articleData.images || [],
|
||
});
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.error(`Error obteniendo artículo de Redis (${key}):`, error.message);
|
||
}
|
||
}
|
||
|
||
// Enviar artículos nuevos por WebSocket
|
||
if (newArticles.length > 0) {
|
||
broadcast({
|
||
type: 'new_articles',
|
||
data: newArticles
|
||
});
|
||
|
||
// Enviar notificaciones push para cada artículo nuevo
|
||
for (const article of newArticles) {
|
||
await sendPushNotifications({
|
||
title: `Nuevo artículo en ${article.platform?.toUpperCase() || 'Wallabicher'}`,
|
||
body: article.title || 'Artículo nuevo disponible',
|
||
icon: '/android-chrome-192x192.png',
|
||
image: article.images?.[0] || null,
|
||
url: article.url || '/',
|
||
platform: article.platform,
|
||
price: article.price,
|
||
currency: article.currency || '€',
|
||
id: article.id,
|
||
});
|
||
}
|
||
}
|
||
|
||
// Actualizar el set de claves notificadas
|
||
notifiedArticleKeys = currentKeysSet;
|
||
}
|
||
} catch (error) {
|
||
console.error('Error verificando artículos nuevos:', error.message);
|
||
}
|
||
}
|
||
|
||
// Inicializar el check de artículos cuando Redis esté listo
|
||
async function startArticleMonitoring() {
|
||
if (redisClient) {
|
||
// Iniciar intervalo para verificar nuevos artículos cada 3 segundos
|
||
articlesCheckInterval = setInterval(checkForNewArticles, 3000);
|
||
console.log('✅ Monitoreo de artículos nuevos iniciado');
|
||
}
|
||
}
|
||
|
||
// Inicializar servidor
|
||
const PORT = process.env.PORT || 3001;
|
||
|
||
async function startServer() {
|
||
await initRedis();
|
||
|
||
// Iniciar monitoreo de artículos nuevos
|
||
await startArticleMonitoring();
|
||
|
||
server.listen(PORT, () => {
|
||
console.log(`🚀 Servidor backend ejecutándose en http://localhost:${PORT}`);
|
||
console.log(`📡 WebSocket disponible en ws://localhost:${PORT}`);
|
||
});
|
||
}
|
||
|
||
startServer().catch(console.error);
|
||
|