/***************************************************************************************
 FICHEROS DE FUNCIONES UTILIZADOS:
	- comunes.js
	- fechas.js
	- horas.js
	- formatos.js
/***************************************************************************************



/***************************************************************************************
 FUNCION GENERICA DE VALIDACION DE CAMPOS DE ENTRADA
 Tipos de campos:
 	- "NUM_ENTERO":	esNumeros()
 			* opcional1 = numero minimo permitido
 			* opcional2 = numero maximo permitido
 	- "NUMERICO":	esNumerico()
 	- "TEXTO":	contieneComillas()
 	- "PATH":	contieneCaracteres()
 	- "FECHA":	fechaValida()
 			* opcional1 = fecha mínima permitida. Puede venir o no
 			* opcional2 = fecha máxima permitida. Puede venir o no
 				ambas debe ir en formato AAAAMMDD
 	- "IMPORTE":	validarDesformatear()
  			* opcional1 = numero maximo de decimales
 	- "HORA:MIN": 	validaHora()
 	- "HORA":	esHora()
 	- "MINUTOS":	esMinutos()
 	- "NIF":	esNif()
 	- "MAIL":	esMail()
 	- "TELEFONO":	esTelefono()
 	- "EXTFICH":	esExtFich()
 			* opcional1 = tamaño máximo
 	- "COMBO":	validarCombo()
 	- "CHECK":	validarCheck()
 			* opcional1 = tipo de validacion
				- "-1": al menos un checkbox seleccionado
				- "0": sin validación
				- "1": exactamente 1 checkbox marcado
				- ...
				- "N": exactamente N checkbox marcado
 	- "RADIO":	validarRadio()
 	- "AREA":	comprueba el texto introducido en un textarea
***************************************************************************************/
function isValid(nombreCampo, isObligado, tipo, opcional1, opcional2) {
	var strAux = "";
	
	if ((tipo != "RADIO") && (tipo != "CHECK") && (tipo != "COMBO") && (tipo != "FECHA") && (tipo != "AREA")) {
		if (trim(document.all[nombreCampo].value) == "") {
			if (isObligado == "S") {
				alert ("Campo "+ tipo +". Debe rellenar el valor del campo");
				document.all[nombreCampo].focus();
				return false;
			}
			else {
				return true;
			}
		}	
	}
	
	if ((tipo != "RADIO") && (tipo != "CHECK") && (tipo != "COMBO") && (tipo != "AREA") && (contieneComillas(nombreCampo))) {
		alert("No se admiten ningun tipo de comilla en un campo de texto.");			
		document.all[nombreCampo].focus();
		return false;
	}

	switch (tipo) {
	    case "PATH": 
		if (contieneCaracteres(nombreCampo)){
			alert("El campo no admite ninguno de los siguientes caracteres: \ * : ? < > |");			
			document.all[nombreCampo].focus();
			return false;
		}
		break;
	
	    case "FECHA":
		if (trim(document.all[nombreCampo].value) != ""){
			var fechaOk = fechaValida(document.all[nombreCampo].value);
			if ( fechaOk == "") {
				alert("Fecha incorrecta o con formato erroneo (dd/mm/aaaa)");			
				document.all[nombreCampo].focus();
				return false;	
			}
			else {
				if (opcional1 != undefined) {
					var fechaPrueba = desformatFechaR (document.all[nombreCampo].value);
					if (fechaPrueba < opcional1) {
						alert ("La fecha debe ser igual o superior a " + formatFecha(opcional1));
						document.all[nombreCampo].focus();
						return false;
					}
				}
				if (opcional2 != undefined) {
					var fechaPrueba = desformatFechaR (document.all[nombreCampo].value);
					if (fechaPrueba > opcional2) {
						alert ("La fecha debe ser igual o inferior a " + formatFecha(opcional2));
						document.all[nombreCampo].focus();
						return false;
					}
				}				
				document.all[nombreCampo].value = fechaOk;
			} // fin de fechaOK
		} // fin de blancos
		else {
	    		if (isObligado == "S") {
				alert ("Fecha obligatoria. Debe rellenar el valor del campo")
				document.all[nombreCampo].focus();
				return false;
			}
		}
		break;

	    case "IMPORTE":
		strAux = validarDesformatear(document.all[nombreCampo].value,",",".",parseInt(Math.round(opcional1)),"N","N");
		if (strAux == "") {
			document.all[nombreCampo].focus();
			return false;
		}
		else {
			//almacenar en el campo el valor con formato
			document.all[nombreCampo].value = formatearCampo(strAux,",",".",parseInt(Math.round(opcional1)),"N","N");
			//almacenar en el atributo value2 el importe sin formato (numerico javascript)
			document.all[nombreCampo].value2 = strAux;
		}
		break;
	
	    case "HORA:MIN":
		strAux = validaHora(document.all[nombreCampo].value,"S");
		if (strAux == "") {
			document.all[nombreCampo].focus();
			return false;
		}
		else {
			document.all[nombreCampo].value = strAux;
		}
		break;

	    case "HORA":
		strAux = esHora(document.all[nombreCampo].value,"S");
		if (strAux == "") {
			document.all[nombreCampo].focus();
			return false;
		}
		else {
			document.all[nombreCampo].value = strAux;
		}
		break;

	    case "MINUTOS":
		strAux = esMinutos(document.all[nombreCampo].value,"S");
		if (strAux == "") {
			document.all[nombreCampo].focus();
			return false;
		}
		else {
			document.all[nombreCampo].value = strAux;
		}
		break;

	    case "NIF":
		strAux = esNif(document.all[nombreCampo].value);
		if (strAux == "") {
			document.all[nombreCampo].focus();
			return false;
		}
		break;

	    case "MAIL":
		if (!esMail(document.all[nombreCampo].value)) {
			alert("Endereço de e-mail inválido.");
			document.all[nombreCampo].focus();
			return false;
		}
		break;

	    case "TELEFONO":
		strAux = esTelefono(document.all[nombreCampo].value);
		if (strAux == "") {
			alert("Telefone inválido.");
			document.all[nombreCampo].focus();
			return false;
		}
		break;
		case "TELEFONO2":
			strAux = esTelefono(document.all[nombreCampo].value);
			if (strAux == "") {
				alert("Campo Outro contacto inválido.");
				document.all[nombreCampo].focus();
			return false;
		}
		break;


	    case "EXTFICH":
		if (!esExtFich(document.all[nombreCampo].value,parseInt(opcional1,10))) {
			alert("Extensión no válida.");
			document.all[nombreCampo].focus();
			return false;
		}
		break;

	    case "COMBO":
		if (!validarCombo(nombreCampo)) {
			return false;
		}
		break;

	    case "CHECK":
		if (!validarCheck(nombreCampo,opcional1)) {
			return false;
		}
		break;

	    case "RADIO":
		if (!validarRadio(nombreCampo)) {
			return false;
		}
		break;
		
	    case "TEXTO":  //validacion de cadenas de texto
	    	break;
		
	    case "NUM_ENTERO":  //validacion de numéricos enteros
	    	if (!esNumeros(trim(document.all[nombreCampo].value))) {
			alert('El valor asignado debe ser numérico entero');
			document.all[nombreCampo].focus();
			return false;
		}		
		if ((opcional1 != undefined) && (parseInt(Math.round(trim(document.all[nombreCampo].value))) < parseInt(Math.round(opcional1)))) {
			if (opcional1 == opcional2){
				alert('El valor asignado debe ser ' + opcional1);
			}else{
				alert('El valor asignado debe ser mayor o igual que ' + opcional1);
			}	
			document.all[nombreCampo].focus();
			return false;
		}
		if ((opcional2 != undefined) && (parseInt(Math.round(trim(document.all[nombreCampo].value))) > parseInt(Math.round(opcional2)))) {
			if (opcional1 == opcional2){
				alert('El valor asignado debe ser ' + opcional2);
			}else{
				alert('El valor asignado debe ser menor o igual que ' + opcional2);
			}	
			document.all[nombreCampo].focus();
			return false;
		}	
	    	break;
	
	
	    case "NUMERICO":  //validacion de numéricos enteros
	    	if (!esNumerico(trim(document.all[nombreCampo].value))) {
			alert('El valor asignado debe ser numérico');
			document.all[nombreCampo].focus();
			return false;
		}
				break;
		case "CANTIDAD":  //validacion de numéricos enteros
	    	if (!esNumerico(trim(document.all[nombreCampo].value))) {
			alert('A quantidade seleccionada não é válida.');
			document.all[nombreCampo].focus();
			return false;
			}
			break;
		case "AREA":
			alert('Va a validar el TEXTAREA');
			if (trim(document.all[nombreCampo].innerText)=="" && isObligado=="S"){
				alert ("Campo obligatorio. Debe rellenar el valor del campo");
				document.all[nombreCampo].focus();
				return false;
			}
			break;

	    default:  //codigo tipo no valido
	    	return false;
	}

	return true;
}

