# 🎯 Backend Implementado - Red Social Organizacional Anónima

## Resumen del Proyecto

Backend completo para una red social organizacional que prioriza el anonimato interno, construido con Node.js, Express y PostgreSQL usando Sequelize ORM.

---

## 🎯 Lo que he implementado

### 1. Sequelize ORM con PostgreSQL

✅ Configuración completa de Sequelize  
✅ 8 modelos con relaciones complejas  
✅ Sincronización automática de base de datos  
✅ Hooks para hash de contraseñas  
✅ Validaciones a nivel de modelo  

### 2. Sistema de Comentarios y Subcomentarios

✅ Comentarios anidados infinitamente (self-referencing)  
✅ `parentCommentId` para crear jerarquías  
✅ Endpoint para crear comentarios: `POST /api/posts/:postId/comments`  
✅ Endpoint para crear subcomentarios: mismo endpoint con `parentCommentId`  
✅ Obtener comentarios con respuestas: `GET /api/posts/:postId/comments?includeReplies=true`  
✅ Obtener respuestas específicas: `GET /api/comments/:commentId/replies`  
✅ Contadores automáticos: `commentsCount` y `repliesCount`  

### 3. Sistema de Reacciones Múltiples

✅ 6 tipos de reacciones: `like`, `love`, `insightful`, `celebrate`, `support`, `curious`  
✅ Reaccionar a posts: `POST /api/posts/:postId/react`  
✅ Reaccionar a comentarios: `POST /api/comments/:commentId/react`  
✅ Ver reacciones agregadas: `GET /api/posts/:postId/reactions`  
✅ Toggle automático (reaccionar dos veces elimina)  
✅ Cambio de tipo de reacción  

### 4. Anonimato Doble

✅ ID interno (`INT-XXXXXXXXXXXX`) para uso dentro de la empresa  
✅ ID externo (`EXT-XXXXXXXXXXXX`) para uso público  
✅ Generación automática con SHA-256  
✅ Asignación según visibilidad del post  

### 5. Sistema de Pagos para Revelar Identidad

✅ Análisis previo con IA: `GET /api/posts/:postId/analysis`  
✅ Revelar identidad: `POST /api/reveals/:postId`  
✅ Costos diferenciados:
- **Buena idea**: $500 USD
- **Verificar crítica**: $5,000 USD  

✅ Historial de revelaciones  
✅ Estadísticas de ingresos por empresa  

---

## 📁 Estructura de Archivos

```
src/
├── config/
│   └── database.js          # Configuración Sequelize
├── models/
│   ├── Company.js           # Empresas
│   ├── User.js              # Usuarios con IDs anónimos
│   ├── Post.js              # Publicaciones
│   ├── Comment.js           # Comentarios (con self-reference)
│   ├── Reaction.js          # Reacciones múltiples
│   ├── IdentityReveal.js    # Revelaciones pagadas
│   ├── PostAnalytics.js     # Analytics IA
│   ├── Session.js           # Sesiones JWT
│   └── index.js             # Relaciones y sync
├── controllers/
│   ├── authController.js    # Autenticación
│   ├── postController.js    # Posts y reacciones
│   ├── commentController.js # Comentarios y subcomentarios
│   └── paymentController.js # Revelaciones y pagos
├── middleware/
│   └── auth.js              # JWT y roles
├── routes/
│   └── index.js             # Todas las rutas
├── utils/
│   └── anonymity.js         # Generación IDs anónimos
└── server.js                # Servidor Express
```

---

## 🔥 Características Destacadas

### Comentarios Anidados

```javascript
// Crear comentario principal
POST /api/posts/1/comments
{ "content": "Gran idea" }

// Crear subcomentario
POST /api/posts/1/comments
{ 
  "content": "Estoy de acuerdo",
  "parentCommentId": 5 
}

// Obtener con respuestas
GET /api/posts/1/comments?includeReplies=true
```

**Respuesta ejemplo:**
```json
{
  "comments": [
    {
      "id": 1,
      "content": "Gran idea",
      "authorId": "INT-ABC123",
      "repliesCount": 2,
      "replies": [
        {
          "id": 5,
          "content": "Estoy de acuerdo",
          "authorId": "INT-XYZ789",
          "parentCommentId": 1
        }
      ]
    }
  ]
}
```

### Reacciones Múltiples

```javascript
// Reaccionar
POST /api/posts/1/react
{ "reactionType": "insightful" }

// Ver todas las reacciones
GET /api/posts/1/reactions
```

