Class: Braintree::Configuration

Inherits:
Object
  • Object
show all
Defined in:
lib/braintree/configuration.rb

Constant Summary collapse

API_VERSION =

:nodoc:

"6"
DEFAULT_ENDPOINT =

:nodoc:

"api"
GRAPHQL_API_VERSION =

:nodoc:

"2018-09-10"
READABLE_ATTRIBUTES =
[
  :merchant_id,
  :public_key,
  :private_key,
  :client_id,
  :client_secret,
  :access_token,
  :environment
]
NON_REQUIRED_READABLE_ATTRIBUTES =
[
  :proxy_address,
  :proxy_port,
  :proxy_user,
  :proxy_pass,
  :ssl_version
]
WRITABLE_ATTRIBUTES =
[
  :custom_user_agent,
  :endpoint,
  :http_open_timeout,
  :http_read_timeout,
  :logger,
  :merchant_id,
  :public_key,
  :private_key,
  :environment,
  :proxy_address,
  :proxy_port,
  :proxy_user,
  :proxy_pass,
  :ssl_version
]

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Configuration

Returns a new instance of Configuration.


113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
# File 'lib/braintree/configuration.rb', line 113

def initialize(options = {})
  WRITABLE_ATTRIBUTES.each do |attr|
    instance_variable_set "@#{attr}", options[attr]
  end

  @environment = @environment.to_sym if @environment

  _check_for_mixed_credentials(options)

  parser = Braintree::CredentialsParser.new
  if options[:client_id] || options[:client_secret]
    parser.parse_client_credentials(options[:client_id], options[:client_secret])
    @client_id = parser.client_id
    @client_secret = parser.client_secret
    @environment = parser.environment
  elsif options[:access_token]
    parser.parse_access_token(options[:access_token])

    _check_for_mixed_environment(options[:environment], parser.environment)

    @access_token = parser.access_token
    @environment = parser.environment
    @merchant_id = parser.merchant_id
  else
    @merchant_id = options[:merchant_id] || options[:partner_id]
  end
end

Class Method Details

._default_loggerObject

:nodoc:


288
289
290
291
292
# File 'lib/braintree/configuration.rb', line 288

def self._default_logger # :nodoc:
  logger = Logger.new(STDOUT)
  logger.level = Logger::INFO
  logger
end

.environment=(env) ⇒ Object

Sets the Braintree environment to use. Valid values are :sandbox and :production


62
63
64
65
66
67
68
# File 'lib/braintree/configuration.rb', line 62

def self.environment=(env)
  env = env.to_sym
  unless [:development, :qa, :sandbox, :production].include?(env)
    raise ArgumentError, "#{env.inspect} is not a valid environment"
  end
  @environment = env
end

.expectant_reader(*attributes) ⇒ Object

:nodoc:


50
51
52
53
54
55
56
57
58
# File 'lib/braintree/configuration.rb', line 50

def self.expectant_reader(*attributes) # :nodoc:
  attributes.each do |attribute|
    (class << self; self; end).send(:define_method, attribute) do
      attribute_value = instance_variable_get("@#{attribute}")
      raise ConfigurationError.new("Braintree::Configuration.#{attribute.to_s} needs to be set") if attribute_value.nil? || attribute_value.to_s.empty?
      attribute_value
    end
  end
end

.gatewayObject

:nodoc:


70
71
72
# File 'lib/braintree/configuration.rb', line 70

def self.gateway # :nodoc:
  Braintree::Gateway.new(instantiate)
end

.http_open_timeoutObject


93
94
95
# File 'lib/braintree/configuration.rb', line 93

def self.http_open_timeout
  @http_open_timeout ||= 60
end

.http_read_timeoutObject


97
98
99
# File 'lib/braintree/configuration.rb', line 97

def self.http_read_timeout
  @http_read_timeout ||= 60
end

.instantiateObject

:nodoc:


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
# File 'lib/braintree/configuration.rb', line 74

def self.instantiate # :nodoc:
  config = new(
    :custom_user_agent => @custom_user_agent,
    :endpoint => @endpoint,
    :environment => environment,
    :http_open_timeout => http_open_timeout,
    :http_read_timeout => http_read_timeout,
    :logger => logger,
    :merchant_id => merchant_id,
    :private_key => private_key,
    :public_key => public_key,
    :proxy_address => proxy_address,
    :proxy_port => proxy_port,
    :proxy_user => proxy_user,
    :proxy_pass => proxy_pass,
    :ssl_version => ssl_version,
  )