/***************************************************************************************
 FUNCION GENERICA DE VALIDACION DE CAMPOS DE ENTRADA
 igual que la anterior pero recibe el objeto en lugar de su nombre
 
***************************************************************************************/
function isValidObj(objCampo, isObligado, tipo, opcional1, opcional2) {
	var strAux = "";
	
	if ((tipo != "RADIO") && (tipo != "CHECK") && (tipo != "COMBO") && (tipo != "FECHA") && (tipo != "AREA")) {
		if (trim(objCampo.value) == "") {
			if (isObligado == "S") {
				alert ("Por favor, preencha o campo" + objCampo)
				objCampo.focus();
				return false;
			}
			else {
				return true;
			}
		}	
	}
	
	if ((tipo != "RADIO") && (tipo != "CHECK") && (tipo != "COMBO") && (tipo != "AREA") && (contieneComillasObj(objCampo))) {
		alert("No se admiten ningun tipo de comilla en un campo de texto.");			
		objCampo.focus();
		return false;
	}

	switch (tipo) {
	    case "PATH": 
		break;
	
	    case "FECHA":
		if (trim(objCampo.value) != ""){
			var fechaOk = fechaValida(objCampo.value);
			if ( fechaOk == "") {
				alert("Fecha incorrecta o con formato erroneo (dd/mm/aaaa)");			
				return false;	
			}
			else {
				if (opcional1 != undefined) {
					var fechaPrueba = desformatFechaR (objCampo.value);
					if (fechaPrueba < opcional1) {
						alert ("La fecha debe ser igual o superior a " + formatFecha(opcional1));
						return false;
					}
				}
				if (opcional2 != undefined) {
					var fechaPrueba = desformatFechaR (objCampo.value);
					if (fechaPrueba > opcional2) {
						alert ("La fecha debe ser igual o inferior a " + formatFecha(opcional2));
						return false;
					}
				}				
				objCampo.value = fechaOk;
			} // fin de fechaOK
		} // fin de blancos
		else {
	    		if (isObligado == "S") {
				alert ("Fecha obligatoria. Debe rellenar el valor del campo")
				return false;
			}
		}
		break;

	    case "IMPORTE":
		strAux = validarDesformatear(objCampo.value,",",".",parseInt(Math.round(opcional1)),"N","N");
		if (strAux == "") {
			objCampo.focus();
			return false;
		}
		else {
			//almacenar en el campo el valor con formato
			objCampo.value = formatearCampo(strAux,",",".",parseInt(Math.round(opcional1)),"N","N");
			//almacenar en el atributo value2 el importe sin formato (numerico javascript)
			objCampo.value2 = strAux;
		}
		break;
	
	    case "HORA:MIN":
		strAux = validaHora(objCampo.value,"S");
		if (strAux == "") {
			objCampo.focus();
			return false;
		}
		else {
			objCampo.value = strAux;
		}
		break;

	    case "HORA":
		strAux = esHora(objCampo.value,"S");
		if (strAux == "") {
			objCampo.focus();
			return false;
		}
		else {
			objCampo.value = strAux;
		}
		break;

	    case "MINUTOS":
		strAux = esMinutos(objCampo.value,"S");
		if (strAux == "") {
			objCampo.focus();
			return false;
		}
		else {
			objCampo.value = strAux;
		}
		break;

	    case "NIF":
		strAux = esNif(objCampo.value);
		if (strAux == "") {
			dobjCampo.focus();
			return false;
		}
		break;

	    case "MAIL":
		if (!esMail(objCampo.value)) {
			alert("Dirección de correo no válida.");
			objCampo.focus();
			return false;
		}
		break;

	    case "TELEFONO":
		strAux = esTelefono(objCampo.value);
		if (strAux == "") {
			objCampo.focus();
			return false;
		}
		break;

	    case "EXTFICH":
		if (!esExtFich(objCampo.value,parseInt(opcional1,10))) {
			alert("Extensión no válida.");
			objCampo.focus();
			return false;
		}
		break;

	    case "COMBO":
		break;

	    case "CHECK":
		break;

	    case "RADIO":
		break;
		
	    case "TEXTO":  //validacion de cadenas de texto
	    	break;
		
	    case "NUM_ENTERO":  //validacion de numéricos enteros
	    	if (!esNumeros(trim(objCampo.value))) {
			alert('El valor asignado debe ser numérico entero');
			objCampo.focus();
			return false;
		}		
		if ((opcional1 != undefined) && (parseInt(Math.round(trim(objCampo.value))) < parseInt(Math.round(opcional1)))) {
			if (opcional1 == opcional2){
				alert('El valor asignado debe ser ' + opcional1);
			}else{
				alert('El valor asignado debe ser mayor o igual que ' + opcional1);
			}	
			objCampo.focus();
			return false;
		}
		if ((opcional2 != undefined) && (parseInt(Math.round(trim(objCampo.value))) > parseInt(Math.round(opcional2)))) {
			if (opcional1 == opcional2){
				alert('El valor asignado debe ser ' + opcional2);
			}else{
				alert('El valor asignado debe ser menor o igual que ' + opcional2);
			}	
			objCampo.focus();
			return false;
		}	
	    	break;
	
	
	    case "NUMERICO":  //validacion de numéricos enteros
	    	if (!esNumerico(trim(objCampo.value))) {
			alert('El valor asignado debe ser numérico');
			objCampo.focus();
			return false;
		}
				break;
		
		case "AREA":
			if (trim(objCampo.innerText)=="" && isObligado=="S"){
				alert ("Campo obligatorio. Debe rellenar el valor del campo");
				objCampo.focus();
				return false;
			}
			break;

	    default:  //codigo tipo no valido
	    	return false;
	}

	return true;
}

