/*Script File Containing Validation and Formatting routines*/

var ns4 = (document.layers) ? true:false;
var ie4 = (document.all) ? true:false

var gCurrentElementId, gCurrentElementValue;
var gAllowSubmit=false;
var gDigitMask = "#";         //defines placeholder for digits
var gAlphaMask = "@";         //defines placeholder for alphanumeric characters
var gRJZFMask = "0";          //defines place holder for digits that need to be RJZF
var gOptionalMask = "?"       //defines that a digit/alphabet may/maynot exist

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

function validateEmail() { 
	
	if (!isFieldValueChanged()) return;
	var eSrc=window.event.srcElement;
	var emailStr = eSrc.value;
	var matchArray=emailStr.match(emailPat); 
	if (matchArray==null) { 
	  setStatusClassName(eSrc,"statusFlagError","invalid email address.");
	  return false; 
    } else if ((getStatusClassName(eSrc).toUpperCase() != "STATUSFLAGERRORREQUIRED")) {
     //reset red flag if there are no other errors
		setStatusClassName (eSrc, "StatusFlagOkRequired","");
      
    } else {
		setStatusClassName (eSrc, "StatusFlagOk","");
	}
	return false;
	 
}

function doFocusInit() {
/*
 * Purpose: Method should be called from onFocus event of all elements
 *          Stores the element id and element value when the element gets focus
 *          This can be checked in blur event to see if value has changed
 */
   var eSrc = window.event.srcElement;
   switch (eSrc.type.toUpperCase()) {
      case "TEXT":
         eSrc.select(); break;
      case "TEXTAREA":
         eSrc.select(); break;
   }

   gCurrentElementId = eSrc.id;
   gCurrentElementValue = document.getElementById(gCurrentElementId).value;
   gAllowSubmit = true;
}

function isFieldValueChanged() {
/*
 * Purpose: Method should be called from onBlur event
 *          This element should have called doFocusInit () in onFocus event
 *          This method will return true if value was changed between onFocus and onBlur events
 */
   var eSrc = window.event.srcElement;
   
   //The following line of code will be executed if you forgot to add onFocus=doFocusInit()
   if (gCurrentElementId != eSrc.id) return true;
   

   if (gCurrentElementValue == document.getElementById(eSrc.id).value) 
      return false; 
   else 
      return true;
   
}
function rjzf (inputStr, len) {
//Right Justify zero fill
   inputStr = "00000000000000000000000000000000000000000000000000000000000000" + inputStr
   inputStr = inputStr.slice(inputStr.length - len, inputStr.length)
   return inputStr
}

function ljzf (inputStr, len) {
//Left Justify zero fill
   inputStr = inputStr + "00000000000000000000000000000000000000000000000000000000000000"
   inputStr = inputStr.substr(0, len)
   return inputStr
}
function select(field) {
/*
   Purpose:
      select the contents of given field
   NOTE: 
     Selecting the field triggers onBlur event
*/
   field.focus()
   field.select()   
}

function selectGivenListElement (listObj, textToSelect) {
   var listLength = listObj.length
   for (var i=0; i < listLength; i++) {
      if (listObj.options[i].text == textToSelect) {
         listObj.selectedIndex = i
      }
   }
}

function selectGivenListValue (listObj, valueToSelect) {
   var listLength = listObj.length;
   for (var i=0; i < listLength; i++) {
      if (listObj.options[i].value == valueToSelect) {
         listObj.selectedIndex = i;
      }
   }
}

function setDivStartFocus(i) {
	var id="";
	if (i==1) {
		id="001IN";
	} else if (i==2) {
	    id="020IN";
	} else if (i==3) {
		id="030IN";
	}
	var firstDivEle = document.getElementById(id);
	firstDivEle.focus();
	
}

function doSetup() {
	var firstelement = document.getElementById('001IN');
	firstelement.focus();
}

function isEmpty(inputStr) {
// general purpose function to see if the input value is empty ("" or null)
   if (inputStr == "" || inputStr == null) 
	return true
	else
     return false
}
function getStatusID (eSrc) {
	var sID = getCurrentFieldID(eSrc) + "S";
	
	return sID;
}

function getCurrentFieldID (eSrc) {
   if (eSrc.id.length<3) return "";
   var fieldID = eSrc.id.substr(0,3);
   return fieldID;
}



