/*******************************************************
* Form Validation functions
* $Author: StanD $
* Revision $Date: Tuesday, April 10, 2001 1:20:56 PM $
* Purpose: To provide generic functions that can be used
* 	   for client side validation over the Web
* $Filename: C:\usr\local\dev\CodeLibraries\Javascript\FormValidation.js $
* $Log: C:\usr\local\archive\CodeLibraries\Javascript\FormValidation.kt $
   
     syntax error in directory directive

	Revision 2.0 by KO		Rev date: Thu Sep 27 2001
		added vf_MaxLength function that tests for maximum length of a 
		field value and truncates existing value to maximum length
		added vf_ValidDate function that tests for a valid date
   
   Revision 1.3  by: StanD  Rev date: Tue Apr 10 13:20:56 2001
     added a vf_Exists function that tests for the existence of a field. If
     the field does not exist, it returns false and appends to the
     ErrorArray.
   
   Revision 1.2  by: StanD  Rev date: Mon Apr 09 22:38:34 2001
     added messageValidate function, fixed Goto field bug and fixed eval
     statements with AForm in them.
   
   Revision 1.1  by: StanD  Rev date: Mon Apr 09 20:38:26 2001
     syntax error in directory directive
   
   Revision 1.0  by: StanD  Rev date: Mon Apr 09 20:29:52 2001
     Initial revision.
   
   $Endlog$
*******************************************************/
function test() { alert("reached");}
function messageValidate(AForm, ValidationArray, doGoto) {
	//this is a wrapper function to the ValidateForm function. It outputs errors to an alert box
	var FlatErrorArray = ValidateForm(AForm, ValidationArray, doGoto);
	if (FlatErrorArray == "") {
		return true;
	} else {
		//turn the FlatErrorArray into a real array...
		var ErrorArray = FlatErrorArray.split("|");
		//...and output it to an alert box.
		var msg = "This form has the following errors:\n";
		msg += ErrorArray.join("\n");
		alert(msg);
		return false;
	}
}
function ValidateForm(AForm, ValidationArray, doGoto) {
	//This function will return an array of errors given the form name (aForm), an array of validation
	//code (ValidationArray) and a Boolean (doGoto) which if true will put the user's cursor in the
	//first non-valid field and if false will not.


	//ErrorArray is a "|" delimited string of error messages compiled by the function.
	var ErrorArray;
	
	//ValidationElements is an array of all the validation code.
	ValidationElements = new Array();

	ErrorArray = ""; //it passes for now, but let's check it out!
	ValidationElements = ValidationArray.split(";");
	if (ValidationArray == "") return ErrorArray;	//There is no validation code.

	//GotoField records the name of the first field that fails validation.
	var GotoField = "";
	var oForm = eval("document." + AForm);

	for(i = 0; i < ValidationElements.length; i++)
	{
		FieldArray = ValidationElements[i].split("|"); //parse out the validation code parameters
		if (FieldArray[0] != "") {
			//itmTmp is an javascript Input object pulled from the form.
			itmTmp = eval("oForm." + FieldArray[0]);
			//alert("calling " + FieldArray[1]);
			switch (FieldArray[1].toUpperCase()) {
			case "EXISTS":
				{
					ErrorArray = vf_Exists(itmTmp, ErrorArray, FieldArray[2]);
					if (ErrorArray != "") {
						GotoField == "";
					}
				break;
				}
			case "NOBLANK": 
				{	
					//alert("itmTmp = " + itmTmp);
					if(itmTmp) {
						ErrorArray = vf_NoBlank(itmTmp, ErrorArray, FieldArray[2]);
					
						//alert("NoBlank returned " + ErrorArray + ", i = " + i);
						if (ErrorArray != "") {
							if (GotoField == "") {
								if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
									GotoField = "";
								} else {
									GotoField = FieldArray[0];
								}
							}
						}
					}
				break;
				}
			case "ISNUMBER":
				{
					if(itmTmp) {
						ErrorArray = vf_IsNumber(itmTmp, ErrorArray, FieldArray[2]);
						if (ErrorArray != "") {
							if (GotoField == "") {
								if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
									GotoField = "";
								} else {
									GotoField = FieldArray[0];
								}
							}
						}
					}
				break;
				}
			case "ISDATE":
				{
					if(itmTmp) {
						ErrorArray = vf_IsDate(itmTmp, ErrorArray, FieldArray[2]);
						if (ErrorArray != "") {
							if (GotoField == "") {
								if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
									GotoField = "";
								} else {
									GotoField = FieldArray[0];
								}
							}
						}
						//alert("gotofield = " + GotoField);
					}
				break;
				}
			case "LENGTHBETWEEN":
				{
					if(itmTmp) {
						ErrorArray = vf_LengthBetween(itmTmp, ErrorArray, FieldArray[2], FieldArray[3], FieldArray[4]);
						if (ErrorArray != "") {
							if (GotoField == "") {
								if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
									GotoField = "";
								} else {
									GotoField = FieldArray[0];
								}
							}
						}
					}
				break;
				}
			case "NUMRANGE":
				{
					if(itmTmp) {
						ErrorArray = vf_NumRange(itmTmp, ErrorArray, FieldArray[2], FieldArray[3], FieldArray[4]);
						if (ErrorArray != "") {
							if (GotoField == "") {
								if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
									GotoField = "";
								} else {
									GotoField = FieldArray[0];
								}
							}
						}
					}
				break;
				}
			case "ISLIKE":
				{
					if(itmTmp) {
						ErrorArray = vf_IsLike(itmTmp, ErrorArray, FieldArray[2], FieldArray[4]);
						if (ErrorArray != "") {
							if (GotoField == "") {
								if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
									GotoField = "";
								} else {
									GotoField = FieldArray[0];
								}
							}
						}
					}
				break;
				}
			case "NOBLANKNUM":
				{
					if(itmTmp) {
						ErrorArray = vf_NoBlankNum(itmTmp, ErrorArray, FieldArray[2]);
						if (ErrorArray != "") {
							if (GotoField == "") {
								if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
									GotoField = "";
								} else {
									GotoField = FieldArray[0];
								}
							}
						}
					}
				break;
				}
			case "MAXLENGTH":
				//alert("maxlength");
				{
					if(itmTmp) {
						ErrorArray = vf_MaxLength(itmTmp, ErrorArray, FieldArray[2], FieldArray[3]);
						if (ErrorArray != "") {
							if (GotoField == "") {
								if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
									GotoField = "";
								} else {
									GotoField = FieldArray[0];
								}
							}
						}
					}
				break;
				}
			case "VALIDDATE":
				//alert("valid date");
				{
					if(itmTmp) {
						ErrorArray = vf_ValidDate(itmTmp, ErrorArray, FieldArray[2]);
						if (ErrorArray != "") {
							if (GotoField == "") {
								if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
									GotoField = "";
								} else {
									GotoField = FieldArray[0];
								}
							}
						}
					}
				break;
				}
			default:
				{
					//you've used a non-supported validation code. Shame on you! I'll just write a little note in the ErrorArray.

					if (ErrorArray == "") {
						ErrorArray = "Internal Validation Error: " + FieldArray[1].toUpperCase() + " Validation Code not supported";
					} else {
						ErrorArray = ErrorArray + "|" + "Internal Validation Error: " + FieldArray[1].toUpperCase() + " Validation Code not supported";
					}
					if (GotoField == "") {
						if(eval("oForm." + FieldArray[0] + ".type") == "hidden") {
							GotoField = "";
						} else {
							GotoField = FieldArray[0];
						}
					}
				}
			}
		} else {
			//This section handles the case where the validation code does not refer to an actual field on the form.
			//if (ErrorArray == "") {
			//	ErrorArray = "Internal Validation Error: This form does not have a field named " + FieldArray[0];
			//} else {
			//	ErrorArray = ErrorArray + "|" + "Internal Validation Error: This form does not have a field named " + FieldArray[0];
			//}
		}
	}
	//If the code calling this function wants the focus to be placed on the
	//first offending field, do so here.
	if (ErrorArray != "" && doGoto) {
		if(GotoField != "") {	
			if(eval("oForm." + GotoField + ".type")) {
				eval("oForm." + GotoField + ".focus()");
			} else {
				eval("oForm." + GotoField + "[0].focus()");
			}
		}
	}
	//alert("ValidateForm returning " + ErrorArray);
	return ErrorArray;
}

