// Trivelobike.es

/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		cambiarTamanio
* Parámetros:	-
* Descripción:	Cambia la altura y anchura de frame ifDerecha que contiene al documento actual, para ajustarlo al contenido
-----------------------------------------------------------------------------------------------------------------------------*/
function cambiarTamanio() {
	var dbsh = document.all ? document.body.scrollHeight : document.body.offsetHeight;
	var dbsw = screen.availWidth;
	var o = parent.document.getElementById ('ifDerecha');
	if (o) o.style.height = dbsh + 50;
	if (o) o.style.width = dbsw - 300;
//	o.parentNode.style.height = dbsh + 50;	// necesario para que funcione en Mozilla
}

/* -------------------------------
* Función: 		cambiarTamanioCalendario
* Parámetros:	-
* Descripción:	Cambia la altura del frame ifCalendario que contiene al documento actual, para ajustarlo al contenido
-----------------------------------------------------------------------------------------------------------------------------*/
function cambiarTamanioCalendario() {
	var dbsh = document.all ? document.body.scrollHeight : document.body.offsetHeight;
	var o = parent.document.getElementById ('ifCalendario');
	if (o) o.style.height = dbsh;
//	o.parentNode.style.height = dbsh + 50;	// necesario para que funcione en Mozilla
}

/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		bEsCadVacio
* Parámetros:	Cadena de texto
* Descripción:	Comprueba si la cadena suministrada está vacia o son espacios en blanco
-----------------------------------------------------------------------------------------------------------------------------*/
function bEsCadVacio(Cadena) {
	if ( Cadena.length = 0 ) { return true }
	for ( i = 0; i < Cadena.length; i++ ) {  
		if ( Cadena.charAt(i) != " " ) {  
			return false  
		}  
	}  
	return true  
}

/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		bEsFechaCorrecta
* Parámetros:	Campo de fecha o cadena de texto que represente una fecha, separadores - o /
* Descripción:	Comprueba si la cadena de texto o el valor del campo pasado como argumento es una fecha en formato correcto
-----------------------------------------------------------------------------------------------------------------------------*/
function bEsFechaCorrecta( oCampo ) {
	//Se comprueba si el parámetro es una cadena de texto o un campo como Objeto	
	var sFecha;
	if( typeof( oCampo ) == "string" ) { sFecha = oCampo; }
	else if( typeof( oCampo ) == "object" ) { 
		sFecha = oCampo.value;
		if ( "" + sFecha == "undefined" ) { return( false ) }
	}
	else { return( false ); }

	//La fecha es vacia
	if( sFecha.length < 1) { return( false ); }
	
	//Se obtienen las diferentes partes de la fecha según los separadores
	var asSeparadores = new Array( "-", "/" );
	var asFecha, sDia, sMes, sAnio, bSeparadores = false;
	for( i = 0; i < asSeparadores.length; i++ ) {
		if( sFecha.indexOf( asSeparadores[ i ] ) != -1 ) {
			asFecha = sFecha.split( asSeparadores[ i ] );
			if( asFecha.length != 3 ) {
				return( false );
			}
			else {
				sDia = asFecha[0];
				sMes = asFecha[1];
				sAnio = asFecha[2];
			}
			bSeparadores = true;
   		}
	}

	//Si ha fallado la operación anterior
	if( bSeparadores == false ) {
		if( sFecha.length > 5 )  {
			sDia = sFecha.substr( 0, 2 );
			sMes = sFecha.substr( 2, 2 );
			sAnio = sFecha.substr( 4 );
	   	}
	}
	
	//Comprobación del año
	var nAnio = parseInt( sAnio, 10 );
	if( isNaN( nAnio ) ) { return( false ); }
	if( nAnio > 9999 ) { return( false ); }
	if( nAnio < 50 ) { nAnio = nAnio + 2000; }
	else if( nAnio < 100 ) { nAnio = nAnio + 1900; }
	
	//Primera comprobación del día
	var nDia = parseInt( sDia, 10 );
	if( isNaN( nDia ) || nDia >31 || nDia < 1 ) {	return false; }
	
	//Comprobación del mes y los días de este
	var nMes = parseInt( sMes, 10 );
	if( isNaN( nMes ) ) { return( false ); }

	if( nMes >12 || nMes < 1 ) { return( false ); }
	if( ( nMes == 1 || nMes == 3 || nMes == 5 || nMes == 7 || nMes == 8 || nMes == 10 || nMes == 12 ) && ( nDia > 31 || nDia < 1 ) ) {
		return( false );
	}
	if( ( nMes == 4 || nMes == 6 || nMes == 9 || nMes == 11 ) && ( nDia > 30 || nDia < 1 ) ) {
		return( false );
	}
	if( nMes == 2 ) {
		if( nDia < 1 ) { return( false ); }
		if( bEsAnioBisiesto( nAnio ) == true ) {
			if( nDia > 29 ) { return( false ); }
		}
		else {
			if( nDia > 28 ) { return( false ); }
		}
	}

	return true;
}

