Merge: Integrar Sistema de Análisis de Seguridad v1.6.0 a main

CARACTERÍSTICAS PRINCIPALES v1.6.0:
- Sistema de auditoría multi-tenant completo
- Análisis de seguridad con detección de amenazas en tiempo real
- Panel de seguridad con 4 algoritmos de detección:
  * Ataques de fuerza bruta
  * Escalada de privilegios
  * Eliminaciones masivas
  * Cuentas comprometidas
- Acciones de seguridad: bloquear IP, resetear contraseña, notificar admin
- Cross-tenant viewing para ADMIN/SUPPORT_MANAGER
- Frontend completamente funcional con nuevo menú Seguridad
- Sistema completamente verificado y operativo

Resolución de conflictos:
- Versiones actualizadas a 1.6.0 en todos los package.json y pyproject.toml
- Menú de seguridad integrado en Sidebar
- Tickets endpoint actualizado con auditoría
- Correcciones de middleware y queries SQL aplicadas

backend/app/api/schemas/audit.py

@@ -0,0 +1,159 @@
+"""
+Audit Schemas - ServiceManagerWeb
+
+Schemas Pydantic para endpoints de auditoría
+"""
+
+from pydantic import BaseModel, Field, UUID4
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+
+class AuditLogBase(BaseModel):
+    """Schema base para audit logs."""
+    action: str = Field(..., description="Acci├│n realizada (ej: ticket.create)")
+    resource_type: str = Field(..., description="Tipo de recurso (ticket, user, etc.)")
+    resource_id: Optional[UUID4] = Field(None, description="ID del recurso afectado")
+    extra_metadata: Optional[Dict[str, Any]] = Field(None, description="Metadata adicional", alias="metadata")
+
+
+class AuditLogResponse(AuditLogBase):
+    """
+    Schema de respuesta para audit logs.
+    
+    Incluye toda la informaci├│n del log con datos del usuario.
+    """
+    id: UUID4
+    tenant_id: UUID4
+    user_id: Optional[UUID4]
+    
+    # Informaci├│n del usuario (si existe)
+    user_email: Optional[str] = None
+    user_name: Optional[str] = None
+    user_role: Optional[str] = None
+    
+    # Contexto de la acci├│n
+    ip_address: Optional[str]
+    user_agent: Optional[str]
+    correlation_id: Optional[UUID4]
+    
+    # Cambios realizados
+    old_values: Optional[Dict[str, Any]]
+    new_values: Optional[Dict[str, Any]]
+    
+    # Timestamp
+    created_at: datetime
+    
+    # Display friendly
+    action_display: str = Field(description="Acci├│n en formato amigable")
+    
+    class Config:
+        from_attributes = True
+
+
+# ===================================
+# SECURITY ANALYSIS SCHEMAS
+# ===================================
+
+class SecurityThreatPattern(BaseModel):
+    """Patrón de amenaza detectado."""
+    type: str = Field(description="Tipo de amenaza (brute_force, privilege_escalation, etc.)")
+    severity: str = Field(description="Severidad: low, medium, high, critical")
+    description: str = Field(description="Descripción de la amenaza")
+    occurrences: int = Field(description="Número de ocurrencias")
+    affected_ips: list[str] = Field(default=[], description="IPs involucradas")
+    affected_users: list[str] = Field(default=[], description="Usuarios afectados")
+    first_seen: datetime = Field(description="Primera ocurrencia")
+    last_seen: datetime = Field(description="Última ocurrencia")
+    recommendations: list[str] = Field(default=[], description="Recomendaciones de acción")
+
+
+class SecurityAnalysisResponse(BaseModel):
+    """Análisis completo de seguridad."""
+    overall_risk_level: str = Field(description="Nivel de riesgo general: safe, low, medium, high, critical")
+    total_threats_detected: int = Field(description="Total de amenazas detectadas")
+    threats: list[SecurityThreatPattern] = Field(description="Lista de amenazas detectadas")
+    analysis_period_hours: int = Field(description="Período de análisis en horas")
+    generated_at: datetime = Field(description="Timestamp del análisis")
+    
+    # Estadísticas de seguridad
+    failed_login_attempts: int = Field(description="Intentos fallidos de login")
+    suspicious_ips_count: int = Field(description="IPs sospechosas detectadas")
+    critical_actions_count: int = Field(description="Acciones críticas realizadas")
+    
+    # Opciones de acción
+    recommended_actions: list[str] = Field(default=[], description="Acciones recomendadas")
+
+
+class SecurityActionRequest(BaseModel):
+    """Solicitud de acción de seguridad."""
+    action_type: str = Field(description="Tipo de acción: block_ip, notify_admin, reset_password, etc.")
+    target: str = Field(description="Objetivo de la acción (IP, email, etc.)")
+    reason: str = Field(description="Razón de la acción")
+    duration_minutes: Optional[int] = Field(None, description="Duración del bloqueo en minutos")
+
+
+class SecurityActionResponse(BaseModel):
+    """Respuesta de acción de seguridad."""
+    success: bool = Field(description="Si la acción fue exitosa")
+    message: str = Field(description="Mensaje descriptivo")
+    action_id: Optional[UUID4] = Field(None, description="ID de la acción registrada")
+
+
+class AuditLogFilters(BaseModel):
+    """
+    Filtros para consulta de audit logs.
+    
+    Permite filtrar por m├║ltiples criterios.
+    """
+    # Paginaci├│n
+    page: int = Field(default=1, ge=1, description="Número de página")
+    per_page: int = Field(default=50, ge=1, le=100, description="Elementos por página")
+    
+    # Filtros
+    user_id: Optional[UUID4] = Field(None, description="Filtrar por usuario")
+    action: Optional[str] = Field(None, description="Filtrar por acción específica")
+    resource_type: Optional[str] = Field(None, description="Filtrar por tipo de recurso")
+    resource_id: Optional[UUID4] = Field(None, description="Filtrar por ID de recurso")
+    
+    # Rango de fechas
+    date_from: Optional[datetime] = Field(None, description="Fecha inicio (ISO 8601)")
+    date_to: Optional[datetime] = Field(None, description="Fecha fin (ISO 8601)")
+    
+    # B├║squeda
+    search: Optional[str] = Field(None, description="B├║squeda en acciones o recursos")
+
+
+class AuditLogStats(BaseModel):
+    """
+    Estadísticas de auditoría.
+    
+    Resumen de actividad del sistema.
+    """
+    total_actions: int = Field(description="Total de acciones registradas")
+    actions_today: int = Field(description="Acciones en las ├║ltimas 24 horas")
+    actions_this_week: int = Field(description="Acciones en los últimos 7 días")
+    critical_actions_today: int = Field(description="Acciones críticas hoy (delete, cambios sensibles)")
+    
+    # Top acciones
+    top_actions: Dict[str, int] = Field(description="Acciones más frecuentes")
+    
+    # Top usuarios
+    top_users: Dict[str, int] = Field(description="Usuarios más activos")
+    
+    # Actividad por tipo de recurso
+    by_resource_type: Dict[str, int] = Field(description="Acciones por tipo de recurso")
+
+
+class AuditLogListResponse(BaseModel):
+    """
+    Respuesta paginada de audit logs.
+    """
+    logs: list[AuditLogResponse]
+    total: int = Field(description="Total de registros")
+    page: int = Field(description="Página actual")
+    per_page: int = Field(description="Registros por página")
+    total_pages: int = Field(description="Total de páginas")
+    
+    class Config:
+        from_attributes = True

