/***************************************************************************************************
  Fichero:     FuncionesValidacion.js
  Fecha:       07-05-2002
  Descripcion: Libreria de funciones de cliente para la validación de una página web 
***************************************************************************************************/



/****************************************************************************************
  Nombre: SubmitForm
  Fecha: 21/11/2002 (17:51)
  Descripcion: Esta función se encarga de comprobar todos los campos de formulario
  				antes de hacer el submit
  Entrada: objeto Formulario, podemos llamarlo en la llamada con this
           pFuncionComprobacion: Nombre de otra funcion de Comprobacion [formato.- nomFuncion()]
  Salida: TRUE  -> se lanza el formulario hacia el action de dicho objeto
  		  FALSE -> debemos capturarlo mediante return, para que no se lanze el action
  Como Usarlo: lanzarlo en el evento onSubmit del formulario HTML, ejemplo:

    <FORM onsubmit="return SubmitForm(this);" action="direccion.asp" name="formulario">    				
     o con 2 argumentos:
  	<FORM onsubmit="return SubmitForm(this,nomFuncion());" action="direccion.asp" name="formulario">    				

*****************************************************************************************/

function SubmitForm(objForm,pFuncionComprobacion)
{
  if (ValidarFormulario(objForm.name)) 
    if (arguments.length == 2)
	   if (pFuncionComprobacion) 
	     objForm.submit();
	   else
	     return false;	 
	else
	    objForm.submit();
  else
    return false;
 return false; 
}


/**************************************************************************************************
  Nombre: ValidarDniYPin
  Fecha: 16/10/2002 (13:03)
  Descripcion: Esta función se encarga de validar un DNI y un PIN
  Entrada:
    - p_in_fFormulario: formulario, en la llamada se le pasa "this"
	- p_in_nDni: nombre del campo DNI
	- p_in_nPin: nombre del campo Pin
  Salida: Devuelve TRUE si son valores validos y FALSE en caso contrario
**************************************************************************************************/

  function ValidarDniYPin(p_in_fFormulario, p_in_nDni, p_in_nPin)
  {
	var f = p_in_fFormulario
	  
	if(!ValidaVacio(f[p_in_nDni], "DNI"))
	  return false;
	  
	if(!ValidaNumerico(f[p_in_nPin], "PIN") || !ValidaVacio(f[p_in_nPin], "PIN"))
	  return false;

	return true;
  }

/***************************************************************************************************
  Nombre: ValidarFormulario
  Fecha: 07-05-2002 (08:20)
  Última Modificación: [22/11/2002 (11:02)] - Víctor Manuel Álvarez Álvarez (vmalvarez@umh.es)
  Descripción: Función que sirve para validar que todos los campos de texto de un formulario deben
    tener valor. 
  Entrada: 
    - formulario: Nombre del formulario que queremos validar
  Salida: 
  Observaciones: Para que funcione esta función los campos del formulario q queramos validar deben
    de tener un nombre con un prefijo determinado, según el tipo:
	  fecha: 
	  		prefijo "date_sn" + nombre del campo.
			prefijo "date_nn" + nombre del campo.
	  email: 
	  		prefijo "mail_sn" + nombre del campo.
			prefijo "mail_nn" + nombre del campo.
	  dni:   
	  		prefijo "ndni_sn" + nombre del campo.
			prefijo "ndni_nn" + nombre del campo.
	  texto: 
	  		prefijo "text_sn" + nombre del campo.
			prefijo "text_nn" + nombre del campo.
	  text_Area: 
	  		prefijo "area_sn" + nombre del campo.
			prefijo "area_nn" + nombre del campo.
      telefono/fax:
	  		prefijo "telf_sn" + nombre del campo.
			prefijo "telf_nn" + nombre del campo.
	  			
	los prefijos terminados en _sn _nn indican respectivamente si el campo puede contener NULOS [sn]
	o NO [nn]

***************************************************************************************************/

