Class: ReamazeAPI::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/reamaze_api/client.rb

Defined Under Namespace

Classes: RaiseErrorMiddleware

Constant Summary

HTTP_METHODS =

HTTP methods used by the API

Returns:

  • an Array.

%i(get put post)
API_URL =

URL for Reamaze API.

Returns:

  • a String.

"https://%{brand}.reamaze.com/api/v1".freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(brand:, login:, token:) { ... } ⇒ void

Initialize a new Client instance.

Parameters:

  • brand —

    Brand name (subdomain from your Reamaze URL)

  • login —

    Reamaze login

  • token —

    Reamaze API token

Yields:

  • Yields a Faraday::Connection if a block is given.



47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/reamaze_api/client.rb', line 47

def initialize(brand:, login:, token:)
  @url = URI.parse(API_URL % { brand: brand })

  @http = Faraday.new(url: @url, ssl: { verify: true }) do |builder|
    builder.request    :json
    builder.response   :json
    builder.use        RaiseErrorMiddleware
    builder.adapter    Faraday.default_adapter
    builder.basic_auth , token

    yield builder if block_given?
  end
end

Instance Attribute Details

#http ⇒ Object (readonly)

HTTP adapter used for API requests.

Returns:

  • a Faraday::Connection.



36
37
38
 
# File 'lib/reamaze_api/client.rb', line 36

def http
  @http
end

Instance Method Details

#articles ⇒ Object

Article resource.

Returns:

  • an Article instance.



64
65
66
 
# File 'lib/reamaze_api/client.rb', line 64

def articles
  @articles ||= Article.new(self)
end

#channels ⇒ Object

Channel resource.

Returns:

  • a Channel instance.



71
72
73
 
# File 'lib/reamaze_api/client.rb', line 71

def channels
  @channels ||= Channel.new(self)
end

#commit(method:, path:, params: {}) ⇒ Object

Submits an HTTP request to the upstream API.

Parameters:

  • method —

    HTTP method (eg: :get, :post)

  • path —

    API path (without `/api/v1` prefix, eg: “/messages”)

  • params —

    Hash of parameters to send with the request (default: {})

Returns:

  • a Hash.

Raises:

  • a ReamazeAPI::Error for any HTTP response code 400-599 unless `ReamazeAPI.config.exceptions` is false.



107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/reamaze_api/client.rb', line 107

def commit(method:, path:, params: {})
  path = "#{@url.path}#{path}"

  response = @http.run_request(method, path, params, {})

  Utils.symbolize_hash(success: response.success?, payload: response.body)
rescue ReamazeAPI::Error => e
  raise if ReamazeAPI.config.exceptions

  Utils.error_hash(e)
end

#contacts ⇒ Object

Contact resource.

Returns:

  • a Contact instance.



79
80
81
 
# File 'lib/reamaze_api/client.rb', line 79

def contacts
  @contacts ||= Contact.new(self)
end

#conversations ⇒ Object

Conversation resource.

Returns:

  • a Conversation instance.



86
87
88
 
# File 'lib/reamaze_api/client.rb', line 86

def conversations
  @conversations ||= Conversation.new(self)
end

#messages ⇒ Object

Message resource.

Returns:

  • a Message instance.



93
94
95
 
# File 'lib/reamaze_api/client.rb', line 93

def messages
  @messages ||= Message.new(self)
end

#paginate(path, resource, params = {}) ⇒ Object

Performs a GET request on the given path/resource. If results are more than one page, each additional page is fetched and added to the payload. If any page returns an error response, that response is immediately returned and no further requests are performed.

Parameters:

  • NOTE: —

    Beware of API rate limiting when using this method with large

  • datasets.
  • path —

    API path (without `/api/v1` prefix, eg: “/messages”)

  • resource —

    ReamazeAPI resource name (eg: `:messages`)

  • params (defaults to: {}) —

    Hash of parameters to send with the request (default: {})

Returns:

  • a Hash.



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/reamaze_api/client.rb', line 132

def paginate(path, resource, params = {})
  params        = Utils.symbolize_hash(params)
  auto_paginate = params.delete(:auto_paginate)
  output        = get(path, params)
  page          = params.fetch(:page, 1)
  success       = output[:success]
  payload       = output[:payload]
  page_count    = payload[:page_count]

  if success && auto_paginate && page_count && page_count > page
    more = paginate(path, resource, params.merge(
      page:          page.next,
      auto_paginate: true
    ))

    if more[:success] && more[:payload]
      payload[resource].concat more[:payload][resource]
    else
      output[:success] = false
      output[:payload] = more[:payload]
    end
  end

  output
end