Subir todos los cambios recientes a la rama principal

alembic.ini

@@ -1,37 +0,0 @@
-[alembic]
-script_location = backend/migrations
-
-sqlalchemy.url =
-
-[loggers]
-keys = root,sqlalchemy,alembic
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-[logger_root]
-level = WARN
-handlers = console
-qualname =
-
-[logger_sqlalchemy]
-level = WARN
-handlers = console
-qualname = sqlalchemy.engine
-
-[logger_alembic]
-level = INFO
-handlers = console
-qualname = alembic
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = NOTSET
-formatter = generic
-
-[formatter_generic]
-format = %(asctime)s %(levelname)-5.5s [%(name)s] %(message)s

backend/alembic.ini

@@ -1,10 +1,6 @@
 [alembic]
-script_location = backend/migrations
-sqlalchemy.url = postgresql://servicemanager:servicemanager123@172.19.0.3:5432/servicemanager
-
-target_metadata = app.core.database.Base.metadata
-
-default_environment = development
+script_location = backend/alembic
+sqlalchemy.url = postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
 
 [loggers]
 keys = root,sqlalchemy,alembic
@@ -18,21 +14,23 @@ keys = generic
 [logger_root]
 level = WARN
 handlers = console
+qualname =
 
 [logger_sqlalchemy]
 level = WARN
-handlers = console
+handlers =
 qualname = sqlalchemy.engine
 
 [logger_alembic]
 level = INFO
-handlers = console
+handlers =
 qualname = alembic
 
 [handler_console]
 class = StreamHandler
 args = (sys.stderr,)
+level = NOTSET
 formatter = generic
 
 [formatter_generic]
-format = %(asctime)s %(levelname)-5.5s [%(name)s] %(message)s
+format = %(levelname)-5.5s [%(name)s] %(message)s

backend/alembic/env.py

@@ -0,0 +1,65 @@
+from logging.config import fileConfig
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+from alembic import context
+import os
+from dotenv import load_dotenv
+import sys
+import os
+from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
+import asyncio
+
+# Cargar variables de entorno desde .env
+load_dotenv()
+
+# Agregar el directorio 'backend' al PYTHONPATH
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+
+# Configuración de Alembic
+config = context.config
+
+# Configurar logging
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# Agregar la URL de la base de datos desde las variables de entorno
+config.set_main_option(
+    "sqlalchemy.url",
+    os.getenv("DATABASE_URL", "postgresql+asyncpg://user:password@localhost/dbname")
+)
+
+# Importar modelos para las migraciones
+from app.models import *  # Importa todos los modelos aquí
+from app.core.database import Base
+
+target_metadata = Base.metadata  # Reemplaza con tu metadata
+
+# Cambiar el motor a asíncrono para Alembic
+from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
+
+# Crear el motor asíncrono
+connectable = create_async_engine(
+    os.getenv("DATABASE_URL", "postgresql+asyncpg://user:password@localhost/dbname"),
+    echo=True,  # Habilitar logs para depuración
+)
+
+async def run_migrations():
+    async with connectable.connect() as connection:
+        await connection.run_sync(do_run_migrations)
+
+def do_run_migrations(connection):
+    context.configure(connection=connection, target_metadata=target_metadata)
+    with context.begin_transaction():
+        context.run_migrations()
+
+# Configurar migraciones en modo offline
+def run_migrations_offline():
+    context.configure(url=os.getenv("DATABASE_URL"), target_metadata=target_metadata, literal_binds=True)
+    with context.begin_transaction():
+        context.run_migrations()
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    asyncio.run(run_migrations())

backend/alembic/versions/add_clients_table.py

@@ -0,0 +1,28 @@
+"""
+Add clients table
+"""
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import inspect
+
+# revision identifiers, used by Alembic.
+revision = "add_clients_table"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+def upgrade():
+    bind = op.get_bind()
+    inspector = inspect(bind)
+    if 'clients' not in inspector.get_table_names():
+        op.create_table(
+            'clients',
+            sa.Column('id', sa.Integer, primary_key=True, autoincrement=True),
+            sa.Column('name', sa.String, nullable=False),
+            sa.Column('email', sa.String, nullable=False, unique=True),
+            sa.Column('phone', sa.String, nullable=False),
+        )
+
+def downgrade():
+    op.drop_table('clients')

backend/alembic/versions/add_system_id_to_tickets.py

@@ -0,0 +1,20 @@
+"""
+Agregar columna system_id a la tabla tickets
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+# Revisión ID y dependencias
+revision = 'add_system_id_to_tickets'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+def upgrade():
+    """Agregar columna system_id a la tabla tickets."""
+    op.add_column('tickets', sa.Column('system_id', sa.UUID, nullable=True))
+
+def downgrade():
+    """Eliminar columna system_id de la tabla tickets."""
+    op.drop_column('tickets', 'system_id')

backend/alembic/versions/add_updated_at_to_category.py

@@ -0,0 +1,18 @@
+"""
+Add updated_at column to ticket_categories
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = "add_updated_at_to_category"
+down_revision = "add_clients_table"
+branch_labels = None
+depends_on = None
+
+def upgrade():
+    op.add_column("ticket_categories", sa.Column("updated_at", sa.DateTime(timezone=True), nullable=True))
+
+def downgrade():
+    op.drop_column("ticket_categories", "updated_at")

backend/app/api/deps.py

@@ -55,3 +55,13 @@ async def get_current_active_superuser(
             status_code=403, detail="The user doesn't have enough privileges"
         )
     return current_user
+
+async def get_current_active_user(
+    current_user: User = Depends(get_current_user),
+) -> User:
+    if not current_user.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Inactive user",
+        )
+    return current_user

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

@@ -4,6 +4,7 @@ from sqlalchemy import select
 from pydantic import BaseModel, ConfigDict
 from typing import List, Optional
 import uuid
+import logging
 
 from app.core.database import get_db
 from app.models.category import Category
@@ -11,6 +12,8 @@ from app.api import deps
 
 router = APIRouter()
 
+logger = logging.getLogger("categories")
+
 class CategoryBase(BaseModel):
     name: str
     description: Optional[str] = None
@@ -38,18 +41,56 @@ async def read_categories(
     db: AsyncSession = Depends(get_db),
     current_user = Depends(deps.get_current_active_superuser)
 ):
-    query = select(Category).offset(skip).limit(limit)
-    result = await db.execute(query)
-    return result.scalars().all()
+    try:
+        logger.debug("Fetching categories with skip=%d, limit=%d", skip, limit)
+        query = select(Category).offset(skip).limit(limit)
+        result = await db.execute(query)
+        categories = result.scalars().all()
+        logger.debug("Fetched %d categories", len(categories))
+        return categories
+    except Exception as e:
+        logger.exception("Unhandled exception occurred while fetching categories.")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 @router.post("/", response_model=CategoryResponse)
 async def create_category(
-    category: CategoryCreate, 
+    category: CategoryCreate,
     db: AsyncSession = Depends(get_db),
     current_user = Depends(deps.get_current_active_superuser)
 ):
-    db_category = Category(**category.model_dump())
-    db.add(db_category)
+    new_category = Category(**category.model_dump())
+    db.add(new_category)
+    await db.commit()
+    await db.refresh(new_category)
+    return new_category
+
+@router.put("/{category_id}", response_model=CategoryResponse)
+async def update_category(
+    category_id: uuid.UUID,
+    category: CategoryUpdate,
+    db: AsyncSession = Depends(get_db),
+    current_user = Depends(deps.get_current_active_superuser)
+):
+    db_category = await db.get(Category, category_id)
+    if not db_category:
+        raise HTTPException(status_code=404, detail="Category not found")
+
+    for key, value in category.model_dump(exclude_unset=True).items():
+        setattr(db_category, key, value)
+
     await db.commit()
     await db.refresh(db_category)
     return db_category
+
+@router.delete("/{category_id}", status_code=204)
+async def delete_category(
+    category_id: uuid.UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user = Depends(deps.get_current_active_superuser)
+):
+    db_category = await db.get(Category, category_id)
+    if not db_category:
+        raise HTTPException(status_code=404, detail="Category not found")
+
+    await db.delete(db_category)
+    await db.commit()

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

@@ -0,0 +1,61 @@
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import text  # <--- IMPORTANTE: Necesario para consultas SQL
+from app.core.database import get_db
+
+# IMPORTANTE: Renombramos para evitar conflictos
+from app.models.client import Client as ClientModel
+from app.schemas.client import ClientCreate, ClientUpdate, Client as ClientSchema
+
+router = APIRouter()
+
+# GET: Obtener todos los clientes
+@router.get("/clients", response_model=list[ClientSchema])
+async def get_clients(db: AsyncSession = Depends(get_db)):
+    # Corrección: Usamos text() y mappings().all()
+    query = text("SELECT * FROM clients")
+    result = await db.execute(query)
+    return result.mappings().all()
+
+# POST: Crear cliente
+@router.post("/clients", response_model=ClientSchema)
+async def create_client(client: ClientCreate, db: AsyncSession = Depends(get_db)):
+    # Usamos ClientModel para guardar en BD
+    new_client = ClientModel(**client.dict())
+    db.add(new_client)
+    await db.commit()
+    await db.refresh(new_client)
+    return new_client
+
+# GET ONE: Obtener un cliente por ID
+@router.get("/clients/{client_id}", response_model=ClientSchema)
+async def read_client(client_id: int, db: AsyncSession = Depends(get_db)):
+    db_client = await db.get(ClientModel, client_id)
+    if not db_client:
+        raise HTTPException(status_code=404, detail="Client not found")
+    return db_client
+
+# PUT: Actualizar cliente
+@router.put("/clients/{client_id}", response_model=ClientSchema)
+async def update_client(client_id: int, client: ClientUpdate, db: AsyncSession = Depends(get_db)):
+    db_client = await db.get(ClientModel, client_id)
+    if not db_client:
+        raise HTTPException(status_code=404, detail="Client not found")
+    
+    for key, value in client.dict(exclude_unset=True).items():
+        setattr(db_client, key, value)
+    
+    await db.commit()
+    await db.refresh(db_client)
+    return db_client
+
+# DELETE: Borrar cliente
+@router.delete("/clients/{client_id}")
+async def delete_client(client_id: int, db: AsyncSession = Depends(get_db)):
+    db_client = await db.get(ClientModel, client_id)
+    if not db_client:
+        raise HTTPException(status_code=404, detail="Client not found")
+    
+    await db.delete(db_client)
+    await db.commit()
+    return {"message": "Client deleted successfully"}

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

