nfcom 0.1.2

data/lib/nfcom/builder/qrcode.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'rqrcode'
+require_relative '../validators/schema_validator'
+
+module Nfcom
+  module Builder
+    # Gera a URL e SVG do QR Code para consulta da NF-COM.
+    #
+    # Esta classe cria a URL que será codificada em um QR Code, permitindo que os clientes
+    # validem a NF-COM diretamente no portal da SEFAZ.
+    #
+    # A URL gerada contém os seguintes parâmetros:
+    # - chNFCom: Chave de acesso da NF-COM
+    # - tpAmb: Código do ambiente (1 = produção, 2 = homologação)
+    class Qrcode
+      # @return [String] chave de acesso da NF-COM
+      attr_reader :chave
+
+      # @return [Symbol] ambiente :producao ou :homologacao
+      attr_reader :ambiente
+
+      # Inicializa o gerador de QR Code
+      #
+      # @param chave [String] chave de acesso da NF-COM
+      # @param ambiente [Symbol] :producao ou :homologacao
+      #
+      # @raise [ArgumentError] se algum argumento estiver ausente ou inválido
+      def initialize(chave, ambiente)
+        raise ArgumentError, 'Chave de acesso não pode ser vazia' if chave.nil? || chave.strip.empty?
+        unless Nfcom::Validators::SchemaValidator.valido_por_schema?(chave, :er3)
+          raise ArgumentError, "Chave de acesso inválida: #{chave}"
+        end
+
+        raise ArgumentError, 'Ambiente deve ser :producao ou :homologacao' unless %i[producao
+                                                                                     homologacao].include?(ambiente)
+
+        @chave = chave
+        @ambiente = ambiente
+      end
+
+      # Gera a URL do QR Code
+      #
+      # @return [String] URL completa
+      def gerar_url
+        base_url = 'https://dfe-portal.svrs.rs.gov.br/nfcom/qrcode'
+        tp_amb = ambiente == :homologacao ? 2 : 1
+
+        "#{base_url}?#{URI.encode_www_form(chNFCom: chave, tpAmb: tp_amb)}"
+      end
+
+      # Gera a imagem SVG do QR Code
+      #
+      # @return [String] SVG do QR Code
+      def gerar_qrcode_svg
+        qr = RQRCode::QRCode.new(gerar_url)
+        qr.as_svg(
+          offset: 0,
+          color: '000',
+          shape_rendering: 'crispEdges',
+          module_size: 6,
+          standalone: true
+        )
+      end
+    end
+  end
+end