/***************************************************************************************
 VALIDAR DIRECCION DE CORREO ELECTRONICO
 Segun los siguientes criterios:
	- la cadena contiene una @ y sólo una.
	- la cadena contiene algo antes de la @.
	- la cadena contiene algo después de la @, formado por palabras separadas por puntos.
	- sólo puede contener números, letras o el guión bajo.
***************************************************************************************/
function esMail(variable) {
  //var patron = /^\w+@(\w+\.\w+)+$/;
	var patron = /^[\w|.]+@(\w+\.\w+)+$/;
	return patron.test(variable);
}


/***************************************************************************************
 VALIDAR EXTENSION DE UN FICHERO
 Segun los siguientes criterios:
	- la cadena puede comenzar con un punto.
	- a partir del punto, si existe, no supera un determinado tamaño.
	- sólo puede contener números, letras o el guión bajo.
***************************************************************************************/
function esExtFich(variable,tamMax) {
	var patron = /^\.?\w+$/;
	if (patron.test(variable)) {
		if (variable.substring(0,1) == ".") {
			tamMax++;
		}
		
		if (variable.length > tamMax) {
			return false;
		}
		else {
			return true;
		}
	}
	else {
		return false;
	}
}


/***************************************************************************************
 VALIDAR NUMERO DE TELEFONO
 Segun los siguientes criterios:
	- con prefijo del país: un signo y 11 dígitos numéricos (+XXXXXXXXXXX).
	- sin prefijo del país: 9 dígitos numéricos (XXXXXXXXX).
***************************************************************************************/
function esTelefono(variable) {
	var strAux = trim(variable);
	var tam = strAux.length;
	if ((tam != 9) && (tam != 12)) {
		alert("Número de teléfono no válido.");
		return false;
	} 
	if ((tam == 9) && (!esNumeros(strAux))) {
		alert("Número de teléfono no válido.");
		return false;
	}
	if (tam == 12) {
		var strAux2 = strAux.substring(1,tam);
		if ((strAux.substr(0,1) != "+") || (!esNumeros(strAux2))) {
			alert("Número de teléfono no válido.");
			return false;
		}
	}
	return true;
}


