Creación de APIs con Django REST Framework

Resumen

La separación de la lógica de backend y frontend es una práctica común en el desarrollo de software moderno, con el frontend generalmente escrito en JavaScript y la conexión al backend manejada a través de APIs. Django REST es una librería de Python que facilita la creación de estas APIs, permitiendo una integración eficiente entre frontend y backend.

¿Cómo instalar Django REST Framework?

Para instalar Django REST Framework, utilizamos el siguiente comando:

pip install django-rest-framework

No olvides agregarlo a tu archivo requirements.txt para mantener un registro de las dependencias del proyecto. Además, debes incluirlo en la configuración del proyecto dentro del archivo settings.py en la sección de INSTALLED_APPS:

INSTALLED_APPS = [
    ...
    'rest_framework',
]

¿Cómo configurar un Serializer en Django REST?

Los Serializers en Django REST convierten modelos de Django en JSON. Para crear un nuevo Serializer, sigue estos pasos:

Crea un archivo llamado serializers.py en la aplicación correspondiente.

Importa ModelSerializer desde rest_framework:

from rest_framework import serializers
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = '__all__'

¿Cómo crear una vista en Django REST?

Para crear una vista que devuelva datos en formato JSON:

Crea una vista heredando de APIView:

from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Product
from .serializers import ProductSerializer

class ProductListAPI(APIView):
    def get(self, request):
        products = Product.objects.all()
        serializer = ProductSerializer(products, many=True)
        return Response(serializer.data)

Define la URL para esta vista en urls.py:

from django.urls import path
from .views import ProductListAPI

urlpatterns = [
    ...
    path('api/products/', ProductListAPI.as_view(), name='product-list-api'),
]

¿Cómo manejar permisos y autenticación en Django REST?

Dependiendo de tu caso de uso, puedes configurar permisos y autenticación. Para esta vista, vamos a desactivarlos:

from rest_framework.permissions import AllowAny

class ProductListAPI(APIView):
    permission_classes = [AllowAny]

    def get(self, request):
        products = Product.objects.all()
        serializer = ProductSerializer(products, many=True)
        return Response(serializer.data)

¿Cómo ejecutar y probar tu API?

Una vez configurado todo, puedes ejecutar tu servidor de desarrollo y acceder a la URL de la API para ver los datos en formato JSON:

python manage.py runserver

Luego, visita http://localhost:8000/api/products/ para ver la lista de productos.

Julio Bastidas

student•

excelente curso, seria genial que pronto, mas pronto de lo posible, creen otro para rest framework ya que el standard es la separacion del frontend con el backend

Luis Martinez

teacher•

Estamos trabajando en ese curso! Muchas gracias por tu comentario

Luis Martinez

teacher•

El curso de Django Rest ya está disponible. https://platzi.com/cursos/django-rest-framework/

Ismael Castillo

student•

Buenas. Por aqui anexo mi solución en donde cree todo el crud del api de productos. Tanto los metodos como GET, POST, PATCH y DELETE fueron creados.

class ProductListAPI(APIView):
    authentication_classes = []
    permission_classes = []

    def get(self, request, pk=None, format=None):
        id = pk

        if id is not None:
            try: 
                product_id = Product.objects.get(id=id)
                serializer = ProductSerializer(product_id)
                return Response(serializer.data)
            except Exception as error:
                return Response({'msg': 'Product Was not found'}, 
                    status=status.HTTP_404_NOT_FOUND
                    )
        
        products = Product.objects.all()
        serializer = ProductSerializer(products, many=True)
        return Response(serializer.data)

    def post(self, request, pk=None, format=None):
        serializer = ProductSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response({'msg': 'Product Created'}, 
                            status=status.HTTP_201_CREATED
                            )
        
        return Response(serializer.errors,
                        status=status.HTTP_400_BAD_REQUEST
                        )

    def patch(self, request, pk=None, format=None):
        id = pk
        try: 
            product_id = Product.objects.get(pk=id)
            serializer = ProductSerializer(
                product_id, data=request.data, partial=True)

            if serializer.is_valid():
                serializer.save()
                return Response({'msg': 'Product Updated'}, 
                                status=status.HTTP_201_CREATED
                                )
            
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST
                            )
        except Exception as error:
            return Response({'msg': 'Product Was not found'}, 
                    status=status.HTTP_404_NOT_FOUND
                    )
        

    
    def delete(self, request, pk=None, format=None):
        id = pk
        try: 
            product_id = Product.objects.get(pk=id)
            product_id.delete()
            return Response({'msg': 'Product Deleted'}, 
                                status=status.HTTP_200_OK
                            )
        except Exception as error:
            return Response({'msg': 'Product Was not found'}, 
                    status=status.HTTP_404_NOT_FOUND
                    )
```Tambien tuve que afectar el archivo de URLS de los productos:



```python
from django.contrib import admin
from django.urls import path
from .views import ProductFormView, ProductListView, ProductListAPI

urlpatterns = [
    path('', ProductListView.as_view(), name="products_list"),
    path('agregar/', ProductFormView.as_view(), name="add_product"),
    path('api/', ProductListAPI.as_view(), name="list_product_api_1"),
    path('api/<int:pk>', ProductListAPI.as_view(), name="list_product_api")
]

