domingo, 15 de diciembre de 2013

Subir una aplicación django a heroku

Subir una aplicación realizada con django a heroku es rápido y sencillo. Aquí se tratarán los pasos a seguir para subir la aplicación a heroku.


-Lo primero es tener instalado la herramienta heroku:
-Se obtiene desde:
-Lo siguiente es loguearse en la herramienta, para ello insertar el siguiente comando en la consola:
heroku login
-Introducimos las credenciales de nuestra cuenta y ya estarán listos para subir la aplicación django a heroku.
-Crean un directorio para el proyecto y entran en el:
mkdir hellodjango && cd hellodjango
-Inician o copian el proyecto:
django-admin.py startproject hellodjango
-Crean el archivo de texto Procfile dentro del proyecto creado e insertan la siguiente línea:
web: gunicorn hellodjango.wsgi
-Ahora indicar las dependencias, para ello tenemos dos métodos:
- $ pip freeze > requirements.txt
- o a mano, creando requirements.txt e introduciendo
Django==1.6
dj-database-url==0.2.2
dj-static==0.0.5
gunicorn==18.0
psycopg2==2.5.1
static==0.4
wsgiref==0.1.2
-Ahora hay que modificar un poco el settings.py para ello nos dirigimos a las lineas abajo indicada o la creamos si no existe alguna:
# importamos elmóduloo de bases de datos de heroku

import dj_database_url
DATABASES['default'] =  dj_database_url.config()


# añadimos esta linea para poder acceder desde el modo seguro
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')


# aceptamos las peticiones desde cualquier host
ALLOWED_HOSTS = ['*']


#configuramos el acceso de los archivos estáticos
import os
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
STATIC_ROOT = 'staticfiles'
STATIC_URL = '/static/'


STATICFILES_DIRS = (
   os.path.join(BASE_DIR, 'static'),
)


-Ahora toca el wsgi.py, solo añadir las siguientes líneas:
from django.core.wsgi import get_wsgi_application
from dj_static import Cling


application = Cling(get_wsgi_application())


-Ahora hay que usar git, si no se tuviera instalado usar el comando : 
sudo apt-get install git-core.
-Estando dentro del directorio del proyecto iniciamos git:
git init
-Se añaden los archivos al git:
git add .
-Se confirman los archivos añadidos:
git commit -m “my django app”


-Una vez se tiene el git actualizado se sigue con heroku:
heroku create
git push heroku master


-Por último crear la base de datos:
heroku run python manage.py syncdb


Terminado, tecleando lo siguiente podréis acceder a vuestro sitio y la aplicación estará finalmente en producción.
heroku open

sábado, 16 de noviembre de 2013

Modelos en Django

Buenas, en esta entrada trataré más a fondo los modelos en django.

¿Qué es un modelo?
En Django los modelos son como django tratara los datos, contendrá los campos de los objetos que queremos guardar. Generalmente django creara por cada modelo una tabla en la base de datos.

Lo básico
  • Cada modelo es una clase python que hereda de django.db.models.Model
  • Cada atributo del modelo representa un campo de la tabla de la base de datos
  • Django de base nos da acceso a la base de datos.


Usando los modelos
Para crear un modelo lo primero es añadir al settings.py la aplicación en la que esta contenida el models.py, para ello nos dirigimos a INSTALLED_APPS del setting y añadimos el nombre de la aplicación:

           INSTALLED_APPS = (
              #...
              'myapp',
              #...
           )

A la hora de usar los campos de un modelo tendrás que importar models y llamarlo cada vez que vayas a crear un campo. Los modelos se suelen guardan en el models.py de la aplicación previamente creada.
from django.db import models

          class Car(models.Model):
              manufacturer = models.ForeignKey('Manufacturer')
              # ...

