Diseño de una API RESTful para interactuar con la base de datos SQLite

En este capítulo, crearemos vistas de API de Django para requests HTTP y discutiremos cómo Django y Django REST framework procesan cada solicitud HTTP. 

• Creación de vistas de Django
• Enrutamiento de URL a vistas y funciones de Django
• Lanzamiento del servidor de desarrollo de Django
• Realización de requests HTTP mediante la herramienta de línea de comandos
• Hacer requests HTTP con Postman

Creación de vistas de Django

En los capítulos anteriores, ha visto cómo crear un modelo y su serializador. Ahora, veamos cómo procesar requests HTTP y proporcionar respuestas HTTP. Aquí, crearemos vistas de Django para procesar las requests HTTP. Al recibir una solicitud HTTP, Django crea una instancia de HttpRequest y se pasa como primer argumento a la función de vista. Esta instancia contiene información de metadatos que tiene verbos HTTP como GET, POST o PUT. La función de visualización comprueba el valor y ejecuta el código en función del verbo HTTP. Aquí, el código usa el decorador @csrf_exempt para configurar una cookie CSRF (falsificación de solicitud entre sitios). Esto facilita la prueba del código, que no representa un servicio web listo para producción. Entremos en la implementación del código.

from django.http import HttpResponse
from django.views.decorators.csrf import csrf_exempt
from rest_framework.renderers import JSONRenderer
from rest_framework.parsers import JSONParser
from rest_framework import status
from taskmanagement.models import TaskManagement
from taskmanagement.serializers import TaskMngSerializer
  
  
class JSONResponse(HttpResponse):
    def __init__(self, data, **kwargs):
        content = JSONRenderer().render(data)
        kwargs['content_type'] = 'application/json'
        super(JSONResponse, self).__init__(content, **kwargs)
  
@csrf_exempt
def task_list(request):
    if request.method == 'GET':
        task = TaskManagement.objects.all()
        task_serializer = TaskMngSerializer(task, many=True)
        return JSONResponse(task_serializer.data)
  
    elif request.method == 'POST':
        task_data = JSONParser().parse(request)
        task_serializer = TaskMngSerializer(data=task_data)
        if task_serializer.is_valid():
            task_serializer.save()
            return JSONResponse(task_serializer.data, \
                                status=status.HTTP_201_CREATED)
        return JSONResponse(task_serializer.errors, \
                            status = status.HTTP_400_BAD_REQUEST)
              
  
@csrf_exempt
def task_detail(request, pk):
    try:
        task = TaskManagement.objects.get(pk=pk)
    except TaskManagement.DoesNotExist:
        return HttpResponse(status=status.HTTP_404_NOT_FOUND)
  
    if request.method == 'GET':
        task_serializer = TaskMngSerializer(task)
        return JSONResponse(task_serializer.data)
  
    elif request.method == 'PUT':
        task_data = JSONParser().parse(request)
        task_serializer = TaskMngSerializer(task, data=task_data)
        if task_serializer.is_valid():
            task_serializer.save()
            return JSONResponse(task_serializer.data)
        return JSONResponse(task_serializer.errors, \
                            status=status.HTTP_400_BAD_REQUESTS)
  
    elif request.method == 'DELETE':
        task.delete()
        return HttpResponse(status=status.HTTP_204_NO_CONTENT)
         

Evaluemos el código. Aquí tenemos dos funciones.

1. lista de tareas()
2. detalle_tarea()

Nota: Más adelante agregaremos las reglas de seguridad y limitación para nuestro servicio web RESTFul. Y también necesitamos eliminar los códigos repetidos. Ahora el código anterior es necesario para comprender cómo funcionan las cosas básicas.

lista de tareas()

La función task_list() es capaz de procesar dos verbos HTTP: GET y POST . 

Si el verbo es GET , el código recupera todas las instancias de administración de tareas. 

if solicitud.método == ‘OBTENER’:

       tarea = TaskManagement.objects.all()

       task_serializer = TaskMngSerializer(tarea, muchos=Verdadero)

       devolver JSONResponse(task_serializer.data)

• Recupera todas las tareas usando el método TaskManagement.objects.all() ,
• serializa las tareas usando TaskMngSerializer(task, many=True) ,
• los datos generados por TaskMngSerializer se pasan a JSONResponse y
• devuelve la JSONResponse construida.

