//alert ('En validación');
// -----------------------------------------------------------------------------

// Generic Form Validation
//
// Copyright (C) 2000 Jacob Hage - [jacobhage@hotmail.com]
// Modified by luish, for siafi, Universidad del Valle
// Distributed under the terms of the GNU Library General Public License
// -----------------------------------------------------------------------------


// -----------------------------------------------------------------------------
// Initializing script  - setting global variables
// -----------------------------------------------------------------------------

var checkObjects		= new Array();
// Array containing the objects to validate.
var errors				= "";
// Variable holding the error message.
var returnVal			= false;
// General return value. The validated form will only be submitted if true.
var language			= new Array();
// Language independent error messages!
var selectecLanguage	= "spanish";
// Choose between "english", "danish", "dutch", "french", "spanish", "russian", "portuguese"

language.english		= new Array();
language.danish			= new Array();
language.dutch			= new Array();
language.french			= new Array();
language.spanish		= new Array();
language.russian		= new Array();
language.portuguese		= new Array();
language.swedish		= new Array();
language.polish			= new Array();
language.brazport		= new Array();

// Error messages in english:
	language.english.header		= "The following error(s) occured:"
	language.english.start		= "->";
	language.english.field		= " Field ";
	language.english.require	= " is required";
	language.english.min		= " and must consist of at least ";
	language.english.max		= " and must not contain more than ";
	language.english.minmax		= " and no more than ";
	language.english.chars		= " characters";
	language.english.num		= " and must contain a number";
	language.english.date		= " and must contain a date";
	language.english.email		= " must contain a valid e-mail address";

// Error messages in Spanish: Thanks to Edu <edu@macneto.com>

	language.spanish.header		= "Se ha producido un error:"
	language.spanish.start		= "->";
	language.spanish.field		= " El campo ";
	language.spanish.require	= " es obligatorio";
	language.spanish.min		= " y debe contener al menos ";
	language.spanish.max		= " y no debe contener m\341s de ";
	language.spanish.minmax		= " y no m\341s de ";
	language.spanish.chars		= " caracteres";
	language.spanish.num		= " y debe contener un n\372mero";
	language.spanish.date		= " y debe contener una fecha";
	language.spanish.hora_requerida	= " y debe contener una hora";
	language.spanish.hora_formato = " debe contener una hora";
	language.spanish.email		= " debe contener una direcci\363n de e-mail v\341lida";
	language.spanish.alfanumerico = " caracteres y/o n\372meros";
    language.spanish.flotante   = ", y debe contener un número real";
    language.spanish.natural    = " y debe contener un número natural";
    language.spanish.entero     = " y debe contener un número entero";
    language.spanish.enterononegativo = " y debe contener un número entero no negativo";
    language.spanish.racionalgeneral = " y debe contener un número real";
    language.spanish.booleano   = " y debe ser seleccionado";
    language.spanish.telefonofijo = " y debe contener un número telefónico fijo iniciando con indicativo así: (###) ";
    language.spanish.telefonomovil = " y debe contener un número telefónico móvil";
    language.spanish.contrasena = " y debe contener una contrasena";
    language.spanish.ip = " y debe contener un número ip";
    language.spanish.entradaselect   = ", debe seleccionar una opci\363n";
    language.spanish.entradaselectmultiple   = ", debe seleccionar un o varias opciones";
    language.spanish.entradawincombo = ", debe elegir un valor de la lista desplegada con (...)";
	language.spanish.minnumero	= ", debe ser mayor que ";
	language.spanish.maxnumero	= " y menor que ";
	language.spanish.extension = " y debe contener un número de extensi\363on así: ### ";
    language.spanish.archivo = " y debe contener una ruta de Archivo"; 

// -----------------------------------------------------------------------------

// define - Call this function in the beginning of the page. I.e. onLoad.
//
// n = name of the input field (Required)
// type= string, num, email (Required)
// min = the value must have at least [min] characters (Optional)
// max = the value must have maximum [max] characters (Optional)
// d = (Optional)
// -----------------------------------------------------------------------------

