rnfse 0.0.1

data/lib/rnfse/api/abrasf_1_0.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+require 'json-schema'
+
+module Rnfse::API::Abrasf10
+
+  module ClassMethods
+
+    def recepcionar_lote_rps(hash = {})
+      file = get_filepath('recepcionar_lote_rps.json')
+      json = Rnfse::Hash.camelize_and_symbolize_keys(hash, false).to_json
+      errors = JSON::Validator.fully_validate(file, json)
+      if errors.empty?
+        xml = xml_builder.build_recepcionar_lote_rps_xml(hash)
+        xml.sign!(certificate: File.read(self.certificate), key: File.read(self.key))
+        response = self.soap_client.call(
+          :recepcionar_lote_rps,
+          soap_action: 'RecepcionarLoteRps',
+          message_tag: 'RecepcionarLoteRps',
+          message: { :'xml!' => "<![CDATA[#{xml}]]>" })
+        parse_response(response)
+      else
+        raise ArgumentError, errors, caller
+      end
+    end
+
+    private
+
+    def parse_response(response)
+      hash = Rnfse::Hash.new(response.body)
+      lote_rps_response = hash[:recepcionar_lote_rps_response]
+      if !lote_rps_response.empty? and lote_rps_response[:recepcionar_lote_rps_result]
+        xml = hash[:recepcionar_lote_rps_response][:recepcionar_lote_rps_result]
+        hash[:recepcionar_lote_rps_response][:recepcionar_lote_rps_result] =
+          Nori.new.parse(xml)
+      end
+      hash.underscore_and_symbolize_keys
+    end
+
+    def get_filepath(filename)
+      File.join(File.expand_path(File.dirname(__FILE__)), 'abrasf_1_0', filename)
+    end
+
+  end
+
+  extend ClassMethods
+
+  def self.extended(base)
+    base.extend(ClassMethods)
+  end
+
+  def self.included(base)
+    base.send(:include, ClassMethods)
+  end
+
+end

data/lib/rnfse/api/iss_net_1_0.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+require 'json-schema'
+
+module Rnfse::API::IssNet10
+  include Rnfse::API::Abrasf10
+end

data/lib/rnfse/api.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+
+module Rnfse
+  
+  class API
+    attr_accessor :namespace
+    attr_accessor :endpoint
+    attr_accessor :api
+    attr_accessor :certificate
+    attr_accessor :key
+    attr_accessor :xml_builder
+    attr_accessor :soap_client
+    attr_accessor :verbose
+
+    def initialize(options = {})
+      options = load_options(options)
+      
+      file = Pathname.new(File.expand_path('../..', __FILE__))
+      provedores = YAML.load_file(file.join('provedores.yml'))
+      
+      case
+      when has_options(options, 'provedor', 'homologacao')
+        provedor = provedores['homologacao'][options['provedor'].to_s]
+        raise ArgumentError, 'provedor de homologação inexistente', caller if provedor.nil?
+        self.namespace = provedor['namespace']
+        self.endpoint = provedor['endpoint']
+        self.api = provedor['api']
+
+      when has_options(options, 'provedor', 'municipio')
+        provedor = provedores['producao'][options['provedor'].to_s]
+        raise ArgumentError, 'provedor inexistente', caller if provedor.nil?
+        self.namespace = provedor['namespace']
+        self.endpoint = provedor['endpoint'] % { municipio: options['municipio'] }
+        self.api = provedor['api']
+
+      when has_options(options, 'padrao', 'namespace', 'endpoint')
+        self.namespace = options['namespace'].to_s
+        self.endpoint = options['endpoint'].to_s
+        self.api = options['padrao'].to_s
+
+      else
+        raise ArgumentError, 'opções inválidas', caller
+      end
+
+      if has_options(options, 'certificate', 'key')
+        self.certificate = options['certificate']
+        self.key = options['key']
+      else
+        raise ArgumentError, 'opções de assinatura digital faltando', caller
+      end
+
+      self.verbose = options['verbose'] || false
+      self.xml_builder = options['xml_builder'] || XMLBuilder.new(padrao: self.api)
+      self.soap_client = options['soap_client'] || savon_client
+
+      extend self.class.const_get(String.camelize(self.api))
+    end
+
+    private
+
+    def savon_client
+      savon_hash = {
+        soap_version: 2,
+        env_namespace: :soap,
+        namespace_identifier: nil,
+        ssl_verify_mode: :peer,
+        ssl_cert_file: self.certificate,
+        ssl_cert_key_file: self.key,
+        endpoint: self.endpoint,
+        namespace: self.namespace
+      }
+
+      savon_hash = savon_hash.merge(
+        log: true,
+        log_level: :debug,
+        pretty_print_xml: true
+      ) if self.verbose
+
+      Savon.client(savon_hash)
+    end
+
+    def has_options(hash, *options)
+      options.each { |option| return false if hash[option].nil? }
+    end
+
+    def load_options(hash)
+      hash = Rnfse::Hash.new(hash)
+      hash = hash.stringify_keys
+      config = Rnfse::Configuration.instance
+
+      attrs = ['provedor', 'municipio', 'namespace', 'endpoint',
+               'verbose', 'api', 'certificate', 'key', 'xml_builder',
+               'soap_client', 'verbose', 'homologacao']
+      attrs.each do |attr|
+        hash[attr] = config.send(attr) if hash[attr].nil?
+      end
+      hash
+    end
+
+  end
+end

