Class: SEFAZ::Webservice::NFE::Client

Inherits:
Base
  • Object
show all
Defined in:
lib/sefaz/webservice/nfe/client.rb

Overview

Principal classe de integração com o módulo NF-e/NFC-e

Constant Summary collapse

SERVICES = 
%i[ setaAmbiente setaRespTecnico setaPFXTss setaPFXAss statusDoServico consultarNF consultarCadastro consultarRecibo
assinarNF validarNF auditarNF inutilizarNF exportarInutilizarNF enviarInutilizarNF calculaChaveInutilizacao
enviarEvento enviarLoteDeEvento cancelarNF exportarCancelarNF enviarCCe exportarCCe enviarNF enviarLoteNF calculaChaveNF
gerarDANFE gerarDocCancelamento gerarDocCartaCorrecao]

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Client

Métodos de Manipulação: (MAIORIA EXIGE ASSINATURA) – Os métodos ‘enviarNF’ e ‘enviarLoteNF’ não precisa ‘exportar’, pois os dados são montados externo à gema (XML ou Hash ou Dataset)

  • assinarNF

  • enviarNF

  • enviarLoteNF

  • calculaChaveNF

  • inutilizarNF

    • exportarInutilizarNF

    • enviarInutilizarNF

    • calculaChaveInutilizacao

  • cancelarNF (EVENTO)

    • exportarCancelarNF (EVENTO)

  • enviarCCe (EVENTO)

    • exportarCCe (EVENTO)

  • enviarManifestacao (PENDENTE) (EVENTO)

    • exportarManifestacao (PENDENTE) (EVENTO)

  • enviarEvento

  • enviarLoteDeEvento

  • gerarDANFE

  • gerarDANFCE (PENDENTE)

  • gerarDocCancelamento

  • gerarDocCartaCorrecao

  • gerarDocInutilizacao (PENDENTE)

  • gerarLeiauteEvento (PRIVADO)



56
57
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 56

def initialize
end

Instance Method Details

#assinarNF(documento) ⇒ Object

Assinar NF - PFX de assinatura - Certificado A1 @documento(Hash ou String) = XML ou HASH que será assinado



134
135
136
137
138
139
140
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 134

def assinarNF(documento)
  xml = (documento.is_a?(Hash) ? documento.to_xml! : documento)
  doc = SEFAZ::Utils::Signer.new(xml)
  doc.sign!(@pkcs12Ass.certificate, @pkcs12Ass.key)
  xml = doc.to_xml
  return [xml, xml.to_hash!]
end

#auditarNF(documento, openTimeout = 60, readTimeout = 60) ⇒ Object

Auditar NF no validador TecnoSpeed (validador.nfe.tecnospeed.com.br/) @documento(Hash ou String) = XML ou HASH que será auditado @openTimeout(Integer) = Tempo de espera em segundos para abrir conexão (opcional: padrão 60) @readTimeout(Integer) = Tempo de espera em segundos para ler resposta (opcional: padrão 60)



216
217
218
219
220
221
222
223
224
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 216

def auditarNF(documento, openTimeout = 60, readTimeout = 60)
  xml = (documento.is_a?(Hash) ? documento.to_xml! : documento)
  auditor = SEFAZ::Webservice::NFE::Auditor.new(xml)
  stat, msg = auditor.exec(openTimeout, readTimeout)
  case stat
  when :ok; return [true, msg]
  else      return [false, {}]
  end
end

#calculaChaveInutilizacao(ano, cnpj, modelo, serie, nroNFIni, nroNFFin) ⇒ Object

Calcular Chave de Inutilização



248
249
250
251
252
253
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 248

def calculaChaveInutilizacao(ano, cnpj, modelo, serie, nroNFIni, nroNFFin)
  serie = serie.to_s.rjust(3, "0")
  nroNFIni = nroNFIni.to_s.rjust(9, "0")
  nroNFFin = nroNFFin.to_s.rjust(9, "0")
  return "ID#{@uf}#{ano}#{cnpj}#{modelo}#{serie}#{nroNFIni}#{nroNFFin}"
end

