//--- Este archivo contiene metodos que pueden aplicarse para la validacion 
//--- de formularios HTML

//--- Lista de metodos ---------------------------------------
String.prototype.lTrim = lTrim;
String.prototype.rTrim = rTrim;
String.prototype.reemplazarCadena = reemplazarCadena;
String.prototype.esBlanco = esBlanco;
String.prototype.partir = partir;
String.prototype.hayCadenas = hayCadenas;
String.prototype.hayCadenas2 = hayCadenas2;
String.prototype.hayTags = hayTags;
String.prototype.esEMail = esEMail;
String.prototype.esNumeroNatural = esNumeroNatural;
String.prototype.esCodigoPostal = esCodigoPostal;
String.prototype.contarOcurrencias = contarOcurrencias;
String.prototype.comprimir = comprimir;
Date.prototype.formato = formato;
Date.prototype.agregar = agregar;
Date.prototype.getYear2 = getYear2;
//-------------------------------------------------------------

//--- Descripcion: quita los espacios y tabs a la izquierda de una cadena
//--- Argumentos: no posee
//--- Devuelve: String
//--- Requiere: no requiere metodos o funciones
function lTrim( ) {
	var i=0;
	var cadenaNueva="";
	
	while ( this.charAt(i) == " " || this.charAt(i) == "\t" ) {
		i++;
		}
		
	cadenaNueva=this.substring(i,this.length);

	return cadenaNueva;
	}

//--- Descripcion: quita los espacios y tabs a la derecha de una cadena
//--- Argumentos: no posee
//--- Devuelve: String
//--- Requiere: no requiere metodos o funciones
function rTrim( ) {
	var i=this.length - 1;
	var cadenaNueva="";

	while (this.charAt(i) == " " || this.charAt(i) == "\t" ) {
		i--;
		}
		
	cadenaNueva=this.substring(0,++i);

	return cadenaNueva;
	}


//--- Descripcion: reemplaza una cadena por otra
//--- Argumentos: 
//---		String cadenaABuscar
//---		String cadenaReemplazante
//---	Devuelve: String
//--- Requiere: no requiere metodos o funciones
function reemplazarCadena( cadenaABuscar, cadenaReemplazante ) {
	var i=0;
	var cadenaNueva="";
	
	if (cadenaABuscar=="") {
		return this;
		}

	while (i < this.length)
		{
		if( this.substring(i, i + cadenaABuscar.length ) == cadenaABuscar )
			{
			cadenaNueva+=cadenaReemplazante;
			i=i + cadenaABuscar.length;
			}
		else
			{
			cadenaNueva+=this.charAt(i);
			i++;	
			}
		}
	
	return cadenaNueva;
	}



//--- Descripcion: determina si una cadena es vacia o contiene blancos o tabs
//--- Argumentos: no posee
//--- Devuelve: Boolean (true o false)
//--- Requiere: no requiere metodos o funciones
function esBlanco ( ) {
	var i;
	for ( i=0; i < this.length; i++ ) {
		if ( this.charAt(i) != " " && this.charAt(i) != "\t" ) {
			return false;
			} 	
		}
		
	return true;
	}

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


//--- Descripcion: devuelve un array a partir de un caracter separador
//--- Argumentos: 
//---			caracter c (caracter separador)		
//--- Devuelve: un objeto Array
//--- Requiere: no requiere metodos o funciones
function partir( c ) {
      var a = new Array();

      for (var i = j = k = 0; i < this.length; i++) {
        if (this.substring(i,i+1) == c) {
            a[k++] = this.substring(j, i);
            j = i + 1;
           } 
          }
          
	  a[k] = this.substring(j, i);
	  
      return a; 
      }

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