data/lib/rnfse/configuration.rb

@@ -0,0 +1,18 @@
+module Rnfse
+  class Configuration
+    include Singleton
+    
+    attr_accessor :provedor
+    attr_accessor :municipio
+    attr_accessor :namespace
+    attr_accessor :endpoint
+    attr_accessor :homologacao
+    attr_accessor :api
+    attr_accessor :certificate
+    attr_accessor :key
+    attr_accessor :xml_builder
+    attr_accessor :soap_client
+    attr_accessor :verbose
+
+  end
+end

data/lib/rnfse/core.rb

@@ -0,0 +1,9 @@
+module Rnfse
+  def self.configuration
+    Rnfse::Configuration.instance
+  end
+
+  def self.configure
+    yield(configuration) if block_given?
+  end
+end

data/lib/rnfse/hash.rb

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+
+module Rnfse
+  class Hash < ::Hash
+
+    def initialize(constructor = {})
+      if constructor.is_a?(::Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def update(other_hash)
+      if other_hash.is_a?(Hash)
+        super(other_hash)
+      else
+        other_hash.to_hash.each_pair do |key, value|
+          self[key] = value
+        end
+      end
+    end
+
+    def self.stringify_keys(obj)
+      self.transform_keys(obj) { |key| key.to_s rescue key }
+    end
+    
+    def stringify_keys
+      self.class.stringify_keys(self)
+    end
+
+    def self.symbolize_keys(obj)
+      self.transform_keys(obj) { |key| key.to_sym rescue key }
+    end
+    
+    def symbolize_keys
+      self.class.symbolize_keys(self)
+    end
+
+    def self.camelize_and_symbolize_keys(obj, uppercase_first_letter = true)
+      self.transform_keys(obj) do |key|
+        String.camelize(key.to_s, uppercase_first_letter).to_sym rescue key
+      end
+    end
+
+    def camelize_and_symbolize_keys(uppercase_first_letter = true)
+      self.class.camelize_and_symbolize_keys(self, uppercase_first_letter)
+    end
+
+    def self.underscore_and_symbolize_keys(obj)
+      self.transform_keys(obj) do |key|
+        String.underscore(key.to_s).to_sym rescue key
+      end
+    end
+
+    def underscore_and_symbolize_keys
+      self.class.underscore_and_symbolize_keys(self)
+    end
+    
+    def self.transform_keys(obj, &block)
+      case
+      when obj.kind_of?(::Hash)
+        result = {}
+        obj.each_key do |key|
+          result[yield(key)] = self.transform_keys(obj[key], &block)
+        end
+        result
+      when obj.kind_of?(::Array)
+        result = []
+        obj.each do |elem|
+          result << self.transform_keys(elem, &block)
+        end
+        result
+      else
+        obj
+      end
+    end
+
+    def transform_keys(&block)
+      self.class.transform_keys(self, &block)
+    end
+
+    def self.transform_values(obj, key, &block)
+      key = /\A#{key}\Z/ unless key.kind_of?(::Regexp)
+
+      case
+      when obj.kind_of?(::Hash)
+        result = {}
+        obj.each_key do |k|
+          if key.match(k)
+            result[k] = yield(obj[k])
+          else
+            result[k] = self.transform_values(obj[k], key, &block)
+          end
+        end
+        result
+      when obj.kind_of?(::Array)
+        result = []
+        obj.each do |elem|
+          result << self.transform_values(elem, key, &block)
+        end
+        result
+      else
+        obj
+      end
+    end
+
+    def transform_values(key, &block)
+      self.class.transform_values(self, key, &block)
+    end
+
+    def self.replace_key_values(obj, key, &block)
+      parent = key.to_s.split('/').first
+      childs = key.to_s.split('/')[1..-1]
+      regex = key.kind_of?(::Regexp) ? key : /\A#{parent}\Z/
+
+      case
+      when obj.kind_of?(::Hash)
+        result = {}
+        obj.each_key do |k|
+          case
+          when (regex.match(k) and childs.empty?)
+            result.merge!(yield(k, obj[k]))
+          when (regex.match(k) and !childs.empty?)
+            result[k] = self.replace_key_values(obj[k], childs.join('/'), &block)            
+          else
+            result[k] = self.replace_key_values(obj[k], key, &block)
+          end
+        end
+        result
+      when obj.kind_of?(::Array)
+        result = []
+        obj.each do |elem|
+          result << self.replace_key_values(elem, key, &block)
+        end
+        result
+      else
+        obj
+      end
+    end
+
+    def replace_key_values(key, &block)
+      self.class.replace_key_values(self, key, &block)
+    end
+
+  end
+end

data/lib/rnfse/string.rb

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+module Rnfse
+  class String < ::String
+    def self.camelize(term, uppercase_first_letter = true)
+      string = term.to_s
+      if uppercase_first_letter
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      else
+        string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+      end
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { $2.capitalize }
+      string.gsub!('/', '::')
+      string
+    end
+
+    def camelize
+      self.class.camelize(self) 
+    end
+
+    def self.underscore(term)
+      word = term.to_s.gsub('::', '/')
+      word.gsub!(/(?:([A-Za-z\d])|^)(?=\b|[^a-z])/)
+      #{ "#{$1}#{$1 && '_'}#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    def underscore
+      self.class.underscore(self)
+    end
+  end
+end

data/lib/rnfse/version.rb

@@ -0,0 +1,3 @@
+module Rnfse
+  VERSION = '0.0.1'
+end

data/lib/rnfse/xml_builder/abrasf_1_0.rb

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+
+module Rnfse::XMLBuilder::Abrasf10
+
+  module ClassMethods
+
+    def build_recepcionar_lote_rps_xml(hash = {})
+      hash = prepare_hash(hash)
+      inner_xml = ::Gyoku.xml(hash, key_converter: :none)
+      xml_builder('EnviarLoteRpsEnvio', inner_xml).doc
+    end
+
+    private
+
+    # prepara um hash para ser convertido a xml com o Gyoku
+    def prepare_hash(hash)
+      hash = camelize_hash(hash)
+      hash = wrap_rps(hash)
+      hash = add_tc_namespace(hash)
+      hash = clean_numerics(hash)
+      hash = date_to_utc(hash)
+      hash = fix_booleans(hash)
+      hash
+    end
+    
+    # converte booleanos para 1 ou 2
+    def fix_booleans(hash)
+      regex = /(IssRetido|OptanteSimplesNacional|IncentivadorCultural)\Z/
+      Rnfse::Hash.transform_values(hash, regex) do |val|
+        val ? 1 : 2
+      end
+    end
+      
+    # converte datas para GMT-0
+    def date_to_utc(hash)
+      Rnfse::Hash.transform_values(hash, /DataEmissao\Z/) do |val|
+        DateTime.parse(val).new_offset(0).strftime('%FT%T')
+      end
+    end
+
+    # limpa tags que por precaução é melhor só conter números
+    def clean_numerics(hash)
+      regex = /(Cep|Cnae|Cpf|Cnpj)\Z/
+      Rnfse::Hash.transform_values(hash, regex) { |val| val.gsub(/\D/, '') }
+    end
+    
+    # converte as chaves do hash para CamelCase
+    def camelize_hash(hash)
+      Rnfse::Hash.camelize_and_symbolize_keys(hash)
+    end
+
+    # encapsula as rps dentro de listaRps com Rps/InfRps
+    def wrap_rps(hash)
+      hash[:LoteRps][:ListaRps] = {
+        :Rps => { :InfRps => hash[:LoteRps][:ListaRps] }
+      }
+      hash
+    end
+
+    # adiciona o namespace tc nas tags dentro de loteRps
+    def add_tc_namespace(hash)
+      hash[:LoteRps] = Rnfse::Hash.transform_keys(hash[:LoteRps]) { |key| "tc:#{key}".to_sym }
+      hash
+    end
+
+    def xmlns
+      'http://www.abrasf.org.br/servico_enviar_lote_rps_envio.xsd'
+    end
+
+    # namespace dos tipos complexos
+    def xmlns_tc
+      'http://www.abrasf.org.br/tipos_complexos.xsd'
+    end  
+
+    # instancia o builder a ser utilizado na geracao do xml
+    def xml_builder(root, inner_xml)
+      Nokogiri::XML::Builder.new(encoding: 'utf-8') do |xml|
+        xml.send(root.to_sym, 'xmlns' => xmlns, 'xmlns:tc' => xmlns_tc) do
+          xml << inner_xml
+        end
+      end
+    end
+  end
+
+  extend ClassMethods
+
+  def self.extended(base)
+    base.extend(ClassMethods)
+  end
+
+  def self.included(base)
+    base.send(:include, ClassMethods)
+  end
+
+end

data/lib/rnfse/xml_builder/iss_net_1_0.rb

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+module Rnfse::XMLBuilder::IssNet10
+  include Rnfse::XMLBuilder::Abrasf10
+
+  private
+
+  # prepara um hash para ser convertido a xml com o Gyoku
+  def prepare_hash(hash)
+    hash = camelize_hash(hash)
+    hash = wrap_rps(hash)
+    hash = add_tc_namespace(hash)
+    hash = clean_numerics(hash)
+    hash = date_to_utc(hash)
+    hash = fix_booleans(hash)
+    hash = wrap_cpf_cnpj(hash)    
+    hash = add_municipio_prestacao_servico(hash)
+    hash = add_estado(hash)
+    hash = add_cidade(hash)
+    hash = alter_aliquota(hash)
+
+    hash
+  end
+
+  # alterar o formato da aliquota de 0 a 1 para 0 a 100
+  def alter_aliquota(hash)
+    Rnfse::Hash.transform_values(hash, 'tc:Aliquota') do |val|
+      "%.2f" % (val * 100)
+    end
+  end
+
+  # troca a tag Endereco/CodigoMunicipio por Cidade
+  def add_cidade(hash)
+    Rnfse::Hash.replace_key_values(hash, 'tc:Endereco/tc:CodigoMunicipio') do |key, value|
+      { 'tc:Cidade' => value }
+    end
+  end
+
+  # troca a tag Uf pela tag Estado
+  def add_estado(hash)
+    Rnfse::Hash.replace_key_values(hash, 'tc:Uf') do |key, value|
+      { :'tc:Estado' => value } 
+    end
+  end
+
+  # troca a tag CodigoMunicipio para MunicipioPrestacaoServico
+  # na tag Servico
+  def add_municipio_prestacao_servico(hash)
+    Rnfse::Hash.replace_key_values(hash, 'tc:Servico/tc:CodigoMunicipio') do |key, value|
+      { :'tc:MunicipioPrestacaoServico' => value }
+    end
+  end
+
+  # encapsula as tags cpf ou cnpj em uma tag cpfcnpj
+  def wrap_cpf_cnpj(hash)
+    regex = /(Cpf|Cnpj)\Z/
+    Rnfse::Hash.replace_key_values(hash, regex) do |key, value|
+      { :'tc:CpfCnpj' => { key => value } }
+    end
+  end
+
+  def xmlns
+    'http://www.issnetonline.com.br/webserviceabrasf/vsd/servico_enviar_lote_rps_envio.xsd'
+  end
+
+  def xmlns_tc
+    'http://www.issnetonline.com.br/webserviceabrasf/vsd/tipos_complexos.xsd'
+  end  
+
+end

data/lib/rnfse/xml_builder.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+module Rnfse
+  class XMLBuilder
+    def initialize(options)
+      options = Hash.stringify_keys(options)
+      extend self.class.const_get(String.camelize(options['padrao']))
+    end
+  end
+end

data/lib/rnfse.rb

@@ -0,0 +1,22 @@
+require 'date'
+require 'pathname'
+require 'yaml'
+require 'json'
+require 'json-schema'
+require 'gyoku'
+require 'nokogiri-xmlsec1'
+require 'savon'
+
+require 'rnfse/core'
+require 'rnfse/version'
+require 'rnfse/configuration'
+require 'rnfse/hash'
+require 'rnfse/string'
+
+require 'rnfse/api'
+require 'rnfse/api/abrasf_1_0'
+require 'rnfse/api/iss_net_1_0'
+
+require 'rnfse/xml_builder'
+require 'rnfse/xml_builder/abrasf_1_0'
+require 'rnfse/xml_builder/iss_net_1_0'

data/rnfse.gemspec

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'rnfse/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'rnfse'
+  s.version       = Rnfse::VERSION
+  s.summary       = %q{Biblioteca para a API de Nota Fiscal de Serviços 
+    eletrônica (NFS-e) da ABRASF.}
+  s.description   = %q{Biblioteca para integração com as várias implementações
+    municipais de Nota Fiscal de Serviços eletrônica (NFS-e) que utilizam uma 
+    das versões ou variações dos padrões
+    [ABRASF](http://www.abrasf.org.br/paginas_multiplas_detalhes.php?cod_pagina=1).}
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.licenses      = ['MIT', 'GPL-3']
+
+  s.authors       = ['Renan Mendes Carvalho']
+  s.email         = ['aitherios@gmail.com']
+  s.homepage      = 'https://github.com/aitherios/rnfse'
+
+  s.files         = `git ls-files`.split($/)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+  s.rubyforge_project = '[none]'
+
+  s.add_dependency 'json',                                  '~> 1.0'
+  s.add_dependency 'json-schema',                           '~> 2.0'
+  s.add_dependency 'gyoku',                                 '~> 1.0'
+  s.add_dependency 'nokogiri-xmlsec1',                      '~> 0.0.7'
+  s.add_dependency 'savon',                                 '~> 2.0'
+
+  s.add_development_dependency 'bundler',                   '~> 1.3'
+  s.add_development_dependency 'rake',                      '~> 10.0'
+  s.add_development_dependency 'rdoc',                      '~> 4.0'
+  s.add_development_dependency 'gem-release',               '~> 0.7.0'
+  s.add_development_dependency 'rspec',                     '~> 3.0.0'
+  s.add_development_dependency 'rspec-its',                 '~> 1.0.0'
+  s.add_development_dependency 'simplecov',                 '~> 0.7.0'
+  s.add_development_dependency 'codeclimate-test-reporter', '>= 0'
+  s.add_development_dependency 'equivalent-xml',            '~> 0.4.0'
+  s.add_development_dependency 'wwtd',                      '~> 0.5.0'
+  s.add_development_dependency 'vcr',                       '~> 2.9'
+  s.add_development_dependency 'webmock',                   '~> 1.0'
+  s.add_development_dependency 'guard',                     '~> 2.6.0'
+  s.add_development_dependency 'guard-rspec',               '~> 4.2.0'
+  s.add_development_dependency 'guard-bundler',             '~> 2.0.0'
+  s.add_development_dependency 'foreman',                   '~> 0.74.0'
+  s.add_development_dependency 'pry',                       '~> 0.10'
+  if RUBY_VERSION.to_i < 2
+    s.add_development_dependency 'pry-debugger',            '~> 0.2'
+  else
+    s.add_development_dependency 'pry-byebug',              '~> 1.0'
+  end
+
+end