#calculaChaveNF(uf, aamm, cnpj, modelo, serie, nNF, tpEmis, cNF) ⇒ Object

Calcular Chave NF



184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 184

def calculaChaveNF(uf, aamm, cnpj, modelo, serie, nNF, tpEmis, cNF)
  uf = uf.to_s.rjust(2, "0")
  aamm = aamm.to_s.rjust(4, "0")
  cnpj = cnpj.to_s.delete("^0-9").rjust(14, "0")
  modelo = modelo.to_s.rjust(2, "0")
  serie = serie.to_s.rjust(3, "0")
  nNF = nNF.to_s.rjust(9, "0")
  cNF = cNF.to_s.rjust(8, "0")
  nChave = "#{uf[0,2]}#{aamm[0,4]}#{cnpj[0,14]}#{modelo[0,2]}#{serie[0,3]}#{nNF[0,9]}#{tpEmis[0,1]}#{cNF[0,8]}"
  nPesos = "4329876543298765432987654329876543298765432"
  cDV = 11 - (nChave.split("").each_with_index.map { |n, index| n.to_i * nPesos[index].to_i }.sum % 11)
  return ["#{nChave}#{cDV}", cDV]
end

#cancelarNF(chaveNF, sequenciaEvento, dataHoraEvento, numProtocolo, justificativa, idLote) ⇒ Object

Cancelar NF - Gera, assina e envia o documento com certificado A1 (exportarCancelarNF, assinarNF, enviarEvento)



303
304
305
306
307
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 303

def cancelarNF(chaveNF, sequenciaEvento, dataHoraEvento, numProtocolo, justificativa, idLote)
  _, hash = exportarCancelarNF(chaveNF, sequenciaEvento, dataHoraEvento, numProtocolo, justificativa)
  _, hash = assinarNF(hash)
  return enviarEvento(hash, idLote)
end

#consultarCadastro(nroDocumento, tpDocumento, uf) ⇒ Object

Consulta Cadastro @nroDocumento(String) = Número do documento @tpDocumento(String) = CNPJ/CPF/IE @uf(String) = Sigla do estado que será consultado (SP; MG; RJ; …)



107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 107

def consultarCadastro(nroDocumento, tpDocumento, uf)
  versao = "2.00"
  hash = { ConsCad: { infCons: { xServ: 'CONS-CAD', UF: uf }, :@xmlns => "http://www.portalfiscal.inf.br/nfe", :@versao => versao } }
  case tpDocumento
  when 'CNPJ'; hash[:ConsCad][:infCons][:CNPJ] = nroDocumento.to_s.delete("^0-9")
  when 'CPF';  hash[:ConsCad][:infCons][:CPF]  = nroDocumento.to_s.delete("^0-9")
  when 'IE';   hash[:ConsCad][:infCons][:IE]   = nroDocumento.to_s.delete("^0-9")
  end
  wsdl = SEFAZ::Webservice::NFE::WSDL.get(:NfeConsultaCadastro, @ambiente, @uf)
  conn = SEFAZ::Webservice::NFE::Connection.new(@pkcs12Tss, wsdl, versao, @uf)
  resp = conn.call(:consulta_cadastro, hash)
  return [resp.body.to_xml!, resp.body]
end

#consultarNF(chaveNF) ⇒ Object

Consulta Situação NF @chaveNF(String) = Chave de acesso de uma NF



94
95
96
97
98
99
100
101
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 94

def consultarNF(chaveNF)
  versao = "4.00"
  hash = { consSitNFe: { tpAmb: @ambiente, xServ: 'CONSULTAR', chNFe: chaveNF, :@xmlns => "http://www.portalfiscal.inf.br/nfe", :@versao => versao } }
  wsdl = SEFAZ::Webservice::NFE::WSDL.get(:NfeConsultaProtocolo, @ambiente, @uf)
  conn = SEFAZ::Webservice::NFE::Connection.new(@pkcs12Tss, wsdl, versao, @uf)
  resp = conn.call(:nfe_consulta_nf, hash)
  return [resp.body.to_xml!, resp.body]
end

#consultarRecibo(numRecibo) ⇒ Object

Consulta Recebido de Lote @numRecibo(String) = Número do recibo do lote de NF-e



