Site is under maintenance mode. Please wait few min!
Saltar al contenido

Cómo crear y ejecutar trabajos programados con Node.js

marzo 4, 2020

 

Introducción

Si has seguido junto con nuestras series de desarrollo de Django, usted ha creado con éxito una aplicación Django que permite a los usuarios con privilegios de administrador para añadir comentarios y mensajes , a través de la interfaz de usuario de administración tablero de Django. También ha configurado persistencia de los datos mediante el aprovechamiento de MySQL y solución de mapeo objeto-relacional de Django modelos .

En este tutorial, creará Django ve que permiten a nuestra aplicación web para manejar adecuadamente las peticiones web y devolver las respuestas requeridas web. Tal 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 de HTTP (por ejemplo 404). El código para las funciones de vista en cualquier lugar puede técnicamente vivo en los proyectos, siempre y cuando está en su camino de Python. Sin embargo, hay algunas convenciones populares para nombrar y colocar el archivo en el que existen estas funciones de vista, y que van a seguir estas prácticas.

Una vez que haya terminado de pasar por los pasos de este tutorial, su sitio de blogs Django tirar de un post reciente en el su-o-dominio IP / URL posterior.

Requisitos previos

Este tutorial es parte de la serie de desarrollo de Django. Con el fin de completar la configuración técnica exacta en este tutorial, usted debe haber hecho lo siguiente:

  • instalado Django y configurar un entorno de desarrollo
  • Se creó una aplicación de Django y se conecta a una base de datos MySQL
  • Creado modelos de Django
  • conectado su aplicación a una interfaz de administración de Django

Sin embargo, si usted tiene una configuración de Django existente, puede seguir junto a entender mejor cómo implementar las vistas de Django.

Paso 1 – Crear Funciones de visión

Dentro de su terminal de servidor de Ubuntu, primero tiene que entrar en el directorio correspondiente y activar su entorno virtual de Python:

cd ~/my_blog_app
. env/bin/activate

  • cd ~ / my_blog_app
  • . env / bin / activar

Ahora que su entorno virtual se activa, vamos a navegar al directorio blogsite donde vamos a abrir un archivo de Python y crear nuestra primera función de vista.

cd ~/my_blog_app/blog/blogsite

  • cd ~ / my_blog_app / blog / blogsite

Abrir el archivo de puntos de vista para la edición, el uso de nano o el editor de texto de su elección.

nano views.py

  • nano views.py

Al abrir el archivo, debería ver el código que es similar al siguiente:

from django.shortcuts import render

# Create your views here.

Nos mantendrán la declaración de importación que las importaciones del render () la función de la biblioteca django.shortcuts. La función de render () nos permite combinar tanto una plantilla y un contexto para que podamos devolver el objeto HttpResponse apropiado. Tenga esto en cuenta, ya que con todas las vistas que escribimos, somos responsable de instanciar, poblando, y devolver un HttpResponse.

A continuación vamos a poner nuestra primera vista de que dará la bienvenida a los usuarios a la página de índice. Importaremos la función HttpResponse () de la biblioteca http Django. El uso de esa función, vamos a pasar en el texto que se mostrará cuando se solicita 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, vamos a añadir una función más que mostrará la entrada individual que vamos a crear más adelante en el tutorial. archivo views.py última

...
def individual_post(request):
return HttpResponse('Hi, this is where an individual post will be.')

Nuestro tendrá este aspecto.

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 haya terminado de editar el archivo, asegúrese de guardar y salir.

En este momento, no hay designado URL que estas funciones están apuntando a, por lo que tendremos que añadir que a nuestro bloque urlpatterns dentro de nuestro archivo de configuración de URL. Con las vistas añaden, vamos a pasar a direcciones URL de asignación a ellos a través de este archivo de configuración para que podamos ver las páginas que hemos creado.

Paso 2 – Mapa URL a Vistas

