Creando modelos¶

A continuación definiremos los modelos, que viene a ser la estructura de la base de datos con metadatos adicionales.

Para nuestra aplicación cms, crearemos dos modelos: Contenido y Comentario. Un Contenido tiene una clave y un valor, al igual que ya lo tenía en la aplicación web que hicimos en su día y que guardábamos en un diccionario Python. Una Comentario tiene tres campos: el título, el cuerpo y la fecha del comentario. Cada Comentario está asociado a un Contenido.

Estos conceptos vienen representados por clases en Python. Edita el fichero cms/models.py para que el resultado sea el siguiente:

from django.db import models

class Contenido(models.Model):
    clave = models.CharField(max_length=64)
    valor = models.TextField()

class Comentario(models.Model):
    contenido = models.ForeignKey(Contenido, on_delete=models.CASCADE)
    titulo = models.CharField(max_length=200)
    cuerpo = models.TextField(blank=False)
    fecha = models.DateTimeField('publicado')

Como se puede ver, cada modelo viene representado pro una clase que hereda de django.db.models.Model. Cada modelo tiene una serie de variables de clase, que representa un campo de la base de datos en el modelo.

Configuración de la base de datos¶

Una vez que hemos definido el modelo, vamos a configurar la base de datos. La base de datos es utilizada a nivel de proyecto, esto es, todas las aplicaciones comparten una misma base de datos. Dentro de la base de datos, habrá tablas; una aplicación puede o no tener tablas (por ejemplo, nuestra calc de la última semana no tenía tablas), o tener una tabla o bien tener muchas. Las tablas sí son específicas de las aplicaciones.

Para configurar la base de datos abre el archivo proyecto/settings.py. Es un módulo (fichero) normal de Python con variables de nivel de módulo que representan la configuración de Django.

Por defecto la base de datos utilizada SQLite, que es la que utilizaremos en esta asignatura. SQLite es un gestor de base de datos incluido en Python por lo que no tendremos que instalar nada más para soportar nuestras bases de datos. Para proyectos reales, es recomendable utilizar una base de datos más potente como PostgreSQL o MySQL para evitar dolores de cabeza en el futuro al tener que cambiar entre base de datos.

Si desea utilizar otra base de datos, instale los conectores de base de datos apropiados, y cambie las siguientes claves en el ítem DATABASES 'default' para que se ajusten a la configuración de conexión de la base de datos:

• ENGINE – bien sea 'django.db.backends.sqlite3', 'django.db.backends.postgresql_psycopg2', 'django.db.backends.mysql', o 'django.db.backends.oracle'. Otros backends también están disponibles.
• NAME –el nombre de tu base de datos. Si estás utilizando SQLite, la base de datos será un archivo en tu ordenador; en ese caso NAME debe ser la ruta absoluta completa, incluyendo el respectivo nombre del archivo. El valor predeterminado, os.path.join(BASE_DIR, 'db.sqlite3'), guardará el archivo en el directorio de tu proyecto.

Si no estás utilizando SQLite como gestor de base de datos, se deben añadir ajustes adicionales tales como USER, PASSWORD, y HOST se deben añadir. Para más información, vea la documentación de referencia para DATABASES.

Ya que estamos editando el archivo proyecto/settings.py, configuremos TIME_ZONE a nuestra zona horaria ("Europe/Madrid").

Activando los modelos¶

Dentro de proyecto/settings.py, existe una variable llamada INSTALLED_APPS se encuentra en la parte superior del archivo. Esta variable, una lista, contiene los nombres de todas las aplicaciones Django que están activadas en nuestro proyecto.

Es hora de indicarle a nuestro proyecto que la aplicación cms está instalada y lista para ser usada.

Para incluir la aplicación cms en nuestro proyecto necesitamos agregar una referencia en INSTALLED_APPS. Lo que debemos indicar en INSTALLED_APPS es una clase con la configuración que guardaremos en el fichero cms/apps.py. Esta clase la llamaremos CmsConfig. La ruta para que el proyecto la reconozca será 'cms.apps.CmsConfig', de manera que edita el archivo proyecto/settings.py y agrega esta ruta punteada a INSTALLED_APPS. ¿Y CmsConfig, no lo tenemos que crear? Por ahora, como no necesitamos ninguna configuración específica para nuestra aplicación cms, no hará falta editar el fichero cms/apps.py para añadir una clase CmsConfig. Con la configuración por defecto, o sea sin explícitamente tener CmsConfig, nos valdrá.

El resultado de la variable INSTALLED_APPS en el fichero proyecto/settings.py se verá así:

INSTALLED_APPS = [
    'cms.apps.CmsConfig',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Hecho esto, Django es consciente de que existe una aplicación llamada cms que necesita que se cree una base de datos. Nota que por ahora, hemos definido el modelo en lenguage Python. Necesitaremos ejecutar una serie de acciones para que se cree la base de datos a partir de ese model. Para ello, ejecutaremos el siguiente comando:

$ python3 manage.py makemigrations

...\> py manage.py makemigrations

Al ejecutarlo, como es la primera vez que lo hacemos, se crearán no sólo las tablas de nuestra aplicación cms, sino de todas las demás. Veremos por pantalla un montón de información sobre creación de esas tablas. Las líneas relativas a cms serán similares a las siguientes:

   
Migrations for 'cms':
  cms/migrations/0001_initial.py
    - Create model Contenido
    - Create model Comentario

Al ejecutar makemigrations, le estamos indicando a Django que hemos realizado algunos cambios a sus modelos (en este caso, ha realizado cambios nuevos) y que le gustaría que los guarde como una migración.

Las migraciones son cómo Django almacena los cambios en sus modelos (y, por lo tanto, en el esquema de la base de datos) - ahora ya no son clases de Python (los modelos) sino que son archivos (donde guardaremos los datos) en el disco. Puedes ver la migración del nuevo modelo, si lo deseas, en el archivo cms/migrations/0001_initial.py. No te preocupes, no se espera que te los leas cada vez que Django hace uno -- pero están diseñados para ser editados por humanos en caso de que desees modificar manualmente cómo Django cambia las cosas.

Hay un comando que ejecutará las migraciones y que gestionará el esquema de base de datos automáticamente: migrate.

También puedes ejecutar el comando python manage.py check para revisar cualquier problema en tu proyecto sin hacer migraciones o modificar la base de datos.

A continuación, ejecuta de nuevo el comando migrate para crear esas tablas modelos en tu base de datos:

$ python3 manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, cms, sessions
Running migrations:
  Applying cms.0001_initial... OK

...\> py manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, cms, sessions
Running migrations:
  Rendering model states... DONE
  Applying cms.0001_initial... OK

El comando migrate toma todas las migraciones que no han sido aplicadas (Django rastrea cuales se aplican utilizando una tabla especial en su base de datos llamada django_migrations) y las ejecuta contra su base de datos; básicamente, sincronizando los cambios que hayas realizado a tus modelos con el esquema en la base de datos.

Las migraciones son muy potentes y le permiten modificar sus modelos con el tiempo, a medida que desarrolla tu proyecto, sin necesidad de eliminar su base de datos o las tablas y hacer otras nuevas. Este se especializa en la actualización de su base de datos en vivo, sin perder datos. Vamos a hablar de ellas en mayor profundidad más tarde en el tutorial, pero por ahora, recuerde la guía de tres pasos para hacer cambios de modelo:

• Cambie sus modelos (en models.py).
• Ejecuta el comando python manage.py makemigrations para crear migraciones para esos cambios
• Ejecuta el comando python manage.py migrate para aplicar esos cambios a la base de datos.

La razón por la que existen comandos separados para realizar y aplicar migraciones es porque enviarás las migraciones a tu sistema de control de versiones (git) y las enviarás con tu aplicación; no solo facilitan el desarrollo, también pueden ser utilizadas por otros desarrolladores y en producción.

Creando un usuario para admin¶

Primero tendremos que crear un usuario, el superusuario, que pueda iniciar sesión en el sitio administrativo. Este superusuario tendrá permisos no sólo para acceder al interfaz de admin vía web, sino que podrá crear otros usuarios, gestionar los permisos, entre otras tareas. Además, como veremos pronto, podrá añadir, modificar o borrar contenidos en la base de datos. Para crear el superusuario, ejecuta el siguiente comando:

$ python3 manage.py createsuperuser

...\> py manage.py createsuperuser

Introduce un nombre de usuario (por ejemplo, admin) y pulsa enter.

Username: admin

A continuación se solicitará una dirección de correo electrónico:

Email address: alumno@alumnos.urjc.es

Y el paso final consiste en introducir una contraseña. Se pedirá que introducir la contraseña dos veces, la segunda vez como confirmación de la primera.

Password: **********
Password (again): *********
Superuser created successfully.

Inicie el servidor de desarrollo¶

El sitio administrativo de Django se activa de forma predeterminada. Vamos a iniciar el servidor de desarrollo y a explorarlo. Si el servidor no está en marcha, lánzalo de la siguiente forma:

$ python3 manage.py runserver

...\> py manage.py runserver

A continuación, abre un navegador web y ve a «/admin/» en tu dominio local, por ejemplo, http://127.0.0.1:8000/admin/. Deberás ver la pantalla de inicio de sesión del sitio administrativo:

Dado que la traducción se activa de forma predeterminada, la pantalla de inicio de sesión puede aparecer en tu propio idioma, dependiendo de la configuración del navegador y de si Django tiene una traducción para este idioma.

Accede al sitio administrativo¶

Ahora, intenta iniciar sesión con la cuenta de superusuario que has creado en el paso anterior. Deberías ver la página de índice del sitio administrativo de Django:

Deberías ver algunos tipos de contenidos editables: grupos y usuarios. Ellos son proporcionados por django.contrib.auth, el framework de autenticación enviado por Django. En usuarios ahora mismo sólo encontrarás al superusuario que acabamos de crear, pero verás que se pueden crear nuevos usuarios (y asignarles roles, permisos, etc.) de manera sencilla. Los usuarios se pueden agrupar en grupos, que aúnan a usuarios con características comunes (p.ej., editores, periodistas, diseñadores). Ahora mismo no hay ningún grupo creado, pero podrás observar que su creación y gestión es muy sencilla.

Haciendo que la aplicación cms se pueda modificar desde admin¶

Pero, ¿dónde está nuestra aplicación cms? No se muestra en la página de índice del sitio administrativo. Para que aparezca, debemos realizar todavía una acción. Necesitamos decirle a admin que los objetos Contenido puedan ser gestionados desde el interfaz de administrador. Para ello, abre el archivo cms/admin.py, y edítalo para que se vea así:

from django.contrib import admin

from .models import Contenido

admin.site.register(Contenido)

Explorando la funcionalidad de admin¶

Ahora que hemos registrado el modelo Contenido, Django desplegará esa tabla en la página índice del sitio administrativo:

Haz clic en «Contenidos» (nota que la interfaz de admin añade automáticamente una ese al final del nombre del modelo), y te llevará a la página «lista de cambios» para los contenidos. Esta página muestra todos los contenidos en la base de datos y permite seleccionar uno para modificarla.

Ahora mismo, no tenemos ninguno, pero podemos crear uno de manera sencilla pulsando sobre el botón gris «Add Contenido» en el margen superior derecho. De esta forma, crea un contenido cuya clave sea «nabucco» y cuyo valor sea «Vuela, pensamiento, en alas doradas».

Al guardarlo, podrás observar que has creado un objeto contenido, pero no mucho más. Veremos más adelante cómo cambiar esto.

Creando las URLs y la vista¶

Una vez que hemos introducido algunos contenidos, veamos cómo hacer para que nuestro servidor los muestre. Lo primero que haremos es definir las URLs. Como en el caso de la calculadora, lo que haremos es incluir en cms/urls.py (el URLs del proyecto) una línea indicando que queremos que las URLs las maneje la aplicación:

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('cms/', include('cms.urls')),
    path('calc/', include('calc.urls')),
    path('admin/', admin.site.urls),
]

