Class: ZendeskAPI::Client

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

Overview

The top-level class that handles configuration and connection to the Zendesk API. Can also be used as an accessor to resource collections.

Constant Summary

GZIP_EXCEPTIONS = 
[:em_http, :httpclient]

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize {|config| ... } ⇒ Client

Creates a new ZendeskAPI::Client instance and yields #config.

Requires a block to be given.

Does basic configuration constraints:

Yields:

Raises:

  • (ArgumentError) 


83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/zendesk_api/client.rb', line 83

def initialize
  raise ArgumentError, "block not given" unless block_given?

  @config = ZendeskAPI::Configuration.new
  yield config

  @callbacks = []
  @resource_cache = {}

  check_url

  config.retry = !!config.retry # nil -> false

  set_token_auth

  set_default_logger
  add_warning_callback
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Collection

Handles resources such as 'tickets'. Any options are passed to the underlying collection, except reload which disregards memoization and creates a new Collection instance.

Returns:

  • (Collection) —

    Collection instance for resource



38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/zendesk_api/client.rb', line 38

def method_missing(method, *args, &block)
  method = method.to_s
  options = args.last.is_a?(Hash) ? args.pop : {}

  @resource_cache[method] ||= { :class => nil, :cache => ZendeskAPI::LRUCache.new }
  if !options.delete(:reload) && (cached = @resource_cache[method][:cache].read(options.hash))
    cached
  else
    @resource_cache[method][:class] ||= method_as_class(method)
    raise "Resource for #{method} does not exist" unless @resource_cache[method][:class]
    @resource_cache[method][:cache].write(options.hash, ZendeskAPI::Collection.new(self, @resource_cache[method][:class], options))
  end
end

Instance Attribute Details

#callbacks ⇒ Array (readonly)

Returns Custom response callbacks

Returns:

  • (Array) —

    Custom response callbacks



33
34
35
 
# File 'lib/zendesk_api/client.rb', line 33

def callbacks
  @callbacks
end

#config ⇒ Configuration (readonly)

Returns Config instance

Returns:



31
32
33
 
# File 'lib/zendesk_api/client.rb', line 31

def config
  @config
end

Class Method Details

.check_deprecated_namespace_usage(attributes, name) ⇒ Object

show a nice warning for people using the old style api



117
118
119
120
121
 
# File 'lib/zendesk_api/client.rb', line 117

def self.check_deprecated_namespace_usage(attributes, name)
  if attributes[name].is_a?(Hash)
    raise "un-nest '#{name}' from the attributes"
  end
end

Instance Method Details

#build_connection ⇒ Object (protected)

Called by #connection to build a connection. Can be overwritten in a subclass to add additional middleware and make other configuration changes.

Uses middleware according to configuration options.

Request logger if logger is not nil

Retry middleware if retry is true



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/zendesk_api/client.rb', line 141

def build_connection
  Faraday.new(config.options) do |builder|
    # response
    builder.use ZendeskAPI::Middleware::Response::RaiseError
    builder.use ZendeskAPI::Middleware::Response::Callback, self
    builder.use ZendeskAPI::Middleware::Response::Logger, config.logger if config.logger
    builder.use ZendeskAPI::Middleware::Response::ParseIsoDates
    builder.use ZendeskAPI::Middleware::Response::ParseJson
    builder.use ZendeskAPI::Middleware::Response::SanitizeResponse

    adapter = config.adapter || Faraday.default_adapter

    unless GZIP_EXCEPTIONS.include?(adapter)
      builder.use ZendeskAPI::Middleware::Response::Gzip
      builder.use ZendeskAPI::Middleware::Response::Deflate
    end

    # request
    if config.access_token && !config.url_based_access_token
      builder.authorization("Bearer", config.access_token)
    elsif config.access_token
      builder.use ZendeskAPI::Middleware::Request::UrlBasedAccessToken, config.access_token
    else
      builder.use Faraday::Request::BasicAuthentication, config.username, config.password
    end

    if config.cache
      builder.use ZendeskAPI::Middleware::Request::EtagCache, :cache => config.cache
    end

    builder.use ZendeskAPI::Middleware::Request::Upload
    builder.request :multipart
    builder.use ZendeskAPI::Middleware::Request::EncodeJson
    builder.use ZendeskAPI::Middleware::Request::Retry, :logger => config.logger if config.retry # Should always be first in the stack

    builder.adapter(*adapter)
  end
end

#connection ⇒ Faraday::Connection

Creates a connection if there is none, otherwise returns the existing connection.

Returns:

  • (Faraday::Connection) —

    Faraday connection for the client



105
106
107
108
 
# File 'lib/zendesk_api/client.rb', line 105

def connection
  @connection ||= build_connection
  return @connection
end

#current_account(reload = false) ⇒ Hash

Returns the current account

Returns:

  • (Hash) —

    The attributes of the current account or nil



65
66
67
68
 
# File 'lib/zendesk_api/client.rb', line 65

def (reload = false)
  return @current_account if @current_account && !reload
  @current_account = SilentMash.new(connection.get('account/resolve').body)
end

#current_locale(reload = false) ⇒ ZendeskAPI::Locale

Returns the current locale

Returns:



72
73
74
75
 
# File 'lib/zendesk_api/client.rb', line 72

def current_locale(reload = false)
  return @locale if @locale && !reload
  @locale = locales.find(:id => 'current')
end

#current_user(reload = false) ⇒ ZendeskAPI::User

Returns the current user (aka me)

Returns:



58
59
60
61
 
# File 'lib/zendesk_api/client.rb', line 58

def current_user(reload = false)
  return @current_user if @current_user && !reload
  @current_user = users.find(:id => 'me')
end

#insert_callback(&block) ⇒ Object

Pushes a callback onto the stack. Callbacks are executed on responses, last in the Faraday middleware stack.

Parameters:

  • block (Proc) —

    The block to execute. Takes one parameter, env.



112
113
114
 
# File 'lib/zendesk_api/client.rb', line 112

def insert_callback(&block)
  @callbacks << block
end

#respond_to?(method, *args) ⇒ Boolean

Returns:

  • (Boolean) 


52
53
54
 
# File 'lib/zendesk_api/client.rb', line 52

def respond_to?(method, *args)
  ((cache = @resource_cache[method]) && cache[:class]) || !method_as_class(method).nil? || super
end