/**
 * Phone Parser
 *
 * For all forms, a regular expression check must be implemented for all phone numbers...
 *
 * - for the first 3 digits of the phone number, the same 3 numbers can't be repeated (555, for example)
 * - for the next three digits, this also applies.  
 * - check for 1234567890 and variations of that (0987654321)
 * - check for 123-123-xxxx
 */
var hPhone = {
	_value : null,
	_length: 0,
	code : null,
	prefix: null,
	phone : null,
	controls : null
};	
	
function initPhoneUS10(_value) {
	if ( _value.length == 10 ) {
		hPhone._length = 10;
		hPhone._value	= _value.substr(0, 10);
		hPhone.code		= _value.substr(0, 3);
		hPhone.prefix	= _value.substr(3, 3);
		hPhone.phone	= _value.substr(6, 4);

		setPhoneControlsUS10();
		return true;
	}
		
	return false;
}

function initPhoneUSAll(_value) {
	var re = new RegExp(/^([1-9]([0-9]{2}))[ -]?([0-9]{3})[ -]?([0-9]{4})$/);
		
	if ( _value.search(re) != -1 ) {
		var findArray = re.exec(_value);
			
		hPhone._length = 10;
		hPhone._value	= findArray[1] + findArray[3] + findArray[4];
		hPhone.code	= findArray[1];
		hPhone.prefix	= findArray[3];
		hPhone.phone	= findArray[4];
			
		setPhoneControlsUS10();
		return true;
	}
		
	return false;
}

function setPhoneControlsUS10() {
	hPhone.controls = {
		0 : {
			key : 'code',
			pattern : /^(\d)(\d)(\d)$/,
			_length : 3,
			checking : 'duplicate'
		},

		1 : {
			key : 'prefix',
			pattern : /^(\d)(\d)(\d)$/,
			_length : 3,
			checking : 'duplicate'
		},

		2 : {
			key : '_value',
			pattern : /^1234567890$/,
			_length : 10,
			checking : 'increment'
		},

		3 : {
			key : '_value',
			pattern : /^0987654321$/,
			_length : 10,
			checking : 'decrement'
		},

		4 : {
			key : '_value',
			pattern : /^(\d\d\d)(\d\d\d)/,
			_length : 2,
			checking : 'duplicate'
		},
		
		5 : {
			key : 'phone',
			pattern : /^(\d)(\d)(\d)(\d)$/,
			_length : 4,
			checking : 'duplicate'
		}
	}
}

function parserPhoneValidation() {
	var foundArray = new Array();
		
	for ( key in hPhone.controls ) {
		switch ( hPhone.controls[key]['checking'] ) {
			case 'duplicate' : 
				var re = new RegExp(hPhone.controls[key]['pattern']);
				var str = new String(), isDuplicate = true;
					
				foundArray = re.exec( hPhone[hPhone.controls[key]['key']] );
				for ( i = 1; i < hPhone.controls[key]['_length']; i++ ) {
					if ( foundArray[i] != foundArray[(i + 1)] ) {
						isDuplicate = false;
						break;
					}
				}
				if ( isDuplicate == true ) return false;
				break;
				
			case 'increment' :
			case 'decrement' : 
				var re = new RegExp(hPhone.controls[key]['pattern']);
				var _value = hPhone[hPhone.controls[key]['key']];
					
				if ( _value.search(re) != -1 ) {
					return false;
				}
				break;
		}
	}

	return true;
}
	
function parserPhone(type, value) {
	bRet = true;	

	switch ( type ) {
		case 'US10' :
			if ( initPhoneUS10(value) )
				bRet = parserPhoneValidation();
			break;

		case 'USA' :
			if ( initPhoneUSAll(value) ) {
				bRet = parserPhoneValidation();
			}
				break;
	}
	
	return bRet;
}

// end Phone Parser


