feat: Add maintenance scripts and testing utilities

- Added password management utilities for user administration
- Added PowerShell scripts for testing attachment endpoints
- Enhanced development and testing workflow capabilities
- Completed v1.4.0 with all maintenance tools included"

backend/app/api/deps.py

@@ -9,6 +9,7 @@ from app.core.database import get_db
 from app.core.security import security
 from app.core.config import get_settings
 from app.models.user import User, UserRole
+from app.models.tenant import Tenant
 
 settings = get_settings()
 
@@ -55,3 +56,20 @@ async def get_current_active_superuser(
             status_code=403, detail="The user doesn't have enough privileges"
         )
     return current_user
+
+
+async def get_current_tenant(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+) -> Tenant:
+    """Obtener el tenant del usuario actual."""
+    result = await db.execute(select(Tenant).where(Tenant.id == current_user.tenant_id))
+    tenant = result.scalar_one_or_none()
+    
+    if not tenant:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Tenant not found"
+        )
+    
+    return tenant

backend/app/api/schemas/__init__.py

@@ -0,0 +1,15 @@
+"""Schemas package initialization."""
+
+from .client_profile import (
+    ClientProfileCreate,
+    ClientProfileUpdate, 
+    ClientProfileResponse,
+    ClientProfileSummary
+)
+
+__all__ = [
+    "ClientProfileCreate",
+    "ClientProfileUpdate",
+    "ClientProfileResponse", 
+    "ClientProfileSummary"
+]

backend/app/api/schemas/attachment.py

@@ -0,0 +1,25 @@
+"""
+Attachment Schemas - ServiceManagerWeb
+"""
+from pydantic import BaseModel, ConfigDict, Field
+from datetime import datetime
+from typing import Optional
+import uuid
+
+
+class AttachmentResponse(BaseModel):
+    """Schema para respuesta de attachment"""
+    id: uuid.UUID
+    ticket_id: uuid.UUID
+    comment_id: Optional[uuid.UUID] = None
+    uploaded_by: uuid.UUID
+    filename: str
+    original_filename: str
+    mime_type: str
+    file_size: int
+    file_path: str
+    uploaded_by_name: Optional[str] = None
+    created_at: datetime
+    download_url: Optional[str] = None
+    
+    model_config = ConfigDict(from_attributes=True)

backend/app/api/schemas/client_profile.py

@@ -0,0 +1,202 @@
+"""
+Client Profile Schemas - ServiceManagerWeb
+Esquemas de validación para el perfil empresarial de clientes
+"""
+
+from pydantic import BaseModel, Field, validator, EmailStr
+from typing import Optional
+from decimal import Decimal
+from datetime import datetime
+import uuid
+
+
+class ClientProfileBase(BaseModel):
+    """Schema base para ClientProfile."""
+    
+    # === INFORMACIÓN GENERAL ===
+    business_name: Optional[str] = Field(None, max_length=255, description="Razón social")
+    commercial_name: Optional[str] = Field(None, max_length=255, description="Nombre comercial")
+    client_code: Optional[str] = Field(None, max_length=50, description="Clave de cliente")
+    client_type: Optional[str] = Field(None, max_length=50, description="Tipo de cliente")
+    rfc: Optional[str] = Field(None, max_length=13, description="RFC (México)")
+    tax_id: Optional[str] = Field(None, max_length=50, description="ID fiscal general")
+    
+    # === UBICACIÓN ===
+    country: Optional[str] = Field(None, max_length=100, description="País")
+    state: Optional[str] = Field(None, max_length=100, description="Estado/Provincia")
+    city: Optional[str] = Field(None, max_length=100, description="Ciudad")
+    address: Optional[str] = Field(None, description="Dirección completa")
+    external_number: Optional[str] = Field(None, max_length=20, description="Número exterior")
+    internal_number: Optional[str] = Field(None, max_length=20, description="Número interior")
+    postal_code: Optional[str] = Field(None, max_length=10, description="Código postal")
+    neighborhood: Optional[str] = Field(None, max_length=100, description="Colonia")
+    
+    # === CONTACTO ===
+    main_phone: Optional[str] = Field(None, max_length=20, description="Teléfono principal")
+    secondary_phone: Optional[str] = Field(None, max_length=20, description="Teléfono secundario")
+    direct_phone: Optional[str] = Field(None, max_length=20, description="Teléfono directo")
+    phone_extension: Optional[str] = Field(None, max_length=10, description="Extensión")
+    fax: Optional[str] = Field(None, max_length=20, description="Fax")
+    
+    # === INFORMACIÓN ADICIONAL ===
+    business_hours: Optional[str] = Field(None, max_length=255, description="Horario de atención")
+    website: Optional[str] = Field(None, max_length=255, description="Página web")
+    main_email: Optional[EmailStr] = Field(None, description="Email principal")
+    billing_email: Optional[EmailStr] = Field(None, description="Email de facturación")
+    
+    # === MARKETING ===
+    advertising_medium: Optional[str] = Field(None, max_length=255, description="Medio de publicidad")
+    nationality: Optional[str] = Field(None, max_length=100, description="Nacionalidad")
+    
+    # === CONFIGURACIÓN EMPRESARIAL ===
+    logo_url: Optional[str] = Field(None, max_length=500, description="URL del logo")
+    company_representative: Optional[str] = Field(None, max_length=255, description="Representante de empresa")
+    legal_representative: Optional[str] = Field(None, max_length=255, description="Representante legal")
+    
+    # === FINANZAS/FACTURACIÓN ===
+    credit_limit: Optional[Decimal] = Field(None, description="Límite de crédito")
+    payment_terms: Optional[str] = Field(None, max_length=100, description="Términos de pago")
+    preferred_currency: str = Field("MXN", max_length=3, description="Moneda preferida")
+    
+    # === METADATOS ===
+    send_to_billing: bool = Field(False, description="Enviar a facturación")
+    is_active_client: bool = Field(True, description="Cliente activo")
+    is_prospect: bool = Field(False, description="Es prospecto")
+    notes: Optional[str] = Field(None, description="Notas adicionales")
+
+    @validator('rfc')
+    def validate_rfc(cls, v):
+        """Validar formato de RFC mexicano."""
+        if v is None:
+            return v
+        
+        v = v.strip().upper()
+        if len(v) < 10 or len(v) > 13:
+            raise ValueError('RFC debe tener entre 10 y 13 caracteres')
+        
+        # Validación básica de formato RFC
+        import re
+        rfc_pattern = r'^[A-ZÑ&]{3,4}[0-9]{6}[A-Z0-9]{3}$'
+        if not re.match(rfc_pattern, v):
+            raise ValueError('Formato de RFC inválido')
+        
+        return v
+
+    @validator('postal_code')
+    def validate_postal_code(cls, v):
+        """Validar código postal."""
+        if v is None:
+            return v
+        
+        v = v.strip()
+        if not v.isdigit() or len(v) != 5:
+            raise ValueError('Código postal debe tener 5 dígitos')
+        
+        return v
+
+    @validator('website')
+    def validate_website(cls, v):
+        """Validar formato de sitio web."""
+        if v is None:
+            return v
+        
+        v = v.strip()
+        if not v.startswith(('http://', 'https://')):
+            v = f"https://{v}"
+        
+        import re
+        url_pattern = r'^https?://.+\..+'
+        if not re.match(url_pattern, v):
+            raise ValueError('Formato de sitio web inválido')
+        
+        return v
+
+    @validator('preferred_currency')
+    def validate_currency(cls, v):
+        """Validar código de moneda."""
+        valid_currencies = ['MXN', 'USD', 'EUR', 'GBP', 'CAD']
+        if v not in valid_currencies:
+            raise ValueError(f'Moneda debe ser una de: {", ".join(valid_currencies)}')
+        return v
+
+
+class ClientProfileCreate(ClientProfileBase):
+    """Schema para crear un perfil de cliente."""
+    pass
+
+
+class ClientProfileUpdate(ClientProfileBase):
+    """Schema para actualizar un perfil de cliente."""
+    pass
+
+
+class ClientProfileResponse(ClientProfileBase):
+    """Schema de respuesta para ClientProfile."""
+    
+    id: Optional[uuid.UUID] = None
+    tenant_id: uuid.UUID
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+    @property
+    def full_address(self) -> str:
+        """Dirección completa formateada."""
+        address_parts = []
+        
+        if self.address:
+            address_parts.append(self.address)
+        
+        if self.external_number:
+            if self.internal_number:
+                address_parts.append(f"#{self.external_number}-{self.internal_number}")
+            else:
+                address_parts.append(f"#{self.external_number}")
+        
+        if self.neighborhood:
+            address_parts.append(f"Col. {self.neighborhood}")
+        
+        if self.city and self.state:
+            address_parts.append(f"{self.city}, {self.state}")
+        
+        if self.postal_code:
+            address_parts.append(f"C.P. {self.postal_code}")
+            
+        if self.country:
+            address_parts.append(self.country)
+            
+        return ", ".join(address_parts)
+
+    @property
+    def display_name(self) -> str:
+        """Nombre para mostrar."""
+        return self.commercial_name or self.business_name or "Sin nombre"
+
+
+class ClientProfileSummary(BaseModel):
+    """Schema resumido para listados."""
+    
+    id: uuid.UUID
+    tenant_id: uuid.UUID
+    business_name: Optional[str]
+    commercial_name: Optional[str]
+    rfc: Optional[str]
+    client_code: Optional[str]
+    city: Optional[str]
+    state: Optional[str]
+    main_phone: Optional[str]
+    main_email: Optional[str]
+    is_active_client: bool
+    is_prospect: bool
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+    @property
+    def display_name(self) -> str:
+        """Nombre para mostrar."""
+        return self.commercial_name or self.business_name or "Sin nombre"

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

