class Radar::API::Client

Constants

VERB_MAP

Attributes

http[R]

Public Class Methods

new() click to toggle source
# File lib/radar/api/client.rb, line 16
def initialize
  uri = URI.parse(base_uri)
  @http = Net::HTTP.new(uri.host, uri.port)
  @http.use_ssl = Radar.use_ssl
end

Public Instance Methods

delete(path) click to toggle source
# File lib/radar/api/client.rb, line 40
def delete(path)
  request :delete, path
end
get(path, params: {}) click to toggle source
# File lib/radar/api/client.rb, line 24
def get(path, params: {})
  request :get, path, params
end
parsed_response(response, object_class:) click to toggle source
# File lib/radar/api/client.rb, line 44
def parsed_response(response, object_class:)
  response_hash = JSON.parse(response.body)
  response_resource = response_hash[object_class::RESOURCE_NAME[:plural]]
  if collection?(response_resource)
    response_resource.map { |json_item| object_class.new(json_item) }
  else
    object_class.new(response_hash[object_class::RESOURCE_NAME[:singular]])
  end
end
patch(path, params: {}) click to toggle source
# File lib/radar/api/client.rb, line 36
def patch(path, params: {})
  request :patch, path, params
end
post(path, params: {}) click to toggle source
# File lib/radar/api/client.rb, line 28
def post(path, params: {})
  request :post, path, params
end
put(path, params: {}) click to toggle source
# File lib/radar/api/client.rb, line 32
def put(path, params: {})
  request :put, path, params
end

Private Instance Methods

base_uri() click to toggle source
# File lib/radar/api/client.rb, line 56
def base_uri
  @base_uri ||= Radar.use_ssl ? "https://#{Radar.api_host}/" : "http://#{Radar.api_host}/"
end
collection?(response_body) click to toggle source
# File lib/radar/api/client.rb, line 60
def collection?(response_body)
  response_body && response_body.is_a?(Array)
end
encode_path(path, params = nil) click to toggle source
# File lib/radar/api/client.rb, line 107
def encode_path(path, params = nil)
  encoded_path = URI.encode(path)
  return path if params.nil?

  encoded_params = URI.encode_www_form(params)
  [encoded_path, encoded_params].join('?')
end
handle_error(response) click to toggle source
# File lib/radar/api/client.rb, line 80
def handle_error(response)
  error_params = JSON.parse(response.body, symbolize_names: true)[:meta]
  case response.code
  when '400'
    raise Radar::API::BadRequestError.new(error_params)
    # raise Radar::API::UnprocessableEntityError.new(error_params)
  when '401'
    raise Radar::API::UnauthorizedError.new(error_params)
  when '402'
    raise Radar::API::UsageError.new(error_params)
  when '403'
    raise Radar::API::ForbiddenError.new(error_params)
  when '404'
    raise Radar::API::NotFoundError.new(error_params)
  when '409'
    raise Radar::API::ConflictError.new(error_params)
  when '422'
    raise Radar::API::UnprocessableEntityError.new(error_params)
  when '429'
    raise Radar::API::TooManyRequestsError.new(error_params)
  when '451'
    raise Radar::API::UnavailableError.new(error_params)
  else
    raise Radar::API::Error.new(error_params)
  end
end
handle_response(response) click to toggle source
# File lib/radar/api/client.rb, line 75
def handle_response(response)
  return response if %w[200 201 202 204].include?(response.code)
  handle_error(response)
end
headers() click to toggle source
# File lib/radar/api/client.rb, line 115
def headers
  @headers ||= { 'Authorization' => "#{Radar.secret_token}", 'Content-Type' => 'application/json' }
end
parameterize(object) click to toggle source
# File lib/radar/api/client.rb, line 119
def parameterize(object)
  object.tap do |obj|
    return object.map { |item| parameterize(item) } if object.is_a?(Array)

    obj.keys.each do |key|
      obj[key] = parameterize_object(obj[key]) unless (obj[key].is_a?(String) || obj[key].is_a?(Numeric) || obj[key].is_a?(Boolean))
      obj[key.to_s.to_camel_case] = obj.delete(key)
    end
  end
end
parameterize_object(object) click to toggle source
# File lib/radar/api/client.rb, line 130
def parameterize_object(object)
  return parameterize(object.to_h) if Radar::API::Resource.descendants.include?(object.class)
  return parameterize(object) if object.is_a?(Hash)
  return object.map { |item| item.is_a?(String) ? item : parameterize_object(item) } if object.is_a?(Array)
end
request(method, path, params = {}) click to toggle source
# File lib/radar/api/client.rb, line 64
def request(method, path, params = {})
  case method
  when :get
    request = VERB_MAP[method].new(encode_path(path, params), headers)
  else
    request = VERB_MAP[method].new(encode_path(path), headers)
    request.body = parameterize(params).to_json
  end
  handle_response(http.request(request))
end