// validations.js


//valida que la cantidad de caracteres del texto ingresado, 
//no supere un limite determinado
function validateManuallyMaxLength(form,formName) {
	var isValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var arrName = eval('maxlength'+formName);
	oMaxLength = new arrName();
	for (x in oMaxLength) {
		var field = form[oMaxLength[x][0]];
		if (field != null && (field.type == 'text'|| field.type == 'textarea')) {
			var iMax = parseInt(oMaxLength[x][2] ("maxlength"));
			if (field.value.length > iMax) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oMaxLength[x][1];
				isValid = false;
			}
		}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return isValid;
}



//valida q la fecha ingresada sea válida (esta version NO tiene en cuenta la hora)
function validateManuallyDate(form,formName) {
	var bValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var arrName = eval('DateValidations'+formName);
	oDate = new arrName();
	for (x in oDate) {
		var value = form[oDate[x][0]].value;
		var datePattern = oDate[x][2] ("datePatternStrict");
		if ((form[oDate[x][0]].type == 'text'|| form[oDate[x][0]].type == 'textarea' || 
		form[oDate[x][0]].type == 'hidden') && (value.length > 0) && (datePattern.length > 0)) {
			var MONTH = "MM";
			var DAY = "dd";
			var YEAR = "yyyy";
			var orderMonth = datePattern.indexOf(MONTH);
			var orderDay = datePattern.indexOf(DAY);
			var orderYear = datePattern.indexOf(YEAR);

			if ((orderDay < orderYear && orderDay > orderMonth)) {
				var iDelim1 = orderMonth + MONTH.length;
				var iDelim2 = orderDay + DAY.length;
				var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
				var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
				if (iDelim1 == orderDay && iDelim2 == orderYear) {
					dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
				}
				else if (iDelim1 == orderDay) {
					dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
				}
				else if (iDelim2 == orderYear) {
					dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
				}
				else {
					dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
				}
				var matched = dateRegexp.exec(value);
				if (matched != null) {
					if (!isValidDate(matched[2], matched[1], matched[3])) {
						if (i == 0) {
							focusField = form[oDate[x][0]];
						}
						fields[i++] = oDate[x][1];
						bValid = false;
					}
				}
				else {
					if (i == 0) {
						focusField = form[oDate[x][0]];
					}
					fields[i++] = oDate[x][1];
					bValid = false;
				}
			}
			else if ((orderMonth < orderYear && orderMonth > orderDay)) {
				var iDelim1 = orderDay + DAY.length;
				var iDelim2 = orderMonth + MONTH.length;
				var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
				var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
				if (iDelim1 == orderMonth && iDelim2 == orderYear) {
					dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
				}
				else if (iDelim1 == orderMonth) {
					dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
				}
				else if (iDelim2 == orderYear) {
					dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
				}
				else {
					dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
				}
				var matched = dateRegexp.exec(value);
				if (matched != null) {
					if (!isValidDate(matched[1], matched[2], matched[3])) {
						if (i == 0) {
							focusField = form[oDate[x][0]];
						}
						fields[i++] = oDate[x][1];
						bValid = false;
					}
				}
				else {
					if (i == 0) {
						focusField = form[oDate[x][0]];
					}
					fields[i++] = oDate[x][1];
					bValid = false;
				}
			}
			else if ((orderMonth > orderYear && orderMonth < orderDay)) {
				var iDelim1 = orderYear + YEAR.length;
				var iDelim2 = orderMonth + MONTH.length;
				var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
				var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
				if (iDelim1 == orderMonth && iDelim2 == orderDay) {
					dateRegexp = new RegExp("^(\\d{4})(\\d{2})(\\d{2})$");
				}
				else if (iDelim1 == orderMonth) {
					dateRegexp = new RegExp("^(\\d{4})(\\d{2})[" + delim2 + "](\\d{2})$");
				}
				else if (iDelim2 == orderDay) {
					dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})(\\d{2})$");
				}
				else {
					dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{2})$");
				}
				var matched = dateRegexp.exec(value);
				if (matched != null) {
					if (!isValidDate(matched[3], matched[2], matched[1])) {
						if (i == 0) {
							focusField = form[oDate[x][0]];
						}
						fields[i++] = oDate[x][1];
						bValid = false;
					}
				}
				else {
					if (i == 0) {
						focusField = form[oDate[x][0]];
					}
					fields[i++] = oDate[x][1];
					bValid = false;
				}
			}
			else {
				if (i == 0) {
					focusField = form[oDate[x][0]];
				}
				fields[i++] = oDate[x][1];
				bValid = false;
			}
		}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return bValid;
}

