Although several options exist for interface development in Java, even popular UI toolkits like Swing have been notoriously complex and difficult to use. Griffon, an agile framework that uses Groovy to simplify Swing, makes UI development dramatically faster and easier. In many respects, Griffon is for desktop development what Grails is for web development. While it’s based on Swing, its declarative style and approachable level of abstraction is instantly familiar to developers familiar with other technologies such as Flex or JavaFX.

A continuación algunas de las presentaciones disponibles en Slideshare:

• Opening Keynote by Søren Berg Glasius and Guillaume Laforge
• Practical Groovy DSL by Guillaume Laforge
• What’s New in Groovy 1.6? by Guillaume Laforge
• Industrial Strength Groovy by Paul King
• Groovy Finance: Grid Computing and Computational Finance
• The Grails Plugin System by Graeme Rocher

• Getting Started Guide
• User Guide
• Advanced usage guide
• Groovy and Grails talk: http://www.slideshare.net/desistartups/groovy-and-grails-talk
• Curso de Groovy: http://www.dosideas.com/cursos/course/view.php?id=9
• Introducción a Groovy: http://www.asert.com/pubs/Groovy/Groovy.pdf
• Creating “Hello World” Web Application Using the Grails Framework
• Grails : Hello world
• Getting Started with Grails :
• GRAILS QUICK REFERENCE
• http://www.slideshare.net/loffenauer/2007-09-10-fzi-training-groovy-grails-v-ws
• http://www.slideshare.net/desistartups/groovy-and-grails-talk
• http://www.slideshare.net/mjhugo/groovy-grails-devjam-jam-session-presentation