Nota: El argumento many=True en TaskMngSerializer(task, many=True) especifica que se deben serializar varias instancias.

Si el verbo es POST , el código crea una nueva tarea. Aquí, la nueva tarea se proporciona como datos JSON en el cuerpo de la solicitud HTTP.

elif solicitud.método == ‘POST’:

       task_data = JSONParser().parse(solicitud)

       task_serializer = TaskMngSerializer(data=task_data)

       si task_serializer.is_valid():

           task_serializer.save()

           devolver JSONResponse(task_serializer.data, \

                               estado=estado.HTTP_201_CREATED)

       devolver JSONResponse(task_serializer.errors, \

                           estado = estado.HTTP_400_BAD_REQUEST)

• Utiliza JSONParser para analizar la solicitud,
• Serialice los datos analizados usando TaskMngSerializer,
• Si los datos son válidos, se guardan en la base de datos y
• devuelve la JSONResponse construida (contiene datos y estado HTTP_201_CREATED).

detalle_tarea()

La función task_detail() es capaz de procesar tres verbos HTTP: GET, PUT y DELETE. Aquí, la función recibe la clave principal como argumento y la operación respectiva se realiza en la instancia particular que tiene la misma clave.

Si el verbo es GET, entonces el código recupera una sola tarea basada en la clave. Si el verbo es PUT, el código actualiza la instancia y la guarda en la base de datos. si el verbo es DELETE, el código elimina la instancia de la base de datos, según el valor pk.

Respuesta JSON()

Aparte de las dos funciones explicadas, el código tiene una clase llamada JSONResponse .

clase JSONResponse(HttpResponse):

   def __init__(uno mismo, datos, **kwargs):

       contenido = JSONRenderer().render(datos)

       kwargs[‘content_type’] = ‘aplicación/json’

       super(JSONResponse, self).__init__(contenido, **kwargs)

Representa los datos en JSON y guarda la string de bytes devuelta en la variable local de contenido .

Enrutamiento de URL a vistas y funciones de Django

Ahora, es necesario enrutar las URL para ver. Debe crear un nuevo nombre de archivo de Python urls.py en la carpeta de administración de tareas ( restapi\taskmanagement ) y agregar el siguiente código.

from django.conf.urls import url
from taskmanagement import views
  
urlpatterns = [
    url(r'^taskmanagement/$',views.task_list),
    url(r'^taskmanagement/(?P<pk>[0-9]+)$', views.task_detail),
]

En función de la expresión regular coincidente, las direcciones URL se enrutan a las vistas correspondientes. A continuación, tenemos que reemplazar el código en el archivo urls.py en la carpeta restapi ( restapi\restapi\urls.py ). En la actualidad, tiene las configuraciones de URL raíz. Actualice el archivo urls.py con el siguiente código.

from django.conf.urls import url, include
  
urlpatterns = [
    url(r'^',include('taskmanagement.urls')), 
]

Lanzamiento del servidor de desarrollo de Django

Después de activar el entorno virtual, puede ejecutar el siguiente comando para iniciar el servidor.

python manage.py servidor de ejecución

Compartiendo la captura de pantalla a continuación.

servidor de desarrollo

Realización de requests HTTP mediante la herramienta de línea de comandos

Hagamos uso de las herramientas de línea de comandos que instalamos en el Capítulo 1.

Solicitud HTTP GET

Las requests HTTP GET se utilizan para recuperar los detalles de la tarea de la base de datos. Podemos usar requests GET para recuperar una colección de tareas o una sola tarea. 

Recuperar todos los elementos 

El siguiente comando curl recupera una colección de tareas. 

curl -X GET localhost:8000/taskmanagement/

Producción:

Al ejecutar el comando, Django crea una instancia de HttpRequest y se pasa como primer argumento a la función de vista. Django enruta la URL a la función de visualización adecuada. Aquí las vistas tienen dos métodos, task_list y task_detail. Veamos el patrón de URL, que está configurado en el archivo taskmanagement\urls.py

patrones de URL = [

   url(r’^administración de tareas/$’,vistas.lista_de_tareas),

   url(r’^administración de tareas/(?P<pk>[0-9]+)$’, vistas.tarea_detalle),

]

