POST y GET en el mismo endpoint con Django REST

Clase 7 de 21 • Curso de Django Rest Framework

Resumen

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

student•

Dejo la función PUT:

@api_view(["PUT"])
def update_patient(request, pk):
    try:
        # Look for the patient by their primary key (pk)
        patient = Patient.objects.get(pk=pk)
    except Patient.DoesNotExist:
        # If the patient does not exist, return a 404 error
        return Response({'error': 'Patient not found'}, status=status.HTTP_404_NOT_FOUND)
    
    # Deserialize the incoming request data
    serializer = PatientSerializer(patient, data=request.data)
    
    # Validate the incoming data
    if serializer.is_valid():
        # Save the changes if the data is valid
        serializer.save()
        # Return the updated patient data
        return Response(serializer.data)
    
    # If the data is not valid, return the errors
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Andres Trujillo

student•

Jonathan Mauricio Meza Bastidas

student••

get_object_or_404 para manejar mejor los casos donde el paciente no existe, y evitar que se rompa la aplicación:

Luis Martinez

teacher•

Depende también del caso, puede que no quieras mostrar un 404.

Miguel Salazar Tolentino

student•

¿No es recomendable que cada función tenga una responsabilidad específica? Es una buena práctica tener los métodos GET y POST en una misma función?

Luis Martinez

teacher•

Puesto que django rest abstrae bastante bien la lógica de ambas cosas está bien tenerla en la misma parte, dependiendo de que tan ordenado estes pues "omitir" ciertas reglas, en este caso diria que no se omite porque la unica funcionalidad de ese method es "recibir el request" y enviarlo a procesar en otros metodos internos.

Sebastian Cerquera carvajal

student•

EL codigo del reto: (spoiler, para actualizar el usuario se debe actualizar toda la informacion, esto debido a que todos los campos estan obligatorios en el modelo)

if request.method == 'PUT':
        try:
            patient = Patient.objects.get(id=id)
        except Patient.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)
        
        serializer = PatientSerializer(patient, data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data)
```if request.method == 'PUT':        try:            patient = Patient.objects.get(id=id)        except Patient.DoesNotExist:            return Response(status=status.HTTP\_404\_NOT\_FOUND)                serializer = PatientSerializer(patient, data=request.data)        serializer.is\_valid(raise\_exception=True)        serializer.save()        return Response(serializer.data)

Ronaldo Ricardo Mata Rodriguez

student•

patient_exits = Patient.objects.filter(
  first_name=request.data['first_name'],
  last_name=request.data['last_name'],
  date_of_birth=request.data['date_of_birth']
)

Antonio Demarco Bonino

student•

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

student•

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

Luis Antonio Del Rio Salguero

student•


@api_view(["GET","PUT"])
def detail_patient(request,id):
    if request.method =="GET":
        try:
            patient = Patient.objects.get(id=id)
        except Patient.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)
        serializer = PatientSerializer(patient)
        return Response(serializer.data)
    
    if request.method == "PUT":
        try:
            patient = Patient.objects.get(id = id)
        except Patient.DoesNotExist:
            return Response (status=status.HTTP_404_NOT_FOUND)
        serializer = PatientSerializer(patient, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_200_OK)
        else:
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Implementacion de PUT en el mismo endpoint

José Ángel Arreola González

student•

Ejemplo con manejo de excepción al principio y teniendo mas robusticidad al momento de enviar las responses. 😁✌🏻

@api_view(["GET","PUT","DELETE"])
def patient_detail(request, pk):
    try:
        patient = Patient.objects.get(pk=pk)
    except Patient.DoesNotExist:
        return Response({"error": "Patient not found"}, status=status.HTTP_404_NOT_FOUND)
        
    if request.method == "GET":
        serializer = PatientSerializer(patient)
        return Response(serializer.data)
    elif request.method == "PUT":
        serializer = PatientSerializer(patient, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    elif request.method == "DELETE":
        patient.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

Daniel André Amaya López

student•

César Ernesto Rivas Martínez

student•


@api_view(['GET','PUT'])
def patient_detail_view(request, id):
    if request.method == 'GET':
        patient = Patient.objects.filter(id=id).first()
        if patient is None:
            return Response(status=status.HTTP_404_NOT_FOUND)
        serializer = PatientSerializer(patient)
        return Response(serializer.data)

    if request.method == 'PUT':
        patient = Patient.objects.filter(id=id).first()
        if patient is None:
            return Response(status=status.HTTP_400_BAD_REQUEST)
        serializer = PatientSerializer(patient, data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status=status.HTTP_200_OK)

Edward Rodríguez

student•

Mi solución al reto:@api_view(["GET", "PUT"])def patient(request, pk, format=None): match request.method: case "GET": data = None status = HTTP_200_OK try: patient = Patient.objects.get(id=pk) serializer = PatientSerializer(patient) data = serializer.data except Patient.DoesNotExist: data = {"error": "Patient not found"} status = HTTP_404_NOT_FOUND finally: return Response(data, status=status) case "PUT": data = None status = HTTP_200_OK try: patient = Patient.objects.get(id=pk) serializer = PatientSerializer(patient, data=request.data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() data = serializer.data except Patient.DoesNotExist: data = {"error": "Patient not found"} status = HTTP_404_NOT_FOUND finally: return Response(data, status=status)

@api_view(["GET", "PUT"])
def patient(request, pk, format=None):
    match request.method:
        case "GET":
            data = None
            status = HTTP_200_OK

            try:
                patient = Patient.objects.get(id=pk)
                serializer = PatientSerializer(patient)
                data = serializer.data
            except Patient.DoesNotExist:
                data = {"error": "Patient not found"}
                status = HTTP_404_NOT_FOUND
            finally:
                return Response(data, status=status)

        case "PUT":
            data = None
            status = HTTP_200_OK

            try:
                patient = Patient.objects.get(id=pk)
                serializer = PatientSerializer(patient, data=request.data, partial=True)
                serializer.is_valid(raise_exception=True)
                serializer.save()
                data = serializer.data
            except Patient.DoesNotExist:
                data = {"error": "Patient not found"}
                status = HTTP_404_NOT_FOUND
            finally:
                return Response(data, status=status)

Ronaldo Ricardo Mata Rodriguez

student•

importante si cuando usando el metodo 'PUT' solo le mandan un campo, por ejemplo:patient_serializer = PatientSerializer(patient, data=request.data, partial=True)

{"first_name": "Nuevo Nombre"}
```van a recibir error, porque los serializers de django siempre espera que lleguen todos los campos segun las condiciones en la que se hayan creado sus campos, en este caso similar al Modelo, porque usamos ModelSerializer, asi que para actualizer un atributo o varios de forma parcial deben usar el serializer asi:

