snoopy_afip 2.1.1 → 3.0.1

data/lib/snoopy_afip/bill.rb

@@ -1,254 +1,175 @@
 # coding: utf-8
 module Snoopy
   class Bill
-    include AuthData
+    attr_accessor :total_net, :document_num, :document_type, :concept, :currency, :result,
+                  :cbte_asoc_num, :cae, :service_date_to, :due_date,
+                  :number, :alicivas, :cuit, :sale_point, :service_date_from,
+                  :due_date_cae, :voucher_date, :process_date, :imp_iva, :cbte_asoc_sale_point,
+                  :receiver_iva_cond, :issuer_iva_cond, :errors
 
-    attr_reader :base_imp, :total
+    ATTRIBUTES = [ :total_net, :document_num, :document_type, :concept, :currency, :result,
+                   :cbte_asoc_num, :cae, :service_date_to, :due_date,
+                   :number, :alicivas, :cuit, :sale_point, :service_date_from,
+                   :due_date_cae, :voucher_date, :process_date, :imp_iva, :cbte_asoc_sale_point,
+                   :receiver_iva_cond, :issuer_iva_cond, :errors ]
 
-    attr_accessor :neto_total, :numero_documento, :condicion_iva_receptor, :tipo_documento, :concepto, :moneda,
-                  :due_date, :aliciva_id, :fecha_servicio_desde, :fecha_servicio_hasta, :body,
-                  :response, :cbte_asoc_num, :cbte_asoc_pto_venta, :numero, :alicivas,
-                  :pkey, :cert, :cuit, :punto_venta, :condicion_iva_emisor, :auth, :errors,
-                  :cae, :resultado, :fecha_proceso, :vencimiento_cae, :fecha_comprobante,
-                  :observaciones, :events, :imp_iva, :backtrace
+    TAX_ATTRIBUTES = [ :id, :amount, :taxeable_base ]
+
+    ATTRIBUTES_PRECENSE = [:total_net, :concept, :receiver_iva_cond, :alicivas, :document_type, :service_date_from, :service_date_to, :sale_point, :issuer_iva_cond]
 
     def initialize(attrs={})
