class Synapse::HTTPClient

Wrapper for HTTP requests using RestClient.

Attributes

base_url[RW]

@!attribute [rw] base_url

@return [String] the base url of the API (production or sandbox)

@!attribute [rw] config

@return [Hash] various settings related to request headers

@!attribute [rw] raise_for_202

@return [Boolean] relating to how to handle 202 exception
config[RW]

@!attribute [rw] base_url

@return [String] the base url of the API (production or sandbox)

@!attribute [rw] config

@return [Hash] various settings related to request headers

@!attribute [rw] raise_for_202

@return [Boolean] relating to how to handle 202 exception
raise_for_202[RW]

@!attribute [rw] base_url

@return [String] the base url of the API (production or sandbox)

@!attribute [rw] config

@return [Hash] various settings related to request headers

@!attribute [rw] raise_for_202

@return [Boolean] relating to how to handle 202 exception

Public Class Methods

new(base_url:, client_id:, client_secret:, fingerprint:, ip_address:, raise_for_202:false, **options) click to toggle source

@param base_url [String] the base url of the API (production or sandbox) @param client_id [String] @param client_secret [String] @param fingerprint [String] @param ip_address [String] @param raise_for_202 [String] @param logging [Boolean] (optional) logs to stdout when true @param log_to [String] (optional) file path to log to file (logging must be true)

# File lib/synapse_api/http_request.rb, line 25
          def initialize(base_url:, client_id:, client_secret:, fingerprint:, ip_address:, raise_for_202:false, **options)
@raise_for_202 = raise_for_202
                  log_to         = options[:log_to] || 'stdout'
                  RestClient.log = log_to if options[:logging]
                  @logging       = options[:logging]

                  @config = {
                          client_id: client_id,
                          client_secret: client_secret,
                          fingerprint: fingerprint,
                          ip_address: ip_address,
                          oauth_key:  '',
                  }
                  @base_url = base_url
          end

Public Instance Methods

delete(path) click to toggle source

Sends a DELETE request to the given path @param path [String] @return [Hash] API response @raise [Synapse::Error] subclass depends on HTTP response

# File lib/synapse_api/http_request.rb, line 135
def delete(path)
  response = with_error_handling {RestClient.delete(full_url(path), headers)}
  puts 'RESPONSE:', JSON.parse(response) if @logging
  response = JSON.parse(response)

  if raise_for_202 && response["http_code"] == "202"
    raise Error.from_response(response)
  elsif response["error"]
    raise Error.from_response(response)
  else
    response
  end
end
get(path) click to toggle source

Sends a GET request to the given path with the given payload. @param path [String] @return [Hash] API response @raise [Synapse::Error] subclass depends on HTTP response

# File lib/synapse_api/http_request.rb, line 117
          def get(path)
                  response = with_error_handling {RestClient.get(full_url(path), headers)}
                  puts 'RESPONSE:', JSON.parse(response) if @logging
                  response = JSON.parse(response)

if raise_for_202 && response["http_code"] == "202"
  raise Error.from_response(response)
elsif response["error"]
  raise Error.from_response(response)
else
  response
end
          end
get_headers()

Alias for headers (copy of current headers)

Alias for: headers
headers() click to toggle source

Returns headers for HTTP requests. @return [Hash]

# File lib/synapse_api/http_request.rb, line 43
          def headers
                  user    = "#{config[:oauth_key]}|#{config[:fingerprint]}"
                  gateway = "#{config[:client_id]}|#{config[:client_secret]}"
                  headers = {
                          content_type: :json,
                          accept: :json,
                          'X-SP-GATEWAY' => gateway,
                      'X-SP-USER'    => user,
                      'X-SP-USER-IP' => config[:ip_address],
                  }
if config[:idemopotency_key]
  headers['X-SP-IDEMPOTENCY-KEY'] = config[:idemopotency_key]
end
headers
          end
Also aliased as: get_headers
oauthenticate(user_id:) click to toggle source
# File lib/synapse_api/http_request.rb, line 173
def oauthenticate(user_id:)
  refresh_token = refresh_token(user_id: user_id)
end
patch(path, payload) click to toggle source

Sends a PATCH request to the given path with the given payload. @param path [String] @param payload [Hash] @return [Hash] API response @raise [Synapse::Error] subclass depends on HTTP response

