Added two new apis

Co-authored-by: Copilot <copilot@github.com>

src/application/ports/metrics_repository.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import List, Dict
+from domain.metrics import Metric, DailyStats, AnalyticsReport
+
+
+class MetricsRepository(ABC):
+    """Puerto para persistencia de métricas"""
+    
+    @abstractmethod
+    def save_metric(self, metric: Metric) -> Metric:
+        """Guarda una métrica"""
+        pass
+    
+    @abstractmethod
+    def get_metrics_by_date_range(self, start_date: datetime, end_date: datetime) -> List[Metric]:
+        """Obtiene métricas en un rango de fechas"""
+        pass
+    
+    @abstractmethod
+    def get_daily_stats(self, date: datetime) -> List[DailyStats]:
+        """Obtiene estadísticas diarias"""
+        pass
+    
+    @abstractmethod
+    def get_event_count_by_type(self, start_date: datetime, end_date: datetime) -> Dict[str, int]:
+        """Obtiene conteo de eventos por tipo"""
+        pass
+    
+    @abstractmethod
+    def generate_report(self, start_date: datetime, end_date: datetime) -> AnalyticsReport:
+        """Genera reporte de analítica"""
+        pass

src/application/ports/moderation_repository.py

@@ -0,0 +1,43 @@
+"""Puerto de abstracción para repositorio de Moderaciones"""
+from abc import ABC, abstractmethod
+from domain.moderations import ModerationAction, ModerationLog
+from typing import List, Optional
+
+
+class ModerationRepository(ABC):
+    """Interfaz (puerto) para operaciones de persistencia de moderaciones"""
+    
+    @abstractmethod
+    def save_moderation_action(self, action: ModerationAction) -> bool:
+        """Guarda una acción de moderación"""
+        pass
+    
+    @abstractmethod
+    def get_moderation_action(self, action_id: str) -> Optional[ModerationAction]:
+        """Obtiene una acción de moderación por ID"""
+        pass
+    
+    @abstractmethod
+    def get_actions_by_moderator(self, moderator_id: int) -> List[ModerationAction]:
+        """Obtiene todas las acciones de un moderador"""
+        pass
+    
+    @abstractmethod
+    def get_actions_by_target(self, target_id: str, target_type: str) -> List[ModerationAction]:
+        """Obtiene todas las acciones sobre un target específico"""
+        pass
+    
+    @abstractmethod
+    def update_action_status(self, action_id: str, status: str) -> bool:
+        """Actualiza el estado de una acción"""
+        pass
+    
+    @abstractmethod
+    def save_moderation_log(self, log: ModerationLog) -> bool:
+        """Guarda un log de moderación"""
+        pass
+    
+    @abstractmethod
+    def get_moderation_logs(self, action_id: str) -> List[ModerationLog]:
+        """Obtiene todos los logs de una acción"""
+        pass

src/application/services/metrics_services.py

@@ -0,0 +1,39 @@
+from datetime import datetime, timedelta
+from typing import List, Dict
+from domain.metrics import Metric, DailyStats, AnalyticsReport, EventType
+from application.ports.metrics_repository import MetricsRepository
+
+
+class MetricsService:
+    """Servicio de lógica de negocio para métricas"""
+    
+    def __init__(self, repository: MetricsRepository):
+        self.repository = repository
+    
+    def record_event(self, event_type: str, entity_id: str, entity_type: str, 
+                     user_id: int = None, metadata: dict = None) -> Metric:
+        """Registra un evento de métrica"""
+        metric = Metric(
+            metric_id=None,
+            event_type=event_type,
+            entity_id=entity_id,
+            entity_type=entity_type,
+            timestamp=datetime.now(),
+            user_id=user_id,
+            metadata=metadata or {}
+        )
+        return self.repository.save_metric(metric)
+    
+    def get_metrics_report(self, days_back: int = 7) -> AnalyticsReport:
+        """Obtiene reporte de últimos N días"""
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_back)
+        return self.repository.generate_report(start_date, end_date)
+    
+    def get_daily_statistics(self, date: datetime) -> List[DailyStats]:
+        """Obtiene estadísticas de un día específico"""
+        return self.repository.get_daily_stats(date)
+    
+    def get_event_summary(self, start_date: datetime, end_date: datetime) -> Dict[str, int]:
+        """Obtiene resumen de eventos en rango"""
+        return self.repository.get_event_count_by_type(start_date, end_date)

src/application/services/moderation_services.py

