La Empresa con Software Abierto

Probando Django 1.7 con Python 3

2014-11-01T07:07:00.000-07:00

Django desde la versión 1.5 es compatible con Python 3, muchos programadores han estado probando y portando sus aplicaciones de Django a esta nueva versión por las ventajas que ofrece.

¡Usa la ultima versión estable!

La última versión estable es la 3.4.2, al momento de escribir este articulo, la versión de Ubuntu 14.04 viene con la 3.4.0, es la que usare para este tutorial.

Entorno Virtual con Python 3

$ pyvenv-3.4 --without-pip py3 # py3 es el nombre del virtualenv

Activar el entorno vitual:

$ cd py3
$ source bin/activate
(py3) $

Verifica que el entorno virtual esta en Python 3:

(py3) $ python --version
Python 3.4.0

Instalar pip:

(py3) $ curl https://raw.githubusercontent.com/pypa/pip/master/contrib/get-pip.py | python

Django

(py3) $ pip install django

Crear un proyecto:

(py3) $ django-admin startproject demo
(py3) $ cd demo

Crear la base de datos en Django 1.7

(py3) $ python manage.py migrate

Servidor de Desarrollo

Probamos nuestro servidor de desarrollo a ver si todo va bien hasta ahora

(py3) $ python manage.py runserver

Performing system checks...

System check identified no issues (0 silenced).
November 01, 2014 - 03:00:12
Django version 1.7.1, using settings 'demo.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Probamos en la dirección http://127.0.0.1:8000

Creado una Aplicación

Vamos a crear una aplicación:

(py3) $ python manage.py startapp main

Creamos el modelo de la Aplicación en main/models.py

from django.db import models

class Persona(models.Model):
nombre = models.CharField(max_length=100)
apellido = models.CharField(max_length=100)

def __str__(self):
return self.nombre

Como podrán ver se usa el método __str__ en vez de __unicode__, ya que es uno de los cambios en Python 3

Agregamos main en demo/settings.py en INSTALLED_APPS

INSTALLED_APPS = (
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'main',
)

Ahora ejecutamos:

(py3) $ python manage.py makemigrations main

Mediante la ejecución de makemigrations, le decimos a Django que se han hecho algunos cambios en el modelo (en este caso, son nuevos) y que desea que los cambios se guarden como una migración.

Ahora, ejecute migrate de nuevo para crear las tablas del modelo en la base de datos

(py3) $ python manage.py migrate

Creando el usuario Administrador

Para crear un usuario que puede iniciar sesión en el sitio de administración. Ejecute el siguiente comando:

(py3) $ python manage.py createsuperuser

Como podrás ver, hasta aquí hemos creado una aplicación básica de Django usando Python 3, te recomiendo que revises la documentación para la creación de sitios web con Django.

¡Consideraciones Importantes!

Chequea siempre si los paquetes que vas a utilizar desde PyPi son compatibles con Python 3
En un proyecto Django, compruebe en los modelos, los métodos __str __ (). Si los tiene, es un buen indicador de que es compatible con Python 3.
Utilice 2to3 para escanear el código de problemas de compatibilidad.
Revisa el sitio donde va correr en producción tu aplicación, en el caso de Linux, la mayoría de las distribuciones ya tienen Python 3 instalado, y es accesible a los usuarios finales. En general, la eliminación de Python 2 por defecto, ha sido gradual. Sin embargo, hay algunos módulos clave que pueden requerir el uso de Python 2 en lugar de Python 3
Ya existen cerca de 500 paquetes de Django compatibles con Python3, eso lo puedes revisar en la pagina de Django Packages.

Aunque la mayoría del código Python está escrito para Python 2.x, Python 3 es el presente y futuro de este lenguaje de programación.

Python 2.7.8 fue lanzado en Octubre de 2014. La rama 2.x no tendrá más lanzamientos importantes, aunque la versión 2.7 en su vida útil tendrá un período prolongado de correcciones de errores y huecos de seguridad.

Python 3.x continúa siendo desarrollado activamente. El lanzamiento más reciente de Python 3.4, fue el 6 de Octubre del 2014.

Recursos útiles

Los siguientes enlaces son recursos que pueden revisar a fin de tener mas información sobre Python 3 y como portar sus aplicaciones a esta versión del lenguaje.

Python.org - Página Oficial de Python
getpython3.com - Este sitio tiene como objetivo ser un recurso para para desarrolladores de Python 3
Python 3 Porting Guide
My experiences with Django and Python 3 - Blog de Daniel Greenfeld
Pagina para revisar los módulos mas populares portados a Python 3
La Documentación de Django sobre Python 3

Para concluir aclaro que este articulo es con fines didácticos y siempre depende de usted el buscar la mejor alternativa para su aplicación web con Django. Python 2 aún tiene soporte y lo va mantener por mucho tiempo, espero que con este artículo le ayude a crear su propia estrategia de desarrollo con Django.

Registro de Usuarios para un sitio web con Django 1.6 usando Class Based Views y reCAPTCHA

2014-06-22T11:26:00.000-07:00

En esta nueva entrada veremos como registrar usuarios en un sitio web creado con Django 1.6 y utilizando las vistas basadas en clases (Class Based Views), es importante recordar que desde la versión 1.5 Django introduce soporte para un modelo de usuario configurable, donde el modelo básico sigue presente, solo que ahora podemos especificar nuestro propio modelo y el sistema de autenticación de Django lo usa perfectamente.

Hay un cambio de paradigma total en este aspecto, si eres un programador de versiones anteriores a la 1.5, donde completabas el modelo del usuario con perfiles, esto ha quedado oficialmente desaprobado en la versión 1.6 en favor de modelos de usuarios personalizados. Dichos modelos deben ser configurados en la creación inicial del proyecto. les invito a ver la documentación para ampliar mas este tema.

También se aprovecha al máximo el uso de las vistas basadas en clases (CBV), yo voy asumir que quienes están siguiendo este tutorial debe tener los conocimientos básicos del uso de Django.

También utilizaremos ReCaptcha que nos ayudara a prevenir el abuso automatizado del sitio web (por ejemplo, los comentarios no deseados o registros falsos) usando un CAPTCHA, garantizamos que sólo los seres humanos realizan estas acciones. Nos apoyaremos con una aplicación llamada django-recaptcha, para facilitarnos esta tarea.

La aplicación de registro le permitirá a un usuario ingresar sus datos y correo electrónico donde recibirá un enlace con una clave que activara su cuenta. Así de sencillo, quizás algunos se pregunten, ¿Por qué no utilizar django-registration? primero, esto lo hago con fines didácticos, segundo, si alguien quiere tener mas el control de su código esta es la mejor manera, de todas formas estoy abierto a sugerencias y mejoras. Bien, luego de esta breve introducción empecemos con el tutorial.

1.- Requisitos de Instalación:

Para este ejemplo utilizare algunos programas para facilitar la realización del tutorial, en este caso utilizare django-bootstrap3 para instalar mas sencillo el framework de css bootstrap con filtros y tags de Django templates. Y por supuesto como dije previamente instalar django-recaptcha para el captcha en el formulario de registro. Es importante cumplir con los requisitos de recaptcha y generar sus claves para tu sitio web, también puedes crearlas para tu ambiente de desarrollo. ve la documentación de recaptcha. Para instalar estas aplicaciones solo tienes que instalarlas via pip.

pip install django-bootstrap3 django-recaptcha

Revisa la documentación de ambas aplicaciones si quieres obtener mas información.

2.- Creación del modelo:

Supongamos que hemos creado el proyecto de Django y dentro de el una aplicación llamada "registro", y basándonos en la nueva forma de crear modelos de usuario, creamos models.py

from django.db import models
from django.contrib.auth.models import AbstractUser

class UserRegister(AbstractUser):
activation_key = models.CharField(max_length=30)

En este caso solo le hemos agregado a la clase abstracta de User un campo adicional, como he comentado brevemente, ustedes pueden crear sus propios modelos de usuario, de acuerdo a sus necesidades. En este caso, solo necesito un campo adicional de los que trae por defecto Django y es un campo para guardar la clave de registro. Luego se agrega el siguiente campo en el archivo settings.py:

AUTH_USER_MODEL = 'registro.UserRegister'

Revisamos que tenemos agregadas las aplicaciones que vamos a utilizar en INSTALLED_APPS como por ejemplo:

INSTALLED_APPS = (
    ...
    'bootstrap3',
    'registrar',
    'captcha',
)

Se crea el archivo admin.py, para poder seguir lo que esta registrando la base de datos por el administrador

from django.contrib import admin
from .models import UserRegister

admin.site.register(UserRegister)

Ahora creamos la base de datos con el comando python manage.py syncdb, hasta ahora solo hemos creado una aplicación con el sistema de autenticación por defecto de Django con un campo adicional. Ahora a realizar el sistema de registro de usuarios.

3.- Registro de Usuarios:

Primero vamos a crear el formulario en forms.py dentro de la aplicación. En principio se importa la clase creada en models.py, y como vamos a usar captcha para validar que no es un robot quien esta tratando de registrarse, importamos también el tipo de campo para el mismo. Creamos la clase heredada de forms y creamos los campos donde el usuario va registrar su clave y el campo captcha.

# -*- coding: UTF-8 -*-
from django import forms
from .models import UserRegister
from captcha.fields import ReCaptchaField

class RegistrationForm(forms.ModelForm):
    #Información de la clave
    password = forms.CharField( label='Clave', widget=forms.PasswordInput()
    )
    password_check = forms.CharField(label='Ingrese su clave nuevamente',
        widget=forms.PasswordInput()
    )
    captcha = ReCaptchaField(attrs={'theme' : 'clean'})

Agregamos la clase Meta para indicarle a la clase RegistrationForm con que modelo va trabajar y que campos va mostrar:

class Meta:
model = UserRegister
fields = ["username", "first_name", "last_name", "email",]

Ahora creamos los métodos para la clase RegistrationForm que haran las validaciones respectivas, asegurándose que las claves coincidan, que el usuario no exista o agreguen caracteres inválidos y evitar correos ya registrados, así nos debe quedar forms.py completo:

# -*- coding: UTF-8 -*-
from django import forms
from .models import UserRegister

import re
from captcha.fields import ReCaptchaField

class RegistrationForm(forms.ModelForm):
    #Información de la clave
    password = forms.CharField(
        label='Clave',
        widget=forms.PasswordInput()
    )
    password_check = forms.CharField(
        label='Ingrese su clave nuevamente',
        widget=forms.PasswordInput()
    )
    captcha = ReCaptchaField(attrs={'theme' : 'clean'})

    class Meta:
        model = UserRegister
        fields = ["username", "first_name", "last_name", "email",]

    def clean_password_check(self):
        """
        Revisar que ambas claves dadas coincidan
        """
        if 'password' in self.cleaned_data:
                password = self.cleaned_data['password']
                password_check = self.cleaned_data['password_check']
                if password == password_check:
                        return password_check
                raise forms.ValidationError('Claves no coinciden.')

    def clean_username(self):
        """
        Chequear que el usuario no exista y validar los caracteres ingresados
        """
        username = self.cleaned_data['username']
        if not re.search(r'^\w+$', username):
                raise forms.ValidationError('Usuario solo puede contener '
                                            'caracteres alfanumericos y underscore o piso.')
        try:
                UserRegister.objects.get(username=username)
        except UserRegister.DoesNotExist:
                return username
        raise forms.ValidationError('Nombre de usuario ya existe')

    def clean_email(self):
        """
        Validar que la direccion de correos dada sea unica en el proyecto
        """
        if UserRegister.objects.filter(email__iexact=self.cleaned_data['email']).count():
            raise forms.ValidationError(u'Esta dirección de correos esta en uso, por favor utilice otra')
        return self.cleaned_data['email']

