CRUD completo con PUT y DELETE en 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:006:06

CRUD completo con PUT y DELETE en Django Rest

Curso de Django Rest Framework

Clase 8 de 21

Clase 8 / 21

Recursos

Aprende a completar el CRUD de un recurso en Django Rest con una sola URL de detalle. Aquí verás cómo estructurar endpoints para listar, crear, modificar y borrar Patients, usando serializers, validación, códigos de estado y respuestas en JSON de forma clara y consistente.

CRUD de Patients con una sola URL

En lugar de crear múltiples rutas, se reutiliza la misma vista Detail Patient con la URL de detalle que incluye el ID del paciente. Así, la búsqueda del objeto y el manejo de errores se centralizan y se evita duplicar código.

¿Cómo se aprovecha una única vista con endpoints GET, PUT y DELETE?

Reutilizar la misma URL: Patients/<id>.
Centralizar la consulta del paciente y responder 404 si no existe.
Si el método es GET: devolver el paciente serializado.
Si el método es PUT: actualizar el paciente con validación.
Si el método es DELETE: borrar el registro y responder sin contenido.

¿Qué lógica común evita duplicación y errores?

Extraer la búsqueda del paciente al inicio de la vista.
Retornar 404 not found de forma consistente.
En función del método, ejecutar solo la acción necesaria.

Actualización con put y validación

Para modificar un paciente con PUT, se inicializa el serializer con dos fuentes: la instancia existente y los datos entrantes del usuario. Esto permite aplicar reglas de validación y luego guardar los cambios en base de datos de manera segura.

¿Cómo se configura el serializer para modificar?

Inicializar con la instancia: el paciente recuperado por ID.
Pasar los datos del cliente: request.data como data del serializer.
Validar con serializer.is_valid con raise exception para mostrar errores.
Guardar con serializer.save para persistir en el modelo (ModelSerializer).

¿Qué respuestas devuelve la actualización?

Confirmar la modificación con status 201 y el objeto actualizado.
Ver cambios reflejados al recargar, confirmando escritura en base de datos.
Mantener respuestas en JSON para consistencia del endpoint.

Borrado con delete y respuestas

Una vez habilitado el método DELETE, incluso la interfaz navegable de Django Rest muestra el botón Delete. La acción se realiza directamente sobre el modelo y la API responde de forma clara, indicando que no hay contenido que devolver.

¿Cómo se ejecuta el borrado desde el modelo?

Detectar el método DELETE en la vista de detalle.
Llamar a delete sobre la instancia recuperada.
No es necesario usar el serializer para esta acción.

¿Qué respuesta envía el API al borrar?

Retornar status 204 no content tras el borrado.
Si se consulta de nuevo el recurso: responder 404 not found.

¿Qué habilidades y conceptos aplicas aquí?

Diseño de endpoints REST con una sola URL de detalle.
Manejo de métodos HTTP: GET, POST, PUT, DELETE.
Validación con serializers: instancia existente + request.data.
Persistencia con serializer.save en ModelSerializer.
Códigos de estado: 404 para inexistente, 201 para modificación, 204 para borrado.
Respuestas en JSON y pruebas en el navegador.

¿Quieres seguir practicando? replica la misma estructura con Doctores y cuenta cómo te fue.

@api_view(["DELETE"])
def delete_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)
    
    # Delete the patient
    patient.delete()
    # Return a success message
    return Response({'message': 'Patient successfully deleted'}, status=status.HTTP_204_NO_CONTENT)

from django.urls import path

from .views import patients, onePatient

urlpatterns = [
    path("patients/", patients),
    path("patients/<int:id>", onePatient),
]
``````js
@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
        )

from django.contrib import admin
from django.urls import path, include


urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/", include("patients.urls")),
    path("api/", include("doctors.urls")),
]

```2. `urls.py` module doctors:

```js
from django.urls import path

from .views import doctors, oneDoctor

urlpatterns = [
    path("doctors/", doctors),
    path("doctor/<int:id>", oneDoctor),
]

```3. `views.py` doctor:

```js
from .serializers import DoctorSerializer
from .models import Doctor

from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status


@api_view(["GET", "POST"])
def doctors(request):
    if request.method == "GET":
        doctors = Doctor.objects.all()
        serializer = DoctorSerializer(doctors, many=True)
        return Response(serializer.data)
    elif request.method == "POST":
        serializer = DoctorSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)


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

from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
from .serializers import DoctorSerializer
from .models import Doctor


@api_view(["GET", "POST"])
def doctor_list(request):
    if request.method == "GET":
        doctors = Doctor.objects.all()
        serializer = DoctorSerializer(doctors, many=True)
        return Response(serializer.data)
    elif request.method == "POST":
        serializer = DoctorSerializer(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)
    
