// JavaScript Document
/***************************************************************************************
*función carctres_espcles(casilla)														*
*     Util para verificar caracteres especiales en los textos de un formulario			*
*IN: casilla a verificar                              									*
*OUT: verdadero si no hay error, falso y desplegado de error si encuentra alguno		*                     			   
***************************************************************************************/
function carctres_espcles(casilla)
{	if (casilla.value.length==0)
		return true;
	if(casilla.value.indexOf("/")!==(-1)||
	   casilla.value.indexOf("*")!==(-1)||
	   casilla.value.indexOf("{")!==(-1)||
	   casilla.value.indexOf("}")!==(-1)||
	   casilla.value.indexOf("?")!==(-1)||
	   casilla.value.indexOf("¿")!==(-1)||
	   casilla.value.indexOf("[")!==(-1)||
	   casilla.value.indexOf("]")!==(-1)||
	   casilla.value.indexOf("\"")!==(-1)||
	   casilla.value.indexOf("\'")!==(-1)||
	   casilla.value.indexOf("$")!==(-1)||
	   casilla.value.indexOf("&")!==(-1)||
	   casilla.value.indexOf("=")!==(-1)||
	   casilla.value.indexOf("@")!==(-1)||
	   casilla.value.indexOf("#")!==(-1))
	   {
	    error(20);
		casilla.select();
		casilla.focus();
		return false;
	    }
	else
		return true;
}
/****************************************************************************************************
*función quitaEspcios(cadna)																		*
*     Util para eliminar los espacios en blanco a la izquierda de los campos text de formulario		*
*IN: casilla a verificar                			              									*
*OUT: se eliminan los espacios en blanco a la izquierda de la casilla seleccionada					*                     			   
*****************************************************************************************************/
function quitaEspcios(cadna)
{
    cuenta=0;	
	for(pos=0;pos<cadna.value.length;pos++)
	{
		if (cadna.value.charAt(pos)==' '){
			cuenta+=1;
		}
	}
    if(cadna.value.length==cuenta && cuenta!=0){
		error(43);
		cadna.select();
		cadna.focus();
		return true;	
	}
	else{
		return false;
	}
}
/***************************************************************************************
*function verfcaNumro(numro)															*
*     Util para verificar si existen caracteres alfabeticos en un campo numerico		*
*IN: casilla a verificar                              									*
*OUT: verdadero si la casilla contiene solo números, falso y desplegado de error si 	*
*	tiene carcateres no númericos														*
***************************************************************************************/
function verfcaNumro(numro)
{	   
	for (pos=0;pos<numro.value.length;pos++)
		{	
			a=pos*1;
			carctrActual=numro.value.charAt(a);
			if(isFinite(carctrActual)==true){}
			else
			{
				error(19);
				numro.select();
				numro.focus();
				return false;
			}
		} 
		return true;
}
/***************************************************************************************
*function esFlotante(numro)															*
*     Util para verificar si es ingresado un número flotante en el formato especificado	*
*IN: casilla a verificar                              									*
*OUT: verdadero si la casilla contiene solo números y  un punto, falso y desplegado de error si 	*
*	tiene carcateres no númericos														*
***************************************************************************************/
function esFlotante(numro){
	puntos=0
	numDespPun=0
	for (pos=0;pos<numro.value.length;pos++)
		{	
			a=pos*1;
			carctrActual=numro.value.charAt(a);
			if(isFinite(carctrActual)==true){
			//es numerico	
			}
			else
			{
				 
				
				
				if(carctrActual=='.'){
				puntos+=1;	
				}
				else{
					if(carctrActual=='-' && pos==0){
					//es un menos
					} else {
						if(carctrActual=='-' && pos!=0)
						{
							alert('Error al ingresar el signo "-"');
							numro.select();
							numro.focus();
							return false;
						} else {
							error(19);
							numro.select();
							numro.focus();
							return false;
						
						}
					
					} 
					
					
					
				}
			}
		}
		
		if(puntos>1)
		{
		 //no puede tener mas de un punto
		 error(44);
		 numro.select();
		 numro.focus();
		 return false;
		}
		
		if(puntos==1 && numro.value.charAt(a)=='.'){
			//no ingreso decimales despues del punto
			 error(45);
			 numro.select();
			 numro.focus();
			 return false;
		}
		
		return true;
}

