Curso de Django Rest Framework
Curso de Django Rest Framework

Fundamentos de Django Rest Framework

1

Creación de APIs con Django REST Framework

2

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

3

Creación de APIs con Django REST Framework

4

Django REST: Funcionalidades y Ventajas al Crear APIs

5

Modelos y Serializadores en Django para DoctorApp

6

Uso de Serializadores en Vistas con Django REST Framework

7

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

8

CRUD de Recursos con Django REST Framework

9

Pruebas de APIs con Postman y Curl

10

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

11

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

12

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

Vistas y Endpoints

13

Uso de Viewsets y Routers en Django REST Framework

14

Creación de acciones personalizadas en Django REST Framework

15

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

16

Validaciones Personalizadas en Serializadores de Django REST Framework

Serializadores Avanzados

17

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

18

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

19

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

Testing y Desempeño

20

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

21

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,

Curso de Django Rest Framework

Curso de Django Rest Framework

Luis Martínez

Luis Martínez

Uso de Serializadores en Vistas con Django REST Framework

6/21
Recursos

Cómo crear una vista basada en funciones que nos permita listar los pacientes en nuestra base de datos utilizando Django REST Framework y serializadores. Además, configuraremos las rutas y endpoints para consumir esta funcionalidad desde el frontend o cualquier cliente que utilice el API.

¿Cómo creamos una vista para listar pacientes utilizando serializadores?

Primero, abrimos nuestro archivo de vistas y realizamos las siguientes importaciones necesarias:

  • Importamos el PatientSerializer desde los serializadores.
  • Traemos el modelo Patient desde el archivo de Modelos.
  • Importamos la clase Response desde Django REST Framework, que nos permitirá devolver datos en formato JSON o XML, entre otros.

Luego, creamos una función llamada ListPatients que será nuestra vista basada en funciones. Esta función hará una consulta a la base de datos para obtener todos los pacientes. Para esto, usamos Patient.objects.all() y guardamos el resultado en una variable.

¿Cómo usamos el serializador para manejar la lista de pacientes?

Una vez que obtenemos los pacientes, necesitamos serializar los datos. Para ello, usamos el PatientSerializer, pero como estamos serializando una lista de objetos, pasamos el parámetro many=True. Esto le indica al serializador que procese múltiples ítems.

La data serializada estará disponible en serializer.data, que será lo que devolvemos en el Response.

¿Cómo agregamos un decorador a nuestra vista?

Para que Django REST Framework reconozca nuestra vista, necesitamos usar el decorador @api_view. Lo importamos desde rest_framework.decorators. Este decorador se configura para que la vista solo acepte peticiones GET. De esta manera, evitamos que se utilicen otros métodos HTTP, como POST, en esta misma URL.

¿Cómo configuramos la URL para la vista?

Abrimos el archivo de configuración de URLs y creamos una nueva ruta. Asociamos el path api-patients con la vista ListPatients, importándola desde el archivo de vistas.

Guardamos todo y ejecutamos el servidor con el comando manage.py runserver.

¿Qué muestra el API cuando accedemos al endpoint?

Al acceder a la URL api-patients, Django REST Framework nos muestra un listado de pacientes en formato JSON. Este listado incluye toda la información de los pacientes almacenados en la base de datos, con campos como nombres, apellidos y fechas. Las fechas aparecen en formato de cadena, aunque en el modelo de Python están como DateTime.

¿Qué reto sigue después de listar pacientes?

El siguiente paso es crear un nuevo endpoint que permita añadir pacientes a través del método POST. El reto será validar que los datos enviados coincidan con las reglas definidas en el modelo, usando nuevamente los serializadores.

Aportes 15

Preguntas 0

Ordenar por:

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

Antonio Demarco Bonino

Antonio Demarco Bonino

Platzi Team

hace 7 meses
Dejo el "POST" para que lo peguen debajo del "GET": ```python @api_view(["POST"]) def create_patient(request): serializer = PatientSerializer(data=request.data) # Deserializar los datos enviados por el cliente if serializer.is_valid(): # Verificar si los datos son válidos serializer.save() # Guardar el nuevo paciente en la base de datos return Response(serializer.data, status=status.HTTP_201_CREATED) # Devolver los datos del paciente creado return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) # Si hay errores, devolverlos ```
Eduard Nicolás Sarmiento Herrera

Eduard Nicolás Sarmiento Herrera

hace 7 meses
Esto que les quiero compartir, lo investigue por mi cuenta, pero tambien es una forma valida de poblar las tablas con datos dummy. paso 1: pip install django-seed psycopg paso 2: agrego la app en mi settings.py INSTALLED\_APPS = \[ .... "django\_seed", ] paso 3 si quiero se poblen todas mis tablas creadas en mi app, para este caso uso patients python manage.py seed patients --number=10 si quiero poblar una tabla especifica de una app especifica python manage.py seed patients.\[nombre de la tabla] --number=10 sobra aclarar que el numero en number=... puede ser el que queramos la dependencia que instalamos usa nuestros modelos y asi sabe con que datos poblar nuestras tablas.
Ronaldo Jiménez

Ronaldo Jiménez

