/*------------------------------------------------------------------------------

	Name:

		include/BaseFramework/js/Validation.js

	Synopsis:

		onSubmit="return SubmitData('dataform',aELEMENTS);
		onClick="SubmitData('dataform',aELEMENTS);

	Modified by TJC on 7/19/2004:

		Modified to use ACC++ for the constants so that we can put new
		values in without renumbering everything.

		Added the DATE_NOREQ error type to allow blank string for a date.

		Rewrote isFloatNumber.  The pattern /\d|\./ was returning true if
		either a digit or a period were found in the number string.  This
		was not really checking the validity of the string.  Changed it
		to split the number on the decimal point and check each side (if
		it is defined) with /\D/ pattern which looks for any non-digit.

		Modified NUMBERRANGE so that blank string is accepted.  Previously
		it returned an empty error string.  Thus if a blank string was
		passed to the number range check, it stopped checking (as if there
		were an error) but did not notify the user of any error.

		Fixed GetErrorString.  See comments on get error string.

	Modified by TJC on 8/9/2004:

		Added return true or false to SubmitData and SubmitDataCustom so that
		onSubmit="return submitdata..." will stop the submit if there are
		errors in the validation.  Hitting the enter key was bypassing the
		onClick event handler and submitting forms without validation.  The
		onSubmit will submit unless the "return onSubmit..." is used and thus
		the SubmitData function here must return a true or false for this
		all to work.

	MR8643331 - Modified by TJC on 10/04/2004:

		Incorporated COMPARE.  This is the preferred path for this file.  There
		is an exact copy of this in include/js/ACCEL_Validation.js

	MR8643433 - Added MUSTSET test for elements

	MR8643509 - Added MINVALUEOPTION for option list only.

	MR8643814 - Modified by TJC on 5/17/2007
		Allow negative number for NUMERIC option.
		
	MR8643964 - Added blSubmitData for Template Input Validation

	Examples:

		<script>
			var aELEMENTS = new Array();

			Check for unset radio buttons
			aELEMENTS[0] = ['prospectcustomer','Prospect or Customer',[[EMPTY,,]]];

			Check for valid date or blank string
			aELEMENTS[1] = ['startdate','Start Date',[[DATE_NOREQ,,]]];
			aELEMENTS[2] = ['probclosedate','Probable Close Date',[[DATE_NOREQ,,]]];

			Check for integer number range.  First check for integer, then recheck
			for range.
			aELEMENTS[3] = ['probwin','Probability of Win',[[INTEGER,,]]];
			aELEMENTS[4] = ['probwin','Probability of Win',[[NUMBERRANGE,0,100]]];

			Check for valid floating point number
			aELEMENTS[5] = ['amount','One Time Revenue',[[CURRENCY,,]]];
			aELEMENTS[6] = ['annualrecurringrevenue','Annual Recurring Revenue',[[CURRENCY,,]]];

			Check for alphanumeric values
			aELEMENTS[7] = ['newopportunity','New Opportunity',[[ALPHANUMERIC,,]]];
			aELEMENTS[8] = ['accountname','Account Name',[[ALPHANUMERIC,,]]];
			aELEMENTS[9] = ['opportunityname','Opportunity Name',[[ALPHANUMERIC,,]]];
			aELEMENTS[10] = ['description','Description',[[ALPHANUMERIC,,]]];

			Make options with value less than 0 non-selectable
			aELEMENTS[11] = ['manager', 'Manager', [[MINVALUEOPTION,0,]]];
		</script>

------------------------------------------------------------------------------*/
//------------------------ERROR TYPES-------------------------------------------
var ACC							= 1
var EMPTY						= ACC++;
var OVERFLOW					= ACC++;
var MIN							= ACC++;
var MAX							= ACC++;
var RANGE						= ACC++;
var TEXT						= ACC++;
var INTEGER						= ACC++;
var NUMERIC						= ACC++;
var CURRENCY					= ACC++;
var ALPHANUMERIC				= ACC++;
var DATE						= ACC++;
var DATE_NOREQ					= ACC++;
var DATERANGE					= ACC++;
var FILENAME					= ACC++;
var PHONENUMBER					= ACC++;
var ZIPCODE						= ACC++;
var SSNUMBER					= ACC++;
var TEXTRANGE					= ACC++;
var NUMBERRANGE					= ACC++;
var MAXNUMBERSELECTED			= ACC++;
var MINNUMBERSELECTED			= ACC++;
var CUSTOM						= ACC++;
var COMPARE						= ACC++;
var MUSTSET						= ACC++;
var MINVALUEOPTION				= ACC++;

//------------------------------------------------------------------------------

//------------------------ERROR CODES-------------------------------------------
ACC = 0;
var ERR_NOERROR 				= ACC++;
var ERR_EMPTY 					= ACC++;
var ERR_OVERFLOW 				= ACC++;
var ERR_OUTOFRANGE 				= ACC++;
var ERR_INVALIDPHONENUMBER 		= ACC++;
var ERR_INVALIDFILENAME 		= ACC++;
var ERR_INVALIDZIPCODE 			= ACC++;
var ERR_INVALIDSSNUMBER 		= ACC++;
var ERR_DATATYPETEXT 			= ACC++;
var ERR_DATATYPEINTEGER 		= ACC++;
var ERR_DATATYPENUMERIC 		= ACC++;
var ERR_DATATYPECURRENCY		= ACC++;
var ERR_DATATYPEALPHANUMERIC 	= ACC++;
var ERR_INVALIDDATE 			= ACC++;
var ERR_OUTOFTEXTRANGE 			= ACC++;
var ERR_OUTOFNUMBERRANGE 		= ACC++;
var ERR_MAXNUMBERSELECTED 		= ACC++;
var ERR_MINNUMBERSELECTED 		= ACC++;
var ERR_COMPARE					= ACC++;
var ERR_MUSTSET					= ACC++;
var ERR_MINVALUEOPTION			= ACC++;
//------------------------------------------------------------------------------