-      @pkey                   = attrs[:pkey]
-      @cert                   = attrs[:cert]
-      @cuit                   = attrs[:cuit]
-      @punto_venta            = attrs[:sale_point]
-      @condicion_iva_emisor   = attrs[:own_iva_cond]
-      @neto_total             = attrs[:net]       || 0
-      @tipo_documento         = attrs[:documento] || Snoopy.default_documento
-      @moneda                 = attrs[:moneda]    || Snoopy.default_moneda
-      @concepto               = attrs[:concepto]  || Snoopy.default_concepto
-      @numero_documento       = attrs[:doc_num]
-      @fecha_servicio_desde   = attrs[:fch_serv_desde]
-      @fecha_servicio_hasta   = attrs[:fch_serv_hasta]
-      @cbte_asoc_pto_venta    = attrs[:cbte_asoc_pto_venta] # Esto es el punto de venta de la factura para la nota de credito
-      @cbte_asoc_num          = attrs[:cbte_asoc_num]       # Esto es el numero de factura para la nota de credito
-      @condicion_iva_receptor = attrs[:iva_cond]
-      @alicivas               = attrs[:alicivas]
-      @imp_iva                = attrs[:imp_iva]             # Monto total de impuestos
-      @response               = nil
-      @errors                 = []
-      @observaciones          = []
-      @events                 = []
-      @backtrace              = ""
-    end
+      # attrs = attrs.deep_symbolize_keys
+      @cuit                    = attrs[:cuit]
+      @result                  = nil
+      @number                  = nil
+      @errors                  = {}
+      @concept                 = attrs[:concept] || Snoopy.default_concept
+      @imp_iva                 = attrs[:imp_iva] # Monto total de impuestos
+      @currency                = attrs[:currency] || Snoopy.default_currency
+      @alicivas                = attrs[:alicivas]
+      @total_net               = attrs[:total_net] || 0
+      @sale_point              = attrs[:sale_point]
+      @document_num            = attrs[:document_num]
+      @cbte_asoc_num           = attrs[:cbte_asoc_num] # Esto es el numero de factura para la nota de credito
+      @document_type           = attrs[:document_type] || Snoopy.default_document_type
+      @issuer_iva_cond         = attrs[:issuer_iva_cond]
+      @service_date_to         = attrs[:service_date_to]
+      @service_date_from       = attrs[:service_date_from]
+      @receiver_iva_cond       = attrs[:receiver_iva_cond]
+      @cbte_asoc_to_sale_point = attrs[:cbte_asoc_to_sale_point] # Esto es el punto de venta de la factura para la nota de credito
+    end
+
+    # def self.bill_request(number, attrs={})
+    #   bill = Snoopy::Bill.new(attrs)
+    #   bill.response = bill.client_call( :fe_comp_consultar,
+    #                                     :message => {"Auth" => bill.auth,
+    #                                                  "FeCompConsReq" => {"CbteTipo" => bill.cbte_type, "PtoVta" => bill.sale_point, "CbteNro" => number.to_s}})
+    #   bill.parse_fe_comp_consultar_response
+    #   bill
+    # rescue => e
+    #   binding.pry
+    # end
+
+    # Para probar que la conexion con afip es correcta, si este metodo devuelve true, es posible realizar cualquier consulta al ws de la AFIP.
+    # def connection_valid?
+    #   # result = client.call(:fe_dummy).body[:fe_dummy_response][:fe_dummy_result]
+    #   result = client_call(:fe_dummy)[:fe_dummy_response][:fe_dummy_result]
+    #   @afip_observations[:db_server]   = result[:db_server]
+    #   @afip_observations[:app_server]  = result[:app_server]
+    #   @afip_observations[:auth_server] = result[:auth_server]
+    #   result[:app_server] == 'OK' and result[:db_server] == 'OK' and result[:auth_server] == 'OK'
+    # end
 
     def exchange_rate
-      return 1 if moneda == :peso
-      response = client.fe_param_get_cotizacion do |soap|
-        soap.namespaces["xmlns"] = "http://ar.gov.afip.dif.FEV1/"
-        soap.body = body.merge!({"MonId" => Snoopy::MONEDAS[moneda][:codigo]})
-      end
-      response.to_hash[:fe_param_get_cotizacion_response][:fe_param_get_cotizacion_result][:result_get][:mon_cotiz].to_f
+      return 1 if currency == :peso
+      # response = client.fe_param_get_cotizacion do |soap|
+      #   soap.namespaces["xmlns"] = "http://ar.gov.afip.dif.FEV1/"
+      #   soap.body = body.merge!({"MonId" => Snoopy::CURRENCY[currency][:code]})
+      # end
+      # response.to_hash[:fe_param_get_cotizacion_response][:fe_param_get_cotizacion_result][:result_get][:mon_cotiz].to_f
     end
 
     def total
-      @total = neto_total.zero? ? 0 : (neto_total + iva_sum).round(2)
+      @total = total_net.zero? ? 0 : (total_net + iva_sum).round(2)
     end
 
     def iva_sum
-      @iva_sum = alicivas.collect{|aliciva| if aliciva.has_key?('importe'); aliciva['importe'].to_f; else aliciva[:importe].to_f end }.sum.to_f.round_with_precision(2)
+      @iva_sum = alicivas.map{|aliciva| aliciva[:amount].to_f }.inject(:+).to_f.round_with_precision(2)
     end
 
     def cbte_type
-      Snoopy::BILL_TYPE[condicion_iva_receptor.to_sym] || raise(NullOrInvalidAttribute.new, "Please choose a valid document type.")
+      Snoopy::BILL_TYPE[receiver_iva_cond.to_sym]
     end
 
