//////////////////////////////////////////////////////////////////////////////////////////
////////						Biblioteca JavaScript							//////////
////////					Webroom Soluçoes Interativas						//////////
////////						A internet sob Medida							//////////
////////					http://www.webroom.com.br							//////////
////////					email:: webroom@webroom.com.br						//////////
//////////////////////////////////////////////////////////////////////////////////////////
////////				Criado por : Flávio Theruo Kaminisse					//////////
////////					E-Mail : flavio@webroom.com.br						//////////
////////						Data Criaçao : 28/09/2008						//////////
////////																		//////////
////////				- Compatível com MSIE, Firefox e Opera.					//////////
//////////////////////////////////////////////////////////////////////////////////////////

//Funçao responsável por verificar se o campo é igual a máscara
//se for igual, deixo o valor como vazio, caso contrário nao faço nada
function trata_valor( campo ) {
	if ( campo.value == WBR_GetDisplayMask(campo,true) )
		campo.value = '';
}

//Funçao responsável pelas validaçao de datas
function valida_data(campo_data) {
	trata_valor( campo_data );
	if ( campo_data.value != '' ) {
		var date = campo_data.value;
		var array_data = new Array;
		//Expressao regular utilizada para validaçao de datas
		var ExpReg = new RegExp("^(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[012])/[1-3][0-9]{3}$");
		//vetor que contem o dia o mes e o ano
		array_data = date.split("/");
		erro = false;
		//Valido se a data esta no formato dd/mm/yyyy e se o dia tem 2 dígitos e esta entre 01 e 31
		//se o mes tem 2 dígitos e esta entre 01 e 12 e o ano se tem 4 dígitos e esta entre 1000 e 3999
		if ( date.search(ExpReg) == -1 )
			erro = true;
		//Valido os meses que nao tem 31 dias com exeçao de fevereiro
		else if ( ( ( array_data[1] == 4 ) || ( array_data[1] == 6 ) || ( array_data[1] == 9 ) || ( array_data[1] == 11 ) ) && ( array_data[0] > 30 ) )
			erro = true;
		//Valido o mes de fevereiro
		else if ( array_data[1] == 2 ) {
			//Valido ano que nao e bissexto
			if ( ( array_data[0] > 28 ) && ( ( array_data[2] % 4 ) != 0 ) )
				erro = true;
			//Valido ano bissexto
			if ( ( array_data[0] > 29 ) && ( ( array_data[2] % 4 ) == 0 ) )
				erro = true;
		}
		if ( erro ) {			
			alert("Data Inválida");
			campo_data.focus();
			return false;
		}
		return true;
	}
}

//Funçao responsável pela validaçao de endereços de e-mail
function valida_email(campo_email) {
	if ( campo_email.value != '' ) {
		//Expressao Regular utilizada para validar o endereço de email
		var ExpReg = /^[a-zA-Z0-9_\.-]{2,}@([A-Za-z0-9_-]{2,}\.)+[A-Za-z]{2,4}$/;
		if ( !ExpReg.test(campo_email.value) ) {
			alert("E-MAIL inválido!");
			campo_email.focus();
			return false;
		}
		return true;
	}
}

//Funçao responsável pela validaçao de horas
function valida_hora(campo_hora) {
	trata_valor( campo_hora );
	if ( campo_hora.value != '' ) {
		//Expressao Regular utilizada para validar a hora
		var ExpReg = /^([0-1][0-9]|[2][0-3]):[0-5][0-9]$/;
		if ( campo_hora.value.search(ExpReg) == -1 ) {
			campo_hora.value = "";
			campo_hora.focus();
			alert("A hora é inválida");
			return false;
		}
		return true;
	}
}

//Funçao responsável pela validaçao de campos somente números
function valida_somente_número(campo_número) {
	if ( campo_número.value != '' ) {
		//Expressao Regular utilizada para validar se o campo possui somente números
		var ExpReg = /^\d{0,}$/;
		if ( campo_número.value.search(ExpReg) == -1 ) {
			campo_número.focus();
			alert("O campo nao comtém apenas números");
			return false;
		}
		return true;
	}
}

