Entradas

Integración Django-CMS y REST Framework

1. SISTEMAS

Xubuntu-12.04.3-desktop-i386

2. INSTALACION DJANGO-CMS

2.1 Instalando requerimientos de Django-CMS (todos los requerimientos):

$ sudo apt-get install python2.7
$ sudo apt-get install python-pip
$ sudo pip install django-cms south

Debemos obtener algo tal que así:

Successfully installed django-cms south Django django-classy-tags html5lib django-mptt django-sekizai six
Cleaning up...

Asegurarnos de que no falta ningún requerimiento.

Creamos un proyecto de prueba y vemos que todo funciona correctamente, para ello

 $ cd ~/workspace
 $ django-admin.py startproject myproject
 $ cd myproject
 $ python manage.py runserver

Probamos que se está escuchando redireccionando 127.0.0.1:8000

django-cms-introduction

2.2 Instalar y configurar POSTGRES

Primero instalar Postgres y PGadmin

$ sudo apt-get install postgresql pgadmin3

Continuamos instalando el Driver de la base de datos

$ sudo apt-get install python-psycopg2

Creamos el usuario Postgres

developer@developer-VirtualBox:~$ sudo su postgres -c psql

psql (9.1.3)
Type "help" for help.
postgres=# ALTER USER postgres WITH PASSWORD 'your_password';

A continuación en el sistema operativo:

$ sudo passwd -d postgres
$ sudo su postgres
$ passwd

Reiniciamos el servicio y comprobamos que todo va bien:

developer@developer-VirtualBox:~$ sudo /etc/init.d/postgresql restart
* Restarting PostgreSQL 9.1 database server [ OK ]

Configurar postgres añadiendo al archivo pg_hba.conf esta configuración:

$ sudo gedit /etc/postgresql/9.1/main/pg_hba.conf

Añadir esta lí­nea al final del archivo:

local all all md5

Finalmente se volverá a  reinicar postgres

$ sudo /etc/init.d/postgresql restart

A continuación creamos el usuario propietario de la base de datos de django_cms

$ sudo -u postgres createuser --createdb --no-superuser --no-createrole --pwprompt django
$ sudo -u postgres psql -d postgres
$ postgres=# ALTER USER django WITH PASSWORD 'django_password';

A continuación la base de datos con el propietario creado

postgres=# CREATE DATABASE django_cms OWNER django;
postgres=# q

Ya sería posible añadir al archivo settings.py del CMS todo lo relativo a la base de datos que va a utilizar:

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2', # Add 'postgresql_p$
'NAME': 'django_cms', # Or path to database file i$
'USER': 'django', # Not used with sqlite3.
'PASSWORD': 'django_password', # Not used with sqlite3.
'HOST': '192.168.0.122', # Set to empty string for 192.168.0.122. N$
'PORT': '', # Set to empty string for default. Not$
 }

2.3 Configurar Django-CMS

Modificamos la cabecera del archivo settings.py

# -*- coding: utf-8 -*-
 import os
 gettext = lambda s: s
 PROJECT_PATH = os.path.abspath(os.path.dirname(__file__))

Añadimos las siguientes aplicaciones a la sección INSTALLED_APPS:

INSTALLED_APPS = (
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.sites',
 'django.contrib.messages',
 'django.contrib.staticfiles',
 'cms',
 'mptt',
 'menus',
 'south',
 'sekizai',
 'django.contrib.admin',
 # Uncomment the next line to enable admin documentation:
 # 'django.contrib.admindocs',
 )

También añadimos los plugins que sean necesarios:

-'cms.plugins.file'
 'cms.plugins.flash'
 'cms.plugins.googlemap'
 'cms.plugins.link'
 'cms.plugins.picture'
 'cms.plugins.snippet'
 'cms.plugins.teaser'
 'cms.plugins.text'
 'cms.plugins.video'
 'cms.plugins.twitter'

Por tanto, la sección de aplicaciones instaladas para el CMS quedaría tal que así:

INSTALLED_APPS = (
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.sites',
 'django.contrib.messages',
 'django.contrib.staticfiles',
 'cms',
 'mptt',
 'menus',
 'south',
 'sekizai',
 'django.contrib.admin',
 'cms.plugins.file',
 'cms.plugins.flash',
 'cms.plugins.googlemap',
 'cms.plugins.link',
 'cms.plugins.picture',
 'cms.plugins.snippet',
 'cms.plugins.teaser',
 'cms.plugins.text',
 'cms.plugins.video',
 'cms.plugins.twitter',
# Uncomment the next line to enable admin documentation:
 # 'django.contrib.admindocs',
 )

