Class: Taproot

Inherits:

Sinatra::Base

• Object
• Sinatra::Base
• Taproot

Includes:

Term::ANSIColor

Defined in:

lib/taproot.rb

Instance Method Summary

• #_client_token(options = {}) ⇒ Object
• #_color_status(status) ⇒ Object
• #log(message) ⇒ Object
• #nonce_from_params ⇒ Object
• #sale(nonce, amount) ⇒ Object
• #server_config ⇒ Object
• #vault(nonce, customer_id) ⇒ Object

Instance Method Details

#_client_token(options = {}) ⇒ Object

# File 'lib/taproot.rb', line 275

def _client_token(options = {})
  content_type :json

  raw_client_token = Braintree::ClientToken.generate(params)
  client_token = JSON.parse(Base64.decode64(raw_client_token))
  if Braintree::Configuration.environment == :production
    client_token["venmo"] = "production"
  end

  if options[:decoded]
    client_token
  else
    Base64.strict_encode64(JSON.dump(client_token))
  end
end

#_color_status(status) ⇒ Object

# File 'lib/taproot.rb', line 291

def _color_status(status)
  if status >= 400
    yellow status.to_s
  elsif status >= 500
    red status.to_s
  else
    green status.to_s
  end
end

#log(message) ⇒ Object

# File 'lib/taproot.rb', line 220

def log(message)
  puts "--- [#{CONFIG_MANAGER.current}] #{message}"
end

#nonce_from_params ⇒ Object

# File 'lib/taproot.rb', line 224

def nonce_from_params
  server_config[:nonce_param_names].find do |nonce_param_name|
    if params[nonce_param_name]
      return params[nonce_param_name]
    end
  end
end

#sale(nonce, amount) ⇒ Object

# File 'lib/taproot.rb', line 232

def sale(nonce, amount)
  transaction_params = {
    :amount => amount,
    :payment_method_nonce => nonce,
  }

  if CONFIG_MANAGER.current_merchant_account
    transaction_params[:merchant_account_id] = CONFIG_MANAGER.current_merchant_account
  end

  log("Creating transaction #{transaction_params.inspect}")

  result = Braintree::Transaction.sale(transaction_params)

  if result.transaction.present?
    void_result = Braintree::Transaction.void(result.transaction.id)
  end

  if result.success? and void_result.present? and void_result.success?
    {:message => "created #{result.transaction.id} #{result.transaction.status}"}
  else
    {:message => result.message || void_result.message}
  end

rescue Exception => e
  {:message => e.message}
end

#server_config ⇒ Object

# File 'lib/taproot.rb', line 214

def server_config
  {
    :nonce_param_names => ["nonce", "payment_method_nonce", "paymentMethodNonce"]
  }
end

#vault(nonce, customer_id) ⇒ Object

# File 'lib/taproot.rb', line 260

def vault(nonce, customer_id)
  log("Vaulting payment method #{nonce} for customer #{customer_id}")

  result = Braintree::PaymentMethod.create({
    :customer_id => customer_id,
    :payment_method_nonce => nonce
  })

  if result.success?
    {:message => "Vaulted payment method #{result.payment_method.token}"}
  else
    {:message => result.message}
  end
end