//Funçao responsável pela validaçao de telefones
function valida_telefone(campo_telefone) {
	trata_valor( campo_telefone );
	if ( campo_telefone.value != '' ) {
		//Expressao Regular utilizada para validar o telefone
		var ExpReg = /^\(\d{2}\) \d{4}-\d{4}$/;
		if ( campo_telefone.value.search(ExpReg) == -1 ) {
			campo_telefone.focus();
			alert("O Telefone é inválido");
			return false;
		}
		return true;
	}
}

//Funçao responsável pela validaçao de CEPs
function valida_CEP(campo_cep) {
	trata_valor( campo_cep );
	if ( campo_cep.value != '' ) {
		//Expressao Regular utilizada para validar o formato do CEP
		var ExpReg = /^\d{2}\.\d{3}-\d{3}$/;
		if ( campo_cep.value.search(ExpReg) == -1 ) {
			campo_cep.focus();
			alert("Formato do CEP inválido!");
			return false;
		}
		return true;
	}
}

//Funçao responsável pela validaçao de CPFs
function valida_CPF(campo_cpf) {
	trata_valor( campo_cpf );
	if ( campo_cpf.value != '' ) {
		var soma;
		var multiplicador;
		var dig1 = 0;
		var dig2 = 0;
		var verifica;
		var cpf = campo_cpf.value;
		//Expressao Regular utilizada para validar o formato CPF
		var ExpReg = /^(\d{3}).(\d{3}).(\d{3})-(\d{2})$/;
		
		if ( cpf.search(ExpReg) == -1 ) {
			campo_cpf.focus();
			alert("O formato do CPF é inválido");
			return false;
		}
		
		//Remover os caracteres diferentes de números
		cpf = strip(cpf);
		
		verifica = cpf.match("00000000000");
		//Se todos os caracteres sao diferentes de zero
		if ( verifica == null ) {
			//Utilizo o algoritmo de calcular os dígitos verificadores do CPF
			//Calculo o primeiro dígito verificador
			soma = 0;
			multiplicador = 10;
			for ( i = 0; i < 9; i++ ) {
				soma += parseInt(cpf.substr(i,1) * multiplicador);
				multiplicador--;
			} //Fim do for
			dig1 = parseInt(11 - (soma % 11));
			if ( dig1 == 11 || dig1 == 10 )
				dig1 = 0;
			//Calculo o segundo dígito verificador
			soma = 0;
			multiplicador = 11;
			for ( i = 0; i < 10; i++ ) {
				soma += parseInt(cpf.substr(i,1) * multiplicador);
				multiplicador--;
			} //Fim do for
			dig2 = parseInt(11 - (soma % 11));
			if ( dig2 == 11 || dig2 == 10 )
				dig2 = 0;
			//Se os dois dígitos nao forem iguais o CPF é inválido
			if ( !( ( dig1 == parseInt(cpf.substr(9,1)) ) && ( dig2 == parseInt(cpf.substr(10,1)) ) ) ) {
				alert("CPF Inválido!!!");
				campo_cpf.focus();
				return false;
			} //if
		} //if
		else {
			campo_cpf.focus();
			alert("CPF Inválido!!!");
			return false;
		} //Fim do else
		return true;
	}
}

//Funçao responsável pela validaçao de CNPJs
function valida_CNPJ(campo_cnpj) {
	var valor = campo_cnpj.value;
	var erro = false;
	if ( campo_cnpj.value != '' ) {
		if ( valor.length != 14 )
			erro = true;
		
		var números = valor.split('');
	
		var igual = true;
		for ( j = 1; j < 14; j++ ) {
			if ( números[j] != números[0] ) {
				igual = false;
				break;
			}
		} //Fim do for
			
		if ( igual )
			erro = true;
			
		var soma = 0;
		var fator = 5;
		for ( j = 0; j < 12 ; j++ ) {
			soma += fator * números[j];
			fator--;
			if ( fator == 1 )
				fator = 9;
		}
		
		var resultado = soma % 11;
		
		if ( resultado == 1 || resultado == 0 ) {
			if ( números[12] != 0 )
				erro = true;
		}
		else {
			if ( números[12] != 11 - resultado )
				erro = true;
		}
		
		soma = 0;
		fator = 6;
		for ( j = 0; j < 13 ; j++ ) {
			soma += fator * números[j];
			fator--;
			if ( fator == 1 )
				fator=9;
		} //Fim do for
		
		resultado = soma%11;
		
		if ( resultado == 1 || resultado == 0 ) {
			if ( números[13] != 0 )
				erro = true;
		}
		else {
			if ( números[13] != 11 - resultado )
				erro = true;
		}
		if ( erro == true ) {
			campo_cnpj.focus();
			alert("CNPJ inválido!");
			return false;
		}
		return true;
	}
}

