Envio de correo con Grails - Plugin Mail

1 - Instalar el plugin

grails install-plugin mail

2 - en Config.groovy Configuramos la cuenta de correo

grails {
    mail {
        host = "smtp.midominio.com"
        port = 25
        username = "usuario"
        password = "contraseña"
        props = ["smtp.midominio.com":"true", 
        "smtp.midominio.com":"25"]
    }
}

3- en el controlador

sendMail {   

    to params.email
    from "admin@midominio.net"
    subject "Asunto"
    html "Mensage a enviar"
}

Programación modular en Grails - TagLib

Si lo que necesitamos es reutilizar código, Grails nos lo facilita con los TagLibs (Librerias de etiquetas)
Por ejemplo: si lo que se quiere es crear un TexBox con unas caracteristicas determinadas el cual usar en muchas vistas podemos crear un taglib el cual lo defina; de esta manera si se realizan modificaciones solo habrá que realizarlas en un solo sitio.

Crear TagLib
Botón derecho sobre la carpeta Tag Libraries -> New -> Grails Tag Library...  proporcionamos un nombre ej. Controls y esto generará un archivo ControlsTagLib.groovy ahora solo hay que añadir el código del TexBox


class ControlsTagLib {
static namespace = 'controls' 
   /**
       * - size: Para forzar un ancho (HTML) concreto
       * - id: el id del <input>
       * - value: el valor que tedrá el <input>
       * - click: código javascript que se ejecutará al hacer click
      */
     def textBox = { attrs ->
         def size = getOptionalAttribute(attrs, "size")
         def id = getOptionalAttribute(attrs, "id")
         def value = getOptionalAttribute(attrs, "value")
         def click = getOptionalAttribute(attrs, "click")
         def className = getOptionalAttribute(attrs, "class")
         // Otros Atributos
         def extraAttrs = ""
         attrs.each{k,v ->
              extraAttrs += "${k}=\"${v.encodeAsHTML()}\" "
        }

     out << """
            <input onclick=\"selectTextInput('${id}'); ${click}\" id=\"${id}\" type=\"text\" size=\"${size ? size : "10"}\" value=\"${value}\" class=\"elemsFilterForm ${className}\"  ${extraAttrs}>
     """
     }

     protected getRequiredAttribute(attrs, String name, String tagName) {
         if (!attrs.containsKey(name)) {
    throwTagError("Tag [$tagName] is missing required attribute [$name]")
        }
        attrs.remove name
     }

     protected getOptionalAttribute(attrs, String name) {
         def ret = attrs.remove(name)
         if(!ret || ret.equals("")){
       ret = ""
        }
        return ret
     }
}

Para utilizar el taglib desde una vista

<controls:textBox id="username" name="username"  value="${userInstance.username}" size="20"/>

En Grails: HashMap (collectEntries VS Iterator)

Los dos métodos hacen lo mismo; retornan un map (clave, valor)

def static getUsersGroups(){
     def groups;
     User obj;
     HashMap mapGrp = new HashMap();
     groups=User.findAll("FROM User Where userType='G'");
     Iterator<User> gr = groups.iterator();
     while(gr.hasNext()){
  obj=gr.next();
  mapGrp.put(obj.id, obj.username);
     }
     return mapGrp;
 }

Mucho más fácil (puramente en lenguaje groovy)

def static getUsersGroups(){
     def groups=User.findAllByUserType("G");
     groups.collectEntries {
          [(it.id): (it.username)]
     }
}

FindAll - Subconsulta

Ejemplo de subconsulta con findAll en Grails

def filtrosNoAsignados = Filter.findAll("FROM Filter f where f.code not in(SELECT filter.code FROM UserFilterView)")

JqGrid otra opción al FlexiGrid

http://www.trirand.com/blog/jqgrid/jqgrid.html

Interando con Rangos

(0..9).each { i->
   println i
}

for(int i=0;i<=9;i++) {
    println i
}

for (i in 0..9) {
    println i
}

Grails con MySql

En una entrada anterior ya hablé de como configurar una conexión entre Grails y Oracle. Como no podía ser de otra manera ahora toca el turno a MySql. La conexión entre Grails y MySql es muy fácil y solo hay que tener en cuenta lo siguiente:

1 -Hay que bajarse el conector mysql-connector-java-5.1.10-bin.jar o una versión superior y dejarlo caer en la carpeta lib del proyecto Grails.

2 -Seguidamente puedes cargarte todo el código del archivo DataSource.groovy y pegar el que tienes más abajo teniendo en cuenta que que tendrás que modificar la Url para que apunte a la base de datos y asignar permisos al usuario sobre la misma. 

Importante: Grails genera automáticamente todas la tablas y sus relaciones basándose en el modelo de datos pero la base de datos debe existir previamente.

dataSource {

    pooled = true

    driverClassName = "com.mysql.jdbc.Driver"

}

hibernate {

cache.use_second_level_cache=true

cache.use_query_cache=true

cache.provider_class='com.opensymphony.oscache.hibernate.OSCacheProvider'   

}

environments {

    development {

         dataSource {

                dbCreate = "update"

                username = "grails"

                password = "grails"

                url = "jdbc:mysql://localhost/mydatabase"

         }

    }

    test {

         dataSource {

                dbCreate = "update"

                username = "grails"

                password = "grails"

                url = "jdbc:mysql://localhost/mydatabase"

         }

    }

    production {

         dataSource {

                dbCreate = "update"

                username = "grails"

                password = "grails"

                url = "jdbc:mysql://localhost/mydatabase"

         }

    }

}

No solo de Grails vive el hombre - JSON

En algún momento necesitaremos realizar llamadas con Ajax y que mejor que usar JSON para ello ya es un formato de datos muy ligero y utiliza la misma sintaxis que javascript. Además tiene la ventaja de que podemos incorporarlo dentro del código javascript sin necesidad de realizar análisis previos.

Sintaxis para los literales de matriz:

var dias = ["Lunes","Martes","Miercoles","Jueves","Viernes","Sabado","Domingo"];

También es posible crear una matriz, utilizando el constructor Array (esto es solo valido para javascript pero no para JSON)

var dias = new Array("Lunes","Martes","Miercoles","Jueves","Viernes","Sabado","Domingo");

el acceso a los valores se realiza indicando el nombre y su posición, teniendo en cuenta que la primera posición de la matriz siempre empieza por 0

alert(dias[0]); //Muestra Lunes

alert(dias[6]); //Muestra Domingo

Los Array no tienen un tipo de datos definido, por tanto pueden contener cualquiera de los tipos posibles.

Literales de objeto

Su finalidad es poder crear un objeto mediante el literal. Su sintaxis:

var libro = {

            "Titulo": "JSON VS XML",

            "autor": "Marty MCFly",

            "paginas" : 260,

            "digital": true

};

Nota: el valor de la última propiedad no lleva coma

se puede acceder al valor de las propiedades de varias maneras: 

Nombrando el objeto y utilizando la notación de punto

alert(libro.autor);

o utilizando la notación de corchetes

alert(libro["autor"]);

Literales de objeto y matriz

var libro = [

        {

                "Titulo":"JSON VS XML",

                "autor": "Marty MCFly",

                "paginas" : 260,

                "digital": true

        },

        {

                "Titulo":"Lenguaje Groovy",

                "autor": "Pepe HHLL",

                "paginas" : 120,

                "digital": false

        },

        {

                "Titulo":"Grails. El Santo Grial de Java",

                "autor": "Jason DDFF",

                "paginas" : 210,

                "digital": true

        }

];

Nota: el valor de la última propiedad de cada objeto no lleva coma, así como la última llave 

Libros es un array que contiene tres objetos de tipo libro. Y el acceso a las propiedades se realiza de la siguiente manera

alert(libro[2].autor); // Escribe Jason DDFF

Literales de matriz dentro de un objeto

