//----------------------------------------------------------------------
//                         Copyright © 2001 MAPFRE
//----------------------------------------------------------------------
//
//    Programa : validacionCampos.js
// Descripción : Validación de campos de un formulario.
// Programador : Sergio Rodríguez Márquez
//       Fecha : 30-08-2001
//     Versión : 1.00
//    Historia : Basado en el checks.js del Portal_Interno
//
//----------------------------------------------------------------------

//-----------------------------------------------------------
//-- Definimos el prototipo del método para el objeto String

//-----------------------------------------------------------
String.prototype.Trim = String_trim;

//----------------------------------------------------------------------
//     Función : validacionAlfaNum
// Descripción : Comprueba que en el texto sólo hay letras sin acentuar, 
//               los caracteres extendidos (ñÑçÇ) o dígitos
//  Parámetros : Cadena con el texto a analizar
//     Retorno : false / true
//       Notas : -
//----------------------------------------------------------------------
function validacionAlfaNum( cTexto ) {
	// Recorremos los datos introducidos
	for ( nPos = 0; nPos < cTexto.length; nPos++ ) {
		var cCaracter = cTexto.charAt( nPos );
		if ( !( (cCaracter >= '0' && cCaracter <= '9') ||
				(cCaracter >= 'a' && cCaracter <= 'z') ||
				(cCaracter >= 'A' && cCaracter <= 'Z') ||
				(cCaracter == 'ñ' || cCaracter == 'Ñ'  ||
				 cCaracter == 'ç' || cCaracter == 'Ç') ) ) {
			return false;
		}
	}
	return true;
}

//----------------------------------------------------------------------
//     Función : validacionNumerico
// Descripción : Comprobación básica de que todos los caracteres de la
//               cadena son sólo uno de estos "0123456789+-.,() "
//  Parámetros : Cadena con en número a comprobar
//     Retorno : false / true
//       Notas : -
//----------------------------------------------------------------------
function validacionNumerico( cNumero ) {
	// Recorremos los datos introducidos
	for ( nPos = 0; nPos < cNumero.length; nPos++ ) {
		var cCaracter = cNumero.charAt( nPos )
		if ( isNaN( parseInt( cCaracter ) ) 
		     && cCaracter != "-"
		     && cCaracter != "+"
		     && cCaracter != "."
		     && cCaracter != ","
		     && cCaracter != "("
		     && cCaracter != ")"
		     && cCaracter != " " ) {
			return false;
		}
	}
	return true;
}

//----------------------------------------------------------------------
//     Función : controlNumCaracteres
// Descripción : Control del máximo número de caracteres en un Textarea
//  Parámetros : maxNumCaracteres,nameTextArea, nameFormulario, nameCapa
//	         maxNumCaracteres : Máximo número de caracteres permitidos en el TextArea
//		 nameTextArea 	  : Name del TextArea 
//		 nameFormulario   : Name del Formulario
//		 nameCapa         : Name de la Capa
//     Retorno : false / true
//       Notas : Si el formulario no tiene capas el parámetro nameCapa no será necesario
//----------------------------------------------------------------------
function controlNumCaracteres(maxNumCaracteres,nameTextArea, nameFormulario, nameCapa, nameCapa2)
{
	var form_div = "";
	if (navigator.appName == 'Netscape' && nameCapa != null && nameCapa2 != null)
	{
		//netscape
		form_div = 'document.layers["' + nameCapa + '"].document.layers["' + nameCapa2 + '"].document.' + nameFormulario;
	}
	else if (navigator.appName == 'Netscape' && nameCapa != null && nameCapa2 == null)
	{
		//netscape
		form_div = 'document.layers["' + nameCapa + '"].document.' + nameFormulario;
	}
	else 
	{
		//explorer
		form_div = 'document.' + nameFormulario;
	}
	if (eval(form_div + '.' + nameTextArea + '.value.length') > maxNumCaracteres)
	{
		alert("El máximo número de caracteres permitidos es " + maxNumCaracteres);	
		eval (form_div + '.' + nameTextArea + '.focus');
		return false;
	}
	else {
		return true;
	}					
}