-    def client
-      Savon.client( :wsdl => Snoopy.service_url,
-                    :ssl_cert_key_file => pkey,
-                    :ssl_cert_file => cert,
-                    :ssl_version => :TLSv1,
-                    :read_timeout => 90,
-                    :open_timeout => 90,
-                    :headers => { "Accept-Encoding" => "gzip, deflate", "Connection" => "Keep-Alive" },
-                    :pretty_print_xml => true,
-                    :namespaces => {"xmlns" => "http://ar.gov.afip.dif.FEV1/"} )
+    def approved?
+      result == 'A'
     end
 
-    def set_bill_number!
-      resp = client.call( :fe_comp_ultimo_autorizado,
-                          :message => { "Auth" => generate_auth_file, "PtoVta" => punto_venta, "CbteTipo" => cbte_type })
+    def rejected?
+      result == 'R'
+    end
 
-      resp_errors = resp.hash[:envelope][:body][:fe_comp_ultimo_autorizado_response][:fe_comp_ultimo_autorizado_result][:errors]
-      resp_errors.each_value { |value| @errors << "Código #{value[:code]}: #{value[:msg]}" } unless resp_errors.nil?
-      @numero = resp.to_hash[:fe_comp_ultimo_autorizado_response][:fe_comp_ultimo_autorizado_result][:cbte_nro].to_i + 1 if @errors.empty?
+    def partial_approved?
+      result == 'P'
     end
 
-    def build_header
-      { "CantReg" => "1", "CbteTipo" => cbte_type, "PtoVta" => punto_venta }
+    def valid?
+      validate!
     end
 
-    def build_body_request
-      # today = Time.new.in_time_zone('Buenos Aires').strftime('%Y%m%d')
-      today = Date.today.strftime('%Y%m%d')
-
-      fecaereq = {"FeCAEReq" => {
-                    "FeCabReq" => build_header,
-                    "FeDetReq" => {
-                      "FECAEDetRequest" => {
-                        "Concepto"    => Snoopy::CONCEPTOS[concepto],
-                        "DocTipo"     => Snoopy::DOCUMENTOS[tipo_documento],
-                        "CbteFch"     => today,
-                        "ImpTotConc"  => 0.00,
-                        "MonId"       => Snoopy::MONEDAS[moneda][:codigo],
-                        "MonCotiz"    => exchange_rate,
-                        "ImpOpEx"     => 0.00,
-                        "ImpTrib"     => 0.00 }}}}
-
-      unless condicion_iva_emisor.to_sym == :responsable_monotributo
-        _alicivas = alicivas.collect do |aliciva|
-          id = if aliciva.has_key?('id'); aliciva['id']; else aliciva[:id]; end
-          importe = if aliciva.has_key?('importe'); aliciva['importe']; else aliciva[:importe]; end
-          base_imp = if aliciva.has_key?('base_imp'); aliciva['base_imp']; else aliciva[:base_imp]; end
-          { "Id" => Snoopy::ALIC_IVA[id], "BaseImp" => base_imp, "Importe" => importe }
-        end
-        fecaereq["FeCAEReq"]["FeDetReq"]["FECAEDetRequest"]["Iva"] = { "AlicIva" => _alicivas }
-      end
+    def to_h
+      Hash[*instance_variables.map { |v|
+        [v.to_s.sub('@', '').to_sym, instance_variable_get(v)]
+      }.flatten]
+    end
+    alias :to_hash :to_h
 
-      detail = fecaereq["FeCAEReq"]["FeDetReq"]["FECAEDetRequest"]
+    private
 
-      detail["DocNro"]    = numero_documento
-      detail["ImpNeto"]   = neto_total.to_f
-      detail["ImpIVA"]    = iva_sum
-      detail["ImpTotal"]  = total
+    def validate!
+      # validate_attributes_name(attrs)
+      @errors = {}
+      validate_attributes_presence
+      validate_standar_values
+    end
 
-      detail["CbteDesde"] = detail["CbteHasta"] = numero
+    def validate_attributes_presence
+      missing_attributes = []
+      ATTRIBUTES_PRECENSE.each { |_attr| missing_attributes << _attr if (self.send(_attr).blank? || self.send(_attr).nil?) }
 