function isValidDate(day, month, year) {
	if (month < 1 || month > 12) {
		return false;
	}
	if (day < 1 || day > 31) {
		return false;
	}
	if ((month == 4 || month == 6 || month == 9 || month == 11) && (day == 31)) {
		return false;
	}
	if (month == 2) {
		var leap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
		if (day > 29 || (day == 29 && !leap)) {
			return false;
		}
	}
	if(year == 0){
		return false;
	}
	return true;
}



//Valida q el valor ingresado para la cantidad en el par: cod.producto-cantidad, sea un entero
//se usa en la carga rápida
function validateIntegerIndexed(form,formName) {
	var bValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var arrName = eval('IntegerValidations'+formName);
	oInteger = new arrName();
	for (x in oInteger) {
		field = form[oInteger[x][0]]; //federicof
		for(j=0;j<field.length;j++){
			oField = field[j];
			if ((oField.type == 'text'|| oField.type == 'textarea'|| oField.type == 'select-one'|| oField.type == 'radio') && (oField.value.length > 0)) {
				var before = (oField.value).length;
				var iValue = parseInt(oField.value);
				var after = (iValue.toString()).length;
				if (isNaN(iValue) || !(iValue >= -2147483648 && iValue <= 2147483647) || before != after) {
					if (i == 0) {
						focusField = oField;
					}
					fields[i++] = oInteger[x][1];
					bValid = false;
				}
			}
		}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return bValid;
}



//valida q el dato ingresado sea numero y entero
function validateManuallyInteger(form,formName) {
    var bValid = true;
    var focusField = null;
    var i = 0;
    var fields = new Array();
    var arrName = eval('IntegerValidations'+formName);
	oInteger = new arrName();
    for (x in oInteger) {
        if ((form[oInteger[x][0]].type == 'text' ||
             form[oInteger[x][0]].type == 'textarea' ||
             form[oInteger[x][0]].type == 'select-one' ||
             form[oInteger[x][0]].type == 'radio') &&
            (form[oInteger[x][0]].value.length > 0)) {
            var before = (form[oInteger[x][0]].value).length;
            var iValue = parseInt(form[oInteger[x][0]].value);
            var after = (iValue.toString()).length;

            if (isNaN(iValue) || !(iValue >= -2147483648 && iValue <= 2147483647) || before != after) {
                if (i == 0) {
                    focusField = form[oInteger[x][0]];
                }
                fields[i++] = oInteger[x][1];
                bValid = false;
           }
        }
    }
    if (fields.length > 0) {
		try{
       		focusField.focus();
       	}catch(e){}
       alert(fields.join('\n'));
    }
    return bValid;
}



//valida q la fecha ingresada, sea mayor o igual a otra fecha con la q se la compara.
//Esta función se usa para saber si la fecha hasta es mayor o igual q la fecha desde, y para eso en 
//el parametro, secondProperty se le pasa la fecha desde.
function validateManuallyTwoDates(form,formName) {
	var bValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var arrName = eval('twoDates'+formName);
	oTwoDates = new arrName();
	for (x in oTwoDates) {
		var field = form[oTwoDates[x][0]];
		var secondField = form[oTwoDates[x][2] ("secondProperty")];
		
			var value;
			var secondValue;
			var datePattern = oDate[x][2] ("datePatternStrict");
        if(secondField.value != "" && field.value != ""){
			var resultCompareDates = compareDates(secondField.value, datePattern, field.value, datePattern);
			if (resultCompareDates != 0) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oTwoDates[x][1];
				bValid = false;
			}
		}
	}
	if (fields.length > 0) {
		//focusField.focus();
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return bValid;
}



//valida q se haya cargado algun tipo de informacion en aquellos campos definidos
//como requeridos u obligatorios 
function validateManuallyRequired(form,formName) {
	var isValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var arrName = eval('required'+formName);
	oRequired = new arrName();
	for (x in oRequired) {
		var field = form[oRequired[x][0]];
		//if (field.type == 'text'|| field.type == 'textarea'|| field.type == 'file'|| field.type == 'select-one'|| field.type == 'radio'|| field.type == 'password') {
			var value = '';
			// get field's value
			if (field.type == "select-one") {
				var si = field.selectedIndex;
				if (si >= 0) {
					value = field.options[si].value;
				}
			}
			else {
				value = field.value;
			}
			if (trim(value).length == 0) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oRequired[x][1];
				isValid = false;
			}
		//}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return isValid;
}

//valida q lo q se haya ingresado sea una direccion de e-mail válida. Verifica q exista un @
//en algun lado y q ademas despues de esa @ haya algo.algo
function validateManuallyEmail(form,formName) {
	var bValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var arrName = eval('email'+formName);
	oEmail = new arrName();
	for (x in oEmail) {
		if ((form[oEmail[x][0]].type == 'text'|| form[oEmail[x][0]].type == 'textarea') && (form[oEmail[x][0]].value.length > 0)) {
			if (!checkEmail(form[oEmail[x][0]].value)) {
				if (i == 0) {
					focusField = form[oEmail[x][0]];
				}
				fields[i++] = oEmail[x][1];
				bValid = false;
			}
		}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return bValid;
}

  function checkEmail(emailStr) {
  	if (emailStr.length == 0) {
    	return true;
    }
    var emailPat=/^(.+)@(.+)$/;
    var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";
    var validChars="\[^\\s" + specialChars + "\]";
    var quotedUser="(\"[^\"]*\")";
    var ipDomainPat=/^(\d{1,3})[.](\d{1,3})[.](\d{1,3})[.](\d{1,3})$/;
    var atom=validChars + '+';
    var word="(" + atom + "|" + quotedUser + ")";
    var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
    var domainPat=new RegExp("^" + atom + "(\\." + atom + ")*$");
    var matchArray=emailStr.match(emailPat);
    if (matchArray == null) {
    	return false;
    }
    var user=matchArray[1];
    var domain=matchArray[2];
    if (user.match(userPat) == null) {
    	return false;
    }
    var IPArray = domain.match(ipDomainPat);
    if (IPArray != null) {
    	for (var i = 1; i <= 4; i++) {
        	if (IPArray[i] > 255) {
            	return false;
            }
        }
    	return true;
  	}
    var domainArray=domain.match(domainPat);
    if (domainArray == null) {
    	return false;
    }
    var atomPat=new RegExp(atom,"g");
    var domArr=domain.match(atomPat);
    var len=domArr.length;
    if ((domArr[domArr.length-1].length < 2) ||
    (domArr[domArr.length-1].length > 3)) {
    	return false;
    }
    if (len < 2) {
    	return false;
    }
    return true;
  }
            


//Valida q el valor ingresado para la cantidad en el par: cod.producto-cantidad, este dentro de un rango
//de numeros enteros predefinido. Se usa en la carga rápida
function validateIntRangeIndexed(form,formName) {
	var isValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var arrName = eval('intRange'+formName);
	oRange = new arrName();
	for (x in oRange) {
		field = form[oRange[x][0]];
		for(j=0;j<field.length;j++){
			oField = field[j];		
			if ((oField.type == 'text'|| oField.type == 'textarea') && (oField.value.length > 0)) {
				var iMin = parseInt(oRange[x][2] ("min"));
				var iMax = parseInt(oRange[x][2] ("max"));
				var iValue = parseInt(oField.value);
				
				if (!(iValue >= iMin && iValue <= iMax)) {
					if (i == 0) {
						focusField = oField;
					}
					fields[i++] = oRange[x][1];
					isValid = false;
				}
				
			}
		}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return isValid;
}



//Valida q lo q se haya ingresado en el campo, corresponda con la mascara especificada.
//Las mascaras q usamos son, en realidad, definiciones de expresiones regulares que se 
//pasan a esta funcion mediante el parametro mask
function validateManuallyMask(form,formName) {
	var isValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var arrName = eval('mask'+formName);
	oMasked = new arrName();
	for (x in oMasked) {
		var field = form[oMasked[x][0]];
		if ((field.type == 'text'|| field.type == 'textarea') && (field.value.length > 0)) {
			if (!matchPattern(field.value, oMasked[x][2]("mask"))) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oMasked[x][1];
				isValid = false;
			}
		}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return isValid;
}

function matchPattern(value, mask) {
   mask = new RegExp(mask);
   return mask.test(value);
}



//Esta funcion se usa en todos los lugares desde los q se puede comprar un producto.
//Lo q hace es validar q la cantidad a comprar ingresada para un producto particular, corresponda
//con lo q tiene definido ese producto, para la cantidad de digitos de la parte entera 
//y la cantidad de digitos de la parte decimal. Funciona tanto para un arreglo de cantidades 
//como para una sola.
function validateDecimals (form,maskAsString) { 
		var field = form.quantities;	
		var decimalsNumber = form.decimals;	
		var ids = form.items;
		var maxIntegerDigits = form.maxIntegerDigits;
		isValid = true;
		var isInteger = true;

		if(field != null && field.length != undefined && maxIntegerDigits != undefined && decimalsNumber != undefined){//es un arreglo de valores
			//dv. se agrega para alertar en el caso del arreglo de valores vacio.
			isEmpty = true;
			for(j=0;j<field.length;j++){
				if(field[j].value!='' && maxIntegerDigits[j].value != null && decimalsNumber[j].value != null &&
				maxIntegerDigits[j].value > 0){//tengo q validar
					isEmpty = false;
					var replacePosition = maskAsString.lastIndexOf("3");
					//cambio el maximo de digitos permitidos para la parte entera del nro, segun lo q viene del TO
					var mask = maskAsString.substring(0,replacePosition) + maxIntegerDigits[j].value + maskAsString.substring(replacePosition+1,maskAsString.length);
					
					//veo si el arreglo de ids es igual al de cantidades
					var idValue = "";
					if(field.length == ids.length){
						idValue = ids[j].value;
					}
					else{
						idValue = ids.value;
					}
					var message = msgBuyAmmount.replace(/\{0\}/,idValue);
					
					if (decimalsNumber[j].value != null && decimalsNumber[j].value == 0){
						//el campo tiene q validarse como entero
						mask = mask.substring(0,replacePosition+3)+')?$';
					}
					else if(decimalsNumber[j].value != null && decimalsNumber[j].value > 0){
						//el campo acepta decimales
						isInteger = false;
						replacePosition = mask.lastIndexOf("d");
						if(decimalsNumber[j].value == 1){
							mask = mask.substring(0,replacePosition+1) + '{'+ decimalsNumber[j].value + '}' + mask.substring(replacePosition+2,mask.length);
						}
						else {
							mask = mask.substring(0,replacePosition+1) + '{1,'+ decimalsNumber[j].value + '}' + mask.substring(replacePosition+2,mask.length);
						}
					}
					mask = new RegExp(mask);
					if(!mask.test(field[j].value)){
						isValid = false;
						var completeMsg;
						if(isInteger){
							completeMsg = errorsOrderInteger.replace(/\{0\}/,message);
							alert(completeMsg.replace(/\{1\}/,maxIntegerDigits[j].value));
						}
						else {
							completeMsg = errorsOrderDecimal.replace(/\{0\}/,message);
							completeMsg = completeMsg.replace(/\{1\}/,decimalsNumber[j].value);
							alert(completeMsg.replace(/\{2\}/,maxIntegerDigits[j].value));
						}
						break;
					}
				}
			}		
			if (isEmpty){
				alert(msgNoAmmount);
				isValid = false;
			}
		}
		else if(field != null && maxIntegerDigits != undefined && decimalsNumber != undefined){//es un solo campo
			if(field.value!='' && maxIntegerDigits.value != null && decimalsNumber.value != null &&
				maxIntegerDigits.value > 0){//tengo q validar
				var replacePosition = maskAsString.lastIndexOf("3");
				//cambio el maximo de digitos permitidos para la parte entera del nro, segun lo q viene del TO
				var mask = maskAsString.substring(0,replacePosition) + maxIntegerDigits.value + maskAsString.substring(replacePosition+1,maskAsString.length);
				var message = msgBuyAmmount.replace(/\{0\}/,ids.value);
					
				if (decimalsNumber.value != null && decimalsNumber.value == 0){
					//el campo tiene q validarse como entero
					mask = mask.substring(0,replacePosition+3)+')?$';
				}
				else if(decimalsNumber.value != null && decimalsNumber.value > 0){
					//el campo acepta decimales
					isInteger = false;
					replacePosition = mask.lastIndexOf("d");
					if(decimalsNumber.value == 1){
						mask = mask.substring(0,replacePosition+1) + '{'+ decimalsNumber.value + '}' + mask.substring(replacePosition+2,mask.length);
					}
					else {
						mask = mask.substring(0,replacePosition+1) + '{1,'+ decimalsNumber.value + '}' + mask.substring(replacePosition+2,mask.length);
					}
				}
				mask = new RegExp(mask);
				if(!mask.test(field.value)){
					isValid = false;
					var completeMsg;
					if(isInteger){
						completeMsg = errorsOrderInteger.replace(/\{0\}/,message);
						alert(completeMsg.replace(/\{1\}/,maxIntegerDigits.value));
					}
					else {
						completeMsg = errorsOrderDecimal.replace(/\{0\}/,message);
						completeMsg = completeMsg.replace(/\{1\}/,decimalsNumber.value);
						alert(completeMsg.replace(/\{2\}/,maxIntegerDigits.value));
					}
				}
			}
		}
		//dv. se agrega para alertar en el caso de uno o varios campos no rendereando el input text Cantidad (ej. prod.obsoletos)
		else if(field == undefined && maxIntegerDigits == undefined && decimalsNumber == undefined){
			isValid = false;
		}
		return isValid;	
	}

//Esta función realiza la misma validación que la anterior, pero permite indicar el campo que se desea validar.
//Es un reflejo fiel de la máscara que se le pasa como parámetro, es decir, que tiene en cuenta la cantidad de
//posiciones enteras y decimales definidas en la máscara.
//Parámetros:
//fieldToValidate campo del formulario que se desea validar (puede ser un array)
//fieldIds campos con los identificadores de de cada item a validar (p. ej. un nro. de producto o un nro. de factura)
//Puede ser un string en el caso de tratarse de un único campo a validar.
//mask Máscara que se utilizará para validar.
//integerPositions cantidad de posiciones para la parte entera. Si se desea usar el valor de la máscara, pasar null.
//decimalPositions cantidad de posiciones para la parte decimal. Si se desea usar el valor de la máscara, pasar null.
//itemMessage Mensaje de error a mostrar por cada item en el caso que falle la validación.
function validateDecimalsExtended(fieldToValidate, fieldIds, mask, integerPositions, decimalPositions, itemMessage) {	
	var field = fieldToValidate;
	var ids = fieldIds;
	isValid = true;
	var isInteger = true;

	var integerPositionsIndex = mask.lastIndexOf("d{1,") + 4;
	if (integerPositions != null) {
		mask = mask.substring(0, integerPositionsIndex) + integerPositions + mask.substring(mask.indexOf("}", integerPositionsIndex), mask.length);
	} else {
		integerPositions = mask.substring(integerPositionsIndex, mask.indexOf("}", integerPositionsIndex));
	}
	if (decimalPositions == null) {
		decimalPositions = mask.substring(mask.lastIndexOf("d{") + 2, mask.lastIndexOf("}"));
		if (decimalPositions.indexOf(",") > -1) {
			decimalPositions = decimalPositions.substring(decimalPositions.indexOf(",") + 1);
		}
	}
	
	if ((decimalPositions == null) || (decimalPositions != null && decimalPositions == 0)){
		//el campo tiene q validarse como entero
		mask = mask.substring(0, integerPositionsIndex + 2 + ("" + integerPositions).length) + ')?$';
	} else if (decimalPositions != null && decimalPositions > 0) {
		//el campo acepta decimales
		isInteger = false;
		decimalPositionsIndex = mask.lastIndexOf("d{");
		if (decimalPositions == 1){
			mask = mask.substring(0, decimalPositionsIndex + 2) + decimalPositions + mask.substring(mask.indexOf('}', decimalPositionsIndex), mask.length);
		}
		else {
			mask = mask.substring(0, decimalPositionsIndex + 2) + '1,' + decimalPositions + mask.substring(mask.indexOf('}', decimalPositionsIndex), mask.length);
		}
	}

	if(field != null && field.length != undefined) {//es un arreglo de valores
		
		for (j = 0; j < field.length; j++) {
			if (field[j].value != '') {//tengo q validar
				isEmpty = false;
				
				//veo si el arreglo de ids es igual al de cantidades
				var idValue = "";
				if (field.length == ids.length) {
					idValue = ids[j].value;
				}
				else {
					idValue = ids.value;
				}
				var message = itemMessage.replace(/\{0\}/, idValue);
				
				mask = new RegExp(mask);
				if (!mask.test(field[j].value)) {
					isValid = false;
					var completeMsg;
					if (isInteger) {
						completeMsg = errorsOrderInteger.replace(/\{0\}/, message);
						alert(completeMsg.replace(/\{1\}/, integerPositions));
					} else {
						completeMsg = errorsOrderDecimal.replace(/\{0\}/,message);
						completeMsg = completeMsg.replace(/\{1\}/, decimalPositions);
						alert(completeMsg.replace(/\{2\}/, integerPositions));
					}
					break;
				}
			}
		}
	}
	else if (field != null ) {//es un solo campo
		if (field.value!='') {//tengo q validar
			var message = '';
			if (ids.value != undefined) {
				message = itemMessage.replace(/\{0\}/, ids.value);
			} else {
				message = itemMessage.replace(/\{0\}/, ids);
			}	
						
			mask = new RegExp(mask);
			if (!mask.test(field.value)) {
				isValid = false;
				var completeMsg;
				if (isInteger) {
					completeMsg = errorsOrderInteger.replace(/\{0\}/,message);
					alert(completeMsg.replace(/\{1\}/, integerPositions));
				} else {
					completeMsg = errorsOrderDecimal.replace(/\{0\}/,message);
					completeMsg = completeMsg.replace(/\{1\}/, decimalPositions);
					alert(completeMsg.replace(/\{2\}/, integerPositions));
				}
			}
		}
	}
	
	return isValid;	
}	

	
	
	
//Valida q el numero de tarjeta de credito ingresado, sea válido 
//usando el algoritmo Luhn (MOD10)
function validateManuallyCreditCard(form,formName) {
	var bValid = true;
    var focusField = null;
    var i = 0;
    var fields = new Array();
    var arrName = eval('creditCard'+formName);
	oCreditCard = new arrName();
    for (x in oCreditCard) {
    	if ((form[oCreditCard[x][0]].type == 'text' ||
        form[oCreditCard[x][0]].type == 'textarea') &&
        (form[oCreditCard[x][0]].value.length > 0)) {
        	if (!luhnCheck(form[oCreditCard[x][0]].value)) {
            	if (i == 0) {
                	focusField = form[oCreditCard[x][0]];
                }
                fields[i++] = oCreditCard[x][1];
                bValid = false;
            }
        }
    }
    if (fields.length > 0) {
    	focusField.focus();
        alert(fields.join('\n'));
    }
   	return bValid;
}

/**
  * Reference: http://www.ling.nwu.edu/~sburke/pub/luhn_lib.pl
*/
function luhnCheck(cardNumber) {
	if (isLuhnNum(cardNumber)) {
    	var no_digit = cardNumber.length;
        var oddoeven = no_digit & 1;
        var sum = 0;
        for (var count = 0; count < no_digit; count++) {
        	var digit = parseInt(cardNumber.charAt(count));
            if (!((count & 1) ^ oddoeven)) {
            	digit *= 2;
                if (digit > 9) digit -= 9;
            };
            sum += digit;
        };
        if (sum == 0) return false;
        if (sum % 10 == 0) return true;
	};
    return false;
}

function isLuhnNum(argvalue) {
	argvalue = argvalue.toString();
     	if (argvalue.length == 0) {
        	return false;
        }
        for (var n = 0; n < argvalue.length; n++) {
        	if ((argvalue.substring(n, n+1) < "0") ||
            	(argvalue.substring(n,n+1) > "9")) {
                return false;
            }
       }
      return true;
}
	
	
	
//Valida que la fecha ingresada sea >= a hoy mas 1 día hábil. Es decir, si hoy es viernes, 
//la fecha ingresada tiene q ser >= al proximo martes. Se usa, por ejemplo, en la verificacion
//de la validez de la tarjeta de credito; xq si la tarjeta vence hoy no va a poder concretarse
//la transaccion.
function validateManuallyDateWorkingDates(form,formName) {
	var bValid = true;
    var focusField = null;
    var i = 0;
    var fields = new Array();
    var arrName = eval('dateWorkingDates'+formName);
	oDateWorkingDates = new arrName();
    for (x in oDateWorkingDates) {
    	var field = form[oDateWorkingDates[x][0]];
           
        var datePattern = oDateWorkingDates[x][2] ("datePatternStrict");
        if(field.value != ""){
        	//var resultDate = getDateFromFormat(field.value,datePattern) + daysAmmount.value*24*60*60*1000;
						
			var weekDay = (new Date()).getDay();
			var maxDate;
			switch (weekDay){
				case 5: //es viernes y lo llevo a lunes
					maxDate = (new Date()).getDate() + 3;
					break;
				case 6: //es sabado y lo llevo a lunes
					maxDate = (new Date()).getDate() + 2;
					break;
				default : maxDate = (new Date()).getDate() + 1;//en cualquier otro caso, le sumo 1
			}
						
			var d = new Date();
			d.setDate(maxDate);
			maxDate = formatDate(d,datePattern);

			//comparo las fechas, para ver si la fecha obtenida como maximo, es mayor o igual a la ingresada
	        var resultCompareDates = compareDates(maxDate, datePattern, field.value, datePattern);
			if (resultCompareDates != 0) {
		    	if (i == 0) {
		        	focusField = field;
		        }
		        fields[i++] = oDateWorkingDates[x][1];
		        bValid = false;
            }
        }
    }
    if (fields.length > 0) {
    	try{
        	focusField.focus();
        }
        catch(e){}
        alert(fields.join('\n'));
    }
    return bValid;
}
		

 
//Valida q se haya ingresado algo en los campos multiidioma definidos como requeridos.
//Usamos otra funcion para los requeridos multiidioma, distinta a la de los requeridos comunes 
//xq dependiendo de como este configurada la app puede/n existir alguno/s de los campos y no todos  
function validateManuallyRequiredInter(form,formName) {
	var isValid = true;
    var focusField = null;
    var i = 0;
    var fields = new Array();
    var arrName = eval('requiredInter'+formName);
	oRequired = new arrName();
    for (x in oRequired) {
    	var field = form[oRequired[x][0]];
			if(field != undefined){
	        	if (field.type == 'text' ||
	            	field.type == 'textarea' ||
	                field.type == 'file' ||
	                field.type == 'select-one' ||
	                field.type == 'radio' ||
	                field.type == 'password') {
	                var value = '';
					// get field's value
					if (field.type == "select-one") {
						var si = field.selectedIndex;
						if (si >= 0) {
							value = field.options[si].value;
						}
					} else {
						value = field.value;
					}
	                if (trim(value).length == 0) {
	                        
		            	if (i == 0) {
		                	focusField = field;
		                }
		                fields[i++] = oRequired[x][1];
		                isValid = false;
	                }
	             }
	         }
	}
    if (fields.length > 0) {
    	try{
        	focusField.focus();
        }
        catch(e){}
        alert(fields.join('\n'));
    }
    return isValid;
}
            
            

//Valida q el valor ingresado sea un número flotante q se encuentra dentro de un rango 
//predefinido.   
function validateManuallyMaskRange(form,formName) {
	var bValid = true;
    var focusField = null;
    var i = 0;
    var fields = new Array();
    var arrName = eval('maskRange'+formName);
	oRange = new arrName();
    for (x in oRange) {
    	if ((form[oRange[x][0]].type == 'text' || form[oRange[x][0]].type == 'textarea') &&
        (form[oRange[x][0]].value.length > 0)) {
        	var fMin = parseFloat(oRange[x][2]("min"));
            var fMax = parseFloat(oRange[x][2]("max"));
            var fValue = parseFloat(form[oRange[x][0]].value);

            if (!(fValue >= fMin && fValue <= fMax)) {
            	if (i == 0) {
                	focusField = form[oRange[x][0]];
                }
                fields[i++] = oRange[x][1];
                bValid = false;
           	}
       	}
  	}
    if (fields.length > 0) {
    	focusField.focus();
        alert(fields.join('\n'));
    }
    return bValid;
}
         
         
function validateManuallyGreaterThanZero(form, formName) {
	var bValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var arrName = eval('greaterThanZero'+formName);
	oGreaterThan = new arrName();
	for (x in oGreaterThan) {
		var field = form[oGreaterThan[x][0]];

		if (field.type == 'text' || field.type == 'textarea'){
             
			if (parseFloat(field.value) <= 0) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oGreaterThan[x][1];
				bValid = false;
			}
			                    
		}
	}
	if (fields.length > 0) {
		focusField.focus();
		alert(fields.join('\n'));
	}
	return bValid;
}


function validateDynamicFields(form,field,msg) { 
		var field = form[field];	
		for(j=0;j<field.length;j++){
			oField = field[j];
			if (oField.value == ''){
				alert(msg);
				return false;
			}
		}
		return true;
	}
	
//Agregado por BDL_CSP

function validateRequired(form) {
	var isValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	oRequired = new required();
	for (x in oRequired) {
		var field = form[oRequired[x][0]];
		if (field.type == 'text'|| field.type == 'textarea'|| field.type == 'file'|| field.type == 'select-one'|| field.type == 'radio'|| field.type == 'password') {
			var value = '';
			// get field's value
			if (field.type == "select-one") {
				var si = field.selectedIndex;
				if (si >= 0) {
					value = field.options[si].value;
				}
			}
			else {
				value = field.value;
			}
			if (trim(value).length == 0) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oRequired[x][1];
				isValid = false;
			}
		}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return isValid;
}

function validateMaxLength(form) {
	var isValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	oMaxLength = new maxlength();
	for (x in oMaxLength) {
		var field = form[oMaxLength[x][0]];
		if (field.type == 'text'|| field.type == 'textarea') {
			var iMax = parseInt(oMaxLength[x][2] ("maxlength"));
			if (field.value.length > iMax) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oMaxLength[x][1];
				isValid = false;
			}
		}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return isValid;
}

function validateMask(form) {
	var isValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	oMasked = new mask();
	for (x in oMasked) {
		var field = form[oMasked[x][0]];
		if ((field.type == 'text'|| field.type == 'textarea') && (field.value.length > 0)) {
			if (!matchPattern(field.value, oMasked[x][2] ("mask"))) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oMasked[x][1];
				isValid = false;
			}
		}
	}
	if (fields.length > 0) {
		try {
			focusField.focus();
		}
		catch (e) {}
		alert(fields.join('\n'));
	}
	return isValid;
}

function validateGreaterThanZero(form) {
	var bValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	oGreaterThan = new greaterThanZero();
	for (x in oGreaterThan) {
		var field = form[oGreaterThan[x][0]];
		if (field.type == 'text' || field.type == 'textarea'){		                    
			if (parseFloat(field.value) <= 0) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oGreaterThan[x][1];
				bValid = false;
			}
		}
	}
	if (fields.length > 0) {
		focusField.focus();
		alert(fields.join('\n'));
	}
	return bValid;
}	
	