@@ -8,6 +8,7 @@ from fastapi import APIRouter, HTTPException, status, Depends
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
+from sqlalchemy.orm import selectinload
 from pydantic import BaseModel, EmailStr
 from typing import Optional
 import structlog
@@ -257,41 +258,49 @@ async def get_current_user(
             detail="Invalid token"
         )
     
-    # TODO: Fetch actual user from database
+    user_id = payload.get("sub")
+    if not user_id:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid token payload"
+        )
+    
+    # Fetch actual user from database
+    query = select(User).where(User.id == user_id).options(
+        selectinload(User.tenant)
+    )
+    result = await db.execute(query)
+    user = result.scalar_one_or_none()
+    
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+        
+    if not user.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="User account is disabled"
+        )
     
     return {
-        "id": payload["sub"],
+        "id": str(user.id),
-        "email": payload["email"],
+        "email": user.email,
-        "role": payload["role"],
+        "first_name": user.first_name,
-        "tenant_id": payload["tenant_id"]
+        "last_name": user.last_name,
+        "role": user.role.value if hasattr(user.role, 'value') else user.role,
+        "tenant_id": str(user.tenant_id),
+        "tenant_name": user.tenant.name if user.tenant else None,
+        "is_active": user.is_active,
+        "is_two_factor_enabled": user.totp_secret is not None,
+        "last_login": user.last_login.isoformat() if user.last_login else None,
+        "created_at": user.created_at.isoformat()
     }
 
 
 # ===================================
 # DEPENDENCIES
 # ===================================
-
+# Dependencies are imported from app.api.deps to avoid duplication
-async def get_current_active_user(token: str = Depends(oauth2_scheme)):
+# Use get_current_user and get_current_active_superuser from deps.py
-    """
-    Dependency to get current active user from token.
-    
-    Args:
-        token: Access token
-        
-    Returns:
-        Current user data
-        
-    Raises:
-        HTTPException: If token is invalid or user is inactive
-    """
-    payload = security.verify_token(token)
-    if not payload:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid token",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-    
-    # TODO: Verify user exists and is active
-    
-    return payload

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

@@ -0,0 +1,337 @@
+"""
+Client Profile Endpoints - ServiceManagerWeb
+Endpoints para gestión del perfil empresarial de clientes
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, or_
+from typing import Optional
+
+from app.core.database import get_db
+from app.api.deps import get_current_user, get_current_tenant
+from app.api.schemas.client_profile import (
+    ClientProfileCreate,
+    ClientProfileUpdate,
+    ClientProfileResponse,
+    ClientProfileSummary
+)
+from app.models.user import User
+from app.models.tenant import Tenant
+from app.models.client_profile import ClientProfile
+import uuid
+
+
+router = APIRouter()
+
+
+@router.get("/", response_model=ClientProfileResponse)
+async def get_current_client_profile(
+    current_user: User = Depends(get_current_user),
+    current_tenant: Tenant = Depends(get_current_tenant),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Obtener el perfil empresarial del tenant actual.
+    
+    **Permisos**: CLIENT_ADMIN, CLIENT_USER
+    """
+    # Solo clientes pueden acceder
+    if current_user.role not in ['CLIENT_ADMIN', 'CLIENT_USER']:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Solo los clientes pueden acceder al perfil empresarial"
+        )
+    
+    # Buscar perfil existente
+    result = await db.execute(
+        select(ClientProfile).where(ClientProfile.tenant_id == current_tenant.id)
+    )
+    profile = result.scalar_one_or_none()
+    
+    if not profile:
+        # Si no existe, devolver un perfil vacío con solo tenant_id
+        # No crear en base de datos hasta que el usuario guarde
+        return ClientProfileResponse(
+            id=None,
+            tenant_id=current_tenant.id,
+            business_name=None,
+            commercial_name=None,
+            client_code=None,
+            client_type=None,
+            rfc=None,
+            tax_id=None,
+            country=None,
+            state=None,
+            city=None,
+            address=None,
+            external_number=None,
+            internal_number=None,
+            postal_code=None,
+            neighborhood=None,
+            main_phone=None,
+            secondary_phone=None,
+            direct_phone=None,
+            phone_extension=None,
+            fax=None,
+            business_hours=None,
+            website=None,
+            main_email=None,
+            billing_email=None,
+            advertising_medium=None,
+            nationality=None,
+            logo_url=None,
+            company_representative=None,
+            legal_representative=None,
+            credit_limit=None,
+            payment_terms=None,
+            preferred_currency="MXN",
+            send_to_billing=False,
+            is_active_client=True,
+            is_prospect=False,
+            notes=None,
+            created_at=None,
+            updated_at=None
+        )
+    
+    return profile
+
+
+@router.post("/", response_model=ClientProfileResponse)
+async def create_or_update_client_profile(
+    profile_data: ClientProfileCreate,
+    current_user: User = Depends(get_current_user),
+    current_tenant: Tenant = Depends(get_current_tenant),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Crear o actualizar el perfil empresarial del tenant actual.
+    
+    **Permisos**: CLIENT_ADMIN
+    """
+    # Solo CLIENT_ADMIN puede modificar el perfil
+    if current_user.role != 'CLIENT_ADMIN':
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Solo los administradores de cliente pueden modificar el perfil empresarial"
+        )
+    
+    # Buscar perfil existente
+    result = await db.execute(
+        select(ClientProfile).where(ClientProfile.tenant_id == current_tenant.id)
+    )
+    existing_profile = result.scalar_one_or_none()
+    
+    if existing_profile:
+        # Actualizar perfil existente
+        update_data = profile_data.dict(exclude_unset=True)
+        for field, value in update_data.items():
+            setattr(existing_profile, field, value)
+        
+        profile = existing_profile
+    else:
+        # Crear nuevo perfil
+        profile = ClientProfile(
+            tenant_id=current_tenant.id,
+            **profile_data.dict()
+        )
+        db.add(profile)
+    
+    await db.commit()
+    await db.refresh(profile)
+    
+    return profile
+
+
+@router.patch("/", response_model=ClientProfileResponse)
+async def update_client_profile(
+    profile_data: ClientProfileUpdate,
+    current_user: User = Depends(get_current_user),
+    current_tenant: Tenant = Depends(get_current_tenant),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Actualizar parcialmente el perfil empresarial del tenant actual.
+    
+    **Permisos**: CLIENT_ADMIN
+    """
+    # Solo CLIENT_ADMIN puede modificar el perfil
+    if current_user.role != 'CLIENT_ADMIN':
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Solo los administradores de cliente pueden modificar el perfil empresarial"
+        )
+    
+    # Buscar perfil existente
+    result = await db.execute(
+        select(ClientProfile).where(ClientProfile.tenant_id == current_tenant.id)
+    )
+    profile = result.scalar_one_or_none()
+    
+    if not profile:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Perfil empresarial no encontrado"
+        )
+    
+    # Actualizar solo campos proporcionados
+    update_data = profile_data.dict(exclude_unset=True)
+    for field, value in update_data.items():
+        setattr(profile, field, value)
+    
+    await db.commit()
+    await db.refresh(profile)
+    
+    return profile
+
+
+@router.delete("/")
+async def delete_client_profile(
+    current_user: User = Depends(get_current_user),
+    current_tenant: Tenant = Depends(get_current_tenant),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Eliminar el perfil empresarial del tenant actual.
+    
+    **Permisos**: CLIENT_ADMIN
+    """
+    # Solo CLIENT_ADMIN puede eliminar el perfil
+    if current_user.role != 'CLIENT_ADMIN':
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Solo los administradores de cliente pueden eliminar el perfil empresarial"
+        )
+    
+    # Buscar perfil existente
+    result = await db.execute(
+        select(ClientProfile).where(ClientProfile.tenant_id == current_tenant.id)
+    )
+    profile = result.scalar_one_or_none()
+    
+    if not profile:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Perfil empresarial no encontrado"
+        )
+    
+    await db.delete(profile)
+    await db.commit()
+    
+    return {"message": "Perfil empresarial eliminado exitosamente"}
+
+
+# === ENDPOINTS ADMINISTRATIVOS (Solo para ADMIN y SUPPORT_MANAGER) ===
+
+@router.get("/admin/list", response_model=list[ClientProfileSummary])
+async def list_all_client_profiles(
+    skip: int = 0,
+    limit: int = 100,
+    search: Optional[str] = None,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Listar todos los perfiles empresariales (solo para administradores).
+    
+    **Permisos**: ADMIN, SUPPORT_MANAGER
+    """
+    # Solo personal interno puede ver todos los perfiles
+    if current_user.role not in ['ADMIN', 'SUPPORT_MANAGER']:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Acceso denegado"
+        )
+    
+    query = select(ClientProfile)
+    
+    # Filtro de búsqueda
+    if search:
+        search_filter = or_(
+            ClientProfile.business_name.ilike(f"%{search}%"),
+            ClientProfile.commercial_name.ilike(f"%{search}%"),
+            ClientProfile.rfc.ilike(f"%{search}%"),
+            ClientProfile.client_code.ilike(f"%{search}%")
+        )
+        query = query.where(search_filter)
+    
+    # Paginación
+    query = query.offset(skip).limit(limit)
+    query = query.order_by(ClientProfile.created_at.desc())
+    
+    result = await db.execute(query)
+    profiles = result.scalars().all()
+    
+    return profiles
+
+
+@router.get("/admin/{tenant_id}", response_model=ClientProfileResponse)
+async def get_client_profile_by_tenant(
+    tenant_id: uuid.UUID,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Obtener perfil empresarial de un tenant específico (solo para administradores).
+    
+    **Permisos**: ADMIN, SUPPORT_MANAGER
+    """
+    # Solo personal interno puede ver perfiles de otros tenants
+    if current_user.role not in ['ADMIN', 'SUPPORT_MANAGER']:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Acceso denegado"
+        )
+    
+    result = await db.execute(
+        select(ClientProfile).where(ClientProfile.tenant_id == tenant_id)
+    )
+    profile = result.scalar_one_or_none()
+    
+    if not profile:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Perfil empresarial no encontrado"
+        )
+    
+    return profile
+
+
+@router.patch("/admin/{tenant_id}", response_model=ClientProfileResponse)
+async def update_client_profile_by_admin(
+    tenant_id: uuid.UUID,
+    profile_data: ClientProfileUpdate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Actualizar perfil empresarial de un tenant específico (solo para administradores).
+    
+    **Permisos**: ADMIN, SUPPORT_MANAGER
+    """
+    # Solo personal interno puede modificar perfiles de otros tenants
+    if current_user.role not in ['ADMIN', 'SUPPORT_MANAGER']:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Acceso denegado"
+        )
+    
+    result = await db.execute(
+        select(ClientProfile).where(ClientProfile.tenant_id == tenant_id)
+    )
+    profile = result.scalar_one_or_none()
+    
+    if not profile:
+        # Crear perfil si no existe
+        profile = ClientProfile(tenant_id=tenant_id, **profile_data.dict(exclude_unset=True))
+        db.add(profile)
+    else:
+        # Actualizar perfil existente
+        update_data = profile_data.dict(exclude_unset=True)
+        for field, value in update_data.items():
+            setattr(profile, field, value)
+    
+    await db.commit()
+    await db.refresh(profile)
+    
+    return profile

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