function define(n,type,HTMLname,min,max,nulo,entrada,d){

    //alert(' n '+n+' ipo'+type+' nombre'+HTMLname+' min'+min+' max'+max+' nulo'+nulo+' entrada'+entrada+' d '+d);

	var p;
	var i;
	var x;
	if(!d) d=document;
	if((p=n.indexOf("?"))>0&&parent.frames.length){
	    	d=parent.frames[n.substring(p+1)].document;
	    	n=n.substring(0,p);

	}
	
    
	if(!(x=d[n])&&d.all)
         x=d.all[n];

  	for (i=0;!x&&i<d.forms.length;i++){
  		x=d.forms[i][n];
  	}
    
	for(i=0;!x&&d.layers&&i<d.layers.length;i++){
		x=define(n,type,HTMLname,min,max,nulo,entrada,d.layers[i].document);
		return x;		
	}
	
	// Create Object. The name will be "V_something" where something is the "n" parameter above.    
	eval("V_"+n+" = new formResult(x,type,HTMLname,min,max, nulo, entrada, n);");
	checkObjects[eval(checkObjects.length)] = eval("V_"+n);
}

// -----------------------------------------------------------------------------
// formResult - Used internally to create the objects
// -----------------------------------------------------------------------------
function formResult(form,type,HTMLname,min,max,nulo, entrada){
    this.form = form;
	this.type = type;
	this.HTMLname = HTMLname;
	this.min  = min;
	this.max  = max;
    this.nulo  = nulo;
    this.entrada  = entrada;
}

