braintree 1.0.0

data/lib/braintree/credit_card_verification.rb

@@ -0,0 +1,31 @@
+module Braintree
+  class CreditCardVerification
+    include BaseModule
+
+    attr_reader :avs_error_response_code, :avs_postal_code_response_code,
+      :avs_street_address_response_code, :cvv_response_code, :status
+
+    def initialize(attributes) # :nodoc:
+      set_instance_variables_from_hash(attributes)
+    end
+
+    def inspect # :nodoc:
+      attr_order = [
+        :status, :cvv_response_code, :avs_error_response_code,
+        :avs_postal_code_response_code, :avs_street_address_response_code
+      ]
+      formatted_attrs = attr_order.map do |attr|
+        "#{attr}: #{send(attr).inspect}"
+      end
+      "#<#{self.class} #{formatted_attrs.join(", ")}>"
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args) # :nodoc:
+      self.new *args
+    end
+  end
+end

data/lib/braintree/customer.rb

@@ -0,0 +1,231 @@
+module Braintree
+  class Customer
+    include BaseModule
+    
+    attr_reader :addresses, :company, :created_at, :credit_cards, :email, :fax, :first_name, :id, :last_name,
+      :phone, :updated_at, :website
+  
+    # Returns a PagedCollection of all customers stored in the vault. Due to race conditions, this method
+    # may not reliably return all customers stored in the vault.
+    #
+    #   page = Braintree::Customer.all
+    #   loop do
+    #     page.each do |customer|
+    #       puts "Customer #{customer.id} email is #{customer.email}"
+    #     end
+    #     break if page.last_page?
+    #     page = page.next_page
+    #   end
+    def self.all(options = {})
+      page_number = options[:page] || 1
+      response = Http.get("/customers?page=#{page_number}")
+      attributes = response[:customers]
+      attributes[:items] = Util.extract_attribute_as_array(attributes, :customer).map do |customer_attributes|
+        new customer_attributes
+      end
+      PagedCollection.new(attributes) { |page_number| Customer.all(:page => page_number) }
+    end
+    
+    # Creates a customer using the given +attributes+. If <tt>:id</tt> is not passed,
+    # the gateway will generate it.
+    #
+    #   result = Braintree::Customer.create(
+    #     :first_name => "John",
+    #     :last_name => "Smith",
+    #     :company => "Smith Co.",
+    #     :email => "john@smith.com",
+    #     :website => "www.smithco.com",
+    #     :fax => "419-555-1234",
+    #     :phone => "614-555-1234"
+    #   )
+    #   if result.success?
+    #     puts "Created customer #{result.customer.id}
+    #   else
+    #     puts "Could not create customer, see result.errors"
+    #   end
+    def self.create(attributes = {})
+      Util.verify_keys(_create_signature, attributes)
+      _do_create "/customers", :customer => attributes
+    end
+    
+    def self.create!(attributes = {})
+      return_object_or_raise(:customer) { create(attributes) }
+    end
+
+    def self.create_customer_url
+      "#{Braintree::Configuration.base_merchant_url}/customers/all/create_via_transparent_redirect_request"
+    end
+
+    def self.create_from_transparent_redirect(query_string)
+      params = TransparentRedirect.parse_and_validate_query_string query_string
+      _do_create("/customers/all/confirm_transparent_redirect_request", :id => params[:id])
+    end
+  
+    def self.create_customer_transparent_redirect_url
+      "#{Braintree::Configuration.base_merchant_url}/customers"
+    end
+    
+    def self.credit(customer_id, transaction_attributes)
+      Transaction.credit(transaction_attributes.merge(:customer_id => customer_id))
+    end
+    
+    def self.credit!(customer_id, transaction_attributes)
+       return_object_or_raise(:transaction){ credit(customer_id, transaction_attributes) }
+    end
+
+    def self.delete(customer_id)
+      Http.delete("/customers/#{customer_id}")
+      SuccessfulResult.new
+    end
+  
+    def self.find(customer_id)
+      response = Http.get("/customers/#{customer_id}")
+      new(response[:customer])
+    rescue NotFoundError
+      raise NotFoundError, "customer with id #{customer_id.inspect} not found"
+    end
+    
+    def self.sale(customer_id, transaction_attributes)
+      Transaction.sale(transaction_attributes.merge(:customer_id => customer_id))
+    end
+    
+    def self.sale!(customer_id, transaction_attributes)
+       return_object_or_raise(:transaction){ sale(customer_id, transaction_attributes) }
+    end
+    
+    def self.update(customer_id, attributes)
+      Util.verify_keys(_update_signature, attributes)
+      _do_update(:put, "/customers/#{customer_id}", :customer => attributes)
+    end
+    
+    def self.update!(customer_id, attributes)
+      return_object_or_raise(:customer) { update(customer_id, attributes) }
+    end
+
+    def self.update_customer_url
+      "#{Braintree::Configuration.base_merchant_url}/customers/all/update_via_transparent_redirect_request"
+    end
+
+    def self.update_from_transparent_redirect(query_string)
+      params = TransparentRedirect.parse_and_validate_query_string(query_string)
+      _do_update(:post, "/customers/all/confirm_transparent_redirect_request", :id => params[:id])
+    end
+  
+    def initialize(attributes) # :nodoc:
+      set_instance_variables_from_hash(attributes)
+      @credit_cards = (@credit_cards || []).map { |pm| CreditCard._new pm }
+      @addresses = (@addresses || []).map { |addr| Address._new addr }
+    end
+    
+    def credit(transaction_attributes)
+      Customer.credit(self.id, transaction_attributes)
+    end
+    
+    def credit!(transaction_attributes)
+      return_object_or_raise(:transaction) { credit(transaction_attributes) }
+    end
+    
+    def delete
+      Customer.delete(id)
+    end
+    
+    def inspect # :nodoc:
+      first = [:id]
+      last = [:addresses, :credit_cards]
+      order = first + (self.class._attributes - first - last) + last
+      nice_attributes = order.map do |attr|
+        "#{attr}: #{send(attr).inspect}"
+      end
+      "#<#{self.class} #{nice_attributes.join(', ')}>"
+    end
+    
+    def sale(transaction_attributes)
+      Customer.sale(self.id, transaction_attributes)
+    end
+    
+    def sale!(transaction_attributes)
+      return_object_or_raise(:transaction) { sale(transaction_attributes) }
+    end
+
+    # Finds transactions associated to the customer. Returns a PagedCollection.
+    def transactions(options = {})
+      page_number = options[:page] || 1
+      response = Http.get "/customers/#{id}/transactions?page=#{page_number}"
+      attributes = response[:credit_card_transactions]
+      attributes[:items] = Util.extract_attribute_as_array(attributes, :transaction).map do |transaction_attributes|
+        Transaction._new transaction_attributes
+      end
+      PagedCollection.new(attributes) { |page_number| self.transactions(:page => page_number) }
+    end
+
+    def update(attributes)
+      response = Http.put "/customers/#{id}", :customer => attributes
+      if response[:customer]
+        set_instance_variables_from_hash response[:customer]
+        SuccessfulResult.new(:customer => self)
+      elsif response[:api_error_response]
+        ErrorResult.new(response[:api_error_response])
+      else
+        raise "expected :customer or :errors"
+      end      
+    end
+    
+    def update!(attributes)
+      return_object_or_raise(:customer) { update(attributes) }
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Customer)
+      id == other.id
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._attributes # :nodoc:
+      [
+        :addresses, :company, :credit_cards, :email, :fax, :first_name, :id, :last_name, :phone, :website,
+        :created_at, :updated_at
+      ]
+    end
+
+    def self._create_signature # :nodoc:
+      credit_card_signature = CreditCard._create_signature - [:customer_id]
+      [
+        :company, :email, :fax, :first_name, :id, :last_name, :phone, :website,
+        {:credit_card => credit_card_signature}
+      ]
+    end
+
+    def self._do_create(url, params) # :nodoc:
+      response = Http.post url, params
+      if response[:customer]
+        SuccessfulResult.new(:customer => new(response[:customer]))
+      elsif response[:api_error_response]
+        ErrorResult.new(response[:api_error_response])
+      else
+        raise "expected :customer or :api_error_response"
+      end
+    end
+
+    def self._do_update(http_verb, url, params) # :nodoc:
+      response = Http.send http_verb, url, params
+      if response[:customer]
+        SuccessfulResult.new(:customer => new(response[:customer]))
+      elsif response[:api_error_response]
+        ErrorResult.new(response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :customer or :api_error_response"
+      end
+    end
+
+    def self._new(*args) # :nodoc:
+      self.new *args
+    end  
+
+    def self._update_signature # :nodoc:
+      [ :company, :email, :fax, :first_name, :id, :last_name, :phone, :website ]
+    end
+  end
+end

data/lib/braintree/digest.rb

@@ -0,0 +1,20 @@
+module Braintree
+  module Digest # :nodoc:
+    def self.hexdigest(string)
+      _hmac_sha1(Configuration.private_key, string)
+    end
+
+    def self._hmac_sha1(key, message)
+      key_digest = ::Digest::SHA1.digest(key)
+      inner_padding = "\x36" * 64
+      outer_padding = "\x5c" * 64
+      0.upto(19) do |i|
+        inner_padding[i] ^= key_digest[i]
+        outer_padding[i] ^= key_digest[i]
+      end
+      inner_hash = ::Digest::SHA1.digest(inner_padding + message.to_s)
+      ::Digest::SHA1.hexdigest(outer_padding + inner_hash)
+    end
+  end
+end
+

data/lib/braintree/error_codes.rb

@@ -0,0 +1,95 @@
+module Braintree
+  # The ErrorCodes module provides constants for validation errors.
+  # The constants should be used to check for a specific validation error in a ValidationErrorCollection.
+  # The error messages returned from the server may change, but the codes will remain the same. 
+  module ErrorCodes
+    module Address
+      CannotBeBlank = "81801"
+      CompanyIsTooLong = "81802"
+      CountryNameIsNotAccepted = "91803"
+      ExtendedAddressIsTooLong = "81804"
+      FirstNameIsTooLong = "81805"
+      LastNameIsTooLong = "81806"
+      LocalityIsTooLong = "81807"
+      PostalCodeIsRequired = "81808"
+      PostalCodeIsTooLong = "81809"
+      RegionIsTooLong = "81810"
+      StreetAddressIsRequired = "81811"
+      StreetAddressIsTooLong = "81812"
+    end
+
+    module CreditCard
+      BillingAddressConflict = "91701"
+      BillingAddressIdIsInvalid = "91702"
+      CreditCardTypeIsNotAccepted = "81703"
+      CustomerIdIsRequired = "91704"
+      CustomerIdIsInvalid = "91705"
+      CvvIsRequired = "81706"
+      CvvIsInvalid = "81707"
+      ExpirationDateConflict = "91708"
+      ExpirationDateIsRequired = "81709"
+      ExpirationDateIsInvalid = "81710"
+      ExpirationDateYearIsInvalid = "81711"
+      ExpirationMonthIsInvalid = "81712"
+      ExpirationYearIsInvalid = "81713"
+      NumberIsRequired = "81714"
+      NumberIsInvalid = "81715"
+      NumberInvalidLength = "81716"
+      NumberMustBeTestNumber = "81717"
+      TokenInvalid = "91718"
+      TokenIsInUse = "91719"
+      TokenIsTooLong = "91720"
+      TokenIsNotAllowed = "91721"
+      TokenIsRequired = "91722"
+    end
+
+    module Customer
+      CompanyisTooLong = "81601"
+      CustomFieldIsInvalid = "91602"
+      CustomFieldIsTooLong = "81603"
+      EmailIsInvalid = "81604"
+      EmailIsTooLong = "81605"
+      EmailIsRequired = "81606"
+      FaxIsTooLong = "81607"
+      FirstNameIsTooLong = "81608"
+      IdIsInUse = "91609"
+      IdIsInvaild = "91610"
+      IdIsNotAllowed = "91611"
+      IdIsTooLong = "91612"
+      LastNameIsTooLong = "81613"
+      PhoneIsTooLong = "81614"
+      WebsiteIsTooLong = "81615"
+      WebsiteIsInvalid = "81616"
+    end
+    
+    module Transaction
+      AmountCannotBeNegative = "81501"
+      AmountIsRequired = "81502"
+      AmountIsInvalid = "81503"
+      CannotBeVoided = "91504"
+      CannotRefundCredit = "91505"
+      CannotRefundUnlessSettled = "91506"
+      CannotSubmitForSettlement = "91507"
+      CreditCardIsRequired = "91508"
+      CustomerDefaultPaymentMethodCardTypeIsNotAccepted = "81509"
+      CustomerIdIsInvalid = "91510"
+      CustomerDoesNotHaveCreditCard = "91511"
+      HasAlreadyBeenRefunded = "91512"
+      MerchantAccountNameIsInvalid = "91513"
+      MerchantAccountIsSuspended = "91514"
+      PaymentMethodConflict = "91515"
+      PaymentMethodDoesNotBelongToCustomer = "91516"
+      PaymentMethodTokenCardTypeIsNotAccepted = "91517"
+      PaymentMethodTokenIsInvalid = "91518"
+      ProcessorAuthorizationCodeCannotBeSet = "91519"
+      ProcessorAuthorizationCodeIsInvalid = "81520"
+      RefundAmountIsTooLarge = "91521"
+      SettlementAmountIsTooLarge = "91522"
+      TypeIsInvalid = "91523"
+      TypeIsRequired = "91524"
+      module Options
+        VaultIsDisabled = "91525"
+      end
+    end
+  end
+end

data/lib/braintree/error_result.rb

@@ -0,0 +1,39 @@
+module Braintree 
+  # An ErrorResult will be returned from non-bang methods when
+  # validations fail. It will provide access to the params passed
+  # to the server. The params are primarily useful for re-populaing
+  # web forms when using transparent redirect. ErrorResult also
+  # provides access to the validation errors.
+  #
+  #   result = Braintree::Customer.create(:email => "invalid.email.address")
+  #   if result.success?
+  #     # have a SuccessfulResult
+  #   else
+  #     # have an ErrorResult
+  #     puts "Validations failed when attempting to create customer."
+  #     result.errors.for(:customer).each do |error|
+  #       puts error.message
+  #     end
+  #   end
+  class ErrorResult
+  
+    attr_reader :credit_card_verification, :errors, :params 
+  
+    def initialize(data) # :nodoc:
+      @params = data[:params]
+      if data[:verification]
+        @credit_card_verification = CreditCardVerification._new(data[:verification])
+      end
+      @errors = Errors.new(data[:errors])
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class} params:{...} errors:<#{@errors._inner_inspect}>>"
+    end
+    
+    # Always returns false.
+    def success?
+      false
+    end
+  end
+end

data/lib/braintree/errors.rb

@@ -0,0 +1,29 @@
+module Braintree
+  # Provides access to errors from an ErrorResult.
+  class Errors
+    def initialize(data = {}) # :nodoc:
+      @errors = ValidationErrorCollection.new(data.merge(:errors => []))
+    end
+
+    # Accesses validation errors for the given +scope+.
+    def for(scope)
+      @errors.for(scope)
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class} #{_inner_inspect}>"
+    end
+
+    # Returns the total number of validation errors at all levels of nesting. For example,
+    # if creating a customer with a credit card and a billing address, and each of the customer,
+    # credit card, and billing address has 1 error, this method will return 3.
+    def size
+      @errors.deep_size
+    end
+
+    def _inner_inspect # :nodoc:
+      @errors._inner_inspect
+    end
+  end
+end
+