//------------------------ERROR STRINGS-----------------------------------------
var ERRSTR_NOERROR = 0;
var ERRSTR_EMPTY = "The %%FIELD%% field is empty and requires a value.";
var ERRSTR_OVERFLOW = "The value in the %%FIELD%% field is too long. The value can not exceed %%VALUE1%% characters." ;
var ERRSTR_OUTOFRANGE = "The value in the %%FIELD%% field is out of range. The field requires at least %%VALUE1%% characters, but not more than %%VALUE2%% characters." ;
var ERRSTR_INVALIDPHONE = "The phone number entered into the %%FIELD%% field is invalid.";
var ERRSTR_INVALIDFILENAME = "The file name entered into the %%FIELD%% field is invalid.\nThe file name cannot contain any of the following characters:\n /  \\  :  ;  *  ?  <  >  |  \"";
var ERRSTR_INVALIDZIPCODE = "The zip code entered into the %%FIELD%% field is invalid.";
var ERRSTR_INVALIDSSNUMBER = "Then social security number entered into the %%FIELD%% is invalid.  It must be of the format xxx-xx-xxxx.";
var ERRSTR_DATATYPETEXT = "The value in the %%FIELD%% field must be text only.";
var ERRSTR_DATATYPEINTEGER = "The value in the %%FIELD%% field must be an integer.";
var ERRSTR_DATATYPECURRENCY = "The value in the %%FIELD%% field may contain a leading $, commas, and one decimal point.";
var ERRSTR_DATATYPENUMERIC = "The value in the %%FIELD%% field must be valid number";
var ERRSTR_DATATYPEALPHANUMERIC = "The value in the %%FIELD%% field may contain only alphanumeric characters.";
var ERRSTR_INVALIDDATE = "The date value in the %%FIELD%% is invalid.";
var ERRSTR_OUTOFTEXTRANGE = "The value in the %%FIELD%% field is out of range.  The value must be between %%VALUE1%% and %%VALUE2%% .";
var ERRSTR_OUTOFNUMBERRANGE = "The value in the %%FIELD%% field is out of range. The field must be between %%VALUE1%% and %%VALUE2%% ." ;
var ERRSTR_MAXNUMBERSELECTED = "The %%FIELD%% allows a maximum of %%VALUE1%% items to be selected.";
var ERRSTR_MINNUMBERSELECTED = "This field requires that a minimum of %%VALUE1%% values be selected.";
var ERRSTR_COMPARE = "The %%FIELD%% fields do not match."
var ERRSTR_MUSTSET = "The %%FIELD%% must be set."
var ERRSTR_MINVALUEOPTION = "This option is not selectable"
//------------------------------------------------------------------------------

//-----------------------ELEMENT ARRAY------------------------------------------
var EL_NAME = 0;
var EL_TITLE = 1;
var EL_ERRORATTR = 2;

var EL_ERRORTYPE = 0;
var EL_VALUE1 = 1;
var EL_VALUE2 = 2;
//------------------------------------------------------------------------------

//------------------------ERROR ARRAY-------------------------------------------
var AERR_ERRORCODE = 0;
var AERR_FIELDNAME = 1;
var AERR_ERRORSTRING = 2;
var AERR_VALUE1 = 3;
var AERR_VALUE2 = 4;
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------


function SubmitData(frm,aEL) {
	var aERR;
	aERR = ValidateForm(frm,aEL);
	if (aERR[0] == ERR_NOERROR) {
		document[frm].submit();
	} else {
		alert(GetErrorString(aERR));
	}
}

function blSubmitData(frm, aEL) {

	var aERR;
	var rtn;
	
	aERR = ValidateForm(frm, aEL);
	
	if (aERR[0] == ERR_NOERROR) {
		document[frm].submit();
		rtn = true;
	} else {
		alert(GetErrorString(aERR));
		rtn = false;
	}
	return rtn;
}

function SubmitDataCustom(frm,aEL,mthd) {
	var aERR;
	aERR = ValidateForm(frm,aEL);
	if (aERR[0] == ERR_NOERROR) {
		eval(mthd);
	} else {
		alert(GetErrorString(aERR));
	}
}
//-----------------------------------------------------------