function ValidarFormulario(formulario)
{
  var f = document[formulario];
		
		var sInicioMensaje = 'Please, fill in the field called ';
		var sFinalMensaje = ' for sending the form';
		
  for(var i=0; i<f.elements.length; i++) 
  {
    var cadena = new String(f.elements[i].name).toLowerCase();
	
	var tipoCampo    = cadena.substring(0, 5);
	var nuloCampo    = cadena.substring(5,8);
	var nombreCampo  = cadena.substring(8, cadena.length).toUpperCase();

    switch(tipoCampo)
	{
	  case "date_":  // Validación de campos tipo FECHA
        switch(nuloCampo)
		{
		  case "nn_":
            if(f.elements[i].value.length == 0) {

    	      Error(f.elements[i], sInicioMensaje + nombreCampo + sFinalMensaje);
      	      return false;
	        }
		    else if(!ValidaFecha(f.elements[i]))
	          return false;
		    break;
		  case "sn_":
		    if(!ValidaFecha(f.elements[i]))
	          return false;
			break;
		}
		break;	
	  case "mail_": // Validación de campos tipo DIRECCION E-MAIL
        switch(nuloCampo)
		{
		  case "nn_":
		    if(f.elements[i].value.length == 0){
    	      Error(f.elements[i], sInicioMensaje + nombreCampo + sFinalMensaje);
      	      return false;
	        }
			else if(!ValidaEmail(f.elements[i]))
	          return false;
			break;
		  case "sn_":

		    if(!ValidaEmail(f.elements[i]))
	          return false;
			break;
		}
		break;
	  case "ndni_": // Validación de campos tipo NIF
        switch(nuloCampo)
		{
		  case "nn_":
            if(f.elements[i].value.length == 0){
    	      Error(f.elements[i], sInicioMensaje + nombreCampo + sFinalMensaje);
      	      return false;
	        }
		    else if(!ValidaNif(f.elements[i]))
	          return false;
		    break;
		  case "sn_":
		    if(!ValidaNif(f.elements[i]))
	          return false;
			break;
		}
		break;
	  case "telf_": // Validación de campos tipo Telefono / FAX
        switch(nuloCampo)
		{
		  case "nn_":
            if(f.elements[i].value.length == 0)
			{
    	      Error(f.elements[i], sInicioMensaje + nombreCampo + sFinalMensaje);
      	      return false;
	        }
		    else if(!ValidaTelefono(f.elements[i], nombreCampo))
	          return false;
		    break;
		  case "sn_":
			if(!ValidaTelefono(f.elements[i], nombreCampo))
	          return false;
			break;
		}
		break;

	  case "text_": // Validación de campos tipo TEXTO
        switch(nuloCampo)
		{
		  case "nn_":
            if(f.elements[i].value.length == 0) {
    	      Error(f.elements[i], sInicioMensaje + nombreCampo + sFinalMensaje);
      	      return false;
	        }
		    break;
		}
		break;
		
	  case "area_": // Validación de campos tipo TEXT_AREA
      {
        switch(nuloCampo)
		{
		  case "nn_":
            if(f.elements[i].value.length == 0) {
    	      Error(f.elements[i], sInicioMensaje + nombreCampo + sFinalMensaje);
      	      return false;
	        }
		    break;
		}

		if (!ValidaLongitudTextArea(f.elements[i]))
		  return false; 	
		break;
      }
	}
  }
  return true;
}

/***************************************************************************************************
  Nombre: ValidaFecha
  Fecha: 07-05-2002 (09:30)
  Descripción: Función que sirve para validad si una fecha tiene el formato correcto. 
  Observaciones: Soporta solo formato dd/mm/aaaa, meses mayores de 30 y bisiestos
  Entrada: 
    - campo: campo que queremos validr
  Salida: Devuelve TRUE si la fecha es valida y FALSE en caso contrario
****************************************************************************************************/

function ValidaFecha(campo)
{
  var fecha = campo.value;
  var estado = 0;
  var partes = new Array("", "", "");

  if (fecha == "")
	return true;

  for (var i = 0; i < fecha.length; i++)
  {
	var c = fecha.substring(i, i + 1);
	if (estado > 2 || (c < "0" || c > "9") && c != "/")
	  return Error(campo, "Fecha incorrecta");
	if (c == "/")
	  estado ++;
	else
	  partes[estado] += c;
  }

  if (estado != 2)
	return Error(campo, "Fecha incorrecta");

  var maxDia = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
  var dd, mm, yy;
  dd = parseInt(partes[0], 10);
  mm = parseInt(partes[1], 10);
  aa = parseInt(partes[2], 10);
  if (isNaN(dd) || isNaN(mm) || isNaN(aa))
	return Error(campo, "Fecha incorrecta");

  //Comprobar año
  if (aa < 1900 || aa > 2100)
    return Error(campo, "Año de la fecha incorrecto");
  if (aa % 4 == 0)
	maxDia[1] ++;

  //Comprobar mes
  if (mm < 1 || mm > 12)
	return Error(campo, "Mes de la fecha incorrecto");

  //Comprobar dia
  if (dd < 1 || dd > maxDia[mm - 1])
	return Error(campo, "Día de la fecha incorrecto");

  return true;
}