function vf_Exists(FieldName, ErrorArray, ErrMsg) {
	var strDefaultMessage;
	var passedValidation = true;
	
	//Construction the default message
	strDefaultMessage = "The field does not exist";
	if(!FieldName) {
		passedValidation = false;
	}
	if (!passedValidation) {
		if (ErrMsg.toUpperCase() == "DEFAULT") {
			if (ErrorArray == "") {
				ErrorArray = "* " + strDefaultMessage;
			} else {
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		} else {
			if (ErrorArray == "") {
				ErrorArray = "* " + ErrMsg;
			} else {
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}
		}
	}
	//alert("Returning ->" + ErrorArray + "<-");
	return ErrorArray;
}
function vf_NoBlank(FieldName, ErrorArray, ErrMsg)
{
	var strDefaultMessage;
	var passedValidation = true;


	//Construct the default message
	if (FieldName.name) {
		strDefaultMessage = "The " + FieldName.name + " field cannot be blank.";
	} else {
		strDefaultMessage = "The " + FieldName[0].name + " field cannot be blank.";
	}
	switch (FieldName.type) {
	case "text":
	case "textarea":
	case "hidden":
	case "password":
	case "file":
		if (Trim(FieldName.value) == "") {
			passedValidation = false;
		}
		break;
	case "select-one":
	case "select-many":
		if (FieldName.options[FieldName.selectedIndex].text == "") {
			passedValidation = false;
		}
		break;
	case "select-multiple":
		if (FieldName.selectedIndex < 0)
		{
			passedValidation = false;
		}
		break;
	case "radio":
	case "checkbox":
	default:
		//alert("FieldName[0].type = " + FieldName[0].type);
		passedValidation = false;
		for(j=0; j<FieldName.length; j++) {
			if (FieldName[j].checked) {
				passedValidation = true;
				break;
			}
		}
		break;
	}
	if (!passedValidation)
	{
		if (ErrMsg.toUpperCase() == "DEFAULT")
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + strDefaultMessage;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		}
		else
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + ErrMsg;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}

		}
	}
	//alert("Returning ->" + ErrorArray + "<-");
	return ErrorArray;
}

