/**
 * JavaScript Form Validation Library
 *
 * <p>
 * <b>Changelog:</b> <pre>
 *   1.00  author 2000/02/21 created
 *   1.01  REVIE  2000/09/29 added a checkAll() to check to see if all
 *                           form fields had been at least filled in
 * </pre>
 *
 *     NOTE: Save this file as validate.js
 * HOMEPAGE: http://sites.netscape.net/michaelanino/kitten
 *
 * @author Michael Nino (mnino@insight.com)
 * @version 1.01
 */

/**
 * FUNCTION: Match( field, value, equals)
 *  PURPOSE: Returns true if field's value matches/equals the 
 *           value argument otherwise returns false. Setting the
 *           the equal argument to true indicates you wish the
 *           the value argument to equal the field's value. 
 *
 */
// general purpose function to see if an input value has been
// entered at all
// general purpose function to see if an input value has been
// entered at all
var gField
var gFrame
function isNotEmpty(inputStr) {
	if (inputStr == null || inputStr == "") {
		return false
	}
	return true
}

function isEmpty(inputStr) {
	if (inputStr == null || inputStr == "") {
		return true
	}
	return false
}


// general purpose function to see if a suspected numeric input
// is a Number


// general purpose function to see if a suspected numeric input
// is a positive nNumber

function isPosNumber(inputVal) {
 var  oneDecimal = false
  inputStr = inputVal.toString()
  if (inputStr.length== 0) {
    return false;
  }
    
  for (var i = 0; i < inputStr.length; i++) {
		var oneChar = inputStr.charAt(i)
		if (i == 0 && oneChar == "-") {
		  alert('Only Positive numbers allowed');
		  return false;
		}
		if (oneChar == "." && !oneDecimal) {
		  oneDecimal = true
		  continue
		}
		if (oneChar < "0" || oneChar > "9") {
		    alert('Please enter a valid number');
			return false
		}
	}
	return true
}

// general purpose function to see if a suspected numeric input
// is a positive integer
function isPosInteger(inputVal) {
	inputStr = inputVal.toString()
	for (var i = 0; i < inputStr.length; i++) {
		var oneChar = inputStr.charAt(i)
		if (oneChar < "0" || oneChar > "9") {
			return false
		}
	}
	return true
}
function isPositiveInteger(inputVal) {
	inputStr = inputVal.toString()
	for (var i = 0; i < inputStr.length; i++) {
		var oneChar = inputStr.charAt(i)
		if (oneChar < "0" || oneChar > "9") {
			return false
		}
	}
	return true
}

