API REST de Django – CRUD con DRF

Django REST Framework se utiliza para crear API web de manera muy fácil y eficiente. Este es un envoltorio sobre Django Framework. Hay tres etapas antes de crear una API a través del marco REST, convertir los datos de un modelo a formato JSON/XML (serialización), representar estos datos en la vista, crear una URL para mapear al conjunto de vistas.

En este tutorial, analizaremos las operaciones CRUD utilizando la API REST de Django. Se supone que está familiarizado con los conceptos básicos de Django: tutorial de Django .

¿Qué vamos a construir?

Para este tutorial, crearemos API REST simples para aplicaciones de supermercados. Esta tienda contiene una variedad de alimentos, bebidas y productos para el hogar, organizados en varias categorías. Estas categorías tienen subcategorías y las subcategorías tienen elementos debajo de ellas. Cada artículo tiene un precio por el cual se puede vender. Ahora deberíamos poder agregar, actualizar, ver y eliminar dichos registros de nuestra base de datos utilizando las API de DRF.

Supongamos que tiene Django configurado e instalado en su sistema. En caso de que no tenga ninguna configuración, consulte los siguientes artículos: 

• Introducción e instalación de Django
• ¿Cómo crear un proyecto básico usando MVT en Django?
• ¿Cómo crear una aplicación en Django?

¿Cómo instalar Django REST Framework?

Para instalar Django REST Framework en Windows, Linux o cualquier sistema operativo, se necesitaría el paquete pip. Para verificar cómo instalar pip en su sistema operativo, consulte – Instalación de PIP – Windows || linux _

Ahora, ejecute un comando simple,

pip install djangorestframework

Después de instalar el marco REST, vaya a settings.py y en INSTALLED_APPS agregue ‘ rest_framework ‘ en la parte inferior. 

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
      
]

Para obtener más información, consulte nuestro artículo Django REST Framework Installation .

Crear aplicación

Después de instalar el DRF y agregarlo a settings.py, creemos una aplicación usando el comando: 

python manage.py startapp api

Ya se habría registrado una carpeta con el nombre api. 

Agreguemos esta aplicación a INSTALLED_APPS y urls.py también.

En, configuración.py, 

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'api.apps.ApiConfig',
  
]

Ahora, agregue URL de API en urls.py. En GFG_REST.urls.py, 

from django.contrib import admin
from django.urls import path, include
  
urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('api.urls')),
]

Ahora vamos a crear urls.py en nuestra carpeta api –

En api/urls.py

from django.urls import path
  
urlpatterns = [
      
]

Crear modelo

Ahora vamos a crear nuestro modelo . Crearemos un modelo de artículo. Este modelo será utilizado por API para realizar las operaciones CRUD. 

from django.db import models
  
class Item(models.Model):
    category = models.CharField(max_length=255)
    subcatgeory = models.CharField(max_length=255)
    name = models.CharField(max_length=255)
    amount = models.PositiveIntegerField()
  
    def __str__(self) -> str:
        return self.name

Ahora, después de que nuestra aplicación esté lista, creemos el serializador para nuestra clase Item.

Publicación por entregas

Los serializadores en Django REST Framework convierten los objetos en tipos de datos que son comprensibles para javascript y marcos front-end. Los serializadores también brindan deserialización, lo que permite que los datos analizados se vuelvan a convertir en tipos complejos, después de validar primero los datos entrantes. Los dos principales serializadores que se utilizan con más frecuencia son ModelSerializer e HyperLinkedModelSerialzer .

Para este tutorial, usaremos el ModelSerializer . Si desea obtener más información sobre cómo crear serializadores manualmente, consulte los siguientes artículos: 

• Serializadores – Django REST Framework
• HyperlinkedModelSerializer en serializadores – Django REST Framework

ModelSerializerModelSerializer

ModelSerializer es una capa de abstracción sobre el serializador predeterminado que permite crear rápidamente un serializador para un modelo en Django. Proporciona un acceso directo que le permite crear automáticamente una clase de serializador con campos que corresponden a los campos del modelo. La clase ModelSerializer es la misma que una clase Serializer regular, excepto que:

• Generará automáticamente un conjunto de campos para usted, según el modelo.
• Generará automáticamente validadores para el serializador, como validadores únicos_juntos.
• Incluye implementaciones predeterminadas simples de .create() y .update().

Ahora creemos nuestro archivo serlializers.py en la carpeta api y agreguemos el siguiente código: 

from django.db.models import fields
from rest_framework import serializers
from .models import Item
  
class ItemSerializer(serializers.ModelSerializer):
    class Meta:
        model = Item
        fields = ('category', 'subcatgeory', 'name', 'amount')

Crear la vista

Para procesar datos en la interfaz y manejar las requests del usuario, necesitamos crear una vista. En Django REST Framework, llamamos a estos conjuntos de vistas, así que vamos a crear una vista en apis/views.py,

from rest_framework.decorators import api_view
from rest_framework.response import Response
from .models import Item
from .serializers import ItemSerializer
  
@api_view(['GET'])
def ApiOverview(request):
    api_urls = {
        'all_items': '/',
        'Search by Category': '/?category=category_name',
        'Search by Subcategory': '/?subcategory=category_name',
        'Add': '/create',
        'Update': '/update/pk',
        'Delete': '/item/pk/delete'
    }
  
    return Response(api_urls)

