Panel de control para Linux

Un panel de control Linux via WEB desarrollado con Grails

https://www.sublinux.com

Hay que tener instalado un servidor Tomcat para poder usarlo
Es muy fácil instalarlo, solo hay que descargar el .war y dejarlo caer en el directorio webapps del Tomcat; el despliegue es automático y solo hay que esperar un poco a que cree unos archivos en el directorio /opt/sublinux

El acceso se realiza mediante la URL http://<IP_DEL_SERVER>:8080/Sublinux
Es case sensitive asi que la "S" de Sublinux va en mayúsculas

Como desbloquear la descarga de archivos zip

Los administradores de sistemas suelen bloquear el acceso a determinados archivos debido a los problemas de seguridad que puden ocasionar en servidores y a redes internas, pero a veces esto puede ocasionar problemas a programadores que necesitan descargar, plantillas o código que se encuentra empaquetado en archivos zip u otro tipos de rachivos (rar, 7zip,...)
Para sortear este bloqueo he desarrollado la siguiente aplicación http://timewaves.es/downloader/   que te permitirá descargar archivos bloqueados en tu intranet sin ningun problema. Como usuario avanzado que debes ser, procura descargarte material de páginas oficiales y legítimas.

[Grails - base de datos] BD sin modelo relacional

Es posible que encuentres alguna base de datos que no tenga las tablas relacionadas y que además no puedes tocar, en ese caso mejor olvidarse de hibernate y utilizar consultas SQL a la antigua usanza.

Este es un ejemplo de como pasar los resultados de una consulta a la vista que los mostrará

package DB

import grails.converters.JSON;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import groovy.sql.Sql
import groovy.sql.GroovyRowResult
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.security.access.annotation.Secured
import static org.springframework.http.HttpStatus.*
import grails.transaction.Transactional
import org.hibernate.persister.entity.AbstractEntityPersister
import org.codehaus.groovy.grails.commons.DefaultGrailsDomainClass
import org.codehaus.groovy.grails.orm.hibernate.cfg.GrailsDomainBinder


@Transactional
class DdataService {
    boolean transactional = true
    def dataSource
 
 
    def recover(params, nameClass, principalTable, nonRelational) {
        def sql = new Sql(dataSource)
        def sqlProvider = new Sql(dataSource)
        def rows = []
        def data = [:]
        data['page']=params.page
        def sortname = params.sortname
        def sortorder = params.sortorder
        //def all=params.all
        //def all2=params.all2
        def cadSql1, cadSql2, cadSql
        def numRegister = (Integer.valueOf(params.page)-1)*(Integer.valueOf(params.rp))
        def nPages, nReg
     
        def GrailsDomainBinder = getClass().classLoader.loadClass('org.codehaus.groovy.grails.orm.hibernate.cfg.GrailsDomainBinder')
        def cLs = GrailsDomainBinder.newInstance().getMapping(Class.forName(nameClass))?.columns
     
     
     
        def nReg7='select count(*) as nreg from '+principalTable+' where ('
        def cadSql7='select * from '+principalTable+' where ('
     
        def tableNonRelational
        def fieldNonRelational
        nonRelational.each { entry ->
            fieldNonRelational=entry.key
            tableNonRelational=entry.value
        }
        def control = false
        cLs.each{ k, v ->
            if(control==true){
                if(!v?.columns?.name.get(0).equals(fieldNonRelational)){
                    nReg7=nReg7+" OR "+v?.columns?.name.get(0)+" LIKE '%"+all+"%'"
                    cadSql7=cadSql7+" OR "+v?.columns?.name.get(0)+" LIKE '%"+all+"%'"
                }
            }
            if(control==false){
                if(!v?.columns?.name.get(0).equals(fieldNonRelational)){
                    nReg7=nReg7+v?.columns?.name.get(0)+" LIKE '%"+all+"%'"
                    cadSql7=cadSql7+v?.columns?.name.get(0)+" LIKE '%"+all+"%'"
                }
                control=true
            }
        }
   
        //dejo por construir las select
        nReg='select count(*) as nreg from ....
        cadSql='select * from ...
     
     
        sqlProvider.eachRow(nReg){prov ->
            nPages=prov.nreg
        }
        data['total']=nPages
        def pr = [:]
     
        sqlProvider.eachRow('select * from '+tableNonRelational){prov ->
            pr.put(prov.id,(prov.(fieldNonRelational.toString())))
        }
        sql.eachRow(cadSql) { is ->
            def value =[:]      
         
            cLs.each{ k, v ->
                try {
                    if(k==fieldNonRelational){
                    value.put(k,pr[Integer.valueOf(is.(v?.columns?.name.get(0)))])
                    }else{
                        value.put(k,is.(v?.columns?.name.get(0)))
                    }
                } catch (NullPointerException e){
                    value.put(k,'');
                } catch(NumberFormatException e){
                    value.put(k,'');
                }
            }
            rows << [cell:value]
        }
   
        data['rows']=rows
        [data:data]
    }
}

 Post protegido por post2i.es

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