// Rodrigo Augosto C
// Tecnologías Avanzadas de Información S.A.
// 31/05/2005
// ---------------------------------------------------------------------- //
//                             RESUMEN                                    //
// ---------------------------------------------------------------------- //
// 
// El objetivo de las siguientes funciones en JavaScript es
// validar los ingresos del usuario en un formulario antes
// de que estos datos vayan al servidor.
//
// Varias de ellas toman un parametro opcional E.O.K (eok) 
// emptyOK = true : (dato obligatorio)
// emptyOK = false : (dato no obligatorio)
//
// El valor por omision es el que indique la
// variable global defaultEmptyOK definida mas abajo.
//
// ---------------------------------------------------------------------- //
//                      SINTAXIS DE LAS FUNCIONES                         //
// ---------------------------------------------------------------------- //
//
// FUNCION PARA CHEQUEAR UN CAMPO DE INGRESO:
//
// checkField (theField, theFunction, [, s] [,eok])
//        verifica que el campo de ingreso theField cumpla con la
//        condicion indicada en la funcion theFunction (que puede ser
//        una de las descritas en "FUNCIONES DE VALIDACION" o cualquier
//        otra provista por el usuario). En caso contrario despliega el
//        string "s" (opcional, hay mensajes por default para las
//        funciones de validacion provistas aqui).
//
// FUNCIONES DE VALIDACION:
//
// isInteger (s [,eok])                s representa un entero
// isNumber (s [,eok])                 s es entero o tiene punto decimal
// isAlphabetic (s [,eok])             s tiene solo letras
// isAlphanumeric (s [,eok])           s tiene solo letras y/o numeros
// isPhoneNumber (s [,eok])            s tiene solo numeros, (,),-
// isEmail (s [,eok])                  s es una direccion de e-mail
// isRut (s)   			               s es rut valido
// isRutEmpresa (s)                    s es rut valido mayor o igual a 50.000.000 
//
// FUNCIONES INTERNAS:
//
// isWhitespace (s)                    s es vacio o solo son espacios
// isLetter (c)                        c es una letra
// isDigit (c)                         c es un digito
// isLetterOrDigit (c)                 c es letra o digito
// isNice (s)                          ayuda a evitar comillas simples o dobles que causan problemas con muchos CGIs
//
// FUNCIONES PARA REFORMATEAR DATOS:
//
// stripCharsInBag (s, bag)            quita de s los caracteres en bag
// stripCharsNotInBag (s, bag)         quita de s los caracteres NO en bag
// stripWhitespace (s)                 quita el espacio dentro de s
// stripInitialWhitespace (s)          quita el espacio al principio de s
//
// FUNCIONES PARA PREGUNTARLE AL USUARIO:
//
// statBar (s)                         pone s en la barra de estado
// warnEmpty (theField, s)             indica que theField esta vacio, s es un mensaje alternativo
// warnInvalid (theField, s)           indica que theField es invalido
// ---------------------------------------------------------------------- //
//                                VARIABLES                               //
// ---------------------------------------------------------------------- //

// Esta variable indica si está bien dejar los campos
// en blanco como regla general
var defaultEmptyOK = false;

// Esta variable indica si se debe verificar la presencia de comillas
// u otros símbolos extraños en un campo, por omisión no, porque
// siempre crea problemas con las bases de datos o programas CGI
var checkNiceness = true;

// listas de caracteres
var digits = "0123456789";
var lowercaseLetters = "abcdefghijklmnopqrstuvwxyzáéíóúñü @"
var uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZÁÉÍÓÚÑÜ,.;:-()+-*|¡¿'?!<>/\$&%#= "
var whitespace = " \t\n\r";

// caracteres admitidos en números de teléfonos
var phoneChars = "()-+ ";

// ---------------------------------------------------------------------- //
//                     TEXTOS PARA LOS MENSAJES                           //
// ---------------------------------------------------------------------- //

// m abrevia "missing" (faltante)
var mMessage = "Error: no puede dejar este espacio vacio"

// p abrevia "prompt"
var pPrompt = "Error: ";
var pAlphanumeric = "Ingrese un texto que contenga sólo letras y/o números";
var pAlphabetic   = "Ingrese un texto que contenga sólo letras";
var pInteger = "Ingrese un número entero";
var pNumber = "Ingrese un número";
var pPhoneNumber = "Ingrese un número de Teléfono válido";
var pEmail = "Ingrese una dirección de correo electrónico válida";
var pName = "Ingrese un texto que contenga sólo letras, números o espacios";
var pNice = "No puede utilizar Comillas aquí";
var pRut = "Ingrese un Rut válido"