//Funçao responsável pela validaçao de valores no formato de moeda brasileira
function valida_valor(campo_valor) {
	var valor = campo_valor.value;
	if ( valor != '' ) {
		//O número nao pode iniciar com zero e só deve ter dígitos, ponto e vírgula
		var ExpReg = /^[^0]+[0-9\.,]{0,}$/;
		if ( valor.search(ExpReg) == -1 ) {
			alert("O Valor nao pode iniciar com zero (0)!");
			campo_valor.focus();
		}
		var ExpReg = /^[-+]?\d{1,3}(\.\d{3})*,\d{2}$/;
		if ( valor.search(ExpReg) == -1 ) {
			alert("Valor inválido!");
			campo_valor.focus();
		}
	}
}

//Funçao responsável pela validaçao de valores no formato de moeda brasileira
//Antiga funçao utiizada para validar valores
//Desenvolvida baseada na mesma funçao de formataçao
function valida_valor2(campo_valor) {
	if ( campo_valor.value != '' ) {
		var valor = campo_valor.value;
		//Expressao regular que garante que o número nao comece com zero e que siga
		//os padroes do número que sao apenas dígitos e ponto (.) e virgula (,)
		var ExpReg = /^[^0]+[0-9\.,]{0,}$/;
		var count_virgula = 0;
		var count_ponto = 0;
		var coloquei_virgula = false;
		if ( valor.search(ExpReg) == -1 ) {
			campo_valor.focus();
			alert("O Valor nao pode iniciar com zero (0)!");
			return false;
		}
		//Utilizo um algoritmo semelhante ao formataçao do número para validar o campo
		//Iniciando da direita para a esquerda analiso o número dígito a dígito
		//sendo que depois de dois dígitos tenho que ter uma virgula (,)
		//e depois da virgula de tres em tres dígitos tenho que ter um ponto (.)
		for ( i = valor.length - 1; i >= 0; i-- ) {
			if ( count_virgula == 2 && !coloquei_virgula ) {
				coloquei_virgula = true;
			} //if
			if ( count_virgula == 2 && !coloquei_virgula && valor.charAt(i) != "," ) {
				campo_valor.focus();
				alert("Formato Inválido (,)!");
				return false;
			} //if
			if ( count_ponto != 0 && valor.charAt(i) != "." && ( count_ponto % 4 ) == 0 ) {
				if ( !( valor.charAt(i) == "-" && i == 0 ) ) {
					campo_valor.focus();
					alert("Formato Inválido (.)!");
					return false;
				} //if ( !( valor.charAt(i) == "-" && i == 0 ) )
			} //if ( count_ponto != 0 && valor.charAt(i) != "." && ( count_ponto % 4 ) == 0 )
			if ( coloquei_virgula )
				count_ponto++;
			else
				count_virgula++;
		} //Fim do for
		return true;
	} //if ( campo_valor.value != '' )
}

//Funçao responsável pela validaçao dos dígitos do cartao
function cartaoValido(st) {
	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--;
	} //Fim do for
	
	if ( ( sum % 10 ) == 0 )
		return (true);
	else
		return (false);
}

//Funçao responsável pela remo o de caracteres diferentes de números
function strip(val) {
	val = "" + val;
	if ( val == null )
		return "";
	var result = "";
	for ( i = 0; i < val.length; i++ ) {
		character = val.charAt(i);
		if ( "0123456789".indexOf(character) != -1 )
			result += character;
	}
	return result;
}

//Funçao responsável pela validaçao de números de cartao de crédito
function valida_cartao(campo_cartao) {
	trata_valor( campo_cartao );
	if ( campo_cartao.value != '' ) {
		if ( !cartaoValido(strip(campo_cartao.value)) ) {
			campo_cartao.focus();
			alert("O número do cartao de crédito é inválido");
			return false;
		}
	}
}

//Funçao que retira os espaços em branco da string OBS: Só os espaços antes e depois conservando os espaços do meio da string...
function TrimJS(campo){
   return campo.replace(/^\s+|\s+$/g,"");
}