-      unless concepto == "Productos"
-        detail.merge!({ "FchServDesde" => fecha_servicio_desde || today,
-                        "FchServHasta" => fecha_servicio_hasta || today,
-                        "FchVtoPago"   => due_date       || today})
-      end
+      @alicivas.each { |imp| missing_attributes += Snoopy::Bill::TAX_ATTRIBUTES - imp.keys }
 
-      if self.condicion_iva_receptor.to_s.include?("nota_credito")
-        detail.merge!({"CbtesAsoc" => {"CbteAsoc" => {"Nro"    => cbte_asoc_num,
-                                                      "PtoVta" => cbte_asoc_pto_venta,
-                                                      "Tipo"   => cbte_type }}})
+      missing_attributes.uniq.each do |attr|
+        @errors[attr.to_sym] = [] unless errors.has_key?(attr)
+        @errors[attr.to_sym] << Snoopy::Exception::Bill::MissingAttributes.new(attr).message
       end
 
-      @body = { "Auth" => generate_auth_file }.merge!(fecaereq)
     end
 
-    def cae_request
-      begin
-        set_bill_number!
-        if @errors.empty?
-          build_body_request
-          @response = client.call( :fecae_solicitar, :message => body ).body
-          parse_fecae_solicitar_response
-        end
-      rescue => e #Curl::Err::GotNothingError, Curl::Err::TimeoutError
-        @errors = e.message
-        @backtrace = e.backtrace
+    def validate_standar_values
+      status = true
+      unless Snoopy::CURRENCY.keys.include?(@currency.to_sym)
+        @errors[:currency] = [] unless errors.has_key?(:currency)
+        @errors[:currency] << Snoopy::Exception::Bill::InvalidValueAttribute.new("Invalid value #{@currency}, Possible values #{Snoopy::CURRENCY.keys}").message
+        status = false unless errors.empty?
       end
-      !@response.nil?
-    end
-
-    def aprobada?; @resultado == "A"; end
-    def parcial?; @resultado == "P"; end
-    def rechazada?; @resultado == "R"; end
 
-    # Para probar que la conexion con afip es correcta, si este metodo devuelve true, es posible realizar cualquier consulta al ws de la AFIP.
-    def connection_valid?
-      begin
-        result = client.call(:fe_dummy).body[:fe_dummy_response][:fe_dummy_result]
-        @observaciones << "app_server: #{result[:app_server]}, db_server: #{result[:db_server]}, auth_server: #{result[:auth_server]}"
-        result[:app_server] == "OK" and result[:db_server] == "OK" and result[:auth_server] == "OK"
-      rescue => e
-        @errors << e.message
-        @backtrace = e.backtrace
-        false
+      unless Snoopy::IVA_COND.include?(@issuer_iva_cond.to_sym)
+        @errors[:issuer_iva_cond] = [] unless errors.has_key?(:issuer_iva_cond)
+        @errors[:issuer_iva_cond] << Snoopy::Exception::Bill::InvalidValueAttribute.new("Invalid value #{@issuer_iva_cond}. Possible values #{Snoopy::IVA_COND}").message
+        status = false unless errors.empty?
       end
-    end
 
-    def parse_observations(fecae_observations)
-      begin
-        fecae_observations.each_value do |obs|
-          [obs].flatten.each { |ob| @observaciones << "Código #{ob[:code]}: #{ob[:msg]}" }
-        end
-      rescue
-        @observaciones << "Ocurrió un error al parsear las observaciones de AFIP"
+      unless Snoopy::BILL_TYPE.keys.include?(@receiver_iva_cond.to_sym)
+        @errors[:receiver_iva_cond] = [] unless errors.has_key?(:receiver_iva_cond)
+        @errors[:receiver_iva_cond] << Snoopy::Exception::Bill::InvalidValueAttribute.new("Invalid value #{@receiver_iva_cond}. Possible values #{Snoopy::BILL_TYPE.keys}").message
+        status = false unless errors.empty?
       end