// date field validation (called by other validation functions that specify minYear/maxYear)
function isDate(minYear,maxYear,minDays,maxDays) {
	var inputStr = gField.value
	// convert hyphen delimiters to slashes
	while (inputStr.indexOf("-") != -1) {
		inputStr = replaceString(inputStr,"-","/")
	}
	var delim1 = inputStr.indexOf("/")
	var delim2 = inputStr.lastIndexOf("/")
	if (delim1 != -1 && delim1 == delim2) {
		// there is only one delimiter in the string
		alert("The date entry is not in an acceptable format.\n\nYou can enter dates in the following formats: mmddyyyy, mm/dd/yyyy, or mm-dd-yyyy.  (If the month or date data is not available, enter \'01\' in the appropriate location.)")
		gField.focus()
		gField.select()
		return false
	}
	if (delim1 != -1) {
		// there are delimiters; extract component values
		var mm = parseInt(inputStr.substring(0,delim1),10)
		var dd = parseInt(inputStr.substring(delim1 + 1,delim2),10)
		var yyyy = parseInt(inputStr.substring(delim2 + 1, inputStr.length),10)
	} else {
		// there are no delimiters; extract component values
		var mm = parseInt(inputStr.substring(0,2),10)
		var dd = parseInt(inputStr.substring(2,4),10)
		var yyyy = parseInt(inputStr.substring(4,inputStr.length),10)
	}
	if (isNaN(mm) || isNaN(dd) || isNaN(yyyy)) {
		// there is a non-numeric character in one of the component values
		alert("The date entry is not in an acceptable format.\n\nYou can enter dates in the following formats: mmddyyyy, mm/dd/yyyy, or mm-dd-yyyy.")
		gField.focus()
		gField.select()
		return false
	}
	if (mm < 1 || mm > 12) {
		// month value is not 1 thru 12
		alert("Months must be entered between the range of 01 (January) and 12 (December).")
		gField.focus()
		gField.select()
		return false
	}
	if (dd < 1 || dd > 31) {
		// date value is not 1 thru 31
		alert("Days must be entered between the range of 01 and a maximum of 31 (depending on the month and year).")
		gField.focus()
		gField.select()
		return false
	}

	// validate year, allowing for checks between year ranges
	// passed as parameters from other validation functions
	if (yyyy < 100) {
		// entered value is two digits, which we allow for 1930-2029
		if (yyyy >= 30) {
			yyyy += 1900
		} else {
			yyyy += 2000
		}
	}

	var today = new Date()
	if (!minYear) {
		// function called with specific day range parameters
		var dateStr = new String(monthDayFormat(mm) + "/" + monthDayFormat(dd) + "/" + yyyy)
		var testDate = new Date(dateStr)
		if (testDate.getTime() < (today.getTime() + (minDays * 24 * 60 * 60 * 1000))) {
			alert("The most likely range for this entry begins " + minDays + " days from today.")
		}
		if (testDate.getTime() > today.getTime() + (maxDays * 24 * 60 * 60 * 1000)) {
			alert("The most likely range for this entry ends " + maxDays + " days from today.")
		}
	} else if (minYear && maxYear) {
		// function called with specific year range parameters
		if (yyyy < minYear || yyyy > maxYear) {
			// entered year is outside of range passed from calling function
			alert("The most likely range for this entry is between the years " + minYear + " and " + maxYear + ".  If your source data indicates a date outside this range, then enter that date.")
		}
	} else {
		// default year range (now set to (this year - 100) and (this year + 25)
		var thisYear = today.getYear()
		if (thisYear < 100) {
			thisYear += 1900
		}
		if (yyyy < minYear || yyyy > maxYear) {
			alert("It is unusual for a date entry to be before " + minYear + " or after " + maxYear + ". Please verify this entry.")
		}
	}
	if (!checkMonthLength(mm,dd)) {
		gField.focus()
		gField.select()
		return false
	}
	if (mm == 2) {
		if (!checkLeapMonth(mm,dd,yyyy)) {
			gField.focus()
			gField.select()
			return false
		}
	}
	// put the Informix-friendly format back into the field
	gField.value = monthDayFormat(mm) + "/" + monthDayFormat(dd) + "/" + yyyy
	return true
}


function getTheYear() {
	var thisYear = (new Date()).getYear()
	thisYear = (thisYear < 100)? thisYear + 1900: thisYear
	return thisYear
}


/*
   Begin validation dispatching mechanism
*/
function dispatcher(validationFunc) {
   this.doValidate = validationFunc
}
var dispatchLookup = new Array()
dispatchLookup["isNotEmpty"] = new dispatcher(isNotEmpty)
dispatchLookup["isPositiveInteger"] = new dispatcher(isPositiveInteger)
dispatchLookup["isPosInteger"] = new dispatcher(isPositiveInteger)
dispatchLookup["isDate"] = new dispatcher(isDate)
dispatchLookup["isNumber"] = new dispatcher(isNumber)
dispatchLookup["isPosNumber"] = new dispatcher(isPosNumber)

// Master value validator routine
function isValid(inputStr) {
	if (isEmpty(inputStr)) {
		alert("Please enter a number into the field before clicking the button.")
		return false
	} else {
		if (!isNumber(inputStr)) {
			alert("Please make sure entries are numbers only.")
			return false
		} else {
			if (!inRange(inputStr)) {
				alert("Sorry, the number you entered is not part of our database.  Try another three-digit number.")
				return false
			}
		}
	}
	return true
}

// function to determine if value is in acceptable range
// for this application
function inRange(inputStr) {
	var num = parseInt(inputStr)
	if (num < 1 || num > 586 && num < 596 || num > 599 && num < 700 || num > 728) {
		return false
	}
	return true
}