/***************************************************************************************
 VALIDAR NIF
***************************************************************************************/
function esNif(pCif){
	var cif, cif2, A, B,B1,B11,B111,B2,B22,B222,B3,B33,B333,B4,B44,B444,C, D
	var letraInicial, letrasOK, posLetra, strSQL
	var aLetras, strLetraNIF, nDNI
	var salida=true;
	cif=pCif.toUpperCase();

	//si tiene menos de 9 caracteres, chungo
	if (cif.length != 9) {
		alert(pCif+' no es un NIF válido.\n');
		return false;
	}

	// busco si la letra inicial es de un tipo válido
	letraInicial = cif.substr(0,1);
	letrasOk ="ABCDEFGHKLMQS";
	posLetra = letrasOk.indexOf(letraInicial);

	//si el primer caracter no es letra válida, pruebo a ver si es un NIF
	if (posLetra < 0){
		nDNI = cif.substr(0,8);
		aLetras = new Array("T","R","W","A","G","M","Y","F","P","D","X","B","N","J","Z","S","Q","V","H","L","C","K","E");
		
		strLetraNIF = aLetras[nDNI-(Math.floor(nDNI/23) *23)];
		if (strLetraNIF != cif.substr(8,1)) {
			alert(pCif+' no es un NIF válido.\n');
			salida = false;
		}
	}
	else {
		alert(pCif+' no es un NIF válido.\n');
		salida = false;
	}
	return salida;
}	