//----------------------------------------------------------------------
//     Función : validacionFechaSlash
// Descripción : Comprobación básica de que todos los caracteres de la
//               cadena son sólo uno de estos "0123456789/ "
//  Parámetros : Cadena con en número a comprobar
//     Retorno : false / true
//       Notas : -
//----------------------------------------------------------------------
function validacionFechaSlash( cFecha ) {
	// Recorremos los datos introducidos
	for ( nPos = 0; nPos < cFecha.length; nPos++ ) {
		var cCaracter = cFecha.charAt( nPos )
		if ( isNaN( parseInt( cCaracter ) ) 
		     && cCaracter != "/") 
		{
			return false;
		}
	}
	return true;
}
//----------------------------------------------------------------------
//
//     Función : validacionMail()
// Descripción : Comprueba que una determinada cadena tiene formato de 
//               dirección de correo electrónico
//  Parámetros : cMail - Cadena a comprobar
//     Retorno : true / false
//     Ejemplo : <input type="text" onBlur="return CheckMail( this.value )">
//
//----------------------------------------------------------------------

function validacionMail( cMail ) {
	// Eliminar los blancos por delante y por detrás
	//cMail = cMail.Trim();	
	// Comprobar que se tiene una arroba y esta no está al principio
	var nPos1 = cMail.indexOf("@");
	if ( nPos1 < 1 ){
		return false;
	}

	// Comprobar que se termina con un dominio	
	var nPos2 = cMail.lastIndexOf(".");
	if (   nPos2 < nPos1 
		|| nPos2 == nPos1+1 
		|| (nPos2 + 3 > cMail.length) ) {		
		return false;
	}	
	
	// Comprobar que no contiene blancos entre medias
	if ( cMail.indexOf( " " ) != -1 ) {
		return false
	}

	// El formato parece correcto
	return true;
}

//----------------------------------------------------------------------
//
//     Función : validacionDigito
// Descripción : Comprobación básica de que todos los caracteres de la
//               cadena son sólo uno de estos "0123456789"
//  Parámetros : Cadena con en número a comprobar
//     Retorno : false / true
//       Notas : -
//
//----------------------------------------------------------------------
function validacionDigito( cNumero ) {
	// Recorremos los datos introducidos
	for ( nPos = 0; nPos < cNumero.length; nPos++ ) {
		var cCaracter = cNumero.charAt( nPos )
		if ( isNaN( parseInt( cCaracter ) ) ) {
			return false;
		}
	}
	return true;
}

//----------------------------------------------------------------------
//     Función : validacionFormatoNumero
// Descripción : Comprobación básica de que todos los caracteres de la
//               cadena son sólo uno de estos "0123456789 ," además sólo tiene que tener una coma
//  Parámetros : Cadena con el número a comprobar
//     Retorno : false / true
//       Notas : -
//----------------------------------------------------------------------
function validacionFormatoNumero( cNumero ) {
	// Recorremos los datos introducidos
	var numComas = 0;
	for ( nPos = 0; nPos < cNumero.length; nPos++ ) {
		var cCaracter = cNumero.charAt( nPos );
		if ( isNaN( parseInt( cCaracter ) ) && cCaracter != "," ) {
			return false;
		}
		if (cCaracter == "," ) {
			numComas ++;
			if (numComas > 1){
				return false;
			}	
		}

	}
	return true;
}

