var myErrorObject; 
/* Author: Jesse Williams
 * Date: February 2008
 *
 * Description: Form validation for Launch Net Registration Pages.
 * Capture all the elements in the form and determine if an element
 * requires validation.
 *
 * Inputs: None.
 * Outputs: True | False; if false the form is not submitted.
 */
 
/* getFormElements obtains all the elements on the form and verifies if the element
 * should be validated.  It identifies an element to be validated by a suffix that
 * contains an "_" with a corresponding field name.  If the id of the element does not
 * contain an "_" it will be ignored.
 *
 * The suffix is then parsed to obtain the field name.  The field name is appended to 
 * the signature of the validation method and executed.  If the field fails validation
 * the user is notified - note, only the first failure is reported.
 */
/***** Begin getFormElements *****/
function FormValidation()
{
   
    
    
    var myValidator;
    
    
    
    ////////////////////////////////////////////////////////
    // Public Functions ////////////////////////////////////
   
    

    this.getFormElements = getFormElements;
    function getFormElements() 
    {
//        myErrorObject = CommonUtil.GetValidatorErrObjRef();
//        myValidator = CommonUtil.GetValidatorRef();
        myErrorObject = new  ValidationErrorObject();
        var myValidator = new Validator();
        var formForValidation = document.forms[0];
        var retVal = true;
        var FunctArray = new Array;
        var int = 0;
        var idx = 0;    
        
        //Reflect on the validator object and pick out it's methods.  Yes I said
        // REFLECT.
        for (var member in myValidator) 
           {                  
               FunctArray[int] = member;
               int++; 
           }    
        
        for(var i=0; i < formForValidation.length; i++) 
        {
            var elementID = formForValidation.elements[i].id;
            var suffix = elementID.substr(elementID.lastIndexOf("_"));

                if(suffix.indexOf("_") != -1)
                 {                                   
               
                        idx = FunctArray.indexOfString("validate" + suffix.substr(suffix.indexOf("_") + 1));    
                            
                        if(idx > -1)
                          {
                                if (typeof formForValidation.elements[i] != "undefined")
                                {
                                    if(!(eval("myValidator." + FunctArray[idx] + "(formForValidation.elements[i])")))
                                    {
                                        myErrorObject.CreateErrorContainer(formForValidation.elements[i], myErrorObject.GetErrorMessage());
                                        if(retVal) {retVal=false;}
                                    }
                                }
                           }     
                  
             
             }
                
        }
        return retVal;
    }
    /***** End getFormElements *****/
}

/* ValidationErrorObject class handles reporting the failure messages to the user.
 * Inputs: None.
 * Outputs: None.
 * Public Properties: GetErrorMessage, SetErrorMessage, GetFieldErrorMessage
 * Public Methods: CreateErrorContainer, RemoveErrorContainer
 * Private Variables: _errorMessage
 * Constants used to build error messages.
 *
 * SetErrorMessage(value) sets the error message.
 * GetErrorMessage returns the error message set by the validator.
 * GetFieldErrorMessage(code) returns the appropriate error code.
 *
 * CreateErrorContainer generates a division in the HTML to display error message.
 * RemoveErrorContainer removes the division in the HTML that displays the error message.
 */