-    end
 
-    def parse_errors(fecae_errors)
-      begin
-        fecae_errors.each_value do |errores|
-          [errores].flatten.each { |error| @errors << "Código #{error[:code]}: #{error[:msg]}" }
-        end
-      rescue
-        @errors << "Ocurrió un error al parsear los errores de AFIP"
+      unless Snoopy::DOCUMENTS.keys.include?(@document_type)
+        @errors[:document_type] = [] unless errors.has_key?(:document_type)
+        @errors[:document_type] << Snoopy::Exception::Bill::InvalidValueAttribute.new("Invalid value #{@document_type}. Possible values #{Snoopy::DOCUMENTS.keys}").message
+        status = false unless errors.empty?
       end
-    end
 
-    def parse_events(fecae_events)
-      begin
-        fecae_events.each_value do |events|
-          [events].flatten.each { |event| @events << "Código #{event[:code]}: #{event[:msg]}" }
-        end
-      rescue
-        @events << "Ocurrió un error al parsear los eventos de AFIP"
+      unless Snoopy::CONCEPTS.keys.include?(@concept)
+        @errors[:concept] = [] unless errors.has_key?(:concept)
+        @errors[:concept] << Snoopy::Exception::Bill::InvalidValueAttribute.new("Invalid value #{@concept}. Possible values #{Snoopy::CONCEPTS.keys}").message
+        status = false unless errors.empty?
       end
+      status
     end
 
-    def parse_fecae_solicitar_response
-      fecae_response = @response[:fecae_solicitar_response][:fecae_solicitar_result][:fe_det_resp][:fecae_det_response] rescue {}
-      fe_cab_resp    = @response[:fecae_solicitar_response][:fecae_solicitar_result][:fe_cab_resp] rescue {}
-      fecae_result   = @response[:fecae_solicitar_response][:fecae_solicitar_result] rescue {}
-
-      @cae               = fecae_response[:cae]
-      @numero            = fecae_response[:cbte_desde]
-      @resultado         = fecae_response[:resultado]
-      @vencimiento_cae   = fecae_response[:cae_fch_vto]
-      @fecha_comprobante = fecae_response[:cbte_fch]
-
-      @fecha_proceso     = fe_cab_resp[:fch_proceso]
-
-      parse_observations(fecae_response.delete(:observaciones)) if fecae_response.has_key? :observaciones
-      parse_errors(fecae_result[:errors])                       if fecae_result.has_key? :errors
-      parse_events(fecae_result[:events])                       if fecae_result.has_key? :events
-    end
+    # def validate_attributes_name attrs
+    #   attrs_not_found = attrs.keys - Snoopy::Bill::ATTRIBUTES
+    #   imp_atts_not_found = []
 
-    def parse_fe_comp_consultar_response
-      result_get               = @response.to_hash[:fe_comp_consultar_response][:fe_comp_consultar_result][:result_get]
-      fe_comp_consultar_result = @response.to_hash[:fe_comp_consultar_response][:fe_comp_consultar_result]
-
-      unless result_get.nil?
-        @cae                  = result_get[:cod_autorizacion]
-        @imp_iva              = result_get[:imp_iva]
-        @numero               = result_get[:cbte_desde]
-        @resultado            = result_get[:resultado]
-        @fecha_proceso        = result_get[:fch_proceso]
-        @vencimiento_cae      = result_get[:fch_vto]
-        @numero_documento     = result_get[:doc_numero]
-        @fecha_comprobante    = result_get[:cbte_fch]
-        @fecha_servicio_desde = result_get[:fch_serv_desde]
-        @fecha_servicio_hasta = result_get[:fch_serv_hasta]
-        parse_events(result_get[:observaciones]) if result_get.has_key? :observaciones
-      end
-
-      self.parse_events(fe_comp_consultar_result[:errors]) if fe_comp_consultar_result and fe_comp_consultar_result.has_key? :errors
-      self.parse_events(fe_comp_consultar_result[:events]) if fe_comp_consultar_result and fe_comp_consultar_result.has_key? :events
-    end
-
-    def self.bill_request(numero, attrs={})
-      bill = new(attrs)
-      begin
-        bill.response = bill.client.call( :fe_comp_consultar,
-                                          :message => {"Auth" => bill.generate_auth_file,
-                                                       "FeCompConsReq" => {"CbteTipo" => bill.cbte_type, "PtoVta" => bill.punto_venta, "CbteNro" => numero.to_s}})
-        bill.parse_fe_comp_consultar_response
-      rescue => e
-        bill.errors << e.message
-        bill.backtrace = e.backtrace
-      end
-      bill
-    end
+    #   if attrs.has_key?(:alicivas)
+    #     attrs[:alicivas].each { |imp| imp_atts_not_found += imp.keys - Snoopy::Bill::TAX_ATTRIBUTES }
+    #   end
 
