Tutorial Django: Parte II

​ En este tutorial continuaré con el framework Django. Si recordamos del post anterior ya aprendimos:

• A instalar la herramienta.
• Crear un proyecto.
• Crear una aplicación y modelo.
• CRUD de un modelo.
• Uso de archivos estáticos.
• Configuración básica del admin.

Por tanto continuaré a partir de ese punto. Consulta el repositorio de este proyecto en Github y su último commit como punto de arranque de este tutorial aquí.

1 - Migraciones

Es un sistema que nos permite evolucionar nuestro esquema de la base de datos mientras desarrollamos nuestra aplicación. Este sistema nos permite hacer los cambios en la base de datos sin tener que usar código SQL directamente.

Como practica crearé un modelo que represente los comentarios realizados por un usuario a nuestro blog. Por ello modifico el archivo posts/models.py agregando la siguiente clase:

Ahora creamos la migración con el comando que vimos en el primer post python manage.py makemigrations posts este detectará automáticamente, que ya existe una migración anterior y por lo tanto creará el archivo con el nombre 0002_comentario.py, donde 0002 indica el número de migración en esta aplicación y comentario el nombre que refleja el cambio realizado. El archivo generado luce así:

Este lo podemos modificar y agregar, por lo tanto mayor detalle a la migración, como por ejemplo agregar funciones para un cálculo especial. En este caso el archivo refleja la creación del modelo en la base de datos, indicando que depende del archivo 0001_initial.py (migración creada en la primera parte del tutorial) y usa la función CreateModel con el nombre y atributos especificados en el posts/models.py.

Para realizar esta migración ejecutamos python manage.py migrate posts. Ya con esto contamos con el modelo a nivel lógico y con una tabla en la base de datos que le corresponde.

Y para seguir con la practica queremos agregar al modelo comentario el atributo autor, con el valor por defecto Tony, para ello agregamos únicamente la línea autor = models.CharField(max_length=200, default='Tony') a la clase Comentario en el posts/models.py. Nuevamente ejecutamos python manage.py makemigrations posts y con esto ya tendremos el siguiente archivo de migración:

Si observamos bien, nos percatamos que el archivo tiene la misma estructura que el anterior, lo que cambia son obviamente los parámetros y que en esta oportunidad usamos la función AddField, la cual requiere:

• model_name: Nombre del modelo.
• name: Nombre del atributo.
• field: Tipo del atributo.

Realizamos nuevamente la migración con el comando python manage.py migrate posts y tendremos el modelo con su tabla correspondiente en la base de datos.

Otras operaciones que podemos llegar a realizar en una migración son:

• CreateModel: Crea el modelo.
• DeleteModel: Elimina el modelo.
• RenameModel: Permite renombrar el modelo.
• AlterModelTable: Permite asociar a un modelo con otra tabla en la base de datos.
• AlterUniqueTogether: Modifica las condiciones de unicidad.
• AlterIndexTogether: Modifica los indices.
• AlterOrderWithRespectTo: Permite modificar el orden por defecto de la tabla.
• AddField: Agrega un atributo al modelo especificado.
• RemoveField: Elimina un atributo un modelo especificado.
• AlterField: Permite cambiar las especificaciones de un atributo para un modelo.
• RenameField: Permite cambiar el nombre de un atributo para un modelo.

Para saber más sobre migraciones consulta en la documentación oficial y específicamente para operaciones sobre migraciones el siguiente enlace.

2 - Operaciones con la base de datos

Esta sección más que un ejemplo, será para explicar las funciones que tenemos para interactuar con la base de datos. Entonces si revisamos el archivo de posts/views.py, podemos ver todas las funciones que normalmente se usan.

• Post.objects.all() Selecciona todos los Posts y entrega una lista en el orden por defecto en el que estaban almacenados.
• Post(nombre='Hola mundo', contenido='Funciona',pub_fecha=datetime.now(),autor='Tony') Crea una instancia del modelo Post con el nombre, autor, contenido y fecha en los argumentos.
• post.save() Almacena en la base de datos, la instancia que se tenga del modelo en la variable post.
• get_object_or_404(Post, pk=1) Permite seleccionar de la base de datos la instancia con id 1 en el modelo Post.
• Post.objects.get(nombre__exact='Hola') Busca en la base de datos dentro del modelo Post las instancias que tengan el nombre exactamente con el valor Hola. También existen otras operaciones de búsqueda __iexact (tiene exactamente el valor, pero no es sensible a mayúsculas y minúsculas) y __contains (contiene el valor).
• post.update(campo=valor) Permite actualizar la instancia del modelo que este en la variable post con los valores que corresponda a unos atributos especificados.
• post.delete() Elimina la instancia que este en la variable.
• Post.objects.filter Sólo deja instancias según los parámetros.
• Post.objects.exclude Excluye del grupo de la consulta a todas instancias que correspondan a los parámetros.

3 - Manejo de sesión