function setStatusClassName (eSrc, statusClass, message) {
   
   var eStatus = document.getElementById(getStatusID(eSrc));
   switch (statusClass.toUpperCase()) {
      case "STATUSFLAGERROR":
	eStatus.className = statusClass
	if (isEmpty(message)) {
		eStatus.title="Error occured.";
         } else {
  		eStatus.title = message;
	 }
	 gAllowSubmit=false;
      case "STATUSFLAGERRORREQUIRED":

         //Field is required. It cannot be blank. Set Tooltip. No Message Displayed
         eStatus.className = statusClass;
         if (isEmpty(message)) {
            eStatus.title = "Field cannot be left blank";
         } else {
            eStatus.title = message;
         }
	gAllowSubmit=false;
         break;

      case "STATUSFLAGOK":
         eStatus.className = statusClass;
         eStatus.title = "";

         break;
     
      case "STATUSFLAGOKREQUIRED":
         //Do not display any message or tooltip
         eStatus.className = statusClass;
         if (isEmpty(message)) {
            eStatus.title = "Required Field";
         } else {
            eStatus.title = message;
         }
         break;
     
      default:
         eStatus.className = statusClass;
         //If there is an error, display the message and set the title property - tooltip
         if (!isEmpty(message)) {
           alert (message);
           eStatus.title = message;
           gAllowSubmit = false;
         }
         break;
   }
}

function getStatusClassName (eSrc) {
  var eStatus = document.getElementById(getStatusID(eSrc));
  return (eStatus.className);
}



function lTrim (inputStr) {
//Remove leading space characters
   var i;

   if (isEmpty(inputStr)) return "";
   
   for (i=0; i <= inputStr.length - 1; i++) {
      if (inputStr.charAt(i) != " ") return inputStr.substr (i, inputStr.length - i);
      
   }
   
   return "";
}

function rTrim (inputStr) {
//Remove trailing space characters
   var i;

   if (isEmpty(inputStr)) return "";
   
 
   for (i=inputStr.length - 1; i >= 0; i--) {
      if (inputStr.charAt(i) != " ") {
         //return at the first occurence of non-blank character
         return inputStr.substr (0, i + 1);
      }
   }
   
   return "";
}

function trim (inputStr) {
//Remove leading and trailing space characters
   inputStr = lTrim (inputStr)
   return (rTrim (inputStr))
}


function doChkRequired() {
// Purpose: Validates fields that cannot be left blank
//          Should be called in onBlur event of the field
  var eSrc = window.event.srcElement;
  
  if (isEmpty(eSrc.value)) {
	 //Required field is blank            
     setStatusClassName (eSrc, "StatusFlagErrorRequired", "Field cannot be left blank");
  }else {
     //reset red flag if there are no other errors
    setStatusClassName (eSrc, "StatusFlagOkRequired","");
  }
  
}

function formatURL() {
  var eSrc=window.event.srcElement;
  if (!isFieldValueChanged()) return;
  var tmpURL=trim(eSrc.value);
  if (isEmpty(tmpURL)) return ;
 
  if (tmpURL.indexOf('://')==-1) {
	tmpURL="http://"+tmpURL;
	eSrc.value=tmpURL;
 }
  
}


function validateLoginName() {
	
	var eSrc=window.event.srcElement;
	if (!isFieldValueChanged()) return;
	var tmpLoginName=trim(eSrc.value);
	if (isEmpty(tmpLoginName)) return;
	
	if ( tmpLoginName.indexOf('*')>-1 || tmpLoginName.indexOf('\'')>-1 || tmpLoginName.indexOf('"')>-1) 
	{
		setStatusClassName(eSrc,"statusFlagError","invalid character in Log In Name");
	} else if ((getStatusClassName(eSrc).toUpperCase() != "STATUSFLAGERRORREQUIRED")) {
     //reset red flag if there are no other errors
		setStatusClassName (eSrc, "StatusFlagOkRequired","");
    }  
}
function removeSpaces() {
 var eSrc = window.event.srcElement;
 var inVal = eSrc.value;
 var newVal = "";
 for (var i=0; i<inVal.length; i++) {
	if (inVal.substr(i,1)!=" ") {
	  newVal = newVal + inVal.substr(i,1);
	}
 }
 eSrc.value = newVal;
 
}

