Kudos Ltda. .:: Open Systems

Introducción al Desarrollo de Aplicaciones con Groovy y Grails (Parte 2)

Creando una Clase del Dominio del Problema

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