Los campos
Los campos son el tipo de objeto del atributo que guardara, hay varios tipos:
  • AutoField: Es un IntegerField que se incrementa cuando creas un nuevo objeto, casi que no es necesario ya que django lo crea solo si no especificas otro campo como id.
  • BigIntegerField: Representa un Entero de 64 bit, es como el IntegerField, solo que permite números desde el -9223372036854775808 hasta el 9223372036854775807. El campo por defecto de los formularios es el TextField.
  • BooleanField: El campo de true/false. El campo por defecto de los formularios es un CheckboxInput. El vlaor por defecto es None si no defines el default.
  • CharField: Para string pequeños, frases o palabras. El campo por defecto en los formularios es el TextInput.
    • max_length=20: Establece el tamaño máximo del string, es requerido.
  • CommaSeparateIntegerField: Guarda una lista de enteros separados por coma. 
    • Max_length=20: Establece el valor máximo de los enteros, es requerido.
  • DateField: Guarda una instancia de la fecha a partir de la clase datetime.date de python.
    • auto_now=True: Actualiza la fecha cada vez que se actualiza el objeto.
    • auto_now_add=True: Guarda la fecha de cuando se creo.
  • DateTimeField: Como el DateField solo que guarda también la hora
    • auto_now=True: Actualiza la fecha cada vez que se actualiza el objeto.
    • auto_now_add=True: Guarda la fecha de cuando se creo.
  • DecimalField: Guarda números decimales.
    • max_digits=5: Establece el numero de dígitos máximo, la suma de la parte entera y la decimal
    • decimal_places=2: Establece el número de dígitos de la parte decimal.
  • EmailField: Es un CharField que comprueba lo introducido para verificar que sea un email.
    • max_length=75: Establece el tamaño máximo del email, es requerido.
  • FileField: Sirve para guardar archivos en el servidor. En el formulario saldría el campo de escoger un fichero del ordenador. Tiene que estar definido el MEDIA_ROOT en el settings para que guarde los archivos. Guardara el archivo en la ruta especificada por el MEDIA_ROOT.
    • upload_to='/videos': Subirá el archivo a la carpeta vídeos alojada en la carpeta definida por MEDIA_ROOT. (Requerido)
    • FileField(upload_to='/video'[, max_length=100, **options]): si se quiere poner los atributos opcionales tendrán que añadirse así.
  • FilePathField: Sirve para mostrar los archivos accesible de una carpeta siguiendo una restricción si se quiera, para hacer alguna operación sobre ellos.
    • FilePathField(path=None[, match=None,recursive=False, max_length=100, **options])
      • path (requerido): directorio del que sacara FilePathField las opciones.
      • match: filtro por el que pasaran los archivos, se usaran expresiones regulares.
      • recursive: False por defecto, especifica si entran las subcarpetas de la ruta indicada por path.
      • max_length: Indica el tamaño máximo del nombre del archivo.
  • FloatField: Campo que guarda una instancia del modelo Float de python.
  • ImageField: Como el FileField pero solo acepta formatos de imágenes. Tiene dos campos opcionales mas que el FielField
    • height_field: Representa el alto máximo de la imagen.
    • width_field: Representa el ancho máximo de la imagen.
  • IntegerField: Guarda un entero.
  • IPAddressField: Guarda un string que coincida con el formato ip (192.168.0.1).
  • GenericIPAddressField: Guarda una ip, ya sea ipv4 o ipv6. Para saber como las guarda Doc Django.
  • NullBooleanField: Como el BooleanField pero permite null.
  • PositiveIntegerField: Guarda un entero mayor o igual que cero.
  • SlugField:  Campo que guarda una pequeña etiqueta (letras, números, guiones) suele usarse en las url.
  • TextField: Campo que guarda texto.
  • TimeField: Guarda una hora, comparte los campos con DateField
    • auto_now=True: Actualiza la hora cada vez que se actualiza el objeto.
    • auto_now_add=True: Guarda la hora de cuando se creo.
  • URLField: Guarda una dirección html, comprueba que lo introducido sea una dirección html.
Campos de relación:
  • ForeignKey:  Para referir objetos a un objeto, un modelo puede referirse a un modelo, pero un modelo puede estar referido a mas de uno, es lo que se llama un many-to-one referencia.
  • ManyToManyField: Para guardar una referencia a varios objetos de la misma clase. Hay que definir la clase con la que se relaciona. Va guardando las referencias a esos objetos en una lista con las primary keys referncia.
  • OneToOneField: Es como el ForeignKey pero tiene unique=True, por lo que solo puede haber una referencia a ese objeto.
