nfcom 0.1.2

data/lib/nfcom/utils/certificate.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module Nfcom
+  module Utils
+    class Certificate
+      attr_reader :cert, :key
+
+      def initialize(path, password = nil)
+        @path = path
+        @password = password
+        carregar_certificado
+      end
+
+      def valido?
+        return false if @cert.nil? || @key.nil?
+        return false if expirado?
+
+        true
+      end
+
+      def expirado?
+        @cert.not_after < Time.now
+      end
+
+      def dias_para_vencer
+        return 0 if expirado?
+
+        ((@cert.not_after - Time.now) / 86_400).to_i
+      end
+
+      def cnpj
+        # Extrai CNPJ do subject do certificado
+        # Formato pode ser: CN=12345678000100 ou CN=EMPRESA:12345678000100
+        subject = @cert.subject.to_s
+
+        # Tenta formato direto: CN=12345678000100
+        match = subject.match(/CN=(\d{14})/)
+        return match[1] if match
+
+        # Tenta formato com nome: CN=EMPRESA:12345678000100
+        match = subject.match(/CN=[^:]+:(\d{14})/)
+        return match[1] if match
+
+        # Tenta buscar CNPJ em qualquer lugar do subject
+        match = subject.match(/(\d{14})/)
+        return match[1] if match
+
+        nil
+      end
+
+      def to_pem
+        {
+          cert: @cert.to_pem,
+          key: @key.to_pem
+        }
+      end
+
+      private
+
+      def carregar_certificado
+        raise Errors::CertificateError, "Arquivo de certificado não encontrado: #{@path}" unless File.exist?(@path)
+
+        begin
+          conteudo = File.read(@path)
+
+          # Tenta carregar como PKCS12 (.pfx)
+          if @path.end_with?('.pfx', '.p12')
+            pkcs12 = OpenSSL::PKCS12.new(conteudo, @password)
+            @cert = pkcs12.certificate
+            @key = pkcs12.key
+          else
+            # Tenta carregar como PEM
+            @cert = OpenSSL::X509::Certificate.new(conteudo)
+            @key = OpenSSL::PKey::RSA.new(conteudo, @password)
+          end
+
+          validar_certificado
+        rescue OpenSSL::PKCS12::PKCS12Error => e
+          raise Errors::CertificateError, "Erro ao carregar certificado PKCS12. Senha incorreta? #{e.message}"
+        rescue OpenSSL::X509::CertificateError => e
+          raise Errors::CertificateError, "Erro ao carregar certificado: #{e.message}"
+        rescue OpenSSL::PKey::RSAError => e
+          raise Errors::CertificateError, "Erro ao carregar chave privada: #{e.message}"
+        end
+      end
+
+      def validar_certificado
+        # Verifica se o certificado tem os componentes necessários
+        raise Errors::CertificateError, 'Certificado inválido: faltando certificado' if @cert.nil?
+        raise Errors::CertificateError, 'Certificado inválido: faltando chave privada' if @key.nil?
+
+        # Verifica se está expirado
+        raise Errors::CertificateError, 'Certificado está expirado' if expirado?
+
+        # Verifica se a chave privada corresponde ao certificado
+        unless @cert.check_private_key(@key)
+          raise Errors::CertificateError, 'Chave privada não corresponde ao certificado'
+        end
+
+        # Aviso de vencimento próximo
+        return unless dias_para_vencer <= 30
+
+        warn "ATENÇÃO: Certificado vence em #{dias_para_vencer} dias!"
+      end
+    end
+  end
+end

data/lib/nfcom/utils/compressor.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'zlib'
+require 'base64'
+
+module Nfcom
+  module Utils
+    # Compressor/Decompressor para XML de NFCom
+    #
+    # Responsável por compactar e descompactar XMLs usando GZIP com
+    # nível máximo de compressão, conforme exigido pela SEFAZ.
+    class Compressor
+      # Compacta XML e retorna Base64
+      #
+      # @param xml [String] XML a ser compactado
+      # @return [String] String Base64 com XML compactado em GZIP
+      def self.gzip_base64(xml)
+        xml = xml.dup
+        xml.sub!("\uFEFF", '') # remove BOM se existir
+
+        io = StringIO.new
+        # Nível 9 = compressão máxima (FORCE_GZIP do PHP)
+        gz = Zlib::GzipWriter.new(io, Zlib::BEST_COMPRESSION)
+        gz.write(xml)
+        gz.close
+
+        Base64.strict_encode64(io.string)
+      end
+
+      # Descompacta Base64+GZIP e retorna XML
+      #
+      # @param base64_data [String] String Base64 contendo XML compactado
+      # @return [String] XML descompactado
+      def self.ungzip_base64(base64_data)
+        compressed_data = Base64.strict_decode64(base64_data)
+
+        io = StringIO.new(compressed_data)
+        gz = Zlib::GzipReader.new(io)
+        xml = gz.read
+        gz.close
+
+        xml
+      end
+    end
+  end
+end