/***************************************************************************************
*function verfcaNombre(nombre)															*
*     Util para verificar si existen caracteres numericos en un campo alfabetico		*
*IN: casilla a verificar                              									*
*OUT: verdadero si no hay error, falso y desplegado de error si encuentra alguno		*                     			   
***************************************************************************************/
function verfcaNombre(nombre)
{	   
	for (pos=0;pos<nombre.value.length;pos++)
		{	
			a=pos*1;
			carctrActual=nombre.value.charAt(a);
			if(isFinite(carctrActual)==false || carctrActual==' '){}
			else
			{
				error(18);
				nombre.select();
				nombre.focus();
				return false;
			}
		} 
		return true;
}
//-----------------------------Esta es la parte que sirve para validar correo------------------------------------------
<!-- Changes:  Sandeep V. Tamhankar (stamhankar@hotmail.com) -->

/* 1.1.2: Fixed a bug where trailing . in e-mail address was passing
            (the bug is actually in the weak regexp engine of the browser; I
            simplified the regexps to make it work).
   1.1.1: Removed restriction that countries must be preceded by a domain,
            so abc@host.uk is now legal.  However, there's still the 
            restriction that an address must end in a two or three letter
            word.
     1.1: Rewrote most of the function to conform more closely to RFC 822.
     1.0: Original  */

<!-- This script and many more are available free online at -->
<!-- The JavaScript Source!! http://javascript.internet.com -->

<!-- Begin
function verfcaCorreo(emailStr){
/* The following pattern is used to check if the entered e-mail address
   fits the user@domain format.  It also is used to separate the username
   from the domain. */
var emailPat=/^(.+)@(.+)$/;
/* The following string represents the pattern for matching all special
   characters.  We don't want to allow special characters in the address. 
   These characters include ( ) < > @ , ; : \ " . [ ]    */
var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";
/* The following string represents the range of characters allowed in a 
   username or domainname.  It really states which chars aren't allowed. */
var validChars="\[^\\s" + specialChars + "\]";
/* The following pattern applies if the "user" is a quoted string (in
   which case, there are no rules about which characters are allowed
   and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
   is a legal e-mail address. */
var quotedUser="(\"[^\"]*\")";
/* The following pattern applies for domains that are IP addresses,
   rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal
   e-mail address. NOTE: The square brackets are required. */
var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;
/* The following string represents an atom (basically a series of
   non-special characters.) */
var atom=validChars + '+';
/* The following string represents one word in the typical username.
   For example, in john.doe@somewhere.com, john and doe are words.
   Basically, a word is either an atom or quoted string. */
var word="(" + atom + "|" + quotedUser + ")";
// The following pattern describes the structure of the user
var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
/* The following pattern describes the structure of a normal symbolic
   domain, as opposed to ipDomainPat, shown above. */
var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");


/* Finally, let's start trying to figure out if the supplied address is
   valid. */

/* Begin with the coarse pattern to simply break up user@domain into
   different pieces that are easy to analyze. */
var matchArray=emailStr.match(emailPat);
if (matchArray==null) {
  /* Too many/few @'s or something; basically, this address doesn't
     even fit the general mould of a valid e-mail address. */
	error(46);
	return false;
}
var user=matchArray[1];
var domain=matchArray[2];

// See if "user" is valid 
if (user.match(userPat)==null) {
    // user is not valid
    error(46);
    return false;
}

/* if the e-mail address is at an IP address (as opposed to a symbolic
   host name) make sure the IP address is valid. */
var IPArray=domain.match(ipDomainPat);
if (IPArray!=null) {
    // this is an IP address
	  for (var i=1;i<=4;i++) {
	    if (IPArray[i]>255) {
	        error(46);
		return false;
	    }
    }
    return true;
}

// Domain is symbolic name
var domainArray=domain.match(domainPat);
if (domainArray==null) {
	error(46);
    return false;
}

/* domain name seems valid, but now make sure that it ends in a
   three-letter word (like com, edu, gov) or a two-letter word,
   representing country (uk, nl), and that there's a hostname preceding 
   the domain or country. */

/* Now we need to break up the domain to get a count of how many atoms
   it consists of. */
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) {
   // the address must end in a two letter or three letter word.
   error(46);
   return false;
}