function formatDollar() {
	var msg="";
	var eSrc = window.event.srcElement;
	var srcNumber = eSrc.value;
	var txtNumber = '' + srcNumber;
	if (txtNumber=="") return;
		
	if (isNaN(txtNumber)) {
		msg="An invalid number was entered";
		setStatusClassName (eSrc, "StatusFlagError", msg);
		
	}
	
	var rxSplit = new RegExp('([0-9])([0-9][0-9][0-9][,.])');
	var arrNumber = txtNumber.split('.');
	arrNumber[0] += '.';
	do {
		arrNumber[0] = arrNumber[0].replace(rxSplit, '$1,$2');
	} while (rxSplit.test(arrNumber[0]));
	
	if (arrNumber.length > 1) {
		eSrc.value= arrNumber.join('');
	}
	else {
		eSrc.value= arrNumber[0].split('.')[0];
    }
 }



function doSegment (maskSegment) {
/****
   Purpose:
      Validate whether the value entered matches the mask segment.
      See doMask for more details
   Global Variables Used:
      gDigitMask, gAlphaMask, gOptionalMask, gInput, gOutput, maskChar
****/
   var validDigits = "0123456789";
   var eSrc = window.event.srcElement;
   var eSrcClassName = getStatusClassName(eSrc); 

   //User did not populate the current segment
   if (isEmpty(gInput) == true) return true;

   //Ensure that field value matches the mask segment
   var i, maskChar, j, tmpStr
   var numZeroes = 0

   for (i=0; i < maskSegment.length; i++) {

      //get the next chracter in mask. Replace optional mask character with previous placeholder found
      maskChar = maskSegment.substr(i, 1);
      if (maskChar == gOptionalMask) {
         maskChar = gLastPlaceholder;
      } else {
         if ("@#0".indexOf (maskChar) > -1) {
            gLastPlaceholder = maskChar;
         }
      }

      switch (maskChar) {
         case gDigitMask:
            //Mask character specifies that input at this position is a digit
            if (gInput.length > 0) {
		
               if (validDigits.indexOf(gInput.substr(0, 1)) == -1) {
		
                  eSrc.value = gOutput + gInput
                  msg = "A character other than 0-9 was entered where digit expected \n";
                  msg = msg + "Ensure field value is entered in the format " + gMask;
		  if (eSrcClassName.toUpperCase() == "STATUSFLAGOKREQUIRED" || eSrcClassName.toUpperCase()=="STATUSFLAGERRORREQUIRED") {
			setStatusClassName(eSrc, "StatusFlagErrorRequired", msg);
		  } else {
                  	setStatusClassName (eSrc, "StatusFlagError", msg);
		  }
                  return false;
               };
            } else {
               if (maskSegment.substr(i, 1) == gOptionalMask) {
                  return true;
               } else {
                  eSrc.value = gOutput + gInput
                  msg = "Field value is shorter than expected \n";
                  msg = msg + "Ensure data is entered in the format " + gMask;
		  if (eSrcClassName.toUpperCase() == "STATUSFLAGOKREQUIRED" || eSrcClassName.toUpperCase()=="STATUSFLAGERRORREQUIRED") {
			setStatusClassName(eSrc, "StatusFlagErrorRequired", msg);
		  } else {
                  	setStatusClassName (eSrc, "StatusFlagError", msg);
		  }     

                  return false;
               }
            }
            gOutput = gOutput + gInput.substr(0, 1);
            gInput = gInput.substr (1);
            break;
         case gAlphaMask:
            //Mask character specifies that input at this position is alphanumeric
            if (gInput.length == 0) {
               if (maskSegment.substr(i, 1) == gOptionalMask) {
                  return true;
               } else {
                  eSrc.value = gOutput + gInput
                  msg = "Field value is shorter than expected \n";
                  msg = msg + "Ensure data is entered in the format " + gMask;
		  if (eSrcClassName.toUpperCase() == "STATUSFLAGOKREQUIRED" || eSrcClassName.toUpperCase()=="STATUSFLAGERRORREQUIRED") {
			setStatusClassName(eSrc, "StatusFlagErrorRequired", msg);
		  } else {
                  	setStatusClassName (eSrc, "StatusFlagError", msg);
		  }  
                
                  return false;
               }
            }
            gOutput = gOutput + gInput.substr(0, 1);
            gInput = gInput.substr (1);
            break;
         case gRJZFMask:
            //Mask character specifies that input at this position is a digit.
            //This digit is part of a set that needs to RJZF
            numZeroes = numZeroes + 1
            if ((maskSegment.substr(i + 1, 1) == gRJZFMask) || (maskSegment.substr(i + 1, 1) == gOptionalMask)) {
               //Mask specifies more zeroes.
               break;
            }

            //All zeroes occuring sequentially have been found. RJZF the corresponding input
            tmpStr = ""
            for (j=0; j < numZeroes; j++) {
               //Get numeric input
               if (validDigits.indexOf(gInput.substr(0, 1)) > -1) {
                  tmpStr = tmpStr + gInput.substr(0, 1);
                  gInput = gInput.substr (1);
               }
            }
            if (tmpStr == "") {
               if (isEmpty(gInput)) {
                  eSrc.value = gOutput + gInput
                  msg = "Field value is shorter than expected \n";
                  msg = msg + "Ensure data is entered in the format " + gMask;
		   if (eSrcClassName.toUpperCase() == "STATUSFLAGOKREQUIRED" || eSrcClassName.toUpperCase()=="STATUSFLAGERRORREQUIRED") {
			setStatusClassName(eSrc, "StatusFlagErrorRequired", msg);
		  } else {
                  	setStatusClassName (eSrc, "StatusFlagError", msg);
		  }
                
                  return false;
               } else {
                  eSrc.value = gOutput + gInput
		
                  msg = "A character other than 0-9 was entered where digit expected \n";
                  msg = msg + "Ensure field value is entered in the format " + gMask;
                   if (eSrcClassName.toUpperCase() == "STATUSFLAGOKREQUIRED" || eSrcClassName.toUpperCase()=="STATUSFLAGERRORREQUIRED") {
			setStatusClassName(eSrc, "StatusFlagErrorRequired", msg);
		  } else {
                  	setStatusClassName (eSrc, "StatusFlagError", msg);
		  }
                  return false;
               }
            } else {
               //RJZF takes place here
               gOutput = gOutput + rjzf(tmpStr, numZeroes);
            }
            numZeroes = 0;
            break;
         default:
            //Mask character specifies that input at this position is a separator
            if (gInput.length > 0) {
               if (gInput.substr(0, 1) == maskChar) {
                  //input contains mask character
                  gOutput = gOutput + gInput.substr(0, 1);
                  gInput = gInput.substr (1);
               } else {
                  //input does not contain mask character
                  gOutput = gOutput + maskChar;
               }
            }

      } // switch statement
   }  // for loop

}