// -----------------------------------------------------------------------------
// validate - Call this function onSubmit and return the "returnVal". (onSubmit="validate();return returnVal;")
// -----------------------------------------------------------------------------
function validate(){

    //alert('Hola '+checkObjects.length);

	if(checkObjects.length>0){
		errorObject = "";
		for(i=0;i<checkObjects.length;i++)
		{
			//alert('los objetos son: '+checkObjects[i].HTMLname+'-'+i+' form '+checkObjects[i].form+' y el valor es '+checkObjects[i].form.value);
			if(checkObjects[i].form != undefined)
			{
				validateObject 			= new Object();
				validateObject.form 	= checkObjects[i].form;
				validateObject.HTMLname = checkObjects[i].HTMLname;
				validateObject.val 	= checkObjects[i].form.value;
				validateObject.len 	= checkObjects[i].form.value.length;
				validateObject.min 	= checkObjects[i].min;
				validateObject.max 	= checkObjects[i].max;
				validateObject.nulo 	= checkObjects[i].nulo;
				validateObject.entrada 	= checkObjects[i].entrada;
				validateObject.type 	= checkObjects[i].type;
//isNaN
				//Debug alert line
				//alert("LA 2:  validateObject: "+validateObject.HTMLname+"\nvalidateObject.val: "+validateObject.val+"\nvalidateObject.len: "+validateObject.len+"\nvalidateObject.min,validateObject.max: "+validateObject.min+","+validateObject.max+"\nvalidateObject.type: "+validateObject.type+"\nvalidateObject.nulo: "+validateObject.nulo);

	            //alert("hola comparacion len==0"+(validateObject.len == 0));
                //alert('Entre if no..'+validateObject.HTMLname+' y el objeto en la forma es '+validateObject.form.name+' de valor '+validateObject.val+" y el tipo es "+validateObject.type);
//isNaN
				if(validateObject.type != "select_multiple" && validateObject.len == 0 )
				{
					if(validateObject.nulo =="no_null")
					{
						//alert('Entre if no..'+validateObject.HTMLname+' y la entrada es '+validateObject.entrada+' de len '+validateObject.len);

						switch(validateObject.entrada){
						case "select":
                            errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].entradaselect+"\n";
							break;
                        case "select_multiple": 
							errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].entradaselectmultiple+"\n";
							break;
						case "wincombo":
							errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].entradawincombo+"\n";
							break;
						default:
							switch (validateObject.type){
								case "num":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].num+"\n";
									break;
								case "string":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].min+validateObject.min+language[selectecLanguage].minmax+validateObject.max+language[selectecLanguage].chars+"\n";
									break;
								case "date":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].date+"\n";
									break;
								case "hora":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].hora_requerida+"\n";
									break;
								case "email":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].email+"\n";
									break;
								// Agregado el caso de 'texto', por Eduardo Castillo y Germán González Nov-13-03
								case "texto":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+"\n";
									break;
								case "archivo":
                                case "alfanumerico":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+" y debe contener " +language[selectecLanguage].alfanumerico+"\n";
									break;
								case "float":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].flotante+"\n";
									break;
								case "natural":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].natural+"\n";
									break;
								case "entero":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].entero+"\n";
									break;
								case "enterononegativo":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].enterononegativo+"\n";
									break;
								case "racionalgeneral":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].racionalgeneral+"\n";
									break;
								case "boolean":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].booleano+"\n";
									break;
								case "telefonofijo":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].telefonofijo+"\n";
									break;
								case "telefonomovil":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].telefonomovil+"\n";
									break;
								case "contrasena":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].contrasena+"\n";
									break;
								case "ip":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].ip+"\n";
									break;
								case "extension":
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].extension+"\n";
									break;

								default :
								//alert("EL tipo de dato no existe");
							}// end switch type
						}//end switch entrada

					} //end if validateObjet.nulo
				}//end if validateObject.len
				else
				{
					//alert('Entre al else..'+validateObject.HTMLname+' y el tipo es '+validateObject.type+' de len '+validateObject.len);

					// Checking input. If "min" and/or "max" is defined the input has to be within the specific range



						switch (validateObject.type){
                            case "select_multiple":  
                                //alert("el validateObj es  "+validateObject.form); 
                                //

								if( (!validaSelectMultiple(validateObject.form))){
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].entradaselectmultiple+"\n";
								} 
                               
								break;
							case "num":
                                valor_antes = validateObject.val;
                                valor = valor_antes*1;
                                //alert("valor es "+valor+" del objeto "+valor_antes); 
                                //

								if( (validateObject.len <= 0 || !esNumerico(valor_antes) || isNaN(valor))){
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].num+"\n";
								}
                               
								break;
							case "string":
                            case "texto":
								//Debug alert line
								//alert("validateObject: "+validateObject+"\nvalidateObject.val: "+validateObject.val+"\nvalidateObject.len: "+validateObject.len+"\nvalidateObject.min,validateObject.max: "+validateObject.min+","+validateObject.max+"\nvalidateObject.type: "+validateObject.type+"\nvalidateObject.nulo: "+validateObject.nulo);
								// No valida si son solo letras
								if(isNaN(validateObject.val)){
									if (validateObject.min && validateObject.max && (validateObject.len < validateObject.min || validateObject.len > validateObject.max)){
										errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].min+validateObject.min+language[selectecLanguage].minmax+validateObject.max+language[selectecLanguage].chars+"\n";
									} else if (validateObject.min && !validateObject.max && (validateObject.len < validateObject.min)){
										errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].min+validateObject.min+language[selectecLanguage].chars+"\n";
									} else if (validateObject.max && !validateObject.min &&(validateObject.len > validateObject.max)){
										errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].max+validateObject.max+language[selectecLanguage].chars+"\n";
									} else if (!validateObject.min && !validateObject.max && validateObject.len <= 0){
										errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+"\n";
									}

								}else{
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].min+validateObject.min+language[selectecLanguage].minmax+validateObject.max+language[selectecLanguage].chars+"\n";
								}
						break;

						case "date":
						// alert("validateObject: "+validateObject+"\nvalidateObject.val: "+validateObject.val+"\nvalidateObject.len: "+validateObject.len+"\nvalidateObject.min,validateObject.max: "+validateObject.min+","+validateObject.max+"\nvalidateObject.type: "+validateObject.type+"\nvalidateObject.nulo: "+validateObject.nulo);
								if(validateObject.len <= 0){
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].date+"\n";
								} else if (!validafecha(validateObject.val)){
									errors+="-> Formato de Fecha Invalido (Formato AAAA-MM-DD) en "+language[selectecLanguage].field+validateObject.HTMLname+"\n";
									//alert ('error');
							//		errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].min+validateObject.min+language[selectecLanguage].chars+"\n";
								} else if (validateObject.max && !validateObject.min &&(validateObject.len > validateObject.max)){
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].max+validateObject.max+language[selectecLanguage].chars+"\n";
								}

							break;

							case "email":
								// Checking existense of "@" and ".". The length of the input must be at least 5 characters. The "." must neither be preceding the "@" nor follow it.
								if((validateObject.val.indexOf("@") == -1) || (validateObject.val.charAt(0) == ".") || (validateObject.val.charAt(0) == "@") ||(validateObject.len < 6) || (validateObject.val.indexOf(".") == -1) || (validateObject.val.charAt(validateObject.val.indexOf("@")+1) == ".") || (validateObject.val.charAt(validateObject.val.indexOf("@")-1) == ".")){
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].email+"\n";
									}
							break;


                            case "telefonofijo":
                            case "archivo":
							case "alfanumerico":                             
								// OJO, no valida si tiene o no numerosy/o letras
								if (validateObject.min && validateObject.max && (validateObject.len < validateObject.min || validateObject.len > validateObject.max)){
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].min+validateObject.min+language[selectecLanguage].minmax+validateObject.max+language[selectecLanguage].alfanumerico+"\n";
								} else if (validateObject.min && !validateObject.max && (validateObject.len < validateObject.min)){
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].min+validateObject.min+language[selectecLanguage].alfanumerico+"\n";
								} else if (validateObject.max && !validateObject.min &&(validateObject.len > validateObject.max)){
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].max+validateObject.max+language[selectecLanguage].alfanumerico+"\n";
								} else if (!validateObject.min && !validateObject.max && validateObject.len <= 0){
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+"\n";
								}
							break;
						case "hora":
								if (!esHoraMilitar(validateObject.val))
								{
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].hora_formato+"\n";
								}
							break;
						case "float":
								if (!esRacionalSencillo(validateObject.val) || esMenor(validateObject.val,validateObject.min) || esMenor(validateObject.max,validateObject.val))
								{
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].minnumero+validateObject.min+language[selectecLanguage].maxnumero+validateObject.max+language[selectecLanguage].flotante+"\n";
								}
							break;
						case "natural":
								if (!esNatural(validateObject.val) || esMenor(validateObject.val,validateObject.min) || esMenor(validateObject.max,validateObject.val))
								{
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].minnumero+validateObject.min+language[selectecLanguage].maxnumero+validateObject.max+language[selectecLanguage].flotante+"\n";
								}
							break;
							
						case "extension":
						case "entero":
								if (!esEntero(validateObject.val) || esMenor(validateObject.val,validateObject.min) || esMenor(validateObject.max,validateObject.val))
								{
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].minnumero+validateObject.min+language[selectecLanguage].maxnumero+validateObject.max+language[selectecLanguage].flotante+"\n";
								}
							break;
						case "enterononegativo":
								if (!esEnteroNoNegativo(validateObject.val) || esMenor(validateObject.val,validateObject.min) || esMenor(validateObject.max,validateObject.val))
								{
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].minnumero+validateObject.min+language[selectecLanguage].maxnumero+validateObject.max+language[selectecLanguage].enterononegativo+"\n";
								}
							break;
						case "racionalgeneral":
								if (!esRacionalGeneral(validateObject.val) || esMenor(validateObject.val,validateObject.min) || esMenor(validateObject.max,validateObject.val))
								{
									errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].minnumero+validateObject.min+language[selectecLanguage].maxnumero+validateObject.max+language[selectecLanguage].flotante+"\n";
								}
							break;
							case "contrasena":
								break;
							case "ip":
								break;

			        } // end switch
			    } //en else
			} //end del if undefined
		}   // end for


	}   // end lengh

	// Used to set the state of the returnVal. If errors -> show error messages in chosen language
	if(errors){
		alert(language[selectecLanguage].header.concat("\n"+errors));
		errors = "";
		returnVal = false;
	} else {
		returnVal = true;
	}
}

    /**
     * Valida si una cadena tiene el formato de hora HH:MM
     * 
     * @author Juan Manuel Reyes García <seyerman@hotmail.com>
     * @access 	private 
     * @copyright	OIT, Universidad del Valle 2.003
     * @since   2004-09-16
     * @param  	string	$hora para comprobar si es una hora
     * @return 	boolean	es TRUE si $hora es una hora
     */

    function esHoraMilitar (hora)
    {
      er_hora = /^((2[0-3])|([0-1]?[0-9])):([0-5]?[0-9])(:([0-5]?[0-9]))?$/; 
      return hora.match(er_hora);
    }

    // add luish
    function validafecha(campo){

       if(!(isdate(campo))){
            return false;
       }
       return true;
    }


    // add luish
    function isdate (fecha)
    {

        var cadena=fecha;
        var longitud = cadena.length ; longitud++; longitud--;

        var ano= cadena.substring(0,4);
        var mes= cadena.substring(5,7);
        var dia= cadena.substring(8,longitud);

        var bisiesto=ano % 4;isNaN
        var formato = ((cadena.charAt(4) == "-") &&
                    (cadena.charAt(7) == "-") &&
                    (cadena.length == 10));

        var r_ano = (ano >= 1900 && ano <= 2200);isNaN
        var r_mes = (mes >= 1 && mes <= 12);
        var r_dia = (dia >= 1 && dia <= 31);

        var mes30 = (mes==4 || mes==6 ||mes==9 ||mes==11 );
        var mes31 = (mes==1 || mes==3 ||mes==5 ||mes==7 || mes==8 ||mes==10 ||mes==12);

        var ismes29 = (bisiesto==0 && mes==2 && dia <=29);
        var ismes28 = (bisiesto!=0 && mes==2 && dia <= 28);
        var ismes30 = (mes30 && dia <= 30);
        var ismes31 = (mes31 && dia <= 31);

        if ((formato) && (r_ano) && (r_mes) && (r_dia) && ((ismes29) || (ismes28) || (ismes30) || (ismes31)))
            return true;
        else
            return false;
    }

    //Funcion agregada por Juan Manuel
    function esMenor(primera_cantidad, segunda_cantidad)
    {
        if(!isNaN(primera_cantidad) && !isNaN(segunda_cantidad))
        {
            isNaN
            var a = parseFloat(primera_cantidad);
            var b = parseFloat(segunda_cantidad);
            return (a<b)
        }
        else isNaN
        {
            return false
        }
    }

    /**
     * Valida si la cadena numero representa un numero que pertenece al
     * conjunto de numeros naturales (el cero no es numero natural)
     * y su valor esta en un rango valido de los numeros enteros de 4 bytes manejados en postgres
     *
     * @author Juan Manuel Reyes Garcia <seyerman@hotmail.com>
     * @access 	private
     * @copyright	OIT, Universidad del Valle 2.003
     * @since  	2003-03-19
     * @param  	string	numero es la cadena que se desea comprobar si representa el numero descrito     * @return 	boolean	es TRUE si numero representa un numero natural
     */

    function esNatural(numero)
    {
        //Se supone en principio que el numero es natural
        es_natural = true;

        var i=0;

        //el tamano en bytes del entero que se esta
        //utilizando en la base de datos
        tamano_bytes_entero = 4;

        //Convertimos los bytes a bits
        tamano_bits_entero = tamano_bytes_entero*8-1;

        //Convertimos el numero a cadena para poder
        //revisarla caracter por caracter
        numero = numero.toString();

        //Recorremos toda la cadena del numero
        //para revisarla caracter por caracter
        for(i=0;i<numero.length && es_natural;i++)
        {
            //Si encontramos un caracter de dicha cadena
            //que no sea numero, entonces no es natural
            if(isNaN(numero.charAt(i)))
            {
                es_natural = false;
            }
        }

        //Revisamos que no sea cero, pues cero no 
        //pertenece a los numeros naturales
        if(es_natural)
        {
            if(numero>0)
            {
                es_natural = true;
            }
        }

        //Revisamos que el numero sea menor que el maximo
        //del rango permitido por el tipo de entero que se
        //esta manejando
        es_menor_maximo_rango = esMenor(numero,Math.pow(2,tamano_bits_entero))

        return (es_natural && es_menor_maximo_rango);
    }

    /**
     * Valida si la cadena numero representa un numero que pertenece al
     * conjunto de numeros enteros positivos mas el cero
     * y su valor esta en un rango valido de los numeros enteros de 4 bytes manejados en postgres
     * isNaN
     * @author Juan Manuel Reyes Garcia <seyerman@hotmail.com>
     * @access 	private 
     * @copyright	OIT, Universidad del Valle 2.003
     * @since  	2003-03-19
     * @param  	string	numero es la cadena que se desea comprobar si representa el numero descrito
     * @return 	boolean	es TRUE si numero representa un entero Positivo o cero
     *
     */
     
    function esEnteroNoNegativo(numero)
    {
        var i=0;

        //Se supone en principio que el numero es entero no negativo
        es_entero_nn = true;

        //el tamano en bytes del entero que se esta
        //utilizando en la base de datos
        tamano_bytes_entero = 4;

        //Convertimos los bytes a bits
        tamano_bits_entero = tamano_bytes_entero*8-1;        

        //Convertimos el numero a cadena para poder 
        //revisarla caracter por caracter
        numero = numero.toString();

        //Recorremos toda la cadena del numero
        //para revisarla caracter por caracter
        for(i=0;i<numero.length && es_entero_nn;i++)isNaN
        {
            //Si encontramos un caracter de dicha cadena
            //que no sea numero, entonces no es entero no negativo
            if(isNaN(numero.charAt(i)))
            {isNaN
                es_entero_nn = false;
            }
        }

        es_menor_maximo_rango = esMenor(numero,Math.pow(2,tamano_bits_entero))

        return (es_entero_nn && es_menor_maximo_rango);
    }

    /**
     * Valida si la cadena numero representa un numero que pertenece al
     * conjunto de numeros enteros
     * y su valor esta en un rango valido de los numeros enteros de 4 bytes manejados en postgres
     * 
     * @author Juan Manuel Reyes Garcia <seyerman@hotmail.com>isNaN
     * @access 	private 
     * @copyright	OIT, Universidad del Valle 2.003
     * @since  	2003-03-19
     * @param  	string	numero es la cadena que se desea comprobar si representa el numero descrito
     * @return 	boolean	es TRUE si numero representa un numero entero
     */

    function esEntero(numero)
    {
        //Se supone en principio que el numero es entero
        es_entero = true;

        //el tamano en bytes del entero que se esta
        //utilizando en la base de datos
        tamano_bytes_entero = 4;

        //Convertimos los bytes a bits
        tamano_bits_entero = tamano_bytes_entero*8-1;        

        //Convertimos el numero a cadena para poder 
        //revisarla caracter por caracter
        numero = numero.toString();

        var i=0;
        
        //Revisamos si el numero tiene el signo "-"
        //en su primer caracter
        if(numero.charAt(i)=="-")
        {
            i++;isNaN
        }

        //Recorremos toda la cadena del numero
        //para revisarla caracter por caracter
         for(;i<numero.length && es_entero;i++)isNaN
        {
            //Si encontramos un caracter de dicha cadena
            //que no sea numero, entonces no es entero
            if(isNaN(numero.charAt(i)))
            {
                es_entero = false;
            }
        }

        es_menor_maximo_rango = esMenor(numero,Math.pow(2,tamano_bits_entero))
        es_mayor_minimo_rango = esMenor(-Math.pow(2,tamano_bits_entero),numero)

        return (es_entero && es_menor_maximo_rango && es_mayor_minimo_rango);
    }

    /**
     * Valida si la cadena numero representa un numero que pertenece al
     * conjunto de numeros racionales de la forma numero entero sequido opcionalmente
     * de punto y numero entero
     * y su valor esta en un rango valido de los numeros float de 8 bytes manejados en postgres
     * 
     * @author Juan Manuel Reyes Garcia <seyerman@hotmail.com>
     * @access 	private 
     * @copyright	OIT, Universidad del Valle 2.003
     * @since  	2003-03-19
     * @param  	string	numero es la cadena que se desea comprobar si representa el numero descrito
     * @return 	boolean	es TRUE si numero representa un numero racional
     */

    function esRacionalSencillo(numero)
    {
        //Se supone en principio que el numero es racional sencillo
        es_racional_sencillo = true;
        
        //Inicialmente no hemos encontrado ningun punto
        encontrado_punto = false;

        //Valor maximo que puede tomar un float en el tipo
        //declarado en la base de datos
        valor_maximo_float = 1E+308;isNaN

        var i = 0;

        //Revisamos si el numero tiene el signo "-"
        //en su primer caracter
        if(numero.charAt(i)=="-")
        {
            i++;
        }

        //Recorremos toda la cadena del numero
        //para revisarla caracter por caracter
        for(;i<numero.length && es_racional_sencillo;i++)
        {
            //Si encontramos un caracter de dicha cadena
            //que no sea numero, entonces ...
            if(isNaN(numero.charAt(i)))
            {
                //Revisamos que si ese caracter es "."
                if(numero.charAt(i)==".")
                {
                    //Si no se ha encontrado ningun punto antes
                    //Hacemos verdadera la variable que nos indica
                    //este hecho, y el ciclo continua normalmente, 
                    //pues no este es permitido
                    if(!encontrado_punto)
                    {
                        encontrado_punto = true;
                    }
                    else
                    //Si ya se ha encontrado un punto, entonces este
                    //numero no es un racional sencillo
                    {
                        es_racional_sencillo = false;
                    }
                }
                else
                //si no es un caracter numerico y no es punto, entonces
                //este numero no es un racional sencillo
                {
                    es_racional_sencillo = false;
                }
            }
        }

        es_menor_maximo_rango = esMenor(numero,valor_maximo_float)
        es_mayor_minimo_rango = esMenor(-valor_maximo_float,numero)

        return (es_racional_sencillo && es_menor_maximo_rango && es_mayor_minimo_rango);
    }

    /**
     * Valida si la cadena numero representa un numero que pertenece al
     * conjunto de numeros racionales de la forma numero entero sequido opcionalmente
     * de punto y numero entero, y de la forma numero racional sencillo seguido
     * de E sequido de un numero entero
     * y su valor esta en un rango valido de los numeros float de 8 bytes manejados en postgres
     * 
     * @author Juan Manuel Reyes Garcia <seyerman@hotmail.com>
     * @access 	private 
     * @copyright	OIT, Universidad del Valle 2.003
     * @since  	2003-03-19
     * @param  	string	numero es la cadena que se desea comprobar si representa el numero descrito
     * @return 	boolean	es TRUE si numero representa un numero racional
     */

    function esRacionalGeneral(numero)
    {
        //Valor maximo que puede tomar un float en el tipo
        //declarado en la base de datos
        valor_maximo_float = 1E+308;

        //La funcion isNaN de JavaScript revisa si
        //la variable que se envia como parametro
        //tiene formato de numero con punto flotante
        es_racional_general = !isNaN(numero)

        es_menor_maximo_rango = esMenor(numero,valor_maximo_float)
        es_mayor_minimo_rango = esMenor(-valor_maximo_float,numero)

        return (es_racional_general && es_menor_maximo_rango && es_mayor_minimo_rango);
    }
    
    /**
     * Valida si la cadena numero representa un número ya sea entero o flotante
     * 
     * @author Alejandro Forero Arango <alforero@hotmail.com>
     * @access 	private 
     * @copyright	OIT, Universidad del Valle 2.005
     * @since  	2005-07-07
     * @param  	string	numero es la cadena que se desea comprobar si representa un número
     * @return 	boolean	es TRUE si numero representa un número entero o flotante
     */
    
    
    function esNumerico(numero)
    {
        var CaracteresValidos = "0123456789.";
        var EsNumero=true;
        var Caracter;
        var i;

        //alert("El numero es "+numero+" y el largo es "+numero.length);
        for (i = 0; i < numero.length && EsNumero == true; i++) 
        { 
            Caracter = numero.charAt(i);
            //alert ("El caracter es "+Caracter+" y el indice es"+CaracteresValidos.indexOf(Caracter));

            if (CaracteresValidos.indexOf(Caracter) == -1)         
                EsNumero = false;

        }

        return EsNumero;

    }
    
    /**
     * Valida si el campo que es un select multiple tiene algún valor seleccionado
     * 
     * @author Alejandro Forero Arango <alforero@hotmail.com>
     * @access 	private 
     * @copyright	OIT, Universidad del Valle 2.005
     * @since  	2005-07-07
     * @param  	object	campo Contiene el campo que es selecy múltiple
     * @return 	boolean	es TRUE si tiene algún valor seleccionado, FALSE en caso contrario.
     */
    
    
    function validaSelectMultiple(campo)
    {
        var hasSelections = false;
        //alert('En la funcion validateSelectMultiple el campo es '+campo)
        
        for(var i = 0; i < campo.options.length; i++)
        {
            if(campo.options[i].selected)
            {
                if (campo.options[i].value != '')
                {
                    hasSelections = true;
                    break;
                }
            }
        }    

        return hasSelections;

    }