Ahora en views.py se crea la clase para el registro de usuario, donde utilizaremos las librerías de Python random y string para crear la clave de 20 dígitos y grabarla en el campo activation_key que agregamos en el modelo y preparar el correo electrónico con el enlace a ser enviado al nuevo usuario para activar su cuenta, ya que hasta este momento esta registrado pero inactivo. Para esto hay que configurar a Django para que envié correos electrónicos, solo agrega estas lineas en settings.py:

#Aqui va la configuracion del servidor de correo (en este caso GMAIL)
EMAIL_HOST = 'smtp.gmail.com'
EMAIL_PORT = 587
EMAIL_HOST_USER = 'usuario@gmail.com'
EMAIL_HOST_PASSWORD = 'suclave'
EMAIL_USE_TLS = True

Así queda views.py

# -*- coding: UTF-8 -*-
from django.views.generic import CreateView
from django.core.mail import EmailMultiAlternatives
from django.http import HttpResponseRedirect
import random, string

from .models import UserRegister
from .forms import RegistrationForm

class UserCreateView(CreateView):
    model = UserRegister
    form_class = RegistrationForm
    template_name = 'register/register.html'

    def form_valid(self, form):
        form.instance.is_active = False
        form.instance.activation_key = ''.join(random.choice(string.ascii_uppercase + string.digits)
                                               for n in range(20))
        usuario = form.cleaned_data.get('email')
        html_content = 'Por favor visite http://midominio.com/activar/%s/ para activar su cuenta' \
                       %(form.instance.activation_key)
        msg = EmailMultiAlternatives('Código de Activación',html_content,\
                                     'registration@midiminio.com',[usuario])
        msg.attach_alternative(html_content,'text/html') # Definimos el contenido como HTML
        msg.send() # Enviamos el correo
        return super(UserCreateView, self).form_valid(form)

Ahora crea urls.py, pero antes agrega la linea en urls.py del proyecto para incluir las urls de la aplicación:

#urls.py en el Proyecto
from django.conf.urls import patterns, include, url

from django.contrib import admin
admin.autodiscover()

urlpatterns = patterns('',
url(r'^register/', include('register.urls')), # Agrega esta linea

url(r'^admin/', include(admin.site.urls)),
)

Crea el archivo urls.py dentro de tu aplicación:

from django.conf.urls import patterns, include, url
from .views import *

urlpatterns = patterns('.views',
url(r'^$', UserCreateView.as_view(), name='register'),
)

Ahora configura los templates dentro de settings.py

TEMPLATE_DIRS = (
os.path.join(BASE_DIR, "templates"),
)

Crea la carpeta templates donde esta manage.py (Esto por supuesto depende de la configuración). Este es un ejemplo como quedaría el árbol del proyecto:

Crea el template base y lo llamas base.html

{% load bootstrap3 %}
<!DOCTYPE html>

