nfcom 0.1.2

data/lib/nfcom/validators/schema_validator.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Validators
+    # Validadores baseados no Schema NFCom v1.00
+    # Expressões Regulares (ER) conforme documentação oficial SEFAZ
+    module SchemaValidator # rubocop:disable Metrics/ModuleLength
+      # Expressões Regulares do Schema NFCom
+      REGEX_PATTERNS = {
+        # ER1 - Data/hora no formato AAAA-MM-DDTHH:MM:SS+HH:MM
+        er1: /
+          \A
+          (
+            (20(([02468][048])|([13579][26]))-02-29) |
+            (20[0-9][0-9])-
+            (
+              (((0[1-9])|(1[0-2]))-((0[1-9])|(1\d)|(2[0-8]))) |
+              ((((0[13578])|(1[02]))-31)) |
+              (((0[1,3-9])|(1[0-2]))-(29|30))
+            )
+          )
+          T
+          (20|21|22|23|[0-1]\d):
+          [0-5]\d:
+          [0-5]\d
+          (
+            [-,+](0[0-9]|10|11):00 |
+            (\+(12):00)
+          )
+          \z
+        /x,
+
+        # ER2 - 7 dígitos (cNF, cMun, etc)
+        er2: /\A[0-9]{7}\z/,
+
+        # ER3 - Chave de acesso (44 dígitos)
+        er3: /\A[0-9]{6}[A-Z0-9]{12}[0-9]{26}\z/,
+
+        # ER7 - CNPJ (14 dígitos)
+        er7: /\A[A-Z0-9]{12}[0-9]{2}\z/,
+
+        # ER8 - CNPJ opcional (0 ou 14 dígitos)
+        er8: /\A([0-9]{0}|[A-Z0-9]{12}[0-9]{2})\z/,
+
+        # ER9 - CPF (11 dígitos)
+        er9: /\A[0-9]{11}\z/,
+
+        # ER11 - Alíquota ICMS (3,2)
+        er11: /\A(0|0\.[0-9]{2}|[1-9]{1}[0-9]{0,2}(\.[0-9]{2})?)\z/,
+
+        # ER16 - Percentual (3,2-4)
+        er16: /\A(0|0\.[0-9]{2,4}|[1-9]{1}[0-9]{0,2}(\.[0-9]{2,4})?)\z/,
+
+        # ER31 - Quantidade (11,0-4)
+        er31: /\A[0-9]{1,11}(\.[0-9]{2,4})?\z/,
+
+        # ER36 - Valor (13,2)
+        er36: /\A(0|0\.[0-9]{2}|[1-9]{1}[0-9]{0,12}(\.[0-9]{2})?)\z/,
+
+        # ER37 - Valor (13,2) - pode ser zero
+        er37: /\A0\.[0-9]{2}|[1-9]{1}[0-9]{0,12}(\.[0-9]{2})?\z/,
+
+        # ER39 - Valor (13,2-8)
+        er39: /\A[0-9]{1,13}(\.[0-9]{2,8})?\z/,
+
+        # ER41 - IE (0-14 dígitos ou ISENTO)
+        er41: /\A([0-9]{0,14}|ISENTO)\z/,
+
+        # ER42 - IE (2-14 dígitos)
+        er42: /\A[0-9]{2,14}\z/,
+
+        # ER43 - Número NF (1-9 dígitos, não pode começar com zero)
+        er43: /\A[1-9]{1}[0-9]{0,8}\z/,
+
+        # ER44 - Série (0 ou 1-999)
+        er44: /\A(0|[1-9]{1}[0-9]{0,2})\z/,
+
+        # ER47 - Texto geral (1-infinito caracteres, não pode ter apenas espaços)
+        er47: /\A[^\r\n\t]*[!-ÿ][^\r\n\t]*\z/,
+
+        # ER48 - Data AAAA-MM-DD
+        er48: /
+          \A
+          (
+            (20|19|18)(([02468][048])|([13579][26]))-02-29 |
+            (20|19|18)[0-9][0-9]-
+            (
+              (((0[1-9])|(1[0-2]))-((0[1-9])|(1\d)|(2[0-8]))) |
+              ((((0[13578])|(1[02]))-31)) |
+              (((0[1,3-9])|(1[0-2]))-(29|30))
+            )
+          )
+          \z
+        /x,
+
+        # ER57 - 1 dígito
+        er57: /\A[0-9]{1}\z/,
+
+        # ER58 - Texto (0 ou 2-20 caracteres)
+        er58: /\A([!-ÿ]{0}|[!-ÿ]{2,20})?\z/,
+
+        # ER59 - Texto (0 ou 1-30 caracteres)
+        er59: /\A([!-ÿ]{0}|[!-ÿ]{1,30})?\z/,
+
+        # ER60 - Texto (0 ou 1-20 caracteres)
+        er60: /\A([!-ÿ]{0}|[!-ÿ]{1,20})?\z/,
+
+        # ER61 - Telefone (7-12 dígitos)
+        er61: /\A[0-9]{7,12}\z/,
+
+        # ER62 - Número item (1-9999)
+        er62: /\A[1-9]{1}[0-9]{0,3}\z/,
+
+        # ER63 - Número (1-20 dígitos)
+        er63: /\A[0-9]{1,20}\z/,
+
+        # ER64 - Código barras (1-48 dígitos)
+        er64: /\A[0-9]{1,48}\z/,
+
+        # ER65 - ID com prefixo NFCom
+        er65: /\ANFCom[0-9]{6}[A-Z0-9]{12}[0-9]{26}\z/,
+
+        # ER67 - CEP (8 dígitos)
+        er67: /\A[0-9]{8}\z/,
+
+        # ER70 - Versão (1.00)
+        er70: /\A1\.00\z/,
+
+        # ER72 - Email
+        er72: /\A[^@]+@[^.]+\..+\z/,
+
+        # ER73 - CFOP
+        er73: /\A[123567][0-9]([0-9][1-9]|[1-9][0-9])\z/,
+
+        # ER74 - Competência (1-6 dígitos)
+        er74: /\A[0-9]{1,6}\z/
+      }.freeze
+
+      DOMAINS = {
+        # D1 - Códigos UF (IBGE)
+        d1: [11, 12, 13, 14, 15, 16, 17, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             31, 32, 33, 35, 41, 42, 43, 50, 51, 52, 53],
+
+        # D4 - Modelo NFCom
+        d4: [62],
+
+        # D5 - Siglas UF
+        d5: %w[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],
+
+        # D7 - Tipo de Ambiente (tpAmb)
+        d7: [1, 2], # 1=Produção, 2=Homologação
+
+        # D8 - Valores 1-4 (usado em vários campos como uMed)
+        d8: [1, 2, 3, 4],
+
+        # D10 - Indicador booleano
+        d10: [1],
+
+        # D11 - CST ICMS - Tributação normal
+        d11: ['00'],
+
+        # D12 - CST ICMS - Tributação com redução de BC
+        d12: ['20'],
+
+        # D13 - CST ICMS - Isenta/Não tributada
+        d13: %w[40 41],
+
+        # D14 - CST ICMS - Diferimento
+        d14: ['51'],
+
+        # D15 - CST ICMS - Outros
+        d15: ['90'],
+
+        # D16 - CST PIS/COFINS
+        d16: %w[01 02 06 07 08 09 49],
+
+        # D18 - Tipos de assinante
+        d18: [1, 2, 3, 4, 5, 6, 7, 8, 99],
+
+        # D19 - Finalidade da NFCom (finNFCom)
+        d19: [0, 3, 4], # 0=Normal, 3=Substituição, 4=Ajuste
+
+        # D20 - Tipo de Faturamento (tpFat)
+        d20: [0, 1, 2], # 0=Normal, 1=Centralizado, 2=Cofaturamento
+
+        # D22 - Indicador IE Destinatário (indIEDest)
+        d22: [1, 2, 9], # 1=Contribuinte, 2=Isento, 9=Não Contribuinte
+
+        # D23 - Código Regime Tributário (CRT)
+        d23: [1, 2, 3], # 1=Simples Nacional, 2=Simples Excesso, 3=Normal
+
+        # D24 - Tipos de serviço utilizado
+        d24: [1, 2, 3, 4, 5, 6, 7],
+
+        # D25 - Modelo documento (NF21/22)
+        d25: [21, 22],
+
+        # D26 - Motivo de substituição
+        d26: %w[01 02 03 04 05]
+      }.freeze
+
+      def self.valido_por_schema?(valor, chave_regex)
+        return false if valor.nil?
+
+        pattern = REGEX_PATTERNS[chave_regex]
+        return false unless pattern
+
+        valor.to_s.match?(pattern)
+      end
+
+      # Valida um valor contra um domínio
+      def self.valido_por_dominio?(valor, chave_dominio, converter_para_int: false)
+        return false if valor.nil?
+
+        dominio = DOMAINS[chave_dominio]
+        return false unless dominio
+
+        valor_comparar = converter_para_int ? valor.to_i : valor.to_s.upcase
+        dominio.include?(valor_comparar)
+      end
+
+      # Validadores complexos que fazem mais do que checar pattern/domain
+
+      def self.cnpj_formato_valido?(cnpj)
+        cnpj_limpo = cnpj.to_s.gsub(/\D/, '')
+        cnpj_limpo.length == 14 && cnpj_limpo.match?(/\A[0-9]{14}\z/)
+      end
+
+      def self.cpf_formato_valido?(cpf)
+        cpf_limpo = cpf.to_s.gsub(/\D/, '')
+        valido_por_schema?(cpf_limpo, :er9)
+      end
+
+      def self.cep_valido?(cep)
+        cep_limpo = cep.to_s.gsub(/\D/, '')
+        valido_por_schema?(cep_limpo, :er67)
+      end
+
+      def self.telefone_valido?(telefone)
+        return true if telefone.nil? || telefone.to_s.strip.empty?
+
+        telefone_limpo = telefone.to_s.gsub(/\D/, '')
+        valido_por_schema?(telefone_limpo, :er61)
+      end
+
+      def self.email_valido?(email)
+        return true if email.nil? || email.to_s.strip.empty?
+
+        valido_por_schema?(email.to_s, :er72)
+      end
+
+      def self.texto_valido?(texto, tamanho_max = nil)
+        return false if texto.nil? || texto.to_s.strip.empty?
+        return false if tamanho_max && texto.to_s.length > tamanho_max
+        # Verifica espaços no início ou fim (ER47 não permite)
+        return false if texto != texto.strip
+
+        valido_por_schema?(texto.to_s, :er47)
+      end
+
+      def self.data_valida?(data)
+        return false if data.nil? || data.to_s.strip.empty?
+
+        valido_por_schema?(data.to_s, :er48)
+      end
+
+      def self.cst_icms_valido?(cst)
+        cst_str = cst.to_s.rjust(2, '0')
+        DOMAINS[:d11].include?(cst_str) ||
+          DOMAINS[:d12].include?(cst_str) ||
+          DOMAINS[:d13].include?(cst_str) ||
+          DOMAINS[:d14].include?(cst_str) ||
+          DOMAINS[:d15].include?(cst_str)
+      end
+
+      # Executa validações múltiplas e retorna mensagens de erro
+      def self.validar_campos(campos) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        erros = []
+
+        campos.each do |campo, config|
+          valor = config[:valor]
+          validador = config[:validador]
+          nome = config[:nome] || campo.to_s
+
+          valido = if validador.to_s.start_with?('er')
+                     # ER pattern: :er48, :er59, etc.
+                     valido_por_schema?(valor, validador)
+                   elsif validador.to_s.start_with?('d')
+                     # Domain: :d18, :d24, etc.
+                     # Assume integer domains unless the domain contains strings
+                     sample = DOMAINS[validador]&.first
+                     converter_para_int = sample.is_a?(Integer)
+                     valido_por_dominio?(valor, validador, converter_para_int: converter_para_int)
+                   else
+                     # Named validator methods
+                     case validador
+                     when :cnpj then cnpj_formato_valido?(valor)
+                     when :cpf then cpf_formato_valido?(valor)
+                     when :cep then cep_valido?(valor)
+                     when :telefone then telefone_valido?(valor)
+                     when :email then email_valido?(valor)
+                     when :texto then texto_valido?(valor, config[:max])
+                     when :data then data_valida?(valor)
+                     when :cst_icms then cst_icms_valido?(valor)
+                     else true
+                     end
+                   end
+
+          erros << "#{nome} inválido: '#{valor}'" unless valido
+        end
+
+        erros
+      end
+    end
+  end
+end

