/*----------------------------------------------------------------------------*\
	*	Generic Form Validation
	*	Clientside JavaScript include
	*
	*	Purpose: To provide generic, but extendable, form validation.
	*	Author: Donald F. Sivori Jr. June 8, 2001.
	*			gcr & associates
	*
	*       History: 
         *        $Workfile: validate.js $
         *       $Revision: 6 $ -->
         * Last Change By: $Author: Vbothello $ 
         * Last Change Date: $$Modtime: 3/23/04 6:31p $ 
	*
	*	Exported Objects: 
	*		FormValObj
	*			To define: var formVal = new FormValObj(formID, formName);
	*			Properties:
	*				id			Id of form
	*				name		Form Name
	*				items		Collection of input validation objects
	*			Methods:
	*				Add(validationObject)	Adds a validation object to items
	*				Validate(showMsg)		Validates form, returns as string with error messages
	*										for all invalid inputs found, delimited by new line chars.
	*										Setting showMsg=true causes Validate to display the errors
	*										using the alert() function.
	*
	*		GenericValObj
	*			To define: var inputVal = new GenericValObj(inputID, fieldName, inputType, isRequired, valParams);
	*			Properties:
	*				id			id of input element
	*				type		input type:'numeric','date','time','datetime','text','email','username', or 'password'
	*				isRequired	True for required field
	*				params		additional parameter strings. (see AddToValidation() below)
	*			Methods:
	*				Validate(showMsg) Validates input. Returns error message. Set showMsg = true to cause
	*									alert() to show error message;
	*
	*	Exported Routines:
	*	  AddToValidation(formValObj, inputID, inputtype, isRequired, valParams)
	*		Purpose: Add validation for input element to formValObj.
	*		Where:
	*			formValObj is the global declared above.
	*			inputID is the ID of the input element.
	*			inputType is one of 'numeric','currency','date','time','datetime','text','email','username','password'
	*			isRequired is true or false.
	*			valParams is addition validation instructions:
	*				"range min#:max#" Checks number against min and max. ex: "range 10:100".
	*				"min min#"		For numbers tests agains minimum, for text min# is minimum length of strng.
	*				"max max#"		For numbers tests agains maximum, for text max# is maximum length of strng.
	*				"match regexp"	Checks text against the regular expression regexp.
	*
	*	  AddToValidationExt(formValObj, inputID, inputtype, isRequired, valParams,valFunc)
	*		Purpose: Add validation for input element to formValObj, but substitutes custom
	*			validation function for default validation.
	*
	*		Where:
	*			formValObj is the global declared above.
	*			inputID is the ID of the input element.
	*			inputType is one of 'numeric','date','time','datetime','text','email',
	*                 'username','password'
	*			isRequired is true or false.
	*			valParams is addition validation instructions:
	*				"range min#:max#" Checks number against min and max. ex: "range 10:100".
	*				"min min#"		For numbers tests agains minimum, for text min# is 
	*								minimum length of strng.
	*				"max max#"		For numbers tests agains maximum, for text max# is 
	*								maximum length of strng.
	*				"match regexp"	Checks text against the regular expression regexp.
	*			valFunc Custom validation function
	*		valFunc prototype:
	*		function valFunc(showMsg)
	*		{
	*			// this = GenericValObj, for example the type is this.type
	*		}
	*-----------------------------------------------------------------------------
	* To use default validations add the following in the HTML header :
	*-----------------------------------------------------------------------------
	*	<!-- Include javascript genutil //-->
	*	<SCRIPT LANGUAGE=javascript src='genutil.js'></SCRIPT>
	*	<!-- Include validation scripts //-->
	*	<SCRIPT LANGUAGE=javascript src='validate.js'></SCRIPT>
	*	<SCRIPT LANGUAGE=javascript>
	*	<!--
	*		// Declaration of form validation object
	*		var form1Val = new FormValObj("form1","form1");
	*	
	*	//-->
	*	</SCRIPT>
	*
	* For each input to validate: 
	* <SCRIPT LANGUAGE=javascript> 
	*	AddToValidation(form1Val, inputID, inputtype, isRequired, valparams)
	* </SCRIPT>
	*
	* To execute validation on the form:
	* <INPUT type="button" value="Submit" id=submit1 name=submit1 
	*		onclick=" msg=form1Val.Validate(true);">
	*
	\*----------------------------------------------------------------------------*/
	
	/*----------------------------------------------------------------------------*\
	*  Some constants
	\*----------------------------------------------------------------------------*/
	
	/*----------------------------------------------------------------------------*\
	 * Default Validation Method for the GenericValObj object.
	 *	showMsg = true to show error message
	 *	return false if validation fails
	 *
	 * Ex:
	 *		var valObj = new GenericValObj(inputID, "My Field", "text", false, "")
	 *
	 *		valObj.Validate(true);
	\*----------------------------------------------------------------------------*/
	function GenericValidate(showMsg)
	{
		var genFloat = new Number();
		var genText = new String();
		var genDate = new Date();
		var validInput = new Boolean();
		var paramArray = new Array();
		var paramDataArray = new Array();
		var errorMsg = new String();
		var textMatch = new RegExp();
		var emailPattern = new RegExp("\\w+@[A-Za-z0-9._-]+\n","i");
		
		var inputObj = GetFormElemByID(document,this.id);
		
		errorMsg = "";
		validInput = true;	// initialize as valid input		
		
		
		if (inputObj.value.length > 0)
		{
			switch (this.type.toLowerCase())
			{
			case "numeric" :
				
				genText = inputObj.value;
				// Get rid of commas before parsing
				textMatch = new RegExp("^[\\d,+-][\\d]*\\.?\\d*$","i");
				if (textMatch.test(genText))
				{
					genFloat = parseFloat(genText.replace(",",""));
					if (!isNaN(genFloat))
					{

						if (this.params.length > 0)
						{ // There are more parameters
							paramArray = this.params.split("~");
							switch (paramArray[0])
							{
							case "range" :
								paramDataArray = paramArray[1].split(":");
								if (parseFloat(paramDataArray[0]) > genFloat || genFloat > parseFloat(paramDataArray[1]))
								{ // genFloat is out of range paramDataArray[0] <= genFloat <= paramDataArray[1]
									validInput = false;
									errorMsg = "must be between " + paramDataArray[0] + " and " + paramDataArray[1];
								}
								break;
							case "min" :
								if ( genFloat < parseFloat(paramArray[1]) )
								{ // genFloat is below minimum
									validInput = false;
									errorMsg = "must be greater than " + paramArray[1];								
								}
								break;
							case "max" :
								if ( genFloat > parseFloat(paramArray[1]) )
								{ // genFloat is above maximum
									validInput = false;
									errorMsg = "must be less than " + paramArray[1];								
								}
								break;

							}
						}
					}
					else
					{
						errorMsg = "must be numeric";
						validInput = false;
					}
				}
				else
				{
					errorMsg = "must be numeric";
					validInput = false;
				}
				break;
			case "currency" :
				
				genText = inputObj.value;
				// Get rid of commas before parsing
				textMatch = new RegExp("^[\\$]?[\\d+-][\\d,]*\\.?\\d*$","i");
				if (textMatch.test(genText))
				{
					genText = genText.replace("$","")
					genFloat = parseFloat(genText.replace(",",""));
					if (!isNaN(genFloat))
					{

						if (this.params.length > 0)
						{ // There are more parameters
							paramArray = this.params.split("~");
							switch (paramArray[0])
							{
							case "range" :
								paramDataArray = paramArray[1].split(":");
								if (parseFloat(paramDataArray[0]) > genFloat || genFloat > parseFloat(paramDataArray[1]))
								{ // genFloat is out of range paramDataArray[0] <= genFloat <= paramDataArray[1]
									validInput = false;
									errorMsg = "must be between " + paramDataArray[0] + " and " + paramDataArray[1];
								}
								break;
							case "min" :
								if ( genFloat < parseFloat(paramArray[1]) )
								{ // genFloat is below minimum
									validInput = false;
									errorMsg = "must be greater than " + paramArray[1];								
								}
								break;
							case "max" :
								if ( genFloat > parseFloat(paramArray[1]) )
								{ // genFloat is above maximum
									validInput = false;
									errorMsg = "must be less than " + paramArray[1];								
								}
								break;

							}
						}
					}
					else
					{
						errorMsg = "must be currency";
						validInput = false;
					}
				}
				else
				{
					errorMsg = "must be currency";
					validInput = false;
				}
				break;
			case "datetime" :
				genDate = ValidateDateTime(inputObj.value);
				if (!isNaN(genDate))
				{
					if (this.params.length > 0)
					{ // There are more parameters
						paramArray = this.params.split("~");
						switch (paramArray[0])
						{
						case "range" :
							paramDataArray = paramArray[1].split(":");
							if (ValidateDateTime(paramDataArray[0]) > genDate || genDate > ValidateDateTime(paramDataArray[1]))
							{ // date is out of range paramDataArray[0] <= genDate <= paramDataArray[1]
								validInput = false;
								errorMsg = "must be between " + paramDataArray[0] + " and " + paramDataArray[1];
							}
							break;
						case "min" :
							if ( genDate < ValidateDateTime(paramArray[1]) )
							{ // genDate is below minimum
								validInput = false;
								errorMsg = "must be greater than " + paramArray[1];								
							}
							break;
						case "max" :
							if ( genDate > ValidateDateTime(paramArray[1]) )
							{ // genDate is above maximum
								validInput = false;
								errorMsg = "must be less than " + paramArray[1];								
							}
							break;

						} // End Switch
					} // End if Params.length > 0
				}
				else
				{
					errorMsg = "must be a date and time";
					validInput = false;
				}
				break;
			case "date" :
				genDate = ValidateDate(inputObj.value)
				if (!isNaN(genDate))
				{

					if (this.params.length > 0)
					{ // There are more parameters
						paramArray = this.params.split("~");
						switch (paramArray[0])
						{
						case "range" :
							paramDataArray = paramArray[1].split(":");
							if (ValidateDate(paramDataArray[0]) > genDate || genDate > ValidateDate(paramDataArray[1]))
							{ // date is out of range paramDataArray[0] <= genDate <= paramDataArray[1]
								validInput = false;
								errorMsg = "must be between " + paramDataArray[0] + " and " + paramDataArray[1];
							}
							break;
						case "min" :
							if ( genDate < ValidateDate(paramArray[1]) )
							{ // genDate is below minimum
								validInput = false;
								errorMsg = "must be greater than " + paramArray[1];								
							}
							break;
						case "max" :
							if ( genDate > ValidateDate(paramArray[1]) )
							{ // genDate is above maximum
								validInput = false;
								errorMsg = "must be less than " + paramArray[1];								
							}
							break;

						} // End Switch
					} // End if Params.length > 0
				
				}
				else
				{
					errorMsg = "must be a date";
					validInput = false;
				}
				break;
				
			case "time" :
				genDate = ValidateTime(inputObj.value);
				if (!isNaN(genDate))
				{
					if (this.params.length > 0)
					{ // There are more parameters
						paramArray = this.params.split("~");
						switch (paramArray[0])
						{
						case "range" :
							paramDataArray = paramArray[1].split(":");
							if (ValidateTime(paramDataArray[0]) > genDate || genDate > ValidateTime(paramDataArray[1]))
							{ // date is out of range paramDataArray[0] <= genDate <= paramDataArray[1]
								validInput = false;
								errorMsg = "must be between " + paramDataArray[0] + " and " + paramDataArray[1];
							}
							break;
						case "min" :
							if ( genDate < ValidateTime(paramArray[1]) )
							{ // genDate is below minimum
								validInput = false;
								errorMsg = "must be greater than " + paramArray[1];								
							}
							break;
						case "max" :
							if ( genDate > ValidateTime(paramArray[1]) )
							{ // genDate is above maximum
								validInput = false;
								errorMsg = "must be less than " + paramArray[1];								
							}
							break;

						} // End Switch
					}
				}
				else
				{
					errorMsg = "must be a time";
					validInput = false;
				}
				break;
			case "text" :
				genText = inputObj.value;
				if (this.params.length > 0)
				{ // There are more parameters
					paramArray = this.params.split("~");
					switch (paramArray[0])
					{
					case "match" :  // test with passed regular expression
						textMatch = new RegExp(paramArray[1]);
						if (! textMatch.test(genText))
						{
							validInput = false;
							errorMsg = "must match pattern";
						}
						break;
					case "min" :
						if (genText.length < parseInt(paramArray[1]))
						{
							validInput = false;
							errorMsg = "must be longer than " + paramArray[1];					
						}
						break;
					case "max" :
						if (genText.length > parseInt(paramArray[1]))
						{
							validInput = false;
							errorMsg = "must be shorter than " + paramArray[1];					
						}
						break;
					}
					if (paramArray.length >= 3 && !validInput) 
					{
						// Use alternate message
						errorMsg = paramArray[2];
					}
				}
				break;
			case "email" :
				genText = inputObj.value + "\n"
				if (!emailPattern.test(genText))
				{
					errorMsg = "must be a valid email address";
					validInput = false;
				}
				break;
			case "username" :
				genText = inputObj.value;
				textMatch = new RegExp("^\\w+$","i");
				if (textMatch.test(genText))
				{
					if (this.params.length > 0)
					{ // There are more parameters
						paramArray = this.params.split("~");
						switch (paramArray[0])
						{
						case "min" :
							if (genText.length < parseInt(paramArray[1]))
							{
								validInput = false;
								errorMsg = "must be longer than " + paramArray[1];					
							}
							break;
						case "max" :
							if (genText.length > parseInt(paramArray[1]))
							{
								validInput = false;
								errorMsg = "must be shorter than " + paramArray[1];					
							}
							break;
						}
					}
				}
				else
				{
					validInput = false;
					errorMsg = "must contain only letters, numbers, underscore or dash";
				}
				break;
			case "password" :
				genText = inputObj.value;
				textMatch = new RegExp("^\\w+$","i");
				if (textMatch.test(genText))
				{
				if (this.params.length > 0)
				{ // There are more parameters
					paramArray = this.params.split("~");
					switch (paramArray[0])
					{
					case "min" :
						if (genText.length < parseInt(paramArray[1]))
						{
							validInput = false;
							errorMsg = "must be longer than " + paramArray[1];					
						}
						break;
					case "max" :
						if (genText.length > parseInt(paramArray[1]))
						{
							validInput = false;
							errorMsg = "must be shorter than " + paramArray[1];					
						}
						break;
					}
				}
				}
				else
				{
					validInput = false;
					errorMsg = "must contain only letters, numbers, underscore or dash";
				}
				break;
			}
		}
		else
		{
			if (this.isRequired)
			{
				errorMsg = "is required";
				validInput = false;
			}
		}
		
		// see if we want to show a message now
		if (validInput)
		{	// return null on no error
			errorMsg = null;
		}
		else
		{
			if (showMsg)
			{
				alert ( this.fieldName + " " + errorMsg + ".");	
			}
		}
		
		return errorMsg;
	}
	
	/* validate date and time */
	function ValidateDateTime(dateTimeStr)
	{
		//var datePart;
		//var timePart;
		var isValid = new Boolean(true);
		var datePattern = new RegExp();
		var datePatternRes;
		var dateInput = new Date();
		var dateString = new String();
		var dateMonth = new String();
		var dateYear = new Number();
		var dateDay = new Number();
		var minutes = new String();
		var hours = new Number();
		var amPm = new String();
		
		datePattern = new RegExp("^(\\d?\\d)/(\\d?\\d)/(\\d{2,4})\\s(\\d?\\d):?(\\d?\\d)\\s*(am|pm)?$","i");
		isValid = datePattern.test(dateTimeStr);
		if (isValid)
		{ // Matches pattern, test for good date
			datePatternRes = datePattern.exec(dateTimeStr);
			dateDay = parseInt(datePatternRes[2]);
			dateMonth = MonthName(parseInt(datePatternRes[1]));
			dateYear = parseInt(datePatternRes[3]);
			hours = parseInt(datePatternRes[4]);
			minutes = parseInt(datePatternRes[5]);
			amPm = datePatternRes[6].toLowerCase();
			
			if (dateYear < 100)
			{ // Convert 2 digit years to 4 digit. All other years taken as is.
				if (dateYear < 20)
					dateYear = 2000 + dateYear;
				else
					dateYear = 1900 + dateYear;
			}
			
			if (amPm.length == 2)
			{ // AM-PM time
				if (hours <= 12 && hours > 0)
				{
					if (amPm == "pm")
					{
						hours = hours + 12;
						if (hours >= 24) hours = 0;
					}
					else
						isValid = false;
				}
				else
					isValid = false;
			}
			else
			{ // 24 hour clock
				if (hours > 24 || hours < 0)
					isValid = false;
			}
			
			if (isValid)
			{
				if (minutes > 59 || minutes < 0)
					isValid = false
			}
			
			if (isValid)
			{
				dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString() + " " + hours + ":" + minutes + " " + amPm;
				//alert(dateString);
				dateInput = new Date(Date.parse(dateString));
				isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
			}
		}
		else
		{
			datePattern = new RegExp("^(\\d?\\d)-(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)-(\\d{2,4})\\s(\\d?\\d):?(\\d?\\d)\\s*(am|pm)?$","i");
			isValid = datePattern.test(dateTimeStr);
			//alert (dateTimeStr + " " + isValid.toString());
			if (isValid)
			{ // Matches pattern, test for good date
				datePatternRes = datePattern.exec(dateTimeStr);
				dateDay = parseInt(datePatternRes[1]);
				dateMonth = datePatternRes[2];
				dateYear = parseInt(datePatternRes[3]);
				hours = parseInt(datePatternRes[4]);
				minutes = parseInt(datePatternRes[5]);
				amPm = datePatternRes[6].toLowerCase();
				//alert (hours + " " + minutes + " " + amPm);
				if (dateYear < 100)
				{ // Convert 2 digit years to 4 digit. All other years taken as is.
					if (dateYear < 20)
						dateYear = 2000 + dateYear;
					else
						dateYear = 1900 + dateYear;
				}
				
				if (amPm.length == 2)
				{ // AM-PM time
					if (hours <= 12 && hours > 0)
					{
						if (amPm.toLowerCase() == "pm")
						{
							hours = hours + 12;
							if (hours >= 24) hours = 0;
						}
					}
					else
						isValid = false;
				}
				else
				{ // 24 hour clock
					if (hours > 24 || hours < 0)
						isValid = false;
				}
				
				if (isValid)
				{
					if (minutes > 59 || minutes < 0)
						isValid = false
				}
				
				if (isValid)
				{
					dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString() + " " + hours + ":" + minutes + " " + amPm;
					dateInput = new Date(Date.parse(dateString));
					
					isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
				}
			}
			else
			{
				datePattern = new RegExp("^(\\d?\\d)-(january|february|march|april|may|june|july|august|september|october|november|december)-(\\d{2,4})\\s(\\d?\\d):(\\d?\\d)\\s*(am|pm)?$","i");
				isValid = datePattern.test(dateTimeStr);
				if (isValid)
				{ // Matches pattern, test for good date
					datePatternRes = datePattern.exec(dateTimeStr);
					dateDay = parseInt(datePatternRes[1]);
					dateMonth = datePatternRes[2];
					dateYear = parseInt(datePatternRes[3]);
					hours = parseInt(datePatternRes[4]);
					minutes = parseInt(datePatternRes[5]);
					amPm = datePatternRes[6].toLowerCase();
					
					if (dateYear < 100)
					{ // Convert 2 digit years to 4 digit. All other years taken as is.
						if (dateYear < 20)
							dateYear = 2000 + dateYear;
						else
							dateYear = 1900 + dateYear;
					}
					
					if (amPm.length == 2)
					{ // AM-PM time
						if (hours <= 12 && hours > 0)
						{
							if (amPm.toLowerCase() == "pm")
							{
								hours = hours + 12;
								if (hours >= 24) hours = 0;
							}
						}
						else
							isValid = false;
					}
					else
					{ // 24 hour clock
						if (hours > 24 || hours < 0)
							isValid = false;
					}
					
					if (isValid)
					{
						if (minutes > 59 || minutes < 0)
							isValid = false
					}
					
					if (isValid)
					{
						dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString() + " " + hours + ":" + minutes + " " + amPm;
						dateInput = new Date(Date.parse(dateString));
						
						isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
					}
				}
				else
				{
					datePattern = new RegExp("^(january|february|march|april|may|june|july|august|september|october|november|december)\\s(\\d?\\d),\\s*(\\d{2,4})\\s(\\d?\\d):(\\d?\\d)\\s*(am|pm)?$","i");
					isValid = datePattern.test(dateTimeStr);
					if (isValid)
					{ // Matches pattern, test for good date
						datePatternRes = datePattern.exec(dateTimeStr);
						dateDay = parseInt(datePatternRes[2]);
						dateMonth = datePatternRes[1];
						dateYear = parseInt(datePatternRes[3]);
						hours = parseInt(datePatternRes[4]);
						minutes = parseInt(datePatternRes[5]);
						amPm = datePatternRes[6].toLowerCase();
						
						if (dateYear < 100)
						{ // Convert 2 digit years to 4 digit. All other years taken as is.
							if (dateYear < 20)
								dateYear = 2000 + dateYear;
							else
								dateYear = 1900 + dateYear;
						}
						
						if (amPm.length == 2)
						{ // AM-PM time
							if (hours <= 12 && hours > 0)
							{
								if (amPm.toLowerCase() == "pm")
								{
									hours = hours + 12;
									if (hours >= 24) hours = 0;
								}
							}
							else
								isValid = false;
						}
						else
						{ // 24 hour clock
							if (hours > 24 || hours < 0)
								isValid = false;
						}
						
						if (isValid)
						{
							if (minutes > 59 || minutes < 0)
								isValid = false
						}
						if (isValid)
						{
							dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString() + " " + hours + ":" + minutes + " " + amPm;
							dateInput = new Date(Date.parse(dateString));
							
							isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
						}
					}
					else
					{
						datePattern = new RegExp("^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\s(\\d?\\d),\\s*(\\d{2,4})\\s(\\d?\\d):(\\d?\\d)\\s*(am|pm)?$","i");
						isValid = datePattern.test(dateTimeStr);
						if (isValid)
						{ // Matches pattern, test for good date
							datePatternRes = datePattern.exec(dateTimeStr);
							dateDay = parseInt(datePatternRes[2]);
							dateMonth = datePatternRes[1];
							dateYear = parseInt(datePatternRes[3]);
							hours = parseInt(datePatternRes[4]);
							minutes = parseInt(datePatternRes[5]);
							amPm = datePatternRes[6].toLowerCase();
						
							if (dateYear < 100)
							{ // Convert 2 digit years to 4 digit. All other years taken as is.
								if (dateYear < 20)
									dateYear = 2000 + dateYear;
								else
									dateYear = 1900 + dateYear;
							}
							
							if (amPm.length == 2)
							{ // AM-PM time
								if (hours <= 12 && hours > 0)
								{
									if (amPm.toLowerCase() == "pm")
									{
										hours = hours + 12;
										if (hours >= 24) hours = 0;
									}
									//else
									//	isValid = false;
								}
								else
									isValid = false;
							}
							else
							{ // 24 hour clock
								if (hours > 24 || hours < 0)
									isValid = false;
							}
							
							if (isValid)
							{
								if (minutes > 59 || minutes < 0)
									isValid = false
							}
							
							if (isValid)
							{
								dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString() + " " + hours + ":" + minutes + " " + amPm;
								dateInput = new Date(Date.parse(dateString));
								
								isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
							}
						}

					}
				}
			}
		}
		
		if (isValid)
			return dateInput;
		else
			return NaN;
		
	}
	
	/* Validate Date */
	function ValidateDate(dateTimeStr)
	{
		var isValid = new Boolean(true);
		var datePattern = new RegExp();
		var datePatternRes;
		var dateInput = new Date();
		var dateString = new String();
		var dateMonth = new String();
		var dateYear = new Number();
		var dateDay = new Number();
		
		datePattern = new RegExp("^(\\d?\\d)/(\\d?\\d)/(\\d{2,4})$","i");
		isValid = datePattern.test(dateTimeStr);
		if (isValid)
		{ // Matches pattern, test for good date
			datePatternRes = datePattern.exec(dateTimeStr);
			dateDay = parseInt(datePatternRes[2]);
			dateMonth = MonthName(parseInt(datePatternRes[1]));
			dateYear = parseInt(datePatternRes[3]);
			
		//vb
		 var datestr = datePatternRes[2]
		 var monthstr = datePatternRes[1]

		   if (datestr.charAt(0) == '0')
			{
			    datestr= datestr.substring(1,2); // remove any leading zeros 
			    dateDay = parseInt(datestr);
			}
			
		   if (monthstr.charAt(0) == '0')
			{
			    monthstr= monthstr.substring(1,2); // remove any leading zeros 
			    dateMonth = MonthName(parseInt(monthstr));
			}
		      //
			
			
			
			if (dateYear < 100)
			{ // Convert 2 digit years to 4 digit. All other years taken as is.
				if (dateYear < 20)
					dateYear = 2000 + dateYear;
				else
					dateYear = 1900 + dateYear;
			}
			
			dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString();
			dateInput = new Date(Date.parse(dateString));
			isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
		}
		else
		{
			datePattern = new RegExp("^(\\d?\\d)-(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)-(\\d{2,4})$","i");
			isValid = datePattern.test(dateTimeStr);
			if (isValid)
			{ // Matches pattern, test for good date
				datePatternRes = datePattern.exec(dateTimeStr);
				dateDay = parseInt(datePatternRes[1]);
				dateMonth = datePatternRes[2];
				dateYear = parseInt(datePatternRes[3]);
			
				if (dateYear < 100)
				{ // Convert 2 digit years to 4 digit. All other years taken as is.
					if (dateYear < 20)
						dateYear = 2000 + dateYear;
					else
						dateYear = 1900 + dateYear;
				}
			
				dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString();
				dateInput = new Date(Date.parse(dateString));
				isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
			}
			else
			{
				datePattern = new RegExp("^(\\d?\\d)-(january|february|march|april|may|june|july|august|september|october|november|december)-(\\d{2,4})$","i");
				isValid = datePattern.test(dateTimeStr);
				if (isValid)
				{ // Matches pattern, test for good date
					datePatternRes = datePattern.exec(dateTimeStr);
					dateDay = parseInt(datePatternRes[1]);
					dateMonth = datePatternRes[2];
					dateYear = parseInt(datePatternRes[3]);
			
					if (dateYear < 100)
					{ // Convert 2 digit years to 4 digit. All other years taken as is.
						if (dateYear < 20)
							dateYear = 2000 + dateYear;
						else
							dateYear = 1900 + dateYear;
					}
			
					dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString();
					dateInput = new Date(Date.parse(dateString));
					isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
				}
				else
				{
					datePattern = new RegExp("^(january|february|march|april|may|june|july|august|september|october|november|december)\\s(\\d?\\d),\\s*(\\d{2,4})$","i");
					isValid = datePattern.test(dateTimeStr);
					if (isValid)
					{ // Matches pattern, test for good date
						datePatternRes = datePattern.exec(dateTimeStr);
						dateDay = parseInt(datePatternRes[2]);
						dateMonth = datePatternRes[1];
						dateYear = parseInt(datePatternRes[3]);
			
						if (dateYear < 100)
						{ // Convert 2 digit years to 4 digit. All other years taken as is.
							if (dateYear < 20)
								dateYear = 2000 + dateYear;
							else
								dateYear = 1900 + dateYear;
						}
			
						dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString();
						dateInput = new Date(Date.parse(dateString));
						isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
					}
					else
					{
						datePattern = new RegExp("^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\s(\\d?\\d),\\s*(\\d{2,4})$","i");
						isValid = datePattern.test(dateTimeStr);
						if (isValid)
						{  // Matches pattern, test for good date
							datePatternRes = datePattern.exec(dateTimeStr);
							dateDay = parseInt(datePatternRes[2]);
							dateMonth = datePatternRes[1];
							dateYear = parseInt(datePatternRes[3]);
			
							if (dateYear < 100)
							{ // Convert 2 digit years to 4 digit. All other years taken as is.
								if (dateYear < 20)
									dateYear = 2000 + dateYear;
								else
									dateYear = 1900 + dateYear;
							}
			
							dateString = dateMonth + " " + dateDay.toString() + ", " + dateYear.toString();
							dateInput = new Date(Date.parse(dateString));
							isValid = (!isNaN(dateInput) && dateDay == dateInput.getDate());
						}
					}
				}
			}
		}
		if (isValid)
			return dateInput;
		else
			return NaN;
	
	}
	
	/* Validate Time */
	function ValidateTime(dateTimeStr)
	{
		var isValid = new Boolean(true);
		var timeMatch;
		var hours = new Number();
		var minutes = new Number();
		var datePattern = new RegExp();
		var timeInput = new Date();
		
		datePattern = new RegExp("^(\\d?\\d):(\\d?\\d)\\s*(am|pm)?$","i");
		isValid = datePattern.test(dateTimeStr);
		if (isValid)
		{
			timeMatch = datePattern.exec(dateTimeStr);
			hours = parseInt(timeMatch[1]);
			minutes = parseInt(timeMatch[2]);
			
			if (timeMatch[3].length > 0)
			{ // Am-Pm time
				//alert ("AM-PM");
				if (hours <= 12 && hours > 0 && minutes <= 59 && minutes >= 0)
				{ // time parts in correct range.
					if (timeMatch[3].toLowerCase() == "pm")
					{
						hours = hours + 12;
						if (hours == 24) hours = 0;
					}
					
				}
				else
					isValid = false;
			}
			else
			{ // 24 hour clock
				//alert("24 hour clock");
				if (hours >= 24 || hours < 0 || minutes > 59 || minutes < 0)
					isValid = false;
			}
		}
		else
		{ // Test by the military pattern
			datePattern = new RegExp("^(\\d\\d)(\\d\\d)$","i");
			isValid = datePattern.test(dateTimeStr);
			if (isValid)
			{
				timeMatch = datePattern.exec(dateTimeStr);
				hours = parseInt(timeMatch[1]);
				minutes = parseInt(timeMatch[2]);
				
				if (hours >= 24 || hours < 0 || minutes > 59 || minutes < 0)
					isValid = false;
			}
		}
		
		if (isValid)
		{
			timeInput.setHours(hours,minutes,0); // Set Hours, Minutes and seconds
			return timeInput;
		}
		else
			return NaN;
	}
	
	
	/* Validation Object Constructor 
	 *	inputID = ID attribute of input element
	 *  fieldName = Readable name of input field for display on error messages
	 *	inputType = Data types "numeric","datetime", "date", "time","text", "email", "username", "password"
	 *	isRequires = true or false
	 *	valParams = additional parameters based on data type
	 */
	function GenericValObj(inputID, fieldName, inputType, isRequired, valParams)
	{
		this.id = inputID || "" ;
		this.fieldName = fieldName || "" ;
		this.type = inputType || "" ;
		this.isRequired = isRequired || false ;
		this.isValid = true;
		this.params = valParams || "" ;
		this.Validate = GenericValidate;
		
	}
	
	/*----------------------------------------------------------------------------*\
	*	HiLiteField
	*
	*	Set background color to high lite a field
	\*----------------------------------------------------------------------------*/
	function ToggleFieldHiLite(inputID)
	{
		var bgColor;
		var fgColor;
		
		var inputObj = GetFormElemByID(document,inputID);
		if (inputObj)
		{
			if (inputObj.style)
			{
				bgColor = inputObj.style.backgroundColor;
				fgColor = inputObj.style.color;
				inputObj.style.backgroundColor=fgColor;
				inputObj.style.color=fgColor;
			}
			else
			{
				bgColor = inputObj.style.backgroundColor;
				fgColor = inputObj.style.color;
				inputObj.style.backgroundColor=fgColor;
				inputObj.style.color=fgColor;
			}
		}
	}

	/*----------------------------------------------------------------------------*\
	*	ClearHiLiteField
	*
	*	Clear background color highlite.
	\*----------------------------------------------------------------------------*/
	function ClearHiLiteField(inputID)
	{
		var inputObj = GetFormElemByID(document,inputID);
		if (inputObj)
		{
			if ( inputObj.style)
				inputObj.style.backgroundColor="";
			else
				inputObj.backgroundColor="";
		}
	}
	
	/*----------------------------------------------------------------------------*\
	*	ValidateItemArray
	*
	*	Validate method for FormValObj.
	\*----------------------------------------------------------------------------*/
	function ValidateItemArray(showMsg)
	{
		var i;
		var errorMsg = new String();
		var formErrorMsg = new String();
		var itemValid = new Boolean();
		var formValid = new Boolean(true);
		
		
		for (i=0; i < this.items.length; i++)
		{
			errorMsg = this.items[i].Validate(false);
			if (errorMsg)
			{// Collect item errors
				formErrorMsg = formErrorMsg + this.items[i].fieldName + " " + errorMsg + ".\n";
				//HiLiteField(this.items[i].id);
			}
			else
				ClearHiLiteField(this.items[i].id);
			
		}
		
		if (showMsg && formErrorMsg.length > 0) 
			alert(formErrorMsg);
			
		return formErrorMsg;
	}
	
	/*----------------------------------------------------------------------------*\
	*	AddValObj
	*
	*	Add object method for FormValObj.
	\*----------------------------------------------------------------------------*/
	function AddValObj(valID, valObj)
	{
		
		this.items[this.items.length] = valObj;
	}
	
	/*----------------------------------------------------------------------------*\
	*	FormValObj
	*
	*	Construction for FormValObj object.
	\*----------------------------------------------------------------------------*/
	function FormValObj(formID, formName)
	{
		this.id = formID;
		this.name = formName;
		this.items = new Array();
		this.Add = AddValObj;
		this.Validate = ValidateItemArray;
	}
	
	/*----------------------------------------------------------------------------*\
	*		AddToValidation(formValObj, inputID, inputtype, isRequired, valParams)
	*		Where:
	*			formValObj is the global declared above.
	*			inputID is the ID of the input element.
	*			inputType is one of 'numeric','date','time','datetime','text','email',
	*                 'username','password'
	*			isRequired is true or false.
	*			valParams is addition validation instructions:
	*				"range min#:max#" Checks number against min and max. ex: "range 10:100".
	*				"min min#"		For numbers tests agains minimum, for text min# is 
	*								minimum length of strng.
	*				"max max#"		For numbers tests agains maximum, for text max# is 
	*								maximum length of strng.
	*				"match regexp"	Checks text against the regular expression regexp.
	*
	\*----------------------------------------------------------------------------*/
	function AddToValidation(formVal, inputID, fieldName, inputType, isRequired, valParams)
	{
		var itemObj;
		
		if (formVal)
		{
			itemObj = new GenericValObj(inputID, fieldName, inputType, isRequired, valParams);
			formVal.Add(inputID,itemObj);
		}
		
		
	}
	
	/*----------------------------------------------------------------------------*\
	* GenericValObjExt
	*
	*	Constructor for extended Generic Validation Object.
	*
	\*----------------------------------------------------------------------------*/
	function GenericValObjExt(inputID, fieldName, inputType, isRequired, valParams, valFunc)
	{
		this.base = GenericValObj;
		this.base(inputID, fieldName, inputType, isRequired, valParams)
		this.Validate = valFunc;
		this.DefaultValidate = GenericValidate;
	}
	GenericValObjExt.prototype = new GenericValObj;
	
	/*----------------------------------------------------------------------------*\
	*		AddToValidationExt(formValObj, inputID, inputtype, isRequired, valParams,valFunc)
	*		Where:
	*			formValObj is the global declared above.
	*			inputID is the ID of the input element.
	*			inputType is one of 'numeric','date','time','datetime','text','email',
	*                 'username','password'
	*			isRequired is true or false.
	*			valParams is addition validation instructions:
	*				"range min#:max#" Checks number against min and max. ex: "range 10:100".
	*				"min min#"		For numbers tests agains minimum, for text min# is 
	*								minimum length of strng.
	*				"max max#"		For numbers tests agains maximum, for text max# is 
	*								maximum length of strng.
	*				"match regexp"	Checks text against the regular expression regexp.
	*			valFunc Custom validation function
	\*----------------------------------------------------------------------------*/
	function AddToValidationExt(formVal, inputID, fieldName, inputType, isRequired, valParams,valFunc)
	{
		var itemObj;
		
		if (formVal)
		{
			itemObj = new GenericValObjExt(inputID, fieldName, inputType, isRequired, valParams,valFunc);
			//itemObj.Validate = valFunc;
			
			formVal.Add(inputID,itemObj);
		}
		
	}