123
124
125
126
127
128
129
130
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 123

def consultarRecibo(numRecibo)
  versao = "4.00"
  hash = { consReciNFe: { tpAmb: @ambiente, nRec: numRecibo, :@xmlns => "http://www.portalfiscal.inf.br/nfe", :@versao => versao } }
  wsdl = SEFAZ::Webservice::NFE::WSDL.get(:NFeRetAutorizacao, @ambiente, @uf)
  conn = SEFAZ::Webservice::NFE::Connection.new(@pkcs12Tss, wsdl, versao, @uf)
  resp = conn.call(:nfe_ret_autorizacao_lote, hash)
  return [resp.body.to_xml!, resp.body]
end

#enviarCCe(chaveNF, sequenciaEvento, dataHoraEvento, textoCorrecao, idLote) ⇒ Object

Enviar CCe - Gera, assina e envia o documento com certificado A1 (exportarCCe, assinarNF, enviarEvento)



335
336
337
338
339
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 335

def enviarCCe(chaveNF, sequenciaEvento, dataHoraEvento, textoCorrecao, idLote)
  _, hash = exportarCCe(chaveNF, sequenciaEvento, dataHoraEvento, textoCorrecao)
  _, hash = assinarNF(hash)
  return enviarEvento(hash, idLote)
end

#enviarEvento(evento, idLote) ⇒ Object

Enviar Evento - Necessário um documento assinado OBS: Recomendado quando utilizado o certificado A3 @evento(Hash ou String) = XML ou HASH assinado que será enviado @idLote(String) = Identificador de controle do Lote de envio do Evento



363
364
365
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 363

def enviarEvento(evento, idLote)
  return enviarLoteDeEvento([ evento ], idLote)
end

#enviarInutilizarNF(documento) ⇒ Object

Enviar Inutilização NF - Necessário um documento assinado OBS: Recomendado quando utilizado o certificado A3 @documento(Hash ou String) = XML ou HASH assinado que será enviado



287
288
289
290
291
292
293
294
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 287

def enviarInutilizarNF(documento)
  versao = "4.00"
  hash = (documento.is_a?(Hash) ? documento : documento.to_hash!)
  wsdl = SEFAZ::Webservice::NFE::WSDL.get(:NfeInutilizacao, @ambiente, @uf)
  conn = SEFAZ::Webservice::NFE::Connection.new(@pkcs12Tss, wsdl, versao, @uf)
  resp = conn.call(:nfe_inutilizacao_nf, hash)
  return [resp.body.to_xml!, resp.body]
end

#enviarLoteDeEvento(lote, idLote) ⇒ Object

Envia Lote de Eventos - Necessário que cada evento esteja assinado OBS: Recomendado quando utilizado o certificado A3 e/ou para envio em lote de eventos

Cada elemento do Array pode ser Hash ou XML assinados

@lote(Array) = Array de eventos assinados @idLote(String) = Identificador de controle do Lote de envio do Evento Exemplo de @lote: @eve1_xml, @eve1_hash = @webservice.exportarCancelarNF(…) @eve2_xml, @eve2_hash = @webservice.exportarCancelarNF(…)



376
377
378
379
380
381
382
383
384
385
386
387
388
389
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 376

def enviarLoteDeEvento(lote, idLote)
  versao = "1.00"
  lote = (lote.map { |el| el.is_a?(Hash) ? el[:evento] : el.to_hash![:evento] })
  hash = {
    envEvento: { :@xmlns => "http://www.portalfiscal.inf.br/nfe", :@versao => versao,
      idLote: idLote,
      evento: lote
    }
  }
  wsdl = SEFAZ::Webservice::NFE::WSDL.get(:RecepcaoEvento, @ambiente, @uf)
  conn = SEFAZ::Webservice::NFE::Connection.new(@pkcs12Tss, wsdl, versao, @uf)
  resp = conn.call(:nfe_recepcao_evento, hash)
  return [resp.body.to_xml!, resp.body]
end

#enviarLoteNF(lote, indSinc, idLote) ⇒ Object

