/*
	r = required
	o = optional
	
	i = integer
	f = float
	m = money
	p3 = phone number split into 3 fields
		the 3 phone number fields must be named the same.
	z2 = zip code split into 2 fields
		the 2 zip code fields must be named the same.
	zc = Canadian zip code
	d3 = date split into 3 fields
		the 3 fields must be named the same.
	u = sbcuid
	cn = crewname
	s = select box
	rb = radio button
	rw = radio buttons for work addresses needing Corporate Real Estate Approval
	cb = checkbox
	ph = place holder
	     Use this type for a hidden form field to prevent the user from submitting the page.  This may be necessary
		 if the user must search for an employee before continuing.
	
	ri = rehire indicator
	     Only use this type if a comments field is also used and is required based upon value selected in this field.
	pm = positive money
	     dollar value greater than 0
*/
var firstBadField = "-1";
var errorMsg;
var checkSubmit;
var radioCheckElementList;

function textRemove(s, spec){
	// remove passed special characters from the passed text string
	var len = s.length;
	var pos = s.indexOf(spec);

	while (pos != -1) {
		s = s.substring(0, pos) + s.substring(pos + 1, len)
		len = len - 1
		
		pos = s.indexOf(spec)
	}
	return s
}

function formatFieldName(fieldName) {
	var formattedFieldName;

	// remove the underscore(_) and preceeding characters from the field name
	pos = fieldName.indexOf("_");
	fieldName = fieldName.substring(pos + 1, fieldName.length);
	
	fieldName = textRemove(fieldName,"[");
	fieldName = textRemove(fieldName,"]");
	
	// seperate field name into seprate words
	formattedFieldName = fieldName.charAt(0).toUpperCase();
	for (k = 1; k < fieldName.length; k++) {
		if (fieldName.charAt(k) == fieldName.charAt(k).toUpperCase()) {
			formattedFieldName += " ";
		}
		formattedFieldName += fieldName.charAt(k);
	}
	return formattedFieldName;
}

function getValidationType(fieldName) {
	var validationType;
	
	pos = fieldName.indexOf("_");
	if (pos != -1) {
		validationType = fieldName.substring(1, pos);
	} else {
		validationType = "";
	}
	
	return validationType;
}

function hasBeenChecked(fieldName) {
	beenChecked = false;
	for (q = 0; q < radioCheckElementList.length; q++) {
		if (radioCheckElementList[q] == fieldName) {
	    	beenChecked = true;
			break;
		}
	}
	return beenChecked;
}

function anOrA(fieldName) {
	var firstLetter = formatFieldName(fieldName).charAt(0);
	if ("AEIOU".indexOf(firstLetter) == "-1") {
		return("A");
	} else {
		return("An");
	}
}

function checkRequired(formField) {
	if (formField.name.charAt(0) == "r" && checkSubmit) {
		if (formField.value.length == 0) {
			errorMsg += formatFieldName(formField.name) + " is a required field.\n\n";
			return false;
		}
	}
	return true;
}

function isInteger(formField) {
	var errorCode = "-1";

	formField.value = textRemove(formField.value, ",");
	//formField.value = textRemove(formField.value, " ");
	
	for (m = 0; m < formField.value.length; m++) {
		if (isNaN(parseInt(formField.value.charAt(m)))) {
			if (formField.value.charAt(m) == ".") 
				errorCode = "dd";
			else
				errorCode = "nn";
			break;
		}
	}
	return errorCode;
}

function removeLeadingZeros(formFieldValue) {
  var newValue;
  var startFlag = false;
  var startPos;

  for (b=0; b<formFieldValue.length; b++) {
    if (formFieldValue.charAt(b) == '0') {
    } else {
      startFlag = true;
      startPos = b;
      break;
    }
  }

  if (startFlag) {
    newValue = formFieldValue.substring(startPos);
  } else {
    newValue = '0';
  }

  return newValue;
}