data/lib/nfcom/utils/helpers.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Utils
+    module Helpers
+      module_function
+
+      # Formata valor decimal para uso no XML (2 casas decimais)
+      def formatar_decimal(valor, casas = 2)
+        format("%.#{casas}f", valor.to_f)
+      end
+
+      # Converte String ou Date para Date de forma segura (sem depender do Rails)
+      # @param value [String, Date, Time, DateTime, nil]
+      # @return [Date, nil]
+      def safe_to_date(value)
+        return nil if value.nil?
+        return value if value.is_a?(Date)
+        return value.to_date if value.respond_to?(:to_date) && !value.is_a?(String)
+
+        Date.parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      # Formata data/hora para padrão ISO 8601
+      def formatar_data_hora(datetime)
+        datetime.strftime('%Y-%m-%dT%H:%M:%S%:z')
+      end
+
+      # Formata data para padrão AAAA-MM-DD
+      def formatar_data(date)
+        date = safe_to_date(date)
+        return nil unless date
+
+        date.strftime('%Y-%m-%d')
+      end
+
+      # Remove caracteres não numéricos
+      def apenas_numeros(texto)
+        texto.to_s.gsub(/\D/, '')
+      end
+
+      # Limita texto ao tamanho máximo
+      def limitar_texto(texto, tamanho_max)
+        texto = texto.to_s.strip
+        texto = texto[0...tamanho_max].strip if texto.length > tamanho_max
+        texto
+      end
+
+      # Remove acentos e caracteres especiais
+      def remover_acentos(texto)
+        texto.to_s
+          .unicode_normalize(:nfkd)
+          .encode('ASCII', invalid: :replace, undef: :replace, replace: '')
+          .gsub(/[^\w\s-]/, '')
+      end
+
+      # Valida se uma string está vazia
+      def vazio?(texto)
+        texto.to_s.strip.empty?
+      end
+
+      # Formata CNPJ
+      def formatar_cnpj(cnpj)
+        numeros = apenas_numeros(cnpj)
+        return cnpj if numeros.length != 14
+
+        "#{numeros[0..1]}.#{numeros[2..4]}.#{numeros[5..7]}/#{numeros[8..11]}-#{numeros[12..13]}"
+      end
+
+      # Formata CPF
+      def formatar_cpf(cpf)
+        numeros = apenas_numeros(cpf)
+        return cpf if numeros.length != 11
+
+        "#{numeros[0..2]}.#{numeros[3..5]}.#{numeros[6..8]}-#{numeros[9..10]}"
+      end
+
+      # Formata CEP
+      def formatar_cep(cep)
+        numeros = apenas_numeros(cep)
+        return cep if numeros.length != 8
+
+        "#{numeros[0..4]}-#{numeros[5..7]}"
+      end
+
+      # Gera ID único para elementos XML
+      def gerar_id(prefixo = 'ID')
+        "#{prefixo}#{Time.now.to_i}#{SecureRandom.hex(4)}"
+      end
+
+      # Valida CNPJ
+      # @param cnpj [String] CNPJ com ou sem formatação
+      # @return [Boolean] true se válido, false caso contrário
+      def cnpj_valido?(cnpj) # rubocop:disable Metrics/AbcSize
+        return false if cnpj.nil?
+
+        cnpj_limpo = apenas_numeros(cnpj)
+        return false if cnpj_limpo.length != 14
+        return false if cnpj_limpo.chars.uniq.length == 1 # Todos dígitos iguais
+
+        calc_digito = lambda do |numeros|
+          multiplicadores = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
+          soma = numeros.chars.each_with_index.sum { |d, i| d.to_i * multiplicadores[i + (13 - numeros.length)] }
+          resto = soma % 11
+          resto < 2 ? 0 : 11 - resto
+        end
+
+        base = cnpj_limpo[0..11]
+        digito1 = calc_digito.call(base)
+        digito2 = calc_digito.call(base + digito1.to_s)
+
+        cnpj_limpo[-2].to_i == digito1 && cnpj_limpo[-1].to_i == digito2
+      end
+
+      # Valida CPF
+      # @param cpf [String] CPF com ou sem formatação
+      # @return [Boolean] true se válido, false caso contrário
+      def cpf_valido?(cpf) # rubocop:disable Metrics/AbcSize
+        return false if cpf.nil?
+
+        cpf_limpo = apenas_numeros(cpf)
+        return false if cpf_limpo.length != 11
+        return false if cpf_limpo.chars.uniq.length == 1 # Todos dígitos iguais
+
+        calc_digito = lambda do |numeros, peso_inicial|
+          soma = numeros.chars.each_with_index.sum { |d, i| d.to_i * (peso_inicial - i) }
+          resto = soma % 11
+          resto < 2 ? 0 : 11 - resto
+        end
+
+        base = cpf_limpo[0..8]
+        digito1 = calc_digito.call(base, 10)
+        digito2 = calc_digito.call(base + digito1.to_s, 11)
+
+        cpf_limpo[-2].to_i == digito1 && cpf_limpo[-1].to_i == digito2
+      end
+    end
+  end
+end