data/lib/nfcom/builder/signature.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'openssl'
+require 'base64'
+
+module Nfcom
+  module Builder
+    class Signature
+      ALGORITHMS = {
+        c14n: 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315',
+        rsa_sha1: 'http://www.w3.org/2000/09/xmldsig#rsa-sha1',
+        sha1: 'http://www.w3.org/2000/09/xmldsig#sha1',
+        enveloped: 'http://www.w3.org/2000/09/xmldsig#enveloped-signature'
+      }.freeze
+
+      DSIG_NS = 'http://www.w3.org/2000/09/xmldsig#'
+
+      def initialize(configuration)
+        @configuration = configuration
+        @certificate = Utils::Certificate.new(
+          configuration.certificado_path,
+          configuration.certificado_senha
+        )
+      end
+
+      def assinar(xml_string)
+        # Parse XML
+        doc = Nokogiri::XML(xml_string)
+
+        # Find infNFCom element
+        inf_nfcom = doc.at_xpath(
+          '//nfcom:infNFCom',
+          'nfcom' => 'http://www.portalfiscal.inf.br/nfcom'
+        )
+
+        raise Errors::XmlError, 'infNFCom element not found' unless inf_nfcom
+
+        # Get reference URI
+        ref_uri = "##{inf_nfcom['Id']}"
+
+        # Calculate digest of canonicalized infNFCom
+        digest_value = calculate_digest(inf_nfcom)
+
+        # Build SignedInfo
+        signed_info = build_signed_info(ref_uri, digest_value)
+
+        # Calculate signature of canonicalized SignedInfo
+        signature_value = calculate_signature(signed_info)
+
+        # Build complete Signature element
+        signature_xml = build_signature_xml(signed_info, signature_value, certificate_value)
+
+        # Insert Signature into NFCom
+        insert_signature(doc, signature_xml)
+
+        # Return signed XML
+        doc.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
+      end
+
+      private
+
+      def calculate_digest(element)
+        # Canonicalize using C14N 1.0
+        canonicalized = element.canonicalize(Nokogiri::XML::XML_C14N_1_0)
+
+        # Calculate SHA1 digest
+        digest = OpenSSL::Digest::SHA1.digest(canonicalized)
+
+        # Return Base64 encoded
+        Base64.strict_encode64(digest)
+      end
+
+      def build_signed_info(ref_uri, digest_value)
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.SignedInfo(xmlns: DSIG_NS) do
+            # Use exact algorithm URIs required by NFCom
+            xml.CanonicalizationMethod(Algorithm: ALGORITHMS[:c14n])
+            xml.SignatureMethod(Algorithm: ALGORITHMS[:rsa_sha1])
+
+            xml.Reference(URI: ref_uri) do
+              xml.Transforms do
+                xml.Transform(Algorithm: ALGORITHMS[:enveloped])
+                xml.Transform(Algorithm: ALGORITHMS[:c14n])
+              end
+              xml.DigestMethod(Algorithm: ALGORITHMS[:sha1])
+              xml.DigestValue digest_value
+            end
+          end
+        end
+
+        builder.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
+      end
+
+      def calculate_signature(signed_info_xml)
+        # Parse SignedInfo
+        signed_info_doc = Nokogiri::XML(signed_info_xml)
+
+        # Canonicalize using C14N 1.0
+        canonicalized = signed_info_doc.canonicalize(Nokogiri::XML::XML_C14N_1_0)
+
+        # Sign with RSA-SHA1
+        signature = @certificate.key.sign(OpenSSL::Digest.new('SHA1'), canonicalized)
+
+        # Return Base64 encoded
+        Base64.strict_encode64(signature)
+      end
+
+      def certificate_value
+        # Get certificate as DER, then Base64 encode
+        # Remove PEM headers/footers, just the certificate data
+        cert_der = @certificate.cert.to_der
+        Base64.strict_encode64(cert_der)
+      end
+
+      def build_signature_xml(signed_info_xml, signature_value, cert_value)
+        # Parse SignedInfo to get the element
+        signed_info_doc = Nokogiri::XML(signed_info_xml)
+        signed_info_element = signed_info_doc.root
+
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.Signature(xmlns: DSIG_NS) do
+            # Insert SignedInfo element
+            xml.parent << signed_info_element
+
+            xml.SignatureValue signature_value
+
+            xml.KeyInfo do
+              xml.X509Data do
+                xml.X509Certificate cert_value
+              end
+            end
+          end
+        end
+
+        builder.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
+      end
+
+      def insert_signature(doc, signature_xml)
+        # Parse signature
+        signature_doc = Nokogiri::XML(signature_xml)
+        signature_element = signature_doc.root
+
+        # Find NFCom root element
+        nfcom_element = doc.at_xpath(
+          '//nfcom:NFCom',
+          'nfcom' => 'http://www.portalfiscal.inf.br/nfcom'
+        )
+
+        raise Errors::XmlError, 'NFCom element not found' unless nfcom_element
+
+        nfcom_element.add_child(signature_element)
+      end
+    end
+  end
+end