+    #   _attrs = attrs_not_found + imp_atts_not_found.uniq
+    #   raise Snoopy::Exception::NonExistAttributes.new(_attrs.join(', ')) if _attrs.present?
+    # end
   end
 end

data/lib/snoopy_afip/client.rb

@@ -0,0 +1,20 @@
+module Snoopy
+  class Client
+    attr_accessor :savon
+
+    def initialize(attrs)
+      @savon = Savon.client(attrs)
+    end
+
+    def call service, args={}
+      Timeout::timeout(5) do
+        savon.call(service, args).body
+      end
+    rescue Timeout::Error
+      raise Snoopy::Exception::ServerTimeout.new
+    rescue => e
+      raise Snoopy::Exception::ClientError.new(e.message)
+    end
+
+  end
+end

data/lib/snoopy_afip/constants.rb

@@ -1,72 +1,77 @@
 # encoding: utf-8
 module Snoopy
-  CBTE_TIPO = { "01" => "Factura A",
-                "02" => "Nota de Débito A",
-                "03" => "Nota de Crédito A",
-                "04" => "Recibos A",
-                "05" => "Notas de Venta al contado A",
-                "06" => "Factura B",
-                "07" => "Nota de Debito B",
-                "08" => "Nota de Credito B",
-                "09" => "Recibos B",
-                "10" => "Notas de Venta al contado B",
-                "11" => "Factura C",
-                "13" => "Nota de Crédito C",
-                "34" => "Cbtes. A del Anexo I, Apartado A,inc.f),R.G.Nro. 1415",
-                "35" => "Cbtes. B del Anexo I,Apartado A,inc. f),R.G. Nro. 1415",
-                "39" => "Otros comprobantes A que cumplan con R.G.Nro. 1415",
-                "40" => "Otros comprobantes B que cumplan con R.G.Nro. 1415",
-                "60" => "Cta de Vta y Liquido prod. A",
-                "61" => "Cta de Vta y Liquido prod. B",
-                "63" => "Liquidacion A",
-                "64" => "Liquidacion B" }
+  CBTE_TYPE = { '01' => 'Factura A',
+                '02' => 'Nota de Débito A',
+                '03' => 'Nota de Crédito A',
+                '04' => 'Recibos A',
+                '05' => 'Notas de Venta al contado A',
+                '06' => 'Factura B',
+                '07' => 'Nota de Debito B',
+                '08' => 'Nota de Credito B',
+                '09' => 'Recibos B',
+                '10' => 'Notas de Venta al contado B',
+                '11' => 'Factura C',
+                '13' => 'Nota de Crédito C',
+                '34' => 'Cbtes. A del Anexo I, Apartado A,inc.f),R.G.Nro. 1415',
+                '35' => 'Cbtes. B del Anexo I,Apartado A,inc. f),R.G. Nro. 1415',
+                '39' => 'Otros comprobantes A que cumplan con R.G.Nro. 1415',
+                '40' => 'Otros comprobantes B que cumplan con R.G.Nro. 1415',
+                '60' => 'Cta de Vta y Liquido prod. A',
+                '61' => 'Cta de Vta y Liquido prod. B',
+                '63' => 'Liquidacion A',
+                '64' => 'Liquidacion B' }
 