@@ -3,18 +3,24 @@ Tickets endpoints - ServiceManagerWeb
 """
 
 from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File
+from fastapi.responses import FileResponse
 from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, func
+from sqlalchemy.orm import selectinload
 from typing import List, Optional
 from datetime import datetime
 from app.core.database import get_db
-from app.api.deps import get_current_user
+from app.api.deps import get_current_user, get_current_tenant
 from app.models.ticket import Ticket, TicketStatus, TicketPriority
 from app.models.user import User
-from app.models.category import Category  # ✅ CORREGIDO: Era TicketCategory
+from app.models.tenant import Tenant
+from app.models.category import Category
 from app.models.system import System
 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
 import uuid
 
 router = APIRouter()
@@ -573,19 +579,60 @@ async def delete_ticket(
     return {"message": "Ticket deleted successfully"}
 
 # ===================================
-# ATTACHMENT ENDPOINTS (placeholder)
+# ===================================
+# ATTACHMENT ENDPOINTS
 # ===================================
 
-@router.get("/{ticket_id}/attachments")
+@router.get("/{ticket_id}/attachments", response_model=List[AttachmentResponse])
 async def get_ticket_attachments(
     ticket_id: str,
     db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
+    current_user: User = Depends(get_current_user),
+    current_tenant: Tenant = Depends(get_current_tenant)
 ):
-    """
+    """Obtener adjuntos de un ticket"""
-    Obtener adjuntos de un ticket
+    try:
-    """
+        ticket_uuid = uuid.UUID(ticket_id)
-    return []
+    except ValueError:
+        raise HTTPException(status_code=400, detail="ID de ticket inválido")
+    
+    # Verificar que el ticket existe y pertenece al tenant
+    result = await db.execute(
+        select(Ticket).where(Ticket.id == ticket_uuid, Ticket.tenant_id == current_tenant.id)
+    )
+    ticket = result.scalar_one_or_none()
+    
+    if not ticket:
+        raise HTTPException(status_code=404, detail="Ticket no encontrado")
+    
+    # Obtener attachments
+    result = await db.execute(
+        select(TicketAttachment)
+        .where(TicketAttachment.ticket_id == ticket_uuid)
+        .options(selectinload(TicketAttachment.uploaded_by_user))
+        .order_by(TicketAttachment.created_at.desc())
+    )
+    attachments = result.scalars().all()
+    
+    # Construir respuesta
+    response = []
+    for att in attachments:
+        response.append(AttachmentResponse(
+            id=att.id,
+            ticket_id=att.ticket_id,
+            comment_id=att.comment_id,
+            uploaded_by=att.uploaded_by,
+            filename=att.filename,
+            original_filename=att.original_filename,
+            mime_type=att.mime_type,
+            file_size=att.file_size,
+            file_path=att.file_path,
+            uploaded_by_name=f"{att.uploaded_by_user.first_name} {att.uploaded_by_user.last_name}" if att.uploaded_by_user else "Unknown",
+            created_at=att.created_at,
+            download_url=f"/api/v1/tickets/{ticket_id}/attachments/{att.id}/download"
+        ))
+    
+    return response
 
 
 @router.post("/{ticket_id}/attachments", status_code=status.HTTP_201_CREATED)
@@ -593,12 +640,106 @@ async def upload_attachment(
     ticket_id: str,
     file: UploadFile = File(...),
     db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
+    current_user: User = Depends(get_current_user),
+    current_tenant: Tenant = Depends(get_current_tenant)
 ):
-    """
+    """Subir un archivo adjunto a un ticket"""
-    Subir un archivo adjunto a un ticket
+    try:
-    """
+        ticket_uuid = uuid.UUID(ticket_id)
-    raise HTTPException(
+    except ValueError:
-        status_code=status.HTTP_501_NOT_IMPLEMENTED,
+        raise HTTPException(status_code=400, detail="ID de ticket inválido")
-        detail="File uploads not yet implemented"
+    
+    # Verificar ticket
+    result = await db.execute(
+        select(Ticket).where(Ticket.id == ticket_uuid, Ticket.tenant_id == current_tenant.id)
+    )
+    ticket = result.scalar_one_or_none()
+    
+    if not ticket:
+        raise HTTPException(status_code=404, detail="Ticket no encontrado")
+    
+    # Guardar archivo
+    file_metadata = await file_handler.save_upload(file, current_tenant.id, ticket_uuid)
+    
+    # Crear registro en BD
+    attachment = TicketAttachment(
+        id=uuid.uuid4(),
+        ticket_id=ticket_uuid,
+        uploaded_by=current_user.id,
+        filename=file_metadata["filename"],
+        original_filename=file_metadata["original_filename"],
+        mime_type=file_metadata["mime_type"],
+        file_size=file_metadata["file_size"],
+        file_path=file_metadata["file_path"],
+        md5_hash=file_metadata["md5_hash"],
+        sha256_hash=file_metadata["sha256_hash"],
+        created_at=datetime.utcnow()
+    )
+    
+    db.add(attachment)
+    await db.commit()
+    await db.refresh(attachment, ["uploaded_by_user"])
+    
+    return {
+        "success": True,
+        "message": "Archivo subido exitosamente",
+        "data": AttachmentResponse(
+            id=attachment.id,
+            ticket_id=attachment.ticket_id,
+            comment_id=attachment.comment_id,
+            uploaded_by=attachment.uploaded_by,
+            filename=attachment.filename,
+            original_filename=attachment.original_filename,
+            mime_type=attachment.mime_type,
+            file_size=attachment.file_size,
+            file_path=attachment.file_path,
+            uploaded_by_name=f"{attachment.uploaded_by_user.first_name} {attachment.uploaded_by_user.last_name}",
+            created_at=attachment.created_at,
+            download_url=f"/api/v1/tickets/{ticket_id}/attachments/{attachment.id}/download"
+        )
+    }
+
+
+@router.get("/{ticket_id}/attachments/{attachment_id}/download")
+async def download_attachment(
+    ticket_id: str,
+    attachment_id: str,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+    current_tenant: Tenant = Depends(get_current_tenant)
+):
+    """Descargar un archivo adjunto"""
+    try:
+        ticket_uuid = uuid.UUID(ticket_id)
+        attachment_uuid = uuid.UUID(attachment_id)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="ID inválido")
+    
+    # Verificar ticket
+    result = await db.execute(
+        select(Ticket).where(Ticket.id == ticket_uuid, Ticket.tenant_id == current_tenant.id)
+    )
+    ticket = result.scalar_one_or_none()
+    
+    if not ticket:
+        raise HTTPException(status_code=404, detail="Ticket no encontrado")
+    
+    # Obtener attachment
+    result = await db.execute(
+        select(TicketAttachment)
+        .where(TicketAttachment.id == attachment_uuid, TicketAttachment.ticket_id == ticket_uuid)
+    )
+    attachment = result.scalar_one_or_none()
+    
+    if not attachment:
+        raise HTTPException(status_code=404, detail="Adjunto no encontrado")
+    
+    # Obtener path del archivo
+    file_path = file_handler.get_file_path(attachment.file_path)
+    
+    # Retornar archivo
+    return FileResponse(
+        path=file_path,
+        filename=attachment.original_filename,
+        media_type=attachment.mime_type
     )

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
+from app.api.v1.endpoints import auth, health, tenants, users, systems, categories, tickets, client_profile
 
 api_router = APIRouter()
 
@@ -54,6 +54,9 @@ api_router.include_router(
     tags=["tickets"]
 )
 
-# Ensure FastAPI is installed in the environment
+# Client Profile routes
-# If not, install it using:
+api_router.include_router(
-# pip install fastapi
+    client_profile.router,
+    prefix="/client-profile",
+    tags=["client-profile"]
+)

backend/app/core/config.py

@@ -23,101 +23,98 @@ class Settings(BaseSettings):
     # ===================================
     # GENERAL
     # ===================================
-    ENVIRONMENT: str = Field(default="development", env="ENVIRONMENT")
+    ENVIRONMENT: str = Field(default="development")
-    DEBUG: bool = Field(default=False, env="DEBUG")
+    DEBUG: bool = Field(default=False)
-    SECRET_KEY: str = Field(..., env="SECRET_KEY")
+    SECRET_KEY: str = Field(...)
-    API_VERSION: str = Field(default="v1", env="API_VERSION")
+    API_VERSION: str = Field(default="v1")
     
     # ===================================
     # DATABASE
     # ===================================
-    DATABASE_URL: str = Field(..., env="DATABASE_URL")
+    DATABASE_URL: str = Field(...)
     
     # ===================================
     # REDIS
     # ===================================
-    REDIS_URL: str = Field(..., env="REDIS_URL")
+    REDIS_URL: str = Field(...)
     
     # ===================================
     # JWT AUTHENTICATION
     # ===================================
-    JWT_SECRET_KEY: str = Field(..., env="JWT_SECRET_KEY")
+    JWT_SECRET_KEY: str = Field(...)
-    JWT_ALGORITHM: str = Field(default="HS256", env="JWT_ALGORITHM")
+    JWT_ALGORITHM: str = Field(default="HS256")
-    ACCESS_TOKEN_EXPIRE_MINUTES: int = Field(default=60, env="ACCESS_TOKEN_EXPIRE_MINUTES")
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = Field(default=60)
-    REFRESH_TOKEN_EXPIRE_DAYS: int = Field(default=7, env="REFRESH_TOKEN_EXPIRE_DAYS")
+    REFRESH_TOKEN_EXPIRE_DAYS: int = Field(default=7)
     
     # ===================================
     # CORS
     # ===================================
     CORS_ORIGINS: str = Field(
-        default="http://localhost:3000,http://localhost:3001",
+        default="http://localhost:3000,http://localhost:3001"
-        env="CORS_ORIGINS"
     )
     
     # ===================================
     # EMAIL
     # ===================================
-    SMTP_HOST: str = Field(default="localhost", env="SMTP_HOST")
+    SMTP_HOST: str = Field(default="localhost")
-    SMTP_PORT: int = Field(default=587, env="SMTP_PORT")
+    SMTP_PORT: int = Field(default=587)
-    SMTP_USER: Optional[str] = Field(default=None, env="SMTP_USER")
+    SMTP_USER: Optional[str] = Field(default=None)
-    SMTP_PASSWORD: Optional[str] = Field(default=None, env="SMTP_PASSWORD")
+    SMTP_PASSWORD: Optional[str] = Field(default=None)
-    SMTP_USE_TLS: bool = Field(default=True, env="SMTP_USE_TLS")
+    SMTP_USE_TLS: bool = Field(default=True)
-    SMTP_USE_SSL: bool = Field(default=False, env="SMTP_USE_SSL")
+    SMTP_USE_SSL: bool = Field(default=False)
     
-    DEFAULT_FROM_EMAIL: str = Field(default="noreply@servicemanager.local", env="DEFAULT_FROM_EMAIL")
+    DEFAULT_FROM_EMAIL: str = Field(default="noreply@servicemanager.local")
-    DEFAULT_FROM_NAME: str = Field(default="ServiceManager", env="DEFAULT_FROM_NAME")
+    DEFAULT_FROM_NAME: str = Field(default="ServiceManager")
     
     # ===================================
     # FILE UPLOADS
     # ===================================
-    MAX_UPLOAD_SIZE_MB: int = Field(default=10, env="MAX_UPLOAD_SIZE_MB")
+    MAX_UPLOAD_SIZE_MB: int = Field(default=10)
-    ALLOWED_FILE_EXTENSIONS: List[str] = Field(
+    ALLOWED_FILE_EXTENSIONS_STR: str = Field(
-        default=["pdf", "jpg", "jpeg", "png", "doc", "docx", "xls", "xlsx", "txt"],
+        default="pdf,jpg,jpeg,png,doc,docx,xls,xlsx,txt",
-        env="ALLOWED_FILE_EXTENSIONS"
+        alias="ALLOWED_FILE_EXTENSIONS"
     )
-    UPLOAD_PATH: str = Field(default="/app/uploads", env="UPLOAD_PATH")
+    UPLOAD_PATH: str = Field(default="/app/uploads")
     
-    @field_validator("ALLOWED_FILE_EXTENSIONS", mode='before')
+    @property
-    @classmethod
+    def ALLOWED_FILE_EXTENSIONS(self) -> List[str]:
-    def validate_file_extensions(cls, v):
+        """Parse the comma-separated file extensions."""
-        if isinstance(v, str):
+        return [ext.strip().lower() for ext in self.ALLOWED_FILE_EXTENSIONS_STR.split(",")]
-            return [ext.strip().lower() for ext in v.split(",")]
-        return [ext.lower() for ext in v]
     
     # ===================================
     # SECURITY
     # ===================================
-    RATE_LIMIT_ENABLED: bool = Field(default=True, env="RATE_LIMIT_ENABLED")
+    RATE_LIMIT_ENABLED: bool = Field(default=True)
-    PASSWORD_MIN_LENGTH: int = Field(default=8, env="PASSWORD_MIN_LENGTH")
+    PASSWORD_MIN_LENGTH: int = Field(default=8)
     
     # Argon2 settings
-    ARGON2_TIME_COST: int = Field(default=3, env="ARGON2_TIME_COST")
+    ARGON2_TIME_COST: int = Field(default=3)
-    ARGON2_MEMORY_COST: int = Field(default=65536, env="ARGON2_MEMORY_COST")
+    ARGON2_MEMORY_COST: int = Field(default=65536)
-    ARGON2_PARALLELISM: int = Field(default=4, env="ARGON2_PARALLELISM")
+    ARGON2_PARALLELISM: int = Field(default=4)
     
     # ===================================
     # LOGGING
     # ===================================
-    LOG_LEVEL: str = Field(default="INFO", env="LOG_LEVEL")
+    LOG_LEVEL: str = Field(default="INFO")
-    LOG_FORMAT: str = Field(default="json", env="LOG_FORMAT")
+    LOG_FORMAT: str = Field(default="json")
-    LOG_FILE: Optional[str] = Field(default=None, env="LOG_FILE")
+    LOG_FILE: Optional[str] = Field(default=None)
     
     # ===================================
     # FRONTEND URLS
     # ===================================
-    CLIENT_FRONTEND_URL: str = Field(default="http://localhost:3000", env="CLIENT_FRONTEND_URL")
+    CLIENT_FRONTEND_URL: str = Field(default="http://localhost:3000")
-    INTERNAL_FRONTEND_URL: str = Field(default="http://localhost:3001", env="INTERNAL_FRONTEND_URL")
+    INTERNAL_FRONTEND_URL: str = Field(default="http://localhost:3001")
     
     # ===================================
     # HEALTH CHECKS
     # ===================================
-    HEALTH_CHECK_TIMEOUT: int = Field(default=30, env="HEALTH_CHECK_TIMEOUT")
+    HEALTH_CHECK_TIMEOUT: int = Field(default=30)
     
     # ===================================
     # CELERY
     # ===================================
-    CELERY_BROKER_URL: str = Field(..., env="CELERY_BROKER_URL")
+    CELERY_BROKER_URL: str = Field(...)
-    CELERY_RESULT_BACKEND: str = Field(..., env="CELERY_RESULT_BACKEND")
+    CELERY_RESULT_BACKEND: str = Field(...)
     
     def is_production(self) -> bool:
         """Check if environment is production."""

backend/app/core/file_handler.py

@@ -0,0 +1,101 @@
+"""
+File Handler - ServiceManagerWeb  
+Gestión simple de archivos adjuntos
+"""
+import os
+import uuid
+import hashlib
+from pathlib import Path
+from typing import Tuple
+from fastapi import UploadFile, HTTPException, status
+
+from app.core.config import get_settings
+
+settings = get_settings()
+
+
+class FileHandler:
+    """Handler simple para archivos adjuntos"""
+    
+    def __init__(self):
+        self.upload_path = Path(settings.UPLOAD_PATH)
+        self.max_size_bytes = settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024
+        self.allowed_extensions = settings.ALLOWED_FILE_EXTENSIONS
+        # Crear directorio si no existe
+        self.upload_path.mkdir(parents=True, exist_ok=True)
+    
+    def _validate_file(self, filename: str, file_size: int) -> None:
+        """Validar archivo"""
+        extension = Path(filename).suffix.lower().lstrip('.')
+        
+        if extension not in self.allowed_extensions:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Extensión no permitida: {extension}"
+            )
+        
+        if file_size > self.max_size_bytes:
+            raise HTTPException(
+                status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+                detail=f"Archivo muy grande. Máximo: {settings.MAX_UPLOAD_SIZE_MB}MB"
+            )
+    
+    def _calculate_checksums(self, content: bytes) -> Tuple[str, str]:
+        """Calcular MD5 y SHA256"""
+        return hashlib.md5(content).hexdigest(), hashlib.sha256(content).hexdigest()
+    
+    async def save_upload(self, file: UploadFile, tenant_id: uuid.UUID, ticket_id: uuid.UUID) -> dict:
+        """Guardar archivo y retornar metadata"""
+        if not file.filename:
+            raise HTTPException(status_code=400, detail="Filename requerido")
+        
+        content = await file.read()
+        file_size = len(content)
+        
+        self._validate_file(file.filename, file_size)
+        
+        md5_hash, sha256_hash = self._calculate_checksums(content)
+        
+        # Nombre único
+        extension = Path(file.filename).suffix.lower()
+        safe_filename = f"{uuid.uuid4().hex}{extension}"
+        
+        # Estructura: uploads/tenant_id/tickets/ticket_id/
+        file_directory = self.upload_path / str(tenant_id) / "tickets" / str(ticket_id)
+        file_directory.mkdir(parents=True, exist_ok=True)
+        
+        file_path = file_directory / safe_filename
+        relative_path = str(file_path.relative_to(self.upload_path))
+        
+        # Guardar archivo
+        with open(file_path, "wb") as f:
+            f.write(content)
+        
+        import mimetypes
+        mime_type = mimetypes.guess_type(file.filename)[0] or "application/octet-stream"
+        
+        return {
+            "filename": safe_filename,
+            "original_filename": file.filename,
+            "file_path": relative_path,
+            "file_size": file_size,
+            "mime_type": mime_type,
+            "md5_hash": md5_hash,
+            "sha256_hash": sha256_hash
+        }
+    
+    def get_file_path(self, relative_path: str) -> Path:
+        """Obtener path absoluto del archivo"""
+        file_path = (self.upload_path / relative_path).resolve()
+        
+        # Verificar que no escape del directorio de uploads
+        if not str(file_path).startswith(str(self.upload_path.resolve())):
+            raise HTTPException(status_code=403, detail="Acceso denegado")
+        
+        if not file_path.exists():
+            raise HTTPException(status_code=404, detail="Archivo no encontrado")
+        
+        return file_path
+
+
+file_handler = FileHandler()

backend/app/main.py

@@ -22,6 +22,7 @@ from app.models.category import Category
 from app.models.user import User
 from app.models.ticket import Ticket
 from app.models.comment import TicketComment
+from app.models.attachment import TicketAttachment
 
 from app.core.logging import setup_logging
 from app.api.v1.router import api_router

backend/app/models/__init__.py

@@ -0,0 +1,21 @@
+"""Models package initialization."""
+
+from .user import User
+from .tenant import Tenant
+from .ticket import Ticket
+from .comment import TicketComment
+from .system import System
+from .category import Category
+from .client_profile import ClientProfile
+from .attachment import TicketAttachment
+
+__all__ = [
+    "User",
+    "Tenant", 
+    "Ticket",
+    "TicketComment",
+    "System",
+    "Category",
+    "ClientProfile",
+    "TicketAttachment"
+]

backend/app/models/attachment.py

@@ -0,0 +1,62 @@
+"""
+Attachment Model - ServiceManagerWeb
+"""
+from sqlalchemy import String, ForeignKey, Integer, DateTime, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.dialects.postgresql import UUID
+from typing import Optional, TYPE_CHECKING
+from datetime import datetime
+import uuid
+
+from app.core.database import Base
+
+if TYPE_CHECKING:
+    from app.models.ticket import Ticket
+    from app.models.comment import TicketComment
+    from app.models.user import User
+
+
+class TicketAttachment(Base):
+    """Modelo de archivos adjuntos en tickets"""
+    __tablename__ = "ticket_attachments"
+    
+    # Sobrescribir campos heredados de Base para que coincidan con la tabla real
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    # Esta tabla NO tiene updated_at, así que lo excluimos del mapping
+    
+    ticket_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("tickets.id", ondelete="CASCADE"),
+        nullable=False
+    )
+    
+    comment_id: Mapped[Optional[uuid.UUID]] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("ticket_comments.id", ondelete="CASCADE"),
+        nullable=True
+    )
+    
+    uploaded_by: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("users.id"),
+        nullable=False
+    )
+    
+    filename: Mapped[str] = mapped_column(String(255), nullable=False)
+    original_filename: Mapped[str] = mapped_column(String(255), nullable=False)
+    mime_type: Mapped[str] = mapped_column(String(100), nullable=False)
+    file_size: Mapped[int] = mapped_column(Integer, nullable=False)
+    file_path: Mapped[str] = mapped_column(String(500), nullable=False)
+    
+    md5_hash: Mapped[Optional[str]] = mapped_column(String(32), nullable=True)
+    sha256_hash: Mapped[Optional[str]] = mapped_column(String(64), nullable=True)
+    
+    ticket: Mapped["Ticket"] = relationship("Ticket", back_populates="attachments")
+    comment: Mapped[Optional["TicketComment"]] = relationship("TicketComment", back_populates="attachments")
+    uploaded_by_user: Mapped["User"] = relationship("User")
+    
+    # Excluir updated_at del mapping ya que la tabla no lo tiene
+    __mapper_args__ = {
+        "exclude_properties": ["updated_at"]
+    }

backend/app/models/client_profile.py

@@ -0,0 +1,123 @@
+"""
+Client Profile Model - ServiceManagerWeb
+
+Modelo para perfil empresarial de clientes
+Almacena información detallada de la empresa cliente
+"""
+
+from sqlalchemy import String, Boolean, DateTime, ForeignKey, Text, Numeric
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.dialects.postgresql import UUID
+from typing import Optional, TYPE_CHECKING
+import uuid
+from datetime import datetime
+
+from app.core.database import Base
+
+if TYPE_CHECKING:
+    from app.models.tenant import Tenant
+
+
+class ClientProfile(Base):
+    """Modelo de Perfil de Cliente Empresarial."""
+    
+    __tablename__ = "client_profiles"
+    
+    # Relación con tenant (uno a uno)
+    tenant_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("tenants.id", ondelete="CASCADE"),
+        unique=True,
+        nullable=False,
+        index=True
+    )
+    
+    # === INFORMACIÓN GENERAL ===
+    business_name: Mapped[Optional[str]] = mapped_column(String(255))  # Razón social
+    commercial_name: Mapped[Optional[str]] = mapped_column(String(255))  # Nombre comercial
+    client_code: Mapped[Optional[str]] = mapped_column(String(50))  # Clave de cliente
+    client_type: Mapped[Optional[str]] = mapped_column(String(50))  # Tipo de cliente
+    rfc: Mapped[Optional[str]] = mapped_column(String(13))  # RFC México
+    tax_id: Mapped[Optional[str]] = mapped_column(String(50))  # ID fiscal general
+    
+    # === UBICACIÓN ===
+    country: Mapped[Optional[str]] = mapped_column(String(100))
+    state: Mapped[Optional[str]] = mapped_column(String(100))
+    city: Mapped[Optional[str]] = mapped_column(String(100))
+    address: Mapped[Optional[str]] = mapped_column(Text)
+    external_number: Mapped[Optional[str]] = mapped_column(String(20))
+    internal_number: Mapped[Optional[str]] = mapped_column(String(20))
+    postal_code: Mapped[Optional[str]] = mapped_column(String(10))
+    neighborhood: Mapped[Optional[str]] = mapped_column(String(100))
+    
+    # === CONTACTO ===
+    main_phone: Mapped[Optional[str]] = mapped_column(String(20))
+    secondary_phone: Mapped[Optional[str]] = mapped_column(String(20))
+    direct_phone: Mapped[Optional[str]] = mapped_column(String(20))
+    phone_extension: Mapped[Optional[str]] = mapped_column(String(10))
+    fax: Mapped[Optional[str]] = mapped_column(String(20))
+    
+    # === INFORMACIÓN ADICIONAL ===
+    business_hours: Mapped[Optional[str]] = mapped_column(String(255))
+    website: Mapped[Optional[str]] = mapped_column(String(255))
+    main_email: Mapped[Optional[str]] = mapped_column(String(320))
+    billing_email: Mapped[Optional[str]] = mapped_column(String(320))
+    
+    # === MARKETING ===
+    advertising_medium: Mapped[Optional[str]] = mapped_column(String(255))
+    nationality: Mapped[Optional[str]] = mapped_column(String(100))
+    
+    # === CONFIGURACIÓN EMPRESARIAL ===
+    logo_url: Mapped[Optional[str]] = mapped_column(String(500))
+    company_representative: Mapped[Optional[str]] = mapped_column(String(255))  # Encargado/Representante
+    legal_representative: Mapped[Optional[str]] = mapped_column(String(255))
+    
+    # === FINANZAS/FACTURACIÓN ===
+    credit_limit: Mapped[Optional[float]] = mapped_column(Numeric(15, 2))
+    payment_terms: Mapped[Optional[str]] = mapped_column(String(100))
+    preferred_currency: Mapped[str] = mapped_column(String(3), default="MXN")
+    
+    # === METADATOS ===
+    send_to_billing: Mapped[bool] = mapped_column(Boolean, default=False)
+    is_active_client: Mapped[bool] = mapped_column(Boolean, default=True)
+    is_prospect: Mapped[bool] = mapped_column(Boolean, default=False)
+    notes: Mapped[Optional[str]] = mapped_column(Text)
+    
+    # === RELACIONES ===
+    tenant: Mapped["Tenant"] = relationship("Tenant", back_populates="client_profile")
+    
+    def __repr__(self) -> str:
+        return f"<ClientProfile(tenant_id={self.tenant_id}, business_name='{self.business_name}')>"
+
+    @property
+    def full_address(self) -> str:
+        """Dirección completa formateada."""
+        address_parts = []
+        
+        if self.address:
+            address_parts.append(self.address)
+        
+        if self.external_number:
+            if self.internal_number:
+                address_parts.append(f"#{self.external_number}-{self.internal_number}")
+            else:
+                address_parts.append(f"#{self.external_number}")
+        
+        if self.neighborhood:
+            address_parts.append(f"Col. {self.neighborhood}")
+        
+        if self.city and self.state:
+            address_parts.append(f"{self.city}, {self.state}")
+        
+        if self.postal_code:
+            address_parts.append(f"C.P. {self.postal_code}")
+            
+        if self.country:
+            address_parts.append(self.country)
+            
+        return ", ".join(address_parts)
+
+    @property
+    def display_name(self) -> str:
+        """Nombre para mostrar (comercial o razón social)."""
+        return self.commercial_name or self.business_name or "Sin nombre"

backend/app/models/comment.py

@@ -64,6 +64,11 @@ class TicketComment(Base):
     # Relationships
     ticket: Mapped["Ticket"] = relationship("Ticket", back_populates="comments")
     author: Mapped["User"] = relationship("User")
+    attachments: Mapped[list["TicketAttachment"]] = relationship(
+        "TicketAttachment",
+        back_populates="comment",
+        cascade="all, delete-orphan"
+    )
     
     def __repr__(self) -> str:
         return f"<TicketComment {self.id} by {self.author_id}>"

backend/app/models/tenant.py

@@ -54,6 +54,7 @@ class Tenant(Base):
     users: Mapped[List["User"]] = relationship("User", back_populates="tenant")
     tickets: Mapped[List["Ticket"]] = relationship("Ticket", back_populates="tenant")
     categories: Mapped[List["Category"]] = relationship("Category", back_populates="tenant")  # ✅ CORREGIDO: Era "TicketCategory"
+    client_profile: Mapped[Optional["ClientProfile"]] = relationship("ClientProfile", back_populates="tenant", uselist=False)
     
     def __repr__(self) -> str:
         return f"<Tenant(id={self.id}, name='{self.name}', slug='{self.slug}')>"

backend/app/models/ticket.py

@@ -126,6 +126,12 @@ class Ticket(Base):
         cascade="all, delete-orphan"
     )
     
+    attachments: Mapped[list["TicketAttachment"]] = relationship(
+        "TicketAttachment",
+        back_populates="ticket",
+        cascade="all, delete-orphan"
+    )
+    
     # ✅ AÑADIDOS: Constraints según schema.sql
     __table_args__ = (
         UniqueConstraint('tenant_id', 'ticket_number', name='uq_tickets_tenant_number'),

backend/backend/migrations/README

@@ -1 +0,0 @@
-Generic single-database configuration.

backend/backend/migrations/env.py

@@ -1,78 +0,0 @@
-from logging.config import fileConfig
-
-from sqlalchemy import engine_from_config
-from sqlalchemy import pool
-
-from alembic import context
-
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
-config = context.config
-
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
-# add your model's MetaData object here
-# for 'autogenerate' support
-# from myapp import mymodel
-# target_metadata = mymodel.Base.metadata
-target_metadata = None
-
-# other values from the config, defined by the needs of env.py,
-# can be acquired:
-# my_important_option = config.get_main_option("my_important_option")
-# ... etc.
-
-
-def run_migrations_offline() -> None:
-    """Run migrations in 'offline' mode.
-
-    This configures the context with just a URL
-    and not an Engine, though an Engine is acceptable
-    here as well.  By skipping the Engine creation
-    we don't even need a DBAPI to be available.
-
-    Calls to context.execute() here emit the given string to the
-    script output.
-
-    """
-    url = config.get_main_option("sqlalchemy.url")
-    context.configure(
-        url=url,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-def run_migrations_online() -> None:
-    """Run migrations in 'online' mode.
-
-    In this scenario we need to create an Engine
-    and associate a connection with the context.
-
-    """
-    connectable = engine_from_config(
-        config.get_section(config.config_ini_section, {}),
-        prefix="sqlalchemy.",
-        poolclass=pool.NullPool,
-    )
-
-    with connectable.connect() as connection:
-        context.configure(
-            connection=connection, target_metadata=target_metadata
-        )
-
-        with context.begin_transaction():
-            context.run_migrations()
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    run_migrations_online()

backend/backend/migrations/script.py.mako

@@ -1,26 +0,0 @@
-"""${message}
-
-Revision ID: ${up_revision}
-Revises: ${down_revision | comma,n}
-Create Date: ${create_date}
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-${imports if imports else ""}
-
-# revision identifiers, used by Alembic.
-revision: str = ${repr(up_revision)}
-down_revision: Union[str, None] = ${repr(down_revision)}
-branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
-depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
-
-
-def upgrade() -> None:
-    ${upgrades if upgrades else "pass"}
-
-
-def downgrade() -> None:
-    ${downgrades if downgrades else "pass"}