En esta sección del tutorial utilizaremos un plugin para la generación de RSS utilizando grails.  (Puede encontrar una lista de los plugins existentes en la siguiente ubicación: http://grails.org/plugin/home

El plugin que utilizaremos para la generación de rss se llama Feeds.  Para instalarlo ejecutamos el siguiente comando (tenga en cuenta estar ubicado en la carpeta de su proyecto)

> F:\dev\issuetracker>grails install-plugin feeds

Cuando aparezca en la consola el mensaje “Plugin feeds-1.4 installed” podemos seguir al siguiente paso del tutorial.

Vamos a crear un feed rss con los issues creados en el sistema. Primero procedemos a ubicar el archivo /issuetracker/grails-app/controllers/IssueController.groovy y adicionamos el siguiente método:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def feed = {
        render(feedType:"rss", feedVersion:"2.0") {
            title = "Mi feed de prueba "
            link = "http://localhost:8080/issuetracker/issue/feed"
            description = "Issues Grails news feed"
 
            Issue.list().each() { 
            	issue -> entry(issue.submitter) { 
            		link = "http://your.test.server/article/${issue.id}" 
            		issue.description // return the content 
            	} 
            } 
        } 
    }

Si digitamos la dirección http://localhost:8080/issuetracker/issue/feed podremos ver generado el siguiente feed:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" version="2.0">
  <channel>
    <title>Mi feed de prueba</title>
    <link>http://localhost:8080/issuetracker/issue/feed</link>
    <description>Issues Grails news feed</description>
    <item>
      <title>User 1</title>
      <link>http://your.test.server/article/5</link>
      <content:encoded>My report from error</content:encoded>
      <guid>http://your.test.server/article/5</guid>
    </item>
    <item>
      <title>User 2</title>
      <link>http://your.test.server/article/6</link>
      <content:encoded>This component does not work in firefox</content:encoded>
      <guid>http://your.test.server/article/6</guid>
    </item>
  </channel>
</rss>

Si queremos incluir el enlace para la visualización del RSS en nuestra página de listado de Issues podemos adicionar el siguiente código al archivo /issuetracker/grails-app/views/issue/list.gsp

1
2
3

   <div >
	<a href="${createLinkTo(dir:'issue/feed', file:'')}">View RSS</a>
   </div>

En muchas ocasiones no es suficiente la funcionalidad que genera automáticamente el marco de trabajo Grails.  En la presente sección realizaremos algunas modificaciones a las pantallas generadas por la herramienta.

Vamos a la carpeta ‘grails-app/views‘, notese que hay una carpeta por cada tabla creada, en estas carpetas estará en código seudo-HTML para cada una de nuestras vistas en la aplicación.

El siguiente paso es modificar algunas de las vistas para ver su funcionamiento, para nuestro ejemplo vamos a modificar la vista que muestra la lista de “issues”, abrimos el archivo ‘grails-app/views/issue/list.gsp‘, pero, primero vamos a crear un nuevo tag dinamico para nuestra aplicación (ud puede ver mas de los tags en http://grails.org/Dynamic+Tag+Libraries).

Teniendo como base la carpeta de nuestro proyecto ejecutamos el comando:

> grails create-tag-lib Misc

Una vez ejecutado este comando se creara el archivo ‘grails-app/taglib/MiscTagLib.groovy ‘ y a este le vamos a añadir las siguientes líneas de código:

Descargamos la siguiente imagen: http://openclipart.org/people/hrum/hrum_cocktail.png y la copiamos en la carpeta issuetracker\web-app\images (es recomendable reducir el tamaño de la imagen para una mejor visualización).

Ahora modificamos   el archivo ‘grails-app/views/issue/list.gsp ‘ de la siguiente forma: (Nótense las líneas 27, y 39 a la 43.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
        <meta name="layout" content="main" />
        <title>Issue List</title>
    </head>
    <body>
        <div class="nav">
            <span class="menuButton"><a class="home" href="${resource(dir:'')}">Home</a></span>
            <span class="menuButton"><g:link class="create" action="create">New Issue</g:link></span>
        </div>
        <div class="body">
            <h1>Issue List</h1>
            <g:if test="${flash.message}">
            <div class="message">${flash.message}</div>
            </g:if>
            <div class="list">
                <table>
                    <thead>
                        <tr>
                   	        <g:sortableColumn property="id" title="Id" />
                   	        <th>Component</th>
                   	        <g:sortableColumn property="type" title="Type" />
                   	        <g:sortableColumn property="submitter" title="Submitter" />
                   	        <g:sortableColumn property="description" title="Description" />
                   	        <g:sortableColumn property="status" title="Status" />
                   	        <g:sortableColumn property="bounty" title="Bounty" />
                        </tr>
                    </thead>
                    <tbody>
                    <g:each in="${issueInstanceList}" status="i" var="issueInstance">
                        <tr class="${(i % 2) == 0 ? 'odd' : 'even'}">
                            <td><g:link action="show" id="${issueInstance.id}">${fieldValue(bean:issueInstance, field:'id')}</g:link></td>
                            <td>${fieldValue(bean:issueInstance, field:'component')}</td>
                            <td>${fieldValue(bean:issueInstance, field:'type')}</td>
                            <td>${fieldValue(bean:issueInstance, field:'submitter')}</td>
                            <td>${fieldValue(bean:issueInstance, field:'description')}</td>
                            <td>${fieldValue(bean:issueInstance, field:'status')}</td>
                            <td>
                            	<g:repeat times="${issueInstance.bounty}">  
   									<img src="${createLinkTo(dir:'images', file:'hrum_cocktail.png')}" alt="${issueInstance.bounty} beers"/>  
   								</g:repeat>  
                            </td>
                        </tr>
                    </g:each>
                    </tbody>
                </table>
            </div>
            <div class="paginateButtons">
                <g:paginate total="${issueInstanceTotal}" />
            </div>
        </div>
    </body>
</html>

Ahora nuestro listado de Issues se verá de la siguiente forma:

Grails soporta los conceptos de “Pruebas Unitarias” y “Pruebas de Integración“.
Las “pruebas unitarias” se orientan a pruebas pequeñas de ejecución rápida que no soportan carga de Componentes.  Las “pruebas de integración” se encargan de evalular el ambiente en el que se ejecuta el aplicativo.

Para nuestro ejemplo vamos a modificar el archivo “ProjectTests.groovy“  (Este archivo se encuentra dentro de la carpeta   “\issuetracker\test\unit\” .  Grails crea automáticamente Archivos de pruebas para las entidades del dominio creadas previamente) :

import grails.test.*
 
class ProjectTests extends GrailsUnitTestCase {
    protected void setUp() {
        super.setUp()
    }
 
    protected void tearDown() {
        super.tearDown()
    }
 
    //Test sin errores
    void testSomething() {
    	Project hs = new Project(name:"hello world")
        assertEquals "hello world", hs.name
    }
 
    //Test con errores
    void testSomethingFails() {
    	Project hs = new Project(name:"hello world")
        assertEquals "hello world failed", hs.name
    }
}

En este ejemplo vemos dos pruebas testsomething y testsomethingfails.

Para ejecutar el conjunto de pruebas unitarias del proyecto ejecutamos el comando:

>> F:\dev\issuetracker>grails test-app

Para nuestro ejemplo la consola debería mostrar un mensaje similar al siguiente:

Starting unit tests ...
Running tests of type 'unit'
-------------------------------------------------------
Running 4 unit tests...
Running test ComponentTests...PASSED
Running test IssueTests...PASSED
Running test ProjectTests...
                    testSomethingFails...FAILED
Tests Completed in 312ms ...
-------------------------------------------------------
Tests passed: 3
Tests failed: 1
-------------------------------------------------------

Adicionalmente grails genera un reporte en la siguiente ruta: F:\dev\issuetracker\test\reports\html\index.html. A continuación un pantallazo del reporte:

Pruebas Funcionales de Proyectos Grails

Además de pruebas unitarias , Grails también soporta pruebas funcionales utilizando Canoo WebTest. (Canoo WebTest es una herramienta de software libre destinada para la automatización de pruebas de aplicaciones web.)

Para instalar el plugin de pruebas funcionales ejecutamos el siguiente comando:

F:\dev\issuetracker>grails install-plugin webtest

(Nota: Durante la instalación del plugin el instalador pedirá también la instalación de WebTest)

Para crear una prueba funcional de nuestra clase de dominio Project, ejecutamos el siguiente comando:

F:\dev\issuetracker>grails create-webtest Project

Grails creará el siguiente archivo: “/issuetracker/webtest/tests/ProjectTest.groovy“  con el siguiente contenido:

class ProjectTest extends grails.util.WebTest {
 
    // Unlike unit tests, functional tests are sometimes sequence dependent.
    // Methods starting with 'test' will be run automatically in alphabetical order.
	// If you require a specific sequence, prefix the method name (following 'test') with a sequence
	// e.g. test001ProjectListNewDelete
 
    def testProjectListNewDelete() {
            invoke      'project'
            verifyText  'Home'
 
            verifyListSize 0
 
            clickLink   'New Project'
            verifyText  'Create Project'
            clickButton 'Create'
            verifyText  'Show Project', description:'Detail page'
            clickLink   'List', description:'Back to list view'
 
            verifyListSize 1
 
            group(description:'edit the one element') {
                showFirstElementDetails()
                clickButton 'Edit'
                verifyText  'Edit Project'
                clickButton 'Update'
                verifyText  'Show Project'
                clickLink   'List', description:'Back to list view'
            }
 
            verifyListSize 1
 
            group(description:'delete the only element') {
                showFirstElementDetails()
                clickButton 'Delete'
                verifyXPath xpath:  "//div[@class='message']",
                            text:   /.*Project.*deleted.*/,
                            regex:  true
            }
 
            verifyListSize 0
    }
 
    String ROW_COUNT_XPATH = "count(//div[@class='list']//tbody/tr)"
 
    def verifyListSize(int size) {
        ant.group(description:"verify Project list view with $size row(s)") {
            verifyText  'Project List'
            verifyXPath xpath:      ROW_COUNT_XPATH,
                        text:       size,
                        description:"$size row(s) of data expected"
        }
    }
 
    def showFirstElementDetails() {
        clickLink   '1', description:'go to detail view'
    }
}

Para ejecutar la prueba escribimos el comando:

> F:\dev\issuetracker>grails run-webtest

Se generará un reporte como el siguiente:

Puede encontrar un listado de completo para pruebas de canoo en la siguiente ubicación: http://webtest.canoo.com/webtest/manual/manualOverview.html

Adicionalmente puede utilizar la herramienta WebTestRecorder.

Enlaces Relacionados:

• Grails Unit Testing
• Testing Controllers
• Testing Services
• Testing Domain Classes
• Grails Functional Testing
• Mastering Grails: Testing your Grails application

A continuación se describirá el proceso para configurar el entorno de Eclipse con las opciones para edición de Código Groovy y soporte para aplicaciones Grails.  (Eclipse es un entorno de desarrollo múltiplataforma de código abierto. Más información en esta dirección: http://es.wikipedia.org/wiki/Eclipse_(software) ) .

Primero abrir eclipse y seleccionar en el menú la opción  help → software updates.   Esta opción abrirá una nueva pantalla. En esta seleccionamos la opción  Avaliable Software:

Seleccionamos el botón Add Site y en la url añadimos http://dist.codehaus.org/groovy/distributions/updateDev/ y damos clic en OK.

Ahora agregamos el siguiente sitio, repitiendo el paso anterior http://dist.codehaus.org/groovy/distributions/update/

Y seleccionamos los plugins a instalar de la siguiente forma (Tener en cuenta exactamente las versiones seleccionadas para el “Groovy Feature” y el “Grails Eclipse Feature” :

Seleccionamos la opción “Install” y aceptamos los términos de la licencia. Luego de terminada la descarga automática de los plugins seleccionados debemos proceder a reiniciar Eclipse.

Configuración de Variables de Entorno de Eclipse

Ahora vamos a añadir la variable de entorno GRAILS_HOME en eclipse. Vamos a Windows → Preferences, buscamos Java → Build Path → Classpath Variables:

Damos clic en la opción New,

Name: GRAILS_HOME
Path: (La ruta donde esta instalado grails, ej: C:\grails)

Ahora importemos un proyecto grails a eclipse.
Vamos a File → Import, ahí escogemos General → Existing Projects into Workspace, y le damos Next:

Ahora buscamos el directorio donde esta nuestro proyecto grails y hacemos clic en finish:

Ahora vamos a modificar las propiedades del configuración del proyecto Eclipse. Hacemos Click derecho sobre el proyecto → properties y seleccionamos la opción “groovy project properties” (Modificamos los valores de las variables según como muestra la imagen)

Para ejecutar la aplicación podemos utilizar la combinación de teclas  CTRL+F11, o la opción  Run → Run en el menú. Seleccionamos la primera opción, para nuestro ejemplo issuetracker y la opción  OK.

Cuando en la consola de eclipse aparezca   Server running. Browse to http://localhost:8080/issuetracker, podremos iniciar la aplicación  en el explorador.

Configuración para Depuración (Debug) de Grails en Eclipse

Para que el depurador de Eclipse funcione con Grails, debemos verificar en las propiedades del proyecto  que la opción Disable Groovy Compiler Generating Files esté habilitada  y en Groovy compiler output location este la ruta “web-app/WEB-INF/classes”.

Para nuestro ejemplo, vamos a hacer un debug para la clase “ComponentController.groovy”

Abrimos la clase “ComponentController.groovy” y ponemos un break point en cualquier linea, para nuestro ejemplo en la linea 9, Hacemos clic en el botón debug, o F11, saldrá una pantalla similar a esta:

Habilitamos la casilla “Don’t tell me again” y OK.
Ahora vemos la aplicación en el navegador, y hacemos clic en el vinculo ComponentController ,y el debug es activado en eclipse.

Damos clic derecho en el proyecto en la pantalla debug y vamos a Edit Source Lookup, damos click en el botón add, seleccionamos la opción Workspace Folder,

Buscamos la ruta web-app/ WEB-INF/classes, habilitamos la opción Search subfolders y la opción OK.  Adicionalmente, seleccionamos de nuevo la opción  add, y agregamos la ruta grails-app, también habilitamos la opción Search subfolders y OK.

En este momento ya tenemos habilitado  entorno de eclipse para depuración de aplicaciones Groovy / Grails.

Para nuestro ejemplo vamos a crear los siguientes modelos de dominio: Project, Component, and Issue.
La clase “Project” que representa el proyecto de software para el cual vamos a registrar incidencias (Bugs).
Un Project puede tener uno o más Componentes (Ejm: gui, documentación, etc)
Un Componente solo está asociado a un proyecto y puede tener cero o más Issues asociados.
Un objeto Issue está asociado a un Componente.

Con el siguiente comando creamos la entidad Project:

>  D:\dev\issuetracker>grails create-domain-class  Project

Si el comando se ejecuta satisfactoriamente debería obtenerse una respuesta similar a la
siguiente:

>  Welcome to Grails 1.1.1 – http://grails.org/
>  Licensed under Apache Standard License 2.0
>  Grails home is set to: C:\dev\grails-1.1.1
>  Base Directory: D:\dev\issuetracker
>  Running script C:\dev\grails-1.1.1\scripts\CreateDomainClass.groovy
>  Environment set to development
>  Created DomainClass for Project
>  Created Tests for Project

grails automáticamente crea el archivo    %PROJECT_HOME%\grails-app\domain\Project.groovy     con la siguiente estructura

1
2
3
4

class Project {
 
static constraints = {}
}

Qué es una Clase de Dominio?

Una clase de dominio es un artefacto persistente para el cual todas sus propiedades  son persistidas
en la base de datos (Más información en  GORM http://www.grails.org/GORM (Grails Object Relational Mapping) )

Para nuestro ejemplo editamos el archivo Project.groovy de la siguiente forma:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Project {
  // relaciones
  static hasMany = [components: Component]
 
// campos
String name
 
String toString() {
return name
}
 
// restricciones
static constraints = {
name()
components()
}
}

Como se puede ver en la clase Project, por lo general una clase de dominio de GORM se compone de relaciones con otras entidades,
campos (Columnas en la base de datos), y restricciones.

Para nuestro sistema de ejemplo debemos crear también las clases de dominio Issue y Component:

>  D:\dev\issuetracker>grails create-domain-class  Component
>  D:\dev\issuetracker>grails create-domain-class  Issue

y las editamos de la siguiente forma:

Component.groovy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Component {
// relationships
static belongsTo = Project
static hasMany = [issues: Issue]
 
// fields
Project project
String name
 
// override for nice display
String toString() {
return “${project} - ${name}”
}
 
// constraints
static def constraints = {
//’empty’ constraints
//garantizan el orden como apareceran los campos en la forma
name()
project()
issues()
}
}

Issue.groovy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Issue {
// relationships
static belongsTo = Component
 
// fields
Component component
String type
String submitter
String description
String status = “New”
Integer bounty
Date dateCreated
Date lastUpdated
 
// constraints
static constraints = {
component()
//restringe una lista de valores
type(inList: ["Defect", "Feature"])
submitter()
 
description(size: 0..5000)
status(inList: ["New", "Accepted", "Closed", "Won't Fix"])
bounty(range:0..12)
}
}

En los siguientes enlaces puede encontrarse información mucho más detallada sobre el funcionamiento de GORM:
Mapeo de Entidades: http://www.grails.org/GORM+-+Mapping+DSL
Relaciones: http://www.grails.org/GORM+-+Defining+relationships
Colecciones: http://www.grails.org/GORM+-+Collection+Types
Operaciones de Crud: http://www.grails.org/GORM+-+CRUD

Creación de Datos de Prueba

Muchas veces se requieren datos de ejemplo para realizar pruebas al sistema.
Grails nos permite la creación inicial de datos de la siguiente forma:

Ubicar el archivo    %PROJECT_HOME%\grails-app\conf\BootStrap.groovy   y modificarlo de la siguiente forma:

class BootStrap {

def init = { servletContext ->
// Create some test data
new Project(name:”Widget para Facebook”).save()
new Project(name:”Simple Issue Tracker”).save()
new Project(name:”Extensión para Openlayers”).save()
}
def destroy = {
}
}

En este ejemplo creamos tres objetos Project como datos de prueba.

Creación de Controladores y Vistas

Dado que ya disponemos de nuestras clases de dominio, podemos ejecutar los siguientes comandos que se
encargarán de generar los controladores y vistas para nuestras entidades:

>D:\dev\issuetracker>grails generate-all Project
>D:\dev\issuetracker>grails generate-all Component
>D:\dev\issuetracker>grails generate-all Issue

El comando generate-all genera el código necesario para habilitar el CRUD de las entidades Project, Component e Issue.

Para ejecutar la aplicación podemos utilizar el comando:

> D:\dev\issuetracker>grails run-app

Una vez  se ha inicializado el servidor, puede ingresar a la aplicación a través del siguiente url:  http://localhost:8080/issuetracker

En la pantalla de inicio podrá ver lo siguiente:

Si selecciona la opción ProjectController podrá ver el listado de los proyectos:

A continuación la pantalla donde se muestra el detalle de un Component:

Si desea crear un nuevo Issue, grails ha generado para usted la siguiente pantalla:

Nótese que con muy poco esfuerzo hemos logrado crear una aplicación completa de CRUD para administrar nuestras entidades Project, Component e Issue.  En las siguientes partes del tutorial se incluirán  funcionalidades adicionales y personalización de la visualización.

Puede descargar el código completo de la parte 2 desde esta ubicación

Introducción:

Grails es un marco de trabajo para el desarrollo de aplicaciones web que se basa en las ideas de
“Codificación a través de Convenciones” (coding by convention) y DRY (don’t repeat yourself) utilizando el lenguaje de programación Groovy.

Grails se ejecuta sobre una máquina virtual de Java, teniendo acceso completo a la plataforma y librerías Java.

Con Grails pueden crearse fácilmente aplicaciones web gracias a:

• Ofrece un Entorno completo para el desarrollo y publicación de aplicaciones: Todas las dependencias y configuración requeridas para ejecutar las aplicaciones web son proporcionadas por Grails.  Usted debe solamente preocuparse por el código particular de su aplicación.
• Incluye un servidor Jetty embebido.
• El modo de desarrollo automáticamente recarga los cambios realizados al código de la aplicación sin tener que reiniciar el servidor web.
• Ofrece mapeo de persistencia automàtico para las clases del Dominio del problema, así como también manejo automàtico de las relaciones entre las entidades.
• Ofrece scaffolding para el acceso a datos, ofreciendo posibilidades para el desarrollo rápido de operaciones CRUD (Create, Read, Update, Delete).
• Soporte de tecnologías para la implementación de vistas de datos utilizando “dynamic tag libraries” y “Groovy Server Pages (GSP)”
• Extensibilidad a través de la utilización de plugins.

Grails puede usarse como un entorno de desarrollo autónomo que esconde todos los detalles de configuración así como también permite integrar lógica de negocio escrita en Java.  Entre los objetivos de Grails está el hacer el desarrollo web lo más simple y atractivo posible de tal forma que un amplio segmento de desarrolladores puedan utilizarlo.

Tutorial “Escribir un Manejador de Incidencias Utilizando Grails”

El tutorial a desarrollar a continuación se basa en el artículo “Writing a Simple Issue Tracker in Grails” Part 1 y   Part 2

Cómo Obtener el Framework Grails?

Usted puede descargar la última versión del framework desde la siguiente ubicación: http://www.grails.org/Download

Instalación

Una vez ha obtenido y descomprimido el framework debe adicionar a su sistema operativo la variable de entorno GRAILS_HOME.

Si utiliza windows puede configurar las variables de entorno de la siguiente forma:

> set GRAILS_HOME=C:\download\grails
> echo %GRAILS_HOME%
C:\download\grails
> set PATH=%GRAILS_HOME%\bin;%PATH%

(Información adicional:  Administrar variables de entorno en Windows XP )

O si utiliza sistemas basados en linux puede utilizar los siguientes comandos:

> set GRAILS_HOME=~/download/grails
> export GRAILS_HOME
> echo ${GRAILS_HOME}
~/download/grails
> cd ${GRAILS_HOME}
> chmod a+x bin/grails
> set PATH=${GRAILS_HOME}/bin:${PATH}
> export PATH

(No olvide configurar también la variable JAVA_HOME apuntando a la carpeta donde reside su instalación
particular de Java (JDK http://java.sun.com/javase/downloads/index.jsp).
Configuración de Java en Windows
Configuración de Java en Unix)

para comprobar su instalación de grails puede digitar el siguiente comando

> grails

debe aparecer como respuesta un mensaje similar al siguiente:

> C:\Documents and Settings\user>grails
> Welcome to Grails 1.1.1 – http://grails.org/
> Licensed under Apache Standard License 2.0
> Grails home is set to: C:\dev\grails-1.1.1
> No script name specified. Use ‘grails help’ for more info or ‘grails interactive’ to enter interactive mode

Creando el proyecto Con Grails

Para crear nuestro  proyecto Grails debe utilizar el siguiente comando

> D:\dev>grails  create-app issuetracker

este comando creará una carpeta con la siguiente estructura de directorios:
(Para nuestro ejemplo la carpeta %PROJECT_HOME% es representada por la carpeta D:\dev\issuetracker)

Configuración de la Base de Datos

Para nuestro ejemplo utilizaremos el motor de bases de datos relacionales PostgreSql. (Debemos crear
una instancia y usuario en la base de datos. Para este caso creamos la base de datos “issues” con
su usuario relacionado “issuetracker” con clave “issuetracker”)

Primero necesitamos descargar el driver Jdbc disponible en la siguiente ubicación: http://jdbc.postgresql.org/download.html
(Para nuestro ejemplo descargamos el jar postgresql-8.3-604.jdbc4.jar )
El jar obtenido debe ser copiado en la carpeta %PROJECT_HOME%/lib

Configuración del Datasource

Una de las grandes ventajas de Grails es la facilidad para el manejo de la configuración del proyecto.

Por ejemplo el comando ejecutado “create-app”  entre otros archivos crea uno llamado  DataSource.groovy (En la carpeta %PROJECT_HOME%grails-app/conf/ ).
Este archivo nos permite especificar diferentes ambientes (Development, TestData y Production)
para el manejo de la fuente de datos del proyecto.  Como opción por omisión utiliza el manejador de datos
HSQLDB.

Para modificar la configuración del entorno “Development” utilizando postgresql debemos modificar el archivo DataSource.groovy de la siguiente forma:

development {
dataSource {
driverClassName = "org.postgresql.Driver"
dbCreate = "create-drop" // one of 'create', 'create-drop','update'
url = "jdbc:postgresql://localhost:5432/issues"
dialect = org.hibernate.dialect.PostgreSQLDialect
username = "issuetracker"
password = "issuetracker"
}
}

(Más información en http://hartsock.blogspot.com/2008/07/postgresql-and-grails.html )

Project Description: (You can read the spanish version of this article here)

VGICC is a Proof of concept using the new Google Earth Browser Plug-in. This application takes advantage of the plug-in to visualize and interact with statistical and geographical information of government contracts in Colombia.

(Note: The information available in this application is only for testing purposes. Official data can be found at the Official Contracting Site of Colombia, “PUC, Portal Único de Contratación” http://www.contratos.gov.co/puc/ )

Online Links

• Launch Application (This application requires Google Earth’s Browser Plug-in. You can download it from this location:: http://code.google.com/apis/earth/)
• Screencast 1: 3D Visualization of contract statistics using Google Earth Browser Plug-in.
• Screencast 2: Browsing Contracts using VGICC

Project Challenge:

Provide an interactive Geographic Rich Internet Application that allows users to visually explore and discover new relations of Government’s investments using spatial, statistical and public contract information of Colombia.

This Geographic Rich Internet Application uses Interactive Web Mapping techniques as an alternative tool to explore PUC´s data. (Current search engine is based solely on plain text filters).

Technical Challenge:
During development stages of this proof of concept some technical challenges must be confronted:

• Information Extraction:Although PUC (http://www.contratos.gov.co/puc/) lets public search options for general users, it doesn’t provide any free Web Service, RSS or interoperable API that could be integrated with external systems. However, thanks to the implementation of Web Scrapping techniques it was possible to automatically extract information from web pages published at PUC’s search portal.

• Transformation, Georreferencing and Data Loading: Once information extraction was accomplished, it was necessary to transform and georeference each one of the contracts against the available database of political-administrative divisions of Colombia. Furthermore, all data was stored in a geographic database managed by Postgres and Postgis.

• Interactive Visualization of Geographical and Statistical Information through Internet: May one of the biggest technical challenges of the VGICC was related to the implementation of the web visualization of geographical and statistical data using modern web technologies and tools.  Firstly, Google’s brand new “Google Earth Browser Plug-in”  was used to enable web browser based geographic visualization of data. One of the most interesting features of Google Earth and KML is the possibility of draw 3D objects over the earth globe. In this case, 3D objects are used to represent the amount of government investment in a particular state or county.  Secondly, it was possible to programmatically interact with the GE plug-in using JavaScript and KML (perhaps this is the most appealing feature of the plug-in for programmers and system integrators).  Finally, to provide a single and unified user experience based on Html it was necessary to use different JavaScript/Ajax techniques and tools.  This framework, as a whole, proved to be a suitable alternative for the implementation of geospatial browser based applications.

Basic Features:
Basically, the application allows geographic visualization of consolidated data by State and County.  There are two basic interactions:

• State selection using lists: A user selects a State using a combo box and the application dynamically loads Kml data from the server side and shows the results using the Google Earth Browser Plug-in. Camera views are relocated according to the selected State.

• Contract search by feature selection on the map: A user can search a specific list of contracts related to a County. (State and County polygons are shown on the Google Earth Plug-in). Each balloon attached to a placemark on the map shows the amount of investment and quantity of contracts that take place in the given region and a link to the detailed list of contracts.  Such list also provides links to detailed information for each contract as well as a reference to the official related site at http://www.contratos.gov.co/puc/.

Benefits:
Provide alternative ways of data discovery and exploration of PUC’s data (Portal Único de Contratación de Colombia) using techniques based on Rich Internet Applications, geographic information and 3D visualization.

Tools:

• Google Earth Browser Plugin
• Javascript, Ajax, Adobe Spry Framework for Ajax
• Java, Grails
• Postgresql, Postgis

Lessons Learned:
Nevertheless the amazing features of Google Earth Browser plug-in, there are some issues related to rendering that affect visualization in some computers.   For example,  this is an extract of the correct visualization of the application for a particular State in Colombia:

In other machines polygons are not rendered correctly:

Or even in other machines rendering is completely different:

Such issue was reported at Google Groups. So far the issue stills open. (For more information look at Google Earth Browser Plugin: Polygons don’t render correctly )

Descripción del Proyecto: (You can read the english version of this article here)

Prueba de concepto del Google Earth Browser Plugin donde se utilizan sus posibilidades como motor de visualización de Información Geográfica y estadística  a través de la creación de un aplicativo que permite explorar de forma interactiva la información de contratación estatal de Colombia publicada en el Portal Único de Contratación (PUC, http://www.contratos.gov.co/puc/).

(Nota: La información publicada en este aplicativo es únicamente para efectos de prueba. Los datos oficiales del PUC puede encontrarlos en la dirección http://www.contratos.gov.co/puc/ )

Enlaces en Línea

• Ver Aplicación en Línea (Requiere el plugin de google earth que puede ser descargado en la siguiente ubicación:  http://code.google.com/apis/earth/)
• Screencast 1: Visualización de Estadísticas en 3D
• Screencast 2: Consulta de Contratos

Desafíos del Proyecto:
Proveer un sistema de consultas interactivo basado en mapas y gráficos para el Portal Único de Contratación de Colombia  de manera que los usuarios puedan explorar y visualizar la información de contratación teniendo en cuenta la ubicación geográfica de las inversiones realizadas en el país.

Esta prueba de concepto de un sistema de consultas interactivas para el PUC permitiría a los usuarios una forma más eficiente para visualizar la información de contratación de Colombia en comparación a las búsquedas que actualmente existen donde únicamente se limitan a filtros por criterios alfanuméricos.

Desafío Técnico:
Para el desarrollo del proyecto se presentaron múltiples desafíos técnicos en diferentes temas:

• Extracción de Información: Aunque la información del Portal Único de Contratación puede ser consultada  libremente por los usuarios en la página http://www.contratos.gov.co/puc/, no existe en el momento un Servicio Web, RSS o Interfaz de programación abierto que permita su comunicación  con otros sistemas externos.  Para que nuestro sistema VGICC  pudiera utilizar la información del PUC  fue necesaria la implementación de técnicas de Web Scrapping (http://en.wikipedia.org/wiki/Web_scraping) que permitieran la extracción automática la información publicada en el Portal Único de Contratación.

• Transformación, Georreferenciación y Carga de Datos: Una vez extraída la información del PUC fue necesaria la transformación y Georreferenciación de la ubicación  de los contratos respecto a la división política de Colombia por Municipios.  Posteriormente dicha información fue cargada  en una base de datos espacial publicada en el motor Postgresql / Postgis.

• Visualización Interactiva de Información Geográfica y Estadísticas a través de Internet: Uno de los principales desafíos técnicos del VGICC fue el de permitir herramientas Web interactivas de fácil uso para la visualización de información geográfica y estadística.  Con el fin de suplir esta necesidad se valió de las utilidades de representación geográfica y 3D que presta el recientemente publicado servicio de Google Earth Browser Plugin (http://code.google.com/apis/earth/).  Dicho plugin permite la interacción con el motor de visualización de Google Earth a través de técnicas de programación basadas en KML, Javascript/AJAX.  Gracias a este marco de trabajo (tal como se demuestra en la prueba de concepto) es posible realizar aplicaciones Web que permitan explorar la información ya sea desde el punto de vista alfanumérico como el Geográfico.

Funcionalidades Básicas Implementadas:
Permite visualizar de manera geográfica información consolidada por Departamento y Municipio. Se implementaron dos formas básicas de interacción:

• Selección de Departamentos a través de Listas: Seleccionando un Departamento de una lista se hace un acercamiento al área que este cubre. Sobre el centroide de cada municipio de muestra una barra que es proporcional al monto total de contratación que ha tenido el municipio.

• Filtros de Consulta a través de Selección en el Mapa: El usuario tiene la posibilidad de interactuar con la información de los municipios disponible en el Mapa de Google Earth.  En los globos de información de Google Earth se despliega la información de cuantos contratos y el monto de los contratos que afectan al municipio seleccionado. De la misma forma se habilita un link de “Ver contratos”,  que permite la consulta de todos los contratos que afectan a dicha región. Dicho listado a su vez permite ver la información detallada para cada uno de los contratos así como también el link a la información oficial publicada en el PUC (Portal único de Contratación).

Beneficios:
Permitir a los usuarios que consultan el Portal Único de Contratación formas alternativas de exploración y descubrimiento de información de las inversiones estatales realizadas en Colombia  a través de técnicas de Visualización en 3D y representación espacial / geográfica de la información de los contratos estatales desarrollados en el país.

Herramientas:

• Google Earth Browser Plugin
• Javascript, Ajax, Adobe Spry Framework for Ajax
• Java, Grails
• Postgresql, Postgis

Lecciones Aprendidas:
No obstante las grandes virtudes que posee actualmente la herramienta Google Earth Browser Plugin, durante el desarrollo del VGICC  se encontraron algunos bugs de renderización del plugin entre diferentes versiones de navegador.

Por ejemplo se tiene el siguiente segmento de visualización para el departamento de Boyacá:

Sin embargo en algunas máquinas los polígonos se muestran de forma incompleta:

O incluso en otros equipos la renderización es completamente inconsistente:

Dicha inconsistencia fue reportada en los foros de Google Groups pero hasta el momento no se ha dado una solución satisfactoria a la incidencia (Para más información ver Google Earth Browser Plugin: Polygons don’t render correctly )