function validateInt(formField) {
	if (arguments.length == 2)
	  fieldName = arguments[1];
	else
	  fieldName = formatFieldName(formField.name);
	  
	var valid = true;
	
	valid = checkRequired(formField);
	if (valid) {
		errorCode = isInteger(formField);
	
		if (errorCode != "-1") {
			if (errorCode == "nn") 
				errorMsg += fieldName + " must be numeric.\n\n";
			else if (errorCode == "dd")
				errorMsg += fieldName + " must be an integer.\n\n";
			valid = false;
		} else {
			if (formField.value.length > 0) 
//				formField.value = parseInt(formField.value);
				formField.value = parseInt(removeLeadingZeros(formField.value));
		}
	}
	return valid;
}
	
function validateFloat(formField) {
	var valid = true;
	var hasDecimal = false;
	var errorCode = "-1";

	formField.value = textRemove(formField.value, ",");
	formField.value = textRemove(formField.value, " ");
	
	valid = checkRequired(formField);
	
	for (j = 0; j < formField.value.length; j++) {
		if (isNaN(parseInt(formField.value.charAt(j)))) {
			if (formField.value.charAt(j) == ".") {
				if (hasDecimal) {
					errorCode = "dd";
					break;
				}
				hasDecimal = true;
			} else {
				errorCode = "nn";
				break;
			}
		}
	}
	
	if (errorCode != "-1") {
		if (errorCode == "nn") 
			errorMsg += formatFieldName(formField.name) + " must be numeric.\n\n";
		else if (errorCode == "dd")
			errorMsg += formatFieldName(formField.name) + " contains multiple decimal points.\n\n";
		valid = false;
	} else {
		if (formField.value.length > 0) {
			formField.value = parseFloat(formField.value);
		}
	}
	return valid;
}

function validateMoney(formField) {
	var valid = true;
	var hasDecimal = false;
	var errorCode = "-1";

	formField.value = textRemove(formField.value, "$");
	formField.value = textRemove(formField.value, ",");
	formField.value = textRemove(formField.value, " ");
	
	valid = checkRequired(formField);
	
	for (j = 0; j < formField.value.length; j++) {
		if (isNaN(parseInt(formField.value.charAt(j)))) {
			if (formField.value.charAt(j) == ".") {
				if (hasDecimal) {
					errorCode = "dd";
					break;
				}
				hasDecimal = true;
			} else {
				errorCode = "nn";
				break;
			}
		}
	}
	
	if (errorCode != "-1") {
		if (errorCode == "nn") 
			errorMsg += formatFieldName(formField.name) + " must be numeric.\n\n";
		else if (errorCode == "dd")
			errorMsg += formatFieldName(formField.name) + " contains multiple decimal points.\n\n";
		valid = false;
	} else {
		if (formField.value.length > 0) {
			formField.value = parseFloat(formField.value);
			formField.value *= 100;
			formField.value = parseInt(formField.value);
			formField.value /= 100;
		}
	}
	return valid;
}

function validatePositiveMoney(formField) {
	var valid;
	
	valid = validateMoney(formField);
	if (valid && formField.value.length > 0) {
		if (formField.value <= 0) {
			errorMsg += formatFieldName(formField.name) + " must be greater than zero.\n\n";
			valid = false;
		}
	}
	return valid;
}

function validateMaskedPhoneNumber(form, position) {
	var valid = true;
	var areaCode = form.elements[position];
	var prefix = form.elements[position + 1];
	var suffix = form.elements[position + 2];
	
	valid = checkRequired(areaCode);
	if (valid)
		valid = checkRequired(prefix);
	if (valid)
		valid = checkRequired(suffix);
	
	var aError = isInteger(areaCode);
	var pError = isInteger(prefix);
	var sError = isInteger(suffix);
	
	if (aError != "-1") {
		if (aError == "nn")
			errorMsg += formatFieldName(areaCode.name) + " area code must be numeric.\n\n";
		else if (aError == "dd")
			errorMsg += formatFieldName(areaCode.name) + " area code must be an integer.\n\n";
		valid = false;
	} if (pError != "-1") {
		if (pError == "nn")
			errorMsg += formatFieldName(prefix.name) + " prefix must be numeric.\n\n";
		else if (pError == "dd")
			errorMsg += formatFieldName(prefix.name) + " prefix must be an integer.\n\n";
		valid = false;
	} if (sError != "-1") {
		if (sError == "nn")
			errorMsg += formatFieldName(suffix.name) + " suffix must be numeric.\n\n";
		else if (sError == "dd")
			errorMsg += formatFieldName(suffix.name) + " suffix must be an integer.\n\n";
		valid = false;
	}
	if (areaCode.value.length > 0 || prefix.value.length > 0 || suffix.value.length > 0) {
		if (checkSubmit) {
			if (areaCode.value.length != 3) {
				errorMsg += formatFieldName(areaCode.name) + " area code must contain 3 digits.\n\n";
				valid = false;
			} if (prefix.value.length != 3) {
				errorMsg += formatFieldName(prefix.name) + " prefix must contain 3 digits.\n\n";
				valid = false;
			} if (suffix.value.length != 4) {
				errorMsg += formatFieldName(suffix.name) + " suffix must contain 4 digits.\n\n";
				valid = false;
			}
		}
	}
	i += 2;
	return valid;
}