/***************************************************************************************
 OBTENER SELECCION RADIO-BUTTON
	- Recibe: el objeto grupo de radio-buttons, es decir, el name de los radio-buttons
	- Devuelve una cadena con el value asociado al radio-button seleccionado.
    	  Si no hay ninguno seleccionado devuelve una cadena vacía.
    	  
 Ejemplo de llamada a la funcion:
 	valorRadio('rbtname')
 	donde rbtname es el name de los radio-buttons.   	  
***************************************************************************************/
function valorRadio(objeto) {
	var i = 0;
	var strSel = "";

	if (document.all(objeto)){
		var tam = document.all(objeto).length;
	
		if (isNaN(tam)){
			if (document.all(objeto).checked){
				strSel = document.all(objeto).value;
			}
		}else{
			for (i=0;i<tam;i++) {
				if (document.all(objeto)[i].checked) {
					strSel = document.all(objeto)[i].value;
					break;
				}
			}
		}
	}

	return strSel;
}

/***************************************************************************************
 OBTENER SELECCION RADIO-BUTTON
	- Recibe: el objeto grupo de radio-buttons, es decir, el name de los radio-buttons
	- Devuelve una cadena con el value asociado al radio-button seleccionado.
    	  Si no hay ninguno seleccionado devuelve una cadena vacía.
    	  
 Ejemplo de llamada a la funcion:
 	valorRadio('rbtname')
 	donde rbtname es el name de los radio-buttons.   	  
***************************************************************************************/
function valorRadio(objeto) {
	var i = 0;
	var strSel = "";

	if (document.all(objeto)){
		var tam = document.all(objeto).length;
	
		if (isNaN(tam)){
			if (document.all(objeto).checked){
				strSel = document.all(objeto).value;
			}
		}else{
			for (i=0;i<tam;i++) {
				if (document.all(objeto)[i].checked) {
					strSel = document.all(objeto)[i].value;
					break;
				}
			}
		}
	}

	return strSel;
}

/***************************************************************************************
 OBTENER LA  POSICION DE 1 OBJETO SELECCIONADO DENTRO DE UN CONJUNTO DE  RADIO-BUTTON
	- Recibe: el nombre grupo de radio-buttons, es decir, el name de los radio-buttons
	- Devuelve la posicion del objeto seleccionado en el grupo radio button.
    	  Si no hay ninguno seleccionado devuelve null.
    	  
 Ejemplo de llamada a la funcion:
 	valorRadio('rbtname')
 	donde rbtname es el name de los radio-buttons.   	  
***************************************************************************************/

function positionRadio(objeto) {
		var i = 0;
		var strSel ="";

		if (document.all(objeto)){
			var tam = document.all(objeto).length;

			if (isNaN(tam)){

				if (document.all(objeto).checked){
					strSel = 0;
				}
			}else{

				strSel = "";	

				for (i=0;i<tam;i++) {
					if (document.all(objeto)[i].checked) {
						strSel = i;
						break;
					}
				}
			}
		}

		return strSel;
	}


/***************************************************************************************
 VALIDAR NUMERO DE SELECCIONES EN CONJUNTO DE CHECKBOX
	* Es necesario que el name e id de los objetos checkbox responda al siguiente
	  patrón de numeración secuencial con 0 como índice inicial:
		- name="nombre0"
		- name="nombre1"
		- ...
		- name="nombreX"
	* Recibe:
		- El objeto checkbox salvo el índice: ej. "document.all.nombre".
		- Una cadena con el tipo de validación a aplicar a la selección:
			- "-1": al menos un checkbox seleccionado
			- "0": sin validación
			- "1": exactamente 1 checkbox marcado
			- ...
			- "N": exactamente N checkbox marcado
	* Devuelve una cadena formada por los value de los checkbox seleccionados
	  separdos por el carácter dolar ($).
	  Si no hay ninguno seleccionado devuelve una cadena vacía.
***************************************************************************************/
function validarCheck(nombre,cantidad) {
	var i = 0;
	var strAux = "";
	var cont = 0;
	var esValido = true;
	
	for (i=0;document.all(nombre+i);i++) {
		if (document.all(nombre+i).checked) {
			cont++;
		}
	}

	switch (cantidad) {
		case "-1": //al menos 1
			if (cont == 0) {
				esValido = false;
			}
			break;
		case "0": //sin validar
			break;
		default:
			if (cont != cantidad) {
				esValido = false;
			}
	}
	
	return esValido;
}