// List of allowed symbols for different field types
var digits      = "0-9";
var letters_low = "a-z";
var letters_up  = "A-Z";
var letters = letters_low + letters_up;
var simbols = digits + letters;
// List of banned simbols for different field types
var all_banned  = "\\!\\?\\.\\,\\;\\:\\/\\'\\\"\\@\\#\\$\\&\\^\\%\\~\\|\\+\\=\\(\\)\\[\\]\\{\\}\\<\\>\\_\\*\\-";
var banned      = '\\!\\?\\,\\;\\:\\/\"\\@\\#\\$\\&\\^\\%\\~\\|\\+\\=\\{\\}\\<\\>\\_\\*\\[\\]';
var aError = new Array();
var maxTextAreaLength = 2000;

function checkMaxValue(oField,sName,maxValue)
{
  var s = oField.value;
  var l = s.length;
  var max_length = 150;
  var sError = maxValue+" - max value form '" + sName + "'";
  if(oField.value>maxValue)
  {
    error(oField, sError);
    return false;
  }
  return true;
}

function trim(st)
{
  var s = new String(st);
  while ((s.charAt(0)==' ')&&(s.length>1))
  {
    s=s.substring(1,s.length);
  }
  while ((s.charAt(s.length-1)==' ')&&(s.length>0))
  {
    s=s.substring(0,s.length-1);
  }
  return s;
}

// Check if value of target field is name (first name, last name, etc.)
//   max length is 150
function isName(oField, sName)
{
  var max_length = 150;

  return checkLength(max_length, oField, sName);
} 


// Check if value of target field is address
//   max length is 150
function isAddress(oField, sName)
{
  var max_length = 150;

  return checkLength(max_length, oField, sName);
} 


// 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 the "."
//   there must be at least two character after the "."
//   the characters @ and . are both required
function isEmail(oField, sName)
{
  var s = oField.value;
  var l = s.length;
  var max_length = 255;
  var sError = "Field '" + sName + "': invalid e-mail address.";

  if (isEmpty(s)) return true;
  if (!checkLength(max_length, oField, sName)) return false;

  var tmp="^([-\\.a-z0-9_])+@(([-a-z0-9_]|-)+\\.)+[a-z]{2,6}$";
//window.alert(tmp);
//window.alert(value);
//  var re = /^([0-9]*)$/;
  var re = new RegExp(tmp, 'i');
  var result = re.test(s) ? true : false;
  if (!result)
  {
    error(oField, sError);
  }
  return result;
}


// Value of target field should be an integer number
function isInteger(oField, sName)
{
  if (checkAllowed(oField.value, digits))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' should be an integer number.");
    return false;
  }
}

function isWidth(oField, sName)
{
  if (checkAllowed(oField.value, digits))
  {
    if((oField.value<=800)&&(oField.value>=0))
    return true;
  }
  error(oField, "Field '" + sName + "' should be positive integer less 800.");
  return false;
}

function isHeight(oField, sName)
{
  if (checkAllowed(oField.value, digits))
  {
    if((oField.value<=600)&&(oField.value>=0))
    return true;
  }
  error(oField, "Field '" + sName + "' should be positive integer less 600.");
  return false;
}



// Value of target field should be an integer number
function isIntegerPositive(oField, sName)
{
  if (checkAllowed(oField.value, digits) && oField.value > 0)
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' should be a positive integer number.");
    return false;
  }
}

// Value of target field should be a string of latin characters
function isString(oField, sName)
{
  if (checkAllowed(oField.value, letters))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' should contain letter symbols only.");
    return false;
  }
}


// Check if value of target field is city name
//   max length is 150
//   letters of any language are allowed (digits and special simbols are banned)
function isCity(oField, sName)
{
  var max_length = 150;

//  if (!checkLength(max_length, oField, sName)) return false;

  if (checkNotAllowed(oField.value, banned + digits))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' is incorrect city name.");
    return false;
  }
}


// Check if value of target field is "russian" city name (could contain digits)
//   max length is 150
//   letters of any language and digits are allowed (only special simbols are banned)
function isCityRU(oField, sName)
{
  var max_length = 150;

  if (!checkLength(max_length, oField, sName)) return false;

  if (checkNotAllowed(oField.value, banned))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' is incorrect city name.");
    return false;
  }
}


