Chats were added

app.js

@@ -8,12 +8,27 @@ import commentRoutes from './routes/comments.js';
 import communityRoutes from './routes/communities.js';
 import offerRoutes from './routes/offers.js';
 
+// Chat stuff
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+import { initializeSocketIO } from './socket/chatSocket.js';
+import chatRoutes from './routes/chat.js';
+
 const app = express();
 const port = 3000;
 
+const httpServer = createServer(app);
+const io = new Server(httpServer, {
+  cors: {
+    origin: '*',
+    methods: ['GET', 'POST']
+  }
+});
+
 app.use(express.json());
 app.use(cors());
 
+
 let corsOptions = {
   origin: '*', // Reemplaza con el origen permitido
   optionsSuccessStatus: 200 // Algunos navegadores (como IE11) requieren este estado
@@ -34,6 +49,8 @@ ENDPOINT                HTTP REQ    ACCIÓN                                  RES
 /api/user/all           - GET       (Ver todos los usuarios)                Todos los usuarios
 /api/user/:userID       - DELETE    (Eliminar usuario)                      Administradores o Usuario.
 */
+app.set('io', io);
+
 
 app.use('/', indexRoutes);        // Rutas base
 app.use('/api', apiRoutes);       // Rutas de API
@@ -44,8 +61,12 @@ app.use('/uploads', express.static('uploads'));
 app.use('/api/offers', express.static('uploads'));
 app.use('/api/offers', offerRoutes); // Rutas de ofertas
 app.use('/api/communities', communityRoutes); // Rutas de comunidades
+app.use('/api/chat', chatRoutes); // Rutas de chat
 
-app.listen(port, () => {
+initializeSocketIO(io);
+
+// Iniciar el servidor HTTP
+httpServer.listen(port, () => {
   console.log(`Example app listening on port ${port}`);
   console.log(`URL at: http://localhost:${port}`)
-})
+});

routes/chat.js

@@ -0,0 +1,175 @@
+import express from 'express';
+import {pool} from '../lib/database.js'; // Ajusta según tu configuración
+
+const router = express.Router();
+
+// Crear o obtener conversación entre dos usuarios
+router.post('/conversation/get-or-create', async (req, res) => {
+  const { usuario1Id, usuario2Id } = req.body;
+
+  if (!usuario1Id || !usuario2Id) {
+    return res.status(400).json({ error: 'Se requieren ambos IDs de usuarios' });
+  }
+
+  const client = await pool.connect();
+
+  try {
+    await client.query('BEGIN');
+
+    // Verificar si ya existe una conversación entre estos dos usuarios (en cualquier orden)
+    const existingConv = await client.query(
+    `SELECT c.id_conversacion 
+    FROM conversaciones c
+    JOIN conversacion_participantes cp1 ON c.id_conversacion = cp1.id_conversacion
+    JOIN conversacion_participantes cp2 ON c.id_conversacion = cp2.id_conversacion
+    WHERE (cp1.id_usuario = $1 AND cp2.id_usuario = $2)
+        OR (cp1.id_usuario = $2 AND cp2.id_usuario = $1)
+    LIMIT 1`,
+    [usuario1Id, usuario2Id]
+    );
+
+
+    let conversacionId;
+
+    if (existingConv.rows.length > 0) {
+      conversacionId = existingConv.rows[0].id_conversacion;
+    } else {
+      // Crear nueva conversación
+      const convResult = await client.query(
+        'INSERT INTO conversaciones DEFAULT VALUES RETURNING id_conversacion'
+      );
+      conversacionId = convResult.rows[0].id_conversacion;
+
+      // Agregar participantes
+      await client.query(
+        `INSERT INTO conversacion_participantes (id_conversacion, id_usuario)
+        VALUES ($1, $2), ($1, $3)
+        ON CONFLICT DO NOTHING`,
+        [conversacionId, usuario1Id, usuario2Id]
+    );
+
+    }
+
+    await client.query('COMMIT');
+
+    res.json({ conversacionId });
+
+  } catch (error) {
+    await client.query('ROLLBACK');
+    console.error('Error al crear/obtener conversación:', error);
+    res.status(500).json({ error: 'Error al crear conversación' });
+  } finally {
+    client.release();
+  }
+});
+
+// Obtener conversaciones de un usuario con info del otro participante
+router.get('/conversations/:userId', async (req, res) => {
+  const { userId } = req.params;
+
+  try {
+    const result = await pool.query(
+      `SELECT DISTINCT 
+        c.id_conversacion, 
+        c.fecha_creacion, 
+        c.ultima_actualizacion,
+        u.id_usuario as otro_usuario_id,
+        u.nombre as otro_usuario_nombre,
+        u.apellido_pa as otro_usuario_apellido,
+        (SELECT contenido FROM mensajes 
+         WHERE id_conversacion = c.id_conversacion 
+         ORDER BY fecha_envio DESC LIMIT 1) as ultimo_mensaje,
+        (SELECT fecha_envio FROM mensajes 
+         WHERE id_conversacion = c.id_conversacion 
+         ORDER BY fecha_envio DESC LIMIT 1) as fecha_ultimo_mensaje,
+        (SELECT COUNT(*) FROM mensajes 
+         WHERE id_conversacion = c.id_conversacion 
+         AND leido = FALSE 
+         AND id_remitente != $1) as mensajes_no_leidos
+       FROM conversaciones c
+       JOIN conversacion_participantes cp1 ON c.id_conversacion = cp1.id_conversacion
+       JOIN conversacion_participantes cp2 ON c.id_conversacion = cp2.id_conversacion
+       JOIN usuarios u ON cp2.id_usuario = u.id_usuario
+       WHERE cp1.id_usuario = $1 AND cp2.id_usuario != $1
+       ORDER BY c.ultima_actualizacion DESC`,
+      [userId]
+    );
+
+    res.json(result.rows);
+
+  } catch (error) {
+    console.error('Error al obtener conversaciones:', error);
+    res.status(500).json({ error: 'Error al obtener conversaciones' });
+  }
+});
+
+// Obtener mensajes de una conversación
+router.get('/messages/:conversacionId', async (req, res) => {
+  const conversacionId = parseInt(req.params.conversacionId, 10);
+  const limit = parseInt(req.query.limit ?? 50, 10);
+  const offset = parseInt(req.query.offset ?? 0, 10);
+
+  if (isNaN(conversacionId)) {
+    return res.status(400).json({ error: 'ID de conversación inválido' });
+  }
+
+  try {
+    const result = await pool.query(
+      `SELECT m.*, u.nombre, u.apellido_pa, u.apellido_ma
+       FROM mensajes m
+       JOIN usuarios u ON m.id_remitente = u.id_usuario
+       WHERE m.id_conversacion = $1
+       ORDER BY m.fecha_envio ASC
+       LIMIT $2 OFFSET $3`,
+      [conversacionId, limit, offset]
+    );
+
+    res.json(result.rows);
+
+  } catch (error) {
+    console.error('Error al obtener mensajes:', error);
+    res.status(500).json({ error: 'Error al obtener mensajes' });
+  }
+});
+
+// Marcar mensajes como leídos
+router.put('/messages/read/:conversacionId/:userId', async (req, res) => {
+  const conversacionId = parseInt(req.params.conversacionId, 10);
+  const userId = parseInt(req.params.userId, 10);
+
+  if (isNaN(conversacionId) || isNaN(userId)) {
+    return res.status(400).json({ error: 'Parámetros inválidos' });
+  }
+
+  await pool.query(
+    `UPDATE mensajes 
+     SET leido = TRUE 
+     WHERE id_conversacion = $1 
+     AND id_remitente != $2 
+     AND leido = FALSE`,
+    [conversacionId, userId]
+  );
+
+  res.json({ mensaje: 'Mensajes marcados como leídos' });
+});
+
+
+// Eliminar conversación
+router.delete('/conversations/:conversacionId', async (req, res) => {
+  const { conversacionId } = req.params;
+
+  try {
+    await pool.query(
+      'DELETE FROM conversaciones WHERE id_conversacion = $1',
+      [conversacionId]
+    );
+
+    res.json({ mensaje: 'Conversación eliminada exitosamente' });
+
+  } catch (error) {
+    console.error('Error al eliminar conversación:', error);
+    res.status(500).json({ error: 'Error al eliminar conversación' });
+  }
+});
+
+export default router;

routes/posts.js

@@ -92,6 +92,7 @@ router.post('/', upload.single('imagen'), validatePostPayload, processUploadedIm
 router.get('/:id_post', getPostById);
 router.delete('/:id_post', deletePost);
 router.get('/', getAllPosts);
+router.get('/comunities/:comunity', getPostById);
 router.get('/user/:userId', getPostsByUserId);
 router.put('/:id_post', editPost);
 

socket/chatSocket.js

@@ -0,0 +1,79 @@
+import { pool } from '../lib/database.js';
+
+const connectedUsers = new Map();
+
+export function initializeSocketIO(io) {
+  io.on('connection', (socket) => {
+    console.log('Usuario conectado:', socket.id);
+
+    socket.on('register', (userId) => {
+      connectedUsers.set(userId.toString(), socket.id);
+      console.log(`Usuario ${userId} registrado con socket ${socket.id}`);
+      socket.emit('registered', { userId, socketId: socket.id });
+    });
+
+    socket.on('join_conversation', (conversacionId) => {
+      socket.join(`conversation_${conversacionId}`);
+      console.log(`Socket ${socket.id} se unió a conversation_${conversacionId}`);
+    });
+
+    socket.on('send_message', async (data) => {
+      const { conversacionId, remitenteId, contenido } = data;
+
+      try {
+        const result = await pool.query(
+          'INSERT INTO mensajes (id_conversacion, id_remitente, contenido) VALUES ($1, $2, $3) RETURNING *',
+          [conversacionId, remitenteId, contenido]
+        );
+
+        const nuevoMensaje = result.rows[0];
+
+        const userResult = await pool.query(
+          'SELECT id_usuario, nombre, apellido_pa, apellido_ma FROM usuarios WHERE id_usuario = $1',
+          [remitenteId]
+        );
+
+        const mensajeCompleto = {
+          ...nuevoMensaje,
+          nombre: userResult.rows[0].nombre,
+          apellido_pa: userResult.rows[0].apellido_pa,
+          apellido_ma: userResult.rows[0].apellido_ma
+        };
+
+        await pool.query(
+          'UPDATE conversaciones SET ultima_actualizacion = CURRENT_TIMESTAMP WHERE id_conversacion = $1',
+          [conversacionId]
+        );
+
+        io.to(`conversation_${conversacionId}`).emit('receive_message', mensajeCompleto);
+
+      } catch (error) {
+        console.error('Error al enviar mensaje:', error);
+        socket.emit('error', { message: 'Error al enviar mensaje' });
+      }
+    });
+
+    socket.on('typing', (data) => {
+      const { conversacionId, userId, userName } = data;
+      socket.to(`conversation_${conversacionId}`).emit('user_typing', { userId, userName });
+    });
+
+    socket.on('stop_typing', (data) => {
+      const { conversacionId, userId } = data;
+      socket.to(`conversation_${conversacionId}`).emit('user_stop_typing', { userId });
+    });
+
+    socket.on('disconnect', () => {
+      for (let [userId, socketId] of connectedUsers.entries()) {
+        if (socketId === socket.id) {
+          connectedUsers.delete(userId);
+          console.log(`Usuario ${userId} desconectado`);
+          break;
+        }
+      }
+      console.log('Usuario desconectado:', socket.id);
+    });
+  });
+}
+
+export { connectedUsers };