-  CONCEPTOS = { "Productos"             => "01",
-                "Servicios"             => "02",
-                "Productos y Servicios" => "03" }
+  RESPONSABLE_INSCRIPTO   = :responsable_inscripto
+  RESPONSABLE_MONOTRIBUTO = :responsable_monotributo
 
-  DOCUMENTOS = { "CUIT"                   => "80",
-                 "CUIL"                   => "86",
-                 "CDI"                    => "87",
-                 "LE"                     => "89",
-                 "LC"                     => "90",
-                 "CI Extranjera"          => "91",
-                 "en tramite"             => "92",
-                 "Acta Nacimiento"        => "93",
-                 "CI Bs. As. RNP"         => "95",
-                 "DNI"                    => "96",
-                 "Pasaporte"              => "94",
-                 "Doc. (Otro)"            => "99",
-                 "CI Policía Federal"     => '00',
-                 "CI Buenos Aires"        => '01',
-                 "CI Catamarca"           => '02',
-                 "CI Córdoba"             => '03',
-                 "CI Corrientes"          => '04',
-                 "CI Entre Ríos"          => '05',
-                 "CI Jujuy"               => '06',
-                 "CI Mendoza"             => '07',
-                 "CI La Rioja"            => '08',
-                 "CI Salta"               => '09',
-                 "CI San Juan"            => '10',
-                 "CI San Luis"            => '11',
-                 "CI Santa Fe"            => '12',
-                 "CI Santiago del Estero" => '13',
-                 "CI Tucumán"             => '14',
-                 "CI Chaco"               => '16',
-                 "CI Chubut"              => '17',
-                 "CI Formosa"             => '18',
-                 "CI Misiones"            => '19',
-                 "CI Neuquén"             => '20',
-                 "CI La Pampa"            => '21',
-                 "CI Río Negro"           => '22',
-                 "CI Santa Cruz"          => '23',
-                 "CI Tierra del Fuego"    => '24' }
+  IVA_COND = [ RESPONSABLE_MONOTRIBUTO, RESPONSABLE_INSCRIPTO ]
 
-  MONEDAS = { :peso  => { :codigo => 'PES', :nombre => 'Pesos Argentinos' },
-              :dolar => { :codigo => 'DOL', :nombre => 'Dolar Estadounidense' },
-              :real  => { :codigo => '012', :nombre => 'Real' },
-              :euro  => { :codigo => '060', :nombre => 'Euro' },
-              :oro   => { :codigo => '049', :nombre => 'Gramos de Oro Fino' } }
+  CONCEPTS = { 'Productos'             => '01',
+               'Servicios'             => '02',
+               'Productos y Servicios' => '03' }
+
+  DOCUMENTS = { 'CUIT'                   => '80',
+                'CUIL'                   => '86',
+                'CDI'                    => '87',
+                'LE'                     => '89',
+                'LC'                     => '90',
+                'CI Extranjera'          => '91',
+                'en tramite'             => '92',
+                'Acta Nacimiento'        => '93',
+                'CI Bs. As. RNP'         => '95',
+                'DNI'                    => '96',
+                'Pasaporte'              => '94',
+                'Doc. (Otro)'            => '99',
+                'CI Policía Federal'     => '00',
+                'CI Buenos Aires'        => '01',
+                'CI Catamarca'           => '02',
+                'CI Córdoba'             => '03',
+                'CI Corrientes'          => '04',
+                'CI Entre Ríos'          => '05',
+                'CI Jujuy'               => '06',
+                'CI Mendoza'             => '07',
+                'CI La Rioja'            => '08',
+                'CI Salta'               => '09',
+                'CI San Juan'            => '10',
+                'CI San Luis'            => '11',
+                'CI Santa Fe'            => '12',
+                'CI Santiago del Estero' => '13',
+                'CI Tucumán'             => '14',
+                'CI Chaco'               => '16',
+                'CI Chubut'              => '17',
+                'CI Formosa'             => '18',
+                'CI Misiones'            => '19',
+                'CI Neuquén'             => '20',
+                'CI La Pampa'            => '21',
+                'CI Río Negro'           => '22',
+                'CI Santa Cruz'          => '23',
+                'CI Tierra del Fuego'    => '24' }
+
+  CURRENCY = { :peso  => { :code => 'PES', :nombre => 'Pesos Argentinos' },
+               :dolar => { :code => 'DOL', :nombre => 'Dolar Estadounidense' },
+               :real  => { :code => '012', :nombre => 'Real' },
+               :euro  => { :code => '060', :nombre => 'Euro' },
+               :oro   => { :code => '049', :nombre => 'Gramos de Oro Fino' } }
 
   ALIC_IVA = { 0     => '3',
                0.0   => '3',
@@ -82,5 +87,4 @@ module Snoopy
                 :nota_credito_a => '03',
                 :nota_credito_b => '08',
                 :nota_credito_c => '13' }