function vf_IsNumber(FieldName, ErrorArray, ErrMsg)
{
	var strDefaultMessage;

	strDefaultMessage = "The " + FieldName.name + " field must contain a number.";

	//This line tests the condition: Is the value in the field a number? If it isn't, it's an error. Blanks are ok too.
	if (isNaN(Trim(FieldName.value)))
	{
		if (ErrMsg.toUpperCase() == "DEFAULT")
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + strDefaultMessage;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		}
		else
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + ErrMsg;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}

		}
	}
	return ErrorArray;
}

function vf_NoBlankNum(FieldName, ErrorArray, ErrMsg)
{
	var strDefaultMessage;
	var passedValidation = true;


	//Construct the default message
	strDefaultMessage = "The " + FieldName.name + " field cannot be blank and must be a number.";

	//These lines tests the condition: Is the field blank and if it isn't is it a number? If it is blank or if it is a non-number, it's an error.
	if (Trim(FieldName.value) == "" || isNaN(Trim(FieldName.value))) {
		passedValidation = false;
	}

	if (!passedValidation)
	{
		if (ErrMsg.toUpperCase() == "DEFAULT")
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + strDefaultMessage;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		}
		else
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + ErrMsg;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}

		}
	}
	return ErrorArray;
}
function vf_IsDate(FieldName, ErrorArray, ErrMsg)
{
	var strDefaultMessage;
	strDefaultMessage = "The " + FieldName.name + " field must be a date.";
	if (Trim(FieldName.value) == "") return ErrorArray;	//Blanks are ok.

	//This line tests the condition: does the value in the field parse out to a date? If it doesn't it's an error.
	if (isNaN(Date.parse(Trim(FieldName.value))))
	{
		if (ErrMsg.toUpperCase() == "DEFAULT")
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + strDefaultMessage;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		}
		else
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + ErrMsg;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}

		}
	}
	return ErrorArray;
}
function vf_LengthBetween(FieldName, ErrorArray, ErrMsg, LowerLength, UpperLength)
{
	var strDefaultMessage;
	var NoLower;
	var NoUpper;
	var GotError = 0;

	//This function is more complicated. You have to ensure that:
		//1. LowerLength exists and is a number OR
		//2. UpperLength exists and is a number OR
		//3. Both LowerLength and UpperLength exist, are numbers AND
			//3.1 LowerLength + 1 < UpperLength (if LowerLength = 4 and UpperLength = 5, you can't enter a valid number of characters.)
	//Only if these conditions exist is it possible to proceed.

	if (FieldName.value == "") return ErrorArray;

	if (LowerLength.length == 0) {NoLower = 1}
	else {NoLower = 0}

	if (UpperLength.length == 0) {NoUpper = 1}
	else {NoUpper = 0}

	if ((NoLower && !isNaN(UpperLength)) ||
	   (NoUpper && !isNaN(LowerLength)) ||
	   (!isNaN(LowerLength) && !isNaN(UpperLength)))

	{} else
	{
		if (NoLower && NoUpper)
		{
			strError = "Internal Error: Both upper and lower parameters cannot be blank";
			GotError = 1;
		}
		else if (NoUpper && isNaN(LowerLength))
		{
			strError = "Internal Error: The lower parameter must be a number";
			GotError = 1;
		}
		else if (NoLower && isNaN(UpperLength))
		{
			strError = "Internal Error: The upper parameter must be a number";
			GotError = 1;
		}
		else if (isNaN(UpperLength) || isNaN(LowerLength))
		{
			strError = "Internal Error: upper and lower parameters must be numbers";
			GotError = 1;
		}
	}

	if (parseInt(LowerLength) > parseInt(UpperLength))
	{
		strError = "Internal Error: Lower parameter cannot be greater than the Upper parameter";
		GotError = 1;
	}
	else if (Math.abs(LowerLength - UpperLength) <= 1)
	{
		strError = "Internal Error: Lower and upper parameters must have a difference of at least 2";
		GotError = 1;
	}

	if (GotError)
	{
		if (ErrorArray == "")
		{
			ErrorArray = "* " + strError;
		}
		else
		{
			ErrorArray = ErrorArray + "|* " + strError;
		}
	return ErrorArray;
	}

	//We've verified all the parameters, now we can proceed to test the field value.
	//The default message depends on what parameters were entered.
	strDefaultMessage = "The " + FieldName.name + " field must ";
	if (NoLower)
	{
		strDefaultMessage = strDefaultMessage + "have less than " + UpperLength + " characters.";
		strUseCase = "LessThan";
	}

	if (NoUpper)
	{
		strDefaultMessage = strDefaultMessage + "have more than " + LowerLength + " characters.";
		strUseCase = "MoreThan";
	}

	if (!NoLower && !NoUpper)
	{
		strDefaultMessage = strDefaultMessage + " have more than " + LowerLength + " and less than " + UpperLength + " characters.";
		strUseCase = "Range";
	}

	PassedValidation = 1;

	//Now we actually test the value's length against the parameters.
	switch (strUseCase) {

	case "LessThan":
	{
		if (FieldName.value.length >= UpperLength)
			{ PassedValidation = 0 }
		break;
	}
	case "MoreThan":
	{
		if (FieldName.value.length - 1 < LowerLength)
			{ PassedValidation = 0 }
		break;
	}
	case "Range":
	{
		if ((FieldName.value.length - 1 < LowerLength) | (FieldName.value.length + 1 > UpperLength))
			{ PassedValidation = 0 }
		break;
	}
	} //end switch
	if (!PassedValidation)
	{
		if (ErrMsg.toUpperCase() == "DEFAULT")
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + strDefaultMessage;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		}
		else
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + ErrMsg;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}
		}
	}
	return ErrorArray;
}

