Publica tu how-to

Dinos como hacer lo que sabes hacer, mándanos un email a wdonet@gmail.com y lo publicamos (dos días máximo) o si te interesa unirte al equipo de redactores, también háznoslo saber por correo.

2 configuraciones con Spring Mail para usar Gmail

He notado que la configuración de la clase "JavaMailSender" de Spring es un poco confusa para algunos y personalmente me ocurrió cuando al principio tomé el proyecto de enviar correos con Spring.

Así que dejo aquí, dos configuraciones que me funcionaron a la perfección con Gmail: TLS y SSL

Debo hacer notar que también funciona con Google Apps for Business.

Entorno No Integrado de Desarrollo (UDE)


Casi todos los desarrolladores que conozco acostumbran utilizar herramientas pesadas para hacer su trabajo.

Una de dichas herramientas, el IDE (entorno de desarrollo integrado) suele ser un programa grande que incluye en un sólo paquete las herramientas más comunes que un desarrollador puede llegar a necesitar.

Ese es el problema: asumir que el desarrollador VA a necesitar las herramientas, cuando en realidad sólo PUEDE que las necesite.

Por esa razón, tiene un tiempo ya que no utilizo IDEs para mi trabajo. O como leí alguna vez, utilizo un entorno NoIntegrado de Desarrollo (Unintegrated Development Environment).

Armar un entorno así no es nada difícil, y sólo requiere de un conocimiento concisio de las herramientas que en realidad tiene a su disposición un programador para hacer su trabajo, según el sistema sobre el que trabaje.


Como subir un proyecto con GIT a GitHub

Para subir un proyecto a gitHub no hay mas que seguir los mismos tutoriales que te proveen pero a resumidas cuentas tienes que hacer lo siguiente:

1.- Crear una cuenta en GitHub

 Tienes que ir a la liga : https://github.com/plans y darle en el botón de Create a free Account, una cuenta libre te permite tener tantos repositorios públicos y colaboradores públicos como quieras, pero ninguno privado, si quieres esto, tienes que pagar.

Este paso es muy rápido y obvio, después de ingresar tus datos recibirás un mail de confirmación y listo, regresas a la página para entrar a tu cuenta.

2.- Instalar Git en tu equipo 

En windows puedes descargar una versión de Git desde : http://code.google.com/p/msysgit/, pero para los que usamos linux Mint y similares a Ubuntu lo que tienes que hacer es:

sudo apt-get install git git-core git-gui git-doc
(lo que está en negritas es lo esencial, lo demás son agregados y puedes no indicarlos)

luego debes crear la configuración global de git para que se puede rastrear los cambios que tu haces y diferenciarlos con respecto a los demás integrantes del proyecto.

git config --global user.name "Nombres Apellidos"
git config --global user.mail "tunick@gmail.com"


Creacion de un proyecto base con Grails 2.0.3

Vamos a crear un proyecto web base para una aplicación que podría usar un kinder considerando solo poder hacer Altas Bajas y Cambios (ABC) de dos entidades Tutores y Alumnos.  Yo trabajaré en un Linux Mint, las instrucciones en consola son similares en cualquier distribución derivada de Debian o Ubuntu, para windows solo cambiarían las carpetas y las variables de entorno.

Empecemos instalando Grails.

Necesitamos tener instalado java y haber definido nuestra variable de entorno JAVA_HOME.
  1. Descargar grails
  2. Descomprimir ZIP en una carpeta (la mia será /opt )
  3. Crear las variables de entorno GRAILS_HOME y JAVA_HOME (si no existe)
export GRAILS_HOME=/opt/grails-2.0.3
export PATH=$PATH:/opt/grails-2.0.3/bin


Para comprobar que nuestra instalación está completa debemos ejecutar el comando grails para obtener la versión.  En algunos sistemas como el mío se requiere reiniciar la sesión de usuario para que se apliquen los cambios en las variables de entorno.

$ grails -version
Grails version: 2.0.3


Ahora creamos nuestra aplicación, se genera una carpeta con el nombre de la aplicación, ingresamos a dicha carpeta y luego abrimos la consola de grails.