El modelo de usuario que tenemos en la base de datos ya se creo en la primera parte de este tutorial, este ya contiene los atributos de nombre de usuario y contraseña en el modelo. Además de eso tenemos una variable dentro del request al cual le podemos agregar información y esta se llama session. Podemos agregar contadores, mensajes, entre muchos otros y esto lo logramos con operaciones como: request.session['saludo'] = 'hola'. Si queremos eliminar esa información usamos del request.session['saludo'].

Con motivo de mostrar buenas prácticas crearé una aplicación extra llamada sesion (sin acento porque no puedo), con la cual veremos las funciones de autenticación y manejo de usuarios. La aplicación la creamos usando python manage.py startapp sesion, luego agregamos dentro la carpeta una carpeta llamada templates para tener los html que correspondan a esta aplicación. Y como primer archivo dentro de esta carpeta agregamos login.html con el siguiente contenido:

En este vemos un formulario de costumbre que usamos para pasar los datos del usuario para iniciar su sesión (líneas 5 -32) y uso de bloques para estructurar la página con mensajes de errores (líneas 35 - 42).

Para garantizar que podamos cerrar y abrir sesión agregamos al posts/templates/base.html lo siguiente:

Con esto ya podemos verificar si el usuario esta autenticado y por tanto mostrar el link adecuado para iniciar o cerrar sesión desde todas las vistas!

Luego modificamos el archivo sesion/views.py con el siguiente contenido:

En este ya encontramos los nuevos comandos:

• request.user.is_authenticated() Revisa si ya existe un usuario con sesión iniciada.
• authenticate(username=nombre, password=contraseña) Devuelve una instancia de Usuario en caso de encontrar los datos correctamente en la base de datos.
• .is_active Verifica si el usuario que se tiene en la instancia ya esta activo.
• login(request,usuario) Inicia la sesión del usuario.
• logout(request) Cierra la sesión que este activa.

Lo siguiente es agregar el archivo de sesion/urls.py con el siguiente contenido:

Ahora queda notificar al proyecto y para eso agregamos dentro del archivo blog/urls.py la instrucción url(r'^sesion/', include('sesion.urls')),.

Por último dentro del archivo blog/settings.py agregamos a la lista de aplicaciones (INSTALLED_APPS) el valor 'sesion'.

La vista que tendremos resultante será la siguiente:

Como siempre, si algo no queda muy claro siempre me pueden escribir a mi correo tonylattke@gmail.com o también pueden dejar comentarios al final de este post y trataré de ayudarles lo antes posible.

Tutorial Django: Parte I

​ Después de haber recorrido el camino de desarrollo de sistemas web dentro de todos los post que he realizado, voy a empezar con otra de las opciones que tenemos dentro de los frameworks web Django. ​

Este proyecto consistirá en desarrollo de un blog. Lo voy a tener al día en mi repositorio de Github y me basaré en la documentación oficial de Django.

1 - Instalación

Existen según la documentación oficial la instalación a manual y través de la herramienta pip, siendo esta última la que voy a usar. Los comandos de instalación en Linux son:

2 - Crear un proyecto

Lo primero que debemos hacer es posicionarnos en la carpeta donde deseamos tener nuestro proyecto y luego ejecutar el comando django-admin.py startproject blog para crear un proyecto, donde blog es el nombre. Esto creará una carpeta con la siguiente estructura:

• manage.py: Es el que permite correr el proyecto. Toma la configuración del archivo blog/settings.py.
• blog/__init__.py: Este archivo es más una convención que cualquier otra cosa, ya que indica que este proyecto se trata de un paquete de Python.
• blog/settings.py: Contiene todas las configuraciones del proyecto.
• blog/urls.py: Tiene la tabla de asociaciones de URLS y los views.
• blog/wsgi.py: Es el que permite llamar a este proyecto como aplicación.

Ya con esto somos capaces de montar el servidor, así que ejecutamos en la consola python manage.py runserver y podremos visitar en la dirección (por defecto) localhost:8000. La página que verán a continuación luce como la siguiente:

3 - Crear una aplicación y modelo

En Django para tener un modelo necesitamos una aplicación dentro del proyecto y para eso ejecutamos python manage.py startapp posts, donde posts es el nombre de la aplicación. La estructura de carpetas que se creará es:

• posts/__init__.py: Nuevamente configuración de paquete de Python.
• posts/models.py: Contiene los modelos.
• posts/tests.py: Tienes funciones de prueba para esta aplicación.
• posts/views.py: Posee las funciones que controlan las vistas.

Ahora podemos crear nuestro modelo dentro de la aplicación y para esto modificaré el archivo posts/models.py así:

Con esto estaré creando un modelo Post que tiene:

• Nombre del post y de autor con un máximo de 200 caracteres.
• Valor de contenido del tipo texto (permite saltos de línea).
• Fecha de publicación.