function doMask (mask) {
/*
   Purpose:
      Validate whether the value entered matches the mask
   Validation rules:
      Support the following tokens in the input/output format:
      # - indicates digit 0-9 only
      @ - indicates any alpha/numeric character other than space
      ? - indicates an optional character based on the segment prefix
      []- indicate optional segment
      0 - indicates put either a 0 or number. If user doesn't enter anything, 0 will be entered. Right justifies, zero fills.
   Examples:
      @@### means 2 alpha chars followed by 3 numerics
      ##### means 5 numeric characters
      #???? means 1 to 5 numeric characters (# is the segment prefix)
      #####[-####] is a zip code format. Either 5 or 9 numeric characters may be entered. If the user enters the dash in position 6, it will be preserved. If the user does not enter the dash, it will be inserted in position 6 if more than 5 characters have been entered.
      ###-##-#### is a SSN format. 9 digits must be entered. If the user enters the hyphens in the correct positions, we preserver. If not, we insert.
      ###-###-#### could be a phone number format. 10 numeric digits must be supplied. Could also be represented as (###) ###-#### (where 'space' is a valid character in the mask which simply means that a space must exist there - just like a hyphen is used to represent a dash).
      00000 indicates up to 5 numeric characters may be entered. Right justfies and zero fills to the left. If user enters '1', '00001' will be returned. If user enters '125', '00125' will be returned
   Global Variables used:
      gDigitMask, gAlphaMask, gOptionalMask, gInput, gOutput, maskChar
*/
   if (!isFieldValueChanged()) {return};

   var i; lenPlaceholder=0;
   var bAllOk=true;
   var msg;

   gOutput = ''; gLastPlaceholder = '';
   gMask = mask;

   var eSrc = window.event.srcElement;
   var eSrcClassName = getStatusClassName(eSrc); 
   gInput = eSrc.value;
   

   /********************** Validate the input parameters *************************************************/
   if (isEmpty(gInput) == true) {
	if (eSrcClassName.toUpperCase()=="STATUSFLAGERROR") setStatusClassName(eSrc,"StatusFlagOK","");
	return;
   }

   if (isEmpty(mask) == true) {
      msg = "Mask for this field has not been defined";
      if (eSrcClassName.toUpperCase() == "STATUSFLAGOKREQUIRED" || eSrcClassName.toUpperCase()=="STATUSFLAGERRORREQUIRED") {
	setStatusClassName(eSrc, "StatusFlagErrorRequired", msg);
      } else {
      	setStatusClassName (eSrc, "StatusFlagError", msg);
      }
    
      return;
   }

   //We do not need "]" that ends a segment
   mask = mask.replace ("]", "")

   /********************** Split the mask to various segments and process each segment individually *******/
   var seg;
   seg = mask.split ("[");
   
   for (i=0; i < seg.length; i++) {
      if (doSegment (seg[i]) == false) {
         //Error message would have been generated by doSegment
         return;
      }
   }

   if (isEmpty(gInput)) {
      eSrc.value = gOutput + gInput
      if (eSrcClassName.toUpperCase() == "STATUSFLAGOKREQUIRED" || eSrcClassName.toUpperCase() == "STATUSFLAGERRORREQUIRED")       {
	setStatusClassName(eSrc, "StatusFlagOkRequired", msg);
      } else {
      	setStatusClassName (eSrc, "StatusFlagOk", msg);
      }
      
   } else {
      eSrc.value = gOutput + gInput
      msg = "Value entered exceeds the field format " + gMask;
      if (eSrcClassName.toUpperCase() =="STATUSFLAGOKREQUIRED" || eSrcClassName.toUpperCase() == "STATUSFLAGERRORREQUIRED") {
	setStatusClassName(eSrc, "StatusFlagErrorRequired", msg);
      } else {
      	setStatusClassName (eSrc, "StatusFlagError", msg);
      }
   }

   return;
}

