arca.rb 1.0.0

data/lib/arca/persona_service_a4.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Arca
+  class PersonaServiceA4
+    WSDL = {
+      development: "https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA4?WSDL",
+      production: "https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA4?WSDL",
+      test: "#{Root}/test/fixtures/ws_sr_padron_a4.wsdl"
+    }.freeze
+
+    attr_reader :wsaa
+
+    def initialize(options = {})
+      @cuit = options[:cuit]
+      @wsaa = WSAA.new options.merge(service: "ws_sr_padron_a4")
+      @client = Client.new Hash(options[:savon]).reverse_merge(wsdl: WSDL[@wsaa.env], soap_version: 1)
+    end
+
+    def dummy
+      request(:dummy)[:return]
+    end
+
+    def get_persona(id)
+      message = @wsaa.auth.merge(cuitRepresentada: @cuit, idPersona: id)
+      request(:get_persona, message)[:persona_return][:persona]
+    end
+
+    private
+
+    def request(action, body = nil)
+      @client.request(action, body).to_hash[:"#{action}_response"]
+    end
+  end
+end

data/lib/arca/persona_service_a5.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Arca
+  class PersonaServiceA5
+    WSDL = {
+      development: "https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA5?WSDL",
+      production: "https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA5?WSDL",
+      test: "#{Root}/test/fixtures/ws_sr_padron_a5.wsdl"
+    }.freeze
+
+    attr_reader :wsaa
+
+    def initialize(options = {})
+      @cuit = options[:cuit]
+      @wsaa = WSAA.new options.merge(service: "ws_sr_padron_a5")
+      @client = Client.new Hash(options[:savon]).reverse_merge(wsdl: WSDL[@wsaa.env], soap_version: 1)
+    end
+
+    def dummy
+      request(:dummy)[:return]
+    end
+
+    def get_persona(id)
+      message = @wsaa.auth.merge(cuitRepresentada: @cuit, idPersona: id)
+      request(:get_persona, message)[:persona_return]
+    end
+
+    # Request many personas in one SOAP call. ids: array of CUIT/id_persona.
+    # Returns array of persona_return hashes (same shape as get_persona per element).
+    def get_persona_list(ids)
+      ids = Array(ids)
+      return [] if ids.empty?
+
+      message = @wsaa.auth.merge(cuitRepresentada: @cuit, idPersona: ids.map(&:to_s))
+      raw = request(:get_persona_list, message)[:persona_list_return]
+      personas = raw[:persona]
+      Array.wrap(personas).compact
+    end
+
+    private
+
+    def request(action, body = nil)
+      @client.request(action, body).to_hash[:"#{action}_response"]
+    end
+  end
+end

data/lib/arca/type_conversions.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Arca
+  module TypeConversions
+    def r2x(x, types)
+      convert x, types, marshall_fn
+    end
+
+    def x2r(x, types)
+      convert x, types, parsing_fn
+    end
+
+    private
+
+    # Hace una conversión recursiva de tipo de todos los values según los tipos de las keys indicados en types
+    def convert(object, types, convert_fn)
+      case object
+      when Array
+        object.map { |e| convert e, types, convert_fn }
+      when Hash
+        object.to_h do |k, v|
+          [ k, v.is_a?(Hash) || v.is_a?(Array) ? convert(v, types, convert_fn) : convert_fn[types[k]].call(v) ]
+        end
+      else
+        object
+      end
+    end
+
+    def parsing_fn
+      @parsing_fn ||= Hash.new(proc { |v| v }).tap do |p|
+        p[:date] = proc { |v| ::Date.parse(v) rescue nil }
+        p[:integer] = proc(&:to_i)
+        p[:float] = proc(&:to_f)
+        p[:boolean] = proc { |v| v == "S" }
+      end
+    end
+
+    def marshall_fn
+      @marshall_fn ||= Hash.new(proc { |other| other }).tap do |p|
+        p[:date] = proc { |date| date.strftime("%Y%m%d") }
+      end
+    end
+  end
+end

data/lib/arca/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Arca
+  VERSION = "1.0.0"
+end

