diff --git a/README.md b/README.md index b040355..f0d6c7a 100644 --- a/README.md +++ b/README.md @@ -129,6 +129,42 @@ cd ../frontend-internal npm test ``` +## Troubleshooting + +### Error 500 en Login / Proxy Error + +**Síntoma**: Error 500 al intentar hacer login, o error de proxy de Vite "connect ECONNREFUSED". + +**Causa**: Configuración incorrecta de la comunicación entre servicios de Docker. + +**Solución**: +1. En desarrollo con Docker, los servicios usan nombres de servicio (no `localhost`) +2. Verificar `vite.config.js`: el proxy debe apuntar a `http://backend:8000` +3. Verificar `docker-compose.yml`: `PUBLIC_API_URL` debe ser `http://backend:8000` +4. Después de cambios, reiniciar contenedor: `docker-compose restart frontend-internal` + +**Nota**: Para desarrollo local sin Docker, cambiar el proxy a `http://localhost:8000`. + +### Tenant Slug Incorrecto + +**Síntoma**: Error de autenticación incluso con credenciales correctas. + +**Causa**: El `tenant_slug` en el login no coincide con los tenants en la BD. + +**Solución**: +1. Verificar tenants existentes: `docker exec servicemanager-backend python check_tenants.py` +2. Actualizar el tenant_slug en el código de login +3. Tenants por defecto: `aduanasoft-demo`, `test-tenant` + +### Credenciales de Prueba + +``` +Email: admin@aduanasoft.com +Password: admin123 +Tenant: aduanasoft-demo +Role: ADMIN +``` + ## Contribución 1. Fork del proyecto diff --git a/backend/app/api/schemas/sla.py b/backend/app/api/schemas/sla.py new file mode 100644 index 0000000..ddeafa3 --- /dev/null +++ b/backend/app/api/schemas/sla.py @@ -0,0 +1,253 @@ +""" +SLA Schemas - ServiceManagerWeb + +Schemas para el sistema de gestión de SLAs +""" + +from pydantic import BaseModel, ConfigDict +from typing import Optional, List, Dict, Any +from datetime import datetime +from enum import Enum +import uuid + + +class SLATypeEnum(str, Enum): + """Tipos de SLA""" + RESPONSE = "response" + RESOLUTION = "resolution" + + +class SLAStatusEnum(str, Enum): + """Estados de cumplimiento SLA""" + MET = "met" # Cumplido + VIOLATED = "violated" # Violado + AT_RISK = "at_risk" # En riesgo (80%+ del tiempo) + PENDING = "pending" # Pendiente (ticket aún abierto) + + +# =================================== +# DASHBOARD SCHEMAS +# =================================== + +class SLAComplianceMetrics(BaseModel): + """Métricas de cumplimiento SLA""" + target_hours: int + met_count: int + violated_count: int + at_risk_count: int + total_count: int + compliance_percentage: float + avg_time_hours: Optional[float] = None + + +class SLADashboardResponse(BaseModel): + """Response del dashboard principal de SLA""" + tenant_id: uuid.UUID + period_start: datetime + period_end: datetime + generated_at: datetime + + # Métricas generales + response_sla: SLAComplianceMetrics + resolution_sla: SLAComplianceMetrics + + # Contadores rápidos + active_violations: int + at_risk_tickets: int + total_tickets_period: int + + # Breakdown por categoría (top 5) + by_category: List[Dict[str, Any]] + + # Breakdown por prioridad + by_priority: Dict[str, Dict[str, float]] + + # Tendencias (comparación con período anterior) + trends: Dict[str, str] + + model_config = ConfigDict(from_attributes=True) + + +# =================================== +# VIOLATIONS SCHEMAS +# =================================== + +class TicketBasicInfo(BaseModel): + """Información básica del ticket""" + id: uuid.UUID + ticket_number: str + subject: str + priority: str + status: str + + +class UserBasicInfo(BaseModel): + """Información básica del usuario""" + id: uuid.UUID + first_name: str + last_name: str + email: str + + +class CategoryBasicInfo(BaseModel): + """Información básica de categoría""" + id: uuid.UUID + name: str + sla_response_hours: int + sla_resolution_hours: int + + +class SLAViolationResponse(BaseModel): + """Detalle de una violación SLA""" + ticket: TicketBasicInfo + category: Optional[CategoryBasicInfo] = None + created_by: UserBasicInfo + assigned_to: Optional[UserBasicInfo] = None + + sla_type: SLATypeEnum + sla_due_at: datetime + violated_at: datetime + hours_overdue: float + + # Contexto adicional + first_response_at: Optional[datetime] = None + resolved_at: Optional[datetime] = None + + model_config = ConfigDict(from_attributes=True) + + +class SLAViolationsListResponse(BaseModel): + """Lista paginada de violaciones""" + violations: List[SLAViolationResponse] + total: int + page: int + per_page: int + total_pages: int + + +# =================================== +# TICKETS AT RISK +# =================================== + +class SLATicketAtRisk(BaseModel): + """Ticket que está en riesgo de violar SLA""" + ticket: TicketBasicInfo + category: Optional[CategoryBasicInfo] = None + assigned_to: Optional[UserBasicInfo] = None + + sla_type: SLATypeEnum + sla_due_at: datetime + time_remaining_hours: float + risk_percentage: float # 0-100, qué % del tiempo ha pasado + + model_config = ConfigDict(from_attributes=True) + + +class SLAAtRiskListResponse(BaseModel): + """Lista de tickets en riesgo""" + tickets: List[SLATicketAtRisk] + total: int + + +# =================================== +# METRICS & REPORTS SCHEMAS +# =================================== + +class SLAMetricsByCategory(BaseModel): + """Métricas SLA por categoría""" + category_id: uuid.UUID + category_name: str + response_sla_compliance: float + resolution_sla_compliance: float + total_tickets: int + response_violations: int + resolution_violations: int + avg_response_time_hours: Optional[float] + avg_resolution_time_hours: Optional[float] + + +class SLAMetricsByAgent(BaseModel): + """Métricas SLA por agente""" + agent_id: uuid.UUID + agent_name: str + tickets_assigned: int + response_sla_met: int + resolution_sla_met: int + response_compliance: float + resolution_compliance: float + avg_response_time_hours: Optional[float] + avg_resolution_time_hours: Optional[float] + + +class SLAMetricsByPriority(BaseModel): + """Métricas SLA por prioridad""" + priority: str + total_tickets: int + response_sla_compliance: float + resolution_sla_compliance: float + avg_response_time_hours: Optional[float] + avg_resolution_time_hours: Optional[float] + + +class SLADetailedMetricsResponse(BaseModel): + """Response de métricas detalladas""" + tenant_id: uuid.UUID + date_from: datetime + date_to: datetime + group_by: str # 'category', 'agent', 'priority' + + by_category: Optional[List[SLAMetricsByCategory]] = None + by_agent: Optional[List[SLAMetricsByAgent]] = None + by_priority: Optional[List[SLAMetricsByPriority]] = None + + generated_at: datetime + + model_config = ConfigDict(from_attributes=True) + + +# =================================== +# HISTORICAL TRENDS +# =================================== + +class SLADailyTrend(BaseModel): + """Tendencia diaria de SLA""" + date: str # YYYY-MM-DD + response_compliance: float + resolution_compliance: float + total_tickets: int + violations: int + + +class SLATrendsResponse(BaseModel): + """Response de tendencias históricas""" + tenant_id: uuid.UUID + days: int + daily_trends: List[SLADailyTrend] + + # Promedios del período + avg_response_compliance: float + avg_resolution_compliance: float + total_tickets: int + total_violations: int + + model_config = ConfigDict(from_attributes=True) + + +# =================================== +# CONFIGURATION +# =================================== + +class SLAConfigByCategoryResponse(BaseModel): + """Configuración SLA por categoría""" + category_id: uuid.UUID + category_name: str + sla_response_hours: int + sla_resolution_hours: int + warning_threshold_percentage: int # % del tiempo para alertar + is_active: bool + + +class SLAConfigListResponse(BaseModel): + """Lista de configuraciones SLA""" + tenant_id: uuid.UUID + categories: List[SLAConfigByCategoryResponse] diff --git a/backend/app/api/v1/endpoints/sla.py b/backend/app/api/v1/endpoints/sla.py new file mode 100644 index 0000000..2144db6 --- /dev/null +++ b/backend/app/api/v1/endpoints/sla.py @@ -0,0 +1,649 @@ +""" +SLA Endpoints - ServiceManagerWeb + +Endpoints para gestión y monitoreo de SLAs +Solo accesible por roles staff internos +""" + +from fastapi import APIRouter, Depends, HTTPException, Query, status +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy import select, func, and_, or_, desc, case, cast +from typing import Optional, List +from datetime import datetime, timedelta, timezone +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.ticket import Ticket, TicketStatus, TicketPriority +from app.models.category import Category +from app.api.schemas.sla import ( + SLADashboardResponse, + SLAComplianceMetrics, + SLAViolationResponse, + SLAViolationsListResponse, + SLAAtRiskListResponse, + SLATicketAtRisk, + SLADetailedMetricsResponse, + SLAMetricsByCategory, + SLAMetricsByAgent, + SLAMetricsByPriority, + SLATrendsResponse, + SLADailyTrend, + SLAConfigListResponse, + SLAConfigByCategoryResponse, + SLATypeEnum, + TicketBasicInfo, + UserBasicInfo, + CategoryBasicInfo +) + +router = APIRouter() +logger = structlog.get_logger(__name__) + + +def require_staff_role(current_user: User = Depends(get_current_user)) -> User: + """Requiere roles de staff interno (ADMIN, SUPPORT_MANAGER, AGENT)""" + allowed_roles = [UserRole.ADMIN, UserRole.SUPPORT_MANAGER, UserRole.AGENT, UserRole.AUDITOR] + if current_user.role not in allowed_roles: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Solo staff interno puede acceder a métricas de SLA" + ) + return current_user + + +def require_manager_role(current_user: User = Depends(get_current_user)) -> User: + """Requiere roles de gestión (ADMIN, SUPPORT_MANAGER)""" + if current_user.role not in [UserRole.ADMIN, UserRole.SUPPORT_MANAGER]: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Solo managers pueden acceder a esta funcionalidad" + ) + return current_user + + +# =================================== +# DASHBOARD PRINCIPAL +# =================================== + +@router.get("/dashboard", response_model=SLADashboardResponse) +async def get_sla_dashboard( + days: int = Query(default=30, ge=1, le=365, description="Días hacia atrás para el período"), + current_user: User = Depends(require_staff_role), + current_tenant: Tenant = Depends(get_current_tenant), + db: AsyncSession = Depends(get_db) +): + """ + Dashboard principal de métricas SLA. + + **Permisos**: ADMIN, SUPPORT_MANAGER, AGENT, AUDITOR + + Retorna métricas agregadas de cumplimiento SLA para el período especificado. + """ + logger.info( + "SLA dashboard requested", + user_id=str(current_user.id), + tenant_id=str(current_tenant.id), + days=days + ) + + now = datetime.now(timezone.utc) + period_start = now - timedelta(days=days) + + # Usar func.now() para comparaciones en SQL (evita timezone issues) + db_now = func.now() + + # Query base para tickets del período + base_query = select(Ticket).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.created_at >= period_start + ) + ) + + # Calcular métricas de Response SLA + # Para "at risk": ticket pendiente que ha consumido >80% del tiempo disponible + # Calculamos: (now - created_at) > 0.8 * (sla_response_due - created_at) + response_query = select( + func.count().label('total'), + func.sum(case((Ticket.first_response_at <= Ticket.sla_response_due, 1), else_=0)).label('met'), + func.sum(case((and_(Ticket.first_response_at > Ticket.sla_response_due, Ticket.first_response_at != None), 1), else_=0)).label('violated'), + func.sum(case((and_(Ticket.first_response_at == None, Ticket.sla_response_due != None, db_now > Ticket.sla_response_due), 1), else_=0)).label('violated_pending'), + func.sum(case(( + and_( + Ticket.first_response_at == None, + Ticket.sla_response_due != None, + db_now < Ticket.sla_response_due, + func.extract('epoch', db_now - Ticket.created_at) > (func.extract('epoch', Ticket.sla_response_due - Ticket.created_at) * 0.8) + ), 1), else_=0) + ).label('at_risk'), + func.avg( + func.extract('epoch', Ticket.first_response_at - Ticket.created_at) / 3600 + ).label('avg_hours') + ).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.created_at >= period_start, + Ticket.sla_response_due != None + ) + ) + + response_result = await db.execute(response_query) + response_row = response_result.one() + + response_total = response_row.total or 0 + response_met = (response_row.met or 0) + response_violated = (response_row.violated or 0) + (response_row.violated_pending or 0) + response_at_risk = response_row.at_risk or 0 + response_avg = float(response_row.avg_hours) if response_row.avg_hours else 0.0 + response_compliance = (response_met / response_total * 100) if response_total > 0 else 0.0 + + # Calcular métricas de Resolution SLA + resolution_query = select( + func.count().label('total'), + func.sum(case((Ticket.resolved_at <= Ticket.sla_resolution_due, 1), else_=0)).label('met'), + func.sum(case((and_(Ticket.resolved_at > Ticket.sla_resolution_due, Ticket.resolved_at != None), 1), else_=0)).label('violated'), + func.sum(case((and_(Ticket.status.notin_([TicketStatus.RESOLVED, TicketStatus.CLOSED]), Ticket.sla_resolution_due != None, db_now > Ticket.sla_resolution_due), 1), else_=0)).label('violated_pending'), + func.sum(case(( + and_( + Ticket.status.notin_([TicketStatus.RESOLVED, TicketStatus.CLOSED]), + Ticket.sla_resolution_due != None, + db_now < Ticket.sla_resolution_due, + func.extract('epoch', db_now - Ticket.created_at) > (func.extract('epoch', Ticket.sla_resolution_due - Ticket.created_at) * 0.8) + ), 1), else_=0) + ).label('at_risk'), + func.avg( + func.extract('epoch', Ticket.resolved_at - Ticket.created_at) / 3600 + ).label('avg_hours') + ).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.created_at >= period_start, + Ticket.sla_resolution_due != None + ) + ) + + resolution_result = await db.execute(resolution_query) + resolution_row = resolution_result.one() + + resolution_total = resolution_row.total or 0 + resolution_met = (resolution_row.met or 0) + resolution_violated = (resolution_row.violated or 0) + (resolution_row.violated_pending or 0) + resolution_at_risk = resolution_row.at_risk or 0 + resolution_avg = float(resolution_row.avg_hours) if resolution_row.avg_hours else 0.0 + resolution_compliance = (resolution_met / resolution_total * 100) if resolution_total > 0 else 0.0 + + # Métricas por categoría (top 5) + category_query = select( + Category.id, + Category.name, + func.count(Ticket.id).label('ticket_count'), + func.avg(case((Ticket.first_response_at <= Ticket.sla_response_due, 100.0), else_=0.0)).label('response_compliance'), + func.avg(case((Ticket.resolved_at <= Ticket.sla_resolution_due, 100.0), else_=0.0)).label('resolution_compliance') + ).select_from(Ticket).join( + Category, Ticket.category_id == Category.id, isouter=True + ).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.created_at >= period_start + ) + ).group_by(Category.id, Category.name).order_by(desc('ticket_count')).limit(5) + + category_result = await db.execute(category_query) + by_category = [ + { + "category_id": str(row.id) if row.id else None, + "category_name": row.name or "Sin categoría", + "ticket_count": row.ticket_count, + "response_compliance": float(row.response_compliance or 0.0), + "resolution_compliance": float(row.resolution_compliance or 0.0) + } + for row in category_result.all() + ] + + # Métricas por prioridad + by_priority = {} + for priority in TicketPriority: + priority_query = select( + func.avg(case((Ticket.first_response_at <= Ticket.sla_response_due, 100.0), else_=0.0)).label('response'), + func.avg(case((Ticket.resolved_at <= Ticket.sla_resolution_due, 100.0), else_=0.0)).label('resolution') + ).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.created_at >= period_start, + Ticket.priority == priority + ) + ) + + priority_result = await db.execute(priority_query) + priority_row = priority_result.one() + + by_priority[priority.value] = { + "response_compliance": float(priority_row.response or 0.0), + "resolution_compliance": float(priority_row.resolution or 0.0) + } + + # Calcular tendencias (comparación con período anterior) + prev_period_start = period_start - timedelta(days=days) + prev_response_query = select( + func.count().label('total'), + func.sum(case((Ticket.first_response_at <= Ticket.sla_response_due, 1), else_=0)).label('met') + ).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.created_at >= prev_period_start, + Ticket.created_at < period_start, + Ticket.sla_response_due != None + ) + ) + + prev_response_result = await db.execute(prev_response_query) + prev_response_row = prev_response_result.one() + prev_response_compliance = ((prev_response_row.met or 0) / (prev_response_row.total or 1) * 100) if (prev_response_row.total or 0) > 0 else 0.0 + + response_trend = response_compliance - prev_response_compliance + response_trend_str = f"+{response_trend:.1f}%" if response_trend >= 0 else f"{response_trend:.1f}%" + + prev_resolution_query = select( + func.count().label('total'), + func.sum(case((Ticket.resolved_at <= Ticket.sla_resolution_due, 1), else_=0)).label('met') + ).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.created_at >= prev_period_start, + Ticket.created_at < period_start, + Ticket.sla_resolution_due != None + ) + ) + + prev_resolution_result = await db.execute(prev_resolution_query) + prev_resolution_row = prev_resolution_result.one() + prev_resolution_compliance = ((prev_resolution_row.met or 0) / (prev_resolution_row.total or 1) * 100) if (prev_resolution_row.total or 0) > 0 else 0.0 + + resolution_trend = resolution_compliance - prev_resolution_compliance + resolution_trend_str = f"+{resolution_trend:.1f}%" if resolution_trend >= 0 else f"{resolution_trend:.1f}%" + + # Contar violaciones activas + active_violations_query = select(func.count()).select_from(Ticket).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.status.notin_([TicketStatus.RESOLVED, TicketStatus.CLOSED]), + or_( + and_(Ticket.first_response_at == None, Ticket.sla_response_due != None, db_now > Ticket.sla_response_due), + and_(Ticket.resolved_at == None, Ticket.sla_resolution_due != None, db_now > Ticket.sla_resolution_due) + ) + ) + ) + + active_violations_result = await db.execute(active_violations_query) + active_violations = active_violations_result.scalar() or 0 + + # Contar total de tickets del período + total_tickets_query = select(func.count()).select_from(Ticket).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.created_at >= period_start + ) + ) + + total_tickets_result = await db.execute(total_tickets_query) + total_tickets_period = total_tickets_result.scalar() or 0 + + return SLADashboardResponse( + tenant_id=current_tenant.id, + period_start=period_start, + period_end=now, + generated_at=now, + response_sla=SLAComplianceMetrics( + target_hours=2, # Promedio, podría calcularse + met_count=response_met, + violated_count=response_violated, + at_risk_count=response_at_risk, + total_count=response_total, + compliance_percentage=response_compliance, + avg_time_hours=response_avg + ), + resolution_sla=SLAComplianceMetrics( + target_hours=24, # Promedio, podría calcularse + met_count=resolution_met, + violated_count=resolution_violated, + at_risk_count=resolution_at_risk, + total_count=resolution_total, + compliance_percentage=resolution_compliance, + avg_time_hours=resolution_avg + ), + active_violations=active_violations, + at_risk_tickets=response_at_risk + resolution_at_risk, + total_tickets_period=total_tickets_period, + by_category=by_category, + by_priority=by_priority, + trends={ + "response_sla": response_trend_str, + "resolution_sla": resolution_trend_str + } + ) + + +# =================================== +# VIOLACIONES +# =================================== + +@router.get("/violations", response_model=SLAViolationsListResponse) +async def get_sla_violations( + skip: int = Query(default=0, ge=0), + limit: int = Query(default=50, ge=1, le=100), + sla_type: Optional[str] = Query(default=None, regex="^(response|resolution)$"), + category_id: Optional[uuid.UUID] = None, + priority: Optional[str] = None, + current_user: User = Depends(require_staff_role), + current_tenant: Tenant = Depends(get_current_tenant), + db: AsyncSession = Depends(get_db) +): + """ + Listar violaciones SLA activas. + + **Permisos**: ADMIN, SUPPORT_MANAGER, AGENT (solo sus tickets), AUDITOR + + Retorna tickets que han violado sus SLAs de respuesta o resolución. + """ + logger.info( + "SLA violations requested", + user_id=str(current_user.id), + tenant_id=str(current_tenant.id), + sla_type=sla_type + ) + + now = datetime.now(timezone.utc) + db_now = func.now() + + # Base query + query = select(Ticket).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.status.notin_([TicketStatus.RESOLVED, TicketStatus.CLOSED]) + ) + ) + + # Filtrar por tipo de SLA + if sla_type == "response": + query = query.where( + and_( + Ticket.first_response_at == None, + Ticket.sla_response_due != None, + db_now > Ticket.sla_response_due + ) + ) + elif sla_type == "resolution": + query = query.where( + and_( + Ticket.sla_resolution_due != None, + db_now > Ticket.sla_resolution_due + ) + ) + else: + # Ambos tipos + query = query.where( + or_( + and_(Ticket.first_response_at == None, Ticket.sla_response_due != None, db_now > Ticket.sla_response_due), + and_(Ticket.sla_resolution_due != None, db_now > Ticket.sla_resolution_due) + ) + ) + + # Filtros adicionales + if category_id: + query = query.where(Ticket.category_id == category_id) + + if priority: + try: + priority_enum = TicketPriority(priority.upper()) + query = query.where(Ticket.priority == priority_enum) + except ValueError: + pass + + # AGENTS solo ven sus tickets + if current_user.role == UserRole.AGENT: + query = query.where(Ticket.assigned_to == current_user.id) + + # Contar total + 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 + query = query.order_by(desc(Ticket.created_at)).offset(skip).limit(limit) + + result = await db.execute(query) + tickets = result.scalars().all() + + # Formatear response + violations = [] + for ticket in tickets: + # Determinar tipo de violación + response_violated = ticket.first_response_at is None and ticket.sla_response_due and now > ticket.sla_response_due + resolution_violated = ticket.sla_resolution_due and now > ticket.sla_resolution_due + + # Priorizar resolution si ambos están violados + if resolution_violated: + violation_type = SLATypeEnum.RESOLUTION + due_at = ticket.sla_resolution_due + else: + violation_type = SLATypeEnum.RESPONSE + due_at = ticket.sla_response_due + + hours_overdue = (now - due_at).total_seconds() / 3600 if due_at else 0 + + # Cargar relaciones + await db.refresh(ticket, ['created_by', 'assigned_to', 'category']) + + violations.append(SLAViolationResponse( + ticket=TicketBasicInfo( + id=ticket.id, + ticket_number=ticket.ticket_number, + subject=ticket.subject, + priority=ticket.priority.value, + status=ticket.status.value + ), + category=CategoryBasicInfo( + id=ticket.category.id, + name=ticket.category.name, + sla_response_hours=ticket.category.sla_response_hours, + sla_resolution_hours=ticket.category.sla_resolution_hours + ) if ticket.category else None, + created_by=UserBasicInfo( + id=ticket.created_by.id, + first_name=ticket.created_by.first_name, + last_name=ticket.created_by.last_name, + email=ticket.created_by.email + ), + assigned_to=UserBasicInfo( + id=ticket.assigned_to.id, + first_name=ticket.assigned_to.first_name, + last_name=ticket.assigned_to.last_name, + email=ticket.assigned_to.email + ) if ticket.assigned_to else None, + sla_type=violation_type, + sla_due_at=due_at, + violated_at=due_at, # Se violó en el momento del due + hours_overdue=hours_overdue, + first_response_at=ticket.first_response_at, + resolved_at=ticket.resolved_at + )) + + total_pages = (total + limit - 1) // limit + + return SLAViolationsListResponse( + violations=violations, + total=total, + page=(skip // limit) + 1, + per_page=limit, + total_pages=total_pages + ) + + +# =================================== +# TICKETS EN RIESGO +# =================================== + +@router.get("/at-risk", response_model=SLAAtRiskListResponse) +async def get_tickets_at_risk( + threshold: int = Query(default=80, ge=50, le=95, description="% de tiempo consumido para considerar en riesgo"), + current_user: User = Depends(require_staff_role), + current_tenant: Tenant = Depends(get_current_tenant), + db: AsyncSession = Depends(get_db) +): + """ + Listar tickets que están en riesgo de violar SLA. + + **Permisos**: ADMIN, SUPPORT_MANAGER, AGENT (solo sus tickets), AUDITOR + + Retorna tickets que están cerca de vencer su SLA (por defecto, 80% del tiempo consumido). + """ + logger.info( + "SLA at-risk tickets requested", + user_id=str(current_user.id), + tenant_id=str(current_tenant.id), + threshold=threshold + ) + + now = datetime.now(timezone.utc) + db_now = func.now() + threshold_decimal = threshold / 100.0 + + # Query para tickets en riesgo + # Un ticket está en riesgo si: (now - created_at) / (due_at - created_at) >= threshold + query = select(Ticket).where( + and_( + Ticket.tenant_id == current_tenant.id, + Ticket.status.notin_([TicketStatus.RESOLVED, TicketStatus.CLOSED]), + or_( + # Response SLA en riesgo + and_( + Ticket.first_response_at == None, + Ticket.sla_response_due != None, + db_now < Ticket.sla_response_due, + # Calcular si está en zona de riesgo + func.extract('epoch', db_now - Ticket.created_at) >= (func.extract('epoch', Ticket.sla_response_due - Ticket.created_at) * threshold_decimal) + ), + # Resolution SLA en riesgo + and_( + Ticket.sla_resolution_due != None, + db_now < Ticket.sla_resolution_due, + func.extract('epoch', db_now - Ticket.created_at) >= (func.extract('epoch', Ticket.sla_resolution_due - Ticket.created_at) * threshold_decimal) + ) + ) + ) + ).order_by(desc(Ticket.sla_response_due if Ticket.sla_response_due else Ticket.sla_resolution_due)) + + # AGENTS solo ven sus tickets + if current_user.role == UserRole.AGENT: + query = query.where(Ticket.assigned_to == current_user.id) + + result = await db.execute(query) + tickets = result.scalars().all() + + # Formatear response + at_risk_tickets = [] + for ticket in tickets: + # Determinar cuál SLA está en riesgo + response_at_risk = ( + ticket.first_response_at is None and + ticket.sla_response_due and + now < ticket.sla_response_due + ) + + resolution_at_risk = ( + ticket.sla_resolution_due and + now < ticket.sla_resolution_due + ) + + # Priorizar response si ambos están en riesgo + if response_at_risk: + sla_type = SLATypeEnum.RESPONSE + due_at = ticket.sla_response_due + elif resolution_at_risk: + sla_type = SLATypeEnum.RESOLUTION + due_at = ticket.sla_resolution_due + else: + continue + + time_remaining = (due_at - now).total_seconds() / 3600 + total_time = (due_at - ticket.created_at).total_seconds() / 3600 + elapsed_time = total_time - time_remaining + risk_percentage = (elapsed_time / total_time * 100) if total_time > 0 else 0 + + # Cargar relaciones + await db.refresh(ticket, ['assigned_to', 'category']) + + at_risk_tickets.append(SLATicketAtRisk( + ticket=TicketBasicInfo( + id=ticket.id, + ticket_number=ticket.ticket_number, + subject=ticket.subject, + priority=ticket.priority.value, + status=ticket.status.value + ), + category=CategoryBasicInfo( + id=ticket.category.id, + name=ticket.category.name, + sla_response_hours=ticket.category.sla_response_hours, + sla_resolution_hours=ticket.category.sla_resolution_hours + ) if ticket.category else None, + assigned_to=UserBasicInfo( + id=ticket.assigned_to.id, + first_name=ticket.assigned_to.first_name, + last_name=ticket.assigned_to.last_name, + email=ticket.assigned_to.email + ) if ticket.assigned_to else None, + sla_type=sla_type, + sla_due_at=due_at, + time_remaining_hours=time_remaining, + risk_percentage=risk_percentage + )) + + return SLAAtRiskListResponse( + tickets=at_risk_tickets, + total=len(at_risk_tickets) + ) + + +# =================================== +# CONFIGURACIÓN +# =================================== + +@router.get("/config", response_model=SLAConfigListResponse) +async def get_sla_config( + current_user: User = Depends(require_manager_role), + current_tenant: Tenant = Depends(get_current_tenant), + db: AsyncSession = Depends(get_db) +): + """ + Obtener configuración de SLAs por categoría. + + **Permisos**: ADMIN, SUPPORT_MANAGER + + Retorna la configuración de tiempos SLA para todas las categorías del tenant. + """ + query = select(Category).where( + Category.tenant_id == current_tenant.id + ).order_by(Category.name) + + result = await db.execute(query) + categories = result.scalars().all() + + return SLAConfigListResponse( + tenant_id=current_tenant.id, + categories=[ + SLAConfigByCategoryResponse( + category_id=cat.id, + category_name=cat.name, + sla_response_hours=cat.sla_response_hours, + sla_resolution_hours=cat.sla_resolution_hours, + warning_threshold_percentage=80, # Por ahora hardcoded + is_active=cat.is_active + ) + for cat in categories + ] + ) diff --git a/backend/app/api/v1/router.py b/backend/app/api/v1/router.py index f280cce..e361920 100644 --- a/backend/app/api/v1/router.py +++ b/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, audit +from app.api.v1.endpoints import auth, health, tenants, users, systems, categories, tickets, client_profile, audit, sla api_router = APIRouter() @@ -66,4 +66,11 @@ api_router.include_router( audit.router, prefix="/audit", tags=["audit"] +) + +# SLA routes +api_router.include_router( + sla.router, + prefix="/sla", + tags=["sla"] ) \ No newline at end of file diff --git a/backend/check_tenants.py b/backend/check_tenants.py new file mode 100644 index 0000000..2a0fda0 --- /dev/null +++ b/backend/check_tenants.py @@ -0,0 +1,35 @@ +""" +Utility script to list all tenants in the database +""" +import asyncio +from sqlalchemy import select +from app.core.database import AsyncSessionLocal +from app.models.tenant import Tenant + +async def list_tenants(): + """List all tenants with their details.""" + async with AsyncSessionLocal() as db: + result = await db.execute(select(Tenant)) + tenants = result.scalars().all() + + print("\n" + "="*60) + print("📋 TENANTS EN LA BASE DE DATOS") + print("="*60 + "\n") + + if not tenants: + print("⚠️ No hay tenants en la base de datos\n") + print("💡 Ejecuta las migraciones o crea un tenant manualmente") + return + + for tenant in tenants: + print(f"Slug: {tenant.slug}") + print(f"Nombre: {tenant.name}") + print(f"Status: {tenant.status}") + print(f"Email: {tenant.contact_email or 'N/A'}") + print(f"ID: {tenant.id}") + print("-" * 60) + + print(f"\nTotal: {len(tenants)} tenant(s)\n") + +if __name__ == "__main__": + asyncio.run(list_tenants()) diff --git a/docker-compose.yml b/docker-compose.yml index 7a296c7..0c399e8 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -161,7 +161,7 @@ services: restart: unless-stopped environment: - NODE_ENV=${ENVIRONMENT:-development} - - PUBLIC_API_URL=${API_BASE_URL:-http://localhost:8000} + - PUBLIC_API_URL=http://backend:8000 - PUBLIC_APP_NAME=ServiceManager Cliente volumes: - ./frontend-client:/app @@ -186,7 +186,7 @@ services: restart: unless-stopped environment: - NODE_ENV=${ENVIRONMENT:-development} - - PUBLIC_API_URL=${API_BASE_URL:-http://localhost:8000} + - PUBLIC_API_URL=http://backend:8000 - PUBLIC_APP_NAME=ServiceManager Admin volumes: - ./frontend-internal:/app diff --git a/docs/changelog-2026-02-17.md b/docs/changelog-2026-02-17.md new file mode 100644 index 0000000..54db5ac --- /dev/null +++ b/docs/changelog-2026-02-17.md @@ -0,0 +1,119 @@ +# Changelog - 17 de Febrero 2026 +## Versión 1.7.0 - Corrección Sistema de SLA Dashboard + +### 🐛 Bugs Corregidos + +#### Error 500 en Endpoint `/api/v1/sla/dashboard` + +**Problema Identificado:** +El endpoint de SLA Dashboard estaba generando errores 500 (Internal Server Error) al intentar cargar las métricas. Se identificaron dos problemas críticos en las queries SQL: + +1. **Error de Sintaxis SQL - "missing FROM-clause entry for table 'ticket'"** + - **Causa:** Uso incorrecto de `text()` con referencias al modelo SQLAlchemy dentro de expresiones SQL sin formato + - **Ubicación:** Cálculo de tickets "at risk" en queries de Response y Resolution SLA + - **Expresión problemática:** + ```python + text("INTERVAL '20%' * (Ticket.sla_response_due - Ticket.created_at)") + ``` + +2. **Error de Timezone - "can't subtract offset-naive and offset-aware datetimes"** + - **Causa:** Comparación entre `datetime.now(timezone.utc)` (timezone-aware) y campos de base de datos `TIMESTAMP WITHOUT TIME ZONE` (timezone-naive) + - **Ubicación:** Todas las comparaciones temporales en queries SLA + +### ✅ Solución Implementada + +#### Archivo Modificado: +- `backend/app/api/v1/endpoints/sla.py` + +#### Cambios Realizados: + +1. **Eliminación de SQL Crudo con `text()`** + - Se reemplazaron todas las expresiones `text()` con funciones nativas de SQLAlchemy + - Se utilizó `func.extract('epoch', ...)` para cálculos temporales seguros + +2. **Corrección de Timezone** + - Se introdujo `db_now = func.now()` para usar la función `NOW()` de PostgreSQL directamente + - `now = datetime.now(timezone.utc)` se mantiene solo para cálculos en Python (ej: `period_start`) + - Se reemplazaron todas las comparaciones `now > Ticket.sla_response_due` por `db_now > Ticket.sla_response_due` + +3. **Cálculo de Tickets "At Risk" Mejorado** + - **Lógica:** Un ticket está "en riesgo" cuando ha consumido más del 80% del tiempo disponible + - **Nueva expresión segura:** + ```python + func.extract('epoch', db_now - Ticket.created_at) > + (func.extract('epoch', Ticket.sla_response_due - Ticket.created_at) * 0.8) + ``` + +#### Secciones del Código Corregidas: + +1. **Dashboard Principal** (líneas 93-280) + - Query de Response SLA + - Query de Resolution SLA + - Contadores de violaciones activas + +2. **Lista de Violaciones** (líneas 355-395) + - Filtro por tipo de SLA (response/resolution) + - Queries con timezone corregido + +3. **Tickets en Riesgo** (líneas 505-540) + - Cálculo del umbral de riesgo + - Filtrado de tickets según porcentaje de tiempo consumido + +### 🧪 Validación + +**Pruebas Realizadas:** +- ✅ Endpoint `/api/v1/sla/dashboard?days=30` responde correctamente (200 OK) +- ✅ Backend reiniciado sin errores de sintaxis +- ✅ Logs del backend sin excepciones de SQLAlchemy +- ✅ Frontend carga el dashboard de SLA sin errores 500 + +**Estado del Servicio:** +``` +servicemanager-backend: Up and healthy +servicemanager-db: Up and healthy +servicemanager-redis: Up and healthy +``` + +### 📊 Impacto + +**Alta Prioridad:** Este fix desbloquea una funcionalidad crítica del sistema de gestión de SLAs, permitiendo a los equipos de soporte visualizar: +- Métricas de cumplimiento de Response SLA +- Métricas de cumplimiento de Resolution SLA +- Tickets en riesgo de violar SLA +- Violaciones activas +- Tendencias por categoría y prioridad + +### 🔍 Detalles Técnicos + +**Stack Tecnológico:** +- Python 3.11 +- FastAPI (async) +- SQLAlchemy 2.0 (async ORM) +- PostgreSQL +- Docker + +**Patrón de Solución:** +- Uso de funciones SQL nativas a través de SQLAlchemy ORM +- Separación entre datetime Python (timezone-aware) y SQL timestamps (timezone-naive) +- Eliminación de strings SQL dinámicos en favor de expresiones type-safe + +### 📝 Notas para Desarrollo Futuro + +**Lecciones Aprendidas:** +1. Siempre usar `func.now()` para comparaciones temporales en queries SQL +2. Evitar `text()` cuando sea posible; preferir funciones SQLAlchemy +3. Los campos `TIMESTAMP WITHOUT TIME ZONE` en PostgreSQL deben compararse con valores timezone-naive o funciones SQL + +**Recomendaciones:** +- Considerar migración de campos timestamp a `TIMESTAMP WITH TIME ZONE` en futuras versiones +- Agregar tests de integración para endpoints SLA +- Implementar monitoreo de queries SQL lentas + +--- + +**Desarrollador:** GitHub Copilot +**Fecha:** 17 de Febrero 2026 +**Tipo:** Bug Fix +**Severidad:** Alta +**Branch:** main +**Versión:** 1.7.0 diff --git a/frontend-client/vite.config.js b/frontend-client/vite.config.js index 152d435..c0a6d4b 100644 --- a/frontend-client/vite.config.js +++ b/frontend-client/vite.config.js @@ -8,7 +8,7 @@ export default defineConfig({ host: '0.0.0.0', proxy: { '/api': { - target: 'http://servicemanager-backend:8000', + target: process.env.PUBLIC_API_URL || 'http://backend:8000', changeOrigin: true, rewrite: (path) => path.replace(/^\/api/, '') } diff --git a/frontend-internal/src/lib/components/sla/ComplianceGauge.svelte b/frontend-internal/src/lib/components/sla/ComplianceGauge.svelte new file mode 100644 index 0000000..5847d76 --- /dev/null +++ b/frontend-internal/src/lib/components/sla/ComplianceGauge.svelte @@ -0,0 +1,71 @@ + + +
+ + + + + + + + + + {value.toFixed(0)}% + + + + {#if label} +

{label}

+ {/if} +
diff --git a/frontend-internal/src/routes/categories/+page.svelte b/frontend-internal/src/routes/categories/+page.svelte index 7d840e1..c4460fb 100644 --- a/frontend-internal/src/routes/categories/+page.svelte +++ b/frontend-internal/src/routes/categories/+page.svelte @@ -14,7 +14,10 @@ name: '', description: '', tenant_id: '', - is_active: true + is_active: true, + color: '#4F46E5', + sla_response_hours: 24, + sla_resolution_hours: 72 }; async function loadData() { @@ -35,7 +38,15 @@ function openCreateModal() { editingCategory = null; - formData = { name: '', description: '', tenant_id: '', is_active: true }; + formData = { + name: '', + description: '', + tenant_id: '', + is_active: true, + color: '#4F46E5', + sla_response_hours: 24, + sla_resolution_hours: 72 + }; showModal = true; } @@ -45,7 +56,10 @@ name: category.name, description: category.description, tenant_id: category.tenant_id || '', - is_active: category.is_active + is_active: category.is_active, + color: category.color || '#4F46E5', + sla_response_hours: category.sla_response_hours || 24, + sla_resolution_hours: category.sla_resolution_hours || 72 }; showModal = true; } @@ -104,6 +118,8 @@ Nombre Descripción + SLA Respuesta + SLA Resolución Tipo (Cliente) Estado @@ -113,14 +129,31 @@ {#if isLoading} - Cargando... + Cargando... {:else if categories.length === 0} - No hay categorías registradas + No hay categorías registradas {:else} {#each categories as category} - {category.name} + +
+ {#if category.color} +
+ {/if} + {category.name} +
+ {category.description || '-'} + + + ⏱️ {category.sla_response_hours || 24}h + + + + + ✅ {category.sla_resolution_hours || 72}h + + {getTenantName(category.tenant_id)} @@ -148,7 +181,7 @@ showModal = false}>
- +
@@ -157,6 +190,61 @@ +
+
+ + +
+
+ +
+

Configuración de SLA

+ +
+
+ + +

Tiempo máximo para primera respuesta

+
+ +
+ + +

Tiempo máximo para resolver el ticket

+
+
+ +
+

+ Ejemplos comunes:
+ - Crítico: Respuesta 1h, Resolución 8h
+ - Alto: Respuesta 2h, Resolución 24h
+ - Normal: Respuesta 4h, Resolución 48h
+ - Bajo: Respuesta 24h, Resolución 72h +

+
+
+
+ + + + +
+ + + {#if isLoading} +
+
+

Cargando métricas...

+
+ {:else if dashboardData} + +
+ +
+
+
+
+ + + +
+
+
+
Response SLA
+
+
+ {dashboardData.response_sla.compliance_percentage.toFixed(1)}% +
+
+ {getTrendIcon(dashboardData.trends.response_sla)} {dashboardData.trends.response_sla} +
+
+
+ {dashboardData.response_sla.met_count} / {dashboardData.response_sla.total_count} cumplidos +
+
+
+
+
+
+ + +
+
+
+
+ + + +
+
+
+
Resolution SLA
+
+
+ {dashboardData.resolution_sla.compliance_percentage.toFixed(1)}% +
+
+ {getTrendIcon(dashboardData.trends.resolution_sla)} {dashboardData.trends.resolution_sla} +
+
+
+ {dashboardData.resolution_sla.met_count} / {dashboardData.resolution_sla.total_count} cumplidos +
+
+
+
+
+
+ + +
+
+
+
+ + + +
+
+
+
Violaciones Activas
+
+ {dashboardData.active_violations} +
+
+ Ver detalles → +
+
+
+
+
+
+ + +
+
+
+
+ + + +
+
+
+
Tickets en Riesgo
+
+ {dashboardData.at_risk_tickets} +
+
+ Ver lista → +
+
+
+
+
+
+
+ + +
+ +
+

Cumplimiento por Categoría

+
+ + + + + + + + + + + {#each dashboardData.by_category as cat} + + + + + + + {/each} + +
CategoríaTicketsRespuestaResolución
{cat.category_name}{cat.ticket_count} + + {cat.response_compliance.toFixed(1)}% + + + + {cat.resolution_compliance.toFixed(1)}% + +
+
+
+ + +
+

Cumplimiento por Prioridad

+
+ {#each Object.entries(dashboardData.by_priority) as [priority, metrics]} +
+
+ {priority} + + Response: {getMetricValue(metrics, 'response_compliance').toFixed(1)}% + | Resolution: {getMetricValue(metrics, 'resolution_compliance').toFixed(1)}% + +
+
+
+
+
+
+
+
+
+
+ {/each} +
+
+
+ + +
+

Acciones Rápidas

+
+ + + + + Ver Violaciones + + + + + + + Configurar SLAs + + + + + + Ver Todos los Tickets + +
+
+ + +
+
+
+

Total de Tickets

+

{dashboardData.total_tickets_period}

+
+
+

Tiempo Promedio de Respuesta

+

+ {dashboardData.response_sla.avg_time_hours?.toFixed(1) || 'N/A'} hrs +

+
+
+

Tiempo Promedio de Resolución

+

+ {dashboardData.resolution_sla.avg_time_hours?.toFixed(1) || 'N/A'} hrs +

+
+
+
+ {:else} +
+

No se pudieron cargar los datos

+
+ {/if} + diff --git a/frontend-internal/src/routes/sla/at-risk/+page.svelte b/frontend-internal/src/routes/sla/at-risk/+page.svelte new file mode 100644 index 0000000..e763a1d --- /dev/null +++ b/frontend-internal/src/routes/sla/at-risk/+page.svelte @@ -0,0 +1,240 @@ + + +
+ +
+
+

Tickets en Riesgo

+

+ Tickets que están próximos a violar sus SLAs +

+
+
+ + + ← Volver al Dashboard + +
+
+ + +
+
+
+ + + +
+
+

+ Mostrando tickets que han consumido {threshold}% o más de su tiempo SLA. + Estos tickets requieren atención prioritaria para evitar violaciones. +

+
+
+
+ + +
+ {#if isLoading} +
+
+

Cargando tickets en riesgo...

+
+ {:else if atRiskTickets.length === 0} +
+ + + +

¡Todo bajo control!

+

No hay tickets en riesgo de violar SLA

+
+ {:else} + {#each atRiskTickets as ticket} +
+
+
+
+
+ + {ticket.ticket.ticket_number} + + + {ticket.ticket.priority} + + + {getSLATypeLabel(ticket.sla_type)} + +
+

{ticket.ticket.subject}

+ + {#if ticket.category} +
+ 📂 {ticket.category.name} + + (SLA: {ticket.sla_type === 'response' ? ticket.category.sla_response_hours : ticket.category.sla_resolution_hours}h) + +
+ {/if} + + {#if ticket.assigned_to} +
+ 👤 Asignado a: {ticket.assigned_to.first_name} {ticket.assigned_to.last_name} +
+ {/if} +
+ +
+
+ {getRiskLabel(ticket.risk_percentage)} +
+
+ + Progreso: {ticket.risk_percentage.toFixed(1)}% + +
+
+ Quedan: {formatHours(ticket.time_remaining_hours)} +
+
+
+ + +
+
+
+
+
+
+ 0% + {threshold}% (umbral) + 100% +
+
+
+
+ +
+ + Ver ticket → + +
+
+ {/each} + {/if} +
+ + + {#if !isLoading && atRiskTickets.length > 0} +
+

Resumen

+
+
+

Total en Riesgo

+

{atRiskTickets.length}

+
+
+

Riesgo Crítico (≥95%)

+

+ {atRiskTickets.filter(t => t.risk_percentage >= 95).length} +

+
+
+

Riesgo Alto (≥90%)

+

+ {atRiskTickets.filter(t => t.risk_percentage >= 90 && t.risk_percentage < 95).length} +

+
+
+

Riesgo Medio (≥80%)

+

+ {atRiskTickets.filter(t => t.risk_percentage >= 80 && t.risk_percentage < 90).length} +

+
+
+
+ {/if} +
diff --git a/frontend-internal/src/routes/sla/violations/+page.svelte b/frontend-internal/src/routes/sla/violations/+page.svelte new file mode 100644 index 0000000..c2d4686 --- /dev/null +++ b/frontend-internal/src/routes/sla/violations/+page.svelte @@ -0,0 +1,389 @@ + + +
+ +
+
+

Violaciones SLA

+

+ Tickets que han violado sus SLAs de respuesta o resolución +

+
+
+ + ← Volver al Dashboard + +
+
+ + +
+
+
+ + +
+ +
+ + +
+ +
+ + +
+ +
+ +
+
+
+ + +
+
+
+ + + +
+
+

+ {total} violaciones activas encontradas + {#if total > 0} + - Requieren atención inmediata + {/if} +

+
+
+
+ + +
+
+
+
+ + + + + + + + + + + + + + {#if isLoading} + + + + {:else if violations.length === 0} + + + + {:else} + {#each violations as violation} + + + + + + + + + + {/each} + {/if} + +
+ Ticket + + Categoría + + Tipo SLA + + Prioridad + + Tiempo Vencido + + Asignado a + + Acciones +
+
+

Cargando violaciones...

+
+ + + +

Excelente! No hay violaciones de SLA activas

+
+
+ + {violation.ticket.ticket_number} + + + {violation.ticket.subject} + +
+ 		+ {#if violation.category} + {violation.category.name} +
+ R: {violation.category.sla_response_hours}h | + Res: {violation.category.sla_resolution_hours}h +
+ {:else} + Sin categoría + {/if} + 		+ + {getSLATypeLabel(violation.sla_type)} + + + + {violation.ticket.priority} + + + + {formatHours(violation.hours_overdue)} + +
+ vencido +
+ 		+ {#if violation.assigned_to} +
+ + {violation.assigned_to.first_name} {violation.assigned_to.last_name} + + + {violation.assigned_to.email} + +
+ {:else} + Sin asignar + {/if} + 		+ + Ver ticket → + +
+
+
+
+
+ + + {#if totalPages > 1} +
+
+ + +
+ +
+ {/if} +
diff --git a/frontend-internal/vite.config.js b/frontend-internal/vite.config.js index 9854a1a..fa2d689 100644 --- a/frontend-internal/vite.config.js +++ b/frontend-internal/vite.config.js @@ -8,7 +8,7 @@ export default defineConfig({ host: '0.0.0.0', proxy: { '/api': { - target: 'http://servicemanager-backend:8000', + target: process.env.PUBLIC_API_URL || 'http://backend:8000', changeOrigin: true, rewrite: (path) => path.replace(/^\/api/, '') } diff --git a/workers/README.md b/workers/README.md index 636b324..58e23c4 100644 --- a/workers/README.md +++ b/workers/README.md @@ -23,16 +23,19 @@ workers/ ## Tareas Implementadas ### Email Tasks (`email_tasks.py`) + - [x] `send_email_task`: Envío básico de emails SMTP - [x] `send_templated_email_task`: Emails con plantillas Jinja2 - [x] `send_bulk_email_task`: Envío masivo con progreso ### SLA Tasks (`sla_tasks.py`) + - [x] `check_sla_violations`: Monitoreo de violaciones SLA - [x] `calculate_sla_metrics`: Cálculo de métricas SLA - [x] `send_sla_warnings`: Alertas de SLAs próximos a vencer ### Maintenance Tasks (`maintenance_tasks.py`) + - [x] `health_check`: Health check de workers - [x] `cleanup_old_logs`: Limpieza de logs antiguos - [x] `generate_weekly_reports`: Reportes semanales @@ -40,6 +43,7 @@ workers/ - [x] `database_maintenance`: Mantenimiento de BD ### Notification Tasks (`notification_tasks.py`) + - [x] `send_daily_digest`: Digest diario para agentes - [x] `send_ticket_notifications`: Notificaciones de tickets - [x] `send_system_alert`: Alertas del sistema @@ -53,12 +57,12 @@ workers/ "check-sla-violations": check_sla_violations # Diario a las 8:00 AM -"send-daily-digest": send_daily_digest +"send-daily-digest": send_daily_digest # Semanal los domingos a las 2:00 AM "cleanup-old-logs": cleanup_old_logs -# Semanal los lunes a las 9:00 AM +# Semanal los lunes a las 9:00 AM "generate-weekly-reports": generate_weekly_reports # Cada minuto (health check) @@ -115,7 +119,7 @@ DEFAULT_FROM_EMAIL=noreply@servicemanager.local SLA_CHECK_ENABLED=true SLA_WARNING_THRESHOLD=0.8 -# Mantenimiento +# Mantenimiento LOG_RETENTION_DAYS=30 DIGEST_ENABLED=true ``` @@ -133,6 +137,7 @@ DIGEST_ENABLED=true ### Logs Estructurados Todos los workers utilizan structured logging con: + - Task ID único - Correlation ID para tracking - Contexto de tenant @@ -154,7 +159,7 @@ celery -A app.celery inspect active ### Métricas - Task execution times -- Success/failure rates +- Success/failure rates - Queue lengths - Worker load @@ -163,6 +168,7 @@ celery -A app.celery inspect active ### Agregar Nueva Tarea 1. Crear función en módulo apropiado: + ```python @celery_app.task(bind=True, time_limit=300) def new_task(self, param1: str, param2: int): @@ -172,6 +178,7 @@ def new_task(self, param1: str, param2: int): ``` 2. Registrar en `celery.py` si es periódica: + ```python beat_schedule = { "new-periodic-task": { @@ -201,8 +208,9 @@ def reliable_task(self): Los templates están definidos en código por ahora. En el futuro se moverán a base de datos para ser editables por tenants. Templates disponibles: + - `ticket_created` -- `ticket_assigned` +- `ticket_assigned` - `ticket_resolved` - `sla_warning` - `sla_violation` @@ -229,7 +237,7 @@ celery -A app.celery call app.tasks.email_tasks.send_email_task --args='["test@e ```bash # Múltiples workers por queue celery -A app.celery worker --loglevel=info --concurrency=4 --queues=email -celery -A app.celery worker --loglevel=info --concurrency=2 --queues=sla,maintenance +celery -A app.celery worker --loglevel=info --concurrency=2 --queues=sla,maintenance celery -A app.celery worker --loglevel=info --concurrency=1 --queues=default # Beat scheduler (solo una instancia) @@ -249,7 +257,7 @@ celery -A app.celery beat --loglevel=info ### Problemas Comunes -1. **Tasks stuck in queue**: +1. **Tasks stuck in queue**: - Verificar workers activos - Revisar configuración de routing @@ -276,4 +284,4 @@ celery -A app.celery inspect failed # Purgar queue celery -A app.celery purge -Q queue_name -``` \ No newline at end of file +``` diff --git a/workers/app/tasks/sla_tasks.py b/workers/app/tasks/sla_tasks.py index 51a5737..a034f80 100644 --- a/workers/app/tasks/sla_tasks.py +++ b/workers/app/tasks/sla_tasks.py @@ -8,12 +8,24 @@ from celery import current_task from datetime import datetime, timedelta from typing import List, Dict, Any, Optional import structlog +import asyncio +from sqlalchemy import select, and_, or_, func +from sqlalchemy.ext.asyncio import AsyncSession from app.celery import celery_app from app.core.config import get_settings from app.core.logging import get_logger +from app.core.database import get_async_session_context from app.tasks.email_tasks import send_templated_email_task +# Import models +import sys +sys.path.insert(0, '../../backend') +from app.models.ticket import Ticket, TicketStatus +from app.models.user import User +from app.models.category import Category +from app.models.tenant import Tenant + settings = get_settings() logger = get_logger(__name__) @@ -46,92 +58,161 @@ def check_sla_violations(self) -> Dict[str, Any]: task_logger.info("SLA check disabled, skipping") return {"status": "disabled"} - try: - current_time = datetime.utcnow() - results = { - "checked_at": current_time.isoformat(), - "response_violations": [], - "resolution_violations": [], - "warnings": [], - "notifications_sent": 0 - } - - # TODO: Implement actual database queries - # For now, simulate some checks - - # Mock violations for development - mock_violations = [ - { - "ticket_id": "mock-ticket-1", - "ticket_number": "TKT-2024-000001", - "subject": "Problema urgente de conexión", - "priority": "HIGH", - "sla_type": "response", - "due_at": (current_time - timedelta(minutes=30)).isoformat(), - "assigned_to_email": "agent@example.com", - "created_by_email": "cliente@example.com", - "tenant_id": "mock-tenant-1" + async def check_violations_async(): + """Inner async function for database operations""" + async with get_async_session_context() as db: + current_time = datetime.utcnow() + results = { + "checked_at": current_time.isoformat(), + "response_violations": [], + "resolution_violations": [], + "warnings": [], + "notifications_sent": 0 } - ] - - # Process violations - for violation in mock_violations: - task_logger.info( - "Processing SLA violation", - ticket_id=violation["ticket_id"], - sla_type=violation["sla_type"] - ) - if violation["sla_type"] == "response": - results["response_violations"].append(violation) + try: + # Query para Response SLA violations + # Tickets sin primera respuesta y con SLA vencido + response_violations_query = select(Ticket).where( + and_( + Ticket.first_response_at == None, + Ticket.sla_response_due != None, + Ticket.sla_response_due < current_time, + Ticket.status.notin_([TicketStatus.RESOLVED, TicketStatus.CLOSED]) + ) + ) - # Send notification to assigned agent - if violation["assigned_to_email"]: + response_result = await db.execute(response_violations_query) + response_tickets = response_result.scalars().all() + + task_logger.info(f"Found {len(response_tickets)} response SLA violations") + + # Procesar violaciones de respuesta + for ticket in response_tickets: + # Cargar relaciones + await db.refresh(ticket, ['created_by', 'assigned_to', 'category']) + + violation = { + "ticket_id": str(ticket.id), + "ticket_number": ticket.ticket_number, + "subject": ticket.subject, + "priority": ticket.priority.value, + "sla_type": "response", + "due_at": ticket.sla_response_due.isoformat(), + "assigned_to_email": ticket.assigned_to.email if ticket.assigned_to else None, + "created_by_email": ticket.created_by.email, + "tenant_id": str(ticket.tenant_id) + } + + results["response_violations"].append(violation) + + task_logger.info( + "Processing response SLA violation", + ticket_id=violation["ticket_id"], + ticket_number=violation["ticket_number"] + ) + + # Enviar notificación al agente asignado + if violation["assigned_to_email"]: + send_templated_email_task.apply_async(kwargs={ + "to_email": violation["assigned_to_email"], + "template_name": "sla_response_violation", + "context": { + "ticket_number": violation["ticket_number"], + "subject": violation["subject"], + "priority": violation["priority"], + "due_at": violation["due_at"], + "ticket_url": f"https://admin.servicemanager.local/tickets/{violation['ticket_id']}" + }, + "tenant_id": violation["tenant_id"], + "correlation_id": self.request.id + }) + results["notifications_sent"] += 1 + + # Query para Resolution SLA violations + # Tickets no resueltos con SLA de resolución vencido + resolution_violations_query = select(Ticket).where( + and_( + Ticket.resolved_at == None, + Ticket.sla_resolution_due != None, + Ticket.sla_resolution_due < current_time, + Ticket.status.notin_([TicketStatus.RESOLVED, TicketStatus.CLOSED]) + ) + ) + + resolution_result = await db.execute(resolution_violations_query) + resolution_tickets = resolution_result.scalars().all() + + task_logger.info(f"Found {len(resolution_tickets)} resolution SLA violations") + + # Procesar violaciones de resolución + for ticket in resolution_tickets: + await db.refresh(ticket, ['created_by', 'assigned_to', 'category']) + + violation = { + "ticket_id": str(ticket.id), + "ticket_number": ticket.ticket_number, + "subject": ticket.subject, + "priority": ticket.priority.value, + "sla_type": "resolution", + "due_at": ticket.sla_resolution_due.isoformat(), + "assigned_to_email": ticket.assigned_to.email if ticket.assigned_to else None, + "created_by_email": ticket.created_by.email, + "tenant_id": str(ticket.tenant_id) + } + + results["resolution_violations"].append(violation) + + task_logger.info( + "Processing resolution SLA violation", + ticket_id=violation["ticket_id"], + ticket_number=violation["ticket_number"] + ) + + # Enviar escalación al manager + # TODO: Obtener email del manager desde configuración del tenant send_templated_email_task.apply_async(kwargs={ - "to_email": violation["assigned_to_email"], - "template_name": "sla_response_violation", + "to_email": violation["assigned_to_email"] or "manager@example.com", + "template_name": "sla_resolution_violation", "context": { "ticket_number": violation["ticket_number"], "subject": violation["subject"], "priority": violation["priority"], - "due_at": violation["due_at"], + "assigned_to": violation["assigned_to_email"] or "Sin asignar", "ticket_url": f"https://admin.servicemanager.local/tickets/{violation['ticket_id']}" }, "tenant_id": violation["tenant_id"], "correlation_id": self.request.id }) results["notifications_sent"] += 1 - - elif violation["sla_type"] == "resolution": - results["resolution_violations"].append(violation) - # Send escalation notification - send_templated_email_task.apply_async(kwargs={ - "to_email": "manager@example.com", # TODO: Get from tenant config - "template_name": "sla_resolution_violation", - "context": { - "ticket_number": violation["ticket_number"], - "subject": violation["subject"], - "priority": violation["priority"], - "assigned_to": violation["assigned_to_email"], - "ticket_url": f"https://admin.servicemanager.local/tickets/{violation['ticket_id']}" - }, - "tenant_id": violation["tenant_id"], - "correlation_id": self.request.id - }) - results["notifications_sent"] += 1 + task_logger.info( + "SLA violations check completed", + response_violations=len(results["response_violations"]), + resolution_violations=len(results["resolution_violations"]), + warnings=len(results["warnings"]), + notifications_sent=results["notifications_sent"] + ) + + return results + + except Exception as exc: + task_logger.error( + "Error during SLA violations check", + error=str(exc), + exc_info=True + ) + raise + + try: + # Ejecutar la función async + loop = asyncio.get_event_loop() + if loop.is_running(): + # Si ya hay un loop corriendo, crear uno nuevo + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) - # TODO: Check for SLA warnings (approaching deadline) - - task_logger.info( - "SLA violations check completed", - response_violations=len(results["response_violations"]), - resolution_violations=len(results["resolution_violations"]), - warnings=len(results["warnings"]), - notifications_sent=results["notifications_sent"] - ) - - return results + return loop.run_until_complete(check_violations_async()) except Exception as exc: task_logger.error( @@ -171,60 +252,132 @@ def calculate_sla_metrics(self, tenant_id: str, date_from: str, date_to: str) -> date_to=date_to ) - try: - # TODO: Implement actual database queries - # For now, return mock metrics - - metrics = { - "tenant_id": tenant_id, - "date_from": date_from, - "date_to": date_to, - "calculated_at": datetime.utcnow().isoformat(), - "response_sla": { - "target_hours": 2, - "met_count": 45, - "total_count": 50, - "percentage": 90.0, - "avg_response_time_hours": 1.8 - }, - "resolution_sla": { - "target_hours": 24, - "met_count": 42, - "total_count": 48, - "percentage": 87.5, - "avg_resolution_time_hours": 22.5 - }, - "by_priority": { - "LOW": { - "response_sla_percentage": 95.0, - "resolution_sla_percentage": 90.0 - }, - "MEDIUM": { - "response_sla_percentage": 88.0, - "resolution_sla_percentage": 85.0 - }, - "HIGH": { - "response_sla_percentage": 92.0, - "resolution_sla_percentage": 88.0 - }, - "URGENT": { - "response_sla_percentage": 85.0, - "resolution_sla_percentage": 80.0 + async def calculate_metrics_async(): + """Inner async function for database operations""" + async with get_async_session_context() as db: + try: + from uuid import UUID + tenant_uuid = UUID(tenant_id) + date_from_dt = datetime.fromisoformat(date_from) + date_to_dt = datetime.fromisoformat(date_to) + + # Query base para tickets del período + base_query = select(Ticket).where( + and_( + Ticket.tenant_id == tenant_uuid, + Ticket.created_at >= date_from_dt, + Ticket.created_at <= date_to_dt + ) + ) + + result = await db.execute(base_query) + tickets = result.scalars().all() + + total_count = len(tickets) + + # Calcular métricas de Response SLA + response_met = 0 + response_total = 0 + response_times = [] + + for ticket in tickets: + if ticket.sla_response_due: + response_total += 1 + if ticket.first_response_at: + if ticket.first_response_at <= ticket.sla_response_due: + response_met += 1 + response_time = (ticket.first_response_at - ticket.created_at).total_seconds() / 3600 + response_times.append(response_time) + + avg_response_time = sum(response_times) / len(response_times) if response_times else 0 + response_percentage = (response_met / response_total * 100) if response_total > 0 else 0 + + # Calcular métricas de Resolution SLA + resolution_met = 0 + resolution_total = 0 + resolution_times = [] + + for ticket in tickets: + if ticket.sla_resolution_due: + resolution_total += 1 + if ticket.resolved_at: + if ticket.resolved_at <= ticket.sla_resolution_due: + resolution_met += 1 + resolution_time = (ticket.resolved_at - ticket.created_at).total_seconds() / 3600 + resolution_times.append(resolution_time) + + avg_resolution_time = sum(resolution_times) / len(resolution_times) if resolution_times else 0 + resolution_percentage = (resolution_met / resolution_total * 100) if resolution_total > 0 else 0 + + # Métricas por prioridad + by_priority = {} + for priority in ["LOW", "MEDIUM", "HIGH", "URGENT"]: + priority_tickets = [t for t in tickets if t.priority.value == priority] + + p_response_met = sum(1 for t in priority_tickets if t.first_response_at and t.sla_response_due and t.first_response_at <= t.sla_response_due) + p_response_total = sum(1 for t in priority_tickets if t.sla_response_due) + p_response_pct = (p_response_met / p_response_total * 100) if p_response_total > 0 else 0 + + p_resolution_met = sum(1 for t in priority_tickets if t.resolved_at and t.sla_resolution_due and t.resolved_at <= t.sla_resolution_due) + p_resolution_total = sum(1 for t in priority_tickets if t.sla_resolution_due) + p_resolution_pct = (p_resolution_met / p_resolution_total * 100) if p_resolution_total > 0 else 0 + + by_priority[priority] = { + "response_sla_percentage": round(p_response_pct, 1), + "resolution_sla_percentage": round(p_resolution_pct, 1) + } + + metrics = { + "tenant_id": tenant_id, + "date_from": date_from, + "date_to": date_to, + "calculated_at": datetime.utcnow().isoformat(), + "response_sla": { + "target_hours": 2, # Promedio estimado + "met_count": response_met, + "total_count": response_total, + "percentage": round(response_percentage, 1), + "avg_response_time_hours": round(avg_response_time, 1) + }, + "resolution_sla": { + "target_hours": 24, # Promedio estimado + "met_count": resolution_met, + "total_count": resolution_total, + "percentage": round(resolution_percentage, 1), + "avg_resolution_time_hours": round(avg_resolution_time, 1) + }, + "by_priority": by_priority, + "trends": { + "response_sla_trend": "Calculating...", + "resolution_sla_trend": "Calculating..." + } } - }, - "trends": { - "response_sla_trend": "+2.5%", - "resolution_sla_trend": "-1.2%" - } - } + + task_logger.info( + "SLA metrics calculation completed", + response_sla_percentage=metrics["response_sla"]["percentage"], + resolution_sla_percentage=metrics["resolution_sla"]["percentage"], + total_tickets=total_count + ) + + return metrics + + except Exception as exc: + task_logger.error( + "Error during SLA metrics calculation", + error=str(exc), + exc_info=True + ) + raise + + try: + # Ejecutar la función async + loop = asyncio.get_event_loop() + if loop.is_running(): + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) - task_logger.info( - "SLA metrics calculation completed", - response_sla_percentage=metrics["response_sla"]["percentage"], - resolution_sla_percentage=metrics["resolution_sla"]["percentage"] - ) - - return metrics + return loop.run_until_complete(calculate_metrics_async()) except Exception as exc: task_logger.error(