function doCheckFields() {
  var i=0;
  var tmpFieldId="";
  var eSrc; 
  var grpSrc;
  var tmpIndex;
  var fieldId="";
 
  var strCaption=""; 
	
  //if (gAllowSubmit == false) {
  //   switch (document.getElementById(gCurrentElementId).type.toUpperCase()) {
  //      case "TEXT":
  //         document.getElementById(gCurrentElementId).select(); break;
  //   }
  //   return false;
  // }

  for (i=0; i < document.all.length; i++) {
	 eSrc = document.all(i);
	 
	 tmpFieldId = eSrc.id;

     //Check if status field
     if ((tmpFieldId.toLowerCase().charAt(tmpFieldId.length - 1) == "s")) {
        //get the ID of input field
        fieldId = eSrc.id.substr(0, eSrc.id.length-1);
        strCaption = document.all(fieldId + "C").innerText
		if (eSrc.className.toLowerCase() == "statusflagerror" || eSrc.className.toLowerCase()=="statusflagerrorrequired") {
			alert("Error in '" + strCaption + "'. "+document.getElementById(tmpFieldId).title + ".");
			//get the input field
			inpSrc = document.getElementById(fieldId+"IN");
			switch (inpSrc.type.toUpperCase()) {
				case "TEXT":
					inpSrc.select(); break;
				case "TEXTAREA":
					inpSrc.select(); break;
			}

			return false;
		}

        //Process required fields
        if (eSrc.className.toLowerCase() == "statusflagerrorrequired" || eSrc.className.toLowerCase()=="statusflagokrequired") {
           if (isEmpty(document.getElementById(fieldId+"IN").value)) {
              eSrc.className = "StatusFlagErrorRequired";
              eSrc.title = "Field cannot be left blank";
              inpSrc = document.getElementById(fieldId+"IN");
			  switch (inpSrc.type.toUpperCase()) {
				case "TEXT":
					inpSrc.select(); break;
				case "TEXTAREA":
					inpSrc.select(); break;
			  }
			  return false;
           } else {
              eSrc.className = "StatusFlagOkRequired";
           }
        }
	
     }

  }
  return true;
}

function openwindow(window) {
top.location = window;
}
function closeIt() {
  close();
}

function doReset(){
   var allInputs=document.getElementsByTagName("input");
   var allSelects = document.getElementsByTagName("select");
   var allTextAreas = document.getElementsByTagName("textarea");
   var i;
	   
   for (i=0; i<allInputs.length; i++) {
	if (allInputs[i].type=="text") allInputs[i].value = "";
   }
   		
   for (i=0; i <allSelects.length; i++) {
	allSelects[i].selectedIndex = -1;
	
   }
   for (i=0; i<allTextAreas.length; i++) {
		allTextAreas[i].value = "";
   }
}