/****************************************************************************************
  Nombre: ValidaTelefono
  Fecha: 22/11/2002 (12:14)
  Descripcion: Esta función se encarga de validar si un campo puede ser un número de telefono
  Entrada: 
    - [in] campo: campo del formulario. Se utiliza como f.campo
	- [in] nombre: nombre que queremos que aparezca si se produce un mensaje de error.
  Salida: Devuelve TRUE en caso de que sea válido y FALSE en caso contrario
*****************************************************************************************/

function ValidaTelefono(campo, nombre)
{
  var telefono = campo.value;
  var estado = 0;
  var partes = new Array("", "", "");

  if (telefono == "")
	return true;
	
  if (!nombre)
	if (!ValidaNumerico(campo))
      return false;
  else
	if (!ValidaNumerico(campo, nombre))
      return false;

  return true;
}

/***************************************************************************************************
 Nombre: Error
 Fecha: 07/05/2002 (12:09)
 Descripcion: Esta función muestra un mensaje de error y pone el foco en el campo que le pasamos
   como parámetro.
 Entrada:
   - campo: campo sobre el se ve va a poner el foco
   - msj: mensaje de error que se va a mostrar con un alert
 Salida: Devuelve false siempre   
****************************************************************************************************/

function Error(campo, msj)
{
  alert(msj);
  campo.focus();
  return false;
}

/***************************************************************************************************
  Nombre: ValidaNumerico
  Fecha: 07/05/2002 (14:59)
  Descripcion: Función que realiza la validación de un campo numerico
  Entrada: 
    opcional: cadena que especifica la etiqueta del campo (para dar mejor el error)
	  Por defecto, nombre del control
  Salida: Devuelve TRUE si es numérico y FALSE en caso contrario
****************************************************************************************************/

function ValidaNumerico(campo, nombre, longitud)
{
  var c = campo.value

  if (c == "")
    return true;
	
  if (!longitud)
    longitud = c.length;
        
  if (!nombre)
    var nom = campo.name
  else
    var nom = nombre

  if (c.length != longitud)
	return Error(campo, "El campo " + nom.toUpperCase() + " debe tener una longitud de " + longitud + " caracteres")

  for (var i = 0; i < c.length; i++)
  {
    if (c.substring(i, i + 1) < "0" || c.substring(i, i + 1) > "9")
 	  return Error(campo, "El campo " + nom + " debe ser numérico");
  }

  return true;
}

/**************************************************************************************************
  Nombre: ValidaAlfanumerico
  Fecha: 24/10/2002 (10:39)
  Descripcion: Validacion de digitos alfanumericos
  Entrada:
    - campo: campo que queremos validar
    - nombre [opcional]: cadena que especifica la etiqueta del campo (para dar mejor el error)
 	    Por defecto, nombre del control
	- longitud [opcional]: entero que indica el numero de digitos.
  Salida: Devuelve true si es válido y false en caso contrario
**************************************************************************************************/

function ValidaAlfanumerico(campo, nombre, longitud)
{
	var c = campo.value;
	
	if (c == "")
		return true;
	
	if (!longitud)
		longitud = c.length;
        
    if (!nombre)
        var nom = campo.name
    else
        var nom = nombre

	if (c.length != longitud)
		return Error(campo, "El campo " + nom.toUpperCase() + " debe tener una longitud de " + longitud + " caracteres")

	for (var i = 0; i < longitud; i++)
	{
		var d = c.substring(i, i + 1)
		if ((d < "0" || d > "9") && (d < "A" || d > "Z") && (d < "a" || d > "z"))
			return Error(campo, "El campo " + nom.toUpperCase() + " solo puede contener números y letras"); 
	}

	return true
}