Dentro del subdirector cms (el de la aplicación), crearemos (en cms/urls.py y añadiremos la siguiente regla:

from django.urls import path

from . import views

urlpatterns = [
    path('<str:llave>', views.get_content),
]

Y ahora vayamos a por la vista, que como hemos especificado en cms/urls.py ha de llamarse get_content. Por eso, en cms/views.py pondremos lo siguiente:

from django.http import HttpResponse
from .models import Contenido

def get_content(request, llave):
    contenido = Contenido.objects.get(clave=llave)
    return HttpResponse(contenido.valor)

La parte relevante de la vista está en la siguiente línea: Contenido.objects.get(clave=llave). Contenido es el modelo creado en calc/models.py, y Contenido.objects son todos los objetos (datos) que contiene esa tabla. De todos ellos, con get(clave=llave), lo que hacemos es obtener aquél objeto de Contenido cuyo valor de clave sea igual al valor de la variable llave que hemos obtenido como parámetro en la vista. Veremos en la clase de la semana que viene cómo realizar búsquedas más sofisticadas en la base de datos.

Prueba a ir a http://localhost:8000/cms/nabucco con tu navegador... si todo ha ido bien, debería devolver una página web con el contenido (el valor) con lo que canta el coro de los esclavos judíos en la famosa ópera.

La variable contenido es un objeto Contenido. Como ya sabemos de los modelos, los objetos Contenido tienen dos campos: clave y valor. En la línea HttpResponse(contenido.valor), lo que indicamos es que queremos responder con una página web con el campo valor (un string). Prueba con el código HttpResponse(contenido) para cerciorarte de que así estarías enviando el objeto.

Sin embargo, si intentas introducir cualquier otra llave, por ejemplo http://localhost:8000/cms/rigoletto, nos devolverá una página con un error. Resulta que cuando no existe una clave en la tabla de Contenido con el valor de la llave, saltará una excepción DoesNotExist (asociada al modelo Contenido). Para manejarlo correctamente, deberíamos modificar nuestra vista para que sea tal que así:

from django.http import HttpResponse
from .models import Contenido

def get_content(request, llave):
    try:
        respuesta = Contenido.objects.get(clave=llave).valor
    except Contenido.DoesNotExist:
        respuesta = 'No existe contenido para la clave ' + llave
    return HttpResponse(respuesta)

Y hasta aquí la práctica de hoy. Por favor, pon en el chat de Teams: "He terminado con el guión" para que los profes lo sepamos. Esto nos ayuda a dimensionar las prácticas. Muchas gracias.

Si has llegado hasta aquí y todavía tienes tiempo, prueba a introducir más contenidos en la base de datos mediante el interfaz de administración y prueba con el navegador que los muestre bien.

from django.http import HttpResponse
from django.views.decorators.csrf import csrf_exempt

from .models import Contenido

@csrf_exempt
def get_content(request, llave):
    if request.method == "PUT":
        valor = request.body.decode('utf-8')
        c = Contenido(clave=llave, valor=valor)
        c.save()

    try:
        respuesta = Contenido.objects.get(clave=llave).valor
    except Contenido.DoesNotExist:
        respuesta = 'No existe contenido para la clave ' + llave
    return HttpResponse(respuesta)