//-----------------------------------------------------------
function ValidateForm(frm,aEL) {
	var DataEl, DataElType, DataValue;

	var a_err = new Array;
	var err = ERR_NOERROR;
	var errtype;
	var val1, val2;

	a_err[AERR_ERRORCODE] = ERR_NOERROR;
	a_err[AERR_FIELDNAME] = "";
	a_err[AERR_ERRORSTRING] = "";

	for (var i = 0; i < aEL.length; i++) {
		DataEl = document[frm][aEL[i][EL_NAME]];
		if (DataEl) {
		
			DataElType = DataEl.type;

			//alert("Form: "+frm+"\nElement("+i+"): "+aEL[i][EL_NAME]+"\nType: "+DataElType);
			
			if (DataElType == "select-one") {

				DataValue = DataEl.options[DataEl.selectedIndex].value;
				for (var x = 0; x < aEL[i][EL_ERRORATTR].length; x++) {

					errtype = aEL[i][EL_ERRORATTR][x][EL_ERRORTYPE];
					val1 = aEL[i][EL_ERRORATTR][x][EL_VALUE1];
					val2 = aEL[i][EL_ERRORATTR][x][EL_VALUE2];

					switch (errtype) 
					{
						case EMPTY:
							if (!IsAValueSelected(frm,aEL[i][EL_NAME])) {
								a_err[AERR_ERRORCODE] = ERR_EMPTY;
								a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
								a_err[AERR_ERRORSTRING] = ERRSTR_EMPTY;	       
							}
				
							break;
						case MUSTSET:
							if (!IsAValueSelected(frm,aEL[i][EL_NAME]) || DataValue == 0) {
								a_err[AERR_ERRORCODE] = ERR_MUSTSET;
								a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
								a_err[AERR_ERRORSTRING] = ERRSTR_MUSTSET;	       
							}
				
							break;
						case MINVALUEOPTION:
							if (DataValue < val1) {
								a_err[AERR_ERRORCODE] = ERR_MINVALUEOPTION;
				        a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
				        a_err[AERR_ERRORSTRING] = ERRSTR_MINVALUEOPTION;
							}
							break;
					}

				} // end for (var x = 0; x < aEL[i][EL_ERRORATTR].length; x++

			} else if (DataElType == "select-multiple") {

				//punt

			} else if (DataElType == "text" || DataElType == "textarea" || DataElType == "hidden" || DataElType == "password") {

				DataValue = DataEl.value;
				for (var x = 0; x < aEL[i][EL_ERRORATTR].length; x++) {

					errtype = aEL[i][EL_ERRORATTR][x][EL_ERRORTYPE];
					val1 = aEL[i][EL_ERRORATTR][x][EL_VALUE1];
					val2 = aEL[i][EL_ERRORATTR][x][EL_VALUE2];

					if (errtype == EMPTY && DataValue == "") {
						a_err[AERR_ERRORCODE] = ERR_EMPTY;
						a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
						a_err[AERR_ERRORSTRING] = ERRSTR_EMPTY;
						return a_err;
					}

					if (errtype == COMPARE && DataValue != document[frm][aEL[val1][EL_NAME]].value) {
			         	 a_err[AERR_ERRORCODE] = ERR_COMPARE;
			         	 a_err[AERR_FIELDNAME] = aEL[val1][EL_TITLE];
			         	 a_err[AERR_ERRORSTRING] = ERRSTR_COMPARE;
			         	 return a_err;
           			}

					if (errtype == MAX && DataValue.length > val1) {

			         	a_err[AERR_ERRORCODE] = ERR_OVERFLOW;
			         	a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
			         	a_err[AERR_ERRORSTRING] = ERRSTR_OVERFLOW;
			         	a_err[AERR_VALUE1] = val1;
						return a_err;
					}

					if (errtype == RANGE && (DataValue.length < val1 || DataValue.length > val2)) {
						a_err[AERR_ERRORCODE] = ERR_OUTOFRANGE;
						a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
						a_err[AERR_ERRORSTRING] = ERRSTR_OUTOFRANGE;
						a_err[AERR_VALUE1] = val1;
						a_err[AERR_VALUE2] = val2;
						return a_err;
					}

					if (errtype == TEXT) {
						if (!isText(DataValue)) {
							a_err[AERR_ERRORCODE] = ERR_DATATYPETEXT;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_DATATYPETEXT;
							return a_err;
						}
					}

					if (errtype == INTEGER) {
						if (!isInteger(DataValue)) {
							a_err[AERR_ERRORCODE] = ERR_DATATYPEINTEGER;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_DATATYPEINTEGER;
							return a_err;
						}
					}

					if (errtype == NUMERIC) {
						if (!isFloatNumber(DataValue)) {
							a_err[AERR_ERRORCODE] = ERR_DATATYPENUMERIC;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_DATATYPENUMERIC;
							return a_err;
						}
					}

					if (errtype == CURRENCY) {
						if (!isCurrency(DataValue)) {
							a_err[AERR_ERRORCODE] = ERR_DATATYPECURRENCY;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_DATATYPECURRENCY;
							return a_err;
						}
					}

					if (errtype == ALPHANUMERIC) {
						if (!isAlphaNumeric(DataValue)) {
							a_err[AERR_ERRORCODE] = ERR_DATATYPEALPHANUMERIC;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_DATATYPEALPHANUMERIC;
							return a_err;
						}
					}

					if (errtype == PHONENUMBER) {
						if (!isPhoneNumberFormatValid(DataValue,val1)) {
							a_err[AERR_ERRORCODE] = ERR_INVALIDPHONENUMBER;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_INVALIDPHONE;
							return a_err;
						}
					}

					if (errtype == FILENAME) {
						if (!IsFileNameLegal(DataValue)) {
							a_err[AERR_ERRORCODE] = ERR_INVALIDFILENAME;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_INVALIDFILENAME;
							return a_err;
						}
					}

					if (errtype == ZIPCODE) {
						if (!isZipCodeValid(DataValue)) {
							a_err[AERR_ERRORCODE] = ERR_INVALIDZIPCODE;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_INVALIDZIPCODE;
							return a_err;
						}
					}

					if (errtype == SSNUMBER) {
						if (!isSSNFormatValid(DataValue)) {
							a_err[AERR_ERRORCODE] = ERR_INVALIDSSNUMBER;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_INVALIDSSNUMBER;
							return a_err;
						}
					}

					if (errtype == DATE) {
						if (fn_isDate(DataValue,val1,aEL[i][EL_TITLE]) < 0) {
							a_err[AERR_ERRORCODE] = ERR_INVALIDDATE;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_INVALIDDATE;
							return a_err;
						}
					}

					if (errtype == DATE_NOREQ) {
						if (fn_isDateNreq(DataValue,val1,aEL[i][EL_TITLE]) < 0) {
							a_err[AERR_ERRORCODE] = ERR_INVALIDDATE;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_INVALIDDATE;
							return a_err;
						}
					}

					if (errtype == TEXTRANGE) {
						if (!isValidTextRange(DataValue,val1,val2)) {
							a_err[AERR_ERRORCODE] = ERR_OUTOFTEXTRANGE;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_OUTOFTEXTRANGE;
							a_err[AERR_VALUE1] = val1;
							a_err[AERR_VALUE2] = val2;
							return a_err;
						}
					}

					if (errtype == NUMBERRANGE) {

						if (DataValue != "") {

							if (!(DataValue >= val1 && DataValue <= val2)) {
								a_err[AERR_ERRORCODE] = ERR_OUTOFNUMBERRANGE;
								a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
								a_err[AERR_ERRORSTRING] = ERRSTR_OUTOFNUMBERRANGE;
								a_err[AERR_VALUE1] = val1;
								a_err[AERR_VALUE2] = val2;
								return a_err;
							}
						}
					}
				} // end for

			} else if (DataElType == "radio" || DataElType == "checkbox") {

				if (errtype == EMPTY) {
					if (!IsAValueSelected(frm,aEL[i][EL_NAME])) {
						a_err[AERR_ERRORCODE] = ERR_EMPTY;
						a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
						a_err[AERR_ERRORSTRING] = ERRSTR_EMPTY;
					}
				}

			} else {

				for (var x = 0; x < aEL[i][EL_ERRORATTR].length; x++) {

					var errtype = aEL[i][EL_ERRORATTR][x][EL_ERRORTYPE];
					var val1 = aEL[i][EL_ERRORATTR][x][EL_VALUE1];
					var val2 = aEL[i][EL_ERRORATTR][x][EL_VALUE2];

					if (errtype == EMPTY) {
						if (!IsAValueSelected(frm,aEL[i][EL_NAME])) {
							a_err[AERR_ERRORCODE] = ERR_EMPTY;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_EMPTY;
						}
					}

					if (errtype == MAXNUMBERSELECTED) {
						if (NumberOfValuesSelected(frm,aEL[i][EL_NAME]) > val1) {
							a_err[AERR_ERRORCODE] = ERR_MAXNUMBERSELECTED;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_MAXNUMBERSELECTED;
							a_err[AERR_VALUE1] = val1;
						}
					}

					if (errtype == MINNUMBERSELECTED) {
						if (NumberOfValuesSelected(frm,aEL[i][EL_NAME]) < val1) {
							a_err[AERR_ERRORCODE] = ERR_MINNUMBERSELECTED;
							a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
							a_err[AERR_ERRORSTRING] = ERRSTR_MINNUMBERSELECTED;
							a_err[AERR_VALUE1] = val1;
						}
					}

				} // end for
			}
		} else {
			//	This is specifically intended to handle the case where one radio
			//	button must be set (which would be the default) but if none are
			//	set the radio button array doesn't exist (cf. EditRegistrationCode.asp)
			//	This can be used anywhere that an element is created dynamically
			//	and needs to be checked to see if it exists.

			for (var x = 0; x < aEL[i][EL_ERRORATTR].length; x++) {

				errtype = aEL[i][EL_ERRORATTR][x][EL_ERRORTYPE];
				val1 = aEL[i][EL_ERRORATTR][x][EL_VALUE1];
				val2 = aEL[i][EL_ERRORATTR][x][EL_VALUE2];

				if (errtype == MUSTSET) {
					a_err[AERR_ERRORCODE] = ERR_MUSTSET;
					a_err[AERR_FIELDNAME] = aEL[i][EL_TITLE];
					a_err[AERR_ERRORSTRING] = ERRSTR_MUSTSET;
					return a_err;
				}
			}
		}
	}
	return a_err
}
//-----------------------------------------------------------

