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().
Esto que les quiero compartir, lo investigue por mi cuenta, pero tambien es una forma valida de poblar las tablas con datos dummy.
paso 1:
pip install django-seed psycopg
paso 2:
agrego la app en mi settings.py
INSTALLED_APPS = [
....
"django_seed",
]
paso 3
si quiero se poblen todas mis tablas creadas en mi app, para este caso uso patients
python manage.py seed patients --number=10
si quiero poblar una tabla especifica de una app especifica
python manage.py seed patients.[nombre de la tabla] --number=10
sobra aclarar que el numero en number=... puede ser el que queramos
la dependencia que instalamos usa nuestros modelos y asi sabe con que datos poblar nuestras tablas.
Dejo el "POST" para que lo peguen debajo del "GET":
@api_view(["POST"])defcreate_patient(request): serializer = PatientSerializer(data=request.data)# Deserializar los datos enviados por el clienteif serializer.is_valid():# Verificar si los datos son válidos serializer.save()# Guardar el nuevo paciente en la base de datosreturn Response(serializer.data, status=status.HTTP_201_CREATED)# Devolver los datos del paciente creadoreturn Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)# Si hay errores, devolverlos
ty
para que funcione los HTTP de los response importar lo siguiente:
from rest_framework import status
```*from* rest\_framework *import* status
Si prefieren usar postgresql, aquí dejo una, guía de como yo lo implemento (es la forma que yo prefiero, mi gusto personal):
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 .envload_dotenv()# Obtener la cadena de conexión desde la variable de entornoDATABASE_URL = os.getenv('DATABASE_URL')DATABASES ={'default': dj_database_url.config(default=DATABASE_URL)}
Finalmente ejecutar la migración:
python manage.py migrate
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"])deflist_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)
Muy buena implementación!
from django.shortcuts import render
from .serializers import PatientSerializers
from rest_framework.response import Response
from rest_framework.decorators import api_view
from rest_framework import status
from .models import Patient
# Create your views here.
@api_view(["GET"])
def list_patients(request):
patients = Patient.objects.all()
# con many hacemos que pueda leer multiples instancias y no solo una
from.serializersimportPatientSerializerfrom.modelsimportPatientfrom rest_framework.decoratorsimportapi_viewfrom rest_framework.responseimportResponse@api_view(["GET"])def list_patients(request): patients =Patient.objects.all() # Obtener todos los pacientes
serializer =PatientSerializer(patients, many=True) # Serializar los datos
returnResponse(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.
se puede agregar el método "POST" a la misma función y crear la lógica de acuerdo al "request.method" que se ejecute.
{"first_name":"Juan","last_name":"Pérez","date_of_birth":"1990-05-21","contact_number":"+521234567890","email":"juan.perez@email.com","address":"Av. Siempre Viva 742, Springfield","medical_history":"Sin antecedentes médicos relevantes."}
un Json valido para probar el POST
Mi implementación, por si a alguien le sirve: 😁✌🏻
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
from.serializers import PatientSerializer
from.models import Patient
@api_view(["GET","POST"])deflist_patients(request):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)
Patient.objects.create(
first_name="Juan",
last_name="Pérez",
date_of_birth="1990-01-01",
contact_number="1234567890",
email="juan.perez@example.com",
address="Calle Falsa 123, Ciudad",
medical_history="Sin antecedentes relevantes"
)
Patient.objects.create(
first_name="María",
last_name="Gómez",
date_of_birth="1985-05-15",
contact_number="0987654321",
email="maria.gomez@example.com",
address="Avenida Siempre Viva 742, Ciudad",
medical_history="Alergia a penicilina"
)
Patient.objects.create(
first_name="Carlos",
last_name="López",
date_of_birth="1978-09-20",
contact_number="1122334455",
email="carlos.lopez@example.com",
address="Calle Principal 456, Ciudad",
medical_history="Hipertensión"
)
Patient.objects.create(
first_name="Ana",
last_name="Martínez",
date_of_birth="1995-12-10",
contact_number="6677889900",
email="ana.martinez@example.com",
address="Boulevard Central 789, Ciudad",
medical_history="Asma"
)
Patient.objects.create(
first_name="Luis",
last_name="Hernández",
date_of_birth="2000-03-25",
contact_number="3344556677",
email="luis.hernandez@example.com",
address="Plaza Mayor 101, Ciudad",
medical_history="Diabetes tipo 2"
)
```**para los que no tienen datos que importar, entren a la shell ORM importen el metodo y utilizen estos comando para crear algunos objetos** 
aqui mi endpoint para crear usuarios:@api_view(['POST'])def create_patient(request): serializer = PatientSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=201) return Response(serializer.errors, status=400)
Un Tip que acabo de aprender: ya que he estado aprendiendo mucho de django, es necesario crear las vistas para poder exponer los modelos serializados, si no se crean las vistas, solo serviran internamente, las vistas permiten que externamente los usuarios puedan interactuar con el modelo usando metodos http.
Antes comenzar a crear la API de post, necesitamos importr @api_view(["POST"])def createPatient(request): 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)status que proviene de rest_framework:
Una ventaja de utilizar vistas basadas en funciones en Django Rest Framework es la simplicidad y claridad que ofrecen al definir la lógica de manejo de solicitudes HTTP. Al utilizar funciones en lugar de clases, el código puede ser más directo y fácil de entender, lo que facilita la implementación y el mantenimiento de la lógica de negocio, especialmente en aplicaciones más pequeñas o con requisitos específicos de personalización.