Opciones que tiene todos los campos:
  • null=True: Permite que los valores puedan ser null.
  • blank=True: Permite que el campo se pueda quedar en blanco.
  • choices=meses: Permite asignar un diccionario de elementos a un objetos para que los valores solo sean los contenidos en el diccionario. La clave del diccionario sera lo que se guarda en la base de datos, el valor asociado sera lo que se mostrar en el formulario que lo use.
  • db_column: El nombre de la columna donde django guardara el campo, si no se especifica guarda el nombre del campo.
  • db_index=True: Sirve para indexar el campo en las búsqueda de django. Por defecto django busca entre las PK de la base de datos, si añades esto también buscara entre esos datos y no tendrás que acceder directamente al objeto para comprobar el campo en las búsquedas.
  • db_tablespace: El nombre al que se referencia para buscar si ha sido indicado como index.
  • default: El valor por defecto que tiene el modelo, si se va a guardar un valor distinto a vació se guardara con el valor por defecto.
  • editable=False: Indica si el valor se puede modificar, si es falso no aparecerá en el admin ni similares.
  • error_messages={null:"Hay que darle un valor",blank:"No se puede dejar en blanco",invalid="El valor introducido es erróneo", invalid_choice:"Has escogido un valor inadecuado", unique="Este valor ya existe"}: Como se ve en el ejemplo hacer referencia a los mensajes que se mostraran si se produce ese error. No hace falta crear todos los mensajes. Si no los creas saldrá el que tiene por defecto.
  • help_text="Inserta un nombre": Un texto que aparecerá en forma de ayuda en el campo del formulario.
  • primary_key=True: Para asignar que el campos es la clave primaria del modelo.
  • unique=True: Indica que el valor es único, solo podrá haber uno en la base de datos.
  • unique_for_date='pub_date': El valor de esta propiedad tendrá que existir como campo del modelo y tendrá que ser del tipo DateField o DateTimeField. Lo que hace es no dejar que haya un elemento con el mismo valor del campo y el mismo día.
  • unique_for_month='pub_date': El valor de esta propiedad tendrá que existir como campo del modelo y tendrá que ser del tipo DateField o DateTimeField. Lo que hace es no dejar que haya un elemento con el mismo valor del campo y el mismo mes.
  • unique_for_year='pub_date': El valor de esta propiedad tendrá que existir como campo del modelo y tendrá que ser del tipo DateField o DateTimeField. Lo que hace es no dejar que haya un elemento con el mismo valor del campo y el mismo año.
  • verbose_name="Nombre de usuario": Nombre del campo comprensible por humanos, si no se crea django lo generar automáticamente, convirtiendo los guiones en espacios.
  • validators=[]: Una lista de validaciones para el campo referencia.
Documentación oficial mas completa Doc Django

Para seguir con el ejemplo tratado anteriormente crearemos un modelo mas complejo:

#encoding:utf-8
from django.db import models

PAISES=(('ES','Español'),('EN',"Ingles"),('DE','Aleman'))

class Autor(models.Model):
nombre = models.CharField(max_length=20, help_text='Introduce el nombre del autor')
apellidos = models.CharField(max_length=60, blank=True, null=True)
nacimineto = models.DateField(blank=True, null=True)
nacionalidad = models.CharField(max_length=10, choices=PAISES, default='ES')
correo = models.EmailField(unique=True, blank=True, null=True)
foto = models.ImageField(upload_to='/imagenes', blank=True, null=True)
pagina = models.URLField(blank=True, null=True)

def __unicode__(self):
return self.nombre

class Libro(models.Model):
titulo = models.CharField(max_length=100)
autor = models.ForeignKey('Autor')
paginas = models.IntegerField(blank=True, null=True)
resumen = models.TextField()
texto = models.FileField(upload_to='/libros', blank=True, null=True)
terminado = models.BooleanField(default=False)

def __unicode__(self):
return self.titulo

def get_puntuacion_media(self):
return 0

Con esto doy por concluidos los modelos, si tenis alguna duda no dudéis en dejar un comentario, enviar un correo o lo que queráis.

Un Saludo y hasta el próximo post.

martes, 5 de noviembre de 2013

Vuelta al Blog