Añadir las clases que hacen de Middleware:

MIDDLEWARE_CLASSES = (
 'django.contrib.sessions.middleware.SessionMiddleware',
 'django.middleware.csrf.CsrfViewMiddleware',
 'django.contrib.auth.middleware.AuthenticationMiddleware',
 'django.contrib.messages.middleware.MessageMiddleware',
 'django.middleware.locale.LocaleMiddleware',
 'django.middleware.doc.XViewMiddleware',
 'django.middleware.common.CommonMiddleware',
 'cms.middleware.page.CurrentPageMiddleware',
 'cms.middleware.user.CurrentUserMiddleware',
 'cms.middleware.toolbar.ToolbarMiddleware',
 'cms.middleware.language.LanguageCookieMiddleware',
 )

y de procesadores:

TEMPLATE_CONTEXT_PROCESSORS = (
 'django.contrib.auth.context_processors.auth',
 'django.core.context_processors.i18n',
 'django.core.context_processors.request',
 'django.core.context_processors.media',
 'django.core.context_processors.static',
 'cms.context_processors.media',
 'sekizai.context_processors.sekizai',
 )

Referenciamos los futuros archivos estáticos, y no olvidar crear dicho directorio en el proyecto con permiso de escritura

STATIC_ROOT = os.path.join(PROJECT_PATH, "static")
STATIC_URL = "/static/"

Los mismo para los archivos multimedia:

MEDIA_ROOT = os.path.join(PROJECT_PATH, "media")
MEDIA_URL = "/media/"

De igual forma en lo relativo al directorio que contendrá los Templates:

TEMPLATE_DIRS = (
 # The docs say it should be absolute path: PROJECT_PATH is precisely one.
 # Life is wonderful!
 os.path.join(PROJECT_PATH, "templates"),
 )

Añadimos un template en la configuración:

CMS_TEMPLATES = (
 ('template_1.html', 'Template One'),
 )

Creamos dicho template a partir de un template base:

base.html

{% load cms_tags sekizai_tags %}
 <html>
 <head>
 {% render_block "css" %}
 </head>
 <body>
 {% cms_toolbar %}
 {% placeholder base_content %}
 {% block base_content %}{% endblock %}
 {% render_block "js" %}
 </body>
 </html>

template1.html

{% extends "base.html" %}
 {% load cms_tags %}
{% block base_content %}
 {% placeholder template_1_content %}
 {% endblock %}

Sincronizar la base de datos y crear usuario administrador de Django:

sincronizacion django

 

3. Django-Rest Framework

3.1 Instalación

 $ sudo pip install djangorestframework
 $ sudo pip install markdown # Markdown support for the browsable API.
 $ sudo pip install django-filter # Filtering support

A continuación, añadir al settings la aplicación rest-framework

INSTALLED_APPS = (
 ...
 'rest_framework',
 )

Añadir los permisos, en mi caso decidí no añadir los hyperlinked por un problema que tuve así que quedaría tal que así:

REST_FRAMEWORK = {
 # Use hyperlinked styles by default.
 # Only used if the `serializer_class` attribute is not set on a view.
 #'DEFAULT_MODEL_SERIALIZER_CLASS':
 # 'rest_framework.serializers.HyperlinkedModelSerializer',
# Use Django's standard `django.contrib.auth` permissions,
 # or allow read-only access for unauthenticated users.
 'DEFAULT_PERMISSION_CLASSES': [
 'rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly'
 ]
 }

Configurar el archivo urls.py obteniendo finalmente la url por defecto del cms, la de administrador /admin, y la escucha en /rest

urls.py

 from django.conf.urls.i18n import i18n_patterns
 from django.contrib import admin
 from django.conf.urls import patterns, url, include
 from django.contrib.auth.models import User
 from rest_framework import routers,viewsets
 from django.conf import settings
admin.autodiscover()
urlpatterns = i18n_patterns('',
 url(r'^admin/', include(admin.site.urls)),
 url(r'^', include('cms.urls')),
 )
# ViewSets define the view behavior.
 class UserViewSet(viewsets.ModelViewSet):
 model = User
router = routers.DefaultRouter()
 router.register(r'users', UserViewSet)
# Wire up our API using automatic URL routing.
 # Additionally, we include login URLs for the browseable API.
 urlpatterns += patterns('',
 url(r'^rest/', include(router.urls)),
 url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework'))
 )
