FUNCAO - Verifica Inscrição Estadual de todos estados

JMARCELO · Mensagem por **JMARCELO** » 15 Set 2004 15:26

caros colegas

utilizo a procedure descrita abaixo a ate o momento nao havia tido grandes problemas mas um cliente me ligou e nao consegui digitar as inscricoes abaixo verifiquei no site do sintegra e estao corretas gostaria da ajuda de voces neste caso desde ja obrigado

1o. EX.

CNPJ 06.016.286/0002-60 IE 00000001232347 UF - RO

2o. EX.

CNPJ 03.571.040/0001-81 IE 253979986 UF - SC

PROCEDURE USADA PARA VERIFICACAO (consegui na net)

Código: Selecionar todos

procedure ieok(puf,pie)
   local ok:=.f.,base,vpos,valg,vsom,vres,vdig1,vdig2,vpro,p,d,n,vbase2,origem
   vbase2:=base:=origem:=""
   if alltrim(pie)=="ISENTO";return .t.;endif
   if SUBS(pie,1,1)=="P";return .t.;endif

   for vpos:=1 to len(alltrim(pie))
       if substr(pie,vpos,1)$"0123456789P"
          origem+=substr(pie,vpos,1)
       endif
   next
   mascara:="99999999999999"
   if     puf=="AC"
      mascara:="99,99,9999-9"
      base   :=padr(origem,9,"0")
      if left(base,2)=="01" .and. substr(base,3,2)<>"00"
         vsom:=0
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*(10-vpos)
             vsom+=valg
         next
         vres  :=vsom%11
         vdig1 :=str(if(vres<2,0,11-vres),1,0)
         vbase2:=left(base,8)+vdig1
         ok    :=(vbase2==origem)
      endif
   elseif puf=="AL"
      mascara:="999999999"
      base   :=padr(origem,9,"0")
      if left(base,2)=="24"
         vsom:=0
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*(10-vpos)
             vsom+=valg
         next
         vpro  :=vsom*10
         vres  :=vpro%11
         vdig1 :=if(vres==10,"0",str(vres,1,0))
         vbase2:=left(base,8)+vdig1
         ok    :=(vbase2==origem)
      endif
   elseif puf=="AM"
      mascara:="99,999,999-9"
      base   :=padr(origem,9,"0")
      vsom   :=0
      for vpos:=1 to 8
          valg:=val(substr(base,vpos,1))
          valg:=valg*(10-vpos)
          vsom+=valg
      next
      if vsom<11
         vdig1:=str(11-vsom,1,0)
      else
         vres :=vsom%11
         vdig1:=if(vres<2,"0",str(11-vres,1,0))
      endif
      vbase2:=left(base,8)+vdig1
      ok    :=(vbase2==origem)
   elseif puf=="AP"
      mascara:="999999999"
      base   :=padr(origem,9,"0")
      if left(base,2)=="03"
         n:=val(left(base,8))
         if     n>=3000001 .and. n<=3017000
            p:=5
            d:=0
         elseif n>=3017001 .and. n<=3019022
            p:=9
            d:=1
         elseif n>=3019023
            p:=0
            d:=0
         endif
         vsom:=p
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*(10-vpos)
             vsom+=valg
         next
         vres :=vsom%11
         vdig1:=11-vres
         if vdig1==10
            vdig1:=0
         elseif vdig1==11
            vdig1:=d
         endif
         vdig1 :=str(vdig1,1,0)
         vbase2:=left(base,8)+vdig1
         ok    :=(vbase2==origem)
      endif
   elseif puf=="BA"
      mascara:="999999-99"
      base   :=padr(origem,8,"0")
      if left(base,1)$"0123458"
         vsom:=0
         for vpos:=1 to 6
             valg:=val(substr(base,vpos,1))
             valg:=valg*(8-vpos)
             vsom+=valg
         next
         vres  :=vsom%10
         vdig2 :=str(if(vres==0,0,10-vres),1,0)
         vbase2:=left(base,6)+vdig2
         vsom  :=0
         for vpos:=1 to 7
             valg:=val(substr(vbase2,vpos,1))
             valg:=valg*(9-vpos)
             vsom+=valg
         next
         vres :=vsom%10
         vdig1:=str(if(vres==0,0,10-vres),1,0)
      else
         vsom:=0
         for vpos:=1 to 6
             valg:=val(substr(base,vpos,1))
             valg:=valg*(8-vpos)
             vsom+=valg
         next
         vres  :=vsom%11
         vdig2 :=str(if(vres<2,0,11-vres),1,0)
         vbase2:=left(base,6)+vdig2
         vsom  :=0
         for vpos:=1 to 7
             valg:=val(substr(vbase2,vpos,1))
             valg:=valg*(9-vpos)
             vsom+=valg
         next
         vres :=vsom%11
         vdig1:=str(if(vres<2,0,11-vres),1,0)
      endif
      vbase2:=left(base,6)+vdig1+vdig2
      ok:=(vbase2==origem)
   elseif puf=="CE"
      mascara:="99999999-9"
      base   :=padr(origem,9,"0")
      vsom   :=0
      for vpos:=1 to 8
          valg:=val(substr(base,vpos,1))
          valg:=valg*(10-vpos)
          vsom+=valg
      next
      vres :=vsom%11
      vdig1:=11-vres
      if vdig1>9;vdig1:=0;endif
      vbase2:=left(base,8)+str(vdig1,1,0)
      ok    :=(vbase2==origem)
   elseif puf=="DF"
      mascara:="999,99999,999-99"
      base   :=padr(origem,13,"0")
      if left(base,3)=="073"
         vsom:=0
         vmul:={4,3,2,9,8,7,6,5,4,3,2}
         for vpos:=1 to 11
             valg:=val(substr(base,vpos,1))
             valg:=valg*vmul[vpos]
             vsom+=valg
         next
         vres  :=vsom%11
         vdig1 :=if(vres<2,0,11-vres)
         vbase2:=left(base,11)+str(vdig1,1,0)
         vsom  :=0
         vmul  :={5,4,3,2,9,8,7,6,5,4,3,2}
         for vpos:=1 to 12
             valg:=val(substr(vbase2,vpos,1))
             valg:=valg*vmul[vpos]
             vsom+=valg
         next
         vres  :=vsom%11
         vdig2 :=if(vres<2,0,11-vres)
         vbase2+=str(vdig2,1,0)
         ok    :=(vbase2==origem)
      endif
   elseif puf=="ES"
      mascara:="999999999"
      base   :=padr(origem,9,"0")
      vsom   :=0
      for vpos:=1 to 8
          valg:=val(substr(base,vpos,1))
          valg:=valg*(10-vpos)
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=str(if(vres<2,0,11-vres),1,0)
      vbase2:=left(base,8)+vdig1
      ok    :=(vbase2==origem)
   elseif puf=="GO"
      mascara:="99,999,999-9"
      base   :=padr(origem,9,"0")
      if left(base,2)$"10,11,15"
         vsom:=0
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*(10-vpos)
             vsom+=valg
         next
         vres:=vsom%11
         if vres==0
            vdig1:="0"
         elseif vres==1
            n    :=val(left(base,8))
            vdig1:=if(n>=10103105 .and. n<=10119997,"1","0")
         else
            vdig1:=str(11-vres,1,0)
         endif
         vbase2:=left(base,8)+vdig1
         ok    :=(vbase2==origem)
      endif
   elseif puf=="MA"
      mascara:="999999999"
      base   :=padr(origem,9,"0")
      if left(base,2)=="12"
         vsom:=0
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*(10-vpos)
             vsom+=valg
         next
         vres  :=vsom%11
         vdig1 :=str(if(vres<2,0,11-vres),1,0)
         vbase2:=left(base,8)+vdig1
         ok    :=(vbase2==origem)
      endif
   elseif puf=="MT"
      mascara:="9999999999-9"
      vmul   :={3,2,9,8,7,6,5,4,3,2}
      vsom:=0
      for vpos:=1 to 10
          valg:=val(substr(base,vpos,1))
          valg:=valg*vmul[vpos]
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=if(vres<2,0,11-vres)
      vbase2:=left(base,10)+str(vdig1,1,0)
      ok    :=(vbase2==origem)
   elseif puf=="MS"
      mascara:="999999999"
      base   :=padr(origem,9,"0")
      if left(base,2)=="28"
         vsom:=0
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*(10-vpos)
             vsom+=valg
         next
         vres  :=vsom%11
         vdig1 :=str(if(vres<2,0,11-vres),1,0)
         vbase2:=left(base,8)+vdig1
         ok    :=(vbase2==origem)
      endif
   elseif puf=="MG"
      mascara:="999,999,999/9999"
      base   :=padr(origem,13,"0")
      vbase2 :=left(base,3)+"0"+substr(base,4,8)
      n      :=2
      vsom   :=""
      for vpos:=1 to 12
          valg:=val(substr(vbase2,vpos,1))
          n   :=if(n==2,1,2)
          valg:=alltrim(str(valg*n,2,0))
          vsom+=valg
      next
      n     :=0
      for vpos:=1 to len(vsom);n+=val(substr(vsom,vpos,1));next
      vsom  :=n
      do while right(str(n,3,0),1)<>"0";n++;enddo
      vdig1 :=str(n-vsom,1,0)
      vbase2:=left(base,11)+vdig1
      vsom  :=0
      vmul  :={3,2,11,10,9,8,7,6,5,4,3,2}
      for vpos:=1 to 12
          valg:=val(substr(vbase2,vpos,1))
          valg:=valg*vmul[vpos]
          vsom+=valg
      next
      vres  :=vsom%11
      vdig2 :=if(vres<2,0,11-vres)
      vbase2+=str(vdig2,1,0)
      ok    :=(vbase2==origem)
   elseif puf=="PA"
      mascara:="99-999999-9"
      base   :=padr(origem,9,"0")
      if left(base,2)=="15"
         vsom:=0
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*(10-vpos)
             vsom+=valg
         next
         vres  :=vsom%11
         vdig1 :=str(if(vres<2,0,11-vres),1,0)
         vbase2:=left(base,8)+vdig1
         ok    :=(vbase2==origem)
      endif
   elseif puf=="PB"
      mascara:="99,999,999-9"
      base   :=padr(origem,9,"0")
      vsom   :=0
      for vpos:=1 to 8
          valg:=val(substr(base,vpos,1))
          valg:=valg*(10-vpos)
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=11-vres
      if vdig1>9;vdig1:=0;endif
      vbase2:=left(base,8)+str(vdig1,1,0)
      ok    :=(vbase2==origem)
   elseif puf=="PE"
      mascara:="99,9,999,9999999-9"
      base   :=padr(origem,14,"0")
      vsom   :=0
      vmul   :={5,4,3,2,1,9,8,7,6,5,4,3,2}
      for vpos:=1 to 13
          valg:=val(substr(base,vpos,1))
          valg:=valg*vmul[vpos]
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=11-vres
      if(vdig1>9,vdig1-=10,)
      vbase2:=left(base,13)+str(vdig1,1,0)
      ok    :=(vbase2==origem)
   elseif puf=="PI"
      mascara:="999999999"
      base   :=padr(origem,9,"0")
      vsom   :=0
      for vpos:=1 to 8
          valg:=val(substr(base,vpos,1))
          valg:=valg*(10-vpos)
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=str(if(vres<2,0,11-vres),1,0)
      vbase2:=left(base,8)+vdig1
      ok    :=(vbase2==origem)
   elseif puf=="PR"
      mascara:="999,99999-99"
      base   :=padr(origem,10,"0")
      vsom   :=0
      vmul   :={3,2,7,6,5,4,3,2}
      for vpos:=1 to 8
          valg:=val(substr(base,vpos,1))
          valg:=valg*vmul[vpos]
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=str(if(vres<2,0,11-vres),1,0)
      vbase2:=left(base,8)+vdig1
      vsom  :=0
      vmul  :={4,3,2,7,6,5,4,3,2}
      for vpos:=1 to 9
          valg:=val(substr(vbase2,vpos,1))
          valg:=valg*vmul[vpos]
          vsom+=valg
      next
      vres  :=vsom%11
      vdig2 :=str(if(vres<2,0,11-vres),1,0)
      vbase2+=vdig2
      ok    :=(vbase2==origem)
   elseif puf=="RJ"
      mascara:="99,999,99-9"
      base   :=padr(origem,8,"0")
      vsom   :=0
      vmul   :={2,7,6,5,4,3,2}
      for vpos:=1 to 7
          valg:=val(substr(base,vpos,1))
          valg:=valg*vmul[vpos]
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=str(if(vres<2,0,11-vres),1,0)
      vbase2:=left(base,7)+vdig1
      ok    :=(vbase2==origem)
   elseif puf=="RN"
      mascara:="99,999,999-9"
      base   :=padr(origem,9,"0")
      if left(base,2)=="20"
         vsom:=0
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*(10-vpos)
             vsom+=valg
         next
         vpro  :=vsom*10
         vres  :=vpro%11
         vdig1 :=str(if(vres>9,0,vres),1,0)
         vbase2:=left(base,8)+vdig1
         ok    :=(vbase2==origem)
      endif
   elseif puf=="RO"
      mascara:="999999999"
      base   :=padr(origem,9,"0")
      vbase2 :=substr(base,4,5)
      vsom   :=0
      for vpos:=1 to 5
          valg:=val(substr(vbase2,vpos,1))
          valg:=valg*(7-vpos)
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=11-vres
      if vdig1>9;vdig1-=10;endif
      vbase2:=left(base,8)+str(vdig1,1,0)
      ok    :=(vbase2==origem)
   elseif puf=="RR"
      mascara:="99999999-9"
      base   :=padr(origem,9,"0")
      if left(base,2)=="24"
         vsom:=0
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*vpos
             vsom+=valg
         next
         vres  :=vsom%9
         vdig1 :=str(vres,1,0)
         vbase2:=left(base,8)+vdig1
         ok    :=(vbase2==origem)
      endif
   elseif puf=="RS"
      mascara:="999/999999-9"
      base   :=padr(origem,10,"0")
      n      :=val(left(base,3))
      if n>0 .and. n<468
         vsom:=0
         vmul:={2,9,8,7,6,5,4,3,2}
         for vpos:=1 to 9
             valg:=val(substr(base,vpos,1))
             valg:=valg*vmul[vpos]
             vsom+=valg
         next
         vres  :=vsom%11
         vdig1 :=11-vres
         if vdig1>9;vdig1:=0;endif
         vbase2:=left(base,9)+str(vdig1,1,0)
         ok    :=(vbase2==origem)
      endif
   elseif puf=="SC"
      mascara:="999,999,999"
      base   :=padr(origem,9,"0")
      vsom   :=0
      for vpos:=1 to 8
          valg:=val(substr(base,vpos,1))
          valg:=valg*(10-vpos)
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=if(vres<2,"0",str(11-vres,1,0))
      vbase2:=left(base,8)+vdig1
      ok    :=(vbase2==origem)
   elseif puf=="SE"
      mascara:="99999999-9"
      base   :=padr(origem,9,"0")
      vsom   :=0
      for vpos:=1 to 8
          valg:=val(substr(base,vpos,1))
          valg:=valg*(10-vpos)
          vsom+=valg
      next
      vres  :=vsom%11
      vdig1 :=11-vres
      if vdig1>9;vdig1:=0;endif
      vbase2:=left(base,8)+str(vdig1,1,0)
      ok    :=(vbase2==origem)
   elseif puf=="SP"
      if left(base,1)=="P"
         mascara:="P-99999999,9/999"
         base   :=padr(origem,13,"0")
         vbase2 :=substr(base,2,8)
         vsom   :=0
         vmul   :={1,3,4,5,6,7,8,10}
         for vpos:=1 to 8
             valg:=val(substr(vbase2,vpos,1))
             valg:=valg*vmul[vpos]
             vsom+=valg
         next
         vres  :=vsom%11
         vdig1 :=right(str(vres,2,0),1)
         vbase2:=left(base,9)+vdig1+substr(base,11,3)
      else
         mascara:="999,999,999,999"
         base   :=padr(origem,12,"0")
         vsom   :=0
         vmul   :={1,3,4,5,6,7,8,10}
         for vpos:=1 to 8
             valg:=val(substr(base,vpos,1))
             valg:=valg*vmul[vpos]
             vsom+=valg
         next
         vres  :=vsom%11
         vdig1 :=right(str(vres,2,0),1)
         vbase2:=left(base,8)+vdig1+substr(base,10,2)
         vsom  :=0
         vmul  :={3,2,10,9,8,7,6,5,4,3,2}
         for vpos:=1 to 11
             valg:=val(substr(vbase2,vpos,1))
             valg:=valg*vmul[vpos]
             vsom+=valg
         next
         vres  :=vsom%11
         vdig2 :=right(str(vres,2,0),1)
         vbase2+=vdig2
      endif
      ok:=(vbase2==origem)
   elseif puf=="TO"
      mascara:="99,99,999999-9"
      base   :=padr(origem,11,"0")
      if substr(base,3,2)$"01,02,03,99"
         vbase2:=left(base,2)+substr(base,5,6)
         vsom  :=0
         for vpos:=1 to 8
             valg:=val(substr(vbase2,vpos,1))
             valg:=valg*(10-vpos)
             vsom+=valg
         next
         vres  :=vsom%11
         vdig1 :=str(if(vres<2,0,11-vres),1,0)
         vbase2:=left(base,10)+vdig1
         ok    :=(vbase2==origem)
      endif
   else
      alert("Unidade Federal Invalida !")
   endif
   if !ok
      if empty(vbase2)
         alert("Os D¡gitos Identificadores de Cidade e/ou Estado N„o Conferem !")
      else
         vbase2:=strtran(transform(val(vbase2),mascara)," ","0")
         vbase2:=strtran(vbase2,",",".")
         alert("Inscri‡„o Inv lida !;O Correto Seria;"+vbase2)
      endif
      RETURN .F.
   ELSE
      RETURN .T.
   endif