Envia Lote de NF - Necessário que cada NF esteja assinada OBS: Recomendado para envio em lote de NF, cada elemento do Array pode ser Hash ou XML assinados @lote(Array) = Array de NF assinadas @indSinc(String) = “0”=Assíncrono / “1”=Síncrono @idLote(String) = Identificador de controle do Lote de envio do Lote Exemplo de @lote: @nf1_xml, @nf1_hash = @webservice.assinarNF(…) @nf2_xml, @nf2_hash = @webservice.assinarNF(…)



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 159

def enviarLoteNF(lote, indSinc, idLote)
  versao = "4.00"
  lote = (lote.map { |el| el.is_a?(Hash) ? el[:NFe] : el.to_hash![:NFe] })
  hash = {
    enviNFe: { :@xmlns => "http://www.portalfiscal.inf.br/nfe", :@versao => versao,
      idLote: idLote,
      indSinc: indSinc,
      NFe: lote
    }
  }
  wsdl = SEFAZ::Webservice::NFE::WSDL.get(:NFeAutorizacao, @ambiente, @uf)
  conn = SEFAZ::Webservice::NFE::Connection.new(@pkcs12Tss, wsdl, versao, @uf)
  resp = conn.call(:nfe_autorizacao_lote, hash)
  return [resp.body.to_xml!, resp.body]
end

#enviarNF(documento, indSinc, idLote) ⇒ Object

Enviar NF - Necessário uma NF assinada @documento(Hash ou String) = XML ou HASH assinado que será enviado @indSinc(String) = “0”=Assíncrono / “1”=Síncrono @idLote(String) = Identificador de controle do Lote de envio do Lote



146
147
148
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 146

def enviarNF(documento, indSinc, idLote)
  return enviarLoteNF([ documento ], indSinc, idLote)
end

#exportarCancelarNF(chaveNF, sequenciaEvento, dataHoraEvento, numProtocolo, justificativa) ⇒ Object

Exportar Cancelar NF - Exporta um documento bruto (sem assinatura) OBS: Recomendado quando utilizado o certificado A3



317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 317

def exportarCancelarNF(chaveNF, sequenciaEvento, dataHoraEvento, numProtocolo, justificativa)
  versao = "1.00"
  tpEvento = "110111"
  _, hash  = gerarLeiauteEvento(versao, tpEvento, chaveNF, sequenciaEvento, dataHoraEvento)
  hash[:evento][:infEvento][:detEvento] = { :@versao => versao,
    descEvento: "Cancelamento",
    nProt: numProtocolo,
    xJust: justificativa
  }
  return [hash.to_xml!, hash]
end

#exportarCCe(chaveNF, sequenciaEvento, dataHoraEvento, textoCorrecao) ⇒ Object

Exportar CCe - Exporta um documento bruto (sem assinatura) OBS: Recomendado quando utilizado o certificado A3



347
348
349
350
351
352
353
354
355
356
357
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 347

def exportarCCe(chaveNF, sequenciaEvento, dataHoraEvento, textoCorrecao)
  versao = "1.00"
  tpEvento = "110110"
  _, hash  = gerarLeiauteEvento(versao, tpEvento, chaveNF, sequenciaEvento, dataHoraEvento)
  hash[:evento][:infEvento][:detEvento] = { :@versao => versao,
    descEvento: "Carta de Correcao",
    xCorrecao: textoCorrecao,
    xCondUso: "A Carta de Correcao e disciplinada pelo paragrafo 1o-A do art. 7o do Convenio S/N, de 15 de dezembro de 1970 e pode ser utilizada para regularizacao de erro ocorrido na emissao de documento fiscal, desde que o erro nao esteja relacionado com: I - as variaveis que determinam o valor do imposto tais como: base de calculo, aliquota, diferenca de preco, quantidade, valor da operacao ou da prestacao; II - a correcao de dados cadastrais que implique mudanca do remetente ou do destinatario; III - a data de emissao ou de saida."
  }
  return [hash.to_xml!, hash]
end

#exportarInutilizarNF(chaveInut, ano, modelo, serie, nroNFIni, nroNFFin, justificativa) ⇒ Object