// ---------------------------------------------------------------------- //
//                FUNCIONES PARA MANEJO DE ARREGLOS                              //
// ---------------------------------------------------------------------- //

// JavaScript 1.0 (Netscape 2.0) no tenia un constructor para arreglos,
// asi que ellos tenian que ser hechos a mano. Desde JavaScript 1.1 
// (Netscape 3.0) en adelante, las funciones de manejo de arreglos no
// son necesarias.

function makeArray(n) {
//*** BUG: If I put this line in, I get two error messages:
//(1) Window.length can't be set by assignment
//(2) daysInMonth has no property indexed by 4
//If I leave it out, the code works fine.
//   this.length = n;
   for (var i = 1; i <= n; i++) {
      this[i] = 0
   } 
   return this
}

// ---------------------------------------------------------------------- //
//                  CODIGO PARA FUNCIONES BASICAS                                   //
// ---------------------------------------------------------------------- //


// s es vacio
function isEmpty(s){   
	return ((s == null) || (s.length == 0))
}

// s es vacio o solo caracteres de espacio
function isWhitespace (s)
{   var i;
    if (isEmpty(s)) return true;
    for (i = 0; i < s.length; i++)
    {   
        var c = s.charAt(i);
        // si el caracter en que estoy no aparece en whitespace,
        // entonces retornar falso
        if (whitespace.indexOf(c) == -1) return false;
    }
    return true;
}

// Quita todos los caracteres que que estan en "bag" del string "s" s.
function stripCharsInBag (s, bag)
{   var i;
    var returnString = "";

    // Buscar por el string, si el caracter no esta en "bag", 
    // agregarlo a returnString
    
    for (i = 0; i < s.length; i++)
    {   var c = s.charAt(i);
        if (bag.indexOf(c) == -1) returnString += c;
    }

    return returnString;
}

// Lo contrario, quitar todos los caracteres que no estan en "bag" de "s"
function stripCharsNotInBag (s, bag)
{   var i;
    var returnString = "";
    for (i = 0; i < s.length; i++)
    {   
        var c = s.charAt(i);
        if (bag.indexOf(c) != -1) returnString += c;
    }

    return returnString;
}

// Quitar todos los espacios en blanco de un string
function stripWhitespace (s)
{   return stripCharsInBag (s, whitespace)
}

// La rutina siguiente es para cubrir un bug en Netscape
// 2.0.2 - seria mejor usar indexOf, pero si se hace
// asi stripInitialWhitespace() no funcionaria

function charInString (c, s)
{   for (i = 0; i < s.length; i++)
    {   if (s.charAt(i) == c) return true;
    }
    return false
}

// Quita todos los espacios que antecedan al string
function stripInitialWhitespace (s)
{   var i = 0;
    while ((i < s.length) && charInString (s.charAt(i), whitespace))
       i++;
    return s.substring (i, s.length);
}

// c es una letra del alfabeto espanol
function isLetter (c){
    return( ( uppercaseLetters.indexOf( c ) != -1 ) ||
            ( lowercaseLetters.indexOf( c ) != -1 ) )
}

// ---------------------------------------------------------------------- //
//                  FUNCIONES PARA VERIFICAR RUT                          //
// ---------------------------------------------------------------------- //
function isRutEmpresa(strRut, fieldRut){
    var Largo, LargoN, i, Total;
    var Numero="", Verif, Carac, CaracVal;
    var tmpRut,intTmp;

    tmpRut = trim(strRut.split("-")[0])
    Largo = tmpRut.length
    LargoN = 0
	
    for(i=0;i<Largo;i++) {
        Carac = parseInt(tmpRut.charAt(i),10);
        if(Carac >=0 && Carac <=9) {
			Numero+=tmpRut.charAt(i);
          LargoN++;
	 	}
    }
	if ( parseInt(Numero) < 50000000){
		return false;
	}
	return true;
}


