/* ----------------------------------------------------------------------------- Nome da Função: SomenteNumero(evento) Objetivo: Permitir apenas caracteres numéricos. Parâmetros: evento -> tecla digitada (event). Chamada: OnKeyPress="return SomenteNumero(event)" ----------------------------------------------------------------------------- */ function SomenteNumero(teclapres) { // codigo ASCII da tecla pressionada switch (getNavegador()) { case 'IE': codtecla = teclapres.keyCode; break; case 'FIREFOX': codtecla = teclapres.which; break; } if (!(((codtecla >= 48) && (codtecla <= 57)) || ((codtecla >= 48) && (codtecla <= 57)) || (codtecla == 8) || (codtecla == 9) || (codtecla == 13))) return false; } //Função para obter o navegador utilizado function getNavegador() { agent = navigator.userAgent; /* IE5 = (agent.indexOf("MSIE 5") > -1)?true:false; IE6 = (agent.indexOf("MSIE 6") > -1)?true:false; IE7 = (agent.indexOf("MSIE 7") > -1)?true:false; */ IE = (agent.indexOf("MSIE") > -1)?true:false; FIREFOX = (agent.indexOf("Firefox/1.0")> -1)?true:false; if (IE) return "IE"; else if (FIREFOX) return "FIREFOX"; } /* ----------------------------------------------------------------------------- Nome da Função: SaltaCampo(campo,formulario) Objetivo: Pular para o próximo campo TEXTO, SE HOUVER, após preenchimento. Parâmetros: campo -> campo a ser analisado (this) formulario -> formulario onde está o campo. Chamada: OnKeyUp="SaltaCampo(this,formulario)" ----------------------------------------------------------------------------- */ function SaltaCampo(campo,formulario) { nome = campo.name; if (campo.value.length == campo.maxLength) { tam = formulario.length; for (i=0; i < tam; i++) { if (formulario.elements[i].name == nome) { if (i < tam-1) if ((formulario.elements[i+1].type == 'text') || (formulario.elements[i+1].type == 'password')) { formulario[i+1].focus(); } } } return false } return true; } /* ----------------------------------------------------------------------------- Função: VerificaData(campo) Objetivo: Faz a validação da data digitada. Parâmetros: campo -> campo a ser validado. Chamada: OnBlur="VerificaData(this)" ----------------------------------------------------------------------------- */ function VerificaData(campo) { msg = '' bissexto = false tam = campo.value.length; if (tam == 0) return false; if ((tam < 10) && (tam > 0)) msg = 'Data Inválida! O ano deve ter 4 dígitos!'; if (tam == 10) { partes = campo.value.split("/"); dia = partes[0]; mes = partes[1]; ano = partes[2]; if (!((dia >= 01)&&(dia <= 31))) msg = 'Dia Inválido!'; else { if (!((mes >= 01)&&(mes <= 12))) msg = 'Mês Inválido!'; else { if (((ano % 4 == 0) && (ano % 100 != 0)) || (ano % 400 == 0)) bissexto = true; if (mes == 02) { if ((dia > 28) && (!bissexto)) msg = 'O mês correspondente possui no máximo 28 dias!'; if ((dia > 29) && (bissexto)) msg = 'O mês correspondente possui no máximo 29 dias!'; } if (!((mes == 01) || (mes == 03) || (mes == 05) || (mes == 07) || (mes == 08) || (mes == 10) || (mes == 12)) && (dia == "31")) msg = 'O mês correspondente possui apenas 30 dias!'; } } } if (msg != '') { alert(msg); campo.value = ''; campo.focus(); } else return true; } /* ----------------------------------------------------------------------------- Função: VerificaVencimento(campo,dia,mes,ano,ref) Objetivo: Verificar preenchimento do Vencimento, e preencher a data de referência, se for automático. Parâmetros: campo -> campo a ser verificado (this). dia, mes, ano -> variáveis com os valores da data atual do servidor. ref -> indica se a data de referencia sera preenchida automaticamente. 1 - automatico / 0 - manual. Validações: 1 - Não permite ano diferente do atual (servidor). 2 - Não permite data menor que a atual (servidor). Chamada: OnBlur="VerificaVencimento(this,dia,mes,ano,ref)" ----------------------------------------------------------------------------- */ function VerificaVencimento(campo,dia,mes,ano,ref) { df = document.formulario; vencimento = campo.value; if (VerificaData(campo)) { data = vencimento.split("/") dia = dia; mes = mes; ano = ano; diaV = data[0]; mesV = data[1]; anoV = data[2]; if (anoV == ano) { if ((mesV > mes) || ((mesV == mes) && (diaV >= dia))) { if (ref == 1) { df.TXT_REFERENCIA.value = mesV+'/'+anoV } } else { alert('A data de vencimento não pode ser anterior à data atual!') campo.value = ''; campo.focus(); } } else { if ((anoV - ano < 2) && (anoV - ano > 0)) { if (ref == 1) { df.TXT_REFERENCIA.value = mesV+'/'+anoV } return true; } else { alert('O ano deve ser igual a '+ ano+' !') campo.value = ''; campo.focus(); } } } } /* ----------------------------------------------------------------------------- Função: VerificaReferencia(campo) Objetivo: Verificar preenchimento da data de referência, se for manual. Parâmetros: campo -> campo a ser verificado (this). Validacoes: 1 - Nao pode ser mais de 5 anos mais antiga que a data de vencimento (verifica ano e meses) 2 - Nao permite ano maior do que o atual, e mes que nao exista; 3 - Nao permite mes de referencia maior que o mes do vencimento, caso seja o mesmo ano Chamada: OnBlur="VerificaReferencia(this)" ----------------------------------------------------------------------------- */ function VerificaReferencia(campo){ df = document.formulario; if (campo.value != ''){ if(df.txt_APLICACAO.value != "PD") vencimento = df.TXT_VENCIMENTO.value; else vencimento = df.TXT_VENCIMENTO_PARC.value; if (vencimento.length == 10){ data = vencimento.split("/"); diaV = data[0]; mesV = data[1]; anoV = data[2]; if (campo.value.length == 7){ data = campo.value.split("/"); mesR = data[0]; anoR = data[1]; } else{ alert('Data de Referência inválida!'); campo.value = ''; campo.focus(); return false; } if (!((Number(mesR) >= 01)&&(Number(mesR) <= 12))){ alert('Mês Inválido!'); campo.value = ''; return false; } if (anoR.length < 4){ alert('O Ano deve ter 4 dígitos!'); campo.value = ''; return false; } if ((Number(anoR) + 6 < anoV) || ((Number(anoR) + 6 == anoV) && (Number(mesR) < mesV))){ alert('A data de referência não pode ter mais de 6 anos de diferença para a data de vencimento!'); campo.value = ''; return false; } if (((anoR == anoV) && (mesR > mesV)) || (anoR > anoV)){ alert('A data de referência não pode ser maior que a data de vencimento!'); campo.value = ''; return false; } } else{ campo.value = ''; alert('Data de Vencimento inválida!'); df.TXT_VENCIMENTO.value = ''; df.TXT_VENCIMENTO.focus(); return false; } } return true; } /* ----------------------------------------------------------------------------- Função: FormataMoeda(numero) Objetivo: Formata um valor moeda. Usada na soma dos campos do DUA. Parâmetros: numero -> número a ser formatado. Chamada: NumFormatado = FormataMoeda(NumNaoFormatado) ----------------------------------------------------------------------------- */ function FormataMoeda(numero) { posv = numero.indexOf(","); //posicao da virgula tamint = posv; //tamanho da parte inteira strint = numero.substr(0,tamint); strdec = numero.substr(tamint,numero.length); numformatado = ''; if (tamint > 3) { qpt = tamint/3; qpt = qpt.toString(); qpt = Number(qpt.substr(0,1)); if ((tamint % 3) == 0) qpt = qpt - 1; ini = 0; fim = tamint - qpt*3; q = 0; numold = strint; while(q != qpt) { numformatado += numold.substr(ini, fim) + '.' numold = numold.substr(fim,numold.length); fim = 3; q += 1; } numformatado += numold.substr(0,3); numformatado += strdec; } else numformatado = numero; return numformatado; } /* ----------------------------------------------------------------------------- Função: RoundTo(numero,pow) Objetivo: Arrendonda um valor numérico. Parâmetros: numero -> número a ser arredondado. pow -> casas decimais. Chamada: NumArredondado = RoundTo(NumNaoArredondado,2) ----------------------------------------------------------------------------- */ function RoundTo(numero,pow) { if( isNaN( numero ) ) { numero = 0; } numero *= Math.pow(10,pow); numero = (Math.round(numero)/Math.pow(10,pow))+ "" ; if(numero.indexOf(".") == -1) numero += "." ; while(numero.length - numero.indexOf(".") - 1 < pow) numero += "0" ; return numero; } /* ----------------------------------------------------------------------------- Função: IniciaNumero(numero) Objetivo: Inicializar valores numéricos. String -> Número. Parâmetros: numero -> String / Número a ser inicializado. Chamada: NumSemPontosEVirgulas = IniciaNumero(Numero) ----------------------------------------------------------------------------- */ function IniciaNumero(numero) { //se vazio, entao é ZERO. if (numero == '') { numero = 0; } //senão, troca vírgula por ponto para calcular. else { numero = numero.replace("R$",""); numero = numero.replace(".",""); numero = numero.replace(".",""); numero = numero.replace(",","."); numero = Number(numero); } return numero; } /* ----------------------------------------------------------------------------- Função: Mascara(campo, tipo) Objetivo: Aplica Máscara a um campo. Parâmetros: campo -> campo a ser aplicado a máscara. tipo -> tipo de máscara(data, telefone, cpf..) Chamada: OnKeyUp="Mascara(this,'##/##/####')" ----------------------------------------------------------------------------- */ function Mascara(campo, tipo) { var valorAtual = campo.value; var valorNumerico = ''; var nIndexModelo = 0; var nIndexString = 0; var valorFinal = ''; var adicionarValor = true; switch(tipo) { case 'telefone': Modelo = '(##)####-####' break; case 'data': Modelo = '##/##/####' break; case 'referencia': Modelo = '##/####' break; } // limpa a string valor atual para verificar // se todos os caracteres são números for (i=0;i campo a ser formatado (this). tammax -> quantos numeros devem ser digitados para a virgula ficar na posicao certa. teclapress -> codtecla pressionada pelo usuário (event) Validacoes: 1 - Não deixa digitar numero negativo; Chamada: onKeyUp="FormataValor(this,2,event)" ----------------------------------------------------------------------------- */ function FormataValor(campo,tammax,teclapres) { var codtecla = teclapres.keyCode; vr = campo.value; vr = vr.replace( ".", "" ); vr = vr.replace( ".", "" ); vr = vr.replace( ",", "" ); tam = vr.length; if (tam < tammax && codtecla != 8){ tam = vr.length + 1 ; } if ( codtecla == 8 || codtecla >= 48 && codtecla <= 57 || codtecla >= 96 && codtecla <= 105 ){ if ( tam <= 2 ){ campo.value = vr ; } if ( (tam > 2) && (tam <= 17) ){ campo.value = vr.substr( 0, tam - 2 ) + ',' + vr.substr( tam - 2, tam ) ; } if ( (tam >= 6) && (tam <= 8) ){ campo.value = vr.substr( 0, tam - 5 ) + '.' + vr.substr( tam - 5, 3 ) + ',' + vr.substr( tam - 2, tam ) ; } if ( (tam >= 9) && (tam <= 11) ){ campo.value = vr.substr( 0, tam - 8 ) + '.' + vr.substr( tam - 8, 3 ) + '.' + vr.substr( tam - 5, 3 ) + ',' + vr.substr( tam - 2, tam ) ; } if ( (tam >= 12) && (tam <= 14) ){ campo.value = vr.substr( 0, tam - 11 ) + '.' + vr.substr( tam - 11, 3 ) + '.' + vr.substr( tam - 8, 3 ) + '.' + vr.substr( tam - 5, 3 ) + ',' + vr.substr( tam - 2, tam ) ; } if ( (tam >= 15) && (tam <= 17) ){ campo.value = vr.substr( 0, tam - 14 ) + '.' + vr.substr( tam - 14, 3 ) + '.' + vr.substr( tam - 11, 3 ) + '.' + vr.substr( tam - 8, 3 ) + '.' + vr.substr( tam - 5, 3 ) + ',' + vr.substr( tam - 2, tam ) ;} } } /* ----------------------------------------------------------------------------- Nome da Função: FormataUnidade(fld, milSep, decSep, e) Objetivo: Formatar e validar campos de unidades Parâmetros: fld -> campo a ser formatado (this). milSep -> separador de milhar decSep -> separador decimal 1 - Não deixa digitar numero negativo; Chamada: onKeyPress="return(FormataUnidade(this,'.',',',event))" ----------------------------------------------------------------------------- */ function FormataUnidade(fld, milSep, decSep, e) { var sep = 0; var key = ''; var i = j = 0; var len = len2 = 0; var strCheck = '0123456789'; var aux = aux2 = ''; var whichCode = (window.Event) ? e.which : e.keyCode; if (event.keyCode == 13) return true; // Enter key = String.fromCharCode(event.keyCode); // Get key value from key code //alert(event.keyCode); if (strCheck.indexOf(key) == -1) return false; // Not a valid key len = fld.value.length; for(i = 0; i < len; i++) if ((fld.value.charAt(i) != '0') && (fld.value.charAt(i) != decSep)) break; aux = ''; for(; i < len; i++) if (strCheck.indexOf(fld.value.charAt(i))!=-1) aux += fld.value.charAt(i); aux += key; len = aux.length; if (len == 0) fld.value = ''; if (len == 1) fld.value = '0'+ decSep + '00' + aux; if (len == 2) fld.value = '0'+ decSep + '0' + aux; if (len == 3) fld.value = '0'+ decSep + aux; if (len > 3) { aux2 = ''; for (j = 0, i = len - 4; i >= 0; i--) { if (j == 3) { aux2 += milSep; j = 0; } aux2 += aux.charAt(i); j++; } fld.value = ''; len2 = aux2.length; for (i = len2 - 1; i >= 0; i--) fld.value += aux2.charAt(i); fld.value += decSep + aux.substr(len - 3, len); } return false; } /* ----------------------------------------------------------------------------- Nome da Função: VerificaTotal() Parâmetros: Objetivo: Verificar se o valor total dos campos do DUA está igual ao total digitado pelo usuário e o informa caso esteja errado. Validacoes: 1 - Soma o Valor da Receita, Multa, Juros, Atualização e subtrai o valor do Crédito. 2 - Verifica se esta soma está igual ao valor digitado no campo Total Chamada: OnBlur="VerificaTotal()" ----------------------------------------------------------------------------- */ function VerificaTotal() { var soma = 0; df = document.formulario; vltrib = df.TXT_VLTRIB.value; vltrib = IniciaNumero(vltrib); vlmul = df.TXT_VLMULTA.value vlmul = IniciaNumero(vlmul); vljur = df.TXT_VLJUROS.value vljur = IniciaNumero(vljur); vlatu = df.TXT_VLCOR.value vlatu = IniciaNumero(vlatu); vlcrd = df.TXT_VLCRD.value vlcrd = IniciaNumero(vlcrd); if (Number(vlcrd) > Number(vltrib)) { df.TXT_VLCRD.value = '' vlcrd = 0 alert('O valor do crédito não pode ser maior que o valor da receita!'); } soma += vltrib + vlmul + vljur + vlatu; soma -= vlcrd soma = RoundTo(soma,2) if ((soma > 0) || (vltrib == vlcrd)) { //troca ponto por virgula para exibicao soma = soma.toString(); soma = soma.replace(".",","); df.TXT_VLTOTAL.value = 'R$ ' + FormataMoeda(soma); } else { df.TXT_VLTOTAL.value = ''; alert('O valor total deve ser maior que zero!'); } } /* ----------------------------------------------------------------------------- Nome da Função: VerificaFunres() Objetivo: Verificar valor do Funres Validacoes: 1 - O valor do Funres é no maximo igual a 5% do valor da receita. Chamada: OnBlur="VerificaFunres()" ----------------------------------------------------------------------------- */ function VerificaFunres() { df = document.formulario; rec = df.TXT_VLTRIB.value rec = IniciaNumero(rec); crd = df.TXT_VLCRD.value crd = IniciaNumero(crd); fun = df.TXT_VLFUN.value fun = IniciaNumero(fun); var porcentagem = 5/100 var tot = (rec-crd)*porcentagem if (fun > tot) { df.TXT_VLFUN.value = '' alert('O Valor do FUNRES não pode ultrapassar 5% do Valor da Receita!'); } } /* ----------------------------------------------------------------------------- Nome da Função: MM_validateForm Objetivo: Validar preenchimento dos campos do formulário. Parâmetros: Nome do Campo; Nome referente ao campo, que aparece na mensagem de erro, se houver; Validação(ões) referente ao campo; R - campo de preenchimento obrigatório; isEmail - campo de e-mail; RisEmail - campo de e-mail e obrigatório; OBS.: podem ser colocados na sequencia, quantos campos forem necessarios; Exemplo: MM_validateForm('dsnome','Nome','R','tel','Telefone','R');return MM_returnValue ----------------------------------------------------------------------------- */ function MM_validateForm() { //v3.0 var i,p,q,nm,test,num,nome,min,max,errors='',args=MM_validateForm.arguments; for (i=0; i<(args.length-3); i+=3) { nome=args[i+1]; test=args[i+2]; val=MM_findObj(args[i]); if (val) { nm=val.name; if ((val=val.value)!="") { if (test.indexOf('isEmail')!=-1) { p=val.indexOf('@'); if (p<1 || p==(val.length-1)) errors+='- '+nome+' deve conter um endereço de e-mail válido.\n'; } else if (test!='R') { num = parseFloat(val); if (val!=''+num) errors+='- '+nome+' deve conter apenas números.\n'; if (test.indexOf('inRange') != -1) { p=test.indexOf(':'); min=test.substring(8,p); max=test.substring(p+1); if (num ZERO if (args[args.length-1] == 'true') { total = document.frm4.TXTVLTOT.value; total = iniciaNum(total); if (total <= 0) {errors += 'O Valor Total deve ser maior que ZERO !';} } if (errors) alert('O(s) seguinte(s) erro(s) ocorreram:\n'+errors); // retorno da função document.MM_returnValue = (errors == ''); } /* ----------------------------------------------------------------------------- Nome da Função: Apaga(campo) Objetivo: Apaga o conteúdo do campo. Parâmetros: campo -> campo a ser apagado (this). Chamada: onClick="Apaga(this)" ----------------------------------------------------------------------------- */ function Apaga(campo) { campo.value = '' } /* ----------------------------------------------------------------------------- Nome da Função: Seleciona(campo) Objetivo: Seleciona o conteúdo do campo. Parâmetros: campo -> campo a ser apagado (this). Chamada: onClick="Seleciona(this)" ----------------------------------------------------------------------------- */ function Seleciona(campo) { campo.select(); } /* ----------------------------------------------------------------------------- Nome da Função: ValidaFormulario(formulario) Objetivo: Valida o preenchimento dos campos do formulário. Parâmetros: Chamada: Botão de Envio - onClick="return ValidaFormulario()" ----------------------------------------------------------------------------- */ function ValidaFormulario(formulario) { msg = ''; qt_campos = formulario.length; for (i=0;i -1)?true:false; IE6 = (agent.indexOf("MSIE 6") > -1)?true:false; IE7 = (agent.indexOf("MSIE 7") > -1)?true:false; IE8 = (agent.indexOf("MSIE 8") > -1)?true:false; IE9 = (agent.indexOf("MSIE 9") > -1)?true:false; FIREFOX = (agent.indexOf("Firefox/1.0")> -1)?true:false; if (!((IE5) || (IE6) || (IE7) || (IE8) || (IE9) || (FIREFOX))) { /*alert('Prezado(a) Contribuinte,\n' + 'A aplicação do DUA-Eletrônico possui, por motivos de segurança, várias funções de tratamentos de erro que são incompatíveis com o seu navegador.\n' + 'Para a perfeita utilização dos serviços disponíveis no DUA-Eletrônico é necesário que o seu computador possua instalado o Internet Explorer 5.5 ou Superior ou Firefox 1.0.\n' + 'A distribuição deste navegador é gratuita.\n' + 'Redirecioná-lo-emos agora para a página de download de um navegador compatível com a nossa aplicação.\n\n' + 'Certo de sua compreenssão.\n\n' + 'Webmaster-SEFAZ/ES.') window.location="http://www.microsoft.com/brasil/windows/downloads/ie/getitnow.mspx"*/ window.location="http://e-dua.sefaz.es.gov.br/erro/index.html"; } }