ADUANASOFT/service_manager
10
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Versión 1.3.0: Conexion completa del proyecto

Browse Source
This commit is contained in:
icamarillo
2026-02-03 10:38:54 -07:00
parent 6215fc40a7
commit 0d7cdf51ca
24 changed files with 5038 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
backend/app/api/v1/endpoints/categories.py
View File

@@ -3,53 +3,191 @@ from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from pydantic import BaseModel, ConfigDict
from typing import List, Optional
from datetime import datetime
import uuid
from app.core.database import get_db
from app.models.category import Category
from app.models.user import User
from app.api import deps
router = APIRouter()
class CategoryBase(BaseModel):
# ===================================
# PYDANTIC SCHEMAS
# ===================================
class CategoryCreate(BaseModel):
"""Schema para crear categoría - NO incluye tenant_id (se asigna automáticamente)"""
name: str
description: Optional[str] = None
is_active: bool = True
tenant_id: Optional[uuid.UUID] = None
color: Optional[str] = None
sla_response_hours: int = 24
sla_resolution_hours: int = 72
auto_assign_to: Optional[uuid.UUID] = None
class CategoryCreate(CategoryBase):
pass
class CategoryUpdate(CategoryBase):
class CategoryUpdate(BaseModel):
"""Schema para actualizar categoría"""
name: Optional[str] = None
description: Optional[str] = None
color: Optional[str] = None
sla_response_hours: Optional[int] = None
sla_resolution_hours: Optional[int] = None
auto_assign_to: Optional[uuid.UUID] = None
is_active: Optional[bool] = None
tenant_id: Optional[uuid.UUID] = None
class CategoryResponse(CategoryBase):
class CategoryResponse(BaseModel):
"""Schema de respuesta - incluye todos los campos"""
id: uuid.UUID
tenant_id: uuid.UUID # ✅ AÑADIDO
name: str
description: Optional[str] = None
color: Optional[str] = None
sla_response_hours: int
sla_resolution_hours: int
auto_assign_to: Optional[uuid.UUID] = None
is_active: bool
created_at: datetime # ✅ AÑADIDO
updated_at: datetime # ✅ AÑADIDO
model_config = ConfigDict(from_attributes=True)
# ===================================
# ENDPOINTS
# ===================================
@router.get("/", response_model=List[CategoryResponse])
async def read_categories(
skip: int = 0,
limit: int = 100,
db: AsyncSession = Depends(get_db),
current_user = Depends(deps.get_current_active_superuser)
current_user: User = Depends(deps.get_current_user) # ✅ CORREGIDO: Type hint + no solo superuser
):
query = select(Category).offset(skip).limit(limit)
"""
Listar categorías del tenant del usuario actual.
✅ Implementa multi-tenancy: solo muestra categorías del tenant del usuario.
"""
# ✅ CORREGIDO: Filtrar por tenant_id
query = select(Category).where(
Category.tenant_id == current_user.tenant_id
).offset(skip).limit(limit)
result = await db.execute(query)
return result.scalars().all()
@router.post("/", response_model=CategoryResponse)
@router.post("/", response_model=CategoryResponse, status_code=status.HTTP_201_CREATED)
async def create_category(
category: CategoryCreate,
db: AsyncSession = Depends(get_db),
current_user = Depends(deps.get_current_active_superuser)
current_user: User = Depends(deps.get_current_user) # ✅ CORREGIDO: Type hint
):
db_category = Category(**category.model_dump())
"""
Crear nueva categoría en el tenant del usuario actual.
✅ Implementa multi-tenancy: asigna automáticamente tenant_id del usuario.
"""
# ✅ CORREGIDO: Asignar tenant_id del usuario actual
db_category = Category(
**category.model_dump(),
tenant_id=current_user.tenant_id # ✅ Multi-tenancy automático
)
db.add(db_category)
await db.commit()
await db.refresh(db_category)
return db_category
@router.get("/{category_id}", response_model=CategoryResponse)
async def read_category(
category_id: uuid.UUID,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Obtener una categoría específica del tenant.
✅ Implementa multi-tenancy: solo permite acceso a categorías del propio tenant.
"""
query = select(Category).where(
Category.id == category_id,
Category.tenant_id == current_user.tenant_id # ✅ Seguridad multi-tenant
)
result = await db.execute(query)
category = result.scalar_one_or_none()
if not category:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Category not found"
)
return category
@router.put("/{category_id}", response_model=CategoryResponse)
async def update_category(
category_id: uuid.UUID,
category_update: CategoryUpdate,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Actualizar categoría del tenant.
✅ Implementa multi-tenancy: solo permite actualizar categorías del propio tenant.
"""
query = select(Category).where(
Category.id == category_id,
Category.tenant_id == current_user.tenant_id
)
result = await db.execute(query)
db_category = result.scalar_one_or_none()
if not db_category:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Category not found"
)
# Actualizar campos
update_data = category_update.model_dump(exclude_unset=True)
for field, value in update_data.items():
setattr(db_category, field, value)
await db.commit()
await db.refresh(db_category)
return db_category
@router.delete("/{category_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_category(
category_id: uuid.UUID,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Desactivar categoría del tenant (soft delete).
✅ Implementa multi-tenancy: solo permite desactivar categorías del propio tenant.
"""
query = select(Category).where(
Category.id == category_id,
Category.tenant_id == current_user.tenant_id
)
result = await db.execute(query)
db_category = result.scalar_one_or_none()
if not db_category:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Category not found"
)
# Soft delete
db_category.is_active = False
await db.commit()
return None

152
backend/app/api/v1/endpoints/systems.py
View File

@@ -3,51 +3,179 @@ from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from pydantic import BaseModel, ConfigDict
from typing import List, Optional
from datetime import datetime
import uuid
from app.core.database import get_db
from app.models.system import System
from app.models.user import User
from app.api import deps
router = APIRouter()
class SystemBase(BaseModel):
# ===================================
# PYDANTIC SCHEMAS
# ===================================
class SystemCreate(BaseModel):
"""Schema para crear sistema - NO incluye tenant_id (se asigna automáticamente)"""
name: str
description: Optional[str] = None
is_active: bool = True
class SystemCreate(SystemBase):
pass
class SystemUpdate(SystemBase):
class SystemUpdate(BaseModel):
"""Schema para actualizar sistema"""
name: Optional[str] = None
description: Optional[str] = None
is_active: Optional[bool] = None
class SystemResponse(SystemBase):
class SystemResponse(BaseModel):
"""Schema de respuesta - incluye todos los campos"""
id: uuid.UUID
tenant_id: uuid.UUID # ✅ AÑADIDO
name: str
description: Optional[str] = None
is_active: bool
created_at: datetime # ✅ AÑADIDO
updated_at: datetime # ✅ AÑADIDO
model_config = ConfigDict(from_attributes=True)
# ===================================
# ENDPOINTS
# ===================================
@router.get("/", response_model=List[SystemResponse])
async def read_systems(
skip: int = 0,
limit: int = 100,
db: AsyncSession = Depends(get_db),
current_user = Depends(deps.get_current_active_superuser)
current_user: User = Depends(deps.get_current_user) # ✅ CORREGIDO: Type hint + no solo superuser
):
query = select(System).offset(skip).limit(limit)
"""
Listar sistemas del tenant del usuario actual.
✅ Implementa multi-tenancy: solo muestra sistemas del tenant del usuario.
"""
# ✅ CORREGIDO: Filtrar por tenant_id
query = select(System).where(
System.tenant_id == current_user.tenant_id
).offset(skip).limit(limit)
result = await db.execute(query)
return result.scalars().all()
@router.post("/", response_model=SystemResponse)
@router.post("/", response_model=SystemResponse, status_code=status.HTTP_201_CREATED)
async def create_system(
system: SystemCreate,
db: AsyncSession = Depends(get_db),
current_user = Depends(deps.get_current_active_superuser)
current_user: User = Depends(deps.get_current_user) # ✅ CORREGIDO: Type hint
):
db_system = System(**system.model_dump())
"""
Crear nuevo sistema en el tenant del usuario actual.
✅ Implementa multi-tenancy: asigna automáticamente tenant_id del usuario.
"""
# ✅ CORREGIDO: Asignar tenant_id del usuario actual
db_system = System(
**system.model_dump(),
tenant_id=current_user.tenant_id # ✅ Multi-tenancy automático
)
db.add(db_system)
await db.commit()
await db.refresh(db_system)
return db_system
@router.get("/{system_id}", response_model=SystemResponse)
async def read_system(
system_id: uuid.UUID,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Obtener un sistema específico del tenant.
✅ Implementa multi-tenancy: solo permite acceso a sistemas del propio tenant.
"""
query = select(System).where(
System.id == system_id,
System.tenant_id == current_user.tenant_id # ✅ Seguridad multi-tenant
)
result = await db.execute(query)
system = result.scalar_one_or_none()
if not system:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="System not found"
)
return system
@router.put("/{system_id}", response_model=SystemResponse)
async def update_system(
system_id: uuid.UUID,
system_update: SystemUpdate,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Actualizar sistema del tenant.
✅ Implementa multi-tenancy: solo permite actualizar sistemas del propio tenant.
"""
query = select(System).where(
System.id == system_id,
System.tenant_id == current_user.tenant_id
)
result = await db.execute(query)
db_system = result.scalar_one_or_none()
if not db_system:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="System not found"
)
# Actualizar campos
update_data = system_update.model_dump(exclude_unset=True)
for field, value in update_data.items():
setattr(db_system, field, value)
await db.commit()
await db.refresh(db_system)
return db_system
@router.delete("/{system_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_system(
system_id: uuid.UUID,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Desactivar sistema del tenant (soft delete).
✅ Implementa multi-tenancy: solo permite desactivar sistemas del propio tenant.
"""
query = select(System).where(
System.id == system_id,
System.tenant_id == current_user.tenant_id
)
result = await db.execute(query)
db_system = result.scalar_one_or_none()
if not db_system:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="System not found"
)
# Soft delete
db_system.is_active = False
await db.commit()
return None