/**************************************************************************************************
  Nombre: EsVacio
  Fecha: 23/09/2002 (10:34)
  Descripcion: Esta función devuelve true si el campo es vacio y false en caso contrario
  Entrada: 
  	- campo: campo que vamos a comprobar
  Salida: Devuelve TRUE si el campo es VACIO y FALSE en caso contrario
**************************************************************************************************/

function EsVacio(campo)
{
  if(campo.value == "")
    return true;
  
  return false;
}

/**************************************************************************************************
  Nombre: ValidaVacio
  Fecha: 23/09/2002 (10:34)
  Descripcion: Esta función devuelve true si el campo es vacio y false en caso contrario
  Entrada: 
	- campo: campo que vamos a comprobar
	- nombre: Nombre del campo que queremos que aparezca en el mensaje de error
  Salida: Devuelve TRUE si el campo es VACIO y FALSE en caso contrario
**************************************************************************************************/

function ValidaVacio(campo, nombre)
{
  if(campo.value == "")
  {
    var booleano = Error(campo, "El campo " + nombre + " no puede estar vacio");    
	return false;
  }
  return true;
}

/***************************************************************************************************
  Nombre: ValidaDecimal
  Fecha: 07/05/2002 (15:01)
  Descripcion: Función que realiza la validacion de campo decimal
  Entrada:
	- campo: campo a validar
	- minimo: rango menor
	- maximo: rango mayor
	- nombre: [opciona] cadena que especifica la etiqueta del campo (para dar mejor el error)
   	    Por defecto, nombre del control
	- numeroDecimales: numero de decimales que admite
  Salida: Devuelve TRUE si el campo es decimal y false en caso contrario
****************************************************************************************************/

function ValidaDecimal(campo, nombre, minimo, maximo, numeroDecimales) 
{
  var	numero	= new Array();
  var n	= campo.value.replace(/\,/gi,".");

  if (campo.value == "")
    return true;

  if (!nombre)
    var nom = campo.name;
  else
    var nom = nombre;

  numero = campo.value.replace(/\./gi,",").split(",");

  for (var i = 0; i < numero[0].length; i++) 
  {
	if (numero[0].substring(i, i + 1) < "0" || numero[0].substring(i, i + 1) > "9")
	  if (numeroDecimales > 0)
	    return Error(campo, "El campo " + nombre + " debe ser numérico con separador de decimales la coma \',\'");
	  else
		return Error(campo, "El campo " + nombre + " debe ser numérico.");
  }

  if (numero.length > 1) 
  {
	if (numero[1].length <= numeroDecimales || !numeroDecimales) 
	{
	  for (var i = 0; i < numero[1].length; i++) 
	  {
	    if (numero[1].substring(i, i + 1) < "0" || numero[1].substring(i, i + 1) > "9")
		  return Error(campo, "El campo " + nombre + " debe ser numérico");
	  }
	}
	else 
	{
	  return Error(campo, "El campo " + nombre + " debe tener como máximo " + numeroDecimales + " número de decimales");
	}
  }

  if (minimo)
    if (Number(n) < Number(minimo))
	  return Error(campo, "El campo " + nombre + " debe de ser mayor o igual a " + minimo);

  if (maximo)
	if (Number(n) > Number(maximo))
 	  return Error(campo, "El campo " + nombre + " debe de ser menor o igual a " + maximo);
  
  return true
}

/***************************************************************************************************
  Nombre: ValidaNif
  Fecha: 07/05/2002 (16:44)
  Descripcion: Validacion del N.I.F. con la letra y todo
  Entrada: 
    - campo: campo donde se encuentra el NIF a validar
****************************************************************************************************/