Exportar Inutilização NF - Exporta um documento bruto (sem assinatura) OBS: Recomendado quando utilizado o certificado A3

Caso parâmetro @chaveInut estiver em branco, a chave será calculada automaticamente (calculaChaveInutilizacao)



265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 265

def exportarInutilizarNF(chaveInut, ano, modelo, serie, nroNFIni, nroNFFin, justificativa)
  versao  = "4.00"
  chaveInut = calculaChaveInutilizacao(ano, @cnpj, modelo, serie, nroNFIni, nroNFFin) if chaveInut.blank?
  hash = { inutNFe: { :@xmlns => "http://www.portalfiscal.inf.br/nfe", :@versao => versao, infInut: {
    :@Id => chaveInut,
    tpAmb:  @ambiente,
    xServ:  'INUTILIZAR',
    cUF:    @uf,
    ano:    ano,
    CNPJ:   @cnpj,
    mod:    modelo,
    serie:  serie,
    nNFIni: nroNFIni,
    nNFFin: nroNFFin,
    xJust:  justificativa
  } } }
  return [hash.to_xml!, hash]
end

#gerarDANFE(documento, logo_path = nil, logo_dimensions = nil) ⇒ Object

Gerar DANFE - Gera o Documento Auxiliar da Nota Fiscal Eletrônica (DANFE) em PDF @documento(Hash ou String) = XML ou HASH que será tratado @logo_path(String) = Caminho do arquivo de logo (opcional) @logo_dimensions(Hash) = Dimensões do logo (opcional) Exemplo: { width: 100, height: 100 }



395
396
397
398
399
400
401
402
403
404
405
406
407
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 395

def gerarDANFE(documento, logo_path = nil, logo_dimensions = nil)
  xml = (documento.is_a?(Hash) ? documento.to_xml! : documento)
  doc = BrDanfe::Danfe.new(xml)
  
  if Configuration.default.nfe_default_logotipo_enabled
    doc.options. = Configuration.default.nfe_default_logotipo_path
    doc.options.logo_dimensions = Configuration.default.nfe_default_logotipo_dimensions
  end

  doc.options. = logo_path if logo_path
  doc.options.logo_dimensions = logo_dimensions if logo_dimensions
  return doc.render_pdf
end

#gerarDocCancelamento(documento) ⇒ Object

Gerar Documento de Cancelamento em PDF @documento(Hash ou String) = XML ou HASH que será tratado



411
412
413
414
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 411

def gerarDocCancelamento(documento)
  hash = (documento.is_a?(Hash) ? documento : documento.to_hash!)
  SEFAZ::Webservice::NFE::Templates::EventoCancelamento.new.render(hash)
end

#gerarDocCartaCorrecao(documento) ⇒ Object

Gerar Documento de Carta de Correção Eletrônica (CCe) em PDF @documento(Hash ou String) = XML ou HASH que será tratado



418
419
420
421
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 418

def gerarDocCartaCorrecao(documento)
  hash = (documento.is_a?(Hash) ? documento : documento.to_hash!)
  SEFAZ::Webservice::NFE::Templates::EventoCartaCorrecao.new.render(hash)
end

#gerarDocInutilizacao(documento) ⇒ Object

Gerar Documento de Inutilização em PDF @documento(Hash ou String) = XML ou HASH que será tratado



425
426
427
428
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 425

def gerarDocInutilizacao(documento)
  hash = (documento.is_a?(Hash) ? documento : documento.to_hash!)
  SEFAZ::Webservice::NFE::Templates::EventoInutilizacao.new.render(hash)
end

#gerarInfRespTec(documento) ⇒ Object

Gera Informações do Responsável Técnico - Calcula o hashCSRT e cria o grupo do responsável técnico Necessário quando estiver emitindo uma NF-e/NFC-e @documento(Hash ou String) = XML ou HASH que será tratado



433
434
435
436
437
438
439
440
441
442
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 433