Aquí la URL ( localhost:8000/taskmanagement/ ) coincide con el patrón de URL para views.task_list. El método task_list se ejecuta y verifica el verbo HTTP. Dado que nuestro verbo HTTP para la solicitud es GET , recupera todas las tareas.

Ejecutemos el comando para recuperar todas las tareas combinando las opciones -i y -X. Aquí, el beneficio es que muestra el encabezado de respuesta HTTP, el estado, el tipo de contenido, etc.

curl -iX GET localhost:8000/taskmanagement/

Producción:

Hasta ahora hemos ejecutado el comando cURL. Ahora veremos el comando de la utilidad HTTPie para redactar y enviar requests HTTP. Para esto, necesitamos acceder al indicador de la utilidad HTTPie instalada en el entorno virtual. Después de activar el entorno virtual, ejecute el siguiente comando.

http :8000/taskmanagement/

El comando envía la solicitud: GET http://localhost:8000/taskmanagement/.

Producción:

Solicitud GET de la utilidad HTTPie: recuperar todas las tareas

Recuperar un solo elemento

Ahora está familiarizado con el comando para recuperar una colección de tareas. A continuación, comprendamos cómo recuperar una tarea en función de una identificación de tarea. Aquí, pasaremos la identificación de la tarea junto con la URL. Dado que la URL tiene un parámetro, Django enruta la URL a la función task_detail. Ejecutemos los comandos.

El comando de la utilidad HTTPie para recuperar una sola tarea.

http :8000/taskmanagement/2

El comando anterior envía la solicitud: GET http://localhost:8000/taskmanagement/2. 

Producción:

Recuperar un solo elemento usando la utilidad HTTPie

El comando curl equivalente de la siguiente manera:

curl -iX GET localhost:8000/taskmanagement/2

Producción:

Intentemos recuperar un elemento que no está en la base de datos.

 http :8000/taskmanagement/5

La salida de la siguiente manera

HTTP/1.1 404 Not Found
Content-Length: 0
Content-Type: text/html; charset=utf-8
Date: Fri, 30 Oct 2020 14:32:46 GMT
Referrer-Policy: same-origin
Server: WSGIServer/0.2 CPython/3.7.5
X-Content-Type-Options: nosniff
X-Frame-Options: DENY

Solicitud HTTP POST

Usamos requests POST para crear una tarea. El comando HTTPUtilityPie para crear una nueva solicitud de la siguiente manera.

http POST :8000/taskmanagement/ task_name=”Documento XYZ” task_desc=”Descripción del documento” categoría=”Escritura” prioridad=”Baja” created_date=”2020-10-30 00:00:00.000000+00:00″ fecha límite=” 2020-11-03 00:00:00.000000+00:00″ estado=”Pendiente” pago_hecho=falso

Aquí la solicitud de URL ( http POST :8000/taskmanagement/ ) coincide con la expresión regular ( taskmanagement/$ ). Por lo tanto, llama a la función task_list y el verbo POST cumple la condición para ejecutar el código para la creación de la tarea. 

Producción:

Solicitud POST usando HTTPUtilityPie

Creemos otra instancia usando el comando curl. El comando curl para la solicitud POST de la siguiente manera

curl -iX POST -H “Content-Type: application/json” -d “{\”task_name\”:\”Task 01\”, \”task_desc\”:\”Desc 01\”, \”category\” :\”Escritura\”, \”prioridad\”:\”Medio\”, \”fecha_de_creación\”:\”2020-10-27 13:02:20.890678\”, \”fecha límite\”:\”2020- 10-29 00:00:00.000000+00:00\”, \”estado\”:\”Completado\”, \”pago_hecho\”: \”verdadero\”}” localhost:8000/administración de tareas/

Producción:

Solicitud POST usando curl

Aquí, los datos necesarios para crear una nueva tarea se especifican después de -d y el uso de -H «Content-Type: application/json» significa que los datos están en formato JSON. 

{

“task_name”:”Task 01″, “task_desc”:”Desc 01″, “category”:”Writing”, “priority”:”Medium”, “created_date”:”2020-10-27 13:02:20.890678″ , “fecha límite”:”2020-10-29 00:00:00.000000+00:00″, “estado”:”Completado”, “pago_hecho”: “verdadero”

}