18
backend/app/api/v1/endpoints/tenants.py
View File

@@ -85,6 +85,9 @@ 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)
@@ -92,3 +95,18 @@ 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"}

46
backend/app/api/v1/endpoints/tickets.py
View File

@@ -3,6 +3,7 @@ Tickets endpoints - ServiceManagerWeb
"""
from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File
from pydantic import BaseModel
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, func
from typing import List, Optional
@@ -11,7 +12,8 @@ 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 pydantic import BaseModel
from app.models.category import Category # ✅ CORREGIDO: Era TicketCategory
from app.models.system import System
import uuid
router = APIRouter()
@@ -24,7 +26,7 @@ class TicketCreate(BaseModel):
subject: str
description: str
category_id: Optional[str] = None
system_id: Optional[str] = None
affected_system_id: Optional[str] = None # ✅ CORREGIDO: Era system_id
priority: str = "MEDIUM"
class TicketUpdate(BaseModel):
@@ -42,7 +44,7 @@ class TicketResponse(BaseModel):
status: str
priority: str
category_id: Optional[str] = None
system_id: Optional[str] = None
affected_system_id: Optional[str] = None # ✅ CORREGIDO: Era system_id
created_by: str
assigned_to: Optional[str] = None
created_at: datetime
@@ -78,7 +80,25 @@ async def create_ticket(
# 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.system_id) if ticket.system_id else None
system_uuid = uuid.UUID(ticket.affected_system_id) if ticket.affected_system_id else None # ✅ CORREGIDO
# ✅ CORREGIDO: Validar en la tabla correcta con el nombre correcto del modelo
if category_uuid:
category = await db.get(Category, category_uuid) # ✅ Category, no TicketCategory
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 affected_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."
)
db_ticket = Ticket(
id=uuid.uuid4(),
@@ -87,7 +107,7 @@ async def create_ticket(
subject=ticket.subject,
description=ticket.description,
category_id=category_uuid,
system_id=system_uuid,
affected_system_id=system_uuid, # ✅ CORREGIDO: Nombre correcto del campo
priority=TicketPriority[ticket.priority.upper()],
created_by=current_user.id,
status=TicketStatus.NEW,
@@ -99,7 +119,7 @@ async def create_ticket(
await db.commit()
await db.refresh(db_ticket)
# Convertir a respuesta
# ✅ CORREGIDO: Usar affected_system_id en respuesta
return {
"id": str(db_ticket.id),
"ticket_number": db_ticket.ticket_number,
@@ -108,7 +128,7 @@ async def create_ticket(
"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.system_id) if db_ticket.system_id else None,
"affected_system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None, # ✅ CORREGIDO
"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,
@@ -160,6 +180,7 @@ async def get_tickets(
result = await db.execute(query)
tickets = result.scalars().all()
# ✅ CORREGIDO: Usar affected_system_id
return [
{
"id": str(t.id),
@@ -169,7 +190,7 @@ async def get_tickets(
"status": t.status.value,
"priority": t.priority.value,
"category_id": str(t.category_id) if t.category_id else None,
"system_id": str(t.system_id) if t.system_id else None,
"affected_system_id": str(t.affected_system_id) if t.affected_system_id else None, # ✅ CORREGIDO
"created_by": str(t.created_by),
"assigned_to": str(t.assigned_to) if t.assigned_to else None,
"created_at": t.created_at,
@@ -211,6 +232,7 @@ async def get_ticket(
detail=f"Ticket {ticket_id} not found"
)
# ✅ CORREGIDO: Usar affected_system_id
return {
"id": str(ticket.id),
"ticket_number": ticket.ticket_number,
@@ -219,7 +241,7 @@ async def get_ticket(
"status": ticket.status.value,
"priority": ticket.priority.value,
"category_id": str(ticket.category_id) if ticket.category_id else None,
"system_id": str(ticket.system_id) if ticket.system_id else None,
"affected_system_id": str(ticket.affected_system_id) if ticket.affected_system_id else None, # ✅ CORREGIDO
"created_by": str(ticket.created_by),
"assigned_to": str(ticket.assigned_to) if ticket.assigned_to else None,
"created_at": ticket.created_at,
@@ -278,6 +300,7 @@ async def update_ticket(
await db.commit()
await db.refresh(db_ticket)
# ✅ CORREGIDO: Usar affected_system_id
return {
"id": str(db_ticket.id),
"ticket_number": db_ticket.ticket_number,
@@ -286,7 +309,7 @@ async def update_ticket(
"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.system_id) if db_ticket.system_id else None,
"affected_system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None, # ✅ CORREGIDO
"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,
@@ -341,6 +364,7 @@ async def close_ticket(
await db.commit()
await db.refresh(db_ticket)
# ✅ CORREGIDO: Usar affected_system_id
return {
"id": str(db_ticket.id),
"ticket_number": db_ticket.ticket_number,
@@ -349,7 +373,7 @@ async def close_ticket(
"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.system_id) if db_ticket.system_id else None,
"affected_system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None, # ✅ CORREGIDO
"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,

317
backend/app/api/v1/endpoints/users.py
View File

@@ -3,6 +3,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from pydantic import BaseModel, ConfigDict, EmailStr
from typing import List, Optional
from datetime import datetime
import uuid
from app.core.database import get_db
@@ -12,57 +13,335 @@ from app.api import deps
router = APIRouter()
class UserBase(BaseModel):
# ===================================
# PYDANTIC SCHEMAS
# ===================================
class UserCreate(BaseModel):
"""Schema para crear usuario - NO incluye tenant_id (se asigna automáticamente)"""
email: EmailStr
first_name: str
last_name: str
role: UserRole
is_active: bool = True
tenant_id: Optional[uuid.UUID] = None
class UserCreate(UserBase):
password: str
language: str = "es"
timezone: str = "UTC"
notifications_email: bool = True
class UserUpdate(BaseModel):
"""Schema para actualizar usuario"""
email: Optional[EmailStr] = None
first_name: Optional[str] = None
last_name: Optional[str] = None
role: Optional[UserRole] = None
is_active: Optional[bool] = None
password: Optional[str] = None # Optional password update
password: Optional[str] = None
language: Optional[str] = None
timezone: Optional[str] = None
notifications_email: Optional[bool] = None
class UserResponse(UserBase):
class UserResponse(BaseModel):
"""Schema de respuesta - incluye todos los campos públicos"""
id: uuid.UUID
tenant_id: uuid.UUID
email: EmailStr
first_name: str
last_name: str
avatar_url: Optional[str] = None
role: UserRole
is_active: bool
email_verified: bool
last_login: Optional[datetime] = None
language: str
timezone: str
notifications_email: bool
totp_enabled: bool
created_at: datetime
updated_at: datetime
model_config = ConfigDict(from_attributes=True)
# ===================================
# ENDPOINTS
# ===================================
@router.get("/", response_model=List[UserResponse])
async def read_users(
skip: int = 0,
limit: int = 100,
limit: int = 100,
role: Optional[UserRole] = None,
is_active: Optional[bool] = None,
db: AsyncSession = Depends(get_db),
current_user = Depends(deps.get_current_active_superuser)
current_user: User = Depends(deps.get_current_user)
):
query = select(User).offset(skip).limit(limit)
"""
Listar usuarios del tenant del usuario actual.
✅ Implementa multi-tenancy: solo muestra usuarios del tenant del usuario.
Filtros opcionales:
- role: filtrar por rol
- is_active: filtrar por estado activo
"""
# ✅ CORREGIDO: Filtrar por tenant_id
query = select(User).where(User.tenant_id == current_user.tenant_id)
# Aplicar filtros opcionales
if role:
query = query.where(User.role == role)
if is_active is not None:
query = query.where(User.is_active == is_active)
query = query.offset(skip).limit(limit).order_by(User.created_at.desc())
result = await db.execute(query)
return result.scalars().all()
@router.post("/", response_model=UserResponse)
@router.post("/", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
async def create_user(
user: UserCreate,
db: AsyncSession = Depends(get_db),
current_user = Depends(deps.get_current_active_superuser)
current_user: User = Depends(deps.get_current_user)
):
query = select(User).where(User.email == user.email)
"""
Crear nuevo usuario en el tenant del usuario actual.
✅ Implementa multi-tenancy: asigna automáticamente tenant_id del usuario.
Restricciones:
- Solo ADMIN, SUPPORT_MANAGER y CLIENT_ADMIN pueden crear usuarios
- El email debe ser único dentro del tenant
"""
# Verificar permisos
if not current_user.can_manage_users:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="You don't have permission to create users"
)
# Verificar si el email ya existe en el tenant
query = select(User).where(
User.email == user.email,
User.tenant_id == current_user.tenant_id
)
result = await db.execute(query)
if result.scalar_one_or_none():
raise HTTPException(status_code=400, detail="Email already registered")
user_data = user.model_dump(exclude={"password"})
password_hash = security.get_password_hash(user.password)
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Email already registered in this tenant"
)
# Preparar datos del usuario
user_data = user.model_dump(exclude={"password"})
password_hash = security.hash_password(user.password)
# ✅ CORREGIDO: Asignar tenant_id del usuario actual
db_user = User(
**user_data,
password_hash=password_hash,
tenant_id=current_user.tenant_id # ✅ Multi-tenancy automático
)
db_user = User(**user_data, password_hash=password_hash)
db.add(db_user)
await db.commit()
await db.refresh(db_user)
return db_user
@router.get("/{user_id}", response_model=UserResponse)
async def read_user(
user_id: uuid.UUID,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Obtener un usuario específico del tenant.
✅ Implementa multi-tenancy: solo permite acceso a usuarios del propio tenant.
"""
query = select(User).where(
User.id == user_id,
User.tenant_id == current_user.tenant_id # ✅ Seguridad multi-tenant
)
result = await db.execute(query)
user = result.scalar_one_or_none()
if not user:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="User not found"
)
return user
@router.put("/{user_id}", response_model=UserResponse)
async def update_user(
user_id: uuid.UUID,
user_update: UserUpdate,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Actualizar usuario del tenant.
✅ Implementa multi-tenancy: solo permite actualizar usuarios del propio tenant.
Restricciones:
- Solo ADMIN, SUPPORT_MANAGER y CLIENT_ADMIN pueden actualizar usuarios
- No se puede cambiar el tenant_id
"""
# Verificar permisos
if not current_user.can_manage_users:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="You don't have permission to update users"
)
# Buscar usuario
query = select(User).where(
User.id == user_id,
User.tenant_id == current_user.tenant_id
)
result = await db.execute(query)
db_user = result.scalar_one_or_none()
if not db_user:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="User not found"
)
# Verificar email único si se está cambiando
update_data = user_update.model_dump(exclude_unset=True)
if "email" in update_data and update_data["email"] != db_user.email:
email_query = select(User).where(
User.email == update_data["email"],
User.tenant_id == current_user.tenant_id,
User.id != user_id
)
email_result = await db.execute(email_query)
if email_result.scalar_one_or_none():
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Email already in use by another user"
)
# Actualizar campos
for field, value in update_data.items():
if field == "password":
# Hash the new password
db_user.password_hash = security.hash_password(value)
else:
setattr(db_user, field, value)
await db.commit()
await db.refresh(db_user)
return db_user
@router.delete("/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_user(
user_id: uuid.UUID,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Desactivar usuario del tenant (soft delete).
✅ Implementa multi-tenancy: solo permite desactivar usuarios del propio tenant.
Restricciones:
- Solo ADMIN puede eliminar usuarios
- No se puede eliminar a sí mismo
- No se puede eliminar el último ADMIN del tenant
"""
# Verificar permisos - solo ADMIN puede eliminar
if current_user.role != UserRole.ADMIN:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Only admins can delete users"
)
# No se puede eliminar a sí mismo
if user_id == current_user.id:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="You cannot delete yourself"
)
# Buscar usuario
query = select(User).where(
User.id == user_id,
User.tenant_id == current_user.tenant_id
)
result = await db.execute(query)
db_user = result.scalar_one_or_none()
if not db_user:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="User not found"
)
# Verificar que no sea el último admin del tenant
if db_user.role == UserRole.ADMIN:
admin_query = select(User).where(
User.tenant_id == current_user.tenant_id,
User.role == UserRole.ADMIN,
User.is_active == True,
User.id != user_id
)
admin_result = await db.execute(admin_query)
active_admins = admin_result.scalars().all()
if len(active_admins) == 0:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Cannot delete the last active admin of the tenant"
)
# Soft delete
db_user.is_active = False
await db.commit()
return None
@router.patch("/{user_id}/activate", response_model=UserResponse)
async def activate_user(
user_id: uuid.UUID,
db: AsyncSession = Depends(get_db),
current_user: User = Depends(deps.get_current_user)
):
"""
Reactivar usuario desactivado.
✅ Implementa multi-tenancy: solo permite reactivar usuarios del propio tenant.
"""
# Verificar permisos
if not current_user.can_manage_users:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="You don't have permission to activate users"
)
# Buscar usuario
query = select(User).where(
User.id == user_id,
User.tenant_id == current_user.tenant_id
)
result = await db.execute(query)
db_user = result.scalar_one_or_none()
if not db_user:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="User not found"
)
db_user.is_active = True
await db.commit()
await db.refresh(db_user)
return db_user