backend/app/api/v1/endpoints/audit.py

@@ -0,0 +1,715 @@
+"""
+Audit Endpoints - ServiceManagerWeb
+
+Endpoints para consulta de logs de auditoría.
+Solo accesible por roles: ADMIN, SUPPORT_MANAGER, AUDITOR
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, and_, or_, desc
+from sqlalchemy.orm import selectinload
+from typing import Optional, List
+from datetime import datetime, timedelta
+import uuid
+import structlog
+
+from app.core.database import get_db
+from app.api.deps import get_current_user, get_current_tenant
+from app.models.user import User, UserRole
+from app.models.tenant import Tenant
+from app.models.audit import AuditLog
+from app.services.audit_service import AuditService
+from app.api.schemas.audit import (
+    AuditLogResponse,
+    AuditLogListResponse,
+    AuditLogFilters,
+    AuditLogStats,
+    SecurityAnalysisResponse,
+    SecurityThreatPattern,
+    SecurityActionRequest,
+    SecurityActionResponse
+)
+
+router = APIRouter()
+logger = structlog.get_logger(__name__)
+
+
+def require_auditor_role(current_user: User = Depends(get_current_user)) -> User:
+    """
+    Dependency que verifica que el usuario tenga rol de auditor.
+    
+    Solo ADMIN, SUPPORT_MANAGER y AUDITOR pueden ver logs de auditoría.
+    """
+    allowed_roles = [UserRole.ADMIN, UserRole.SUPPORT_MANAGER, UserRole.AUDITOR]
+    
+    if current_user.role not in allowed_roles:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Solo usuarios con rol ADMIN, SUPPORT_MANAGER o AUDITOR pueden acceder a logs de auditoría"
+        )
+    
+    return current_user
+
+
+@router.get("/", response_model=AuditLogListResponse)
+async def get_audit_logs(
+    # Paginaci├│n
+    page: int = Query(default=1, ge=1, description="Número de página"),
+    per_page: int = Query(default=50, ge=1, le=100, description="Registros por página"),
+    
+    # Filtros
+    user_id: Optional[uuid.UUID] = Query(None, description="Filtrar por usuario"),
+    action: Optional[str] = Query(None, description="Filtrar por acci├│n"),
+    resource_type: Optional[str] = Query(None, description="Filtrar por tipo de recurso"),
+    resource_id: Optional[uuid.UUID] = Query(None, description="Filtrar por ID de recurso"),
+    date_from: Optional[datetime] = Query(None, description="Fecha desde"),
+    date_to: Optional[datetime] = Query(None, description="Fecha hasta"),
+    search: Optional[str] = Query(None, description="B├║squeda en acci├│n o email"),
+        # Multi-tenant filters (solo ADMIN/SUPPORT_MANAGER)
+    tenant_id: Optional[uuid.UUID] = Query(None, description="Ver logs de un tenant específico"),
+    all_tenants: bool = Query(False, description="Ver logs de todos los tenants"),
+        # Dependencies
+    current_user: User = Depends(require_auditor_role),
+    current_tenant: Tenant = Depends(get_current_tenant),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Obtener logs de auditoría con filtros y paginación.
+    
+    **Permisos**: ADMIN, SUPPORT_MANAGER, AUDITOR
+    
+    **Filtros disponibles**:
+    - `user_id`: Acciones de un usuario específico
+    - `action`: Tipo de acci├│n (ej: "ticket.create")
+    - `resource_type`: Tipo de recurso (ej: "ticket")
+    - `resource_id`: ID de recurso específico
+    - `date_from`, `date_to`: Rango de fechas
+    - `search`: B├║squeda en acciones
+    
+    **Retorna**: Lista paginada de audit logs
+    """
+    logger.info(
+        "Fetching audit logs",
+        user_id=str(current_user.id),
+        tenant_id=str(current_tenant.id),
+        filters={
+            "user_id": str(user_id) if user_id else None,
+            "action": action,
+            "resource_type": resource_type,
+            "page": page,
+            "tenant_filter": str(tenant_id) if tenant_id else None,
+            "all_tenants": all_tenants
+        }
+    )
+    
+    # Determinar el filtro de tenant
+    # Solo ADMIN y SUPPORT_MANAGER pueden ver otros tenants o todos los tenants
+    can_see_all_tenants = current_user.role in [UserRole.ADMIN, UserRole.SUPPORT_MANAGER]
+    
+    # Query base con filtro de tenant dinámico
+    query = select(AuditLog).options(selectinload(AuditLog.user))
+    
+    if all_tenants and can_see_all_tenants:
+        # Ver todos los tenants (no agregar filtro de tenant)
+        pass
+    elif tenant_id and can_see_all_tenants:
+        # Ver un tenant específico
+        query = query.where(AuditLog.tenant_id == tenant_id)
+    else:
+        # Ver solo el tenant actual (comportamiento default)
+        query = query.where(AuditLog.tenant_id == current_tenant.id)
+    
+    # Aplicar filtros
+    if user_id:
+        query = query.where(AuditLog.user_id == user_id)
+    
+    if action:
+        query = query.where(AuditLog.action == action)
+    
+    if resource_type:
+        query = query.where(AuditLog.resource_type == resource_type)
+    
+    if resource_id:
+        query = query.where(AuditLog.resource_id == resource_id)
+    
+    if date_from:
+        query = query.where(AuditLog.created_at >= date_from)
+    
+    if date_to:
+        # El frontend ya envía el timestamp correcto
+        query = query.where(AuditLog.created_at < date_to)
+    
+    if search:
+        # B├║squeda en action
+        search_filter = AuditLog.action.ilike(f"%{search}%")
+        query = query.where(search_filter)
+    
+    # Ordenar por fecha descendente (más recientes primero)
+    query = query.order_by(desc(AuditLog.created_at))
+    
+    # Contar total antes de paginar
+    count_query = select(func.count()).select_from(query.subquery())
+    total_result = await db.execute(count_query)
+    total = total_result.scalar() or 0
+    
+    # Aplicar paginaci├│n
+    offset = (page - 1) * per_page
+    query = query.offset(offset).limit(per_page)
+    
+    # Ejecutar query
+    result = await db.execute(query)
+    logs = result.scalars().all()
+    
+    # Calcular total de páginas
+    total_pages = (total + per_page - 1) // per_page
+    
+    # Convertir a response schema (agregar info del usuario)
+    logs_response = []
+    for log in logs:
+        log_dict = {
+            "id": log.id,
+            "tenant_id": log.tenant_id,
+            "user_id": log.user_id,
+            "action": log.action,
+            "resource_type": log.resource_type,
+            "resource_id": log.resource_id,
+            "ip_address": str(log.ip_address) if log.ip_address else None,
+            "user_agent": log.user_agent,
+            "correlation_id": log.correlation_id,
+            "old_values": log.old_values,
+            "new_values": log.new_values,
+            "metadata": log.extra_metadata,
+            "created_at": log.created_at,
+            "action_display": log.action_display,
+            "user_email": None,
+            "user_name": None
+        }
+        
+        # Agregar info del usuario si existe
+        if log.user:
+            log_dict["user_email"] = log.user.email
+            log_dict["user_name"] = log.user.full_name
+            log_dict["user_role"] = log.user.role.value if hasattr(log.user.role, 'value') else str(log.user.role)
+        
+        logs_response.append(AuditLogResponse(**log_dict))
+    
+    return AuditLogListResponse(
+        logs=logs_response,
+        total=total,
+        page=page,
+        per_page=per_page,
+        total_pages=total_pages
+    )
+
+
+@router.get("/stats", response_model=AuditLogStats)
+async def get_audit_stats(
+    all_tenants: bool = Query(False, description="Ver stats de todos los tenants"),
+    current_user: User = Depends(require_auditor_role),
+    current_tenant: Tenant = Depends(get_current_tenant),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Obtener estadísticas de auditoría del tenant (o todos los tenants si es ADMIN).
+    
+    **Permisos**: ADMIN, SUPPORT_MANAGER, AUDITOR
+    
+    **Retorna**: Estadísticas de actividad
+    """
+    can_see_all_tenants = current_user.role in [UserRole.ADMIN, UserRole.SUPPORT_MANAGER]
+    
+    logger.info(
+        "Fetching audit stats",
+        user_id=str(current_user.id),
+        tenant_id=str(current_tenant.id),
+        all_tenants=all_tenants,
+        can_see_all=can_see_all_tenants
+    )
+    
+    now = datetime.utcnow()
+    
+    # Determinar si aplicar filtro de tenant
+    apply_tenant_filter = not (all_tenants and can_see_all_tenants)
+    
+    # Total de acciones
+    total_query = select(func.count()).select_from(AuditLog)
+    if apply_tenant_filter:
+        total_query = total_query.where(AuditLog.tenant_id == current_tenant.id)
+    total_result = await db.execute(total_query)
+    total_actions = total_result.scalar() or 0
+    
+    # Acciones hoy (├║ltimas 24 horas)
+    today_start = now - timedelta(days=1)
+    today_query = select(func.count()).select_from(AuditLog).where(
+        AuditLog.created_at >= today_start
+    )
+    if apply_tenant_filter:
+        today_query = today_query.where(AuditLog.tenant_id == current_tenant.id)
+    today_result = await db.execute(today_query)
+    actions_today = today_result.scalar() or 0
+    
+    # Acciones esta semana (últimos 7 días)
+    week_start = now - timedelta(days=7)
+    week_query = select(func.count()).select_from(AuditLog).where(
+        AuditLog.created_at >= week_start
+    )
+    if apply_tenant_filter:
+        week_query = week_query.where(AuditLog.tenant_id == current_tenant.id)
+    week_result = await db.execute(week_query)
+    actions_this_week = week_result.scalar() or 0
+    
+    # Top 5 acciones más frecuentes
+    top_actions_query = select(
+        AuditLog.action,
+        func.count(AuditLog.id).label('count')
+    )
+    if apply_tenant_filter:
+        top_actions_query = top_actions_query.where(AuditLog.tenant_id == current_tenant.id)
+    top_actions_query = top_actions_query.group_by(
+        AuditLog.action
+    ).order_by(
+        desc('count')
+    ).limit(5)
+    
+    top_actions_result = await db.execute(top_actions_query)
+    top_actions = {row.action: row.count for row in top_actions_result}
+    
+    # Acciones por tipo de recurso
+    by_resource_query = select(
+        AuditLog.resource_type,
+        func.count(AuditLog.id).label('count')
+    )
+    if apply_tenant_filter:
+        by_resource_query = by_resource_query.where(AuditLog.tenant_id == current_tenant.id)
+    by_resource_query = by_resource_query.group_by(
+        AuditLog.resource_type
+    ).order_by(
+        desc('count')
+    )
+    
+    by_resource_result = await db.execute(by_resource_query)
+    by_resource_type = {row.resource_type: row.count for row in by_resource_result}
+    
+    # Top usuarios (con join a users para obtener nombres)
+    top_users_query = select(
+        User.email,
+        func.count(AuditLog.id).label('count')
+    ).join(
+        User, AuditLog.user_id == User.id
+    )
+    if apply_tenant_filter:
+        top_users_query = top_users_query.where(AuditLog.tenant_id == current_tenant.id)
+    top_users_query = top_users_query.group_by(
+        User.email
+    ).order_by(
+        desc('count')
+    ).limit(5)
+    
+    top_users_result = await db.execute(top_users_query)
+    top_users = {row.email: row.count for row in top_users_result}
+    
+    # Acciones críticas hoy (delete, update sensibles, etc.)
+    critical_conditions = [
+        AuditLog.created_at >= today_start,
+        or_(
+            AuditLog.action.like('%.delete'),
+            AuditLog.action.like('user.update'),
+            AuditLog.action.like('%.assign'),
+            AuditLog.action.in_(['user.login_failed', 'user.logout'])
+        )
+    ]
+    if apply_tenant_filter:
+        critical_conditions.append(AuditLog.tenant_id == current_tenant.id)
+    
+    critical_actions_query = select(func.count()).select_from(AuditLog).where(
+        and_(*critical_conditions)
+    )
+    critical_result = await db.execute(critical_actions_query)
+    critical_actions_today = critical_result.scalar() or 0
+    
+    return AuditLogStats(
+        total_actions=total_actions,
+        actions_today=actions_today,
+        actions_this_week=actions_this_week,
+        critical_actions_today=critical_actions_today,
+        top_actions=top_actions,
+        top_users=top_users,
+        by_resource_type=by_resource_type
+    )
+
+
+@router.get("/{log_id}", response_model=AuditLogResponse)
+async def get_audit_log_detail(
+    log_id: uuid.UUID,
+    current_user: User = Depends(require_auditor_role),
+    current_tenant: Tenant = Depends(get_current_tenant),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Obtener detalle de un audit log específico.
+    
+    **Permisos**: ADMIN, SUPPORT_MANAGER, AUDITOR
+    
+    **Retorna**: Detalle completo del audit log
+    """
+    # Buscar el log
+    query = select(AuditLog).where(
+        and_(
+            AuditLog.id == log_id,
+            AuditLog.tenant_id == current_tenant.id
+        )
+    )
+    
+    result = await db.execute(query)
+    log = result.scalar_one_or_none()
+    
+    if not log:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Audit log {log_id} no encontrado"
+        )
+    
+    # Convertir a response
+    log_dict = {
+        "id": log.id,
+        "tenant_id": log.tenant_id,
+        "user_id": log.user_id,
+        "action": log.action,
+        "resource_type": log.resource_type,
+        "resource_id": log.resource_id,
+        "ip_address": str(log.ip_address) if log.ip_address else None,
+        "user_agent": log.user_agent,
+        "correlation_id": log.correlation_id,
+        "old_values": log.old_values,
+        "new_values": log.new_values,
+        "metadata": log.extra_metadata,
+        "created_at": log.created_at,
+        "action_display": log.action_display,
+        "user_email": None,
+        "user_name": None
+    }
+    
+    if log.user:
+        log_dict["user_email"] = log.user.email
+        log_dict["user_name"] = log.user.full_name
+    
+    return AuditLogResponse(**log_dict)
+
+
+# ===================================
+# SECURITY ANALYSIS ENDPOINTS
+# ===================================
+
+@router.get("/security/analysis", response_model=SecurityAnalysisResponse)
+async def get_security_analysis(
+    hours: int = Query(default=24, ge=1, le=168, description="Período de análisis en horas"),
+    current_user: User = Depends(require_auditor_role),
+    current_tenant: Tenant = Depends(get_current_tenant),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Análisis de seguridad y detección de amenazas.
+    
+    **Permisos**: ADMIN, SUPPORT_MANAGER, AUDITOR
+    
+    **Detecta**:
+    - Intentos de fuerza bruta (login_failed)
+    - Escalada de privilegios
+    - Eliminaciones masivas
+    - Accesos desde IPs sospechosas
+    - Patrones anómalos de actividad
+    
+    **Retorna**: Análisis completo con amenazas y recomendaciones
+    """
+    logger.info(
+        "Security analysis requested",
+        user_id=str(current_user.id),
+        tenant_id=str(current_tenant.id),
+        hours=hours
+    )
+    
+    now = datetime.utcnow()
+    analysis_start = now - timedelta(hours=hours)
+    
+    threats = []
+    failed_login_attempts = 0
+    suspicious_ips = set()
+    critical_actions_count = 0
+    
+    # 1. DETECCIÓN DE FUERZA BRUTA
+    brute_force_query = select(
+        AuditLog.ip_address,
+        func.count(AuditLog.id).label('attempts'),
+        func.min(AuditLog.created_at).label('first_seen'),
+        func.max(AuditLog.created_at).label('last_seen')
+    ).where(
+        and_(
+            AuditLog.tenant_id == current_tenant.id,
+            AuditLog.action == 'user.login_failed',
+            AuditLog.created_at >= analysis_start
+        )
+    ).group_by(AuditLog.ip_address).having(func.count(AuditLog.id) >= 5)
+    
+    brute_force_result = await db.execute(brute_force_query)
+    brute_force_ips = brute_force_result.all()
+    
+    for ip_data in brute_force_ips:
+        if ip_data.ip_address:
+            suspicious_ips.add(str(ip_data.ip_address))
+            failed_login_attempts += ip_data.attempts
+            
+            severity = "high" if ip_data.attempts > 20 else "medium" if ip_data.attempts > 10 else "low"
+            
+            threats.append(SecurityThreatPattern(
+                type="brute_force_attack",
+                severity=severity,
+                description=f"Ataque de fuerza bruta detectado desde {ip_data.ip_address}",
+                occurrences=ip_data.attempts,
+                affected_ips=[str(ip_data.ip_address)],
+                affected_users=[],
+                first_seen=ip_data.first_seen,
+                last_seen=ip_data.last_seen,
+                recommendations=[
+                    f"Bloquear IP {ip_data.ip_address} temporalmente",
+                    "Revisar logs de firewall",
+                    "Considerar implementar CAPTCHA",
+                    "Notificar al equipo de seguridad"
+                ]
+            ))
+    
+    # 2. ESCALADA DE PRIVILEGIOS
+    privilege_query = select(
+        User.email,
+        func.count(AuditLog.id).label('changes'),
+        func.min(AuditLog.created_at).label('first_seen'),
+        func.max(AuditLog.created_at).label('last_seen')
+    ).join(
+        User, AuditLog.user_id == User.id
+    ).where(
+        and_(
+            AuditLog.tenant_id == current_tenant.id,
+            AuditLog.action == 'user.update',
+            AuditLog.created_at >= analysis_start,
+            AuditLog.new_values.op('?')('role')
+        )
+    ).group_by(User.email).having(func.count(AuditLog.id) >= 3)
+    
+    privilege_result = await db.execute(privilege_query)
+    privilege_changes = privilege_result.all()
+    
+    for priv_data in privilege_changes:
+        threats.append(SecurityThreatPattern(
+            type="privilege_escalation",
+            severity="critical",
+            description=f"Posible escalada de privilegios - {priv_data.email} ha modificado roles {priv_data.changes} veces",
+            occurrences=priv_data.changes,
+            affected_ips=[],
+            affected_users=[priv_data.email],
+            first_seen=priv_data.first_seen,
+            last_seen=priv_data.last_seen,
+            recommendations=[
+                f"Revisar permisos del usuario {priv_data.email}",
+                "Auditar todos los cambios de roles realizados",
+                "Verificar si los cambios fueron autorizados",
+                "Considerar revertir cambios no autorizados"
+            ]
+        ))
+    
+    # 3. ELIMINACIONES MASIVAS
+    deletion_query = select(
+        User.email,
+        func.count(AuditLog.id).label('deletions'),
+        func.min(AuditLog.created_at).label('first_seen'),
+        func.max(AuditLog.created_at).label('last_seen')
+    ).join(
+        User, AuditLog.user_id == User.id
+    ).where(
+        and_(
+            AuditLog.tenant_id == current_tenant.id,
+            AuditLog.action.like('%.delete'),
+            AuditLog.created_at >= analysis_start
+        )
+    ).group_by(User.email).having(func.count(AuditLog.id) >= 10)
+    
+    deletion_result = await db.execute(deletion_query)
+    mass_deletions = deletion_result.all()
+    
+    for del_data in mass_deletions:
+        critical_actions_count += del_data.deletions
+        threats.append(SecurityThreatPattern(
+            type="mass_deletion",
+            severity="high",
+            description=f"Eliminaciones masivas detectadas - {del_data.email} ha eliminado {del_data.deletions} recursos",
+            occurrences=del_data.deletions,
+            affected_ips=[],
+            affected_users=[del_data.email],
+            first_seen=del_data.first_seen,
+            last_seen=del_data.last_seen,
+            recommendations=[
+                f"Verificar urgentemente las eliminaciones de {del_data.email}",
+                "Comprobar si hay backups disponibles",
+                "Contactar al usuario para verificar la acción",
+                "Revisar sistema de permisos"
+            ]
+        ))
+    
+    # 4. ACCESOS DESDE MÚLTIPLES IPS (Cuenta comprometida)
+    multi_ip_query = select(
+        User.email,
+        func.count(func.distinct(AuditLog.ip_address)).label('ip_count'),
+        func.min(AuditLog.created_at).label('first_seen'),
+        func.max(AuditLog.created_at).label('last_seen')
+    ).join(
+        User, AuditLog.user_id == User.id
+    ).where(
+        and_(
+            AuditLog.tenant_id == current_tenant.id,
+            AuditLog.action.in_(['user.login', 'user.logout']),
+            AuditLog.created_at >= analysis_start
+        )
+    ).group_by(User.email).having(func.count(func.distinct(AuditLog.ip_address)) >= 5)
+    
+    multi_ip_result = await db.execute(multi_ip_query)
+    multi_ip_users = multi_ip_result.all()
+    
+    for ip_data in multi_ip_users:
+        threats.append(SecurityThreatPattern(
+            type="account_compromise",
+            severity="medium",
+            description=f"Posible cuenta comprometida - {ip_data.email} accedió desde {ip_data.ip_count} IPs diferentes",
+            occurrences=ip_data.ip_count,
+            affected_ips=[],
+            affected_users=[ip_data.email],
+            first_seen=ip_data.first_seen,
+            last_seen=ip_data.last_seen,
+            recommendations=[
+                f"Contactar a {ip_data.email} para verificar actividad",
+                "Forzar cambio de contraseña",
+                "Revisar ubicaciones de acceso",
+                "Considerar habilitar 2FA obligatorio"
+            ]
+        ))
+    
+    # Calcular nivel de riesgo general
+    critical_count = sum(1 for t in threats if t.severity == "critical")
+    high_count = sum(1 for t in threats if t.severity == "high")
+    medium_count = sum(1 for t in threats if t.severity == "medium")
+    
+    if critical_count > 0:
+        overall_risk = "critical"
+    elif high_count >= 3:
+        overall_risk = "high"
+    elif high_count > 0 or medium_count >= 3:
+        overall_risk = "medium"
+    elif medium_count > 0 or len(threats) > 0:
+        overall_risk = "low"
+    else:
+        overall_risk = "safe"
+    
+    # Recomendaciones generales
+    recommended_actions = []
+    if failed_login_attempts > 20:
+        recommended_actions.append("Implementar límite de intentos de login por IP")
+    if len(suspicious_ips) > 0:
+        recommended_actions.append(f"Bloquear {len(suspicious_ips)} IPs sospechosas identificadas")
+    if critical_actions_count > 50:
+        recommended_actions.append("Revisar políticas de permisos - demasiadas acciones críticas")
+    if len(threats) == 0:
+        recommended_actions.append("Sistema seguro - continuar monitoreando")
+    
+    return SecurityAnalysisResponse(
+        overall_risk_level=overall_risk,
+        total_threats_detected=len(threats),
+        threats=threats,
+        analysis_period_hours=hours,
+        generated_at=now,
+        failed_login_attempts=failed_login_attempts,
+        suspicious_ips_count=len(suspicious_ips),
+        critical_actions_count=critical_actions_count,
+        recommended_actions=recommended_actions
+    )
+
+
+@router.post("/security/action", response_model=SecurityActionResponse)
+async def execute_security_action(
+    action: SecurityActionRequest,
+    current_user: User = Depends(require_auditor_role),
+    current_tenant: Tenant = Depends(get_current_tenant),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Ejecutar acción de seguridad.
+    
+    **Permisos**: ADMIN, SUPPORT_MANAGER (solo ellos pueden ejecutar acciones)
+    
+    **Acciones disponibles**:
+    - `block_ip`: Bloquear IP temporalmente
+    - `notify_admin`: Notificar administradores
+    - `force_password_reset`: Forzar cambio de contraseña
+    - `disable_user`: Desactivar usuario temporalmente
+    
+    **Retorna**: Resultado de la acción
+    """
+    # Verificar que solo ADMIN y SUPPORT_MANAGER puedan ejecutar acciones
+    if current_user.role not in [UserRole.ADMIN, UserRole.SUPPORT_MANAGER]:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Solo administradores pueden ejecutar acciones de seguridad"
+        )
+    
+    logger.info(
+        "Security action requested",
+        user_id=str(current_user.id),
+        action_type=action.action_type,
+        target=action.target
+    )
+    
+    # Registrar la acción en auditoría
+    try:
+        await AuditService.log(
+            db=db,
+            tenant_id=current_tenant.id,
+            user_id=current_user.id,
+            action=f"security.{action.action_type}",
+            resource_type="security",
+            resource_id=None,
+            metadata={
+                "target": action.target,
+                "reason": action.reason,
+                "duration_minutes": action.duration_minutes
+            }
+        )
+        await db.commit()
+    except Exception as e:
+        logger.error("Failed to log security action", error=str(e))
+    
+    # Por ahora, simular la ejecución (en producción conectar con firewall, email, etc.)
+    message = ""
+    success = True
+    
+    if action.action_type == "block_ip":
+        message = f"IP {action.target} bloqueada por {action.duration_minutes or 60} minutos. Razón: {action.reason}"
+        # TODO: Integrar con firewall/WAF
+        
+    elif action.action_type == "notify_admin":
+        message = f"Notificación enviada a administradores sobre: {action.reason}"
+        # TODO: Enviar email/Slack notification
+        
+    elif action.action_type == "force_password_reset":
+        message = f"Se forzará cambio de contraseña para {action.target}. Razón: {action.reason}"
+        # TODO: Marcar usuario para reset password
+        
+    elif action.action_type == "disable_user":
+        message = f"Usuario {action.target} desactivado temporalmente. Razón: {action.reason}"
+        # TODO: Desactivar usuario en BD
+        
+    else:
+        success = False
+        message = f"Tipo de acción no reconocida: {action.action_type}"
+    
+    return SecurityActionResponse(
+        success=success,
+        message=message,
+        action_id=None  # TODO: Retornar ID del audit log creado
+    )