data/lib/nfcom/validators/xml_validator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Validators
+    class XmlValidator
+      SCHEMA_PATH = File.join(__dir__, '../../schemas/nfcom_v1.00.xsd')
+
+      def validar(xml)
+        # TODO: Implementar validação contra XSD
+        # Por enquanto, apenas valida se é XML válido
+        doc = Nokogiri::XML(xml)
+
+        if doc.errors.any?
+          erros = doc.errors.map(&:message).join(', ')
+          raise Errors::ValidationError, "XML inválido: #{erros}"
+        end
+
+        # TODO: Validar contra schema XSD quando disponível
+        # xsd = Nokogiri::XML::Schema(File.read(SCHEMA_PATH))
+        # erros = xsd.validate(doc)
+        # raise Errors::ValidationError, erros.map(&:message).join(', ') if erros.any?
+
+        true
+      rescue Nokogiri::XML::SyntaxError => e
+        raise Errors::XmlError, "Erro de sintaxe no XML: #{e.message}"
+      end
+    end
+  end
+end

data/lib/nfcom/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Nfcom
+  VERSION = '0.1.2'
+end

data/lib/nfcom/webservices/autorizacao.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Webservices
+    class Autorizacao < Base
+      def enviar(xml_assinado)
+        url = configuration.webservice_url(:recepcao)
+        unless url
+          raise Errors::ConfigurationError,
+                "URL de recepção não configurada para #{configuration.estado}"
+        end
+
+        xml_limpo = Utils::XmlCleaner.clean(xml_assinado)
+        configuration.logger&.debug("XML da nota:\n#{xml_limpo}") if configuration.log_level == :debug
+
+        xml_comprimido = Utils::Compressor.gzip_base64(xml_limpo)
+
+        body_xml = build_nfcom_body(xml_comprimido)
+        envelope = montar_envelope(body_xml)
+
+        action = 'http://www.portalfiscal.inf.br/nfcom/wsdl/NFComRecepcao/nfcomRecepcao'
+        post_soap(url: url, action: action, xml: envelope)
+      end
+
+      private
+
+      def build_nfcom_body(xml_comprimido)
+        <<~XML
+          <nfcomDadosMsg xmlns="http://www.portalfiscal.inf.br/nfcom/wsdl/NFComRecepcao">
+            #{xml_comprimido}
+          </nfcomDadosMsg>
+        XML
+      end
+    end
+  end
+end