// Make sure there's a host name preceding the domain.
if (len<2) {
   error(46);
   return false;
}

// If we've gotten this far, everything's valid!
return true;
}
//  End -->
//----------------------Termina la parte de validar correo------------------------------------------
/*************************************************************************
*función esNulo(caslla) nos dice si una casilla pasada como argumento    *
*se encuentra vacía                                                      *
*IN: caslla a verificar                                                  *
*OUT: true-->la casilla esta vacía || false-->la casilla no esta vacía   *
*************************************************************************/
function esNulo(caslla)
{
     if (caslla.value == '')
     {
         error(1);
		 return true;
     }
     else
         return false;
}

/************************************************************************************
*función checaContrasenyaCambio(contrasenya,contrasenyaconf)						*
*	Revisa que al interntar cambiar alguna contraseña, la contraseña nueva y su		*
*	confirmación tengan los mismos valores, además de que tener una longitud por lo	*
	menos de 6 caracteres.															*
*IN: los campos donde se encuentran tanto la contraseña nueva como su confirmación	* 
*OUT: true-->si se cumple con la condiciones antes mencionada de longitud mayor		* 
			igual a 6 y que los dos campos tengan los mismo valores					*
*	  false-->si no se cumple alguna de las condiciones dadas				 		*
************************************************************************************/
function checaContrasenyaCambio(contrasenya,contrasenyaconf)
{
	//verificamos que la contraseña tengan un mínimo de longitud de 6
	 if(contrasenya.value.length<6)
	 {
		error(23);
		contrasenya.select();
		contrasenya.focus();
		return false;
	 }
	
	 else
	 {
		 //verificamos que las dos contraseñas tendrán el mismo contenido
		 if (contrasenyaconf.value!=contrasenya.value)
		 {
			error(24);
			contrasenyaconf.value="";
			contrasenya.select();
			contrasenya.focus();
			return false;
		 }
		 else
		 {
			return true; 
		 }
	 }
}