@@ -0,0 +1,347 @@
+"""Servicios de aplicación para Moderación"""
+from domain.moderations import ModerationAction, ModerationLog
+from application.ports.moderation_repository import ModerationRepository
+from infrastructure.adapters.rabbitmq.sender import send_to_queue
+from infrastructure.adapters.rabbitmq.messages import ModerationMessage, ModerationEventType
+from datetime import datetime
+from typing import Dict, Any, Optional
+import uuid
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class DeleteReportUseCase:
+    """Use case para eliminar un reporte como moderador"""
+    def __init__(self, repo: ModerationRepository):
+        if not isinstance(repo, ModerationRepository):
+            raise TypeError("repo must implement ModerationRepository")
+        self.repo = repo
+    
+    def execute(self, moderator_id: int, report_id: str, reason: str, 
+                description: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Envía un evento a RabbitMQ para eliminar un reporte
+        
+        Args:
+            moderator_id: ID del moderador
+            report_id: ID del reporte a eliminar
+            reason: Razón de la eliminación
+            description: Descripción adicional
+            
+        Returns:
+            Dictionary con status y detalles
+        """
+        try:
+            action_id = str(uuid.uuid4())
+            
+            # Crear acción de moderación
+            action = ModerationAction(
+                action_id=action_id,
+                moderator_id=moderator_id,
+                action_type="delete_report",
+                target_type="report",
+                target_id=report_id,
+                reason=reason,
+                description=description,
+                status="pending",
+                fecha_creacion=datetime.now()
+            )
+            
+            # Guardar acción
+            self.repo.save_moderation_action(action)
+            
+            # Enviar evento a RabbitMQ
+            message = {
+                "action_id": action_id,
+                "event_type": "moderation.delete_report",
+                "moderator_id": moderator_id,
+                "report_id": report_id,
+                "reason": reason,
+                "description": description or "",
+                "timestamp": datetime.now().isoformat()
+            }
+            
+            send_to_queue('moderation_queue', message)
+            
+            return {
+                "status": "success",
+                "message": "Reporte marcado para eliminación",
+                "action_id": action_id
+            }
+        except Exception as e:
+            logger.error(f"Error deleting report: {e}")
+            return {
+                "status": "error",
+                "message": f"Error al eliminar reporte: {str(e)}"
+            }
+
+
+class CloseAccountUseCase:
+    """Use case para cerrar una cuenta de usuario"""
+    def __init__(self, repo: ModerationRepository):
+        if not isinstance(repo, ModerationRepository):
+            raise TypeError("repo must implement ModerationRepository")
+        self.repo = repo
+    
+    def execute(self, moderator_id: int, user_id: int, reason: str,
+                description: Optional[str] = None, is_permanent: bool = True) -> Dict[str, Any]:
+        """
+        Envía un evento para cerrar una cuenta de usuario
+        
+        Args:
+            moderator_id: ID del moderador
+            user_id: ID del usuario cuya cuenta cerrar
+            reason: Razón del cierre
+            description: Descripción adicional
+            is_permanent: Si el cierre es permanente o temporal
+            
+        Returns:
+            Dictionary con status y detalles
+        """
+        try:
+            action_id = str(uuid.uuid4())
+            
+            action = ModerationAction(
+                action_id=action_id,
+                moderator_id=moderator_id,
+                action_type="close_account",
+                target_type="user",
+                target_id=str(user_id),
+                reason=reason,
+                description=description,
+                is_permanent=is_permanent,
+                status="pending",
+                fecha_creacion=datetime.now()
+            )
+            
+            self.repo.save_moderation_action(action)
+            
+            message = {
+                "action_id": action_id,
+                "event_type": "moderation.close_account",
+                "moderator_id": moderator_id,
+                "user_id": user_id,
+                "reason": reason,
+                "description": description or "",
+                "is_permanent": is_permanent,
+                "timestamp": datetime.now().isoformat()
+            }
+            
+            send_to_queue('moderation_queue', message)
+            
+            return {
+                "status": "success",
+                "message": "Cuenta marcada para cierre",
+                "action_id": action_id
+            }
+        except Exception as e:
+            logger.error(f"Error closing account: {e}")
+            return {
+                "status": "error",
+                "message": f"Error al cerrar cuenta: {str(e)}"
+            }
+
+
+class BanUserUseCase:
+    """Use case para banear un usuario"""
+    def __init__(self, repo: ModerationRepository):
+        if not isinstance(repo, ModerationRepository):
+            raise TypeError("repo must implement ModerationRepository")
+        self.repo = repo
+    
+    def execute(self, moderator_id: int, user_id: int, reason: str,
+                duration_days: Optional[int] = None, description: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Envía un evento para banear un usuario
+        
+        Args:
+            moderator_id: ID del moderador
+            user_id: ID del usuario a banear
+            reason: Razón del ban
+            duration_days: Duración en días (None para ban permanente)
+            description: Descripción adicional
+            
+        Returns:
+            Dictionary con status y detalles
+        """
+        try:
+            action_id = str(uuid.uuid4())
+            is_permanent = duration_days is None
+            
+            action = ModerationAction(
+                action_id=action_id,
+                moderator_id=moderator_id,
+                action_type="ban_user",
+                target_type="user",
+                target_id=str(user_id),
+                reason=reason,
+                description=description,
+                duration_days=duration_days,
+                is_permanent=is_permanent,
+                status="pending",
+                fecha_creacion=datetime.now()
+            )
+            
+            self.repo.save_moderation_action(action)
+            
+            message = {
+                "action_id": action_id,
+                "event_type": "moderation.ban_user",
+                "moderator_id": moderator_id,
+                "user_id": user_id,
+                "reason": reason,
+                "duration_days": duration_days,
+                "is_permanent": is_permanent,
+                "description": description or "",
+                "timestamp": datetime.now().isoformat()
+            }
+            
+            send_to_queue('moderation_queue', message)
+            
+            return {
+                "status": "success",
+                "message": "Usuario marcado para ban",
+                "action_id": action_id
+            }
+        except Exception as e:
+            logger.error(f"Error banning user: {e}")
+            return {
+                "status": "error",
+                "message": f"Error al banear usuario: {str(e)}"
+            }
+
+
+class WarnUserUseCase:
+    """Use case para advertir a un usuario"""
+    def __init__(self, repo: ModerationRepository):
+        if not isinstance(repo, ModerationRepository):
+            raise TypeError("repo must implement ModerationRepository")
+        self.repo = repo
+    
+    def execute(self, moderator_id: int, user_id: int, reason: str,
+                description: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Envía un evento para advertir a un usuario
+        
+        Args:
+            moderator_id: ID del moderador
+            user_id: ID del usuario a advertir
+            reason: Razón de la advertencia
+            description: Descripción adicional
+            
+        Returns:
+            Dictionary con status y detalles
+        """
+        try:
+            action_id = str(uuid.uuid4())
+            
+            action = ModerationAction(
+                action_id=action_id,
+                moderator_id=moderator_id,
+                action_type="warn_user",
+                target_type="user",
+                target_id=str(user_id),
+                reason=reason,
+                description=description,
+                status="pending",
+                fecha_creacion=datetime.now()
+            )
+            
+            self.repo.save_moderation_action(action)
+            
+            message = {
+                "action_id": action_id,
+                "event_type": "moderation.warn_user",
+                "moderator_id": moderator_id,
+                "user_id": user_id,
+                "reason": reason,
+                "description": description or "",
+                "timestamp": datetime.now().isoformat()
+            }
+            
+            send_to_queue('moderation_queue', message)
+            
+            return {
+                "status": "success",
+                "message": "Advertencia registrada",
+                "action_id": action_id
+            }
+        except Exception as e:
+            logger.error(f"Error warning user: {e}")
+            return {
+                "status": "error",
+                "message": f"Error al advertir usuario: {str(e)}"
+            }
+
+
+class ReviewContentUseCase:
+    """Use case para revisar contenido reportado"""
+    def __init__(self, repo: ModerationRepository):
+        if not isinstance(repo, ModerationRepository):
+            raise TypeError("repo must implement ModerationRepository")
+        self.repo = repo
+    
+    def execute(self, moderator_id: int, report_id: str, action: str,
+                reason: Optional[str] = None, notes: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Envía un evento para revisar y actuar sobre contenido reportado
+        
+        Args:
+            moderator_id: ID del moderador
+            report_id: ID del reporte
+            action: Acción a tomar (approve, reject, needs_more_info)
+            reason: Razón de la decisión
+            notes: Notas adicionales
+            
+        Returns:
+            Dictionary con status y detalles
+        """
+        try:
+            if action not in ["approve", "reject", "needs_more_info"]:
+                return {
+                    "status": "error",
+                    "message": "Acción inválida"
+                }
+            
+            action_id = str(uuid.uuid4())
+            
+            moderation_action = ModerationAction(
+                action_id=action_id,
+                moderator_id=moderator_id,
+                action_type="review_content",
+                target_type="report",
+                target_id=report_id,
+                reason=reason or action,
+                description=notes,
+                status="approved",
+                fecha_creacion=datetime.now(),
+                fecha_ejecucion=datetime.now()
+            )
+            
+            self.repo.save_moderation_action(moderation_action)
+            
+            message = {
+                "action_id": action_id,
+                "event_type": "moderation.review_content",
+                "moderator_id": moderator_id,
+                "report_id": report_id,
+                "review_action": action,
+                "reason": reason or "",
+                "notes": notes or "",
+                "timestamp": datetime.now().isoformat()
+            }
+            
+            send_to_queue('moderation_queue', message)
+            
+            return {
+                "status": "success",
+                "message": f"Revisión registrada: {action}",
+                "action_id": action_id
+            }
+        except Exception as e:
+            logger.error(f"Error reviewing content: {e}")
+            return {
+                "status": "error",
+                "message": f"Error al revisar contenido: {str(e)}"
+            }

src/consumers/metrics_consumer.py

@@ -0,0 +1,139 @@
+"""Metrics RabbitMQ Consumer - Processes system events and saves metrics"""
+import sys
+import os
+import logging
+from datetime import datetime
+
+# Add src to path to import modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from infrastructure.adapters.rabbitmq.consumer import RabbitMQConsumer
+from infrastructure.adapters.rabbitmq.messages import (
+    UserMessage, ReportMessage, NotificationMessage, ModerationMessage
+)
+from application.services.metrics_services import MetricsService
+from infrastructure.adapters.persistence.metrics_repository_postgres import MetricsRepositoryPostgres
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('logs/metrics_consumer.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+
+class MetricsConsumer:
+    """Consumer for all system events from RabbitMQ"""
+    
+    def __init__(self):
+        self.metrics_service = MetricsService(MetricsRepositoryPostgres())
+        
+        # Create separate consumers for each event type
+        self.user_consumer = RabbitMQConsumer(queue_name='users_queue')
+        self.report_consumer = RabbitMQConsumer(queue_name='reports_queue')
+        self.notification_consumer = RabbitMQConsumer(queue_name='notifications_queue')
+        self.moderation_consumer = RabbitMQConsumer(queue_name='moderations_queue')
+        
+        # Set callbacks
+        self.user_consumer.set_callback(self.process_user_event)
+        self.report_consumer.set_callback(self.process_report_event)
+        self.notification_consumer.set_callback(self.process_notification_event)
+        self.moderation_consumer.set_callback(self.process_moderation_event)
+    
+    def process_user_event(self, message_dict: dict):
+        """Procesa eventos de usuario"""
+        try:
+            message = UserMessage.from_dict(message_dict)
+            self.metrics_service.record_event(
+                event_type=f"user_{message.event_type.value}",
+                entity_id=str(message.user_id),
+                entity_type="user",
+                user_id=message.user_id,
+                metadata={"email": message.email}
+            )
+            logger.info(f"Métrica registrada: user_{message.event_type.value}")
+        except Exception as e:
+            logger.error(f"Error procesando evento de usuario: {e}")
+    
+    def process_report_event(self, message_dict: dict):
+        """Procesa eventos de reportes"""
+        try:
+            message = ReportMessage.from_dict(message_dict)
+            self.metrics_service.record_event(
+                event_type=f"report_{message.event_type.value}",
+                entity_id=str(message.report_id),
+                entity_type="report",
+                user_id=message.user_id,
+                metadata={"status": message.status}
+            )
+            logger.info(f"Métrica registrada: report_{message.event_type.value}")
+        except Exception as e:
+            logger.error(f"Error procesando evento de reporte: {e}")
+    
+    def process_notification_event(self, message_dict: dict):
+        """Procesa eventos de notificaciones"""
+        try:
+            message = NotificationMessage.from_dict(message_dict)
+            self.metrics_service.record_event(
+                event_type=f"notification_{message.event_type.value}",
+                entity_id=str(message.notification_id),
+                entity_type="notification",
+                user_id=message.user_id,
+                metadata={"type": message.notification_type}
+            )
+            logger.info(f"Métrica registrada: notification_{message.event_type.value}")
+        except Exception as e:
+            logger.error(f"Error procesando evento de notificación: {e}")
+    
+    def process_moderation_event(self, message_dict: dict):
+        """Procesa eventos de moderación"""
+        try:
+            message = ModerationMessage.from_dict(message_dict)
+            self.metrics_service.record_event(
+                event_type=f"moderation_{message.event_type.value}",
+                entity_id=str(message.moderation_id),
+                entity_type="moderation",
+                user_id=message.moderator_id,
+                metadata={"action": message.action}
+            )
+            logger.info(f"Métrica registrada: moderation_{message.event_type.value}")
+        except Exception as e:
+            logger.error(f"Error procesando evento de moderación: {e}")
+    
+    def start(self):
+        """Inicia todos los consumers"""
+        logger.info("Iniciando Metrics Consumer...")
+        try:
+            # Start consumers in separate threads
+            import threading
+            threads = [
+                threading.Thread(target=self.user_consumer.start, daemon=True),
+                threading.Thread(target=self.report_consumer.start, daemon=True),
+                threading.Thread(target=self.notification_consumer.start, daemon=True),
+                threading.Thread(target=self.moderation_consumer.start, daemon=True),
+            ]
+            for t in threads:
+                t.start()
+            
+            # Keep main thread alive
+            for t in threads:
+                t.join()
+        except KeyboardInterrupt:
+            logger.info("Metrics Consumer detenido")
+            self.stop()
+    
+    def stop(self):
+        """Detiene los consumers"""
+        self.user_consumer.stop()
+        self.report_consumer.stop()
+        self.notification_consumer.stop()
+        self.moderation_consumer.stop()
+
+
+if __name__ == "__main__":
+    consumer = MetricsConsumer()
+    consumer.start()

src/consumers/moderation_consumer.py

@@ -0,0 +1,174 @@
+"""Consumidor de eventos de Moderación desde RabbitMQ"""
+import pika
+import json
+import logging
+from datetime import datetime
+from threading import Thread
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+class ModerationConsumer:
+    """Consumidor de eventos de moderación desde RabbitMQ"""
+    
+    def __init__(self, host: str = 'localhost', port: int = 5672):
+        self.host = host
+        self.port = port
+        self.queue_name = 'moderation_queue'
+        self.running = False
+    
+    def start(self):
+        """Inicia el consumidor en un thread separado"""
+        thread = Thread(target=self._consume, daemon=True)
+        thread.start()
+        logger.info("Moderation Consumer started")
+    
+    def _consume(self):
+        """Consume mensajes de RabbitMQ"""
+        try:
+            connection = pika.BlockingConnection(
+                pika.ConnectionParameters(host=self.host, port=self.port)
+            )
+            channel = connection.channel()
+            
+            # Declarar cola
+            channel.queue_declare(queue=self.queue_name, durable=True)
+            
+            # Configurar QoS
+            channel.basic_qos(prefetch_count=1)
+            
+            # Configurar callback
+            channel.basic_consume(
+                queue=self.queue_name,
+                on_message_callback=self._process_message
+            )
+            
+            logger.info(f"Moderation Consumer listening on {self.queue_name}")
+            self.running = True
+            channel.start_consuming()
+            
+        except Exception as e:
+            logger.error(f"Error in moderation consumer: {e}")
+            self.running = False
+    
+    def _process_message(self, ch, method, properties, body):
+        """Procesa un mensaje de moderación"""
+        try:
+            message = json.loads(body)
+            logger.info(f"Processing moderation event: {message.get('event_type')}")
+            
+            event_type = message.get('event_type')
+            
+            if event_type == 'moderation.delete_report':
+                self._handle_delete_report(message)
+            elif event_type == 'moderation.close_account':
+                self._handle_close_account(message)
+            elif event_type == 'moderation.ban_user':
+                self._handle_ban_user(message)
+            elif event_type == 'moderation.warn_user':
+                self._handle_warn_user(message)
+            elif event_type == 'moderation.review_content':
+                self._handle_review_content(message)
+            else:
+                logger.warning(f"Unknown moderation event type: {event_type}")
+            
+            # Confirmar mensaje
+            ch.basic_ack(delivery_tag=method.delivery_tag)
+            
+        except json.JSONDecodeError:
+            logger.error("Error decoding JSON message")
+            ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False)
+        except Exception as e:
+            logger.error(f"Error processing moderation message: {e}")
+            ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
+    
+    def _handle_delete_report(self, message: Dict[str, Any]):
+        """Maneja evento de eliminación de reporte"""
+        try:
+            action_id = message.get('action_id')
+            report_id = message.get('report_id')
+            reason = message.get('reason')
+            
+            logger.info(f"Deleting report {report_id} (Action: {action_id})")
+            
+            # Aquí implementarías la lógica para eliminar el reporte en la BD
+            # Por ahora solo registramos el evento
+            logger.info(f"Report {report_id} marked as deleted by moderator {message.get('moderator_id')}")
+            
+        except Exception as e:
+            logger.error(f"Error handling delete report: {e}")
+            raise
+    
+    def _handle_close_account(self, message: Dict[str, Any]):
+        """Maneja evento de cierre de cuenta"""
+        try:
+            action_id = message.get('action_id')
+            user_id = message.get('user_id')
+            is_permanent = message.get('is_permanent', True)
+            
+            logger.info(f"Closing account for user {user_id} (Action: {action_id}, Permanent: {is_permanent})")
+            
+            # Aquí implementarías la lógica para cerrar la cuenta en la BD
+            logger.info(f"Account for user {user_id} marked as closed")
+            
+        except Exception as e:
+            logger.error(f"Error handling close account: {e}")
+            raise
+    
+    def _handle_ban_user(self, message: Dict[str, Any]):
+        """Maneja evento de ban de usuario"""
+        try:
+            action_id = message.get('action_id')
+            user_id = message.get('user_id')
+            duration_days = message.get('duration_days')
+            is_permanent = message.get('is_permanent', False)
+            reason = message.get('reason')
+            
+            logger.info(f"Banning user {user_id} (Action: {action_id}, Duration: {duration_days} days, Permanent: {is_permanent})")
+            
+            # Aquí implementarías la lógica para banear al usuario
+            if is_permanent:
+                logger.info(f"User {user_id} permanently banned")
+            else:
+                logger.info(f"User {user_id} banned for {duration_days} days")
+            
+        except Exception as e:
+            logger.error(f"Error handling ban user: {e}")
+            raise
+    
+    def _handle_warn_user(self, message: Dict[str, Any]):
+        """Maneja evento de advertencia a usuario"""
+        try:
+            action_id = message.get('action_id')
+            user_id = message.get('user_id')
+            reason = message.get('reason')
+            
+            logger.info(f"Warning user {user_id} (Action: {action_id}, Reason: {reason})")
+            
+            # Aquí implementarías la lógica para registrar la advertencia
+            logger.info(f"Warning recorded for user {user_id}")
+            
+        except Exception as e:
+            logger.error(f"Error handling warn user: {e}")
+            raise
+    
+    def _handle_review_content(self, message: Dict[str, Any]):
+        """Maneja evento de revisión de contenido"""
+        try:
+            action_id = message.get('action_id')
+            report_id = message.get('report_id')
+            review_action = message.get('review_action')  # approve, reject, needs_more_info
+            
+            logger.info(f"Reviewing report {report_id} (Action: {action_id}, Decision: {review_action})")
+            
+            # Aquí implementarías la lógica para procesar la revisión
+            logger.info(f"Report {report_id} review: {review_action}")
+            
+        except Exception as e:
+            logger.error(f"Error handling review content: {e}")
+            raise
+
+
+# Crear instancia global
+moderation_consumer = ModerationConsumer()

src/domain/metrics.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+from enum import Enum
+
+
+class EventType(str, Enum):
+    """Tipos de eventos que se rastrean"""
+    USER_CREATED = "user_created"
+    USER_UPDATED = "user_updated"
+    USER_DELETED = "user_deleted"
+    REPORT_CREATED = "report_created"
+    REPORT_RESOLVED = "report_resolved"
+    NOTIFICATION_SENT = "notification_sent"
+    MODERATION_COMPLETED = "moderation_completed"
+
+
+@dataclass
+class Metric:
+    """Modelo de dominio para Métrica"""
+    metric_id: int
+    event_type: str
+    entity_id: str
+    entity_type: str
+    timestamp: datetime
+    metadata: dict = field(default_factory=dict)
+    user_id: Optional[int] = None
+    
+    
+@dataclass
+class DailyStats:
+    """Estadísticas diarias"""
+    date: datetime
+    event_type: str
+    count: int
+    
+    
+@dataclass
+class AnalyticsReport:
+    """Reporte de analítica"""
+    report_id: int
+    start_date: datetime
+    end_date: datetime
+    total_events: int
+    events_by_type: dict
+    creation_date: datetime = field(default_factory=datetime.now)

src/domain/moderations.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional, Literal
+
+@dataclass
+class ModerationAction:
+    """Modelo de dominio para Acciones de Moderación"""
+    action_id: str
+    moderator_id: int
+    action_type: Literal["delete_report", "close_account", "ban_user", "warn_user", "review_content"]
+    target_type: Literal["report", "user"]
+    target_id: str  # ID del reporte o usuario afectado
+    reason: str
+    description: Optional[str] = None
+    duration_days: Optional[int] = None  # Para bans temporales
+    is_permanent: bool = False
+    status: Literal["pending", "approved", "rejected", "executed"] = "pending"
+    fecha_creacion: Optional[datetime] = None
+    fecha_ejecucion: Optional[datetime] = None
+    observaciones: Optional[str] = None
+
+
+@dataclass
+class ModerationLog:
+    """Log de todas las acciones de moderación realizadas"""
+    log_id: str
+    action_id: str
+    moderator_id: int
+    action_type: str
+    target_type: str
+    target_id: str
+    resultado: Literal["success", "failed", "pending"]
+    mensaje: Optional[str] = None
+    fecha_log: Optional[datetime] = None
+    ip_moderator: Optional[str] = None

src/infrastructure/adapters/moderation_repository_mongo.py

@@ -0,0 +1,176 @@
+"""Adaptador de repositorio de Moderación con MongoDB"""
+from application.ports.moderation_repository import ModerationRepository
+from domain.moderations import ModerationAction, ModerationLog
+from typing import List, Optional
+import logging
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class ModerationRepositoryMongo(ModerationRepository):
+    """Implementación de ModerationRepository usando MongoDB"""
+    
+    def __init__(self):
+        self.db = None
+        self.moderation_actions_collection = None
+        self.moderation_logs_collection = None
+        self._initialize_db()
+    
+    def _initialize_db(self):
+        """Inicializa conexión a MongoDB"""
+        try:
+            from infrastructure.adapters.persistence.mongodb import mongo_db
+            self.db = mongo_db
+            
+            # Obtener o crear colecciones
+            self.moderation_actions_collection = self.db['moderation_actions']
+            self.moderation_logs_collection = self.db['moderation_logs']
+            
+            # Crear índices
+            self.moderation_actions_collection.create_index('action_id')
+            self.moderation_actions_collection.create_index('moderator_id')
+            self.moderation_actions_collection.create_index('target_id')
+            self.moderation_logs_collection.create_index('action_id')
+            
+            logger.info("Moderation MongoDB adapter initialized")
+        except Exception as e:
+            logger.error(f"Error initializing MongoDB for moderations: {e}")
+            raise
+    
+    def save_moderation_action(self, action: ModerationAction) -> bool:
+        """Guarda una acción de moderación en MongoDB"""
+        try:
+            action_dict = {
+                'action_id': action.action_id,
+                'moderator_id': action.moderator_id,
+                'action_type': action.action_type,
+                'target_type': action.target_type,
+                'target_id': action.target_id,
+                'reason': action.reason,
+                'description': action.description,
+                'duration_days': action.duration_days,
+                'is_permanent': action.is_permanent,
+                'status': action.status,
+                'fecha_creacion': action.fecha_creacion or datetime.now(),
+                'fecha_ejecucion': action.fecha_ejecucion,
+                'observaciones': action.observaciones
+            }
+            
+            self.moderation_actions_collection.insert_one(action_dict)
+            logger.info(f"Moderation action saved: {action.action_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Error saving moderation action: {e}")
+            return False
+    
+    def get_moderation_action(self, action_id: str) -> Optional[ModerationAction]:
+        """Obtiene una acción de moderación por ID"""
+        try:
+            doc = self.moderation_actions_collection.find_one({'action_id': action_id})
+            if doc:
+                return self._doc_to_moderation_action(doc)
+            return None
+        except Exception as e:
+            logger.error(f"Error getting moderation action: {e}")
+            return None
+    
+    def get_actions_by_moderator(self, moderator_id: int) -> List[ModerationAction]:
+        """Obtiene todas las acciones de un moderador"""
+        try:
+            docs = self.moderation_actions_collection.find({'moderator_id': moderator_id})
+            return [self._doc_to_moderation_action(doc) for doc in docs]
+        except Exception as e:
+            logger.error(f"Error getting actions by moderator: {e}")
+            return []
+    
+    def get_actions_by_target(self, target_id: str, target_type: str) -> List[ModerationAction]:
+        """Obtiene todas las acciones sobre un target específico"""
+        try:
+            docs = self.moderation_actions_collection.find({
+                'target_id': target_id,
+                'target_type': target_type
+            })
+            return [self._doc_to_moderation_action(doc) for doc in docs]
+        except Exception as e:
+            logger.error(f"Error getting actions by target: {e}")
+            return []
+    
+    def update_action_status(self, action_id: str, status: str) -> bool:
+        """Actualiza el estado de una acción"""
+        try:
+            result = self.moderation_actions_collection.update_one(
+                {'action_id': action_id},
+                {'$set': {'status': status}}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating action status: {e}")
+            return False
+    
+    def save_moderation_log(self, log: ModerationLog) -> bool:
+        """Guarda un log de moderación"""
+        try:
+            log_dict = {
+                'log_id': log.log_id,
+                'action_id': log.action_id,
+                'moderator_id': log.moderator_id,
+                'action_type': log.action_type,
+                'target_type': log.target_type,
+                'target_id': log.target_id,
+                'resultado': log.resultado,
+                'mensaje': log.mensaje,
+                'fecha_log': log.fecha_log or datetime.now(),
+                'ip_moderator': log.ip_moderator
+            }
+            
+            self.moderation_logs_collection.insert_one(log_dict)
+            logger.info(f"Moderation log saved: {log.log_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Error saving moderation log: {e}")
+            return False
+    
+    def get_moderation_logs(self, action_id: str) -> List[ModerationLog]:
+        """Obtiene todos los logs de una acción"""
+        try:
+            docs = self.moderation_logs_collection.find({'action_id': action_id})
+            return [self._doc_to_moderation_log(doc) for doc in docs]
+        except Exception as e:
+            logger.error(f"Error getting moderation logs: {e}")
+            return []
+    
+    @staticmethod
+    def _doc_to_moderation_action(doc: dict) -> ModerationAction:
+        """Convierte un documento de MongoDB a ModerationAction"""
+        return ModerationAction(
+            action_id=doc.get('action_id'),
+            moderator_id=doc.get('moderator_id'),
+            action_type=doc.get('action_type'),
+            target_type=doc.get('target_type'),
+            target_id=doc.get('target_id'),
+            reason=doc.get('reason'),
+            description=doc.get('description'),
+            duration_days=doc.get('duration_days'),
+            is_permanent=doc.get('is_permanent', False),
+            status=doc.get('status', 'pending'),
+            fecha_creacion=doc.get('fecha_creacion'),
+            fecha_ejecucion=doc.get('fecha_ejecucion'),
+            observaciones=doc.get('observaciones')
+        )
+    
+    @staticmethod
+    def _doc_to_moderation_log(doc: dict) -> ModerationLog:
+        """Convierte un documento de MongoDB a ModerationLog"""
+        return ModerationLog(
+            log_id=doc.get('log_id'),
+            action_id=doc.get('action_id'),
+            moderator_id=doc.get('moderator_id'),
+            action_type=doc.get('action_type'),
+            target_type=doc.get('target_type'),
+            target_id=doc.get('target_id'),
+            resultado=doc.get('resultado'),
+            mensaje=doc.get('mensaje'),
+            fecha_log=doc.get('fecha_log'),
+            ip_moderator=doc.get('ip_moderator')
+        )

src/infrastructure/adapters/persistence/metrics_repository_postgres.py

@@ -0,0 +1,136 @@
+from datetime import datetime
+from typing import List, Dict, Optional
+from sqlalchemy import Column, Integer, String, DateTime, JSON, create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+from sqlalchemy.sql import func
+
+from domain.metrics import Metric, DailyStats, AnalyticsReport, EventType
+from application.ports.metrics_repository import MetricsRepository
+from core.config import ConfSettings
+
+Base = declarative_base()
+
+
+class MetricModel(Base):
+    """Modelo SQLAlchemy para métricas en Postgres"""
+    __tablename__ = "metrics"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    event_type = Column(String, nullable=False, index=True)
+    entity_id = Column(String, nullable=False)
+    entity_type = Column(String, nullable=False)
+    timestamp = Column(DateTime, nullable=False, default=datetime.now, index=True)
+    metadata = Column(JSON, default={})
+    user_id = Column(Integer, nullable=True)
+
+
+class MetricsRepositoryPostgres(MetricsRepository):
+    """Implementación de repositorio de métricas con PostgreSQL"""
+    
+    def __init__(self):
+        db_url = f"postgresql://voxpopuli:voxpopuli_pass@localhost:5432/voxpopuli_metrics"
+        self.engine = create_engine(db_url, echo=False)
+        Base.metadata.create_all(self.engine)
+        self.SessionLocal = sessionmaker(bind=self.engine)
+    
+    def save_metric(self, metric: Metric) -> Metric:
+        """Guarda una métrica en la base de datos"""
+        session = self.SessionLocal()
+        try:
+            db_metric = MetricModel(
+                event_type=metric.event_type,
+                entity_id=metric.entity_id,
+                entity_type=metric.entity_type,
+                timestamp=metric.timestamp,
+                metadata=metric.metadata,
+                user_id=metric.user_id
+            )
+            session.add(db_metric)
+            session.commit()
+            metric.metric_id = db_metric.id
+            return metric
+        finally:
+            session.close()
+    
+    def get_metrics_by_date_range(self, start_date: datetime, end_date: datetime) -> List[Metric]:
+        """Obtiene métricas en un rango de fechas"""
+        session = self.SessionLocal()
+        try:
+            db_metrics = session.query(MetricModel).filter(
+                MetricModel.timestamp >= start_date,
+                MetricModel.timestamp <= end_date
+            ).all()
+            
+            return [
+                Metric(
+                    metric_id=m.id,
+                    event_type=m.event_type,
+                    entity_id=m.entity_id,
+                    entity_type=m.entity_type,
+                    timestamp=m.timestamp,
+                    metadata=m.metadata or {},
+                    user_id=m.user_id
+                )
+                for m in db_metrics
+            ]
+        finally:
+            session.close()
+    
+    def get_daily_stats(self, date: datetime) -> List[DailyStats]:
+        """Obtiene estadísticas diarias"""
+        session = self.SessionLocal()
+        try:
+            start = datetime(date.year, date.month, date.day)
+            end = datetime(date.year, date.month, date.day, 23, 59, 59)
+            
+            results = session.query(
+                MetricModel.event_type,
+                func.count(MetricModel.id).label('count')
+            ).filter(
+                MetricModel.timestamp >= start,
+                MetricModel.timestamp <= end
+            ).group_by(MetricModel.event_type).all()
+            
+            return [
+                DailyStats(date=date, event_type=r[0], count=r[1])
+                for r in results
+            ]
+        finally:
+            session.close()
+    
+    def get_event_count_by_type(self, start_date: datetime, end_date: datetime) -> Dict[str, int]:
+        """Obtiene conteo de eventos por tipo"""
+        session = self.SessionLocal()
+        try:
+            results = session.query(
+                MetricModel.event_type,
+                func.count(MetricModel.id).label('count')
+            ).filter(
+                MetricModel.timestamp >= start_date,
+                MetricModel.timestamp <= end_date
+            ).group_by(MetricModel.event_type).all()
+            
+            return {r[0]: r[1] for r in results}
+        finally:
+            session.close()
+    
+    def generate_report(self, start_date: datetime, end_date: datetime) -> AnalyticsReport:
+        """Genera reporte de analítica"""
+        session = self.SessionLocal()
+        try:
+            total_events = session.query(func.count(MetricModel.id)).filter(
+                MetricModel.timestamp >= start_date,
+                MetricModel.timestamp <= end_date
+            ).scalar() or 0
+            
+            events_by_type = self.get_event_count_by_type(start_date, end_date)
+            
+            return AnalyticsReport(
+                report_id=None,
+                start_date=start_date,
+                end_date=end_date,
+                total_events=total_events,
+                events_by_type=events_by_type
+            )
+        finally:
+            session.close()

src/infrastructure/adapters/rabbitmq/messages.py

@@ -27,6 +27,15 @@ class NotificationEventType(str, Enum):
     REPORT_STATUS_CHANGE = "notification.report_status_change"
 
 
+class ModerationEventType(str, Enum):
+    """Types of moderation events"""
+    DELETE_REPORT = "moderation.delete_report"
+    CLOSE_ACCOUNT = "moderation.close_account"
+    BAN_USER = "moderation.ban_user"
+    WARN_USER = "moderation.warn_user"
+    REVIEW_CONTENT = "moderation.review_content"
+
+
 @dataclass
 class UserMessage:
     """Message for user events"""
@@ -122,3 +131,36 @@ class NotificationMessage:
         """Create from dictionary"""
         data['event_type'] = NotificationEventType(data['event_type'])
         return NotificationMessage(**data)
+
+
+@dataclass
+class ModerationMessage:
+    """Message for moderation events"""
+    event_type: ModerationEventType
+    action_id: Optional[str] = None
+    moderator_id: Optional[int] = None
+    report_id: Optional[str] = None
+    user_id: Optional[int] = None
+    reason: Optional[str] = None
+    description: Optional[str] = None
+    duration_days: Optional[int] = None  # Para bans temporales
+    is_permanent: Optional[bool] = None
+    review_action: Optional[str] = None  # approve, reject, needs_more_info
+    notes: Optional[str] = None
+    fecha_creacion: Optional[str] = None  # ISO format datetime string
+    
+    def to_dict(self):
+        """Convert to dictionary"""
+        data = asdict(self)
+        data['event_type'] = self.event_type.value
+        return data
+    
+    def to_json(self) -> str:
+        """Convert to JSON string"""
+        return json.dumps(self.to_dict())
+    
+    @staticmethod
+    def from_dict(data: dict) -> 'ModerationMessage':
+        """Create from dictionary"""
+        data['event_type'] = ModerationEventType(data['event_type'])
+        return ModerationMessage(**data)

src/infrastructure/api/metrics/__init__.py

@@ -0,0 +1 @@
+# Metrics API

src/infrastructure/api/metrics/app.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+from infrastructure.api.metrics.router import router
+
+
+def create_app() -> FastAPI:
+    """Factory para crear la aplicación de Métricas"""
+    app = FastAPI(
+        title="Métricas Microservice",
+        version="1.0.0",
+        description="Microservicio de métricas y analítica"
+    )
+    app.include_router(router)
+    return app

src/infrastructure/api/metrics/router.py

@@ -0,0 +1,80 @@
+from fastapi import APIRouter, Query
+from datetime import datetime, timedelta
+from infrastructure.api.metrics.schemas import (
+    MetricRequest, MetricResponse, AnalyticsReportResponse,
+    EventSummaryResponse, DailyStatsResponse
+)
+from application.services.metrics_services import MetricsService
+from infrastructure.adapters.persistence.metrics_repository_postgres import MetricsRepositoryPostgres
+from domain.metrics import Metric
+
+router = APIRouter(prefix="/metrics", tags=["metrics"])
+metrics_service = MetricsService(MetricsRepositoryPostgres())
+
+
+@router.post("/record", response_model=MetricResponse)
+async def record_metric(metric: MetricRequest):
+    """Registra un nuevo evento de métrica"""
+    saved_metric = metrics_service.record_event(
+        event_type=metric.event_type,
+        entity_id=metric.entity_id,
+        entity_type=metric.entity_type,
+        user_id=metric.user_id,
+        metadata=metric.metadata
+    )
+    return {
+        "metric_id": saved_metric.metric_id,
+        "event_type": saved_metric.event_type,
+        "entity_id": saved_metric.entity_id,
+        "entity_type": saved_metric.entity_type,
+        "timestamp": saved_metric.timestamp,
+        "user_id": saved_metric.user_id
+    }
+
+
+@router.get("/report", response_model=AnalyticsReportResponse)
+async def get_analytics_report(days: int = Query(7, ge=1, le=365)):
+    """Obtiene reporte de analítica de los últimos N días"""
+    report = metrics_service.get_metrics_report(days_back=days)
+    return {
+        "start_date": report.start_date,
+        "end_date": report.end_date,
+        "total_events": report.total_events,
+        "events_by_type": report.events_by_type
+    }
+
+
+@router.get("/daily-stats", response_model=list[DailyStatsResponse])
+async def get_daily_stats(date: datetime = Query(default_factory=datetime.now)):
+    """Obtiene estadísticas de un día específico"""
+    stats = metrics_service.get_daily_statistics(date)
+    return [
+        {
+            "date": s.date,
+            "event_type": s.event_type,
+            "count": s.count
+        }
+        for s in stats
+    ]
+
+
+@router.get("/summary", response_model=EventSummaryResponse)
+async def get_event_summary(
+    start_date: datetime = Query(default_factory=lambda: datetime.now() - timedelta(days=7)),
+    end_date: datetime = Query(default_factory=datetime.now)
+):
+    """Obtiene resumen de eventos en un rango de fechas"""
+    summary = metrics_service.get_event_summary(start_date, end_date)
+    return {
+        "summary": summary,
+        "date_range": {
+            "start_date": start_date,
+            "end_date": end_date
+        }
+    }
+
+
+@router.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy"}

src/infrastructure/api/metrics/schemas.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel
+from datetime import datetime
+from typing import Dict, List, Optional
+
+
+class MetricRequest(BaseModel):
+    """Esquema para crear una métrica"""
+    event_type: str
+    entity_id: str
+    entity_type: str
+    user_id: Optional[int] = None
+    metadata: Optional[Dict] = None
+
+
+class MetricResponse(BaseModel):
+    """Esquema de respuesta para métrica"""
+    metric_id: int
+    event_type: str
+    entity_id: str
+    entity_type: str
+    timestamp: datetime
+    user_id: Optional[int]
+
+
+class DailyStatsResponse(BaseModel):
+    """Esquema de estadísticas diarias"""
+    date: datetime
+    event_type: str
+    count: int
+
+
+class AnalyticsReportResponse(BaseModel):
+    """Esquema de reporte de analítica"""
+    start_date: datetime
+    end_date: datetime
+    total_events: int
+    events_by_type: Dict[str, int]
+
+
+class EventSummaryResponse(BaseModel):
+    """Esquema de resumen de eventos"""
+    summary: Dict[str, int]
+    date_range: Dict[str, datetime]

src/infrastructure/api/moderations/app.py

@@ -0,0 +1,46 @@
+"""Aplicación FastAPI para API de Moderación"""
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from infrastructure.api.moderations.router import router
+from core.config import ConfSettings
+import logging
+
+# Configurar logging
+logging.basicConfig(
+    level=ConfSettings.log_level.upper(),
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def create_app() -> FastAPI:
+    """
+    Factory function para crear la aplicación FastAPI de Moderación
+    
+    Returns:
+        FastAPI application instance
+    """
+    app = FastAPI(
+        title="VoxPopuli Moderation API",
+        description="API para gestión de acciones de moderación en VoxPopuli",
+        version="1.0.0",
+        docs_url="/docs",
+        redoc_url="/redoc",
+        openapi_url="/openapi.json"
+    )
+    
+    # Agregar CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=ConfSettings.cors_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    # Incluir rutas
+    app.include_router(router)
+    
+    logger.info("Moderation API initialized")
+    
+    return app

src/infrastructure/api/moderations/moderations.py

@@ -0,0 +1,182 @@
+"""Endpoints de moderación para gestión de reportes, cuentas y usuarios"""
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import JSONResponse
+from infrastructure.api.moderations.schemas import (
+    DeleteReportRequest,
+    CloseAccountRequest,
+    BanUserRequest,
+    WarnUserRequest,
+    ReviewContentRequest,
+    ModerationActionResponse
+)
+from application.services.moderation_services import (
+    DeleteReportUseCase,
+    CloseAccountUseCase,
+    BanUserUseCase,
+    WarnUserUseCase,
+    ReviewContentUseCase
+)
+from infrastructure.adapters.persistence.mongodb import mongo_db
+from infrastructure.adapters.persistence.db import get_db
+from infrastructure.adapters.moderation_repository_mongo import ModerationRepositoryMongo
+from sqlalchemy.orm import Session
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# Instanciar repositorio de moderación
+moderation_repo = ModerationRepositoryMongo()
+
+
+@router.post("/reports/delete", response_model=ModerationActionResponse)
+async def delete_report(request: DeleteReportRequest):
+    """
+    Eliminar un reporte como moderador
+    
+    - **moderator_id**: ID del moderador que ejecuta la acción
+    - **report_id**: ID del reporte a eliminar
+    - **reason**: Razón de la eliminación (mínimo 5 caracteres)
+    - **description**: Descripción adicional (opcional)
+    """
+    try:
+        use_case = DeleteReportUseCase(moderation_repo)
+        result = use_case.execute(
+            moderator_id=request.moderator_id,
+            report_id=request.report_id,
+            reason=request.reason,
+            description=request.description
+        )
+        
+        if result["status"] == "error":
+            raise HTTPException(status_code=400, detail=result["message"])
+        
+        return ModerationActionResponse(**result)
+    
+    except Exception as e:
+        logger.error(f"Error in delete_report: {e}")
+        raise HTTPException(status_code=500, detail="Error interno del servidor")
+
+
+@router.post("/accounts/close", response_model=ModerationActionResponse)
+async def close_account(request: CloseAccountRequest):
+    """
+    Cerrar una cuenta de usuario
+    
+    - **moderator_id**: ID del moderador
+    - **user_id**: ID del usuario cuya cuenta cerrar
+    - **reason**: Razón del cierre (mínimo 5 caracteres)
+    - **description**: Descripción adicional (opcional)
+    - **is_permanent**: Si el cierre es permanente (por defecto True)
+    """
+    try:
+        use_case = CloseAccountUseCase(moderation_repo)
+        result = use_case.execute(
+            moderator_id=request.moderator_id,
+            user_id=request.user_id,
+            reason=request.reason,
+            description=request.description,
+            is_permanent=request.is_permanent
+        )
+        
+        if result["status"] == "error":
+            raise HTTPException(status_code=400, detail=result["message"])
+        
+        return ModerationActionResponse(**result)
+    
+    except Exception as e:
+        logger.error(f"Error in close_account: {e}")
+        raise HTTPException(status_code=500, detail="Error interno del servidor")
+
+
+@router.post("/users/ban", response_model=ModerationActionResponse)
+async def ban_user(request: BanUserRequest):
+    """
+    Banear a un usuario
+    
+    - **moderator_id**: ID del moderador
+    - **user_id**: ID del usuario a banear
+    - **reason**: Razón del ban (mínimo 5 caracteres)
+    - **duration_days**: Duración del ban en días (None para permanente)
+    - **description**: Descripción adicional (opcional)
+    """
+    try:
+        use_case = BanUserUseCase(moderation_repo)
+        result = use_case.execute(
+            moderator_id=request.moderator_id,
+            user_id=request.user_id,
+            reason=request.reason,
+            duration_days=request.duration_days,
+            description=request.description
+        )
+        
+        if result["status"] == "error":
+            raise HTTPException(status_code=400, detail=result["message"])
+        
+        return ModerationActionResponse(**result)
+    
+    except Exception as e:
+        logger.error(f"Error in ban_user: {e}")
+        raise HTTPException(status_code=500, detail="Error interno del servidor")
+
+
+@router.post("/users/warn", response_model=ModerationActionResponse)
+async def warn_user(request: WarnUserRequest):
+    """
+    Advertir a un usuario
+    
+    - **moderator_id**: ID del moderador
+    - **user_id**: ID del usuario a advertir
+    - **reason**: Razón de la advertencia (mínimo 5 caracteres)
+    - **description**: Descripción adicional (opcional)
+    """
+    try:
+        use_case = WarnUserUseCase(moderation_repo)
+        result = use_case.execute(
+            moderator_id=request.moderator_id,
+            user_id=request.user_id,
+            reason=request.reason,
+            description=request.description
+        )
+        
+        if result["status"] == "error":
+            raise HTTPException(status_code=400, detail=result["message"])
+        
+        return ModerationActionResponse(**result)
+    
+    except Exception as e:
+        logger.error(f"Error in warn_user: {e}")
+        raise HTTPException(status_code=500, detail="Error interno del servidor")
+
+
+@router.post("/content/review", response_model=ModerationActionResponse)
+async def review_content(request: ReviewContentRequest):
+    """
+    Revisar y actuar sobre contenido reportado
+    
+    - **moderator_id**: ID del moderador
+    - **report_id**: ID del reporte a revisar
+    - **action**: Acción a tomar (approve, reject, needs_more_info)
+    - **reason**: Razón de la decisión (opcional)
+    - **notes**: Notas adicionales (opcional)
+    """
+    try:
+        use_case = ReviewContentUseCase(moderation_repo)
+        result = use_case.execute(
+            moderator_id=request.moderator_id,
+            report_id=request.report_id,
+            action=request.action,
+            reason=request.reason,
+            notes=request.notes
+        )
+        
+        if result["status"] == "error":
+            raise HTTPException(status_code=400, detail=result["message"])
+        
+        return ModerationActionResponse(**result)
+    
+    except Exception as e:
+        logger.error(f"Error in review_content: {e}")
+        raise HTTPException(status_code=500, detail="Error interno del servidor")

src/infrastructure/api/moderations/root.py

@@ -0,0 +1,32 @@
+"""Rutas raíz para API de Moderación"""
+from fastapi import APIRouter, Response
+from fastapi.responses import JSONResponse
+
+router = APIRouter()
+
+
+@router.get("/")
+async def root():
+    """Root endpoint - información de la API"""
+    return JSONResponse({
+        "status": "ok",
+        "service": "VoxPopuli Moderation API",
+        "version": "1.0.0",
+        "description": "API para gestión de acciones de moderación",
+        "endpoints": {
+            "delete_report": "POST /moderation/reports/delete",
+            "close_account": "POST /moderation/accounts/close",
+            "ban_user": "POST /moderation/users/ban",
+            "warn_user": "POST /moderation/users/warn",
+            "review_content": "POST /moderation/content/review"
+        }
+    })
+
+
+@router.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return JSONResponse({
+        "status": "healthy",
+        "service": "Moderation API"
+    })

src/infrastructure/api/moderations/router.py

@@ -0,0 +1,18 @@
+"""Router principal para API de Moderación"""
+from fastapi import APIRouter
+from infrastructure.api.moderations.moderations import router as moderations_router
+from infrastructure.api.moderations.root import router as root_router
+
+router = APIRouter()
+
+router.include_router(
+    moderations_router,
+    prefix="/moderation",
+    tags=["moderation"]
+)
+
+router.include_router(
+    root_router,
+    prefix='',
+    tags=["root"]
+)

src/infrastructure/api/moderations/schemas.py

@@ -0,0 +1,60 @@
+"""Pydantic schemas para validación de datos en API de Moderación"""
+from pydantic import BaseModel, Field
+from typing import Optional, Literal
+from datetime import datetime
+
+
+class DeleteReportRequest(BaseModel):
+    """Esquema para solicitud de eliminación de reporte"""
+    moderator_id: int = Field(..., description="ID del moderador")
+    report_id: str = Field(..., description="ID del reporte a eliminar")
+    reason: str = Field(..., min_length=5, description="Razón de la eliminación")
+    description: Optional[str] = Field(None, description="Descripción adicional")
+
+
+class CloseAccountRequest(BaseModel):
+    """Esquema para solicitud de cierre de cuenta"""
+    moderator_id: int = Field(..., description="ID del moderador")
+    user_id: int = Field(..., description="ID del usuario")
+    reason: str = Field(..., min_length=5, description="Razón del cierre")
+    description: Optional[str] = Field(None, description="Descripción adicional")
+    is_permanent: bool = Field(True, description="Si el cierre es permanente")
+
+
+class BanUserRequest(BaseModel):
+    """Esquema para solicitud de ban de usuario"""
+    moderator_id: int = Field(..., description="ID del moderador")
+    user_id: int = Field(..., description="ID del usuario a banear")
+    reason: str = Field(..., min_length=5, description="Razón del ban")
+    duration_days: Optional[int] = Field(None, description="Duración en días (None para permanente)")
+    description: Optional[str] = Field(None, description="Descripción adicional")
+
+
+class WarnUserRequest(BaseModel):
+    """Esquema para solicitud de advertencia"""
+    moderator_id: int = Field(..., description="ID del moderador")
+    user_id: int = Field(..., description="ID del usuario a advertir")
+    reason: str = Field(..., min_length=5, description="Razón de la advertencia")
+    description: Optional[str] = Field(None, description="Descripción adicional")
+
+
+class ReviewContentRequest(BaseModel):
+    """Esquema para solicitud de revisión de contenido"""
+    moderator_id: int = Field(..., description="ID del moderador")
+    report_id: str = Field(..., description="ID del reporte a revisar")
+    action: Literal["approve", "reject", "needs_more_info"] = Field(..., description="Acción de revisión")
+    reason: Optional[str] = Field(None, description="Razón de la decisión")
+    notes: Optional[str] = Field(None, description="Notas adicionales")
+
+
+class ModerationActionResponse(BaseModel):
+    """Esquema de respuesta para acciones de moderación"""
+    status: str = Field(..., description="Estado de la acción (success/error)")
+    message: str = Field(..., description="Mensaje descriptivo")
+    action_id: Optional[str] = Field(None, description="ID de la acción creada")
+
+
+class ActionStatusRequest(BaseModel):
+    """Esquema para actualizar estado de acción"""
+    status: Literal["pending", "approved", "rejected", "executed"] = Field(..., description="Nuevo estado")
+    notes: Optional[str] = Field(None, description="Notas sobre el cambio de estado")

src/main.py

@@ -1,13 +1,17 @@
 """
 Punto de entrada principal para VoxPopuli Microservices
-Ejecuta dos APIs en paralelo: Usuarios (puerto 8000) y Reportes (puerto 8001), Notificaciones (puerto 8002)
+Ejecuta cinco APIs en paralelo: Usuarios (8000), Reportes (8001), Notificaciones (8002), Moderación (8003), Métricas (8004)
 """
 from infrastructure.api.users.app import create_app as create_users_app
 from infrastructure.api.reports.app import create_app as create_reports_app
 from infrastructure.api.notifications.app import create_app as create_notifications_app
+from infrastructure.api.moderations.app import create_app as create_moderations_app
+from infrastructure.api.metrics.app import create_app as create_metrics_app
 from consumers.report_consumer import ReportConsumer
 from consumers.user_consumer import UserConsumer
 from consumers.notification_consumer import NotificationConsumer
+from consumers.moderation_consumer import ModerationConsumer
+from consumers.metrics_consumer import MetricsConsumer
 from core.config import ConfSettings
 import threading
 import uvicorn
@@ -45,6 +49,28 @@ def run_notifications_api():
         log_level=ConfSettings.log_level,
     )
 
+def run_moderations_api():
+    """Ejecuta la API de Moderación en puerto 8003"""
+    app_moderations = create_moderations_app()
+    uvicorn.run(
+        app_moderations,
+        host=ConfSettings.host,
+        port=8003,
+        reload=False,
+        log_level=ConfSettings.log_level,
+    )
+
+def run_metrics_api():
+    """Ejecuta la API de Métricas en puerto 8004"""
+    app_metrics = create_metrics_app()
+    uvicorn.run(
+        app_metrics,
+        host=ConfSettings.host,
+        port=8004,
+        reload=False,
+        log_level=ConfSettings.log_level,
+    )
+
 def run_user_consumer():
     consumer = UserConsumer()
     consumer.start()
@@ -57,6 +83,14 @@ def run_notifications_consumer():
     consumer = NotificationConsumer()
     consumer.start()
 
+def run_moderations_consumer():
+    consumer = ModerationConsumer()
+    consumer.start()
+
+def run_metrics_consumer():
+    consumer = MetricsConsumer()
+    consumer.start()
+
 
 def run():
     """Inicia todas las APIs en threads separados"""
@@ -67,31 +101,44 @@ def run():
     users_thread = threading.Thread(target=run_users_api, daemon=True, name="Users-API")
     reports_thread = threading.Thread(target=run_reports_api, daemon=True, name="Reports-API")
     notifications_thread = threading.Thread(target=run_notifications_api, daemon=True, name="Notifications-API")
+    moderations_thread = threading.Thread(target=run_moderations_api, daemon=True, name="Moderations-API")
+    metrics_thread = threading.Thread(target=run_metrics_api, daemon=True, name="Metrics-API")
     user_consumer_thread = threading.Thread(target=run_user_consumer, daemon=True, name="Users-Consumer")
     report_consumer_thread = threading.Thread(target=run_reports_consumer, daemon=True, name="Reports-Consumer")
     notifications_consumer_thread = threading.Thread(target=run_notifications_consumer, daemon=True, name="Notifications-Consumer")
+    moderations_consumer_thread = threading.Thread(target=run_moderations_consumer, daemon=True, name="Moderations-Consumer")
+    metrics_consumer_thread = threading.Thread(target=run_metrics_consumer, daemon=True, name="Metrics-Consumer")
 
-    
     users_thread.start()
     reports_thread.start()
     notifications_thread.start()
+    moderations_thread.start()
+    metrics_thread.start()
     user_consumer_thread.start()
     report_consumer_thread.start()
     notifications_consumer_thread.start()
+    moderations_consumer_thread.start()
+    metrics_consumer_thread.start()
     
     print("\n✓ API de Usuarios ejecutándose en http://0.0.0.0:8000")
     print("✓ API de Reportes ejecutándose en http://0.0.0.0:8001")
     print("✓ API de Notificaciones ejecutándose en http://0.0.0.0:8002")
+    print("✓ API de Moderación ejecutándose en http://0.0.0.0:8003")
+    print("✓ API de Métricas ejecutándose en http://0.0.0.0:8004")
     print("\nDocumentación disponible en:")
     print("  - Usuarios: http://localhost:8000/docs")
     print("  - Reportes: http://localhost:8001/docs")
     print("  - Notificaciones: http://localhost:8002/docs")
+    print("  - Moderación: http://localhost:8003/docs")
+    print("  - Métricas: http://localhost:8004/docs")
     print("\n" + "=" * 60 + "\n")
     
     try:
         users_thread.join()
         reports_thread.join()
         notifications_thread.join()
+        moderations_thread.join()
+        metrics_thread.join()
     except KeyboardInterrupt:
         print("\n\nRecibiendo señal de salida...")
         print("Cerrando APIs...")