//--- Descripcion:etermina la ocurrencia de una serie de cadenas dentro de otra
//--- La serie de cadenas a buscar se especifica con una cadena con
//--- un caracter separador.
//--- Si el modo es un valor Verdadero, la funcion devuelve true si 
//--- todas las cadenas de la lista aparecen.
//--- Si el modo es un valor Falso, la funcion devuelve true con la
//--- primera ocurrencia de una cadena de la lista.
//--- Argumentos:
//---			String lista (la lista de cadenas que se deben buscar con el separador)
//---			caracter separador
//---			Boolean modo (true si deben aparecer todas las cadenas, false si basta con que aparezca solo una)
//--- Devuelve:  	Boolean (true o false)
//--- Requiere los metodos: partir.
function hayCadenas ( lista, separador, modo ) {
	var i;
	var arrayLista = new Array();
	arrayLista=lista.partir( separador );

	
	for ( i=0; i < arrayLista.length ; i++ ) {
		
		if ( modo ) { //Todas tienen que estar
			if ( this.indexOf(arrayLista[i]) == -1 ) {
					return false;
					}
			}
		else { // Por lo menos una
			if ( this.indexOf(arrayLista[i]) != -1 ) {
					return true;
					}
				}
				
				
		}
	
	return ( (modo) ? true : false );
	}

//--- Descripcion:etermina la ocurrencia de una serie de cadenas dentro de otra
//--- La serie de cadenas a buscar se especifica con una cadena con
//--- un caracter separador.
//--- Si el modo es un valor Verdadero, la funcion devuelve true si 
//--- todas las cadenas de la lista aparecen.
//--- Si el modo es un valor Falso, la funcion devuelve true con la
//--- primera ocurrencia de una cadena de la lista.
//--- Argumentos:
//---			Array arrayLista (un array que contiene las cadenas a buscar)
//---			Boolean modo (true si deben aparecer todas las cadenas, false si basta con que aparezca solo una)
//--- Devuelve:  	Boolean (true o false)
//--- Requiere: no requiere metodos o funciones.
function hayCadenas2 ( arrayLista, modo ) {
	var i;
		
	for ( i=0; i < arrayLista.length ; i++ ) {
		
		if ( modo ) { //Todas tienen que estar
			if ( this.indexOf(arrayLista[i]) == -1 ) {
					return false;
					}
			}
		else { // Por lo menos una
			if ( this.indexOf(arrayLista[i]) != -1 ) {
					return true;
					}
				}
				
				
		}
	
	return ( (modo) ? true : false );
	}

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

//--- Descripcion: Determina si existen determinados tags de html en una cadena
//--- Los tags se especifican en una cadena con el caracter coma
//--- como separador y sin los signos < o > Ej: "B,UL,H1"
//--- Reconoce el tag siempre y cuando no tenga espacios en blanco
//--- Argumentos: 
//---			String cadenaTags (una cadena con los tags a buscar separeados por comas)
//--- Devuelve: Boolean (true o false)
//--- Requiere: partir, hayCadenas.
function hayTags ( cadenaTags ) {
	var cadenaTagsCierre = cadenaTags + "," + cadenaTags;
	var i;

	var arrayTags=cadenaTagsCierre.partir(",");
	
	for ( i=0 ; i < arrayTags.length ; i++ ) {
		arrayTags[i]= "<" + ( ( i < ( arrayTags.length / 2 ) ) ? "" : "/" ) + arrayTags[i] + ">";
		}

	if ( this.hayCadenas2 ( arrayTags, false ) ) {
		return true;
		}

	return false;
	}

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

//--- Descripcion: determina si una cadena posee el formato de una direccion de E-Mail
//--- Argumentos: no posee argumentos
//--- Devuelve: Boolean (true o false)
//--- Requiere los metodos: hayCadenas, esBlanco
function esEMail ( ) {
	if (
		( this.hayCadenas( " ,\",\'", ",", false ) )  ||
		( this.indexOf("@") != this.lastIndexOf("@") )||
		( this.indexOf("@") == -1 ) ||
		( this.indexOf("@") == 0 ) ||
		( this.indexOf("@") == this.length - 1 ) ||
		( this.esBlanco() ) 
	   )	{
		return false;
		}

	return true;
	}	
//------------------------------------------------------------------------