function validateMaskedZipCode(form, position) {
	var valid = true;
	var zipCode = form.elements[position];
	var suffix = form.elements[position + 1];
	
	valid = checkRequired(zipCode);
	if (valid)
		valid = checkRequired(suffix);
	
	var zError = isInteger(zipCode);
	var sError = isInteger(suffix);
	
	if (zError != "-1") {
		if (zError == "nn") 
			errorMsg += formatFieldName(zipCode.name) + " must be numeric.\n\n";
		else if (zError == "dd")
			errorMsg += formatFieldName(zipCode.name) + " must be an integer.\n\n";
		valid = false;
	} if ((zipCode.value.length > 0 || suffix.value.length > 0 ) && zipCode.value.length != 5 && checkSubmit) {
		errorMsg += formatFieldName(zipCode.name) + " must contain 5 digits.\n\n";
		valid = false;
	} if (sError != "-1") {
		if (sError == "nn")
			errorMsg += formatFieldName(suffix.name) + " suffix must be numeric.\n\n";
		else if (sError == "dd")
			errorMsg += formatFieldName(suffix.name) + " suffix must be an integer.\n\n";
		valid = false;
	} if (suffix.value.length > 0 && suffix.value.length < 4 && checkSubmit) {
		errorMsg += formatFieldName(suffix.name) + " suffix must contain 4 digits.\n\n";
		valied = false;
	}
	
	i++;
	return valid;
}

function validateCreditCard(form, position) {
	var valid = true;
	var c1 = form.elements[position];
	var c2 = form.elements[position + 1];
	var c3 = form.elements[position + 2];
	var c4 = form.elements[position + 3];
	
	valid = checkRequired(c1);
	if (valid)	
		valid = checkRequired(c2);
	if (valid)
		valid = checkRequired(c3);
	if (valid)
		valid = checkRequired(c4);
	
	if (valid) {
		var aError = isInteger(c1);
		var bError = isInteger(c1);
		var cError = isInteger(c1);
		var dError = isInteger(c1);
	
		if (aError != "-1" || bError != "-1" || cError != "-1" || dError != "-1") {
			if (aError == "nn" || bError == "nn" || cError == "nn" || dError == "nn") 
				errorMsg += formatFieldName(c1.name) + " must be numeric.\n\n";
			else
				errorMsg += formatFieldName(c1.name) + " must be an integer.\n\n";
			valid = false;
		}
	
		if (c1.value.length != 4 || c2.value.length != 4 || c3.value.length != 4 || c4.value.length != 4) {
			errorMsg += formatFieldName(c1.name) + " must be 16 digits.\n\n";
			valid = false;
		}
	}
	i+=3;
	return valid;
}

function validateCVV2(formField) {
	var valid = true;
	
	valid = checkRequired(formField);
	
	if (valid) {
		var aError = isInteger(formField);
	
		if (aError != "-1") {
			if (aError == "nn") 
				errorMsg += formatFieldName(formField.name) + " must be numeric.\n\n";
			else
				errorMsg += formatFieldName(formField.name) + " must be an integer.\n\n";
			valid = false;
		}
	
		if (formField.value.length != 3) {
			errorMsg += formatFieldName(formField.name) + " must be 3 digits.\n\n";
			valid = false;
		}
	}

	return valid;
}