function vf_NumRange(FieldName, ErrorArray, ErrMsg, LowerRange, UpperRange)
{
	var strDefaultMessage;
	var NoLower;
	var NoUpper;
	var GotError = 0;

	//This function is more complicated. You have to ensure that:
		//1. LowerRange exists and is a number OR
		//2. UpperRange exists and is a number OR
		//3. Both LowerRange and UpperRange exist, are numbers AND
			//3.1 LowerRange < UpperRange
	//Only if these conditions exist is it possible to proceed.

	if (FieldName.value == "") return ErrorArray;

	if (LowerRange.length == 0) {NoLower = 1}
	else {NoLower = 0}

	if (UpperRange.length == 0) {NoUpper = 1}
	else {NoUpper = 0}
	
	if(NoLower && NoUpper) {
		strError = "Internal Error: Both upper and lower parameters cannot be blank.";
		GotError = 1;
	} else {
		if ((NoLower && !isNaN(UpperRange)) ||
		   (NoUpper && !isNaN(LowerRange)) ||
		   (!isNaN(LowerRange) && !isNaN(UpperRange)))

		{} else
		{
			if (NoUpper && isNaN(LowerRange))
			{
				strError = "Internal Error: The lower parameter must be a number";
				GotError = 1;
			}
			else if (NoLower && isNaN(UpperRange))
			{
				strError = "Internal Error: The upper parameter must be a number";
				GotError = 1;
			}
			else if (isNaN(UpperRange) || isNaN(LowerRange))
			{
				strError = "Internal Error: upper and lower parameters must be numbers";
				GotError = 1;
			}
		}
	}

	if (parseFloat(LowerRange) > parseFloat(UpperRange))
	{
		strError = "Internal Error: Lower parameter cannot be greater than the Upper parameter";
		GotError = 1;
	}
	
	if (GotError)
	{
		if (ErrorArray == "")
		{
			ErrorArray = "* " + strError;
		}
		else
		{
			ErrorArray = ErrorArray + "|* " + strError;
		}
	return ErrorArray;
	}

	//We've verified all the parameters, now we can proceed to test the field value.
	//The default message depends on what parameters were entered.
	strDefaultMessage = "The " + FieldName.name + " field must ";
	if (NoLower)
	{
		strDefaultMessage = strDefaultMessage + "be a number  less than " + UpperRange + ".";
		strUseCase = "LessThan";
	}

	if (NoUpper)
	{
		strDefaultMessage = strDefaultMessage + "be a number greater than " + LowerRange + ".";
		strUseCase = "MoreThan";
	}

	if (!NoLower && !NoUpper)
	{
		strDefaultMessage = strDefaultMessage + " be a number greater than " + LowerRange + " and less than " + UpperRange + ".";
		strUseCase = "Range";
	}

	PassedValidation = 1;	

	//Now we actually test the value's length against the parameters.
	if (isNaN(parseFloat(FieldName.value))) {
		PassedValidation = 0
	} else {
		switch (strUseCase) {

		case "LessThan":
		{
			if (parseFloat(FieldName.value) > parseFloat(UpperRange))
				{ PassedValidation = 0 }
			break;
		}
		case "MoreThan":
		{
			if (parseFloat(FieldName.value) < parseFloat(LowerRange))
				{ PassedValidation = 0 }
			break;
		}
		case "Range":
		{
			if ((parseFloat(FieldName.value) < parseFloat(LowerRange)) || (parseFloat(FieldName.value) > parseFloat(UpperRange)))
				{ PassedValidation = 0 }
			break;
		}
		} //end switch
	}
	if (!PassedValidation)
	{
		if (ErrMsg.toUpperCase() == "DEFAULT")
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + strDefaultMessage;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		}
		else
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + ErrMsg;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}
		}
	}
	return ErrorArray;
}


