POST y GET en el mismo endpoint con Django REST

Contenido del curso

Fundamentos de Django Rest Framework

Vistas y Endpoints

Serializadores Avanzados

Testing y Desempeño

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0019:08

POST y GET en el mismo endpoint con Django REST

Curso de Django Rest Framework

Clase 7 de 21

Clase 7 / 21

Recursos

Optimiza tu API en Django REST Framework con un endpoint que lista y crea pacientes en la misma URL, valida datos con serializadores y responde con códigos HTTP claros como 201 Created y 404 Not Found. Aprende a usar la variable request, el atributo method y a estructurar URLs por aplicación con include y parámetros int:pk.

¿Cómo crear y listar pacientes en un endpoint REST con GET y POST?

Un mismo recurso puede listar con GET y crear con POST usando la misma ruta. La clave está en leer request.method y aplicar un condicional por método para ejecutar la lógica correcta.

¿Qué hace la misma URL según el método?

En GET: se consulta la base de datos y se serializa con many=True.
En POST: se recibe request.data y se intenta crear un paciente.
La variable request expone el atributo method para decidir la acción.

¿Cómo validar y guardar con el serializador?

Se instancia el serializador con el parámetro data=request.data.
Se valida con isValid (en DRF se usa con excepciones para manejar errores automáticamente).
Si es válido, se guarda con serializer.save() como si fuera un ModelSerializer.

@api_view(['GET', 'POST'])
def list_patients(request):
    if request.method == 'GET':
        patients = Patient.objects.all()
        serializer = PatientSerializer(patients, many=True)
        return Response(serializer.data)
    if request.method == 'POST':
        serializer = PatientSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)  # raisedException en la explicación.
        serializer.save()
        return Response(status=status.HTTP_201_CREATED)

¿Qué responder al crear con HTTP 201 created?

Se puede retornar sin body y comunicar éxito solo con status=HTTP_201_CREATED.
Los campos de solo lectura (como id) no se toman del body: el backend asigna el valor.

¿Cómo manejar errores y validaciones con serializadores y códigos HTTP?

Validar entradas del usuario es crítico. Un dato inválido (por ejemplo, una fecha con formato incorrecto) no debe causar un 500, sino una respuesta JSON con errores de campo.

¿Qué pasa con datos inválidos y raisedException?

Al usar raisedException en la validación, DRF captura los errores y los formatea en JSON.
El cliente recibe el detalle del campo y el formato esperado, evitando caídas del servidor.

¿Por qué eliminar el if tras las excepciones?

Si se lanza una excepción de validación, el flujo se detiene.
Por eso, se puede omitir el if “si es válido” y dejar la secuencia: validar → guardar → responder.

¿Cómo implementar detalle y rutas en Django con include y parámetros?

Para el detalle, el mismo recurso admite ver con GET y modificar con PUT (el reto propuesto). Es necesario capturar el pk desde la URL y manejar el caso de un paciente inexistente.

¿Cómo obtener un paciente o responder 404 not found?

Intentar con get y capturar la excepción Patient.DoesNotExist.
Si no existe, retornar 404 Not Found.

@api_view(['GET', 'PUT'])
def detail_patient(request, pk):
    try:
        patient = Patient.objects.get(id=pk)
    except Patient.DoesNotExist:
        return Response(status=status.HTTP_404_NOT_FOUND)

    if request.method == 'GET':
        serializer = PatientSerializer(patient)
        return Response(serializer.data)

    if request.method == 'PUT':
        # Reto: implementar la modificación del paciente.
        pass

¿Cómo estructurar las URLs por aplicación con include y parámetros?

Crear un archivo urls.py en la app de pacientes.
En las URLs globales, usar include para incorporar las rutas de la app.
Capturar el parámetro con int:pk.

# project/urls.py
from django.urls import path, include

urlpatterns = [
    path('api/', include('patients.urls')),
]

# patients/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('patients/', views.list_patients),
    path('patients/<int:pk>/', views.detail_patient),
]

¿Qué tener en cuenta con el slash final y los 404 engañosos?

La consistencia del slash importa: una barra final mal definida puede confundirse con parte del pk y provocar 404.
Ajusta los patrones de ruta para que el pk no incluya el slash.

