// This file contains the data validation JavaScript functions
// It is included in the HTML pages with forms that need these
// data validation routines.


// DEFINE VARIABLES


/****************************************************************/
// Returns true if string s is empty or 
// whitespace characters only.

function isWhitespace (s) {
	
// whitespace characters
    var whitespace = " \t\n\r";
    var i;
    // Is s empty?
    if ( (s == null) || (s.length == 0) ) return true;

    // Search through string's characters one by one
    // until we find a non-whitespace character.
    // When we do, return false; if we don't, return true.
    for (i = 0; i < s.length; i++)
    {   
	// Check that current character isn't whitespace.
	var c = s.charAt(i);

	if (whitespace.indexOf(c) == -1)  return false;
    }
    // All characters are whitespace.
    return true;
}


/****************************************************************/
// Check for valid e-mail address

function EmailOK (objField) {
    var emailStr = new String(objField.value);

/* 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  
   From http://javascript.internet.com */

   <!-- Define patterns to check address                                                                  
   /* 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. */                                          
      alert("E-mail address is blank or incorrect (check @ and .'s)")                                     
      objField.focus();                                                                                                                                                                     
      return false                                                                                        
   }                                                                                                      
   var user=matchArray[1]                                                                                 
   var domain=matchArray[2]                                                                               
                                                                                                          
   // See if "user" is valid                                                                              
   if (user.match(userPat)==null) {                                                                       
       // user is not valid                                                                               
      alert("Problem with the username part of the e-mail address")                                       
      objField.focus();                                                                                   
      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) {                                                                          
    	   alert("E-mail IP address is incorrect")                                                     
           objField.focus();                                                                           
   	   return false                                                                                
           }                                                                                              
       }                                                                                                  
       return true                                                                                        
   }                                                                                                      
                                                                                                          
   // Domain is symbolic name                                                                             
   var domainArray=domain.match(domainPat)                                                                
   if (domainArray==null) {                                                                               
      alert("E-mail address is incorrect - check the domain name.")                                       
      objField.focus();                                                                                   
      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.                                       
      alert("E-mail address is incorrect - must end in 2/3 letter domain/country.")                                  
      objField.focus();                                                                                   
      return false                                                                                        
   }                                                                                                      
                                                                                                          
   // Make sure there's a host name preceding the domain.                                                 
   if (len<2) {                                                                                           
      alert("E-mail address is incorrect - error in host name.")                                           
      objField.focus();                                                                                   
      return false                                                                                        
   }                                                                                                      
                                                                                                          
   // Everything's valid!                                                                                 
   return true;                                                                                           
}
//  End -->


/****************************************************************/
// Checks to see if a required field is blank.  
// If it is and the FieldName para is not blank , a warning
// message is displayed...

function CheckNotBlank(objField, FieldName)
{
	var strField = new String(objField.value);

	if (isWhitespace(strField)) {
            if (!isWhitespace(FieldName)) {
            	alert("You must enter " + FieldName);
		objField.focus();
	    }
	     return false;
	}

	return true;
}