function vf_IsLike(FieldName, ErrorArray, ErrMsg, PatternMatch)
{
	var strDefaultMessage;
	var re;
	strDefaultMessage = "The " + FieldName.name + " must look like " + PatternMatch + ".";
	if (FieldName.value == "") return ErrorArray;	//blanks are ok.

	//PatternMatch is a regular expression. We must eval it.
	re = eval(PatternMatch);

	//This line tests the condition: Does the value in the field match the regular expression. If it doesn't, it's an error.
	if (FieldName.value.search(re) == -1)
	{
		if (ErrMsg.toUpperCase() == "DEFAULT")
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + strDefaultMessage;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		}
		else
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + ErrMsg;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}

		}
	}
	return ErrorArray;
}

function Trim(InputString) {
	if(InputString == "") return InputString;
	startIndex = InputString.length;
	for (i2=0; i2 < InputString.length; i2++) {
		if(InputString.charAt(i2) != " ") {
			startIndex = i2;
			break;
		}
	}
	finishIndex = 0;
	for (j2=InputString.length - 1; j2 >= 0; j2--) {
		if(InputString.charAt(j2) != " ") {
			finishIndex = j2;
			break;
		}
	}
	return InputString.substr(startIndex, finishIndex - startIndex + 1);
}

// Added KO 09-27-01
// tests for maximum length of a field value and truncates existing value 
//		to maximum length
function vf_MaxLength(FieldName, ErrorArray, ErrMsg, MaxLength)
{
	//alert("testing maxlength on " + FieldName.name + " with " + MaxLength + " characters");
	
	var strDefaultMessage;
	var passedValidation = true;

	//Construct the default message
	if (FieldName.name) {
		strDefaultMessage = "The " + FieldName.name + " field cannot be more than " + MaxLength + " characters.";
	} else {
		strDefaultMessage = "The " + FieldName[0].name + " field cannot be more than " + MaxLength + " characters.";
	}
	
	if (FieldName.value == "") return ErrorArray;	//blanks are ok.
	
	//Check field value length
	if (FieldName.value.length > MaxLength) passedValidation = false;
	
	if (!passedValidation)
	{
		//Truncate current value
		FieldName.value = FieldName.value.substr(0,MaxLength);
		
		//Add error message to error array
		if (ErrMsg.toUpperCase() == "DEFAULT")
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + strDefaultMessage;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		}
		else
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + ErrMsg;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}

		}
	}
	
	//return
	return ErrorArray;
}

