// FileName: /includes/validation.js
var mainErrorMessage="    Please enter the required fields.\n"

function validateNotEmpty(aValue,errorMessage)
{
	// This function checks to see that the user has entered data in a specific field.
	if (aValue=="")
	{
		alert(mainErrorMessage+"    "+errorMessage);
		return false;
	}
    
	// This function also checks to make sure there are not just spaces in it either.
	var strValidChars = " ";
    var tempChar;
    var noSpace = false;
 
    for (i = 0; i < aValue.length; i++)
    {
		tempChar = aValue.charAt(i);
		if (strValidChars.indexOf(tempChar) == -1)
			noSpace = true;
	}
    if(noSpace==false)
	{
		alert(mainErrorMessage+"    "+errorMessage);
		return false;
	}
}

function validateHTTPDefault(aValue,errorMessage)
{
	//This function checks to see if a URL field doesn't have a default value of "http://"
	//It tries to make them a valid URL
	if(aValue.substring(0,7)!="http://" && aValue != "")
	{
		alert(errorMessage);
		return false;
	}
}

function validateRadioButtons(fieldName,errorMessage)
{
    //This checks to make sure the user clicked 1 of the radio buttons in a group
	var TempFlag
    var TempField
	TempField=eval(fieldName)

	for(x=0;x<TempField.length;x++)
	{
		if(TempField[x].checked!=false)
			return true;	
	}
	alert(mainErrorMessage+"    "+errorMessage);
	return false;
}

function validatePasswordMatch(password1,password2,errorMessage)
{
     // This function checks two password fields to make sure they are the same password.
	 if (password1!=password2)
	 {
		alert(errorMessage);
		return false;
	 }
}

function validateIsNumeric(aValue,errorMessage)
{
	//This function checks to make sure that the data in a field is numeric.
    var strValidChars = "0123456789.-";
    var tempChar;

    for (i = 0; i < aValue.length; i++)
    {
        tempChar = aValue.charAt(i);
        if (strValidChars.indexOf(tempChar) == -1)
        {
	        alert(errorMessage);
            return false;
        }
    }
}

function validateDefaultCheck(aValue,aValue2,errorMessage)
{
	//This function checks to make sure the field has been changed from the default value of the field.
	if (aValue==aValue2)
	{
		alert(errorMessage);
		return false;
	}
}

function validateEMailCheck(emailAddress,errorMessage)
{
    //This function checks to make sure the email address entered is valid.
	if(emailAddress!="")
	{
          var emailStr=emailAddress
             /* 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(errorMessage)
	           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("The username doesn't seem to be valid.")
               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("Destination IP address is invalid!")
		                  return false
	                }
               }
               return true
          }

          // Domain is symbolic name
          var domainArray=domain.match(domainPat)
          if (domainArray==null) 
		  {
	          alert("The domain name doesn't seem to be valid.")
              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("The address must end in a three-letter domain, or two letter country.")
               return false
          }

          // Make sure there's a host name preceding the domain.
          if (len<2)
		  {
               var errStr="This address is missing a hostname!"
               alert(errStr)
               return false
          }

          // If we've gotten this far, everything's valid!
          return true;
	}
}