Mensagem por **Dudu_XBase** » 15 Set 2004 23:44

...eu sei qm eh o pai da criança vou falar pro amigo Elcio (Toya) se ele pode dar um pulo aki e averiguar...mas eu testei aki...ta estranho msm...

Mensagem por **Maligno** » 16 Set 2004 00:07

JMARCELO escreveu:gostaria da ajuda de voces neste caso

Com relação a Rondônia, você está usando a legislação antiga. No site do SINTEGRA consta a informação: a partir de Agosto/2000 as inscrições de Rondônia foram alteradas de 9 para 14 dígitos. O cálculo não mudou com a legislação.
No caso de Santa Catarina o cálculo está correto até o ponto em que se calcula vbase2. Ao incluir sua mensagem apareceu uma carinha que não me deixou entender o conteúdo desta linha. O erro deve estar aí.

Esse código que você diz que conseguiu na Net tem uma série de defeitos. Além de não ser exatamente um primor de codificação. Eis o que notei:

Porquê em quase todo teste tem um PadR() no número, antes do cálculo? Uma função de teste não deve ajustar o alvo do teste. Deve simplesmente testá-lo "in natura". Qualquer ajuste deve ser feito ANTES, ou pela função que chama o teste ou alguma outra função criada especificamente para este fim. Mas, se fosse o caso da função de teste ajustar o alvo, você teria de usar PadL() e não PadR(). Os zeros entram à esquerda do número e não à direita. Ou seja, além de não precisar fazer, ainda está sendo feito errado.
Quer ir mais longe no pensamento? A inscrição de Rondônia realmente está certa. Vamos supor que o usuário tenha digitado apenas 1232347. É um número inválido, mas sua função de teste, já corrijida, o ajustaria para 00000001232347, o que está correto. O usuário não terá problema e o número será gravado. Num documento fiscal, por exemplo. Imagine que com a inclusão de um documento de entrada você esteja obrigado a informar isso ao SINTEGRA. Você gravou o que o usuário digitou, ou seja, 1232347. Você informa o SINTEGRA e o que dá? Erro! Ele invalidará seu arquivo informando que esta é uma inscrição inválida. "Como pode ser inválida?" você pergunta. "Minha função de teste validou!". Validou depois do ajuste que só repercute dentro do teste. Exatamente por isso que você precisa incluir os zeros à esquerda ANTES do teste, para que ele seja GRAVADO na sua forma correta. Conseguiu entender o perigo de se atribuir à uma função mais tarefa do que ela deve fazer?