data/lib/nfcom/builder/xml_builder.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Nfcom
+  module Builder
+    # Construtor de XML para NFCom (Nota Fiscal de Comunicação)
+    #
+    # Esta classe é responsável por gerar o XML completo da NFCom
+    # seguindo o layout 1.00 do schema oficial da SEFAZ.
+    class XmlBuilder
+      include Utils::Helpers
+
+      attr_reader :nota, :configuration
+
+      VERSAO_LAYOUT = '1.00'
+      NAMESPACE = 'http://www.portalfiscal.inf.br/nfcom'
+      MODELO_NFCOM = 62
+
+      # Indicadores de IE do destinatário
+      INDIEDEST_CONTRIBUINTE = 1
+      INDIEDEST_ISENTO = 2
+      INDIEDEST_NAO_CONTRIBUINTE = 9
+
+      def initialize(nota, configuration)
+        @nota = nota
+        @configuration = configuration
+      end
+
+      # Gera o XML completo da NFCom
+      # @return [String] XML formatado em UTF-8
+      def gerar
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml.NFCom(xmlns: NAMESPACE) do
+            xml.infNFCom(versao: VERSAO_LAYOUT, Id: "NFCom#{nota.chave_acesso}") do
+              gerar_ide(xml)
+              gerar_emit(xml)
+              gerar_dest(xml)
+              gerar_assinante(xml) if nota.assinante
+              gerar_sub(xml) if nota.finalidade == :substituicao
+              # gCofat iria aqui (cofaturamento)
+              gerar_detalhes(xml)
+              gerar_total(xml)
+              # gFidelidade iria aqui (programa de fidelidade)
+              gerar_fatura(xml) if nota.fatura
+              # gFatCentral iria aqui (faturamento centralizado)
+              # autXML iria aqui (autorizados para download)
+              gerar_info_adicional(xml) if nota.informacoes_adicionais
+              # gRespTec iria aqui (responsável técnico)
+            end
+
+            gerar_info_suplementar(xml)
+          end
+        end
+
+        builder.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
+      end
+
+      private
+
+      # Gera o grupo de identificação da NFCom (tag ide)
+      def gerar_ide(xml)
+        xml.ide do
+          xml.cUF configuration.codigo_uf
+          xml.tpAmb configuration.ambiente_codigo
+          xml.mod MODELO_NFCOM
+          xml.serie nota.serie
+          xml.nNF nota.numero
+          xml.cNF nota.codigo_verificacao
+          xml.cDV nota.chave_acesso[-1].to_i
+          xml.dhEmi formatar_data_hora(nota.data_emissao)
+          xml.tpEmis nota.tipo_emissao_codigo
+          xml.nSiteAutoriz 0 # Zero para autorizador com único site
+          xml.cMunFG nota.emitente.endereco.codigo_municipio
+          xml.finNFCom nota.finalidade_codigo
+          xml.tpFat nota.tipo_faturamento || 0 # 0=Normal, 1=Centralizado, 2=Cofaturamento
+          xml.verProc 'Nfcom-Ruby-1.0'
+
+          # Campos de contingência (se aplicável)
+          if nota.tipo_emissao == :contingencia
+            xml.dhCont formatar_data_hora(nota.data_contingencia) if nota.data_contingencia
+            xml.xJust limitar_texto(nota.justificativa_contingencia, 256) if nota.justificativa_contingencia
+          end
+        end
+      end
+
+      # Gera o grupo de dados do emitente (tag emit)
+      def gerar_emit(xml)
+        xml.emit do
+          xml.CNPJ apenas_numeros(nota.emitente.cnpj)
+          xml.IE apenas_numeros(nota.emitente.inscricao_estadual)
+          # IEUFDest - IE virtual na UF destino (opcional para partilha)
+          xml.CRT nota.emitente.regime_tributario_codigo || 3 # 1=Simples, 2=Simples excesso, 3=Normal
+          xml.xNome limitar_texto(nota.emitente.razao_social, 60)
+          xml.xFant limitar_texto(nota.emitente.nome_fantasia, 60) if nota.emitente.nome_fantasia
+          gerar_endereco(xml, nota.emitente.endereco, 'emit')
+        end
+      end
+
+      # Gera o grupo de dados do destinatário (tag dest)
+      def gerar_dest(xml)
+        xml.dest do
+          xml.xNome limitar_texto(nota.destinatario.razao_social, 60)
+
+          cpf  = apenas_numeros(nota.destinatario.cpf)
+          cnpj = apenas_numeros(nota.destinatario.cnpj)
+          ie   = apenas_numeros(nota.destinatario.inscricao_estadual)
+
+          # CPF ou CNPJ (mutuamente exclusivo)
+          if cnpj.to_s.strip == ''
+            xml.CPF cpf
+          else
+            xml.CNPJ cnpj
+          end
+
+          if cnpj.to_s.strip != '' && ie.to_s.strip != ''
+            # PJ com IE → Contribuinte
+            xml.indIEDest INDIEDEST_CONTRIBUINTE
+            xml.IE ie
+          else
+            # PF ou PJ sem IE → Não contribuinte
+            xml.indIEDest INDIEDEST_NAO_CONTRIBUINTE
+          end
+
+          gerar_endereco(xml, nota.destinatario.endereco, 'dest')
+        end
+      end
+
+      # Gera o grupo de dados do assinante (tag assinante)
+      def gerar_assinante(xml)
+        assinante = nota.assinante
+        return unless assinante
+
+        xml.assinante do
+          # Código único do assinante (1-30 caracteres)
+          xml.iCodAssinante limitar_texto(assinante.codigo, 30)
+
+          # Tipo: 1=Comercial, 2=Industrial, 3=Residencial, 4=Rural, 5=Público, 6=Telecom,
+          # 7=Diplomático, 8=Religioso, 99=Outros
+          xml.tpAssinante assinante.tipo
+
+          # Tipo serviço: 1=Telefonia, 2=Dados, 3=TV, 4=Internet, 5=Multimídia, 6=Outros, 7=Vários
+          xml.tpServUtil assinante.tipo_servico
+
+          # Dados do contrato (opcional)
+          xml.nContrato limitar_texto(assinante.numero_contrato, 20) if assinante.numero_contrato
+          xml.dContratoIni formatar_data(assinante.data_inicio_contrato) if assinante.data_inicio_contrato
+          xml.dContratoFim formatar_data(assinante.data_fim_contrato) if assinante.data_fim_contrato
+
+          # Terminal principal (condicional - se informar um, deve informar ambos)
+          if assinante.terminal_principal && assinante.uf_terminal_principal
+            xml.NroTermPrinc apenas_numeros(assinante.terminal_principal)
+            xml.cUFPrinc assinante.uf_terminal_principal
+          end
+
+          # Terminais adicionais (0-n ocorrências)
+          assinante.terminais_adicionais&.each do |terminal|
+            xml.NroTermAdic apenas_numeros(terminal[:numero])
+            xml.cUFAdic terminal[:uf]
+          end
+        end
+      end
+
+      # Gera o grupo de faturamento (tag gFat)
+      # Contém apenas informações de controle de cobrança, NÃO valores
+      def gerar_fatura(xml)
+        xml.gFat do
+          # Competência no formato AAAAMM (ex: 202601)
+          xml.CompetFat nota.fatura.competencia
+
+          # Data de vencimento no formato AAAA-MM-DD
+          xml.dVencFat nota.fatura.data_vencimento
+
+          # Período de uso do serviço (ambos ou nenhum)
+          if nota.fatura.periodo_uso_inicio && nota.fatura.periodo_uso_fim
+            xml.dPerUsoIni formatar_data(nota.fatura.periodo_uso_inicio)
+            xml.dPerUsoFim formatar_data(nota.fatura.periodo_uso_fim)
+          end
+
+          # Linha digitável do código de barras (obrigatório)
+          xml.codBarras nota.fatura.codigo_barras
+
+          # Débito automático (opcional - se informar um, deve informar todos)
+          if nota.fatura.codigo_debito_automatico
+            xml.codDebAuto nota.fatura.codigo_debito_automatico
+            xml.codBanco nota.fatura.codigo_banco
+            xml.codAgencia nota.fatura.codigo_agencia
+          end
+
+          # enderCorresp - Endereço de correspondência (opcional)
+          # gPIX - Informações do PIX (opcional)
+        end
+      end
+
+      # Gera o endereço do emitente ou destinatário
+      # @param xml [Nokogiri::XML::Builder] Builder do XML
+      # @param endereco [Endereco] Objeto com dados do endereço
+      # @param tipo [String] 'emit' ou 'dest'
+      def gerar_endereco(xml, endereco, tipo)
+        tag_name = tipo == 'emit' ? 'enderEmit' : 'enderDest'
+
+        xml.send(tag_name) do
+          xml.xLgr limitar_texto(endereco.logradouro, 60)
+          xml.nro limitar_texto(endereco.numero, 60)
+          xml.xCpl limitar_texto(endereco.complemento, 60) if endereco.complemento
+          xml.xBairro limitar_texto(endereco.bairro, 60)
+          xml.cMun endereco.codigo_municipio
+          xml.xMun limitar_texto(endereco.municipio, 60)
+          xml.CEP apenas_numeros(endereco.cep)
+          xml.UF endereco.uf
+
+          # País apenas para destinatário
+          if tipo == 'dest'
+            xml.cPais endereco.codigo_pais || 1058 # 1058 = Brasil (tabela BACEN)
+            xml.xPais endereco.pais || 'Brasil'
+          end
+
+          xml.fone apenas_numeros(endereco.telefone) if endereco.telefone
+        end
+      end
+
+      # Gera os itens/serviços da NFCom (tag det)
+      def gerar_detalhes(xml)
+        nota.itens.each do |item|
+          xml.det(nItem: item.numero_item) do
+            gerar_produto(xml, item)
+            gerar_impostos_item(xml, item)
+          end
+        end
+      end
+
+      # Gera os dados do produto/serviço (tag prod)
+      def gerar_produto(xml, item)
+        xml.prod do
+          xml.cProd item.codigo_servico
+          xml.xProd limitar_texto(item.descricao, 120)
+          xml.cClass item.classe_consumo # Código de classificação do item (tabela ANATEL)
+          xml.CFOP item.cfop
+          xml.uMed item.unidade # 1=Minuto, 2=MB, 3=GB, 4=UN
+          xml.qFaturada formatar_decimal(item.quantidade, 4)
+
+          # vItem = valor unitário, vProd = valor total do item
+          xml.vItem formatar_decimal(item.valor_unitario)
+          xml.vProd formatar_decimal(item.valor_total)
+
+          # Valores opcionais
+          xml.vDesc formatar_decimal(item.valor_desconto) if item.valor_desconto&.positive?
+          xml.vOutro formatar_decimal(item.valor_outras_despesas) if item.valor_outras_despesas&.positive?
+        end
+      end
+
+      # Gera os impostos do item (tag imposto)
+      def gerar_impostos_item(xml, _item)
+        xml.imposto do
+          # ICMS00 - Tributação normal do ICMS
+          # Para ISPs normalmente BC=0 (serviço isento ou não tributado)
+          xml.ICMS00 do
+            xml.CST '00' # 00 = Tributação normal
+            xml.vBC '0.00' # Base de cálculo (0.00 para isentos)
+            xml.pICMS '0.00' # Alíquota do ICMS
+            xml.vICMS '0.00' # Valor do ICMS
+          end
+
+          # PIS - Programa de Integração Social (se aplicável)
+          # xml.PIS do
+          #   xml.CST '01' # 01=Tributável com alíquota básica
+          #   xml.vBC formatar_decimal(item.valor_total)
+          #   xml.pPIS '0.65' # Alíquota padrão 0.65%
+          #   xml.vPIS formatar_decimal(item.valor_total * 0.0065)
+          # end
+
+          # COFINS - Contribuição para Financiamento da Seguridade Social (se aplicável)
+          # xml.COFINS do
+          #   xml.CST '01' # 01=Tributável com alíquota básica
+          #   xml.vBC formatar_decimal(item.valor_total)
+          #   xml.pCOFINS '3.00' # Alíquota padrão 3%
+          #   xml.vCOFINS formatar_decimal(item.valor_total * 0.03)
+          # end
+
+          # FUST - Fundo de Universalização dos Serviços de Telecomunicações (se aplicável)
+          # FUNTTEL - Fundo para o Desenvolvimento Tecnológico (se aplicável)
+        end
+      end
+
+      # Gera os totalizadores da NFCom (tag total)
+      def gerar_total(xml)
+        xml.total do
+          # Valor total dos produtos/serviços
+          xml.vProd formatar_decimal(nota.total.valor_servicos)
+
+          # Totais de ICMS
+          xml.ICMSTot do
+            xml.vBC formatar_decimal(nota.total.icms_base_calculo)
+            xml.vICMS formatar_decimal(nota.total.icms_valor)
+            xml.vICMSDeson formatar_decimal(nota.total.icms_desonerado || 0)
+            xml.vFCP formatar_decimal(nota.total.fcp_valor || 0) # Fundo de Combate à Pobreza
+          end
+
+          # Tributos federais
+          xml.vCOFINS formatar_decimal(nota.total.cofins_valor)
+          xml.vPIS formatar_decimal(nota.total.pis_valor)
+          xml.vFUNTTEL formatar_decimal(nota.total.funttel_valor || 0)
+          xml.vFUST formatar_decimal(nota.total.fust_valor || 0)
+
+          # Retenções na fonte
+          xml.vRetTribTot do
+            xml.vRetPIS formatar_decimal(nota.total.pis_retido || 0)
+            xml.vRetCofins formatar_decimal(nota.total.cofins_retido || 0)
+            xml.vRetCSLL formatar_decimal(nota.total.csll_retido || 0)
+            xml.vIRRF formatar_decimal(nota.total.irrf_retido || 0)
+          end
+
+          # Descontos e acréscimos
+          xml.vDesc formatar_decimal(nota.total.valor_desconto)
+          xml.vOutro formatar_decimal(nota.total.valor_outras_despesas)
+
+          # Valor total da NFCom (deve ser o último campo)
+          xml.vNF formatar_decimal(nota.total.valor_total)
+        end
+      end
+
+      # Gera informações adicionais (tag infAdic)
+      def gerar_info_adicional(xml)
+        return unless nota.informacoes_adicionais&.any?
+
+        xml.infAdic do
+          nota.informacoes_adicionais.each do |texto|
+            xml.infCpl texto
+          end
+        end
+      end
+
+      # Gera informações suplementares (tag infNFComSupl)
+      # Contém o QR Code para consulta da NFCom
+      def gerar_info_suplementar(xml)
+        xml.infNFComSupl do
+          xml.qrCodNFCom gerar_qrcode
+        end
+      end
+
+      # Gera a URL do QR Code para consulta da NFCom
+      # @return [String] URL completa do QR Code
+      def gerar_qrcode
+        base_url = 'https://dfe-portal.svrs.rs.gov.br/nfcom/qrcode'
+
+        # Formato: URL?chNFCom=CHAVE&tpAmb=AMBIENTE
+        "#{base_url}?chNFCom=#{nota.chave_acesso}&tpAmb=#{configuration.ambiente_codigo}"
+      end
+
+      # Gera o grupo de informações da substituição (tag gSub)
+      # Obrigatório quando finNFCom = 3 (Substituição)
+      def gerar_sub(xml)
+        return unless nota.chave_nfcom_substituida
+
+        xml.gSub do
+          xml.chNFCom nota.chave_nfcom_substituida
+          xml.motSub nota.motivo_substituicao.to_s.rjust(2, '0')
+        end
+      end
+    end
+  end
+end