// general purpose function to see if a suspected numeric input
// is a positive or negative number
function isNumber(inputVal) {
	var oneDecimal = false
	inputStr = inputVal.toString()
	for (var i = 0; i < inputStr.length; i++) {
		var oneChar = inputStr.charAt(i)
		if (i == 0 && oneChar == "-") {
			continue
		}
		if (oneChar == "." && !oneDecimal) {
			oneDecimal = true
			continue
		}
		if (oneChar < "0" || oneChar > "9") {
			return false
		}
	}
	return true
}

// general purpose function to see if a suspected numeric input
// is a positive or negative integer
function isInteger(inputVal) {
	var inputStr = inputVal.toString()
	for (var i = 0; i < inputStr.length; i++) {
		var oneChar = inputStr.charAt(i)
		if (i == 0 && oneChar == "-") {
			continue
		}
		if (oneChar < "0" || oneChar > "9") {
			return false
		}
	}
	return true
}

// check the entered month for too high a value
function checkMonthLength(mm,dd) {
	var months = new Array("","January","February","March","April","May","June","July","August","September","October","November","December")
	if ((mm == 4 || mm == 6 || mm == 9 || mm == 11) && dd > 30) {
		alert(months[mm] + " has only 30 days.")
		return false
	} else if (dd > 31) {
		alert(months[mm] + " has only 31 days.")
		return false
	}
	return true
}

// check the entered February date for too high a value 
function checkLeapMonth(mm,dd,yyyy) {
	if (yyyy % 4 > 0 && dd > 28) {
		alert("February of " + yyyy + " has only 28 days.")
		return false
	} else if (dd > 29) {
		alert("February of " + yyyy + " has only 29 days.")
		return false
	}
	return true
}