Outra coisa que atrapalha bastante a leitura do código é o acúmulo de IFs de linha única. Não há necessidade disso. Você não ganhará agilidade. Eu sei que não foi você que escreveu a função, mas é certo que sua facilidade de leitura também será prejudicada.
Aliás, ajudaria bastante, da próxima vez, ao postar alguma outra mensagem que contém código, se você o inserisse entre os delimitadores de código, para que os espaços que o precedem não sejam suprimidos. É fácil. Inclua seu código entre o par de delimitadores code e /code, entre colchetes. Se tivesse isso eu conseguiria ver o código completo do cálculo da IE de Santa Catarina.

Outra coisa que parece ser um vício para muita gente: função que testa não deve emitir qualquer alerta sobre o resultado do teste. Ela só deve testar. Qualquer sinalização de erro deve partir da função que chama a função de teste. Inserindo alertas na função de teste você mata a solidez e aumenta sua fragilidade e dependência de código externo (e estranho) a ela. Toda função, à (possível) exceção de funções de alto nível, deve ser única com relação à tarefa que executa. Esse tipo de pensamento vai ajudá-lo a desenvolver programas muito mais sólidos e isentos de erros.

Aceite minhas críticas como uma forma de contribuição para o seu desenvolvimento como programador. É claro que eu poderia extender ainda mais a discussão, até porquê o assunto é de fato extenso. Mas eu já fui muito além do escopo desta thread. E só fiz isso porquê fico sentido em ver alguém sofrendo à toa, com coisa pequena, que nem deveria existir.
Acho o desenvolvimento de software a melhor coisa do mundo. É algo extremamente prazeiroso. Imagino que você também goste. Mas esse trabalho poderia ser muito mais prazeiroso se algumas poucas regras da boa prática de programação fossem seguidas. Infelizmente, é comum que muitos programadores "queimem" certas etapas no seu aprendizado, justamente no afã de meter logo a "mão na massa" e fazer aquilo que mais gostam. Não é uma boa idéia. Programação de verdade se aprende, primeiro, longe do computador. É claro que cada um tem seus motivos pessoais para "queimar" essas etapas e passar adiante. Mas já vi muita gente que faz isso apenas por ansiedade. Muitos daqui deste fórum, inclusive. É pena. Não precisaria ser assim. Nem deveria. Até porquê a qualidade final de um software vai depender profundamente da solidez do conhecimento do programador.