function isRut(strRut, fieldRut){
  if (isEmpty(strRut)) 
     if (isRut.arguments.length == 1) return defaultEmptyOK;
     else return (isRut.arguments[1] == true);
	
	var rut;
	var rut_array;
	var falso_array;
	var dv;
	var falso ;
	var c = 0;

	falso = "000000000,00000000-0,111111111,11111111-1,222222222,22222222-2,333333333,33333333-3,";
	falso = falso + "444444444,44444444-4,555555555,55555555-5,666666666,66666666-6,";
	falso = falso + "777777777,77777777-7,888888888,88888888-8,999999999,99999999-9";
	falso_array = falso.split(",");
	/*while(c < falso_array.length) { 
	   if (strRut == falso_array[c])
			return false;
	   c++; 
	}*/ 

	rut_array=strRut.split("-");
	if( rut_array[0].length < 5 )
		return false;

	if(rut_array[0].length != 0){
		if (rut_array[0].length == strRut.length){   // sin guion
			dv = rut_array[0].substring(strRut.length-1,strRut.length);
			rut = rut_array[0].substring(0,strRut.length-1);

			if (esRutValido(rut,dv) != 1)
				return false;
		}
		else  {                           //   con guion
			rut = rut_array[0];
			dv = rut_array[1];
			if (esRutValido(rut,dv) != 1)
				return false;
		}
			
		// formatea el rut para luego imprimirlo en pantalla
		if (!isEmpty(fieldRut)){
			var count = 0
			var Numero = "";
			var rutfinal = ""
			var sLength = rut.length;
			
			for(i=0;i<sLength;i++) {
				Carac = parseInt(rut.charAt(i),10);
				if(Carac >=0 && Carac <=9) {
					Numero+=rut.charAt(i);
				}
			}
			rut = Numero
			sLength = rut.length;
			while(sLength > -1) {
					count ++;
					rutfinal = (count==4 || count ==7)?"." + rut.charAt(sLength) + rutfinal:rut.charAt(sLength) + rutfinal;
					sLength--;
			}
			fieldRut.value = rutfinal+"-"+dv.toUpperCase();
		}
		
	}
	return true;
}

// Verifica que el Digito verificador corresponda al RUT.
function esRutValido(strRut,strDigito) {
   var digVerif;
   digVerif=digitoVerificador(strRut)
  // alert("digito:" + digVerif + "| dig ing:"+strDigito+"|");
   if(digVerif==strDigito.toUpperCase())
       return(1);
   else
   	   return(0);

}

// Retorna el Digito verificador de un RUT.
function digitoVerificador(strRut) {

    var Largo, LargoN, i, Total;
    var Numero="", Verif, Carac, CaracVal;
    var tmpRut,intTmp;

    tmpRut = trim(strRut)
    Largo = tmpRut.length
    LargoN = 0
    
    for(i=0;i<Largo;i++) {
        Carac = parseInt(tmpRut.charAt(i),10);
        if(Carac >=0 && Carac <=9) {
			Numero+=tmpRut.charAt(i);
          LargoN++;
	 	}
    }

	Total=0;
    for(i=LargoN-1;i>=0;i--) {
		if((LargoN - i) < 7) {
		   intTmp=LargoN - i + 1;
		} else {
		   intTmp=LargoN - i - 5;
		}
        Total+= parseInt(Numero.charAt(i),10) * intTmp 
    }
    
    CaracVal = 11 - (Total % 11)
    
    if(CaracVal==10) 
       return('K');
	
	if(CaracVal >=0 && CaracVal <=9) 
       return(CaracVal);
	
	if(CaracVal==11) 
	   return(0);
}
// ---------------------------------------------------------------------- //
//                FUNCIONES PARA VERIFICAR EMAIL (v1)                     //
// ---------------------------------------------------------------------- //
function isEmail (s){
    if (isEmpty(s)) 
       if (isEmail.arguments.length == 1) return defaultEmptyOK;
       else return (isEmail.arguments[1] == true);
    if (isWhitespace(s)) return false;
    var i = 1;
    var sLength = s.length;
    while ((i < sLength) && (s.charAt(i) != "@"))// avanza en toda la variable hasta encontrar @ 
    { i++
    }

    if ((i >= sLength) || (s.charAt(i) != "@")) return false;//llego al finl y no encontro el @
    else i += 2;


    while ((i < sLength) && (s.charAt(i) != ".") && (s.charAt(i) != "@"))
    { i++
    }

    if ((i >= sLength - 1) || (s.charAt(i) != ".") || (s.charAt(i) == "@")) return false;
    else return true;
}
// ---------------------------------------------------------------------- //
//                FUNCIONES PARA VERIFICAR EMAIL (v2)                     //
// ---------------------------------------------------------------------- //