/************************************************************************************
*función validaRFC(RFC)                                                             *
*	Checa que el RFC introducido por el usuario este correctamente introducido      *
*IN: el campo que tendrá el RFC                    									*
*OUT: true-->si cumple con la sintaxis del RFC                                      *
*	  false-->si existe algun error en su introducción                              *
************************************************************************************/
function validaRFC(RFC)
{
	if(RFC.value.search(/^([a-zA-Z]){4}([0-9]){6}$/ig))
	{//la g es para explorar la cadena completa, i es para no distinguir mayusculas de minusculas
        alert("El formato de el RFC no es valida, verifique");
        RFC.select();
        RFC.focus();
        return false;
    }
	else
	{
	return true;
	}
}
/*************************************************************************
*función error(tipo) nos despliega los errores en verificaciones         *
*IN: tipo del error                                                      *
*OUT: desplegado del error, no devuelve ningun valor                     *
*************************************************************************/
function error(tipo)
{
 switch (tipo)
     {
     case 1:
         alert("Debe llenar todos los campos.");
         break;
	 case 2:		   
		 alert ("El campo lada de teléfono partícular no puede ser nulo.");
		 break;
	 case 3:
		alert ("El campo teléfono partícular no puede ser nulo.");
		break;
	 case 4:
		alert ("El campo dirección no puede ser nulo.");
		break;
	 case 5:
		alert ("El campo colonia no puede ser nulo.");
		break;		
	 case 6:
		alert ("El campo código postal no puede ser nulo.");
		break;	
	 case 7:
		alert ("El campo estado no puede ser nulo.");
		break;
	 case 8:
		alert ("El campo delegación/municipio no puede ser nulo.");
		break;
	 case 9:
		alert ("El campo nombre de familiar no puede ser nulo.");
		break;
	 case 10:
		alert ("El campo lada de teléfono de familiar no puede ser nulo.");
		break;
	 case 11:
		alert ("El campo télefono de familiar no puede ser nulo.");
		break;
	 case 12:
		alert("El campo padecimientos no puede ser nulo, si no tiene alergias seleccione ninguno.");
		break;
	 case 13:
		alert ("Ningún nombre de beneficiario puede ser nulo.\n Número de beneficiarios "+validacion[2]);
		break;
	 case 14:
    	alert ("El campo alergias no puede ser nulo, si no tiene alergias seleccione no o no lo se.");
		break;
	 case 15:
		alert ("Ningun campo parentesco puede ser nulo.");
		break;
	 case 16:
		alert ("La suma de porcentajes debe ser del 100%.");
		break;
	case 17:
		alert("Correo eletrónico no válido.\n Formato cadena@cadena.cadena.");
		break;
	case 18:
		alert("Campo con digitos no válidos (numéricos).");
		break;
	case 19:
		alert("Campo con digitos no válidos (alfabéticos).");
		break;
	case 20:
		alert("NO puedes ingresar simbolos especiales como /,*,{,},?,¿,[,],#,etc.");
		break;
	case 21:
		alert("El campo correo electrónico no puede ser nulo.");
		break;
	case 22:
		alert("El campo CURP no puede ser nulo.");
		break;	
	case 23:
	 	alert("La CONTRASEÑA debe tener por lo menos 6 digitos");
		break;
	case 24:
	 	alert("La CONTRASEÑA y su confirmación tienen valores distintos");
		break;
	case 25:
		alert("El número de trabajador debe contener 6 dígitos");
		break;
	case 26:
		alert("Debes ingresar la división");
		break;
	case 27:
		alert("Debes ingresar el nombre completo");
		break;
	case 28:
		alert("Debes ingresar el NÚMERO DE TRABAJADOR");
		break;
	case 29:
	 	alert("Debes ingresar LA CONTRASEÑA");
		break;
	case 30:
		alert("Debes ingresar la confirmación de la CONTRASEÑA");
		break;
	case 31:
		alert("El campo homoclave de la CURP no puede ser nulo.");
		break;
	case 32:
		alert("El campo RFC no puede ser nulo.");
		break;
	case 33:
		alert("Seleccione algún nombramiento.");
		break;
  	case 34:
		alert("Ningún campo de fecha puede estar vacio, seleccione alguna fecha.");
		break;
   	case 35:
		alert("Seleccione algún tipo de gráfica.");
		break;
 	case 36:
		alert("La fecha final no puede ser menor a la inicial , verifique.");
		break;
  	case 37:
		alert("Seleccione algun tipo de consulta.");
		break;
  	case 38:
		alert("El campo cantidad no puede ser menor a uno");
		break;
	case 39:
		 alert("La clave de división y de área deben tener los  dos primeros dígitos idénticos");
		 break;
	case 40:
		alert("Clave de área debe ser de 4 dígitos");
		break;
	case 41:
		alert("Debes ingresar el área");
		break;
	case 42:
		alert("La hora final precede a la hora inicial, verifique");
		break;
	case 43:
		alert("Por favor no introducir espacios en blanco");
		break;
	case 44:
		alert("La cifra no puede tener más de un punto");
	break;
	case 45:
		alert("Requieres ingresar decimales después del punto");
	break;
	case 46:
		alert("Formato erróneo  de correo electrónico");
	break;
	}
}