braintree 2.4.0 → 2.5.1

data/lib/braintree/transaction/credit_card_details.rb

@@ -10,6 +10,10 @@ module Braintree
         set_instance_variables_from_hash attributes unless attributes.nil?
       end
 
+      def expiration_date
+        "#{expiration_month}/#{expiration_year}"
+      end
+
       def inspect
         attr_order = [:token, :bin, :last_4, :card_type, :expiration_date, :cardholder_name, :customer_location]
         formatted_attrs = attr_order.map do |attr|
@@ -18,10 +22,6 @@ module Braintree
         "#<#{formatted_attrs.join(", ")}>"
       end
 
-      def expiration_date
-        "#{expiration_month}/#{expiration_year}"
-      end
-
       def masked_number
         "#{bin}******#{last_4}"
       end

data/lib/braintree/transaction_gateway.rb

@@ -0,0 +1,124 @@
+module Braintree
+  class TransactionGateway # :nodoc:
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+
+    def create(attributes)
+      Util.verify_keys(TransactionGateway._create_signature, attributes)
+      _do_create "/transactions", :transaction => attributes
+    end
+
+    # Deprecated
+    def create_from_transparent_redirect(query_string)
+      params = @gateway.transparent_redirect.parse_and_validate_query_string query_string
+      _do_create("/transactions/all/confirm_transparent_redirect_request", :id => params[:id])
+    end
+
+    def create_transaction_url
+      warn "[DEPRECATED] Transaction.create_transaction_url is deprecated. Please use TransparentRedirect.url"
+      "#{@config.base_merchant_url}/transactions/all/create_via_transparent_redirect_request"
+    end
+
+    def credit(attributes)
+      create(attributes.merge(:type => 'credit'))
+    end
+
+    def find(id)
+      response = @config.http.get "/transactions/#{id}"
+      Transaction._new(@gateway, response[:transaction])
+    rescue NotFoundError
+      raise NotFoundError, "transaction with id #{id.inspect} not found"
+    end
+
+    def refund(transaction_id, amount = nil)
+      response = @config.http.post "/transactions/#{transaction_id}/refund", :transaction => {:amount => amount}
+      if response[:transaction]
+        SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :transaction or :api_error_response"
+      end
+    end
+
+    def retry_subscription_charge(subscription_id, amount=nil)
+      attributes = {
+        :amount => amount,
+        :subscription_id => subscription_id,
+        :type => Transaction::Type::Sale
+      }
+      _do_create "/transactions", :transaction => attributes
+    end
+
+    def sale(attributes)
+      create(attributes.merge(:type => 'sale'))
+    end
+
+    def search(&block)
+      search = TransactionSearch.new
+      block.call(search) if block
+
+      response = @config.http.post "/transactions/advanced_search_ids", {:search => search.to_hash}
+      ResourceCollection.new(response) { |ids| _fetch_transactions(search, ids) }
+    end
+
+    def submit_for_settlement(transaction_id, amount = nil)
+      raise ArgumentError, "transaction_id is invalid" unless transaction_id =~ /\A[0-9a-z]+\z/
+      response = @config.http.put "/transactions/#{transaction_id}/submit_for_settlement", :transaction => {:amount => amount}
+      if response[:transaction]
+        SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :transaction or :response"
+      end
+    end
+
+    def void(transaction_id)
+      response = @config.http.put "/transactions/#{transaction_id}/void"
+      if response[:transaction]
+        SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :transaction or :api_error_response"
+      end
+    end
+
+    def self._create_signature # :nodoc:
+      [
+        :amount, :customer_id, :merchant_account_id, :order_id, :payment_method_token, :type,
+        {:credit_card => [:token, :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number]},
+        {:customer => [:id, :company, :email, :fax, :first_name, :last_name, :phone, :website]},
+        {
+          :billing => AddressGateway._shared_signature
+        },
+        {
+          :shipping => AddressGateway._shared_signature
+        },
+        {:options => [:store_in_vault, :submit_for_settlement, :add_billing_address_to_payment_method, :store_shipping_address_in_vault]},
+        {:custom_fields => :_any_key_}
+      ]
+    end
+
+    def _do_create(url, params=nil) # :nodoc:
+      response = @config.http.post url, params
+      if response[:transaction]
+        SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :transaction or :api_error_response"
+      end
+    end
+
+    def _fetch_transactions(search, ids) # :nodoc:
+      search.ids.in ids
+      response = @config.http.post "/transactions/advanced_search", {:search => search.to_hash}
+      attributes = response[:credit_card_transactions]
+      Util.extract_attribute_as_array(attributes, :transaction).map { |attrs| Transaction._new(@gateway, attrs) }
+    end
+  end
+end