data/lib/arca/w_cons_declaracion.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Arca
+  class WConsDeclaracion
+    WSDL = {
+      development: "https://wsaduhomoext.afip.gob.ar/diav2/wconsdeclaracion/wconsdeclaracion.asmx?WSDL",
+      production: "https://webservicesadu.afip.gov.ar/DIAV2/wconsdeclaracion/wconsdeclaracion.asmx?WSDL",
+      test: "#{Root}/test/fixtures/wconsdeclaracion/wconsdeclaracion.wsdl"
+    }.freeze
+
+    attr_reader :wsaa
+
+    def initialize tipo_agente: "IMEX", rol: "IMEX", **options
+      @cuit, @tipo_agente, @rol = options[:cuit], tipo_agente, rol
+      @wsaa = WSAA.new(options.merge(service: "wconsdeclaracion"))
+      @client = Client.new(Hash(options[:savon]).reverse_merge(wsdl: WSDL[@wsaa.env]))
+    end
+
+    def dummy
+      request :dummy
+    end
+
+    def detallada_lista_declaraciones(identificador_declaracion: nil, fecha_oficializacion_desde: nil,
+      fecha_oficializacion_hasta: nil)
+      message = {
+        "argDetalladasListaParams" => {
+          "CuitImportadorExportador" => @cuit,
+          "IdentificadorDeclaracion" => identificador_declaracion,
+          "FechaOficializacionDesde" => fecha_oficializacion_desde&.iso8601,
+          "FechaOficializacionHasta" => fecha_oficializacion_hasta&.iso8601
+        }.compact
+      }
+      request(:detallada_lista_declaraciones, auth.merge(message))[:declaraciones][:declaracion]
+    end
+
+    def detallada_estado(identificador_declaracion)
+      message = { "argIdentificadorDestinacion" => identificador_declaracion }
+      request(:detallada_estado, auth.merge(message))[:estado]
+    end
+
+    private
+
+    def request(action, body = nil)
+      response = @client.request(action, body).to_hash[:"#{action}_response"][:"#{action}_result"]
+      if response[:lista_errores] && response[:lista_errores][:detalle_error][:codigo] != "0"
+        raise ResponseError, Array.wrap(response[:lista_errores][:detalle_error]).map { |e|
+          { code: e[:codigo], msg: e[:descripcion] }
+        }
+      else
+        response
+      end
+    end
+
+    def auth
+      {
+        "argWSAutenticacionEmpresa" => {
+          "Token" => @wsaa.auth[:token],
+          "Sign" => @wsaa.auth[:sign],
+          "CuitEmpresaConectada" => @cuit,
+          "TipoAgente" => @tipo_agente,
+          "Rol" => @rol
+        }
+      }
+    end
+  end
+end

data/lib/arca/ws_constancia_inscripcion.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Arca
+  class WSConstanciaInscripcion
+    WSDL = {
+      development: "https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA5?WSDL",
+      production: "https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA5?WSDL",
+      test: "#{Root}/test/fixtures/ws_sr_constancia_inscripcion/ws_constancia_inscripcion.wsdl"
+    }.freeze
+
+    attr_reader :wsaa
+
+    def initialize(options = {})
+      @cuit = options[:cuit]
+      @wsaa = WSAA.new options.merge(service: "ws_sr_constancia_inscripcion")
+      @client = Client.new Hash(options[:savon]).reverse_merge(wsdl: WSDL[@wsaa.env], soap_version: 1)
+    end
+
+    def dummy
+      request(:dummy)[:return]
+    end
+
+    def get_persona(id)
+      message = @wsaa.auth.merge(cuit_representada: @cuit, id_persona: id)
+      request(:get_persona, message)[:persona_return]
+    end
+
+    private
+
+    def request(action, body = nil)
+      @client.request(action, body).to_hash[:"#{action}_response"]
+    end
+  end
+end