end

.loggerObject


101
102
103
# File 'lib/braintree/configuration.rb', line 101

def self.logger
  @logger ||= _default_logger
end

.sha256_signature_serviceObject


109
110
111
# File 'lib/braintree/configuration.rb', line 109

def self.sha256_signature_service
  instantiate.sha256_signature_service
end

.signature_serviceObject


105
106
107
# File 'lib/braintree/configuration.rb', line 105

def self.signature_service
  instantiate.signature_service
end

Instance Method Details

#_check_for_mixed_credentials(options) ⇒ Object


141
142
143
144
145
146
147
148
149
150
151
152
153
# File 'lib/braintree/configuration.rb', line 141

def _check_for_mixed_credentials(options)
  if (options[:client_id] || options[:client_secret]) && (options[:public_key] || options[:private_key])
    raise ConfigurationError.new("Braintree::Gateway cannot be initialized with mixed credential types: client_id and client_secret mixed with public_key and private_key.")
  end

  if (options[:client_id] || options[:client_secret]) && (options[:access_token])
    raise ConfigurationError.new("Braintree::Gateway cannot be initialized with mixed credential types: client_id and client_secret mixed with access_token.")
  end

  if (options[:public_key] || options[:private_key]) && (options[:access_token])
    raise ConfigurationError.new("Braintree::Gateway cannot be initialized with mixed credential types: public_key and private_key mixed with access_token.")
  end
end

#_check_for_mixed_environment(options_environment, token_environment) ⇒ Object


155
156
157
158
159
# File 'lib/braintree/configuration.rb', line 155

def _check_for_mixed_environment(options_environment, token_environment)
  if options_environment && options_environment.to_sym != token_environment.to_sym
    warn "Braintree::Gateway should not be initialized with mixed environments: environment parameter and access_token do not match, environment from access_token is used."
  end
end

#api_versionObject

:nodoc:


161
162
163
# File 'lib/braintree/configuration.rb', line 161

def api_version # :nodoc:
  API_VERSION
end

#assert_has_access_token_or_keysObject


308
309
310
311
312
# File 'lib/braintree/configuration.rb', line 308

def assert_has_access_token_or_keys
  if (public_key.nil? || private_key.nil?) && access_token.nil?
    raise ConfigurationError.new("Braintree::Gateway access_token or public_key and private_key are required.")
  end
end

#assert_has_client_credentialsObject


302
303
304
305
306
# File 'lib/braintree/configuration.rb', line 302

def assert_has_client_credentials
  if client_id.nil? || client_secret.nil?
    raise ConfigurationError.new("Braintree::Gateway client_id and client_secret are required.")
  end
end

#auth_urlObject


261
262
263
264
265
266
267
268
269
270
271
272
# File 'lib/braintree/configuration.rb', line 261

def auth_url
  case @environment
  when :development, :integration
    "http://auth.venmo.dev:9292"
  when :production
    "https://auth.venmo.com"
  when :qa
    "https://auth.venmo.qa2.braintreegateway.com"
  when :sandbox
    "https://auth.venmo.sandbox.braintreegateway.com"
  end
end

#base_merchant_pathObject

:nodoc:


169
170
171
# File 'lib/braintree/configuration.rb', line 169

def base_merchant_path # :nodoc:
  "/merchants/#{merchant_id}"
end

#base_merchant_urlObject

:nodoc:


181
182
183
# File 'lib/braintree/configuration.rb', line 181

def base_merchant_url # :nodoc:
  "#{base_url}#{base_merchant_path}"
end

#base_urlObject


173
174
175
# File 'lib/braintree/configuration.rb', line 173

def base_url
  "#{protocol}://#{server}:#{port}"
end

#ca_fileObject

:nodoc:


185
186
187
# File 'lib/braintree/configuration.rb', line 185

def ca_file # :nodoc:
  File.expand_path(File.join(File.dirname(__FILE__), "..", "ssl", "api_braintreegateway_com.ca.crt"))
end

#client_credentials?Boolean

Returns:

  • (Boolean)

298
299
300
# File 'lib/braintree/configuration.rb', line 298

def client_credentials?
  !client_id.nil?
end

#endpointObject