/***************************************************************************************
 OBTENER SELECCIONES EN CONJUNTO DE CHECKBOX
	* Es necesario que el name e id de los objetos checkbox responda al siguiente
	  patrón de numeración secuencial con 0 como índice inicial:
		- name="nombre0"
		- name="nombre1"
		- ...
		- name="nombreX"
	* Recibe:
		- El objeto checkbox salvo el índice: ej. "document.all.nombre".
	* Devuelve una cadena formada por los value de los checkbox seleccionados
	  separdos por el carácter dolar ($).
	  Si no hay ninguno seleccionado devuelve una cadena vacía.
***************************************************************************************/
function seleccionCheck(nombre) {
	var strAux = "";
	
	for (var i=0;document.all(nombre+i);i++) {
		if (document.all(nombre+i).checked) {
			if (strAux == "") {
				strAux = document.all(nombre+i).value;
			}
			else {
				strAux = strAux + "$" + document.all(nombre+i).value;
			}
		}
	}
	
	return strAux;
}


/***************************************************************************************
 VERICACION DE SELECCION EN UN COMBO
***************************************************************************************/
function validarCombo(nombreCombo){
	if ( (trim(document.all[nombreCombo].value) == "")){
		alert ("Campo obligatorio, debe seleccionar una opción del combo.")
		document.all[nombreCombo].focus();
		return false;
	}
	else{
		return true;
	}
			
}


/***************************************************************************************
 VERICACION DE SELECCION EN GRUPO RADIO-BUTTONS
***************************************************************************************/
function validarRadio(nombreRadio) {
	var i = 0;
	var esValido = false;
	
	for (i=0;document.all(nombreRadio+i);i++) {
		if (document.all(nombreRadio+i).checked) {
			esValido = true;
			break;
		}
	}
	return esValido;
}


/***************************************************************************************
 CONTROL MAXLENGTH PARA TEXTAREA
***************************************************************************************/
function textCounter(field, maxlimit) {
	cadena = field.innerText;
	cadRep = cadena.replace(/[\n|\r]+/g,"%&");
	if (cadRep.length > maxlimit) {
		aux = cadRep.substr(maxlimit-1,2);
		aux2 = "";
		if (aux=="%&"){
			aux2 = cadRep.substring(0,maxlimit-1);
		}else{
			aux2 = cadRep.substring(0,maxlimit);
		}
		field.innerText= aux2.replace(/%&/g,"\n");
	}
}


/*****************************************************************************************
FORMATEO DE MINUTOS:SEGUNDOS: MM -> MM:SS
        * formatMinutos(minutos)-> MM 
	* formatResto(minutos)  -> SS
******************************************************************************************/
function formatMinutos(minutos){
	var indice = minutos.indexOf(":")
	if (indice > 0){
      		var aux=minutos.split(":");		  
		var resultadoMinutos=trim(aux[0]);		
		return resultadoMinutos;	
	}else{
		return "";
	}	
}

function formatResto(minutos){
      
      	var indice = minutos.indexOf(":")
	if (indice > 0){
      		var aux=minutos.split(":");		  
		var segundos=trim(aux[1]);		
		return segundos;
	}else{
		return "";
	}	
}


/********************************************************************************************
FORMATEA LOS SEGUNDOS A MINUTOS: SS-> MM:SS
*********************************************************************************************/
function pasarSegundosMinutos(segundos){
    var resto = 0;
    var strResto = "";
    var minutos = 0;
    var strminutos = "";
    resto = segundos % 60;
    minutos = (segundos - resto ) / 60;
    
    if (resto < 10){
      strResto = "0" + resto;
    }else{
      strResto = resto;
    } 
    strminutos = minutos;
                
    resultado = strminutos + ":" + strResto
    return resultado;
  }


/********************************************************************************************
FORMATEA LOS MINUTOS A SEGUNDOS: MM:SS -> SS
*********************************************************************************************/  
function pasarMinutosSegundos(minutos, segundos){
    intMinutos = parseInt(minutos, 10) * 60    
    intSegundos = parseInt(segundos, 10)    
    var intResultado= 0;    
    intResultado = intMinutos + intSegundos
    return intResultado      
}