function validateCanadianZipCode(formField) {
	var valid = true;

	valid = checkRequired(formField);
	if (valid) {
		if (formField.value.length != 7) {
			errorMsg += formatFieldName(formField.name) + " must contain 7 characters.\n\n";
			valid = false;
		}
	}
	return valid;
}

function validateMaskedDate(form, position) {
	var valid = true;
	var errorCode;
	var month = form.elements[position];
	var day = form.elements[position + 1];
	var year = form.elements[position + 2];
	
	valid = checkRequired(month);
	if (valid)
		valid = checkRequired(day);
	if (valid) 
		valid = checkRequired(year);

	if (month.value.length > 0 || day.value.length > 0 || year.value.length > 0) {
		var mError = isInteger(month);
		var dError = isInteger(day);
		var yError = isInteger(year);
		
		if (mError != "-1") {
			if (mError == "nn")
				errorMsg += formatFieldName(month.name) + " month must be numeric.\n\n";
			else if (mError == "dd")
				errorMsg += formatFieldName(month.name) + " month must be an integer.\n\n";
			valid = false;
		} if (dError != "-1") {
			if (dError == "nn")
				errorMsg += formatFieldName(day.name) + " day must be numeric.\n\n";
			else if (dError == "dd")
				errorMsg += formatFieldName(day.name) + " day must be an integer.\n\n";
			valid = false;
		} if (yError != "-1") {
			if (yError == "nn")
				errorMsg += formatFieldName(year.name) + " year must be numeric.\n\n";
			else if (yError == "dd")
				errorMsg += formatFieldName(year.name) + " year must be an integer.\n\n";
			valid = false;
		}
		if (checkSubmit) {
			if (month.value.length == 0) {
				errorMsg += formatFieldName(month.name) + " month must be entered.\n\n";
				valid = false;
			} if (day.value.length == 0) {
				errorMsg += formatFieldName(day.name) + " day must be entered.\n\n";
				valid = false;
			} if (year.value.length == 0) {
				errorMsg += formatFieldName(day.name) + " year must be entered.\n\n";
				valid = false;
			}

		}				
				
		if (valid && checkSubmit) {
			// check to make sure day corresponds with month entered
			monthVal = parseInt(removeLeadingZeros(month.value));
			dayVal = parseInt(removeLeadingZeros(day.value));
			yearVal = parseInt(removeLeadingZeros(year.value));
			if (monthVal < 1 || monthVal > 12) 
				valid = false;
			switch (monthVal) {
				case 1:
				case 3:
				case 5:
				case 7:
				case 8:
				case 10:
				case 12:
					if (dayVal < 1 || dayVal > 31) 
						valid = false;
					break;
				case 4:
				case 6:
				case 9:
				case 11:
					if (dayVal < 1 || dayVal > 30)
						valid = false;
					break;
				case 2:
					if (((yearVal % 4 == 0) && (yearVal % 100 != 0)) || (yearVal % 400 == 0)) { // leap year
						if (dayVal < 1 || dayVal > 29)
							valid = false;
					} else {
						if (dayVal < 1 || dayVal > 28)
							valid = false;
					}
					break;
			}
			if (!valid) 
				errorMsg += formatFieldName(month.name) + " is not a valid date.\n\n";
		}
	}
	
	if (valid) {
		if (month.value.length == 1)
			month.value = "0" + month.value;
		if (day.value.length == 1)
			day.value = "0" + day.value;
	}
	
	i+=2;
	return valid;
}

function validateSbcuid(formField) {
   if (arguments.length == 2)
	  fieldName = arguments[1];
	else
	  fieldName = formatFieldName(formField.name);
	  
	valid = true;	
	if (formField.value.length > 0) {
		if (formField.value.length != 6) {
			errorMsg += fieldName + " must contain 6 characters.\n\n";
			valid = false;
		} else {
			// SBCUID has 6 characters, lets make sure the first 2 are letters
			for (j = 0; j < 2; j++) {
				if ((formField.value.charAt(j) < "A") || (formField.value.charAt(j) > "z")) {
					errorMsg += fieldName + " must begin with two letters.\n\n";
					valid = false;
					break;
				}
			}
		}
	} 
	return valid;
}

