// FormCheck.js
//
// SUMMARY
//
//
// BASIC DATA VALIDATION FUNCTIONS:
//
// trim (s) Trims both left and right blank spaces in string
// isWhitespace (s) Check whether string s is empty or whitespace.
// isLetter (c) Check whether character c is an English letter
// isDigit (c) Check whether character c is a digit
// isLetterOrDigit (c) Check whether character c is a letter or digit.
// isInteger (s [,eok]) True if all characters in string s are numbers.
// isSignedInteger (s [,eok]) True if all characters in string s are numbers; leading + or - allowed.
// isPositiveInteger (s [,eok]) True if string s is an integer > 0.
// isNonnegativeInteger (s [,eok]) True if string s is an integer >= 0.
// isNegativeInteger (s [,eok]) True if s is an integer < 0.
// isNonpositiveInteger (s [,eok]) True if s is an integer <= 0.
// isFloat (s [,eok]) True if string s is an unsigned floating point (real) number. (Integers also OK.)
// isSignedFloat (s [,eok]) True if string s is a floating point number; leading + or - allowed. (Integers also OK.)
// isAlphabetic (s [,eok]) True if string s is English letters
// isAlphanumeric (s [,eok]) True if string s is English letters and numbers only.
//
// isSSN (s [,eok]) True if string s is a valid U.S. Social Security Number.
// isUSPhoneNumber (s [,eok]) True if string s is a valid U.S. Phone Number.
// isInternationalPhoneNumber (s [,eok]) True if string s is a valid international phone number.
// isZIPCode (s [,eok]) True if string s is a valid U.S. ZIP code.
// isStateCode (s [,eok]) True if string s is a valid U.S. Postal Code
// isEmail (s [,eok]) True if string s is a valid email address.
// isYear (s [,eok]) True if string s is a valid Year number.
// isIntegerInRange (s, a, b [,eok]) True if string s is an integer between a and b, inclusive.
// isMonth (s [,eok]) True if string s is a valid month between 1 and 12.
// isDay (s [,eok]) True if string s is a valid day between 1 and 31.
// daysInFebruary (year) Returns number of days in February of that year.
// isDate (year, month, day) True if string arguments form a valid date.
// FUNCTIONS TO REFORMAT DATA:
//
// stripCharsInBag (s, bag) Removes all characters in string bag from string s.
// stripCharsNotInBag (s, bag) Removes all characters NOT in string bag from string s.
// stripWhitespace (s) Removes all whitespace characters from s.
// stripInitialWhitespace (s) Removes initial (leading) whitespace characters from s.
// reformat (TARGETSTRING, STRING, Function for inserting formatting characters or
// INTEGER, STRING, INTEGER ... ) delimiters into TARGETSTRING.
// reformatZIPCode (ZIPString) If 9 digits, inserts separator hyphen.
// reformatSSN (SSN) Reformats as 123-45-6789.
// reformatUSPhone (USPhone) Reformats as (123) 456-789.
// FUNCTIONS TO PROMPT USER:
//
// prompt (s) Display prompt string s in status bar.
// promptEntry (s) Display data entry prompt string s in status bar.
// warnEmpty (theField, s) Notify user that required field theField is empty.
// warnInvalid (theField, s) Notify user that contents of field theField are invalid.
// FUNCTIONS TO INTERACTIVELY CHECK FIELD CONTENTS:
//
// checkString (theField, s [,eok]) Check that theField.value is not empty or all whitespace.
// checkStateCode (theField) Check that theField.value is a valid U.S. state code.
// checkZIPCode (theField [,eok]) Check that theField.value is a valid ZIP code.
// checkUSPhone (theField [,eok]) Check that theField.value is a valid US Phone.
// checkInternationalPhone (theField [,eok]) Check that theField.value is a valid International Phone.
// checkEmail (theField [,eok]) Check that theField.value is a valid Email.
// checkSSN (theField [,eok]) Check that theField.value is a valid SSN.
// checkYear (theField [,eok]) Check that theField.value is a valid Year.
// checkMonth (theField [,eok]) Check that theField.value is a valid Month.
// checkDay (theField [,eok]) Check that theField.value is a valid Day.
// checkDate (yearField, monthField, dayField, labelString, OKtoOmitDay)
// Check that field values form a valid date.
// getRadioButtonValue (radio) Get checked value from radio button.
// checkCreditCard (radio, theField) Validate credit card info.
// CREDIT CARD DATA VALIDATION FUNCTIONS
//
// isCreditCard (st) True if credit card number passes the Luhn Mod-10 test.
// isVisa (cc) True if string cc is a valid VISA number.
// isMasterCard (cc) True if string cc is a valid MasterCard number.
// isAmericanExpress (cc) True if string cc is a valid American Express number.
// isDinersClub (cc) True if string cc is a valid Diner's Club number.
// isCarteBlanche (cc) True if string cc is a valid Carte Blanche number.
// isDiscover (cc) True if string cc is a valid Discover card number.
// isEnRoute (cc) True if string cc is a valid enRoute card number.
// isJCB (cc) True if string cc is a valid JCB card number.
// isAnyCard (cc) True if string cc is a valid card number for any of the accepted types.
// isCardMatch (Type, Number) True if Number is valid for credic card of type Type.
//
// Other stub functions are retained for backward compatibility with LivePayment code.
// See comments below for details.
//
// Performance hint: when you deploy this file on your website, strip out the
// comment lines from the source code as well as any of the functions which
// you don't need. This will give you a smaller .js file and achieve faster
// downloads.
//
// REGULAR EXPRESSION DECLARATIONS
// Notes which apply to all the regexps below:
// (1) We want to only match strings exactly. In other words,
// we only want to return true if the string being tested
// matches the regular expression with no leading or trailing
// unmatched characters. So, we begin each regexp with
// the special character ^ (which matches beginning of input)
// and end each regexp with the special character $ (which
// matches end of input).
// (2) In the below comments we use these abbreviations:
// BOI = Beginning Of Input
// EOI = End Of Input
// BOI, followed by one or more whitespace characters, followed by EOI.
var reWhitespace = /^\s+$/
// BOI, followed by one lower or uppercase English letter, followed by EOI.
var reLetter = /^[a-zA-Z]$/
// BOI, followed by one or more lower or uppercase English letters,
// followed by EOI.
var reAlphabetic = /^[a-zA-Z]+$/
// BOI, followed by one or more lower or uppercase English letters
// or digits, followed by EOI.
var reAlphanumeric = /^[a-zA-Z0-9]+$/
// BOI, followed by one digit, followed by EOI.
var reDigit = /^\d/
// BOI, followed by one lower or uppercase English letter
// or digit, followed by EOI.
var reLetterOrDigit = /^([a-zA-Z]|\d)$/
// BOI, followed by one or more digits, followed by EOI.
var reInteger = /^\d+$/
// BOI, followed by an optional + or -, followed by one or more digits,
// followed by EOI.
// Line below commented by Pinaki
//var reSignedInteger = /^(+|-)?\d+$/
// BOI, followed by one of these two patterns:
// (a) one or more digits, followed by ., followed by zero or more digits
// (b) zero or more digits, followed by ., followed by one or more digits
// ... followed by EOI.
var reFloat = /^((\d+(\.\d*)?)|((\d*\.)?\d+))$/
// BOI, followed by an optional + or -, followed by one of these two patterns:
// (a) one or more digits, followed by ., followed by zero or more digits
// (b) zero or more digits, followed by ., followed by one or more digits
// ... followed by EOI.
// Line below is commented out by Pinaki... creates an error
//var reSignedFloat = /^(((+|-)?\d+(\.\d*)?)|((+|-)?(\d*\.)?\d+))$/
// BOI, followed by one or more characters, followed by @,
// followed by one or more characters, followed by .,
// followed by one or more characters, followed by EOI.
var reEmail = /^.+\@.+\..+$/
// VARIABLE DECLARATIONS
var digits = "0123456789";
var lowercaseLetters = "abcdefghijklmnopqrstuvwxyz"
var uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
// whitespace characters as defined by this sample code
var whitespace = " \t\n\r";
// non-digit characters which are allowed in phone numbers
var phoneNumberDelimiters = "()- ";
// characters which are allowed in US phone numbers
var validUSPhoneChars = digits + phoneNumberDelimiters;
// characters which are allowed in international phone numbers
// (a leading + is OK)
var validWorldPhoneChars = digits + phoneNumberDelimiters + "+";
// non-digit characters which are allowed in
// Social Security Numbers
var SSNDelimiters = "- ";
// characters which are allowed in Social Security Numbers
var validSSNChars = digits + SSNDelimiters;
// U.S. Social Security Numbers have 9 digits.
// They are formatted as 123-45-6789.
var digitsInSocialSecurityNumber = 9;
// U.S. phone numbers have 10 digits.
// They are formatted as 123 456 7890 or (123) 456-7890.
var digitsInUSPhoneNumber = 10;
// non-digit characters which are allowed in ZIP Codes
var ZIPCodeDelimiters = "-";
// our preferred delimiter for reformatting ZIP Codes
var ZIPCodeDelimeter = "-"
// characters which are allowed in Social Security Numbers
var validZIPCodeChars = digits + ZIPCodeDelimiters
// U.S. ZIP codes have 5 or 9 digits.
// They are formatted as 12345 or 12345-6789.
var digitsInZIPCode1 = 5
var digitsInZIPCode2 = 9
// non-digit characters which are allowed in credit card numbers
var creditCardDelimiters = " "
// CONSTANT STRING DECLARATIONS
// (grouped for ease of translation and localization)
// m is an abbreviation for "missing"
var mPrefix = "You did not enter a value into the "
var mSuffix = " field. This is a required field. Please enter it now."
// s is an abbreviation for "string"
var sUSLastName = "Last Name"
var sUSFirstName = "First Name"
var sWorldLastName = "Family Name"
var sWorldFirstName = "Given Name"
var sTitle = "Title"
var sCompanyName = "Company Name"
var sUSAddress = "Street Address"
var sWorldAddress = "Address"
var sCity = "City"
var sStateCode = "State Code"
var sWorldState = "State, Province, or Prefecture"
var sCountry = "Country"
var sZIPCode = "ZIP Code"
var sWorldPostalCode = "Postal Code"
var sPhone = "Phone Number"
var sFax = "Fax Number"
var sDateOfBirth = "Date of Birth"
var sExpirationDate = "Expiration Date"
var sEmail = "Email"
var sSSN = "Social Security Number"
var sCreditCardNumber = "Credit Card Number"
var sOtherInfo = "Other Information"
// i is an abbreviation for "invalid"
var iStateCode = "This field must be a valid two character U.S. state abbreviation (like CA for California). Please reenter it now."
var iZIPCode = "This field must be a 5 or 9 digit U.S. ZIP Code (like 94043). Please reenter it now."
var iUSPhone = "This field must be a 10 digit U.S. phone number (like 415 555 1212). Please reenter it now."
var iWorldPhone = "This field must be a valid international phone number. Please reenter it now."
var iSSN = "This field must be a 9 digit U.S. social security number (like 123 45 6789). Please reenter it now."
var iEmail = "This field must be a valid email address (like foo@bar.com). Please reenter it now."
var iCreditCardPrefix = "This is not a valid "
var iCreditCardSuffix = " credit card number. (Click the link on this form to see a list of sample numbers.) Please reenter it now."
var iDay = "This field must be a day number between 1 and 31. Please reenter it now."
var iMonth = "This field must be a month number between 1 and 12. Please reenter it now."
var iYear = "This field must be a 2 or 4 digit year number. Please reenter it now."
var iDatePrefix = "The Day, Month, and Year for "
var iDateSuffix = " do not form a valid date. Please reenter them now."
// p is an abbreviation for "prompt"
var pEntryPrompt = "Please enter a "
var pStateCode = "2 character code (like CA)."
var pZIPCode = "5 or 9 digit U.S. ZIP Code (like 94043)."
var pUSPhone = "10 digit U.S. phone number (like 415 555 1212)."
var pWorldPhone = "international phone number."
var pSSN = "9 digit U.S. social security number (like 123 45 6789)."
var pEmail = "valid email address (like foo@bar.com)."
var pCreditCard = "valid credit card number."
var pDay = "day number between 1 and 31."
var pMonth = "month number between 1 and 12."
var pYear = "2 or 4 digit year number."
// Global variable defaultEmptyOK defines default return value
// for many functions when they are passed the empty string.
// By default, they will return defaultEmptyOK.
//
// defaultEmptyOK is false, which means that by default,
// these functions will do "strict" validation. Function
// isInteger, for example, will only return true if it is
// passed a string containing an integer; if it is passed
// the empty string, it will return false.
//
// You can change this default behavior globally (for all
// functions which use defaultEmptyOK) by changing the value
// of defaultEmptyOK.
//
// Most of these functions have an optional argument emptyOK
// which allows you to override the default behavior for
// the duration of a function call.
//
// This functionality is useful because it is possible to
// say "if the user puts anything in this field, it must
// be an integer (or a phone number, or a string, etc.),
// but it's OK to leave the field empty too."
// This is the case for fields which are optional but which
// must have a certain kind of content if filled in.
var defaultEmptyOK = false
// Attempting to make this library run on Navigator 2.0,
// so I'm supplying this array creation routine as per
// JavaScript 1.0 documentation. If you're using
// Navigator 3.0 or later, you don't need to do this;
// you can use the Array constructor instead.
function makeArray(n) {
//*** BUG: If I put this line in, I get two error messages:
//(1) Window.length can't be set by assignment
//(2) daysInMonth has no property indexed by 4
//If I leave it out, the code works fine.
// this.length = n;
for (var i = 1; i <= n; i++) {
this[i] = 0
}
return this
}
var daysInMonth = makeArray(12);
daysInMonth[1] = 31;
daysInMonth[2] = 29; // must programmatically check this
daysInMonth[3] = 31;
daysInMonth[4] = 30;
daysInMonth[5] = 31;
daysInMonth[6] = 30;
daysInMonth[7] = 31;
daysInMonth[8] = 31;
daysInMonth[9] = 30;
daysInMonth[10] = 31;
daysInMonth[11] = 30;
daysInMonth[12] = 31;
// Valid U.S. Postal Codes for states, territories, armed forces, etc.
// See http://www.usps.gov/ncsc/lookups/abbr_state.txt.
var USStateCodeDelimiter = "|";
var USStateCodes = "AL|AK|AS|AZ|AR|CA|CO|CT|DE|DC|FM|FL|GA|GU|HI|ID|IL|IN|IA|KS|KY|LA|ME|MH|MD|MA|MI|MN|MS|MO|MT|NE|NV|NH|NJ|NM|NY|NC|ND|MP|OH|OK|OR|PW|PA|PR|RI|SC|SD|TN|TX|UT|VT|VI|VA|WA|WV|WI|WY|AE|AA|AE|AE|AP"
// Trims both left and right blank spaces
function trim(str)
{
return(str.replace(/^\s+/, '').replace(/\s+$/, ''));
}
// Check whether string s is empty.
function isEmpty(s)
{ return ((s == null) || (s.length == 0))
}
// Returns true if string s is empty or
// whitespace characters only.
function isWhitespace (s)
{ // Is s empty?
return (isEmpty(s) || reWhitespace.test(s));
}
// Removes all characters which appear in regexp bag from string s.
// NOTES:
// 1) bag must be a regexp which matches single characters in isolation,
// i.e. A or B or C or D or 1 or 2 etc.
// e.g. /\d/g or /[a-zA-Z]/g
// 2) make sure to append the 'g' modifier (for global search & replace)
// at the end of the regexp
// e.g. /\d/g or /[a-zA-Z]/g
function stripCharsInRE (s, bag)
{ return s.replace(bag, "")
}
// Removes all characters which appear in string bag from string s.
function stripCharsInBag (s, bag)
{ var i;
var returnString = "";
// Search through string's characters one by one.
// If character is not in bag, append to returnString.
for (i = 0; i < s.length; i++)
{
// Check that current character isn't whitespace.
var c = s.charAt(i);
if (bag.indexOf(c) == -1) returnString += c;
}
return returnString;
}
// Removes all characters which do NOT appear in string bag
// from string s.
function stripCharsNotInBag (s, bag)
{ var i;
var returnString = "";
// Search through string's characters one by one.
// If character is in bag, append to returnString.
for (i = 0; i < s.length; i++)
{
// Check that current character isn't whitespace.
var c = s.charAt(i);
if (bag.indexOf(c) != -1) returnString += c;
}
return returnString;
}
// Removes all whitespace characters from s.
// Global variable whitespace (see above)
// defines which characters are considered whitespace.
function stripWhitespace (s)
{ return stripCharsInBag (s, whitespace)
}
// WORKAROUND FUNCTION FOR NAVIGATOR 2.0.2 COMPATIBILITY.
//
// The below function *should* be unnecessary. In general,
// avoid using it. Use the standard method indexOf instead.
//
// However, because of an apparent bug in indexOf on
// Navigator 2.0.2, the below loop does not work as the
// body of stripInitialWhitespace:
//
// while ((i < s.length) && (whitespace.indexOf(s.charAt(i)) != -1))
// i++;
//
// ... so we provide this workaround function charInString
// instead.
//
// charInString (CHARACTER c, STRING s)
//
// Returns true if single character c (actually a string)
// is contained within string s.
function charInString (c, s)
{ for (i = 0; i < s.length; i++)
{ if (s.charAt(i) == c) return true;
}
return false
}
// Removes initial (leading) whitespace characters from s.
// Global variable whitespace (see above)
// defines which characters are considered whitespace.
function stripInitialWhitespace (s)
{ var i = 0;
while ((i < s.length) && charInString (s.charAt(i), whitespace))
i++;
return s.substring (i, s.length);
}
// Returns true if character c is an English letter
// (A .. Z, a..z).
//
// NOTE: Need i18n version to support European characters.
// This could be tricky due to different character
// sets and orderings for various languages and platforms.
function isLetter (c)
{ return reLetter.test(c)
}
// Returns true if character c is a digit
// (0 .. 9).
function isDigit (c)
{ return reDigit.test(c)
}
// Returns true if character c is a letter or digit.
function isLetterOrDigit (c)
{ return reLetterOrDigit.test(c)
}
// isInteger (STRING s [, BOOLEAN emptyOK])
//
// Returns true if all characters in string s are numbers.
//
// Accepts non-signed integers only. Does not accept floating
// point, exponential notation, etc.
//
// We don't use parseInt because that would accept a string
// with trailing non-numeric characters.
//
// By default, returns defaultEmptyOK if s is empty.
// There is an optional second argument called emptyOK.
// emptyOK is used to override for a single function call
// the default behavior which is specified globally by
// defaultEmptyOK.
// If emptyOK is false (or any value other than true),
// the function will return false if s is empty.
// If emptyOK is true, the function will return true if s is empty.
//
// EXAMPLE FUNCTION CALL: RESULT:
// isInteger ("5") true
// isInteger ("") defaultEmptyOK
// isInteger ("-5") false
// isInteger ("", true) true
// isInteger ("", false) false
// isInteger ("5", false) true
function isInteger (s)
{ var i;
if (isEmpty(s))
if (isInteger.arguments.length == 1) return defaultEmptyOK;
else return (isInteger.arguments[1] == true);
return reInteger.test(s)
}
// isSignedInteger (STRING s [, BOOLEAN emptyOK])
//
// Returns true if all characters are numbers;
// first character is allowed to be + or - as well.
//
// Does not accept floating point, exponential notation, etc.
//
// We don't use parseInt because that would accept a string
// with trailing non-numeric characters.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
//
// EXAMPLE FUNCTION CALL: RESULT:
// isSignedInteger ("5") true
// isSignedInteger ("") defaultEmptyOK
// isSignedInteger ("-5") true
// isSignedInteger ("+5") true
// isSignedInteger ("", false) false
// isSignedInteger ("", true) true
function isSignedInteger (s)
{ if (isEmpty(s))
if (isSignedInteger.arguments.length == 1) return defaultEmptyOK;
else return (isSignedInteger.arguments[1] == true);
else {
return reSignedInteger.test(s)
}
}
// isPositiveInteger (STRING s [, BOOLEAN emptyOK])
//
// Returns true if string s is an integer > 0.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isPositiveInteger (s)
{ var secondArg = defaultEmptyOK;
if (isPositiveInteger.arguments.length > 1)
secondArg = isPositiveInteger.arguments[1];
// The next line is a bit byzantine. What it means is:
// a) s must be a signed integer, AND
// b) one of the following must be true:
// i) s is empty and we are supposed to return true for
// empty strings
// ii) this is a positive, not negative, number
return (isSignedInteger(s, secondArg)
&& ( (isEmpty(s) && secondArg) || (parseInt (s) > 0) ) );
}
// isNonnegativeInteger (STRING s [, BOOLEAN emptyOK])
//
// Returns true if string s is an integer >= 0.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isNonnegativeInteger (s)
{ var secondArg = defaultEmptyOK;
if (isNonnegativeInteger.arguments.length > 1)
secondArg = isNonnegativeInteger.arguments[1];
// The next line is a bit byzantine. What it means is:
// a) s must be a signed integer, AND
// b) one of the following must be true:
// i) s is empty and we are supposed to return true for
// empty strings
// ii) this is a number >= 0
return (isSignedInteger(s, secondArg)
&& ( (isEmpty(s) && secondArg) || (parseInt (s) >= 0) ) );
}
// isNegativeInteger (STRING s [, BOOLEAN emptyOK])
//
// Returns true if string s is an integer < 0.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isNegativeInteger (s)
{ var secondArg = defaultEmptyOK;
if (isNegativeInteger.arguments.length > 1)
secondArg = isNegativeInteger.arguments[1];
// The next line is a bit byzantine. What it means is:
// a) s must be a signed integer, AND
// b) one of the following must be true:
// i) s is empty and we are supposed to return true for
// empty strings
// ii) this is a negative, not positive, number
return (isSignedInteger(s, secondArg)
&& ( (isEmpty(s) && secondArg) || (parseInt (s) < 0) ) );
}
// isNonpositiveInteger (STRING s [, BOOLEAN emptyOK])
//
// Returns true if string s is an integer <= 0.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isNonpositiveInteger (s)
{ var secondArg = defaultEmptyOK;
if (isNonpositiveInteger.arguments.length > 1)
secondArg = isNonpositiveInteger.arguments[1];
// The next line is a bit byzantine. What it means is:
// a) s must be a signed integer, AND
// b) one of the following must be true:
// i) s is empty and we are supposed to return true for
// empty strings
// ii) this is a number <= 0
return (isSignedInteger(s, secondArg)
&& ( (isEmpty(s) && secondArg) || (parseInt (s) <= 0) ) );
}
// isFloat (STRING s [, BOOLEAN emptyOK])
//
// True if string s is an unsigned floating point (real) number.
//
// Also returns true for unsigned integers. If you wish
// to distinguish between integers and floating point numbers,
// first call isInteger, then call isFloat.
//
// Does not accept exponential notation.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isFloat (s)
{ if (isEmpty(s))
if (isFloat.arguments.length == 1) return defaultEmptyOK;
else return (isFloat.arguments[1] == true);
return reFloat.test(s)
}
// isSignedFloat (STRING s [, BOOLEAN emptyOK])
//
// True if string s is a signed or unsigned floating point
// (real) number. First character is allowed to be + or -.
//
// Also returns true for unsigned integers. If you wish
// to distinguish between integers and floating point numbers,
// first call isSignedInteger, then call isSignedFloat.
//
// Does not accept exponential notation.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isSignedFloat (s)
{ if (isEmpty(s))
if (isSignedFloat.arguments.length == 1) return defaultEmptyOK;
else return (isSignedFloat.arguments[1] == true);
else {
return reSignedFloat.test(s)
}
}
// isAlphabetic (STRING s [, BOOLEAN emptyOK])
//
// Returns true if string s is English letters
// (A .. Z, a..z) only.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
//
// NOTE: Need i18n version to support European characters.
// This could be tricky due to different character
// sets and orderings for various languages and platforms.
function isAlphabetic (s)
{ var i;
if (isEmpty(s))
if (isAlphabetic.arguments.length == 1) return defaultEmptyOK;
else return (isAlphabetic.arguments[1] == true);
else {
return reAlphabetic.test(s)
}
}
// isAlphanumeric (STRING s [, BOOLEAN emptyOK])
//
// Returns true if string s is English letters
// (A .. Z, a..z) and numbers only.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
//
// NOTE: Need i18n version to support European characters.
// This could be tricky due to different character
// sets and orderings for various languages and platforms.
function isAlphanumeric (s)
{ var i;
if (isEmpty(s))
if (isAlphanumeric.arguments.length == 1) return defaultEmptyOK;
else return (isAlphanumeric.arguments[1] == true);
else {
return reAlphanumeric.test(s)
}
}
// reformat (TARGETSTRING, STRING, INTEGER, STRING, INTEGER ... )
//
// Handy function for arbitrarily inserting formatting characters
// or delimiters of various kinds within TARGETSTRING.
//
// reformat takes one named argument, a string s, and any number
// of other arguments. The other arguments must be integers or
// strings. These other arguments specify how string s is to be
// reformatted and how and where other strings are to be inserted
// into it.
//
// reformat processes the other arguments in order one by one.
// * If the argument is an integer, reformat appends that number
// of sequential characters from s to the resultString.
// * If the argument is a string, reformat appends the string
// to the resultString.
//
// NOTE: The first argument after TARGETSTRING must be a string.
// (It can be empty.) The second argument must be an integer.
// Thereafter, integers and strings must alternate. This is to
// provide backward compatibility to Navigator 2.0.2 JavaScript
// by avoiding use of the typeof operator.
//
// It is the caller's responsibility to make sure that we do not
// try to copy more characters from s than s.length.
//
// EXAMPLES:
//
// * To reformat a 10-digit U.S. phone number from "1234567890"
// to "(123) 456-7890" make this function call:
// reformat("1234567890", "(", 3, ") ", 3, "-", 4)
//
// * To reformat a 9-digit U.S. Social Security number from
// "123456789" to "123-45-6789" make this function call:
// reformat("123456789", "", 3, "-", 2, "-", 4)
//
// HINT:
//
// If you have a string which is already delimited in one way
// (example: a phone number delimited with spaces as "123 456 7890")
// and you want to delimit it in another way using function reformat,
// call function stripCharsNotInBag to remove the unwanted
// characters, THEN call function reformat to delimit as desired.
//
// EXAMPLE:
//
// reformat (stripCharsNotInBag ("123 456 7890", digits),
// "(", 3, ") ", 3, "-", 4)
function reformat (s)
{ var arg;
var sPos = 0;
var resultString = "";
for (var i = 1; i < reformat.arguments.length; i++) {
arg = reformat.arguments[i];
if (i % 2 == 1) resultString += arg;
else {
resultString += s.substring(sPos, sPos + arg);
sPos += arg;
}
}
return resultString;
}
// isSSN (STRING s [, BOOLEAN emptyOK])
//
// isSSN returns true if string s is a valid U.S. Social
// Security Number. Must be 9 digits.
//
// NOTE: Strip out any delimiters (spaces, hyphens, etc.)
// from string s before calling this function.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isSSN (s)
{ if (isEmpty(s))
if (isSSN.arguments.length == 1) return defaultEmptyOK;
else return (isSSN.arguments[1] == true);
return (isInteger(s) && s.length == digitsInSocialSecurityNumber)
}
// isUSPhoneNumber (STRING s [, BOOLEAN emptyOK])
//
// isUSPhoneNumber returns true if string s is a valid U.S. Phone
// Number. Must be 10 digits.
//
// NOTE: Strip out any delimiters (spaces, hyphens, parentheses, etc.)
// from string s before calling this function.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isUSPhoneNumber (s)
{ if (isEmpty(s))
if (isUSPhoneNumber.arguments.length == 1) return defaultEmptyOK;
else return (isUSPhoneNumber.arguments[1] == true);
return (isInteger(s) && s.length == digitsInUSPhoneNumber)
}
// isInternationalPhoneNumber (STRING s [, BOOLEAN emptyOK])
//
// isInternationalPhoneNumber returns true if string s is a valid
// international phone number. Must be digits only; any length OK.
// May be prefixed by + character.
//
// NOTE: A phone number of all zeros would not be accepted.
// I don't think that is a valid phone number anyway.
//
// NOTE: Strip out any delimiters (spaces, hyphens, parentheses, etc.)
// from string s before calling this function. You may leave in
// leading + character if you wish.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isInternationalPhoneNumber (s)
{ if (isEmpty(s))
if (isInternationalPhoneNumber.arguments.length == 1) return defaultEmptyOK;
else return (isInternationalPhoneNumber.arguments[1] == true);
return (isPositiveInteger(s))
}
// isZIPCode (STRING s [, BOOLEAN emptyOK])
//
// isZIPCode returns true if string s is a valid
// U.S. ZIP code. Must be 5 or 9 digits only.
//
// NOTE: Strip out any delimiters (spaces, hyphens, etc.)
// from string s before calling this function.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isZIPCode (s)
{ if (isEmpty(s))
if (isZIPCode.arguments.length == 1) return defaultEmptyOK;
else return (isZIPCode.arguments[1] == true);
return (isInteger(s) &&
((s.length == digitsInZIPCode1) ||
(s.length == digitsInZIPCode2)))
}
// isStateCode (STRING s [, BOOLEAN emptyOK])
//
// Return true if s is a valid U.S. Postal Code
// (abbreviation for state).
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isStateCode(s)
{ if (isEmpty(s))
if (isStateCode.arguments.length == 1) return defaultEmptyOK;
else return (isStateCode.arguments[1] == true);
return ( (USStateCodes.indexOf(s) != -1) &&
(s.indexOf(USStateCodeDelimiter) == -1) )
}
// isEmail (STRING s [, BOOLEAN emptyOK])
//
// Email address must be of form a@b.c -- in other words:
// * there must be at least one character before the @
// * there must be at least one character before and after the .
// * the characters @ and . are both required
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isEmail (s)
{ if (isEmpty(s))
if (isEmail.arguments.length == 1) return defaultEmptyOK;
else return (isEmail.arguments[1] == true);
else {
return reEmail.test(s)
}
}
// isYear (STRING s [, BOOLEAN emptyOK])
//
// isYear returns true if string s is a valid
// Year number. Must be 2 or 4 digits only.
//
// For Year 2000 compliance, you are advised
// to use 4-digit year numbers everywhere.
//
// And yes, this function is not Year 10000 compliant, but
// because I am giving you 8003 years of advance notice,
// I don't feel very guilty about this.
//
// For B.C. compliance, write your own function. ;->
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isYear (s)
{ if (isEmpty(s))
if (isYear.arguments.length == 1) return defaultEmptyOK;
else return (isYear.arguments[1] == true);
if (!isNonnegativeInteger(s)) return false;
return ((s.length == 2) || (s.length == 4));
}
// isIntegerInRange (STRING s, INTEGER a, INTEGER b [, BOOLEAN emptyOK])
//
// isIntegerInRange returns true if string s is an integer
// within the range of integer arguments a and b, inclusive.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isIntegerInRange (s, a, b)
{ if (isEmpty(s))
if (isIntegerInRange.arguments.length == 1) return defaultEmptyOK;
else return (isIntegerInRange.arguments[1] == true);
// Catch non-integer strings to avoid creating a NaN below,
// which isn't available on JavaScript 1.0 for Windows.
if (!isInteger(s, false)) return false;
// Now, explicitly change the type to integer via parseInt
// so that the comparison code below will work both on
// JavaScript 1.2 (which typechecks in equality comparisons)
// and JavaScript 1.1 and before (which doesn't).
var num = parseInt (s);
return ((num >= a) && (num <= b));
}
// isMonth (STRING s [, BOOLEAN emptyOK])
//
// isMonth returns true if string s is a valid
// month number between 1 and 12.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isMonth (s)
{ if (isEmpty(s))
if (isMonth.arguments.length == 1) return defaultEmptyOK;
else return (isMonth.arguments[1] == true);
return isIntegerInRange (s, 1, 12);
}
// isDay (STRING s [, BOOLEAN emptyOK])
//
// isDay returns true if string s is a valid
// day number between 1 and 31.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function isDay (s)
{ if (isEmpty(s))
if (isDay.arguments.length == 1) return defaultEmptyOK;
else return (isDay.arguments[1] == true);
return isIntegerInRange (s, 1, 31);
}
// daysInFebruary (INTEGER year)
//
// Given integer argument year,
// returns number of days in February of that year.
function daysInFebruary (year)
{ // February has 29 days in any year evenly divisible by four,
// EXCEPT for centurial years which are not also divisible by 400.
return ( ((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0) ) ) ? 29 : 28 );
}
/*
// isDate (STRING year, STRING month, STRING day)
//
// isDate returns true if string arguments year, month, and day
// form a valid date.
//
function isDate (year, month, day)
{ // catch invalid years (not 2- or 4-digit) and invalid months and days.
if (! (isYear(year, false) && isMonth(month, false) && isDay(day, false))) return false;
// Explicitly change type to integer to make code work in both
// JavaScript 1.1 and JavaScript 1.2.
var intYear = parseInt(year);
var intMonth = parseInt(month);
var intDay = parseInt(day);
// catch invalid days, except for February
if (intDay > daysInMonth[intMonth]) return false;
if ((intMonth == 2) && (intDay > daysInFebruary(intYear))) return false;
return true;
}
*/
/* FUNCTIONS TO NOTIFY USER OF INPUT REQUIREMENTS OR MISTAKES. */
// Display prompt string s in status bar.
function prompt (s)
{ window.status = s
}
// Display data entry prompt string s in status bar.
function promptEntry (s)
{ window.status = pEntryPrompt + s
}
// Notify user that required field theField is empty.
// String s describes expected contents of theField.value.
// Put focus in theField and return false.
function warnEmpty (theField, s)
{ theField.focus()
alert(mPrefix + s + mSuffix)
return false
}
// Notify user that contents of field theField are invalid.
// String s describes expected contents of theField.value.
// Put select theField, pu focus in it, and return false.
function warnInvalid (theField, s)
{ theField.focus()
theField.select()
alert(s)
return false
}
/* FUNCTIONS TO INTERACTIVELY CHECK VARIOUS FIELDS. */
// checkString (TEXTFIELD theField, STRING s, [, BOOLEAN emptyOK==false])
//
// Check that string theField.value is not all whitespace.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkString (theField, s, emptyOK)
{ // Next line is needed on NN3 to avoid "undefined is not a number" error
// in equality comparison below.
if (checkString.arguments.length == 2) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
if (isWhitespace(theField.value))
return warnEmpty (theField, s);
else return true;
}
function CheckLen(oField,nLength)
{
var szValue;
szValue = oField.value;
if(szValue.length < nLength)
{
alert('Pasword must be at least ' + nLength + ' characters long. Please try again')
oField.focus();
return false;
}
else
return true;
}
// checkStateCode (TEXTFIELD theField [, BOOLEAN emptyOK==false])
//
// Check that string theField.value is a valid U.S. state code.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkStateCode (theField, emptyOK)
{ if (checkStateCode.arguments.length == 1) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
else
{ theField.value = theField.value.toUpperCase();
if (!isStateCode(theField.value, false))
return warnInvalid (theField, iStateCode);
else return true;
}
}
// takes ZIPString, a string of 5 or 9 digits;
// if 9 digits, inserts separator hyphen
function reformatZIPCode (ZIPString)
{ if (ZIPString.length == 5) return ZIPString;
else return (reformat (ZIPString, "", 5, "-", 4));
}
// checkZIPCode (TEXTFIELD theField [, BOOLEAN emptyOK==false])
//
// Check that string theField.value is a valid ZIP code.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkZIPCode (theField, emptyOK)
{ if (checkZIPCode.arguments.length == 1) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
else
{ var normalizedZIP = stripCharsInBag(theField.value, ZIPCodeDelimiters)
if (!isZIPCode(normalizedZIP, false))
return warnInvalid (theField, iZIPCode);
else
{ // if you don't want to insert a hyphen, comment next line out
theField.value = reformatZIPCode(normalizedZIP)
return true;
}
}
}
// takes USPhone, a string of 10 digits
// and reformats as (123) 456-789
function reformatUSPhone (USPhone)
{ return (reformat (USPhone, "(", 3, ") ", 3, "-", 4))
}
// checkUSPhone (TEXTFIELD theField [, BOOLEAN emptyOK==false])
//
// Check that string theField.value is a valid US Phone.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkUSPhone (theField, emptyOK)
{ if (checkUSPhone.arguments.length == 1) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
else
{ var normalizedPhone = stripCharsInBag(theField.value, phoneNumberDelimiters)
if (!isUSPhoneNumber(normalizedPhone, false))
return warnInvalid (theField, iUSPhone);
else
{ // if you don't want to reformat as (123) 456-789, comment next line out
theField.value = reformatUSPhone(normalizedPhone)
return true;
}
}
}
// checkInternationalPhone (TEXTFIELD theField [, BOOLEAN emptyOK==false])
//
// Check that string theField.value is a valid International Phone.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkInternationalPhone (theField, emptyOK)
{ if (checkInternationalPhone.arguments.length == 1) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
else
{ if (!isInternationalPhoneNumber(theField.value, false))
return warnInvalid (theField, iWorldPhone);
else return true;
}
}
// checkEmail (TEXTFIELD theField [, BOOLEAN emptyOK==false])
//
// Check that string theField.value is a valid Email.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkEmail (theField, emptyOK)
{ if (checkEmail.arguments.length == 1) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
else if (!isEmail(theField.value, false))
return warnInvalid (theField, iEmail);
else return true;
}
// takes SSN, a string of 9 digits
// and reformats as 123-45-6789
function reformatSSN (SSN)
{ return (reformat (SSN, "", 3, "-", 2, "-", 4))
}
// Check that string theField.value is a valid SSN.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkSSN (theField, emptyOK)
{ if (checkSSN.arguments.length == 1) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
else
{ var normalizedSSN = stripCharsInBag(theField.value, SSNDelimiters)
if (!isSSN(normalizedSSN, false))
return warnInvalid (theField, iSSN);
else
{ // if you don't want to reformats as 123-456-7890, comment next line out
theField.value = reformatSSN(normalizedSSN)
return true;
}
}
}
// Check that string theField.value is a valid Year.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkYear (theField, emptyOK)
{ if (checkYear.arguments.length == 1) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
if (!isYear(theField.value, false))
return warnInvalid (theField, iYear);
else return true;
}
// Check that string theField.value is a valid Month.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkMonth (theField, emptyOK)
{ if (checkMonth.arguments.length == 1) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
if (!isMonth(theField.value, false))
return warnInvalid (theField, iMonth);
else return true;
}
// Check that string theField.value is a valid Day.
//
// For explanation of optional argument emptyOK,
// see comments of function isInteger.
function checkDay (theField, emptyOK)
{ if (checkDay.arguments.length == 1) emptyOK = defaultEmptyOK;
if ((emptyOK == true) && (isEmpty(theField.value))) return true;
if (!isDay(theField.value, false))
return warnInvalid (theField, iDay);
else return true;
}
// checkDate (yearField, monthField, dayField, STRING labelString [, OKtoOmitDay==false])
//
// Check that yearField.value, monthField.value, and dayField.value
// form a valid date.
//
// If they don't, labelString (the name of the date, like "Birth Date")
// is displayed to tell the user which date field is invalid.
//
// If it is OK for the day field to be empty, set optional argument
// OKtoOmitDay to true. It defaults to false.
function checkDate (yearField, monthField, dayField, labelString, OKtoOmitDay)
{ // Next line is needed on NN3 to avoid "undefined is not a number" error
// in equality comparison below.
if (checkDate.arguments.length == 4) OKtoOmitDay = false;
if (!isYear(yearField.value)) return warnInvalid (yearField, iYear);
if (!isMonth(monthField.value)) return warnInvalid (monthField, iMonth);
if ( (OKtoOmitDay == true) && isEmpty(dayField.value) ) return true;
else if (!isDay(dayField.value))
return warnInvalid (dayField, iDay);
if (isDate (yearField.value, monthField.value, dayField.value))
return true;
alert (iDatePrefix + labelString + iDateSuffix)
return false
}
// Get checked value from radio button.
function getRadioButtonValue (radio)
{ for (var i = 0; i < radio.length; i++)
{ if (radio[i].checked) { break }
}
return radio[i].value
}
// Validate credit card info.
function checkCreditCard (radio, theField)
{ var cardType = getRadioButtonValue (radio)
var normalizedCCN = stripCharsInBag(theField.value, creditCardDelimiters)
if (!isCardMatch(cardType, normalizedCCN))
return warnInvalid (theField, iCreditCardPrefix + cardType + iCreditCardSuffix);
else
{ theField.value = normalizedCCN
return true
}
}
/* ================================================================
Credit card verification functions
Originally included as Starter Application 1.0.0 in LivePayment.
20 Feb 1997 modified by egk:
changed naming convention to initial lowercase
(isMasterCard instead of IsMasterCard, etc.)
changed isCC to isCreditCard
retained functions named with older conventions from
LivePayment as stub functions for backward
compatibility only
added "AMERICANEXPRESS" as equivalent of "AMEX"
for naming consistency
================================================================ */
/* ================================================================
FUNCTION: isCreditCard(st)
INPUT: st - a string representing a credit card number
RETURNS: true, if the credit card number passes the Luhn Mod-10
test.
false, otherwise
================================================================ */
function isCreditCard(st) {
// Encoding only works on cards with less than 19 digits
if (st.length > 19)
return (false);
sum = 0; mul = 1; l = st.length;
for (i = 0; i < l; i++) {
digit = st.substring(l-i-1,l-i);
tproduct = parseInt(digit ,10)*mul;
if (tproduct >= 10)
sum += (tproduct % 10) + 1;
else
sum += tproduct;
if (mul == 1)
mul++;
else
mul--;
}
// Uncomment the following line to help create credit card numbers
// 1. Create a dummy number with a 0 as the last digit
// 2. Examine the sum written out
// 3. Replace the last digit with the difference between the sum and
// the next multiple of 10.
// document.writeln("
Sum = ",sum,"
");
// alert("Sum = " + sum);
if ((sum % 10) == 0)
return (true);
else
return (false);
} // END FUNCTION isCreditCard()
/* ================================================================
FUNCTION: isVisa()
INPUT: cc - a string representing a credit card number
RETURNS: true, if the credit card number is a valid VISA number.
false, otherwise
Sample number: 4111 1111 1111 1111 (16 digits)
================================================================ */
function isVisa(cc)
{
if (((cc.length == 16) || (cc.length == 13)) &&
(cc.substring(0,1) == 4))
return isCreditCard(cc);
return false;
} // END FUNCTION isVisa()
/* ================================================================
FUNCTION: isMasterCard()
INPUT: cc - a string representing a credit card number
RETURNS: true, if the credit card number is a valid MasterCard
number.
false, otherwise
Sample number: 5500 0000 0000 0004 (16 digits)
================================================================ */
function isMasterCard(cc)
{
firstdig = cc.substring(0,1);
seconddig = cc.substring(1,2);
if ((cc.length == 16) && (firstdig == 5) &&
((seconddig >= 1) && (seconddig <= 5)))
return isCreditCard(cc);
return false;
} // END FUNCTION isMasterCard()
/* ================================================================
FUNCTION: isAmericanExpress()
INPUT: cc - a string representing a credit card number
RETURNS: true, if the credit card number is a valid American
Express number.
false, otherwise
Sample number: 340000000000009 (15 digits)
================================================================ */
function isAmericanExpress(cc)
{
firstdig = cc.substring(0,1);
seconddig = cc.substring(1,2);
if ((cc.length == 15) && (firstdig == 3) &&
((seconddig == 4) || (seconddig == 7)))
return isCreditCard(cc);
return false;
} // END FUNCTION isAmericanExpress()
/* ================================================================
FUNCTION: isDinersClub()
INPUT: cc - a string representing a credit card number
RETURNS: true, if the credit card number is a valid Diner's
Club number.
false, otherwise
Sample number: 30000000000004 (14 digits)
================================================================ */
function isDinersClub(cc)
{
firstdig = cc.substring(0,1);
seconddig = cc.substring(1,2);
if ((cc.length == 14) && (firstdig == 3) &&
((seconddig == 0) || (seconddig == 6) || (seconddig == 8)))
return isCreditCard(cc);
return false;
}
/* ================================================================
FUNCTION: isCarteBlanche()
INPUT: cc - a string representing a credit card number
RETURNS: true, if the credit card number is a valid Carte
Blanche number.
false, otherwise
================================================================ */
function isCarteBlanche(cc)
{
return isDinersClub(cc);
}
/* ================================================================
FUNCTION: isDiscover()
INPUT: cc - a string representing a credit card number
RETURNS: true, if the credit card number is a valid Discover
card number.
false, otherwise
Sample number: 6011000000000004 (16 digits)
================================================================ */
function isDiscover(cc)
{
first4digs = cc.substring(0,4);
if ((cc.length == 16) && (first4digs == "6011"))
return isCreditCard(cc);
return false;
} // END FUNCTION isDiscover()
/* ================================================================
FUNCTION: isEnRoute()
INPUT: cc - a string representing a credit card number
RETURNS: true, if the credit card number is a valid enRoute
card number.
false, otherwise
Sample number: 201400000000009 (15 digits)
================================================================ */
function isEnRoute(cc)
{
first4digs = cc.substring(0,4);
if ((cc.length == 15) &&
((first4digs == "2014") ||
(first4digs == "2149")))
return isCreditCard(cc);
return false;
}
/* ================================================================
FUNCTION: isJCB()
INPUT: cc - a string representing a credit card number
RETURNS: true, if the credit card number is a valid JCB
card number.
false, otherwise
================================================================ */
function isJCB(cc)
{
first4digs = cc.substring(0,4);
if ((cc.length == 16) &&
((first4digs == "3088") ||
(first4digs == "3096") ||
(first4digs == "3112") ||
(first4digs == "3158") ||
(first4digs == "3337") ||
(first4digs == "3528")))
return isCreditCard(cc);
return false;
} // END FUNCTION isJCB()
/* ================================================================
FUNCTION: isAnyCard()
INPUT: cc - a string representing a credit card number
RETURNS: true, if the credit card number is any valid credit
card number for any of the accepted card types.
false, otherwise
================================================================ */
function isAnyCard(cc)
{
if (!isCreditCard(cc))
return false;
if (!isMasterCard(cc) && !isVisa(cc) && !isAmericanExpress(cc) && !isDinersClub(cc) &&
!isDiscover(cc) && !isEnRoute(cc) && !isJCB(cc)) {
return false;
}
return true;
} // END FUNCTION isAnyCard()
/* ================================================================
FUNCTION: isCardMatch()
INPUT: cardType - a string representing the credit card type
cardNumber - a string representing a credit card number
RETURNS: true, if the credit card number is valid for the particular
credit card type given in "cardType".
false, otherwise
================================================================ */
function isCardMatch (cardType, cardNumber)
{
cardType = cardType.toUpperCase();
var doesMatch = true;
if ((cardType == "VISA") && (!isVisa(cardNumber)))
doesMatch = false;
if ((cardType == "MASTERCARD") && (!isMasterCard(cardNumber)))
doesMatch = false;
if ( ( (cardType == "AMERICANEXPRESS") || (cardType == "AMEX") )
&& (!isAmericanExpress(cardNumber))) doesMatch = false;
if ((cardType == "DISCOVER") && (!isDiscover(cardNumber)))
doesMatch = false;
if ((cardType == "JCB") && (!isJCB(cardNumber)))
doesMatch = false;
if ((cardType == "DINERS") && (!isDinersClub(cardNumber)))
doesMatch = false;
if ((cardType == "CARTEBLANCHE") && (!isCarteBlanche(cardNumber)))
doesMatch = false;
if ((cardType == "ENROUTE") && (!isEnRoute(cardNumber)))
doesMatch = false;
return doesMatch;
} // END FUNCTION CardMatch()
/* ================================================================
The below stub functions are retained for backward compatibility
with the original LivePayment code so that it should be possible
in principle to swap in this new module as a replacement for the
older module without breaking existing code. (There are no
guarantees, of course, but it should work.)
When writing new code, do not use these stub functions; use the
functions defined above.
================================================================ */
function IsCC (st) {
return isCreditCard(st);
}
function IsVisa (cc) {
return isVisa(cc);
}
function IsVISA (cc) {
return isVisa(cc);
}
function IsMasterCard (cc) {
return isMasterCard(cc);
}
function IsMastercard (cc) {
return isMasterCard(cc);
}
function IsMC (cc) {
return isMasterCard(cc);
}
function IsAmericanExpress (cc) {
return isAmericanExpress(cc);
}
function IsAmEx (cc) {
return isAmericanExpress(cc);
}
function IsDinersClub (cc) {
return isDinersClub(cc);
}
function IsDC (cc) {
return isDinersClub(cc);
}
function IsDiners (cc) {
return isDinersClub(cc);
}
function IsCarteBlanche (cc) {
return isCarteBlanche(cc);
}
function IsCB (cc) {
return isCarteBlanche(cc);
}
function IsDiscover (cc) {
return isDiscover(cc);
}
function IsEnRoute (cc) {
return isEnRoute(cc);
}
function IsenRoute (cc) {
return isEnRoute(cc);
}
function IsJCB (cc) {
return isJCB(cc);
}
function IsAnyCard(cc) {
return isAnyCard(cc);
}
function IsCardMatch (cardType, cardNumber) {
return isCardMatch (cardType, cardNumber);
}
// ===================================================================
// Author: Matt Kruse
// WWW: http://www.mattkruse.com/
//
// NOTICE: You may use this code for any purpose, commercial or
// private, without any further permission from the author. You may
// remove this notice from your final code if you wish, however it is
// appreciated by the author if at least my web site address is kept.
//
// You may *NOT* re-distribute this code in any way except through its
// use. That means, you can include it in your product, or your web
// site, or any other form where the code is actually being used. You
// may not put the plain javascript up on your site for download or
// include it in your javascript libraries for download.
// If you wish to share this code with others, please just point them
// to the URL instead.
// Please DO NOT link directly to my .js files from your site. Copy
// the files to your server and use them there. Thank you.
// ===================================================================
// HISTORY
// ------------------------------------------------------------------
// May 17, 2003: Fixed bug in parseDate() for dates <1970
// March 11, 2003: Added parseDate() function
// March 11, 2003: Added "NNN" formatting option. Doesn't match up
// perfectly with SimpleDateFormat formats, but
// backwards-compatability was required.
// ------------------------------------------------------------------
// These functions use the same 'format' strings as the
// java.text.SimpleDateFormat class, with minor exceptions.
// The format string consists of the following abbreviations:
//
// Field | Full Form | Short Form
// -------------+--------------------+-----------------------
// Year | yyyy (4 digits) | yy (2 digits), y (2 or 4 digits)
// Month | MMM (name or abbr.)| MM (2 digits), M (1 or 2 digits)
// | NNN (abbr.) |
// Day of Month | dd (2 digits) | d (1 or 2 digits)
// Day of Week | EE (name) | E (abbr)
// Hour (1-12) | hh (2 digits) | h (1 or 2 digits)
// Hour (0-23) | HH (2 digits) | H (1 or 2 digits)
// Hour (0-11) | KK (2 digits) | K (1 or 2 digits)
// Hour (1-24) | kk (2 digits) | k (1 or 2 digits)
// Minute | mm (2 digits) | m (1 or 2 digits)
// Second | ss (2 digits) | s (1 or 2 digits)
// AM/PM | a |
//
// NOTE THE DIFFERENCE BETWEEN MM and mm! Month=MM, not mm!
// Examples:
// "MMM d, y" matches: January 01, 2000
// Dec 1, 1900
// Nov 20, 00
// "M/d/yy" matches: 01/20/00
// 9/2/00
// "MMM dd, yyyy hh:mm:ssa" matches: "January 01, 2000 12:30:45AM"
// ------------------------------------------------------------------
var MONTH_NAMES=new Array('January','February','March','April','May','June','July','August','September','October','November','December','Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec');
var DAY_NAMES=new Array('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sun','Mon','Tue','Wed','Thu','Fri','Sat');
function LZ(x) {return(x<0||x>9?"":"0")+x}
// ------------------------------------------------------------------
// isDate ( date_string, format_string )
// Returns true if date string matches format of format string and
// is a valid date. Else returns false.
// It is recommended that you trim whitespace around the value before
// passing it to this function, as whitespace is NOT ignored!
// ------------------------------------------------------------------
function isDate(val,format) {
var date=getDateFromFormat(val,format);
if (date==0) { return false; }
return true;
}
// -------------------------------------------------------------------
// compareDates(date1,date1format,date2,date2format)
// Compare two date strings to see which is greater.
// Returns:
// 1 if date1 is greater than date2
// 0 if date2 is greater than date1 of if they are the same
// -1 if either of the dates is in an invalid format
// -------------------------------------------------------------------
//function compareDates(date1,dateformat1,date2,dateformat2) {
// var d1=getDateFromFormat(date1,dateformat1);
// var d2=getDateFromFormat(date2,dateformat2);
// if (d1==0 || d2==0) {
// return -1;
// }
// else if (d1 > d2) {
// return 1;
// }
// return 0;
// }
//
//function compareDatesLessEqual(date1,dateformat1,date2,dateformat2) {
// var d1=getDateFromFormat(date1,dateformat1);
// var d2=getDateFromFormat(date2,dateformat2);
// if (d1==0 || d2==0) {
// return -1;
// }
// else if (d1 <= d2) {
// return 1;
// }
// return 0;
// }
// ------------------------------------------------------------------
// formatDate (date_object, format)
// Returns a date in the output format specified.
// The format string uses the same abbreviations as in getDateFromFormat()
// ------------------------------------------------------------------
function formatDate(date,format) {
format=format+"";
var result="";
var i_format=0;
var c="";
var token="";
var y=date.getYear()+"";
var M=date.getMonth()+1;
var d=date.getDate();
var E=date.getDay();
var H=date.getHours();
var m=date.getMinutes();
var s=date.getSeconds();
var yyyy,yy,MMM,MM,dd,hh,h,mm,ss,ampm,HH,H,KK,K,kk,k;
// Convert real date parts into formatted versions
var value=new Object();
if (y.length < 4) {y=""+(y-0+1900);}
value["y"]=""+y;
value["yyyy"]=y;
value["yy"]=y.substring(2,4);
value["M"]=M;
value["MM"]=LZ(M);
value["MMM"]=MONTH_NAMES[M-1];
value["NNN"]=MONTH_NAMES[M+11];
value["d"]=d;
value["dd"]=LZ(d);
value["E"]=DAY_NAMES[E+7];
value["EE"]=DAY_NAMES[E];
value["H"]=H;
value["HH"]=LZ(H);
if (H==0){value["h"]=12;}
else if (H>12){value["h"]=H-12;}
else {value["h"]=H;}
value["hh"]=LZ(value["h"]);
if (H>11){value["K"]=H-12;} else {value["K"]=H;}
value["k"]=H+1;
value["KK"]=LZ(value["K"]);
value["kk"]=LZ(value["k"]);
if (H > 11) { value["a"]="PM"; }
else { value["a"]="AM"; }
value["m"]=m;
value["mm"]=LZ(m);
value["s"]=s;
value["ss"]=LZ(s);
while (i_format < format.length) {
c=format.charAt(i_format);
token="";
while ((format.charAt(i_format)==c) && (i_format < format.length)) {
token += format.charAt(i_format++);
}
if (value[token] != null) { result=result + value[token]; }
else { result=result + token; }
}
return result;
}
// ------------------------------------------------------------------
// Utility functions for parsing in getDateFromFormat()
// ------------------------------------------------------------------
function _isInteger(val) {
var digits="1234567890";
for (var i=0; i < val.length; i++) {
if (digits.indexOf(val.charAt(i))==-1) { return false; }
}
return true;
}
function _getInt(str,i,minlength,maxlength) {
for (var x=maxlength; x>=minlength; x--) {
var token=str.substring(i,i+x);
if (token.length < minlength) { return null; }
if (_isInteger(token)) { return token; }
}
return null;
}
// ------------------------------------------------------------------
// getDateFromFormat( date_string , format_string )
//
// This function takes a date string and a format string. It matches
// If the date string matches the format string, it returns the
// getTime() of the date. If it does not match, it returns 0.
// ------------------------------------------------------------------
function getDateFromFormat(val,format) {
val=val+"";
format=format+"";
var i_val=0;
var i_format=0;
var c="";
var token="";
var token2="";
var x,y;
var now=new Date();
var year=now.getYear();
var month=now.getMonth()+1;
var date=1;
var hh=now.getHours();
var mm=now.getMinutes();
var ss=now.getSeconds();
var ampm="";
while (i_format < format.length) {
// Get next token from format string
c=format.charAt(i_format);
token="";
while ((format.charAt(i_format)==c) && (i_format < format.length)) {
token += format.charAt(i_format++);
}
// Extract contents of value based on format token
if (token=="yyyy" || token=="yy" || token=="y") {
if (token=="yyyy") { x=4;y=4; }
if (token=="yy") { x=2;y=2; }
if (token=="y") { x=2;y=4; }
year=_getInt(val,i_val,x,y);
if (year==null) { return 0; }
i_val += year.length;
if (year.length==2) {
if (year > 70) { year=1900+(year-0); }
else { year=2000+(year-0); }
}
}
else if (token=="MMM"||token=="NNN"){
month=0;
for (var i=0; i11)) {
month=i+1;
if (month>12) { month -= 12; }
i_val += month_name.length;
break;
}
}
}
if ((month < 1)||(month>12)){return 0;}
}
else if (token=="EE"||token=="E"){
for (var i=0; i12)){return 0;}
i_val+=month.length;}
else if (token=="dd"||token=="d") {
date=_getInt(val,i_val,token.length,2);
if(date==null||(date<1)||(date>31)){return 0;}
i_val+=date.length;}
else if (token=="hh"||token=="h") {
hh=_getInt(val,i_val,token.length,2);
if(hh==null||(hh<1)||(hh>12)){return 0;}
i_val+=hh.length;}
else if (token=="HH"||token=="H") {
hh=_getInt(val,i_val,token.length,2);
if(hh==null||(hh<0)||(hh>23)){return 0;}
i_val+=hh.length;}
else if (token=="KK"||token=="K") {
hh=_getInt(val,i_val,token.length,2);
if(hh==null||(hh<0)||(hh>11)){return 0;}
i_val+=hh.length;}
else if (token=="kk"||token=="k") {
hh=_getInt(val,i_val,token.length,2);
if(hh==null||(hh<1)||(hh>24)){return 0;}
i_val+=hh.length;hh--;}
else if (token=="mm"||token=="m") {
mm=_getInt(val,i_val,token.length,2);
if(mm==null||(mm<0)||(mm>59)){return 0;}
i_val+=mm.length;}
else if (token=="ss"||token=="s") {
ss=_getInt(val,i_val,token.length,2);
if(ss==null||(ss<0)||(ss>59)){return 0;}
i_val+=ss.length;}
else if (token=="a") {
if (val.substring(i_val,i_val+2).toLowerCase()=="am") {ampm="AM";}
else if (val.substring(i_val,i_val+2).toLowerCase()=="pm") {ampm="PM";}
else {return 0;}
i_val+=2;}
else {
if (val.substring(i_val,i_val+token.length)!=token) {return 0;}
else {i_val+=token.length;}
}
}
// If there are any trailing characters left in the value, it doesn't match
if (i_val != val.length) { return 0; }
// Is date valid for month?
if (month==2) {
// Check for leap year
if ( ( (year%4==0)&&(year%100 != 0) ) || (year%400==0) ) { // leap year
if (date > 29){ return 0; }
}
else { if (date > 28) { return 0; } }
}
if ((month==4)||(month==6)||(month==9)||(month==11)) {
if (date > 30) { return 0; }
}
// Correct hours value
if (hh<12 && ampm=="PM") { hh=hh-0+12; }
else if (hh>11 && ampm=="AM") { hh-=12; }
var newdate=new Date(year,month-1,date,hh,mm,ss);
return newdate.getTime();
}
// ------------------------------------------------------------------
// parseDate( date_string [, prefer_euro_format] )
//
// This function takes a date string and tries to match it to a
// number of possible date formats to get the value. It will try to
// match against the following international formats, in this order:
// y-M-d MMM d, y MMM d,y y-MMM-d d-MMM-y MMM d
// M/d/y M-d-y M.d.y MMM-d M/d M-d
// d/M/y d-M-y d.M.y d-MMM d/M d-M
// A second argument may be passed to instruct the method to search
// for formats like d/M/y (european format) before M/d/y (American).
// Returns a Date object or null if no patterns match.
// ------------------------------------------------------------------
function parseDate(val) {
var preferEuro=(arguments.length==2)?arguments[1]:false;
generalFormats=new Array('y-M-d','MMM d, y','MMM d,y','y-MMM-d','d-MMM-y','MMM d');
monthFirst=new Array('M/d/y','M-d-y','M.d.y','MMM-d','M/d','M-d');
dateFirst =new Array('d/M/y','d-M-y','d.M.y','d-MMM','d/M','d-M');
var checkList=new Array('generalFormats',preferEuro?'dateFirst':'monthFirst',preferEuro?'monthFirst':'dateFirst');
var d=null;
for (var i=0; i objLesserDate) {
alert(txtTwo + " must be greater than " + txtOne);
oFldTwo.focus();
oFldTwo.select();
return false;
}
return true;
}
/*
Copyright 2005, 4word systems
All rights reserved.
This software may not be reproduced or distributed in any form without the express
written consent of 4word systems or it's designee.
Revision 1.1: 20050729 Added underscore to list of valid characters
*/
function isValidEmail(email, required) {
if (required==undefined) { // if not specified, assume it's required
required=true;
}
if (email==null) {
if (required) {
return false;
}
return true;
}
if (email.length==0) {
if (required) {
return false;
}
return true;
}
if (! allValidChars(email)) { // check to make sure all characters are valid
return false;
}
if (email.indexOf("@") < 1) { // must contain @, and it must not be the first character
return false;
} else if (email.lastIndexOf(".") <= email.indexOf("@")) { // last dot must be after the @
return false;
} else if (email.indexOf("@") == email.length) { // @ must not be the last character
return false;
} else if (email.indexOf("..") >=0) { // two periods in a row is not valid
return false;
} else if (email.indexOf(".") == email.length) { // . must not be the last character
return false;
}
return true;
}
function allValidChars(email) {
var parsed = true;
var validchars = "abcdefghijklmnopqrstuvwxyz0123456789@.-_";
for (var i=0; i < email.length; i++) {
var letter = email.charAt(i).toLowerCase();
if (validchars.indexOf(letter) != -1)
continue;
parsed = false;
break;
}
return parsed;
}
////////////////////////////////////////////////////////////////////////////////
// SIMPLIFIED VALIDATION FUNCTIONS [ by Will Gomes ]
////////////////////////////////////////////////////////////////////////////////
// Required Field Check: make sure that the field is not left blank
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function strCheck(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val == "") {
alert(txt + " must be entered.");
oFld.focus();
oFld.select();
return false;
}
return true;
}
// Number Check for either decimal or integer value (numType = decimal or integer)
// Parameters: oFld = form field object
// txt = text name (label) of the form field
// numType = type of number check, should be either "decimal" or "integer"
// nDecimals = number of decimal places (default = 2) (either 1, 2 or 3)
function numCheck(oFld, txt, numType, nDecimals)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (numType == "decimal") {
if (!isFloat(val)) {
alert(txt + " must be a numeric value.");
oFld.focus();
oFld.select();
return false;
}else{
if (nDecimals == undefined) {nDecimals = 2;}
formatDecimals(oFld, nDecimals);
}
}else if (numType == "integer") {
if (!isInteger(val)) {
alert(txt + " must be numeric and a whole number value.");
oFld.focus();
oFld.select();
return false;
}
}
}
return true;
}
function isUrl(s) {
var regexp = /^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$/
if (isEmpty(s))
if (isUrl.arguments.length == 1) return defaultEmptyOK;
else return (isUrl.arguments[1] == true);
else {
return regexp.test(s);
}
}
// Valid URL Check: check to see if entered value is a valid URL
function urlCheck(oFld, txt) {
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isUrl(val)) {
alert("Please enter a valid " + txt + ".");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
function isUrlShort(s) {
var regexp = /^([0-z\-]+\.)+?[a-z]{2,5}$/
//var regexp = /^(www.){1}([\w]+)(.[\w]+){1,2}$/;
if (isEmpty(s))
if (isUrlShort.arguments.length == 1) return defaultEmptyOK;
else return (isUrl.arguments[1] == true);
else {
return regexp.test(s);
}
}
function urlCheckShort(oFld, txt) {
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isUrlShort(val)) {
alert("Please enter a valid " + txt + " without the http or https protocal.");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
function isUrlExtended(s) {
var regexp = /(www[.])[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$/
//var regexp = /^(www.){1}([\w]+)(.[\w]+){1,2}$/;
if (isEmpty(s))
if (isUrlShort.arguments.length == 1) return defaultEmptyOK;
else return (isUrl.arguments[1] == true);
else {
return regexp.test(s);
}
}
// check URL [example: www.google.com/test.php?string=hello]
function urlCheckExtended(oFld, txt) {
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isUrlExtended(val)) {
alert("Please enter a valid " + txt + " without the http or https protocal.");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
// Valid Email Check: check to see if entered value is a valid email
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function emailCheck(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isValidEmail(val)) {
alert("Please enter a valid " + txt + ".");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
// List Check: check to see that an item has been selected in a list
// Parameters: oFld = form field object
// txt = text name (label) of the form field
// updated to use selectedIndex to deal with IE issues - ben - 02-12-2009
function listCheck(oFld, txt)
{
var val = oFld.selectedIndex;
if (val == 0) {
alert(txt + " must be selected.");
oFld.focus();
return false;
}
return true;
}
/*
function listCheck(oFld, txt)
{
var val = trim(oFld.value);
if (val == "") {
alert(txt + " must be selected.");
oFld.focus();
return false;
}
return true;
}
//*/
// Radio Check: validation to make sure that a radio button option was selected
// Parameters: oFld = form field object
// txt = text name (label) of the form field
// OPTIONAL PARAMTERS - ONLY USE WHEN DYNAMICALLY CREATING RADIO BUTTONS
// AND THERE IS A POSSIBILITY OF HAVING ONLY ONE RADIO BUTTON
// oFrm = form object
// sFld = actual name of field referenced
function radioCheck(oFld, txt, oFrm, sFld)
{
// when oFrm is passed in
if (oFrm != undefined) {
var nRadioCnt = 0;
for (i = 0; i < oFrm.elements.length; i++) {
var sName = oFrm.elements[i].name;
var sVal = oFrm.elements[i].value;
if (sName == sFld) {
nRadioCnt++;
}
}
var val = "";
// when ther is more than 1 radio button
if (nRadioCnt > 1) {
for (var i = 0; i < oFld.length; i++)
{
if (oFld[i].checked) {
val = oFld[i].value;
break;
}
}
// when ther is more only 1 radio button
}else{
if (oFld.checked) {
val = oFld.value;
}
}
if (val == "") {
alert(txt + " must be selected.");
if (nRadioCnt > 1) {
oFld[0].focus();
}else{
oFld.focus();
}
return false;
}else{
return true;
}
}else{
var val = "";
for (var i = 0; i < oFld.length; i++)
{
if (oFld[i].checked) {
val = oFld[i].value;
break;
}
}
if (val == "") {
alert(txt + " must be selected.");
oFld[0].focus();
return false;
}else{
return true;
}
}
}
// Date Check: must be a valid date with a 4 digit year value.
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function dateCheck(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isDate(val, "MM/dd/yy") && !isDate(val, "MM/dd/yyyy") && !isDate(val, "M/d/yy") && !isDate(val, "M/d/yyyy")) {
alert("Please enter a valid " + txt + ".");
oFld.focus();
oFld.select();
return false;
}else{
var arrDateParts = val.split("/");
var sYear = arrDateParts[2]
if (sYear.length != 4) {
alert("The " + txt + "'s year value must be 4 digits in length.");
oFld.focus();
oFld.select();
return false;
}else{
var oDate = new Date(val);
oFld.value = formatDate(oDate, "MM/dd/yyyy");
}
}
}
return true;
}
// Date Check: must be a valid date with a 4 digit year value.
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function dateCheckVal(oFld, txt)
{
var val = oFld;
if (val != "") {
if (!isDate(val, "MM/dd/yy") && !isDate(val, "MM/dd/yyyy") && !isDate(val, "M/d/yy") && !isDate(val, "M/d/yyyy")) {
alert("Please enter a valid " + txt + ".");
//oFld.focus();
//oFld.select();
return false;
}else{
var arrDateParts = val.split("/");
var sYear = arrDateParts[2]
if (sYear.length != 4) {
alert("The " + txt + "'s year value must be 4 digits in length.");
//oFld.focus();
//oFld.select();
return false;
}
}
}
return true;
}
// Date Month Check: must be a valid month/year
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function dateMonthCheck(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isDate(val, "MM/yy") && !isDate(val, "MM/yyyy") && !isDate(val, "M/yy") && !isDate(val, "M/yyyy")) {
alert("Please enter a valid " + txt + ".");
oFld.focus();
oFld.select();
return false;
}else{
var arrDateParts = val.split("/");
var sYear = arrDateParts[1]
if (sYear.length != 4) {
alert("The " + txt + "'s year value must be 4 digits in length.");
oFld.focus();
oFld.select();
return false;
}
}
}
return true;
}
// Year Check: must be numeric, a whole number value, and 4 digits in length
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function yearCheck(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isInteger(val) || !(val.length == 4)) {
alert(txt + " must be numeric, a whole number value, and 4 digits in length.");
oFld.focus();
oFld.select();
return false;
}
if (val < 1900) {
alert(txt + " must be at least 1900 or greater.");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
//Month Check: must be numeric, a whole number value, and 2 digits in length
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function monthCheck(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isInteger(val) || !(val.length == 2)) {
alert(txt + " must be numeric, a whole number value, and 2 digits in length.");
oFld.focus();
oFld.select();
return false;
}
if (val > 12 || val==0) {
alert(txt + " must be 1 through 12.");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
// State Check: must be a valid US State
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function stateCheck(oFld, txt)
{
//String of US State Codes (51 total includes DC)
var StateCodes = "AL|AK|AZ|AR|CA|CO|CT|DE|DC|FL|GA|HI|ID|IL|IN|IA|KS|KY|LA|ME|MD|MA|MI|MN|MS|MO|MT|NE|NV|NH|NJ|NM|NY|NC|ND|OH|OK|OR|PA|RI|SC|SD|TN|TX|UT|VT|VA|WA|WV|WI|WY"
var StateCodeDelimiter = "|";
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
val = val.toUpperCase();
oFld.value = val;
if (StateCodes.indexOf(val) == -1 || !(val.length == 2)) {
alert("Please enter a valid " + txt + ".");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
// Zip Check: must be numeric, a whole number value, and 5 digits in length
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function zipCheck(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isInteger(val) || !(val.length == 5)) {
alert(txt + " must be numeric, a whole number value, and 5 digits in length.");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
// Area Code Check: must be numeric, a whole number value, and 3 digits in length
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function areaCodeCheck(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
if (!isInteger(val) || !(val.length == 3)) {
alert(txt + " must be numeric, a whole number value, and 3 digits in length.");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
// Phone Check: must be numeric with exception of "-" and 7 digits in length (8 characters total if "-" included)
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function phoneCheck(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
var regExp = new RegExp("-", "g");
val = val.replace(regExp, "");
if (!isInteger(val) || !(val.length == 7)) {
alert(txt + " must be numeric with the exception of a \"-\" and have 7 numeric digits in total [###-####].");
oFld.focus();
oFld.select();
return false;
}else{
val = val.substring(0,3) + "-" + val.substring(3,7);
oFld.value = val;
}
}
return true;
}
// Phone Check Full: must be numeric with exception of "-" and 10 digits in length (12 characters total if "-"s included)
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function phoneCheckFull(oFld, txt)
{
fieldTrim(oFld);
var val = oFld.value;
if (val != "") {
var regExp = new RegExp("-", "g");
val = val.replace(regExp, "");
var regExp = new RegExp(" ", "g");
val = val.replace(regExp, "");
val = val.replace("(", "");
val = val.replace(")", "");
if (!isInteger(val) || !(val.length == 10)) {
alert(txt + " [###-###-####] must be numeric with the exception of a \"-\" and have 10 numeric digits in total.");
oFld.focus();
oFld.select();
return false;
}else{
val = val.substring(0,3) + "-" + val.substring(3,6)+ "-" + val.substring(6,10);
oFld.value = val;
}
}
return true;
}
// Field Trim: This function trims both left and right space padding from the field being referenced
// Parameters: oFld = form field object
function fieldTrim(oFld)
{
var val = trim(oFld.value);
oFld.value = val;
}
// Replace Commas: This function replaces commas with the value in the sReplace paramater
// Parameters: oFld = form field object
// sReplace = value to take the place of a comma
function replaceCommas(oFld, sReplace)
{
var val = trim(oFld.value);
var regExp = new RegExp(",", "g");
val = val.replace(regExp, sReplace);
oFld.value = val;
}
// Format Decimals: Formats a number to the specified number of decimal places
// Parameters: oFld = form field object
// nDecimals = number of decimal places (either 1 or 2)
function formatDecimals(oFld, nDecimals)
{
var val = trim(oFld.value);
//Rounding Funtionality
//var nDecCalc = Math.pow(10, nDecimals)
//val = Math.round(parseFloat(val) * nDecCalc) / nDecCalc
//val = val + ""
periodLocation = val.indexOf(".");
if (nDecimals == 3) {
if (periodLocation == -1) {
val = val + ".000"
}else if ((val.length - periodLocation) == 1) {
val = val + "000"
}else if ((val.length - periodLocation) == 2) {
val = val + "00"
}else if ((val.length - periodLocation) == 3) {
val = val + "0"
}else if (val.length - periodLocation > nDecimals) {
val = val.substring(0, periodLocation + nDecimals + 1);
}
}else if (nDecimals == 2) {
if (periodLocation == -1) {
val = val + ".00"
}else if ((val.length - periodLocation) == 1) {
val = val + "00"
}else if ((val.length - periodLocation) == 2) {
val = val + "0"
}else if (val.length - periodLocation > nDecimals) {
val = val.substring(0, periodLocation + nDecimals + 1);
}
}else if (nDecimals == 1) {
if (periodLocation == -1) {
val = val + ".0"
}else if ((val.length - periodLocation) == 1) {
val = val + "0"
}else if (val.length - periodLocation > nDecimals) {
val = val.substring(0, periodLocation + nDecimals + 1);
}
}
oFld.value = val;
}
// Checkbox Check: make sure that checkbox is not unchecked
// Parameters: oFld = form field object
// txt = text name (label) of the form field
function checkboxCheck(oFld, txt)
{
//check if checkbox is unchecked
if (!oFld.checked) {
alert(txt + " must be checked in order to proceed.");
oFld.focus();
return false;
}
return true;
}
///////////////////////////////////////////////////////////////
////////////// UPDATED CREDIT CARD FUNCTIONS //////////////////
///////////////////////////////////////////////////////////////
function visaCheck(oFld) {
fieldTrim(oFld);
var val = oFld.value;
if (val.length != 16) {
if (val.length != 13) {
alert("Please enter a valid VISA card number");
oFld.focus();
oFld.select();
return false;
}
}
var prefix = parseInt(val.substring(0,1));
if (prefix != 4) {
alert("Please enter a valid VISA card number");
oFld.focus();
oFld.select();
return false;
}
return true;
}
function mcCheck(oFld) {
fieldTrim(oFld);
var val = oFld.value;
if (val.length != 16) {
alert("Please enter a valid MasterCard number");
oFld.focus();
oFld.select();
return false;
}
var prefix = parseInt(val.substring(0,2));
if (prefix < 51) {
alert("Please enter a valid MasterCard number");
oFld.focus();
oFld.select();
return false;
}
if (prefix > 55) {
alert("Please enter a valid MasterCard number");
oFld.focus();
oFld.select();
return false;
}
return true;
}
function amexCheck(oFld) {
fieldTrim(oFld);
var val = oFld.value;
if (val.length != 15) {
alert("Please enter a valid AMEX card number");
oFld.focus();
oFld.select();
return false;
}
var prefix = parseInt(val.substring(0,2));
if (prefix != 34) {
if (prefix != 37) {
alert("Please enter a valid AMEX card number");
oFld.focus();
oFld.select();
return false;
}
}
return true;
}
function IsValidTime(timeStr) {
// Checks if time is in HH:MM:SS AM/PM format.
// The seconds and AM/PM are optional.
var timePat = /^(\d{1,2}):(\d{2})(:(\d{2}))?(\s?(AM|am|PM|pm))?$/;
var matchArray = timeStr.match(timePat);
if (matchArray == null) {
alert("Time is not in a valid format.");
return false;
}
hour = matchArray[1];
minute = matchArray[2];
second = matchArray[4];
ampm = matchArray[6];
if (second=="") { second = null; }
if (ampm=="") { ampm = null }
if (hour < 0 || hour > 23) {
alert("Hour must be between 1 and 12. (or 0 and 23 for military time)");
return false;
}
if (hour <= 12 && ampm == null) {
if (confirm("Please indicate which time format you are using. OK = Standard Time, CANCEL = Military Time")) {
alert("You must specify AM or PM.");
return false;
}
}
if (hour > 12 && ampm != null) {
alert("You can't specify AM or PM for military time.");
return false;
}
if (minute<0 || minute > 59) {
alert ("Minute must be between 0 and 59.");
return false;
}
if (second != null && (second < 0 || second > 59)) {
alert ("Second must be between 0 and 59.");
return false;
}
return false;
}