Direcciones relativas en el fichero settings.py:

import os.pathPROJECT_DIR = os.path.dirname(__file__)...STATIC_DOC_ROOT = os.path.join(PROJECT_DIR, "static")...TEMPLATE_DIRS = (    os.path.join(PROJECT_DIR, "templates"),)

Un decorador para los templates:

@render_to('template.html')def foo(request):    bar = Bar.object.all()    return {'bar': bar}

# equals todef foo(request):    bar = Bar.object.all()    return render_to_response('template.html', {'bar': bar}, context_instance=RequestContext(request))

Ahora se ha añadido al proyecto sobre el que estoy trabajando el módulo south y por lo tanto tenía que añadir las migraciones correspondientes a la base de datos de mi ordenador de desarrollo.

No he sido capaz de añadir south sin borrar los datos que había previamente en las tablas. Me imagino que se podrá, pero como no me ha salido a la primera y los datos que tenía, eran de prueba, simplemente me he cargado las tablas de la base de datos.

El orden que he seguido es el siguiente:

Borrar las tablas de la base de datos se las aplicaciones que vaya a gestionar South.

Eliminar las aplicaciones de INSTALLED_APPS.

Sincronizar la base de datos.

Añadimos de nuevo las aplicaciones a INSTALLED_APPS.

Creamos la primera migración de las aplicaciones que vaya a gestionar South.

python manage.py schemamigration app_name –-initial

Donde app_name es el nombre de la aplicación que gestiona South. Hay que repetir este proceso para cada aplicación que gestionemos con South.

Ahora aplicamos la migración.

python manage.py migrate app_name

A partir de este momento, cada vez que se realice un cambio en los modelos, es necesario crear una nueva migración con:

manage.py schemamigration app_name –-auto

Para aplicar los cambios realizados hay que volver a usar:

python manage.py migrate app_name

X11 color names

http://en.wikipedia.org/wiki/Websafe

En la página de django, nos muestran como se crean los subcomandos.
Writing custom django-admin commands.

La metodología para crear los subcomandos es muy fácil, en el directorio de una app de django, hay que crear unos directorios y unos ficheros. El fichero que contiene el código del subcomando, tendrá el nombre del subcomando con la extensión “py”. Veamos como quedaría el directorio de la app si el nombre del subcomando fuese “my_subcommand”:

app/    __init__.py    models.py    management/        __init__.py        commands/            __init__.py            my_subcommand.py    tests.py    views.py

Por los tanto los ficheros que hay que crear son:

• management/__init__.py
• management/commands/__init__.py
• management/commands/my_subcommand.py

Es importante crear los ficheros __init__.py. Estos ficheros están en blanco, pero indican que los directorios son módulos de python.

En el fichero “management/commands/my_subcommand.py”, es donde hay que escribir el código del subcomando.

Como ejemplo, voy a poner un subcomando de “manage.py” que muestre el texto “Hello world!”.

Dentro del directorio de cualquier aplicación del proyecto, tiene que estar añadida la aplicación a INSTALLED_APPS, creamos los siguientes ficheros:

• management/__init__.py
• management/commands/__init__.py
• management/commands/hello_world.py

Los ficheros __init__.py están vacíos, y en “management/commands/hello_world.py” copiamos el siguiente código.

from django.core.management.base import BaseCommand

class Command(BaseCommand):    help = 'check unchecked votes'

    def handle(self, *args, **options):        print "Hello world!"

Para ejecutar el script, hay que ir al directorio principal del proyecto y ejecutar en el terminal:

python manage.py hello_world

Este ejemplo es muy simple, y no usa los modelos de django, pero vale para ver como es la estructura de un subcomando. En el fichero que contiene el código del subcomando, se pueden importar los modelos como en cualquier otro fichero del proyecto.

from myproject.myapp.models import Model

Lo que nos permite generar scripts que interactúen con los modelos creados en nuestro proyecto y usar la metodología de django para trabajar con la base de datos.

http://code.djangoproject.com/wiki/Tutorials

a = []if not a:    print "list is empty"