Buenas después de un tiempo sin escribir pretendo ponerme ya a escribir mas a menudo. Tengo pensado seguir con el tutorial de django y algunos consejos para el entorno de trabajo. No prometo no desviarme de esto XD. Un saludo y hasta el nuevo post.

jueves, 10 de octubre de 2013

Primera Aplicación

Una vez tenemos dajngo instalado podemos proceder a crear nuestra primera aplicación para ello nos dirigiremos a la carpeta donde queremos que se aloje nuestro proyecto y ejecutaremos el siguiente comando "django-admin.py startproject recetario". Este comando creará un carpeta con el contenido necesario para tener nuestra primera aplicación. Encontraremos una carpeta con este directorio:
-ejemplo
-ejemplo
-settings.py
-urls.py
-
-manage.py
-
Ahora mismo nuestra aplicación ya estaría funcionando si escribimos el siguiente comando estando el la ruta del proyecto "sudo python manage.py runserver", esto iniciara un servidor de desarrollo en local. Para acceder a nuestra aplicación deberemos acceder desde nuestro navegador a la direccion "http://121.0.0.1:8800" podremos ver la siguiente pagina


Si hubiera habido algún problema con el puerto se puede solucionar mediante el comando “python manage.py runserver 1234”.


Ahora procederemos con la configuracion basica en el settings.py:
Lo primero sera establecer la ruta del proyecto, para que cuando lo cambiemos de ruta, para ello escribiremos en la parte superior del settings.py las siguientes líneas:
import os
RUTA_PROYECTO = os.path.dirname(os.path.realpath(__file__))


Ahora se establecerá la codificación que se usara, que será la UTF-8 para ello ponemos en la parte superior del documento lo siguiente:
#encoding:utf-8
Añadir los administradores del proyecto, se puede añadir en:
ADMINS = (
    # ('Your Name', 'your_email@example.com'),
)
Simplemente poner:
ADMINS = (
(‘Francisco Martinez’,’francisco.mar.esp@gmail.com’),
)
El siguiente paso es  configurar la base de datos para ello nos dirigiremos a la parte del fichero que tiene las siguientes líneas:
DATABASES = {
    'default': {
       ‘ENGINE': 'django.db.backends.sqlite3',
'NAME': 'ejemplo.db',        
'USER': '',                      
'PASSWORD': '',                 
       'HOST': '',                    
'PORT': '',                      
}
}


Explicación de cada línea
-ENGINE: Será el motor de la base de datos que se usará en el proyecto.
-Name: Nombre de la base de datos
-User: El usuario de la base de datos
-Password: La contraseña del usuario de la base de datos
-host: El host donde esta alojada la base de datos
-Port: El puerto desde el que se accede a la base de datos
Ahora configuraremos el lenguaje y el uso horario de la aplicación, para ello nos dirigiremos a la parte del fichero donde se encuentran las siguientes líneas
TIME_ZONE = “America/Chicago”
LANGUAGE_CODE = “en-us”
Y sustituiremos por nuestros codigo
TIME_ZONE = “Europe-Madrid”
LANGUAGE_CODE = “es-ES”
Ahora toca configurar las aplicaciones que tendremos instalas, por defecto vienen las siguientes:
INSTALLED_APPS = (
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.sites',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   # Uncomment the next line to enable the admin:
   # 'django.contrib.admin',
   # Uncomment the next line to enable admin doc
   # 'django.contrib.admindocs',
)


Podremos agregar tanto aplicaciones creadas por nosotros como las realizadas por terceros.
Para no volver a esta parte del archivo crearemos la primera aplicación, para ello escribiremos en una terminal con ruta en
nuestro proyecto lo siguiente "python manage.py startapp principal"


Modificamos las aplicaciones instaladas para añadir la aplicación que hemos creado nueva y activar el admin de django:
INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.admin',
    'django.contrib.admindocs',
    ‘principal’,
)
Después de esto la estructura de nuestro proyecto quedará de la siguiente manera:
-ejemplo
-ejemplo
-__init__.py
-settings.py
-urls.py
-wsgi.py
-principal
-__init__.py
-models.py
-test.py
-views.py
-manage.py
Ahora que ya tenemos nuestra primera aplicación y hemos terminado de modificar el archivo de configuración procederemos a crear los modelos para nuestros datos, django por defecto trae bastante modelos creados, como los usuarios comentarios y otros. Por defecto los modelos de usuario vienen activados, pero para  poder crearlos fuera de la consola podemos usar el panel por defecto de django, para ello nos dirigiremos al archivo urls.py que se encuentra dentro de la carpeta ejemplo dentro de la carpeta del proyecto, que por defecto viene asi:
from django.db import models
# Create your models here.