/***** Begin Error Object Class *****/
function ValidationErrorObject()
{
    /***** CONSTRUCTORS *****/
    this.CreateErrorContainer = CreateErrorContainer;
    this.RemoveErrorContainer = RemoveErrorContainer;
    /***** END CONSTRUCTORS *****/
       
    /***** PUBLIC PROPERTIES *****/   
    this.GetErrorMessage = GetErrorMessage;
    function GetErrorMessage()
    {
        return _errorMessage;
    }
    this.SetErrorMessage = SetErrorMessage;
    function SetErrorMessage(value)
    {
        _errorMessage = value;
        //CommonUtil.SetValidatorErrObjRef(this);
    }
    this.GetFieldErrorMessage = GetFieldErrorMessage;
    function GetFieldErrorMessage(code)
    {
        switch(code)
        {
            case "ADDRESSMAXLENGTH":
                return ADDRESSMAXLENGTH;
                break;
            case "HASCRLF":
                return HASCRLF;
                break;
            case "HASDIGITS":
                return HASDIGITS;
                break;
            case "HASSPACES":
                return HASSPACES;
                break;
            case "HASFICOCHARACTERS":
                return HASFICOCHARACTERS;
                break;
            case "HASFICODELIMETER":
                return HASFICODELIMETER;
                break;
            case "INVALIDDATE":
                return INVALIDDATE;
                break;
            case "INVALIDEMAIL":
                return INVALIDEMAIL;
                break;
            case "INVALIDPHONENUMBER":
                return INVALIDPHONENUMBER;
                break;
            case "INVALIDSSN":
                return INVALIDSSN;
                break;
            case "INVALIDSTATE":
                return INVALIDSTATE;
                break;
            case "INVALIDZIPCODE":
                return INVALIDZIPCODE;
                break;
            case "ISATITLE":
                return ISATITLE;
                break;
            case "ISREQUIRED":
                return ISREQUIRED;
                break;
            case "ISREQUIREDLIST":
                return ISREQUIREDLIST;
                break;
            case "MAXLENGTH1":
                return MAXLENGTH1;
                break;
            case "MAXLENGTH2":
                return MAXLENGTH2;
                break;
            case "MAXLENGTH4":
                return MAXLENGTH4;
                break;
            case "MAXLENGTH15":
                return MAXLENGTH15;
                break;
            case "MAXLENGTH20":
                return MAXLENGTH20;
                break;
            case "MINLENGTH1":
                return MINLENGTH1;
                break;
            case "MINLENGTH2":
                return MINLENGTH2;
                break;
            case "NOTALPHA":
                return NOTALPHA;
                break;
            case "TRIPLEREPEAT":
                return TRIPLEREPEAT;
                break;
            case "ZIPCODEMAXLENGTH":
                return ZIPCODEMAXLENGTH;
                break;
            case "ZIPCODEMINLENGTH":
                return ZIPCODEMINLENGTH;
                break;
            case "CONFIRMEMAIL":
                return CONFIRMEMAIL;
                break;   
            case "IS18YEARSOLD":
                return IS18YEARSOLD;
                break;     
                
            default:
                return "Unknown error.";
                break;
        }
    }
    /***** END PUBLIC PROPERTIES *****/
    
    /***** PRIVATE VARIABLES *****/
    var _errorMessage = null;
    /***** END PRIVATE VARIABLES *****/
    
    /***** ERROR MESSAGE CONSTANTS *****/
    var ADDRESSMAXLENGTH = "cannot exceed 50 characters.";
    var CONFIRMEMAIL = "values do not match.";
    var HASCRLF = "cannot contain carriage returns.";
    var HASDIGITS = "cannot contain digits.";
    var HASSPACES = "cannot contain spaces.";
    //HASFICOCHARACTERS = "cannot contain the characters: '@', '#', '$', '%', '*', '^', '!', '{', '}', '[', ']', '?', '+', '-', '=', '\', '/', ',', '.', '\"'";
    var HASFICOCHARACTERS = "* Value cannot contain invalid characters.";
    var HASFICODELIMETER = "cannot contain the character { .";
    var INVALIDDATE = "* Value for date is invalid.";
    var INVALIDEMAIL = "* Value for email is invalid.";
    var INVALIDPHONENUMBER = "* Value for phone number is invalid.";
    var INVALIDSSN = "* Value for social security number is invalid.";
    var INVALIDSTATE = "* Value for state abbrevation is invalid.";
    var INVALIDZIPCODE = "* Value for zip code is invalid.";
    var ISATITLE = "* Value for first name cannot be a title.";
    var ISREQUIRED = "is required.";
    var ISREQUIREDLIST = "* Please select an option";
    var MAXLENGTH1 = "cannot exceed one (1) characters in length.";
    var MAXLENGTH2 = "cannot exceed two (2) characters in length.";
    var MAXLENGTH4 = "cannot exceed four (4) characters in length.";
    var MAXLENGTH15 = "cannot exceed 15 characters in length.";
    var MAXLENGTH20 = "cannot exceed 20 characters in length.";
    var MINLENGTH1 = "must be at least one (1) character in length.";
    var MINLENGTH2  = "must be at least two (2) characters in length.";
    var NOTALPHA = "cannot contain non-alpha characters.";
    var TRIPLEREPEAT = "cannot triple repeat characters.";
    var ZIPCODEMAXLENGTH = "* Value for zip code cannot exceed ten (5) digits.";
    var ZIPCODEMINLENGTH = "* Value for zip code must be at least five (5) digits.";
    var IS18YEARSOLD  = "Please check this option";
    /***** END ERROR MESSAGE CONSTANTS *****/
        
    function CreateErrorContainer(myField, errMsg)
    {
        var errorContainer = null ;
        
        this.RemoveErrorContainer(myField);
        
	    if ((errMsg) && (errMsg.length > 0))
	    {
            errorContainer = document.createElement("span");
            errorContainer.setAttribute("id","error_" + myField.name);
	        errorContainer.className = "errorContainer";
            errorContainer.appendChild(document.createTextNode(errMsg));
            myField.parentNode.insertBefore(errorContainer,myField.nextSibling);
            //myField.parentNode.insertBefore(errorContainer,myField);
            
        }
        
        this.SetErrorMessage(null);
    }
    
    function RemoveErrorContainer(myField)
    {
        if (document.getElementById("error_" + myField.name))
	    {
            var rmElem = document.getElementById("error_" + myField.name);
	        rmElem.parentNode.removeChild(rmElem);
	    }
    }
}
/***** End Error Object Class *****/