$ grails create-app kinder
| Created Grails Application at /home/wdonet/branches/grails/kinder
$ cd kinder/
$ ls
application.properties  grails-app  lib  scripts  src  test  web-app
$ grails
| Downloading: plugins-list.xml
grails> help

Podemos usar el comando help para ver todos los comandos que tenemos disponibles en la consola de grails, incluso puedes obtener ayuda de un comando en especifico escribiendo por ejemplo : help create-appPero toma nota que la consola de grails es una forma para jugar con el ambiente de tu proyecto, si quieres ejecutar tu aplicación es mejor usar el comando grails (fuera de la consola).

Clases embebidas en Grails

En Grails se pueden mapear clases a entidades simplemente ubicándolas en un paquete dentro de la carpeta /grails-app/domain como se muestra abajo.  Mapeando la clase y atributos a una tabla y columnas con un mismo nombre si no se le especifica otra cosa con la propiedad mapping.

import mx.com.proyecto
class Tutor {
    String nombres
    String paterno
    String materno
    Integer edad
    static constraints = {
        nombres maxSize: 150, nullable: false, blank: false
        paterno maxSize: 80, nullable: false, blank: false
        materno maxSize: 80, nullable: true, blank: false
    }
}

Pero quizá nos interese tener nuestra entidad un poco mas amigable y legible agrupando los tres elementos nombres, paterno y materno dentro de un mismo POJO y seguirla mapeando a las mismas columnas de una sola tabla.

La regla de oro está en definir el POJO en el mismo archivo Tutor.groovy o en un archivo separado pero dentro de la carpeta /src/groovy/ (Nombre.groovy).

Introducción a MongoDB


Me metí un poco a ver como funcionaba CouchDB pero entre revisiones y vistas rápidas a referencias aquí y allá llegue a MongoDB, ambas son alternativas No-SQL (termino que empezó a agarrar fama desde 2009) y que su almacenamiento de datos está orientado a documentos JSON y BSON (Bynary JSON) para ofrecer sistemas flexibles, rápidos, ligeros, potentes y fáciles de usar.

Según Eliot Horowitz, 10gen CTO y co-fundador de mongoDB, prácticamente podrías tomar una base de datos hecha en MySQL, cambias el modelo relacional a uno basado en documentos y obtendrías varias mejoras como:
  1. Documentos embebidos para mejorar la velocidad
    1. El uso de json es más amigables con objetos en lenguajes de programación
    2. El meter documentos embebidos y arreglos reduce la necesidad de hacer joins
  2. Manejabilidad
  3. Desarrollo ágil con base de datos sin esquemas
    1. Al usar JSON/BSON es fácil de codificar y administrar
  4. Escalabilidad horizontal más facil
    1. Es una solución para sistemas que requieren escalar horizontalmente sobre varios servidores.
    2. La funcionalidad de autosharding permite escalar tu cluster agregando mas equipos sin necesidad de dar de baja el servicio.

En realidad no estamos quitando todo el trabajo que ya se ha hecho con las bases de datos relacionales porque en muchas cosas como la creación de indices, llaves primarias, consultas dinámicas y actualizaciones, por mencionar algunas,  se tiene que hacer los mismo, salvo que se busca tener las ventajas arriba descritas.

La gente de apache que desarrolla CouchDB mencionan que los esquemas relacionales funcionarán en algunos casos mientras que los esquemas no-SQL funcionarán en otros.

Introducción a PostgreSQL

Hace un par de días me tuve que meter con PostgreSQL (versión 9.1.3) a manera de conocerlo un poquito ya que no sabía nada y me encontré con algunos detalles.

Para su instalación en Linux Mint o Ubuntu debemos hacer lo siguiente.

  1. sudo apt-get install postgresql libpq-dev (instala el motor y un usuario postgress con todos los privilegios para operar sobre el servidor)
  2. sudo su postgress (esto te permite abrir una sesion con el nuevo usuario postgress)
    1. createuser -d -s -P usuario , creamos un usuario donde:
      • -d es para darle permisos de creación de base de datos
      • -s es para darle permisos de superusuario
      • -P para poderle indicar un password al usuario
    2. exit
  3. sudo apt-get install pgadmin3 - para instalar el cliente gráfico (opcional)