function valida_mail(campo) {       
        campo.value = campo.replace (/[ ]+$/,"");                 //realiza un rtrim... 
        campo.value = campo.replace (/^[ ]+/,"");                 //realiza un ltrim... 
        valor=campo 

        if (valor=="") { alert("Debe ingresar una dirección email.");return (false); } 

        if (/(.*);(.+)/.test(valor) || /(.*),(.+)/.test(valor))         //valida que no haya mas de una direccion ( , ) y ( ; )
          { alert("Sólo puede ingresar una dirección email.");return (false);} 
        if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,4})+$/.test(valor))        //valida el email 
          {return (true);} 
        else 
          {alert("La dirección email es incorrecta.");return (false);} 
return false; 
} 

// ---------------------------------------------------------------------- //
//                                           NUMEROS                                            //
// ---------------------------------------------------------------------- //
// c es un digito
function isDigit (c){   
	return ((c >= "0") && (c <= "9"))
}

// c es letra o digito
function isLetterOrDigit (c){ 
	  return (isLetter(c) || isDigit(c))
}


// s es un numero entero (con o sin signo)
function isInteger (s){  
	 var i;
    if (isEmpty(s)) 
       if (isInteger.arguments.length == 1) return defaultEmptyOK;
       else return (isInteger.arguments[1] == true);
    
    for (i = 0; i < s.length; i++)
    {   
        var c = s.charAt(i);
        if( i != 0 ) {
            if (!isDigit(c)) return false;
        } else { 
            if (!isDigit(c) && (c != "-") || (c == "+")) return false;
        }
    }
    return true;
}

// s es un numero (entero o flotante, con o sin signo)
function isNumber (s){  
	 var i;
    var dotAppeared;
    dotAppeared = false;
    if (isEmpty(s)) 
       if (isNumber.arguments.length == 1) return defaultEmptyOK;
       else return (isNumber.arguments[1] == true);
    
    for (i = 0; i < s.length; i++)
    {   
        var c = s.charAt(i);
        if( i != 0 ) {
            if ( c == "." ) {
                if( !dotAppeared )
                    dotAppeared = true;
                else
                    return false;
            } else     
                if (!isDigit(c)) return false;
        } else { 
            if ( c == "." ) {
                if( !dotAppeared )
                    dotAppeared = true;
                else
                    return false;
            } else     
                if (!isDigit(c) && (c != "-") || (c == "+")) return false;
        }
    }
    return true;
}
// s es un valor de dinero
function isMoney (s){   		
	var aux;
	if (s.value.length == 0) {
		enfoca(s);
		alert("Ingrese el cupo solicitado por favor.");
	
		return false;
	}
	
    return true;
}


function noread(s){
	eval(s+".readOnly=true");
	return;
}

function read(s){
	eval(s+".readOnly=false");
	return;
}

// s tiene solo letras
function isAlphabetic (s){   
	var i;

    if (isEmpty(s)) 
       if (isAlphabetic.arguments.length == 1) return defaultEmptyOK;
       else return (isAlphabetic.arguments[1] == true);
    for (i = 0; i < s.length; i++)
    {   
        // Check that current character is letter.
        var c = s.charAt(i);

        if (!isLetter(c))
        return false;
    }
    return true;
}

// s tiene solo letras y numeros
function isAlphanumeric (s){ 
	var i;

    if (isEmpty(s)) 
       if (isAlphanumeric.arguments.length == 1) return defaultEmptyOK;
       else return (isAlphanumeric.arguments[1] == true);

    for (i = 0; i < s.length; i++)
    {   
        var c = s.charAt(i);
        if (! (isLetter(c) || isDigit(c)  ) )
        return false;
    }

    return true;
}


// s tiene solo letras, numeros o espacios en blanco
function isName (s){
    if (isEmpty(s)) 
       if (isName.arguments.length == 1) return defaultEmptyOK;
       else return (isAlphanumeric.arguments[1] == true);
    
    return( isAlphanumeric( stripCharsInBag( s, whitespace ) ) );
}