@api_view(["GET","PUT","DELETE"])
def doctor_detail(request, pk):
    try:
        doctor = Doctor.objects.get(pk=pk)
    except Doctor.DoesNotExist:
        return Response({"error": "Doctor not found"}, status=status.HTTP_404_NOT_FOUND)
        
    if request.method == "GET":
        serializer = DoctorSerializer(doctor)
        return Response(serializer.data)
    elif request.method == "PUT":
        serializer = DoctorSerializer(doctor, 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":
        doctor.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/", include('patients.urls')),
    path("api/", include('doctors.urls')),
]

from django.shortcuts import render

from .serializers import DoctorSerializer
from .models import Doctor

from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status

# GET /api/doctors => Listar
# POST /api/doctors => Crear
# GET /api/doctors/<pk>/ => Detalle
# PUT /api/doctors/<pk>/ => Modificación
# DELETE /api/doctors/<pk>/ => Modificación

@api_view(['GET', 'POST'])
def list_doctors(request):
    if request.method == 'GET':
        doctors = Doctor.objects.all()
        serializer = DoctorSerializer(doctors, many=True)
        return Response(serializer.data)

    if request.method == 'POST':
        serializer = DoctorSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(status=status.HTTP_201_CREATED)

@api_view(['GET', 'PUT', 'DELETE'])       
def detail_doctor(request, pk):
    try:
        doctor = Doctor.objects.get(id=pk)
    except Doctor.DoesNotExist:
        return Response({'error': 'El doctor no existe'},status=status.HTTP_404_NOT_FOUND)
    
    if request.method == 'GET':
        serializer = DoctorSerializer(doctor)
        return Response(serializer.data)
    
    if request.method == 'PUT':
        serializer = DoctorSerializer(doctor, data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)

    if request.method == 'DELETE':
        doctor.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

from django.contrib import admin
from django.urls import path, include

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

Resumen

CRUD de Patients con una sola URL

¿Cómo se aprovecha una única vista con endpoints GET, PUT y DELETE?

Reutilizar la misma URL: Patients/<id>.
Centralizar la consulta del paciente y responder 404 si no existe.
Si el método es GET: devolver el paciente serializado.
Si el método es PUT: actualizar el paciente con validación.
Si el método es DELETE: borrar el registro y responder sin contenido.

¿Qué lógica común evita duplicación y errores?

Extraer la búsqueda del paciente al inicio de la vista.
Retornar 404 not found de forma consistente.
En función del método, ejecutar solo la acción necesaria.

Actualización con put y validación

¿Cómo se configura el serializer para modificar?

Inicializar con la instancia: el paciente recuperado por ID.
Pasar los datos del cliente: request.data como data del serializer.
Validar con serializer.is_valid con raise exception para mostrar errores.
Guardar con serializer.save para persistir en el modelo (ModelSerializer).

¿Qué respuestas devuelve la actualización?

Confirmar la modificación con status 201 y el objeto actualizado.
Ver cambios reflejados al recargar, confirmando escritura en base de datos.
Mantener respuestas en JSON para consistencia del endpoint.

Borrado con delete y respuestas

¿Cómo se ejecuta el borrado desde el modelo?

Detectar el método DELETE en la vista de detalle.
Llamar a delete sobre la instancia recuperada.
No es necesario usar el serializer para esta acción.

¿Qué respuesta envía el API al borrar?

Retornar status 204 no content tras el borrado.
Si se consulta de nuevo el recurso: responder 404 not found.

¿Qué habilidades y conceptos aplicas aquí?

Diseño de endpoints REST con una sola URL de detalle.
Manejo de métodos HTTP: GET, POST, PUT, DELETE.
Validación con serializers: instancia existente + request.data.
Persistencia con serializer.save en ModelSerializer.
Códigos de estado: 404 para inexistente, 201 para modificación, 204 para borrado.
Respuestas en JSON y pruebas en el navegador.

¿Quieres seguir practicando? replica la misma estructura con Doctores y cuenta cómo te fue.

from django.contrib import admin
from django.urls import path, include


urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/", include("patients.urls")),
    path("api/", include("doctors.urls")),
]

```2. `urls.py` module doctors:

```js
from django.urls import path

from .views import doctors, oneDoctor

urlpatterns = [
    path("doctors/", doctors),
    path("doctor/<int:id>", oneDoctor),
]

```3. `views.py` doctor:

```js
from .serializers import DoctorSerializer
from .models import Doctor

from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status


@api_view(["GET", "POST"])
def doctors(request):
    if request.method == "GET":
        doctors = Doctor.objects.all()
        serializer = DoctorSerializer(doctors, many=True)
        return Response(serializer.data)
    elif request.method == "POST":
        serializer = DoctorSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)


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

from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
from .serializers import DoctorSerializer
from .models import Doctor


