rnfse 0.3.0 → 0.5.0

data/lib/rnfse/api/abrasf_1_0/cancelar_nfse.json

@@ -0,0 +1,13 @@
+{ 
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Cancelamento de NFS-e",
+  "description": "Esse serviço permite o cancelamento direto de uma NFS-e sem substituição da mesma por outra.",
+
+  "type": "object",
+  "properties": {
+    "identificacaoNfse": { "$ref": "definitions.json#/identificacaoNfse"},
+    "codigoCancelamento": { "$ref": "definitions.json#/codigoCancelamentoNfse"}
+  },
+  "required": ["identificacaoNfse", "codigoCancelamento"],
+  "additionalProperties": false
+}

data/lib/rnfse/api/abrasf_1_0/consultar_nfse.json

@@ -0,0 +1,17 @@
+{ 
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Consulta de NFS-e",
+  "description": "Esse serviço permite a obtenção de determinada NFS-e já gerada.",
+
+  "type": "object",
+  "properties": {
+    "prestador": { "$ref": "definitions.json#/identificacaoPrestador" },
+    "numeroNfse": { "$ref": "definitions.json#/numeroNfse" },
+    "dataInicial": { "$ref": "definitions.json#/data" },
+    "dataFinal": { "$ref": "definitions.json#/data" },
+    "tomador": { "$ref": "definitions.json#/identificacaoTomador" },
+    "intermediarioServico": { "$ref": "definitions.json#/identificacaoIntermediarioServico" }
+  },
+  "required": ["prestador"],
+  "additionalProperties": false
+}

data/lib/rnfse/api/abrasf_1_0/consultar_nfse_por_rps.json

@@ -0,0 +1,13 @@
+{ 
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Consulta de NFS-e por RPS",
+  "description": "Esse serviço efetua a consulta de uma NFS-e a partir do número de RPS que a gerou.",
+
+  "type": "object",
+  "properties": {
+    "identificacaoRps": { "$ref": "definitions.json#/identificacaoRps" },
+    "prestador": { "$ref": "definitions.json#/identificacaoPrestador" }
+  },
+  "required": ["identificacaoRps", "prestador"],
+  "additionalProperties": false
+}

data/lib/rnfse/api/abrasf_1_0/definitions.json

@@ -2,7 +2,7 @@
   "numeroNfse": {
     "description": "Número da Nota Fiscal de Serviço Eletrônica, formado pelo ano com 04 (quatro) dígitos e um número seqüencial com 11 posições – Formato AAAANNNNNNNNNNN.",
     "type": "integer",
-    "minimum": 199000000000000,
+    "minimum": 190000000000000,
     "maximum": 220099999999999
   },
    "codigoVerificacao": {
@@ -46,7 +46,7 @@
   "numeroRps": {
     "description": "Número do RPS",
     "type": "integer",
-    "minimum": 1,
+    "minimum": 0,
     "maximum": 999999999999999
   },
   "serieRps": {
@@ -369,7 +369,9 @@
       {
         "type": "object",
         "properties": {
-          "cpf": { "$ref": "#/cpf" }
+          "razaoSocial": { "$ref": "#/razaoSocial" },
+          "cpf": { "$ref": "#/cpf" },
+          "inscricaoMunicipal": { "$ref": "#/inscricaoMunicipal" }
         },
         "required": ["cpf"],
         "additionalProperties": false
@@ -385,5 +387,27 @@
     },
     "required": [],
     "additionalProperties": false
+  },
+  "data": {
+    "description": "Data como representada no padrão RFC 3339 section 5.6",
+    "type": "string",
+    "format": "date-time"
+  },
+  "codigoCancelamentoNfse": {
+    "description": "Código de cancelamento com base na tabela de erros e alertas",
+    "type": "string",
+    "maxLength": 4
+  },
+  "identificacaoNfse": {
+    "description": "Representa dados que identificam uma Nota Fiscal de Serviços Eletrônica",
+    "type": "object",
+    "properties": {
+      "numero": { "$ref": "#/numeroNfse" },
+      "cnpj": { "$ref": "#/cnpj" },
+      "inscricaoMunicipal": { "$ref": "#/inscricaoMunicipal" },
+      "codigoMunicipio": { "$ref": "#/codigoMunicipioIbge" }      
+    },
+    "required": ["numero", "cnpj"],
+    "additionalProperties": false
   }
 }

data/lib/rnfse/api/abrasf_1_0/recepcionar_lote_rps.json