7
backend/app/api/v1/router.py
View File

@@ -5,6 +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
api_router = APIRouter()
@@ -51,4 +52,8 @@ api_router.include_router(
tickets.router,
prefix="/tickets",
tags=["tickets"]
)
)
# Ensure FastAPI is installed in the environment
# If not, install it using:
# pip install fastapi

40
backend/app/models/category.py
View File

@@ -1,8 +1,8 @@
"""
Category Model - ServiceManagerWeb
Categorías de tickets por tenant
"""
from sqlalchemy import String, Text, Boolean, ForeignKey
from sqlalchemy import String, Text, Boolean, Integer, ForeignKey, UniqueConstraint
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sqlalchemy.dialects.postgresql import UUID
from typing import List, Optional
@@ -11,18 +11,40 @@ import uuid
from app.core.database import Base
class Category(Base):
__tablename__ = "categories"
"""Modelo de categorías de tickets (ticket_categories en BD)"""
__tablename__ = "ticket_categories" # ✅ CORREGIDO: nombre correcto de tabla
# Campos básicos
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)
description: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
is_active: Mapped[bool] = mapped_column(Boolean, default=True, 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)
# ✅ CORREGIDO: tenant_id es obligatorio para multi-tenancy
tenant_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("tenants.id", ondelete="CASCADE"),
nullable=False # ✅ Obligatorio
)
# ✅ AÑADIDOS: Campos de SLA según schema.sql
color: Mapped[Optional[str]] = mapped_column(String(7), nullable=True)
sla_response_hours: Mapped[int] = mapped_column(Integer, default=24, nullable=False)
sla_resolution_hours: Mapped[int] = mapped_column(Integer, default=72, nullable=False)
auto_assign_to: Mapped[Optional[uuid.UUID]] = mapped_column(
UUID(as_uuid=True),
ForeignKey("users.id"),
nullable=True
)
# Relationships
tickets: Mapped[List["Ticket"]] = relationship("Ticket", back_populates="category")
tenant: Mapped["Tenant"] = relationship("Tenant") # Assuming Tenant model is imported
tenant: Mapped["Tenant"] = relationship("Tenant")
auto_assign_user: Mapped[Optional["User"]] = relationship("User", foreign_keys=[auto_assign_to])
# ✅ AÑADIDO: Constraint único por tenant (no puede haber categorías duplicadas en el mismo tenant)
__table_args__ = (
UniqueConstraint('tenant_id', 'name', name='uq_ticket_categories_tenant_name'),
)
def __repr__(self) -> str:
return f"<Category(id={self.id}, name='{self.name}')>"
return f"<Category(id={self.id}, name='{self.name}', tenant_id={self.tenant_id})>"

