Introducción
Si has seguido nuestra serie sobre desarrollo con Django, habrás creado con éxito una aplicación que permite a los usuarios con privilegios de administrador añadir comentarios y publicaciones a través del panel de control de la interfaz de administración de Django. También has configurado la persistencia de datos mediante los modelos de solución de Mapeo Relacional de Objetos de Django y MySQL.
En este tutorial, crearemos vistas de Django que permiten a nuestra aplicación web gestionar correctamente las solicitudes web y devolver las respuestas web requeridas. Como se define en la documentación de Django, una respuesta web puede ser el contenido HTML de una página web, una redirección o un error HTTP (por ejemplo, 404). El código de las funciones de vista puede existir técnicamente en cualquier parte del proyecto, siempre que se encuentre en la ruta de Python. Sin embargo, existen algunas convenciones comunes para nombrar y ubicar el archivo que contiene estas funciones de vista, y seguiremos estos pasos.
Una vez que haya completado los pasos de este tutorial, su sitio de blog de Django extraerá una publicación reciente a su IP o URL de dominio/publicación.
Requisitos previos
Este tutorial es parte de la serie Desarrollo Django y es una continuación de esa serie.
Si no ha estado siguiendo esta serie, hacemos las siguientes suposiciones:
- Ha instalado Django versión 4 o superior.
- Ha conectado su aplicación Django a una base de datos.
- Estás trabajando con un sistema operativo basado en Unix, preferiblemente un servidor en nube Ubuntu 22.04, ya que este es el sistema en el que hemos realizado pruebas.
- Has configurado tu interfaz de administración de Django.
Dado que esta guía trata principalmente sobre las vistas de Django, es posible que puedas seguirla incluso si tienes una configuración diferente.
Paso 1 – Crear funciones de visualización
En tu terminal, primero deberás navegar al directorio correspondiente y activar tu entorno virtual de Python. Si has seguido esta serie, puedes introducir los siguientes comandos. Es importante usar siempre el entorno de programación de Python al desarrollar tu aplicación para asegurar que tu código esté contenido y funcione con la configuración correcta.
cd ~/my_blog_app
. env/bin/activateAhora que su entorno virtual está habilitado, vayamos al directorio del blog del sitio, donde abriremos un archivo Python y crearemos nuestra primera función de vista.
cd ~/my_blog_app/blog/blogsiteAbra el archivo views.py para editarlo usando nano o el editor de texto de su elección.
nano views.pyDespués de abrir el archivo, debería llenarse con un código similar a este:
from django.shortcuts import render
# Create your views here.Mantenemos la declaración de importación que importa la función render() de la biblioteca django.shortcuts. Esta función nos permite combinar una plantilla y un texto para devolver el objeto HttpResponse adecuado. Tenga esto en cuenta, ya que con cada vista que escribimos, somos responsables de instanciar, rellenar y devolver el objeto HttpResponse.
A continuación, agregaremos nuestra primera vista que da la bienvenida a los usuarios a la página de inicio. Importaremos la función HttpResponse() de la biblioteca http de Django. Con esta función, enviaremos el texto que se mostrará al solicitar la página web.
from django.shortcuts import render
from django.http import HttpResponse
def index(request):
return HttpResponse('Hello, welcome to the index page.')Después de eso, agregamos otra función que muestra las publicaciones individuales que vamos a crear más adelante en el tutorial.
...
def individual_post(request):
return HttpResponse('Hi, this is where an individual post will be.')Nuestro archivo views.py final ahora se verá así.
from django.http import HttpResponse
from django.shortcuts import render
def index(request):
return HttpResponse('Hello, welcome to the index page.')
def individual_post(request):
return HttpResponse('Hi, this is where an individual post will be.')Cuando termines de editar el archivo, asegúrate de guardarlo y salir. En nano, puedes presionar CTRL y X, luego Y y luego ENTER.
Actualmente, no hay una URL específica a la que apunten estas funciones, por lo que debemos agregarla al bloque de patrones de URL en nuestro archivo de configuración de URL. Con las vistas agregadas, asignaremos las URL a ellas mediante este archivo de configuración para poder ver las páginas que hemos creado.
Paso 2: Mostrar URLs a las vistas
Con Django, podemos diseñar nuestras propias URL para usarlas en nuestra aplicación. Esto se hace en Python puro mediante un archivo comúnmente conocido como URLconf o archivo de configuración de URL.
Para mostrar una página web, Django primero debe determinar el módulo URLconf raíz que se usará y luego buscar patrones de URL, una estructura de datos de lista que contiene todos los patrones de URL. Django itera entonces sobre cada patrón de URL hasta encontrar la primera coincidencia. Cuando encuentra una coincidencia, Django busca la vista asociada, y esa función de vista recibe los datos del patrón de URL y un objeto HttpRequest. Si se produce un fallo en cualquier punto de este proceso, se muestra una vista de gestión de errores.
En esta sección, trabajaremos con dos archivos urls.py diferentes en dos directorios diferentes de nuestra aplicación.
Una vez en el directorio ~/my_blog_app/blog/blogsite, abre el archivo urls.py (también conocido como archivo URLconf) para editarlo. Usaremos nano para editarlo.
nano urls.pyModifique el archivo para que se parezca al archivo siguiente con una lista de patrones de URL.
from django.urls import path
from . import views
urlpatterns = [
path('', views.index, name='index'),
path('post/', views.individual_post, name='individual_post')
]Una vez que haya terminado de agregar las líneas anteriores, guarde y cierre el archivo.
Al actualizar el archivo URLconf del directorio del blog, lo colocamos en dicho directorio o no será reconocido. Esto es necesario porque está configurado como ROOT_URLCONF en nuestro archivo de configuración. Esto significa que Django buscará patrones de URL en el directorio del blog.
Para incluir la URLconf de tu blog en la URLconf de tu blog, debes ir a ese directorio.
cd ~/my_blog_app/blog/blogUna vez allí, puedes abrir el archivo URLconf con nano u otro editor de texto de tu elección.
nano urls.pyEn este archivo, agregamos las siguientes líneas para incluir el archivo /blogsite/urls.py con el que acabamos de trabajar, que se muestra en la segunda línea.
from django.contrib import admin
from django.urls import include, path
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('blogsite.urls'))
]Guarde y cierre el archivo.
Ahora abramos un navegador web para acceder a las URL que creamos y verificar que muestren el texto que añadimos a las vistas. Necesitamos ir al directorio principal para acceder al archivo manager.py que proporciona la aplicación Django.
cd ..Ejecute el siguiente comando. Puede reemplazar 0.0.0.0 con su dirección IP.
python manage.py runserver 0.0.0.0:8000En su navegador web, vaya a su dirección IP, puerto 8000:
your-server-ip:8000Obtendrás una página web similar a la siguiente:
Luego vaya a la siguiente dirección:
your-server-ip:8000/post/
Desde aquí se debería mostrar la siguiente página web:
Ahora que hemos verificado que los dos archivos urls.py funcionan y los datos nos muestran exactamente lo que esperamos, agreguemos algunos datos reales a nuestro blog.
Paso 3 – Crear una entrada de blog
Ahora que comprende los conceptos básicos de cómo funcionan los patrones y las vistas de URL, agreguemos una publicación de blog y muestremosla en una página web en lugar del texto que hemos codificado en archivos de Python.
Crearemos una publicación a través de la página de administración que configuramos anteriormente. Mientras su servidor esté sirviendo la aplicación Django, use un navegador web para acceder a la página de administración del blog en la siguiente dirección:
your-server-ip:8000/admin/blogsite/En la interfaz, haga clic en el enlace + Agregar ubicado en la fila Publicaciones para completar la base de datos con una publicación de blog de muestra.
Al hacer clic en el enlace, obtendrá un formulario de entrada como el que se muestra a continuación:
Siempre que quieras añadir una publicación, accede a esta página. También puedes editarla con el enlace "Editar".
En el formulario puedes editar los siguientes campos:
- Título:Agregue aquí el título de la publicación de blog que desee, por ejemplo, Mi primera publicación de blog.
- SLUG: Se refiere a la parte de la URL que identifica una dirección web válida con palabras clave legibles. Generalmente se toma del título de la página, por lo que en este caso podemos usar "mi-primera-entrada-de-blog".
- CONTENIDO: Este es el texto de tu entrada de blog. Solo añadiremos "¡Hola, mundo!" para este ejemplo, pero aquí puedes añadir más texto.
- AUTOR: Añade tu nombre o nombre de usuario aquí. Usaremos Sami.
Complete el formulario de publicación del blog como considere oportuno para sus fines de prueba.
Una vez que haya añadido los datos de muestra a la página, haga clic en el botón GUARDAR. Aparecerá la siguiente página de confirmación:
¡Felicidades! ¡Has creado tu primera entrada de blog!
A continuación, verifiquemos que se ha agregado una fila a la base de datos MySQL que contiene los datos que acabamos de ingresar en la interfaz de administración.
Paso 4: Visualización de datos de la base de datos
En este punto, necesitamos acceder a MySQL. Para detener el proceso del servidor actual desde la terminal, presione Ctrl + C y abra el intérprete de MySQL. El usuario para la base de datos de nuestra aplicación Django es djangouser, pero asegúrese de usar el usuario adecuado para su proyecto.
mysql -u djangouserUna vez que esté en el indicador de MySQL, navegue a la base de datos blog_data (o cualquier base de datos que sea apropiada para su proyecto):
use blog_data;A continuación, muestra el contenido de la tabla blogsite_post.
select * from blogsite_post;Obtendrá un resultado similar al que se muestra a continuación, que debería mostrar la información que agregó a la interfaz de administración.
Output
+----+--------------------+--------------------+---------------+----------------------------+--------+
| id | title | slug | content | created_on | author |
+----+--------------------+--------------------+---------------+----------------------------+--------+
| 1 | My First Blog Post | my-first-blog-post | Hello, World! | 2020-05-14 00:30:03.186564 | Sammy |
+----+--------------------+--------------------+---------------+----------------------------+--------+
1 row in set (0.00 sec)Como se muestra en la salida, hay una fila con los datos de la publicación que añadimos. Ahora, referenciaremos estos datos a la función de vista de publicaciones. Use Ctrl + D para salir del intérprete de MySQL.
Navegue a la ubicación del archivo views.py dentro de la aplicación de blog de su sitio.
cd ~/my_blog_app/blog/blogsiteAhora abra el archivo para que podamos agregar nuestra nueva información.
nano views.pyEdite el archivo como se muestra a continuación.
from django.shortcuts import render
from django.http import HttpResponse
from .models import Post
def index(request):
return HttpResponse('Hello, welcome to the index page.')
def individual_post(request):
recent_post = Post.objects.get(id__exact=1)
return HttpResponse(recent_post.title + ': ' + recent_post.content)En el código anterior, añadimos una declaración de importación adicional para Post. También eliminamos la cadena entre comillas de HttpResponse y la reemplazamos con los datos de nuestra entrada de blog. Para referenciar los datos de un objeto específico, usamos el ID de la entrada de blog asociado al objeto que queremos mostrar y lo almacenamos en una variable llamada last_post. Podemos recuperar campos específicos de ese objeto añadiendo un punto como separador.
Después de guardar y cerrar el archivo, navegue a la ubicación del archivo manager.py para ejecutar la aplicación Django.
cd ~/my_blog_app/blog
python manage.py runserver 0.0.0.0:8000Desde un navegador web, vaya a la siguiente dirección:
your-server-ip:8000/post/
Aquí veremos los cambios que hemos realizado. La página se verá similar a esta, mostrando el texto que añadiste a la publicación.
Cuando haya terminado de inspeccionar la página, presione CTRL + C en la terminal para detener el proceso de ejecución.
Para deshabilitar su entorno de desarrollo, puede escribir el comando deshabilitar y luego cerrar sesión en el servidor.
Resultado
En este tutorial hemos creado vistas, mapeado patrones de URL y mostrado texto en una página web desde nuestra base de datos de publicaciones de blog.
El siguiente tutorial explicará cómo crear una plantilla de Django más atractiva usando HTML. Hasta ahora, esta serie ha abordado los modelos y las vistas de Django. Las plantillas son el último elemento importante en la base de una aplicación Django.
