Valida Inscrição Estadual desenvolvida por Carlos Lages
// Summary: <specify the procedure action>
// Syntax:
//[ <Result> = ] Funcao_Valida_Inscricao_Estadual (<LK_inscricao> is string, <LK_uf> is string)
//
// Parameters:
// LK_inscricao (ANSI string):
// LK_uf (ANSI string): <specify the role of LK_uf>
// Example:
// <Specify a usage example>
//
PROCEDURE Funcao_Valida_Inscricao_Estadual(LK_inscricao is string, LK_uf is string )
//Desevolvido por Dec Sistemas - Carlos Lages
//http://www.sintegra.gov.br/insc_est.html // aqui tem todas as regras dos calculos das insc Estadual
//LK_inscricao = "131300246"
//LK_uf = "BA"
// Esta rotina tem como Objetivo nao ter que usar a DLL do sintegra que e 32 bits e poder usar em qq modulo WINDEV, mob e WEBDEV
// sem precisar de ferramenta de terceiros
// a programacao e simples e foi pensada para nao ser complexa e facil de manutencao
// ela recebe um campo string , tira lixo, preenche com zeros a direita com tamanho maximo de 14
// entao receber exemplo 15.53.65/357# ai fica como 15536535700000
// D1 = 1
// D2 = 5
// ETC
// pela UF chama a rotina de cada UF e dentro da rotina faz umas criticas basicas tipo se tem LEtra, ja da erro
// se numero de Digitos e maior do que o permitido pela UF ja da erro e nem faz a critica
// e obrigatorio preencher na digitacao pelo usuario com os zeros a esquerda para ficar padrao dentro da UF
// e devolve:
// 1 , tipo de erro
// or
// 0, e a inscricao formatada conforme a UF
// ps: no nosso banco de dados a inscricao e salva editada, para que em qq relatorio, NF etc saida editada
ws_inscricao is string = LK_inscricao
ws_inscricao = NoCharacter(ws_inscricao, "'!#$%*();/._-+\<?>,:]}{[=",sscAll) // tira todo que qq caracter, tem que ficar somente numeros
ws_inscricao = NoSpace(ws_inscricao,sscAll) // Tira os espacos
ws_InscricaoEdt is string
D1 is int = 0
D2 is int = 0
D3 is int = 0
D4 is int = 0
D5 is int = 0
D6 is int = 0
D7 is int = 0
D8 is int = 0
D9 is int = 0
D10 is int = 0
D11 is int = 0
D12 is int = 0
D13 is int = 0
D14 is int = 0
Ds1 is string = ""
Ds2 is string = ""
Ds3 is string = ""
Ds4 is string = ""
Ds5 is string = ""
Ds6 is string = ""
Ds7 is string = ""
Ds8 is string = ""
Ds9 is string = ""
Ds10 is string = ""
Ds11 is string = ""
Ds12 is string = ""
Ds13 is string = ""
Ds14 is string = ""
Ws_Digito is array of 14 int
ws_uf is string = NoSpace(Upper(LK_uf))
Ws_Retorno is int = 0
Ws_RetornoEdt is string = "Insc Invalida"
ws_soma is int = 0
ws_resto is int = 0
ws_result is string
ws_peso is int = 0
ws_digcalc1 is int = 0 // digito calculado baseado nos dados informados
ws_digcalc2 is int = 0
ws_digInf1 is int = 0
ws_digInf2 is int = 0 // digito informado pelo usuario que veio junto o campo da inscricao
IF CharactTypeCount(ws_inscricao,ctAlpha) = 0 THEN // nao tem caracter alfa no campo entao tenta validar
SWITCH ws_uf
CASE "AC": Valida_AC()
CASE "AL": Valida_AL()
CASE "AP": Valida_AP()
CASE "AM": Valida_AM()
CASE "BA": Valida_BA()
CASE "CE": Valida_CE()
CASE "DF": Valida_DF()
CASE "ES": Valida_ES()
CASE "GO": Valida_GO()
CASE "MA": Valida_MA()
CASE "MT": Valida_MT()
CASE "MS": Valida_MS()
CASE "MG": Valida_MG()
CASE "PA": Valida_PA()
CASE "PB": Valida_PB()
CASE "PE": Valida_PE()
CASE "PI": Valida_PI()
CASE "RN": Valida_RN()
CASE "RO": Valida_RO()
CASE "RR": Valida_RR()
CASE "SC": Valida_SC()
CASE "SP": Valida_SP()
CASE "SE": Valida_SE()
CASE "TO": Valida_TO()
CASE "RS": Valida_RS()
CASE "PR": Valida_PR()
CASE "RJ": Valida_RJ()
OTHER CASE
END
ELSE
IF Upper(ws_inscricao) <> "ISENTO"
Ws_Retorno = 1
Ws_RetornoEdt = "Nao é Permitido Letras na Inscricao"
ELSE
Ws_Retorno = 1
Ws_RetornoEdt = "ISENTO"
END
END
RESULT (Ws_Retorno,Ws_RetornoEdt)
INTERNAL PROCEDURE Monta_Digitos_Default()
ws_InscricaoEdt = Complete(ws_inscricao,14,"0") //coloca zeros a direita
D1 = Middle(ws_InscricaoEdt,1,1) // distribui cada Digito em sua variavel INT
D2 = Middle(ws_InscricaoEdt,2,1)
D3 = Middle(ws_InscricaoEdt,3,1)
D4 = Middle(ws_InscricaoEdt,4,1)
D5 = Middle(ws_InscricaoEdt,5,1)
D6 = Middle(ws_InscricaoEdt,6,1)
D7 = Middle(ws_InscricaoEdt,7,1)
D8 = Middle(ws_InscricaoEdt,8,1)
D9 = Middle(ws_InscricaoEdt,9,1)
D10 = Middle(ws_InscricaoEdt,10,1)
D11 = Middle(ws_InscricaoEdt,11,1)
D12 = Middle(ws_InscricaoEdt,12,1)
D13 = Middle(ws_InscricaoEdt,13,1)
D14 = Middle(ws_InscricaoEdt,14,1)
Ds1 = D1 // distribui cada Digito em sua variavel , mais aqui em string para depois formatar
Ds2 = D2
Ds3 = D3
Ds4 = D4
Ds5 = D5
Ds6 = D6
Ds7 = D7
Ds8 = D8
Ds9 = D9
Ds10 = D10
Ds11 = D11
Ds12 = D12
Ds13 = D13
Ds14 = D14
END
INTERNAL PROCEDURE Valida_ES()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_SE()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
// Formato: 8 dígitos + 1 dígito verificador
// Exemplo: IE número 27123456-3
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_TO()
IF Length(ws_inscricao) NOT IN (9,11) THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 ou 11 digitos, Check zeros a esquerda"
RETURN
END
IF Length(ws_inscricao) = 11 THEN
Calcula_11Digitos()
ELSE
Calcula_9Digitos()
END
INTERNAL PROCEDURE Calcula_9Digitos()
Monta_Digitos_Default()
// Formato: 08 dígitos + 1 dígito verificador
// Exemplo: 29 022783 6
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF (ws_digcalc1 <> ws_digInf1)
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Calcula_11Digitos()
Monta_Digitos_Default()
// Formato: 08 dígitos + 1 dígito verificador
// Exemplo: 29 022783 6
ws_digInf1 = D11 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D5 * 7) + (D6 * 6) + (D7 * 5) + (D8 * 4) + (D9 * 3) + (D10 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF (ws_digcalc1 <> ws_digInf1)
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
END
INTERNAL PROCEDURE Valida_SC()
// 8 DIGITOS + 1 de Controle
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_PA()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_PB()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_PI()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_GO()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_ref2 is int = Middle(ws_InscricaoEdt,1,2)
ws_ref is int = Middle(ws_InscricaoEdt,1,8)
IF ws_ref2 NOT IN (10,11,15,20,21,22,23,24,25,26,27,28,29) // NAO E inscricao de goias THEN
Ws_Retorno = 1
Ws_RetornoEdt = "Nao e Inscricao de Goias"
RETURN
END
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto = 0
ws_digcalc1 = 0
ELSE
IF ws_resto = 1
IF ws_ref >= 10103105 AND ws_ref <= 10119997
ws_digcalc1 = 1
ELSE
ws_digcalc1 = 0
END
ELSE // maior que 1
ws_digcalc1 = 11 - ws_resto
END
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_RJ()
IF Length(ws_inscricao) <> 8 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 8 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D8 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 2) + (D2 * 7) + (D3 * 6) + (D4 * 5) + (D5 * 4) + (D6 * 3) + (D7 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_AL()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " Sao 9 Digitos , check zeros Esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_soma = ws_soma * 10
ws_resto = ws_soma modulo 11
IF ws_resto = 10 THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = ws_resto
END
IF (ws_digcalc1 <> ws_digInf1) OR
(D1 <> 2) OR
(D2 <> 4)
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_RS()
IF Length(ws_inscricao) <> 10 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 10 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D10 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 2) + (D2 * 9) + (D3 * 8) + (D4 * 7) + (D5 * 6) + (D6 * 5) + (D7 * 4) + (D8 * 3) + (D9 * 2)
ws_soma = ws_soma
ws_resto = ws_soma modulo 11
IF 11 - ws_resto IN(10,11) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_RN()
IF Length(ws_inscricao) NOT IN (9,10) THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 ou 10 digitos, Check zeros a esquerda"
RETURN
END
IF Length(ws_inscricao) = 9 THEN
Calcula_9digitos()
ELSE
Calcula_10digitos()
END
INTERNAL PROCEDURE Calcula_9digitos()
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_soma = ws_soma * 10
ws_resto = ws_soma modulo 11
IF ws_resto = 10 THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Calcula_10digitos()
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 10) + (D2 * 9) + (D3 * 8) + (D4 * 7) + (D5 * 6) + (D6 * 5) + (D7 * 4) + (D8 * 3) + (D9 * 2)
ws_soma = ws_soma * 10
ws_resto = ws_soma modulo 11
IF ws_resto = 10 THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
END
INTERNAL PROCEDURE Valida_AM()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " Sao 9 Digitos , check zeros Esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
IF ws_soma < 11
ws_digcalc1 = 11 - ws_soma
ELSE
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_AP()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + "Sao 9 Digitos, check zeros Esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_p is int = 0
ws_d is int = 0
ws_ref is int = Middle(ws_InscricaoEdt,1,8)
IF ws_ref >= 03000001 AND ws_ref <= 03017000 THEN
ws_p = 5
ws_d = 0
ELSE
IF ws_ref >= 03017001 AND ws_ref <= 03019022 THEN
ws_p = 9
ws_d = 1
ELSE
ws_p = 0
ws_d = 0
END
END
ws_soma = ws_p + (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
ws_digcalc1 = 11 - ws_resto
IF ws_digcalc1 = 10 THEN
ws_digcalc1 = 0
ELSE
IF ws_digcalc1 = 11 THEN
ws_digcalc1 = ws_d
END
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_CE()
IF Length(ws_inscricao) NOT IN (9) THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " Sao 9 Digitos,check zeros Esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
ws_digcalc1 = 11 - ws_resto
IF ws_digcalc1 IN (10,11) THEN
ws_digcalc1 = 0
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
//0011690810068
INTERNAL PROCEDURE Valida_MG()
IF Length(ws_inscricao) <> 13 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
D1 = Middle(ws_InscricaoEdt,1,1)
D2 = Middle(ws_InscricaoEdt,2,1)
D3 = Middle(ws_InscricaoEdt,3,1)
D4 = 0
D5 = Middle(ws_InscricaoEdt,4,1)
D6 = Middle(ws_InscricaoEdt,5,1)
D7 = Middle(ws_InscricaoEdt,6,1)
D8 = Middle(ws_InscricaoEdt,7,1)
D9 = Middle(ws_InscricaoEdt,8,1)
D10 = Middle(ws_InscricaoEdt,9,1)
D11 = Middle(ws_InscricaoEdt,10,1)
D12 = Middle(ws_InscricaoEdt,11,1)
D13 = Middle(ws_InscricaoEdt,12,1)
D14 = Middle(ws_InscricaoEdt,13,1)
ws_digInf1 = Middle(ws_InscricaoEdt,12,1)
ws_digInf2 = Middle(ws_InscricaoEdt,13,1)
// alimenta a array
Ws_Digito[01] = D1
Ws_Digito[02] = D2
Ws_Digito[03] = D3
Ws_Digito[04] = D4
Ws_Digito[05] = D5
Ws_Digito[06] = D6
Ws_Digito[07] = D7
Ws_Digito[08] = D8
Ws_Digito[09] = D9
Ws_Digito[10] = D10
Ws_Digito[11] = D11
Ws_Digito[12] = D12
Ws_Digito[13] = D13
Ws_Digito[14] = D14
ws_soma = 0
ws_result = ""
ws_peso = 0
FOR ws_ind = 1 _TO_ 12 // ArrayCount(Ws_Digito) nao considera posicao 13 e 14 que sao digitos informados no campos
IF IsOdd(ws_ind) = True // e impar peso = 1
ws_peso = 1
ELSE
ws_peso = 2
END
ws_result = NumToString(( Ws_Digito[ws_ind] * ws_peso),"04d") // resulta ficara 0012 por exemplo
ws_soma = ws_soma + Val(Middle(ws_result,3,1)) + Val(Middle(ws_result,4,1))
END
ws_digcalc1 = 10 - Val(Right(NumToString(ws_soma),1)) // transforma ws_soma em string pega ultimo numero e subtrai de 10
IF ws_digcalc1 = 10 THEN
ws_digcalc1 = 0
END
D1 = Middle(ws_InscricaoEdt,1,1)
D2 = Middle(ws_InscricaoEdt,2,1)
D3 = Middle(ws_InscricaoEdt,3,1)
D4 = Middle(ws_InscricaoEdt,4,1)
D5 = Middle(ws_InscricaoEdt,5,1)
D6 = Middle(ws_InscricaoEdt,6,1)
D7 = Middle(ws_InscricaoEdt,7,1)
D8 = Middle(ws_InscricaoEdt,8,1)
D9 = Middle(ws_InscricaoEdt,9,1)
D10 = Middle(ws_InscricaoEdt,10,1)
D11 = Middle(ws_InscricaoEdt,11,1)
D12 = ws_digcalc1 // acrescenta o digito1 na matriz na posicao 12
D13 = Middle(ws_InscricaoEdt,13,1)
D14 = Middle(ws_InscricaoEdt,14,1)
ws_soma = (D1 * 3) + (D2 * 2) + (D3 * 11) + (D4 * 10) + (D5 * 9) + (D6 * 8) + (D7 * 7) + (D8 * 6) + (D9 * 5) + (D10 * 4) + (D11 * 3) + (D12 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN(0,1) THEN
ws_digcalc2 = 0
ELSE
ws_digcalc2 = 11 - ws_resto
END
IF ws_digInf1 <> ws_digcalc1 OR
ws_digInf2 <> ws_digcalc2
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_BA()
IF Length(ws_inscricao) NOT IN (8,9) THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " Sao 8 ou 9digitos, check zeros Esquerda"
RETURN
END
Monta_Digitos_Default()
IF Length(ws_inscricao) = 8 // Módulo 10 com peso de 2 a 7, aplicados da direita para esquerda, atribuindo um peso a cada dígito da I.E. seguindo a ordem abaixo:
ws_digInf1 = D7
ws_digInf2 = D8
IF D1 IN (0,1,2,3,4,5,8)
Valida_BA8Modulo10()
ELSE
Valida_BA8Modulo11()
END
ELSE
ws_digInf1 = D8
ws_digInf2 = D9
IF D2 IN (0,1,2,3,4,5,8)
Valida_BA9Modulo10()
ELSE
Valida_BA9Modulo11()
END
END
IF ws_digInf1 <> ws_digcalc1 OR
ws_digInf2 <> ws_digcalc2
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
INTERNAL PROCEDURE Valida_BA8Modulo10()
ws_soma = (D1 * 7) + (D2 * 6) + (D3 * 5) + (D4 * 4) + (D5 * 3) + (D6 * 2)
ws_resto = ws_soma modulo 10
ws_digcalc2 = 10 - ws_resto
IF ws_digcalc2 = 10
ws_digcalc2 = 0
END
D7 = ws_digcalc2 // incorpora seg digito ao numero e vai calcular Primeiro digito
ws_soma = (D1 * 8) + (D2 * 7) + (D3 * 6) + (D4 * 5) + (D5 * 4) + (D6 * 3) + (D7 * 2)
ws_resto = ws_soma modulo 10
ws_digcalc1 = 10 - ws_resto
IF ws_digcalc1 = 10
ws_digcalc1 = 0
END
END
INTERNAL PROCEDURE Valida_BA8Modulo11()
ws_soma = (D1 * 7) + (D2 * 6) + (D3 * 5) + (D4 * 4) + (D5 * 3) + (D6 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc2 = 0
ELSE
ws_digcalc2 = 11 - ws_resto
END
D7 = ws_digcalc2 // incorpora seg digito ao numero e vai calcular Primeiro digito
ws_soma = (D1 * 8) + (D2 * 7) + (D3 * 6) + (D4 * 5) + (D5 * 4) + (D6 * 3) + (D7 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
END
INTERNAL PROCEDURE Valida_BA9Modulo10()
ws_soma = (D1 * 8) + (D2 * 7) + (D3 * 6) + (D4 * 5) + (D5 * 4) + (D6 * 3) + (D7 * 2)
ws_resto = ws_soma modulo 10
ws_digcalc2 = 10 - ws_resto
IF ws_digcalc2 = 10
ws_digcalc2 = 0
END
D8 = ws_digcalc2 // incorpora seg digito ao numero e vai calcular Primeiro digito
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 10
ws_digcalc1 = 10 - ws_resto
IF ws_digcalc1 = 10
ws_digcalc1 = 0
END
END
INTERNAL PROCEDURE Valida_BA9Modulo11()
ws_soma = (D1 * 8) + (D2 * 7) + (D3 * 6) + (D4 * 5) + (D5 * 4) + (D6 * 3) + (D7 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc2 = 0
ELSE
ws_digcalc2 = 11 - ws_resto
END
D8 = ws_digcalc2 // incorpora seg digito ao numero e vai calcular Primeiro digito
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
END
END
INTERNAL PROCEDURE Valida_AC()
IF Length(ws_inscricao) <> 13 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " Sao 13 digitos, check zeros Esquerda"
RETURN
END
Monta_Digitos_Default()
//Formato: 11 dígitos + 2 dígitos verificadores
ws_digInf1 = D12
ws_digInf2 = D13
ws_soma = (D1 * 4) + (D2 * 3) + (D3 * 2) + (D4 * 9) + (D5 * 8) + (D6 * 7) + (D7 * 6) + (D8 * 5) + (D9 * 4) + (D10 * 3) + (D11 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
D12 = ws_digcalc1 // incorpora seg digito ao numero e vai calcular Primeiro digito
ws_soma = (D1 * 5) + (D2 * 4) + (D3 * 3) + (D4 * 2) + (D5 * 9) + (D6 * 8) + (D7 * 7) + (D8 * 6) + (D9 * 5) + (D10 * 4) + (D11 * 3) + (D12 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc2 = 0
ELSE
ws_digcalc2 = 11 - ws_resto
END
IF ws_digInf1 <> ws_digcalc1 OR
ws_digInf2 <> ws_digcalc2
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_SP()
IF Length(ws_inscricao) = 13 AND
Middle(ws_inscricao,1,1) <> "P" THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 13 digitos mais nao comeca com P de Produtor Rural"
RETURN
ELSE
IF Length(ws_inscricao) NOT IN (12,13)
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 12 ou 13 digitos"
RETURN
END
END
IF Upper(Middle(ws_inscricao,1,1)) = "P" THEN
Calcula_ProdutorRural()
ELSE
Calcula_Normal()
END
INTERNAL PROCEDURE Calcula_Normal()
Monta_Digitos_Default()
// à Formato: 12 dígitos sendo que o 9º e o 12º são dígitos verificadores
// à Exemplo: Inscrição Estadual 110.042.490.114
ws_digInf1 = D9
ws_digInf2 = D12
ws_soma = (D1 * 1) + (D2 * 3) + (D3 * 4) + (D4 * 5) + (D5 * 6) + (D6 * 7) + (D7 * 8) + (D8 * 10)
ws_resto = ws_soma modulo 11
IF ws_resto IN (10,11)
ws_digcalc1 = 0
ELSE
ws_digcalc1 = ws_resto
END
ws_soma = (D1 * 3) + (D2 * 2) + (D3 * 10) + (D4 * 9) + (D5 * 8) + (D6 * 7) + (D7 * 6) + (D8 * 5) + (D9 * 4) + (D10 * 3) + (D11 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (10,11)
ws_digcalc2 = 0
ELSE
ws_digcalc2 = ws_resto
END
IF ws_digInf1 <> ws_digcalc1 OR
ws_digInf2 <> ws_digcalc2
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Calcula_ProdutorRural()
Monta_Digitos_Default()
// Formato: - P0MMMSSSSD000
// 13 caracteres dos quais o 10º caracter contado a partir da esquerda ("D") é o dígito verificador
// Inicia sempre com "P" e apresenta a sequência 0MMMSSSSD000
ws_digInf1 = D10
ws_soma = (D2 * 1) + (D3 * 3) + (D4 * 4) + (D5 * 5) + (D6 * 6) + (D7 * 7) + (D8 * 8) + (D9 * 10)
ws_resto = ws_soma modulo 11
IF ws_resto IN (10,11)
ws_digcalc1 = 0
ELSE
ws_digcalc1 = ws_resto
END
IF ws_digInf1 <> ws_digcalc1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
END
INTERNAL PROCEDURE Valida_PR()
IF Length(ws_inscricao) <> 10 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 10 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
//Formato: 08 dígitos + 2 dígitos verificadores
ws_digInf1 = D9
ws_digInf2 = D10
ws_soma = (D1 * 3) + (D2 * 2) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
D9 = ws_digcalc1 // incorpora digito ao numero e vai calcular segundo digito
ws_soma = (D1 * 4) + (D2 * 3) + (D3 * 2) + (D4 * 7) + (D5 * 6) + (D6 * 5) + (D7 * 4) + (D8 * 3) + (D9 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc2 = 0
ELSE
ws_digcalc2 = 11 - ws_resto
END
IF ws_digInf1 <> ws_digcalc1 OR
ws_digInf2 <> ws_digcalc2
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_PE()
IF Length(ws_inscricao) NOT IN (9,14) THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 ou 14 digitos, Check zeros a esquerda"
RETURN
END
IF Length(ws_inscricao) = 9 THEN
Calcula_9digitos()
ELSE
Calcula_14digitos()
END
INTERNAL PROCEDURE Calcula_9Digitos()
Monta_Digitos_Default()
//Formato: 07 dígitos + 2 dígitos verificadores
ws_digInf1 = D8
ws_digInf2 = D9
ws_soma = (D1 * 8) + (D2 * 7) + (D3 * 6) + (D4 * 5) + (D5 * 4) + (D6 * 3) + (D7 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
D8 = ws_digcalc1 // incorpora digito ao numero e vai calcular segundo digito
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc2 = 0
ELSE
ws_digcalc2 = 11 - ws_resto
END
IF ws_digInf1 <> ws_digcalc1 OR
ws_digInf2 <> ws_digcalc2
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Calcula_14Digitos()
Monta_Digitos_Default()
//Formato: 13 dígitos + 1 dígitos verificadores
ws_digInf1 = D14
ws_soma = (D1 * 5) + (D2 * 4) + (D3 * 3) + (D4 * 2) + (D5 * 1) + (D6 * 9) + (D7 * 8) + (D8 * 7) + (D9 * 6) + (D10 * 5) + (D11 * 4) + (D12 * 3) + (D13 * 2)
ws_resto = ws_soma modulo 11
ws_digcalc1 = 11 - ws_resto
IF ws_digcalc1 > 9
ws_digcalc1 = ws_digcalc1 - 10
END
IF ws_digInf1 <> ws_digcalc1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
END
INTERNAL PROCEDURE Valida_RO()
IF Length(ws_inscricao) NOT IN (9,14) THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 ou 14 digitos, Check zeros a esquerda"
RETURN
END
IF Length(ws_inscricao) = 9 THEN
Calcula_9digitos()
ELSE
Calcula_14digitos()
END
INTERNAL PROCEDURE Calcula_9Digitos()
Monta_Digitos_Default()
//Formato: 08 dígitos + 1 dígitos verificadores
ws_digInf1 = D9
ws_soma = (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
ws_digcalc1 = 11 - ws_resto
IF ws_digcalc1 > 9 // ou seja 10 ou 11
ws_digcalc1 = ws_digcalc1 - 10
END
IF ws_digInf1 <> ws_digcalc1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Calcula_14Digitos()
ws_inscricao = NumToString(Val(ws_inscricao),"014d") // coloca zeros a esquerda para ficar com 14 posicoes
Monta_Digitos_Default()
//Formato: 13 dígitos + 1 dígitos verificadores
ws_digInf1 = D14
ws_soma = (D1 * 5) + (D2 * 4) + (D3 * 3) + (D4 * 2) + (D5 * 1) + (D6 * 9) + (D7 * 8) + (D8 * 7) + (D9 * 6) + (D10 * 5) + (D11 * 4) + (D12 * 3) + (D13 * 2)
ws_resto = ws_soma modulo 11
ws_digcalc1 = 11 - ws_resto
IF ws_digcalc1 > 9
ws_digcalc1 = ws_digcalc1 - 10
END
IF ws_digInf1 <> ws_digcalc1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
END
INTERNAL PROCEDURE Valida_RR()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
//Formato: 08 dígitos + 1 dígitos verificadores
ws_digInf1 = D9
ws_soma = (D1 * 1) + (D2 * 2) + (D3 * 3) + (D4 * 4) + (D5 * 5) + (D6 * 6) + (D7 * 7) + (D8 * 8)
ws_resto = ws_soma modulo 09
ws_digcalc1 = ws_resto
IF ws_digInf1 <> ws_digcalc1 THEN
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_DF()
IF Length(ws_inscricao) < 13 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 13 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
//Formato: 11 dígitos + 2 dígitos verificadores
ws_digInf1 = D12
ws_digInf2 = D13
ws_soma = (D1 * 4) + (D2 * 3) + (D3 * 2) + (D4 * 9) + (D5 * 8) + (D6 * 7) + (D7 * 6) + (D8 * 5) + (D9 * 4) + (D10 * 3) + (D11 * 2)
ws_resto = ws_soma modulo 11
ws_digcalc1 = 11 - ws_resto
IF ws_digcalc1 IN (10,11)
ws_digcalc1 = 0
END
D12 = ws_digcalc1 // incorpora seg digito ao numero e vai calcular Primeiro digito
ws_soma = (D1 * 5) + (D2 * 4) + (D3 * 3) + (D4 * 2) + (D5 * 9) + (D6 * 8) + (D7 * 7) + (D8 * 6) + (D9 * 5) + (D10 * 4) + (D11 * 3) + (D12 * 2)
ws_resto = ws_soma modulo 11
ws_digcalc2 = 11 - ws_resto
IF ws_digcalc2 IN (10,11)
ws_digcalc2 = 0
END
IF ws_digInf1 <> ws_digcalc1 OR
ws_digInf2 <> ws_digcalc2
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_MA()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1) THEN
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_MT()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " sao 9 digitos, Check zeros a esquerda"
RETURN
END
ws_inscricao = NumToString(Val(ws_inscricao),"011d") // coloca zeros a esquerda para ficar com 11 posicoes
Monta_Digitos_Default()
ws_digInf1 = D11 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 3) + (D2 * 2) + (D3 * 9) + (D4 * 8) + (D5 * 7) + (D6 * 6) + (D7 * 5) + (D8 * 4) + (D9 * 3) + (D10 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto IN (0,1)
ws_digcalc1 = 0
ELSE
ws_digcalc1 = 11 - ws_resto
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE Valida_MS()
IF Length(ws_inscricao) <> 9 THEN
Ws_Retorno = 1
Ws_RetornoEdt = ws_uf + " Sao 9 digitos, Check zeros a esquerda"
RETURN
END
Monta_Digitos_Default()
ws_digInf1 = D9 //Guarda digito informado que veio na inscricao digitado pelo usuario
ws_soma = (D1 * 9) + (D2 * 8) + (D3 * 7) + (D4 * 6) + (D5 * 5) + (D6 * 4) + (D7 * 3) + (D8 * 2)
ws_resto = ws_soma modulo 11
IF ws_resto = 0 THEN
ws_digcalc1 = 0
ELSE
IF 11 - ws_resto < 10 THEN
ws_digcalc1 = 11 - ws_resto
ELSE
ws_digcalc1 = 0
END
END
IF ws_digcalc1 <> ws_digInf1
Ws_Retorno = 1
Ws_RetornoEdt = "Insc Invalida"
RETURN
ELSE
FormataInscricao()
RETURN
END
END
INTERNAL PROCEDURE FormataInscricao()
Ws_Retorno = 0
SWITCH ws_uf
CASE "ES": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + "." + Ds4 + Ds5 + Ds6 + "." + Ds7 + Ds8 + "-" + Ds9
CASE "RJ": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + "." + Ds6 + Ds7 + "-" + Ds8
CASE "BA":
IF Length(ws_inscricao) = 8
Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + Ds4 + Ds5 + Ds6 + "-" +Ds7 + Ds8
ELSE
Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + Ds4 + Ds5 + Ds6 + D7 + "-" +Ds8 + Ds9
END
CASE "MG": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + "." + Ds4 + Ds5 + Ds6 + "." + Ds7 + Ds8 + Ds9 + "/" + Ds10 + Ds11 + Ds12 + Ds13
CASE "PA": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "MA": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "MT": Ws_RetornoEdt = Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + Ds9 + Ds10 + "-" + Ds11
CASE "PB": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "PR": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9 + Ds10
CASE "AL": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + "." + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "AP": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "AM": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + "." + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "CE": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "PI": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "RN": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + "." + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "RS": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + "/" + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + Ds9 + Ds10
CASE "RO": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + Ds9 + Ds10 + "." + Ds11 + Ds12 + Ds13 + "-" + Ds14
CASE "RR": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "SC": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + "." + Ds4 + Ds5 + Ds6 + "." + Ds7 + Ds8 + Ds9
CASE "SE": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "GO": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + "." + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "MS": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + "." + Ds6 + Ds7 + Ds8 + "-" + Ds9
CASE "DF": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + Ds8 + "/" + Ds9 + Ds10 + Ds11 + "-" + Ds12 + Ds13
CASE "SP": Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + "." + Ds4 + Ds5 + Ds6 + "." + Ds7 + Ds8 + Ds9 + "." + Ds10 + Ds11 + Ds12
CASE "AC": Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + "." + Ds6 + Ds7 + Ds8 + "/" + Ds9 + Ds10 + Ds11 + "-" + Ds12 + Ds13
CASE "PE":
IF Middle(ws_InscricaoEdt,10,5) <> "00000" THEN // E pq e inscricao antiga com 14 digitos (13+1)
Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + "." + Ds4 + Ds5 + Ds6 + "." + Ds7 + Ds8 + Ds9 + Ds10 + Ds11 + Ds12 + Ds13 + "-" + Ds14
ELSE
Ws_RetornoEdt = Ds1 + Ds2 + Ds3 + Ds4 + Ds5 + Ds6 + Ds7 + "-" + Ds8 + Ds9
END
CASE "TO":
IF Length(ws_inscricao) <> 9
Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + "." + Ds5 + Ds6 + Ds7 + "." + Ds8 + Ds9 + Ds10 + "-" + Ds11
ELSE
Ws_RetornoEdt = Ds1 + Ds2 + "." + Ds3 + Ds4 + Ds5 + "." + Ds6 + Ds7 + Ds8 + "-" + Ds9
END
OTHER CASE: Ws_RetornoEdt = " "
END
END
//------------------------------------------------------------------------
// Summary: <specify the procedure action>
// Syntax:
//[ <Result> = ] Usa_Inscricao_Estadual (<InscricaoEstadual>, <Estado>)
//
// Parameters:
// InscricaoEstadual: <specify the role of InscricaoEstadual>
// Estado: <specify the role of Estado>
// Example:
// <Specify a usage example>
//
// Return value:
PROCEDURE Usa_Inscricao_Estadual(InscricaoEstadual,Estado)
//Aqui a chamada da rotina dentro de qq forms que tenha campo incricao estadual
ws_InscricaoEstadual is string = InscricaoEstadual
ws_uf is string = Estado
ws_Retinscricao is int
ws_Retmsg is ANSI string
ws_RetornoEdt is string
ws_resultado is array of string
IF NoSpace(ws_InscricaoEstadual) <> "ISENTO"
resultado is string = Funcao_Valida_Inscricao_Estadual(NoSpace(ws_InscricaoEstadual),ws_uf)
// insc dec //chama rotina para criticar inscricao estadual
Add(ws_resultado, resultado)
ELSE
ws_Retinscricao = 0 // forca retorno OK ja que e ISENTO
ws_Retmsg = "ISENTO"
ws_RetornoEdt = "ISENTO"
Add(ws_resultado,"ISENTO")
END
SWITCH ws_Retinscricao
CASE 0:
Add(ws_resultado,"0 "+ws_Retmsg)
CASE 1:
Add(ws_resultado,"1 "+ws_Retmsg)
END
RESULT ws_resultado