var libro = {

                        "Titulo":"Grails 2.0 Advanced",

                        "autor": [""Marty MCFly","Pepe HHLL","Jason DDFF"],

                        "paginas" : 260,

                        "digital": true

                };

para acceder a 2º autor tendríamos que hacer: 

alert(libro.autor[1]); //ya que la matriz empieza por 0

Para convertir este objeto a JSON lo único que hay que hacer es eliminar la variable ya que JSON solo es estructura de datos; el código anterior por lo tanto quedaria como sigue:

{

  "Titulo":"Grails 2.0 Advanced",

  "autor": [""Marty MCFly","Pepe HHLL","Jason DDFF"],

  "paginas" : 260,

  "digital": true

}

si transmitimos esta información y la almacenamos en una variable llamada cad lo único que tendremos es una cadena de texto que para convertirla a objeto necesitaremos la ayuda de la función eval()

var objLibro = eval("(" + cad + ")");

ahora ya tenemos un objeto y por tanto podremos acceder a sus propiedades

Flexigrid para JQuery en Grails (Grid)

Un grid muy configurable que permite el redimensionado, ocultación y cambio de posición de las columnas de la tabla y que además permite realizar llamadas AJAX para la actualización de los datos de la Grid.
La integración con Grails es fácil, solo hay que tener en cuenta unas cosillas. La referencia a los CSS, JQUERY, y la libreria FLEXIGRID.JS que seria:

<link rel="stylesheet" href="${resource(dir:'js/flexigrid/css',file:'flexigrid.css')}" />
<script type="text/javascript" src="<g:createLinkTo dir='js' file='jquery-1.7.min.js' />"></script>
<script type="text/javascript" src="<g:createLinkTo dir='js/flexigrid/js' file='flexigrid.js' />"></script>

en dir se encuentran las carpetas de recursos del proyecto de Grails y ahí es donde se deben colocar los archivos .CSS .JS

http://flexigrid.info/

Consultas con Criteria

Los dinamic finders son métodos muy potentes que permiten realizar un gran número de consultas, en la mayoría de casos con estos métodos tendríamos más que suficiente; no obstante el problema que tienen es que no son eficaces si lo que se quiere es realizar consultas muy complejas en las que intervengan un gran número de campos.

Fecha Actual con GregorianCalendar

GregorianCalendar gCalendar = new GregorianCalendar()
Calendar calendar
DateFormat myDateFormat = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss")
def currentDate  
def dia = gCalendar.get(Calendar.DAY_OF_MONTH);//dia del mes
def mes = gCalendar.get(Calendar.MONTH);//mes, de 0 a 11
mes+=1
if(mes<=9){mes="0" + mes}
def anio = gCalendar.get(Calendar.YEAR);
currentDate = myDateFormat.parse(String.valueOf(dia) + "/" + String.valueOf(mes) + "/" + String.valueOf(anio) + " 00:00:00")

Los Dynamic Finders en Grails (findBy, findAllBy)

Son métodos dinámicos que utilizan las propiedades de la clase de dominio para crear expresiones.
findBy* -solo devuelve el primer resultado de la consulta 

Si tenemos una clase libro


class Libro {
   Long id
   Long version
   String titulo
   Date fechaPublicacion
   String autor
}


podemos usar este método de las siguientes maneras:
def lib = Libro.findByTitulo("Caballo de Troya")
lib = Libro.findByTituloAndAutor("Caballo de Troya", "J.J Benitez")
lib = Libro.findByFechaPublicacionBetween(fecha, new Date())
lib = Libro.findByFechaPublicacionGreaterThanEquals(fecha)
lib = Libro.findByFechaPublicacionLessThanEquals(fecha)
lib = Libro.findByTituloLike("%Caballo%")
lib = Libro.findByTituloIlike("%Caballo%") // ignorecase
lib = Libro.findByTituloNotEqual("Harry Potter")
lib = Libro.findByFechaPublicacionIsNull()
lib = Libro.findByFechaPublicacionIsNotNull()

En Grails; usando AJAX de JQuery

En la Vista
<head>
     <script type="text/javascript">
           function miFuncion(inputText){
                 $.ajax({
                       url:"${request.contextPath}/Post/guardarComentario",
                       dataType: 'script',
                       type:'GET',
                       data: {
                             inputText: inputText,
                             val:  $('#'+inputText).attr("value"),
                       },
                       //data: { ListID: '1', ItemName: 'test' },
                       success: function(data) {
                             //alert(data);
                       },
                       error: function(request, status, error) {
                       },
                       complete: function() {
                            //alert(data);
                       }
                 });
           }

     </script>

</head>

<body>

      <input type="text" id="comentario" name="comentario"/>

      <input type="button" onclick="miFuncion('comentario');" value="Enviar Comentario">

...

</body>

En el controlador

class Post {

       static allowedMethods = [save: "POST", update: "POST", delete: "POST", list: "GET"]

       def index() {

            redirect(action: "list")

       }

       def guardarComentario() {

            def user = User.get(session.user_id)

            def val=params.val 

            switch(params.inputText){

                 case "comentario": 

                 ...

                 break;

            ...

            }

       }

}   

Generación de passwords aleatorios de 8 carácteres

1-Importamos la clase random del paquete java.util
2-Definimos las variables newPassword y newPasswordChar que contendran una lista de enteros y una de carácteres ASCII respectivamente
3-Instanciamos la clase Random la cual permite la generación de números al azar
4-se asigna a newPassword un entero aleatorio con un valor de entre 48 y 57 que traducido en ASCII equivale a los símbolos del 0 al 9
5- en la 1ª iteración se asignan dos números más que equivalen a letras en mayúscula y en la segunda 5 números que cuando se traduzcan a ASCII pasarán a ser letras en minúscula
6- se itera la variable newPassword y se asigna su valor traducido a char a la variable newPasswordChar, y listo. Y tenemos un password nuevo generado aleatoriamente.

import java.util.Random
def newPassword = []
String newPasswordChar = ""
Random rand = new Random()
int max
max = 48
newPassword += (rand.nextInt(9))+max
max = 65
(1..2).each {
         newPassword +=  (rand.nextInt(25))+max
}
max = 97
(1..5).each {
         newPassword +=  (rand.nextInt(25))+max
}
(newPassword).each {item->
         newPasswordChar += (char)item
}

Consultas - Métodos estáticos de clase

Supongamos que tenemos la Clase Libro la cual describe un conjunto de objetos que tienen los mismos atributos y que por tanto podríamos modelar de la siguiente manera.

class Libro {
     String isbn
     String titulo
     Autor autor
     Integer numeroPaginas
     Date fechaPublicacion
}

Para realizar consultas no complejas pueden utilizarse los siguientes métodos estáticos de clase, que sirven para obtener tanto una instancia de clase en el caso de usar get (lo cual exigiría pasarle como parámetro un identificador único para referenciar al objeto que se desea obtener) o el total de objetos pertenecientes a una clase en el caso de usar list

def libro
por id: solo obtendra los objetos especificados
libro = Libro.get(1)
libro = Libro.getAll(1,20,30,40)

Obtiene una lista completas de instancias
libro = Libro.list()

Lo mismo pero con paginación
libro = Libro.list(offset:10,max:20)

Ordenando los resultados de modo ascendente
libro = Libro.list(sort:'titulo',order:'asc')

Modelo-Vista-Controlador

En Grails es posible utilizar lenguaje groovy dentro de una vista siempre que este se encuentre entre los símbolos <%  %>  pero esto está totalmente desaconsejado ya que se rompe el patrón Modelo-Vista-Controlador

Each - Iteraciones

[1,2,3,4,5].each() { item -> print "${item}-"}
resultado 1-2-3-4-5-
sin paréntesis
[1,2,3,4,5].each ({item -> print "${item}-" })
resultado 1-2-3-4-5-
[1,2,3,4,5].each {item -> print "${item}-" }
[1,2,3,4,5].each (({item -> print "${item}-" }))

Iterar un Map que ha sido pasado a una vista desde un controlador

Es perfectamente posible poner código javascript y/o jquery dentro del <g:each

<g:each in="${listColumns.entrySet()}" status="i" var="col">
       <g:each in="${col.value}" var="dat">
                <script>
                          switch(${col.key}){
                                   case
                                   .....
                          }
                </script>
       </g:each>
</g:each>             

Grails 2.0.1. Un nuevo nivel de productividad en la plataforma Java

Última versión 2.0.1 de Grails
http://grails.org/ 

Map y List en Java

Map map = new HashMap();
map.put(1,"Uno");
map.put(2,"Dos");
map.put(3,"Tres");

List list = new ArrayList();
list.add("lunes");
list.add("martes");
list.add("miercoles");

Groovy Map

def map = [x:10, 'z':20]
println map
resultado -> ["x":10, "z":20]
println map.x
->10
println map['x']
->10
printl nmap.keySet()
->["x", "z"]
Map map = [1: "Uno",  2:"Dos" , 3:"Tres"]

otras asignaciones
map = [:]
map[1] = 'a'
map[2] = 'b'
map[true] = '1'
map[false] = '0'

iterar un map
mMap.each{ key, value ->println "$key : $value"}

Switch mediante rangos

switch(edad){
      case 20..29:
   //Codigo...
   break
      case 30..39 :
   //...
   break
      case 40..49 :
   //...
   break
      default: throw new IllegalArgumentException()
}

Recorrer archivos

Muestra en el registro el archivo con las líneas numeradas

def nLinea=0
new File ('Config.groovy').eachLine { linea ->
    nLinea++
println "$nLinea: $linea"
}

Links

Crea enlaces entre páginas de forma lógica; si se cambian las Urls de la aplicación los links seguiran funcionando

Ejemplos:

Si no se especifica el controlador, por defecto es el controlador de la vista

<g:link action="documento" id="1">Documento 1</g:link>

Especificando un controlador

<g:link controller="vehiculo" action="list">

Listado de vehiculos

</g:link>

Especificando un controlador y pasando un número n de parametros.
Listado de vehículos por tipo 

<g:link controller="vehiculo" action="list"

params="[sort:'tipo',order:'asc']">

</g:link>

createLink
genera una ruta para utilizar en un atributo href
<script type="text/javascript" src="<g:createLinkTo dir='js/jqueryui/js' file='jquery-1.6.2.min.js' />"></script>

resource
crea enlaces a recursos estáticos como hojas de estilo o scripts
<g:resource dir="css" file="styles.css" />

Grails con Oracle

Configuración del archivo DataSource.groovy (<Nombre_de_Proyecto>->grails-app-->conf->DataSource.groovy) para trabajar con una base de datos Oracle. Previamente hay que descargar y copiar el conector ojbdc6.jar en la carpeta lib del proyecto y crear una base de datos vacia con permisos para el usuario.


dataSource {
    pooled = true
    dbCreate = "update"
    // Driver Oracle
    driverClassName = "oracle.jdbc.driver.OracleDriver"
}
hibernate {
    cache.use_second_level_cache=false
    cache.use_query_cache=false
    cache.provider_class='net.sf.ehcache.hibernate.EhCacheProvider'
}
environments {
    // Nombre de la base de datos con la que trabajaremos
    String baseDeDatos = "DB"  
    //Entorno de  Desarrollo
    development {
        dataSource {
            dbCreate = "update"
            // Usuario
            username = "user"
            password = "user"
            url = "jdbc:oracle:thin:@192.X.X.X:1521:${baseDeDatos}"
        }
    }
    // Entorno Test
    test {
        dataSource {
            dbCreate = "update"
            // Usuario
            username = "user"
            password = "user"
            url = "jdbc:oracle:thin:@192.X.X.X:1521:${baseDeDatos}"
        }
    }
    // Entorno de Produccion
    production {
        dataSource {
            dbCreate = "update"
            // Usuario
            username = "user"
            password = "user"
            url = "jdbc:oracle:thin:@192.X.X.X:1521:${baseDeDatos}"
        }
    }
}

Iteraciones en las vistas

Método en lenguaje groovy para iterar sobre cada elemento del objeto especificado

Siempre en las vistas

si no se usa el atributo var para asignar un nombre a los items it es el nombre por defecto
<g:each in="${books}">
    <p>Title: ${it.title}</p>
    <p>Author: ${it.author}</p>
</g:each>

con un nombre de item
<g:each var="book" in="${books}">
    <p>Title: ${book.title}</p>
    <p>Author: ${book.author}</p>
</g:each>

con un rango literal  (este literal debe ir entre paréntesis)
 <ul>
  <g:each var="i" in="${ (0..<100) }">
    <li>Item ${i}</li>
  </g:each>
</ul>

en este ejemplo el elemento debe tener un nombre ya que de lo contrario el acceso a la propiedad producirá un error
 <g:each in="${itemList}" var="item">
    <g:link action="show" id="${item.id}">${item.title}</g:link>
</g:each>

Atributos:
in - El objeto de iterar
status (opcional) -  nombre de una variable para almacenar el índice de iteración que comienza con 0 y los incrementos para cada iteración. Si se utiliza este parámetro, entonces se requiere var.
var (opcional) - El nombre del elemento, por defecto es "it".