//------------------------ERROR TYPES------------------------
var EMPTY = 1;
var OVERFLOW = 2;
var MIN = 3;
var MAX = 4;
var RANGE = 5;
var TEXT = 6;
var INTEGER = 7;
var NUMERIC = 8;
var ALPHANUMERIC = 9;
var DATE = 10;
var DATERANGE = 11;
var FILENAME = 12;
var PHONENUMBER = 13;
var ZIPCODE = 14;
var SSNUMBER = 15;
var TEXTRANGE = 16;
var NUMBERRANGE = 17;
var MAXNUMBERSELECTED = 18;
var MINNUMBERSELECTED = 19;
var CUSTOM = 20;
//-----------------------------------------------------------

//------------------------ERROR CODES------------------------
var ERR_NOERROR = 0;
var ERR_EMPTY = 1;
var ERR_OVERFLOW = 2;
var ERR_OUTOFRANGE = 3;
var ERR_INVALIDPHONENUMBER = 4;
var ERR_INVALIDFILENAME = 5;
var ERR_INVALIDZIPCODE = 6;
var ERR_INVALIDSSNUMBER = 7;
var ERR_DATATYPETEXT = 8;
var ERR_DATATYPEINTEGER = 9;
var ERR_DATATYPENUMERIC = 10;
var ERR_DATATYPEALPHANUMERIC = 11;
var ERR_INVALIDDATE = 12;
var ERR_OUTOFTEXTRANGE = 13;
var ERR_OUTOFNUMBERRANGE = 14;
var ERR_OUTOFNUMBERRANGE = 15;
var ERR_MAXNUMBERSELECTED = 16;
var ERR_MINNUMBERSELECTED = 17;
//-----------------------------------------------------------

//------------------------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_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."
//-----------------------------------------------------------

//-----------------------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 ValidateForm(frm,aEL) {
   var DataEl,DataElType,DataValue;
   var a_err = new Array;
   var err = ERR_NOERROR
   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;
       if (DataElType == "select-one") {
	     DataValue = DataEl.options[DataEl.selectedIndex].value
	     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 if (DataElType == "select-multiple") {
       }
       else if (DataElType == "text" || DataElType == "textarea" || DataElType == "hidden") {
         DataValue = DataEl.value;
         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 && 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 == 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 == 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,errdetail) < 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 == "") {return a_err};
         	 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;
        	 }
           }
         }
       }
       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;	       
	         }
	       }
	     }
       }
  	 }  	 
   }
   return a_err
}
//-----------------------------------------------------------

//-----------------------------------------------------------
function GetErrorString(aERR) {
  var errstrng = aERR[AERR_ERRORSTRING];
  var rplcvlu = "";
  var regEx = new RegExp("%%\\w+%%","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;  
    }      
    errstrng = errstrng.replace(aMatches[0],rplcvlu)
  }
  return errstrng;
}
//-----------------------------------------------------------


//-----------------------------------------------------------
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 m_vlu = vlu
  var pattern = /\D/
  if (pattern.test(m_vlu))
    return false;
  else
    return true;
}

function isFloatNumber(vlu) {
  var m_vlu = vlu
  var pattern = /\d|\./
  if (pattern.test(m_vlu))
    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_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;
}
//-----------------------------------------------------------