[]'s
Maligno
http://www.buzinello.com/prg

Clash · Mensagem por **Clash** » 16 Set 2004 20:27

Olá galera!

Concordo com vc Maligno, quanto sua preocupação na qualidade da programação, é o que tentamos todos os dias. Eu tb usei uma função pra testar o IE obtida na Net. Tive que fazer vários ajustes, a sorte foi o cliente ter a paciência de testar com vários estados até então ajustarmos alguns, exatamente por nova legislação. Mas após isso a função tem funcionado corretamente, e o preenchimento, não sei com esta, mas com a que estou usando ela insere o caracteres em suas posições corretas e isso é passado para Get ocorrendo a gravação correta no DBF.

[ ]s
Clash

Mensagem por **rochinha** » 23 Fev 2007 14:30

Código: Selecionar todos

/*
* Baixado de: www.caclipper.cjb.net
* Enviado por: Carlos Eduardo Brock - Email: brock_carlos@yahoo.com.br

#include "inkey.ch"
Cls
aIePict :={ {"AC", "@R 99.999.999/999-99"},;
            {"AL", "@R 999999999"},;
            {"AM", "@R 99.999.999-9"},;
            {"AP", "@R 999999999"},;
            {"BA", "@R 999999-99"},;
            {"DF", "@R 99.999999.999-99"},;
            {"CE", "@R 99999999-9"},;
            {"ES", "@R 999999999"},;
            {"GO", "@R 99.999.999-9"},;
            {"MA", "@R 999999999"},;
            {"MG", "@R 999.999.999/9999"},;
            {"MS", "@R 99999999-9"},;
            {"MT", "@R 9999999999-9"},;
            {"PA", "@R 99-999999-9"},;
            {"PB", "@R 99999999-9"},;
            {"PE", "@R 99.9.999.9999999-9"},;
            {"PI", "@R 999999999"},;
            {"PR", "@R 999.99999-99"},;
            {"RJ", "@R 99.999.99-9"},;
            {"RN", "@R 99.999.999-9"},;
            {"RO", "@R 999.99999-9"},;
            {"RR", "@R 99.999.999-9"},;
            {"RS", "@R 999/9999999"},;
            {"SC", "@R 999.999.999"},;
            {"SE", "@R 99999999-9"},;
            {"SP", "@R 999.999.999.999"},;
            {"TO", "@R 99.99.999999-9"} }
cIe := "                  "
cUF := "  "
Do while LastKey() <> K_ESC
   @ 09, 10 Say "Uf  :" Get cUF Picture "@!" Valid AScan( aIePict, {|nI| cUf == nI[ 1 ]} ) <> 0
   Read
   @ 10, 10 Say "I.E.:" Get cIe Picture aIePict[ AScan( aIePict, {|nI| cUf == nI[ 1 ]} ) ][ 2 ]
   Read
   @ 11, 10 Say "I.E.: " + Transform( cIe, aIePict[ AScan( aIePict, {|nI| cUf == nI[ 1 ]} ) ][ 2 ] ) +;
                " - Esta: " + If ( TestaIe( cIe, cUF ), "Certa", "Errada" )
EndDo
*/
/******************************************************************************
* Essa funcao foi feita co base nos dados fornecidos pelo site do Sintegra    *
* http://www.sintegra.gov.br/insc_est.html, calculos e teste foram feitos     *
* apenas com as IEs encontradas como exemplo em 24/04/2003.                   *
* Apesar de alguns estados terem os mesmos peso para a multiplicacao, e o     *
* mesmo roteiro critico achei melhor gerar um codigo especifico para cada     *
* estado, prevendo um possivel mudanca no roteiro                             *
* No caso de alguem fazer alguma melhoria, ou correcao nesta funcao peco por  *
* favor envie uma copia cada um desses e-mails:                               *
* <brock_carlos@yahoo.com.br>, <cal@materiavirtual.com.br>                    *
******************************************************************************/
Function TestaIe( cIe1, cUF )
Local nI, nX, cTemp := "", nT2, nMod := 11
local cIe2 := "", nSoma := 0, cProd := "", aUF
Local nD1, nD2
Local aP1, aP2, nPt
Private nACt, nALt, nAMt, nAPt, nBAt, nCEt, nDFt, nESt, nGOt
Private nMAt, nMGt, nMSt, nMTt, nPAt, nPBt, nPEt, nPIt, nPRt
Private nROt, nRRt, nRSt, nSEt, nSCt, nSPt, nTOt, nRJt, nRNt
Private aAC1, aAL1, aAM1, aAP1, aBA1, aCE1, aDF1, aES1, aGO1
Private aMA1, aMG1, aMS1, aMT1, aPA1, aPB1, aPI1, aPE1, aPR1
Private aRJ1, aRN1, aRO1, aRR1, aRS1, aSE1, aSC1, aSP1, aTO1
aUf:= { "AC", "AL", "AM", "AP", "BA", "CE", "DF", "ES", "GO", "MA", "MG", "MS",;
        "MT", "PA", "PB", "PE", "PI", "PR", "RJ", "RN", "RO", "RR", "RS",  "SC",;
        "SE", "SP","TO", }
cUf := Upper( cUf )
If AScan( aUf, {|nI| cUf == nI} ) == 0
   Return( .F. )
EndiF
// Tamanho da IE
nACt := 13; nALt := 09; nAMt := 09; nAPt := 09; nBAt := 08; nCEt := 09
nDFt := 13; nESt := 09; nGOt := 09; nMAt := 09; nMGt := 13; nMSt := 09
nMTt := 11; nPAt := 09; nPBt := 09; nPEt := 14; nPIt := 09; nPRt := 10
nRJt := 08; nRNt := 09; nROt := 09; nRRt := 09; nRSt := 10; nSEt := 09
nSCt := 09; nSPt := 12; nTOt := 11
// Pesos da multiplicao para IE 
aAC1 := { { 04, 03, 02, 09, 08, 07, 06, 05, 04, 03, 02 },;
          { 05, 04, 03, 02, 09, 08, 07, 06, 05, 04, 03, 02 } }