// Check if value of target field is zip code (in free format)
//   max length is 10
//   latin letters and digits are allowed
function isZip(oField, sName)
{
  if (oField.value=='')
  {
    return true;
  }
  
  var country = document.forms[0].elements['country'] || false;
  if (country)
  {
  	  if (country.value && country.value == 230)
  	  {
  	  	  isZipUS(oField, sName);
  	  	  return true;
  	  }
  	  if (country.value && country.value == 38)
  	  {
  	  	  isZipCanada(oField, sName);
  	  	  return true;
  	  }
  }
  else
  {
  	  if(!isNaN(oField.value))
  	  {
  	  	  isZipUS(oField, sName);
  	  }
  	  else
  	  {
  	  	  isZipCanada(oField, sName);
  	  }
  	  	  return true;
  }
  var max_length = 10;

  if (!checkLength(max_length, oField, sName)) return false;
  
  if (checkAllowed(oField.value, simbols))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' should contain letters and digits only.");
    return false;
  }
}


// Check if value of target field is USA zip code (in format XXXXX or XXXXX-XXXX, X - digit)
function isZipUS(oField, sName)
{
  var zipPattern1 = /^(\d{5})$/;
  var zipPattern2 = /^(\d{5})\-(\d{4})$/;
  var s = oField.value;

  if (isEmpty(s)) return true;

  if ((s.match(zipPattern1) == null) && (s.match(zipPattern2) == null))
  {
    error(oField, "'" + sName + "' should be valid US Zip.");
    return false;
  }

  return true;
}

// Check if value of target field is USA zip code (in format ANA or ANA-NAN, N - digit, A - letter)
function isZipCanada(oField, sName)
{
  var zipPattern1 = /^[A-Z][0-9][A-Z]$/i;
  var zipPattern2 = /^[A-Z][0-9][A-Z][ -]?[0-9][A-Z][0-9]$/i;
  var s = oField.value;

  if (isEmpty(s)) return true;

  if ((s.match(zipPattern1) == null) && (s.match(zipPattern2) == null))
  {
    error(oField, "'" + sName + "' should be valid Canadian Zip");
    return false;
  }

  return true;
}

// Check if value of target field is phone number (in free format)
//   max length is 7
//   max length is 50
//   latin letters and digits and "-.()+ " simbols are allowed
function isPhone(oField, sName)
{
  var country = document.forms[0].elements['country'] || false;
  if (country)
  {
  	  if (country.value && (country.value == 230 || country.value == 38))
  	  {
  	  	  isPhoneUS(oField, sName);
  	  	  return true;
  	  }
  }
  else
  {
  	  isPhoneUS(oField, sName);
  	  return true;
  }
  var min_length = 10;
  var max_length = 50;

  if (!checkLength(max_length, oField, sName)) return false;
  if (!checkMinLength(min_length, oField, sName)) return false;
  
//  if (checkAllowed(oField.value, simbols + "\\-\\.\\(\\)\\+\\ "))
  if (checkAllowed(oField.value, digits + "\\-\\.\\(\\)\\+\\ "))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' is incorrect phone number.");
    return false;
  }
}

function isSplitPhone(sNames, sName)
{
	oFields = sNames.split(',');
	value = '';
	for (var i=0; i < oFields.length; i++)
	{
		value += document.forms[0].elements[oFields[i]].value;
	}
	var rePhone = /^[1-9][0-9]{2}[1-9][0-9]{6}$/;
//	var rePhone = /^[0-9]{10}$/;

	if (!value.length || value.match(rePhone))
	{
		if ( value.length && !parserPhone('US10', value) ) {
			sName = ( sName.lastIndexOf(":") == (sName.length - 1) ) ? sName.substr(0, (sName.length - 1)) : sName;
			error(oField, sName + " : Please enter a valid phone number.");
			return false;
		}
		return true;
	}
	else
	{
	    error(oField, "Field '" + sName + "' should be valid US phone.");
		return false;
	}
}
// Check if value of target field is USA phone number (in format XXX-XXX-XXXX, X is digit)
function isPhoneUS(oField, sName)
{
  if (oField.value=='')
  {
    return true;
  }
  var phonePattern = /^[1-9]([0-9]{2})[ -]?([0-9]{3})[ -]?([0-9]{4})$/;

  if (isEmpty(oField.value)) return true;
  if (oField.value.match(phonePattern) == null)
  {
    error(oField, "Field '" + sName + "' should be valid US phone.");
    return false;
  }
  
  	if ( value.length && !parserPhone('USA', oField.value) ) {
  		sName = ( sName.lastIndexOf(":") == (sName.length - 1) ) ? sName.substr(0, (sName.length - 1)) : sName;
		error(oField, sName + " : Please enter a valid phone number.");
		return false;
	}

  return true;
}