Detalles de interés que se podrán observar en las instrucciones de ejemplo que copio mas adelante:
  • La diferencia contra otros manejadores de Base de Datos es que se puede hacer herencia entre tablas.
  • Cuando se heredan las tablas, las llaves primarias se tienen que redefinir dado que estas no se heredan.
  • Cuando se borran las tablas, los índices también se eliminan de forma automática.
  • Cuando se hacen muchas operaciones de creación/borrado en la base de datos, es necesario darle mantenimiento (opción vacuum en el pgadmin3).
  • La sintaxis para las fechas siempre es: YYYY-MM-DD.

Vamos a los ejemplos ahora sí:
-- Eliminamos la vista
DROP VIEW if exists dime_sus_tutores, dime_personas_sin_cel;

-- Eliminamos indices primero (aunque cuando se borran las tablas estos ya se eliminan)
DROP INDEX if exists idx_clave_escolar;

-- Eliminamos las tablas
drop table if exists
 tutores, personas, alumnos, tutores_alumnos;
 
-- Tabla personas PADRE
create table personas (
 id integer PRIMARY KEY,
 nombres varchar(75) not null,
 genero varchar(1),
 fecha_nacimiento date,
 lugar_nacimiento varchar(150),
 curp varchar(18) unique,
 tel varchar(20),
 cel varchar(20),
 email varchar(50),
 cuando date default current_date
);

-- Tabla hija de personas
create table tutores(
 id integer primary key,
 ocupacion varchar(100)
) inherits (personas);

-- Tutores
insert into tutores (id, nombres, genero, fecha_nacimiento, lugar_nacimiento, cel, ocupacion) values
 (1, 'Ricardo Rogers', 'm', '1970-01-10', 'Ciudad de México', '0445554374879', 'Musico'),
 (2, 'Guillermo Garcia', 'm', '1971-04-12', 'Tlaxcala', '044 55 94637383', 'Contador'),
 (3, 'Pita Perez', 'f', '1964-05-22', 'Ciudad de México', null, 'Ama de casa');

-- Tabla hija de personas
create table alumnos (
 id integer primary key,
 clave_escolar varchar(25),
 fecha_ingreso date,
 carrera varchar(50)
) inherits (personas);

-- Creacion de un indice
create unique index idx_clave_escolar on alumnos(clave_escolar);

insert into alumnos
 (id, nombres, genero, fecha_nacimiento, lugar_nacimiento, cel, clave_escolar, fecha_ingreso, carrera) values
 (4, 'Leonora Rogers Mendoza', 'f', '1994-01-10', 'Ciudad de México', '044 55 12345678', 'a100-101', '2011-08-14', 'informatica'),
 (5, 'Maximiliano Hotel', 'm', '1993-04-12', 'Tlaxcala', '044 55 87654321', 'b200-202', '2011-07-13', 'contaduría'),
 (6, 'Lupita Gómez Pérez', 'f', '1993-02-22', 'Ciudad de México', null, 'c300-303', '2011-06-12', 'contaduría'),
 (7, 'Arturo Gómez Pérez', 'm', '1994-05-22', 'Ciudad de México', null, 'd400-404', '2011-05-11', 'administración')
 ;

-- Tabla que relaciona personas y tutores
create table tutores_alumnos (
 id_tutor integer REFERENCES tutores(id),
 id_alumno integer references alumnos(id),
 primary key (id_tutor, id_alumno)
);

-- relaciones
insert into tutores_alumnos values (1,4),(2,5),(3,6),(3,7);


-- una vista
create view dime_sus_tutores as
 select a.nombres as Alumno, a.clave_escolar as Clave, t.nombres as Tutor, t.cel
 from tutores_alumnos ta
 left join alumnos a on ta.id_alumno = a.id
 right join tutores t on ta.id_tutor = t.id
 order by a.nombres