En este momento le avisamos a nuestro proyecto que deseamos usar este modelo en la base de datos y para esto agregamos primeramente a la lista de aplicaciones en blog/settings.py. El archivo lucirá como el siguiente:

Línea 24 agrega la aplicación.

Luego utilizaré la herramienta de migraciones de Django python manage.py makemigrations posts. Con esto último la aplicación posts ya tiene la carpeta de migraciones preparada y podemos migrar hasta esta versión de la base de datos (por defecto usa el manejador Sqlite), entonces ejecutamos python manage.py migrate. Visita aquí el commit del proyecto hasta este punto.

4 - CRUD del modelo Post

En este momento voy a crear una primera vista dentro de la aplicación, por lo que se necesita:

• Agregar al archivo blog/settings.py el siguiente código para permitir agregar archivos de HTML.

• Crear una subcarpeta dentro de la carpeta posts que contenga los archivos HTML, en este tutorial se llamará templates.
• Crear un archivo HTML con el la vista que deseamos, en este caso mostrar la lista de posts que se tengan almacenados.

En este archivo verán el uso de las etiquetas especiales {% if ... %} (línea 1) y la etiqueta {% for .. in .. %} (línea 3), con estas Django es capaz de utilizar código python dentro del HTML y por lo tanto interactuar con la información que venga de la función del view.

• Crear una función dentro del views de la aplicación posts.

• Crear un archivo de dentro de posts con el nombre urls.py y que luzca como el siguiente archivo:

Con esto estamos indicando que el url / usará la función index dentro del archivo views.py.

• Y por último notificar al blog/urls.py con los links de nuestra aplicación y se logra agregando la siguiente línea: url(r'^posts/', include('posts.urls'))

Al finalizar tendremos un estado del proyecto como el de este commit en mi repositorio. Para verificar que todo haya funcionado levantamos el servidor nuevamente python manage.py runserver, visitamos localhost:8000 y veremos un mensaje que indicará que no se tienen posts publicados.

Ahora bien el hacer cada una de las funciones del modelo y conectarlos con una vista resulta ser un poco más laborioso en Django que en Rails, es por esto que les dejo los HTML correspondientes, las funciones de los views y urls.

Obtener y ver un sólo post:

Crear post:

Editar post:

Eliminar post:

Exportar a Json los post:

5 - Archivos estáticos

Ahora agregare estilo a nuestra página y para eso creare primero una plantilla que le sirva a todos los HTML que tengo hasta ahora. El archivo lucirá como el siguiente y estará en la carpeta de templates.

Y para que todos los archivos HTML que tengo hasta ahora lo conozcan, deberán agregar al principio la instrucción {% extends "base.html" %} y encerrar con las etiquetas {% block principal_content %} y {% endblock principal_content %} el código que se tiene hasta ahora.

Aún así se necesitan agregar los archivos de Bootstrap y Jquery que son invocados desde nuestra plantilla. Para esto creas una carpeta llamada static dentro de la carpeta blog y almacenas los archivos que puedes descargar aquí (fuentes, librerías de Jquery y Bootstrap).

Y para que el proyecto conozca esta carpeta, agrego en blog/settings.py el siguiente código:

Ya con esto podremos visitar nuestras vistas y lucirán como las siguientes imágenes, si agregamos las clases de Bootstrap que corresponden (visita el commit del proyecto para ver esos cambios necesarios).

Crear Post localhost:8000/posts/crear

Lista de Posts localhost:8000

Visitar el Post con identificador 1 localhost:8000/posts/1

Editar el Post con identificador 1 localhost:8000/posts/editar/1

6 - Admin

Por último en este tutorial quiero mostrarles como agregamos el admin a nuestro proyecto y es realmente muy fácil.

• Primero habilitamos el url /admin desde blog/urls.py.
• Luego creamos un usuario de tipo administrador. Usamos el comando python manage.py createsuperuser damos un nombre, correo y contraseña.
• Importamos al archivo posts/admin.py el modelo Post from .models import Post y lo registramos en el admin con el comando admin.site.register(Post).
• Podemos opcionalmente, editar en el archivo blog/settings.py la variable LANGUAGE_CODE y colocar el valor 'es-es' para ver el sitio web del admin en español.

Con esto podremos visitar nuestro admin y ver bajo la dirección localhost:8000/admin la siguiente página:

Ahora bien cuando navegamos hasta la opción de los posts, veremos que tenemos una lista de posts con atributos poco amigables, así que para eso lo podemos mejorar creando un manejador de modelo. Esto último se logra editando el archivo posts/admin.py como sigue: De esta forma tendremos la lista que luce así:

Y si queremos agregar un nuevo Post, el menú luce de la siguiente forma:

Visita aquí el commit del proyecto hasta este punto.

Como siempre, si algo no queda muy claro siempre me pueden escribir a mi correo tonylattke@gmail.com o también pueden dejar comentarios al final de este post y trataré de ayudarles lo antes posible.