backend/app/api/v1/endpoints/auth.py

@@ -18,6 +18,7 @@ from app.core.security import security
 from app.core.config import get_settings
 from app.models.user import User
 from app.models.tenant import Tenant
+from app.services.audit_service import AuditService
 
 router = APIRouter()
 logger = structlog.get_logger(__name__)
@@ -99,6 +100,23 @@ async def login(
             "Login failed - invalid credentials",
             email=login_data.email
         )
+        
+        # Registrar intento fallido en auditoría (si el usuario existe)
+        if user:
+            try:
+                await AuditService.log(
+                    db=db,
+                    tenant_id=user.tenant_id,
+                    user_id=None,  # Login fallido = sin user_id
+                    action="user.login_failed",
+                    resource_type="user",
+                    resource_id=user.id,
+                    metadata={"email": login_data.email, "reason": "invalid_password"}
+                )
+                await db.commit()
+            except Exception as e:
+                logger.warning("Failed to log audit entry", error=str(e))
+        
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Credenciales inválidas"
@@ -126,6 +144,21 @@ async def login(
     access_token = security.create_access_token(token_data)
     refresh_token = security.create_refresh_token(token_data)
     
+    # Registrar login exitoso en auditoría
+    try:
+        await AuditService.log(
+            db=db,
+            tenant_id=user.tenant_id,
+            user_id=user.id,
+            action="user.login",
+            resource_type="user",
+            resource_id=user.id,
+            metadata={"email": user.email, "success": True}
+        )
+        await db.commit()
+    except Exception as e:
+        logger.warning("Failed to log audit entry", error=str(e))
+    
     logger.info(
         "Login successful",
         email=login_data.email,
@@ -227,6 +260,25 @@ async def logout(
     
     # TODO: Revoke refresh token in database
     
+    # Registrar logout en auditoría
+    try:
+        import uuid
+        user_id = uuid.UUID(payload["sub"])
+        tenant_id = uuid.UUID(payload["tenant_id"])
+        
+        await AuditService.log(
+            db=db,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action="user.logout",
+            resource_type="user",
+            resource_id=user_id,
+            metadata={"email": payload.get("email")}
+        )
+        await db.commit()
+    except Exception as e:
+        logger.warning("Failed to log audit entry", error=str(e))
+    
     logger.info("Logout successful", user_id=payload["sub"])
     
     return {"message": "Successfully logged out"}

backend/app/api/v1/endpoints/tickets.py

@@ -21,6 +21,7 @@ from app.models.comment import TicketComment
 from app.models.attachment import TicketAttachment
 from app.api.schemas.attachment import AttachmentResponse
 from app.core.file_handler import file_handler
+from app.services.audit_service import AuditService
 import uuid
 
 router = APIRouter()
@@ -78,85 +79,209 @@ async def create_ticket(
     """
     Crear un nuevo ticket
     """
-    try:
-        # Generar número de ticket único
-        result = await db.execute(
-            select(func.count(Ticket.id)).where(Ticket.tenant_id == current_user.tenant_id)
-        )
-        count = result.scalar() or 0
-        ticket_number = f"TK-{count + 1:06d}"
-        
-        # Generar número de ticket único
-        result = await db.execute(
-            select(func.count(Ticket.id)).where(Ticket.tenant_id == current_user.tenant_id)
-        )
-        count = result.scalar() or 0
-        ticket_number = f"TK-{count + 1:06d}"
-        
-        # Convertir IDs de string a UUID si son proporcionados
-        category_uuid = uuid.UUID(ticket.category_id) if ticket.category_id else None
-        system_uuid = uuid.UUID(ticket.affected_system_id) if ticket.affected_system_id else None  # ✅ CORREGIDO
-        
-        # ✅ CORREGIDO: Validar en la tabla correcta con el nombre correcto del modelo
-        if category_uuid:
-            category = await db.get(Category, category_uuid)  # ✅ Category, no TicketCategory
-            if not category:
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail=f"La categoría con ID {ticket.category_id} no existe."
-                )
+    # Retry logic para evitar race conditions en generación de ticket_number
+    max_retries = 3
+    last_error = None
+    
+    for attempt in range(max_retries):
+        try:
+            # Generar número de ticket único basado en el máximo existente
+            result = await db.execute(
+                select(Ticket.ticket_number)
+                .where(Ticket.tenant_id == current_user.tenant_id)
+                .order_by(Ticket.ticket_number.desc())
+                .limit(1)
+            )
+            last_ticket_number = result.scalar_one_or_none()
+            
+            if last_ticket_number:
+                # Extraer el número del formato TK-XXXXXX
+                last_number = int(last_ticket_number.split('-')[1])
+                next_number = last_number + 1
+            else:
+                next_number = 1
+            
+            ticket_number = f"TK-{next_number:06d}"
+            
+            # Convertir IDs de string a UUID si son proporcionados
+            category_uuid = uuid.UUID(ticket.category_id) if ticket.category_id else None
+            system_uuid = uuid.UUID(ticket.affected_system_id) if ticket.affected_system_id else None
+            
+            # Validar categoría
+            if category_uuid:
+                category = await db.get(Category, category_uuid)
+                if not category:
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail=f"La categoría con ID {ticket.category_id} no existe."
+                    )
 
-        # Validar si el system_id existe en la tabla affected_systems
-        if system_uuid:
-            system = await db.get(System, system_uuid)
-            if not system:
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail=f"El sistema con ID {ticket.affected_system_id} no existe."
+            # Validar sistema
+            if system_uuid:
+                system = await db.get(System, system_uuid)
+                if not system:
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail=f"El sistema con ID {ticket.affected_system_id} no existe."
+                    )
+            
+            db_ticket = Ticket(
+                id=uuid.uuid4(),
+                tenant_id=current_user.tenant_id,
+                ticket_number=ticket_number,
+                subject=ticket.subject,
+                description=ticket.description,
+                category_id=category_uuid,
+                affected_system_id=system_uuid,
+                priority=TicketPriority[ticket.priority.upper()],
+                created_by=current_user.id,
+                status=TicketStatus.NEW,
+                created_at=datetime.utcnow(),
+                updated_at=datetime.utcnow()
+            )
+            
+            db.add(db_ticket)
+            await db.commit()
+            await db.refresh(db_ticket)
+            
+            # Registrar creación en auditoría
+            try:
+                await AuditService.log(
+                    db=db,
+                    tenant_id=current_user.tenant_id,
+                    user_id=current_user.id,
+                    action="ticket.create",
+                    resource_type="ticket",
+                    resource_id=db_ticket.id,
+                    new_values={
+                        "ticket_number": db_ticket.ticket_number,
+                        "subject": db_ticket.subject,
+                        "priority": db_ticket.priority.value,
+                        "status": db_ticket.status.value
+                    }
                 )
-        
-        db_ticket = Ticket(
-            id=uuid.uuid4(),
-            tenant_id=current_user.tenant_id,
-            ticket_number=ticket_number,
-            subject=ticket.subject,
-            description=ticket.description,
-            category_id=category_uuid,
-            affected_system_id=system_uuid,  # ✅ CORREGIDO: Nombre correcto del campo
-            priority=TicketPriority[ticket.priority.upper()],
-            created_by=current_user.id,
-            status=TicketStatus.NEW,
-            created_at=datetime.utcnow(),
-            updated_at=datetime.utcnow()
-        )
-        
-        db.add(db_ticket)
-        await db.commit()
-        await db.refresh(db_ticket)
-        
-        # ✅ CORREGIDO: Usar affected_system_id en respuesta
-        return {
-            "id": str(db_ticket.id),
-            "ticket_number": db_ticket.ticket_number,
-            "subject": db_ticket.subject,
-            "title": db_ticket.subject,
-            "description": db_ticket.description,
-            "status": db_ticket.status.value,
-            "priority": db_ticket.priority.value,
-            "category_id": str(db_ticket.category_id) if db_ticket.category_id else None,
-            "affected_system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None,  # ✅ CORREGIDO
-            "created_by": str(db_ticket.created_by),
-            "assigned_to": str(db_ticket.assigned_to) if db_ticket.assigned_to else None,
-            "created_at": db_ticket.created_at,
-            "updated_at": db_ticket.updated_at
+                await db.commit()
+            except Exception as e:
+                # No fallar si falla el audit log
+                pass
+            
+            # ✅ Éxito - retornar ticket creado
+            return {
+                "id": str(db_ticket.id),
+                "ticket_number": db_ticket.ticket_number,
+                "subject": db_ticket.subject,
+                "title": db_ticket.subject,
+                "description": db_ticket.description,
+                "status": db_ticket.status.value,
+                "priority": db_ticket.priority.value,
+                "category_id": str(db_ticket.category_id) if db_ticket.category_id else None,
+                "affected_system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None,
+                "created_by": str(db_ticket.created_by),
+                "assigned_to": str(db_ticket.assigned_to) if db_ticket.assigned_to else None,
+                "created_at": db_ticket.created_at,
+                "updated_at": db_ticket.updated_at
+            }
+            
+        except ValueError as e:
+            await db.rollback()
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Invalid UUID format: {str(e)}"
+            )
+        except HTTPException:
+            # Re-lanzar HTTPExceptions directamente
+            await db.rollback()
+            raise
+        except Exception as e:
+            await db.rollback()
+            last_error = e
+            
+            # Si es un error de llave duplicada, reintentar
+            if "duplicate key" in str(e).lower() and "ticket_number" in str(e).lower():
+                if attempt < max_retries - 1:
+                    continue  # Reintentar
+            
+            # Para cualquier otro error, fallar inmediatamente
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Error creating ticket: {str(e)}"
+            )
+    
+    # Si llegamos aquí después de todos los reintentos
+    raise HTTPException(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        detail=f"No se pudo crear el ticket después de {max_retries} intentos: {str(last_error)}"
+    )
+
+
+@router.get("/", response_model=List[TicketResponse])
+async def get_tickets(
+    skip: int = 0,
+    limit: int = 100,
+    status_filter: Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Obtener tickets
+    Roles ADMIN/SUPPORT_MANAGER/AGENT: Ven todos los tickets del tenant
+    Roles CLIENT_USER/CLIENT_ADMIN: Solo ven sus propios tickets
+    """
+    # Construir query base filtrado por tenant
+    query = select(Ticket).where(
+        Ticket.tenant_id == current_user.tenant_id
+    )
+    
+    # Si es cliente, solo puede ver sus propios tickets
+    if current_user.role in ["CLIENT_USER", "CLIENT_ADMIN"]:
+        query = query.where(Ticket.created_by == current_user.id)
+    
+    if status_filter:
+        try:
+            status_enum = TicketStatus[status_filter.upper()]
+            query = query.where(Ticket.status == status_enum)
+        except KeyError:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Invalid status: {status_filter}"
+            )
+    
+    query = query.order_by(Ticket.created_at.desc()).offset(skip).limit(limit)
+    
+    result = await db.execute(query)
+    tickets = result.scalars().all()
+    
+    # ✅ CORREGIDO: Usar affected_system_id
+    return [
+        {
+            "id": str(t.id),
+            "ticket_number": t.ticket_number,
+            "subject": t.subject,
+            "title": t.subject,
+            "description": t.description,
+            "status": t.status.value,
+            "priority": t.priority.value,
+            "category_id": str(t.category_id) if t.category_id else None,
+            "affected_system_id": str(t.affected_system_id) if t.affected_system_id else None,
+            "created_by": str(t.created_by),
+            "assigned_to": str(t.assigned_to) if t.assigned_to else None,
+            "created_at": t.created_at,
+            "updated_at": t.updated_at
         }
-        
-    except ValueError as e:
-        await db.rollback()
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Invalid UUID format: {str(e)}"
-        )
+        for t in tickets
+    ]
+
+
+@router.get("/admin/all", response_model=List[dict])
+async def get_all_tickets_admin(
+    skip: int = 0,
+    limit: int = 100,
+    status_filter: Optional[str] = None,
+    priority_filter: Optional[str] = None,
+    tenant_id_filter: Optional[str] = None,
+    category_filter: Optional[str] = None,
+    assigned_to_filter: Optional[str] = None,
+    search: Optional[str] = None,
     date_from: Optional[str] = None,
     date_to: Optional[str] = None,
     db: AsyncSession = Depends(get_db),
@@ -311,6 +436,8 @@ async def get_ticket(
 ):
     """
     Obtener un ticket específico
+    Roles ADMIN/SUPPORT_MANAGER/AGENT: Pueden ver todos los tickets del tenant
+    Roles CLIENT_USER/CLIENT_ADMIN: Solo pueden ver sus propios tickets
     """
     try:
         ticket_uuid = uuid.UUID(ticket_id)
@@ -320,12 +447,16 @@ async def get_ticket(
             detail="Invalid ticket ID format"
         )
     
+    # Construir query basado en el rol del usuario
     query = select(Ticket).where(
         Ticket.id == ticket_uuid,
-        Ticket.tenant_id == current_user.tenant_id,
-        Ticket.created_by == current_user.id
+        Ticket.tenant_id == current_user.tenant_id
     )
     
+    # Si es cliente, solo puede ver sus propios tickets
+    if current_user.role in ["CLIENT_USER", "CLIENT_ADMIN"]:
+        query = query.where(Ticket.created_by == current_user.id)
+    
     result = await db.execute(query)
     ticket = result.scalars().first()
     
@@ -362,6 +493,8 @@ async def update_ticket(
 ):
     """
     Actualizar un ticket
+    Roles ADMIN/SUPPORT_MANAGER/AGENT: Pueden actualizar cualquier ticket del tenant
+    Roles CLIENT_USER/CLIENT_ADMIN: Solo pueden actualizar sus propios tickets
     """
     try:
         ticket_uuid = uuid.UUID(ticket_id)
@@ -371,12 +504,16 @@ async def update_ticket(
             detail="Invalid ticket ID format"
         )
     
+    # Construir query basado en el rol del usuario
     query = select(Ticket).where(
         Ticket.id == ticket_uuid,
-        Ticket.tenant_id == current_user.tenant_id,
-        Ticket.created_by == current_user.id
+        Ticket.tenant_id == current_user.tenant_id
     )
     
+    # Si es cliente, solo puede actualizar sus propios tickets
+    if current_user.role in ["CLIENT_USER", "CLIENT_ADMIN"]:
+        query = query.where(Ticket.created_by == current_user.id)
+    
     result = await db.execute(query)
     db_ticket = result.scalars().first()
     
@@ -386,6 +523,15 @@ async def update_ticket(
             detail=f"Ticket {ticket_id} not found"
         )
     
+    # Guardar valores anteriores para audit
+    old_values = {
+        "subject": db_ticket.subject,
+        "description": db_ticket.description,
+        "status": db_ticket.status.value,
+        "priority": db_ticket.priority.value,
+        "assigned_to": str(db_ticket.assigned_to) if db_ticket.assigned_to else None
+    }
+    
     try:
         update_data = ticket_update.dict(exclude_unset=True)
         
@@ -404,6 +550,34 @@ async def update_ticket(
         await db.commit()
         await db.refresh(db_ticket)
         
+        # Registrar actualización en auditoría
+        try:
+            new_values = {
+                "subject": db_ticket.subject,
+                "description": db_ticket.description,
+                "status": db_ticket.status.value,
+                "priority": db_ticket.priority.value,
+                "assigned_to": str(db_ticket.assigned_to) if db_ticket.assigned_to else None
+            }
+            
+            # Si cambió assigned_to, registrar como acción de asignación
+            action = "ticket.assign" if old_values["assigned_to"] != new_values["assigned_to"] else "ticket.update"
+            
+            await AuditService.log(
+                db=db,
+                tenant_id=current_user.tenant_id,
+                user_id=current_user.id,
+                action=action,
+                resource_type="ticket",
+                resource_id=db_ticket.id,
+                old_values=old_values,
+                new_values=new_values
+            )
+            await db.commit()
+        except Exception as e:
+            # No fallar si falla el audit log
+            pass
+        
         # ✅ CORREGIDO: Usar affected_system_id
         return {
             "id": str(db_ticket.id),
@@ -438,6 +612,8 @@ async def close_ticket(
 ):
     """
     Cerrar un ticket
+    Roles ADMIN/SUPPORT_MANAGER/AGENT: Pueden cerrar cualquier ticket del tenant
+    Roles CLIENT_USER/CLIENT_ADMIN: Solo pueden cerrar sus propios tickets
     """
     try:
         ticket_uuid = uuid.UUID(ticket_id)
@@ -447,12 +623,16 @@ async def close_ticket(
             detail="Invalid ticket ID format"
         )
     
+    # Construir query basado en el rol del usuario
     query = select(Ticket).where(
         Ticket.id == ticket_uuid,
-        Ticket.tenant_id == current_user.tenant_id,
-        Ticket.created_by == current_user.id
+        Ticket.tenant_id == current_user.tenant_id
     )
     
+    # Si es cliente, solo puede cerrar sus propios tickets
+    if current_user.role in ["CLIENT_USER", "CLIENT_ADMIN"]:
+        query = query.where(Ticket.created_by == current_user.id)
+    
     result = await db.execute(query)
     db_ticket = result.scalars().first()
     
@@ -666,9 +846,33 @@ async def delete_ticket(
             detail=f"Ticket {ticket_id} not found"
         )
     
+    # Guardar datos del ticket antes de eliminar para audit
+    old_values = {
+        "ticket_number": db_ticket.ticket_number,
+        "subject": db_ticket.subject,
+        "status": db_ticket.status.value,
+        "priority": db_ticket.priority.value
+    }
+    
     await db.delete(db_ticket)
     await db.commit()
     
+    # Registrar eliminación en auditoría
+    try:
+        await AuditService.log(
+            db=db,
+            tenant_id=current_user.tenant_id,
+            user_id=current_user.id,
+            action="ticket.delete",
+            resource_type="ticket",
+            resource_id=ticket_uuid,
+            old_values=old_values
+        )
+        await db.commit()
+    except Exception as e:
+        # No fallar si falla el audit log
+        pass
+    
     return {"message": "Ticket deleted successfully"}
 
 # ===================================

backend/app/api/v1/endpoints/users.py

@@ -9,6 +9,7 @@ import uuid
 from app.core.database import get_db
 from app.core.security import security
 from app.models.user import User, UserRole
+from app.services.audit_service import AuditService
 from app.api import deps 
 
 router = APIRouter()
@@ -147,6 +148,28 @@ async def create_user(
     db.add(db_user)
     await db.commit()
     await db.refresh(db_user)
+    
+    # Registrar creación en auditoría
+    try:
+        await AuditService.log(
+            db=db,
+            tenant_id=current_user.tenant_id,
+            user_id=current_user.id,
+            action="user.create",
+            resource_type="user",
+            resource_id=db_user.id,
+            new_values=AuditService.sanitize_values({
+                "email": db_user.email,
+                "first_name": db_user.first_name,
+                "last_name": db_user.last_name,
+                "role": db_user.role.value
+            })
+        )
+        await db.commit()
+    except Exception as e:
+        # No fallar si falla el audit log
+        pass
+    
     return db_user
 
 
@@ -214,6 +237,15 @@ async def update_user(
             detail="User not found"
         )
     
+    # Guardar valores anteriores para audit
+    old_values = {
+        "email": db_user.email,
+        "first_name": db_user.first_name,
+        "last_name": db_user.last_name,
+        "role": db_user.role.value,
+        "is_active": db_user.is_active
+    }
+    
     # Verificar email único si se está cambiando
     update_data = user_update.model_dump(exclude_unset=True)
     if "email" in update_data and update_data["email"] != db_user.email:
@@ -239,6 +271,32 @@ async def update_user(
     
     await db.commit()
     await db.refresh(db_user)
+    
+    # Registrar actualización en auditoría
+    try:
+        new_values = {
+            "email": db_user.email,
+            "first_name": db_user.first_name,
+            "last_name": db_user.last_name,
+            "role": db_user.role.value,
+            "is_active": db_user.is_active
+        }
+        
+        await AuditService.log(
+            db=db,
+            tenant_id=current_user.tenant_id,
+            user_id=current_user.id,
+            action="user.update",
+            resource_type="user",
+            resource_id=db_user.id,
+            old_values=AuditService.sanitize_values(old_values),
+            new_values=AuditService.sanitize_values(new_values)
+        )
+        await db.commit()
+    except Exception as e:
+        # No fallar si falla el audit log
+        pass
+    
     return db_user
 
 
@@ -306,6 +364,28 @@ async def delete_user(
     # Soft delete
     db_user.is_active = False
     await db.commit()
+    
+    # Registrar eliminación en auditoría
+    try:
+        await AuditService.log(
+            db=db,
+            tenant_id=current_user.tenant_id,
+            user_id=current_user.id,
+            action="user.delete",
+            resource_type="user",
+            resource_id=db_user.id,
+            old_values={
+                "email": db_user.email,
+                "role": db_user.role.value,
+                "was_active": True
+            },
+            metadata={"action_type": "soft_delete"}
+        )
+        await db.commit()
+    except Exception as e:
+        # No fallar si falla el audit log
+        pass
+    
     return None
 
 

backend/app/api/v1/router.py

@@ -6,7 +6,7 @@ Router principal para la API v1
 
 from fastapi import APIRouter
 
-from app.api.v1.endpoints import auth, health, tenants, users, systems, categories, tickets, client_profile
+from app.api.v1.endpoints import auth, health, tenants, users, systems, categories, tickets, client_profile, audit
 
 api_router = APIRouter()
 
@@ -59,4 +59,11 @@ api_router.include_router(
     client_profile.router,
     prefix="/client-profile",
     tags=["client-profile"]
+)
+
+# Audit routes
+api_router.include_router(
+    audit.router,
+    prefix="/audit",
+    tags=["audit"]
 )