// FormChek.js
// 18 Feb 97 created Eric Krock
// (c) 1997 Netscape Communications Corporation

var whitespace = "\r\n 	";

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 sEmail = "Email"

// i is an abbreviation for "invalid"

var iEmail = "This field must be a valid email address (like me@here.com). Please reenter it now."


// p is an abbreviation for "prompt"

var pEmail = "valid email address (like foo@bar.com)."

var defaultEmptyOK = false

// 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;
}

// 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
}

// 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);

    // is s whitespace?
    if (isWhitespace(s)) return false;

    // there must be >= 1 character before @, so we
    // start looking at character position 1
    // (i.e. second character)
    var i = 1;
    var sLength = s.length;

    // look for @
    while ((i < sLength) && (s.charAt(i) != "@"))
    { i++
    }

    if ((i >= sLength) || (s.charAt(i) != "@")) return false;
    else i += 2;

    // look for .
    while ((i < sLength) && (s.charAt(i) != "."))
    { i++
    }

    // there must be at least one character after the .
    if ((i >= sLength - 1) || (s.charAt(i) != ".")) return false;
    else return true;
}



// 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)


{   var i;

    // Is s empty?
    if (isEmpty(s)) return true;

    // Search through string's characters one by one
    // until we find a non-whitespace character.
    // When we do, return false; if we don't, return true.

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


        // Check that current character isn't whitespace.
        var c = s.charAt(i);

        if (whitespace.indexOf(c) == -1) return false;
    }

    // All characters are whitespace.
    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 (!isValidEmail(theField.value))
       return warnInvalid (theField, iEmail);
    else return true;
}

// 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
}


// isValidEmail (STRING s [, BOOLEAN emptyOK])
//
// Evaluates an email address according to the regular
// expression below. Generally email addresses must be in
// the form name@domain.com.  This differs from the isEmail()
// function in that it allows for a more general format in the
// name and domain fields as well as checking for illegal chars
// like spaces and commas.
//
// Note: The regular expression used here should be compatible
//       with the expression used in the IsValidEmail() function
//		 in the MNSSecurity DLL as well as the ValidEmailAddress()
//		 function in the functions folder.
//
// Modified
// 11/07/02 TJackson  Added the "_" char explicitly because IE5.0
// does not include it in the \w list.
//
// 04/25/03 TJackson Added the "+" char as legal.
//
function isValidEmail (s)
{
	var filter  = /^(([\w_\&\'\-\+]+)\.([\w_\&\'\-\+]*))*([\w_\&\'\-\+]+)\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,})$/;

	s = s.replace(/^ +/,"");	//trim spaces from beginning
	s = s.replace(/ +$/,"");	//trim spaces from end
	
	return (filter.test(s));
}


// checkEmailMulti (TEXTFIELD theField , STRING theSeparator, [, BOOLEAN emptyOK==false])
//
// Check that string theField.value is a valid Email.
// The string can contain multiple emails separated by theSeparator variable
// For explanation of optional argument emptyOK,
// see comments of function isInteger.

function checkEmailMulti (theField, theSeparator, emptyOK)
{   
    var ii;  
    var strEmail;	  

    if (checkEmailMulti.arguments.length == 2) emptyOK = defaultEmptyOK;
	
    if ((emptyOK == true) && (isEmpty(theField.value))){
		return true;
	}else if((emptyOK == false) && (isEmpty(theField.value))){
		return warnInvalid (theField, iEmail);
	}else{ 
		strEmail = theField.value;
		var strEmailArr = strEmail.split(theSeparator);
		for (var ii = 0; ii < strEmailArr.length; ii++ ){
			if (!isValidEmail(strEmailArr[ii]) && !isEmpty(strEmailArr[ii]))
			       return warnInvalid (theField, iEmail);
		}
	}

    return true;
}