/***************************************************************************************
 OBTENER OBJETOS VISIBLES EN CONJUNTO DE ELEMENTOS
	* Es necesario que el name e id de los objetos responda al siguiente
	  patrón de numeración secuencial con 0 como índice inicial:
		- name="nombre0"
		- name="nombre1"
		- ...
		- name="nombreX"
	* Recibe:
		- El name/id del objeto salvo el índice
		- El número de checkbox que forman parte del grupo.
	* Devuelve una cadena formada por los value2 de los objetos seleccionados
	  separdos por el carácter dolar ($).
	  Si no hay ninguno seleccionado devuelve una cadena vacía.
***************************************************************************************/
function objVisibles(nombre) {
	var strAux = "";
	
	for (var i=0;document.all(nombre+i);i++) {
		if (document.all(nombre+i).style.display != "none") {
			if (strAux == "") {
				strAux = document.all(nombre+i).value2;
			}
			else {
				strAux = strAux + "$" + document.all(nombre+i).value2;
			}
		}
	}
	
	return strAux;
}

//*****************************************************
// Función que valida que un CIF sea válido
//*****************************************************
function esCIF2(CIF) 
{
  var v1 = new Array(0,2,4,6,8,1,3,5,7,9); 
  var temp = 0; 
  var temp1;
  
  //comprobar de los datos
  var temp2 = CIF.value.toUpperCase(); // pasar a mayúsculas

  if (!/^[A-Za-z0-9]{9}$/.test(temp2))  return false; // Son 9 dígitos? 
  else if (!/^[ABCDEFGHKLMNPQS]/.test(temp2)) return false;// Es una letra de las admitidas ?
  
  for( i = 2; i <= 6; i += 2 ){
     temp = temp + v1[ parseInt(CIF.value.substr(i-1,1)) ];
     temp = temp + parseInt(CIF.value.substr(i,1));
  };

  temp = temp + v1[ parseInt(CIF.value.substr(7,1)) ];
  temp = (10 - ( temp % 10));

  var ultima = CIF.value.substr(8,1);

  if( temp == 10 ){
    if((ultima == "J")||(ultima == "0"))return true;
    else return false;
  }
  else{
  	if(ultima == temp)return true;
    else return false;
  }
}

/***************************************************************************************
 VALIDAR NIF
***************************************************************************************/
function esDNI(pCif){

	var cif, cif2, A, B,B1,B11,B111,B2,B22,B222,B3,B33,B333,B4,B44,B444,C, D
	var letraInicial, letrasOK, posLetra, strSQL
	var aLetras, strLetraNIF, nDNI
	var salida=true;
	var auxDNI = "";
	
	cif=pCif.toUpperCase();

	//si tiene menos de 9 caracteres, chungo

	if (cif.length != 9) {		
		if (cif.length < 9) {
			for (var i=1; i<=(9-cif.length); i++){
				auxDNI = auxDNI + "0";
			}
			auxDNI = auxDNI + cif;
			cif = auxDNI;
		}else{
			return false;			
		}		
	}


	// busco si la letra inicial es de un tipo válido
	letraInicial = cif.substr(0,1);
	letrasOk ="ABCDEFGHKLMQS";
	posLetra = letrasOk.indexOf(letraInicial);

	//si el primer caracter no es letra válida, pruebo a ver si es un NIF
	if (posLetra < 0){
		nDNI = cif.substr(0,8);
		aLetras = new Array("T","R","W","A","G","M","Y","F","P","D","X","B","N","J","Z","S","Q","V","H","L","C","K","E");

		strLetraNIF = aLetras[nDNI-(Math.floor(nDNI/23) *23)];
		if (strLetraNIF != cif.substr(8,1)) {
			salida = false;
		}
	}
	else {		
		salida = false;
	}
	return salida;
}		

/***************************************************************************************
 VALIDAR NIE
***************************************************************************************/
//Validacion NIE
//           Reglas
//                   a)Primer caracter debe ser 'X'
//		     b)Longitud de al menos 9 caracteres
//		     c)Desde el segundo caracter hasta el final debe ser un NIF.
function esNIE(strTexto){
var strNIE;
strNIE=strTexto.toUpperCase();	//a mayusculas
	
	//comprobacion de menos de 9 caracteres
	if (strNIE.length < 9) {		
		return false;
	}
	//comprobacion de primer caracter una 'X'
	if  (strNIE.substr(0,1)!="X"){
			return false;
	}
	
	return (esDNI(strNIE.substr(1, strNIE.length - 1)));
}


function CompruebaDatos(elCIF) 
{
  var resul = false;
  var temp = elCIF.toUpperCase(); // pasar a mayúsculas

  if (!/^[A-Za-z0-9]{9}$/.test(temp))  // Son 9 dígitos? 

     alert ("Longitud incorrecta, un CIF consta de 9 dígitos");

  else if (!/^[ABCDEFGHKLMNPQS]/.test(temp)) // Es una letra de las admitidas ?

     alert("El primer dígito es incorrecto, debe ser una letra de las siguientes: A,B,C,D,E,F,G,H,K,L,M,N,P,Q,S ");

  else 

     resul = true;

  return resul;
}