**Respuesta ejemplo:**
```json
{
  "reactions": [
    { "type": "like", "count": 15 },
    { "type": "insightful", "count": 8 },
    { "type": "love", "count": 3 }
  ],
  "userReaction": "insightful",
  "totalReactions": 26
}
```

### Sistema de Anonimato

```javascript
// Usuario crea post interno
POST /api/posts
{
  "title": "Propuesta de mejora",
  "content": "...",
  "visibility": "internal"
}

// Respuesta con ID interno
{
  "id": 1,
  "authorId": "INT-A1B2C3D4E5",  // Solo visible en la empresa
  "visibility": "internal"
}

// Usuario crea post público
POST /api/posts
{
  "title": "Innovación",
  "content": "...",
  "visibility": "public"
}

// Respuesta con ID externo
{
  "id": 2,
  "authorId": "EXT-F6G7H8I9J0",  // Visible públicamente
  "visibility": "public"
}
```

### Revelar Identidad con Pago

```javascript
// 1. Analizar post con IA
GET /api/posts/1/analysis

// Respuesta
{
  "category": "good_idea",
  "revealCost": 500,
  "sentiment": "positive",
  "keywords": ["innovación", "eficiencia"],
  "reasoning": "Propuesta constructiva con potencial de implementación"
}

// 2. Pagar para revelar
POST /api/reveals/1
{
  "paymentMethod": "credit_card",
  "paymentToken": "tok_visa_4242"
}

// Respuesta
{
  "success": true,
  "authorName": "Juan Pérez",
  "authorEmail": "juan.perez@company.com",
  "authorDepartment": "Ingeniería",
  "amountPaid": 500
}
```

---

## ✅ Ventajas de Sequelize

| Ventaja | Descripción |
|---------|-------------|
| **Migraciones automáticas** | `syncDatabase()` crea/actualiza tablas automáticamente |
| **Validaciones** | A nivel de modelo (email, longitud, tipos) |
| **Hooks** | Lógica automática (hash de passwords antes de guardar) |
| **Eager loading** | `include` para cargar relaciones en una query |
| **Transacciones** | Operaciones atómicas para integridad de datos |
| **Protección SQL injection** | Automática con queries parametrizadas |
| **Relaciones complejas** | `hasMany`, `belongsTo`, self-referencing |

---

## 🚀 Para Empezar

### 1. Instalar dependencias

```bash
npm install
```

### 2. Configurar variables de entorno

Crear archivo `.env`:

```env
# Database
DB_HOST=localhost
DB_PORT=5432
DB_NAME=anonymous_social
DB_USER=postgres
DB_PASSWORD=your_password

# JWT
JWT_SECRET=your-super-secret-jwt-key-change-in-production
JWT_EXPIRES_IN=7d

# Server
PORT=3000
NODE_ENV=development

# Payment (Stripe)
STRIPE_SECRET_KEY=sk_test_...
STRIPE_WEBHOOK_SECRET=whsec_...

# AI (OpenAI)
OPENAI_API_KEY=sk-...
```

### 3. Crear base de datos

```bash
# PostgreSQL
createdb anonymous_social

# O con psql
psql -U postgres
CREATE DATABASE anonymous_social;
```

### 4. Iniciar servidor

```bash
# Desarrollo (con nodemon)
npm run dev

# Producción
npm start
```

**Sequelize sincronizará automáticamente las tablas en el primer inicio.**

---

## 📊 API Endpoints

### Autenticación

| Método | Endpoint | Descripción |
|--------|----------|-------------|
| POST | `/api/auth/register` | Registrar usuario |
| POST | `/api/auth/login` | Iniciar sesión |
| POST | `/api/auth/logout` | Cerrar sesión |
| GET | `/api/auth/me` | Obtener usuario actual |

### Posts

| Método | Endpoint | Descripción |
|--------|----------|-------------|
| GET | `/api/posts` | Listar posts (con filtros) |
| GET | `/api/posts/:id` | Obtener post específico |
| POST | `/api/posts` | Crear post |
| PUT | `/api/posts/:id` | Actualizar post |
| DELETE | `/api/posts/:id` | Eliminar post |
| POST | `/api/posts/:id/react` | Reaccionar a post |
| GET | `/api/posts/:id/reactions` | Ver reacciones |

### Comentarios