hace 5 meses
Si prefieren usar `postgresql`, aquí dejo una, guía de como yo lo implemento (es la forma que yo prefiero, mi gusto personal): **Instalar dependencias:** `pip install dj-database-url psycopg2 python-dotenv` **Configurar Django (settings.py):** 1. Crear un archivo .`env `que contenga la cadena de conexión, por ejemplo: `DATABASE_URL=postgres://usuario:12345678@localhost:5432/doctorapp` 2. Modificar settings.py: ```python from dotenv import load_dotenv # Cargar variables de entorno desde el archivo .env load_dotenv() # Obtener la cadena de conexión desde la variable de entorno DATABASE_URL = os.getenv('DATABASE_URL') DATABASES = { 'default': dj_database_url.config(default=DATABASE_URL) } ```
Antonio Demarco Bonino

Antonio Demarco Bonino

Platzi Team

hace 7 meses
Dejo el primer "GET" para que lo usen: ```js from .serializers import PatientSerializer from .models import Patient from rest_framework.decorators import api_view from rest_framework.response import Response @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 serializados ```
Jesus Delgado

Jesus Delgado

hace 5 meses
El código que compartiste define un endpoint para crear un paciente utilizando la vista basada en funciones de Django REST Framework. A continuación, te explico cada parte: 1. `@api_view(['POST'])`: Este decorador permite que la función acepte solo solicitudes POST. 2. `serializer = PatientSerializer(data=request.data)`: Se inicializa el serializador con los datos del request. 3. `if serializer.is_valid()`: Valida los datos entrantes. Si son válidos, se procede a guardarlos. 4. `serializer.save()`: Guarda el nuevo paciente en la base de datos. 5. `return Response(serializer.data)`: Devuelve los datos del paciente creado. 6. `else: return Response(serializer.errors)`: Si la validación falla, retorna los errores. Asegúrate de definir correctamente la URL para este endpoint y de importar las dependencias necesarias.
Erik Daniel Garcés Hernández

Erik Daniel Garcés Hernández

hace 7 meses
se puede agregar el método "POST" a la misma función y crear la lógica de acuerdo al "request.method" que se ejecute. `@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)    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)`
Carlos Rodríguez

Carlos Rodríguez

hace 3 meses
Si quieren mejorar como backend en Django y DRF, recomiendo que los endpoints estén docmentados en Swagger, pueden usar este recurso: <https://drf-spectacular.readthedocs.io/en/latest/>
César Ernesto Rivas Martínez

César Ernesto Rivas Martínez

hace 3 meses
```js @api_view(['GET','POST']) def patient_view(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) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=201) return Response(serializer.errors, status=400) ```
Alver Joan perez

Alver Joan perez

hace 5 meses
Un Tip que acabo de aprender: ya que he estado aprendiendo mucho de django, es necesario crear las vistas para poder exponer los modelos serializados, si no se crean las vistas, solo serviran internamente, las vistas permiten que externamente los usuarios puedan interactuar con el modelo usando metodos http.
Andres Trujillo

Andres Trujillo

hace 7 meses
Antes comenzar a crear la API de post, necesitamos importr @api\_view(\["POST"])def createPatient(request): serializer = PatientSerializer(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)`status` que proviene de `rest_framework`: ```js @api_view(["POST"]) def createPatient(request): serializer = PatientSerializer(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) ```
Mario Alexander Vargas Celis

Mario Alexander Vargas Celis

hace 7 meses
**POST** **patients.views.py** ```python from rest_framework import generics class PatientCreateView(generics.CreateAPIView): queryset = Patient.objects.all() serializer_class = PatientSerializer ```**doctorapp** ```python from patients.views import list_patients, PatientCreateView urlpatterns = [ path('admin/', admin.site.urls), path('api/patients', list_patients), path('api/patients/create', PatientCreateView.as_view(), name='patient-create'), ```
LudFox
Una ventaja de utilizar vistas basadas en funciones en Django Rest Framework es la simplicidad y claridad que ofrecen al definir la lógica de manejo de solicitudes HTTP. Al utilizar funciones en lugar de clases, el código puede ser más directo y fácil de entender, lo que facilita la implementación y el mantenimiento de la lógica de negocio, especialmente en aplicaciones más pequeñas o con requisitos específicos de personalización.
jesus manuel vergara arias

jesus manuel vergara arias

hace 7 meses
Post ready: ![](https://static.platzi.com/media/user_upload/code-5f897d1e-5dc8-4298-bd1e-f4a59098f349.jpg) ![](https://static.platzi.com/media/user_upload/Screenshot%202024-09-29%20at%209.18.06PM-df40249f-7bb1-485f-9d19-2a3b2cb16521.jpg)
Carlos Palacios

Carlos Palacios

hace 7 meses
Esta es mi solucion al reto, agregue una validacion de first error donde la idea es validar que si hay un error en el serializer lo retorno inmenditamente en caso contratio sigo con el flujo normal ![](https://static.platzi.com/media/user_upload/image-36c62721-f8d4-4284-8b66-b71cfcbd2862.jpg)
kolab
Así es como lo resolví: ![](https://static.platzi.com/media/user_upload/image-7d2fbf47-7bab-4cc7-a8ea-da8487ed3887.jpg)