```y le agregue el id al serializer de producto.



```python
from rest_framework.serializers import ModelSerializer
from .models import Product

class ProductSerializer(ModelSerializer):
    class Meta:
        model = Product
        fields = [
            "id",
            'name',
            'description',
            'price',
            'available',
            'photo'
        ]
        #fields = '__all__'
```Notese que al serialize se le puede agregar el valor \_\_all\_\_ para traerse todos los campos de la bd del modelo (en este caso lo comente para tenerlo como referencia).

Erik Taveras

student•

no se si es lo mejor, pero yo siempre antes de un push solo hago un pip freeze > requirements.txt, asi evito tener pendiente estar pegando y buscando cada uno

Adrian Ernesto German Becerra

student•

Es correcto, pero de este modo se listan todas las dependencias, incluyendo las que no deberían ir a producción y que solamente utilizamos para el desarrollo. También se listan aquellas dependencias que se instalan como requerimiento de otra dependencia y que de igual modo no es necesario listarlas en nuestro archivo de requerimientos.

Erik Taveras

student•

No se si es lo mejor, pero yo antes de cada push solo hago un: ```js pip freeze > requirements.txt

Sebastián Pineda Duque

student•

¿Qué sentido tiene hoy en día usar solo Django sin la librería REST Framework, ya que la tendencia del Backend es tener la responsabilidad de crear una API y no tener lógica de la vista?

Luis Martinez

teacher•

En algunos casos la implementación de una app puede ser más compleja si se requiere tener dos proyectos (El front y el back) en Django tenemos la posibilidad de tener todo en uno solo, esto es útil en algunos proyectos y hay que tener cuidado al usarlo. Si se es organizado se puede dar mucho soporte sin separarlo y si la empresa escala y en el futuro se tiene que dividir en dos proyectos se podría hacer fácil.

Roberto Barrientos

student•

La version de djangorestframework en este ejemplo no es la 3.15.2?

Bernar Serrano Rubiano

student•

Asi quedo mi solución:

@method_decorator(csrf_exempt, name='dispatch')   
class ProductListAPI(APIView):
    authentication_classes = []
    permission_classes = []
    
    def get(self, request):
        products = Product.objects.all()
        serializer = ProductSerializer(products, many=True)
        return Response(serializer.data)
        
    def post(self, request):
        serializer = ProductSerializer(data=request.data)
        
        if serializer.is_valid():
            serializer.save() # Guarda los productos si los datos son validos
            
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
```@method\_decorator(csrf\_exempt, name='dispatch')   class ProductListAPI(APIView):    authentication\_classes = \[]    permission\_classes = \[]        def get(self, request):        products = Product.objects.all()        serializer = ProductSerializer(products, many=True)        return Response(serializer.data)            def post(self, request):        serializer = ProductSerializer(data=request.data)                if serializer.is\_valid():            serializer.save() # Guarda los productos si los datos son validos                        return Response(serializer.data, status=status.HTTP\_201\_CREATED)        return Response(serializer.errors, status=status.HTTP\_400\_BAD\_REQUEST)

Miguel Angel Reyes Moreno

student•

Un poco de ayuda de Chat GPT en la vistas, lo admito...

serializers.py:


from rest\_framework.serializers import ModelSerializerfrom .models import OrderProduct

class OrderProductSerializer(ModelSerializer):    class Meta:        model = OrderProduct        fields = \[            "product",            "quantity",        ]

views.py:


from django.contrib.auth.mixins import LoginRequiredMixinfrom django.urls import reverse\_lazyfrom rest\_framework.views import APIViewfrom rest\_framework.response import Responsefrom rest\_framework.permissions import IsAuthenticatedfrom rest\_framework.authentication import SessionAuthentication, BasicAuthenticationfrom django.views.generic import DetailView, CreateView
from orders.serializers import OrderProductSerializerfrom .forms import OrderProductFormfrom .models import Order, OrderProduct

class MyOrderView(LoginRequiredMixin, DetailView):    model = Order    template\_name = "orders/my\_order.html"    context\_object\_name = "order"
&#x20;   def get\_object(self, queryset=None):        return Order.objects.filter(user=self.request.user, is\_active=True).first()

class CreateOrderProductView(LoginRequiredMixin, CreateView):    template\_name = "orders/create\_order\_product.html"    form\_class = OrderProductForm    success\_url = reverse\_lazy("my\_order")
&#x20;   def form\_valid(self, form):        order, \_ = Order.objects.get\_or\_create(is\_active=True, user=self.request.user)
&#x20;       form.instance.order = order        form.instance.quantity = 1        form.save()        return super().form\_valid(form)

class OrderProductListAPI(APIView):    authentication\_classes = \[]    permission\_classes = \[]
&#x20;   def get(self, request, \*args, \*\*kwargs):        order = Order.objects.filter(            user\_id=self.request.user.id, is\_active=True        ).first()        if order:            order\_products = OrderProduct.objects.filter(order=order)            serializer = OrderProductSerializer(order\_products, many=True)            return Response(serializer.data)        return Response({"detail": "No active order found."}, status=404)

class OrderProductAddAPI(APIView):    authentication\_classes = \[SessionAuthentication, BasicAuthentication]    permission\_classes = \[IsAuthenticated]
&#x20;   def post(self, request, \*args, \*\*kwargs):        order, \_ = Order.objects.get\_or\_create(is\_active=True, user=self.request.user)        serializer = OrderProductSerializer(data=request.data)        if serializer.is\_valid():            serializer.save(order=order)            return Response(serializer.data, status=201)        return Response(serializer.errors, status=400)

urls.py:


from django.urls import pathfrom .views import (    MyOrderView,    CreateOrderProductView,    OrderProductListAPI,    OrderProductAddAPI,)
urlpatterns = \[    path("mi-orden/", MyOrderView.as\_view(), name="my\_order"),    path(        "agregar-orden/",        CreateOrderProductView.as\_view(),        name="add\_order",    ),    path("api/ordenes/", OrderProductListAPI.as\_view(), name="orders\_api"),    path(        "api/agregar-orden/",        OrderProductAddAPI.as\_view(),        name="add\_order\_api",    ),]

Daniel Buitrago

student•

Difference Between Serializers and Models

Purpose:
- Models: Define the structure of the data in the database. They represent the tables in the database and the fields within those tables. Models are used to interact with the database, perform queries, and manage the lifecycle of data records.
- Serializers: Define how data should be converted between complex types (e.g., model instances) and native Python data types (e.g., dictionaries). They are used to validate, transform, and render data for APIs.
Usage:
- Models: Used for database operations such as creating, reading, updating, and deleting records. They are part of the Django ORM and are essential for defining the data schema.
- Serializers: Used for API operations such as validating input data, transforming data into JSON or other formats, and rendering data for HTTP responses. They are part of the Django REST Framework and are essential for building APIs.
Validation:
- Models: Provide basic validation for field types and constraints (e.g., max_length, unique). However, they do not handle complex validation logic.
- Serializers: Provide comprehensive validation for input data, including complex validation logic, nested serializers, and custom validation methods.
Data Transformation:
- Models: Do not handle data transformation for APIs. They represent the data as it is stored in the database.
- Serializers: Handle data transformation for APIs. They convert complex data types into native Python data types and vice versa.

Daniel Buitrago

student•

Importance of Using Serializers in Django

Data Validation:
- Serializers provide a way to validate and sanitize input data. They ensure that the data received from clients (e.g., via HTTP requests) meets the required format and constraints before it is processed or saved to the database.
Data Transformation:
- Serializers convert complex data types, such as querysets and model instances, into native Python data types that can be easily rendered into JSON, XML, or other content types. This transformation is essential for sending data over the network.
Consistency:
- Serializers help maintain consistency in the data format across different parts of the application. They ensure that the data is always in the expected format, making the application more predictable and easier to debug.
Security:
- By validating and sanitizing input data, serializers help prevent common security issues such as SQL injection and cross-site scripting (XSS). They ensure that only valid and safe data is processed by the application.
Reusability:
- Serializers can be reused across different views and endpoints, reducing code duplication and making the application more modular.

Andres Felipe Ardila

student•

Saludos, qué puedo hacer si al importar ModelSerializer recibo este error: Import "rest_framework.seralizer" could not be resolvedPylance<u>reportMissingImports</u>

Mario Alberto Hernández Pintor

student•

A mi me pasó lo mismo, en mi caso el problema fue seleccionar el interprete correcto:

En VSC abre la paleta de comandos (Ctrl + Shift + P en Windows/Linux, Cmd + Shift + P en macOS).
Escribe Python: Select Interpreter y selecciona el intérprete Python correcto donde tienes instalado Django y djangorestframework.

jesus manuel vergara arias

student•

Woe, el profe luis no decepciona, que excelente curso de django.

Erick Salvador Saballos Pérez

student•

por favor maestro haga un curso sobre django channels

Luis Martinez

teacher•

Django Channels es una muy buena libreria para manejor de sockets.

Hoy en dia es más común usar Js o Golang para manejor de sockets, pero tendré en cuenta este comentario!

kolab Linkear

student•

Pa cuando un cursito que integre DRF con Next😉

Luis Martinez

teacher•

Vamos a tener un Curso de Django Rest, para integrarte a una API rest con Next puedes hacer el curso de Next, todas las API se integran igual independientemente de como están construidas.

Darwinson Camilo Jaimes Rodriguez

student•

No he podido usar la libreria de reest_framework, tengo todas las configuraciones iguales, pero no me permite usarlan dice:

No se ha podido resolver la importación "rest_framework.serializers".Pylance<u>reportMissingImports</u>Ver el problema (Alt+F8)Corrección Rápida (Ctrl+.)

help!!!

Gonzalo Gutiérrez Castillo

student•

Al parecer no estas usando el compilador de python de tu venv

Robert Yesid Barrios Acendra

student•

¿Pero ejecutaste antes de hacer la pregunta? porque el Pylance dice eso probablemente porque el intérprete no es el correcto (la versión de python me refiero).