<html>
<head>
    {# Load CSS and JavaScript #}
    {% bootstrap_css %}
    {% bootstrap_javascript %}
    <title>{% block title %}Ejemplo{% endblock %}</title>
</head>

<body>

<div class="container">
    {% block body_block %}This is body_block's default content.{% endblock %}
</div>

</body>
</html>

Este template carga primeramente bootstrap3 gracias a la aplicación que cargamos al principio django-bootstrap3. Ahora crea el formulario, en este caso podemos crear una carpeta para ordenar los templeates de acuerdo a la aplicación que pertenecen:

{% extends 'base.html' %}
{% load bootstrap3 %}

{% block title %}Formulario de Registro{% endblock %}

{# Display django.contrib.messages as Bootstrap alerts #}
    {% bootstrap_messages %}

{# Display a form #}
{% block body_block %}
<form action="" method="post" class="form">
    {% csrf_token %}
    {% bootstrap_form form %}
    {% buttons %}
        <button type="submit" class="btn btn-primary">
            {% bootstrap_icon "star" %} Submit
        </button>
    {% endbuttons %}
</form>
{% endblock %}

Arrancamos el servidor y colocamos la dirección http://127.0.0.1:8000/register/ en el navegador.

Registramos el primer usuario él cual enviara el correo electrónico y al revisar por admin y vemos que el usuario existe, solo que esta inactivo. El cuerpo del correo sera:

Por favor visite http://midominio/activar/MNP54P4WB50W4N9NJIXG/ para activar su cuenta

Para activarlo, crea una clase en views.py que recibirá por la url el código de activación enviado al correo electrónico del usuario.

class ActivteUserView(View):

    def dispatch(self, *args, **kwargs):
        self.codigo = self.kwargs['codigo']
        return super(ActivteUserView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        try:
            self.usuario = UserRegister.objects.get(activation_key=self.codigo)
            if self.usuario.is_active == False:
                self.usuario.is_active = True
                self.usuario.save()
                return HttpResponseRedirect("/register/activo_exito/")
            else:
                return HttpResponseRedirect("/register/activo/")
        except UserRegister.DoesNotExist:
            return HttpResponseRedirect('/register/error_activacion')

Como se ve en el codigo tenemos unas redirecciones en cada caso, si tuvo exito, si ya esta registrado o simplemente un codigo errado, para ellos creamos las vistas necesarias.

class ErrorActiveView(TemplateView):
    template_name = 'register/error_activacion.html'

class UserActiveErrorView(TemplateView):
    template_name = 'register/usuario_ya_activo.html'

class UserActiveView(TemplateView):
    template_name = 'register/usuario_activo.html'

Hay que importar las nuevas clases utilizadas: TemplateView y View

from django.views.generic import CreateView, TemplateView, View

Así queda views.py completo:

# -*- coding: UTF-8 -*-
from django.views.generic import CreateView, TemplateView, View
from django.core.mail import EmailMultiAlternatives
from django.http import HttpResponseRedirect
import random, string

from .models import UserRegister
from .forms import RegistrationForm

class ErrorActiveView(TemplateView):
    template_name = 'register/error_activacion.html'

class UserActiveErrorView(TemplateView):
    template_name = 'register/usuario_ya_activo.html'

class UserActiveView(TemplateView):
    template_name = 'register/usuario_activo.html'

class UserCreateView(CreateView):
    model = UserRegister
    form_class = RegistrationForm
    template_name = 'register/register.html'

    def form_valid(self, form):
        form.instance.is_active = False
        form.instance.activation_key = ''.join(random.choice(string.ascii_uppercase + string.digits)
                                               for n in range(20))
        usuario = form.cleaned_data.get('email')
        html_content = 'Por favor visite http://midominio.com/activar/%s/ para activar su cuenta' \
                       %(form.instance.activation_key)
        msg = EmailMultiAlternatives('Código de Activación',html_content,\
                                     'registration@midominio.com',[usuario])
        msg.attach_alternative(html_content,'text/html') # Definimos el contenido como HTML
        msg.send() # Enviamos el correo
        return super(UserCreateView, self).form_valid(form)

class ActivteUserView(View):

    def dispatch(self, *args, **kwargs):
        self.codigo = self.kwargs['codigo']
        return super(ActivteUserView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        try:
            self.usuario = UserRegister.objects.get(activation_key=self.codigo)
            if self.usuario.is_active == False:
                self.usuario.is_active = True
                self.usuario.save()
                return HttpResponseRedirect("/register/activo_exito/")
            else:
                return HttpResponseRedirect("/register/activo/")
        except UserRegister.DoesNotExist:
            return HttpResponseRedirect('/register/error_activacion')

Agregamos las urls que faltan en urls.py:

from django.conf.urls import patterns, include, url
from .views import *

urlpatterns = patterns('.views',
                       url(r'^$', UserCreateView.as_view(), name='register'),
                       url(r'^activar/(?P<codigo>.+)/$', ActivteUserView.as_view(), name='activar_user'),
                       url(r'^activo/$', UserActiveErrorView.as_view(), name='activo'),
                       url(r'^activo_exito/$', UserActiveView.as_view(), name='exito_activo'),
                       url(r'^error_activacion/$', ErrorActiveView.as_view(), name='error_activacion'),
)

Se realizan los templates html faltantes:
error_activacion.html:

{% extends 'base.html' %}
{% load bootstrap3 %}

{% block title %}Error de Activacion{% endblock %}

{# Display a form #}
{% block body_block %}
    <div class="container">
        <h1 class="text-muted">Error en Activacion</h1>
    </div>

{% endblock %}

usuario_activo.html

{% extends 'base.html' %}
{% load bootstrap3 %}

{% block title %}Usuario Activo{% endblock %}

{# Display a form #}
{% block body_block %}
    <div class="container">
        <h1 class="text-muted">Usuario Activo</h1>
    </div>

{% endblock %}

usuario_ya_activo.html:

{% extends 'base.html' %}
{% load bootstrap3 %}

{% block title %}Error de Activacion{% endblock %}

{# Display a form #}
{% block body_block %}
    <div class="container">
        <h1 class="text-muted">Error, Usuario ya activo</h1>
    </div>

{% endblock %}

Revisamos nuevamente por admin y veremos que el usuario aparece tildado activo y ya puedes controlar el sitio solo para usuarios registrados. Espero que sea de utilidad y no duden en dejar sus comentarios. Hasta la próxima.

Django en Producción con Centos, PostgreSQL, Virtualenv, Gunicorn, Nginx y Supervisor

2013-10-09T16:43:00.000-07:00

En este articulo vamos llevar a un entorno de Producción nuestra aplicación que creamos con Django, para ello vamos a utilizar varias herramientas:

Nos basaremos en el sistema operativo Centos 6.4 que es el clon libre del Red Hat Enterprise Server, un sistema operativo Linux hecho para servidores. en el caso de otras distribuciones de Linux, solo busca como instalar los paquetes y donde están ubicados sus archivos de configuración.

Puedes hacer esto en un servidor local, o puedes utilizar cualquiera de los proveedores que dan servicio de VPS.

Voy a asumir que usted conoce o sabe como configurar su servidor para apuntar un dominio a la dirección IP del servidor.

1.- Crear un usuario donde va estar nuestro proyecto y darle permisos de Administrador

como usuario root, ejecutamos:

[root@localhost ~]# useradd django

luego editamos el archivo /etc/sudoers, con tu editor de preferencia

[root@localhost ~]# vim /etc/sudoers

allí agrega debajo de la linea donde esta root:

## Allow root to run any commands anywhere
root ALL=(ALL) ALL
django ALL=(ALL) ALL

2.- Instalar PostgreSQL

Yo particularmente recomiendo que cuando este en el proceso de instalación de Centos, escoge la opción de Servidor de Base de datos, para tener ya PostgreSQL instalado, en caso contrario, instalarlo con el siguiente comando:

[root@localhost ~]# yum install postgresql postgresql-server postgresql-contrib

Ahora iniciamos el servidor PostgreSQL

[root@localhost ~]# service postgresql initdb

Arrancamos el servicio:

[root@localhost ~]# service postgresql start

Y lo configuramos para que arranque cada vez que iniciemos el servidor:

[root@localhost ~]# chkconfig postgresql on

Luego configuramos los archivos pg_hba.conf y postgres.conf para poder conectarnos al PostgreSQL, por favor revise la documentación para ver las opciones de configuración para su servidor. Editamos postgres.conf

[root@localhost ~]# vi /var/lib/pgsql/data/postgresql.conf

Descomentar las siguientes lineas y agregamos * en la variable listen_addresses si queremos administrar nuestro PostgreSQL desde cualquier equipo:

listen_addresses = '*'
port = 5432

Ahora editamos pg_hba.conf:

[root@localhost ~]# vi /var/lib/pgsql/data/pg_hba.conf

Y cambiamos la siguiente linea por esto:

# TYPE DATABASE USER CIDR-ADDRESS METHOD
# "local" is for Unix domain socket connections only
local all all trust

Ahora reiniciamos nuestro servicio:

[root@localhost ~]# service postgresql restart

Le asignamos una clave al usuario que viene por defecto llamado postgres en la Base de Datos

[root@localhost ~]# su postgres
bash-4.1$
bash-4.1$ psql
could not change directory to "/root"
psql (8.4.13)
Type "help" for help.
postgres=# ALTER ROLE postgres WITH PASSWORD 'abc123';
postgres=# \q
bash-4.1$

En este caso se le asigno la clave abc123, coloque la que mas le conviene.

Y esta nuestro servidor funcionando, ahora creamos nuestro usuario y base de datos para nuestra aplicación:

bash-4.1$ createuser django -P
could not change directory to "/root"
Enter password for new role:
Enter it again:
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) n
Shall the new role be allowed to create more new roles? (y/n) n
bash-4.1$

Ya tenemos creado el usuario django en PostgreSQL, ese es el usuario que colocaremos en el archivo settings.py de Django, ahora creamos la base de datos de nuestra aplicación:

bash-4.1$ psql
could not change directory to "/root"
psql (8.4.13)
Type "help" for help.
postgres=# CREATE DATABASE mibasedatos OWNER django;
GRANT
postgres=# \q
bash-4.1$ exit

3.- Instalar el repositorio EPEL (Extra Packages for Enterprise Linux):

[root@localhost ~]# wget http://ftp.riken.jp/Linux/fedora/epel/RPM-GPG-KEY-EPEL-6
[root@localhost ~]# rpm --import RPM-GPG-KEY-EPEL-6
[root@localhost ~]# rm -f RPM-GPG-KEY-EPEL-6

Instalamos en este caso para Centos de 64:

[root@localhost ~]# wget http://ftp.riken.jp/Linux/fedora/epel/6/x86_64/epel-release-6-8.noarch.rpm
[root@localhost ~]# rpm -ivh epel-release-6-8.noarch.rpm
[root@localhost ~]# yum update

4.- Instalamos Nginx

[root@localhost ~]# yum install nginx

Arrancamos el servicio y lo configuramos para que arranque cada vez que inicie la maquina:

[root@localhost ~]# service nginx start
[root@localhost ~]# chkconfig nginx on

Nota: debemos inhabilitar el firewall que viene por defecto o configurar para acepte peticiones, en nuestro caso lo vamos a inhabilitar:

[root@localhost ~]# service iptables stop

Probamos nuestro servidor Web en nuestro navegador: http://localhost

5.- Instalar Python y librerías necesarias

Instalamos Python y las librerías y componentes necesarios para que nuestra aplicación funcione correctamente con PostgreSQL

[root@localhost ~]# yum install python python-devel python-setuptools python-pip libxml2-devel

Ademas vamos a instalar gcc, el compilador de C y postgresql-devel. que nos lo exige el psycopg2 para conectarnos desde Django a PostgreSQL

[root@localhost ~]# yum install gcc postgresql-devel

6.- Instalación de Virtualenv

Para instalar virtualenv, utilizamos pip, ya aquí podemos ingresar con nuestro usuario que creamos al principio:

[django@localhost ~]$ sudo pip install virtualenv

Al terminar de instalar, procedemos a crear nuestro ambiente para la aplicación que vamos colocar en producción:

[django@localhost ~]$ virtualenv ~/env

Para activar ejecutamos:

[django@localhost ~]$ source ~/env/bin/activate

Y miren como nos cambia el prompt

(env)[django@localhost ~]$

Todo lo que instalemos aquí vía pip, solo estará en este ambiente, esto es muy útil cuando vamos a tener varias aplicaciones con diferentes versiones de Django

7.- Instalamos Django, psycopg2 y nuestra aplicación

Dentro de nuestro ambiente virtual, este pendiente que tengamos en el prompt los paréntesis con nuestro ambiente "(env)[django@localhost ~]$", instalamos lo que requerimos para nuestra aplicación, primero por supuesto Django:

(env)[django@localhost ~]$ pip install django

La librería para conectarnos a PostgreSQL:

(env)[django@localhost ~]$ pip install psycopg2

La aplicación la copiamos al directorio que queramos, puede ser en /opt/webapps, o donde ustedes lo consideren:

(env)[django@localhost ~]$ sudo mkdir -p /opt/webapps
[sudo] password for django:

Lo mas importante es que el directorio tenga permiso de lectura:

drwxr-xr-x. 4 root root 4096 oct 9 19:31 /opt

Cambiamos el usuario de la carpeta webapps:

(env)[django@localhost ~]$cd /opt
(env)[django@localhost opt]$ sudo chown django:nginx webapps
[sudo] password for django:

Solo para probar creamos una aplicación en Django:

(env)[django@localhost opt]$ cd webapps/
(env)[django@localhost webapps]$ django-admin.py startproject demo
(env)[django@localhost webapps]$ cd demo
(env)[django@localhost demo]$ python manage.py runserver
Validating models...
0 errors found
October 09, 2013 - 19:12:55
Django version 1.5.4, using settings 'demo.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Ya podemos ver que nuestro servidor de desarrollo funciona en nuestro navegador con http://127.0.0.1:8000

Nos queda configurar Django con la Base de datos y podemos empezar a crear las tablas de nuestra aplicación:

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'mibasedatos',
'USER': 'django',
'PASSWORD': 'abc123',
'HOST': 'localhost',
'PORT': '',
}
}

Solo queda que montes tu aplicación y crear las tablas de tu base de datos en el servidor, ahora a configurar Gunicorn y Nginx:

8.- Instalando y configurando Gunicorn

Gunicorn es también conocido como Green Unicorn (Unicornio Verde), es un servidor WSGI HTTP para Python. Es un pre-fork del proyecto Unicorn de Ruby. Gunicorn es compatible con varios frameworks, soporta WSGI, Django y Paster de forma nativa; consume pocos recursos en ejecución y es bastante rápido. Aquí solo voy a tratar lo básico, cualquier configuración adicional, por favor busque la documentación. Para instalarlo:

(env)[django@localhost opt]$ pip install gunicorn

Probemos nuestra pequeña aplicación con Gunicorn:

(env)[django@localhost demo]$ gunicorn -w3 demo.wsgi:application --bind 127.0.0.1:8000
2013-10-09 20:14:49 [8571] [INFO] Starting gunicorn 18.0
2013-10-09 20:14:49 [8571] [INFO] Listening at: http://127.0.0.1:8000 (8571)
2013-10-09 20:14:49 [8571] [INFO] Using worker: sync
2013-10-09 20:14:49 [8576] [INFO] Booting worker with pid: 8576
2013-10-09 20:14:49 [8577] [INFO] Booting worker with pid: 8577
2013-10-09 20:14:49 [8578] [INFO] Booting worker with pid: 8578

Ahora podemos probar en nuestro navegador http://127.0.0.1:8000 y allí tenemos nuestra aplicación corriendo en un servidor WSGI HTTP

El comando gunicorn ofrece una extensa lista de opciones para configurar su comportamiento, pero las que he utilizado en esta oportunidad son:

-w INT: número de procesos workers que se arrancarán para servir las peticiones.Este dependerá en medida de la carga de trabajo que tenga la aplicación, también depende del hardware con que se cuente, de acuerdo a la siguiente formula: 2*CPU +1, Para las maquinas que tienen un solo procesador escriba 3.

demo.wsgi:application: la ubicación del archivo wsgi.py y escribimos después de los dos puntos application

--bind ADDRESS: es posible especificar tanto HOST:PUERTO para decirle a gunicorn por donde va recibir peticiones

Bien, hagamos un script para que levante el entorno virtual y ejecute nuestra aplicación con Gunicorn. lo creamos en nuestro home

(env)[django@localhost opt]$ cd
(env)[django@localhost opt]$ vi gunicorn_start.sh

y escribimos en nuestro archivo:

#!/bin/sh
NAME="demo"
DJANGODIR="/opt/webapps/demo"
NUM_WORKERS=3
echo "Arrancando Demo"
cd $DJANGODIR
source ~/env/bin/activate
exec gunicorn -w $NUM_WORKERS $NAME.wsgi:application --bind 127.0.0.1:8000

Salimos del ambiente virtual y ejecutamos para probarlo:

(env)[django@localhost ~]$ deactivate
[django@localhost ~]$ chmod +x gunicorn_start.sh
[django@localhost ~]$ ./gunicorn_start.sh
Arrancando Demo
2013-10-09 20:41:26 [8686] [INFO] Starting gunicorn 18.0
2013-10-09 20:41:26 [8686] [INFO] Listening at: http://127.0.0.1:8000 (8686)
2013-10-09 20:41:26 [8686] [INFO] Using worker: sync
2013-10-09 20:41:26 [8695] [INFO] Booting worker with pid: 8695
2013-10-09 20:41:26 [8696] [INFO] Booting worker with pid: 8696
2013-10-09 20:41:26 [8697] [INFO] Booting worker with pid: 8697

Como podemos ver nos queda nuestro terminal con la aplicación y no nos deja hacer mas nada y si lo cerramos, se cae la aplicación, esto lo vamos a resolver con Supervisor

9.- Instalando y Configurando Supervisor

Supervisor es un sistema cliente servidor que permite a los usuarios monitorear y controlar una serie de procesos en los sistemas operativos tipo UNIX.

Comparte algunos de los mismos objetivos de los programas como launchd , daemontools y runit . A diferencia de algunos de estos programas, no está diseñada para ejecutarse como un sustituto de init. En cambio, está destinado a ser utilizado para el control de procesos relacionados con un proyecto o un cliente, y está destinado a iniciar como cualquier otro programa en el arranque.

le damos Ctrl-C, para salir de Gunicorn y liberar la terminal, instalamos ahora Supervisor con yum:

[django@localhost ~]$ sudo yum install supervisor

Una vez instalado configuramos supervisor para nuestra aplicación en /etc/supervisord.conf. Hay que hacerlo como root:

[django@localhost ~]$ su -
Contraseña:
[root@localhost ~]# vi /etc/supervisord.conf

Agregamos lo siguiente al final del archivo:

[program:demo]
command=/home/django/gunicorn_start.sh
user=django
autostart=true
stdout_logfile=/opt/webapps/demo/logs/gunicorn_supervisor.log
redirect_stderr=true

Creamos la carpeta y archivo para los logs:

[root@localhost ~]# exit
[django@localhost ~]$ mkdir -p /opt/webapps/demo/logs
[django@localhost ~]$ touch /opt/webapps/demo/logs/gunicorn_supervisor.log

Arrancamos Supervisor y lo configuramos para que arranque siempre

[django@localhost ~]$ sudo service supervisord start
[django@localhost ~]$ sudo chkconfig supervisord on

Reiniciamos el servicio propiamente de Supervisor:

[django@localhost ~]$sudo supervisorctl reload
Restarted supervisord

Y ahora veremos nuestra aplicación corriendo:

[django@localhost ~]$ sudo supervisorctl status demo
[sudo] password for django:
demo RUNNING pid 8883, uptime 0:11:29

Para detenerla:

[django@localhost ~]$ sudo supervisorctl stop demo

Para reiniciarla:

[django@localhost ~]$ sudo supervisorctl restart demo

Listo ya tenemos nuestra aplicación lista para que arranque al iniciar el servidor

10.- Configuración de Nginx

Buscamos el archivo de configuración de nginx en /etc/nginx/conf.d llamado default.conf y lo cambiamos totalmente por esto:

server {
listen 80;
server_name ejemplo.com;
access_log /var/log/nginx/server.log;
root /opt/webapps/demo;
location /static/ {
autoindex on;
alias /opt/webapps/demo/static/;
}
location /media/ {
autoindex on;
alias /opt/webapps/demo/media/;
}
location / {
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}

Lo importante, tu carpeta static y media, es importante colocar la ruta exacta hacia esos archivos, de lo contrario, no te permitirá ver los estilos de tu aplicación. Otra cosa importante es la dirección por donde esta sirviendo tu aplicación el Gunicorn.

Reiniciamos nuestro servicio de Nginx y a probar nuestra aplicación

[django@localhost ~]$ sudo service nginx start

Listo, espero sus comentarios y sugerencias, hasta la próxima.

jQuery Autocomplete en Django

2013-09-29T19:47:00.000-07:00

Hola todos, esta vez vamos hacer algo muy útil cuando tenemos un campo estilo ForeignKey y se nos hace muy grande cuando tenemos muchos datos, como sabemos un campo ForeignKey nos hace un campo select en el formulario.

Tenemos el siguiente modelo:

class Persona(models.Model):
cedula = models.CharField(unique=True, max_length=10)
nombres = models.CharField(verbose_name='Nombres', max_length=60)
apellidos = models.CharField(verbose_name='Apellidos', max_length=60)

class Proyecto(models.Model):
titulo = models.CharField(max_length=200)
autor = models.ForeignKey(Persona)

Ahora vamos a crear el forms.py, donde vamos a crear un campo adicional, que vamos a llamar persona_display:

class ProyectoForm(forms.ModelForm):
persona_display = forms.CharField(max_length=100, help_text='tipee Cedula, Nombre o Apellido')

class_Meta:
model = Proyecto
fields=('titulo', 'persona_display', 'autor',)

def __init__(self, *args, **kwargs):
super(ProyectoForm, self).__init__(*args, **kwargs)
self.field['persona_display'].label = "Agrege el Autor"
self.fields['autor'].widget = forms.HiddenInput()

¿Qué hemos hecho hasta aquí?

Primero creamos nuestro formulario donde agregamos un campo adicional llamado persona_display, en el constructor de la clase hemos dado algunas características al campo persona lo hemos ocultado y le hemos agregado una etiqueta al nuevo campo persona_display

Ahora creamos nuestra url en urls.py:

url(r'^persona/autocomplete/$', 'persona_auto_complete', name='persona_auto_complete'),

Ahora la vista en views.py:

def persona_auto_complete(request):
q = request.REQUEST['term']
if q:
qset = (
Q(cedula__istartswith=q) |
Q(nombres__icontains=q) |
Q(apellidos__icontains=q)
)
personas = Persona.objects.filter(qset).distinct()
else:
personas = []
personas_list = []
for p in personas:
value = '%s, (%s, %s)' % (p.cedula, p.nombres, p.apellidos)
p_dict = {'id': p.id, 'label': value, 'value': value}
personas_list.append(p_dict)
return HttpResponse(simplejson.dumps(personas_list))

Ahora podemos probar lo que hemos hecho, escribiendo en nuestro navegador:

http://localhost:8000/persona/autocomplete/?term=an

En este caso estamos buscando las personas que contengan en el nombre o apellido las letras "an" y nos mostrara un resultado como este:

[{"id": 3, "value": "1234567, (Ana Cecilia, La Cruz)", "label": "1234567, (Ana Cecilia, La Cruz)"}]

Si tenemos este resultado, ya podemos ahora agregar el código JQuery del plugin AutoComplete en nuestro template:

Recuerde que debe agregar los css del Jquery:

<link rel="stylesheet" href="http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css">

el formulario:

<form action="" method="post">{% csrf_token %}
<div class="forms">
{{ form }}
<input type="submit" name="submit" value="Salvar" />
</div>
</form>

Y ahora el JQuery y JQuery UI con el script de que hace accionar nuestro autocomplete:

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js" type="text/javascript"></script>
<script src="http://code.jquery.com/ui/1.10.3/jquery-ui.js"></script>
<script>
$( document ).ready( function() {
$("#id_persona_display").autocomplete({
source: "{% url 'persona_auto_complete' %}",
dataType: "jsonp",
selectFirst: true,
minLength: 2,
select: function(event,ui) {
$("#id_autor").val(ui.item.id)
}
});
});
</script>

Explicando un poco, estamos activando el auto complete en el campo que creamos en el form.py llamado persona_display, llamamos la url del autocomplete en la vista y le decimos por el parámetro minLength que empiece a buscar a partir del segundo carácter y al escoger le agregamos el id al campo autor, para que no nos de error, ya que es un campo requerido por ser clave.

Este es un ejemplo de como nos quedara el autocomplete,

Y eso es todo, espero que les sirva y lo pongan en practica en sus proyectos. Espero sus comentarios. Hasta la próxima.

Chequear disponibilidad de Campo Clave en Django 1.5

2013-09-17T19:36:00.000-07:00

Hoy vamos a hacer algo para validar un campo en un formulario, cuando le quitamos el foco al campo, este revisara en la base de datos, si ya existe, y no al final al hacer el submit. Esto es útil, para verificar si esta tomado el nombre de usuario, en caso de registro de usuarios, así como saber si el numero de identificación o cédula ya existe, entre otros.

Empecemos:

primero creamos nuestra url en urls.py

url(regex=r'^check_cedula/(?P<cedula>\d+)/$',
view=CedulaCheck.as_view(),
name='check_cedula'
),

Ahora nos vamos a nuestra vista views.py:

class CedulaCheck(TemplateView):

def dispatch(self, *args, **kwargs):
self.cedula = self.kwargs['cedula']
return super(CedulaCheck, self).dispatch(*args, **kwargs)

def get(self, request, *args, **kwargs):
if Persona.objects.filter(cedula__iexact=self.cedula):
return HttpResponse(False)
else:
return HttpResponse(True)

ya con esto podemos probar nuestra url con un numero de cédula y nos devolverá si existe o no

http://localhost:8000/check_cedula/12345678/

Ahora nos vamos a poner en acción nuestra API recién creada con un formulario, primero creamos nuestra clase en views.py:

class PersonaCreateView(CreateView):
model = Persona
template_name = 'home/add_persona.html'

En nuestro html, nos vamos al campo que vamos a validar, es de notar que hice mi formulario a mano, no usando la plantilla de Django para crear los campos:

<div class="control-group">
<label for="cedula" class="control-label">
Cedula:
</label>
<div class="controls">
<input name="cedula" type="text" value="" id="cedula">
<span class="help-inline" id="idval"> Escriba su Cedula de Identidad</span>
</div>
</div>

y le agregamos el siguiente código jquery

<script>
function CheckId() {
$.get('/check_cedula/'+escape($('#cedula').val())+'/',
function(data){
if(data == "True"){
$('#idval').html("<i class='icon-ok'></i> Cedula disponible");
} else {
$('#idval').html("<i class='icon-remove'></i> Cedula existe");
}
});
}
function onChange(){
$("#cedula").change( function() {CheckId()});
}
$(document).ready(onChange);
</script>

Y listo, cuando coloquemos una cédula que ya existe, al dejar el foco del campo, nos dará una advertencia que ya existe y así no tenemos que escribir todos los campos y darle submit para que nos de el error.

Hasta la proxima

Fotos con webcam usando Django 1.5 y JpegCam

2013-09-15T18:08:00.000-07:00

Hola nuevamente

Tenia un poco abandonado mi blog, debido a razones de trabajo, hoy vengo nuevamente a hablarles de Django, el framework de Python, esta vez, vamos a ver cosas interesantes como el tomar una instantánea o fotografía desde nuestra webcam utilizando una librería de Flash y Javascript.

Jpegcam es un interesante componente de Flash/JavaScript para capturar y guardar imágenes desde la webcam del usuario. Se puede utilizar por ejemplo para permitir a los usuarios hacer una imagen de sí mismos como avatares, o para completar su perfil.

Es un widget que a través de flash muestra una vista en vivo de la webcam y botones con funciones Javascript asociadas que puede capturar y enviar una imagen a un servidor en modo POST.

¿Qué debemos hacer?

Descargar la ultima versión de Jpegcam y agrégalo a tu carpeta de statics en tu proyecto Django, esta consta de archivos que son: shutter.mp3, webcam.js, webcam.swf
Editamos el archivo webcam.js y buscamos para configurar los path de swf_url y shutter_url. En mi caso:

swf_url: '/static/jpegcam/webcam.swf'
shutter_url: '/static/jpegcam/shutter.mp3'

Y mas abajo en el archivo, aproximadamente en la linea 166, agregar el path:

this.shutter_url = url ? url : '/static/jpegcam/shutter.mp3';

Ahora nos vamos a Django, quiero manifestar que esta guía esta hecha para personas que han programado con Django y tienen conocimientos básicos del framework.

Primero creamos nuestro modelo de datos, donde vamos a almacenar los datos de la persona a registrar y su fotografía.

models.py

from django.db import models
import os
def get_image_name(instance, filename):
f, ext = os.path.splitext(filename)
archivo = '%s%s' % (instance.cedula, ext)
return os.path.join('webcamimages', archivo)

class Persona(models.Model):
"""docstring for Personal"""
cedula = models.CharField(max_length=10)
nombres = models.CharField(max_length=60)
apellidos = models.CharField(max_length=60)
foto = models.ImageField(upload_to=get_image_name, blank=True, null=True)

def __unicode__(self):
return self.cedula

@models.permalink
def get_absolute_url(self):
return ('persona', [str(self.id)])

def _get_full_name(self):
"Retorna los nombres completos de Persona"
return '%s %s' % (self.nombres, self.apellidos)

full_name = property(_get_full_name)

Les explico un poco el modelo, primero tenemos una función llamada get_image_name, esta función nos sirve para llamar los archivos que subamos por la opción file del formulario, siempre tendrán el nombre del campo cedula con su extensión, si mi cédula es 12345 y estoy cargando el archivo foto.jpg, esta función lo renombrada y lo guardara como 12345.jpg en la carpeta webcamimages dentro de media.

foto = models.ImageField(upload_to=get_image_name, blank=True, null=True)

Ahora nos vamos a nuestro url.py, donde tenemos estas dos entradas:

url(regex=r'^persona/$',
view= PersonaCreateView.as_view(),
name='add_persona'
),
url(regex=r'^save_image/(?P<cedula>\d+)/$',
view=SaveImage.as_view(),
name='salvar_imagen'
),

La que nos interesa en este momento es la de save_image, ya que es la url que usaremos para tomar la fotografía, la otra es para que el formulario guarde la información dada.

Ahora crearemos nuestro views.py

from django.views.generic import TemplateView, CreateView, DetailView, ListView
from django.views.decorators.csrf import csrf_exempt
from django.http import HttpResponse
from django.conf import settings
from .models import Persona

class SaveImage(TemplateView):

@csrf_exempt
def dispatch(self, *args, **kwargs):
self.filename = self.kwargs['cedula']+'.jpg'
return super(SaveImage, self).dispatch(*args, **kwargs)

def post(self, request, *args, **kwargs): # save it somewhere
f = open(settings.MEDIA_ROOT + '/webcamimages/'+ self.filename, 'wb')
f.write(request.body)
f.close()
# return the URL
return HttpResponse("/media/webcamimages/" + self.filename)

def get(self, request, *args, **kwargs):
return HttpResponse('No esta pasando el POST')

class PersonaCreateView(CreateView):
model = Persona
template_name = 'home/add_persona.html'

def form_valid(self, form):
form.instance.foto = 'webcamimages/'+ form.instance.cedula + ".jpg"
return super(PersonaCreateView, self).form_valid(form)

Como ven, tenemos dos clases, la primera SaveImage, que es la que nos toma la instantánea y la guarda en la carpeta webcamimages con la cédula de la persona, la otra es la que guarda en base de datos y toma la dirección donde esta guardada la imagen y la agrega en el campo foto.

Ahora hacemos el html, llamado en nuestro caso add_persona.html

{% extends "base.html" %}
{% block extra_css %}

<script type="text/javascript" src="{{ STATIC_URL }}jpegcam/webcam.js"></script>
{% endblock extra_css %}
{% block contenido %}
<h1>Registrar Persona</h1>
<form class="span10" action="" method="POST" enctype="multipart/form-data">
{% csrf_token %}
<div class="row well">
<div class="span6">
<div class="control-group">
<label for="cedula" class="control-label">
Cedula:
</label>
<div class="controls">
<input name="cedula" type="text" value="" id="cedula">
<span class="help-inline"> Escriba su Cedula de Identidad</span>
</div>
</div>
<div class="control-group">
<label for="nombres" class="control-label">
Nombres:
</label>
<div class="controls">
<input name="nombres" type="text" value="" id="nombres">
</div>
</div>
<div class="control-group">
<label for="apellidos" class="control-label">
Apellidos:
</label>
<div class="controls">
<input name="apellidos" type="text" value="" id="apellidos">
</div>
</div>
<div class="control-group">
<label for="foto" class="control-label">
Foto:
</label>
<div class="controls">
<input name="foto" type="file" value="" id="foto">
<a href="#takephoto" role="button" data-toggle="modal" class="btn btn-warning">Tomar Foto</a>
</div>
</div>
</div>
<div class="span3" id="fotoview">
</div>
</div>
<button type="submit" class="btn btn-primary pull-right">Guardar</button>
</form>

<div id="takephoto" class="modal hide fade" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
<h3 id="myModalLabel">Camara</h3>
</div>
<div class="modal-body">

<script language="JavaScript">
document.write( webcam.get_html(320, 240) );
</script>
</div>
<div class="modal-footer">
<button class="btn" data-dismiss="modal" aria-hidden="true">Cerrar</button>
<button class="btn btn-primary" onClick="take_snapshot()" >Fotografíar</button>
</div>
</div>
{% endblock contenido %}

Lo primero es cargar la librería jpegcam.js, luego creamos nuestro formulario, aquí estoy usando bootstrap para ayudarme con los estilos, utilizo una ventana modal para activar la cámara y tomar la fotografía. Aquí algunos captura de pantalla de la aplicación final:

Y listo, quiero manifestar que hay formas de utilizar la cámara sin usar flash, el cual esta muy cuestionado por el tema de seguridad, mas esto les puede servir en un entorno empresarial, esta aplicación la pueden descargar desde github es este enlace, Espero sus recomendaciones y mejoras.

Saludos

Actualizando el Samsung Galaxy Nexus a Jelly Bean 4.2.1 desde Linux

2012-12-25T15:09:00.000-08:00

Hola, aquí estoy con un nuevo tema, el cual surgió de la necesidad de actualizar mi teléfono Samsung Galaxy Nexus GT-i9250, cansado de esperar la actualización automatica por parte de Google, así que me puse a curiosear un poco por la red y conseguí que se podía hacer, pero mis exigencias eran un poco mas allá de lo que normalmente conseguía, aplicaciones hechas solo en Windows. Quería que funcionaran en linux y logre conseguir a Universal Nexus Linux Toolkit v2.0, que es un programa basado en script bash que ofrece una manera fácil de hacer todo lo que necesita hacer antes de flashear una ROM personalizada en el dispositivo Nexus.

Eso es lo que yo necesitaba y me arriesgue a usarlo, aquí les voy a contar lo sencillo que es, sin complicaciones. Eso si, te recomiendo que hagas tu respaldo, ya que este procedimiento te deja el teléfono como viene de fabrica.

Este programa sirve para los siguientes equipos:

Nexus 4 [mako]
Nexus 10 [manta]
Nexus 7 (WiFi) [grouper]
Galaxy Nexus (GSM) [maguro]
Galaxy Nexus (Verizon) [toro]
Galaxy Nexus (Sprint) [toroplus]
Nexus S (worldwide version, i9020t and i9023) [crespo]
Nexus S (850MHz version, i9020a) [crespo]
Nexus S (Korea version, m200) [crespo]
Nexus S 4G (d720) [crespo4g]

En mi caso, por mi modelo voy a usar la numero 4, Galaxy Nexus (GSM) [maguro]

Con esta herramienta usted será capaz de:

Unlock the bootloader. (Desbloquear el gestor de arranque)
Flash CWM recovery (Standard or Touch).
Root the phone. (poner en root el telefono)
Lock the bootloader. (Bloquear el gestor de arranque)
Flash Google Factory Image. (Instalar Imagen de Fabrica de Google)

Empecemos:

Como les dije lo primero es estar seguro que tienes tu respaldo al día de tu teléfono asociado con tu cuenta de gmail, es muy sencillo solo entra en la configuración de tu teléfono en la opción copia de seguridad y restablecer y asegura que tengas tildado la opción de "Hacer una copia de seguridad", que tu cuenta de gmail sea la correcta y la opción de "Restaurar automáticamente". Esto te asegura que al asociar tu teléfono a tu cuenta de gmail, el bajara todas tus aplicaciones y contactos que tenias en la versión anterior. esto también es útil cuando cambias de teléfono, por supuesto debe ser otro android.

¿Que necesitamos?

Bien, primero quiero aclarar que yo uso Ubuntu, por lo tanto no lo he probado en otra distribución, pero al ser un shell script no creo que tengan problemas, cualquier cosa revisen la pagina del desarrollador.

Nota: Si estas corriendo linux en 64 bits, debes instalar las librerías de 32 bits

1.- bajar el shell script desde aqui
2.- Extrae el archivo .tgz donde tu quieras, te recomiendo que sea dentro de tu carpeta home, en mi caso

/home/fquivera
3.- Abre un terminal y escribe lo siguiente:
Primero nos dirigimos a la carpeta donde esta el shell script, en mi caso:

cd /home/fquivera/unlt

Hay que hacer una corrección en los enlaces dentro del shell script, ya que Google, borro las imágenes anteriores de la versión 4.2 por errores, para esto editamos el archivo unlt.sh.
Podemos utilizar cualquier editor, en la linea numero 156 y 157, cambiar estas lineas por:
FACTORY_MAGURO="https://dl.google.com/dl/android/aosp/takju-jop40d-factory-e4d13f14.tgz"

MD5_MAGURO="351926836d314848ed4292bbc499ff36"

Cualquier cosa puedes revisar estos enlaces en la pagina de desarrolladores de Google aqui.

4.- En cuanto tu teléfono debes colocarlo en modo USB Depuración, Para activar la depuración USB en el teléfono: desde configuración -> opciones de desarrollo, marcamos la casilla depuración USB. Aqui te doy un enlace de un video de como hacerlo.

5.- Conectamos el teléfono via USB.

6.- Ahora ejecutamos el shell script

sudo bash ./unlt.sh
se utiliza sudo, porque debe ser utilizado con privilegios de administrador

7.- Escojamos la opción de nuestro teléfono (En mi caso la opción 4):

8.- Ahora nos pedirá si queremos hacerlo en Automático (Recomendado) o Manual.

9.- Ahora nos muestra la pantalla de las acciones que podemos hacer en nuestro dispositivo, en nuestro caso vamos ir por la opción 5 Flash Google Factory Image

10.- Ahora nos pide que tengamos nuestro teléfono encendido y conectado en modo USB Depuración y se procede a empezar el proceso

11.- Aquí ira a Google developers a descargar la imagen, un error que puede ocurrir es que no tengan instalado en su linux el wget, que es el comando que utiliza para ello. en Ubuntu, lo instalas con:

sudo apt-get install wget

Luego de descargar la imagen, comienza a cargar la imagen al Nexus, va parpadear varias veces su teléfono y ustedes podrán ver por el terminal del PC, lo que esta pasando. Al terminar reiniciara el teléfono y lo dejara tal como viene de fabrica, para que comiences a configurar con tu cuenta y baje automáticamente tus aplicaciones y contactos.

Como conclusión les comento que mi teléfono funciona excelente con Jelly Bean 4.2.1 y actualizo todas mis aplicaciones.

Esta no es la única forma de actualizar tu Galaxy Nexus hay varias que puedes ver en Youtube o en Google, espero que este post les ayude y no olviden dejar sus comentarios al respecto. Saludos

Referencias:

galaxy-nexus-linux-toolkit - http://code.google.com/p/galaxy-nexus-linux-toolkit/

xda-developers - http://forum.xda-developers.com/showthread.php?t=1810119

Creando Aplicaciones Web con Django 1.4 (2da Parte)

2012-10-10T12:23:00.000-07:00

En el articulo anterior hablamos de como arrancar un proyecto en Django, en esta oportunidad aprenderemos un tema importante como es la configuración del proyecto. podemos decir primeramente que no hay una manera definitiva de hacerla, ya que la flexibilidad de Django nos permite que cada quien la realice a sus gusto.

Django por ser un framework de Python, utiliza este lenguaje para guardar sus configuraciones y aprovecha la manera de trabajar del lenguaje para hacer archivos de configuración fáciles de leer, extender y utilizar dentro de nuestros proyectos. Por eso es que quizás veremos en algunos proyectos que la configuración esta en varios archivos Python. En nuestro caso solo hablaremos y trabajaremos con el archivo settings.py.

Empecemos:

Editamos nuestro archivo settings.py con nuestro editor preferido, en mi caso yo uso vim, pero también lo puedes hacerlo con gedit, geany o nano (que es un clon del antiguo Wordstar, para algunos nostálgicos).

Primeramente importamos os, este módulo provee docenas de funciones para interactuar con el sistema operativo, en nuestro caso lo usaremos para conocer la ruta de nuestro proyecto.

# -*- coding: UTF-8 -*-
# Django settings for recetas project.

import os

#Definimos la ruta del proyecto
RUTA_PROYECTO = os.path.dirname(os.path.realpath(__file__))

También le damos la codificación UTF-8 a nuestro archivo de configuración para evitar los errores de caracteres en nuestro idioma.

Django por defecto trae la opción DEBUG=True, para que mientras estemos en desarrollo, podamos ver en detalle los errores de la aplicación, en le caso que tengamos la opción de DEBUG=False, normalmente en producción, las notificaciones de error de código son enviadas vía correo electrónico a los administradores, junto con los detalles completos del error. Para poner los datos de los administradores, debemos agregar en forma de tupla, en mi caso lo dejaré así:

ADMINS = (
('Francisco Quivera', 'fquivera@gmail.com'),
)

Una vez hecho esto vamos a definir con que manejador de base de datos trabajara nuestro proyecto. Quiero aclarar que aunque es posible usar Django sin una base de datos, Django incluye un mapeador objeto-relacional (ORM), en el que es posible describir la estructura de la base de datos usando Python. Esto lo veremos en mas detalle cuando veamos los modelos, aquí solo le diremos a Django con que manejador de base de datos vamos a trabajar. Django soporta de manera predeterminada la conexión con Postgresql, MySql, Sqlite3 y Oracle. En nuestro proyecto usaremos Sqlite3, por su facilidad de uso, ya que viene con Python desde la versión 2.5.

Busquemos la siguiente sección del archivo y modificamos:

DATABASES = {
    'default': {
      'ENGINE': 'django.db.backends.sqlite3', #Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': os.path.join(RUTA_PROYECTO,'db/recetas.db'), # Or path to database file if using sqlite3.
        'USER': '',                      # Not used with sqlite3.
        'PASSWORD': '',              # Not used with sqlite3.
        'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
    }
}

Estoy resaltando lo que vamos a agregar, en el caso de utilizar MySql o Postgres, deben instalar previamente los módulos Python para la conexión con estas bases de datos, en Ubuntu se hace con:

MySql:

sudo install python-mysqldb

Postgres:

sudo apt-get install python-psycopg2

Configurar la zona horaria, Django permite configurar la zona horaria del proyecto, esto lo hacemos en la siguiente sección, en mi caso agregue la que me corresponde, pueden buscar en la red cual es la que aplica para su caso:

TIME_ZONE = 'America/Caracas'

Django también permite configurar el idioma que usará de manera predeterminada para su funcionamiento, esto es muy útil ya que el administrador de Django, utilizara el idioma definido aquí, para configurar esto debemos cambiar lo siguiente:

LANGUAGE_CODE = 'es-VE'

Django requiere rutas de archivos para cargar archivos estáticos y definir donde estarán nuestras Plantillas o Templates, para hacer esto de manera dinámica, usamos las bondades que nos ofrece Python. Como ya definimos la variable RUTA_PROYECTO, que no es mas que la ruta del directorio donde se encuentra dicho archivo, a partir de éste armaremos la ruta de los archivos estáticos.

Para esto primero debemos crear las carpetas donde vamos a tener dichos archivos, como ya estamos ubicados en home/fquivera/recetas/recetas, hacemos lo siguiente:

mkdir static media plantillas db

luego nos cambiamos a static para crear otras carpetas

cd static

mkdir js img css fonts

Nos deba quedar nuestro árbol de directorio de la siguiente manera:

└── recetas
    ├── manage.py
    └── recetas
        ├── __init__.py

        ├── db
        ├── media
        ├── plantillas
        ├── settings.py
        ├── static
        │   ├── css
        │   ├── fonts
        │   ├── img
        │   └── js
        ├── urls.py
        └── wsgi.py

¿Para que son esas carpetas que acabamos de crear?

Bien, la carpeta static la utilizamos para ubicar los archivos de estilos css, dentro de la carpeta css, los javascript que podamos utilizar dentro de la carpeta js, las imágenes de nuestro proyecto, como logos, backgrounds, entre otros en la carpeta img y por ultimo si requerimos alguna fuente de letra, la ubicamos en la carpeta fonts

Por otro lado esta la carpeta media, esta carpeta la usamos para almacenar las imágenes, videos, sonidos que utilizamos en nuestros datos, osea, multimedia asociada en nuestra base de datos.

Y por ultimo la carpeta plantillas que allí estarán nuestras plantillas html de nuestro proyecto. La carpeta db es para el archivo de base de datos Sqlite3.

Ahora nos toca decirle a Django a través del archivo settings.py donde están ubicados esos archivos, para ello volvemos a editarlo, buscamos y cambiamos lo siguiente:

Esta variable le dirá a Django donde esta ubicada la carpeta media

MEDIA_ROOT = os.path.join(RUTA_PROYECTO,'media')

La siguiente es la ubicación vía URL, nos permitirá ubicarla mediante http://miproyecto/media

MEDIA_URL = '/media/'

Igualmente la URL para los archivos estáticos

STATIC_URL = '/static/'

La ubicación de los archivos estáticos:

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

Por ultimo, la ubicación de mis plantillas

TEMPLATE_DIRS = (
os.path.join(RUTA_PROYECTO,'plantillas'),
)

Los proyectos en Django trabajan con aplicaciones, algunas ya vienen configuradas de manera predeterminada. Primeramente vamos a utilizar la aplicación de administración y su documentación, estas ya vienen construidas. Para habilitar estas aplicaciones debemos buscar la sección de INSTALLED_APPS que se encuentra casi al final del archivo settings.py y quitarle la marca de comentarios a 'django.contrib.admin' y 'django.contrib.admindocs'. Nos debe quedar de la siguiente manera:

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.flatpages',
    'django.contrib.admin',
    'django.contrib.admindocs',
)

Ahora salvamos nuestro archivo settings.py, regresamos a la carpeta principal y ejecutamos el siguiente comando:

python manage.py syncdb

Este comando nos crea la base de datos del proyecto, hasta ahora solo va generar las tablas necesarias por el administrador de Django.

Creating tables ...
Creating table auth_permission
Creating table auth_group_permissions
Creating table auth_group
Creating table auth_user_user_permissions
Creating table auth_user_groups
Creating table auth_user
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table django_admin_log

You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no):

Aquí nos pide si queremos crear el superusuario para el administrador, le decimos que si, y nos pide los datos del usuario que sera el administrador

Would you like to create one now? (yes/no): yes
Username (leave blank to use 'fquivera'):
E-mail address: fquivera@gmail.com
Password:
Password (again):
Superuser created successfully.
Installing custom SQL ...
Installing indexes ...
Installed 0 object(s) from 0 fixture(s)

Ahora para poder ver los cambios que hicimos y navegar por la interfaz administrativa de Django, aún falta modificar un archivo llamado urls.py. Este archivo esta en la misma carpeta donde esta el archivo settings.py. Modifiquemos este archivo:

vim urls.py

from django.conf.urls import patterns, include, url

# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()

urlpatterns = patterns('',
    # Examples:
    # url(r'^$', 'recetas.views.home', name='home'),
    # url(r'^recetas/', include('recetas.foo.urls')),

#Uncomment the admin/doc line below to enable admin documentation:
    # url(r'^admin/doc/', include('django.contrib.admindocs.urls')),

    # Uncomment the next line to enable the admin:
    # url(r'^admin/', include(admin.site.urls)),
)

Quitemos el comentario a algunas cosas y nos queda el archivo de la siguiente manera:

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

admin.autodiscover()

urlpatterns = patterns('',    # Examples:
    # url(r'^$', 'recetas.views.home', name='home'),
    # url(r'^recetas/', include('recetas.foo.urls')),

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

    url(r'^admin/', include(admin.site.urls)),
)

he resaltado lo que he cambiado, además se han borrado las lineas de comentario, bien ahora si probamos lo que hemos hecho hasta ahora

$ python manage.py runserver
Validating models...

0 errors found
Django version 1.4.1, using settings 'recetas.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Y probamos en nuestro navegador http://127.0.0.1:8000

veremos lo siguiente:

Upssss, que paso aquí, como ya modificamos el archivo urls.py, Django, ve cuales son las URLs validas para el proyecto y estas son /admin y /admin/doc, ya que no hemos colocado la url raíz. corregimos la url en nuestro navegador de la siguiente manera:

http://127.0.0.1:8000/admin

Ahora Django nos pide el usuario y contraseña, para ingresar al administrador, lo hacemos y tenemos la siguiente pantalla:

Hasta aquí esta segunda parte, cualquier duda, escriba en los comentarios y así lo compartimos con todos. Hasta la próxima

Creando Aplicaciones Web con Django 1.4

2012-09-23T15:35:00.000-07:00

Después de mucho tiempo de estar viendo tutoriales en internet, logré hacer una aplicación completamente funcional con el framework de python Django. Es importante aclarar que es indispensable que usted tenga conocimientos básicos de python; para continuar, les recomiendo el libro llamado inmersión en python. el cual puedes descargar de la red.

En este tutorial voy a crear una aplicación que tenga integración con base de datos, autenticación, reportes, JQuery, Css y alguna otra cosa que se nos ocurra.

En esta oportunidad voy a realizar una aplicación que mi esposa me había pedido hace mucho tiempo, para guardar sus recetas de cocina, hay varias como estas en la red, solo que aquí nos iremos un poco mas alla de Django y le colocaremos los juguetes adicionales como JQuery y CSS.

Empecemos:

Este tutorial esta basado en la plataforma Linux, en la distribución que mas le guste, yo utilizo normalmente Ubuntu, actualmente en la versión 12.04. En el caso de las personas que usan Windows, hay muchos manuales en la red de como hacerlo, para ello les invito a ver un excelente vídeo tutorial de Alex Dzul en este enlace.

En Ubuntu como en todas las distribuciones linux, ya viene instalado el python, por lo que no necesita instalarlo, entonces procedemos a instalar Django, el cual esta disponible en código abierto bajo la licencia BSD. Se requiere la versión de Python 2.5 o superior, es importante saber que no depende de otras bibliotecas de Python. Y hay varias maneras de conseguirlo e instalarlo:

1. con los repositorios que trae sus sistema operativo:

$ sudo apt-get install python-django

2. Con easy_install o pip, estos son instaladores de paquetes python, en cualquier sistema operativo, solo hay que tener previamente instalado alguno de los dos paquetes y proceder:

Para utizar easy_install, este debe instalarse previamente en Ubuntu con:

$ sudo apt-get install python-setuptools

Luego procedemos a instalar Django

$ sudo easy_install django

pip es una herramienta para instalar y administrar paquetes de Python, como las que se encuentran en el índice de paquetes de Python. Es un reemplazo para easy_install.

$ sudo apt-get install python-pip

Para instalar django con pip solo hay que tipear:

$ sudo pip install Django

3. Bajarlo directamente de la página de django http://www.djangoproject.com, esta es una de las mejores opciones porque estarás bajando la última versión o release de django. Descargamos este comprimido, normalmente se hace en Descargas y luego lo descomprimimos en nuestra carpeta personal

$ tar xzvf Django-1.4.1.tar.gz
$ cd Django-1.4.1

Luego dentro de la carpeta ejecutamos el setup.py para instalarlo en nuestro sistema operativo.

$ sudo python setup.py install

Una vez que termine probamos la instalación en python

fquivera@fquivera-VGN-CR490E:~$ python
Python 2.7.3 (default, Aug 1 2012, 05:16:07)
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
>>>

Si no produce ningún error esta correctamente instalado, esta prueba es efectiva para cualquiera de las formas que escogió para instalar.

Muy bien, ya que tenemos instalado Django, vamos a proceder a crear nuestro primer proyecto, para ello nos ubicamos en nuestra carpeta personal y creamos la carpeta donde vamos a realizar nuestro proyecto.

$ cd

$ mkdir django

$ cd django

Ahora vamos a crear nuestro primer proyecto que llamaremos recetas con el siguiente comando:

$ django-admin.py startproject recetas

Este nos creará una carpeta llamada recetas, entramos en ella y tenemos un archivo y una carpeta

$ cd recetas

recetas

├── manage.py

└── recetas

├── __init__.py

├── settings.py

├── urls.py

└── wsgi.py

Expliquemos cada uno de estos archivos:

La carpeta superior recetas es sólo un contenedor para su proyecto. Su nombre no le importa a Django, usted le puede cambiar el nombre a cualquier otro que le guste.

manage.py: Una utilidad de línea de comandos que te permite interactuar de distintas formas con este proyecto Django. Utilizaremos muchas veces este programa utilitario a medida que avancemos en nuestro proyecto.

La carpeta interna recetas es un paquete real Python para el proyecto. Su nombre es el nombre del paquete Python que tendrá que utilizar para importar cualquier cosa en su interior (por ejemplo, la importación recetas.settings).

recetas / __init__.py: Un archivo vacío que le dice a Python que esta carpeta debe considerarse como un paquete Python. (Más información acerca de los paquetes en la documentación oficial de Python si usted es un principiante de Python.)

recetas / settings.py: Ajustes y configuración para este proyecto Django. Aqui haremos todas las configuración del proyecto Django y todo acerca de las opciones de trabajo.

recetas / urls.py: Las declaraciones URL para el proyecto Django, es una "tabla de contenidos" de tu sitio Django. Puedes conocer más acerca de las URL en el despachador de URL.

recetas / wsgi.py: Un punto de entrada para WSGI compatibles con servidores web para hospedar su proyecto. Veremos la manera de publicar su proyecto en un servidor mas adelante.

El servidor de desarrollo

Vamos a verificar que todo va bien. Revise que este en directorio superior de recetas, y ejecute el comando

$ python manage.py runserver

Verá la siguiente salida en su terminal:

Validating models...

0 errors found

Django version 1.4.1, using settings 'recetas.settings'

Development server is running at http://127.0.0.1:8000/

Quit the server with CONTROL-C.

Ahora vaya a su navegador favorito y escriba la dirección http://127.0.0.1:8000 y le aparcera esta pagina:

Hasta aquí esta primera parte, cualquier duda, escriba en los comentarios y así lo compartimos con todos. Hasta la proxima

Segunda Parte

Hidrobolivar una empresa de Servicio 100 % Software libre

2011-06-23T20:06:00.000-07:00

Hidrobolívar, C.A. es la empresa prestadora del servicio de agua potable y saneamiento ambiental del Estado Bolívar en la República Bolivariana de Venezuela. Sus accionistas son la Gobernación del Estado Bolívar y sus once Alcaldías, cuya misión es "Proveer el servicio de agua potable y saneamiento en condiciones de óptima calidad, mediante un modelo de gestión efectivo y sustentable, asegurando la satisfacción de nuestros clientes y el desarrollo de una nueva cultura del agua fundamentada en la valoración del recurso hídrico"

Hidrobolívar fue fundada el 26 de Marzo del 2005 y ya en Venezuela existía un marco legal que guiaba a las empresas publicas a la modernización, tal es el caso del artículo 110 de nuestra Constitución Nacional, donde se reconoce como de interés público, la ciencia, la tecnología, el conocimiento, la innovación y los servicios de información con el objeto de lograr el desarrollo económico, social y político del país.

A partir del 28 de Diciembre del 2004, se oficializo el uso de software libre en la Administración Pública Nacional con el Decreto con Fuerza de Ley No. 3.390. Por lo tanto Hidrobolívar debía seguir estos lineamientos desde su fundación, ser una empresa innovadora y con sus sistemas de información de acuerdo a las necesidades de sus clientes y la comunidad. Por lo que nació Libre.

Ahora bien, ¿Por qué se dice una empresa cien por ciento libre?, es libre por que los sistemas que se utilizan son de arquitectura abierta y respecto al software propietario que se utiliza hay la libertad para cambiarlo, ya que estamos en constante evaluación de los mismos. No hay matrimonios obligados, ya que el software medular de la empresa es desarrollado por ella misma cumpliendo con las cuatro libertades.

En cuanto al software utilizado tenemos:

Sistemas Operativos: Centos en Servidores, Fedora, Ubuntu en estaciones

Sistema de Directorio: LDAP, IPA Server, Proyecto 389

Sistema de Autenticación: sssd, Kerberos

Sistema de Archivos: Samba, NFS

Servicio de Proxy: Squid
Correo Electrónico: Posfix en Servidor, Evolution y Mozilla Thunderbird en Clientes
Trabajo en Grupo: SOGO, DocManager
Base de Datos: PostgresSQL, MySQL
Sistema de Información Geográfico: Mapserver, GvSig, PostGis
Lenguajes de Programación: PHP, Javascript, Ajax, python
Central Telefónica: Asterisk, Elastix

Ofimática: OpenOffice, LibreOffice
Herramientas Cad: Bricscad
Herramientas de Diagramas: Dia, Scribus
Herramientas Gráficas: Gimp, Inkscape

Sistema Administrativo: Merú Administrativo

Sistema Comercial: Merú Comercial

Sistema Recursos Humanos: Merú RRHH

Sistema de Operaciones: Merú Operaciones
HelpDesk: Merú Desk basado en GLPI
Herramientas de Administración centralizada de estaciones de trabajo: Puppet, Servidor de instalación desasistida y masiva Cobbler, Mirrors o Espejos de Distribuciones, control de inventario de equipos de computación, reproducción y perifericos con el OCS.
Sistema de Moritoreo de Red: Nagios+MySQL+Nagvis

Tal como comente en un mi articulo anterior La Planificación, elemento esencial en la implantación del Software Libre, Merú es nuestro ERP o sistema de gestión de recursos empresariales, es un software hecho en Hidrobolívar para hidrológicas.

También podrán apreciar que hay software que no es libre, mas tenemos la libertad de escoger el software a la medida de nuestras necesidades, ejemplo: la herramienta CAD, ya que el producto con que acostumbraron a trabajar a nuestros ingenieros tiene un valor económico cuatro veces mayor, y la alternativa que utilizamos hace lo mismo, y me atrevo a decir que tiene muchas mejoras y complementos con respecto al otro.

Algunos se preguntaran ¿Por qué Centos como Sistema Operativo para Servidores?, quizás porque es el que mas se ha adaptado a nuestros servicios y lo consideramos muy robusto y confiable, lo estamos utilizando desde que iniciamos el primer servidor. En cuanto a las estaciones, utilizamos Fedora y Ubuntu por que nos gustaron estas distribuciones de Linux, pero ya nos estamos preparando para cumplir la disposición publicada en Gaceta Oficial No. 39.633 donde los organismos y entes de la Administración Pública Nacional de la República Bolivariana de Venezuela deberán utilizar Canaima GNU/Linux como sistema operativo en sus estaciones de trabajo, cambio que no sera traumático para los usuarios. Esas son algunas de las ventajas que brinda la libertad del Software libre.

Beneficios que ha traído el software libre a Hidrobolívar:

Una sola plataforma de comunicaciones

Voz y data en el mismo canal de comunicaciones

Integración de servicios de voz y datos

Servicio telefónico de notificación de deuda
Saldo en línea (vía web y telefónico)
Autogestionado de Salud Telefónico
Notificación de deuda vía correo electrónico

Indicadores de Gestión para la toma de decisiones

La alta gerencia tiene acceso a indicadores de gestión precisos y en línea directa de los sistemas administrativo, comercial y recursos humanos.

Gasto convertido en inversión

El dinero que se utilizaría para pago de licencias se utiliza para entrenamiento de personal
Ahorro anual aproximado de $ 430.860,74 unos Bs. 1.851.944,21 (4,30x$)

Sistemas Adaptados a las necesidades del cliente

Al contar con un sistema propio, es totalmente factible la integración con distintas plataformas para ofrecer alternativas de atención a los clientes, tales como Bancos, Farmacias, Supermercados, entre otros, a través de un portal de Web Services.

Por esto y muchas cosas mas, podemos decir que Hidrobolívar es una empresa cien por ciento libre, la inversión realizada en tecnología esta allí, no en otro país, contamos con asesoramiento de empresas y cooperativas nacionales y locales que nos ayudan a mantener la plataforma, ya que somos una empresa de servicio de saneamiento y agua potable, que ha demostrado que sí se puede lograr una empresa con la libertad para escoger sus herramientas de gestión sin necesidad de adaptarse a modelos importados que traen otras realidades que no son las nuestras, y esto solo se logra con el software libre.

Software Privativo, Libre, Pirata ¿Cuál opción escoger?

2011-06-18T17:18:00.000-07:00

Cuando conocí a Ana, mi esposa, me resultaba tan curioso observar como una persona se encontraba tan inmersa en el mundo del "Windows", y tan directamente condicionada a asociar equipos de computación con "Microsoft Office". Pasaba días transcribiendo sus trabajos en el usual "Word", así como pasaba horas enteras diseñando sus presentaciones en el clásico "Power Point". Para ella, automáticamente al encender su computadora, era casi instantáneo visualizar antes que apareciera, aquella banderita de colores que le indicaba que su sistema operativo era una licencia de Windows; y de este modo por mucho tiempo, asumió que toda computadora era así, que el mundo de la informática pertenecía exclusivamente a Microsoft y su creador se dedicaba no solo a fabricar computadoras sino a colocar lo que dentro de ella venia, sin pensar siquiera la posibilidad remota de la existencia del uno sin el otro y viceversa.

Creo que esta pequeña anécdota no es extraña para nadie, al punto que inclusive hoy día forma parte de la realidad de muchas personas, de la cual ya ni ella ni yo somos parte, afortunadamente.

Es por ello, que me parece conveniente, traer hoy día esta reflexión, y expandir un poco el horizonte de quienes aún navegan en el exclusivo mar de las licencias privadas, bien porque la adquirieron de modo legal o sencillamente porque se encuentran frente a una reproducción ilegal de la misma, mejor conocida como software pirata.

Empezaremos primeramente definiendo que es software legal: Es aquel que se utiliza con el consentimiento de su creador o dueño, ya sea por medio de una licencia o sin ella, y puede adquirirse pagando dicha licencia o de forma gratuita.

Por otro lado, encontramos el software libre, cuya traducción del inglés "free software" ha generado una ambigüedad que ha hecho pensar que todo es gratis, y sin embargo no es obligatorio que sea así, por lo tanto no hay que asociar que todo software libre es gratis (denominado usualmente freeware), ya que conservando su carácter de libre, puede ser distribuido comercialmente (software comercial).

Análogamente, el "software gratis" incluye en ocasiones el código fuente; no obstante, este tipo de software no es libre en el mismo sentido que el software libre, a menos que se garanticen los derechos de modificación y redistribución de dichas versiones modificadas del programa. Para ser mas precisos y ya que se tiende a confundir, la realidad es la denominación del software que respeta la libertad de los usuarios sobre su producto adquirido, y por tanto, una vez obtenido puede ser usado, copiado, estudiado, modificado y redistribuido libremente.

También existe el software de dominio público, que no debe confundirse tampoco con el software libre, ya que este tipo de software no requiere licencia, pues sus derechos de explotación son para toda la humanidad, pertenece a todos por igual y cualquiera puede hacer uso de el, siempre con fines legales y refiriéndose al autor original, ya que este lo ha donado a la humanidad o puede ser el caso que los derechos de autor han expirado, tras un plazo contado desde la muerte de su creador, que generalmente son unos 70 años. Si un autor condiciona su uso bajo una licencia, por muy débil que sea, ya no es un software de dominio público.

El software propietario llamado también privativo, de código cerrado o software no libre, es cualquier programa informático en el que el usuario tiene limitaciones para usarlo, modificarlo o redistribuirlo (esto último con o sin modificaciones), tal es el caso del conocido Windows.

La persona natural o jurídica al poseer los derechos de autor sobre un software, tiene la posibilidad de controlar y restringir los derechos del usuario sobre su programa, lo que en el software propietario implica por lo general que el usuario sólo tendrá derecho a ejecutar el software bajo ciertas condiciones, comúnmente fijadas por el proveedor, que signifique la restricción de una o varias de las cuatro libertades.

Ahora bien, que usar ¿libre, propietario o pirata?, indudablemente que con la adquisición de un software pirata la empresa corre el riesgo de ser sancionada en caso de realizarse los debidos controles, por lo tanto esta opción debe ser descartada. Pero esto nos lleva mucho mas allá, nos lleva precisamente al problema cultural -no técnico-, y es que nos enseñaron -y lo peor-, nos acostumbraron a usar una herramienta que la consigues en cualquier esquina -ilegalmente por supuesto- y cuando vamos a las empresas, éstas tienen que pagar una licencia, porque las personas jurídicas son mas fáciles de fiscalizar; al respecto hay un excelente articulo escrito por @w3asel cuyo enlace les dejo aquí, donde profundiza muy acertadamente este problema.

En Venezuela existe la Ley Especial contra los delitos informáticos, publicada en la Gaceta Oficial numero 37.313 el 30 de Octubre del 2001, donde se castiga el acceso indebido a un sistema, penado con prisión de uno a cinco años y multa de 10 a 50 unidades tributarias (UT), así como la apropiación indebida de propiedad intelectual mediante la reproducción, divulgación, modificación o copia de un software, penado con prisión de uno a cinco años y multa de 100 a 500 UT: sin embargo a pensar de contar con la legislación que tipifica el delito y sanciona la acción, su efectiva aplicación aún no es la mas idónea.

Aún contando con el contexto anterior, y haciendo a un lado la existencia del software pirata, entonces, ¿Porque las empresas no utilizan el software libre?, ¿Por soporte? no lo creo, cada día hay mas empresas que dan soporte al software libre, y si es por eso, podemos hablar de un sistema operativo propietario como lo es el Windows XP que no tiene soporte desde hace mucho tiempo y aun así lo siguen usando. Usar software libre facilita las condiciones para la creación de nuevo software, adaptado a las necesidades que se tengan y podamos brindar mejor calidad a nuestros clientes ya que es conocimiento, y ésta es la base de la economía del futuro. Los argumentos para la no utilización del software libre se han acabado: primero, existe gran cantidad de software de calidad que hace lo mismo que el propietario y solo esta al alcance de un click, así como también conseguirá algunos con un costo muchísimo menor que el que nos acostumbraron a utilizar. La herramienta está al alcance de sus manos, solo atrévase.

La Planificación, elemento esencial en la implantación del Software Libre

2011-05-09T19:40:00.000-07:00

La planificación es un paso crítico en todo proyecto, que debe hacerse bien para evitar problemas futuros. El definir desde el principio cómo serán las bases del proyecto y estar soportadas por la inteligencia del negocio, nos evitara desperdiciar recursos y materiales. La planificación es un elemento esencial que muchos gerentes parecen no comprender y no le dan la debida importancia. En este articulo trataremos el tema desde la perspectiva de una empresa basada en software libre.

Hidrobolívar, C.A. es la empresa prestadora del servicio de agua potable y saneamiento ambiental del Estado Bolívar en la República Bolivariana de Venezuela. Sus accionistas son la Gobernación del Estado Bolívar y sus once Alcaldías, cuya misión es "Proveer el servicio de agua potable y saneamiento en condiciones de óptima calidad, mediante un modelo de gestión efectivo y sustentable, asegurando la satisfacción de nuestros clientes y el desarrollo de una nueva cultura del agua fundamentada en la valoración del recurso hídrico"

Hidrobolívar fue fundada el 26 de Marzo del 2005 y ya en Venezuela existía un marco legal que guiaba a las empresas publicas a la modernización, tal es el caso del artículo 110 de Nuestra Constitución Nacional, donde se reconoce como de interés publico, la ciencia, la tecnología, el conocimiento, la innovación y los servicios de información con el objeto de lograr el desarrollo económico, social y político del país.

Y a partir del 28 de Diciembre del 2004, se oficializo el uso de software libre en la Administración Publica Nacional con el Decreto con Fuerza de Ley No. 3.390. Por lo tanto Hidrobolívar debía seguir estos lineamientos desde su fundación, ser una empresa innovadora y con sus sistemas de información de acuerdo a las necesidades de sus clientes y la comunidad. Por lo que nació Libre.

El Software Libre y el Conocimiento, nos lanzan un reto para la innovación, donde tenemos disponibles los elementos necesarios para la construcción de un modelo de desarrollo libre e independiente, sin otro límite que la propia creatividad y la capacidad de innovación de cada uno, contribuyendo a ampliar la libertad e igualdad de oportunidades de progreso. Este reto nos lleva a:

Repensar la gestión de las tecnologías de información
Crear nuevos modelos
Mejorar las relaciones con nuestros clientes
Independencia con los proveedores de Software
La Modernización del estado

El principal objetivo es lograr obtener el control de nuestro negocio, por supuesto, esto no es tarea fácil, ya que es un trabajo constante y de mucha resistencia, quizás de muchos años, donde se necesita la misma determinación con que valoramos nuestra libertad y la protegemos a cualquier costo. Estas premisas nos hizo crear una estrategia tecnológica basada en los procesos del negocio, que no es mas que nuestra misión y visión como empresa, el porque existimos; la estrategia de tecnología, que se basa principalmente en el decreto 3.390 y las tecnologías de información existentes en el mercado enmarcadas dentro de este decreto (ver Figura)

Estrategia Tecnológica de Hidrobolivar, C.A.

La unión de estos tres elementos nos proporcionan servicios de tecnología e infraestructura que al final van al servicio del cliente, a quien nos debemos. Con estas premisas, Hidrobolívar planifico primeramente su infraestructura tecnológica, que se convirtió en la base de sus sistemas de información y poder tener la interrelación de cada uno de los sistemas y así evitar las islas de información, basado primeramente en un sistema integral donde todos los procesos de la empresa convergen, este macro sistema lo llamamos merú.

Arquitectura Tecnológica de Hidrobolivar, C.A.

Merú -cuyo significado en el idioma pemón es salto de agua o cascada-, es un nombre escogido para nuestro sistema, primero porque nos identifica nuestra razón de ser, la potabilización del agua y su saneamiento y segundo que es autóctono de nuestra región, el estado Bolívar.

Ahora, Merú es nuestro sistema de planificación de recursos empresariales o ERP, es un sistema de información gerencial que integra y maneja los procesos asociados con las operaciones del servicio de potabilización y saneamiento del agua.

Como podemos apreciar en la figura, tenemos los diferentes módulos de merú, con una clara interrelación entre ellos, ya que la información se comparte y evita la multiplicidad del dato, brindando una calidad del mismo, para luego ser convertido en información e indicadores de gestión que proporcionara a la alta gerencia herramientas para la toma de decisiones.

Para finalizar, debo decir que para implantar cualquier sistema de información gerencial, es importante tener claro el proceso del negocio, las metas y objetivos del mismo; y de allí alinear las tecnologías de información para lograr una sinergia efectiva entre ambas estrategias, lo cual es un principio fundamental dentro de la empresa. La planificación nos permite lograr la claridad de metas y objetivos, y está indicada como un factor clave de éxito para la implantación de sistemas ERP. Es trasladar la visión de la compañía y la estrategia que resulta de esta visión en prioridades concretas, y decidir exactamente cómo la implantación de un sistema de información gerencial como merú puede ayudar a la empresa a lograr sus objetivos.

Estrechamos lazos con otras hidrológicas del país

2011-04-05T07:54:00.000-07:00

La gestión de Hidrobolívar de tan sólo 6 años, ya es motivo de referencia nacional, especialmente en las áreas de tecnología y proyectos, donde otras hidrológicas del país han comenzado a manifestar su interés.

En este sentido, Hidrobolívar ha recibido varias representaciones de hidrológicas hermanas en su sede de la UD-321, en Puerto Ordaz. Recientemente Hidrocaribe, así como Aguas de Monagas y Aguas de Yaracuy, además del apoyo aportado a Hidrollanos en años anteriores.

El Lic. Francisco Quivera, Vice Presidente y Gerente de Tecnología e Informática, ha explicado que se están fomentando estos encuentros con miras a establecer convenios interinstitucionales de intercambio con otras hidrológicas para beneficio de ambas partes. “Ver en qué área las otras empresas son fuertes y en qué áreas nosotros somos fuertes y que al final de este trueque los beneficiados sean los integrantes de la comunidad”.

En las reuniones se han tratado diferentes temas concernientes a la labor que ejecuta cada empresa, entre los que se pueden mencionar la perforación de pozos profundos con el uso de maquinarias, aportes en el área informática, planes estratégicos con empresas internacionales, etc.

Uno de los aspectos más llamativos para el resto de las hidrológicas es el hecho de haber consolidado en Hidrobolívar una plataforma tecnológica con estándares libres que cumple con el decreto presidencial con fuerza de Ley 3.390, el cual habla de la obligación de la administración pública del uso de software libres. El sistema desarrollado por Hidrobolívar además es un conglomerado integral de las áreas administrativa, comercial y de recursos humanos, que facilita la planificación, el estatus de la gestión y el manejo integral de la hidrológica para la toma de decisiones en beneficio de la comunidad.

Se plantea así la posibilidad de la transferencia tecnológica por parte de Hidrobolívar hacia otras hidrológicas, en principio con la implementación del Sistema Comercial MERÚ que permite agilizar el proceso de facturación, casos de catastro, atención al cliente, optimizando de esta manera la atención al cliente y el proceso de cobranza, fundamental para la sustentabilidad del servicio de agua.

Los especialistas de Hidrobolívar han capacitado a los empleados de Hidrollanos, Aguas de Yaracuy e Hidrocaribe, en cuanto al uso y manejo de este software, y se preparan para la puesta en práctica de los compromisos asumidos en dichos convenios interinstitucionales. Próximamente se sumará Aguas de Monagas.

Fuente: Prensa Hidrobolívar, C.A.

Miedo a lo desconocido

2011-03-19T18:28:00.000-07:00

A lo largo de mi carrera, me he dado cuenta que aquellos que tenemos mas miedo a los cambios somos los profesionales de tecnología o de sistemas; esta afirmación me atrevo a expresarla, porque mientras tengamos un sistema que funcione con sus limitaciones, pero que funcione en si, siempre nos dará miedo el cambiar o el innovar. Es precisamente aquí donde voy con el tema que nos compete.... el miedo al cambio, el miedo a lo desconocido.

Desde el inicio de la era tecnológica fuertemente marcada por la venta de las computadoras, nos acostumbraron a una única manera de pensar a través único sistema operativo (Conocido como MS-Windows); nos enseñaron que todo giraba en torno a él, ya que las aplicaciones creadas por los fabricantes de software solo trabajaban para él.

Cuando Linus Torvalds el 5 de Octubre de 1991 anuncio la primera versión de Linux, capaz de ejecutar un shell (BASH), con un compilador de C mejor conocido como gcc, cambio radicalmente la perspectiva y nos dio otra manera de ver el mundo de la informática y principalmente nos concedió: libertad, libertad para escoger el sistema operativo que quiero, programar lo que quiero y adaptarlo a mis necesidades, en fin... Libertad.

Al paso del tiempo Linux se ha convertido en el sistema operativo que utilizan la mayoría de los servidores web en el mundo con Apache, y dio pie a la creación de aplicaciones nuevas, como es el caso de Firefox, el navegador mas popular.

Entonces, esto nos lleva a la siguiente pregunta: ¿Por qué el miedo? ¿Por qué no cambiarnos a Software Libre? ¿Qué nos impide dejar de pagar costosas licencias? ¿Por qué no reinvertir ese dinero en capacitación de personal? o mejor invertir ese dinero en nuestros países y pagarles a nuestros programadores criollos, que han demostrado que las cosas se pueden lograr.

Les diré que pasa, no creemos, al no creer en nosotros mismos, buscamos depender de otro al que podamos echarle la culpa de nuestros fracasos, le tenemos miedo hasta el cambiar una herramienta tan simple como una suite de oficina. Openoffice no tiene ninguna diferencia en cuanto a productividad con respecto a MS-Office, ¡nada! pero nos acostumbraron a el y nos sentimos como pez fuera del agua cuando nos dicen que tenemos que trabajar con otra herramienta. Hay excusas como la siguiente: yo no he hecho curso de eso, les pregunto ¿Donde esta el certificado del curso de MS-Office? nadie lo tiene, porque hay otro gran problema, y es que nuestras Universidades no se dan a la tarea de enseñarnos que hay otras opciones y otras herramientas que fácilmente podemos utilizar. Recuerdo que antes de que explotara el auge de programación de PHP, todo era Visual Basic, todas las clases de programación se daban en ese entorno, ahora es PHP, esta muy bien, es un lenguaje libre, pero no puede faltar el WAMP, que nos monta todo sobre MS-Windows, con solo hacer siguiente, siguiente a través de un asistente. Deberían enseñar primero sobre los diferentes sistemas operativos existentes y no solo uno. En si, no darle el pan en la boca a los programadores nuevos, sería mejor enseñarles como buscarlo y que tienen miles de opciones.

Como ven, este tema es muy extenso y nos dará mucho de que hablar, algunos dirán, si ya alguien lo hizo para que voy hacerlo de nuevo?, yo diría lo mismo, pero en nuestras Universidades deberíamos crear innovadores, no seguidores, ni imitadores, además en el caso de una empresa debemos adaptarnos al proceso del negocio, y no traer e implantar negocios hechos en otras esferas y con sus particularidades.
Muchas empresas han demostrado que el Software Libre es una alternativa, les conversaré a lo largo de este blog de mi experiencia personal en Hidrobolivar, C.A., una empresa Hidrológica creada por la Gobernación del Estado Bolívar y las once Alcaldías para saldar la deuda social en materia de agua potable y saneamiento en el estado Bolívar, República Bolivariana de Venezuela, cuyos sistemas se encuentran basados en el decreto 3.390, referente a la Administración Pública y su asociación directa al Software Libre. El reto en Hidrobolívar, fue repensar la gestión en Tecnologías de Información, aprovechar los beneficios del Software Libre para reestructurar la plataforma tecnológica en busca de la eficiencia y la eficacia de los procedimientos, como resultado de mayor independencia con los proveedores de software, nuevos modelos de gestión y modernización del Estado y darle a su razón de ser -los clientes- un mejor servicio.