/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		bEsAnioBisiesto
* Parámetros:	Año numerico
* Descripción:	Comprueba si el año es bisiesto
-----------------------------------------------------------------------------------------------------------------------------*/
function bEsAnioBisiesto( nAnio ) {
	if( nAnio % 100 == 0 ) {
		if( nAnio % 400 == 0 ) { return( true ); }
	}
	else {
		if( ( nAnio % 4 ) == 0 ) { return( true ); }
	}
	return( false );
}

/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		bEsNumeroCorrecto
* Parámetros:	Campo de número o cadena de texto que represente un número
* Descripción:	Comprueba si la cadena de texto o el valor del campo suministrado es un número en formato correcto
-----------------------------------------------------------------------------------------------------------------------------*/
function bEsNumeroCorrecto( oCampo, sSepMiles, sSepComa ) {
	//Se admite una cadena de texto o el campo como Objeto	
	var sNumero;
	if( typeof( oCampo ) == "string" ) { sNumero = oCampo; }
	else if( typeof( oCampo ) == "object" ) { 
		sNumero = oCampo.value;
		if ( "" + sNumero == "undefined" ) { return( false ) }
	}
	else { return( false ); }
	
	if( typeof( sSepMiles ) != "string" ) { sSepMiles = "."; }
	if( typeof( sSepComa ) != "string" ) { sSepComa = ","; }
	
	if( sNumero.length = 0 ) { return( true ); }
	else {
		//Localizar la posición de la Coma
		var nPosComa = sNumero.indexOf( sSepComa );
		//Dividir el número en parte entera y parte decimal
		var sParteEntera, sParteDecimal;
    		if( nPosComa != -1 ) {
    			sParteEntera = sNumero.substring( 0, nPosComa );
    			sParteDecimal = sNumero.substring( sNumero.length, nPosComa + 1 );
    		}
    		else {
    			sParteEntera = sNumero;
    			sParteDecimal = "";
    		}
    		
    		//Comprobar si la parte decimal es sólo números
    		if( !bEsCadenaNumeros( sParteDecimal ) ) { return( false ); }
    		//Comprobar si la parte entera es sólo números y está en grupos de tres dígitos
    		var asParteEntera = sParteEntera.split( sSepMiles ), i;
    		if( asParteEntera.length == 1 ){
    			if( !bEsCadenaNumeros( asParteEntera[ 0 ] ) ) { return( false ); }
    		}
    		else
    		{
    			for( i = 0; i < asParteEntera.length; i++ ) {
    				if( !bEsCadenaNumeros( asParteEntera[ i ] ) ) { return( false ); }
	    			if( i == 0 ) {
					if( asParteEntera[ i ].length > 3 ) { return( false ); }
				}
				else {
					if( asParteEntera[ i ].length != 3 ) { return( false ); }
				}
			}
    		}
    		return( true );
 	} 	
}

/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		bEsCadenaNumeros
* Parámetros:	Cadena de texto
* Descripción:	Comprueba si una cadena está compuesta unicamente por números
-----------------------------------------------------------------------------------------------------------------------------*/
function bEsCadenaNumeros( sNumero ) {
     var sNumeros = "0123456789", sCaracter, i;
	for( i = 0; i < sNumero.length; i++ ) {
		sCaracter = sNumero.substring( i, i+1 );
		if( sNumeros.indexOf( sCaracter ) == "-1") { return( false ); }
	}
	return( true );
}