backend/check_test_user_password.py

@@ -0,0 +1,77 @@
+"""
+Script para verificar y actualizar password del test_user
+"""
+import asyncio
+import sys
+import os
+from sqlalchemy import select
+from passlib.context import CryptContext
+
+# Configurar el path
+backend_path = os.path.join(os.path.dirname(__file__), 'backend')
+sys.path.insert(0, backend_path)
+
+from app.core.database import AsyncSessionLocal 
+from app.models.user import User
+
+# Configurar passlib igual que en security.py
+pwd_context = CryptContext(
+    schemes=["argon2", "bcrypt"],
+    deprecated="auto",
+    argon2__memory_cost=65536,
+    argon2__time_cost=3,
+    argon2__parallelism=4,
+)
+
+async def check_and_fix_test_user():
+    """Verificar y actualizar password del test_user"""
+    
+    # Contraseñas posibles
+    possible_passwords = [
+        "admin123",
+        "TestPassword123!",
+        "password123",
+        "test123",
+        "hashed_password"
+    ]
+    
+    async with AsyncSessionLocal() as session:
+        try:
+            # Buscar test_user
+            result = await session.execute(
+                select(User).where(User.email == "test_user@example.com")
+            )
+            user = result.scalar_one_or_none()
+            
+            if not user:
+                print("❌ Usuario test_user@example.com no encontrado")
+                return
+            
+            print(f"✅ Usuario encontrado: {user.email}")
+            print(f"Hash actual: {user.password_hash}")
+            
+            # Probar contraseñas posibles
+            found_password = None
+            for password in possible_passwords:
+                if pwd_context.verify(password, user.password_hash):
+                    found_password = password
+                    break
+                    
+            if found_password:
+                print(f"🎉 Contraseña encontrada: {found_password}")
+            else:
+                print("❌ Ninguna contraseña coincide")
+                print("Estableciendo nueva contraseña: admin123")
+                
+                # Establecer nueva contraseña
+                new_password = "admin123"
+                user.password_hash = pwd_context.hash(new_password)
+                await session.commit()
+                print(f"✅ Contraseña actualizada a: {new_password}")
+                
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            await session.rollback()
+
+if __name__ == "__main__":
+    asyncio.run(check_and_fix_test_user())