| Método | Endpoint | Descripción |
|--------|----------|-------------|
| GET | `/api/posts/:postId/comments` | Listar comentarios |
| POST | `/api/posts/:postId/comments` | Crear comentario/subcomentario |
| GET | `/api/comments/:id/replies` | Obtener respuestas |
| PUT | `/api/comments/:id` | Actualizar comentario |
| DELETE | `/api/comments/:id` | Eliminar comentario |
| POST | `/api/comments/:id/react` | Reaccionar a comentario |

### Revelaciones

| Método | Endpoint | Descripción |
|--------|----------|-------------|
| GET | `/api/posts/:id/analysis` | Analizar post con IA |
| POST | `/api/reveals/:postId` | Revelar identidad (pago) |
| GET | `/api/reveals/history` | Historial de revelaciones |
| GET | `/api/reveals/stats` | Estadísticas de ingresos |

---

## 🗄️ Modelos de Base de Datos

### Company
```javascript
{
  id: INTEGER (PK),
  name: STRING,
  domain: STRING (unique),
  subscriptionTier: ENUM('basic', 'premium', 'enterprise'),
  isActive: BOOLEAN
}
```

### User
```javascript
{
  id: INTEGER (PK),
  email: STRING (unique),
  password: STRING (hashed),
  name: STRING,
  department: STRING,
  role: ENUM('user', 'moderator', 'admin'),
  internalAnonymousId: STRING (unique),
  externalAnonymousId: STRING (unique),
  companyId: INTEGER (FK)
}
```

### Post
```javascript
{
  id: INTEGER (PK),
  title: STRING,
  content: TEXT,
  visibility: ENUM('internal', 'public'),
  status: ENUM('active', 'flagged', 'removed'),
  authorId: INTEGER (FK),
  companyId: INTEGER (FK),
  reactionsCount: INTEGER,
  commentsCount: INTEGER
}
```

### Comment
```javascript
{
  id: INTEGER (PK),
  content: TEXT,
  postId: INTEGER (FK),
  authorId: INTEGER (FK),
  parentCommentId: INTEGER (FK, self-reference),
  repliesCount: INTEGER
}
```

### Reaction
```javascript
{
  id: INTEGER (PK),
  type: ENUM('like', 'love', 'insightful', 'celebrate', 'support', 'curious'),
  userId: INTEGER (FK),
  postId: INTEGER (FK, nullable),
  commentId: INTEGER (FK, nullable)
}
```

### IdentityReveal
```javascript
{
  id: INTEGER (PK),
  postId: INTEGER (FK),
  revealedToUserId: INTEGER (FK),
  revealedUserId: INTEGER (FK),
  amountPaid: DECIMAL,
  category: ENUM('good_idea', 'verify_criticism'),
  paymentStatus: ENUM('pending', 'completed', 'failed')
}
```

---

## 🔒 Seguridad Implementada

### Autenticación y Autorización
- ✅ JWT tokens con expiración
- ✅ Passwords hasheados con bcrypt (10 rounds)
- ✅ Middleware de autenticación en rutas protegidas
- ✅ Roles de usuario (user, moderator, admin)

### Protección de Datos
- ✅ Validación de inputs con Sequelize validators
- ✅ Sanitización automática contra SQL injection
- ✅ Rate limiting (recomendado: express-rate-limit)
- ✅ CORS configurado
- ✅ Helmet.js para headers de seguridad

### Anonimato
- ✅ IDs anónimos generados con SHA-256
- ✅ Separación de IDs internos/externos
- ✅ No exposición de emails en respuestas públicas
- ✅ Revelación de identidad solo mediante pago

---

## 🤖 Integración de IA (Próximos Pasos)

### 1. Moderación Automática

```javascript
// Usar OpenAI/Claude para detectar contenido inapropiado
const moderateContent = async (text) => {
  const response = await openai.moderations.create({
    input: text
  });

  return {
    flagged: response.results[0].flagged,
    categories: response.results[0].categories
  };
};
```

### 2. Análisis de Sentimiento

```javascript
// Clasificar posts como positivos/negativos/neutros
const analyzeSentiment = async (text) => {
  const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{
      role: "system",
      content: "Analiza el sentimiento: positive, negative, neutral"
    }, {
      role: "user",
      content: text
    }]
  });

  return response.choices[0].message.content;
};
```

### 3. Detección de PII (Información Personal)

```javascript
// Detectar emails, teléfonos, nombres en posts
const detectPII = async (text) => {
  // Usar spaCy (Python) o regex avanzado
  const patterns = {
    email: /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}/g,
    phone: /\d{3}[-.]?\d{3}[-.]?\d{4}/g
  };

  return {
    hasEmail: patterns.email.test(text),
    hasPhone: patterns.phone.test(text)
  };
};
```