/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		bEmailCorrecto
* Parámetros:	Cadena de texto con una dirección de email correcta en formato nombre@dominio.es
* Descripción:	Comprueba si la cadena de texto o el valor del campo suministrado es un número en formato correcto
-----------------------------------------------------------------------------------------------------------------------------*/
function bEmailCorrecto(emailStr) {
	/* El patrón siguiente es usado para chequear si la dirección de e-email completa cumple el formato user@domain. También es utilizada para separar el nombre de usuario del dominio */
	var emailPat=/^(.+)@(.+)$/
	/* La siguiente cadena representa el patrón para encajar todos los caracteres especiales. No permitiremos carácteres especiales en la dirección. Estos caracteres incluyen ( ) < > @ , ; : \ " . [ ] */
	var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
	// La siguiente cadena representa el rango de caracteres permitidos en el nombre de usuario o dominio.
	var validChars="\[^\\s" + specialChars + "\]"
	/* El siguiente patrón se aplica si el "usuario" es una cadena entre comillas (en cuyo caso, no hay reglas sobre que caracteres son permitidos y cuales no; cualquier cosa) */
	var quotedUser="(\"[^\"]*\")"
	/* El siguiente patrón se aplica para dominios que son direcciones IP, en lugar de nombres. Ej.: usuario@[121.122.222.2] es una dirección de email legal. NOTA: Los corchetes son requeridos. */
	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
	// La siguiente cadena representa un átomo (basicamente una serie de caracteres no especiales.)
	var atom=validChars + '+'
	/* La siguiente cadena representa una palabra en un nombre de usuario típico. Por ejemplo, en juan.ramos@dominio.com, juan y ramos son palabras. Básicamente, una palabra es cada uno de los átomos o cadenas entre comillas. */
	var word="(" + atom + "|" + quotedUser + ")"
	// El siguiente patrón describre la estructura del usuario
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
	// El siguiente patrón describre la estructura de un símbolo normal de dominio, como oposición al ipDomainPatrón.
	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")

	// Finalmente, se sugiere comenzar con una prueba para figurar la salida si la dirección suministrada es válida.

	// Comenzamos con el patrón vulgar para simplificar y dividir usario@dominio en diferentes partes para facilitar el análisis.
	var matchArray=emailStr.match(emailPat)
	if (matchArray==null) {
		// Demasiadas/pocas @ o algo; básicamente, la dirección no se ajusta al molde de una dirección de e-mail válida
		return false
	}
	var user=matchArray[1]
	var domain=matchArray[2]

	// Mirar si el "usuario" es válido
	if (user.match(userPat)==null) {
    	// usuario no válido
    	return false
	}

	// si la dirección de e-mail es una dirección IP (en vez de un nombre de host) nos aseguramos que es válida
	var IPArray=domain.match(ipDomainPat)
	if (IPArray!=null) {
    	// es una dirección IP
		  for (var i=1;i<=4;i++) {
		    if (IPArray[i]>255) {
			return false
	    	}
    	}
    	return true
	}

	// Dominio es un nombre simbólico
	var domainArray=domain.match(domainPat)
	if (domainArray==null) {
    	return false
	}

	/* Nombre de domino parece válido, pero ahora hay que asegurarse que finaliza en una palabra de tres letras (com, edu, gov) o una palabra de dos letras, representando el país (es, uk, nl), y hay un nombre de host precediendo al dominio o país */

	// Ahora necesitamos dividir el dominio para obtener un cálculo del número de átomos que lo componen
	var atomPat=new RegExp(atom,"g")
	var domArr=domain.match(atomPat)
	var len=domArr.length
	if (domArr[domArr.length-1].length<2 || 
    	domArr[domArr.length-1].length>3) {
   		// la dirección debe finalizar en una palabra de dos o tres letras.
   		return false
	}

	// Nos aseguramos de que hay un nombre de host precediendo al dominio.
	if (len<2) {
	   // La dirección omite el nombre de host.
	   return false
	}

	// La dirección de e-mail tiene un formato correcto
	return true;
}