Solicitud HTTP PUT

Hacemos uso de la solicitud PUT para actualizar una tarea existente. Aquí pasamos la identificación de la tarea que debe actualizarse junto con la URL. Dado que la URL tiene un parámetro, Django envía la instancia de URL a la función task_detail en las vistas. Y ejecuta el código que contiene la condición para el verbo PUT.

El comando de la utilidad HTTPie para actualizar la tarea:

http PUT :8000/taskmanagement/1 task_name=”Intercambiar dos elementos” task_desc=”Escribir un programa de Python para intercambiar dos elementos en una lista” category=”Escritura” prioridad=”Medio” created_date=”2020-10-27 13: 02:20.890678″ fecha límite=”2020-10-29 00:00:00.000000+00:00″ estado=”Completado” pago_hecho=verdadero

Producción:

PONER

El comando CURL equivalente de la siguiente manera

curl -iX PUT -H “Content-Type: application/json” -d “{\”task_name\”:\”Intercambiar dos elementos\”, \”task_desc\”:\”Escribir un programa Python para intercambiar dos elementos en una lista\», \»categoría\»:\»Escritura\», \»prioridad\»:\»Medio\», \»fecha_de_creación\»:\»2020-10-27 13:02:20.890678\», \”plazo\”:\”2020-10-29 00:00:00.000000+00:00\”, \”estado\”:\”Completado\”, \”pago_hecho\”: \”verdadero\”}” localhost:8000/gestión de tareas/1

Solicitud de ELIMINACIÓN HTTP 

La solicitud HTTP DELETE se utiliza para eliminar una tarea en particular de la base de datos. Veamos el comando de la utilidad HTTPie.

http ELIMINAR: 8000/gestión de tareas/4

Producción:

Borrar petición

El comando curl equivalente de la siguiente manera:

curl -iX DELETE localhost:8000/administración de tareas/4

Hacer requests HTTP con Postman

Hasta ahora, aprovechamos las herramientas de línea de comandos para redactar y enviar requests HTTP. Ahora, haremos uso de Postman. El cliente REST de Postman es una herramienta de interfaz gráfica de usuario (GUI) que facilita la redacción y el envío de requests HTTP al servidor de desarrollo de Django. Compongamos y enviemos requests GET y POST.

OBTENER solicitud

Puede seleccionar GET en el menú desplegable, escribir la URL ( localhost:8000/taskmanagement/ ) en el campo URL y presionar el botón Enviar. El cartero mostrará la información en la sección Cuerpo de salida. La siguiente captura de pantalla muestra la respuesta de salida JSON.

Solicitud HTTP GET usando Postman

Puede hacer clic en la pestaña Encabezado para ver los detalles del encabezado. Compartiendo la captura de pantalla a continuación:

Encabezamiento

Solicitud POST

Ahora enviemos una solicitud POST usando la herramienta Postman GUI. Siga los pasos a continuación:

1. Seleccione el verbo POST del menú desplegable,
2. Escriba la URL en el campo URL ( localhost:8000/taskmanagement/ )
3. Seleccione la sección Cuerpo (en la sección de entrada)
4. Verifique el botón de radio sin procesar y también seleccione JSON en el menú desplegable en el lado derecho del botón GraphQL
5. Ingrese las siguientes líneas {“task_name”:”Task 01″, “task_desc”:”Desc 01″, “category”:”Writing”, “priority”:”Medium”, “created_date”:”2020-11-02 13 :02:20.890678″, “fecha límite”:”2020-10-29 00:00:00.000000+00:00″, “estado”:”Completado”, “pago_realizado”: ​​“verdadero”} en el cuerpo (sección de entrada) . y pulsa enviar.

Compartiendo la captura de pantalla a continuación.

Resumen

En este artículo, creamos una vista de la API de Django para que las requests HTTP interactúen con la base de datos SQLite a través del servicio web RESTFul. Trabajamos con verbos HTTP GET, POST, PUT y DELETE. Hemos visto cómo enviar y redactar requests HTTP utilizando herramientas de línea de comandos (curl y HTTPie) y la herramienta GUI (POSTMAN).