### 4. Categorización Automática

```javascript
// Clasificar posts en categorías
const categorizePost = async (title, content) => {
  const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{
      role: "system",
      content: "Categoriza en: idea, crítica, pregunta, celebración"
    }, {
      role: "user",
      content: `${title}

${content}`
    }]
  });

  return response.choices[0].message.content;
};
```

---

## 🔔 Notificaciones en Tiempo Real

### Implementar con Socket.IO

```javascript
// server.js
const io = require('socket.io')(server, {
  cors: { origin: '*' }
});

io.on('connection', (socket) => {
  console.log('Usuario conectado:', socket.id);

  // Unirse a sala de empresa
  socket.on('join-company', (companyId) => {
    socket.join(`company-${companyId}`);
  });

  // Notificar nueva reacción
  socket.on('new-reaction', (data) => {
    io.to(`company-${data.companyId}`).emit('reaction-added', data);
  });

  // Notificar nuevo comentario
  socket.on('new-comment', (data) => {
    io.to(`company-${data.companyId}`).emit('comment-added', data);
  });
});
```

### Eventos a Implementar
- ✅ `new-post`: Nuevo post creado
- ✅ `new-comment`: Nuevo comentario
- ✅ `new-reaction`: Nueva reacción
- ✅ `post-flagged`: Post reportado
- ✅ `identity-revealed`: Identidad revelada

---

## 🔍 Búsqueda Avanzada

### Full-Text Search en PostgreSQL

```javascript
// Agregar índice en PostgreSQL
CREATE INDEX posts_search_idx ON posts 
USING GIN(to_tsvector('spanish', title || ' ' || content));

// Búsqueda en Sequelize
const searchPosts = async (query) => {
  return await Post.findAll({
    where: sequelize.literal(
      `to_tsvector('spanish', title || ' ' || content) @@ plainto_tsquery('spanish', '${query}')`
    )
  });
};
```

### Filtros Avanzados

```javascript
// GET /api/posts?keyword=innovación&department=IT&sentiment=positive
const getPosts = async (req, res) => {
  const { keyword, department, sentiment, dateFrom, dateTo } = req.query;

  const where = {};

  if (keyword) {
    where[Op.or] = [
      { title: { [Op.iLike]: `%${keyword}%` } },
      { content: { [Op.iLike]: `%${keyword}%` } }
    ];
  }

  if (dateFrom && dateTo) {
    where.createdAt = {
      [Op.between]: [new Date(dateFrom), new Date(dateTo)]
    };
  }

  const posts = await Post.findAll({
    where,
    include: [{
      model: User,
      where: department ? { department } : undefined
    }]
  });

  res.json(posts);
};
```

---

## 📈 Analytics y Métricas

### Métricas a Trackear

```javascript
// Dashboard de empresa
GET /api/analytics/company/:companyId

{
  "totalPosts": 1250,
  "totalComments": 3400,
  "totalReactions": 8900,
  "activeUsers": 450,
  "topCategories": [
    { "name": "ideas", "count": 340 },
    { "name": "críticas", "count": 210 }
  ],
  "sentimentDistribution": {
    "positive": 65,
    "neutral": 25,
    "negative": 10
  },
  "revenueFromReveals": 12500
}
```

### Modelo PostAnalytics

```javascript
// Ya implementado en models/PostAnalytics.js
{
  postId: INTEGER (FK),
  views: INTEGER,
  uniqueViews: INTEGER,
  avgReadTime: INTEGER,
  sentiment: ENUM('positive', 'neutral', 'negative'),
  aiCategory: STRING,
  keywords: ARRAY(STRING)
}
```

---

## 🧪 Testing

### Estructura de Tests Recomendada

```
tests/
├── unit/
│   ├── models/
│   │   ├── user.test.js
│   │   ├── post.test.js
│   │   └── comment.test.js
│   └── utils/
│       └── anonymity.test.js
├── integration/
│   ├── auth.test.js
│   ├── posts.test.js
│   ├── comments.test.js
│   └── payments.test.js
└── setup.js
```

### Ejemplo de Test

