Subir todos los cambios recientes a la rama principal

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.")