```python
patient_serializer = PatientSerializer(patient, data=request.data, partial=True)
```y si sera valido, de caso contrario no lo es.&#x20;

Luis Martinez

teacher•

Gracias por este aporte, demasiado útil el partial True

Ronaldo Ricardo Mata Rodriguez

student•

patient_exits = Patient.objects.filter( first_name=request.data['first_name'], last_name=request.data['last_name'], date_of_birth=request.data['date_of_birth'] ) if patient_exits: return Response({'message': 'Patient already exists'}, status=status.HTTP_400_BAD_REQUEST)

Andres Trujillo

student•

No estoy tan acostumbrado de escribir código así, o por lo menos el backend, si no tener una api por cada operación, pero lo simpliqué a ver como se ve con python, no se nada mal:

@api_view(["GET", "PUT", "DELETE"])
def onePatient(request, id):
    try:
        patient = Patient.objects.get(id=id)
        if request.method == "GET":
            serializer = PatientSerializer(patient)
            return Response(serializer.data, status=status.HTTP_200_OK)
        elif request.method == "PUT":
            serializer = PatientSerializer(patient, data=request.data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            return Response(serializer.data, status=status.HTTP_200_OK)
        elif request.method == "DELETE":
            patient.delete()
            return Response(
                {"message": "Patient deleted"}, status=status.HTTP_204_NO_CONTENT
            )
    except Patient.DoesNotExist:
        return Response(
            {"message": "Patient not found"}, status=status.HTTP_404_NOT_FOUND
        )

Mario Alexander Vargas Celis

student•

PUT

# modificar un paciente
    if request.method == 'PUT':
        try:
            patient = Patient.objects.get(pk=pk)
        except Patient.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)
        serializer = PatientSerializer(patient, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Manuel Galindo

student•

Entre los códigos HTTP más comunes se encuentran el 200 (OK), que indica que la solicitud ha sido exitosa; el 404 (Not Found), que señala que el recurso solicitado no se ha encontrado; el 500 (Internal Server Error), que indica un error en el servidor; el 301 (Moved Permanently), que informa que el recurso ha sido movido de forma permanente a una nueva URL; y el 302 (Found), que señala una redirección temporal.

Estos códigos ayudan a diagnosticar y solucionar problemas en la navegación web, asegurando una experiencia más fluida para los usuarios.

jesus manuel vergara arias

student•

Put:

Jorge Morales

student•

@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, status=status.HTTP_200_OK) elif request.method == "POST": serializer = PatientSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

@api_view(["PUT"])
def update_patient(request, pk):
    try:
        # Look for the patient by their primary key (pk)
        patient = Patient.objects.get(pk=pk)
    except Patient.DoesNotExist:
        # If the patient does not exist, return a 404 error
        return Response({'error': 'Patient not found'}, status=status.HTTP_404_NOT_FOUND)
    
    # Deserialize the incoming request data
    serializer = PatientSerializer(patient, data=request.data)
    
    # Validate the incoming data
    if serializer.is_valid():
        # Save the changes if the data is valid
        serializer.save()
        # Return the updated patient data
        return Response(serializer.data)
    
    # If the data is not valid, return the errors
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