data/lib/nfcom/utils/response_decompressor.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Nfcom
+  module Utils
+    # Descompressor de respostas da SEFAZ
+    #
+    # Processa respostas SOAP da SEFAZ, extraindo e descompactando
+    # o XML de resposta quando necessário.
+    class ResponseDecompressor
+      # Extrai e descompacta resposta da SEFAZ
+      #
+      # @param soap_response [Nokogiri::XML::Document] Documento SOAP da resposta
+      # @return [Nokogiri::XML::Document] Documento XML descompactado
+      # @raise [Errors::SefazError] Se houver erro na resposta ou faltar nfcomResultMsg
+      def self.extract_and_decompress(soap_response)
+        doc = soap_response.dup
+        doc.remove_namespaces!
+
+        # Verificar se tem Fault
+        if (fault = doc.at_xpath('//Fault'))
+          error_msg = fault.at_xpath('.//Text')&.text || 'Erro desconhecido'
+          raise Errors::SefazError, "Erro SOAP: #{error_msg}"
+        end
+
+        # Extrair nfcomResultMsg
+        result_msg_node = doc.at_xpath('//nfcomResultMsg')
+        raise Errors::SefazError, 'Resposta SOAP não contém nfcomResultMsg' unless result_msg_node
+
+        # Verificar se tem retNFCom direto (resposta não comprimida - geralmente erros)
+        ret_nfcom_direto = result_msg_node.at_xpath('.//retNFCom')
+
+        xml_descomprimido = if ret_nfcom_direto
+                              # Resposta NÃO está comprimida (erro de processamento)
+                              result_msg_node.to_xml
+                            else
+                              # Resposta está comprimida (normal)
+                              base64_comprimido = result_msg_node.text.strip
+                              Compressor.ungzip_base64(base64_comprimido)
+                            end
+
+        Nokogiri::XML(xml_descomprimido)
+      end
+    end
+  end
+end

data/lib/nfcom/utils/xml_authorized.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Utils
+    class XmlAuthorized
+      NFCOM_NAMESPACE = 'http://www.portalfiscal.inf.br/nfcom'
+
+      def self.build_nfcom_proc(xml_assinado:, xml_protocolo:)
+        nfcom_doc = Nokogiri::XML(xml_assinado, &:strict)
+        prot_doc  = Nokogiri::XML(xml_protocolo, &:strict)
+
+        nfcom_node = nfcom_doc.at_xpath('/*[local-name()="NFCom"]')
+        prot_node  = prot_doc.at_xpath('/*[local-name()="protNFCom"]')
+
+        raise Errors::XmlError, 'NFCom não encontrada no XML assinado' unless nfcom_node
+        raise Errors::XmlError, 'protNFCom não encontrada no XML de protocolo' unless prot_node
+
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml.nfcomProc(xmlns: NFCOM_NAMESPACE, versao: '1.00') do
+            xml << nfcom_node.to_xml
+            xml << prot_node.to_xml
+          end
+        end
+
+        builder.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
+      end
+    end
+  end
+end