if settings.DEBUG:
 urlpatterns = patterns('',
 url(r'^media/(?P<path>.*)$', 'django.views.static.serve',
 {'document_root': settings.MEDIA_ROOT, 'show_indexes': True}),
 url(r'', include('django.contrib.staticfiles.urls')),
 ) + urlpatterns

Podemos comprobar el web-service 192.168.0.122:8000/rest

rest-example

3.2 Explotación del Servicio REST

En caso de no disponer del comando curl lo instalamos

$ sudo apt-get install curl

Por último hacemos la prueba, enviando una parte de un formulario y utilizando el usuario administrador de django_cms que creamos previamente:

curl -X POST -H "Content-Type: application/json" -d '
 {
 "username": "PedroOERP",
 "password": "password"
 }' -u usuario:password http://127.0.0.1:8000/rest/users/

Y este sería el resultado del método GET

rest-get-example

 

 

4. LINKS:

Django
http://django-cms.readthedocs.org/en/latest/getting_started/tutorial.html

Rest
http://django-rest-framework.org/

Nuevo proyecto de ZOOOK esale

Instalación de Django y ZOOOK

ZOOOK es una aplicación de Django, pero no es compatible con la versión 1.5, por lo que lo primero que habrá que hacer es instalar la versión 1.4. Se puede instalar ejecutando:

$ sudo pip install django==1.4

En el manual anterior se instalaban todas las dependencias de forma manual, en este se va a utilizar el instalador del proyecto para instalar todas las dependencias. Para descargar e instalar el proyecto:

$ bzr branch lp:zoook-esale/6.1 django-zoook
$ cd django-zoook
$ sudo python setup.py install

Para poder ejecutar ZOOOK será necesario crear la base de datos con su acceso y configurarlo, para que Django cree los datos necesarios.

Se crea el usuario con acceso a la base de datos:

$ sudo -u postgres createuser --createdb --no-superuser --no-createrole --pwprompt zoook

Se crea la base de datos para este usuario:

$ sudo -u postgres psql -d postgres
postgres=# CREATE DATABASE dj_zoook OWNER zoook;
postgres=# q

Por último habrá que configurar ZOOOK, para esto hay que editar el fichero config.py.

Indicar la base de datos:

DATABASES = { 
 'default': { 
 'ENGINE': 'django.db.backends.postgresql_psycopg2', 
 'NAME': 'dj_zoook', 
 'USER': 'zoook', 
 'PASSWORD': 'zoook', 
 'HOST': '192.168.0.122', 
 'PORT': '5432', 
 } 
}

La configuración de OpenERP:

OERP_CONF = { 
 'username':'admin', 
 'password':'admin', 
 'dbname':'openerp', 
 'protocol':'xmlrpc', #xmlrpc 
 'uri':'http://192.168.0.122', #xmlrpc 
 'port':8069, #xmlrpc 
}

En el fichero de configuración se indica la posibilidad de utilizar pyro, pero esta opción no está disponible en OpenERP 6.1

Se puede configurar los idiomas para la web:

LANGUAGE_CODE = 'es' 
LANGUAGES = ( 
 ('en', ugettext('English')), 
 ('es', ugettext('Spanish')), 
) 
DEFAULT_LANGUAGE = 1 
LOCALE_URI = True 
LOCALEURL_USE_ACCEPT_LANGUAGE = True 
LOCALES = { 
 'en':'en_US', 
 'es':'es_ES', 
}

En la configuración se indica también la o las tiendas de OpenERP a las que tiene acceso la web, se indica el identificador interno.

OERP_SALE = 1 #Sale Shop. All price, orders, ... use this Sale Shop ID. 
OERP_SALES = [1] #Sale Shops. Orders by Sale Shops

Por último se puede indicar la configuración para el envío de correos

EMAIL_USE_TLS = True 
EMAIL_HOST = 'smtp.gmail.com' 
EMAIL_HOST_USER = 'myemailuserXXX' 
EMAIL_HOST_PASSWORD = 'mypasswordXXX' 
EMAIL_PORT = 587

Antes de ejecutar por primera vez la aplicación será necesario crear el fichero de log y configurarlo.

Se puede crear por ejemplo, dentro de la carpeta django-zoook principal del proyecto, un directorio para log con un fichero zoook.log

$ mkdir log
$ touch log/zoook.log

En el fichero logconfig.py se indicará donde se encuentra este fichero en esta linea

LOGFILE = os.path.join(zoook_root, 'log', 'zoook.log') #path sync log

Una vez está todo configurado se pueden crear las tablas en la base de datos necesarias para ejecutar la web.

$ python manage.py syncdb

La primera vez que se ejecute syncdb creará un usuario de administración para Django, habrá que indicar el nombre de usuario y su contraseña.