data/lib/braintree/transaction_search.rb

@@ -1,6 +1,6 @@
 module Braintree
-  class TransactionSearch < AdvancedSearch
-    search_fields(
+  class TransactionSearch < AdvancedSearch # :nodoc:
+    text_fields(
       :billing_company,
       :billing_country_name,
       :billing_extended_address,
@@ -24,6 +24,7 @@ module Braintree
       :order_id,
       :payment_method_token,
       :processor_authorization_code,
+      :settlement_batch_id,
       :shipping_company,
       :shipping_country_name,
       :shipping_extended_address,
@@ -59,6 +60,7 @@ module Braintree
 
     key_value_fields :refund
 
-    range_fields :amount, :created_at
+    range_fields :amount, :created_at, :authorized_at, :failed_at, :gateway_rejected_at, :processor_declined_at,
+                 :settled_at, :submitted_for_settlement_at, :voided_at
   end
 end

data/lib/braintree/transparent_redirect.rb

@@ -1,32 +1,12 @@
 module Braintree
-  # The TransparentRedirect module provides methods to build the tr_data param
-  # that must be submitted when using the transparent redirect API. For more information
-  # about transparent redirect, see (TODO).
-  #
-  # You must provide a redirect_url that the gateway will redirect the user to when the
-  # action is complete.
-  #
-  #   tr_data = Braintree::TransparentRedirect.create_customer_data(
-  #     :redirect_url => "http://example.com/redirect_back_to_merchant_site
-  #   )
-  #
-  # In addition to the redirect_url, any data that needs to be protected from user tampering
-  # should be included in the tr_data. For example, to prevent the user from tampering with the transaction
-  # amount, include the amount in the tr_data.
-  #
-  #   tr_data = Braintree::TransparentRedirect.transaction_data(
-  #     :redirect_url => "http://example.com/complete_transaction",
-  #     :transaction => {:amount => "100.00"}
-  #   )
+  # See:
+  # * http://www.braintreepaymentsolutions.com/docs/ruby/transactions/create_tr
+  # * http://www.braintreepaymentsolutions.com/docs/ruby/customers/create_tr
+  # * http://www.braintreepaymentsolutions.com/docs/ruby/customers/update_tr
+  # * http://www.braintreepaymentsolutions.com/docs/ruby/credit_cards/create_tr
+  # * http://www.braintreepaymentsolutions.com/docs/ruby/credit_cards/update_tr
   module TransparentRedirect
-    TransparentRedirectKeys = [:redirect_url] # :nodoc:
-    CreateCustomerSignature = TransparentRedirectKeys + [{:customer => Customer._create_signature}] # :nodoc:
-    UpdateCustomerSignature = TransparentRedirectKeys + [:customer_id, {:customer => Customer._update_signature}] # :nodoc:
-    TransactionSignature = TransparentRedirectKeys + [{:transaction => Transaction._create_signature}] # :nodoc:
-    CreateCreditCardSignature = TransparentRedirectKeys + [{:credit_card => CreditCard._create_signature}] # :nodoc:
-    UpdateCreditCardSignature = TransparentRedirectKeys + [:payment_method_token, {:credit_card => CreditCard._update_signature}] # :nodoc:
-
-    module Kind
+    module Kind # :nodoc:
       CreateCustomer = "create_customer"
       UpdateCustomer = "update_customer"
       CreatePaymentMethod = "create_payment_method"
@@ -35,110 +15,37 @@ module Braintree
     end
 
     def self.confirm(query_string)
-      params = TransparentRedirect.parse_and_validate_query_string query_string
-      confirmation_klass = {
-        Kind::CreateCustomer => Braintree::Customer,
-        Kind::UpdateCustomer => Braintree::Customer,
-        Kind::CreatePaymentMethod => Braintree::CreditCard,
-        Kind::UpdatePaymentMethod => Braintree::CreditCard,
-        Kind::CreateTransaction => Braintree::Transaction
-      }[params[:kind]]
-
-      confirmation_klass._do_create("/transparent_redirect_requests/#{params[:id]}/confirm")
+      Configuration.gateway.transparent_redirect.confirm(query_string)
     end
 
-    # Returns the tr_data string for creating a credit card.
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/credit_cards/create_tr
     def self.create_credit_card_data(params)
-      Util.verify_keys(CreateCreditCardSignature, params)
-      params[:kind] = Kind::CreatePaymentMethod
-      _data(params)
+      Configuration.gateway.transparent_redirect.create_credit_card_data(params)
     end
 
-    # Returns the tr_data string for creating a customer.
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/customers/create_tr
     def self.create_customer_data(params)
-      Util.verify_keys(CreateCustomerSignature, params)
-      params[:kind] = Kind::CreateCustomer
-      _data(params)
-    end
-
-    def self.parse_and_validate_query_string(query_string) # :nodoc:
-      params = Util.symbolize_keys(Util.parse_query_string(query_string))
-      query_string_without_hash = query_string[/(.*)&hash=.*/, 1]
-
-      if params[:http_status] == nil
-        raise UnexpectedError, "expected query string to have an http_status param"
-      elsif params[:http_status] != '200'
-        Util.raise_exception_for_status_code(params[:http_status], params[:bt_message])
-      end
-
-      if _hash(query_string_without_hash) == params[:hash]
-        params
-      else
-        raise ForgedQueryString
-      end
+      Configuration.gateway.transparent_redirect.create_customer_data(params)
     end
 
-    # Returns the tr_data string for creating a transaction.
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/transactions/create_tr
     def self.transaction_data(params)
-      Util.verify_keys(TransactionSignature, params)
-      params[:kind] = Kind::CreateTransaction
-      transaction_type = params[:transaction] && params[:transaction][:type]
-      unless %w[sale credit].include?(transaction_type)
-        raise ArgumentError, "expected transaction[type] of sale or credit, was: #{transaction_type.inspect}"
-      end
-      _data(params)
+      Configuration.gateway.transparent_redirect.transaction_data(params)
     end
 
-    # Returns the tr_data string for updating a credit card.
-    # The payment_method_token of the credit card to update is required.
-    #
-    #   tr_data = Braintree::TransparentRedirect.update_credit_card_data(
-    #     :redirect_url => "http://example.com/redirect_here",
-    #     :payment_method_token => "token123"
-    #   )
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/credit_cards/update_tr
     def self.update_credit_card_data(params)
-      Util.verify_keys(UpdateCreditCardSignature, params)
-      unless params[:payment_method_token]
-        raise ArgumentError, "expected params to contain :payment_method_token of payment method to update"
-      end
-      params[:kind] = Kind::UpdatePaymentMethod
-      _data(params)
+      Configuration.gateway.transparent_redirect.update_credit_card_data(params)
     end
 
-    # Returns the tr_data string for updating a customer.
-    # The customer_id of the customer to update is required.
-    #
-    #   tr_data = Braintree::TransparentRedirect.update_customer_data(
-    #     :redirect_url => "http://example.com/redirect_here",
-    #     :customer_id => "customer123"
-    #   )
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/customers/update_tr
     def self.update_customer_data(params)
-      Util.verify_keys(UpdateCustomerSignature, params)
-      unless params[:customer_id]
-        raise ArgumentError, "expected params to contain :customer_id of customer to update"
-      end
-      params[:kind] = Kind::UpdateCustomer
-      _data(params)
+      Configuration.gateway.transparent_redirect.update_customer_data(params)
     end
 
     # Returns the URL to which Transparent Redirect Requests should be posted
     def self.url
-      "#{Braintree::Configuration.base_merchant_url}/transparent_redirect_requests"
-    end
-
-    def self._data(params) # :nodoc:
-      raise ArgumentError, "expected params to contain :redirect_url" unless params[:redirect_url]
-      tr_data_segment = Util.hash_to_query_string(params.merge(
-        :api_version => Configuration::API_VERSION,
-        :time => Time.now.utc.strftime("%Y%m%d%H%M%S"),
-        :public_key => Configuration.public_key
-      ))
-      tr_data_hash = _hash(tr_data_segment)
-      "#{tr_data_hash}|#{tr_data_segment}"
-    end
-
-    def self._hash(string) # :nodoc:
-      ::Braintree::Digest.hexdigest(string)
+      Configuration.gateway.transparent_redirect.url
     end
   end
 end

data/lib/braintree/transparent_redirect_gateway.rb

@@ -0,0 +1,105 @@
+module Braintree
+  class TransparentRedirectGateway # :nodoc
+    TransparentRedirectKeys = [:redirect_url] # :nodoc:
+    CreateCustomerSignature = TransparentRedirectKeys + [{:customer => CustomerGateway._create_signature}] # :nodoc:
+    UpdateCustomerSignature = TransparentRedirectKeys + [:customer_id, {:customer => CustomerGateway._update_signature}] # :nodoc:
+    TransactionSignature = TransparentRedirectKeys + [{:transaction => TransactionGateway._create_signature}] # :nodoc:
+    CreateCreditCardSignature = TransparentRedirectKeys + [{:credit_card => CreditCardGateway._create_signature}] # :nodoc:
+    UpdateCreditCardSignature = TransparentRedirectKeys + [:payment_method_token, {:credit_card => CreditCardGateway._update_signature}] # :nodoc:
+
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+
+    def confirm(query_string)
+      params = @gateway.transparent_redirect.parse_and_validate_query_string query_string
+      confirmation_gateway = {
+        TransparentRedirect::Kind::CreateCustomer => :customer,
+        TransparentRedirect::Kind::UpdateCustomer => :customer,
+        TransparentRedirect::Kind::CreatePaymentMethod => :credit_card,
+        TransparentRedirect::Kind::UpdatePaymentMethod => :credit_card,
+        TransparentRedirect::Kind::CreateTransaction => :transaction
+      }[params[:kind]]
+
+      @gateway.send(confirmation_gateway)._do_create("/transparent_redirect_requests/#{params[:id]}/confirm")
+    end
+
+    def create_credit_card_data(params)
+      Util.verify_keys(CreateCreditCardSignature, params)
+      params[:kind] = TransparentRedirect::Kind::CreatePaymentMethod
+      _data(params)
+    end
+
+    def create_customer_data(params)
+      Util.verify_keys(CreateCustomerSignature, params)
+      params[:kind] = TransparentRedirect::Kind::CreateCustomer
+      _data(params)
+    end
+
+    def parse_and_validate_query_string(query_string) # :nodoc:
+      params = Util.symbolize_keys(Util.parse_query_string(query_string))
+      query_string_without_hash = query_string[/(.*)&hash=.*/, 1]
+
+      if params[:http_status] == nil
+        raise UnexpectedError, "expected query string to have an http_status param"
+      elsif params[:http_status] != '200'
+        Util.raise_exception_for_status_code(params[:http_status], params[:bt_message])
+      end
+
+      if _hash(query_string_without_hash) == params[:hash]
+        params
+      else
+        raise ForgedQueryString
+      end
+    end
+
+    def transaction_data(params)
+      Util.verify_keys(TransactionSignature, params)
+      params[:kind] = TransparentRedirect::Kind::CreateTransaction
+      transaction_type = params[:transaction] && params[:transaction][:type]
+      unless %w[sale credit].include?(transaction_type)
+        raise ArgumentError, "expected transaction[type] of sale or credit, was: #{transaction_type.inspect}"
+      end
+      _data(params)
+    end
+
+    def update_credit_card_data(params)
+      Util.verify_keys(UpdateCreditCardSignature, params)
+      unless params[:payment_method_token]
+        raise ArgumentError, "expected params to contain :payment_method_token of payment method to update"
+      end
+      params[:kind] = TransparentRedirect::Kind::UpdatePaymentMethod
+      _data(params)
+    end
+
+    def update_customer_data(params)
+      Util.verify_keys(UpdateCustomerSignature, params)
+      unless params[:customer_id]
+        raise ArgumentError, "expected params to contain :customer_id of customer to update"
+      end
+      params[:kind] = TransparentRedirect::Kind::UpdateCustomer
+      _data(params)
+    end
+
+    def url
+      "#{@config.base_merchant_url}/transparent_redirect_requests"
+    end
+
+    def _data(params) # :nodoc:
+      raise ArgumentError, "expected params to contain :redirect_url" unless params[:redirect_url]
+      tr_data_segment = Util.hash_to_query_string(params.merge(
+        :api_version => @config.api_version,
+        :time => Time.now.utc.strftime("%Y%m%d%H%M%S"),
+        :public_key => @config.public_key
+      ))
+      tr_data_hash = _hash(tr_data_segment)
+      "#{tr_data_hash}|#{tr_data_segment}"
+    end
+
+    def _hash(string) # :nodoc:
+      ::Braintree::Digest.hexdigest(@config.private_key, string)
+    end
+  end
+end
+

data/lib/braintree/util.rb

@@ -104,6 +104,10 @@ module Braintree
         full_key = (namespace ? "#{namespace}[#{key}]" : key.to_s)
         if value.is_a?(Hash)
           result += _flatten_hash_keys(value, full_key)
+        elsif value.is_a?(Array)
+          value.each do |item|
+            result += _flatten_hash_keys(item, full_key)
+          end
         else
           result << full_key
         end