data/lib/arca/wsaa.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Arca
+  class WSAA
+    attr_reader :key, :cert, :service, :ta, :cuit, :client, :env
+
+    WSDL = {
+      development: "https://wsaahomo.afip.gov.ar/ws/services/LoginCms?wsdl",
+      production: "https://wsaa.afip.gov.ar/ws/services/LoginCms?wsdl",
+      test: "#{Root}/test/fixtures/wsaa/wsaa.wsdl"
+    }
+
+    def initialize(options = {})
+      @env = (options[:env] || :test).to_sym
+      @key = options[:key]
+      @cert = options[:cert]
+      @service = options[:service] || "wsfe"
+      @ttl = options[:ttl] || 2400
+      @cuit = options[:cuit]
+      @client = Client.new Hash(options[:savon]).reverse_merge(wsdl: WSDL[@env])
+      @ta_path = options[:ta_path] || default_ta_path
+    end
+
+    def generar_tra(service, ttl)
+      xml = Builder::XmlMarkup.new indent: 2
+      xml.instruct!
+      xml.loginTicketRequest version: 1 do
+        xml.header do
+          xml.uniqueId Time.now.to_i
+          xml.generationTime xsd_datetime Time.now - ttl
+          xml.expirationTime xsd_datetime Time.now + ttl
+        end
+        xml.service service
+      end
+    end
+
+    def firmar_tra(tra, key, crt)
+      key = OpenSSL::PKey::RSA.new key
+      crt = OpenSSL::X509::Certificate.new crt
+      OpenSSL::PKCS7.sign crt, key, tra
+    end
+
+    def codificar_tra(pkcs7)
+      pkcs7.to_pem.lines.to_a[1..-2].join
+    end
+
+    def tra(key, cert, service, ttl)
+      codificar_tra firmar_tra(generar_tra(service, ttl), key, cert)
+    end
+
+    def login
+      response = @client.request :login_cms, in0: tra(@key, @cert, @service, @ttl)
+      ta = Nokogiri::XML(Nokogiri::XML(response.to_xml).text)
+      {
+        token: ta.css("token").text,
+        sign: ta.css("sign").text,
+        generation_time: from_xsd_datetime(ta.css("generationTime").text),
+        expiration_time: from_xsd_datetime(ta.css("expirationTime").text)
+      }
+    end
+
+    def auth
+      ta = obtener_y_cachear_ta
+      { token: ta[:token], sign: ta[:sign] }
+    end
+
+    private
+
+    # Previene el error 'El CEE ya posee un TA valido para el acceso al WSN solicitado' que se genera cuando se pide el token varias veces en poco tiempo
+    def obtener_y_cachear_ta
+      @ta ||= restore_ta
+      if ta_expirado? @ta
+        @ta = login
+        persist_ta @ta
+      end
+      @ta
+    end
+
+    def restore_ta
+      return nil unless File.exist?(@ta_path) && !File.empty?(@ta_path)
+
+      data = JSON.parse(File.read(@ta_path))
+      {
+        token: data["token"],
+        sign: data["sign"],
+        generation_time: data["generation_time"] && Time.parse(data["generation_time"]),
+        expiration_time: data["expiration_time"] && Time.parse(data["expiration_time"])
+      }
+    rescue JSON::ParserError, ArgumentError
+      nil
+    end
+
+    def ta_expirado?(ta)
+      if ta.nil?
+        true
+      elsif ta[:expiration_time].nil?
+        true
+      else
+        ta[:expiration_time] <= Time.now
+      end
+    end
+
+    def persist_ta(ta)
+      dir = File.dirname(@ta_path)
+      FileUtils.mkdir_p(dir)
+
+      payload = {
+        "token" => ta[:token],
+        "sign" => ta[:sign],
+        "generation_time" => ta[:generation_time]&.iso8601,
+        "expiration_time" => ta[:expiration_time]&.iso8601
+      }
+
+      temp_path = "#{@ta_path}.#{Process.pid}.tmp"
+      File.write(temp_path, JSON.generate(payload))
+      File.rename(temp_path, @ta_path)
+    rescue StandardError
+      File.delete(temp_path) if defined?(temp_path) && File.exist?(temp_path)
+      raise
+    end
+
+    def xsd_datetime(time)
+      time.strftime("%Y-%m-%dT%H:%M:%S%z").sub /(\d{2})(\d{2})$/, '\1:\2'
+    end
+
+    def from_xsd_datetime(str)
+      Time.parse(str) rescue nil
+    end
+
+    def default_ta_path
+      # Sanitize to prevent path traversal if cuit/service come from input
+      cuit_safe = @cuit.to_s.gsub(/\D/, "")
+      service_safe = @service.to_s.gsub(/[^a-z0-9_]/, "")
+      basename = "#{cuit_safe}-#{@env}-#{service_safe}-ta.json"
+      File.join(Dir.pwd, "tmp", basename)
+    end
+  end
+end