189
190
191
# File 'lib/braintree/configuration.rb', line 189

def endpoint
  @endpoint || DEFAULT_ENDPOINT
end

#graphql_api_versionObject

:nodoc:


165
166
167
# File 'lib/braintree/configuration.rb', line 165

def graphql_api_version # :nodoc:
  GRAPHQL_API_VERSION
end

#graphql_base_urlObject


177
178
179
# File 'lib/braintree/configuration.rb', line 177

def graphql_base_url
  "#{protocol}://#{graphql_server}:#{graphql_port}/graphql"
end

#graphql_clientObject


197
198
199
# File 'lib/braintree/configuration.rb', line 197

def graphql_client
  GraphQLClient.new(self)
end

#graphql_portObject

:nodoc:


214
215
216
217
218
219
220
221
# File 'lib/braintree/configuration.rb', line 214

def graphql_port # :nodoc:
  case @environment
  when :development, :integration
    ENV["GRAPHQL_PORT"] || 8080
  when :production, :qa, :sandbox
    443
  end
end

#graphql_serverObject

:nodoc:


248
249
250
251
252
253
254
255
256
257
258
259
# File 'lib/braintree/configuration.rb', line 248

def graphql_server # :nodoc:
  case @environment
  when :development, :integration
    ENV["GRAPHQL_HOST"] || "graphql.bt.local"
  when :production
    "payments.braintree-api.com"
  when :qa
    "payments-qa.dev.braintree-api.com"
  when :sandbox
    "payments.sandbox.braintree-api.com"
  end
end

#httpObject

:nodoc:


193
194
195
# File 'lib/braintree/configuration.rb', line 193

def http # :nodoc:
  Http.new(self)
end

#http_open_timeoutObject


227
228
229
# File 'lib/braintree/configuration.rb', line 227

def http_open_timeout
  @http_open_timeout
end

#http_read_timeoutObject


231
232
233
# File 'lib/braintree/configuration.rb', line 231

def http_read_timeout
  @http_read_timeout
end

#inspectObject


294
295
296
# File 'lib/braintree/configuration.rb', line 294

def inspect
  super.gsub(/@private_key=\".*\"/, '@private_key="[FILTERED]"')
end

#loggerObject


201
202
203
# File 'lib/braintree/configuration.rb', line 201

def logger
  @logger ||= self.class._default_logger
end

#portObject

:nodoc:


205
206
207
208
209
210
211
212
# File 'lib/braintree/configuration.rb', line 205

def port # :nodoc:
  case @environment
  when :development, :integration
    ENV["GATEWAY_PORT"] || 3000
  when :production, :qa, :sandbox
    443
  end
end

#protocolObject

:nodoc:


223
224
225
# File 'lib/braintree/configuration.rb', line 223

def protocol # :nodoc:
  ssl? ? "https" : "http"
end

#serverObject

:nodoc:


235
236
237
238
239
240
241
242
243
244
245
246
# File 'lib/braintree/configuration.rb', line 235

def server # :nodoc:
  case @environment
  when :development, :integration
    ENV["GATEWAY_HOST"] || "localhost"
  when :production
    "#{endpoint}.braintreegateway.com"
  when :qa
    "gateway.qa.braintreepayments.com"
  when :sandbox
    "api.sandbox.braintreegateway.com"
  end
end

#sha256_signature_serviceObject


318
319
320
# File 'lib/braintree/configuration.rb', line 318

def sha256_signature_service
  @sha256_signature_service ||= SignatureService.new(@private_key, SHA256Digest)
end

#signature_serviceObject


314
315
316
# File 'lib/braintree/configuration.rb', line 314

def signature_service
  @signature_service ||= SignatureService.new(@private_key)
end

#ssl?Boolean

:nodoc:

Returns:

  • (Boolean)

274
275
276
277
278
279
280
281
# File 'lib/braintree/configuration.rb', line 274

def ssl? # :nodoc:
  case @environment
  when :development, :integration
    false
  when :production, :qa, :sandbox
    true
  end
end

#user_agentObject

:nodoc:


283
284
285
286
# File 'lib/braintree/configuration.rb', line 283

def user_agent # :nodoc:
  base_user_agent = "Braintree Ruby Gem #{Braintree::Version::String}"
  @custom_user_agent ? "#{base_user_agent} (#{@custom_user_agent})" : base_user_agent
end