function validateSsn(formField) {
	if (arguments.length == 2)
		fieldName = arguments[1];
	else
		fieldName = formatFieldName(formField.name);
	  
	valid = true;	
	if (formField.value.length > 0) {
		if (formField.value.length != 9) {
			errorMsg += fieldName + " must contain 9 characters.\n\n";
			valid = false;		
		} else {
			valueSansZeroes = textRemove(formField.value, "0");
			if (valueSansZeroes.length == 0) {
				errorMsg += fieldName + " must not equal 0.\n\n";
				valid = false;	
			}
	    }	
	}
	return valid;
}
function validatePernr(formField) {
	if (arguments.length == 2)
		fieldName = arguments[1];
	else
		fieldName = formatFieldName(formField.name);
	  
	valid = true;
	
	if (formField.value.length > 0) {
		if (!validateInt(formField, "PERNR")) {
			valid = false;		
		} else {
			valueSansZeroes = textRemove(formField.value, "0");
			if (valueSansZeroes.length == 0) {
				errorMsg += fieldName + " must not equal 0.\n\n";
				valid = false;	
			}
	    }
		if (formField.value.length > 8) {
			errorMsg += fieldName + " must 8 characters or less.\n\n";
			valid = false;		
		}		
	}
	return valid;
}


function validateCrewName(formField) {
  var valid = true;
  
  capitalized = formField.value.toUpperCase();
  valid = checkRequired(formField);
  if (valid && checkSubmit) {
    if (capitalized.indexOf("CREW") != 0) {
      errorMsg += formatFieldName(formField.name) + " must begin with \"CREW\" (not case sensitive).\n\n";
	  valid = false;
    }
  }
  return valid;
}

function validateSelectBox(formField) {
	if (formField.name.charAt(0) == "r" && checkSubmit) {
		var selectedOption = formField.options[formField.options.selectedIndex].value;
		if (selectedOption.length == 0 || selectedOption == "* Required *") {
			errorMsg += formatFieldName(formField.name) + " is a required field.\n\n";
			return false;
		}
	}
	return true;
}

function validateRadioButtons(form, formField) {
	if (!hasBeenChecked(formField.name)) {
		radioCheckElementList[radioCheckElementList.length] = formField.name;
    	fieldString = "form." + formField.name;
		radioBoxes = eval(fieldString)
		if (formField.name.charAt(0) == "r" && checkSubmit) {
			var optionSelected = false;
			for (x = 0; x < radioBoxes.length; x++) {
				if (radioBoxes[x].checked) {
					optionSelected = true;
					break;
				}
			}
			if (radioBoxes.checked) {
				optionSelected = true;
			}
			if (!optionSelected) {
				errorMsg += anOrA(formField.name) + " " + formatFieldName(formField.name) + " must be selected.\n\n";
			}
			return optionSelected;
		} else {
			return true;
		}
	}
	return true;
}
/** KH8920  ******************************************************************************************************/
function validateBuildingRadioButtons(form, formField) {
	if (!hasBeenChecked(formField.name)) {
		radioCheckElementList[radioCheckElementList.length] = formField.name;
    		fieldString = "form." + formField.name;
		radioBoxes = eval(fieldString)
		if (formField.name.charAt(0) == "r" && checkSubmit) {
			var optionSelected = false;
			var optionIsValid = true;
			for (x = 0; x < radioBoxes.length; x++) {
				if (radioBoxes[x].checked) {
					optionSelected = true;
					if (!confirmPacBellBuilding(radioBoxes[x].value)) {
						optionIsValid = false;
					}
					break;
				}
			}
			if (radioBoxes.checked) {
				optionSelected = true;
				if (!confirmPacBellBuilding(radioBoxes.value)) {
					optionIsValid = false;
				}
			}
			if (!optionSelected) {
				errorMsg += anOrA(formField.name) + " " + formatFieldName(formField.name) + " must be selected.\n\n";
			}
			if (!optionIsValid) {
				errorMsg += "Corporate Real Estate approval is required prior to selecting this Address.\n\n";
			}
			if (optionSelected && optionIsValid) {
				return true;
			} else {
				return false;
			}
		} else {
			return true;
		}
	}
	return true;
}