Antes de arrancar la web habrá que configurar la tienda con:

$ ./configuration.py

Por ultimo se arranca la web con:

python manage.py runserver

En caso de error puede ser debido a la falta de algún módulo de django, se puede comentar en settings.py o instalarlo con pip.

Instalación de ZOOOK en OpenERP

Se instalará ZOOOK sobre OpenERP 6.1.

Para facilitar la instalación se han creado nuevos repositorios, uno con el propio ZOOOK y otro con los addons extra necesarios.

Para descargar los repositorios:

$ bzr branch lp:~zoook-community/zoook-esale/zoook-6.1 
$ bzr branch lp:~zoook-community/zoook-esale/zoook-extra-addons-6.1

La instalación de ZOOOK en OpenERP será igual que cualquier otro módulo, añadiendo los módulos descargados al addons_path, y desde el propio OpenERP actualizando la lista de módulos disponibles e instalando el módulo zoook. Importante al añadir en el archivo de configuración el extra-addons de zoook hacerlo antes del extra-addons genérico, con esto se consigue cargar los módulos de zoook antes.

Configuración de ZOOOK en OpenERP

Una vez instalado el módulo en Ventas/Configuración/Ventas/Tienda podemos configurar los parámetros de la tienda que se quiera sincronizar con ZOOOK.

zoook-OpenERP-01-tienda

Al marcar la opción OpenERP e-sale se podrán configura el resto de parámetros.

La conexión SSH será necesaria para sincronizar ZOOOK

En la solapa de acciones están los procesos para actualizar zook, exportar categorías, productos, imágenes y configuración global.

Para exportar el árbol de categorías, se indicará la categoría raíz en la solapa configuración y habrá que marcar como exportable cada categoría.

Installing Zoook on Ubuntu – Part II: Python and Django

1 Install Python

The default Python interpreter on Ubuntu 11.10 is 2.7.2. To verify that this is the version on your system execute:

$ python

This should return something like the following:

http://www.domatix.com/http://www.domatix.com/wp-content/uploads/python_version.png

Find out the version of your Python installation.

The message indicates that the version 2.7.2 is installed.

To exit the Python interpreter execute a

>>> quit()

In the rare case that there is no Python on your system, install it via

$ sudo apt-get install python

2 Install Django

Install all dependencies needed by Django:

$ sudo apt-get install python-dev python-psycopg2

You can install Django in three different ways:

  1. via the package management system of your distribution,
  2. fetching the latest stable version from the website, or
  3. download the development version from their repositories.

2.1 Installation via the package management system

The installation via the package management system is as simple as

$ sudo apt-get install python-django

2.2 Installing the last stable version from the website

Surf to the download section of the Django site and check for the latest stable version. That was 1.3.1 as of this writing (8th of February 2012).

$ cd ~
$ tar xvzf Django-1.3.1.tar.gz
$ mv Django-1.3.1 django-src

This way you’ll find the source code in the directory ~/django-src. The next step is to pass this information to Python. Locate the site-packages of your Python installation:

$ python -c "from distutils.sysconfig import get_python_lib; 
 print get_python_lib()"

This should return something like the following:

http://www.domatix.com/http://www.domatix.com/wp-content/uploads/site-packages.png

Locate the site-packages of your Python installation.

which indicates that your site-package directory is /usr/lib/python2.7/dist-packages. In this directory you’ll have to add the route to the Django sources:

$ echo '/home/roberto/django-src' | sudo tee -a 
 /usr/lib/python2.7/dist-packages/django.pth

This creates the file /usr/lib/python2.7/dist-packages/django.pth with the path to your Django installation.

To make a live a bit more comfortable, create a symbolic link to django-admin.py:

$ sudo ln -s /home/roberto/django-src/django/bin/django-admin.py 
 /usr/local/bin

This way you can use django-admin.py in every place of the file system instead of executing the script by its absolute path ~/django-src/django/bin/django-admin.py.

3 Verify the installation

Check that Python can find the Django modules:

$ python
>>> import django
>>> print django.get_version()

This should return something like:

http://www.domatix.com/http://www.domatix.com/wp-content/uploads/python-django-verification.png

Check that Python finds Django.

This indicates that Python detected Django in its 1.3.1 version.

3.1 Create a Django test project

We are going to create a Django test page in order to verify that everything is working fine. At first create a new directory for this:

$ mkdir ~/django-projects
$ cd ~/django-projects

In this case the directory is located in the home directory of the user and has the name django-projects. Now, create a test project in this category:

$ django-admin.py startproject testdjango