function ValidaNif(campo)
{
  var nif = campo.value;
  if (campo.value == "")
    return true;

  var i = 0;
  var j = nif.length;
  var letra;
  
  letra = nif.substring(i, i + 1).toLowerCase();
  if (letra < "0" || letra > "9")
  {
	i ++;
	if ((letra < "a" || letra > "h") && letra != "p" && letra != "q" && letra != "r" && letra != "x" && letra != 's'
 		  && letra != "n" && letra != "k" && letra != "l" && letra != "m")

  	  return Error(campo, "Letra del DNI/NIF incorrecta");
	}
	
	if (i == 0 || letra == "x")
	{
	  letra = nif.substring(j - 1, j).toLowerCase();
	  if (letra < "0" || letra > "9")
	  {
		j --;
		var letrasNif = 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", "t");
			if (letrasNif[parseInt(nif.substring(i, j), 10) % 23] != letra)
				return Error(campo, "Letra del DNI/NIF incorrecta");
		}
	}
	
	letra=nif.substring(j-1,j).toLowerCase();
	
	if (letra < "0" || letra > "9")
	  nif=nif.substring(i, j-1);
	else
  	  nif=nif.substring(i, j);
	
	if (nif.length > 8 || nif.length < 1)
	  return Error(campo, "DNI/NIF incorrecto")
	for (var i = 0; i < nif.length; i++)
	{
	  if (nif.substring(i, i + 1) < "0" || nif.substring(i, i + 1) > "9")
	    return Error(campo, "DNI/NIF incorrecto")
	}
	return true
}

/***************************************************************************************************
  Nombre: ValidaEmail
  Fecha: 07/05/2002 (18:25)
  Descripcion: Función que sirve para validar una dirección de correo electronico
  Entrada: 
    - campo: campo donde se encuentra la dirección de correo a validar
****************************************************************************************************/

function ValidaEmail(campo)
{
  var email = campo.value
  if (email == "")
	return true;

  var reg = /^.+\@(\[?).+\.([a-zA-Z]{2,3}|[0-9]{1,3})(\]?)$/
  if (!reg.test(email))
	return Error(campo, "Wrong e-mail address");
  else
	return true;
}

/**************************************************************************************************
  Nombre: ValidaTamanyo
  Fecha: 06/05/2003 (13:13)
  Descripcion: Esta función se encarga de comprobar si el tamanyo del campo no supera el tamanyo
    que le pasamos como parámetro
  Entrada:
    - [in] p_objCampo: objeto del campo que queremos comprobar. Se utiliza f.campo
	- [in] p_iTamanyoMaximo: tamaño máximo que puede tener el campo
	- [in] p_sNombre: nombre del campo
  Salida:
**************************************************************************************************/

function ValidaTamanyo(p_objCampo, p_iTamanyoMaximo, p_sNombre)
{
  var sNombre, sValorCampo;
  var sValorCampo = p_objCampo.value;
  var iLongitud   = sValorCampo.length;

  // Si no le pasamos el nombre del campo entonces cogemos el nombre del objeto
  
  if (!p_sNombre)
    var sNombre = p_objCampo.name;
  else
    var sNombre = p_sNombre;
	
  // Comprobamos que la longitud del campo sea menor al tamanyo máximo	

  if (iLongitud > p_iTamanyoMaximo)
	return Error(p_objCampo, "El campo " + sNombre + " no puede superar los " + p_iTamanyoMaximo + " caracteres.\nActualmente tiene " +  iLongitud + " caracteres.");
  
  return true;
}

/**************************************************************************************************
  Nombre: ValidaLongitudTextArea
  Fecha: 19/05/2003 (10:47)
  Descripcion: Esta función se encarga de controlar la longitud del TEXT AREA para que no supere
    el número máximo de caracteres, que vendrá determinado por el valor de la propiedad maxlegth
	del TEXT AREA. La función hay que programarla, por ejemplo, mediante el evento onKeyPress 
	del TextArea, para que en cada pulsación comprobemos si se ha superado el límite.
	
	Ejemplo de llamada: 
	
	<textarea ..... maxlength="4000" ..... onkeypress=' ValidaLongitudTextArea(this);' ....></textarea>

  Entrada:
    - [in] p_objCampo: obj del campo del text area

  Salida: Devuelve TRUE si el tamñano es correcto y FALSE en caso contrario
**************************************************************************************************/

function ValidaLongitudTextArea(p_objCampo)
{
  //alert("holas");
		if (p_objCampo.value.length >= p_objCampo.maxlength) 
  {
    p_objCampo.value = p_objCampo.value.substring( 0, p_objCampo.maxlength - 1 );
    return Error(p_objCampo, 'Este campo solo admite ' + p_objCampo.maxlength + ' caracteres'); 
				//alert( 'Este campo solo admite ' + p_objCampo.maxlength + ' caracteres.' );
    //return false;
  }
  return true;
}