aAL1 := { { 02, 03, 04, 05, 06, 07, 08, 09 }, }
aAM1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aAP1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aBA1 := { { 07, 06, 05, 04, 03, 02}, { 08, 07, 06, 05, 04, 03, 02 } }
aCE1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aDF1 := { { 04, 03, 02, 09, 08, 07, 06, 05, 04, 03, 02 },;
          { 05, 04, 03, 02, 09, 08, 07, 06, 05, 04, 03, 02 } }
aES1 := { { 09, 09, 09, 09, 09, 09, 09, 09, 09 }, }
aGO1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aMA1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aMG1 := { { 01, 02, 01, 02, 01, 02, 01, 02, 01, 02, 01, 02 },;
          { 03, 02, 11, 10, 09, 08, 07, 06, 05, 04, 03, 02 } }
aMS1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aMT1 := { { 03, 02, 09, 08, 07, 06, 05, 04, 03, 02 }, }
aPA1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aPB1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aPI1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aPE1 := { { 05, 04, 03, 02, 01, 09, 08, 07, 06, 05, 04, 03, 02 }, }
aPR1 := { { 03, 02, 07, 06, 05, 04, 03, 02 },;
          { 04, 03, 02, 07, 06, 05, 04, 03, 02 } }
aRJ1 := { { 02, 07, 06, 05, 04, 03, 02 }, {  } }
aRN1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aRO1 := { { 06, 05, 04, 03, 02 }, }
aRR1 := { { 01, 02, 03, 04, 05, 06, 07, 08 }, }
aRS1 := { { 02, 09, 08, 07, 06, 05, 04, 03, 02 }, {  } }
aSE1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aSC1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }
aSP1 := { { 01, 03, 04, 05, 06, 07, 08, 10 },;
          { 03, 02, 10, 09, 08, 07, 06, 05, 04, 03, 02 } }
aTO1 := { { 09, 08, 07, 06, 05, 04, 03, 02 }, }

aP1 := &("a"+cUF+"1")[1]
aP2 := &("a"+cUF+"1")[2]
nPt := &("n"+cUF+"t")
For nI := 1 To Len(cIe1)
    cTemp += If( SubStr( cIe1, nI, 1 ) $ "0123456789", SubStr( cIe1, nI, 1 ), "" )
Next
cIe1  := cTemp
If Len( cIE1 ) <> nPt
   Return .F.
EndIf
// A partir de alguns pontos já da pra fazer a validacao das IEs, mas sao + 3 linhas de codigo q quer queira, quer nao, vao gerar mais simblolos dentro do obj, entao achei melhor terminar o calculo 