@@ -18,7 +18,7 @@
             "type": "object",
             "properties": {
               "identificacaoRps": { "$ref": "definitions.json#/identificacaoRps" },
-              "dataEmissao": { "type": "string", "format": "date-time" },
+              "dataEmissao": { "$ref": "definitions.json#/data" },
               "naturezaOperacao": { "$ref": "definitions.json#/naturezaOperacao" },
               "regimeEspecialTributacao": { "$ref": "definitions.json#/regimeEspecialTributacao" },
               "optanteSimplesNacional": { "type": "boolean" },

data/lib/rnfse/api/iss_net_1_0.rb

@@ -1,11 +1,32 @@
 # -*- coding: utf-8 -*-
-require 'json-schema'
 
 module Rnfse::API::IssNet10
   include Rnfse::API::Abrasf10
 
+  def operations()
+    [
+      :recepcionar_lote_rps, :consultar_situacao_lote_rps, 
+      :consultar_nfse_por_rps, :consultar_nfse, :consultar_lote_rps,
+      :cancelar_nfse, :consultar_url_visualizacao_nfse, 
+      :consultar_url_visualizacao_nfse_serie
+    ]
+  end
+
+  # def recepcionar_lote_rps(hash = {})
+  #   validate_sign_options
+  #   validate_options(hash)
+  #   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)
+  # end
+
   def consultar_situacao_lote_rps(hash = {})
-    validate(hash)
+    validate_options(hash)
     xml = xml_builder.build_consultar_situacao_lote_rps_xml(hash)
     response = self.soap_client.call(
       :consultar_situacao_lote_rps,
@@ -15,4 +36,27 @@ module Rnfse::API::IssNet10
     parse_response(response)
   end
 
+  def consultar_nfse_por_rps(hash = {})
+    validate_options(hash)
+    xml = xml_builder.build_consultar_nfse_por_rps_xml(hash)
+    response = self.soap_client.call(
+      :consultar_nfse_por_rps,
+      soap_action: 'ConsultarNFSePorRPS',
+      message_tag: 'ConsultarNFSePorRPS',
+      message: { :'xml!' => "<![CDATA[#{xml}]]>" })
+    parse_response(response)
+  end
+
+  def consultar_url_visualizacao_nfse(hash = {})
+    raise Rnfse::Error::NotImplemented
+  end
+
+  def consultar_url_visualizacao_nfse_serie(hash = {})
+    raise Rnfse::Error::NotImplemented
+  end
+
+  def json_folder
+    'iss_net_1_0'
+  end
+
 end

data/lib/rnfse/api/speed_gov_1_0.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+
+module Rnfse::API::SpeedGov10
+  include Rnfse::API::Abrasf10
+
+  def recepcionar_lote_rps(hash = {})
+    validate_sign_options
+    validate_options(hash)
+    validate_ascii(hash)
+    header = xml_builder.build_header_xml()
+    parameters = xml_builder.build_recepcionar_lote_rps_xml(hash)
+    parameters.sign!(certificate: File.read(self.certificate), key: File.read(self.key))
+    response = self.soap_client.call(
+      :recepcionar_lote_rps,
+      soap_action: 'RecepcionarLoteRps',
+      message_tag: 'nfse:RecepcionarLoteRps',
+      message: { :'header!' => "<![CDATA[#{header}]]>",
+                 :'parameters!' => "<![CDATA[#{parameters}]]>" })
+    parse_response(response)
+  end
+
+  def consultar_situacao_lote_rps(hash = {})
+    validate_options(hash)
+    header = xml_builder.build_header_xml()
+    parameters = xml_builder.build_consultar_situacao_lote_rps_envio_xml(hash)
+    response = self.soap_client.call(
+      :consultar_situacao_lote_rps,
+      soap_action: 'ConsultarSituacaoLoteRps',
+      message_tag: 'nfse:ConsultarSituacaoLoteRps',
+      message: { :'header!' => "<![CDATA[#{header}]]>",
+                 :'parameters!' => "<![CDATA[#{parameters}]]>" })
+    parse_response(response)
+  end
+
+  def consultar_lote_rps(hash = {})
+    raise Rnfse::Error::NotImplemented
+  end
+
+  def consultar_nfse_por_rps(hash = {})
+    validate_options(hash)
+    validate_ascii(hash)
+    header = xml_builder.build_header_xml()
+    parameters = xml_builder.build_consultar_nfse_rps_envio_xml(hash)
+    response = self.soap_client.call(
+      :consultar_nfse_por_rps,
+      soap_action: 'ConsultarNfsePorRps',
+      message_tag: 'nfse:ConsultarNfsePorRps',
+      message: { :'header!' => "<![CDATA[#{header}]]>",
+                 :'parameters!' => "<![CDATA[#{parameters}]]>" })
+    parse_response(response)
+  end
+
+  def consultar_nfse(hash = {})
+    validate_options(hash)
+    header = xml_builder.build_header_xml()
+    parameters = xml_builder.build_consultar_nfse_envio_xml(hash)
+    response = self.soap_client.call(
+      :consultar_situacao_lote_rps,
+      soap_action: 'ConsultarNfse',
+      message_tag: 'nfse:ConsultarNfse',
+      message: { :'header!' => "<![CDATA[#{header}]]>",
+                 :'parameters!' => "<![CDATA[#{parameters}]]>" })
+    parse_response(response)
+  end
+
+  def cancelar_nfse(hash = {})
+    raise Rnfse::Error::NotImplemented
+  end
+
+  private
+
+  def validate_ascii(hash)
+    raise Rnfse::Error::NonASCIIEncoding unless hash.to_s.ascii_only?
+  end
+
+  def load_options_for_production(options)
+    provedor = provedores['producao'][options['provedor'].to_s]
+    self.namespace = provedor['namespace']
+    municipio = case options['municipio'].to_s
+                when 'petrolina' then 'pet'
+                when 'aquiraz' then 'aqz'
+                else options['municipio'].to_s
+                end
+    self.endpoint = provedor['endpoint'] % { municipio: municipio }
+    load_default_options(options)
+  end
+
+  def parse_response(response)
+    hash = Rnfse::Hash.new(response.body)
+    response_key = hash.keys.select { |k| k =~ /response$/ }.first
+    return_key = hash[response_key].keys.select { |k| k =~ /return$/ }.first
+    if !hash[response_key].nil? and hash[response_key]
+      xml = hash[response_key][return_key]
+      hash[response_key][return_key] = Nori.new.parse(xml)
+    end
+    hash.underscore_and_symbolize_keys
+  end
+
+  def savon_client_options
+    {
+      soap_version: 1,
+      env_namespace: :soapenv,
+      namespaces: { 'xmlns:soapenv' => 'http://schemas.xmlsoap.org/soap/envelope/',
+                    'xmlns:nfse' => 'http://www.abrasf.org.br/ABRASF/arquivos/nfse.xsd',
+                    'xmlns' => '' },
+      namespace_identifier: nil,
+      ssl_verify_mode: :peer,
+      ssl_cert_file: self.certificate,
+      ssl_cert_key_file: self.key,
+      endpoint: self.endpoint,
+      namespace: self.namespace
+    }
+  end
+
+end

data/lib/rnfse/call_chain.rb

@@ -7,13 +7,13 @@ module Rnfse
 
     private
 
-    # Stolen from ActionMailer, where this was used but was not made
-    # reusable
+    # Stolen from ActionMailer with a tweek,
+    # where this was used but was not made reusable
     def self.parse_caller(at)
-      if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+      if /^(.+?):(\d+)(?::in `((block in )?(.*))')?/ =~ at
         file   = Regexp.last_match[1]
         line   = Regexp.last_match[2].to_i
-        method = Regexp.last_match[3]
+        method = Regexp.last_match[5]
         [file, line, method]
       end
     end

data/lib/rnfse/error.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+module Rnfse
+  class Error
+    # Metodos não implementados
+    class NotImplemented < ::NotImplementedError; end
+
+    # Ações de API que tem comportamento anômalo.
+    # Em alguns provedores algumas ações, embora implemenadas não
+    # funcionam ou tem comportamento anômalo.
+    class BetterNotBeUsed < ::StandardError; end
+
+    # Caracteres fora do padrão ASCII foram utilizados.
+    class NonASCIIEncoding < ::StandardError; end
+  end
+end

data/lib/rnfse/hash.rb

@@ -58,18 +58,24 @@ module Rnfse
       self.class.underscore_and_symbolize_keys(self)
     end
     
-    def self.transform_keys(obj, &block)
+    def self.transform_keys(obj, regex = nil, &block)
+      regex = /.*/ if regex.nil?
+
       case
       when obj.kind_of?(::Hash)
         result = {}
         obj.each_key do |key|
-          result[yield(key)] = self.transform_keys(obj[key], &block)
+          if regex.match(key)
+            result[yield(key)] = self.transform_keys(obj[key], regex, &block)
+          else
+            result[key] = self.transform_keys(obj[key], regex, &block)
+          end
         end
         result
       when obj.kind_of?(::Array)
         result = []
         obj.each do |elem|
-          result << self.transform_keys(elem, &block)
+          result << self.transform_keys(elem, regex, &block)
         end
         result
       else
@@ -77,8 +83,8 @@ module Rnfse
       end
     end
 
-    def transform_keys(&block)
-      self.class.transform_keys(self, &block)
+    def transform_keys(regex = nil, &block)
+      self.class.transform_keys(self, regex, &block)
     end
 
     def self.transform_values(obj, key, &block)
@@ -111,19 +117,26 @@ module Rnfse
     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/
+      parent, children = case
+                         when key.kind_of?(::Regexp)
+                           [ key, [] ]
+                         when key.kind_of?(::Array)
+                           [ key.first, key[1..-1] ]
+                         else
+                           parts = key.to_s.split('/')
+                           [ parts.first, parts[1..-1] ]
+                         end
+      regex = parent.kind_of?(::Regexp) ? parent : /\A#{parent}\Z/
 
       case
       when obj.kind_of?(::Hash)
         result = {}
         obj.each_key do |k|
           case
-          when (regex.match(k) and childs.empty?)
+          when (regex.match(k) and children.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)            
+          when (regex.match(k) and !children.empty?)
+            result[k] = self.replace_key_values(obj[k], children, &block)
           else
             result[k] = self.replace_key_values(obj[k], key, &block)
           end

data/lib/rnfse/string.rb

@@ -11,7 +11,7 @@ module Rnfse
       end
       string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { $2.capitalize }
       string.gsub!('/', '::')
-      string
+      self.new(string)
     end
 
     def camelize
@@ -26,11 +26,25 @@ module Rnfse
       word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
       word.tr!("-", "_")
       word.downcase!
-      word
+      self.new(word)
     end
 
     def underscore
       self.class.underscore(self)
     end
+
+    def self.demodulize(path)
+      path = path.to_s
+      self.new( if i = path.rindex('::')
+                  path[(i+2)..-1]
+                else
+                  path
+                end )
+    end
+    
+    def demodulize
+      self.class.demodulize(self)
+    end
+
   end
 end

data/lib/rnfse/version.rb

@@ -1,3 +1,3 @@
 module Rnfse
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end

data/lib/rnfse/xml_builder/abrasf_1_0.rb

@@ -5,15 +5,51 @@ module Rnfse::XMLBuilder::Abrasf10
   module ClassMethods
 
     def build_recepcionar_lote_rps_xml(hash = {})
-      build_xml('EnviarLoteRpsEnvio', hash)
+      if block_given?
+        build_xml('EnviarLoteRpsEnvio', hash, &Proc.new)
+      else
+        build_xml('EnviarLoteRpsEnvio', hash)
+      end
+    end
+
+    def build_consultar_situacao_lote_rps_xml(hash = {})
+      if block_given?
+        build_xml('ConsultarSituacaoLoteRpsEnvio', hash, &Proc.new)
+      else
+        build_xml('ConsultarSituacaoLoteRpsEnvio', hash)
+      end
+    end
+
+    def build_consultar_nfse_por_rps_xml(hash = {})
+      if block_given?
+        build_xml('ConsultarNfseRpsEnvio', hash, &Proc.new)
+      else
+        build_xml('ConsultarNfseRpsEnvio', hash)
+      end
+    end
+
+    def build_consultar_nfse_xml(hash = {})
+      if block_given?
+        build_xml('ConsultarNfseEnvio', hash, &Proc.new)
+      else
+        build_xml('ConsultarNfseEnvio', hash)
+      end
     end
 
     def build_consultar_lote_rps_xml(hash = {})
-      build_xml('ConsultarLoteRpsEnvio', hash)
+      if block_given?
+        build_xml('ConsultarLoteRpsEnvio', hash, &Proc.new)
+      else
+        build_xml('ConsultarLoteRpsEnvio', hash)
+      end
     end
 
-    def build_consultar_situacao_lote_rps_xml(hash = {})
-      build_xml('ConsultarSituacaoLoteRpsEnvio', hash)
+    def build_cancelar_nfse_xml(hash = {})
+      if block_given?
+        build_xml('CancelarNfseEnvio', hash, &Proc.new)
+      else
+        build_xml('CancelarNfseEnvio', hash)
+      end
     end
 
     private
@@ -21,6 +57,7 @@ module Rnfse::XMLBuilder::Abrasf10
     def build_xml(wrapper, hash = {})
       hash = prepare_hash(hash)
       inner_xml = ::Gyoku.xml(hash, key_converter: :none)
+      inner_xml = yield(Nokogiri::XML(inner_xml)) if block_given?
       xml_builder(wrapper, inner_xml).doc
     end
 
@@ -28,6 +65,8 @@ module Rnfse::XMLBuilder::Abrasf10
     def prepare_hash(hash)
       hash = camelize_hash(hash)
       hash = wrap_rps(hash)
+      hash = wrap_periodo_emissao(hash)
+      hash = wrap_identificacao_nfse(hash)
       hash = add_tc_namespace(hash)
       hash = clean_numerics(hash)
       hash = date_to_utc(hash)
@@ -37,7 +76,7 @@ module Rnfse::XMLBuilder::Abrasf10
     
     # converte booleanos para 1 ou 2
     def fix_booleans(hash)
-      regex = /(IssRetido|OptanteSimplesNacional|IncentivadorCultural)\Z/
+      regex = /((?<!Valor)IssRetido|OptanteSimplesNacional|IncentivadorCultural)\Z/
       Rnfse::Hash.transform_values(hash, regex) do |val|
         val ? 1 : 2
       end
@@ -46,7 +85,7 @@ module Rnfse::XMLBuilder::Abrasf10
     # 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')
+        DateTime.parse(val.to_s).new_offset(0).strftime('%FT%T')
       end
     end
 
@@ -69,16 +108,43 @@ module Rnfse::XMLBuilder::Abrasf10
       hash
     end
 
+    # encapsula as tags data_inicial e data_final em periodo_emissao
+    def wrap_periodo_emissao(hash)
+      if hash[:DataInicial] or hash[:DataFinal]
+        hash[:PeriodoEmissao] = {
+          :DataInicial => hash.delete(:DataInicial),
+          :DataFinal => hash.delete(:DataFinal)
+        }
+      end
+      hash
+    end
+
+    # encapsula a tag identificacao_nfse
+    def wrap_identificacao_nfse(hash)
+      if hash[:IdentificacaoNfse]
+        hash[:Pedido] = { 
+          :InfPedidoCancelamento => {
+            :IdentificacaoNfse => hash.delete(:IdentificacaoNfse),
+            :CodigoCancelamento => hash.delete(:CodigoCancelamento)
+          }
+        }
+      end
+      hash
+    end
+
     # adiciona o namespace tc nas tags dentro de loteRps ou prestador
     def add_tc_namespace(hash)
-      tag = case
-            when !hash[:LoteRps].nil? then :LoteRps
-            when !hash[:Prestador].nil? then :Prestador
-            end
-      if hash[tag]
-        hash[tag] = Rnfse::Hash.transform_keys(hash[tag]) { |key| "tc:#{key}".to_sym }
+      regex = %r{ \A(
+                    LoteRps|
+                    Prestador|
+                    IdentificacaoRps|
+                    Tomador|
+                    IntermediarioServico|
+                    Pedido
+                  )\Z }x
+      Rnfse::Hash.replace_key_values(hash, regex) do |key, value|
+        { key => Rnfse::Hash.transform_keys(value) { |k| "tc:#{k}".to_sym } }
       end
-      hash
     end
 
     # namespace dos tipos complexos
@@ -110,6 +176,30 @@ module Rnfse::XMLBuilder::Abrasf10
       }
     end
 
+    # namespaces do xml consultar_nfse_por_rps
+    def build_consultar_nfse_por_rps_xmlns
+      {
+        'xmlns' => 'http://www.abrasf.org.br/servico_consultar_situacao_lote_rps_envio.xsd',
+        'xmlns:tc' => xmlns_tc
+      }
+    end
+
+    # namespaces do xml consultar_nfse
+    def build_consultar_nfse_xmlns
+      {
+        'xmlns' => 'http://www.abrasf.org.br/servico_consultar_nfse_envio.xsd',
+        'xmlns:tc' => xmlns_tc
+      }
+    end
+
+    # namespaces do xml cancelar_nfse
+    def build_cancelar_nfse_xmlns
+      {
+        'xmlns' => 'http://www.abrasf.org.br/servico_cancelar_nfse_envio.xsd',
+        'xmlns:tc' => xmlns_tc
+      }
+    end
+
     # instancia o builder a ser utilizado na geracao do xml
     def xml_builder(root, inner_xml, xmlns = {})
       xmlns = self.send("#{Rnfse::CallChain.caller_method(2)}ns") if xmlns.empty?