;

-- otra vista
create view dime_personas_sin_cel as
 select p.id, p.nombres, p.tableoid, c.relname
 from personas p, pg_class c
 where cel is null
 and p.tableoid = c.oid
;


Fuentes:    
  1. @mromtz - Mario Martinez -- Taller de PostgreSQL --
  2. 2 módulos de un curso en línea
  3. Comandos de administracion
  4. www.postgresql.org

Usando una conexión a base de datos distinta en un subreporte de JasperReports

Al incluir un subreporte en JasperReports por default éste utiliza la misma conexión a base de datos que el reporte maestro que contiene el subreporte.


Sin embargo, a veces es deseable que el subreporte se conecte a una base de datos diferente.


Una manera de lograrlo es la siguiente:

  1. Incluir el subreporte como cualquier otro
  2. Agregar un parametro, que en este ejemplo llamaré SUBREPORT_CONNECTION, con Parameter Class = java.sql.Connection , no usar prompt,Default value expression = java.sql.DriverManager.getConnection("jdbc:mysql://localhost:3306/base_de_datos", "usuario", "password")[Obviamente, editar la url para que coincida con el motor de BD usado, nombre de base, puerto, host y demas datos]
  3. En las propiedades del subreporte,Connection type = Use a connection expression,
    Connection expression = $P{SUBREPORT_CONNECTION}(o como sea que se le haya nombrado al parámetro del inciso anterior)
  4. Si al intentar generar el reporte, aparece un error del tipo "No suitable driver found for jdbc:mysql://localhost:3306/base_de_datos", puede funcionar agregar un parametro mas, que se cargue antes del de SUBREPORT_CONNECTION (en iReport se pueden acomodar el orden de los parámetros y ese es el orden de carga también), que no use prompt, que
    Parameter Class = java.lang.Classy con
    Default value expression = Class.forName("com.mysql.jdbc.Driver").getName()[O como sea que se llame la clase Driver del manejador de BD utilizado...]
  5. Por último, si aún con esto surge una excepción ClassNotFoundException para, en este ejemplo, com.mysql.jdbc.Driver, se puede copiar el jar al subdirectorio jre/lib/ext de donde se encuentre instalada la máquina virtual que use JasperReports para compilar los reportes.

Usando una base de datos SQLite en un proyecto de Symfony2

Para configurar una base de datos en un proyecto de Symfony2, se edita el archivo app/config/parameters.ini:


[parameters]
    database_driver   = pdo_sqlite
    database_host     = localhost
    database_port     =
    database_name     = test_project.db
    database_user     = root
    database_password = 


Sin embargo, con esta configuración, que es la default para usar cualquier otro motor de base de datos con Doctrine2 (incluido en cualquier instalación estándar de Symfony2), una base de datos SQLite no funciona.


Lo correcto es, primero, editar y agregar una línea en app/config/config.yml:



doctrine:
    dbal:
        driver:   %database_driver%
        host:     %database_host%
        port:     %database_port%
        dbname:   %database_name%
        user:     %database_user%
        password: %database_password%
        path:     %database_path%
        charset:  UTF8

Esta línea no se encuentra originalmente en el archivo, se agrega para que Doctrine utilice el parámetro 'database_path', que ahora se agrega a parameters.ini:

[parameters]
    database_driver   = pdo_sqlite
    database_host     = localhost
    database_port     =
    database_name     = test_project.db
    database_user     = 
    database_password = 
    database_path     = /path_to_my_project/app/db/test_project.db

Y con eso, la base de datos queda creada en el path establecido. Notar que para servidores Unix (Linux por ejemplo), este archivo debe quedar con permisos de lectura/escritura por parte del usuario que utilice el servidor web (cualquiera que este sea, http, www-data o lo que sea): Y el directorio donde reside el archivo tambien debe tener permisos de lectura, escritura y ejecución para este mismo usuario (en este caso, el subdirectorio db que yo puse aquí dentro de app/, pero en realidad podría residir donde más nos convenga).