Do Case
   Case cUF == "AC"
        cIe2 := SubStr( cIe1, 1, 11 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1 := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Ltrim( Str( Int( nD1 ) ) )
        nSoma := 0
        AEval( aP2, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD2 := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Ltrim( Str( Int( nD2 ) ) )
   Case cUF == "AL"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := Mod( nSoma, nMod )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "AP"
        Do Case
           Case cIe1 >= "03000001" .and. cIe1 <= "03017000"
                nSoma := 5; nT2 := 0
           Case cIe1 >= "03017001" .and. cIe1 <= "03019022"
                nSoma := 9; nT1 := 1
           Case cIe1 >= "03019023"
                nSoma := 0; nT2 := 0
        EndCase
        If Substr(cIe1, 1, 2) <> "03"
           Return(.F.)
        EndIf
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := nMod - Mod( nSoma, nMod )
        nD1  := If( nD1 == 10, 0, nD1)
        nD1  := If( nD1 == nMod, nT2, nD1)
        cIe2 += AllTrim( Str( Int( nD1 ) ) )
   Case cUF == "AM"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1 := If( nSoma < nMod, nMod - nSoma,;
                  If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) ) )
        cIe2 += AllTrim( Str( Int( nD1 ) ) )
   Case cUF == "BA" // tem q ser baiano pra ser do contra, eles calculan o 2 dig prim, e usam pro 1 dig
        nMod := If( SubStr( cIe1, 1, 1 ) $ "0123458", 10, 11 )
        cIe2 := SubStr( cIe1, 1, 6 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD2 := If(nMod == 10, nMod - Mod( nSoma, nMod ),;
                  If( nMod - Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) ) )
        cIe2 += AllTrim( Str( Int( nD2 ) ) )
        nSoma := 0
        AEval( aP2, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1 := If(nMod == 10, nMod - Mod( nSoma, nMod ),;
                  If( nMod - Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) ) )
        cIe2 := SubStr( cIe1, 1, 6 ) + AllTrim( Str( Int( nD1 ) ) ) + AllTrim( Str( Int( nD2 ) ) )
   Case cUF == "DF"
        cIe2 := SubStr( cIe1, 1, 11 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := nMod - Mod( nSoma, nMod )
        nD1  := If( nD1 >= 10, 0, nD1 )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
        nSoma := 0
        AEval( aP2, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD2  := nMod - Mod( nSoma, nMod )
        nD2  := If( nD2 >= 10, 0, nD2 )
        cIe2 += Right( Str( Int( nD2 ) ), 1 )
   Case cUF == "CE"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1 := nMod - Mod( nSoma, nMod )
        nD1 := If( nD1 >= 10, 0, nD1 )
        cIe2 += AllTrim( Str( Int( nD1 ) ) )
   Case cUF == "ES"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "GO"  // Essa foi a mais anormal de todas
        nD2 := Val( Right( cIe1, 1 ) )
        cIe2 := SubStr( cIe1, 1, 2 )
        If cIE2 == "10" .OR. cIE2 == "11" .OR. cIE2 == "15" 
           cIe2 := SubStr( cIe1, 1, 8 )
           If cIe1 == "110944020" .OR. cIe1 == "110944021"
              cIe2 := cIe1
            Else
              AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
              Do Case
                 Case Mod( nSoma, nMod ) == 0
                      nD1 := 0
                 Case Mod( nSoma, nMod ) == 1 .AND. cIE2 >= "10103105" .AND. cIE2 <= "10119997"
                      nD1 := 1
                 Case Mod( nSoma, nMod ) == 1 .AND. cIE2 < "10103105" .AND. cIE2 > "10119997"
                      nD1 := 0
                 Case Mod( nSoma, nMod ) > 1
                      nD1 := nMod - Mod( nSoma, nMod )
              EndCase
              cIe2 += Right( Str( Int( nD1 ) ), 1 )
           EndIf
        EndIf
   Case cUF == "MA"
        If Left( cIe1, 2 ) == "12"
           cIe2 := SubStr( cIe1, 1, 8 )
           AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
           nD1 := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
           cIe2 += AllTrim( Str( Int( nD1 ) ) )
        EndIf
   Case cUF == "MG"
        cIe2 := SubStr( cIe1, 1, 3 ) + "0" + Substr( cIe1, 4, 8 ) //0 inutil, 0*2 = 0, pq? 4o. peso.
        AEval( aP1, { |nI, nX| cProd += LTrim( Str( Int( Val( SubStr( cIe2, nX, 1) ) * nI ) ) ) } )
        For nI := 1 to Len( cProd )
            nSoma += Val( SubStr( cProd, nI, 1 ) )
        Next
        cProd := StrZero( nSoma, 3 )
        nD1   := ( Val( SubStr( CProd, 2, 1 ) + "0" ) + 10 ) 
        nD1   -= nSoma
        cIe2  := SubStr( cIe1, 1, 11 ) + Right( Str( Int( nD1 ) ), 1 )
        nSoma := 0
        AEval( aP2, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD2  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD2 ) ), 1 )
   Case cUF == "MS"
        cIe2 := SubStr( cIe1, 1, 08 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1 := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) ) //isso é a mesma coisa do site
        cIe2 += LTrim( Str( Int( nD1 ) ) )
   Case cUF == "MT"
        cIe2 := SubStr( cIe1, 1, 10 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1 := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += LTrim( Str( Int( nD1 ) ) )
   Case cUF == "PA"
        If Left(cIe1, 2) == "15"
           cIe2 := SubStr( cIe1, 1, 8 )
           AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
           nD1 := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
           cIe2 := SubStr( cIe1, 1, 8) + AllTrim( Str( Int( nD1 ) ) )
        EndIf
   Case cUF == "PB"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "PE"
        cIe2 := SubStr( cIe1, 1, 13 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "PI"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += AllTrim( Str( Int( nD1 ) ) )
   Case cUF == "PR"
        cIE2 := SubStr( cIe1, 1, Len( cIe1 ) - 2 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1   := nMod - Mod( nSoma, nMod )
        nD1   := If( nD1 == 10, 0, nD1 )
        cIe2  += AllTrim( Str( Int( nD1 ) ) )
        nSoma := 0
        AEval( aP2,{ |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD2  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "RJ"
        cIe2 := SubStr( cIe1, 1, 7 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "RN"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "RO"
        cIe2 := SubStr( cIe1, 4, 5 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1 := If( Mod( nSoma, nMod )>= 10, 10, 11 ) - Mod( nSoma, nMod )
        cIe2 := SubStr( cIe1, 1, 8) + AllTrim( Str( Int( nD1 ) ) )
   Case cUF == "RR"
        If Substr( cIe1, 1 , 2 ) == "24"
           nMod := 9
           cIe2 := SubStr( cIe1, 1, 8 )
           AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
           nD1  := Mod( nSoma, nMod )
           cIe2 += Right( Str( Int( nD1 ) ), 1 )
        EndIf
   Case cUF == "RS"
        cIe2 := SubStr( cIe1, 1, 9 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "SC"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "SE"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 += Right( Str( Int( nD1 ) ), 1 )
   Case cUF == "SP"
        cIe2 := SubStr( cIe1, 1, 8 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := Mod( nSoma, nMod )
        cIe2 += Right( Str( Int( nD1 ) ), 1 ) + SubStr( cIe1, 10, 2 )
        nSoma := 0
        AEval( aP2, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD2 := If( Mod( nSoma, nMod )>= 10, 10, 11 ) - Mod( nSoma, nMod )
        cIe2 += Right( Str( Int( nD2 ) ), 1 )
   Case cUF == "TO"
        altd()
        cIe2 := SubStr( cIe1, 1, 2 ) + SubStr( cIe1, 5, 6 )
        AEval( aP1, { |nI, nX| nSoma += Val( SubStr( cIe2, nX, 1) ) * nI } )
        nD1  := If( Mod( nSoma, nMod ) <= 1, 0, nMod - Mod( nSoma, nMod ) )
        cIe2 := SubStr( cIe1, 1, 10 ) + Right( Str( Int( nD1 ) ), 1 )
   Otherwise
        Return .F.
EndCase
Return( cIe1 == cIe2 )

Mensagem por **Maligno** » 08 Ago 2007 16:37

Atendo pedido de um colega, seguem as funções para validação das Inscrições Estaduais de todos os Estados e do DF. A função Modulo11() é um complemento necessário a alguns cálculos. O nome de cada função é formado pela string ValidIE_??(), sendo as interrogações substituídas pela sigla do Estado ou DF.

Código: Selecionar todos

//************************************************************
// Módulo 11, com pesos nPeso1 (inicial) a nPeso2 (final), que
// serão utilizados no multiplicador dos dígitos, apanhados da
// direita para a esquerda. Tal multiplicador será reciclado e
// voltará para nPeso1, quando o limite (nPeso2) for atingido.
//************************************************************
function Modulo11(cStr,nPeso1,nPeso2) 
local nTot := 0                       
local nMul := nPeso1                  
local i                               
*
for i := Len(cStr) to 1 step -1
    nTot += Val(SubStr(cStr,i,1)) * nMul
    nMul := if(nMul=nPeso2, nPeso1, nMul+1)
next
return if(nTot%11 < 2, "0", Str(11-(nTot%11),1))


//************************************************************
static function ValidIE_AC(cIE)
return SubStr(cIE, 1,2) = "01"                       .and.;
       SubStr(cIE,12,1) = Modulo11(Left(cIE,11),2,9) .and.;
       SubStr(cIE,13,1) = Modulo11(Left(cIE,12),2,9)


//************************************************************
static function ValidIE_AL(cIE)
return SubStr(cIE,1,2) = "24"                        .and.;
       SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_AM(cIE)
return SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_AP(cIE)
local nTot
local cDVe
local i
*
if !Left(cIE,2) = "03"
   return .F.
end
*
if(cIE <= "03017000", (nTot := 5 , cDVe := "0"),;
if(cIE <= "03019022", (nTot := 9 , cDVe := "1"),;
                      (nTot := 0 , cDVe := "0") ))
for i := 1 to 8
    nTot += Val(SubStr(cIE,i,1)) * (10-i)
next
return SubStr(cIE,9,1) == if(nTot%11=0, "0",;
                          if(nTot%11=1, cDVe, Str(11-(nTot%11),1)))


//************************************************************
static function ValidIE_BA(cIE)
local cStr := Left(cIE,6)
local nMod := if(Left(cIE,1) $ "679", 11, 10)
local nTot := 0
local i,k
*
for i := 1 to 2
    for k := Len(cStr) to 1 step -1
        nTot += Val(SubStr(cStr,k,1)) * ((7+i)-k)
    next
    cStr += if(nTot%nMod < nMod-9, "0", Str(nMod-(nTot%nMod),1))
    nTot := 0
next
return SubStr(cStr,8,1)+SubStr(cStr,7,1) == SubStr(cIE,7,2)


//************************************************************
static function ValidIE_CE(cIE)
return SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_DF(cIE)
local cStr := Left(cIE,11)
local nTot := 0
local nMul
local i,k
*
for i := 1 to 2
    nMul := 2
    for k := Len(cStr) to 1 step -1
        nTot += Val(SubStr(cStr,k,1)) * nMul
        nMul := if(nMul=9, 2, nMul+1)
    next
    cStr += if(nTot%11 < 2, "0", Str(11-(nTot%11),1))
    nTot := 0
next
return Right(cStr,2) == SubStr(cIE,12,2)


//************************************************************
static function ValidIE_ES(cIE)
return SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_GO(cIE)
local nTot := 0
local nMul := 2
*
if !Left(cIE,2) $ "10.11.15"
   return .F.
end
for i := 8 to 1 step -1
    nTot += Val(SubStr(cIE,i,1)) * nMul
    nMul := if(nMul=9, 2, nMul+1)
next
if (nTot := nTot%11) < 2
    nTot := if(nTot=0, 0, if(Left(cIE,8)="11094402", 1,;
                          if(Left(cIE,8)<"10103105" .or. Left(cIE,8)>"10119997", 0, 1)))
else
    nTot := 11-nTot
end
return Str(nTot,1) = Right(cIE,1)


//************************************************************
static function ValidIE_MA(cIE)
return SubStr(cIE,1,2) = "12"                     .and.;
       SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_MG(cIE)
local cStr := Stuff(cIE,4,0,"0")
local nTot := 0
local nSub
local i
*
for i := 1 to 12
    nSub := Val(SubStr(cStr,i,1))*if(i%2=0,2,1)
    nTot += if(nSub>9, Int(nSub/10)+(nSub%10), nSub)
next
cStr := Left(cIE,11) + if(nTot%10=0, "0", Str(((Int(nTot/10)+1)*10)-nTot,1))
cStr += Modulo11(cStr,2,11)
*
return Right(cStr,2) == SubStr(cIE,12,2)


//************************************************************
static function ValidIE_MS(cIE)
return SubStr(cIE,1,2) = "28"                     .and.;
       SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_MT(cIE)
return SubStr(cIE,11,1) = Modulo11(Left(cIE,10),2,9)


//************************************************************
static function ValidIE_PA(cIE)
return SubStr(cIE,1,2) = "15"                      .and.;
       SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_PB(cIE)
return SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_PE(cIE)
local nTot := 0
local nMul := 2
local i
*
for i := 13 to 1 step -1
    nTot += Val(SubStr(cIE,i,1)) * nMul
    nMul := if(nMul=9, 1, nMul+1)
next
nTot := 11-(nTot%11)
return SubStr(cIE,14,1) = Str(if(nTot>9, nTot-10, nTot),1)


//************************************************************
static function ValidIE_PI(cIE)
return SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_PR(cIE)
local cDVs := SubStr(cIE,9,2)
*
cIE := Left(cIE,8)
cIE += Modulo11(cIE,2,7)
cIE += Modulo11(cIE,2,7)
return cDVs = Right(cIE,2)


//************************************************************
static function ValidIE_RJ(cIE)
return SubStr(cIE,8,1) = Modulo11(Left(cIE,7),2,7)


//************************************************************
static function ValidIE_RN(cIE)
local cStr := Left(cIE,8)
local nTot := 0
local nMul := 2
local i
*
for i := Len(cStr) to 1 step -1
    nTot += Val(SubStr(cStr,i,1)) * nMul
    nMul := if(nMul=9, 2, nMul+1)
next
nTot := (nTot*10)%11
return SubStr(cIE,9,1) = Str(if(nTot=10, "0", nTot),1)



//************************************************************
static function ValidIE_RO(cIE)
local cStr := Left(cIE,13)
local nTot := 0
local nMul := 2
local i
*
// Fórmula adotada a partir de 01/08/2000
for i := Len(cStr) to 1 step -1
    nTot += Val(SubStr(cStr,i,1)) * nMul
    nMul := if(nMul=9, 2, nMul+1)
next
nTot := 11-(nTot%11)
return SubStr(cIE,14,1) = Str(if(nTot>9, nTot-10, nTot),1)


//************************************************************
static function ValidIE_RR(cIE)
local cStr := Left(cIE,8)
local nTot := 0
local i
*
for i := 1 to Len(cStr)
    nTot += Val(SubStr(cStr,i,1)) * i
next
return SubStr(cIE,9,1) = Str(nTot%9,1)


//************************************************************
static function ValidIE_RS(cIE)
return SubStr(cIE,10,1) = Modulo11(Left(cIE,9),2,9)


//************************************************************
static function ValidIE_SC(cIE)
return SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_SE(cIE)
return SubStr(cIE,9,1) = Modulo11(Left(cIE,8),2,9)


//************************************************************
static function ValidIE_SP(cIE)
local cStr
local nTot
local nMul
local aMul := {1,3,4,5,6,7,8,10}
local i
*
if Left(cIE,1) = "P"
   cStr := SubStr(cIE,2,8)
   nTot := 0
   for i := 1 to 8
       nTot += Val(SubStr(cStr,i,1)) * aMul[i]
   next
   return SubStr(cIE,10,1) = Right(Str(Int(nTot%11)),1)
else
   cStr := Left(cIE,8)
   nTot := 0
   for i := 1 to 8
       nTot += Val(SubStr(cStr,i,1)) * aMul[i]
   next
   cStr += Right(Str(Int(nTot%11)),1) + SubStr(cIE,10,2)
   *
   nMul := 2
   nTot := 0
   for i := 11 to 1 step -1
       nTot += Val(SubStr(cStr,i,1)) * nMul
       nMul := if(nMul=10, 2, nMul+1)
   next
   return SubStr(cIE,9,4) == SubStr(cStr,9,3)+Right(Str(Int(nTot%11)),1)
end


//************************************************************
static function ValidIE_TO(cIE)
return SubStr(cIE, 1,2) = "29"         .and.; // código do Estado
       SubStr(cIE, 3,2) $ "01.02.03.99".and.; // posições excluídas do cálculo
       SubStr(cIE,11,1) = Modulo11(Left(Stuff(cIE,3,2,""),8),2,9)

Netavin · Mensagem por **Netavin** » 18 Mar 2008 16:50

... para não abrir novo tópico ...

Uso há muito tempo uma função para crítica da Insc.Estadual que acredito seja usada por muitos colegas.
Hoje me deparei com uma inscrição que não bate nem com reza. Poderiam testá-la em vossa função para ver se está certa mesmo

P favor...

É de SP : 707.063.662.118

Código: Selecionar todos

FUNCTION INSC(vcli_ins)
Set Cursor off
    If Empty(vcli_ins)
        Tone(1700,1)
        Alert("Informe a inscrição.")
        Return (.f.)
    Else
        ins1 := val( substr( vcli_ins,  1, 1 ) )
        ins2 := val( substr( vcli_ins,  2, 1 ) )
        ins3 := val( substr( vcli_ins,  3, 1 ) )
        ins4 := val( substr( vcli_ins,  4, 1 ) )
        ins5 := val( substr( vcli_ins,  5, 1 ) )
        ins6 := val( substr( vcli_ins,  6, 1 ) )
        ins7 := val( substr( vcli_ins,  7, 1 ) )
        ins8 := val( substr( vcli_ins,  8, 1 ) )
        ins9 := val( substr( vcli_ins,  9, 1 ) )
        ins10 := val( substr( vcli_ins,  10, 1 ) )
        ins11 := val( substr( vcli_ins,  11, 1 ) )
        ins12 := val( substr( vcli_ins,  12, 1 ) )
        ins13 := val( substr( vcli_ins,  13, 1 ) )
        ins14 := val( substr( vcli_ins,  14, 1 ) )

        // C lculo do Digito //

        inssoma := ins1*6+ins2*5+ins3*4+ins4*3+ins5*2+ins6*9+ins7*8+ins8*7+;
        ins9*6 + ins10*5 + ins11*4 + ins12*3 + ins13*2
        insresto := mod( inssoma, 11 )

        if insresto = 0 .or. insresto = 1
            insdig := 0
        else
            insdig := 11 - insresto
        endif

        if insdig # ins14
            TONE(1700,2);TONE(1700,1)
            alert( "IE Inválida!" )
            Set Cursor on
            return(.f.)
        else
            Set Cursor on
            return(.t.)
        endif
    Endif

    // Segundo Digito //
    inssoma := ins1*3 + ins2*2 + ins3*10 + ins4*9 + ins5*8 + ins6*7 +;
    ins7*6 + ins8*5 + ins9*4 + ins10*3 + ins11*2
    insresto := mod( inssoma, 11 )

    if insresto = 0 .or. insresto = 10
        insdi2 := 0
    else
        insdi2 := insresto
    endif

    if insdi2 # ins12
        TONE(1700,2);TONE(1700,1)
        alert( "IE Inválida!" )
        return(.f.)
    endif

    Set Cursor on
    return(.t.)

Grato!

Neetavin

Mensagem por **Maligno** » 18 Mar 2008 17:00

Não li o código mas essa inscrição de SP deveria ter 12 dígitos. Testei o número num programa meu e validou certinho. Acrescente um 0 à esquerda e tente de novo. A máscara é 9.99999999.9/99.

Aliás, eu publiquei há um bom tempo um conjunto completo de funções de validação de todos os Estados. Clique aqui para ver.

Mensagem por **Maligno** » 31 Jul 2008 19:30

Em tópico mais ou menos antigo (clique aqui para ver), publiquei minhas funções de validação das IEs de todos os Estados e DF, mas esqueci de incluir as máscaras dessas inscrições. Então, como complemento, ei-las:

Código: Selecionar todos

UF    NOME                   MÁSCARA               
----  ---------------------  --------------------  --
"AC", "Acre"               , "99.999.999/999-99" , 13
"AL", "Alagoas"            , "99.9.99999-9"      ,  9
"AM", "Amazonas"           , "99.999.999-9"      ,  9
"AP", "Amapá"              , "99.999.999-9"      ,  9
"BA", "Bahia"              , "999999-99"         ,  8
"CE", "Ceará"              , "99.999.999-9"      ,  9
"DF", "Distrito Federal"   , "99.999999.999-99"  , 13
"ES", "Espírito Santo"     , "99.999.999-9"      ,  9
"GO", "Goiás"              , "99.999.999-9"      ,  9
"MA", "Maranhão"           , "99.999.999-9"      ,  9
"MG", "Minas Gerais"       , "999.999.999/9999"  , 13
"MS", "Mato Grosso do Sul" , "99.999.999-9"      ,  9
"MT", "Mato Grosso"        , "9999999999-9"      , 11
"PA", "Pará"               , "99.999.999-9"      ,  9
"PB", "Paraíba"            , "99.999.999-9"      ,  9
"PE", "Pernambuco"         , "99.9.999.9999999-9", 14
"PI", "Piauí"              , "99.999.999-9"      ,  9
"PR", "Paraná"             , "999.99999-99"      , 10
"RJ", "Rio de Janeiro"     , "99.999.99-9"       ,  8
"RN", "Rio Grande do Norte", "99.999.999-9"      ,  9
"RO", "Rondônia"           , "99999999.99999-9"  , 14
"RR", "Roraima"            , "99.999.999-9"      ,  9
"RS", "Rio Grande do Sul"  , "999/999999-9"      , 10
"SC", "Santa Catarina"     , "999.999.999"       ,  9
"SE", "Sergipe"            , "9.99.999.999-9"    , 10
"SP", "São Paulo"          , "99999999.9/999"    , 12
"TO", "Tocantins"          , "99.99.999999-9"    , 11

A última coluna se refere à quantidade de dígitos (apenas números) de cada inscrição.

Manuel Luis Modernel · Mensagem por **Manuel Luis Modernel** » 31 Jul 2008 19:38

Muitissimo obrigado Maligno !!!

Pablo César · Mensagem por **Pablo César** » 01 Ago 2008 12:06

Nota de Moderação:

Estes três tópicos foram unidos, visto que a principio o colega Rochinha tinha iniciado, no entanto no decorrer de outras postagens foi denunciado que a máscara do estado de SP mostrou-se inconsistente com a do colega Maligno. AO que tudo indica que a máscara de SP do Maligno esteja em maior conformidade. E por tratar-se de assunto similar o de igual conteúdo, fica disponibiizado num tópico só, a fim de facilitar as pesquisas no futuro.

Obs.: Se houverem mais inconsistências, favor comentar neste mesmo tópico, a fim de enriquecer o seu conteúdo.

Iwasa · Mensagem por **Iwasa** » 05 Jun 2009 13:16

Caros colegas, compilei a versão enviada pelo nosso colega rochinha, versão em vetores, e deu erro em cUf=Upper(cUf), não entendi o motivo, pois não havia nada de errado. Compilei com Blinker 7 e clipper 5.3b.
Lembrei que tinha a mesma rotina baixado de algum lugar, não lembro de onde, mas recordo que o de SP, não dava consistência, mesmo sendo um IE legítimo. Pois, vendo a rotina aqui, me interessei e fui a fundo e descobri o bug.
Mas gostaria que todos os colegas testassem, pois, acho muito interessante para aprendizado o uso de vetores e codeblock.
Em anexo nesta mensagem o arquivo, espero ter colaborado de alguma forma :)Pos mesmo parecendo insignificante, acabei aprendendo um bocado com a análise, pois ainda hoje acho um pouco confuso a utilização de codeblock. Mas tenho aprendido bastante com o pessoal do fórum e nesta análise.
ps.: Deixei comentários onde encontrei o bug.

E gostaria também de fazer um comentário sobre o post do nosso colega Pablo, sobre a máscara do nosso colega Maligno:
A mascara de SP apresentada na rotina do colega Maligno (99999999.9/999) é referida como máscara da IE do Produtor Rural de SP e da rotina do nosso colega Rochinha se refere à máscara da IE Comercial/Industrial (999.999.999.999), digitos verificadores na 9a. e 12a. posição, apesar das duas máscaras terem 12 digitos, só fica a questão da estética.

Mas vejo uma inconsistência na máscara do IEP (IE do Produtor Rural), pois como a máscara não permite a inserção da string na primeira posição (letra P), fica então o desafio, pois não sei se há uma maneira de caso a letra P não sendo digitada, fazendo com que pulasse essa string (primeira posição) e passasse direto para a string numérica automaticamente, q no caso geral, a mascara teria os 12 digitos + a letra P na primeira posição, pois pela letra P se distinguiria do IE comericial.
No caso, o IEP somente utiliza o primeiro conjunto de pesos para calcular a 9a. posição 99999999.9/999 (/999) não entra na base de calculo dos digitos verificadores, somente é complemento.

PC Toledo