//-----------------------------------------------------------
function GetErrorString(aERR) {

	var errstrng = aERR[AERR_ERRORSTRING];
	var rtnstrng = errstrng;

	/*	something is wrong with the internal pointers.
		this won't work if we use the usual left and
		right context searching.  So copy the error
		string into another string so all the searches
		work.
	*/

	var rplcvlu = "";
	var regEx = new RegExp("%%.*?%%","gi");

	while ((aMatches = regEx.exec(errstrng)) != null) {

		switch (aMatches[0]) {
			case "%%FIELD%%":
				rplcvlu = aERR[AERR_FIELDNAME];
				break;
			case "%%VALUE1%%":
				rplcvlu = aERR[AERR_VALUE1];
				break;
			case "%%VALUE2%%":
				rplcvlu = aERR[AERR_VALUE2];
				break;
		}

		rtnstrng = rtnstrng.replace(aMatches[0],rplcvlu)
	}

	return rtnstrng;
}
//-----------------------------------------------------------


//-----------------------------------------------------------
function IsAValueSelected(frm,el) {
	var DataEl = document[frm][el]

	if (DataEl) {
		var DataElType = DataEl.type;

		if (DataElType == "select-one" || DataElType == "select-multiple") {
			var intL = DataEl.options.length
			for (var x = 0;x<intL;x++) {
				if (DataEl.options[x].selected == true) {
					return true;
				}
			}
		} else if (DataElType == "text" || DataElType == "textarea" || DataElType == "hidden") {
			if (DataEl.value != "") {
				return true;
			}
		} else if (DataElType == "radio" || DataElType == "checkbox") {
			if (DataEl.checked == true) {
				return true;
			}
		} else {
			for (var x = 0;x<DataEl.length;x++) {
				if (DataEl[x].checked == true) {
					return true;
				}
			}
		}
	}
	return false;
}
//-----------------------------------------------------------


