Agregar Validaciones Personalizadas a JQuery Validator

Me ha sorprendido gratamente el potencial de JQuery y las distintas librerías que le puedes ir agregando, una de estas es Validation, que permite hacer validaciones dentro de los formularios.
Este plugin incluye una serie de validaciones por defecto (email, campo obligatorio, numérico, etc…) y además se pueden agregar nuevas validaciones.



En el ejemplo se puede ver el uso de nuevas validaciones junto a la personalización del mensaje de estas.
Para el ejemplo se usaron las siguientes librerías

• jQuery JavaScript Library v1.4.2
• jQuery validation plug-in 1.7

formulario.html

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Insert title here</title>
<script type="text/javascript" src="js/jquery/jquery.js"></script>
<script type="text/javascript"
src="js/jquery/lib/validate/jquery.validate.js"></script>

<script type="text/javascript">

$(document).ready(
function() {

/**
* creamos una validacion llamada formato que solo permita un cierto rango de caracteres
* en el campo
*/
jQuery.validator.addMethod("formato", function(value,  element) {
return this.optional(element) || /^([a-z]|\d|[ ]|\,)+$/i.test(value);
}, "Error formato");

/**
* Creamos una validacio que no permita duplicidad de valores en ciertos campos
*/
jQuery.validator.addMethod("notEqualTo", function(value, element, param) {
return this.optional(element) || value != $(param).val();
}, "No puede repetir el valor en los campos);

/**
* Validacion con una complejidad mayor
*/
jQuery.validator.addMethod("validacionCompleja",function(value, element, param) {
var result = true;
var comparador = $(param).val();
if (value == "" || param == "") {
result = true;
}

if (value.length >= 3 && comparador >= 3) {
result = true;
} else {
result = false;
}
return result;

}, "validacionCompleja");

$("#fvalida").validate(
{
rules : {
campo1 : "required",
campo2 : {
minlength : 1,
notEqualTo : "#campo1",
validacionCompleja : "#campo1",
formato : true,
required : true
}
},
messages : {
campo1 : {
required : "campo requerido"
},
campo2 : {
notEqualTo : "no debe ser igual al campo 1",
minlength : "largo minimo 1",
formato : "caracteres no permitidos",
validacionCompleja : "campo 1 y campo 2 deben tener al menos 3 caracteres"
}
}
});
});

</script>

</head>

<body>

<form action="controlador" method="post" id="fvalida" class="admform">

<fieldset><legend>Prueba Validator</legend>

<ol>

<li><label for="campo1">campo1</label><input type="text"

id="campo1" name="campo1" /></li>

<li><label for="campo1">campo2</label><input type="text"

id="campo2" name="campo2" /></li>

<li><input type="submit" name="Enviar" /></li>
</ol>
</fieldset>
</form>
</body>
</html>

instalacion apache2 php5 y mysql

Pequeña guia de como me funciono la instalacion de php, mysql y apache2

como complemento esta la instalacion del phpMyAdmin

sudo apt-get install apache2
sudo apt-get install mysql-server
sudo apt-get install php5 libapache2-mod-php5
sudo apt-get install php5 libapache2-mod-php
sudo apt-get install php5-gd
sudo /etc/init.d/apache2 restart
sudo apt-get install phpmyadmin

Carnaval Florianopolis 2010

Algo muy entretenido de las ultimas vacaciones, fue poder ir al carnaval de Florianopolis.

y junto a los carros alegoricos, las miles de personas que desfilaban por escuela (correctamente uniformada).

Existian personas que eran mas destacadas, generalmente encabezaban un grupo dentro del desfile de la escuela, y en este grupo era mas comun ver a los hombres bailar mientras las mujeres se paseaban mas de un lado para otro.

para muestra les dejo este video que filme en el carnaval.

Java Reflection

En un momento se me dio la necesidad de invocar los métodos getter y setter de una clase dinámicamente, y al googlear me encontré con la API de reflection de Java junto al ejemplo que aparece en esta página

Con esto logre invocar los métodos getter y setter sin necesidad de invocarlos explícitamente ( instancia.getValor ), para lo cual hice el siguiente ejemplo.


primero una clase donde tenemos el origen de los datos



PersonaOrigen.java

public class PersonaOrigen {

private String nombre;
private String apellido;
private String edad;

public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public String getEdad() {
return edad;
}
public void setEdad(String edad) {
this.edad = edad;
}


}

una clase donde volvaremos los datos.



Persona.java

public class Persona {

private String nombre;
private String apellido;
private String edad;

public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public String getEdad() {
return edad;
}
public void setEdad(String edad) {
this.edad = edad;
}


}

Y tenemos la clase que realiza la operacion.



Prueba.java

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;





public class Prueba {





 public static void main(String[] args) {



  /*

   * La clase PersonaOrigen Representara la fuente de los datos 

   */

  PersonaOrigen po = new PersonaOrigen();

  po.setNombre("Juan");

  po.setApellido("Perez");

  po.setEdad("18");



  /*

   * por simplicidad, en este caso supondremos que los 

   * campos que vienen de la fuente de datos son conocidos

   * por lo cual los guardaremos en un ArrayList 

   * (Cuando lo implemente los obtenia de base de datos)

   */

  ArrayList<String> campos = new ArrayList<String>(); 

  campos.add("nombre");

  campos.add("apellido");

  campos.add("edad");

  

  

  HashMap metodos;

  try{

   metodos = new HashMap();

   Persona persona = new Persona();

         Field[] fields = persona.getClass().getDeclaredFields();

   

         /*

          * recorro la clase y almaceno los atributos en un hashmap

          * esto se podria evitar, y grabar directamente los datos.

          */

         for( int zz = 0;  zz < fields.length ; zz++ ){

             metodos.put(fields[zz].getName(), fields[zz]);

         }

         

         //recorremos los campos

         Iterator i = campos.iterator();

         String nombreCampo = null;

         while(i.hasNext()){

          

          //rescato el nombre del campo

          nombreCampo = (String) i.next();

          

          //genero el string que contiene el nombre de los metodos getter y settet de cada campo

    String setterName = "set" + String.valueOf(nombreCampo.charAt(0)).toUpperCase() + nombreCampo.substring(1);

    String getterName = "get" + String.valueOf(nombreCampo.charAt(0)).toUpperCase() + nombreCampo.substring(1);



    //rescato el valor de la fuente de origen de los datos

                Method getter = po.getClass().getMethod(getterName);

                Object valor = getter.invoke(po, new Object[0]);

    

                //seteo el valor en la instancia de la clase Persona

    Field field2= (Field) metodos.get(nombreCampo); 

    Method setter = persona.getClass().getMethod(setterName, field2.getType());

    setter.invoke(persona, new Object[]{( valor ) });          

          

         } 



         /*

          * Finalmente podemos ver volcados los datos de PersonaOrigen a persona

          */

         System.out.println("Nombre:" + persona.getNombre());

         System.out.println("Nombre:" + persona.getApellido());

         System.out.println("Nombre:" + persona.getEdad());

         

   

  }

  catch (Exception e) {

    ;

  }

  

  

 }



}

Como usar Log4j

A continuación expondré como hacer funcionar Log4J, no expongo que sea la mejor manera de hacerlo, simplemente es como me funciono bien (Bajo tomcat 5.5) .

Como primera acción debemos incluir la librería (jar) de Log4j en nuestro proyecto

Generamos el Servlet Log4JInit que nos permitira acceder de mojor forma a la ruta del contexto.



Log4jInit.java

package cl.ruta.package;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.PropertyConfigurator;

/**
* Servlet implementation class for Servlet: Log4jInit
*
* Servlet que permite obtener la ruta del contexto de la aplicacion, con el fin
* de poder setear la ruta para la generacion del LOG del Sistema log4j.
*
*/
public class Log4jInit extends javax.servlet.http.HttpServlet implements
javax.servlet.Servlet {
static final long serialVersionUID = 1L;

protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {

}

/**
* Inicializacion de LOG4J en base a lo descrito en {@link log4j.properties}
*/
public void init() throws ServletException {

Properties prop = new Properties();
FileInputStream is = null;

/*
* Obtengo el contexto de la apliación
*/
String prefix = getServletContext().getRealPath("/");

/*
* Cargo desde el web.xml la ruta en donde se encontrara el archivo
* properties
*/
String file = getInitParameter("log4j-init-file");

try {
/*
* Abre el fichero y carga el properties
*/
is = new FileInputStream(prefix + file);
prop.load(is);
} catch (IOException ioe) {
ioe.printStackTrace();
}

FileOutputStream out = null;
/*
* Se guarda la modificacion y se carga para log4j
*/
try {

out = new FileOutputStream(prefix + file);
prop.store(out, "---No Comment---");
out.close();

} catch (IOException ioe) {
ioe.printStackTrace();
}

/*
* Setea para el log4j el properties modificado
*/
if (file != null) {
PropertyConfigurator.configure(prefix + file);
}

}
}

El Servler debe ser agregado al archivo web.xml

<servlet>
<servlet-name>Log4jInit</servlet-name>
<servlet-class>cl.ruta.package.Log4jInit</servlet-class>
<init-param>
<param-name>log4j-init-file</param-name>
<param-value>WEB-INF/classes/log4j.properties</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

luego agregamos el log4j.properties (Donde quedo definido en el param del web.xml) en mi caso quedo en "WEB-INF/classes/log4j.properties"

# ***** Tipos de salida que tendra el LOG.
log4j.rootLogger=debug,R

# Configuración Registro en archivo
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=${catalina.home}/webapps/[contexto]/WEB-INF/log/[archivo_log].log
log4j.appender.R.MaxFileSize=250KB
log4j.appender.R.MaxBackupIndex=20
# ***** Encoding de salida
log4j.appender.R.Encoding=UTF-8
# ***** Patternlayout indica el tipo de formato usado
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=[%d{dd-MMM-yyyy HH:mm:ss}] %p %m%n

por ultimo lo agregamos en las clases java.

import org.apache.log4j.Logger;

/* Dentro de la clase*/
private Logger log = Logger.getLogger(this.getClass());
private String clase = this.getClass().getName().toString();

/*donde se quiere imprimir el mensaje*/
log.debug(clase +"::mensaje:" );

/*Si es dentro de un exception*/
catch (Exception e) {
log.debug(clase +"::Exception::", e);
}

Navegador BOLT pata BlackBerry

Buscando como poder navegar en hattrick desde un blackberry me recomendaron el el navegador BOLT

se ven bastante bien las páginas web.

Arroz para suchi.

Para hacer el arroz para el suchi al menos mi receta es:

para una taza de arroz (de preferencia arroz grano corto) .

• Lavar bien el arroz.
• Poner 2 tazas de agua en una olla mediana (según lo que he escuchado mientras más grande la olla mejor queda el arroz obviamente sin exagerar)
• Prender la cocina llama baja o alta con tostador.
• Echar el arroz con cuidado y en forma uniforme en la olla.
• Tapar la olla y esperar hasta que se cocine bien.

En lo personal para ver si está listo uso un palito chino que lo inserto hasta el fondo de la olla y si sale mojado le doy un ratito más.