-
 end

data/lib/snoopy_afip/core_ext/hash.rb

@@ -20,4 +20,15 @@ class Hash
   def underscore_keys
     dup.underscore_keys!
   end unless method_defined?(:underscore_keys)
+
+  # Implement this method because only is supported by > Rails 4, so if you want use only ruby, this will help. :)
+  def deep_symbolize_keys
+    return self.reduce({}) do |memo, (k, v)|
+      memo.tap { |m| m[k.to_sym] = (v.is_a?(Hash) || v.is_a?(Array)) ? v.deep_symbolize_keys : v }
+    end if self.is_a? Hash
+    return self.reduce([]) do |memo, v|
+      memo << v.deep_symbolize_keys; memo
+    end if self.is_a? Array
+    self
+  end unless method_defined?(:deep_symbolize_keys)
 end

data/lib/snoopy_afip/exceptions.rb

@@ -0,0 +1,74 @@
+module Snoopy
+  module Exception
+
+    class  Exception < ::StandardError
+      attr_accessor :backtrace
+
+      def initialize(msg, backtrace)
+        @backtrace = backtrace
+        super(msg)
+      end
+    end
+
+    class ClientError < Exception
+      def initialize(msj)
+        super(msj, nil)
+      end
+    end
+
+    class ServerTimeout < Timeout::Error
+    end
+
+    module AuthenticationAdapter
+    end
+
+    module AuthorizeAdapter
+      class SetBillNumberParser < Exception
+      end
+
+      class BuildBodyRequest < Exception
+      end
+
+      class ObservationParser < Exception
+      end
+
+      class ErrorParser < Exception
+      end
+
+      class EventsParser < Exception
+      end
+
+      class FecaeSolicitarResultParser < Exception
+      end
+
+      class FecaeResponseParser < Exception
+      end
+
+      class FecompConsultResponseParser < Exception
+      end
+    end
+
+    module Bill
+      # class NonExistAttributes < Exception
+      #   def initialize(attributes, backtrace=nil)
+      #     @backtrace = backtrace
+      #     super("Non exist attributes: #{attributes}", backtrace)
+      #   end
+      # end
+
+      class MissingAttributes < Exception
+        def initialize(attributes, backtrace=nil)
+          @backtrace = backtrace
+          super("Missing attributes: #{attributes}", backtrace)
+        end
+      end
+
+      class InvalidValueAttribute < Exception
+        def initialize(attribute, backtrace=nil)
+          @backtrace = backtrace
+          super("Invalid value for: #{attribute}", backtrace)
+        end
+      end
+    end
+  end
+end

data/lib/snoopy_afip/version.rb

@@ -1,3 +1,3 @@
 module Snoopy
-  VERSION = "2.1.1"
+  VERSION = "3.0.1"
 end