data/lib/arca/wscdc.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# WSCDC: Web Service de Constatación de Comprobantes (ARCA).
+# Verificación de comprobantes electrónicos (CAE, CAEA, CAI).
+# Documentación: Servicio de Constatación de Comprobantes.
+module Arca
+  class WSCDC
+    WSDL = {
+      development: "https://wswhomo.afip.gov.ar/WSCDC/service.asmx?WSDL",
+      production: "https://servicios1.afip.gov.ar/WSCDC/service.asmx?WSDL",
+      test: "#{Root}/test/fixtures/wscdc/wscdc.wsdl"
+    }.freeze
+
+    include TypeConversions
+
+    attr_reader :wsaa, :cuit
+
+    def initialize(options = {})
+      @cuit = normalize_cuit(options[:cuit])
+      @wsaa = WSAA.new options.merge(service: "wscdc")
+      @client = Client.new Hash(options[:savon]).reverse_merge(
+        wsdl: WSDL[@wsaa.env],
+        soap_version: 1,
+        convert_request_keys_to: :camelcase
+      )
+    end
+
+    def dummy
+      r = raw_request(:comprobante_dummy, nil)
+      result = r[:comprobante_dummy_result]
+      {
+        app_server: result[:app_server],
+        db_server: result[:db_server],
+        auth_server: result[:auth_server]
+      }
+    end
+
+    # Constata un comprobante. cmp_req: hash con cbte_modo, cuit_emisor, pto_vta,
+    # cbte_tipo, cbte_nro, cbte_fch, imp_total, cod_autorizacion y opcionalmente
+    # doc_tipo_receptor, doc_nro_receptor, opcionales.
+    # Returns hash con :cmp_resp, :resultado ('A'|'R'), :observaciones, :fch_proceso, :errors.
+    def comprobante_constatar(cmp_req)
+      message = { auth: auth, cmp_req: cmp_req }
+      r = raw_request(:comprobante_constatar, message)
+      result = r[:comprobante_constatar_result]
+      if result[:errors] && (errs = Array.wrap(result[:errors][:err])).any?
+        raise ResponseError, errs.map { |e| { code: e[:code], msg: e[:msg] } }
+      end
+
+      {
+        cmp_resp: result[:cmp_resp],
+        resultado: result[:resultado],
+        observaciones: parse_observaciones(result[:observaciones]),
+        fch_proceso: result[:fch_proceso],
+        errors: parse_errors(result[:errors]),
+        events: parse_events(result[:events])
+      }
+    end
+
+    # Modalidades de autorización (CAE, CAEA, CAI).
+    def comprobantes_modalidad_consultar
+      r = request(:comprobantes_modalidad_consultar)
+      get_array(r, :fac_mod_tipo)
+    end
+
+    # Tipos de comprobante.
+    def comprobantes_tipo_consultar
+      r = request(:comprobantes_tipo_consultar)
+      x2r get_array(r, :cbte_tipo), id: :integer, fch_desde: :date, fch_hasta: :date
+    end
+
+    # Tipos de documento.
+    def documentos_tipo_consultar
+      r = request(:documentos_tipo_consultar)
+      x2r get_array(r, :doc_tipo), id: :integer, fch_desde: :date, fch_hasta: :date
+    end
+
+    # Tipos de datos opcionales.
+    def opcionales_tipo_consultar
+      r = request(:opcionales_tipo_consultar)
+      get_array(r, :opcional_tipo)
+    end
+
+    private
+
+    def request(action, body = nil)
+      message = body || { auth: auth }
+      r = raw_request(action, message)
+      result_key = :"#{action}_result"
+      result = r[result_key]
+      if result && result[:errors] && (errs = Array.wrap(result[:errors][:err])).any?
+        raise ResponseError, errs.map { |e| { code: e[:code], msg: e[:msg] } }
+      end
+
+      result
+    end
+
+    def auth
+      @wsaa.auth.merge(cuit: cuit)
+    end
+
+    def raw_request(action, body = nil)
+      resp = @client.request(action, body).to_hash[:"#{action}_response"]
+      raise ServerError, "Unexpected response structure" unless resp
+
+      resp
+    end
+
+    def get_array(response, array_element)
+      if response && response[:result_get]
+        Array.wrap(response[:result_get][array_element])
+      else
+        []
+      end
+    end
+
+    def parse_observaciones(observaciones)
+      if observaciones && observaciones[:obs]
+        Array.wrap(observaciones[:obs])
+      else
+        []
+      end
+    end
+
+    def parse_errors(errors)
+      if errors && errors[:err]
+        Array.wrap(errors[:err])
+      else
+        []
+      end
+    end
+
+    def parse_events(events)
+      if events && events[:evt]
+        Array.wrap(events[:evt])
+      else
+        []
+      end
+    end
+
+    def normalize_cuit(value)
+      if value.nil? || value == ""
+        0
+      else
+        value.to_s.gsub(/\D/, "").to_i
+      end
+    end
+  end
+end