//valida q la fecha ingresada sea válida (esta version esta teniendo en cuenta tambien la hora)
function validateManuallyDateHour(form,formName) {
               var bValid = true;
               var focusField = null;
               var i = 0;
               var fields = new Array();
               var arrName = eval('DateValidations'+formName);
			   oDate = new arrName();
               for (x in oDate) {
                   var value = form[oDate[x][0]].value;
                   var datePattern = oDate[x][2]("datePatternStrict");
                   if ((form[oDate[x][0]].type == 'text' ||
                        form[oDate[x][0]].type == 'textarea') &&
                       (value.length > 0) &&
                       (datePattern.length > 0)) {
                     var MONTH = "MM";
                     var DAY = "dd";
                     var YEAR = "yyyy";
                     var orderMonth = datePattern.indexOf(MONTH);
                     var orderDay = datePattern.indexOf(DAY);
                     var orderYear = datePattern.indexOf(YEAR);
                     if ((orderDay < orderYear && orderDay > orderMonth)) {
                         var iDelim1 = orderMonth + MONTH.length;
                         var iDelim2 = orderDay + DAY.length;
                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
                         var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
                         if (iDelim1 == orderDay && iDelim2 == orderYear) {
                            dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         } else if (iDelim1 == orderDay) {
                            dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         } else if (iDelim2 == orderYear) {
                            dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         } else {
                            dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         }
                         var matched = dateRegexp.exec(value);
                         if(matched != null) {
                            if (!isValidDate(matched[2], matched[1], matched[3])) {
                               if (i == 0) {
                                   focusField = form[oDate[x][0]];
                               }
                               fields[i++] = oDate[x][1];
                               bValid =  false;
                            }
                         } else {
                            if (i == 0) {
                                focusField = form[oDate[x][0]];
                            }
                            fields[i++] = oDate[x][1];
                            bValid =  false;
                         }
                     } else if ((orderMonth < orderYear && orderMonth > orderDay)) {
                         var iDelim1 = orderDay + DAY.length;
                         var iDelim2 = orderMonth + MONTH.length;
                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
                         var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
                         if (iDelim1 == orderMonth && iDelim2 == orderYear) {
                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         } else if (iDelim1 == orderMonth) {
                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         } else if (iDelim2 == orderYear) {
                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         } else {
                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         }
                         var matched = dateRegexp.exec(value);
                         if(matched != null) {
                             if (!isValidDate(matched[1], matched[2], matched[3])) {
                                 if (i == 0) {
                                     focusField = form[oDate[x][0]];
                                 }
                                 fields[i++] = oDate[x][1];
                                 bValid =  false;
                              }
                         } else {
                             if (i == 0) {
                                 focusField = form[oDate[x][0]];
                             }
                             fields[i++] = oDate[x][1];
                             bValid =  false;
                         }
                     } else if ((orderMonth > orderYear && orderMonth < orderDay)) {
                         var iDelim1 = orderYear + YEAR.length;
                         var iDelim2 = orderMonth + MONTH.length;
                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
                         var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
                         if (iDelim1 == orderMonth && iDelim2 == orderDay) {
                             dateRegexp = new RegExp("^(\\d{4})(\\d{2})(\\d{2})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         } else if (iDelim1 == orderMonth) {
                             dateRegexp = new RegExp("^(\\d{4})(\\d{2})[" + delim2 + "](\\d{2})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         } else if (iDelim2 == orderDay) {
                             dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})(\\d{2})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         } else {
                             dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{2})[\\s]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$");
                         }
                         var matched = dateRegexp.exec(value);
                         if(matched != null) {
                             if (!isValidDate(matched[3], matched[2], matched[1])) {
                                 if (i == 0) {
                                     focusField = form[oDate[x][0]];
                                  }
                                  fields[i++] = oDate[x][1];
                                  bValid =  false;
                              }
                          } else {
                              if (i == 0) {
                                  focusField = form[oDate[x][0]];
                              }
                              fields[i++] = oDate[x][1];
                              bValid =  false;
                          }
                     } else {
                         if (i == 0) {
                             focusField = form[oDate[x][0]];
                         }
                         fields[i++] = oDate[x][1];
                         bValid =  false;
                     }
                  }
               }
               if (fields.length > 0) {
					try{
                   		focusField.focus();
                   	}catch(e){}
                  alert(fields.join('\n'));
               }
               return bValid;
            }