class Zuora::Response

Constants

ERROR_STRINGS

Attributes

raw[R]

Public Class Methods

new(response) click to toggle source

@param [Faraday::Response] @return [Zuora::Response]

# File lib/zuora/response.rb, line 12
def initialize(response)
  @raw = response
end

Public Instance Methods

handle_errors(hash) click to toggle source

@param [Hash] hash

# File lib/zuora/response.rb, line 25
def handle_errors(hash)
  errors = []

  hash.each do |key, value|
    if value.is_a?(Hash)
      handle_errors(value)
    elsif value.is_a?(Array)
      value.each { |v| handle_errors(v) unless v.is_a?(String) }
    elsif error?(key, value)
      errors << value
    end
  end

  raise_errors(errors) if errors.present?
end
to_h() click to toggle source

Convert XML body to object-like nested hash. @return [Hashie::Mash] object-like nested hash

# File lib/zuora/response.rb, line 18
def to_h
  doc = Nokogiri::XML raw.body
  hash = Hash.from_xml doc.to_xml
  Hashie::Mash.new(symbolize_keys_deep(hash))
end

Private Instance Methods

error?(key, value) click to toggle source

@param [String|Symbol] key @param [String] value

# File lib/zuora/response.rb, line 45
def error?(key, value)
  ERROR_STRINGS.any? { |str| value.to_s.match(str) } ||
    key.to_s.casecmp('message').zero?
end
raise_errors(errors) click to toggle source

@param [Array] errors

# File lib/zuora/response.rb, line 78
def raise_errors(errors)
  error_string = errors.join(',')
  error = Zuora::Errors::InvalidValue.new(error_string, to_h)
  raise error
end
symbolize_key(key) click to toggle source

Given a key, convert to symbol, removing XML namespace, if any. @param [String] key - a key, either “abc” or “abc:def” @return [Symbol]

# File lib/zuora/response.rb, line 53
def symbolize_key(key)
  return key unless key.respond_to?(:split)
  key.split(':').last.underscore.to_sym
end
symbolize_keys_deep(hash) click to toggle source

Recursively transforms a hash @param [Hash] hash @return [Hash]

# File lib/zuora/response.rb, line 61
def symbolize_keys_deep(hash)
  return hash unless hash.is_a?(Hash)

  Hash[hash.map do |key, value|
    # if value is array, loop each element and recursively symbolize keys
    if value.is_a? Array
      value = value.map { |element| symbolize_keys_deep(element) }
      # if value is hash, recursively symbolize keys
    elsif value.is_a? Hash
      value = symbolize_keys_deep(value)
    end

    [symbolize_key(key), value]
  end]
end