Estoy sorprendido de tanto refactor jajaja
Me encanta esto de Django REST Framework
Optimiza tu API con confianza: las vistas genéricas de Django Rest permiten crear una vista de detalle que obtiene, actualiza y elimina un recurso, reduciendo código y errores. Aquí verás cómo pasar de lógica duplicada a una implementación clara y reutilizable.
¿Por qué usar vistas genéricas para el detalle?
Las vistas genéricas permiten obtener el objeto, modificarlo, borrarlo o mostrarlo como JSON sin escribir lógica repetida. En lugar de manejar manualmente el 404 por ID y repetir consultas, se hereda de una clase que ya incluye estas operaciones.
¿Cómo evitar código duplicado con vistas genéricas?
La clave es reemplazar el uso de ApiView por una clase que combine operaciones. En lugar de importar y usar por separado RetrieveApiView, UpdateApiView y DestroyApiView, se utiliza una sola clase que reúne todo: la combinada de retrieve, update y destroy.
# Vista de detalle simplificada (esqueleto) class PacienteDetailView(RetrieveUpdateDestroyApiView): queryset = ... # colección de pacientes. serializer_class = ... # serializador del paciente. # Ya no se implementa get_object ni el 404 manual.
El resultado: el código “sigue funcionando perfectamente” y se eliminan bloques redundantes.
¿Qué diferencia hay entre las clases individuales y la combinada?
¿Qué variables hay que definir al heredar de la clase combinada?
Basta con “volver a definir estas mismas variables” ya usadas en la vista previa, típicamente las que indican la colección de objetos y el serializador. Con eso, no hace falta el código manual para buscar por ID ni devolver 404.
¿Cómo validar desde el navegador que todo funciona?
La verificación es directa: se accede al detalle de un paciente (por ejemplo, el ID 3) y funciona. Aparecen un botón de Delete y un formulario que permite editar; incluso es posible enviar cambios con raw data.
¿Cómo probar GET, PUT y delete desde el detalle?
¿Qué aportan los mensajes de error al front end?
Si envías un dato inválido (por ejemplo, una “fecha de nacimiento” no válida), al guardar se muestran mensajes de error claros. Esto es muy útil para el front end: explica por qué el request falla y qué campo corregir.
¿Qué mejoras aporta el formulario y el raw data?
¿Qué sigue: view sets y nuevos endpoints?
El siguiente paso es usar view sets para agrupar vistas sin repetirse, incluso cuando aún queden “dos líneas” duplicadas. Con el endpoint de pacientes ya listo usando vistas basadas en clases (tras el refactor desde vistas basadas en funciones), llega el momento de crear los endpoints de doctores y citas. Todo el código, muy parecido entre sí, estará disponible en el repositorio de recursos.
¿Por qué usar view sets para agrupar vistas?
¿Te quedaron dudas sobre la migración a vistas genéricas o view sets? Comenta qué parte de tu API quieres simplificar y qué operaciones necesitas incluir.
Optimiza tu API con confianza: las vistas genéricas de Django Rest permiten crear una vista de detalle que obtiene, actualiza y elimina un recurso, reduciendo código y errores. Aquí verás cómo pasar de lógica duplicada a una implementación clara y reutilizable.
Las vistas genéricas permiten obtener el objeto, modificarlo, borrarlo o mostrarlo como JSON sin escribir lógica repetida. En lugar de manejar manualmente el 404 por ID y repetir consultas, se hereda de una clase que ya incluye estas operaciones.
La clave es reemplazar el uso de ApiView por una clase que combine operaciones. En lugar de importar y usar por separado RetrieveApiView, UpdateApiView y DestroyApiView, se utiliza una sola clase que reúne todo: la combinada de retrieve, update y destroy.
# Vista de detalle simplificada (esqueleto)
class PacienteDetailView(RetrieveUpdateDestroyApiView):
queryset = ... # colección de pacientes.
serializer_class = ... # serializador del paciente.
# Ya no se implementa get_object ni el 404 manual.
El resultado: el código “sigue funcionando perfectamente” y se eliminan bloques redundantes.
Basta con “volver a definir estas mismas variables” ya usadas en la vista previa, típicamente las que indican la colección de objetos y el serializador. Con eso, no hace falta el código manual para buscar por ID ni devolver 404.
La verificación es directa: se accede al detalle de un paciente (por ejemplo, el ID 3) y funciona. Aparecen un botón de Delete y un formulario que permite editar; incluso es posible enviar cambios con raw data.
Si envías un dato inválido (por ejemplo, una “fecha de nacimiento” no válida), al guardar se muestran mensajes de error claros. Esto es muy útil para el front end: explica por qué el request falla y qué campo corregir.
El siguiente paso es usar view sets para agrupar vistas sin repetirse, incluso cuando aún queden “dos líneas” duplicadas. Con el endpoint de pacientes ya listo usando vistas basadas en clases (tras el refactor desde vistas basadas en funciones), llega el momento de crear los endpoints de doctores y citas. Todo el código, muy parecido entre sí, estará disponible en el repositorio de recursos.
¿Te quedaron dudas sobre la migración a vistas genéricas o view sets? Comenta qué parte de tu API quieres simplificar y qué operaciones necesitas incluir.
Estoy sorprendido de tanto refactor jajaja
Me encanta esto de Django REST Framework
Si por alguna razon les nace ocupar la palabra id en la url en lugar de pk que tenes que saber que se puede. el profe por defecto ocupa pk como convencion de Django, pero se puede cambiar asi
urlpatterns = [
path('', ListPatientsView.as_view()),
path('<int:id>/', DetailPatientView.as_view()),
]
class DetailPatientView(RetrieveUpdateDestroyAPIView):
allowed_methods = ['GET','PUT','DELETE']
lookup_field = "id"
serializer_class = PatientSerializer
queryset = Patient.objects.all()
Sinceramente muy impresionado con la simplificación que tiene django :)
Como tip: cuando empezamos a usar vistas genericas ya no es necesario declarar los metodos: ["GET", "PUT", "DELETE"]) vienen implicitos.
Hermoso código:
from .serializers import PatientSerializer
from .models import Patient
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
from rest_framework.views import APIView
from rest_framework.generics import (
ListAPIView,
CreateAPIView,
RetrieveUpdateDestroyAPIView,
)
# GET /api/patients => Listar
# POST /api/patients => Crear
# GET /api/patients/<pk>/ => Detalle
# PUT /api/patients/<pk>/ => Modificación
# DELETE /api/patients/<pk>/ => Borrar
class ListPatientsView(ListAPIView, CreateAPIView):
allowed_methods = ['GET', 'POST']
serializer_class = PatientSerializer
queryset = Patient.objects.all()
class DetailPatientView(RetrieveUpdateDestroyAPIView):
allowed_methods = ['GET', 'PUT', 'DELETE']
serializer_class = PatientSerializer
queryset = Patient.objects.all()
Django REST Framework es una maravilla, te ahorra muchas cosas
Ventajas de utilizar vistas genéricas en Django Rest Framework:
class PatientRetrieveUpdateDestroyAPIView(generics.RetrieveUpdateDestroyAPIView):
"""
API endpoint that allows a patient to be retrieved, updated or deleted.
GET: Returns a single patient by ID
PUT: Updates an existing patient
PATCH: Partially updates an existing patient
DELETE: Deletes a patient
"""
queryset = Patient.objects.all()
serializer_class = PatientSerializer
lookup_field = "pk"
Vaya , Yo debo decir que el grado de abstracción en vistas pre-fabricadas "genericas" en DRF es tan talto nivel que ya comienzo a sentirme incomodo "Vago" por solo extender y herdear vistas que ya estan hechas en el framwork por alguien mas de la comunidad. el codigo actual ha sido REFACTOR tantas veces que ya ni se parece al original de Vistas basadas en Funciones.
Yo realmente aprecio la intencion del profesor de mostrar como se hacen esos metodos de vistas uno a uno usando HTTP Methods , eso explica de donde provienen las funciones que ya estan tan abstraidas a un nivel superiro que ni parecen su verdadera codigo .
El Curso esta Genial. El Profe @Luis Explcia Bien como sieMpre.
from rest_framework import viewsets
from rest_framework.response import Response
from rest_framework import status
from .models import Cliente, Reserva, Historial
from .serializers import ClienteSerializer, ReservaSerializer, HistorialSerializer
class ClienteViewSet(viewsets.ModelViewSet):
queryset = Cliente.objects.all()
serializer_class = ClienteSerializer
def retrieve(self, request, pk=None):
"""
Sobrescribe el método retrieve para personalizar la respuesta al obtener un cliente por su pk.
"""
try:
cliente = Cliente.objects.get(pk=pk)
serializer = ClienteSerializer(cliente)
return Response(serializer.data, status=status.HTTP_200_OK)
except Cliente.DoesNotExist:
return Response({"error": "Cliente no encontrado"}, status=status.HTTP_404_NOT_FOUND)
class ReservaViewSet(viewsets.ModelViewSet):
queryset = Reserva.objects.all()
serializer_class = ReservaSerializer
class HistorialViewSet(viewsets.ModelViewSet):
queryset = Historial.objects.all()
serializer_class = HistorialSerializer
```from rest\_framework import viewsetsfrom rest\_framework.response import Responsefrom rest\_framework import statusfrom .models import Cliente, Reserva, Historialfrom .serializers import ClienteSerializer, ReservaSerializer, HistorialSerializer
class ClienteViewSet(viewsets.ModelViewSet): queryset = Cliente.objects.all() serializer\_class = ClienteSerializer
def retrieve(self, request, pk=None): """ Sobrescribe el método retrieve para personalizar la respuesta al obtener un cliente por su pk. """ try: cliente = Cliente.objects.get(pk=pk) serializer = ClienteSerializer(cliente) return Response(serializer.data, status=status.HTTP\_200\_OK) except Cliente.DoesNotExist: return Response({"error": "Cliente no encontrado"}, status=status.HTTP\_404\_NOT\_FOUND)
class ReservaViewSet(viewsets.ModelViewSet): queryset = Reserva.objects.all() serializer\_class = ReservaSerializer
class HistorialViewSet(viewsets.ModelViewSet): queryset = Historial.objects.all() serializer\_class = HistorialSerializer