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"
}