0
backend/app/models/relationships.py Normal file
View File

36
backend/app/models/system.py
View File

@@ -1,25 +1,43 @@
"""
System Model - ServiceManagerWeb
Sistemas afectados por tenant
"""
from sqlalchemy import String, Text, Boolean
from sqlalchemy import String, Text, Boolean, ForeignKey, UniqueConstraint
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sqlalchemy.dialects.postgresql import UUID
from typing import List, Optional
import uuid
from app.core.database import Base
class System(Base):
__tablename__ = "systems"
"""Modelo de sistemas afectados (affected_systems en BD)"""
__tablename__ = "affected_systems" # ✅ CORREGIDO: nombre correcto de tabla
# Campos básicos
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)
description: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
# ✅ AÑADIDO: tenant_id obligatorio para multi-tenancy (faltaba completamente)
tenant_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("tenants.id", ondelete="CASCADE"),
nullable=False
)
# 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="system")
# ✅ ACTUALIZADO: nombre de relación a affected_system
tickets: Mapped[List["Ticket"]] = relationship(
"Ticket",
back_populates="affected_system" # ✅ Nombre actualizado
)
tenant: Mapped["Tenant"] = relationship("Tenant")
# ✅ AÑADIDO: Constraint único por tenant (no puede haber sistemas duplicados en el mismo tenant)
__table_args__ = (
UniqueConstraint('tenant_id', 'name', name='uq_affected_systems_tenant_name'),
)
def __repr__(self) -> str:
return f"<System(id={self.id}, name='{self.name}')>"
return f"<System(id={self.id}, name='{self.name}', tenant_id={self.tenant_id})>"