//----------------------------------------------------------------------
//
//     Función : validacionFecha
// Descripción : Realiza la validación de un dato tipo fecha
//  Parámetros : Cadena con la fecha a trasformar
//     Retorno : true / false
//       Notas : - Admite los formatos de entrada siguientes:
//                     d/m/yy
//                     dd/mm/yy
//                     dd/mm/yyyy 
//               - En el caso de incluir solo dos dígitos para el año,
//                 se interpreta como fecha del año 2000 los inferiores 
//                 o igual a 30.
//
//----------------------------------------------------------------------
function validacionFecha( cFecha ) {

	// Comprobación de tamaño
	if ( cFecha.length < 6 || cFecha.length > 10 ) { 
		return false;
	}
	
	if (cFecha.length == 6)
	{
		if (!validacionNumerico(cFecha.substring(0,1)))
		{
			return false;
		}
		if (!validacionNumerico(cFecha.substring(2,3)))
		{
			return false;
		}
		if (!validacionNumerico(cFecha.substring(4)))
		{
			return false;
		}
	}
	
	if ((cFecha.length == 8) || (cFecha.length == 10))
	{
		if (!validacionNumerico(cFecha.substring(0,2)))
		{
			return false;
		}
		if (!validacionNumerico(cFecha.substring(3,5)))
		{
			return false;
		}
		if (!validacionNumerico(cFecha.substring(6)))
		{
			return false;
		}
	}
	// Buscar primer separador de la fecha
	var nSeparador1 = cFecha.indexOf( "/", 0 )
	if ( nSeparador1 < 1 || nSeparador1 > 2 ) {
		return false;
	}
	
	// Obtener el día
	var cDia = cFecha.substring(0, nSeparador1)
	
	// Buscar el segundo separador de la fecha
	var nSeparador2 = cFecha.indexOf( "/", nSeparador1+1 )
	if ( nSeparador2 < nSeparador1+2 || nSeparador2 > nSeparador1+3 ) {
		return false;
	}
	
	// Obtener el mes
	var cMes = cFecha.substring(nSeparador1+1, nSeparador2)
	
	// Obtener el año
	var cYear = cFecha.substring(nSeparador2+1, cFecha.length)

	// Normalización del año
	if ( cYear.length == 1 || cYear.length == 3 ) {
		return false;
	}
	//¡¡¡¡--Cuidado con la funcionalidad de esto para nacimientos anteriores a 1929.---!!!!
	if ( cYear.length == 2 ) {
		if ( parseInt( cYear ) > 29 ) {
			cYear = "19" + cYear
		} else {
			cYear = "20" + cYear
		}
	}

	// Comprobación del mes
	if ( cMes < 1 || cMes >12 ) {
		return false;
	}
	
	// Comprobación básica del día
	if ( cDia < 1 || cDia >31) {
		return false;
	}
	
	// Comprobación del día en los meses con 30 días
	if ( (cMes==4 || cMes==6 || cMes==9 || cMes==11) && (cDia == 31 ) ) {
		return false;
	}
	
	// Comprobación del mes de febrero teniendo en cuenta los bisiestos	
	if ( cMes==2 ){
		if ( cDia > 29 ) {
			return "";
		}
		if ( ( cYear / 4 == parseInt( cYear / 4 ) )  
		     && ! ( ( cYear / 100 == parseInt( cYear / 100 ) ) 
                         && ( cYear / 400 != parseInt( cYear / 400 ) ) ) ) {
			var bBisiesto = true;
		} else {
			var bBisiesto = false;
		}
		if ( ! bBisiesto && cDia==29 ) {
			return false;
		}
	}
	
	// Retorno Ok
	return true;
	
}
 
function formatoDDMMYYYY( cFecha )
{
	// Buscar primer separador de la fecha
	var nSeparador1 = cFecha.indexOf( "/", 0 );
	// Obtener el día
	var cDia = cFecha.substring(0, nSeparador1);
	if(cDia.length==1)
	{
		cDia = "0" + cDia;
	}
	// Buscar el segundo separador de la fecha
	var nSeparador2 = cFecha.indexOf( "/", nSeparador1+1 );
	// Obtener el mes
	var cMes = cFecha.substring(nSeparador1+1, nSeparador2);
	if(cMes.length==1)
	{
		cMes = "0" + cMes;
	}
	// Obtener el año
	var cYear = cFecha.substring(nSeparador2+1, cFecha.length)
	if(cYear.length==2)
	{
		cYear = "20" + cYear;
	}
	var sFechaValida = cDia + "/" + cMes + "/" + cYear;
	return sFechaValida;
}
//----------------------------------------------------------------------
//
//     Función : CheckModificar
// Descripción : Comprobación básica de que todos los caracteres de la
//               cadena son validos.
//  Parámetros : Cadena con en texto a comprobar
//     Retorno : false / true
//       Notas : -
//
//----------------------------------------------------------------------
function CheckModificar( cTexto ) 
{
	// Recorremos los datos introducidos		     
	for ( nPos = 0; nPos < cTexto.length; nPos++ ) 
	{
		var cCaracter = cTexto.charAt( nPos )
	
		if ( 
				cCaracter == "-"
		     || cCaracter == "+"
		     || cCaracter == '#'
		     || cCaracter == '&'
		     || cCaracter == '%'
		     || cCaracter == '"'
		     || cCaracter == "'"
		     || cCaracter == "."
		     || cCaracter == ","
		     || cCaracter == "("
		     || cCaracter == ")"
			 || cCaracter == 'ç' 
			 || cCaracter == 'Ç' )
		{
			return false;
		}
	}
	
	return true;
}