function confirmPacBellBuilding(rdoBoxValue) {
	if(rdoBoxValue.indexOf("*%CAMP%*") > -1){
		message = setPacBellBuildingMessage();
		if (confirm(message)) {
			return true; 
		} else {
			return false;
		}
	} else {
	 	return true;
	}
}

function setPacBellBuildingMessage(){
	var str;
	str = "California Public Utility Commission Code Section 851 (see SBC's Operating Practice 125, Section 11) \n";
	str = str + "compliance requirements mandate Corporate Real Estate approve all Non-Pacific Bell employees locating \n";
	str = str + "within Pacific Bell owned or leased facilities.  The consequences of non-compliance can be severe: \n";
	str = str + "    -The Commission may fine Pacific Bell up to $20,000 per day, per occurrence. \n";
	str = str + "    -Employees may face disciplinary action up to and including dismissal. \n";
	str = str + "To obtain authorization for your request, contact Corporate Real Estate at 1-888-272-4300 or CRE851@msg.pacbell.com. \n";
	str = str + "Have you already obtained Corporate Real Estate's approval for this PCR? \n";
	return str;
}
/** KH8920  ******************************************************************************************************/

function validateCheckBoxes(form, formField) {
	if (!hasBeenChecked(formField.name)) {
		radioCheckElementList[radioCheckElementList.length] = formField.name;
    	fieldString = "form." + formField.name;
		radioBoxes = eval(fieldString)
		if (formField.name.charAt(0) == "r" && checkSubmit) {
			var optionSelected = false;
			for (x = 0; x < radioBoxes.length; x++) {
				if (radioBoxes[x].checked) {
					optionSelected = true;
					break;
				}
			}
			if (radioBoxes.checked) {
				optionSelected = true;
			}
			if (!optionSelected) {
				errorMsg += anOrA(formField.name) + " " + formatFieldName(formField.name) + " must be selected.\n\n";
			}
			return optionSelected;
		} else {
			return true;
		}
	}
	return true;
}

function validatePlaceHolder(formField) {
	if (formField.name.charAt(0) == "r" && checkSubmit && formField.value.length == 0) {
		errorMsg += anOrA(formField.name) + " " + formatFieldName(formField.name) + " must be selected.\n\n";
	}
}

/************************** Begin custom validation **********************/
function validateRehireIndicator(formField) {
	if (validateSelectBox(formField) && checkSubmit) {
		var selectedValue = formField.options[formField.options.selectedIndex].value;
		if ((selectedValue != "01") && (formField.form.ot_comments.value.length == 0)) {
			var selectedText = formField.options[formField.options.selectedIndex].text;
			errorMsg += "Because \"" + selectedText + "\" was selected,\nComments is a required field.\n\n";
			return false;
		}
	} else {
		return false;
	}
	return true;
}
/*************************** End custom validation ***********************/