Django hace que sea relativamente conveniente para las personas que diseñan sus propias URL para usar con su aplicación. Esto se hace en Python puro mediante el uso de un archivo denominado comúnmente como su URLconf o archivo “configuración de URL”.

Para que la página Web que se muestra, Django primero tiene que determinar el módulo URLconf raíz de su uso, entonces procede a buscar urlpatterns, una estructura de datos que contiene la lista de todos los patrones de URL. Django luego pasa a través de cada patrón de URL hasta que encuentra la primera que coincidencias. Una vez que se encuentra una coincidencia, Django encuentra la vista asociada, y que la función vista recibirá los datos relativos al patrón de URL y un objeto HttpRequest. Si hay un fallo en cualquier punto a lo largo de este proceso, se muestra una vista de gestión de errores en su lugar.

Mientras que en el directorio ~ / my_blog_app / blog / blogsite, abra el archivo urls.py – también conocido como el archivo URLconf – para la edición. Usaremos nano aquí para editar el archivo.

nano urls.py

  • nano urls.py

Cambiar el archivo para que se vea exactamente como esta, con la lista urlpatterns como se muestra a continuación.

from django.urls import path
from . import views

urlpatterns = [
path('', views.index, name='index'),
path('post/', views.individual_post, name='individual_post')
]

Cuando haya terminado de agregar las líneas anteriores, guardar y cerrar el archivo.

Después de actualizar el archivo URLconf del directorio blogsite, que ahora debe incluirlo en URLconf del directorio de blogs o de lo contrario no va a ser reconocido. Tenemos que hacer esto porque se establece como el ROOT_URLCONF en nuestro archivo de configuración. Esto significa que Django está mirando URLconf del directorio de blog para urlpatterns.

Para incluir nuestra URLconf blogsite dentro de nuestra URLconf blog, tendremos que vaya a dicho directorio.

cd ~/my_blog_app/blog/blog

  • cd ~ / my_blog_app / blog / blog

Una vez allí, se puede abrir el archivo URLconf con nano u otro editor de texto de su elección.

nano urls.py

  • nano urls.py

Dentro de este archivo, añadiremos las siguientes líneas para incluir el archivo /blogsite/urls.py que acabamos trabajado, lo que se indica 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'))
]

Guardar y cerrar el archivo.

Ahora vamos a abrir un navegador web con el fin de navegar a las direcciones URL que hemos creado y verificar que muestran el texto que hemos añadido a las vistas. Vamos a tener que entrar en el directorio principal de acceso al fichero manage.py que sirve a la aplicación de Django.

cd ..

  • cd ..

emita el siguiente comando, reemplazando su dirección IP a continuación.

python manage.py runserver your-server-ip:8000

  • python manage.py runserver de su servidor-ip: 8000

Dentro de su navegador web, vaya a la siguiente URL:

your-server-ip:8000

verá una página web que tiene el siguiente aspecto:

Siguiente , vaya a la siguiente URL:

your-server-ip:8000/post/

a partir de aquí, debería ver la siguiente pantalla:

ahora hemos comprobado que los dos archivos urls.py trabajo, y los datos nos muestra exactamente lo que cabría esperar. Con este trabajo, vamos a añadir algunos datos reales en nuestro blog.

Paso 3 – Crear un Blogpost

Ahora que conoce los conceptos básicos de patrones de URL y puntos de vista, vamos a añadir una entrada de blog y conseguir que para mostrar en la página web en lugar del texto hemos codificado en los archivos de Python.

vamos a crear un puesto a través de la página de administración que hemos creado. Con el servidor de servicio de la aplicación de Django, utilizar un navegador web para navegar a la página de administración blogsite en:

your-server-ip:8000/admin/blogsite/

En la interfaz, haga clic en el vínculo + Agregar situado en la fila Mensajes para comenzar a poblar la base de datos con un mensaje de ejemplo blog.

Al hacer clic en el enlace, verá un formulario de entrada que es similar al siguiente:

cada vez que desee añadir un post, que irían a esta página para hacerlo. Como alternativa, puede editar mensajes con el enlace Cambiar.

En el formulario, verá los siguientes campos:

Llena la forma de blog como mejor le parezca para sus propósitos de prueba.

Una vez que haya agregado datos de ejemplo en la página, haga clic en el botón Guardar. Recibirá la siguiente página de confirmación:

Felicidades! Que haya creado su primera entrada en el blog!

A continuación, vamos a verificar que se ha añadido una fila que contiene los datos que hemos añadido a la base de datos MySQL.

Paso 4 – Ver información de base de datos

En este punto, tenemos que pasar a MySQL, por lo que detener el proceso de servidor actual a través del terminal tecleando CTRL + C, a continuación, abrir el intérprete de MySQL:

mysql -u root

  • mysql -u raíz

Una vez que estás en el MySQL rápido, movimiento en la base de datos blog_data:

use blog_data;

  • uso blog_data;

A continuación, mostrar el contenido de la tabla blogsite_post.

select * from blogsite_post;

  • seleccionar * de blogsite_post;

Recibirá una salida similar a la siguiente, que debe mostrar la información que ha añadido a la interfaz de usuario de administración.

Output+----+--------------------+--------------------+---------------+----------------------------+--------+
| id | title | slug | content | created_on | author |
+----+--------------------+--------------------+---------------+----------------------------+--------+
| 1 | My First Blog Post | my-first-blog-post | Hello, World! | 2018-04-24 17:10:00.139735 | Sammy |
+----+--------------------+--------------------+---------------+----------------------------+--------+
1 row in set (0.00 sec)

Como se muestra en la salida, hay una fila con los datos para el puesto que hemos añadido. Ahora vamos a Referencia estos datos en la función de vista de mensajes. Use CTRL + D para salir del intérprete de MySQL.

Vaya a la ubicación del archivo en el interior de su aplicación views.py blogsite.

cd ~/my_blog_app/blog/blogsite

  • cd ~ / my_blog_app / blog / blogsite

Ahora abrir el archivo, por lo que podemos incluir nuestros nuevos datos.

nano views.py

  • nano views.py

Editar el archivo para que se vea exactamente 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, hemos añadido una declaración de importación adicional para Post. También hemos eliminado la citada cadena de la HttpResponse y lo reemplazó con los datos de nuestro blog. Para datos de referencia para un objeto en particular, estamos utilizando el ID de entrada de blog asociado con el objeto que nos gustaría mostrar, y estamos almacenando esa ID en una variable llamada recent_post. entonces podemos obtener campos particulares de ese objeto añadiendo el campo con un separador período.

Una vez que haya guardado y cerrado el archivo, vaya a la ubicación del archivo manage.py para ejecutar la aplicación de Django.

cd ~/my_blog_app/blog
python manage.py runserver your-server-ip:8000/post/

  • cd ~ / my_blog_app / blog
  • python manage.py runserver de su servidor IP: 8000 / post /

desde un navegador web, vaya a la siguiente dirección:

your-server-ip:8000/post/

Aquí, vamos a ver los cambios que hemos hecho; La página tendrá un aspecto similar a este, mostrando el texto que ha agregado al poste.

Cuando haya terminado la inspección de la página, pulse CTRL + C en la terminal para detener el proceso de ejecución.

Para desactivar el entorno de programación, puede escribir el comando de desactivación y salga del servidor.

Conclusión

En este tutorial hemos creado vistas, patrones de URL asignadas, y se muestra texto en una página web desde la base de datos de blog.

El siguiente tutorial cubrirá cómo hacer realidad esta más estético mediante el uso de HTML para crear plantillas de Django . Hasta ahora, esta serie ha cubierto modelos de Django Django y puntos de vista. Las plantillas son la última parte crucial cuando se trata de la base de su aplicación Django.