TEMPLATE_DIRS = (    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".    # Always use forward slashes, even on Windows.    # Don't forget to use absolute paths, not relative paths.)

Teniendo en cuenta que es código python, podemos hacer que esos paths se calculen a partir de paths relativos. Veamos como.

Es necesario incluir el siguiente código en el fichero settings.py

import osPROJECT_PATH = os.path.abspath(os.path.dirname(__file__))

Una vez añadido este código al fichero, ya podemos indicar el template de forma relativa.

TEMPLATE_DIRS = (os.path.join(PROJECT_PATH, 'templates')

)

Página oficial del módulo:
http://south.aeracode.org/

Para instalar el módulo, yo lo he hecho, a través de easy_install.

Si no tienes instalado la herramienta de instalción, se instala con:

sudo apt-get install python-setuptools

y para instalar el módulo de south:

sudo easy_install South

Este mini tutorial, está basado en el tutorial oficial que se puede encontrar en la página de South. Es muy importante seguir el orden en que se sincroniza la base de datos. Si no se hace en el orden correcto, pueden aparecer errores.

http://south.aeracode.org/docs/tutorial/index.html

Creamos un proyecto nuevo:

django-admin startproject demosouth

Ahora, hay que configurar la base de datos que va a usar django. Yo he usado sqlite, ya que para estos ejemplos sencillos, me parece la opción más simple. (Ver como hacerlo aquí). También incluimos la applicacion ‘south’ en INSTALLED_APPS. He comentado el resto de aplicaciones que vienen por defecto.

A continuación se sincroniza la base de datos.

./manage.py syncdb

Ahorar creamos una aplicación sobre la que trabajar.

./manage.py startapp southtut

Editamos el fichero southtut/models.py y añadimos la siguiente clase:

class Knight(models.Model):    name = models.CharField(max_length=100)    of_the_round_table = models.BooleanField()

Añadimos la aplicación southtut a INSTALLES_APPS. Ahora no sincronizamos la base de datos, en vez de eso, creamos una migración,

./manage.py schemamigration southtut –-initial

y la aplicamos.

./manage.py migrate southtut

Al aplicar la migración, se ha generado la tabla correspondiente.

Para ver como no afecta los cambios en modelos de django en la la información introducida con anterioridad, es necesario que las tablas de la base de datos contengan información. Se puede hacer mediante “./manage.py shell” o directamente en la base de datos. Al haber usado sqlite, se puede usar la herramienta sqlitemanager para introducir datos en la tabla.

A continuación se va a modificar el modelo. El principal objetivo de este tutorial, es aprender a modificar un modelo de django y que los datos que estaban almacenados con anterioridad, no se pierdan. Editamos southtut/models.py.

class Knight(models.Model):    name = models.CharField(max_length=100)    of_the_round_table = models.BooleanField()    dances_whenever_able = models.BooleanField()

Ahora creamos una migración nueva. Esta migración contiene las modificaciones que se han hecho en los modelos, pero todavía no se han visto reflejadas en las tablas de la base de datos.

./manage.py schemamigration southtut –-auto

y la aplicamos

./manage.py migrate southtut

Al aplicar la migración, la tabla referente al modelo que se ha cambiado reflejará dichos cambios. Si ahora comprobamos los valores de la base de datos, mediante sqlitemanager en nuestro ejemplo, vemos que se mantienen los datos que hemos introducido anteriormente, pero se ha añadido una nueva columna a la tabla.

He encontrado dos servicios que tienen buena pinta:

github.com   Este parece bastante serio. Por ejemplo tiene el repositorio de Ruby on Rails. La única pega que he encontrado, es que la versión gratuita no tiene proyectos privados. Está orientado al software colaborativo.

codaset.com tiene unas características parecidas al anterior. Está pensado para software libre. Además, es gratuito y te permite controlar la privacidad de tu proyecto. Público, semipúblico o privado son las opciones de privacidad de los proyectos. A parte del repositorio propimente dicho, tiene un web presenta el estado del proyecto, un blog, una wiki, un sistema de tickes…

Lo primero que hay que hacer es crear el proyecto de django.

django-admin startproject commentweb

Creamos una app que va a tener el modelo que gestiona los comentarios que se almacenan en la base de datos.

python manage.py startapp comments

Añadimos el modelo dentro de commentweb/commments/models.py.

from django.db import models# Create your models here.class Comment(models.Model):    title = models.CharField(max_length = 20)    date = models.DateTimeField()    text = models.TextField(blank = True)

El modelo consta de tres campos:

• title: título del comentario.
• date: fecha de la publicación.
• text: contenido del comentario.

Ahora hay que modificar el archivo settings.py

Base de datos

DATABASE_ENGINE = 'sqlite3'           # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.DATABASE_NAME = 'comments.sqlite'             # Or path to database file if using sqlite3.DATABASE_USER = ''             # Not used with sqlite3.DATABASE_PASSWORD = ''         # Not used with sqlite3.DATABASE_HOST = ''             # Set to empty string for localhost. Not used with sqlite3.DATABASE_PORT = ''             # Set to empty string for default. Not used with sqlite3.

Zona horaria. Se puede consultar en http://en.wikipedia.org/wiki/List_of_tz_zones_by_name

TIME_ZONE = 'Europe/Madrid'

Añadimos el path donde se almacenan los templates.

TEMPLATE_DIRS = (    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".    # Always use forward slashes, even on Windows.    # Don't forget to use absolute paths, not relative paths.    "/home/user/djangoprojects/commentweb/templates",)

Aplicaciones disponibles. He borrado las que vienen por defecto y he añadido la que hemos creado.

INSTALLED_APPS = (    'commentweb.comments',)

A continuación sincronizamos la base de datos.

python manage.py syncdb

Nos inidica que hemos creado una nueva tabla

Nuestra página web va a tener dos direcciones, por lo tanto debemos editar el fichero commentweb/urls.py para añadirlas.

from django.conf.urls.defaults import *from commentweb.comments.views import savefrom commentweb.comments.views import comments

urlpatterns = patterns('',    (r'^comments/$', comments),    (r'^save/$', save))

Vamos a crear las páginas ‘/comments/’ y ‘/save/’. La página ‘/comments/’ mostrará los comentarios que hay almacenados en la base de datos. Además, tendrá un formulario que nos permita añadir nuevos comentarios. La página ‘/save/’ almacena un comentario nuevo. Esta página se llama desde el formulario de la página anterior cuando se añade un nuevo comentario. Para gestionar estas páginas hay que crear las funciones comments y save en commentweb/comments/views.py. Pero antes, vamos a crear los templates que usan dichas funciones. En el directorio que hemos añadido anteriormente al archivo settings.py, vamos a crear el template comments.html. A continuación muestro su contenido:

< html>    < head>        < title>Comments< /title>    < /head>    < body>        < form method="post" action="/save/">            Title< input type="text" size="20" maxlength="20" name="title"> < br />            < textarea name="text" rows="4" cols="40">< /textarea>< br/>            < input type="submit" value="Comment!"/>        < /form>        {% for comment in comment_list %}            < h2>{{comment.title}}< /h2>            < p>Date: {{comment.date}}< /p>            < p>{{comment.text}}< /p>        {% endfor %}    < /body>< /html>

Nota: he dejado un espacio entre los caracteres ‘<’ y la etiquetas para una correcta visualización en el blog. Cuando se use este fichero hay que eliminar dichos espacios.

La plantilla anterior tiene dos partes fundamentales. La primera, es un formulario que permite añadir comentarios. De este formulario es importante el nombre del textarea (name=”text”), el nombre de título (name=”title”) y que la acción que se ejecuta al pulsar el botón “Comment!” (action=”/save/”) nos lleva a la página ’/save/’. La segunda, es una etiqueta de plantilla for que nos muestra todos los comentarios que están almacenados en la variable comment_list. A continuación se muestra el template para la página save.html

< html>

    < head> 

        < meta http-equiv="Refresh" content="2;url=../comments/"> 

    < /head>

    < body>

        < p>Su comentario ha sido guardado. Por favor esperar a ser redireccionado.< /p>

    < /body>

< /html>

Nota: he dejado un espacio entre los caracteres ‘<’ y la etiquetas para una correcta visualización en el blog. Cuando se use este fichero hay que eliminar dichos espacios. Esta plantilla es muy simple. Nos muestra un mensaje diciendo que el comentario de ha guardado y pasado 2 segundos nos redirecciona otra vez a la página comments. El proceso en el que se guarda el comentario en la base de datos se realiza en la función que invoca este template desde la vista. A continuación, vamos a ver las funciones que generan las vistas.

from commentweb.comments.models import Comment

from django.shortcuts import render_to_response

import datetime

# Create your views here.

def comments(request):

    comment_list = Comment.objects.all()

    return render_to_response('comments.html', {'comment_list': comment_list})

def save(request):

    txt = request.POST["text"]

    title = request.POST["title"]

    comment = Comment()

    comment.text = txt

    comment.date = datetime.datetime.now()

    comment.title = title

    comment.save()

    return render_to_response('save.html', None)

La funcion comment obtiente una lista de todos los comentarios que hay en la base de datos. Esta función retorna la salida de la función render_to_response que tiene dos parametros de entrada. El primero es el template con el que se crea la página. El segundo, es un diccionario que contiene los valores de las variables que hay en las plantillas. La clave del diccionario es una cadena que corresponde al nombre de la variable que usa el template ({{comment_list}} en este caso) y valor del diccionario, es el valor que la variable va a tomar durante la ejecución.

Una vez realizado esto, nuestro ejemplo ya está terminado. Para poder comprobar su funcionamiento es necesario ejecutar el servidor de pruebas que trae django.

python manage.py runserver

la dirección de nuestra nueva página es:

http://127.0.0.1:8000/comments/

Una vez realizado todos los pasos anteriores, nuestra nueva página ya nos debería permitir introducir nuevos comentarios.