module DomoscioRails

api_uri(url = '') click to toggle source

# File lib/domoscio_rails.rb, line 80
def self.api_uri(url = '')
  URI(configuration.root_url + url)
end

configure() { |configuration| ... } click to toggle source

# File lib/domoscio_rails.rb, line 75
def self.configure
  self.configuration ||= Configuration.new
  yield configuration
end

perform_call(uri, method, params, headers) click to toggle source

Actual HTTP call is performed here

# File lib/domoscio_rails.rb, line 179
def self.perform_call(uri, method, params, headers)
  Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
    req = Net::HTTP.const_get(method.capitalize).new(uri.request_uri, headers)
    req.body = DomoscioRails::JSON.dump(params)
    http.request req
  end
end

raise_http_failure(uri, response, params) click to toggle source

This helper will check the response status and build the correcponding DomoscioRails::ResponseError

# File lib/domoscio_rails.rb, line 166
def self.raise_http_failure(uri, response, params)
  return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPNoContent)

  raise ResponseError.new(
    uri,
    response.code.to_i,
    DomoscioRails::JSON.load((response.body.nil? ? '' : response.body), symbolize_keys: true),
    response.body, params
  )
end

request(method, url, params = {}) click to toggle source

method: HTTP method; lowercase symbol, e.g. :get, :post etc.
url: the part after Configuration#root_url
params: hash; entity data for creation, update etc.; will dump it by JSON and assign to Net::HTTPRequest#body

Performs HTTP requests to Adaptive Engine On token issues, will try once to get a new token then will output a DomoscioRails::ReponseError with details

Raises DomoscioRails::ResponseError on Adaptive Error Status Raises DomoscioRails::ProcessingError on Internal Error

# File lib/domoscio_rails.rb, line 95
def self.request(method, url, params = {})
  params ||= {}
  store_tokens, headers = request_headers
  params.merge!({ 'per_page': 1000 }) unless params[:per_page]
  uri = api_uri(url)
  response = DomoscioRails.send_request(uri, method, params, headers)
  return response if response.is_a? DomoscioRails::ProcessingError

  begin
    raise_http_failure(uri, response, params)

    if response['Content-Type'] == 'application/zip' || response['Content-Type'] == 'application/xlsx'
      data = response
    elsif response.is_a?(Net::HTTPNoContent)
      data = []
    else
      data = DomoscioRails::JSON.load(response.body.nil? ? '' : response.body)
    end

    if store_tokens
      DomoscioRails::AuthorizationToken::Manager.storage.store({
                                                                 access_token: response['Accesstoken'],
                                                                 refresh_token: response['Refreshtoken']
                                                               })
    end
  rescue MultiJson::LoadError => e
    data = ProcessingError.new(uri, 500, e, response.body, params)
  rescue ResponseError => e
    data = e
  end

  if response['Total'] || response['Total-Pages'] != '1'

    pagetotal = if response['Total']
                  (response['Total'].to_i / response['Per-Page'].to_f).ceil
                else
                  response['Total-Pages'].to_i
                end

    (2..pagetotal).each do |j|
      response = DomoscioRails.send_request(uri, method, params.merge({ page: j }), headers)
      return response if response.is_a? DomoscioRails::ProcessingError

      begin
        raise_http_failure(uri, response, params)
        body = DomoscioRails::JSON.load(response.body.nil? ? '' : response.body)
        data += body
        data.flatten!
      rescue MultiJson::LoadError => e
        return ProcessingError.new(uri, 500, e, response.body, params)
      rescue ResponseError => e
        return e
      end
    end
  end
  data
end

request_headers() click to toggle source

Process the token loading and analyze will return the processed headers and a token store flag

# File lib/domoscio_rails.rb, line 219
def self.request_headers
  auth_token = DomoscioRails::AuthorizationToken::Manager.token
  if auth_token && auth_token[:access_token] && auth_token[:refresh_token]
    [false, send_current_tokens(auth_token)]
  else
    [true, request_new_tokens]
  end
rescue SyntaxError, StandardError
  [true, request_new_tokens]
end

request_new_tokens() click to toggle source

If we cant find tokens of they are corrupted / expired, then we set headers to request new ones

# File lib/domoscio_rails.rb, line 242
def self.request_new_tokens
  {
    'user_agent' => DomoscioRails.user_agent.to_s,
    'Authorization' => "Token token=#{DomoscioRails.configuration.client_passphrase}",
    'Content-Type' => 'application/json'
  }
end

retry_call_and_store_tokens(uri, method, params) click to toggle source

This method is called when AdaptiveEngine returns tokens errors Action on those errors is to retry and request new tokens, those new token are then stored

# File lib/domoscio_rails.rb, line 189
def self.retry_call_and_store_tokens(uri, method, params)
  headers = request_new_tokens
  response = perform_call(uri, method, params, headers)
  DomoscioRails::AuthorizationToken::Manager.storage.store({
                                                             access_token: response['Accesstoken'],
                                                             refresh_token: response['Refreshtoken']
                                                           })
  response
end

send_current_tokens(auth_token) click to toggle source

If stored token successfully loaded we build the header with them

# File lib/domoscio_rails.rb, line 232
def self.send_current_tokens(auth_token)
  {
    'user_agent' => DomoscioRails.user_agent.to_s,
    'AccessToken' => auth_token[:access_token].to_s,
    'RefreshToken' => auth_token[:refresh_token].to_s,
    'Content-Type' => 'application/json'
  }
end

send_request(uri, method, params, headers) click to toggle source

This function catches usual Http errors during callsheaders

# File lib/domoscio_rails.rb, line 155
def self.send_request(uri, method, params, headers)
  response = perform_call(uri, method, params, headers)
  response = retry_call_and_store_tokens(uri, method, params) if %w[401 403].include? response.code
  response
rescue Timeout::Error, Errno::EINVAL, Errno::ECONNREFUSED, Errno::ECONNRESET,
       EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
  ProcessingError.new(uri, 500, e, response)
end

uname() click to toggle source

# File lib/domoscio_rails.rb, line 210
def self.uname
  `uname -a 2>/dev/null` if RUBY_PLATFORM =~ /linux|darwin/i
rescue Errno::ENOMEM
  'uname lookup failed'
end

user_agent() click to toggle source

# File lib/domoscio_rails.rb, line 199
def self.user_agent
  @uname ||= uname
  {
    bindings_version: DomoscioRails::VERSION,
    lang: 'ruby',
    lang_version: "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
    platform: RUBY_PLATFORM,
    uname: @uname
  }.to_s
end

Constants

Attributes

Public Class Methods