//----------------------------------------------------------------------
//      Método : Trim
// Descripción : Añade un método Trim al objeto String de JavaScript 
//               para eliminar blancos por delante y por detrás de una 
//               cadena
//  Parámetros : -
//     Retorno : Cadena sin espacios por delante y por detras del texto
//       Notas : -
//----------------------------------------------------------------------

function String_trim(Cadena)
{
	// Recorremos los datos introducidos		     
	var lon;
	var p1;
	var p2;
	var c;
	var buffer;
	
	lon=Cadena.length;
	p1=0;
	c=Cadena.charAt(p1);
	
	while (p1<=lon-1 && c==" ")
	{
		p1++;
		c=Cadena.charAt(p1);
	}
	
	p2=lon;
	c=Cadena.charAt(p2-1);
	
	while (p2>=0 && c==" ")
	{
		p2--;
		c=Cadena.charAt(p2-1);
	}

	if (p1>=p2) 
		buffer="";
	  else
	    buffer=Cadena.substr(p1,p2-p1);	

	return buffer;
}

//----------------------------------------------------------------------
//     Función : validaCheckPulsado
// Descripción : Valida si de los checkbox de un formulario hay alguno
//					pulsado antes de enviar el formulario 
//  Parámetros : El nombre del formulario
//     Retorno : true / false
//       Notas : Solo se utilizará si es obligatorio que se seleccione 
//				 algún ckeckbox
//----------------------------------------------------------------------
function validaCheckPulsado(cNombreFormulario)
{
	
	var iNumElem=0;
	
	for (i=0;i<eval("document." + cNombreFormulario + ".length");i++)
	{
			if(eval("document." + cNombreFormulario + "[i].type=='checkbox'") && eval("document." + cNombreFormulario + "[i].checked==true")) 
			{
				iNumElem++;	
			}
	}
	if (iNumElem!=0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//----------------------------------------------------------------------
//     Función : validaOptionPulsado
// Descripción : Valida si de los option de un formulario hay alguno
//					pulsado antes de enviar el formulario 
//  Parámetros : El nombre del formulario
//     Retorno : true / false
//       Notas : Solo se utilizará si es obligatorio que se seleccione 
//				 algún radioButton
//----------------------------------------------------------------------
function validaOptionPulsado(cNombreFormulario)
{
	
	var iNumElem=0;
	for (i=0;i<eval("document." + cNombreFormulario + ".length");i++)
	{
			if(eval("document." + cNombreFormulario + "[i].type=='radio'") && eval("document." + cNombreFormulario + "[i].checked==true")) 
			{
				iNumElem++;	
			}
	}
	
	if (iNumElem!=0)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//----------------------------------------------------------------------
//     Función : validaOptionConcretoPulsado
// Descripción : Valida si alguna de las opciones de un option está pulsada
//  Parámetros : El nombre del formulario, el nombre del radioButton
//     Retorno : true / false
//       Notas : Solo se utilizará si es obligatorio que se seleccione 
//				 algún radioButton
//----------------------------------------------------------------------
function validaOptionConcretoPulsado(cNombreFormulario, cNombreOption)
{
	val = (eval("document." + cNombreFormulario + "." + cNombreOption + ".length"));
	for (i=0; i<val; i++){
		if(eval("document." + cNombreFormulario + "." + cNombreOption + "[i].checked==true")) {
			return true;
		}
	}
	return false;
	
}

//----------------------------------------------------------------------
//     Función : validaCampoObligatorio
// Descripción : Valida si en un campo obligatorio de un formulario
//				 se ha introducido algún valor y no son blancos.	
//  Parámetros : El nombre del formulario y el nombre del campo (String)
//     Retorno : true / false
//       Notas : Solo se utilizará si es obligatorio que se rellene 
//				 el campo texto
//----------------------------------------------------------------------
function validaCampoObligatorio(cNombreFormulario,cTexto)
{
	var texto=String_trim(eval("document." + cNombreFormulario + "." + cTexto + ".value"));
	
	if(texto!='')
	{ 
		return true;
	}
	else
	{
		return false;
	}
}

//----------------------------------------------------------------------
//     Función : validaDNI
//
// Descripción : Valida un campo DNI de un formulario, puede devolver true /false
//				 si deseamos chequear que el DNI introducido es válido o no. O de-
//				 volver el DNI después de chequear que la letra es válida o ponersela
//				 si el uauario no la introdujo.
//
//  Parámetros : La cadena formada por el DNI (String) y true si deseamos validar solo 
//				 la validez del DNI en el formulario(devolverá true / false) o false si  
//				 queremos chequear su validez y caso de no ser válido ponerle nosotros 
//				 una letra válida y devolver el DNI con su letra correcta.
//
//     Retorno : true / false(si la función recibe como parámetro true) o (String)DNI
//					(si la función recibe como parámetro false)
//       Notas : 
//----------------------------------------------------------------------
function validaDNI(DNI,retornoDNI)
{
	var validoDNI;
	var ultimoCaracter;
	ultimoCaracter=DNI.charAt(DNI.length - 1);
	
if(retornoDNI)
{
	if(isNaN(parseInt(ultimoCaracter)))
	{
		if(validaLetraDNI(DNI,true))
		{
			return DNI;
		}
		else
		{
			DNI=DNI.substring(0, DNI.length-1);
			validoDNI=validaLetraDNI(DNI,false);
			return validoDNI;
		}
	}
	else
	{
		validoDNI=validaLetraDNI(DNI,false);
		return validoDNI;
	}
}
else
{
	if(isNaN(parseInt(ultimoCaracter)))
	{
		if(validaLetraDNI(DNI,true))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}	
}
}
//----------------------------------------------------------------------
//     Función : validaLetraDNI
// Descripción : Valida si la letra del DNI introducida por el usuario
//				 es correcta
//  Parámetros : La cadena formada por el DNI (String)
//     Retorno : true / false
//       Notas : 
//----------------------------------------------------------------------
function validaLetraDNI(DNI,reciboLetra)
{
	var letraObtenida="";
	var secLetras="TRWAGMYFPDXBNJZSQVHLCKET";
	var numeroDNI=0;
	var resultado=0;
	var letra="";
if (reciboLetra)
{
	//Obtiene la letra del DNI introducido por el usuario.
	letraObtenida=DNI.charAt(DNI.length-1);
	
	//Obtiene el número de DNI introducido por el usuario
	numeroDNI=DNI.substring(0, DNI.length-1);
	
	//Aplica el algoritmo para obtener la letra real corrspondiente a ese número de DNI.
	resultado=parseInt(numeroDNI)%23+1;
	
	//Recoge la letra de la secuencia de letras válidas
	letra=secLetras.charAt( resultado-1 )
	
	//Compara letra introducida por el usuario y letra obtenida del algoritmo.
	if(letraObtenida.toUpperCase()==letra)
	{
		return true;
	}
	else
	{
		return false;
	}
}
else
{
	
	resultado=parseInt(DNI)%23+1;
	//Recoge la letra de la secuencia de letras válidas
	letra=secLetras.charAt( resultado-1 );
	return DNI + letra;
}	
	//Recoge la letra de la secuencia de letras válidas
	//letra=secLetras.charAt( resultado-1 )
	
	//Compara letra introducida por el usuario y letra obtenida del algoritmo.
	/*if(letraObtenida.toUpperCase()==letra)
	{
		return true;
	}
	else
	{
		return false;
	}*/
}

//----------------------------------------------------------------------
//     Función : validaSelectObligatorio
// Descripción : Valida si en un Select del formulario, se ha cambiado su
//				 valor, o por el contrario se ha dejado el valor que tiene
//				 por defecto. 	
//  Parámetros : El nombre del formulario y el nombre del Select (String)
//     Retorno : true / false
//       Notas : Solo se utilizará si es obligatorio que se le asigne un 
//				 valor al campo Select.
//----------------------------------------------------------------------
function validaSelectObligatorio(cNombreFormulario,cNombre)
{
	return( eval("document." + cNombreFormulario + "." + cNombre + ".options[document." + cNombreFormulario + "." + cNombre + ".selectedIndex].defaultSelected"));
}



function longitudCadena(cadena,longitud)
{
	longitudComentario = cadena.length;
	

	if (longitudComentario > longitud)
	{
		return true;	
	}
	else
	{
		return false;
	}
}

/* ----------------------
    FUNCIÓN : mesesDiferencia
       		  ***********	
	DESCRIPCIÓN : devuelve los meses (naturales) de diferencia que hay entre dos fechas:
					18/09/01 
	PARÁMETROS : param (String, String) : fecha de inicio y fin del tipo  ---> DDMMAAAA
					                                           					                   
	VALOR RETORNO : String 	:   Cantidad de meses de diferencia, (aprox).		 
	
	NOTA : La fecha de inicio debe ser menor que la final.  	
---------------------------*/	

function mesesDiferencia(sFechaInicio, sFechaFin)
{
	var diaInicio, diaFin, mesInicio, mesFin, yearInicio, yearFin, yearTotal, mesTotal, diaTotal;

	diaInicio = parseInt(sFechaInicio.substring(0,2),10);
	mesInicio = parseInt(sFechaInicio.substring(2,4),10);
	yearInicio = parseInt(sFechaInicio.substring(4),10);

	diaFin = parseInt(sFechaFin.substring(0,2),10);
	mesFin = parseInt(sFechaFin.substring(2,4),10);
	yearFin = parseInt(sFechaFin.substring(4),10);

	//Para los años:
	yearTotal = yearFin - yearInicio;

	if(yearTotal < 0)
	{
		//Error, la fecha final no puede ser menor que la inicial.
		return yearTotal;
	}

	//Para los meses:
	mesTotal = mesFin - mesInicio;

	if(mesTotal < 0)
	{
		yearTotal -= 1;
		mesTotal += 12;
	}

	mesTotal += yearTotal * 12;		
	
	//Para los días:
	diaTotal = diaFin - diaInicio;
	if(diaTotal < 0)
	{
		mesTotal -= 1;
		diaTotal += 30;
	}

	mesTotal += diaTotal/30;

}


function mostrarCliente(cual){
    if (cual=="si"){
        document.getElementById("clienteAsunto").style.display="block";
        document.getElementById("asuntoClientes").style.display="block";
        document.getElementById("entidadesAsunto").style.display="none";
        document.getElementById("entidades").style.display="none";
        document.getElementById("asuntoEntidades").style.display="none";
        document.getElementById("entidadesEti").style.display="none";
    } 
    else {
        document.getElementById("clienteAsunto").style.display="none";
        document.getElementById("asuntoClientes").style.display="none";
        document.getElementById("entidadesAsunto").style.display="block";
        document.getElementById("entidades").style.display="block";
        document.getElementById("asuntoEntidades").style.display="block";
        document.getElementById("entidadesEti").style.display="block";
    }
}

// Selecciona la opción del combo que coincide con el texto pasado.	
function seleccionarComboTexto(combo, texto){
    var i = 0;
    var ok = "true";
    while ((i < combo.length) && (ok == "true" )) {
       if (combo[i].text == texto) {
          combo.selectedIndex = i;
          ok = "false";
          break;
       } 
       else 
           i++;
    }
}