En el código anterior, el decorador api_view toma una lista de métodos HTTP a los que una vista debe responder. Otros métodos responderán con el método no permitido.

Ahora actualicemos nuestro archivo api/urls.py – 

from django.urls import path
from . import views
  
urlpatterns = [
    path('', views.ApiOverview, name='home')
]

Ahora desactivemos nuestro servidor. Ejecute los siguientes comandos – 

python manage.py makemigrations
python manage.py migrate
python manage.py runserver

Ahora dirígete a http://127.0.0.1:8000/api/

Ahora implementemos nuestras operaciones CRUD a través de nuestra API.

Django Rest Framework – Crear vista

Ahora nuestra vista de creación utilizará el método POST para insertar datos en nuestra base de datos. Vamos a crear nuestra función add_items en el archivo views.py.

from rest_framework import serializers
from rest_framework import status
  
@api_view(['POST'])
def add_items(request):
    item = ItemSerializer(data=request.data)
  
    # validating for already existing data
    if Item.objects.filter(**request.data).exists():
        raise serializers.ValidationError('This data already exists')
  
    if item.is_valid():
        item.save()
        return Response(item.data)
    else:
        return Response(status=status.HTTP_404_NOT_FOUND)

Ahora actualicemos nuestro archivo urls.py y agreguemos el punto final para la función de creación de vista que acabamos de crear.

from django.urls import path
from . import views
  
urlpatterns = [
    path('', views.ApiOverview, name='home'),
    path('create/', views.add_items, name='add-items'),
]

Visite http://127.0.0.1:8000/api/create/

Django Rest Framework – Vista de lista

Ahora nuestra vista de lista utilizará el método GET para recuperar datos de nuestra base de datos. Vamos a crear nuestra función view_items en el archivo views.py. Esta función view_items mostrará todos los datos o datos filtrados consultados por el usuario según la categoría, subcategoría o nombre.

En vistas.py

@api_view(['GET'])
def view_items(request):
    
    # checking for the parameters from the URL
    if request.query_params:
        items = Item.objects.filter(**request.query_param.dict())
    else:
        items = Item.objects.all()
  
    # if there is something in items else raise error
    if items:
        data = ItemSerializer(items)
        return Response(data)
    else:
        return Response(status=status.HTTP_404_NOT_FOUND)

En urls.py

from django.urls import path
from . import views
  
urlpatterns = [
    path('', views.ApiOverview, name='home'),
    path('create/', views.add_items, name='add-items'),
    path('all/', views.view_items, name='view_items'),
  
]

Ahora visite http://127.0.0.1:8000/api/all/

Esta función de vista también nos permite filtrar por categoría o subcategoría. Puede usar cualquiera de las siguientes URL, es decir, http://127.0.0.1:8000/api/?category=category_name o http://127.0.0.1:8000/api/?subcategory=category_name para filtrar por categoría y subcategoría respectivamente . También puede usar http://127.0.0.1:8000/api/all/?name=item_name para buscar un elemento específico.

Si visitamos http://127.0.0.1:8000/api/all/?category=food nuestro resultado de búsqueda se reducirá a: 

Django Rest Framework – Vista de actualización

Ahora, para nuestra función de vista de actualización, usaremos el método POST. Vamos a crear nuestra función update_items en el archivo views.py. Esta función de vista actualizará un elemento particular de la base de datos. Filtrará el elemento con la ayuda de la clave principal.

En vistas.py

@api_view(['POST'])
def update_items(request, pk):
    item = Item.objects.get(pk=pk)
    data = ItemSerializer(instance=item, data=request.data)
  
    if data.is_valid():
        data.save()
        return Response(data.data)
    else:
        return Response(status=status.HTTP_404_NOT_FOUND)

En urls.py

from django.urls import path
from . import views
  
urlpatterns = [
    path('', views.ApiOverview, name='home'),
    path('create/', views.add_items, name='add-items'),
    path('all/', views.view_items, name='view_items'),
    path('update/<int:pk>/', views.update_items, name='update-items'),
  
]

Ahora dirígete a http://127.0.0.1:8000/api/all/?name=potato

Django Rest Framework – Eliminar vista

Para nuestra función de vista de borrado usaremos el método DELETE. Vamos a crear nuestra función delete_items en el archivo views.py. Esta función de visualización eliminará un elemento en particular de la base de datos.

En vistas.py

@api_view(['DELETE'])
def delete_items(request, pk):
    item = get_object_or_404(Item, pk=pk)
    item.delete()
    return Response(status=status.HTTP_202_ACCEPTED)

En urls.py

from django.urls import path
from . import views
  
urlpatterns = [
    path('', views.ApiOverview, name='home'),
    path('create/', views.add_items, name='add-items'),
    path('all/', views.view_items, name='view_items'),
    path('update/<int:pk>/', views.update_items, name='update-items'),
    path('item/<int:pk>/delete/', views.delete_items, name='delete-items'),
      
]

Ahora visite http://127.0.0.1:8000/api/item/pk/delete/. Vea el siguiente GIF para una mejor comprensión.