braintree 2.31.0 → 2.32.1

data/lib/braintree/payment_method.rb

@@ -0,0 +1,17 @@
+module Braintree
+  class PaymentMethod
+    include BaseModule
+
+    def self.create(attributes)
+      Configuration.gateway.payment_method.create(attributes)
+    end
+
+    def self.find(token)
+      Configuration.gateway.payment_method.find(token)
+    end
+
+    def self.delete(token)
+      Configuration.gateway.payment_method.delete(token)
+    end
+  end
+end

data/lib/braintree/payment_method_gateway.rb

@@ -0,0 +1,58 @@
+module Braintree
+  class PaymentMethodGateway # :nodoc:
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+
+    def create(attributes)
+      Util.verify_keys(PaymentMethodGateway._create_signature, attributes)
+      _do_create("/payment_methods", :payment_method => attributes)
+    end
+
+    def _do_create(url, params=nil) # :nodoc:
+      response = @config.http.post url, params
+      if response[:credit_card]
+        SuccessfulResult.new(:payment_method => CreditCard._new(@gateway, response[:credit_card]))
+      elsif response[:paypal_account]
+        SuccessfulResult.new(:payment_method => PayPalAccount._new(@gateway, response[:paypal_account]))
+      elsif response[:sepa_bank_account]
+        SuccessfulResult.new(:payment_method => SEPABankAccount._new(@gateway, response[:sepa_bank_account]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :payment_method or :api_error_response"
+      end
+    end
+
+    def delete(token)
+      @config.http.delete("/payment_methods/any/#{token}")
+    end
+
+    def find(token)
+      raise ArgumentError if token.nil? || token.to_s.strip == ""
+      response = @config.http.get "/payment_methods/any/#{token}"
+      if response.has_key?(:credit_card)
+        CreditCard._new(@gateway, response[:credit_card])
+      elsif response.has_key?(:paypal_account)
+        PayPalAccount._new(@gateway, response[:paypal_account])
+      elsif response.has_key?(:sepa_bank_account)
+        SEPABankAccount._new(@gateway, response[:sepa_bank_account])
+      else
+        UnknownPaymentMethod.new(response)
+      end
+    rescue NotFoundError
+      raise NotFoundError, "payment method with token #{token.inspect} not found"
+    end
+
+    def self._create_signature # :nodoc:
+      options = [:make_default]
+      [
+        :customer_id,
+        :payment_method_nonce,
+        :token,
+        {:options => options}
+      ]
+    end
+  end
+end

data/lib/braintree/paypal_account.rb

@@ -0,0 +1,47 @@
+module Braintree
+  class PayPalAccount
+    include BaseModule
+
+    attr_reader :email, :token, :image_url, :created_at, :updated_at
+
+    def initialize(gateway, attributes) # :nodoc:
+      @gateway = gateway
+      set_instance_variables_from_hash(attributes)
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args)
+      self.new(*args)
+    end
+
+    def self.find(token)
+      Configuration.gateway.paypal_account.find(token)
+    end
+
+    def self.update(token, attributes)
+      Configuration.gateway.paypal_account.update(token, attributes)
+    end
+
+    def self.delete(token)
+      Configuration.gateway.paypal_account.delete(token)
+    end
+
+    # See http://www.braintreepayments.com/docs/ruby/transactions/create_from_vault
+    def self.sale(token, transaction_attributes)
+      Configuration.gateway.transaction.sale(transaction_attributes.merge(:payment_method_token => token))
+    end
+
+    # See http://www.braintreepayments.com/docs/ruby/transactions/create_from_vault
+    def self.sale!(token, transaction_attributes)
+      return_object_or_raise(:transaction) { sale(token, transaction_attributes) }
+    end
+
+    # Returns true if this paypal account is the customer's default payment method.
+    def default?
+      @default
+    end
+  end
+end

data/lib/braintree/paypal_account_gateway.rb

@@ -0,0 +1,41 @@
+module Braintree
+  class PayPalAccountGateway
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+
+    def find(token)
+      raise ArgumentError if token.nil? || token.to_s.strip == ""
+      response = @config.http.get "/payment_methods/paypal_account/#{token}"
+      PayPalAccount._new(@gateway, response[:paypal_account])
+    rescue NotFoundError
+      raise NotFoundError, "payment method with token #{token.inspect} not found"
+    end
+
+    def update(token, attributes)
+      Util.verify_keys(PayPalAccountGateway._update_signature, attributes)
+      _do_update(:put, "/payment_methods/paypal_account/#{token}", :paypal_account => attributes)
+    end
+
+    def delete(token)
+      @config.http.delete("/payment_methods/paypal_account/#{token}")
+    end
+
+    def _do_update(http_verb, url, params) # :nodoc:
+      response = @config.http.send http_verb, url, params
+      if response[:paypal_account]
+        SuccessfulResult.new(:paypal_account => PayPalAccount._new(@gateway, response[:paypal_account]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :paypal_account or :api_error_response"
+      end
+    end
+
+    def self._update_signature # :nodoc:
+      options = [:make_default]
+      [:token, {:options => options}]
+    end
+  end
+end

data/lib/braintree/sepa_bank_account.rb

@@ -0,0 +1,34 @@
+module Braintree
+  class SEPABankAccount
+    include BaseModule
+
+    module MandateType
+      Business = 'business'
+      Consumer = 'consumer'
+    end
+
+    attr_reader :token, :image_url
+
+    def initialize(gateway, attributes) # :nodoc:
+      @gateway = gateway
+      set_instance_variables_from_hash(attributes)
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args)
+      self.new(*args)
+    end
+
+    def self.find(token)
+      Configuration.gateway.sepa_bank_account.find(token)
+    end
+
+    def default?
+      @default
+    end
+
+  end
+end

data/lib/braintree/sepa_bank_account_gateway.rb

@@ -0,0 +1,16 @@
+module Braintree
+  class SEPABankAccountGateway
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+
+    def find(token)
+      raise ArgumentError if token.nil? || token.to_s.strip == ""
+      response = @config.http.get "/payment_methods/sepa_bank_account/#{token}"
+      SEPABankAccount._new(@gateway, response[:sepa_bank_account])
+    rescue NotFoundError
+      raise NotFoundError, "payment method with token #{token.inspect} not found"
+    end
+  end
+end

data/lib/braintree/successful_result.rb

@@ -3,7 +3,7 @@ module Braintree
   class SuccessfulResult
     include BaseModule
 
-    attr_reader :address, :credit_card, :customer, :merchant_account, :settlement_batch_summary, :subscription, :new_transaction, :transaction
+    attr_reader :address, :credit_card, :customer, :merchant_account, :payment_method, :settlement_batch_summary, :subscription, :new_transaction, :transaction
 
     def initialize(attributes = {}) # :nodoc:
       @attrs = attributes.keys

data/lib/braintree/test/nonce.rb

@@ -0,0 +1,10 @@
+module Braintree
+  module Test
+    module Nonce
+      Transactable = "fake-valid-nonce"
+      Consumed = "fake-consumed-nonce"
+      PayPalOneTimePayment = "fake-paypal-one-time-nonce"
+      PayPalFuturePayment = "fake-paypal-future-nonce"
+    end
+  end
+end

data/lib/braintree/test_transaction.rb

@@ -0,0 +1,15 @@
+module Braintree
+  class TestTransaction < Transaction
+    def self.settle(transaction_id)
+      Configuration.gateway.testing.settle(transaction_id)
+    end
+
+    def self.settlement_confirm(transaction_id)
+      Configuration.gateway.testing.settlement_confirm(transaction_id)
+    end
+
+    def self.settlement_decline(transaction_id)
+      Configuration.gateway.testing.settlement_decline(transaction_id)
+    end
+  end
+end

data/lib/braintree/testing_gateway.rb

@@ -0,0 +1,35 @@
+module Braintree
+  class TestingGateway # :nodoc:
+
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+      @transaction_gateway = TransactionGateway.new(gateway)
+    end
+
+    def settle(transaction_id)
+      check_environment
+
+      response = @config.http.put "/transactions/#{transaction_id}/settle"
+      @transaction_gateway._handle_transaction_response(response)
+    end
+
+    def settlement_confirm(transaction_id)
+      check_environment
+
+      response = @config.http.put "/transactions/#{transaction_id}/settlement_confirm"
+      @transaction_gateway._handle_transaction_response(response)
+    end
+
+    def settlement_decline(transaction_id)
+      check_environment
+
+      response = @config.http.put "/transactions/#{transaction_id}/settlement_decline"
+      @transaction_gateway._handle_transaction_response(response)
+    end
+
+    def check_environment
+      raise TestOperationPerformedInProduction if Braintree::Configuration.environment == :production
+    end
+  end
+end

data/lib/braintree/transaction.rb

@@ -35,6 +35,8 @@ module Braintree
       Failed                 = 'failed'
       ProcessorDeclined      = 'processor_declined'
       Settled                = 'settled'
+      SettlementConfirmed    = 'settlement_confirmed'
+      SettlementDeclined     = 'settlement_declined'
       Settling               = 'settling'
       SubmittedForSettlement = 'submitted_for_settlement'
       Voided                 = 'voided'
@@ -77,6 +79,7 @@ module Braintree
     attr_reader :order_id
     attr_reader :channel
     attr_reader :billing_details, :shipping_details
+    attr_reader :paypal_details
     attr_reader :plan_id
     # The authorization code from the processor.
     attr_reader :processor_authorization_code
@@ -99,6 +102,7 @@ module Braintree
     attr_reader :type
     attr_reader :updated_at
     attr_reader :add_ons, :discounts
+    attr_reader :payment_instrument_type
 
     # See http://www.braintreepayments.com/docs/ruby/transactions/create
     def self.create(attributes)
@@ -230,10 +234,12 @@ module Braintree
       @status_history = attributes[:status_history] ? attributes[:status_history].map { |s| StatusDetails.new(s) } : []
       @tax_amount = Util.to_big_decimal(tax_amount)
       @descriptor = Descriptor.new(@descriptor)
+      @paypal_details = PayPalDetails.new(@paypal)
       disputes.map! { |attrs| Dispute._new(attrs) } if disputes
       @custom_fields = attributes[:custom_fields].is_a?(Hash) ? attributes[:custom_fields] : {}
       add_ons.map! { |attrs| AddOn._new(attrs) } if add_ons
       discounts.map! { |attrs| Discount._new(attrs) } if discounts
+      @payment_instrument_type = attributes[:payment_instrument_type]
     end
 
     # True if <tt>other</tt> is a Braintree::Transaction with the same id.

data/lib/braintree/transaction/paypal_details.rb

@@ -0,0 +1,14 @@
+module Braintree
+  class Transaction
+    class PayPalDetails
+      include BaseModule
+
+      attr_reader :payer_email, :payment_id, :authorization_id, :token,
+        :image_url
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+    end
+  end
+end

data/lib/braintree/transaction_gateway.rb

@@ -108,6 +108,7 @@ module Braintree
       _handle_transaction_response(response)
     end
 
+
     def self._clone_signature # :nodoc:
       [:amount, :channel, {:options => [:submit_for_settlement]}]
     end
@@ -117,7 +118,7 @@ module Braintree
         :amount, :customer_id, :merchant_account_id, :order_id, :channel, :payment_method_token,
         :purchase_order_number, :recurring, :shipping_address_id, :type, :tax_amount, :tax_exempt,
         :venmo_sdk_payment_method_code, :device_session_id, :service_fee_amount, :device_data, :fraud_merchant_id,
-        :billing_address_id, :payment_method_nonce,
+        :billing_address_id, :payment_method_nonce, :three_d_secure_token,
         {:credit_card => [:token, :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number]},
         {:customer => [:id, :company, :email, :fax, :first_name, :last_name, :phone, :website]},
         {
@@ -129,6 +130,7 @@ module Braintree
         {:options => [:hold_in_escrow, :store_in_vault, :store_in_vault_on_success, :submit_for_settlement, :add_billing_address_to_payment_method, :store_shipping_address_in_vault, :venmo_sdk_session]},
         {:custom_fields => :_any_key_},
         {:descriptor => [:name, :phone]},
+        {:paypal_account => [:email, :token, :paypal_data]},
         {:industry => [:industry_type, {:data => [:folio_number, :check_in_date, :check_out_date]}]}
       ]
     end

data/lib/braintree/transaction_search.rb

@@ -23,7 +23,11 @@ module Braintree
       :id,
       :order_id,
       :payment_method_token,
+      :paypal_payment_id,
+      :paypal_authorization_id,
+      :paypal_payer_email,
       :processor_authorization_code,
+      :sepa_bank_account_iban,
       :settlement_batch_id,
       :shipping_company,
       :shipping_country_name,

data/lib/braintree/unknown_payment_method.rb

@@ -0,0 +1,20 @@
+module Braintree
+  class UnknownPaymentMethod
+    include BaseModule
+
+    attr_reader :token
+
+    def initialize(attributes)
+      nested_attributes = attributes[attributes.keys.first]
+      set_instance_variables_from_hash(nested_attributes)
+    end
+
+    def default?
+      @default
+    end
+
+    def image_url
+      "https://assets.braintreegateway.com/payment_method_logo/unknown.png"
+    end
+  end
+end

data/lib/braintree/version.rb

@@ -1,8 +1,8 @@
 module Braintree
   module Version
     Major = 2
-    Minor = 31
-    Tiny = 0
+    Minor = 32
+    Tiny = 1
 
     String = "#{Major}.#{Minor}.#{Tiny}"
   end

data/lib/braintree/webhook_testing_gateway.rb

@@ -7,7 +7,7 @@ module Braintree
 
     def sample_notification(kind, id)
       payload = Base64.encode64(_sample_xml(kind, id))
-      signature_string = "#{Braintree::Configuration.public_key}|#{Braintree::Digest.hexdigest(Braintree::Configuration.private_key, payload)}"
+      signature_string = "#{@config.public_key}|#{Braintree::Digest.hexdigest(@config.private_key, payload)}"
 
       return signature_string, payload
     end

data/spec/integration/braintree/client_api/client_token_spec.rb

@@ -1,20 +1,21 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
 
-describe Braintree::ClientToken do
 
+describe Braintree::ClientToken do
   describe "self.generate" do
     it "generates a fingerprint that the gateway accepts" do
       config = Braintree::Configuration.instantiate
-      client_token = Braintree::ClientToken.generate
+      raw_client_token = Braintree::ClientToken.generate
+      client_token = decode_client_token(raw_client_token)
       http = ClientApiHttp.new(
         config,
-        :authorization_fingerprint => JSON.parse(client_token)["authorizationFingerprint"],
+        :authorization_fingerprint => client_token["authorizationFingerprint"],
         :shared_customer_identifier => "fake_identifier",
         :shared_customer_identifier_type => "testing"
       )
 
-      response = http.get_cards
+      response = http.get_payment_methods
 
       response.code.should == "200"
     end
@@ -25,24 +26,41 @@ describe Braintree::ClientToken do
       end.to raise_error(ArgumentError)
     end
 
+    describe "version" do
+      it "allows a client token version to be specified" do
+        config = Braintree::Configuration.instantiate
+        client_token_string = Braintree::ClientToken.generate(:version => 1)
+        client_token = JSON.parse(client_token_string)
+        client_token["version"].should == 1
+      end
+
+      it "defaults to 2" do
+        config = Braintree::Configuration.instantiate
+        client_token_string = Braintree::ClientToken.generate
+        client_token = decode_client_token(client_token_string)
+        client_token["version"].should == "2"
+      end
+    end
+
     it "can pass verify_card" do
       config = Braintree::Configuration.instantiate
       result = Braintree::Customer.create
-      client_token = Braintree::ClientToken.generate(
+      raw_client_token = Braintree::ClientToken.generate(
         :customer_id => result.customer.id,
         :options => {
           :verify_card => true
         }
       )
+      client_token = decode_client_token(raw_client_token)
 
       http = ClientApiHttp.new(
         config,
-        :authorization_fingerprint => JSON.parse(client_token)["authorizationFingerprint"],
+        :authorization_fingerprint => client_token["authorizationFingerprint"],
         :shared_customer_identifier => "fake_identifier",
         :shared_customer_identifier_type => "testing"
       )
 
-      response = http.add_card(
+      response = http.add_payment_method(
         :credit_card => {
           :number => "4000111111111115",
           :expiration_month => "11",
@@ -57,21 +75,22 @@ describe Braintree::ClientToken do
       config = Braintree::Configuration.instantiate
       result = Braintree::Customer.create
       customer_id = result.customer.id
-      client_token = Braintree::ClientToken.generate(
+      raw_client_token = Braintree::ClientToken.generate(
         :customer_id => customer_id,
         :options => {
           :make_default => true
         }
       )
+      client_token = decode_client_token(raw_client_token)
 
       http = ClientApiHttp.new(
         config,
-        :authorization_fingerprint => JSON.parse(client_token)["authorizationFingerprint"],
+        :authorization_fingerprint => client_token["authorizationFingerprint"],
         :shared_customer_identifier => "fake_identifier",
         :shared_customer_identifier_type => "testing"
       )
 
-      response = http.add_card(
+      response = http.add_payment_method(
         :credit_card => {
           :number => "4111111111111111",
           :expiration_month => "11",
@@ -81,7 +100,7 @@ describe Braintree::ClientToken do
 
       response.code.should == "201"
 
-      response = http.add_card(
+      response = http.add_payment_method(
         :credit_card => {
           :number => "4005519200000004",
           :expiration_month => "11",
@@ -99,18 +118,19 @@ describe Braintree::ClientToken do
       config = Braintree::Configuration.instantiate
       result = Braintree::Customer.create
       customer_id = result.customer.id
-      client_token = Braintree::ClientToken.generate(
+      raw_client_token = Braintree::ClientToken.generate(
         :customer_id => customer_id
       )
+      client_token = decode_client_token(raw_client_token)
 
       http = ClientApiHttp.new(
         config,
-        :authorization_fingerprint => JSON.parse(client_token)["authorizationFingerprint"],
+        :authorization_fingerprint => client_token["authorizationFingerprint"],
         :shared_customer_identifier => "fake_identifier",
         :shared_customer_identifier_type => "testing"
       )
 
-      response = http.add_card(
+      response = http.add_payment_method(
         :credit_card => {
           :number => "4111111111111111",
           :expiration_month => "11",
@@ -120,16 +140,17 @@ describe Braintree::ClientToken do
 
       response.code.should == "201"
 
-      client_token = Braintree::ClientToken.generate(
+      second_raw_client_token = Braintree::ClientToken.generate(
         :customer_id => customer_id,
         :options => {
           :fail_on_duplicate_payment_method => true
         }
       )
+      second_client_token = decode_client_token(second_raw_client_token)
 
-      http.fingerprint = JSON.parse(client_token)["authorizationFingerprint"]
+      http.fingerprint = second_client_token["authorizationFingerprint"]
 
-      response = http.add_card(
+      response = http.add_payment_method(
         :credit_card => {
           :number => "4111111111111111",
           :expiration_month => "11",
@@ -139,5 +160,47 @@ describe Braintree::ClientToken do
 
       response.code.should == "422"
     end
+
+    it "can pass merchant_account_id" do
+      raw_client_token = Braintree::ClientToken.generate(
+        :merchant_account_id => "my_merchant_account"
+      )
+      client_token = decode_client_token(raw_client_token)
+
+      client_token["merchantAccountId"].should == "my_merchant_account"
+    end
+
+    context "paypal" do
+      it "includes the paypal options for a paypal merchant" do
+        with_altpay_merchant do
+          raw_client_token = Braintree::ClientToken.generate
+          client_token = decode_client_token(raw_client_token)
+
+          client_token["paypal"]["displayName"].should == "merchant who has paypal and sepa enabled"
+          client_token["paypal"]["clientId"].should match(/.+/)
+          client_token["paypal"]["privacyUrl"].should match("http://www.example.com/privacy_policy")
+          client_token["paypal"]["userAgreementUrl"].should match("http://www.example.com/user_agreement")
+          client_token["paypal"]["baseUrl"].should_not be_nil
+        end
+      end
+    end
+
+    context "SEPA" do
+      it "includes the SEPA options for a SEPA merchant" do
+        with_altpay_merchant do
+          result = Braintree::Customer.create
+          customer_id = result.customer.id
+
+          raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => customer_id,
+            :sepa_mandate_acceptance_location => "Hamburg, Germany",
+            :sepa_mandate_type => Braintree::SEPABankAccount::MandateType::Business
+          )
+          client_token = decode_client_token(raw_client_token)
+
+          client_token["authorizationFingerprint"].should include("sepa_mandate_type=business")
+        end
+      end
+    end
   end
 end