// La función recibe el CIF completo: A58818501
function ValidaCIF(elCIF) 
{

  var v1 = new Array(0,2,4,6,8,1,3,5,7,9); 
  var temp = 0; 
  var temp1;

  
  for( i = 2; i <= 6; i += 2 ) 
    {
      temp = temp + v1[ parseInt(elCIF.substr(i-1,1)) ];
      temp = temp + parseInt(elCIF.substr(i,1));
    };

  temp = temp + v1[ parseInt(elCIF.substr(7,1)) ];

  temp = (10 - ( temp % 10));

  if (temp != elCIF.substr(8,1)){
  	alert( "Cif erroneo"); 
  	return false;
  }

  return true;
}


function obtenerDigito(valor){
  valores = new Array(1, 2, 4, 8, 5, 10, 9, 7, 3, 6);
  control = 0;
  for (i=0; i<=9; i++)
    control += parseInt(valor.charAt(i)) * valores[i];
  control = 11 - (control % 11);
  if (control == 11) control = 0;
  else if (control == 10) control = 1;
  return control;
}

function validarCCC(cuentaComp) {
	if (cuentaComp.length!=20){
		return false;
	}
	
	if (!esNumeros(cuentaComp)) {
			return false;
	}
	
	var banco=cuentaComp.substring(0,4);
	var sucursal=cuentaComp.substring(4,8);
	var dc=cuentaComp.substring(8,10);
	var cuenta=cuentaComp.substring(10);
        if (!(obtenerDigito("00" + banco + sucursal) ==
              parseInt(dc.charAt(0))) || 
            !(obtenerDigito(cuenta) ==
              parseInt(dc.charAt(1)))){
			return false;
	    }else{
		  return true;
		 }
}


/*
Script para comprobar la validez de
un CIF en España (incluso para sociedades)
*/ 
function esCIF(cif)
{
	//Comprueba que tenga 9 dígitos, el primero debe ser una letra y el resto números

	if (!/^([A-Z]\d{8})|([PX]\d{7}[A-J])$/.test(cif.toUpperCase()))
	{
		return false;
	}

	//Comprueba que la letra sea una de las posibles
	if (!/^[ABCDEFGHKLMPQSX]/.test(cif.toUpperCase()))
	{
	return false;
	}
	
	//Comprueba el dígito de control del CIF
	return ComprobarDigitoControlCIF(cif);
}

/*
La siguiente función se encarga de validar el dígito de control
*/
function ComprobarDigitoControlCIF(cif)
{
var arrayCIF
var sumaDigitosPares = 0;
var sumaDigitosImpares = 0;
var numero;
var arrayNumero;
var digitoControl;

//mete el cif en un array
arrayCIF = cif.split("");

//Si no tiene 9 caracteres es incorrecto
if (arrayCIF.length != 9)
{
return false;
}

//Suma los dígitos pares de la cadena resultante de quitar el primer y último caracter del CIF
for(i = 2; i < arrayCIF.length - 1; i = i + 2)
{
sumaDigitosPares = sumaDigitosPares + parseInt(arrayCIF[i]);
}

//Multiplicar por 2 los dígitos impares de la cadena resultante de quitar el primer y último caracter del CIF
//y con cada resultado, sumar sus dígitos. 
//Sumarlo todo
for(i = 1; i < arrayCIF.length - 1; i = i + 2)
{
numero = arrayCIF[i] * 2;
if (numero > 9)
{
numero = (numero % 10) + 1
}

sumaDigitosImpares = sumaDigitosImpares + numero;
}

//Sumar la suma de dígitos pares y la de dígitos impares
//Coger la última cifra del número obtenido y restarle 10
numero = sumaDigitosPares + sumaDigitosImpares 
for (i = numero; i >= 0; i = i - 10)
{
numero = i;
}
digitoControl = 10 - numero;

//Para los tipos de sociedades P y X el dígito de control debe ser una letra
if (arrayCIF[0].toUpperCase() == "P" || arrayCIF[0].toUpperCase() == "X")
{
digitoControl = String.fromCharCode(digitoControl + 64);
} 

//Comprueba si el dígito de control se corresponde correctamente
if (digitoControl.toString() == arrayCIF[8])
{
return true;
}
else
{
return false;
}
}