function validateFormData(form) {
	errorMsg = "";
	firstBadField = "-1";
	radioCheckElementList = new Array();
	
	if (arguments.length == 2)
	  checkSubmit = arguments[1];
	else
	  checkSubmit = true;

	for (i = 0; i < form.elements.length; i++) {
		validationType = getValidationType(form.elements[i].name);
		if (form.elements[i].type == "text") {
			switch (validationType) {
				// integer
				case "i":
					if (!validateInt(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
				// float
				case "f":
					if (!validateFloat(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
				// money
				case "m":
					if (!validateMoney(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
				// positive money
				case "pm":
					if (!validatePositiveMoney(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;				
				// phone number split into 3 fields
				case "p3":
					if (!validateMaskedPhoneNumber(form, i) && firstBadField == "-1")
						firstBadField = i;
					break;
				// zip code split into 2 fields
				case "z2":
					if (!validateMaskedZipCode(form, i) && firstBadField == "-1")
						firstBadField = i;
					break;
				// Canadian zip code
				case "zc":
					if (!validateCanadianZipCode(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
				// date split into 3 fields
				case "d3":
					if (!validateMaskedDate(form, i) && firstBadField == "-1")
						firstBadField = i;
					break;
				// sbcuid
				case "u":
					if (!checkRequired(formField)) {
						firstBadField = i;
					}
					if (!validateSbcuid(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
				// crew name
				case "cn":
					if (!validateCrewName(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
				// text field with no special validation
				case "t":
					if (!checkRequired(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
				case "cc":
					if (!validateCreditCard(form, i) && firstBadField == "-1")
						firstBadField = i;
					break;
				case "v2":
					if (!validateCVV2(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
			}
		}
		if (form.elements[i].type == "select-one") {
			switch (validationType) {
				// select box
				case "s":
					if (!validateSelectBox(form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
				// rehire indicator select box
				case "ri":
					if (!validateRehireIndicator(form.elements[i]) && firstBadField == "-1") 
						firstBadField = i;
					break;
			}
		}
		if (form.elements[i].type == "radio") {
			switch (validationType) {
				// radio button
				case "rb":
					if (!validateRadioButtons(form, form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
/** KH8920  ******************************************************************************************************/
				case "rw":
					if (!validateBuildingRadioButtons(form, form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
/** KH8920  *****************************************************************************************************/
			}
		}
		if (form.elements[i].type == "checkbox") {
			switch (validationType) {
				// check box
				case "cb":
					if (!validateCheckBoxes(form, form.elements[i]) && firstBadField == "-1")
						firstBadField = i;
					break;
			}
		}
		if (form.elements[i].type == "hidden") {
			switch (validationType) {
				// hidden field
				case "ph":
					validatePlaceHolder(form.elements[i])
					break;
			}
		}
	}
	if (errorMsg.length > 0) {
		var errorHeader = "=======================================================\n";
		errorHeader +=    "            Please Correct the Following Error(s) Before Continuing\n";
		errorHeader +=    "=======================================================\n\n";
		errorMsg = errorHeader + errorMsg;
		alert(errorMsg);
		if (firstBadField != -1)
			form.elements[firstBadField].focus();
		return false;
	} else {
		return true;
	}	
}

/*****************************************************************************************************
 * This code is for validating an sbcuid, ssn, or pernr when searching for an employee               *
 *****************************************************************************************************/
function getIdType(typeField) {
	if (typeField[0]) {
		for (a = 0; a < typeField.length; a++) {
			if (typeField[a].checked) {
				return typeField[a].value;
			}
		}
	} else {
		return typeField.value;
	}
}

/*****************************************************************************************************
 * This funtion assumes:                                                                             *
 *   If the user can search by sbcuid, ssn, or pernr the radio buttons will be named the same        *
 *   as the search field, but with Type added to the end.                                            *
 *   eg. search field name = "employeeIdentifier"                                                    *
 *       type radio buttons names = "employeeIdentifierType"                                         *
 *   Also, the values for the three buttons must be "sbcuid", "ssn", and "pernr"                     *
 *****************************************************************************************************/
function validateSearch(idField) {
	errorMsg = "";
	
 	idFieldName = idField.name;
	typeField = eval("idField.form." + idFieldName + "Type");
	if (typeField) {
		type = getIdType(typeField);
	} else {
		type = "sbcuid";
	}
	
	if (idField.value.length == 0) {
		errorMsg += formatFieldName(idField.name) + " is a required field.\n\n"
	} else {
		switch (type.toUpperCase()) {
			case "SBCUID":
				validateSbcuid(idField, "SBCUID");
				break;
			case "SSN":
				validateSsn(idField, "SSN");
				break;
			case "PERNR":
				validatePernr(idField, "PERNR");
				break; 
		}
	}
	if (errorMsg.length > 0) {
		var errorHeader = "=======================================================\n";
		errorHeader +=    "            Please Correct the Following Error(s) Before Continuing\n";
		errorHeader +=    "=======================================================\n\n";
		errorMsg = errorHeader + errorMsg;
		alert(errorMsg);
		idField.focus();
		idField.select();
		return false;
	} else {
		return true;
	}
}