Contenido del curso
Creación de APIs con Django REST Framework
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:
serializers.py en la aplicación correspondiente.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
Estudiante
Luis Martinez
ProfesorLuis Martinez
Profesor
Ismael Castillo
Estudiante
Erik Taveras
Estudiante
Adrian Ernesto German Becerra
EstudianteErik Taveras
Estudiante
Bryan Castano
Estudiante
Sebastián Pineda Duque
EstudianteLuis Martinez
Profesor
Roger Alberto Chan Arjona
Estudiante
Roberto Barrientos
Estudiante
Bernar Serrano Rubiano
Estudiante
Miguel Angel Reyes Moreno
Estudiante
Daniel Buitrago
EstudianteDaniel Buitrago
Estudiante
Andres Felipe Ardila
Estudiante
Mario Alberto Hernández Pintor
Estudiante
jesus manuel vergara arias
Estudiante
Erick Salvador Saballos Pérez
EstudianteLuis Martinez
Profesor
kolab Linkear
EstudianteLuis Martinez
Profesor
Darwinson Camilo Jaimes Rodriguez
Estudiante
Gonzalo Gutiérrez Castillo
Estudiante
Robert Yesid Barrios Acendra
Estudianteexcelente 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
Estamos trabajando en ese curso! Muchas gracias por tu comentario
El curso de Django Rest ya está disponible. https://platzi.com/cursos/django-rest-framework/
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).
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
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.
No se si es lo mejor, pero yo antes de cada push solo hago un: ```js pip freeze > requirements.txt
Hola Chicos, Aqui dejo algunos curls commands para que prueben su endpoint '/api/products/':
curl -X POST http://localhost:8000/api/products/ \ -H "Content-Type: application/json" \ -d '{ "name": "Cappuccino", "description": "Creamy cappuccino with espresso", "price": "5.50", "stock": 20, "available": true, "product_image": "https://example.com/cappuccino.jpg", "category": "Espresso" }'
curl http://localhost:8000/api/products/
curl "http://localhost:8000/api/products/?id=1"
curl -X PATCH http://localhost:8000/api/products/ \
-H "Content-Type: application/json" \
-d '{
"id": 1,
"price": "6.00",
"stock": 15
}'
\nRecuerden que deben tener los metodos ya en su classe ProductListAPI, pueden ajustar los campos de acuerdo a com otengan sus productos definidos en ./models.py y db.
¿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?
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.
No se ha podido resolver la importación "rest_framework.views".
Ya instale el paquete
pip install django-rest-framework
Ya agregue en las aplicaciones , el entorno es correcto pero Visual Studio no lo reconoce ni recargando ni nada
Django==4.2.30
Python 3.8
djangorestframework==3.13.1
La version de djangorestframework en este ejemplo no es la 3.15.2?
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)
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"   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")   def form\_valid(self, form): order, \_ = Order.objects.get\_or\_create(is\_active=True, user=self.request.user)   form.instance.order = order form.instance.quantity = 1 form.save() return super().form\_valid(form) class OrderProductListAPI(APIView): authentication\_classes = \[] permission\_classes = \[]   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]   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", ),]
Difference Between Serializers and Models
Importance of Using Serializers in Django
Saludos, qué puedo hacer si al importar ModelSerializer recibo este error: Import "rest_framework.seralizer" could not be resolvedPylance<u>reportMissingImports</u>
A mi me pasó lo mismo, en mi caso el problema fue seleccionar el interprete correcto:
Ctrl + Shift + P en Windows/Linux, Cmd + Shift + P en macOS).Python: Select Interpreter y selecciona el intérprete Python correcto donde tienes instalado Django y djangorestframework.Woe, el profe luis no decepciona, que excelente curso de django.
por favor maestro haga un curso sobre django channels
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!
Pa cuando un cursito que integre DRF con Next😉
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.
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!!!
Al parecer no estas usando el compilador de python de tu venv
¿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).