@@ -85,9 +85,6 @@ async def update_tenant(
         raise HTTPException(status_code=404, detail="Tenant not found")
         
     update_data = tenant_in.model_dump(exclude_unset=True)
-    if "status" in update_data:
-        tenant.is_active = update_data.pop("status") == TenantStatus.active
-
     for field, value in update_data.items():
         setattr(tenant, field, value)
         
@@ -95,18 +92,3 @@ async def update_tenant(
     await db.commit()
     await db.refresh(tenant)
     return tenant
-
-@router.delete("/{tenant_id}", status_code=status.HTTP_204_NO_CONTENT)
-async def delete_tenant(
-    tenant_id: uuid.UUID,
-    db: AsyncSession = Depends(get_db),
-    current_user = Depends(deps.get_current_active_superuser)
-):
-    """Eliminar un cliente (tenant) por ID."""
-    tenant = await db.get(Tenant, tenant_id)
-    if not tenant:
-        raise HTTPException(status_code=404, detail="Tenant not found")
-
-    await db.delete(tenant)
-    await db.commit()
-    return {"message": "Tenant deleted successfully"}

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

@@ -1,493 +1,75 @@
-"""
-Tickets endpoints - ServiceManagerWeb (VERSION FINAL CORREGIDA)
-"""
-
-from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File
-from pydantic import BaseModel
+from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func
-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.models.ticket import Ticket, TicketStatus, TicketPriority
-from app.models.user import User
-from app.models.category import Category  
-from app.models.system import System
+from sqlalchemy import select
+from pydantic import BaseModel
+from typing import List
 import uuid
-import logging
+from sqlalchemy.exc import NoResultFound
+
+from app.core.database import get_db
+from app.models.ticket import Ticket  # Asegúrate de tener el modelo Ticket
+from app.models.category import Category  # Ensure Category model is imported
+from app.api import deps  # Para autenticación y permisos
+from app.models.user import User  # Asegúrate de importar el modelo User
 
 router = APIRouter()
-logger = logging.getLogger(__name__)
-
-# ===================================
-# SCHEMAS
-# ===================================
 
+# Esquema para crear un ticket
 class TicketCreate(BaseModel):
-    subject: str
+    title: str
     description: str
-    category_id: Optional[str] = None
-    affected_system_id: Optional[str] = None  # Updated field name
-    priority: str = "MEDIUM"
-
-class TicketUpdate(BaseModel):
-    subject: Optional[str] = None
-    description: Optional[str] = None
-    status: Optional[str] = None
-    priority: Optional[str] = None
-    assigned_to: Optional[str] = None
-
-class TicketResponse(BaseModel):
-    id: str
-    ticket_number: str
-    subject: str
-    description: str
-    status: str
+    category_id: uuid.UUID
     priority: str
-    category_id: Optional[str] = None
-    affected_system_id: Optional[str] = None  # Updated field name
-    created_by: str
-    assigned_to: Optional[str] = None
-    created_at: datetime
-    updated_at: datetime
-    
-    class Config:
-        from_attributes = True
 
-class TicketCloseRequest(BaseModel):
-    resolution: Optional[str] = None
+# Esquema para devolver un ticket
+class TicketResponse(BaseModel):
+    id: uuid.UUID
+    title: str
+    description: str
+    category_id: uuid.UUID
+    priority: str
+    created_at: str
 
-
-# ===================================
-# TICKET ENDPOINTS
-# ===================================
-
-@router.post("/", response_model=TicketResponse, status_code=status.HTTP_201_CREATED)
+@router.post("/", response_model=TicketResponse)
 async def create_ticket(
     ticket: TicketCreate,
     db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
+    current_user: User = Depends(deps.get_current_active_user)  # Verifica que el usuario esté autenticado
 ):
-    """
-    Crear un nuevo ticket
-    """
+    # Validate if the category exists
     try:
-        # Generar número de ticket único
-        result = await db.execute(
-            select(func.count(Ticket.id)).where(Ticket.tenant_id == current_user.tenant_id)
-        )
-        count = result.scalar() or 0
-        ticket_number = f"TK-{count + 1:06d}"
-        
-        # Convertir IDs de string a UUID si son proporcionados
-        category_uuid = uuid.UUID(ticket.category_id) if ticket.category_id else None
-        system_uuid = uuid.UUID(ticket.affected_system_id) if ticket.affected_system_id else None
-        
-        # ✅ CORRECCIÓN: Validar en la tabla correcta 'categories'
-        if category_uuid:
-            category = await db.get(Category, category_uuid)
-            if not category:
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail=f"La categoría con ID {ticket.category_id} no existe."
-                )
-
-        # Validar si el system_id existe en la tabla systems
-        if system_uuid:
-            system = await db.get(System, system_uuid)
-            if not system:
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail=f"El sistema con ID {ticket.affected_system_id} no existe."
-                )
-        
-        # ✅ CORRECCIÓN: Usar 'affected_system_id' (nombre real en la BD)
-        db_ticket = Ticket(
-            id=uuid.uuid4(),
-            tenant_id=current_user.tenant_id,
-            ticket_number=ticket_number,
-            subject=ticket.subject,
-            description=ticket.description,
-            category_id=category_uuid,
-            affected_system_id=system_uuid,  # Updated field name
-            priority=TicketPriority[ticket.priority.upper()],
-            created_by=current_user.id,
-            status=TicketStatus.NEW,
-            created_at=datetime.utcnow(),
-            updated_at=datetime.utcnow()
-        )
-        
-        db.add(db_ticket)
-        await db.commit()
-        await db.refresh(db_ticket)
-        
-        logger.info(f"Ticket {db_ticket.ticket_number} created by {current_user.email}")
-        
-        # ✅ CORRECCIÓN: Usar affected_system_id
-        return {
-            "id": str(db_ticket.id),
-            "ticket_number": db_ticket.ticket_number,
-            "subject": db_ticket.subject,
-            "description": db_ticket.description,
-            "status": db_ticket.status.value,
-            "priority": db_ticket.priority.value,
-            "category_id": str(db_ticket.category_id) if db_ticket.category_id else None,
-            "system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None,  # ✅ CORRECTO
-            "created_by": str(db_ticket.created_by),
-            "assigned_to": str(db_ticket.assigned_to) if db_ticket.assigned_to else None,
-            "created_at": db_ticket.created_at,
-            "updated_at": db_ticket.updated_at
-        }
-        
-    except ValueError as e:
-        await db.rollback()
-        logger.error(f"Invalid UUID format: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Invalid UUID format: {str(e)}"
-        )
-    except HTTPException:
-        await db.rollback()
-        raise
-    except Exception as e:
-        await db.rollback()
-        logger.error(f"Error creating ticket: {str(e)}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Error creating ticket: {str(e)}"
-        )
+        category = await db.execute(select(Category).where(Category.id == ticket.category_id))
+        category = category.scalar_one()
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Category not found")
 
+    # Crear un nuevo ticket
+    db_ticket = Ticket(
+        ticket_number=str(uuid.uuid4())[:8],  # Generate a unique ticket number
+        subject=ticket.title,
+        description=ticket.description,
+        category_id=ticket.category_id,
+        priority=ticket.priority,
+        created_by=current_user.id,
+        tenant_id=current_user.tenant_id
+    )
+    db.add(db_ticket)
+    await db.commit()
+    await db.refresh(db_ticket)
+    return db_ticket
 
 @router.get("/", response_model=List[TicketResponse])
 async def get_tickets(
-    skip: int = 0,
-    limit: int = 100,
-    status_filter: Optional[str] = None,
     db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
+    current_user: User = Depends(deps.get_current_active_user)  # Verifica que el usuario esté autenticado
 ):
-    """
-    Obtener tickets del usuario actual
-    """
     try:
-        query = select(Ticket).where(
-            Ticket.tenant_id == current_user.tenant_id,
-            Ticket.created_by == current_user.id
-        )
-        
-        if status_filter:
-            try:
-                status_enum = TicketStatus[status_filter.upper()]
-                query = query.where(Ticket.status == status_enum)
-            except KeyError:
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail=f"Invalid status: {status_filter}"
-                )
-        
-        query = query.order_by(Ticket.created_at.desc()).offset(skip).limit(limit)
-        
-        result = await db.execute(query)
+        result = await db.execute(select(Ticket).where(Ticket.tenant_id == current_user.tenant_id))
         tickets = result.scalars().all()
-        
-        logger.info(f"Listed {len(tickets)} tickets for user {current_user.email}")
-        
-        # ✅ CORRECCIÓN: Usar affected_system_id
-        return [
-            {
-                "id": str(t.id),
-                "ticket_number": t.ticket_number,
-                "subject": t.subject,
-                "description": t.description,
-                "status": t.status.value,
-                "priority": t.priority.value,
-                "category_id": str(t.category_id) if t.category_id else None,
-                "system_id": str(t.affected_system_id) if t.affected_system_id else None,  # ✅ CORRECTO
-                "created_by": str(t.created_by),
-                "assigned_to": str(t.assigned_to) if t.assigned_to else None,
-                "created_at": t.created_at,
-                "updated_at": t.updated_at
-            }
-            for t in tickets
-        ]
-    except HTTPException:
-        raise
+        return tickets
     except Exception as e:
