braintree 2.0.0 → 2.1.0

data/README.rdoc

@@ -13,9 +13,9 @@ The Braintree gem provides integration access to the Braintree Gateway.
   require "braintree"
 
   Braintree::Configuration.environment = :sandbox
-  Braintree::Configuration.merchant_id = "the_merchant_id"
-  Braintree::Configuration.public_key = "a_public_key"
-  Braintree::Configuration.private_key = "a_private_key"
+  Braintree::Configuration.merchant_id = "your_merchant_id"
+  Braintree::Configuration.public_key = "your_public_key"
+  Braintree::Configuration.private_key = "your_private_key"
 
   result = Braintree::Transaction.sale(
     :amount => "1000.00",

data/lib/braintree.rb

@@ -41,6 +41,7 @@ require "braintree/successful_result.rb"
 require "braintree/test/credit_card_numbers.rb"
 require "braintree/test/transaction_amounts.rb"
 require "braintree/transaction.rb"
+require "braintree/transaction_search.rb"
 require "braintree/transaction/address_details.rb"
 require "braintree/transaction/credit_card_details.rb"
 require "braintree/transaction/customer_details.rb"

data/lib/braintree/advanced_search.rb

@@ -14,8 +14,22 @@ module Braintree
       end
     end
 
-    class TextNode < SearchNode
-      operators :is, :is_not, :ends_with, :starts_with, :contains
+    class EqualityNode < SearchNode
+      operators :is, :is_not
+    end
+
+    class PartialMatchNode < EqualityNode
+      operators :ends_with, :starts_with
+    end
+
+    class TextNode < PartialMatchNode
+      operators :contains
+    end
+
+    class KeyValueNode < SearchNode
+      def is(value)
+        @parent.add_criteria(@node_name, value)
+      end
     end
 
     class MultipleValueNode < SearchNode
@@ -30,6 +44,10 @@ module Braintree
         @parent.add_criteria(@node_name, values)
       end
 
+      def is(value)
+        self.in(value)
+      end
+
       def initialize(name, parent, options)
         super(name, parent)
         @options = options
@@ -40,26 +58,70 @@ module Braintree
       end
     end
 
-    def self.search_fields(*fields)
-      fields.each do |field|
-        define_method(field) do
-          TextNode.new(field, self)
-        end
+    class RangeNode < SearchNode
+      def between(min, max)
+        self >= min
+        self <= max
+      end
+
+      def >=(min)
+        @parent.add_criteria(@node_name, :min => min)
+      end
+
+      def <=(max)
+        @parent.add_criteria(@node_name, :max => max)
       end
     end
 
+    def self.search_fields(*fields)
+      _create_field_accessors(fields, TextNode)
+    end
+
+    def self.equality_fields(*fields)
+      _create_field_accessors(fields, EqualityNode)
+    end
+
+    def self.partial_match_fields(*fields)
+      _create_field_accessors(fields, PartialMatchNode)
+    end
+
     def self.multiple_value_field(field, options={})
       define_method(field) do
         MultipleValueNode.new(field, self, options)
       end
     end
 
+    def self.key_value_fields(*fields)
+      _create_field_accessors(fields, KeyValueNode)
+    end
+
+    def self.range_fields(*fields)
+      _create_field_accessors(fields, RangeNode)
+    end
+
+    def self.date_range_fields(*fields)
+      _create_field_accessors(fields, DateRangeNode)
+    end
+
+    def self._create_field_accessors(fields, node_class)
+      fields.each do |field|
+        define_method(field) do |*args|
+          raise "An operator is required" unless args.empty?
+          node_class.new(field, self)
+        end
+      end
+    end
+
     def initialize
       @criteria = {}
     end
 
     def add_criteria(key, value)
-      @criteria[key] = value
+      if @criteria[key].is_a?(Hash)
+        @criteria[key].merge!(value)
+      else
+        @criteria[key] = value
+      end
     end
 
     def to_hash

data/lib/braintree/credit_card.rb

@@ -6,6 +6,29 @@ module Braintree
   class CreditCard
     include BaseModule # :nodoc:
 
+    module CardType
+      AmEx = "American Express"
+      CarteBlanche = "Carte Blanche"
+      ChinaUnionPay = "China UnionPay"
+      DinersClubInternational = "Diners Club"
+      Discover = "Discover"
+      JCB = "JCB"
+      Laser = "Laser"
+      Maestro = "Maestro"
+      MasterCard = "MasterCard"
+      Solo = "Solo"
+      Switch = "Switch"
+      Visa = "Visa"
+      Unknown = "Unknown"
+
+      All = constants.map { |c| const_get(c) }
+    end
+
+    module CustomerLocation
+      International = "international"
+      US = "us"
+    end
+
     attr_reader :billing_address, :bin, :card_type, :cardholder_name, :created_at, :customer_id, :expiration_month,
       :expiration_year, :last_4, :subscriptions, :token, :updated_at
 
@@ -103,7 +126,7 @@ module Braintree
 
     def initialize(attributes) # :nodoc:
       _init attributes
-      @subscriptions = (@subscriptions || []).map { |subscription_hash| Subscription.new(subscription_hash) }
+      @subscriptions = (@subscriptions || []).map { |subscription_hash| Subscription._new(subscription_hash) }
     end
 
     # Creates a credit transaction for this credit card.
@@ -196,7 +219,7 @@ module Braintree
     end
 
     def self._create_signature # :nodoc:
-      _update_signature + [:customer_id]
+      _signature(:create)
     end
 
     def self._new(*args) # :nodoc:
@@ -226,11 +249,27 @@ module Braintree
     end
 
     def self._update_signature # :nodoc:
-      [
+      _signature(:update)
+    end
+
+    def self._signature(type) # :nodoc:
+      billing_address_params = [:company, :country_name, :extended_address, :first_name, :last_name, :locality, :postal_code, :region, :street_address]
+      signature = [
         :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number, :token,
         {:options => [:make_default, :verify_card]},
-        {:billing_address => [:company, :country_name, :extended_address, :first_name, :last_name, :locality, :postal_code, :region, :street_address]}
+        {:billing_address => billing_address_params}
       ]
+
+      case type
+      when :create
+        signature << :customer_id
+      when :update
+        billing_address_params << {:options => [:update_existing]}
+      else
+        raise ArgumentError
+      end
+
+      return signature
     end
 
     def _init(attributes) # :nodoc:

data/lib/braintree/error_codes.rb

@@ -11,6 +11,7 @@ module Braintree
       FirstNameIsTooLong = "81805"
       LastNameIsTooLong = "81806"
       LocalityIsTooLong = "81807"
+      PostalCodeInvalidCharacters = "81813"
       PostalCodeIsRequired = "81808"
       PostalCodeIsTooLong = "81809"
       RegionIsTooLong = "81810"
@@ -87,6 +88,7 @@ module Braintree
       CreditCardIsRequired = "91508"
       CustomerDefaultPaymentMethodCardTypeIsNotAccepted = "81509"
       CustomFieldIsInvalid = "91526"
+      CustomFieldIsTooLong = "81527"
       CustomerIdIsInvalid = "91510"
       CustomerDoesNotHaveCreditCard = "91511"
       HasAlreadyBeenRefunded = "91512"
@@ -95,10 +97,15 @@ module Braintree
       OrderIdIsTooLong = "91501"
       PaymentMethodConflict = "91515"
       PaymentMethodDoesNotBelongToCustomer = "91516"
+      PaymentMethodDoesNotBelongToSubscription = "91527"
       PaymentMethodTokenCardTypeIsNotAccepted = "91517"
       PaymentMethodTokenIsInvalid = "91518"
+      ProcessorAuthorizationCodeCannotBeSet = "91519"
+      ProcessorAuthorizationCodeIsInvalid = "81520"
       RefundAmountIsTooLarge = "91521"
       SettlementAmountIsTooLarge = "91522"
+      SubscriptionDoesNotBelongToCustomer = "91529"
+      SubscriptionIdIsInvalid = "91528"
       TypeIsInvalid = "91523"
       TypeIsRequired = "91524"
       module Options

data/lib/braintree/subscription.rb

@@ -47,7 +47,7 @@ module Braintree
     def self.cancel(subscription_id)
       response = Http.put "/subscriptions/#{subscription_id}/cancel"
       if response[:subscription]
-        SuccessfulResult.new(:subscription => new(response[:subscription]))
+        SuccessfulResult.new(:subscription => _new(response[:subscription]))
       elsif response[:api_error_response]
         ErrorResult.new(response[:api_error_response])
       else
@@ -66,11 +66,21 @@ module Braintree
     # if the subscription cannot be found.
     def self.find(id)
       response = Http.get "/subscriptions/#{id}"
-      new(response[:subscription])
+      _new(response[:subscription])
     rescue NotFoundError
       raise NotFoundError, "subscription with id #{id.inspect} not found"
     end
 
+    def self.retry_charge(subscription_id, amount=nil)
+      attributes = {
+        :amount => amount,
+        :subscription_id => subscription_id,
+        :type => Transaction::Type::Sale
+      }
+
+      Transaction.send(:_do_create, "/transactions", :transaction => attributes)
+    end
+
     # Allows searching on subscriptions. There are two types of fields that are searchable: text and
     # multiple value fields. Searchable text fields are:
     # - plan_id
@@ -93,7 +103,7 @@ module Braintree
 
       response = Http.post "/subscriptions/advanced_search?page=#{page}", {:search => search.to_hash}
       attributes = response[:subscriptions]
-      attributes[:items] = Util.extract_attribute_as_array(attributes, :subscription).map { |attrs| new(attrs) }
+      attributes[:items] = Util.extract_attribute_as_array(attributes, :subscription).map { |attrs| _new(attrs) }
       ResourceCollection.new(attributes) { |page_number| Subscription.search(page_number, &block) }
     end
 
@@ -101,7 +111,7 @@ module Braintree
       Util.verify_keys(_update_signature, attributes)
       response = Http.put "/subscriptions/#{subscription_id}", :subscription => attributes
       if response[:subscription]
-        SuccessfulResult.new(:subscription => new(response[:subscription]))
+        SuccessfulResult.new(:subscription => _new(response[:subscription]))
       elsif response[:api_error_response]
          ErrorResult.new(response[:api_error_response])
       else
@@ -130,9 +140,17 @@ module Braintree
 
     # True if <tt>other</tt> has the same id.
     def ==(other)
+      return false unless other.is_a?(Subscription)
       id == other.id
     end
 
+    class << self
+      protected :new
+      def _new(*args) # :nodoc:
+        self.new *args
+      end
+    end
+
     def self._do_create(url, params) # :nodoc:
       response = Http.post url, params
       if response[:subscription]

data/lib/braintree/transaction.rb

@@ -123,6 +123,11 @@ module Braintree
   class Transaction
     include BaseModule
 
+    module CreatedUsing
+      FullInformation = 'full_information'
+      Token = 'token'
+    end
+
     module Status
       Authorizing = 'authorizing'
       Authorized = 'authorized'
@@ -134,6 +139,14 @@ module Braintree
       SubmittedForSettlement = 'submitted_for_settlement'
       Unknown = 'unknown'
       Voided = 'voided'
+
+      All = constants.map { |c| const_get(c) }
+    end
+
+    module Source
+      Api = "api"
+      ControlPanel = "control_panel"
+      Recurring = "recurring"
     end
 
     module Type # :nodoc:
@@ -145,6 +158,7 @@ module Braintree
     attr_reader :amount, :created_at, :credit_card_details, :customer_details, :id
     attr_reader :custom_fields
     attr_reader :cvv_response_code
+    attr_reader :merchant_account_id
     attr_reader :order_id
     attr_reader :billing_details, :shipping_details
     # The authorization code from the processor.
@@ -209,13 +223,13 @@ module Braintree
     # Returns a ResourceCollection of transactions matching the search query.
     # If <tt>query</tt> is a string, the search will be a basic search.
     # If <tt>query</tt> is a hash, the search will be an advanced search.
-    def self.search(query, options = {})
-      if query.is_a?(String)
-        _basic_search query, options
-      elsif query.is_a?(Hash)
-        _advanced_search query, options
+    def self.search(query = nil, page=1, &block)
+      if block_given?
+        _advanced_search page, &block
+      elsif query.is_a?(String)
+        _basic_search query, page
       else
-        raise ArgumentError, "expected query to be a string or a hash"
+        raise ArgumentError, "expected search to be a string or a block"
       end
     end
 
@@ -256,8 +270,9 @@ module Braintree
       _init attributes
     end
 
-    # True if <tt>other</tt> has the same id.
+    # True if <tt>other</tt> is a Braintree::Transaction with the same id.
     def ==(other)
+      return false unless other.is_a?(Transaction)
       id == other.id
     end
 
@@ -275,8 +290,8 @@ module Braintree
     end
 
     # Creates a credit transaction that refunds this transaction.
-    def refund
-      response = Http.post "/transactions/#{id}/refund"
+    def refund(amount = nil)
+      response = Http.post "/transactions/#{id}/refund", :transaction => {:amount => amount}
       if response[:transaction]
         # TODO: need response to return original_transaction so that we can update status, updated_at, etc.
         SuccessfulResult.new(:new_transaction => Transaction._new(response[:transaction]))
@@ -380,29 +395,31 @@ module Braintree
       end
     end
 
-    def self._advanced_search(query, options) # :nodoc:
-      page = options[:page] || 1
-      response = Http.post "/transactions/advanced_search?page=#{Util.url_encode(page)}", :search => query
+    def self._advanced_search(page, &block) # :nodoc:
+      search = TransactionSearch.new
+      block.call(search)
+
+      response = Http.post "/transactions/advanced_search?page=#{page}", {:search => search.to_hash}
       attributes = response[:credit_card_transactions]
       attributes[:items] = Util.extract_attribute_as_array(attributes, :transaction).map { |attrs| _new(attrs) }
-      ResourceCollection.new(attributes) { |page_number| Transaction.search(query, :page => page_number) }
+
+      ResourceCollection.new(attributes) { |page_number| Transaction.search(nil, page_number, &block) }
     end
 
     def self._attributes # :nodoc:
       [:amount, :created_at, :credit_card_details, :customer_details, :id, :status, :type, :updated_at]
     end
 
-    def self._basic_search(query, options) # :nodoc:
-      page = options[:page] || 1
+    def self._basic_search(query, page) # :nodoc:
       response = Http.get "/transactions/all/search?q=#{Util.url_encode(query)}&page=#{Util.url_encode(page)}"
       attributes = response[:credit_card_transactions]
       attributes[:items] = Util.extract_attribute_as_array(attributes, :transaction).map { |attrs| _new(attrs) }
-      ResourceCollection.new(attributes) { |page_number| Transaction.search(query, :page => page_number) }
+      ResourceCollection.new(attributes) { |page_number| Transaction.search(query, page_number) }
     end
 
     def self._create_signature # :nodoc:
       [
-        :amount, :customer_id, :order_id, :payment_method_token, :type,
+        :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 => [:first_name, :last_name, :company, :country_name, :extended_address, :locality, :postal_code, :region, :street_address]},

data/lib/braintree/transaction_search.rb

@@ -0,0 +1,63 @@
+module Braintree
+  class TransactionSearch < AdvancedSearch
+    search_fields(
+      :billing_company,
+      :billing_country_name,
+      :billing_extended_address,
+      :billing_first_name,
+      :billing_last_name,
+      :billing_locality,
+      :billing_postal_code,
+      :billing_region,
+      :billing_street_address,
+      :credit_card_cardholder_name,
+      :currency,
+      :customer_company,
+      :customer_email,
+      :customer_fax,
+      :customer_first_name,
+      :customer_id,
+      :customer_last_name,
+      :customer_phone,
+      :customer_website,
+      :id,
+      :order_id,
+      :payment_method_token,
+      :processor_authorization_code,
+      :shipping_company,
+      :shipping_country_name,
+      :shipping_extended_address,
+      :shipping_first_name,
+      :shipping_last_name,
+      :shipping_locality,
+      :shipping_postal_code,
+      :shipping_region,
+      :shipping_street_address
+    )
+
+    equality_fields :credit_card_expiration_date
+    partial_match_fields :credit_card_number
+
+    multiple_value_field :created_using, :allows => [
+      Transaction::CreatedUsing::FullInformation,
+      Transaction::CreatedUsing::Token
+    ]
+    multiple_value_field :credit_card_card_type, :allows => CreditCard::CardType::All
+    multiple_value_field :credit_card_customer_location, :allows => [
+      CreditCard::CustomerLocation::International,
+      CreditCard::CustomerLocation::US
+    ]
+    multiple_value_field :merchant_account_id
+    multiple_value_field :status, :allows => Transaction::Status::All
+    multiple_value_field :source, :allows => [
+      Transaction::Source::Api,
+      Transaction::Source::ControlPanel,
+      Transaction::Source::Recurring
+    ]
+    multiple_value_field :type
+
+    key_value_fields :refund
+
+    range_fields :amount, :created_at
+  end
+end