//--- Determina si un numero es natural (Entero, Positivo, sin exponentes ni
//--- notacion hexadecimal).
//--- Se puede determinar, con un valor verdadero o falso si el 0 es natural o no
//--- y si un número con ceros a la izquierda también lo es.
//--- Requiere los metodos: hayCadena, reemplazarCadena, esBlanco.
//--- Argumentos: 
//---			Boolean ceroEsNatural (si se considera a 0 como numero natural)
//---			Boolean valenCerosALaIzquierda
//--- Devuelve: Boolean (true o false)
function esNumeroNatural ( ceroEsNatural, valenCerosALaIzquierda ) {
	if ( isNaN(this) || this.esBlanco() ) {
		return false;
		}

	if ( this.hayCadenas( "., ,-,e,E,x,X" , "," , false ) ) {
		return false;
		}

	if ( !ceroEsNatural && this.reemplazarCadena("0","")=="" ) {
		return false;
		}

	if ( !valenCerosALaIzquierda && this.indexOf("0") == 0 ) {
		return false;
		}

	
	return true;
	}
//------------------------------------------------------------------------

//--- Determina si una cadena posee el formato de Codigo Postal Argentino
//--- Tanto para el formato actual como el anterior
//--- Argumentos: no posee
//--- Devuelve: Boolean (true o false)
//--- Requiere: esNumeroNatural
function esCodigoPostal ( ) {
	if ( this.length != 4 && this.length != 8 ) {
		return false;
		}

	
	if ( this.length == 4  ) {
		if ( !this.esNumeroNatural( false, false ) ) {
			return false;
			}
		else {
			return true;
			}
		}
		
	else {
		
		if ( 
			( this.charCodeAt(0) < 65 || this.charCodeAt(0) > 90 )	||
			( this.charAt(0).hayCadenas ( "I,O" , "," , false ) ) ||
			( !this.substring(1,5).esNumeroNatural( false, false ) )  ||
			( this.charCodeAt(5) < 65 || this.charCodeAt(5) > 90 )	||
			( this.charCodeAt(6) < 65 || this.charCodeAt(6) > 90 )	||
			( this.charCodeAt(7) < 65 || this.charCodeAt(7) > 90 )
			) {
			return false;
			}
		else {
			return true;
			}
			
		}

	
	}

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

//--- Descripcion: cuenta las ocurrencias de una cadena dentro de otra
//--- Argumentos: 
//---			String cadenaABuscar 
//---			Boolean buscarEnRepeticiones (ej true: buscar "aa" en "aaaa" devuelve 3 ocurrencias,
//---								   false: devuelve 2 ocurrencias)
//--- Devuelve:
//---			Number (cantidad de ocurrencias encontradas)
//--- Requiere: no requiere metodos o funciones
function contarOcurrencias ( cadenaABuscar, buscarEnRepeticiones ) {
	var i=0;
	var cantidad=0;
	
	if ( cadenaABuscar=="" ) return -1;

	while ( i < this.length ) {
		if( this.substring(i, i + cadenaABuscar.length ) == cadenaABuscar )	{
			cantidad++;
			i=i + ( ( buscarEnRepeticiones ) ? 1 : cadenaABuscar.length );
			}
		else {
			i++;	
			}
		}
	
	return cantidad;

	}
//------------------------------------------------------------------------

//--- Descripcion: comprime una secuencia de la misma cadena a una sola, ejemplo:
//--- comprimir las apariciones de la letra 'o' en "saloooon" = "salon".
//--- Argumentos: String cadenaAComprimir
//--- Devuelve:
//---			String (la cadena luego de la compresión)
//--- Requiere: no requiere métodos o funciones
function comprimir ( cadenaAComprimir ) {
	var i=0;
	var cadenaNueva = "";
	var laProximaComprimir=false;

	while ( i < this.length ) {
		if ( this.substring( i, i + cadenaAComprimir.length ) == cadenaAComprimir ) {
			cadenaNueva += ( ( laProximaComprimir ) ? "" : cadenaAComprimir );
			laProximaComprimir=true;
			i = i + cadenaAComprimir.length;
			}
		else	{
			cadenaNueva += this.charAt(i);
			laProximaComprimir=false;
			i++;
			}
		}
		
	return cadenaNueva;	
	}

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