¿Te animas a completar el PUT para modificar un paciente? Comparte tu enfoque y decisiones en los comentarios.

Antonio Demarco Bonino

Hace 2 años

Este código me quedó cómodo pero prueben ustedes qué les parece:

# Importaciones necesarias
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
from .models import Patient  # Importar el modelo Patient
from .serializers import PatientSerializer  # Importar el serializer del modelo

# 1. Método GET: Obtener todos los pacientes
@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 en formato JSON

# 2. Método POST: Crear un nuevo paciente
@api_view(["POST"])
def create_patient(request):
    serializer = PatientSerializer(data=request.data)  # Deserializar los datos del cliente
    if serializer.is_valid():  # Validar los datos
        serializer.save()  # Guardar el nuevo paciente
        return Response(serializer.data, status=status.HTTP_201_CREATED)  # Respuesta exitosa
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)  # Devolver errores si los datos no son válidos

# 3. Método PUT: Actualizar un paciente existente
@api_view(["PUT"])
def update_patient(request, pk):
    try:
        patient = Patient.objects.get(pk=pk)  # Obtener el paciente por su ID (pk)
    except Patient.DoesNotExist:
        return Response({'error': 'Paciente no encontrado'}, status=status.HTTP_404_NOT_FOUND)
    
    serializer = PatientSerializer(patient, data=request.data)  # Deserializar y actualizar con los nuevos datos
    if serializer.is_valid():
        serializer.save()  # Guardar los cambios
        return Response(serializer.data)  # Respuesta con los datos actualizados
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)  # Devolver errores si los datos no son válidos

# 4. Método DELETE: Eliminar un paciente
@api_view(["DELETE"])
def delete_patient(request, pk):
    try:
        patient = Patient.objects.get(pk=pk)  # Obtener el paciente por su ID (pk)
    except Patient.DoesNotExist:
        return Response({'error': 'Paciente no encontrado'}, status=status.HTTP_404_NOT_FOUND)
    
    patient.delete()  # Eliminar el paciente
    return Response({'message': 'Paciente eliminado correctamente'}, status=status.HTTP_204_NO_CONTENT)

Jose Dimas Jimenez Moya

Hace 2 años

hola fernando y como te quedaron las urls ? tengo la duda si una urlpattern puede soportar multiples views creo que no, saludos; tambien me gusta separar cada metodo http en su propia vista

Comentarios (19)19 comentarios

Andres Trujillo

Jonathan Mauricio Meza Bastidas

Hace un año•editado

Luis Martinez

Profesor

Hace un año

Miguel Salazar Tolentino

Sebastian Cerquera carvajal

Ronaldo Ricardo Mata Rodriguez

Osmar Botello

Hace 7 meses•editado

Luis Antonio Del Rio Salguero

Hace 9 meses

José Ángel Arreola González

Daniel André Amaya López

César Ernesto Rivas Martínez

Edward Rodríguez

Mario Alexander Vargas Celis

Manuel Galindo

jesus manuel vergara arias

Jorge Morales

Fundamentos de Django Rest Framework

Django REST Framework para APIs escalables

Qué es una API REST y cómo usar JSON

Configuración de Django REST Framework paso a paso

Django Rest: qué reutiliza de Django

Serializers Django: modelos a JSON fácil

Listado de pacientes con serializers en DRF

POST y GET en el mismo endpoint con Django REST

CRUD completo con PUT y DELETE en Django Rest

Cómo probar APIs con Postman y curl

Django Rest Framework: de funciones a vistas genéricas

Vistas genéricas en Django Rest Framework

Documentación automática de APIs con drf-spectacular

Vistas y Endpoints

ViewSets vs APIView: refactor automático de URLs

Acciones personalizadas en ViewSets REST

Autenticación y permisos en Django Rest Framework

Validaciones custom en Django Rest Framework

Serializadores Avanzados

Serializadores anidados en Django REST Framework

Calcular campos dinámicos con SerializerMethodField

Endpoint anidado para citas en Django REST

Testing y Desempeño

Tests de API con APIClient en Django

Throttling en Django Rest para evitar ataques DOS

POST y GET en el mismo endpoint con Django REST

Progreso del curso

Fundamentos de Django Rest Framework

Vistas y Endpoints

Serializadores Avanzados

Testing y Desempeño

Recursos

Recursos