backend/migrations/versions/13362e8c493a_add_client_profiles_table.py

@@ -0,0 +1,102 @@
+"""Add client_profiles table
+
+Revision ID: 13362e8c493a
+Revises: 48c43e9204c3
+Create Date: 2026-02-05 20:11:52.534918
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision = '13362e8c493a'
+down_revision = '48c43e9204c3'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # Create client_profiles table
+    op.create_table('client_profiles',
+        sa.Column('id', postgresql.UUID(as_uuid=True), nullable=False, default=sa.text('gen_random_uuid()')),
+        sa.Column('tenant_id', postgresql.UUID(as_uuid=True), nullable=False),
+        
+        # === INFORMACIÓN GENERAL ===
+        sa.Column('business_name', sa.String(length=255), nullable=True),
+        sa.Column('commercial_name', sa.String(length=255), nullable=True),
+        sa.Column('client_code', sa.String(length=50), nullable=True),
+        sa.Column('client_type', sa.String(length=50), nullable=True),
+        sa.Column('rfc', sa.String(length=13), nullable=True),
+        sa.Column('tax_id', sa.String(length=50), nullable=True),
+        
+        # === UBICACIÓN ===
+        sa.Column('country', sa.String(length=100), nullable=True),
+        sa.Column('state', sa.String(length=100), nullable=True),
+        sa.Column('city', sa.String(length=100), nullable=True),
+        sa.Column('address', sa.Text(), nullable=True),
+        sa.Column('external_number', sa.String(length=20), nullable=True),
+        sa.Column('internal_number', sa.String(length=20), nullable=True),
+        sa.Column('postal_code', sa.String(length=10), nullable=True),
+        sa.Column('neighborhood', sa.String(length=100), nullable=True),
+        
+        # === CONTACTO ===
+        sa.Column('main_phone', sa.String(length=20), nullable=True),
+        sa.Column('secondary_phone', sa.String(length=20), nullable=True),
+        sa.Column('direct_phone', sa.String(length=20), nullable=True),
+        sa.Column('phone_extension', sa.String(length=10), nullable=True),
+        sa.Column('fax', sa.String(length=20), nullable=True),
+        
+        # === INFORMACIÓN ADICIONAL ===
+        sa.Column('business_hours', sa.String(length=255), nullable=True),
+        sa.Column('website', sa.String(length=255), nullable=True),
+        sa.Column('main_email', sa.String(length=320), nullable=True),
+        sa.Column('billing_email', sa.String(length=320), nullable=True),
+        
+        # === MARKETING ===
+        sa.Column('advertising_medium', sa.String(length=255), nullable=True),
+        sa.Column('nationality', sa.String(length=100), nullable=True),
+        
+        # === CONFIGURACIÓN EMPRESARIAL ===
+        sa.Column('logo_url', sa.String(length=500), nullable=True),
+        sa.Column('company_representative', sa.String(length=255), nullable=True),
+        sa.Column('legal_representative', sa.String(length=255), nullable=True),
+        
+        # === FINANZAS/FACTURACIÓN ===
+        sa.Column('credit_limit', sa.Numeric(precision=15, scale=2), nullable=True),
+        sa.Column('payment_terms', sa.String(length=100), nullable=True),
+        sa.Column('preferred_currency', sa.String(length=3), nullable=False, default='MXN'),
+        
+        # === METADATOS ===
+        sa.Column('send_to_billing', sa.Boolean(), nullable=False, default=False),
+        sa.Column('is_active_client', sa.Boolean(), nullable=False, default=True),
+        sa.Column('is_prospect', sa.Boolean(), nullable=False, default=False),
+        sa.Column('notes', sa.Text(), nullable=True),
+        
+        # === TIMESTAMPS ===
+        sa.Column('created_at', sa.DateTime(timezone=True), nullable=False, default=sa.func.now()),
+        sa.Column('updated_at', sa.DateTime(timezone=True), nullable=False, default=sa.func.now(), onupdate=sa.func.now()),
+        
+        # Constraints
+        sa.PrimaryKeyConstraint('id'),
+        sa.ForeignKeyConstraint(['tenant_id'], ['tenants.id'], ondelete='CASCADE'),
+        sa.UniqueConstraint('tenant_id')  # Relación uno a uno con tenant
+    )
+    
+    # Crear índices para optimizar consultas
+    op.create_index('idx_client_profiles_tenant_id', 'client_profiles', ['tenant_id'])
+    op.create_index('idx_client_profiles_rfc', 'client_profiles', ['rfc'])
+    op.create_index('idx_client_profiles_business_name', 'client_profiles', ['business_name'])
+    op.create_index('idx_client_profiles_client_code', 'client_profiles', ['client_code'])
+
+
+def downgrade() -> None:
+    # Drop índices
+    op.drop_index('idx_client_profiles_client_code', table_name='client_profiles')
+    op.drop_index('idx_client_profiles_business_name', table_name='client_profiles')
+    op.drop_index('idx_client_profiles_rfc', table_name='client_profiles')
+    op.drop_index('idx_client_profiles_tenant_id', table_name='client_profiles')
+    
+    # Drop tabla
+    op.drop_table('client_profiles')

backend/pytest.ini

@@ -0,0 +1,22 @@
+[tool:pytest]
+testpaths = tests
+python_files = test_*.py
+python_functions = test_*
+python_classes = Test*
+asyncio_mode = auto
+addopts = 
+    -v
+    --tb=short
+    --strict-markers
+    --disable-warnings
+    --color=yes
+    --durations=10
+markers =
+    slow: marks tests as slow (deselect with '-m "not slow"')
+    integration: marks tests as integration tests
+    unit: marks tests as unit tests
+    auth: marks tests related to authentication
+    db: marks tests that require database
+filterwarnings =
+    ignore::DeprecationWarning
+    ignore::PendingDeprecationWarning

backend/requirements.txt

@@ -69,6 +69,7 @@ prometheus-client==0.19.0
 pytest==7.4.3
 pytest-asyncio==0.21.1
 pytest-cov==4.1.0
+aiosqlite==0.19.0
 httpx==0.25.2            # For testing
 faker==20.1.0            # Test data generation
 

backend/set_test_password.py

@@ -0,0 +1,59 @@
+"""
+Script para establecer contraseña real al test_user
+"""
+import asyncio
+import sys
+import os
+from sqlalchemy import select
+from passlib.context import CryptContext
+
+# Configurar el path
+backend_path = os.path.join(os.path.dirname(__file__), 'backend')
+sys.path.insert(0, backend_path)
+
+from app.core.database import AsyncSessionLocal 
+from app.models.user import User
+
+# Configurar passlib
+pwd_context = CryptContext(
+    schemes=["argon2", "bcrypt"],
+    deprecated="auto",
+    argon2__memory_cost=65536,
+    argon2__time_cost=3,
+    argon2__parallelism=4,
+)
+
+async def set_test_user_password():
+    """Establecer contraseña admin123 para test_user"""
+    
+    new_password = "admin123"
+    password_hash = pwd_context.hash(new_password)
+    
+    async with AsyncSessionLocal() as session:
+        try:
+            # Buscar test_user
+            result = await session.execute(
+                select(User).where(User.email == "test_user@example.com")
+            )
+            user = result.scalar_one_or_none()
+            
+            if not user:
+                print("❌ Usuario test_user@example.com no encontrado")
+                return
+            
+            print(f"✅ Usuario encontrado: {user.email}")
+            print(f"Hash anterior: {user.password_hash}")
+            
+            # Establecer nueva contraseña hash
+            user.password_hash = password_hash
+            await session.commit()
+            
+            print(f"🎉 Contraseña establecida: {new_password}")
+            print(f"✅ Nuevo hash: {password_hash[:50]}...")
+                
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            await session.rollback()
+
+if __name__ == "__main__":
+    asyncio.run(set_test_user_password())

backend/tests/conftest.py

@@ -0,0 +1,28 @@
+"""
+Test Configuration - ServiceManagerWeb
+
+Configuración básica para testing con pytest
+"""
+
+import pytest
+
+
+@pytest.fixture 
+def test_user_data():
+    """Sample user data for testing."""
+    return {
+        "email": "test@example.com",
+        "first_name": "Test",
+        "last_name": "User", 
+        "password": "TestPassword123!"
+    }
+
+
+@pytest.fixture 
+def test_tenant_data():
+    """Sample tenant data for testing."""
+    return {
+        "name": "Test Tenant",
+        "slug": "test-tenant",
+        "description": "Test tenant for testing"
+    }

backend/tests/test.env

@@ -0,0 +1,7 @@
+# Test Environment Variables
+ENVIRONMENT=test
+DEBUG=true
+SECRET_KEY=test-secret-key-for-testing-123456789
+JWT_SECRET_KEY=test-jwt-secret-key-for-testing-987654321
+DATABASE_URL=postgresql+asyncpg://servicemanager:servicemanager123@postgres:5432/servicemanager
+REDIS_URL=redis://redis:6379/0

backend/tests/test_basic.py

@@ -0,0 +1,58 @@
+"""
+Very basic tests - ServiceManagerWeb
+
+Tests simplísimos para verificar que pytest funciona
+"""
+
+import pytest
+
+
+def test_basic_math():
+    """Test basic functionality."""
+    assert 1 + 1 == 2
+    assert 2 * 3 == 6
+    assert 10 // 3 == 3
+
+
+def test_string_operations():
+    """Test string operations."""
+    text = "ServiceManager"
+    assert text.lower() == "servicemanager"
+    assert len(text) == 14
+    assert "Manager" in text
+
+
+@pytest.mark.asyncio
+async def test_async_operation():
+    """Test async functionality works."""
+    import asyncio
+    await asyncio.sleep(0.001)  # Very short sleep
+    assert True
+
+
+def test_list_operations():
+    """Test list operations."""
+    items = ["tickets", "users", "tenants"]
+    assert len(items) == 3
+    assert "tickets" in items
+    assert items[0] == "tickets"
+
+
+def test_dict_operations():
+    """Test dictionary operations."""
+    data = {
+        "name": "Test User",
+        "email": "test@example.com",
+        "active": True
+    }
+    assert data["name"] == "Test User"
+    assert data.get("email") is not None
+    assert data["active"] is True
+
+
+# Mark for later when configuration is fixed
+@pytest.mark.skip(reason="Configuration issue with ALLOWED_FILE_EXTENSIONS")
+def test_security_imports():
+    """Test security imports - skip for now due to config issue."""
+    from app.core.security import security
+    assert security is not None

backend/tests/test_health.py

@@ -0,0 +1,50 @@
+"""
+Tests for Health Check endpoints - ServiceManagerWeb
+
+Tests básicos para verificar que la configuración de testing funciona
+"""
+
+import pytest
+import asyncio
+
+
+@pytest.mark.asyncio
+async def test_health_check_async():
+    """Test that async operations work in testing."""
+    # Simple async test to verify setup
+    await asyncio.sleep(0.01)
+    assert True
+
+
+def test_basic_math():
+    """Test basic functionality."""
+    assert 1 + 1 == 2
+
+
+# Test básico de importación de módulos principales
+def test_imports():
+    """Test that core modules can be imported without errors."""
+    try:
+        from app.core.config import get_settings
+        from app.core.security import security
+        
+        # Test que las funciones básicas existen
+        assert get_settings is not None
+        assert security is not None
+        assert hasattr(security, 'hash_password')
+        assert hasattr(security, 'verify_password')
+        
+    except ImportError as e:
+        pytest.fail(f"Failed to import core modules: {e}")
+
+
+def test_security_functions():
+    """Test basic security functions."""
+    from app.core.security import security
+    
+    password = "TestPassword123!"
+    hashed = security.hash_password(password)
+    
+    assert hashed != password  # Should be hashed
+    assert security.verify_password(password, hashed)  # Should verify
+    assert not security.verify_password("wrong", hashed)  # Should not verify wrong password

frontend-client/src/lib/stores/tickets.ts

@@ -1,8 +1,14 @@
-import { writable, get } from 'svelte/store';
 import type { Writable } from 'svelte/store';
+import { get, writable } from 'svelte/store';
 import { auth } from './auth';
 
 // Types
+interface FastAPIValidationError {
+  loc: (string | number)[];
+  msg: string;
+  type: string;
+}
+
 export interface Ticket {
   id: string;
   title: string;
@@ -74,11 +80,16 @@ const initialState: TicketsState = {
 async function apiCall(endpoint: string, options: RequestInit = {}) {
   const authState = get(auth);
 
+  if (!authState.token || !authState.user) {
+    throw new Error('Not authenticated');
+  }
+
   const response = await fetch(`/api/v1${endpoint}`, {
     ...options,
     headers: {
       'Content-Type': 'application/json',
       'Authorization': `Bearer ${authState.token}`,
+      'X-Tenant-ID': authState.user.tenant_id,
       ...options.headers
     }
   });
@@ -93,7 +104,7 @@ async function apiCall(endpoint: string, options: RequestInit = {}) {
       if (error.detail) {
         if (Array.isArray(error.detail)) {
           // Errores de validación de FastAPI
-          errorMessage = error.detail.map(e => `${e.loc.join('.')}: ${e.msg}`).join(', ');
+          errorMessage = error.detail.map((e: FastAPIValidationError) => `${e.loc.join('.')}: ${e.msg}`).join(', ');
         } else if (typeof error.detail === 'string') {
           errorMessage = error.detail;
         } else {
@@ -179,16 +190,16 @@ function createTicketsStore() {
 
       try {
         // Mapear campos del frontend al formato del backend
-    const ticketData = {
+        const ticketData = {
-      subject: ticket.title,           // ← Backend espera "subject" no "title"
+          subject: ticket.title,           // ← Backend espera "subject" no "title"
-      description: ticket.description,
+          description: ticket.description,
-      category_id: ticket.category_id,
+          category_id: ticket.category_id,
-      priority: ticket.priority,
+          priority: ticket.priority,
-      system_id: null                  // ← Opcional
+          system_id: null                  // ← Opcional
-      };
+        };
 
 
-      console.log('Sending ticket data:', ticketData);
+        console.log('Sending ticket data:', ticketData);
 
         const newTicket = await apiCall('/tickets/', {
           method: 'POST',
@@ -243,10 +254,16 @@ function createTicketsStore() {
         formData.append('file', file);
 
         const authState = get(auth);
+
+        if (!authState.token || !authState.user) {
+          throw new Error('Not authenticated');
+        }
+
         const response = await fetch(`/api/v1/tickets/${ticketId}/attachments`, {
           method: 'POST',
           headers: {
-            'Authorization': `Bearer ${authState.token}`
+            'Authorization': `Bearer ${authState.token}`,
+            'X-Tenant-ID': authState.user.tenant_id
           },
           body: formData
         });
@@ -256,7 +273,8 @@ function createTicketsStore() {
           throw new Error(error.detail || 'Upload failed');
         }
 
-        const attachment = await response.json();
+        const result = await response.json();
+        const attachment = result.data || result;
 
         update((state: TicketsState) => ({
           ...state,

frontend-client/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "moduleResolution": "bundler",
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true
+  },
+  "include": [
+    "src/**/*",
+    "app.d.ts"
+  ],
+  "exclude": [
+    "node_modules/**",
+    ".svelte-kit/**",
+    "build/**",
+    "dist/**"
+  ]
+}

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: 'http://backend:8000',
 				changeOrigin: true,
 				rewrite: (path) => path.replace(/^\/api/, '')
 			}

frontend-internal/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "moduleResolution": "bundler",
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true
+  },
+  "include": [
+    "src/**/*",
+    "app.d.ts"
+  ],
+  "exclude": [
+    "node_modules/**",
+    ".svelte-kit/**",
+    "build/**",
+    "dist/**"
+  ]
+}

test_attachments.ps1

@@ -0,0 +1,34 @@
+# Test de Attachments API
+# Ejecutar desde PowerShell
+
+# 1. Login
+$body = '{"email":"admin@aduanasoft.com","password":"admin123","tenant_slug":"aduanasoft"}'
+$login = Invoke-RestMethod -Uri "http://localhost:8000/v1/auth/login" -Method POST -Body $body -ContentType "application/json"
+
+$token = $login.data.access_token
+$tenantId = $login.data.user.tenant_id
+
+$headers = @{
+    "Authorization" = "Bearer $token"
+    "X-Tenant-ID" = $tenantId
+}
+
+Write-Host "Autenticacion exitosa" -ForegroundColor Green
+
+# 2. Listar tickets
+$tickets = Invoke-RestMethod -Uri "http://localhost:8000/v1/tickets" -Headers $headers
+$ticketId = $tickets.data[0].id
+
+Write-Host "Ticket ID obtenido: $ticketId" -ForegroundColor Green
+
+# 3. Listar attachments del ticket
+$attachments = Invoke-RestMethod -Uri "http://localhost:8000/v1/tickets/$ticketId/attachments" -Headers $headers
+
+Write-Host "Attachments listados: $($attachments.Count) encontrados" -ForegroundColor Green
+
+if ($attachments.Count -gt 0) {
+    $attachments | Format-Table id, original_filename, file_size, created_at
+}
+
+Write-Host ""
+Write-Host "TEST COMPLETADO" -ForegroundColor Cyan

test_attachments_endpoint.ps1

@@ -0,0 +1,45 @@
+# Test script para attachments endpoint
+Write-Host "=== Testing Attachments Endpoint ===" -ForegroundColor Cyan
+
+# 1. Login
+$body = '{"email":"admin@aduanasoft.com","password":"admin123","tenant_slug":"aduanasoft"}'
+try {
+    $login = Invoke-RestMethod -Uri "http://localhost:8000/v1/auth/login" -Method POST -Body $body -ContentType "application/json"
+    Write-Host "[OK] Login exitoso" -ForegroundColor Green
+    
+    $token = $login.access_token
+    $tenantId = $login.user.tenant_id
+    
+    Write-Host "Token: $($token.Substring(0,20))..." -ForegroundColor Gray
+    Write-Host "Tenant ID: $tenantId" -ForegroundColor Gray
+    
+    # 2. Test attachments endpoint
+    $headers = @{
+        "Authorization" = "Bearer $token"
+        "X-Tenant-ID" = $tenantId
+    }
+    
+    $url = "http://localhost:8000/v1/tickets/68eaf0fe-b5c3-4d42-9b36-895b439be583/attachments"
+    Write-Host "`nProbando GET $url" -ForegroundColor Yellow
+    
+    try {
+        $response = Invoke-WebRequest -Uri $url -Headers $headers -Method GET
+        Write-Host "[OK] Status Code: $($response.StatusCode)" -ForegroundColor Green
+        
+        $data = $response.Content | ConvertFrom-Json
+        Write-Host "[OK] Attachments encontrados: $($data.Count)" -ForegroundColor Green
+        
+        if ($data.Count -gt 0) {
+            $data | Format-Table id, original_filename, file_size
+        } else {
+            Write-Host "  (No hay attachments para este ticket)" -ForegroundColor Gray
+        }
+        
+    } catch {
+        Write-Host "[ERROR] En request: $($_.Exception.Message)" -ForegroundColor Red
+        Write-Host "Status Code: $($_.Exception.Response.StatusCode.value__)" -ForegroundColor Red
+    }
+    
+} catch {
+    Write-Host "[ERROR] En login: $($_.Exception.Message)" -ForegroundColor Red
+}