// Check if value of target field is "russian" phone number (couldn't contain letters)
//   max length is 7
//   max length is 50
//   digits and "-.()+ " simbols are allowed
function isPhoneRU(oField, sName)
{
  if (oField.value=='')
  {
    return true;
  }
  var min_length = 7;
  var max_length = 50;

  if (!checkLength(max_length, oField, sName)) return false;
  if (!checkMinLength(min_length, oField, sName)) return false;
  
  if (checkAllowed(oField.value, digits + "\\-\\.\\(\\)\\+\\ "))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' is incorrect phone number.");
    return false;
  }
}


// Check if value of target field is password
//   max length is 6
//   max length is 12
function isPassword(oField, sName)
{
  var min_length = 6;
  var max_length = 12;

  var reg = /\s+/i;
//  alert(reg.toString());  
//  alert(reg.test(oField.value));
  
  if (reg.test(oField.value))
  {
  	error(oField, "Field '" + sName + "' has wrong symbols (allowed symbols are letters and digits).");
  	return false;
  }
  if (!checkLength(max_length, oField, sName)) return false;
  if (!checkMinLength(min_length, oField, sName)) return false;

  return true;
}


// Check if value of target field is credit card number
//   max length is 16
//   max length is 18
//   only digits are allowed
function isCreditCardNumber(oField, sName)
{
  var min_length = 16;
  var max_length = 18;

  if (!checkLength(max_length, oField, sName)) return false;
  if (!checkMinLength(min_length, oField, sName)) return false;
  
  if (checkAllowed(oField.value, digits))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' should contain digits only.");
    return false;
  }
}


// Check if value of target field is credit card cvv
//   max length is 3
//   max length is 4
//   only digits are allowed
function isCreditCardCVV(oField, sName)
{
  var min_length = 3;
  var max_length = 4;

  if (!checkLength(max_length, oField, sName)) return false;
  if (!checkMinLength(min_length, oField, sName)) return false;
  
  if (checkAllowed(oField.value, digits))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' should contain digits only.");
    return false;
  }
}


// Check if value of target field is flat number
//   max length is 5
//   letters and digits are allowed
function isFlat(oField, sName)
{
  var max_length = 5;

  if (isEmpty(oField.value)) return true;
  if (!checkLength(max_length, oField, sName)) return false;
  
  if (checkNotAllowed(oField.value, all_banned))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' should contain digits only.");
    return false;
  }
}


// Check if value of target field is building number
//   max length is 3
//   letters and digits are allowed
function isBuilding(oField, sName)
{
  var max_length = 3;
  var s = new String(oField.value);

  if (isEmpty(s)) return true;
  if (!checkLength(max_length, oField, sName)) return false;
  
  if (checkNotAllowed(s, all_banned))
  {
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' should contain letters and digits only.");
    return false;
  }
}


// Returns true if the string passed in is a valid money
//   only digits and "." are allowed
//   rounds to two digits after decimal dot
function isMoney(oField, sName)
{
  var max_length = 10;
  var s = oField.value;

  if (isEmpty(s)) return true;
  if (!checkLength(max_length, oField, sName)) return false;

  if (checkAllowed(s, digits + "\\."))
  {
    oField.value = Math.round(parseFloat(s)*100)/100;
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' is incorrect money amount.");
    return false;
  }
}


// Check if value of target field is float number
//   only digits and "." are allowed
//   no accuracy limitations
function isFloat(oField, sName)
{
  var s = oField.value;

  if (isEmpty(s)) return true;
  if (checkAllowed(s, digits + "\\."))
  {
    oField.value = parseFloat(s);
    return true;
  }
  else
  {
    error(oField, "Field '" + sName + "' is incorrect float number.");
    return false;
  }
}