# File lib/synapse_api/http_request.rb, line 154
          def patch(path, payload)
                  response = with_error_handling {RestClient::Request.execute(:method =>  :patch,
                                                            :url =>     full_url(path),
                                                            :payload => payload.to_json,
                                                            :headers => headers,
                                                            :timeout => 300
                                                            )}
                  p 'RESPONSE:', JSON.parse(response) if @logging
                  response = JSON.parse(response)

if raise_for_202 && response["http_code"] == "202"
  raise Error.from_response(response)
elsif response["error"]
  raise Error.from_response(response)
else
  response
end
          end
post(path, payload, **options) click to toggle source

Send a POST request to the given path with the given payload @param path [String] @param payload [HASH] @param **options payload = idempotency_key [String] (optional) avoid accidentally performing the same operation twice @return [Hash] API response @raise [Synapse::Error] subclass depends on HTTP response

# File lib/synapse_api/http_request.rb, line 86
def post(path, payload, **options)
    #copy of current headers
    headers = get_headers

    # update the headers with idempotency_key
    if options[:idempotency_key]
            headers = headers.merge({'X-SP-IDEMPOTENCY-KEY' => options[:idempotency_key]})
    end

    response = with_error_handling { RestClient::Request.execute(:method =>  :post,
                                                               :url =>     full_url(path),
                                                               :payload => payload.to_json,
                                                               :headers => headers,
                                                               :timeout => 300
                                                               ) }
    puts 'RESPONSE:', JSON.parse(response) if @logging
    response = JSON.parse(response)

  if raise_for_202 && response["http_code"] == "202"
    raise Error.from_response(response)
  elsif response["error"]
    raise Error.from_response(response)
  else
    response
  end
end
update_headers(oauth_key: nil, fingerprint: nil, client_id: nil, client_secret: nil, ip_address: nil, idemopotency_key: nil) click to toggle source

Updates current HTPP headers @param fingerprint [String] @param oauth_key [String] @param fingerprint [String] @param client_id [String] @param client_secret [String] @param ip_address [String] @param idemopotency_key [String]

# File lib/synapse_api/http_request.rb, line 70
          def update_headers(oauth_key: nil, fingerprint: nil, client_id: nil, client_secret: nil, ip_address: nil, idemopotency_key: nil)
                  config[:fingerprint]   = fingerprint if fingerprint
                  config[:oauth_key]     = oauth_key if oauth_key
                  config[:client_id]     = client_id if client_id
                  config[:client_secret] = client_secret if client_secret
                  config[:ip_address]    = ip_address if ip_address
config[:idemopotency_key] = idemopotency_key if idemopotency_key
                  nil
          end

Private Instance Methods

authenticate(refresh_token, oauth_path) click to toggle source

options payload to change scope of oauth

# File lib/synapse_api/http_request.rb, line 194
def authenticate(refresh_token, oauth_path)
  oauth_key = post(oauth_path, refresh_token)
  oauth_key = oauth_key['oauth_key']
  update_headers(oauth_key: oauth_key)
  nil
end
full_url(path) click to toggle source
# File lib/synapse_api/http_request.rb, line 205
def full_url(path)
  "#{base_url}#{path}"
end
oauth_path(user_id) click to toggle source
# File lib/synapse_api/http_request.rb, line 201
def oauth_path(user_id)
  "/oauth/#{user_id}"
end
refresh_token(user_id:) click to toggle source

get user get refresh_token send refresh_token to oauth path grabs the refresh token and formats a refresh token payload

# File lib/synapse_api/http_request.rb, line 183
def refresh_token(user_id:)
  path = "/users/#{user_id}"
  response = get(path)
  refresh_token = response["refresh_token"]

  refresh_token = {"refresh_token" => refresh_token}
  oauth_path = oauth_path(user_id)
  authenticate(refresh_token, oauth_path)
end
with_error_handling() { || ... } click to toggle source

raising an exception based on http_request yeilds if http_request raises an exception

# File lib/synapse_api/http_request.rb, line 211
def with_error_handling
        yield
rescue RestClient::Exceptions::Timeout
        body = {
                error: {
                        en: "Request Timeout"
                },
                http_code: 504
        }
        raise Error.from_response(body)
rescue RestClient::Exception => e
        if e.response.headers[:content_type] == 'application/json'
                body = JSON.parse(e.response.body)
        else
                body = {
                        error: {
                                en: e.response.body
                        },
                        http_code: e.response.code
                }
        end
        raise Error.from_response(body)
end