//////////////////////////////////////////////////////////////////////////////////////////
////////						Biblioteca JavaScript							//////////
////////					Webroom Soluções 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ção : 28/09/2008						//////////
////////																		//////////
////////				- Compatível com MSIE, Firefox e Opera.					//////////
//////////////////////////////////////////////////////////////////////////////////////////

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

//Função responsável pelas validação 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;
		//Expressão regular utilizada para validação 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 mês 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 não tem 31 dias com exeção 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 mês de fevereiro
		else if ( array_data[1] == 2 ) {
			//Valido ano que não 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ção responsável pela validação de endereços de e-mail
function valida_email(campo_email) {
	if ( campo_email.value != '' ) {
		//Expressão 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ção responsável pela validação de horas
function valida_hora(campo_hora) {
	trata_valor( campo_hora );
	if ( campo_hora.value != '' ) {
		//Expressão 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ção responsável pela validação de campos somente números
function valida_somente_numero(campo_número) {
	if ( campo_número.value != '' ) {
		//Expressão 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 não comtém apenas números");
			return false;
		}
		return true;
	}
}

//Função responsável pela validação de telefones
function valida_telefone(campo_telefone) {
	trata_valor( campo_telefone );
	if ( campo_telefone.value != '' ) {
		//Expressão 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ção responsável pela validação de CEPs
function valida_CEP(campo_cep) {
	trata_valor( campo_cep );
	if ( campo_cep.value != '' ) {
		//Expressão 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ção responsável pela validação 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;
		//Expressão 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 são 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 não 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ção responsável pela validação 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ção responsável pela validação de valores no formato de moeda brasileira
function valida_valor(campo_valor) {
	var valor = campo_valor.value;
	if ( valor != '' ) {
		//O número não 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 ) {
			valor = '';
			alert("O Valor não 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ção responsável pela validação de valores no formato de moeda brasileira
//Antiga função utiizada para validar valores
//Desenvolvida baseada na mesma função de formatação
function valida_valor2(campo_valor) {
	if ( campo_valor.value != '' ) {
		var valor = campo_valor.value;
		//Expressão 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 não pode iniciar com zero (0)!");
			return false;
		}
		//Utilizo um algoritmo semelhante ao formatação 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 três em três 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ção responsável pela validação dos dígitos do cartão
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ção 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ção responsável pela validação de números de cartão 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 cartão de crédito é inválido");
			return false;
		}
	}
}

//Função responsavel pela mascara do input somente para numeros
function mascara(o,f){
    v_obj=o
    v_fun=f
    setTimeout("execmascara()",1)
}

function execmascara(){
    v_obj.value=v_fun(v_obj.value)
}

function soNumeros(v){
    return v.replace(/\D/g,"")
}