data/lib/nfcom/client.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Nfcom
+  class Client
+    attr_reader :configuration
+
+    def initialize(config = nil)
+      @configuration = config || Nfcom.configuration
+      raise Errors::ConfigurationError, 'Nfcom não está configurado' if @configuration.nil?
+    end
+
+    # Autoriza uma nota fiscal
+    def autorizar(nota) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      validar_configuracao!
+
+      raise Errors::ValidationError, nota.erros.join(', ') unless nota.valida?
+
+      # Gera chave de acesso
+      nota.gerar_chave_acesso
+
+      # Constrói XML
+      xml_builder = Builder::XmlBuilder.new(nota, configuration)
+      xml = xml_builder.gerar
+
+      # Assina XML
+      signature = Builder::Signature.new(configuration)
+      xml_assinado = signature.assinar(xml)
+
+      tentativa = 0
+      begin
+        ws = Webservices::Autorizacao.new(configuration)
+        resposta = ws.enviar(xml_assinado)
+
+        parser = Parsers::Autorizacao.new(resposta)
+        resultado = parser.parse
+
+        nota.protocolo = resultado[:protocolo]
+        nota.data_autorizacao = resultado[:data_autorizacao]
+        nota.xml_autorizado = Utils::XmlAuthorized.build_nfcom_proc(
+          xml_assinado: xml_assinado,
+          xml_protocolo: resultado[:xml]
+        )
+
+        resultado
+      rescue Errors::SefazIndisponivel => e
+        tentativa += 1
+        raise e unless tentativa < configuration.max_tentativas
+
+        sleep(configuration.tempo_espera_retry**tentativa)
+        retry
+      end
+    end
+
+    # Consulta uma nota pela chave de acesso
+    def consultar_nota(chave:)
+      validar_configuracao!
+
+      ws = Webservices::Consulta.new(configuration)
+      resposta = ws.consultar(chave)
+
+      parser = Parsers::Consulta.new(resposta)
+      parser.parse
+    end
+
+    # Verifica status do serviço da SEFAZ
+    def status_servico
+      validar_configuracao!
+
+      ws = Webservices::Status.new(configuration)
+      resposta = ws.verificar
+
+      parser = Parsers::Status.new(resposta)
+      parser.parse
+    end
+
+    # Inutiliza uma numeração de nota
+    def inutilizar(serie:, numero_inicial:, numero_final:, justificativa:)
+      validar_configuracao!
+
+      raise Errors::ValidationError, 'Justificativa deve ter no mínimo 15 caracteres' if justificativa.length < 15
+
+      ws = Webservices::Inutilizacao.new(configuration)
+      resposta = ws.inutilizar(
+        serie: serie,
+        numero_inicial: numero_inicial,
+        numero_final: numero_final,
+        justificativa: justificativa
+      )
+
+      parser = Parsers::Inutilizacao.new(resposta)
+      parser.parse
+    end
+
+    private
+
+    def validar_configuracao!
+      erros = []
+      erros << 'Certificado não configurado' if configuration.certificado_path.nil?
+      erros << 'CNPJ não configurado' if configuration.cnpj.nil?
+      erros << 'Inscrição Estadual não configurada' if configuration.inscricao_estadual.nil?
+      erros << 'Estado não configurado' if configuration.estado.nil?
+
+      raise Errors::ConfigurationError, erros.join(', ') unless erros.empty?
+    end
+  end
+end