Serializadores Anidados en Django Rest Framework

Curso de Django Rest Framework

Fundamentos de Django Rest Framework

Creación de APIs con Django REST Framework

APIs y JSON: Comunicación entre Servidores y Aplicaciones Web

Creación de APIs con Django REST Framework

Django REST: Funcionalidades y Ventajas al Crear APIs

Modelos y Serializadores en Django para DoctorApp

Uso de Serializadores en Vistas con Django REST Framework

Creación y modificación de pacientes en API REST con Django

CRUD de Recursos con Django REST Framework

Pruebas de APIs con Postman y Curl

Refactorización de Vistas: De Funciones a Clases en Django REST

Vistas Genéricas en Django: Detalle, Actualización y Eliminación

Documentación de APIs con DRF Spectacular y Swagger en Django

Vistas y Endpoints

Uso de Viewsets y Routers en Django REST Framework

Creación de acciones personalizadas en Django REST Framework

Autenticación y Autorización en APIs con Django REST Framework

Validaciones Personalizadas en Serializadores de Django REST Framework

Serializadores Avanzados

Serializadores Anidados en Django: Implementación y Uso Práctico

Cálculo de Edad y Experiencia con Serializer Method Field en Django REST

Creación y Gestión de Endpoints para Citas Médicas en Django REST

Testing y Desempeño

Pruebas Unitarias en Django: Validación de API con API Client Test

Limitación de Solicitudes en APIs con Django REST

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

Los serializadores anidados permiten incluir datos de otros modelos directamente en un serializador, lo que resulta útil al necesitar información relacionada en un solo response. En esta clase, aplicamos esta técnica para incluir una lista de citas médicas dentro del recurso de pacientes en la aplicación DoctorApp. Esto mejora la eficiencia en el manejo de relaciones entre modelos, y facilita cambios futuros en la estructura de los response de la API.

¿Cómo implementar un serializador anidado en Django?

Crea un nuevo campo dentro del serializador principal.
Importa el serializador del modelo que deseas anidar.
Define el campo con el serializador importado y marca como Read Only si es necesario.
Asegúrate de incluir el nuevo campo en la lista de fields del serializador para que se refleje en el response.

¿Cómo anidar citas dentro del serializador de pacientes?

Para incluir las citas médicas de un paciente, sigue estos pasos:

Abre el serializador de pacientes.
Agrega un nuevo campo llamado appointments que usará el AppointmentsSerializer.
Importa el serializador de citas médicas desde su respectivo módulo (Bookings.Serializers).
Configura el campo con many=True y read_only=True, ya que es una lista de citas que solo puede ser visualizada.
Verifica que el campo se ha agregado correctamente al incluirlo en la lista de campos del serializador.

¿Cómo validar la implementación?

Ejecuta el servidor de desarrollo con manage.py runserver.
Accede al recurso Patients en la API y revisa si aparece el campo appointments.
En caso de que falte algún campo, como el ID, asegúrate de incluirlo en el serializador.

¿Cómo crear y visualizar citas en la consola?

Para crear una cita desde la consola de comandos:

Abre la consola con manage.py shell.
Importa los modelos relevantes (Paciente, Doctor, Appointment).
Define variables para el paciente y el doctor.
Crea una nueva cita usando el manager de appointments.
Recarga la página para verificar que el array de citas ya contiene información en formato JSON.

¿Cómo usar serializadores anidados para otros modelos?

El uso de serializadores anidados no se limita a las citas de los pacientes. Puedes replicar este mismo enfoque para otros recursos. Por ejemplo, podrías crear un serializador para listar las citas asociadas a un doctor, proporcionando una mayor flexibilidad a la API y haciendo que las relaciones entre modelos sean más visibles y accesibles.

Aportes 6

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Antonio Demarco Bonino

Platzi Team

hace 7 meses

Prueben este serializador del doctor: ```js from rest_framework import serializers from .models import Doctor, Department, DoctorAvailability, MedicalNote from bookings.serializers import AppointmentSerializer class DoctorSerializer(serializers.ModelSerializer): department = DepartmentSerializer(read_only=True) # Anidamos el serializador de Department availabilities = DoctorAvailabilitySerializer(many=True, read_only=True) # Disponibilidad del doctor (anidado) notes = MedicalNoteSerializer(many=True, read_only=True) # Notas médicas del doctor (anidado) appointments = AppointmentSerializer(many=True, read_only=True) # Citas del doctor (relación con citas) class Meta: model = Doctor fields = [ 'id', 'first_name', 'last_name', 'qualification', 'contact_number', 'email', 'address', 'biography', 'department', 'availabilities', 'notes', 'appointments' ] ```

Luis Arellano Velasco

hace 6 meses

Un serializador en Django REST Framework es una herramienta que convierte instancias de modelos en formatos JSON o XML para que puedan ser fácilmente transmitidos a través de una API. Los serializadores permiten definir qué campos se incluirán en la respuesta y cómo se representarán, facilitando la interacción con los datos de la aplicación.

Luis Reyes

hace 2 meses

Aquí van las líneas de código que ingresa a la consola: ````python from datetime import date, time from doctors.models import Doctor from patients.models import Patient from bookings.models import Appointment patient = Patient.objects.get(id=1) doctor = Doctor.objects.first() Appointment.objects.create( patient=patient, doctor=doctor, appointment_date=date(2022, 12, 5), appointment_time=time(9, 0), notes="Ejemplo", status="HECHA" ) ```from datetime import date, timefrom doctors.models import Doctorfrom patients.models import Patientfrom bookings.models import Appointment patient = Patient.objects.get(id=1)doctor = Doctor.objects.first() Appointment.objects.create( patient=patient, doctor=doctor, appointment\_date=date(2022, 12, 5), appointment\_time=time(9, 0), notes="Ejemplo", status="HECHA") ````

César Ernesto Rivas Martínez

hace 3 meses

NOTA: por convention django ocupa los campos ***<u>"related\_name"</u>*** que se declaran en los modelos para manejar las relaciones (en nuestro caso appointments), si ustedes quisiese llamar de otra forma a appointments tendrian que hacer algo asi ```js class Appointment(Model): patient = models.ForeignKey(Patient, related_name='appointments', on_delete=models.CASCADE) ``` ```python class PatientSerializer(ModelSerializer): citas = AppointmentSerializer(many=True, read_only=True, source='appointments') class Meta: model = Patient fields = [ "id", "first_name", "last_name", "date_of_birth", "contact_number", "email", "address", "medical_history", 'citas' ] ```

Christian Kevin Rojas Rojas

hace 4 meses

Algo que solucionó mi problema que no podía visualizar los appointments en la API, es que deben poner el mismo nombre que tienen en su related\_name dentro de su modelo en booking.models en la clase Appointment

JUAN ALEJANDRO PEREZ BERMUDEZ

hace 4 meses

Algo muy importante a destacar es que el nombre del parámetro `appoimnets` dentro del `PatientSerializer` no es arbitrario, pues se relaciona con el `related_name` definido en el modelo de `Appoimnet`. Eso fue algo confuso cuando traté de replicar estos conceptos en otro proyecto, así que quería compartirlo por si alguien mas tenía esa misma duda.