-        logger.error(f"Error listing tickets: {str(e)}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Error listing tickets: {str(e)}"
-        )
-
-
-@router.get("/{ticket_id}", response_model=TicketResponse)
-async def get_ticket(
-    ticket_id: str,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """
-    Obtener un ticket específico
-    """
-    try:
-        ticket_uuid = uuid.UUID(ticket_id)
-    except ValueError:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Invalid ticket ID format"
-        )
-    
-    try:
-        query = select(Ticket).where(
-            Ticket.id == ticket_uuid,
-            Ticket.tenant_id == current_user.tenant_id,
-            Ticket.created_by == current_user.id
-        )
-        
-        result = await db.execute(query)
-        ticket = result.scalars().first()
-        
-        if not ticket:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Ticket {ticket_id} not found"
-            )
-        
-        # ✅ CORRECCIÓN: Usar affected_system_id
-        return {
-            "id": str(ticket.id),
-            "ticket_number": ticket.ticket_number,
-            "subject": ticket.subject,
-            "description": ticket.description,
-            "status": ticket.status.value,
-            "priority": ticket.priority.value,
-            "category_id": str(ticket.category_id) if ticket.category_id else None,
-            "system_id": str(ticket.affected_system_id) if ticket.affected_system_id else None,  # ✅ CORRECTO
-            "created_by": str(ticket.created_by),
-            "assigned_to": str(ticket.assigned_to) if ticket.assigned_to else None,
-            "created_at": ticket.created_at,
-            "updated_at": ticket.updated_at
-        }
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error getting ticket: {str(e)}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Error getting ticket: {str(e)}"
-        )
-
-
-@router.patch("/{ticket_id}", response_model=TicketResponse)
-async def update_ticket(
-    ticket_id: str,
-    ticket_update: TicketUpdate,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """
-    Actualizar un ticket
-    """
-    try:
-        ticket_uuid = uuid.UUID(ticket_id)
-    except ValueError:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Invalid ticket ID format"
-        )
-    
-    try:
-        query = select(Ticket).where(
-            Ticket.id == ticket_uuid,
-            Ticket.tenant_id == current_user.tenant_id,
-            Ticket.created_by == current_user.id
-        )
-        
-        result = await db.execute(query)
-        db_ticket = result.scalars().first()
-        
-        if not db_ticket:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Ticket {ticket_id} not found"
-            )
-        
-        update_data = ticket_update.dict(exclude_unset=True)
-        
-        for field, value in update_data.items():
-            if field == "status" and value:
-                setattr(db_ticket, field, TicketStatus[value.upper()])
-            elif field == "priority" and value:
-                setattr(db_ticket, field, TicketPriority[value.upper()])
-            elif field == "assigned_to" and value:
-                setattr(db_ticket, field, uuid.UUID(value))
-            else:
-                setattr(db_ticket, field, value)
-        
-        db_ticket.updated_at = datetime.utcnow()
-        
-        await db.commit()
-        await db.refresh(db_ticket)
-        
-        logger.info(f"Ticket {db_ticket.ticket_number} updated by {current_user.email}")
-        
-        # ✅ CORRECCIÓN: Usar affected_system_id
-        return {
-            "id": str(db_ticket.id),
-            "ticket_number": db_ticket.ticket_number,
-            "subject": db_ticket.subject,
-            "description": db_ticket.description,
-            "status": db_ticket.status.value,
-            "priority": db_ticket.priority.value,
-            "category_id": str(db_ticket.category_id) if db_ticket.category_id else None,
-            "system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None,  # ✅ CORRECTO
-            "created_by": str(db_ticket.created_by),
-            "assigned_to": str(db_ticket.assigned_to) if db_ticket.assigned_to else None,
-            "created_at": db_ticket.created_at,
-            "updated_at": db_ticket.updated_at
-        }
-        
-    except HTTPException:
-        await db.rollback()
-        raise
-    except Exception as e:
-        await db.rollback()
-        logger.error(f"Error updating ticket: {str(e)}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Error updating ticket: {str(e)}"
-        )
-
-
-@router.patch("/{ticket_id}/close", response_model=TicketResponse)
-async def close_ticket(
-    ticket_id: str,
-    close_request: TicketCloseRequest,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """
-    Cerrar un ticket
-    """
-    try:
-        ticket_uuid = uuid.UUID(ticket_id)
-    except ValueError:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Invalid ticket ID format"
-        )
-    
-    try:
-        query = select(Ticket).where(
-            Ticket.id == ticket_uuid,
-            Ticket.tenant_id == current_user.tenant_id,
-            Ticket.created_by == current_user.id
-        )
-        
-        result = await db.execute(query)
-        db_ticket = result.scalars().first()
-        
-        if not db_ticket:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Ticket {ticket_id} not found"
-            )
-        
-        db_ticket.status = TicketStatus.CLOSED
-        db_ticket.updated_at = datetime.utcnow()
-        
-        await db.commit()
-        await db.refresh(db_ticket)
-        
-        logger.info(f"Ticket {db_ticket.ticket_number} closed by {current_user.email}")
-        
-        # ✅ CORRECCIÓN: Usar affected_system_id
-        return {
-            "id": str(db_ticket.id),
-            "ticket_number": db_ticket.ticket_number,
-            "subject": db_ticket.subject,
-            "description": db_ticket.description,
-            "status": db_ticket.status.value,
-            "priority": db_ticket.priority.value,
-            "category_id": str(db_ticket.category_id) if db_ticket.category_id else None,
-            "system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None,  # ✅ CORRECTO
-            "created_by": str(db_ticket.created_by),
-            "assigned_to": str(db_ticket.assigned_to) if db_ticket.assigned_to else None,
-            "created_at": db_ticket.created_at,
-            "updated_at": db_ticket.updated_at
-        }
-        
-    except HTTPException:
-        await db.rollback()
-        raise
-    except Exception as e:
-        await db.rollback()
-        logger.error(f"Error closing ticket: {str(e)}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Error closing ticket: {str(e)}"
-        )
-
-
-# ===================================
-# COMMENT ENDPOINTS (placeholder)
-# ===================================
-
-@router.get("/{ticket_id}/comments")
-async def get_ticket_comments(
-    ticket_id: str,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """
-    Obtener comentarios de un ticket
-    """
-    return []
-
-
-@router.post("/{ticket_id}/comments", status_code=status.HTTP_201_CREATED)
-async def create_comment(
-    ticket_id: str,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """
-    Agregar un comentario a un ticket
-    """
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED,
-        detail="Comments not yet implemented"
-    )
-
-
-# ===================================
-# ATTACHMENT ENDPOINTS (placeholder)
-# ===================================
-
-@router.get("/{ticket_id}/attachments")
-async def get_ticket_attachments(
-    ticket_id: str,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """
-    Obtener adjuntos de un ticket
-    """
-    return []
-
-
-@router.post("/{ticket_id}/attachments", status_code=status.HTTP_201_CREATED)
-async def upload_attachment(
-    ticket_id: str,
-    file: UploadFile = File(...),
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """
-    Subir un archivo adjunto a un ticket
-    """
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED,
-        detail="File uploads not yet implemented"
-    )
+        # Log the error for debugging purposes
+        import logging
+        logger = logging.getLogger("tickets")
+        logger.exception("Error fetching tickets for tenant_id=%s", current_user.tenant_id)
+        raise HTTPException(status_code=500, detail="An error occurred while fetching tickets.")

backend/app/api/v1/router.py

@@ -5,8 +5,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, clients, tickets
 
 api_router = APIRouter()
 
@@ -47,10 +46,14 @@ api_router.include_router(
     tags=["categories"]
 )
 
-# Tickets routes
+api_router.include_router(
+    clients.router,
+    prefix="/clients",
+    tags=["clients"]
+)
+
 api_router.include_router(
     tickets.router,
     prefix="/tickets",
     tags=["tickets"]
-)
-
+)

backend/app/core/config.py

@@ -119,6 +119,18 @@ class Settings(BaseSettings):
     CELERY_BROKER_URL: str = Field(..., env="CELERY_BROKER_URL")
     CELERY_RESULT_BACKEND: str = Field(..., env="CELERY_RESULT_BACKEND")
     
+    # ===================================
+    # CAMPOS ADICIONALES
+    # ===================================
+    POSTGRES_DB: str = Field(..., env="POSTGRES_DB")
+    POSTGRES_USER: str = Field(..., env="POSTGRES_USER")
+    POSTGRES_PASSWORD: str = Field(..., env="POSTGRES_PASSWORD")
+    SMTP_USERNAME: Optional[str] = Field(default=None, env="SMTP_USERNAME")
+    MAX_UPLOAD_SIZE: int = Field(default=10485760, env="MAX_UPLOAD_SIZE")
+    UPLOAD_DIR: str = Field(default="./uploads", env="UPLOAD_DIR")
+    RATE_LIMIT_REQUESTS: int = Field(default=100, env="RATE_LIMIT_REQUESTS")
+    RATE_LIMIT_WINDOW: int = Field(default=60, env="RATE_LIMIT_WINDOW")
+    
     def is_production(self) -> bool:
         """Check if environment is production."""
         return self.ENVIRONMENT.lower() == "production"
@@ -141,6 +153,5 @@ def get_settings() -> Settings:
     """
     return Settings()
 
-
 # Crear una instancia global de Settings
 settings = Settings()

backend/app/core/database.py

@@ -10,6 +10,7 @@ from sqlalchemy import String, DateTime, func
 from typing import AsyncGenerator
 import uuid
 from datetime import datetime
+import logging
 
 from app.core.config import get_settings
 
@@ -34,6 +35,8 @@ AsyncSessionLocal = async_sessionmaker(
     autocommit=False
 )
 
+logger = logging.getLogger("database")
+
 
 class Base(DeclarativeBase):
     """Base class para todos los modelos SQLAlchemy."""
@@ -57,13 +60,16 @@ async def get_db() -> AsyncGenerator[AsyncSession, None]:
     """
     async with AsyncSessionLocal() as session:
         try:
+            logger.debug("Intentando crear una nueva sesión de base de datos.")
             yield session
             await session.commit()
-        except Exception:
+        except Exception as e:
+            logger.error("Error al crear la sesión de base de datos: %s", str(e))
             await session.rollback()
             raise
         finally:
             await session.close()
+            logger.debug("Sesión de base de datos cerrada.")
 
 
 async def create_tables():

backend/app/middleware/tenant.py

@@ -8,10 +8,20 @@ from fastapi import Request, HTTPException, status
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import Response
 import structlog
+from contextlib import asynccontextmanager
+from sqlalchemy.sql import text
 
 logger = structlog.get_logger(__name__)
 
 
+# Correct the usage of async for by wrapping it in an async function
+@asynccontextmanager
+async def get_db_context():
+    from app.core.database import get_db
+    async for db in get_db():
+        yield db
+
+
 class TenantMiddleware(BaseHTTPMiddleware):
     """
     Middleware para extraer y validar información del tenant.
@@ -34,33 +44,56 @@ class TenantMiddleware(BaseHTTPMiddleware):
         """Process request and add tenant information."""
         
         # Skip tenant validation for excluded paths
-        if request.url.path in self.EXCLUDED_PATHS or request.url.path.startswith("/docs"):
+        if request.url.path in self.EXCLUDED_PATHS or any(request.url.path.startswith(path) for path in self.EXCLUDED_PATHS):
             return await call_next(request)
         
         # Extract tenant from header
         tenant_id = request.headers.get("X-Tenant-ID")
         tenant_slug = request.headers.get("X-Tenant-Slug")
         
-        # For now, we'll be more permissive in development
-        # In production, tenant should be strictly required
+        # Revertir cambios para requerir encabezados de tenant
         if not tenant_id and not tenant_slug:
-            logger.warning(
-                "Request without tenant information",
-                path=request.url.path,
-                method=request.method
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Tenant information required (X-Tenant-ID or X-Tenant-Slug header)"
             )
-            # For now, continue without tenant for development
-            # raise HTTPException(
-            #     status_code=status.HTTP_400_BAD_REQUEST,
-            #     detail="Tenant information required (X-Tenant-ID or X-Tenant-Slug header)"
-            # )
         
         # Store tenant info in request state
         request.state.tenant_id = tenant_id
         request.state.tenant_slug = tenant_slug
         
-        # TODO: Validate tenant exists and is active
-        # This would involve a database query which we'll implement later
+        # Validate tenant exists and is active
+        if tenant_id or tenant_slug:
+            from app.core.database import get_db
+            from app.models.tenant import Tenant
+
+            # Update the middleware to use the new context manager
+            async with get_db_context() as db:
+                tenant = await db.execute(
+                    text(
+                        """
+                        SELECT * FROM tenants
+                        WHERE id = :tenant_id OR slug = :tenant_slug AND status = 'active'
+                        """
+                    ),
+                    {"tenant_id": tenant_id, "tenant_slug": tenant_slug}
+                )
+                tenant = tenant.fetchone()
+
+                if not tenant:
+                    raise HTTPException(
+                        status_code=status.HTTP_404_NOT_FOUND,
+                        detail="Tenant not found or inactive"
+                    )
+
+                # Store validated tenant info
+                request.state.tenant = tenant
+
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Tenant information required (X-Tenant-ID or X-Tenant-Slug header)"
+            )
         
         logger.debug(
             "Tenant middleware processed",

backend/app/models/category.py

@@ -1,30 +1,29 @@
 """
 Category Model - ServiceManagerWeb
 """
-from sqlalchemy import String, Text, Boolean, ForeignKey, Column, Integer
+from sqlalchemy import String, Text, Boolean, ForeignKey, DateTime
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.sql import func
 from typing import List, Optional
 import uuid
 
 from app.core.database import Base
-from app.models.tenant import Tenant
-from app.models.ticket import Ticket
 
 class Category(Base):
-    __tablename__ = "ticket_categories"  # Updated table name
+    __tablename__ = "ticket_categories"
     
     name: Mapped[str] = mapped_column(String(100), nullable=False)
     description: Mapped[Optional[str]] = mapped_column(Text)
     is_active: Mapped[bool] = mapped_column(Boolean, default=True)
-
-    # Updated tenant_id to be required
-    tenant_id: Mapped[uuid.UUID] = mapped_column(
-        UUID(as_uuid=True), 
-        ForeignKey("tenants.id", ondelete="CASCADE"), 
-        nullable=False
-    )
     
+    # Optional: Tenant specific categories?
+    tenant_id: Mapped[Optional[uuid.UUID]] = mapped_column(UUID(as_uuid=True), ForeignKey("tenants.id", ondelete="CASCADE"), nullable=True)
+    
+    # Timestamp columns
+    created_at: Mapped[Optional[DateTime]] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[Optional[DateTime]] = mapped_column(DateTime(timezone=True), onupdate=func.now())
+
     # Relationships
     tickets: Mapped[List["Ticket"]] = relationship("Ticket", back_populates="category")
     tenant: Mapped["Tenant"] = relationship("Tenant") # Assuming Tenant model is imported

backend/app/models/client.py

@@ -0,0 +1,29 @@
+from sqlalchemy import Column, Integer, String
+from app.core.database import Base
+
+class Client(Base):
+    __tablename__ = "clients"
+
+    id = Column(Integer, primary_key=True, index=True)
+    clave = Column(String, nullable=False)
+    tipo_cliente = Column(String, nullable=False)
+    nombre = Column(String, nullable=False)
+    pais = Column(String, nullable=False)
+    estado = Column(String, nullable=False)
+    ciudad = Column(String, nullable=False)
+    direccion = Column(String, nullable=False)
+    numero_ext = Column(String, nullable=True)
+    cp = Column(String, nullable=True)
+    colonia = Column(String, nullable=True)
+    lada = Column(String, nullable=True)
+    telefono1 = Column(String, nullable=True)
+    telefono2 = Column(String, nullable=True)
+    tel_directo = Column(String, nullable=True)
+    ext = Column(String, nullable=True)
+    fax = Column(String, nullable=True)
+    horario = Column(String, nullable=True)
+    pagina = Column(String, nullable=True)
+    correo = Column(String, nullable=True)
+    medio_publicidad = Column(String, nullable=True)
+    nacionalidad = Column(String, nullable=True)
+    logo = Column(String, nullable=True)

backend/app/models/system.py

@@ -1,3 +1,4 @@
+
 """
 System Model - ServiceManagerWeb
 """
@@ -18,11 +19,7 @@ class System(Base):
     # Relationships
     # If we want tickets to link to systems, we will add relationship in Ticket later or now.
     # We will assume Ticket links to System.
-    tickets: Mapped[List["Ticket"]] = relationship(
-        "Ticket",
-        back_populates="affected_system",
-        foreign_keys="Ticket.affected_system_id"
-    )
+    tickets: Mapped[List["Ticket"]] = relationship("Ticket", back_populates="system")
 
     def __repr__(self) -> str:
         return f"<System(id={self.id}, name='{self.name}')>"

backend/app/models/tenant.py

@@ -54,12 +54,15 @@ class Tenant(Base):
         String(20), 
         default=TenantStatus.ACTIVE
     )
-    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
     
     # Relaciones
     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")
     
     def __repr__(self) -> str:
-        return f"<Tenant(id={self.id}, name='{self.name}', slug='{self.slug}')>"
+        return f"<Tenant(id={self.id}, name='{self.name}', slug='{self.slug}')>"
+    
+    @property
+    def is_active(self) -> bool:
+        """Check if tenant is active."""
+        return self.status == TenantStatus.ACTIVE

backend/app/models/ticket.py

@@ -4,17 +4,13 @@ Ticket Model - ServiceManagerWeb
 from sqlalchemy import String, ForeignKey, Text
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from sqlalchemy.dialects.postgresql import UUID, ENUM
-from typing import Optional, TYPE_CHECKING
+from typing import Optional
 import enum
 import uuid
 
 from app.core.database import Base
-from .tenant import Tenant
-from .system import System
-from .user import User
-
-if TYPE_CHECKING:
-    from app.models.category import Category
+from app.models.system import System
+from app.models.category import Category
 
 class TicketStatus(str, enum.Enum):
     NEW = "NEW"
@@ -50,7 +46,7 @@ class Ticket(Base):
     assigned_to: Mapped[Optional[uuid.UUID]] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
     
     affected_system_id: Mapped[Optional[uuid.UUID]] = mapped_column(UUID(as_uuid=True), ForeignKey("systems.id"), nullable=True)
-    category_id: Mapped[Optional[uuid.UUID]] = mapped_column(UUID(as_uuid=True), ForeignKey("categories.id"), nullable=True)
+    category_id: Mapped[Optional[uuid.UUID]] = mapped_column(UUID(as_uuid=True), ForeignKey("ticket_categories.id"), nullable=True)
 
     # Relationships
     tenant: Mapped["Tenant"] = relationship("Tenant", back_populates="tickets")

backend/app/models/user.py

@@ -13,6 +13,7 @@ import uuid
 from datetime import datetime
 
 from app.core.database import Base
+from app.models.ticket import Ticket
 
 
 class UserRole(str, enum.Enum):

backend/app/schemas/client.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel
+
+class ClientBase(BaseModel):
+    clave: str
+    tipo_cliente: str
+    nombre: str
+    pais: str
+    estado: str
+    ciudad: str
+    direccion: str
+    numero_ext: str | None = None
+    cp: str | None = None
+    colonia: str | None = None
+    lada: str | None = None
+    telefono1: str | None = None
+    telefono2: str | None = None
+    tel_directo: str | None = None
+    ext: str | None = None
+    fax: str | None = None
+    horario: str | None = None
+    pagina: str | None = None
+    correo: str | None = None
+    medio_publicidad: str | None = None
+    nacionalidad: str | None = None
+    logo: str | None = None
+
+class ClientCreate(ClientBase):
+    pass
+
+class ClientUpdate(ClientBase):
+    pass
+
+class Client(ClientBase):
+    id: int
+
+    class Config:
+        from_attributes = True

backend/backend/migrations/README

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

backend/backend/migrations/alembic.ini

@@ -1,38 +0,0 @@
-[alembic]
-script_location = backend/migrations
-sqlalchemy.url = postgresql://servicemanager:servicemanager123@172.19.0.3:5432/servicemanager
-
-target_metadata = app.core.database.Base.metadata
-
-default_environment = development
-
-[loggers]
-keys = root,sqlalchemy,alembic
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-[logger_root]
-level = WARN
-handlers = console
-
-[logger_sqlalchemy]
-level = WARN
-handlers = console
-qualname = sqlalchemy.engine
-
-[logger_alembic]
-level = INFO
-handlers = console
-qualname = alembic
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-formatter = generic
-
-[formatter_generic]
-format = %(asctime)s %(levelname)-5.5s [%(name)s] %(message)s

backend/backend/migrations/env.py

@@ -1,50 +0,0 @@
-# backend/migrations/env.py
-from logging.config import fileConfig
-from sqlalchemy import pool
-from sqlalchemy.ext.asyncio import create_async_engine
-from alembic import context
-import asyncio
-
-# Importa tus settings
-from app.core.config import settings
-
-config = context.config
-
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
-# metadata de tus modelos
-from app.core.database import Base
-target_metadata = Base.metadata
-
-def run_migrations_offline():
-    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 do_run_migrations(connection):
-    context.configure(connection=connection, target_metadata=target_metadata)
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-async def run_migrations_online():
-    connectable = create_async_engine(
-        settings.DATABASE_URL, poolclass=pool.NullPool
-    )
-    async with connectable.connect() as connection:
-        await connection.run_sync(do_run_migrations)
-    await connectable.dispose()
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    asyncio.run(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/backend/migrations/versions/1b894c060a94_fix_ambiguous_foreign_key_in_system_.py

@@ -1,30 +0,0 @@
-"""Fix ambiguous foreign key in System.tickets relationship
-
-Revision ID: 1b894c060a94
-Revises: d77aa93a2cf2
-Create Date: 2026-01-27 19:20:19.670006
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = '1b894c060a94'
-down_revision: Union[str, None] = 'd77aa93a2cf2'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass  # No changes needed for the database schema
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass  # No changes needed for the database schema
-    # ### end Alembic commands ###

backend/backend/migrations/versions/d77aa93a2cf2_fix_affected_system_relationship_in_.py

@@ -1,37 +0,0 @@
-"""Fix affected_system relationship in Ticket model
-
-Revision ID: d77aa93a2cf2
-Revises: 
-Create Date: 2026-01-27 19:18:04.005182
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = 'd77aa93a2cf2'
-down_revision: Union[str, None] = None
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_foreign_key(
-        'fk_tickets_affected_system_id',
-        'tickets',
-        'systems',
-        ['affected_system_id'],
-        ['id'],
-        ondelete='SET NULL'
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_constraint('fk_tickets_affected_system_id', 'tickets', type_='foreignkey')
-    # ### end Alembic commands ###

backend/backend/run_sync_migrations.py

@@ -1,23 +0,0 @@
-from sqlalchemy import create_engine
-from alembic import command
-from alembic.config import Config
-
-# Cargar la URL de la base de datos desde el entorno
-from os import getenv
-DATABASE_URL = getenv("DATABASE_URL", "postgresql://servicemanager:servicemanager123@postgres:5432/servicemanager")
-
-# Cambiar el dialecto a uno síncrono
-DATABASE_URL = DATABASE_URL.replace("+asyncpg", "")
-
-# Crear un motor síncrono
-engine = create_engine(DATABASE_URL)
-
-# Configurar Alembic
-alembic_cfg = Config("backend/migrations/alembic.ini")
-alembic_cfg.attributes['connection'] = engine.connect()
-
-# Ejecutar las migraciones
-if __name__ == "__main__":
-    print("Ejecutando migraciones...")
-    command.upgrade(alembic_cfg, "head")
-    print("Migraciones aplicadas correctamente.")

backend/fix_password_script.py

@@ -1,41 +1,40 @@
-
-import asyncio
 import sys
 import os
+import json
 
-# Add parent directory to path so we can import 'app'
+# Asegurar que el directorio raíz esté en PYTHONPATH
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-from sqlalchemy import select
-from app.core.database import AsyncSessionLocal
-from app.models.tenant import Tenant  # Import Tenant to register it
-from app.models.ticket import Ticket  # Import Ticket to register it
-from app.models.user import User
 from app.core.security import SecurityUtils
+from app.core.config import settings
+from app.models.user import User
+from app.models.tenant import Tenant
+from app.core.database import AsyncSessionLocal
+from sqlalchemy.future import select
+import asyncio
 
-async def fix_password():
-    async with AsyncSessionLocal() as session:
-        # Find the admin user
-        email = "admin@aduanasoft.com"
-        result = await session.execute(select(User).where(User.email == email))
-        user = result.scalar_one_or_none()
-        
-        if user:
-            print(f"User {email} found.")
-            # Reset password to 'admin123'
-            new_password = "admin123"
-            hashed = SecurityUtils.hash_password(new_password)
-            user.password_hash = hashed
-            
-            try:
-                await session.commit()
-                print(f"Password for {email} updated successfully!")
-                print(f"New password is: {new_password}")
-            except Exception as e:
-                await session.rollback()
-                print(f"Error updating password: {e}")
-        else:
-            print(f"User {email} not found!")
+# Generar un token predeterminado para el usuario admin
+def generate_default_token():
+    async def async_task():
+        async with AsyncSessionLocal() as db:
+            result = await db.execute(select(User).filter(User.email == "admin@aduanasoft.com"))
+            user = result.scalar_one_or_none()
+            if user:
+                print(f"User found: {user.email}")
+                token = SecurityUtils.create_access_token({"sub": str(user.id), "email": user.email})
+                print(f"Generated token: {token}")
 
-if __name__ == "__main__":
-    asyncio.run(fix_password())
+                # Validate the token
+                payload = SecurityUtils.verify_token(token)
+                if payload:
+                    print("Token is valid. Payload:")
+                    print(json.dumps(payload, indent=4))
+                else:
+                    print("Token validation failed.")
+            else:
+                print("User not found. Token not generated.")
+
+    asyncio.run(async_task())
+
+generate_default_token()
+print("Token generation process completed.")

backend/migrations/env.py

@@ -1,74 +0,0 @@
-from logging.config import fileConfig
-import os
-from sqlalchemy import create_engine, pool
-from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
-from sqlalchemy.engine import engine_from_config
-from alembic import context
-import asyncio
-
-# Import Base and all models
-from app.core.database import Base
-from app.models import tenant  # Import all models explicitly
-
-# Alembic Config object
-config = context.config
-
-# Logging configuration
-if config.config_file_name:
-    fileConfig(config.config_file_name)
-
-# Get DATABASE_URL and convert to synchronous
-DATABASE_URL = os.getenv("DATABASE_URL")
-if not DATABASE_URL:
-    raise RuntimeError("DATABASE_URL environment variable is not set")
-
-SYNC_DATABASE_URL = DATABASE_URL.replace("+asyncpg", "")
-
-# Metadata for autogenerate
-target_metadata = Base.metadata
-
-
-def run_migrations_offline():
-    """
-    Run migrations in 'offline' mode.
-    """
-    context.configure(
-        url=SYNC_DATABASE_URL,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-async def run_migrations_online():
-    """
-    Run migrations in 'online' mode.
-    """
-    # Fetch the URL from Alembic configuration
-    alembic_config = config.get_section(config.config_ini_section)
-    alembic_config["sqlalchemy.url"] = DATABASE_URL  # Use async URL
-
-    connectable: AsyncEngine = create_async_engine(
-        DATABASE_URL,
-        poolclass=pool.NullPool,
-    )
-
-    async with connectable.connect() as connection:
-        await connection.run_sync(
-            lambda sync_connection: context.configure(
-                connection=sync_connection, target_metadata=target_metadata,
-                compare_type=True  # Ensure column types are compared
-            )
-        )
-        await connection.run_sync(context.run_migrations())
-
-    asyncio.run(do_run_migrations())
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    run_migrations_online()

backend/requirements.txt

@@ -15,7 +15,6 @@ pydantic-settings==2.1.0
 sqlalchemy==2.0.23
 alembic==1.13.0
 asyncpg==0.29.0          # PostgreSQL async driver
-psycopg2-binary==2.9.9   # PostgreSQL sync driver (for migrations)
 
 # ===================================
 # AUTHENTICATION & SECURITY
@@ -42,7 +41,7 @@ jinja2==3.1.2            # Email templates
 # FILE HANDLING
 # ===================================
 python-magic==0.4.27    # MIME type detection
-pillow==10.1.0           # Image processing
+# pillow==10.1.0           # Image processing
 
 # ===================================
 # HTTP & REQUESTS

backend/run_migrations.py

@@ -1,28 +0,0 @@
-import asyncio
-from alembic.config import Config
-from alembic.script import ScriptDirectory
-from alembic.runtime.environment import EnvironmentContext
-from sqlalchemy.ext.asyncio import create_async_engine
-
-async def run_async_migrations():
-    alembic_cfg = Config("alembic.ini")
-    script = ScriptDirectory.from_config(alembic_cfg)
-
-    engine = create_async_engine("postgresql+asyncpg://servicemanager:servicemanager123@172.19.0.3:5432/servicemanager")
-
-    async with engine.connect() as connection:
-        def do_run_migrations(connection):
-            with EnvironmentContext(
-                alembic_cfg,
-                script,
-                connection=connection,
-                fn=lambda rev, context: script.run_env()
-            ) as context:
-                context.configure(connection=connection, target_metadata=None)
-                with context.begin_transaction():
-                    context.run_migrations()
-
-        await connection.run_sync(do_run_migrations)
-
-if __name__ == "__main__":
-    asyncio.run(run_async_migrations())

backend/run_sync_migrations.py

@@ -1,23 +0,0 @@
-from sqlalchemy import create_engine
-from alembic import command
-from alembic.config import Config
-
-# Cargar la URL de la base de datos desde el entorno
-from os import getenv
-DATABASE_URL = getenv("DATABASE_URL", "postgresql://servicemanager:servicemanager123@postgres:5432/servicemanager")
-
-# Cambiar el dialecto a uno síncrono
-DATABASE_URL = DATABASE_URL.replace("+asyncpg", "")
-
-# Crear un motor síncrono
-engine = create_engine(DATABASE_URL)
-
-# Configurar Alembic
-alembic_cfg = Config("backend/migrations/alembic.ini")
-alembic_cfg.attributes['connection'] = engine.connect()
-
-# Ejecutar las migraciones
-if __name__ == "__main__":
-    print("Ejecutando migraciones...")
-    command.upgrade(alembic_cfg, "head")
-    print("Migraciones aplicadas correctamente.")

backend/test_db_connection.py

@@ -1,19 +1,18 @@
+import os
 import asyncio
 import asyncpg
 
+def get_database_url():
+    # Replace 'postgresql+asyncpg' with 'postgresql' for asyncpg compatibility
+    return os.getenv("DATABASE_URL", "postgresql://servicemanager:servicemanager123@servicemanager-db:5432/servicemanager").replace("postgresql+asyncpg", "postgresql")
+
 async def test_connection():
     try:
-        conn = await asyncpg.connect(
-            user="servicemanager",
-            password="servicemanager123",
-            database="servicemanager",
-            host="postgres",
-            port=5432
-        )
-        print("Connection successful!")
+        conn = await asyncpg.connect(get_database_url())
+        print("Connection to the database was successful!")
         await conn.close()
     except Exception as e:
-        print(f"Connection failed: {e}")
+        print(f"Failed to connect to the database: {e}")
 
 if __name__ == "__main__":
     asyncio.run(test_connection())

backend/tests/test_clients.py

@@ -0,0 +1,71 @@
+import pytest
+from fastapi.testclient import TestClient
+from app.main import app
+
+client = TestClient(app)
+
+@pytest.fixture
+def sample_client_data():
+    return {
+        "clave": "12345",
+        "tipo_cliente": "Regular",
+        "nombre": "Cliente Prueba",
+        "pais": "México",
+        "estado": "Chihuahua",
+        "ciudad": "Cd. Juárez",
+        "direccion": "Calle Falsa 123",
+        "numero_ext": "12",
+        "cp": "32000",
+        "colonia": "Centro",
+        "lada": "656",
+        "telefono1": "1234567890",
+        "telefono2": "0987654321",
+        "tel_directo": "1231231234",
+        "ext": "101",
+        "fax": "1231231235",
+        "horario": "9:00 - 18:00",
+        "pagina": "www.clienteprueba.com",
+        "correo": "cliente@prueba.com",
+        "medio_publicidad": "Internet",
+        "nacionalidad": "Mexicana",
+        "logo": "logo.png"
+    }
+
+def test_create_client(sample_client_data):
+    response = client.post("/api/v1/clients", json=sample_client_data)
+    assert response.status_code == 200
+    assert response.json()["clave"] == sample_client_data["clave"]
+
+def test_read_client(sample_client_data):
+    # Create a client first
+    create_response = client.post("/api/v1/clients", json=sample_client_data)
+    client_id = create_response.json()["id"]
+
+    # Read the client
+    response = client.get(f"/api/v1/clients/{client_id}")
+    assert response.status_code == 200
+    assert response.json()["id"] == client_id
+
+def test_update_client(sample_client_data):
+    # Create a client first
+    create_response = client.post("/api/v1/clients", json=sample_client_data)
+    client_id = create_response.json()["id"]
+
+    # Update the client
+    updated_data = {"nombre": "Cliente Actualizado"}
+    response = client.put(f"/api/v1/clients/{client_id}", json=updated_data)
+    assert response.status_code == 200
+    assert response.json()["nombre"] == "Cliente Actualizado"
+
+def test_delete_client(sample_client_data):
+    # Create a client first
+    create_response = client.post("/api/v1/clients", json=sample_client_data)
+    client_id = create_response.json()["id"]
+
+    # Delete the client
+    response = client.delete(f"/api/v1/clients/{client_id}")
+    assert response.status_code == 200
+
+    # Verify deletion
+    response = client.get(f"/api/v1/clients/{client_id}")
+    assert response.status_code == 404

backend/tests/test_security.py

@@ -0,0 +1,27 @@
+import pytest
+from app.core.security import SecurityUtils
+from datetime import timedelta
+
+# Test password hashing and verification
+def test_password_hashing():
+    plain_password = "securepassword123"
+    hashed_password = SecurityUtils.hash_password(plain_password)
+
+    assert SecurityUtils.verify_password(plain_password, hashed_password) == True
+    assert SecurityUtils.verify_password("wrongpassword", hashed_password) == False
+
+# Test JWT token generation and validation
+def test_jwt_token_generation():
+    payload = {"sub": "12345", "email": "test@example.com"}
+    token = SecurityUtils.create_access_token(payload, expires_delta=timedelta(minutes=15))
+
+    decoded_payload = SecurityUtils.verify_token(token)
+    assert decoded_payload is not None
+    assert decoded_payload["sub"] == "12345"
+    assert decoded_payload["email"] == "test@example.com"
+
+# Test TOTP secret generation
+def test_totp_secret_generation():
+    secret = SecurityUtils.generate_totp_secret()
+    assert len(secret) > 0
+    assert isinstance(secret, str)

db/migrations/fix_schema_inconsistencies.sql

@@ -1,37 +0,0 @@
--- Migration Script: Fix Schema Inconsistencies
-
--- Step 1: Migrate data from `categories` to `ticket_categories`
-DO $$
-BEGIN
-    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'categories') THEN
-        INSERT INTO ticket_categories (id, tenant_id, name, description)
-        SELECT id, COALESCE(tenant_id, (SELECT id FROM tenants LIMIT 1)), name, description
-        FROM categories;
-    END IF;
-END $$;
-
--- Step 2: Update foreign key for `tickets.category_id`
-ALTER TABLE tickets DROP CONSTRAINT IF EXISTS tickets_category_id_fkey;
-ALTER TABLE tickets ADD CONSTRAINT tickets_category_id_fkey FOREIGN KEY (category_id) REFERENCES ticket_categories (id) ON DELETE CASCADE;
-
--- Step 3: Drop `categories` table
-DROP TABLE IF EXISTS categories CASCADE;
-
--- Step 4: Rename `tickets.system_id` to `affected_system_id`
-DO $$
-BEGIN
-    IF EXISTS (
-        SELECT 1 FROM information_schema.columns 
-        WHERE table_name = 'tickets' AND column_name = 'system_id'
-    ) THEN
-        ALTER TABLE tickets RENAME COLUMN system_id TO affected_system_id;
-    END IF;
-END $$;
-
--- Step 5: Update foreign key for `tickets.affected_system_id`
-ALTER TABLE tickets DROP CONSTRAINT IF EXISTS tickets_system_id_fkey;
-ALTER TABLE tickets ADD CONSTRAINT tickets_affected_system_id_fkey FOREIGN KEY (affected_system_id) REFERENCES affected_systems (id) ON DELETE CASCADE;
-
--- Step 6: Create indexes for performance
-CREATE INDEX IF NOT EXISTS idx_tickets_category_id ON tickets (category_id);
-CREATE INDEX IF NOT EXISTS idx_tickets_affected_system_id ON tickets (affected_system_id);

db/schema.sql

@@ -38,6 +38,74 @@ CREATE INDEX idx_tenants_slug ON tenants(slug);
 CREATE INDEX idx_tenants_status ON tenants(status);
 CREATE INDEX idx_tenants_domain ON tenants(domain);
 
+-- ===================================
+-- DOMINIO: CLIENTS (Cartera de Clientes)
+-- ===================================
+
+-- Enum para los radio buttons de estatus 
+CREATE TYPE client_status_enum AS ENUM (
+    'prospect', 
+    'active', 
+    'suspended', 
+    'cancelled'
+);
+
+CREATE TABLE clients (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
+
+    -- Identificación (Sección General)
+    code VARCHAR(50),           -- Clave del cliente
+    name VARCHAR(200) NOT NULL, -- Nombre / Razón Social
+    tax_id VARCHAR(20),         -- RFC
+    client_type VARCHAR(50),    -- Tipo de Cliente
+    account_manager VARCHAR(100), -- Encargado Cliente (Texto simple por ahora)
+
+    -- Dirección (Desglosada)
+    address_street TEXT,        -- Dirección / Calle
+    address_ext_num VARCHAR(20), -- Núm. Ext
+    neighborhood VARCHAR(100),  -- Colonia
+    zip_code VARCHAR(10),       -- CP
+    city VARCHAR(100),          -- Ciudad
+    state VARCHAR(100),         -- Estado
+    country VARCHAR(100) DEFAULT 'Mexico',
+
+    -- Contacto
+    phone_primary VARCHAR(20),  -- Teléfono 1
+    phone_secondary VARCHAR(20),-- Teléfono 2
+    fax VARCHAR(20),
+    email VARCHAR(320),         -- Correo
+    website VARCHAR(255),       -- Página Web
+
+    -- Configuración y Flexibilidad
+    status client_status_enum DEFAULT 'prospect',
+    logo_url VARCHAR(500),      -- Ruta al archivo PDF/Imagen del logo
+    
+    -- Campo JSONB para lo que sobre (Horario, Nacionalidad, Medio Publicidad, Lada, etc.)
+    properties JSONB DEFAULT '{}'::jsonb,
+
+    -- Auditoría estándar
+    is_active BOOLEAN DEFAULT TRUE,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+
+    -- Restricciones: No repetir RFC ni Clave dentro del mismo Tenant
+    UNIQUE(tenant_id, code),
+    UNIQUE(tenant_id, tax_id)
+);
+
+-- Índices para búsqueda rápida
+CREATE INDEX idx_clients_tenant_id ON clients(tenant_id);
+CREATE INDEX idx_clients_tax_id ON clients(tax_id);
+CREATE INDEX idx_clients_name ON clients(name);
+CREATE INDEX idx_clients_properties ON clients USING gin (properties);
+
+-- Trigger para mantener actualizado el campo updated_at
+-- (Usa la función que ya definiste al final de tu script)
+CREATE TRIGGER update_clients_updated_at BEFORE UPDATE ON clients 
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+
 -- ===================================
 -- DOMINIO: AUTH (Autenticación)
 -- ===================================

docker-compose.yml

@@ -51,10 +51,11 @@ services:
   # ===================================
   backend:
     build:
-      context: .
-      dockerfile: docker/Dockerfile.backend
+      context: ./backend
+      dockerfile: ../docker/Dockerfile.backend
     container_name: servicemanager-backend
     restart: unless-stopped
+    command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
     env_file:
       - .env
     environment:
@@ -70,11 +71,12 @@ services:
       - SMTP_HOST=${SMTP_HOST}
       - SMTP_PORT=${SMTP_PORT}
       - DEFAULT_FROM_EMAIL=${DEFAULT_FROM_EMAIL}
+      - PYTHONPATH=/app
     volumes:
       - ./backend:/app
+      - ./tests:/app/tests
       - uploads_data:/app/uploads
       - logs_data:/app/logs
-      - ./alembic.ini:/app/alembic.ini
     ports:
       - "8000:8000"
     depends_on:
@@ -162,7 +164,7 @@ services:
     restart: unless-stopped
     environment:
       - NODE_ENV=${ENVIRONMENT:-development}
-      - PUBLIC_API_URL=http://servicemanager-backend:8000
+      - PUBLIC_API_URL=http://backend:8000
       - PUBLIC_APP_NAME=ServiceManager Cliente
     volumes:
       - ./frontend-client:/app
@@ -187,7 +189,7 @@ services:
     restart: unless-stopped
     environment:
       - NODE_ENV=${ENVIRONMENT:-development}
-      - PUBLIC_API_URL=http://servicemanager-backend:8000
+      - PUBLIC_API_URL=http://backend:8000
       - PUBLIC_APP_NAME=ServiceManager Admin
     volumes:
       - ./frontend-internal:/app

docker/Dockerfile.backend

@@ -1,3 +1,4 @@
+# FastAPI Backend Dockerfile
 FROM python:3.11-slim
 
 # Instalar dependencias del sistema
@@ -7,20 +8,13 @@ RUN apt-get update && apt-get install -y \
     curl \
     && rm -rf /var/lib/apt/lists/*
 
-# Directorio de trabajo y PYTHONPATH
+# Configurar directorio de trabajo
 WORKDIR /app
-ENV PYTHONPATH=/app
 
-# Instalar dependencias Python
-COPY backend/requirements.txt requirements.txt
+# Copiar requirements y instalar dependencias Python
+COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copiar todo el contenido del directorio backend
-COPY backend /app/backend
-
-# Copiar el script de migraciones
-COPY backend/run_sync_migrations.py /app/backend/run_sync_migrations.py
-
 # Crear usuario no root
 RUN useradd --create-home --shell /bin/bash app \
     && chown -R app:app /app
@@ -29,6 +23,9 @@ RUN useradd --create-home --shell /bin/bash app \
 RUN mkdir -p /app/uploads /app/logs \
     && chown -R app:app /app/uploads /app/logs
 
+# Copiar código de la aplicación
+COPY . .
+
 # Cambiar permisos
 RUN chown -R app:app /app
 
@@ -38,9 +35,9 @@ USER app
 # Exponer puerto
 EXPOSE 8000
 
-# Healthcheck
+# Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
     CMD curl -f http://localhost:8000/health || exit 1
 
-# CMD por defecto
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]
+# Comando por defecto
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

frontend-client/src/lib/components/Header.svelte

@@ -59,9 +59,6 @@
             <button
               on:click={toggleMenu}
               class="flex items-center space-x-2 text-gray-700 hover:text-primary-600 focus:outline-none focus:ring-2 focus:ring-primary-500 focus:ring-offset-2 rounded-md p-2"
-              role="button"
-              tabindex="0"
-              on:keydown={(e) => e.key === 'Enter' && toggleMenu()}
             >
               <div class="w-8 h-8 bg-primary-100 rounded-full flex items-center justify-center">
                 <span class="text-primary-600 text-sm font-medium">
@@ -90,9 +87,6 @@
                   <button
                     on:click={handleLogout}
                     class="block w-full text-left px-4 py-2 text-sm text-gray-700 hover:bg-gray-100"
-                    role="button"
-                    tabindex="0"
-                    on:keydown={(e) => e.key === 'Enter' && handleLogout()}
                   >
                     Cerrar Sesión
                   </button>

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

@@ -29,12 +29,13 @@ const initialState: AppState = {
 // API helper function
 async function apiCall(endpoint: string, options: RequestInit = {}) {
   const authState = get(auth);
-  
+
   const response = await fetch(`/api/v1${endpoint}`, {
     ...options,
     headers: {
       'Content-Type': 'application/json',
       'Authorization': `Bearer ${authState.token}`,
+      'X-Tenant-ID': authState.tenantId, // Added tenant header
       ...options.headers
     }
   });
@@ -60,8 +61,10 @@ function createAppStore() {
       
       try {
         const categories = await apiCall('/categories/');
+        console.log('Loaded categories:', categories); // Debugging
         update(state => ({ ...state, categories, isLoading: false }));
       } catch (error) {
+        console.error('Error loading categories:', error); // Debugging
         update(state => ({ 
           ...state, 
           isLoading: false, 

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

@@ -107,6 +107,7 @@ function createAuthStore() {
           isLoading: false
         });
       } catch (error) {
+        console.error('Login error:', error); // Debugging the error
         update(state => ({ ...state, isLoading: false }));
         throw error;
       }

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

@@ -0,0 +1,44 @@
+import { writable } from 'svelte/store';
+
+export const clients = writable([]);
+
+export async function fetchClients() {
+  const response = await fetch('/api/v1/clients');
+  const data = await response.json();
+  clients.set(data);
+}
+
+export async function createClient(client) {
+  const response = await fetch('/api/v1/clients', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(client),
+  });
+  if (response.ok) {
+    fetchClients();
+  }
+}
+
+export async function updateClient(clientId, client) {
+  const response = await fetch(`/api/v1/clients/${clientId}`, {
+    method: 'PUT',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(client),
+  });
+  if (response.ok) {
+    fetchClients();
+  }
+}
+
+export async function deleteClient(clientId) {
+  const response = await fetch(`/api/v1/clients/${clientId}`, {
+    method: 'DELETE',
+  });
+  if (response.ok) {
+    fetchClients();
+  }
+}

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

@@ -1,15 +0,0 @@
-import { writable } from 'svelte/store';
-import { api } from '$utils/api';
-
-export const tickets = writable({
-  tickets: [],
-
-  async loadTickets() {
-    try {
-      const data = await api.get('/tickets');
-      this.update((state) => ({ ...state, tickets: data }));
-    } catch (error) {
-      console.error('Error al cargar los tickets:', error);
-    }
-  }
-});

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

@@ -1,6 +1,7 @@
-import { writable, get } from 'svelte/store';
+import { writable } from 'svelte/store';
+import { auth } from './auth.js';
+import { get } from 'svelte/store';
 import type { Writable } from 'svelte/store';
-import { auth } from './auth';
 
 // Types
 export interface Ticket {
@@ -83,29 +84,8 @@ async function apiCall(endpoint: string, options: RequestInit = {}) {
   });
 
   if (!response.ok) {
-    let errorMessage = 'Request failed';
-    try {
-      const error = await response.json();
-      console.error('❌ API Error Response:', error);
-      
-      // Manejar diferentes formatos de error de FastAPI
-      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(', ');
-        } else if (typeof error.detail === 'string') {
-          errorMessage = error.detail;
-        } else {
-          errorMessage = JSON.stringify(error.detail);
-        }
-      } else {
-        errorMessage = JSON.stringify(error);
-      }
-    } catch (e) {
-      errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-    }
-    
-    throw new Error(errorMessage);
+    const error = await response.json();
+    throw new Error(error.detail || 'Request failed');
   }
 
   return response.json();
@@ -120,13 +100,13 @@ function createTicketsStore() {
 
     // Load user's tickets
     loadTickets: async () => {
-      update((state: TicketsState) => ({ ...state, isLoading: true, error: null }));
+      update(state => ({ ...state, isLoading: true, error: null }));
       
       try {
         const tickets = await apiCall('/tickets/');
-        update((state: TicketsState) => ({ ...state, tickets, isLoading: false }));
+        update(state => ({ ...state, tickets, isLoading: false }));
       } catch (error) {
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           isLoading: false, 
           error: error instanceof Error ? error.message : 'Failed to load tickets' 
@@ -136,7 +116,7 @@ function createTicketsStore() {
 
     // Load specific ticket with details
     loadTicket: async (ticketId: string) => {
-      update((state: TicketsState) => ({ ...state, isLoading: true, error: null }));
+      update(state => ({ ...state, isLoading: true, error: null }));
       
       try {
         const [ticket, comments, attachments] = await Promise.all([
@@ -145,7 +125,7 @@ function createTicketsStore() {
           apiCall(`/tickets/${ticketId}/attachments`)
         ]);
 
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           currentTicket: ticket, 
           comments, 
@@ -153,7 +133,7 @@ function createTicketsStore() {
           isLoading: false 
         }));
       } catch (error) {
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           isLoading: false, 
           error: error instanceof Error ? error.message : 'Failed to load ticket' 
@@ -163,27 +143,15 @@ function createTicketsStore() {
 
     // Create new ticket
     createTicket: async (ticket: CreateTicketRequest) => {
-      update((state: TicketsState) => ({ ...state, isLoading: true, error: null }));
+      update(state => ({ ...state, isLoading: true, error: null }));
       
       try {
-        // Mapear campos del frontend al formato del backend
-    const ticketData = {
-      subject: ticket.title,           // ← Backend espera "subject" no "title"
-      description: ticket.description,
-      category_id: ticket.category_id,
-      priority: ticket.priority,
-      system_id: null                  // ← Opcional
-      };
-    
-
-      console.log('Sending ticket data:', ticketData);
-
         const newTicket = await apiCall('/tickets/', {
           method: 'POST',
-          body: JSON.stringify(ticketData)
+          body: JSON.stringify(ticket)
         });
 
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           tickets: [newTicket, ...state.tickets], 
           isLoading: false 
@@ -191,8 +159,7 @@ function createTicketsStore() {
 
         return newTicket;
       } catch (error) {
-        console.error('Create ticket error:', error);
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           isLoading: false, 
           error: error instanceof Error ? error.message : 'Failed to create ticket' 
@@ -209,14 +176,14 @@ function createTicketsStore() {
           body: JSON.stringify({ content })
         });
 
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           comments: [...state.comments, comment] 
         }));
 
         return comment;
       } catch (error) {
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           error: error instanceof Error ? error.message : 'Failed to add comment' 
         }));
@@ -246,14 +213,14 @@ function createTicketsStore() {
 
         const attachment = await response.json();
         
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           attachments: [...state.attachments, attachment] 
         }));
 
         return attachment;
       } catch (error) {
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           error: error instanceof Error ? error.message : 'Failed to upload attachment' 
         }));
@@ -269,15 +236,15 @@ function createTicketsStore() {
           body: JSON.stringify({ resolution })
         });
 
-        update((state: TicketsState) => ({
+        update(state => ({
           ...state,
           currentTicket: state.currentTicket?.id === ticketId ? updatedTicket : state.currentTicket,
-          tickets: state.tickets.map((t: Ticket) => t.id === ticketId ? updatedTicket : t)
+          tickets: state.tickets.map(t => t.id === ticketId ? updatedTicket : t)
         }));
 
         return updatedTicket;
       } catch (error) {
-        update((state: TicketsState) => ({ 
+        update(state => ({ 
           ...state, 
           error: error instanceof Error ? error.message : 'Failed to close ticket' 
         }));
@@ -287,12 +254,12 @@ function createTicketsStore() {
 
     // Clear error
     clearError: () => {
-      update((state: TicketsState) => ({ ...state, error: null }));
+      update(state => ({ ...state, error: null }));
     },
 
     // Clear current ticket
     clearCurrentTicket: () => {
-      update((state: TicketsState) => ({ 
+      update(state => ({ 
         ...state, 
         currentTicket: null, 
         comments: [], 

frontend-client/src/routes/clients/+page.svelte

@@ -0,0 +1,53 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { clients } from '$lib/stores/clients';
+  import { toast } from '$lib/stores/toast';
+
+  let clientList = [];
+  let isLoading = true;
+
+  onMount(async () => {
+    try {
+      clientList = await clients.loadClients();
+    } catch (error) {
+      toast.error('Error al cargar los clientes');
+    } finally {
+      isLoading = false;
+    }
+  });
+</script>
+
+<svelte:head>
+  <title>Clientes - ServiceManager</title>
+</svelte:head>
+
+<div class="container mx-auto py-8">
+  <h1 class="text-2xl font-bold mb-4">Listado de Clientes</h1>
+
+  {#if isLoading}
+    <p>Cargando clientes...</p>
+  {:else if clientList.length === 0}
+    <p>No hay clientes registrados.</p>
+  {:else}
+    <table class="table-auto w-full border-collapse border border-gray-300">
+      <thead>
+        <tr>
+          <th class="border border-gray-300 px-4 py-2">Nombre</th>
+          <th class="border border-gray-300 px-4 py-2">Email</th>
+          <th class="border border-gray-300 px-4 py-2">Acciones</th>
+        </tr>
+      </thead>
+      <tbody>
+        {#each clientList as client}
+          <tr>
+            <td class="border border-gray-300 px-4 py-2">{client.name}</td>
+            <td class="border border-gray-300 px-4 py-2">{client.email}</td>
+            <td class="border border-gray-300 px-4 py-2">
+              <a href={`/clients/${client.id}/edit`} class="text-blue-500 hover:underline">Editar</a>
+            </td>
+          </tr>
+        {/each}
+      </tbody>
+    </table>
+  {/if}
+</div>

frontend-client/src/routes/clients/[id]/edit/+page.svelte

@@ -0,0 +1,83 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { clients } from '$lib/stores/clients';
+  import { toast } from '$lib/stores/toast';
+  import { goto, page } from '$app/navigation';
+
+  let clientId = $page.params.id;
+  let name = '';
+  let email = '';
+  let isSubmitting = false;
+  let errors: Record<string, string> = {};
+
+  onMount(async () => {
+    try {
+      const client = await clients.loadClient(clientId);
+      name = client.name;
+      email = client.email;
+    } catch (error) {
+      toast.error('Error al cargar el cliente');
+      goto('/clients');
+    }
+  });
+
+  function validateForm() {
+    errors = {};
+
+    if (!name.trim()) {
+      errors.name = 'El nombre es requerido';
+    }
+
+    if (!email.trim()) {
+      errors.email = 'El email es requerido';
+    }
+
+    return Object.keys(errors).length === 0;
+  }
+
+  async function handleSubmit() {
+    if (!validateForm()) return;
+
+    isSubmitting = true;
+
+    try {
+      await clients.updateClient(clientId, { name, email });
+      toast.success('Cliente actualizado exitosamente');
+      goto('/clients');
+    } catch (error) {
+      toast.error('Error al actualizar el cliente');
+    } finally {
+      isSubmitting = false;
+    }
+  }
+</script>
+
+<svelte:head>
+  <title>Editar Cliente - ServiceManager</title>
+</svelte:head>
+
+<div class="container mx-auto py-8">
+  <h1 class="text-2xl font-bold mb-4">Editar Cliente</h1>
+
+  <form on:submit|preventDefault={handleSubmit} class="space-y-4">
+    <div>
+      <label for="name" class="block text-sm font-medium text-gray-700">Nombre</label>
+      <input id="name" type="text" bind:value={name} class="mt-1 block w-full border-gray-300 rounded-md shadow-sm" />
+      {#if errors.name}
+        <p class="text-red-500 text-sm">{errors.name}</p>
+      {/if}
+    </div>
+
+    <div>
+      <label for="email" class="block text-sm font-medium text-gray-700">Email</label>
+      <input id="email" type="email" bind:value={email} class="mt-1 block w-full border-gray-300 rounded-md shadow-sm" />
+      {#if errors.email}
+        <p class="text-red-500 text-sm">{errors.email}</p>
+      {/if}
+    </div>
+
+    <button type="submit" class="btn btn-primary" disabled={isSubmitting}>
+      {isSubmitting ? 'Guardando...' : 'Guardar Cambios'}
+    </button>
+  </form>
+</div>

frontend-client/src/routes/clients/new/+page.svelte

@@ -0,0 +1,71 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { clients } from '$lib/stores/clients';
+  import { toast } from '$lib/stores/toast';
+  import { goto } from '$app/navigation';
+
+  let name = '';
+  let email = '';
+  let isSubmitting = false;
+  let errors: Record<string, string> = {};
+
+  function validateForm() {
+    errors = {};
+
+    if (!name.trim()) {
+      errors.name = 'El nombre es requerido';
+    }
+
+    if (!email.trim()) {
+      errors.email = 'El email es requerido';
+    }
+
+    return Object.keys(errors).length === 0;
+  }
+
+  async function handleSubmit() {
+    if (!validateForm()) return;
+
+    isSubmitting = true;
+
+    try {
+      await clients.createClient({ name, email });
+      toast.success('Cliente creado exitosamente');
+      goto('/clients');
+    } catch (error) {
+      toast.error('Error al crear el cliente');
+    } finally {
+      isSubmitting = false;
+    }
+  }
+</script>
+
+<svelte:head>
+  <title>Crear Cliente - ServiceManager</title>
+</svelte:head>
+
+<div class="container mx-auto py-8">
+  <h1 class="text-2xl font-bold mb-4">Crear Nuevo Cliente</h1>
+
+  <form on:submit|preventDefault={handleSubmit} class="space-y-4">
+    <div>
+      <label for="name" class="block text-sm font-medium text-gray-700">Nombre</label>
+      <input id="name" type="text" bind:value={name} class="mt-1 block w-full border-gray-300 rounded-md shadow-sm" />
+      {#if errors.name}
+        <p class="text-red-500 text-sm">{errors.name}</p>
+      {/if}
+    </div>
+
+    <div>
+      <label for="email" class="block text-sm font-medium text-gray-700">Email</label>
+      <input id="email" type="email" bind:value={email} class="mt-1 block w-full border-gray-300 rounded-md shadow-sm" />
+      {#if errors.email}
+        <p class="text-red-500 text-sm">{errors.email}</p>
+      {/if}
+    </div>
+
+    <button type="submit" class="btn btn-primary" disabled={isSubmitting}>
+      {isSubmitting ? 'Creando...' : 'Crear Cliente'}
+    </button>
+  </form>
+</div>

frontend-internal/package.json

@@ -28,7 +28,7 @@
     "postcss": "^8.4.24",
     "prettier": "^2.8.0",
     "prettier-plugin-svelte": "^2.10.1",
-    "svelte": "^4.2.20",
+    "svelte": "^4.0.5",
     "svelte-check": "^3.4.3",
     "tailwindcss": "^3.3.0",
     "tslib": "^2.4.1",
@@ -37,13 +37,13 @@
     "vitest": "^0.34.0"
   },
   "dependencies": {
-    "@heroicons/react": "^2.0.18",
     "@tailwindcss/forms": "^0.5.4",
     "@tailwindcss/typography": "^0.5.9",
-    "chart.js": "^4.3.0",
-    "chartjs-adapter-date-fns": "^3.0.0",
-    "date-fns": "^2.30.0",
+    "@heroicons/react": "^2.0.18",
     "heroicons": "^2.0.18",
-    "zod": "^3.22.2"
+    "zod": "^3.22.2",
+    "date-fns": "^2.30.0",
+    "chart.js": "^4.3.0",
+    "chartjs-adapter-date-fns": "^3.0.0"
   }
-}
+}

frontend-internal/src/lib/stores/api.ts

@@ -0,0 +1,45 @@
+import { writable } from 'svelte/store';
+
+export const api = {
+  async getClients() {
+    const response = await fetch('/api/v1/clients');
+    if (!response.ok) {
+      throw new Error('Error fetching clients');
+    }
+    return await response.json();
+  },
+
+  async createClient(client) {
+    const response = await fetch('/api/v1/clients', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(client),
+    });
+    if (!response.ok) {
+      throw new Error('Error creating client');
+    }
+    return await response.json();
+  },
+
+  async updateClient(clientId, client) {
+    const response = await fetch(`/api/v1/clients/${clientId}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(client),
+    });
+    if (!response.ok) {
+      throw new Error('Error updating client');
+    }
+    return await response.json();
+  },
+
+  async deleteClient(clientId) {
+    const response = await fetch(`/api/v1/clients/${clientId}`, {
+      method: 'DELETE',
+    });
+    if (!response.ok) {
+      throw new Error('Error deleting client');
+    }
+    return await response.json();
+  },
+};

frontend-internal/src/routes/tenants/+page.svelte

@@ -43,15 +43,11 @@
   async function handleSubmit() {
     try {
       if (editingTenant) {
-        // Asegurarse de enviar el campo "status" correctamente
-        const updatedData = { ...formData, status: formData.is_active ? 'active' : 'inactive' };
-        await api.put(`/tenants/${editingTenant.id}`, updatedData);
-        toast.success(`Cliente ${formData.is_active ? 'activado' : 'desactivado'} correctamente`);
+        await api.put(`/tenants/${editingTenant.id}`, formData);
+        toast.success('Cliente actualizado');
       } else {
-        // Asegurarse de enviar el campo "status" al crear un cliente
-        const newData = { ...formData, status: formData.is_active ? 'active' : 'inactive' };
-        await api.post('/tenants/', newData);
-        toast.success('Cliente creado correctamente');
+        await api.post('/tenants/', formData);
+        toast.success('Cliente creado');
       }
       showModal = false;
       loadTenants();
@@ -156,11 +152,6 @@
       <button type="button" on:click={() => showModal = false} class="mt-3 w-full inline-flex justify-center rounded-md border border-gray-300 shadow-sm px-4 py-2 bg-white text-base font-medium text-gray-700 hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 sm:mt-0 sm:col-start-1 sm:text-sm">
         Cancelar
       </button>
-      {#if editingTenant}
-        <button type="button" on:click={async () => { await api.delete(`/tenants/${editingTenant.id}`); toast.success('Cliente eliminado'); showModal = false; loadTenants(); }} class="w-full inline-flex justify-center rounded-md border border-transparent shadow-sm px-4 py-2 bg-red-600 text-base font-medium text-white hover:bg-red-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-red-500 sm:col-start-1 sm:text-sm">
-          Eliminar
-        </button>
-      {/if}
     </div>
   </form>
 </Modal>

frontend-internal/src/routes/tickets/+page.svelte

@@ -1,53 +0,0 @@
-<script lang="ts">
-  import { onMount } from 'svelte';
-  import { api } from '$lib/api'; // ajusta el path si es distinto
-
-  let tickets: any[] = [];
-  let loading = true;
-  let error: string | null = null;
-
-  onMount(async () => {
-    try {
-      loading = true;
-      tickets = await api.get('/tickets');
-    } catch (err: any) {
-      console.error(err);
-      error = err.message ?? 'Error cargando tickets';
-    } finally {
-      loading = false;
-    }
-  });
-</script>
-
-<h1>Tickets</h1>
-
-{#if loading}
-  <p>Cargando tickets...</p>
-{:else if error}
-  <p style="color: red;">{error}</p>
-{:else if tickets.length === 0}
-  <p>No hay tickets</p>
-{:else}
-  <table border="1" cellpadding="8">
-    <thead>
-      <tr>
-        <th>Número</th>
-        <th>Asunto</th>
-        <th>Estado</th>
-        <th>Prioridad</th>
-        <th>Creado</th>
-      </tr>
-    </thead>
-    <tbody>
-      {#each tickets as ticket}
-        <tr>
-          <td>{ticket.ticket_number}</td>
-          <td>{ticket.subject}</td>
-          <td>{ticket.status}</td>
-          <td>{ticket.priority}</td>
-          <td>{new Date(ticket.created_at).toLocaleString()}</td>
-        </tr>
-      {/each}
-    </tbody>
-  </table>
-{/if}

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "ServiceManagerWeb",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

tests/test_tenant_middleware.py

@@ -0,0 +1,54 @@
+import sys
+import os
+import pytest
+from httpx import AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.models.tenant import Tenant
+from app.core.database import get_db
+
+# Add the project root to PYTHONPATH
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../')))
+
+from app.main import app
+
+@pytest.fixture(scope="function")
+async def setup_test_data():
+    async with get_db() as db:
+        # Insert a valid tenant
+        valid_tenant = Tenant(id="valid-tenant-id", slug="valid-tenant", status="active")
+        await db.add(valid_tenant)
+        await db.commit()
+
+        # Insert an invalid tenant
+        invalid_tenant = Tenant(id="invalid-tenant-id", slug="invalid-tenant", status="inactive")
+        await db.add(invalid_tenant)
+        await db.commit()
+
+        yield
+
+        # Cleanup
+        await db.delete(valid_tenant)
+        await db.delete(invalid_tenant)
+        await db.commit()
+
+@pytest.mark.asyncio
+async def test_request_without_tenant(setup_test_data):
+    async with AsyncClient(app=app, base_url="http://testserver") as client:
+        response = await client.get("/v1/categories/")
+        assert response.status_code == 400
+        assert response.json()["detail"] == "Tenant information required (X-Tenant-ID or X-Tenant-Slug header)"
+
+@pytest.mark.asyncio
+async def test_request_with_invalid_tenant(setup_test_data):
+    async with AsyncClient(app=app, base_url="http://testserver") as client:
+        headers = {"X-Tenant-ID": "invalid-tenant-id"}
+        response = await client.get("/v1/categories/", headers=headers)
+        assert response.status_code == 404
+        assert response.json()["detail"] == "Tenant not found or inactive"
+
+@pytest.mark.asyncio
+async def test_request_with_valid_tenant(setup_test_data):
+    async with AsyncClient(app=app, base_url="http://testserver") as client:
+        headers = {"X-Tenant-ID": "valid-tenant-id"}
+        response = await client.get("/v1/categories/", headers=headers)
+        assert response.status_code == 200