Subir todos los cambios recientes a la rama principal

backend/alembic.ini

@@ -0,0 +1,36 @@
+[alembic]
+script_location = backend/alembic
+sqlalchemy.url = postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+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/tickets.py

@@ -0,0 +1,75 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from pydantic import BaseModel
+from typing import List
+import uuid
+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()
+
+# Esquema para crear un ticket
+class TicketCreate(BaseModel):
+    title: str
+    description: str
+    category_id: uuid.UUID
+    priority: str
+
+# Esquema para devolver un ticket
+class TicketResponse(BaseModel):
+    id: uuid.UUID
+    title: str
+    description: str
+    category_id: uuid.UUID
+    priority: str
+    created_at: str
+
+@router.post("/", response_model=TicketResponse)
+async def create_ticket(
+    ticket: TicketCreate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(deps.get_current_active_user)  # Verifica que el usuario esté autenticado
+):
+    # Validate if the category exists
+    try:
+        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(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(deps.get_current_active_user)  # Verifica que el usuario esté autenticado
+):
+    try:
+        result = await db.execute(select(Ticket).where(Ticket.tenant_id == current_user.tenant_id))
+        tickets = result.scalars().all()
+        return tickets
+    except Exception as e:
+        # 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,7 +5,7 @@ Router principal para la API v1
 """
 
 from fastapi import APIRouter
-from app.api.v1.endpoints import auth, health, tenants, users, systems, categories
+from app.api.v1.endpoints import auth, health, tenants, users, systems, categories, clients, tickets
 
 api_router = APIRouter()
 
@@ -45,3 +45,15 @@ api_router.include_router(
     prefix="/categories",
     tags=["categories"]
 )
+
+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"
@@ -139,4 +151,7 @@ def get_settings() -> Settings:
     
     Using lru_cache to create a singleton pattern for settings.
     """
-    return 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,17 +1,17 @@
-
 """
 Category Model - ServiceManagerWeb
 """
-from sqlalchemy import String, Text, Boolean, ForeignKey
+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
 
 class Category(Base):
-    __tablename__ = "categories"
+    __tablename__ = "ticket_categories"
     
     name: Mapped[str] = mapped_column(String(100), nullable=False)
     description: Mapped[Optional[str]] = mapped_column(Text)
@@ -20,6 +20,10 @@ class Category(Base):
     # 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/ticket.py

@@ -9,6 +9,8 @@ import enum
 import uuid
 
 from app.core.database import Base
+from app.models.system import System
+from app.models.category import Category
 
 class TicketStatus(str, enum.Enum):
     NEW = "NEW"
@@ -43,8 +45,8 @@ class Ticket(Base):
     created_by: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
     assigned_to: Mapped[Optional[uuid.UUID]] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
     
-    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)
+    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("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/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/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/test_db_connection.py

@@ -0,0 +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(get_database_url())
+        print("Connection to the database was successful!")
+        await conn.close()
+    except Exception as 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)