function ReplaceQuotes(s)
{return s.replace(/\"/g, "'");}

function jTrim(s)
{return s.replace(" ", "");}

function ltrim (s){
	return s.replace( /^\s*/, "" );
}

function rtrim (s){
	return s.replace( /\s*$/, "" );
}

function trim (s){
	return rtrim(ltrim(s));
}

function MaxLength(obj, max)
{if (obj.value.length > max) obj.value = obj.value.substr(0, max);}

function TabFirst(obj, e)
{
	if (e.keyCode != 9 || e.shiftKey) return;
	cantGetFocus = String("radio;hidden");
	for (i = 0; i < obj.form.length; i++)
		if (cantGetFocus.search(obj.form.elements[i].type) == -1)
			return obj.form.elements[i].focus();
}

function BackTabLast(obj, e)
{
	if (e.keyCode != 9 || !e.shiftKey) return;
	cantGetFocus = String("radio;hidden");
	for (i = obj.form.length - 1; i >= 0 ; i--)
		if (cantGetFocus.search(obj.form.elements[i].type) == -1)
			return obj.form.elements[i].focus();
}

function AutoTab(obj, max, e)
{
	if (e.keyCode == 9 || e.keyCode == 13 || e.keyCode == 16) return;
// this function should be called from the onKeyUp event
	if (obj.type == "text" && obj.value.length == max)
	{
		j = -1;
		cantGetFocus = String("radio;hidden");
		for (i = 0; i < obj.form.length; i++)
		{
			if (obj.form.elements[i] == obj || j > -1)
			{
				j = (i == obj.form.length - 1 ? 0 : i + 1);
				if (cantGetFocus.search(obj.form.elements[j].type) == -1)
				{
					obj.form.elements[j].focus();
					i = obj.form.length;
				}
				else if (j == 0)
					i = -1;
			}
		}
	}
}

function ResetUI(focusObj, ErrMsg)
{
	if(ErrMsg>""){
		alert(ErrMsg)
	}
	focusObj.focus();
	return (false);
}

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

function isFloat(s, emptyOK)
{
// Returns true if valid float
  if(isEmpty(s))
    if(isFloat.arguments.length == 1) return false;
    else return (emptyOK == true);

  AlreadyHaveDecimalPoint = new Number(0);
  for(i = new Number(0); i < s.length; i++)
  {
    if((s.charAt(i) >= "0") && (s.charAt(i) <= "9")) continue;
    if(s.charAt(i) != ".") return false;
    if(AlreadyHaveDecimalPoint == 1) return false;
    AlreadyHaveDecimalPoint = 1;
  }
  return true;
}

function isCurrency(s, emptyOK)
{
// Returns true if valid currency
  if(!isFloat(s, emptyOK)) return false;

	pos = new Number(0);
  for(i = new Number(s.length) - 1; i >= 0; i--)
  {
    pos++;
    if(s.charAt(i) == ".")
			if(pos > 3) return false;
			else return true;
  }
  return true;
}

function isNumber(s, emptyOK)
{
// Returns true if positive number
  var oneDecimal = false;
  if(isEmpty(s))
    if(isNumber.arguments.length == 1) return false;
    else return (emptyOK == true);

  
  inputStr = s.toString();
  for (var i = 0; i < inputStr.length; i++) {
		var oneChar = inputStr.charAt(i);
		if (i == 0 && oneChar == "-") {
		  continue;
		}
		if (oneChar == "." && !oneDecimal) {
		  oneDecimal = true;
		  continue;
		}
		if (oneChar < "0" || oneChar > "9") {
			return false;
		}
	}
	return true;

}

function isWhiteSpace(s)
{
  var whitespace = " \t\n\r";
  if(isEmpty(s)) return true;

  for(i = new Number(0); i < s.length; i++)
    if(whitespace.indexOf(s.charAt(i)) == -1) return false;

  return true;
}

function isEmail(s, emptyOK)
{
// Must conform to a@b.c
  if(isEmpty(s))
    if(isEmail.arguments.length == 1) return false;
    else return (emptyOK == true);

  i = new Number(s.indexOf("@", 1));
  if(i == -1) return false;

  i = (s.indexOf(".", i + 2));
  if(i == -1) return false;
  
  return (s.length > i + 1);
}

function isPhoneNbr(areacode, exchange, nbr, emptyOK)
{
  if(isEmpty(areacode + exchange + nbr)){
      return (emptyOK == true);
  }

  if(!isNumber(areacode + exchange + nbr)) return false;
  return true;
}


function isSSNSameNumber(sNumber){
	var inputStr = sNumber.toString()
	var match = true
	for(var i = 0; i < inputStr.length-1; i++){
		var j = i+1;
		if(!(inputStr.charAt(i) == inputStr.charAt(j))) match=false;
	}
	if (!match){
		return false;
	}else{
		return true;
	}
}

// main validation function called by form event handlers
function validate(frame, field, method) {
	gFrame = frame
	gField =  eval('document.forms[1].item(\'' +field+'\')')
	var args = validate.arguments
	for (i = 2; i < args.length; i++) {
		if (!dispatchLookup[args[i]].doValidate(gField.value)) {
			return false
		}
	}
	return true
}

function Match( field, value, equals ) {
   var pattern;
   var r;
   var checked = 0;
   var blank = new RegExp("^[ ]*$");


   if ( equals ) {
      pattern = new RegExp("^"+value+"$");
   } else {
      pattern = new RegExp(value);
   } // if else

   /* Text Fields/Areas/Hidden */
   /* 
      NOTE: DOES NOT SUPPORT MULTIPLE HIDDEN FIELDS 
      WITH THE SAME NAME NOR DOES IT SUPPORT FIELDS
      WITH DIFFERENT TYPES AND USING THE SAME NAME.
      THIS IS A FEATURE TO BE IMPLEMENTED IN THE
      NEXT RELEASE OF THIS LIBRARY!
   */
  
   if ( (field.type == "text") || 
        (field.type == "password") || 
        (field.type == "textarea") || 
        (field.type == "hidden") ) {
      return field.value.match(pattern);
   } // if

   /* Select Fields */
   if ( (field.type == "select-one") || ( field.type == "select" ) ) {
      if (field.selectedIndex == -1) {
         return false;
      } // if
      return field.options[field.selectedIndex].value.match(pattern);
   } // if

   /* Radio Button Groups */
   if ( field[0] && field[0].type == "radio" ) {
      for (r=0; r<field.length; r++) {
         if ( field[r].checked ) {
            checked++;
         } // if 
         if ( (field[r].checked) && (field[r].value.match(pattern)) ) {
            return true;
         } // if
      } // for 
      return false;
   } // if


} // Match


/**
 * FUNCTION: Equal( field, value )
 *  PURPOSE: Returns true if field's value is equals 
 *           the value argument otherwise returns false.
 *           This function is a wrapper to a Match function
 *           call with the equal argument specified. 
 *
 */
function Equal( field, value ) {
   return Match(field,value,true);
} // Equal

 


/**
 * FUNCTION: DateValue( field )
 *  PURPOSE: Returns true if field's value is a valid date string
 *           the value argument otherwise returns false.
 *           This function is a wrapper to a Match function
 *           call with the equal argument specified.
 *
 */
function DateValue( field ) {
   if (Match(field,'(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|30|31)-[1-9][0-9][0-9][0-9]',true) ||
       Match(field,'(0[1-9]|1[0-2])\\/(0[1-9]|[1-2][0-9]|30|31)\\/[1-9][0-9][0-9][0-9]',true) ) { 
      return true; 
   } else { 
      return false; 
   }
} // DateValue


/**
 * FUNCTION: DateValue( field )
 *  PURPOSE: Returns true if field's value is a valid date string
 *           the value argument otherwise returns false.
 *           This function is a wrapper to a Match function
 *           call with the equal argument specified.
 *
 */
function TimeValue( field ) {
   return Match(field,'(0[0-9]|1[0-2]):[0-5][0-9](:[0-5][0-9]){0,1}',true);
} // TimeValue



/**
 * FUNCTION: Currency( field )
 *  PURPOSE: Returns true if field's value is a currency value 
 *           the value argument otherwise returns false.
 *           This function is a wrapper to a Match function
 *           call with the equal argument specified.
 *
 */
function Currency( field ) {
   return Match(field,'[$]*([0-9]{1,3}[,])*[0-9]{0,3}\.[0-9]{2}',true);
} // Currency


/**
 * FUNCTION: SSN( field )
 *  PURPOSE: Returns true if field's value is a social security number
 *           the value argument otherwise returns false.
 *           This function is a wrapper to a Match function
 *           call with the equal argument specified.
 *
 */
function SSN( field ) {
   return Match(field,'[0-9]{3}-[0-9]{2}-[0-9]{4}',true);
} // SSN

/**
 * FUNCTION: Phone( field )
 *  PURPOSE: Returns true if field's value is a phone number
 *           the value argument otherwise returns false.
 *           This function is a wrapper to a Match function
 *           call with the equal argument specified.
 *
 */
function Phone( field ) {
   if (Match(field,'(1-|1 ){0,1}[0-9]{3}-[0-9]{3}-[0-9]{4}',true) ||
       Match(field,'(1-|1 ){0,1}\\([0-9]{3}\\) [0-9]{3}-[0-9]{4}',true) ) {
     return true; 
   } else { 
      return false;
   } 
} // Phone


/**
 * FUNCTION: Email( field )
 *  PURPOSE: Returns true if field's value is an email address
 *           the value argument otherwise returns false.
 *           This function is a wrapper to a Match function
 *           call with the equal argument specified.
 *
 */
function Email( field ) {
   return Match(field,'[0-9a-zA-Z_]+[@][0-9a-zA-Z_]+(\\.[0-9a-zA-Z_]+)+',true);
} // Email


/**
 * FUNCTION: Blank( field )
 *  PURPOSE: Returns true if field's value is blank or 
 *           contains spaces otherwise returns false.
 *           This function is a wrapper to a Match function
 *           call with the value argument specified.
 *
 */
function Blank( field ) {
   var r;

   if ( typeof(field.type) == "undefined" ) { // radio button group
      for (r=0; r<field.length; r++) {
         if (field[r].checked) {
            return false;
         } // if
      } // for
      return true;
   } else {
      return Match(field,"[ ]*",true);
   } // if else

} // Blank

/**
 * FUNCTION: checklength( form )
 *  PURPOSE: Given the minimum length that an input
 *           field should be, this returns true, otherwise 
 *           returns false, and displays an error prompt.
 */
function checkLength( field, min_length ) {
   if(Match( field, '[0-9a-zA-Z_]{'+min_length+'}',false )) {
      return true;
   } else {
      alert("The input field isn't long enough.  Must be at least "+
            min_length + " characters in length.");
      return false;
   }
} // checkLength

/**
 * FUNCTION: checkAll( form )
 *  PURPOSE: Returns true if all form fields filled in, otherwise 
 *           returns false, and displays an error prompt.
 */
function checkAll( form ) {
   var empty_fields = new Array();

   if (form.required && form.required.value) {
      var required = form.required.value;
      var fields = required.split(/\s*,\s*/);
      
      for(var i=0; i < fields.length; i++) {
         var e = eval('form.'+fields[i]);
         if (e && Blank(e)) {
            empty_fields[i] = fields[i];
         }
      }
   } else {
      for(var i=0; i < form.length; i++) {
         var e = form.elements[i];
         if (Blank(e)) {
            empty_fields[i] = e.name;
         }
      }
   }

   if (empty_fields.length<=0) { return true; }

   var msg = 
      "We are unable to process your request.\n" +
      "Please correct and re-submit.\n\n" +
      " - The following required field(s) are empty:\n        " + 
      empty_fields.join("\n        ") + "\n";
   alert(msg);
   return false;
} // checkAll
//------------------------------------------------
function isContain(ss, cc){
	var inputStr = ss.toString()
	var arr = new Array(inputStr.length)
	for (var i = 0; i < inputStr.length; i++){
		if(cc == inputStr.charAt(i)){
			return true;
		}
	}
}
function isLeadingSpace(ss) {
	var SearchItem = " "
	if((ss.length > 0) && (ss.search(SearchItem) == 0)){
		return true
	}
	return false
}


function isBadLeadingCharacter(ss){
	var inputStr = ss.toString()
	var BadChar = "~!@ #$%^&*()_+|<>?{}':`\/.,;-="
	var inputStr2 = BadChar.toString()
	for (var j = 0; j < inputStr2.length; j++){
		if(inputStr.charAt(0) == inputStr2.charAt(j)){
			return true;
		}
	}
	return false;
}
function isContainBadCharacter(ss, BadChar){
	var inputStr = ss.toString()
	var inputStr2 = BadChar.toString()
	for (var i = 0; i < inputStr.length; i++){
		for (var j = 0; j < inputStr2.length; j++){
			if(inputStr.charAt(i) == inputStr2.charAt(j)){
				return true;
			}
		}
	}	
	return false;
}
function isDigitOnly(ss,min,max){
	var inputStr = ss.toString()
	var SearchItem = " "
	if (inputStr.length == 0){
		return false
	}
	if ((inputStr.length < min) || (inputStr.length > max)){
		return false
	}
	if (inputStr.search(SearchItem) >= 0){
		return false;
	}
	for (var i = 0; i < inputStr.length; i++){
		if(isNaN(inputStr.charAt(i))){
			return false;
		}
	}
	return true;
}

function isLetterOnly(string2, min, max){
	var inputStr = string2.toString()
	if (inputStr.length == 0){
		return false
	}
	if ((inputStr.length < min) || (inputStr.length > max)){
		return false
	}
	if (isContainBadCharacter(string2,"~!@#$%^&*()_+|<>?{}':`\/.,;=")){
		return false;
	}
	for (var i = 0; i < inputStr.length; i++){
		if(!isNaN(inputStr.charAt(i))){
			return false;
		}
	}
	return true;
}


function isAlphaNumeric(ss, min, max){
	var inputStr = ss.toString()
	var BadChar = "~!@#$%^&*()_+|`-=\{}:<>?[ ];',./"
	var inputStr2 = BadChar.toString()
	if (inputStr.length==0){
		return false;
	}
	if (inputStr.length < min || inputStr.length > max){
		return false;
	}
	for (var i = 0; i < inputStr.length; i++){
		for (var j = 0; j < inputStr2.length; j++){
			if(inputStr.charAt(i) == inputStr2.charAt(j)){
				return false;
			}
		}
	}	
	return true;
}

function isAddress1(ss, min, max){
	var inputStr = ss.toString()
	var BadChar = "~!@$%^*_+|`={}<>?[];"
	var inputStr2 = BadChar.toString()
	if ((inputStr.length >= min)&&(inputStr.length <= max)){
		for (var i = 0; i < inputStr.length; i++){
			for (var j = 0; j < inputStr2.length; j++){
				if((inputStr.charAt(i) == inputStr2.charAt(j))){
					return false;
				}
			}
		}
		return true;
	}
	else{
		return false;
	}
}
function isAlphaNumericOnly(ss,min,max,bolSpace){
	var inputStr	= ss.toString()
	var OkChar
	var match
	if((inputStr.length >= min)&&(inputStr.length <= max)){
		if(bolSpace){
			OkChar	= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz 1234567890"
		}
		else{
			OkChar	= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"
		}
		for (var i = 0; i < inputStr.length; i++){
			match = false;
			for (var j = 0; j < OkChar.length; j++){
				if(inputStr.charAt(i) == OkChar.charAt(j)){
					match=true;
					j=OkChar.length;
				}
			}
			if(!match){
				return false;
			}
		}	
		return true;
	}
	else{
		return false;
	}
}

function isAlphaOnly(ss,min,max,bolSpace){
	var inputStr = ss.toString()
	var OkChar
	var match
	if((inputStr.length >= min)&&(inputStr.length <= max)){
		if(bolSpace){
			OkChar =  "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz"
		}
		else{
			OkChar =  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
		}
		for(var i = 0; i < inputStr.length; i++){
			match = false
			for (var j = 0; j < OkChar.length; j++){
				if((inputStr.charAt(i) == OkChar.charAt(j))){
					match=true;
					j = OkChar.length
				}
			}
			if (!match){
				return false;
			}
		}
		return true;
	}
	else{
		return false;
	}
	
}


function isNumericOnly(ss,min,max,bolSpace){
	var inputStr = ss.toString()
	var OkChar
	var match
	if((inputStr.length >= min)&&(inputStr.length <= max)){
		if(bolSpace){
			OkChar =  "12345 67890"
		}
		else{
			OkChar =  "1234567890"
		}
		for(var i = 0; i < inputStr.length; i++){
			match = false
			for (var j = 0; j < OkChar.length; j++){
				if((inputStr.charAt(i) == OkChar.charAt(j))){
					match=true;
					j = OkChar.length
				}
			}
			if (!match){
				return false;
			}
		}
		return true;
	}
	else{
		return false;
	}
}


function isZipCode(zc){
	var inputStr = zc.toString()
	var match
	
	switch(inputStr.length){
		case 5: 
		  if(!isNumber(inputStr)){
				alert("A 5 digit zip code should use the format 99999.")
				return false;
			}else{
				return true;
			}
			break;

		case 9: 
		  if(!isNumber(inputStr)){
				alert("A 9 digit zip code should use the format 999999999.")
				return false;
			}else{
				return true;
			}
			break;

		case 10: 
		  if(!isNumber(inputStr.slice(0,5)+inputStr.slice(6))){
				alert("A 10 digit zip code should use the format 99999-9999.")
				return false;
			}else{
			  if(inputStr.slice(5,-4)!="-"){
					alert("A 10 digit zip code should use the format 99999-9999.")
					return false;
			  }else{
					return true;
				}
			}
			break;

		default:
			alert("Please enter a valid zip code.")
			return false;
			break;
	}
}


function isName(ss,min,max,bolSpace){
	var inputStr = ss.toString()
	var OkChar
	var match
	if((inputStr.length >= min)&&(inputStr.length <= max)){
		if(bolSpace){
			OkChar =  "ABCDEFGHIJKLMNOPQRSTUVWXYZ'.- abcdefghijklmnopqrstuvwxyz"
		}
		else{
			OkChar =  "ABCDEFGHIJKLMNOPQRSTUVWXYZ'.-abcdefghijklmnopqrstuvwxyz"
		}
		for(var i = 0; i < inputStr.length; i++){
			match = false
			for (var j = 0; j < OkChar.length; j++){
				if((inputStr.charAt(i) == OkChar.charAt(j))){
					match=true;
					j = OkChar.length
				}
			}
			if (!match){
				return false;
			}
		}
		return true;
	}
	else{
		return false;
	}
	
}