// ========================================
//         VALIDATOR CONSTRUCTOR
// ========================================
function Validator()
{
	this.validateRegistration = validateRegistration ;
	//this.validatePrefix = validatePrefix ;
	this.validateAge = validateAge;
	this.validateFirstName = validateFirstName ;
	this.validateMiddleInitial = validateMiddleInitial ;
	this.validateLastName = validateLastName ;
	//this.validateSuffix = validateSuffix ;
	this.validateAddress1 = validateAddress1 ;
	//this.validateAddress2 = validateAddress2 ;
	this.validateCity = validateCity ;
	this.validateState = validateState ;
	this.validateZipCode = validateZipCode ;
	this.validateEmailAddress = validateEmailAddress ;
	this.validateRequiredList = validateRequiredList;
    this.validateConfirmEmail = validateConfirmEmail;
    this.validateStateName = validateStateName;
// ========================================
//        FIELD VALIDATION FUNCTIONS
// ========================================

    function validateRegistration()
    {
//        myValidator.validatePrefix(document.forms[0].prefix);
//        myValidator.validateFirstName(document.forms[0].firstname);
//        myValidator.validateMiddleInitial(document.forms[0].middleinitial);
//        myValidator.validateLastName(document.forms[0].lastname);
//        myValidator.validateSuffix(document.forms[0].suffix);
//        myValidator.validateAddress1(document.forms[0].address1);
//        myValidator.validateAddress2(document.forms[0].address2);
//        myValidator.validateCity(document.forms[0].city);
//        myValidator.validateState(document.forms[0].state);
//        myValidator.validateZipCode(document.forms[0].zipcode);
//        myValidator.validateEmailAddress(document.forms[0].emailaddress);
    }
    
	function validatePrefix(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);

		if (!(hasNoDigits(myValue)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if (!(hasNoSpaces(myValue)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("HASSPACES"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if (!(hasNoFicoDelimeter(myValue)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if (!(hasNoCrLf(myValue)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if (!(maxLength(myValue,4)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("MAXLENGTH4"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }

		return retVal
	}
    
	function validateFirstName(myField)
	{
	    var retVal = true;	    
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoDigits(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoChars(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("HASFICOCHARACTERS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(notATitle(myValue)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("ISATITLE"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(notTripleRepeat(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("TRIPLEREPEAT"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 2)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("MINLENGTH2"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 15)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("MAXLENGTH15"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateMiddleInitial(myField)
	{
	    var retVal = true;
	    var myValue = getValue(myField);
	    
	    if(!(hasNoDigits(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(isAlpha(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("NOTALPHA"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(hasNoSpaces(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("HASSPACES"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(hasNoFicoDelimeter(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(hasNoCrLf(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(maxLength(myValue, 1)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("MAXLENGTH1"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }		
		
		return retVal;
	}

	function validateLastName(myField)
	{
		var retVal = true;
		var myValue = getValue(myField);
				
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoDigits(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoChars(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("HASFICOCHARACTERS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(notTripleRepeat(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("TRIPLEREPEAT"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 20)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("MAXLENGTH20"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 2)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("MINLENGTH2"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateSuffix(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for suffix " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for suffix " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 4)))
		{
		    myErrorObject.SetErrorMessage("* Value for suffix " + myErrorObject.GetFieldErrorMessage("MAXLENGTH4"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

    function validateAge(myField)
	{
	  var retVal = true;
	  if(!myField.checked)
	  {
	      myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("IS18YEARSOLD"));
	        retVal = false;
	        return;
      }
	  else { myErrorObject.RemoveErrorContainer(myField); }
	  
	  return retVal;
	
	}
	function validateAddress1(myField)
	{
		var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 50)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("ADDRESSMAXLENGTH"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateAddress2(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 50)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("ADDRESSMAXLENGTH"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}
	
	function validateCity(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoDigits(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 1)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("MINLENGTH1"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 20)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("MAXLENGTH20"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateState(myField)
	{
		var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoDigits(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(isValidState(myValue)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("INVALIDSTATE"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 2)))
		{
		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("MINLENGTH2"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 2)))
		{
		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("MAXLENGTH2"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}
	
	function validateZipCode(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for zip code " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoSpaces(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for zip code " + myErrorObject.GetFieldErrorMessage("HASSPACES"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for zip code " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for zip code " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 5)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("ZIPCODEMINLENGTH"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 5)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("ZIPCODEMAXLENGTH"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(isValidZipCode(myValue)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("INVALIDZIPCODE"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateEmailAddress(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for email " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(isValidEmailAddress(myValue)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("INVALIDEMAIL"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoSpaces(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for email " + myErrorObject.GetFieldErrorMessage("HASSPACES"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for email " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}
	
	function validateRequiredList(myField)
	{
	    var retVal = true;    	    
	    var selectCount = 0;
	    var fieldName = myField.name;
	    
	    for(var i=0; i<eval("document.forms[0]." + fieldName + ".length"); i++)
	    {
	        if(eval("document.forms[0]." + fieldName + "[i].checked"))
	        {
	            selectCount++;
	        }
	        
	    }	    
        if(selectCount == 0)
        {
            myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("ISREQUIREDLIST"));
	        retVal = false;
	        return;
        }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    
	    return retVal;
	}
	
	function validateConfirmEmail(myField)
	{
		var myValue = getValue(myField);
		var mainEmailValue=document.getElementById(myField.id.substr(0,myField.id.lastIndexOf("_"))+'_EmailAddress').value;
		
	    if(validateEmailAddress(myField))
	    {
	        if(myValue!=mainEmailValue)
	        {
	            myErrorObject.SetErrorMessage("* email " + myErrorObject.GetFieldErrorMessage("CONFIRMEMAIL"));
		        return false;
	        }
	        else
	        {
	            myErrorObject.RemoveErrorContainer(myField);
	            return true;
	        }
	    }
	    else
	    {
	        return false;
	    }
	}
	
	function validateStateName(myField)
	{
		var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    return false;
		}
		else 
		{ 
		    myErrorObject.RemoveErrorContainer(myField); 
		    return true;
		}
		
	}	

// ========================================
//        BASE  VALIDATOR FUNCTIONS
// ========================================

	function getValue(myField)
	{
		var myValue = '';
		switch(myField.type)
		{
			case "button" :
				myValue = myField.value;
			case "checkbox" :
				if (myField.checked) {
					myValue = myField.value;
				}
			case "file" :
				myValue = myField.value;
			case "hidden" :
				myValue = myField.value;
			case "password" :
				myValue = myField.value;
			case "radio" :
				if (myField.checked) {
					myValue = myField.value;
				}
			case "reset" :
				myValue = myField.value;
			case "select-one" :
				var si = myField.selectedIndex;
				if (si >= 0) {
					myValue = myField.options[si].value;
				}
			case "select-multiple" :
				myValue = myField.value;
			case "text" :
				myValue = myField.value;
			case "textarea" :
				myValue = myField.value;
			default : 
				myValue = myField.value;
		}
		return myValue;
	}

	function isNotNull(myText)
	{
		if ( (myText.length > 0) && (myText.trim().length > 0) ) {
			return true;
		} else {
			// alert("Not Null!");
			return false;
		}
	}

	function isNumeric(myText)
	{
		var charpos = myText.search("[^0-9]"); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Non-Numeric character at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function isAlpha(myText)
	{
		var charpos = myText.search("[^A-Za-z]"); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Non-Alpha character at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function isAlphaNumeric(myText)
	{
		var charpos = myText.search("[^A-Za-z0-9]"); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Non-AlphaNumeric character at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function hasNoDigits(myText)
	{
		var charpos = myText.search("[0-9]"); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Numeric character at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function hasNoSpaces(myText)
	{
		var charpos = myText.search(/\s/); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Space at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	// HAS NO SPACES - OLD
	function hasNoSpaces_v1(myText)
	{
		var InvalidChars = " ";
		var Char;
		for (i = 0; i < myText.length; i++) 
		{ 
			Char = myText.charAt(i); 
			if (InvalidChars.indexOf(Char) != -1) 
			{
				// alert("Space!");
				return false;
			}
		}
		return true;
	}
	
	function hasNoCrLf(myText)
	{
		var charpos = myText.search(/\r\n/); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Carriage Return or Line Feed at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function notATitle(myText)
	{
		var regTitle = /^(CAPT|COL|DR|FR|LT|MISS|MS|MRS|MR|MJR|REV|SIST|AGENCY)$/i ;
		if (regTitle.test(myText))
		{
			// alert("Name is a Title. Please correct and submit again.");
			return false;
		}
		return true;
	}
	
	function notATestWord(myText)
	{
		var regTest = /^(TEST|TESTING|FIRST)$/i ;
		if (regTest.test(myText))
		{
			// alert("Name is a Test Word. Please correct and submit again.");
			return false;
		}
		return true;
	}
	
	function notTripleRepeat(myText)
	{
		var charpos = myText.search(/^([0-9a-zA-Z])\1\1/i); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Triple Alpha Character " + myText.charAt(charpos) + " at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}
	
	function hasNoFicoDelimeter(myText)
	{
		var charpos = myText.search(/{/); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("FICO Delimeter Character " + myText.charAt(charpos) + " at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}
	
	function hasNoFicoChars(myText)
	{
		var charpos = myText.search(/@|#|\$|%|\*|\^|!|{|}|\[|\]|\?|\+|-|=|\\|\/|,|\.|\"/); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Invalid Character " + myText.charAt(charpos) + " at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}
	
	function hasNoFicoChars_old(myText)
	{
		var InvalidChars = "@#$%*^!{}[]?+-=/,.\"";
		var Char;
		for (i = 0; i < myText.length; i++) 
		{ 
			Char = myText.charAt(i); 
			if (InvalidChars.indexOf(Char) != -1) 
			{
				// alert("Invalid Character " + Char + " at " + eval(myText.indexOf(Char) + 1) );
				return false;
			}
		}
		return true;
	}

	function maxLength(myText,myMaxLength)
	{
		if (myText.length > myMaxLength)
		{
			// alert("More than " + myMaxLength + "!");
			return false;
		} else {
			return true;
		}
	}

	function minLength(myText,myMinLength)
	{
		if (myText.length < myMinLength)
		{
			// alert("Less than " + myMinLength + "!");
			return false;
		} else {
			return true;
		}
	}

	function isValidZipCode(myText)
	{
		var regZip = new RegExp(/(^\d{5}$)|(^\d{5}-\d{4}$)/);
		if (!regZip.test(myText))
		{
			// alert("Zip Code Is Not Valid");
			return false;
		}
		return true;
	}

	function isValidEmailAddress(myText)
	{
		var regEmail = "^[\\w-_\.]*[\\w-_\.]\@[\\w]\.+[\\w]+[\\w]$";
		var regex = new RegExp(regEmail);
		if (!regex.test(myText))
		{
			// alert("Email Address Is Not Valid");
			return false;
		}
		return true;
	}

	function isValidDate(myText)
	{
		var regDate=/^\d{2}\/\d{2}\/\d{4}$/ ;
		if (!regDate.test(myText))
		{
			// alert("Invalid Date Format (MM/DD/YYYY). Please correct and submit again.");
			return false;
		}
		return true ;
	}

	function isValidPhoneNumber(myText)
	{
		var regPhone = /^\(?\d{3}\)?\s|-\d{3}-\d{4}$/ ;
		if (!regPhone.test(myText))
		{
			// alert("Invalid Phone Format (###-###-####). Please correct and submit again.");
			return false;
		}
		return true;
	}
	
	function isValidState(myText)
	{
		var regState = /^(AK|AL|AR|AZ|CA|CO|CT|DC|DE|FL|GA|HI|IA|ID|IL|IN|KS|KY|LA|MA|MD|ME|MI|MN|MO|MS|MT|NE|NC|ND|NH|NJ|NM|NV|NY|OH|OK|OR|PA|RI|SC|SD|TN|TX|UT|VA|VT|WA|WI|WV|WY|AA|AE|AP|AS|FM|GU|MH|MP|PR|PW|VI)$/i ;
		if (!regState.test(myText))
		{
			// alert("Invalid State Abbreviation. Please correct and submit again.");
			return false;
		}
		return true;
	}	
	
	function isValidSSN(myText)
	{
		var regSSN = /^\d{3}\-?\d{2}\-?\d{4}$/ ;
		if (!regSSN.test(myText))
		{
			// alert("Invalid SSN (###-##-####). Please correct and submit again.");
			return false;
		}
		return true;
	}
}