def gerarInfRespTec(documento)
  hash = (documento.is_a?(Hash) ? documento : documento.to_hash!)
  chaveNF = hash[:NFe][:infNFe][:@Id].to_s.delete("^0-9")
  concat = @CSRT.to_s + chaveNF.to_s
  hexdigest = Digest::SHA1.hexdigest(concat)
  hashCSRT  = Base64.strict_encode64(hexdigest)
  infRespTec = { infRespTec: { CNPJ: @cnpjTec, xContato: @contatoTec, email: @emailTec, fone: @foneTec, idCSRT: @idCSRT, hashCSRT: hashCSRT } }.compress!
  hash[:NFe][:infNFe][:infRespTec] = infRespTec[:infRespTec]
  return [hash.to_xml!, hash]
end

#inutilizarNF(chaveInut, ano, modelo, serie, nroNFIni, nroNFFin, justificativa) ⇒ Object

Inutilizar NF - Gera, assina e envia o documento com certificado A1 (exportarInutilizarNF, assinarNF, enviarInutilizarNF) OBS: Caso parâmetro @chaveInut estiver em branco, a chave será calculada automaticamente (calculaChaveInutilizacao)



235
236
237
238
239
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 235

def inutilizarNF(chaveInut, ano, modelo, serie, nroNFIni, nroNFFin, justificativa)
  _, hash = exportarInutilizarNF(chaveInut, ano, modelo, serie, nroNFIni, nroNFFin, justificativa)
  _, hash = assinarNF(hash)
  return enviarInutilizarNF(hash)
end

#setaAmbiente(params = {}) ⇒ Object 



59
60
61
62
63
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 59

def setaAmbiente(params = {})
  @uf = params[:uf]
  @ambiente = params[:ambiente]
  @cnpj = params[:cnpj].to_s.delete("^0-9")
end

#setaPFXAss(params = {}) ⇒ Object 



78
79
80
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 78

def setaPFXAss(params = {})
  @pkcs12Ass = OpenSSL::PKCS12.new(params[:pfx], params[:senha])
end

#setaPFXTss(params = {}) ⇒ Object 



74
75
76
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 74

def setaPFXTss(params = {})
  @pkcs12Tss = OpenSSL::PKCS12.new(params[:pfx], params[:senha])
end

#setaRespTecnico(params = {}) ⇒ Object 



65
66
67
68
69
70
71
72
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 65

def setaRespTecnico(params = {})
  @cnpjTec = params[:cnpj]
  @contatoTec = params[:contato]
  @emailTec = params[:email]
  @foneTec = params[:fone]
  @idCSRT = params[:idCSRT]
  @CSRT = params[:CSRT]
end

#statusDoServico ⇒ Object

Consulta Status SEFAZ



83
84
85
86
87
88
89
90
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 83

def statusDoServico
  versao = "4.00"
  hash = { consStatServ: { tpAmb: @ambiente, cUF: @uf, xServ: 'STATUS', :@xmlns => "http://www.portalfiscal.inf.br/nfe", :@versao => versao } }
  wsdl = SEFAZ::Webservice::NFE::WSDL.get(:NfeStatusServico, @ambiente, @uf)
  conn = SEFAZ::Webservice::NFE::Connection.new(@pkcs12Tss, wsdl, versao, @uf)
  resp = conn.call(:nfe_status_servico_nf, hash)
  return [resp.body.to_xml!, resp.body]
end

#validarNF(documento, openTimeout = 60, readTimeout = 60) ⇒ Object

Valida NF no SEFAZ RS NF-e (www.sefaz.rs.gov.br/NFE/NFE-VAL.aspx) @documento(Hash ou String) = XML ou HASH que será validado @openTimeout(Integer) = Tempo de espera em segundos para abrir conexão (opcional: padrão 60) @readTimeout(Integer) = Tempo de espera em segundos para ler resposta (opcional: padrão 60)



202
203
204
205
206
207
208
209
210
 
# File 'lib/sefaz/webservice/nfe/client.rb', line 202

def validarNF(documento, openTimeout = 60, readTimeout = 60)
  xml = (documento.is_a?(Hash) ? documento.to_xml! : documento)
  validator = SEFAZ::Webservice::NFE::Validator.new(xml)
  stat, msg, err = validator.exec(openTimeout, readTimeout)
  case stat
  when :ok; return [true, msg, err]
  else      return [false, {}, {}]
  end
end