//--- Descripcion: da formato a una fecha segun un codigo numerico 
//--- similar a los utilizados en la funcion convert de SQL
//--- Argumentos: Number (codigo a comprimir)
//--- Devuelve:
//---			String (la cadena en formato de fecha)
//--- Requiere los metodos: getYear2

function formato( tipo ) {
	var valor;
	var dia, mes, anio;
	var hora, minuto, segundo, milisegundo;
	
	dia = this.getDate();
	mes = this.getMonth() + 1;
	anio = this.getYear2();
	hora = this.getHours();
	minuto = this.getMinutes();
	segundo = this.getSeconds();

	
	if ( tipo == 101 ) { //USA
		valor = mes + "/" + dia + "/" + anio;
		}
	
	else if ( tipo == 102 ) { //ANSI
		valor = anio + "." + mes + "." + dia;
		}
		
	else if ( tipo == 103 ) { //British/French
		valor =  dia + "/" + mes + "/" + anio;
		}

	else if ( tipo == 104 ) { //German
		valor =  dia + "." + mes + "." + anio;
		}

	else if ( tipo == 105 ) { //Italian
		valor =  dia + "-" + mes + "-" + anio;
		}

	else if ( tipo == 108 ) { //-
		valor =  hora + ":" + minuto + ":" + segundo;
		}
	
	else if ( tipo == 110 ) { //USA
		valor =  mes + "-" + dia + "-" + anio;
		}

	else if ( tipo == 111 ) { //Japan
		valor =  anio + "/" + mes + "/" + dia;
		}
	
	else if ( tipo == 112 ) { //ISO
		valor =  anio + "" + mes + "" + dia;
		}

	else { //No es ninguno de los anteriores
		valor=this;
		}
	
	return valor;
	
	}
//------------------------------------------------------------------------

//--- Descripcion: agrega unidades de tiempo a una fecha 
//--- Argumentos: 
//---			String unidad (que unidad de tiempo se agrega)
//--- Unidades de tiempo:
//---	"s" : segundos
//---	"n" : minutos
//---	"h" : horas
//---	"d" : días
//---	"m" : meses
//---	"y" : años
//---			Number cantidad (cuantas unidades se agregan)
//--- Devuelve:
//---			Date (la fecha modificada)
//--- Requiere los metodos: getYear2
function agregar( unidad, cantidad ) {
	
	var fechaNueva = new Date();
	var anio;
	fechaNueva = this;
			
	if ( unidad == "s" ) {
		fechaNueva.setSeconds(fechaNueva.getSeconds() + cantidad);
		}
	else if ( unidad == "n" ) {
		fechaNueva.setMinutes(fechaNueva.getMinutes() + cantidad);
		}
	else if ( unidad == "h" ) {
		fechaNueva.setHours(fechaNueva.getHours() + cantidad);
		} 
	else if ( unidad == "d" ) {	
		fechaNueva.setDate(fechaNueva.getDate() + cantidad);
		}
	else if ( unidad == "m" ) {
		fechaNueva.setMonth(fechaNueva.getMonth() + cantidad);
		}
	else if ( unidad == "y" ) {
		fechaNueva.setYear(fechaNueva.getYear2() + cantidad);
		}
	
	return fechaNueva;
	
	}
	
//------------------------------------------------------------------------

//--- Descripcion: obtiene el año (en cuatro cifras) de un objeto Date
//--- Intenta subsanar el incomprensible manejo que realizan las diferentes versiones
//--- del metodo getYear 
//--- Devuelve:
//---			Number (el año correspondiente al objeto Date)
//--- Requiere: no requiere metodos o funciones
function getYear2() {
	var anio = this.getYear();
	if ( navigator.userAgent.indexOf("MSIE") != -1 ) {
			anio += (anio >= 0 && anio <= 99) ? 1900 : 0;
			}
		else {
			anio += 1900;
			}
	return anio;	
	}