Aprende a construir una vista basada en funciones con Django Rest Framework para listar pacientes en JSON. Con un serializer, una query simple y el decorador ApiView, tendrás un endpoint limpio, validado y listo para usarse en frontend o pruebas rápidas.
¿Cómo listar pacientes con un serializer en Django Rest Framework?
Crear una vista para devolver datos en JSON es directo cuando usamos Response y un serializer. El flujo es: consultar la base de datos, serializar la lista y responder en un formato correcto.
Importar el serializer de pacientes.
Consultar la base de datos con Patient.objects.all().
Aprende a construir una vista basada en funciones con Django Rest Framework para listar pacientes en JSON. Con un serializer, una query simple y el decorador ApiView, tendrás un endpoint limpio, validado y listo para usarse en frontend o pruebas rápidas.
¿Cómo listar pacientes con un serializer en Django Rest Framework?
Crear una vista para devolver datos en JSON es directo cuando usamos Response y un serializer. El flujo es: consultar la base de datos, serializar la lista y responder en un formato correcto.
Importar el serializer de pacientes.
Consultar la base de datos con Patient.objects.all().
Serializar una lista con many=True.
Responder con Response(serializer.data).
Ejemplo de estructura en views.py:
# views.py
from rest_framework.response import Response
from rest_framework.decorators import ApiView
from .serializers import PatientSerializer
from .models import Patient
@ApiView(['get'])
def ListPatients(request):
patients = Patient.objects.all()
serializer = PatientSerializer(patients, many=True)
return Response(serializer.data)
Puntos clave que refuerzan buenas prácticas:
Variables en minúscula: patients, serializer.
many=True indica que el serializer debe procesar cada ítem de la lista.
La clase Response de DRF devuelve un JSON correctamente formateado y puede configurarse para otros formatos como XML.
¿Qué parámetros clave usa el serializer?
Objeto o lista a serializar: el queryset de pacientes.
many=True: esencial cuando se serializa un listado.
Acceso a datos serializados: serializer.data.
¿Para qué sirve el decorador ApiView y el método get?
El decorador ApiView habilita compatibilidad DRF sobre una vista basada en función y permite fijar qué métodos HTTP acepta.
Limitar el endpoint a GET: evita usos no deseados como POST en la misma ruta.
Recibir request aunque no se use aún: prepara futuras mejoras.
DRF añade capacidades extra en la interfaz de exploración: options, get y cambio de formato rápido.
Detalles que facilitan el testeo y lectura:
La interfaz navegable de DRF muestra headers y la estructura del JSON.
Cambiar a solo JSON es posible con el selector de formato (útil para frontend).
Observación importante: las fechas se ven como cadena, aunque en el model de Python sean DateTime.
¿Cómo publicar la URL y probar el endpoint en JSON?
Para usar la vista, crea la ruta en el archivo de URLs y ejecuta el servidor de desarrollo.
# urls.py
from django.urls import path
from patients import views
urlpatterns = [
path('api-patients', views.ListPatients),
]
Ejecución y prueba:
Iniciar el servidor: manage.py runserver.
Visitar la ruta: api-patients.
Verás los campos de todos los pacientes en formato JSON.
Siguientes pasos propuestos:
Crear un endpoint con método POST para registrar un paciente.
Validar la entrada usando el serializer respecto al model.
Reutilizar la lógica de DRF para confirmar que los datos son válidos antes de guardar.
¿Ya implementaste el POST para crear pacientes con validación mediante serializer? Comparte el código en los comentarios y cuéntanos cómo te fue.
Dejo el "POST" para que lo peguen debajo del "GET":
@api_view(["POST"])
def create_patient(request):
serializer = PatientSerializer(data=request.data) # Deserializar los datos enviados por el cliente
if serializer.is_valid(): # Verificar si los datos son válidos
serializer.save() # Guardar el nuevo paciente en la base de datos
return Response(serializer.data, status=status.HTTP_201_CREATED) # Devolver los datos del paciente creado
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) # Si hay errores, devolverlos
Crear un archivo .env que contenga la cadena de conexión, por ejemplo: DATABASE_URL=postgres://usuario:12345678@localhost:5432/doctorapp
Modificar settings.py:
from dotenv import load_dotenv
# Cargar variables de entorno desde el archivo .env
load_dotenv()
# Obtener la cadena de conexión desde la variable de entorno
DATABASE_URL = os.getenv('DATABASE_URL')
DATABASES = {
'default': dj_database_url.config(default=DATABASE_URL)
}
from rest_framework import status
from .serializers import PatientSerializer
from .models import Patient
from rest_framework.decorators import api_view
from rest_framework.response import Response
@api_view(["GET", "POST"])
def list_patients(request):
"""
Retrieve a list of all patients or create a new patient entry.
This view function handles two HTTP methods:
- GET: Returns a list of all patients serialized as JSON.
- POST: Accepts patient data, validates it, and creates a new patient record
if the data is valid.
Args:
request (rest_framework.request.Request): The HTTP request object containing
the method type and, for POST requests, the data to create a new patient.
Returns:
rest_framework.response.Response:
- For GET requests: A Response containing a list of serialized patient data.
- For POST requests:
- If successful: A Response with the created patient data and
HTTP 201 status.
- If validation fails: A Response with error details and HTTP 400 status.
Raises:
None explicitly, but validation errors during POST requests return HTTP 400.
Examples:
Retrieve all patients:
>>> response = client.get('/api/patients/')
>>> response.status_code
200
>>> len(response.data)
5
Create a new patient:
>>> data = {'name': 'John Doe', 'age': 30}
>>> response = client.post('/api/patients/', data)
>>> response.status_code
201
>>> response.data['name']
'John Doe'
"""
if request.method == "GET":
patients = Patient.objects.all()
serializer = PatientSerializer(patients, many=True)
return Response(serializer.data)
elif request.method == "POST":
serializer = PatientSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
from .serializers import PatientSerializer
from .models import Patient
from rest_framework.decorators import api_view
from rest_framework.response import Response
@api_view(["GET"])
def list_patients(request):
patients = Patient.objects.all() # Obtener todos los pacientes
serializer = PatientSerializer(patients, many=True) # Serializar los datos
return Response(serializer.data) # Devolver los datos serializados
El código que compartiste define un endpoint para crear un paciente utilizando la vista basada en funciones de Django REST Framework. A continuación, te explico cada parte:
@api_view(['POST']): Este decorador permite que la función acepte solo solicitudes POST.
serializer = PatientSerializer(data=request.data): Se inicializa el serializador con los datos del request.
if serializer.is_valid(): Valida los datos entrantes. Si son válidos, se procede a guardarlos.
serializer.save(): Guarda el nuevo paciente en la base de datos.
return Response(serializer.data): Devuelve los datos del paciente creado.
else: return Response(serializer.errors): Si la validación falla, retorna los errores.
Asegúrate de definir correctamente la URL para este endpoint y de importar las dependencias necesarias.