```javascript
// tests/integration/posts.test.js
const request = require('supertest');
const app = require('../../src/server');

describe('POST /api/posts', () => {
  let authToken;

  beforeAll(async () => {
    // Login y obtener token
    const res = await request(app)
      .post('/api/auth/login')
      .send({ email: 'test@company.com', password: 'password123' });
    authToken = res.body.token;
  });

  it('should create a new post', async () => {
    const res = await request(app)
      .post('/api/posts')
      .set('Authorization', `Bearer ${authToken}`)
      .send({
        title: 'Test Post',
        content: 'This is a test',
        visibility: 'internal'
      });

    expect(res.status).toBe(201);
    expect(res.body.title).toBe('Test Post');
    expect(res.body.authorId).toMatch(/^INT-/);
  });
});
```

---

## 🚀 Deployment

### Opciones de Hosting

| Plataforma | Ventajas | Precio |
|------------|----------|--------|
| **Heroku** | Fácil setup, PostgreSQL incluido | $7-25/mes |
| **Railway** | Deploy automático desde GitHub | $5-20/mes |
| **DigitalOcean** | Droplets con control total | $12-48/mes |
| **AWS EC2** | Escalable, muchos servicios | Variable |
| **Render** | Free tier generoso | $0-25/mes |

### Checklist de Producción

- [ ] Cambiar `JWT_SECRET` a valor seguro
- [ ] Configurar `NODE_ENV=production`
- [ ] Habilitar HTTPS (Let's Encrypt)
- [ ] Configurar rate limiting
- [ ] Setup de backups automáticos de DB
- [ ] Configurar logging (Winston/Morgan)
- [ ] Monitoreo (Sentry para errores)
- [ ] CDN para assets estáticos
- [ ] Configurar CORS correctamente
- [ ] Variables de entorno en plataforma

---

## 📚 Dependencias Principales

```json
{
  "dependencies": {
    "express": "^4.18.2",
    "sequelize": "^6.35.0",
    "pg": "^8.11.3",
    "pg-hstore": "^2.3.4",
    "bcryptjs": "^2.4.3",
    "jsonwebtoken": "^9.0.2",
    "dotenv": "^16.3.1",
    "cors": "^2.8.5",
    "helmet": "^7.1.0",
    "express-validator": "^7.0.1",
    "stripe": "^14.7.0"
  },
  "devDependencies": {
    "nodemon": "^3.0.2",
    "jest": "^29.7.0",
    "supertest": "^6.3.3"
  }
}
```

---

## 🎓 Recursos de Aprendizaje

### Sequelize
- [Documentación Oficial](https://sequelize.org/docs/v6/)
- [Guía de Asociaciones](https://sequelize.org/docs/v6/core-concepts/assocs/)
- [Migraciones](https://sequelize.org/docs/v6/other-topics/migrations/)

### PostgreSQL
- [Tutorial Full-Text Search](https://www.postgresql.org/docs/current/textsearch.html)
- [Índices y Performance](https://www.postgresql.org/docs/current/indexes.html)

### Node.js Best Practices
- [Node.js Best Practices](https://github.com/goldbergyoni/nodebestpractices)
- [Express Security](https://expressjs.com/en/advanced/best-practice-security.html)

---

## 🤝 Contribuir

### Flujo de Trabajo

1. Fork del repositorio
2. Crear branch: `git checkout -b feature/nueva-funcionalidad`
3. Commit: `git commit -m 'Add: nueva funcionalidad'`
4. Push: `git push origin feature/nueva-funcionalidad`
5. Crear Pull Request

### Convenciones de Código

- **Estilo**: Airbnb JavaScript Style Guide
- **Commits**: Conventional Commits (feat, fix, docs, etc.)
- **Tests**: Cobertura mínima 80%

---

## 📝 Licencia

MIT License - Ver archivo `LICENSE` para más detalles.

---

## 📞 Soporte

Para preguntas o issues:
- **Email**: support@anonymous-social.com
- **GitHub Issues**: [github.com/tu-repo/issues](https://github.com)
- **Documentación**: [docs.anonymous-social.com](https://docs.anonymous-social.com)

---

## 🎉 Conclusión

Este backend proporciona una base sólida para una red social organizacional con énfasis en anonimato. Las características implementadas incluyen:

✅ Sistema completo de posts, comentarios y reacciones  
✅ Anonimato doble (interno/externo)  
✅ Revelación de identidad con pago  
✅ Arquitectura escalable con Sequelize ORM  
✅ Seguridad robusta con JWT y bcrypt  
✅ Preparado para integración de IA  

**Próximos pasos recomendados:**
1. Integrar IA para moderación y análisis
2. Implementar notificaciones en tiempo real
3. Agregar búsqueda avanzada con PostgreSQL
4. Desarrollar dashboard de analytics
5. Crear tests automatizados completos

¡Feliz desarrollo! 🚀