/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		bEsNifCorrecto
* Parámetros:	Cadena de texto un Nif
* Descripción:	Comprueba si la cadena de texto es un número Nif correcto
-----------------------------------------------------------------------------------------------------------------------------*/
function bEsNifCorrecto(nif){
	
	var patronNif = /^[0-9]{8}[a-zA-Z]{1}$/;
	var patronNie = /^[a-zA-Z]{1}[0-9]{7}[a-zA-Z]{1}$/;
	var dni="";
	if ( patronNif.test(nif) ) {
		dni=nif.substring(0,nif.length-1);
	} else if ( patronNie.test(nif) ) {
		dni="0"+nif.substring(1,nif.length-1);
	} else if ( !bEsCadVacio(nif) ){
		return true;
	} else {
		return false;
	}
	var let=nif.charAt(nif.length-1);
	if (!isNaN(let)) {
		return false;
	} else{
		var cadena = "TRWAGMYFPDXBNJZSQVHLCKET";
		var posicion = dni % 23;
		var letra = cadena.substring(posicion,posicion+1);
		if (letra!=let.toUpperCase()){
			return false;
		}
	}
	return true;
}


/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		sValorCampo
* Parámetros:	Objeto campo
* Descripción:	Retorna el valor del campo en formato
-----------------------------------------------------------------------------------------------------------------------------*/
function sValorCampo( oCampo ) {
	
	//Se instancia el campo, en caso de que no exista, se retorna true
	if( typeof( oCampo ) != "object" ) { return( true ); }
	
	var i, xCampoValor, sCampoTipo = oCampo.type;
	//Para campos Notes de tipo: Texto, Texto enriquecido, Fecha/Hora, Números, Autores, Nombres, Lectores,
	//Contraseña, Fórmula, Todos los Ocultos (con propiedad Generar HTML para todos los campos activa)
	if( sCampoTipo == "text" || sCampoTipo == "textarea" || sCampoTipo == "password" || sCampoTipo == "hidden" ) {
		xCampoValor = ( oCampo.value == "" ) ? oCampo.value : "";
	}
	//Para campos Notes de tipo: Cuadro de diálogo (uno o varios valores), Cuadro de lista (uno o varios valores)
	//Cuadro de lista desplegable
	else if( sCampoTipo == "select-one" || sCampoTipo == "select-multiple" ) {
		xCampoValor = "";
		for( i = 0; i < oCampo.options.length; i++ ) {
			if( oCampo.options[ i ].selected )  { 
				if ( i != 0 ) { xCampoValor = xCampoValor + "," }
				xCampoValor = xCampoValor + oCampo.options[ i ].value;
			}
		}
	}
	//Para campos Notes de tipo: Casilla de verificación, Botón radial (UNO)
	else if( sCampoTipo == "checkbox" || sCampoTipo == "radio" ) {
		xCampoValor = ( oCampo.checked ) ? oCampo.value : "";
	}
	//Para campos Notes de tipo: Casillas de verificación, Botones radiales (MULTIPLES)
	else if ( ( "" + sCampoTipo ) == "undefined" ) {
		if( oCampo.value == null ) {
			xCampoValor = "";
			for( i = 0; i < oCampo.length; i++ ) {
				if ( i != 0 ) { xCampoValor = xCampoValor + "," }
				if( oCampo[ i ].checked ) {
					xCampoValor = xCampoValor + oCampo[ i ].value;
				}
			}
		}
		else {
			xCampoValor = "";
		}
	}
	//Para objetos que no son campos
	else {
		xCampoValor = "";
	}

	return( xCampoValor );
}

/* ---------------------------------------------------------------------------------------------------------------------------
* Función: 		OcultarCapa
* Parámetros:	Nombre capa y color fondo de la página de fondo
* Descripción:	Oculta una capa determinada
-----------------------------------------------------------------------------------------------------------------------------*/
function OcultarCapa( sNomCapa, sColorFondo )
{

    document.getElementById(sNomCapa).style.display = 'none'; /* Ocultar capa superior */
    document.body.style.background = sColorFondo; /* Cambiar color de página */
}