@api_view(["GET", "POST"])
def doctor_list(request):
    if request.method == "GET":
        doctors = Doctor.objects.all()
        serializer = DoctorSerializer(doctors, many=True)
        return Response(serializer.data)
    elif request.method == "POST":
        serializer = DoctorSerializer(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)
    
@api_view(["GET","PUT","DELETE"])
def doctor_detail(request, pk):
    try:
        doctor = Doctor.objects.get(pk=pk)
    except Doctor.DoesNotExist:
        return Response({"error": "Doctor not found"}, status=status.HTTP_404_NOT_FOUND)
        
    if request.method == "GET":
        serializer = DoctorSerializer(doctor)
        return Response(serializer.data)
    elif request.method == "PUT":
        serializer = DoctorSerializer(doctor, 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":
        doctor.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/", include('patients.urls')),
    path("api/", include('doctors.urls')),
]

from django.shortcuts import render

from .serializers import DoctorSerializer
from .models import Doctor

from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status

# GET /api/doctors => Listar
# POST /api/doctors => Crear
# GET /api/doctors/<pk>/ => Detalle
# PUT /api/doctors/<pk>/ => Modificación
# DELETE /api/doctors/<pk>/ => Modificación

@api_view(['GET', 'POST'])
def list_doctors(request):
    if request.method == 'GET':
        doctors = Doctor.objects.all()
        serializer = DoctorSerializer(doctors, many=True)
        return Response(serializer.data)

    if request.method == 'POST':
        serializer = DoctorSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(status=status.HTTP_201_CREATED)

@api_view(['GET', 'PUT', 'DELETE'])       
def detail_doctor(request, pk):
    try:
        doctor = Doctor.objects.get(id=pk)
    except Doctor.DoesNotExist:
        return Response({'error': 'El doctor no existe'},status=status.HTTP_404_NOT_FOUND)
    
    if request.method == 'GET':
        serializer = DoctorSerializer(doctor)
        return Response(serializer.data)
    
    if request.method == 'PUT':
        serializer = DoctorSerializer(doctor, data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)

    if request.method == 'DELETE':
        doctor.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

from django.contrib import admin
from django.urls import path, include

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

Germán Salina

Hace 2 años

¿Por qué usamos Vistas Basadas en Funciones en Django Rest Framework y no basadas en clases?

¿PROS y CONTRAS?

Christopher Andrés Guano Valencia

Hace 2 años

🟢Vistas Basadas en Funciones (FBV)

Pros:

Simplicidad: Más fácil de entender y seguir para vistas simples.
Menor sobrecarga: Menos configuración y sin necesidad de herencia.
Flexibilidad: Lógica de vista más directa y explícita.
Facilidad de pruebas: Se pueden probar directamente como funciones.

Contras:

Reutilización limitada: Dificultad para reutilizar lógica de vista entre diferentes vistas.
Organización: Puede volverse desorganizado con lógica compleja o muchas funciones.
Menos funcionalidad: Carece de las características avanzadas de las CBV.

🔵Vistas basadas en clases CBV

Pros:

Reutilización: Facilitan la reutilización y extensión de la lógica.
Organización: Mejor estructura para vistas más complejas.
Funcionalidades integradas: Proporcionan características como mixins y métodos de respuesta.

Contras:

Complejidad: Pueden ser más complicadas y difíciles de entender para principiantes.
Sobrecarga: Mayor configuración y uso de recursos por la orientación a objetos.

La elección depende del contexto y la complejidad de la aplicación y del problema a resolver.

Espero haberte ayudado. ¡Nunca pares de aprender! 🚀🚀

Germán Salina

Hace 2 años

Muchas Gracias Christopher!

Comentarios (6)6 comentarios

Antonio Demarco Bonino

Acá dejo un "DELETE" para que lo prueben a su gusto, recuerden que nada está escrito en piedra y que este código es perfectamente modificable:

Andres Trujillo

uh great

así lo he dejado yo:

mi aporte:

urls.py doctorsapp:

José Ángel Arreola González

Hace 9 meses•editado

Mi aporte, espero le sirva a alguno! 😁✌🏻

doctors/views.py

doctors/urls.py

from django.urls import path
from doctors.views import doctor_list, doctor_detail

urlpatterns = [
    path("doctors/", doctor_list),
    path("doctors/<str:pk>/", doctor_detail),
]

doctorapp/urls.py

Mario Alexander Vargas Celis

REST de doctors

views.py

urls.py

from django.urls import path

from doctors.views import list_doctors, detail_doctor

urlpatterns = [
    path('doctors/', list_doctors),
    path('doctors/<int:pk>/', detail_doctor)    
]

doctorsapp urls.py

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

CRUD completo con PUT y DELETE en Django Rest

Progreso del curso

Fundamentos de Django Rest Framework

Vistas y Endpoints

Serializadores Avanzados

Testing y Desempeño

Recursos

Recursos