13
backend/app/models/tenant.py
View File

@@ -1,9 +1,7 @@
"""
Tenant Model - ServiceManagerWeb
Modelo para organizaciones cliente (multi-tenancy)
"""
from sqlalchemy import String, Integer, Text, Boolean, ARRAY
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sqlalchemy.dialects.postgresql import UUID, ENUM
@@ -13,17 +11,14 @@ import uuid
from app.core.database import Base
class TenantStatus(str, enum.Enum):
"""Estados de un tenant."""
ACTIVE = "active"
SUSPENDED = "suspended"
INACTIVE = "inactive"
class Tenant(Base):
"""Modelo de Tenant (Organización cliente)."""
__tablename__ = "tenants"
# Información básica
@@ -51,18 +46,14 @@ class Tenant(Base):
# Estado
status: Mapped[TenantStatus] = mapped_column(
String(20),
String(20),
default=TenantStatus.ACTIVE
)
# 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") # ✅ CORREGIDO: Era "TicketCategory"
def __repr__(self) -> str:
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

93
backend/app/models/ticket.py
View File

@@ -1,56 +1,112 @@
"""
Ticket Model - ServiceManagerWeb
Tickets de soporte - Core del negocio
"""
from sqlalchemy import String, ForeignKey, Text
from sqlalchemy import String, ForeignKey, Text, Integer, CheckConstraint, UniqueConstraint
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sqlalchemy.dialects.postgresql import UUID, ENUM
from typing import Optional
from datetime import datetime
import enum
import uuid
from app.core.database import Base
class TicketStatus(str, enum.Enum):
"""Estados posibles de un ticket"""
NEW = "NEW"
TRIAGE = "TRIAGE"
IN_PROGRESS = "IN_PROGRESS"
WAITING_FOR_CLIENT = "WAITING_FOR_CLIENT"
WAITING_CUSTOMER = "WAITING_CUSTOMER" # ✅ CORREGIDO: nombre según schema.sql
RESOLVED = "RESOLVED"
CLOSED = "CLOSED"
REOPENED = "REOPENED"
class TicketPriority(str, enum.Enum):
"""Prioridades posibles de un ticket"""
LOW = "LOW"
MEDIUM = "MEDIUM"
HIGH = "HIGH"
URGENT = "URGENT"
class Ticket(Base):
"""Modelo de tickets de soporte"""
__tablename__ = "tickets"
# Note: id, created_at, updated_at are inherited from Base
tenant_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("tenants.id", ondelete="CASCADE"), nullable=False)
# Multi-tenancy
tenant_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("tenants.id", ondelete="CASCADE"),
nullable=False
)
# Campos básicos
ticket_number: Mapped[str] = mapped_column(String(20), nullable=False)
subject: Mapped[str] = mapped_column(String(255), nullable=False)
description: Mapped[str] = mapped_column(Text, nullable=False)
status: Mapped[TicketStatus] = mapped_column(ENUM(TicketStatus, name="ticket_status_enum", create_type=False), default=TicketStatus.NEW)
priority: Mapped[TicketPriority] = mapped_column(ENUM(TicketPriority, name="ticket_priority_enum", create_type=False), default=TicketPriority.MEDIUM)
# Estado y Prioridad
status: Mapped[TicketStatus] = mapped_column(
ENUM(TicketStatus, name="ticket_status_enum", create_type=False),
default=TicketStatus.NEW,
nullable=False
)
priority: Mapped[TicketPriority] = mapped_column(
ENUM(TicketPriority, name="ticket_priority_enum", create_type=False),
default=TicketPriority.MEDIUM,
nullable=False
)
# Foreign Keys
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)
# ✅ CORREGIDO: Foreign Keys apuntan a tablas correctas
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)
# ✅ CORREGIDO: Renombrado de system_id a affected_system_id
affected_system_id: Mapped[Optional[uuid.UUID]] = mapped_column(
UUID(as_uuid=True),
ForeignKey("affected_systems.id"), # ✅ Tabla correcta
nullable=True
)
# ✅ CORREGIDO: Foreign key a tabla correcta
category_id: Mapped[Optional[uuid.UUID]] = mapped_column(
UUID(as_uuid=True),
ForeignKey("ticket_categories.id"), # ✅ Tabla correcta
nullable=True
)
# ✅ AÑADIDOS: Campos de SLA según schema.sql
sla_response_due: Mapped[Optional[datetime]] = mapped_column(nullable=True)
sla_resolution_due: Mapped[Optional[datetime]] = mapped_column(nullable=True)
first_response_at: Mapped[Optional[datetime]] = mapped_column(nullable=True)
resolved_at: Mapped[Optional[datetime]] = mapped_column(nullable=True)
# ✅ AÑADIDOS: Campos de CSAT (Customer Satisfaction) según schema.sql
rating: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
rating_comment: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
rated_at: Mapped[Optional[datetime]] = mapped_column(nullable=True)
# Relationships
tenant: Mapped["Tenant"] = relationship("Tenant", back_populates="tickets")
system: Mapped["System"] = relationship("System", back_populates="tickets")
category: Mapped["Category"] = relationship("Category", back_populates="tickets")
# ✅ ACTUALIZADO: Nombre de relación y optional
affected_system: Mapped[Optional["System"]] = relationship(
"System",
back_populates="tickets"
)
category: Mapped[Optional["Category"]] = relationship(
"Category",
back_populates="tickets"
)
created_by_user: Mapped["User"] = relationship(
"User",
@@ -63,3 +119,12 @@ class Ticket(Base):
foreign_keys=[assigned_to],
back_populates="assigned_tickets"
)
# ✅ AÑADIDOS: Constraints según schema.sql
__table_args__ = (
UniqueConstraint('tenant_id', 'ticket_number', name='uq_tickets_tenant_number'),
CheckConstraint('rating >= 1 AND rating <= 5', name='check_rating_range'),
)
def __repr__(self) -> str:
return f"<Ticket(id={self.id}, number='{self.ticket_number}', status={self.status})>"

0
backend/app/update_password_hashes.py Normal file
View File

1
backend/backend/migrations/README Normal file
View File

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

78
backend/backend/migrations/env.py Normal file
View File

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

26
backend/backend/migrations/script.py.mako Normal file
View File

@@ -0,0 +1,26 @@
"""${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"}

9
backend/fix_password_script.py
View File

@@ -1,5 +1,4 @@
import asyncio
import asyncio
import sys
import os
@@ -8,8 +7,10 @@ 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.tenant import Tenant
from app.models.ticket import Ticket
from app.models.category import Category # ✅ AÑADIR ESTO
from app.models.system import System # ✅ AÑADIR ESTO
from app.models.user import User
from app.core.security import SecurityUtils

68
backend/migrations/env.py Normal file
View File

@@ -0,0 +1,68 @@
from logging.config import fileConfig
import os
from sqlalchemy import create_engine, pool
from sqlalchemy.engine import engine_from_config
from alembic import context
# 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()
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"] = SYNC_DATABASE_URL
connectable = engine_from_config(
alembic_config,
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()