Change to the directory of the project and start the Django server:

$ cd testdjango
$ python manage.py runserver

This should return something like:

http://www.domatix.com/http://www.domatix.com/wp-content/uploads/testdjango_launched.png

Successfully started Django server.

The server started up correctly and is waiting for connections on port 8000 (http://127.0.0.1:8000/). When navigating your browser to this direction you should see a site like this:

http://www.domatix.com/http://www.domatix.com/wp-content/uploads/django-testproject_ok.png

Djangos start page.

Now, we could create a database in PostgreSQL and verify the connection with the project. But, given the aim of this article (install Zoook) we’re going into the details of the database access when configuring Zoook.

Instalar Zoook en Ubuntu – Parte II: Python y Django

2.- Instalar Django

Django puede instalarse de tres formas:

  1. Usar los sistemas de distribución de paquetes de algunas distribuciones (como Ubuntu).
  2. Descargar la versión estable desde su web.
  3. Descargar la última versión en desarrollo desde repositorios.

En el momento de escribir este artículo la versión estable de los repositorios de Ubuntu coincide con la versión estable descargable por la web. Instalar la última versión desde los repositorios de Ubuntu es tan sencillo como:

sydo apt-get install python-django

Ahora se detallará el proceso a seguir para instalar la última versión estable en caso de no estar disponible a través de repositorios de Ubuntu.

En primer lugar hay que ir a la sección de descargas de la web de Django y descargar la última versión estable/oficial de Django. En el momento de escribir este artículo la versión era la 1.3.1 y el archivo descargado es Django-1.3.1.tar.gz

Suponiendo que se ha descargado el archivo en la carpeta de usuario estos serían los pasos para generar el directorio en el que se almacenará el código fuente de Django:

cd ~
tar xvzf Django-1.3.1.tar.gz
mv Django-1.3.1 django-src

De esta forma la carpeta que contendrá el código fuente de Django queda situada en:

/home/roberto/django-src

Con la carpeta de Django preparada el siguiente paso es informarle a Python de dónde la hemos generado. Para eso, a su vez, hay que buscar dónde están los site-packages de Python.

Averiguar dónde están los site-packages de Python:

python -c "from distutils.sysconfig import get_python_lib; print get_python_lib()"

Nos devolverá algo como:

Tutorial

que indica que en este caso el directorio de los site-packages es: /usr/lib/python2.7/dist-packages

Dentro de ese directorio hay que agregar la ruta a la carpeta con el código fuente de Django.

Para agregar la ruta a Django:

echo '/home/roberto/django-src' | sudo tee -a /usr/lib/python2.7/dist-packages/django.pth

eso creará un archivo /usr/lib/python2.7/dist-packages/django.pth en cuyo interior queda almacenada la ruta de acceso a Django.

A continuación crear enlace simbólico a django-admin.py para facilitar su uso:

sudo ln -s /home/roberto/django-src/django/bin/django-admin.py /usr/local/bin

 De este modo se puede usar django-admin.py desde cualquier carpeta en lugar de tener que usar /home/roberto/django-src/django/bin/django-admin.py

3.- Verificar instalación

Comprobar que Python es capaz de encontrar Django:

python
>>> import django
>>> print django.get_version()

Que devolverá algo como:

Tutorial

que indica que Python ha detectado y conectado correctamente con la versión 1.3.1 de Django que hay en el sistema.

La siguiente verificación será crear el primer proyecto de Django para verificar que la generación funciona.

Crear una carpeta para almacenar los proyectos de Django y acceder a ella:

mkdir /home/roberto/django-projects
cd /home/roberto/django-projects

En este caso la carpeta se ha creado en el home del usuario con el nombre “django-projects” pero no es necesario que sea así. En su lugar podría haberse usado, por ejemplo, la carpeta workspace que usa Eclipse.

Crear el proyecto de prueba en la carpeta:

django-admin.py startproject testdjango

Acceder al proyecto y lanzar el servidor Django integrado:

cd testdjango
python manage.py runserver

que devuelve algo como:

  Tutorial

El servidor ha arrancado correctamente y está esperando conexiones locales en el puerto 8000 ( http://127.0.0.1:8000 ). Al abrir el navegador en la ruta indicada por el mensaje debería aparecer:

  Tutorial

El proyecto ha cargado correctamente y es accesible desde el navegador. Ahora se podría crear una base de datos en PostgreSQL y comprobar la conectividad con el proyecto pero dada la finalidad de este artículo ( instalar Zoook ) el acceso a base de datos se detallará más adelante al configurar Zoook.