//------------------------DATA TYPES-------------------------

function isInteger (vlu) {

   var i;
   var startPos = 0;
   if (isEmpty(vlu)) return true;
   
    // skip leading + or -
    if ( (vlu.charAt(0) == "-") || (vlu.charAt(0) == "+") )
      startPos = 1;

   for (i = startPos; i < vlu.length; i++)
   {
      var c = vlu.charAt(i);

      if (!isDigit(c)) return false;
   }

   return true;
}

function isInteger2 (vlu)
{
   var i;
   var startPos = 0;
   if (isEmpty(vlu))
   if (isInteger2.arguments.length == 1) return 0;
   else return (isInteger2.arguments[1] == true);

    // skip leading + or -
    if ( (vlu.charAt(0) == "-") || (vlu.charAt(0) == "+") )
      startPos = 1;

   for (i = startPos; i < vlu.length; i++)
   {
      var c = vlu.charAt(i);

      if (!isDigit(c)) return false;
   }

   return true;
}

function isSignedInteger (vlu)
{   
  if (isEmpty(vlu))
  if (isSignedInteger.arguments.length == 1) return false;
  else return (isSignedInteger.arguments[1] == true);

  else 
  {
    var startPos = 0;
    var secondArg = false;

    if (isSignedInteger.arguments.length > 1)
        secondArg = isSignedInteger.arguments[1];

    // skip leading + or -
    if ( (vlu.charAt(0) == "-") || (vlu.charAt(0) == "+") )
      startPos = 1;
    return (isInteger2(vlu.substring(startPos, vlu.length), secondArg))
   }
}

function isEmpty(vlu)
{
   return ((vlu == null) || (vlu.length == 0))
}

function isDigit (vlu)
{
return ((vlu >= "0") && (vlu <= "9"))
}

//function isInteger(vlu) {

//	var m_vlu = vlu;
//	var pattern = /\D/;

//	if (pattern.test(m_vlu)) {
//		return false;
//	} else {
//		return true;
//	}
//}

function isFloatNumber(vlu) {

	var f, l;
	var m_vlu = vlu;

	//	only one - allowed and must be first character

	f = m_vlu.indexOf('-');
	l = m_vlu.lastIndexOf('-');

	if ( (f>0) || (l>0) ) {
		return false;
	} else {
		if (f == 0) {
			m_vlu = m_vlu.substring(1);
		}
	}

	var a_vlu = m_vlu.split("\.");

	var pattern = /\D/;

	if (a_vlu[0] && pattern.test(a_vlu[0])) {
		return false;
	} else {
		if (a_vlu[1] && pattern.test(a_vlu[1])) {
			return false;
		}
	}
	return true;
}

function isCurrency(vlu) {

	if (vlu == "") {
		return true;
	}

	var m_vlu = vlu;
	var pattern = /\D/;
	var mytest
	var f,l;

	//	only one $ allowed and must be first character

	f = m_vlu.indexOf('$');
	l = m_vlu.lastIndexOf('$');

	if ( (f>0) || (l>0) ) {
		return false;
	}

	//	only one decimal point allowed

	f = m_vlu.indexOf('.');
	l= m_vlu.lastIndexOf('.');

	if (f != l) {
		return false;
	}

	//	remove the $, commas, and decimal point and see if what is left
	//	have any non-Digits in it

	mytest = m_vlu.replace(/\$/,"");
	mytest = mytest.replace(/\./,"");
	mytest = mytest.replace(/,/g,"");

	if (pattern.test(mytest)) {
		return false;
	} else {
		return true;
	}
}



function isText(vlu) {

	var pattern = /[^a-zA-Z_\s]/;

	if (pattern.test(vlu)) {
		return false;
	} else {
		return true;
	}
}

function isAlphaNumeric(vlu) {

	var pattern = /[^a-zA-Z0-9_\s]/;

	if (pattern.test(vlu)) {
		return false;
	} else {
		return true;
	}
}