data/lib/nfcom/utils/xml_cleaner.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Utils
+    # Limpeza de XML para envio à SEFAZ
+    #
+    # Remove caracteres de controle, BOMs, declarações XML e formatação
+    # desnecessária do XML antes do envio para a SEFAZ.
+    class XmlCleaner
+      class << self
+        # Limpa XML removendo BOMs, declarações e formatação
+        #
+        # @param xml [String] XML a ser limpo
+        # @return [String] XML limpo e pronto para envio
+        def clean(xml) # rubocop:disable Metrics/AbcSize
+          xml = xml.dup
+
+          # Trabalha com encoding binário primeiro para remover BOMs
+          xml.force_encoding('BINARY')
+
+          # Remove BOM (Byte Order Mark) - UTF-8
+          bom_utf8 = "\xEF\xBB\xBF".dup.force_encoding('BINARY')
+          xml.sub!(bom_utf8, '') if xml.start_with?(bom_utf8)
+
+          # Remove BOM variants (UTF-16)
+          bom_utf16_le = "\xFF\xFE".dup.force_encoding('BINARY')
+          xml.sub!(bom_utf16_le, '') if xml.start_with?(bom_utf16_le)
+
+          bom_utf16_be = "\xFE\xFF".dup.force_encoding('BINARY')
+          xml.sub!(bom_utf16_be, '') if xml.start_with?(bom_utf16_be)
+
+          # Agora converte para UTF-8
+          xml.force_encoding('UTF-8')
+
+          # Remove declaração XML e espaços após ela
+          xml.sub!(/\A<\?xml[^?]*\?>\s*/, '')
+
+          # Remove carriage returns (Windows line endings)
+          xml.gsub!("\r", '')
+
+          # Remove espaços/tabs no início de cada linha (multiline mode)
+          xml.gsub!(/^[ \t]+/m, '')
+
+          # Remove espaços/tabs no fim de cada linha (multiline mode)
+          xml.gsub!(/[ \t]+$/m, '')
+
+          # Remove múltiplas linhas vazias, deixando apenas uma
+          xml.gsub!(/\n\n+/, "\n")
+
+          # Remove espaços entre tags (> <) mas mantém conteúdo
+          xml.gsub!(/>\s+</, '><')
+
+          # Trim geral (remove espaços início/fim)
+          xml.strip!
+
+          # Remove qualquer caracter de controle invisível (exceto \n)
+          control_chars_str = (0x00..0x08).map(&:chr).join +
+                              (0x0B..0x0C).map(&:chr).join +
+                              (0x0E..0x1F).map(&:chr).join +
+                              0x7F.chr
+          xml.delete!(control_chars_str)
+
+          xml
+        end
+      end
+    end
+  end
+end

data/lib/nfcom/validators/business_rules.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Nfcom
+  module Validators
+    class BusinessRules
+      def self.validar(nota) # rubocop:disable Metrics/AbcSize
+        erros = []
+
+        # Valida valores
+        erros << 'Valor total da nota não pode ser zero' if nota.total.valor_total.to_f <= 0
+
+        # Valida soma dos itens
+        soma_itens = nota.itens.sum { |i| i.valor_total.to_f }
+        if (soma_itens - nota.total.valor_servicos.to_f).abs > 0.01
+          erros << "Soma dos itens (#{soma_itens}) não confere com total de serviços (#{nota.total.valor_servicos})"
+        end
+
+        nota.itens.each do |item|
+          # Valida códigos de serviço para provedor de internet
+          unless codigo_servico_valido?(item.codigo_servico)
+            erros << "Código de serviço #{item.codigo_servico} inválido para item #{item.numero_item}"
+          end
+          # Valida CFOP
+          erros << "CFOP #{item.cfop} inválido para item #{item.numero_item}" unless cfop_valido?(item.cfop)
+        end
+
+        erros
+      end
+
+      def self.codigo_servico_valido?(codigo)
+        # Códigos válidos para telecomunicações/internet
+        validos = %w[0303 0304 0305]
+        validos.include?(codigo.to_s)
+      end
+
+      def self.cfop_valido?(cfop)
+        # CFOPs comuns para serviços de comunicação
+        # 5300-5399: Prestações de serviços dentro do estado
+        # 6300-6399: Prestações de serviços fora do estado
+        cfop_num = cfop.to_s.to_i
+        cfop_num.between?(5300, 5399) || cfop_num.between?(6300, 6399)
+      end
+    end
+  end
+end