if request.method == 'PUT':
        try:
            patient = Patient.objects.get(id=id)
        except Patient.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)
        
        serializer = PatientSerializer(patient, data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data)
```if request.method == 'PUT':        try:            patient = Patient.objects.get(id=id)        except Patient.DoesNotExist:            return Response(status=status.HTTP\_404\_NOT\_FOUND)                serializer = PatientSerializer(patient, data=request.data)        serializer.is\_valid(raise\_exception=True)        serializer.save()        return Response(serializer.data)

# 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)

@api_view(["GET","PUT"])
def detail_patient(request,id):
    if request.method =="GET":
        try:
            patient = Patient.objects.get(id=id)
        except Patient.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)
        serializer = PatientSerializer(patient)
        return Response(serializer.data)
    
    if request.method == "PUT":
        try:
            patient = Patient.objects.get(id = id)
        except Patient.DoesNotExist:
            return Response (status=status.HTTP_404_NOT_FOUND)
        serializer = PatientSerializer(patient, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_200_OK)
        else:
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

@api_view(["GET","PUT","DELETE"])
def patient_detail(request, pk):
    try:
        patient = Patient.objects.get(pk=pk)
    except Patient.DoesNotExist:
        return Response({"error": "Patient not found"}, status=status.HTTP_404_NOT_FOUND)
        
    if request.method == "GET":
        serializer = PatientSerializer(patient)
        return Response(serializer.data)
    elif request.method == "PUT":
        serializer = PatientSerializer(patient, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    elif request.method == "DELETE":
        patient.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

@api_view(['GET','PUT'])
def patient_detail_view(request, id):
    if request.method == 'GET':
        patient = Patient.objects.filter(id=id).first()
        if patient is None:
            return Response(status=status.HTTP_404_NOT_FOUND)
        serializer = PatientSerializer(patient)
        return Response(serializer.data)

    if request.method == 'PUT':
        patient = Patient.objects.filter(id=id).first()
        if patient is None:
            return Response(status=status.HTTP_400_BAD_REQUEST)
        serializer = PatientSerializer(patient, data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status=status.HTTP_200_OK)

@api_view(["GET", "PUT"])
def patient(request, pk, format=None):
    match request.method:
        case "GET":
            data = None
            status = HTTP_200_OK

            try:
                patient = Patient.objects.get(id=pk)
                serializer = PatientSerializer(patient)
                data = serializer.data
            except Patient.DoesNotExist:
                data = {"error": "Patient not found"}
                status = HTTP_404_NOT_FOUND
            finally:
                return Response(data, status=status)

        case "PUT":
            data = None
            status = HTTP_200_OK

            try:
                patient = Patient.objects.get(id=pk)
                serializer = PatientSerializer(patient, data=request.data, partial=True)
                serializer.is_valid(raise_exception=True)
                serializer.save()
                data = serializer.data
            except Patient.DoesNotExist:
                data = {"error": "Patient not found"}
                status = HTTP_404_NOT_FOUND
            finally:
                return Response(data, status=status)

{"first_name": "Nuevo Nombre"}
```van a recibir error, porque los serializers de django siempre espera que lleguen todos los campos segun las condiciones en la que se hayan creado sus campos, en este caso similar al Modelo, porque usamos ModelSerializer, asi que para actualizer un atributo o varios de forma parcial deben usar el serializer asi:

```python
patient_serializer = PatientSerializer(patient, data=request.data, partial=True)
```y si sera valido, de caso contrario no lo es.&#x20;

@api_view(["GET", "PUT", "DELETE"])
def onePatient(request, id):
    try:
        patient = Patient.objects.get(id=id)
        if request.method == "GET":
            serializer = PatientSerializer(patient)
            return Response(serializer.data, status=status.HTTP_200_OK)
        elif request.method == "PUT":
            serializer = PatientSerializer(patient, data=request.data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            return Response(serializer.data, status=status.HTTP_200_OK)
        elif request.method == "DELETE":
            patient.delete()
            return Response(
                {"message": "Patient deleted"}, status=status.HTTP_204_NO_CONTENT
            )
    except Patient.DoesNotExist:
        return Response(
            {"message": "Patient not found"}, status=status.HTTP_404_NOT_FOUND
        )

# modificar un paciente
    if request.method == 'PUT':
        try:
            patient = Patient.objects.get(pk=pk)
        except Patient.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND)
        serializer = PatientSerializer(patient, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

POST y GET en el mismo endpoint con Django REST

Fundamentos de Django Rest Framework

Django REST Framework para APIs escalables

Qué son las APIs y cómo funcionan

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 en Django Rest con decorador @action

Autenticación y permisos en Django Rest Framework

Validaciones custom en Django Rest Framework

Serializadores Avanzados

Serializadores anidados en Django REST Framework

Serializer_method_field para cálculos en Django REST

Endpoint anidado para agendar citas médicas

Testing y Desempeño

Unit tests con ApiClient en Django REST

Throttling en Django Rest para evitar ataques DOS