// Added KO 09-27-01
// tests for a valid date
function vf_ValidDate(FieldName, ErrorArray, ErrMsg)
{
	//alert("testing valid date on " + FieldName.name);

	var strDefaultMessage;
	var passedValidation = true;

	//Construct the default message
	if (FieldName.name) {
		strDefaultMessage = "The " + FieldName.name + " field must be a valid date.";
	} else {
		strDefaultMessage = "The " + FieldName[0].name + " field must be a valid date.";
	}
	
	if (FieldName.value == "") return ErrorArray;	//blanks are ok.

	// **************** TEST FOR VALID DATE
	// Checks for the following valid date formats:
	// MM/DD/YY   MM/DD/YYYY   MM-DD-YY   MM-DD-YYYY
	// Also separates date into month, day, and year variables

	// To allow a 2 or 4 digit year entry, use this line instead:
	var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{2}|\d{4})$/;

	// To require a 4 digit year entry, use this line:
	//   var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{4})$/;

	var matchArray = FieldName.value.match(datePat); // is the format ok?

	if (matchArray == null) 
	{
		//alert("Date is not in a valid format.")
		//return false;
		passedValidation = false;
	} else {

		month = matchArray[1]; // parse date into variables
		day = matchArray[3];
		year = matchArray[4];

		// check month range
		if (month < 1 || month > 12) 
		{ 
			//alert("Month must be between 1 and 12.");
			//return false;
			passedValidation = false;
		} else {

			if (day < 1 || day > 31) 
			{
				//alert("Day must be between 1 and 31.");
				//return false;
				passedValidation = false;
			} else {

				if ((month==4 || month==6 || month==9 || month==11) && day==31) 
				{
					//alert("Month "+month+" doesn't have 31 days!")
					//return false
					passedValidation = false;
				} else {

					// check for february 29th
					if (month == 2) 
					{ 
						var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
						if (day>29 || (day==29 && !isleap)) {
							//alert("February " + year + " doesn't have " + day + " days!");
							//return false;
							passedValidation = false;
						}
					}
					
				}
				
			}
			
		}
		
	}
	
	// **************** END TEST FOR VALID DATE

	if (!passedValidation)
	{
		//Add error message to error array
		if (ErrMsg.toUpperCase() == "DEFAULT")
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + strDefaultMessage;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + strDefaultMessage;
			}
		}
		else
		{
			if (ErrorArray == "")
			{
				ErrorArray = "* " + ErrMsg;
			}
			else
			{
				ErrorArray = ErrorArray + "|* " + ErrMsg;
			}

		}
	}
	
	//return
	return ErrorArray;
}
///////////////////////////////////////////////////////////////////////////////
// checks for a valid email address 
///////////////////////////////////////////////////////////////////////////////
function validEmail(emailStr)
{
	var checkTLD=1;

	var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;
	var emailPat=/^(.+)@(.+)$/;
	var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";
	var validChars="\[^\\s" + specialChars + "\]";
	var quotedUser="(\"[^\"]*\")";
	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;
	var atom=validChars + '+';
	var word="(" + atom + "|" + quotedUser + ")";
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");

	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("Email address seems incorrect (check @ and .'s)");
		return false;
	}

	var user = matchArray[1];
	var domain = matchArray[2];

	// Start by checking that only basic ASCII characters are in the strings (0-127).

	for (i=0; i<user.length; i++)
	{
		if (user.charCodeAt(i) > 127)
		{
			alert("Ths username contains invalid characters.");
			return false;
   		}
	}

	for (i=0; i<domain.length; i++)
	{
		if (domain.charCodeAt(i) > 127)
		{
			alert("Ths domain name contains invalid characters.");
			return false;
   		}
	}

	// 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.  Check if it's valid.
	var atomPat = new RegExp("^" + atom + "$");
	var domArr = domain.split(".");
	var len = domArr.length;

	for(i = 0; i < len; i++)
	{
		if (domArr[i].search(atomPat) == -1)
		{
			alert("The domain name does not seem to be valid.");
			return false;
   		}
	}

	// domain name seems valid, but now make sure that it ends in a
	// known top-level domain (like com, edu, gov) or a two-letter word,
	// representing country (uk, nl), and that there's a hostname preceding 
	// the domain or country.
	if (checkTLD && domArr[domArr.length-1].length != 2 && 
		domArr[domArr.length-1].search(knownDomsPat) == -1)
	{
		alert("The address must end in a well-known domain or two letter " + "country.");
		return false;
	}

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

	return true;
}