// Check if value of target field is URL
//   function automatically cuts 'http://' & 'https://' value 
//   max length is 4
//   max length is 100
//   only digits and "." simbol are allowed
//   value should contain "." simbol, but not in first or last position
function isURL(oField, sName)
{
  var s = oField.value;
  if (isEmpty(s)) return true;

  var min_length = 4;
  var max_length = 255;
  var sError = "Field '" + sName + "' is incorrect URL.";
  
  s=s.replace(/^.*?:\/\//gi, '');
  
  oField.value = s;
  if (!checkLength(max_length, oField, sName)) return false;
  if (!checkMinLength(min_length, oField, sName)) return false;
  if (oField.value.indexOf('.',0) == -1)
  {
    error(oField, sError);
  	return false;
  }

//  if (checkAllowed(oField.value, simbols + "\\-\\.\\/\\&\\?\\_"))
  if (checkAllowed(oField.value, simbols + "\\-\\.\\/\\&\\?\\=\\[\\]\\{\\}\\_\\#"))  
  {
    var temp;
    var tmp="^[^\\.].*?[^\\.]$";
    var re = new RegExp(tmp);
    var result = re.test(s) ? true : false;
    if(!result)
    {
    	error(oField, sError);
    }
    return result;
  }
  else
  {
   	error(oField, sError);
	  return false;
  }
}

// Check if value of target field is URL
//   function automatically add 'http://' 
//   min length is 4
//   max length is 100
//   only digits and "." simbol are allowed
//   value should contain "." simbol, but not in first or last position
function isURLProtocol(oField, sName)
{
  var s = oField.value;
  if (isEmpty(s)) return true;
  
  var min_length = 4;
  var max_length = 255;
  var sError = "Field '" + sName + "' is incorrect URL.";

//  r = new RegExp('(?:(.*)(:\/\/))?(.*)', 'gi');
  r = new RegExp('^(?:(.*?)(:\/\/))?(.*)', 'gi');
  
  s_ar = r.exec(s);

  oField.value = s_ar[3];
  if (!checkLength(max_length, oField, sName)) return false;
  if (!checkMinLength(min_length, oField, sName)) return false;
  if (oField.value.indexOf('.',0)==-1)
  {
    error(oField, sError);
	  return false;
  }

//  if (checkAllowed(oField.value, simbols + "\\-\\.\\/\\&\\?\\_"))
  if (checkAllowed(oField.value, simbols + "\\-\\.\\/\\&\\?\\=\\[\\]\\_\\:"))
  {
    var temp;
    var tmp="^[^\\.].*?[^\\.]$";
    var re = new RegExp(tmp);
    var result = re.test(s) ? true : false;
    if(!result)
    {
	    error(oField, sError);
    }
    else
    {
    	if (s_ar[1] == 'http' || s_ar[1] == 'https')
    	{
	    	oField.value = s_ar[1] + '://' + s_ar[3];
    	}
    	else
    	{
    		oField.value = 'http://' + s_ar[3];
    	}
    }
    return result;
  }
  else
  {
   	error(oField, sError);
	  return false;
  }
}


// Check if value of target field is IP address
//   required format is N.N.N.N, N is number from 0 to 255
//   IP Addresses 0.0.0.0 and 255.255.255.255 are banned
function isIP(oField, sName) 
{
  var s = oField.value;
  var sError = "Field '" + sName + "' is incorrect IP address.";
  
  var ipPattern = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;

  if (isEmpty(s)) return true;

  if ((s == "0.0.0.0") || (s == "255.255.255.255"))
  {
    error(oField, sError);
    return false;
  }

  var ipArray = s.match(ipPattern);
  if (ipArray == null)
  {
    error(oField, sError);
    return false;
  }
  else
  {
    for (i = 1; i <= 4; i++)
    {
      if (ipArray[i] > 255)
      {
        error(oField, sError);
        return false;
      }
    }
  }

  return true;
}


// Check if value of target field is SSN - Social Security Number (in format XXX-XX-XXXX or XX-XXXXXXX, X is digit)
function isSSN(oField, sName)
{
  var ssnPattern1 = /^(\d{3})\-(\d{2})\-(\d{4})$/;
  var ssnPattern2 = /^(\d{2})\-(\d{7})$/;
  var s = oField.value;

  if (isEmpty(s)) return true;

  if ((s.match(ssnPattern1) == null) && (s.match(ssnPattern2) == null))
  {
    error(oField, "Field '" + sName + "' should be in format XXX-XX-XXXX or XX-XXXXXXX.");
    return false;
  }

  return true;
}


// Check if value of target field is house number
//   digits and letters are allowed
//   one letter (in any language) is optional and could be only on last position
function isHouse(oField, sName)
{
  var housePattern = /^(\d{1,4})(\S{0,1})$/;

  if (isEmpty(oField.value)) return true;

  if (!checkNotAllowed(oField.value, all_banned))
  {
    error(oField, "Field '" + sName + "' should contain digits and letters only.");
    return false;
  }
  else if ((oField.value.match(housePattern) == null))
  {
    error(oField, "Field '" + sName + "': incorrect value.");
    return false;
  }

  return true;
}

function checkDateFromTo(oField1, sName1,oField2, sName2)
{
  if((isDate(oField1, sName1))&&isDate((oField2, sName2)))
  {
    var s1 = new String(oField1.value);
    var s2 = new String(oField2.value);
    var sError = "'" + sName2 + "' date should be later than '" + sName1 + "' date.";
    var aDate1 = s1.split("/");
    var aDate2 = s2.split("/");
    dateName1=new Date(aDate1[2],aDate1[0]-1,aDate1[1]);
    dateName2=new Date(aDate2[2],aDate2[0]-1,aDate2[1]);
    if (dateName2>=dateName1)
    {
      return true;
    }
    error(oField1,sError);
    return false;
  }
  return true;
}

// Check if value of target field is a valid date (in USA format: MM/DD/YYYY)
function isDate(oField, sName)
{   
  var s = new String(oField.value);
  var len = s.length;
  var sError = "Field '" + sName + "' should be in MM/DD/YYYY format.";

  if (isEmpty(oField.value)) return true;
  var aDate = s.split("/");
  if (checkAllowed(s, digits + "\\/") && (aDate.length == 3))
  {
    dateName=new Date(aDate[2],aDate[0]-1,aDate[1]);
    cDay = dateName.getDate();
    cMonth = dateName.getMonth()+1;
    cYear = dateName.getYear();

//    if (cYear < 100)
//    {
//      cYear = '19' + cYear;
//    }
//    else
    if(cYear<1000)
    {
    	cYear=cYear+1900;
    }
    if((aDate[1] != cDay) || (aDate[0] != cMonth) || (aDate[2] != cYear))
    {
      error(oField, sError);
      return false;
    }
  }
  else
  {
    error(oField, sError);
    return false;
  }

  return true;
}


function isInPast(oField, sName)
{
  var sError = "Date in the '" + sName + "' field can't be future date.";
  var today = new Date();
  if (!isDate(oField, sName))
  {
    return false;
  }
  var s = new String(oField.value);
  var aDate = s.split("/");
  var setday = new Date(aDate[2],aDate[0]-1,aDate[1]);
  
//  alert(setday.getTime() + ' > ' + today.getTime() + '/n' + setday + ' > ' + today);
  
  if (setday.getTime() > today.getTime())
  {
    error(oField, sError);
    return false;
  }
  else
  {
    return true;
  }
}


// Check if value of target field is a valid date (in Europian format: DD.MM.YYYY)
function isDateRU(oField, sName)
{   
  var s = new String(oField.value);
  var len = s.length;
  var sError = "Field '" + sName + "' should be in DD.MM.YYYY format.";

  if (isEmpty(oField.value)) return true;

  var aDate = s.split(".");
  if (checkAllowed(s, digits + "\\.") && (aDate.length == 3))
  {
  dateName=new Date(aDate[2],aDate[1]-1,aDate[0]);
  if((aDate[0]!=dateName.getDate())||(aDate[1]!=dateName.getMonth()+1)||(aDate[2]!=dateName.getYear()))
    {
      error(oField, sError);
      return false;
    }
  }
  else
  {
    error(oField, sError);
    return false;
  }

  return true;
}


// Check if value of target field is a valid time (in Europian format: HH:MM, HH from 0 to 23 and MM from 0 to 59)
function isTime(oField, sName)
{   
  var s = new String(oField.value);
  var len = s.length;
  var sError = "Field '" + sName + "' should be in HH:MM format.";

  if (isEmpty(oField.value)) return true;

  var aTime = s.split(":");

  if (checkAllowed(s, digits + "\\:") && (aTime.length == 2))
  {
  dateName=new Date(0,0,0,aTime[0],aTime[1]);
  if((aTime[0]!=dateName.getHours())||(aTime[1]!=dateName.getMinutes()))
    {
      error(oField, sError);
      return false;
    }
  if(aTime[1].lenght==1)
    {
    aTime[1] = '0'+aTime[1];
    }
    s=aTime[0]+':'+aTime[1];
    oField.value=s;
  }
  else
  {
    error(oField, sError);
    return false;
  }

  return true;
}

function isDigits(oField, sName)
{
  if (isEmpty(oField.value)) return true;
  if(!isIntegerPositive(oField, sName))
  {
    return false;
  }
  return true;
}


/* ##Internal Functions## */

// Check if target value contains simbols only from list sValid
//   return false if value contains any additional simbols
function checkAllowed(value, sValid)
{
  if(value=='') return true;
  var temp;
  var s = value;
//  var re = '/^(['+sValid+']*)$/';
  var tmp="^(["+sValid+"]+)$";
//window.alert(tmp);
//window.alert(value);
//  var re = /^([0-9]*)$/;
  var re = new RegExp(tmp);
  var result = re.test(s) ? true : false;
  return result;

/*  for (var i = 0; i < value.length; i++)
  {
    temp = value.substring(i, i + 1);
    if (sValid.indexOf(value.substring(i, i + 1)) == "-1")
    {
      return false;
    }
  }

  return true;*/
}


// Check if target value doesn't contains simbols from sInvalid list
//   return false if value contains simbol from sInvalid list
function checkNotAllowed(value, sInvalid)
{
  if(value=='') return true;
  var temp;
  var s = value;
//  var re = '/^(['+sValid+']*)$/';
  var tmp="^([^"+sInvalid+"]*)$";
//window.alert(tmp);
//window.alert(value);
//  var re = /^([0-9]*)$/;
  var re = new RegExp(tmp);
  var result = re.test(s) ? true : false;
  return result;
/*  var temp;

  for (var i = 0; i < value.length; i++)
  {
    temp = value.substring(i, i + 1);
    if (sInvalid.indexOf(temp) > -1)
    {
      return false;
    }
  }

  return true;*/
}


// Check if target value length less then target maximum
//  if value length more then maximum - show error message and return false
function checkLength(maximum, oField, sName)
{
  if (isEmpty(oField.value)) return true;

  if (oField.value.length > maximum)
  {
    error(oField, "Field '" + sName + "' has " + oField.value.length + " symbols (maximum allowed length is " + maximum + ").");
    return false;
  }
  else
  {
    return true;
  }
}


// Check if target value length more then target minimum
//  if value length less then minimum - show error message and return false
function checkMinLength(minimum, oField, sName)
{
  if (isEmpty(oField.value)) return true;

  if (oField.value.length < minimum)
  {
    error(oField, "Field '" + sName + "' has " + oField.value.length + " symbols (minimum required length is " + minimum + ').\n');
    return false;
  }
  else
  {
    return true;
  }
}


// Show error message and return focus to target field
function error(oField, sError)
{
  aError.push(sError);
}


// Check whether string s is empty.
function isEmpty(s)
{
  return ((s == null) || (s.length == 0));
}


function checkMandatory(oField, sName)
{
  value = '';
  if (typeof(oField.value) != 'undefined')
  {
  	if (oField.type != 'checkbox' || oField.checked)
  	{
      value = trim(oField.value);
  	}
  }
  else if (typeof(oField.length) != 'undefined')
  {
  	for(var i=0; i < oField.length; i++)
  	{
 		if(oField[i].checked)
  		{
			value = trim(oField[i].value);
  		}
  	}

  }

  if (value.length || oField.disabled)
  {
    return true;
  }
  else
  {
  	if(oField.type == 'checkbox')
  	{
  		sError = "Checkbox '" + sName + "' is not checked.";
  	}
  	else
  	{
  		sError = "Mandatory field '" + sName + "' is empty.";
	}
    error(oField, sError);
    return false;
  }
}

function checkInterval(oPass1, oPass2)
{
  if (isEmpty(oPass2.value) || isEmpty(oPass2.value))
  {
    return true;
  }

  if (parseFloat(oPass1.value) > parseFloat(oPass2.value))
  {
    error(oPass2, "Incorrect Interval");
    return false;
  }

  return true;
}

function checkSubmit(sForm, aMandatory, aValid, aExt)
{
  aError = Array();
  sError = "Form corrupted";
  sForm = 'document.' + sForm + '.';
  var oFocusField;
// Check Mandatory Fields
  for (var i in aMandatory)
  {
    try
    {
        oField = eval(sForm + i);
        if (!checkMandatory(oField, aMandatory[i]))
        {
            if (!oFocusField)
            {
                oFocusField = oField[0] || oField;
            }
        }
    }
    catch(er)
    {
        alert(er);
        alert(sError);
        return false;
    }
  }
// Check Field Validation
  for (var i in aValid)
  {
    try
    {
      if (RegExp(',').test(i))
      {
      	eval(aValid[i][1] + '("' + i + '", "' + aValid[i][0] + '")');
      }
      else
      {
 	      var value = eval(sForm + i + '.value');
		  if ((!value || value.length) && !eval(aValid[i][1] + '(' + sForm + i + ', "' + aValid[i][0] + '")'))
	      {
	        oFocusField = eval(sForm + i);
	      }
      }
    }
    catch(er)
    {
        alert(er);
        alert(sError);
        return false;
    }
  }
  if (aError.length == 0)
  {
    // Additional Checks
    for (i = 0; i < aExt.length; i++)
    {
      try
      {
        !eval(aExt[i]);
      }
      catch(er)
      {
        alert(sError);
        return false;
      }
    }
  }
// Check Result
  if (aError.length)
  {
    var s = 'There are following problem(s) in form:\n\n';
    for (i = 0; i < aError.length; i++)
    {
      f = [/&lt;/g, /&gt;/g, /&#039;/g, /&quot;/g, /&amp;/g];
      r = ['<', '>', "'", '"', '&']
      for (var j=0; j < f.length; j++)
      {
      	 // alert(aError[i].replace(f[j], r[j]));
        aError[i] = aError[i].replace(f[j], r[j]);
      }
      s += aError[i] + '\n';
    }

    alert(s);
    try
    {
      if (oFocusField.type != 'hidden')
      {
//      For Mozilla
        window.field = oFocusField;
        if(window.field.focus) 
        {
	        setTimeout('window.field.focus();', 1);
        }
      }
    }
    catch(er)
    {
      return false;
    }
    return false;
  }
  else
  {
    return true;
  }
}

function checkInterval(oField1, oField2, sName)
{
  if (isEmpty(oField1.value) || isEmpty(oField2.value))
  {
    return true;
  }

  if (parseFloat(oField1.value) > parseFloat(oField2.value))
  {
    error(oField1, "Fields '" + sName + "': incorrect range.");
    return false;
  }

  return true;
}

function isSame(src1,src2,str)
{
    if (src1.value!=src2.value)
    {
        alert(str);
        src1.focus();
        return false;
    }
    else
    {
        return true;
    }
}

// Check equality value of target fields

function checkEquality(oField1,sName1, oField2,sName2)
{
  if(oField1.value!=oField2.value)
  {
      error(oField1,"Fields '" + sName1 + "' and '" + sName2 + "' are different.");
      return false;
  }
  else
  {
    return true;
  }
}

function checkMaxInput(form) 
{
  if (form.value.length > (maxTextAreaLength-1)) 
  {
    alert('Maximum data length of "Comments" field is 2000 symbols.');
    form.value = form.value.substring(0, maxTextAreaLength-1);
  }
}