data/lib/nfcom/webservices/base.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Webservices
+    class Base
+      attr_reader :configuration, :certificate
+
+      def initialize(configuration)
+        @configuration = configuration
+        @certificate = Utils::Certificate.new(
+          configuration.certificado_path,
+          configuration.certificado_senha
+        )
+      end
+
+      protected
+
+      def post_soap(url:, action:, xml:)
+        uri  = URI.parse(url)
+        http = configure_http_client(uri)
+        req  = build_http_request(uri, action, xml)
+
+        log_request(xml)
+        response = http.request(req)
+        log_response(response)
+
+        validate_http_response(response)
+
+        response.body
+      rescue ::Timeout::Error
+        raise Errors::TimeoutError, 'Timeout na comunicação com SEFAZ'
+      rescue OpenSSL::SSL::SSLError => e
+        raise Errors::SefazError, "Erro SSL: #{e.message}"
+      rescue StandardError => e
+        raise Errors::SefazError, "Erro SOAP: #{e.message}"
+      end
+
+      def montar_envelope(body_xml)
+        xml = '<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">' \
+              '<soap:Body>' \
+              "#{body_xml}" \
+              '</soap:Body>' \
+              '</soap:Envelope>'
+        Utils::XmlCleaner.clean(xml)
+      end
+
+      private
+
+      def configure_http_client(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl     = uri.scheme == 'https'
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http.open_timeout = configuration.timeout
+        http.read_timeout = configuration.timeout
+
+        cert = certificate.to_pem
+        http.cert = OpenSSL::X509::Certificate.new(cert[:cert])
+        http.key  = OpenSSL::PKey::RSA.new(cert[:key])
+
+        http
+      end
+
+      def build_http_request(uri, action, xml)
+        path = uri.request_uri
+        path = '/' if path.nil? || path.empty?
+
+        request = Net::HTTP::Post.new(path)
+        request['Content-Type'] =
+          %(application/soap+xml;charset=UTF-8;action="#{action}")
+        request.body = xml
+        request
+      end
+
+      def validate_http_response(response)
+        return if response.is_a?(Net::HTTPSuccess)
+
+        raise Errors::SefazError,
+              "Erro HTTP #{response.code}: #{response.message}"
+      end
+
+      def log_request(xml)
+        return unless configuration.log_level == :debug
+
+        configuration.logger&.debug("SOAP Request:\n#{xml}")
+      end
+
+      def log_response(response)
+        return unless configuration.log_level == :debug
+
+        configuration.logger&.debug(
+          "SOAP Response (raw):\n#{response.body}"
+        )
+      end
+    end
+  end
+end

data/lib/nfcom/webservices/consulta.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Webservices
+    # Consulta situação de uma NFCom na SEFAZ
+    #
+    # Implementa a operação "Consulta Protocolo", utilizada para verificar
+    # a situação de uma NFCom já transmitida.
+    class Consulta < Base
+      # Consulta a situação de uma NFCom pela chave de acesso
+      #
+      # @param chave_acesso [String] Chave de acesso da NFCom (44 dígitos)
+      # @return [String] Resposta SOAP bruta da SEFAZ
+      # @raise [Errors::ConfigurationError] se a URL não estiver configurada
+      # @raise [Errors::SefazError] se houver erro na comunicação
+      def consultar(chave_acesso)
+        url = url_consulta!
+
+        body_xml  = build_consulta_body(chave_acesso)
+        envelope  = montar_envelope(body_xml)
+
+        post_soap(
+          url: url,
+          action: soap_action,
+          xml: envelope
+        )
+      rescue StandardError => e
+        configuration.logger&.error("Erro ao consultar NFCom: #{e.message}")
+        raise
+      end
+
+      private
+
+      def url_consulta!
+        configuration.webservice_url(:consulta) ||
+          raise(
+            Errors::ConfigurationError,
+            "URL de consulta não configurada para #{configuration.estado}"
+          )
+      end
+
+      def soap_action
+        'http://www.portalfiscal.inf.br/nfcom/wsdl/NFComConsulta/nfcomConsultaNF'
+      end
+
+      def build_consulta_body(chave_acesso)
+        <<~XML.strip
+          <nfcomDadosMsg xmlns="http://www.portalfiscal.inf.br/nfcom/wsdl/NFComConsulta">
+            <consSitNFCom xmlns="http://www.portalfiscal.inf.br/nfcom" versao="1.00">
+              <tpAmb>#{configuration.ambiente_codigo}</tpAmb>
+              <xServ>CONSULTAR</xServ>
+              <chNFCom>#{chave_acesso}</chNFCom>
+            </consSitNFCom>
+          </nfcomDadosMsg>
+        XML
+      end
+    end
+  end
+end

data/lib/nfcom/webservices/inutilizacao.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Webservices
+    class Inutilizacao < Base
+      # Solicita inutilização de faixa de numeração de NFCom
+      #
+      # @return [String] XML SOAP bruto retornado pela SEFAZ
+      def inutilizar(serie:, numero_inicial:, numero_final:, justificativa:)
+        url = url_inutilizacao!
+
+        body_xml = build_inutilizacao_body(
+          serie: serie,
+          numero_inicial: numero_inicial,
+          numero_final: numero_final,
+          justificativa: justificativa
+        )
+
+        envelope = montar_envelope(body_xml)
+
+        post_soap(
+          url: url,
+          action: soap_action,
+          xml: envelope
+        )
+      rescue StandardError => e
+        configuration.logger&.error("Erro ao inutilizar NFCom: #{e.message}")
+        raise
+      end
+
+      private
+
+      def url_inutilizacao!
+        configuration.webservice_url(:inutilizacao) ||
+          raise(
+            Errors::ConfigurationError,
+            "URL de inutilização não configurada para #{configuration.estado}"
+          )
+      end
+
+      def soap_action
+        'http://www.portalfiscal.inf.br/nfcom/wsdl/nfcomInutilizacao'
+      end
+
+      # Monta o XML da inutilização conforme schema NFCom
+      #
+      # @return [String]
+      def build_inutilizacao_body(serie:, numero_inicial:, numero_final:, justificativa:)
+        <<~XML
+          <nfcomInutilizacaoNF xmlns="http://www.portalfiscal.inf.br/nfcom/wsdl/nfcomInutilizacao">
+            <NFComDadosMsg>
+              <inutNFCom xmlns="http://www.portalfiscal.inf.br/nfcom" versao="1.00">
+                <infInut>
+                  <tpAmb>#{configuration.ambiente_codigo}</tpAmb>
+                  <cUF>#{configuration.codigo_uf}</cUF>
+                  <ano>#{Time.now.strftime('%y')}</ano>
+                  <CNPJ>#{configuration.cnpj.gsub(/\D/, '')}</CNPJ>
+                  <mod>62</mod>
+                  <serie>#{serie}</serie>
+                  <nNFIni>#{numero_inicial}</nNFIni>
+                  <nNFFin>#{numero_final}</nNFFin>
+                  <xJust>#{justificativa}</xJust>
+                </infInut>
+              </inutNFCom>
+            </NFComDadosMsg>
+          </nfcomInutilizacaoNF>
+        XML
+      end
+    end
+  end
+end

data/lib/nfcom/webservices/status.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Webservices
+    # Consulta o status do serviço NFCom na SEFAZ
+    #
+    # Implementa a operação "Status do Serviço", utilizada para verificar
+    # se o ambiente da SEFAZ está disponível.
+    class Status < Base
+      # Executa a consulta de status do serviço NFCom
+      #
+      # @return [String] Resposta SOAP bruta da SEFAZ
+      # @raise [Errors::ConfigurationError] se a URL não estiver configurada
+      # @raise [Errors::SefazError] se houver erro na comunicação
+      def verificar
+        url = url_status!
+
+        body_xml = build_status_body
+        envelope = montar_envelope(body_xml)
+
+        post_soap(
+          url: url,
+          action: soap_action,
+          xml: envelope
+        )
+      rescue StandardError => e
+        configuration.logger&.error("Erro ao consultar Status NFCom: #{e.message}")
+        raise
+      end
+
+      private
+
+      def url_status!
+        configuration.webservice_url(:status) ||
+          raise(
+            Errors::ConfigurationError,
+            "URL de status não configurada para #{configuration.estado}"
+          )
+      end
+
+      def soap_action
+        'http://www.portalfiscal.inf.br/nfcom/wsdl/NFComStatusServico/nfcomStatusServicoNF'
+      end
+
+      # Monta o XML da consulta de status do serviço
+      #
+      # Importante:
+      # - A mensagem NÃO deve ser compactada
+      # - Deve seguir exatamente o schema NFCom v1.00
+      #
+      # @return [String]
+      def build_status_body
+        <<~XML.strip
+          <nfcomDadosMsg xmlns="http://www.portalfiscal.inf.br/nfcom/wsdl/NFComStatusServico">
+            <consStatServNFCom xmlns="http://www.portalfiscal.inf.br/nfcom" versao="1.00">
+              <tpAmb>#{configuration.ambiente_codigo}</tpAmb>
+              <xServ>STATUS</xServ>
+            </consStatServNFCom>
+          </nfcomDadosMsg>
+        XML
+      end
+    end
+  end
+end