function isValidTextRange(vlu,r1,r2) {

	var r1 = r1.toLowerCase();
	var r2 = r2.toLowerCase();
	var R1 = r1.toUpperCase();
	var R2 = r2.toUpperCase();
	var regEx = new RegExp("[^"+r1+"-"+r2+R1+"-"+R2+"]","gi") ;

	if (regEx.test(vlu)) {
		return false;
	} else {
		return true;
	}
}

//-----------------------------------------------------------

//-----------------------------------------------------------
function IsFileNameLegal(vlu) {
	if (vlu.match(/\\/)) {
		return false;
	}
	if (vlu.match(/\//)) {
		return false;
	}
	if (vlu.match(/:/)) {
		return false;
	}
	if (vlu.match(/;/)) {
		return false;
	}
	if (vlu.match(/\*/)) {
		return false;
	}
	if (vlu.match(/\?/)) {
		return false;
	}
	if (vlu.match(/</)) {
		return false;
	}
	if (vlu.match(/>/)) {
		return false;
	}
	if (vlu.match(/\|/)) {
		return false;
	}
	if (vlu.match(/"/)) {
		return false;
	}
	return true;
}
//-----------------------------------------------------------

//-----------------------------------------------------------
function isPhoneNumberFormatValid(vlu,itnl) {

	var m_vlu = vlu;
	var pattern = /\d{3}-\d{3}-\d{4}/;
	var pattern2 = /\(\d{3}\)\s\d{3}-\d{4}/;

	if (pattern.test(m_vlu) && vlu.length < 13) {
		return true;
	} else if (pattern2.test(m_vlu) && vlu.length < 15) {
		return true;
	} else if (itnl == true) {

		var pattern3 = /\d{1}-\d{2}-\d{3}-\d{4}/;

		if (pattern3.test(m_vlu) && vlu.length < 14) {
			return true;
		} else {
			return false;
		}

	} else {
		return false;
	}
}
//-----------------------------------------------------------

//-----------------------------------------------------------
function isZipCodeValid(vlu) {

	var m_vlu = vlu;
	var pattern = /\d{5}/;
	var pattern2 = /\d{5}-\d{4}/;

	if (pattern.test(m_vlu) && vlu.length < 6) {
		return true;
	} else if (pattern2.test(m_vlu) && vlu.length < 11) {
		return true;
	} else {
		return false;
	}
}
//-----------------------------------------------------------

//-----------------------------------------------------------
function isSSNFormatValid(vlu) {

	var m_vlu = vlu;
	var pattern = /\d{3}-\d{2}-\d{4}/;

	if (pattern.test(m_vlu) && vlu.length < 12) {
		return true;
	} else {
		return false;
	}
}
//-----------------------------------------------------------

//-----------------------------------------------------------
var DTERR_INVALIDCHAR = -10;
var DTERR_MONTHMISSING = -11;
var DTERR_MONTHMIN  = -12;
var DTERR_MONTHMAX  = -13;
var DTERR_DAYYEARMISSIING  = -14;
var DTERR_EXTRASLASHES  = -15;
var DTERR_YEARMISSING  = -16;
var DTERR_INVALIDYEAR  = -17;
var DTERR_YEAR4DIGITS  = -18;
var DTERR_DAYMISSING  = -19;
var DTERR_DAYMIN  = -20;
var DTERR_DAYMAX  = -21;

//DTERRSTR_INVALIDCHAR = "Invalid character in date (must be numeric and slashes only).";
//DTERRSTR_MONTHMISSING = "Month is missing.";
//DTERRSTR_MONTHMIN  = "Month is less than 1.";
//DTERRSTR_MONTHMAX  = "Month is greater than 12.";
//DTERRSTR_DAYYEARMISSIING  = "Day and year are missing from date.";
//DTERRSTR_EXTRASLASHES  = "Date contains extra slashes (slash found in year).";
//DTERRSTR_YEARMISSING  = "Year is missing.";
//DTERRSTR_INVALIDYEAR  = "Year is not 2 or 4 digits long.";
//DTERRSTR_YEAR4DIGITS  = "Year is required to be 4 digits, but is only 2.";
//DTERRSTR_DAYMISSING  = "Day is missing.";
//DTERRSTR_DAYMIN  = "Day is less than 1.";
//DTERRSTR_DAYMAX  = "Day is greater than max number of days in month.";


function fn_isDateNreq(as_date, ab_RequireFullYear, as_Field) {

	if (as_date == "") {
		return 0;
	}

	return fn_isDate(as_date, ab_RequireFullYear, as_Field);

}

function fn_isDate(as_date, ab_RequireFullYear, as_Field) {

	var ls_month;
	var ls_day;
	var ls_maxDay;
	var ls_year;
	var li_counter;

	if (as_date == null) {as_date = "";}
	if (as_Field == null) {as_Field = "";}
	if (ab_RequireFullYear != true && ab_RequireFullYear != false)
		{ab_RequireFullYear = false;}

	//Check the date for invalid characters
	if (!fn_ValidateString("1234567890/", as_date)) {
		if (as_Field != "") {
			alert(as_Field + " contains invalid characters. Date must be numbers and slashes ('/') only.")
		}
		return DTERR_INVALIDCHAR;
	}

	//Parse the month
	ls_month = "";
	for (li_counter=0; li_counter < as_date.length; li_counter++) {
		if (as_date.charAt(li_counter) == '/')
			break;
		ls_month += as_date.charAt(li_counter);
	}

	//Check that the month is a valid month.
	if (ls_month == "") {
		if (as_Field != "") {
			alert(as_Field + " does not contain a month in the date.");
		}
		return DTERR_MONTHMISSING;
	}
	if (parseInt(ls_month, 10) < 1) {
		if (as_Field != "") {
			alert("The month in " + as_Field + " must be between 1 and 12.");
		}
		return DTERR_MONTHMIN;
	}
	if (parseInt(ls_month, 10) > 12) {
		if (as_Field != "") {
			alert("The month in " + as_Field + " must be between 1 and 12.");
		}
		return DTERR_MONTHMAX;
	}
	if (ls_month.length == as_date.length) {
		if (as_Field != "") {
			alert("Day and year are missing from " + as_Field + ".");
		}
		return DTERR_DAYYEARMISSIING;
	}

	//Parse the day
	ls_day = "";
	for (li_counter++; li_counter < as_date.length; li_counter++) {
		if (as_date.charAt(li_counter) == '/')
			break;
		ls_day = ls_day + as_date.charAt(li_counter);
	}


	//Check that the day is a valid day.
	//Need year to determine if it is leap year.%>
	ls_maxDay = fn_getMaxDayOfMonth(ls_month, ls_year);
	if (ls_day == "") {
		if (as_Field != "") {
			alert("The day is missing from " + as_Field + ".");
		}
		return DTERR_DAYMISSING;
	}
	if (parseInt(ls_day, 10) < 1) {
		if (as_Field != "") {
			alert("The day in " + as_Field + " must be greater than 1.");
		}
		return DTERR_DAYMIN;
	}
	if (parseInt(ls_day, 10) > ls_maxDay) {
		if (as_Field != "") {
			alert("The day in " + as_Field + " must less than or equal to " + ls_maxDay + ".");
		}
		return DTERR_DAYMAX;
	}


	//Parse the year
	ls_year = "";
	for (li_counter++; li_counter < as_date.length; li_counter++) {
		if (as_date.charAt(li_counter) == ' ')
			break;
		ls_year = ls_year + as_date.charAt(li_counter);
	}

 	//Check that the year is a valid year.
	if (isNaN(ls_year)) {
		if (as_Field != "") {
			alert("Year is invalid in " + as_Field + " ('/' exists in year).");
		}
		return DTERR_EXTRASLASHES;
	}
	if (ls_year == "") {
		if (as_Field != "") {
			alert("The year is missing from " + as_Field + ".");
		}
		return DTERR_YEARMISSING;
	}
	if (ls_year.length != 2 && ls_year.length != 4) {
		if (as_Field != "" && ab_RequireFullYear) {
			alert("The year's length in " + as_Field + " is invalid. It must be exactly four digits.");
		} else if (as_Field != "") {
			alert("The year's length in " + as_Field + " is invalid. It must be either two or four digits.");
		}
		return DTERR_INVALIDYEAR;
	}

	//If year must be 4 digits, check that it is
	if (ls_year.length != 4 && ab_RequireFullYear) {
		if (as_Field != "") {
			if (ls_year.length == 2) {
				alert("Two digit years cannot be entered for " + as_Field + ". The year must be exactly four digits.");
			} else{
				alert("The year must be exactly four digits long in " + as_Field + ".");
			}
		}
		return DTERR_YEAR4DIGITS;
	}

	return 0;
}

/******************************************************************
Function: fn_getMaxDayOfMonth (ai_month, ai_year)

	Description: Function returns the number of days in the month entered.
	the ai_year parameter is optional and is used to determine if February
	has 28 or 29 days. if ai_year is omitted, 28 will be returned as the
	max date.

	Returns: Number of  days in month if as_month is between 1 and 12
	 or a negative number otherwise.

	Modification History:
*******************************************************************/
function fn_getMaxDayOfMonth(ai_month, ai_year) {
	if (ai_month == 1) return (31);
	if (ai_month == 2) {
		if (fn_IsLeapYear(ai_year)) {
			return (29);
		} else {
			return (28);
		}
	}
	if (ai_month == 3) return (31);
	if (ai_month == 4) return (30);
	if (ai_month == 5) return (31);
	if (ai_month == 6) return (30);
	if (ai_month == 7) return (31);
	if (ai_month == 8) return (31);
	if (ai_month == 9) return (30);
	if (ai_month == 10) return (31);
	if (ai_month == 11) return (30);
	if (ai_month == 12) return (31);
}

/******************************************************************
Function: fn_IsLeapYear(ai_Year)
	Description: Function determines if entered year is a leap year or not.
	Returns: True if entered year is a leap year.
	False if not.
	Modification History:
*******************************************************************/
function fn_IsLeapYear(ai_Year) {

	var lb_isLeapYear;

	lb_isLeapYear = false;

	if (isNaN(ai_Year) || ai_Year < 0)
		return false;

	if (ai_Year%4 == 0) {
		lb_isLeapYear = true;
		if (ai_Year%100 == 0) {
			lb_isLeapYear = false;
			if (ai_Year%400 == 0) {
				lb_isLeapYear = true;
			}
		}
	} //else {
		//  lb_isLeapYear = false;
	//}

	return lb_isLeapYear;
}

/******************************************************************
Function: fn_ValidateString

	Description:
	Used to determine if a string (as_string) only has valid
	characters in it (as_template). The empty string for as_string
	is considered to be part of all templates (as_string == "" returns
	true).

	Argument
	as_template - this is a string of valid characters
	as_string   - this is a string we're testing

	Return Value: boolean - returns true if as_string contains only
	characters found in as_template, else returns false

	Modification History:
*******************************************************************/
function fn_ValidateString(as_template, as_string) {

	var li_counter1, li_counter2, lc_CurrentChar;
	var lb_valid;

	if (as_string == null) {as_string = "";}

	if (typeof(as_string).toLowerCase() != "string" || typeof(as_template).toLowerCase() != "string")
		return false;

	if (as_template.length == 0 && as_string.length > 0)
		return false;

	lb_valid = true ;

	for (li_counter1 = 0 ; li_counter1 < as_string.length; li_counter1++) {
		lc_CurrentChar = as_string.charAt(li_counter1);
		for (li_counter2 = 0; li_counter2 < as_template.length; li_counter2++) {
			if (lc_CurrentChar == as_template.charAt(li_counter2))
				break;
			if (li_counter2 == as_template.length - 1) {
				lb_valid = false;
				break;
			}
		}
		if (lb_valid == false)
			break;
	}

	if (lb_valid == true)
		return true;

	return false;
}


function fn_Convert_ccyymmdd (as_date, as_fourbyte) {

	/*	this function assumes a valid date as input. Please validate date
		before calling this function.

		as_date = date
		as_fourbyte = boolean - true would convert date into a four byte year
							false would convert date into ccyymmdd
	*/

	var li_counter;
	var li_year;
	var ls_month;
	var ls_day;
	var ls_year;

	//Parse the month.
	ls_month = "";
	for (li_counter=0; li_counter < as_date.length; li_counter++) {
		if (as_date.charAt(li_counter) == '/')
			break;
		ls_month = ls_month + as_date.charAt(li_counter);
	}
	if (ls_month.length == 1)
		ls_month = "0" + ls_month;

	//Parse the day
	ls_day = "";
	for (li_counter++; li_counter < as_date.length; li_counter++) {
		if (as_date.charAt(li_counter) == '/') {break;}
		ls_day = ls_day + as_date.charAt(li_counter);
	}
	if (ls_day.length == 1) {ls_day = "0" + ls_day;}

	//Parse the year
	ls_year = "";
	for (li_counter++; li_counter < as_date.length; li_counter++) {
		if (as_date.charAt(li_counter) == ' ') {break;}
		ls_year = ls_year + as_date.charAt(li_counter);
	}

	if (ls_year.length == 2) {
		li_year = parseInt(ls_year, 10)
		if (li_year >= 80 ) {
			ls_year = "19" + ls_year;
		} else {
			ls_year = "20" + ls_year;
		}
	}
	if (as_fourbyte) {
		return (ls_day  + "/" + ls_month + "/" + ls_year);
	} else {
		return (ls_year +  ls_month +  ls_day);
	}
}
//-----------------------------------------------------------

//-----------------------------------------------------------
function GetFormElementValue(frm,el) {

	var DataValue = "";
	var DataEl = document[frm][el];

	if (DataEl) {
		var DataElType = DataEl.type;

		if (DataElType == "select-one") {

			DataValue = DataEl.options[DataEl.selectedIndex].value;

		}  else if (DataElType == "select-multiple") {

			var intL = DataEl.options.length;

			for (var x = 0;x<intL;x++) {
				if (DataEl.options[x].selected == true) {
					if (DataValue != "") {
						DataValue = DataValue + ",";
					}
					DataValue = DataValue + DataEl.options[x].value;
				}
			}

		} else if (DataElType == "text" || DataElType == "textarea" || DataElType == "hidden") {

			DataValue = DataEl.value;

		} else if (DataElType == "radio" || DataElType == "checkbox") {

			if (DataEl.checked == true) {
				DataValue = DataEl.value;
			}

		} else {

			for (var x = 0;x<DataEl.length;x++) {

				if (DataEl[x].checked == true) {

					if (DataValue != "") {
						DataValue = DataValue + ",";
					}

					DataValue = DataValue + DataEl[x].value;
				}
			}
		}
	}
	return DataValue;
}
//-----------------------------------------------------------

//-----------------------------------------------------------
function NumberOfValuesSelected(frm,el) {

	var slctdvlus = 0;
	var DataEl = document[frm][el];

	if (DataEl) {
		var DataElType = DataEl.type;

		if (DataElType == "select-one" || DataElType == "select-multiple") {

			var intL = DataEl.options.length;

			for (var x = 0;x<intL;x++) {
				if (DataEl.options[x].selected == true) {
					slctdvlus +=1;
				}
			}
		} else if (DataElType == "text" || DataElType == "textarea" || DataElType == "hidden") {
			if (DataEl.value != "") {
				slctdvlus +=1;
			}
		} else if (DataElType == "radio" || DataElType == "checkbox") {
			if (DataEl.checked == true) {
				slctdvlus +=1;
			}
		} else {
			for (var x = 0;x<DataEl.length;x++) {
				if (DataEl[x].checked == true) {
					slctdvlus +=1;
				}
			}
		}
	}
	return slctdvlus;
}
//-----------------------------------------------------------