Y le añadiremos las siguientes líneas:
from django.contrib.auth.models import User
Para que tengamos un usuario para acceder al panel, para ello utilizaremos el siguiente comando en la terminal estando en el directorio de nuestro proyecto, "sudo python manage.py syncdb". Cuando pregunte si queremos crear el usuario le damos a si y seguimos los pasos.
Una vez añadido esto, procederemos a actiavar la url de administracion, para ello se accedera al documento urls.py ubicado en la carpeta ejemplo y lo dejamos asi:


from django.conf.urls import patterns, include, url
from django.contrib import admin
admin.autodiscover()


urlpatterns = patterns('',
url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
url(r'^admin/', include(admin.site.urls)),
)



y estando el servidor de pruebas en funcionamiento podremos acceder a la siguiente dirección http://127.0.0.1:8000/admin y tendremos el panel de administración de django en funcionamiento, metiendo nuestro usuario y clave estaremos dentro.


Una vez realizado esto tenemos la base para empezar con la aplicación.


Para la realización de un modelo de datos nuevo hay que modificar el models.py ubicado en la carpeta principal.

Este es el esquema más básico de modelo:

from django.db import models

class Libro(models.Model):
titulo = models.CharField(max_length=50)
autor = models.CharField(max_length=50)
contenido = models.TextField()
def __unicode__(self):
return self.titulo

Tras esto estará definido el objeto libro.


Para poder mostrar los libros guardados en la base de datos necesitaremos crear un html que servirá como template para mostrar los datos.
El primer paso sera crear la vista que manejara este html, para ello hara falta modificar el documento view.py ubicado en la carpeta principal.
Este es el esquema basico de vista:


from principal.models import Libro
from django.shortcuts import render_to_response


def lista_libros(request):
libros = Libro.objects.all()
return render_to_response('libros.html',{'lista':libros})


Una vez crada la vista tendremos que llamarla de alguna forma, esto se hace mediante las url para ello nos dirigiremos de nuevo a urls.py y añadir dentro del urlpatterns y añadir:
url(r'^$','principal.views.lista_libros'),


Antes de realizar el html habra que configurar el settings para que encuentre los html, para ello ahi que buscar TEMPLATE_DIRS y dejarlo asi:
TEMPLATE_DIRS = (
    os.path.join(RUTA_PROYECTO,'plantillas'),
)


Finalmente creamos la carpeta plantillas dentro de ejemplo para que quede asi:
-ejemplo
-manage.py
-principal
-ejemplo
-plantillas
-urls.py
...


Ahora nos pondremos con el html finalmente, un ejemplo sencillo sería el siguiente:
<html>
 <head>
<title>Libreria</title>
 </head>
 <body>
   <h1>Lista de Libros</h1>
{% for elemento in lista %}
<ul>
 <li><strong>{{elemento.titulo}}</strong></li>
 <li>{{elemento.autor}}</li>
 <li>{{elemento.contenido}}</li>
</ul>
{% endfor %}
 </body>
</html>



Lo que hace este html es recibir la lista que envía la lista e imprimirla mediante el for.


Por último hay que decirle al admin que existe un nuevo objeto para que aparezca en los objetos disponibles, para ello habrá que crear un documento dentro de la carpeta principal. El archivo se llamara admin.py y tendra el siguiente contenido:


from principal.models import Libro
from django.contrib import admin


admin.site.register(Libro)


Una vez realizado todo esto podemos ejecutar en la terminal de nuevo el comando “python manage.py syncdb” para refrescar la base de datos y reconozca el nuevo objeto libro.


Una vez hecho esto y con el servidor en funcionamiento podremos acceder al admin para crear objetos o al index para ver la lista de los objetos.


Con esto el tutorial ha finalizado, posteriormente se publicará tutoriales para extender más las diferentes parte del tutorial y cosas nuevas.