// s es numero de telefono valido
function isPhoneNumber (s){   
	var modString;
    if (isEmpty(s)) 
       if (isPhoneNumber.arguments.length == 1) return defaultEmptyOK;
       else return (isPhoneNumber.arguments[1] == true);
    modString = stripCharsInBag( s, phoneChars );
    return (isInteger(modString))
	return true
}

//  ayuda a evitar comillas simples o dobles que causan problemas con muchos CGIs
function isNice(s){
        var i = 0;
        var sLength = s.length;
        var b = 1;
        while(i<sLength) {
                if( (s.charAt(i) == "\"") || (s.charAt(i) == "'" ) ) b = 0;
                i++;
        }
        return b;
}

// ---------------------------------------------------------------------- //
//                  FUNCIONES PARA RECLAMARLE AL USUARIO                       //
// ---------------------------------------------------------------------- //

// pone el string s en la barra de estado
function statBar (s){   
	window.status = s
}

// notificar que el campo theField esta vacio
function warnEmpty (theField, d){   
	enfoca(theField);
	if (isEmpty(d)) {
		alert(mMessage)
		statBar(mMessage)
	}
	else{
		alert(d)
		statBar(d)
	}
    return false
}

// notificar que el campo theField es invalido
function warnInvalid (theField, s){
		enfoca(theField);
		theField.select()
		alert(s)
		statBar(pPrompt + s)
		return false
}

// ---------------------------------------------------------------------- //
//                FUNCION PARA CHEQUEAR UN CAMPO DE INGRESO               //
//                       " El Centro de Todo "                            //
// ---------------------------------------------------------------------- //
function checkField (theField, theFunction, emptyOK, s, d){   
	if (theField == null){
		return true;
		}
	if (theFunction == isEmpty)
		if (isEmpty(theField.value))
			return warnEmpty(theField, d);
		else
			return true;

    if (isEmpty(emptyOK)) emptyOK = defaultEmptyOK;

    if ((emptyOK == false) && (isEmpty(theField.value))) return true;

    if ((emptyOK == true) && (isEmpty(theField.value))) {
		return warnEmpty(theField, d);
	}
	
	// Define mensaje de error
    var msg;

	if (!isEmpty(s))  {
        msg = s;
    } 
	else 
	{
        if( theFunction == isAlphabetic ) msg = pAlphabetic;
        if( theFunction == isAlphanumeric ) msg = pAlphanumeric;
        if( theFunction == isInteger ) msg = pInteger;
        if( theFunction == isNumber ) msg = pNumber;
        if( theFunction == isEmail ) msg = pEmail;
        if( theFunction == isPhoneNumber ) msg = pPhoneNumber;
        if( theFunction == isName ) msg = pName;
        if( theFunction == isRut ) msg = pRut;
        if( theFunction == isRutEmpresa ) msg = pRut;
    }
	//valida si esta permitido ingresar comillas
	if ( checkNiceness && !isNice(theField.value))
        return warnInvalid(theField, pNice);
	//valida de acuerdo a la funcion indicada
		//alert(theField.name + " llamando a la funcion " + theFunction.name)
	if (theFunction(theField.value,theField) == true){
		//alert("se valido bien");
		return true;
		} 
    else
		return warnInvalid(theField,msg);
}

// ---------------------------------------------------------------------- //
//                                       FUNCION TRIM                                         //
// ---------------------------------------------------------------------- //

function trim(cadena) {
	var nuevacadenal="";
	var nuevacadenar="";
	var intLimitel;
	var intLimiter;
	
	for(i=0;i<cadena.length;i++) {
	  if(cadena.charAt(i)==" ") {
	    intLimitel++;
	  } 
	  else {
	  	break;
	  }
	}
	
	nuevacadenal=cadena.substring(intLimitel,cadena.length);
	intLimiter=nuevacadenal.length;
	for(i=nuevacadenal.length-1;i>=0;i--) {
	    if(nuevacadenal.charAt(i)==" ") {
			intLimiter--;
	    } else {
		  break;
		}
	}
	
	nuevacadenar=nuevacadenal.substring(0,intLimiter);
	
	return(nuevacadenar)
}
// ---------------------------------------------------------------------- //
//					Permite teclear solamente numeros					  //
// ---------------------------------------------------------------------- //
function OnlyNum()
{
if (document.all)
 {
  t=event.keyCode;
  if ((t>=48 && t<=57) || t==8 || t==46) 
    {t=0}
  else 
   {event.keyCode= 0;}
 }  
}