braintree 2.10.0 → 4.26.0

data/lib/braintree/customer_gateway.rb

@@ -1,12 +1,15 @@
 module Braintree
-  class CustomerGateway # :nodoc:
+  class CustomerGateway
+    include BaseModule
+
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
+      @config.assert_has_access_token_or_keys
     end
 
     def all
-      response = @config.http.post "/customers/advanced_search_ids"
+      response = @config.http.post("#{@config.base_merchant_path}/customers/advanced_search_ids")
       ResourceCollection.new(response) { |ids| _fetch_customers(CustomerSearch.new, ids) }
     end
 
@@ -15,26 +18,21 @@ module Braintree
       _do_create "/customers", :customer => attributes
     end
 
-    # Deprecated
-    def create_customer_url
-      "#{@config.base_merchant_url}/customers/all/create_via_transparent_redirect_request"
-    end
-
-    # Deprecated
-    def create_from_transparent_redirect(query_string)
-      params = @gateway.transparent_redirect.parse_and_validate_query_string query_string
-      _do_create("/customers/all/confirm_transparent_redirect_request", :id => params[:id])
+    def create!(*args)
+      return_object_or_raise(:customer) { create(*args) }
     end
 
     def delete(customer_id)
-      @config.http.delete("/customers/#{customer_id}")
+      @config.http.delete("#{@config.base_merchant_path}/customers/#{customer_id}")
       SuccessfulResult.new
     end
 
-    def find(customer_id)
+    def find(customer_id, options = {})
       raise ArgumentError, "customer_id contains invalid characters" unless customer_id.to_s =~ /\A[\w-]+\z/
-      raise ArgumentError, "customer_id cannot be blank" if customer_id.to_s == ""
-      response = @config.http.get("/customers/#{customer_id}")
+      raise ArgumentError, "customer_id cannot be blank" if customer_id.nil?|| customer_id.to_s.strip == ""
+
+      query_params = options[:association_filter_id].nil? ? "" : "?association_filter_id=#{options[:association_filter_id]}"
+      response = @config.http.get("#{@config.base_merchant_path}/customers/#{customer_id}#{query_params}")
       Customer._new(@gateway, response[:customer])
     rescue NotFoundError
       raise NotFoundError, "customer with id #{customer_id.inspect} not found"
@@ -44,12 +42,12 @@ module Braintree
       search = CustomerSearch.new
       block.call(search) if block
 
-      response = @config.http.post "/customers/advanced_search_ids", {:search => search.to_hash}
+      response = @config.http.post("#{@config.base_merchant_path}/customers/advanced_search_ids", {:search => search.to_hash})
       ResourceCollection.new(response) { |ids| _fetch_customers(search, ids) }
     end
 
     def transactions(customer_id, options = {})
-      response = @config.http.post "/customers/#{customer_id}/transaction_ids"
+      response = @config.http.post("#{@config.base_merchant_path}/customers/#{customer_id}/transaction_ids")
       ResourceCollection.new(response) { |ids| _fetch_transactions(customer_id, ids) }
     end
 
@@ -58,29 +56,42 @@ module Braintree
       _do_update(:put, "/customers/#{customer_id}", :customer => attributes)
     end
 
-    # Deprecated
-    def update_customer_url
-      warn "[DEPRECATED] Customer.update_customer_url is deprecated. Please use TransparentRedirect.url"
-      "#{@config.base_merchant_url}/customers/all/update_via_transparent_redirect_request"
+    def update!(*args)
+      return_object_or_raise(:customer) { update(*args) }
     end
 
-    # Deprecated
-    def update_from_transparent_redirect(query_string)
-      params = @gateway.transparent_redirect.parse_and_validate_query_string(query_string)
-      _do_update(:post, "/customers/all/confirm_transparent_redirect_request", :id => params[:id])
-    end
-
-    def self._create_signature # :nodoc:
+    def self._create_signature
       credit_card_signature = CreditCardGateway._create_signature - [:customer_id]
+      credit_card_options = credit_card_signature.find { |item| item.respond_to?(:keys) && item.keys == [:options] }
+      credit_card_options[:options].delete_if { |option| option == :fail_on_duplicate_payment_method_for_customer }
+      paypal_account_signature = PayPalAccountGateway._create_nested_signature
+      paypal_options_shipping_signature = AddressGateway._shared_signature
+      options = [
+        :paypal => [
+          :payee_email,
+          :order_id,
+          :custom_field,
+          :description,
+          :amount,
+          {:shipping => paypal_options_shipping_signature}
+        ],
+      ]
       [
-        :company, :email, :fax, :first_name, :id, :last_name, :phone, :website,
+        :company, :email, :fax, :first_name, :id,
+        {:international_phone => [:country_code, :national_number]},
+        :last_name, :phone, :website,
+        :device_data, :payment_method_nonce,
+        {:risk_data => [:customer_browser, :customer_ip]},
         {:credit_card => credit_card_signature},
+        {:paypal_account => paypal_account_signature},
+        {:tax_identifiers => [:country_code, :identifier]},
+        {:options => options},
         {:custom_fields => :_any_key_}
       ]
     end
 
-    def _do_create(url, params=nil) # :nodoc:
-      response = @config.http.post url, params
+    def _do_create(path, params=nil)
+      response = @config.http.post("#{@config.base_merchant_path}#{path}", params)
       if response[:customer]
         SuccessfulResult.new(:customer => Customer._new(@gateway, response[:customer]))
       elsif response[:api_error_response]
@@ -90,8 +101,8 @@ module Braintree
       end
     end
 
-    def _do_update(http_verb, url, params) # :nodoc:
-      response = @config.http.send http_verb, url, params
+    def _do_update(http_verb, path, params)
+      response = @config.http.send(http_verb, "#{@config.base_merchant_path}#{path}", params)
       if response[:customer]
         SuccessfulResult.new(:customer => Customer._new(@gateway, response[:customer]))
       elsif response[:api_error_response]
@@ -101,28 +112,44 @@ module Braintree
       end
     end
 
-    def _fetch_customers(search, ids) # :nodoc:
+    def _fetch_customers(search, ids)
       search.ids.in ids
-      response = @config.http.post "/customers/advanced_search", {:search => search.to_hash}
+      response = @config.http.post("#{@config.base_merchant_path}/customers/advanced_search", {:search => search.to_hash})
       attributes = response[:customers]
       Util.extract_attribute_as_array(attributes, :customer).map { |attrs| Customer._new(@gateway, attrs) }
     end
 
-    def _fetch_transactions(customer_id, ids) # :nodoc:
-      response = @config.http.post "/customers/#{customer_id}/transactions", :search => {:ids => ids}
+    def _fetch_transactions(customer_id, ids)
+      response = @config.http.post("#{@config.base_merchant_path}/customers/#{customer_id}/transactions", :search => {:ids => ids})
       attributes = response[:credit_card_transactions]
       Util.extract_attribute_as_array(attributes, :transaction).map do |transaction_attributes|
         Transaction._new @gateway, transaction_attributes
       end
     end
 
-    def self._update_signature # :nodoc:
+    def self._update_signature
       credit_card_signature = CreditCardGateway._update_signature - [:customer_id]
       credit_card_options = credit_card_signature.find { |item| item.respond_to?(:keys) && item.keys == [:options] }
       credit_card_options[:options] << :update_existing_token
+      paypal_options_shipping_signature = AddressGateway._shared_signature
+      options = [
+        :paypal => [
+          :payee_email,
+          :order_id,
+          :custom_field,
+          :description,
+          :amount,
+          {:shipping => paypal_options_shipping_signature}
+        ],
+      ]
       [
-        :company, :email, :fax, :first_name, :id, :last_name, :phone, :website,
+        :company, :email, :fax, :first_name, :id,
+        {:international_phone => [:country_code, :national_number]},
+        :last_name, :phone, :website,
+        :device_data, :payment_method_nonce, :default_payment_method_token,
         {:credit_card => credit_card_signature},
+        {:tax_identifiers => [:country_code, :identifier]},
+        {:options => options},
         {:custom_fields => :_any_key_}
       ]
     end

data/lib/braintree/customer_search.rb

@@ -1,5 +1,5 @@
 module Braintree
-  class CustomerSearch < AdvancedSearch # :nodoc:
+  class CustomerSearch < AdvancedSearch
     text_fields(
       :address_country_name,
       :address_extended_address,
@@ -17,10 +17,13 @@ module Braintree
       :id,
       :last_name,
       :payment_method_token,
+      :paypal_account_email,
       :phone,
-      :website
+      :website,
     )
 
+    is_fields :payment_method_token_with_duplicates
+
     equality_fields :credit_card_expiration_date
 
     partial_match_fields :credit_card_number

data/lib/braintree/customer_session_gateway.rb

@@ -0,0 +1,194 @@
+# Creates and manages PayPal customer sessions.
+
+module Braintree
+    class CustomerSessionGateway
+      CREATE_CUSTOMER_SESSION = <<~GRAPHQL
+        mutation CreateCustomerSession($input: CreateCustomerSessionInput!) {
+          createCustomerSession(input: $input) {
+            sessionId
+          }
+        }
+      GRAPHQL
+
+      UPDATE_CUSTOMER_SESSION = <<~GRAPHQL
+        mutation UpdateCustomerSession($input: UpdateCustomerSessionInput!) {
+          updateCustomerSession(input: $input) {
+            sessionId
+          }
+        }
+      GRAPHQL
+
+      GET_CUSTOMER_RECOMMENDATIONS = <<~GRAPHQL
+        query CustomerRecommendations($input: CustomerRecommendationsInput!) {
+          customerRecommendations(input: $input) {
+            isInPayPalNetwork
+            recommendations {
+              ... on PaymentRecommendations {
+                paymentOptions {
+                  paymentOption
+                  recommendedPriority
+                }
+              }
+            }
+          }
+        }
+      GRAPHQL
+
+      def initialize(gateway, graphql_client)
+        @gateway = gateway
+        @graphql_client = graphql_client
+      end
+
+      # Creates a new customer session.
+      #
+      # Example:
+      #   customer = {
+      #    email: "test@example.com",
+      #    device_fingerprint_id: "1234",
+      #    phone: {country_phone_code: "1", phone_number: "5555555555"},
+      #    paypal_app_installed: true,
+      #    venmo_app_installed: true,
+      #   }
+      #   input = Braintree::CreateCustomerSessionInput.new(
+      #                customer: customer,
+      #   )
+      #   result = gateway.customer_session.create_customer_session(input)
+      #   if result.success?
+      #     puts "Created session #{result.session_id}"
+      #   else
+      #     puts "Validations failed"
+      #     puts result.errors.first.message
+      #   end
+      #
+      # @param input [CreateCustomerSessionInput] The input parameters for creating a customer session.
+      #
+      # @return [(Successful|Error)Result] A result object with session ID if successful, or errors otherwise.
+      #
+      # @raise [UnexpectedError] If there is an unexpected error during the process.
+      def create_customer_session(input)
+        execute_mutation(CREATE_CUSTOMER_SESSION, input, :createCustomerSession)
+      end
+
+
+      # Updates an existing customer session.
+      #
+      # Example:
+      #   customer = {
+      #    email: "test@example.com",
+      #    device_fingerprint_id: "1234",
+      #    phone: {country_phone_code: "1", phone_number: "5555555555"},
+      #    paypal_app_installed: true,
+      #    venmo_app_installed: true,
+      #   }
+      #   input = Braintree::UpdateCustomerSessionInput.new(
+      #                session_id: "11EF-34BC-2702904B-9026-555555555555",
+      #                customer: customer,
+      #   )
+      #   result = gateway.customer_session.updated_customer_session(input)
+      #   if result.success?
+      #     puts "Updated session #{result.session_id}"
+      #   else
+      #     puts "Validations failed"
+      #     puts result.errors.first.message
+      #   end
+      #
+      # @param input [UpdateCustomerSessionInput] The input parameters for updating a customer session.
+      #
+      # @return [(Successful|Error)Result] A result object with session ID if successful, or errors otherwise.
+      #
+      # @raise [UnexpectedError] If there is an unexpected error during the process.
+      def update_customer_session(input)
+        execute_mutation(UPDATE_CUSTOMER_SESSION, input, :updateCustomerSession)
+      end
+
+      # Retrieves customer recommendations associated with a customer session.
+      #
+      # Example:
+      #   customer = {
+      #    email: "test@example.com",
+      #    device_fingerprint_id: "1234",
+      #    phone: {country_phone_code: "1", phone_number: "5555555555"},
+      #    paypal_app_installed: true,
+      #    venmo_app_installed: true,
+      #   }
+      #   input = Braintree::CustomerRecommendationsInput.new(
+      #                session_id: "11EF-34BC-2702904B-9026-555555555555",
+      #                customer: customer,
+      #                recommendations: [Braintree::Recommendations::PAYMENT_RECOMMENDATIONS]
+      #   )
+      #   result = gateway.customer_session.get_customer_recommendations(input)
+      #   if result.success?
+      #     puts "Fetched customer recommendations"
+      #     payload = result.customer_recommendations
+      #     puts payload
+      #   else
+      #     puts "Validations failed"
+      #     puts result.errors.first.message
+      #   end
+      #
+      # @param input [CustomerRecommendationsInput] The input parameters for retrieving customer recommendations.
+      #
+      # @return [Result\Error|Result\Successful] A result object containing the customer recommendations if successful, or errors otherwise.
+      #
+      # @raise [UnexpectedError] If there is an unexpected error during the process.
+      def get_customer_recommendations(customer_recommendations_input)
+        variables = {"input" => customer_recommendations_input.to_graphql_variables}
+
+        begin
+          response = @graphql_client.query(GET_CUSTOMER_RECOMMENDATIONS, variables)
+          errors = GraphQLClient.get_validation_errors(response)
+          if errors
+            ErrorResult.new(@gateway, {errors:errors})
+          else
+            SuccessfulResult.new(:customer_recommendations => extract_customer_recommendations_payload(response))
+          end
+        rescue StandardError => e
+          raise UnexpectedError, e.message
+        end
+      end
+
+      private
+
+      def execute_mutation(query, input, operation_name)
+        variables = {"input" => input.to_graphql_variables}
+        begin
+          response = @graphql_client.query(query, variables)
+          errors = GraphQLClient.get_validation_errors(response)
+          if errors
+            ErrorResult.new(@gateway, {errors:errors})
+          else
+            session_id = get_value(response, "data.#{operation_name}.sessionId")
+            SuccessfulResult.new(:session_id => session_id)
+          end
+        rescue StandardError => e
+          raise UnexpectedError, e.message
+        end
+      end
+
+      def get_value(response, key)
+        map = response
+        key_parts = key.split(".")
+
+        key_parts[0..-2].each do |sub_key|
+          map = pop_value(map, sub_key)
+          raise UnexpectedError, "Couldn't parse response"  unless map.is_a?(Hash)
+        end
+
+        pop_value(map, key_parts.last)
+      end
+
+      def pop_value(map, key)
+        key = key.to_sym
+        if map.key?(key)
+          map[key]
+        else
+          raise UnexpectedError, "Couldn't parse response"
+        end
+      end
+
+      def extract_customer_recommendations_payload(data)
+        customer_recommendations_hash = get_value(data, "data.customerRecommendations")
+        Braintree::CustomerRecommendationsPayload._new(customer_recommendations_hash)
+      end
+    end
+  end

data/lib/braintree/descriptor.rb

@@ -1,8 +1,10 @@
 module Braintree
-  class Descriptor # :nodoc:
+  class Descriptor
     include BaseModule
 
-    attr_reader :name, :phone
+    attr_reader :name
+    attr_reader :phone
+    attr_reader :url
 
     def initialize(attributes)
       set_instance_variables_from_hash attributes unless attributes.nil?

data/lib/braintree/digest.rb

@@ -1,14 +1,27 @@
 module Braintree
-  module Digest # :nodoc:
+  module Digest
     def self.hexdigest(private_key, string)
       _hmac_sha1(private_key, string)
     end
 
+    def self.secure_compare(left, right)
+      return false unless left && right
+
+      left_bytes = left.unpack("C*")
+      right_bytes = right.unpack("C*")
+      return false if left_bytes.size != right_bytes.size
+
+      result = 0
+      left_bytes.zip(right_bytes).each do |left_byte, right_byte|
+        result |= left_byte ^ right_byte
+      end
+      result == 0
+    end
+
     def self._hmac_sha1(key, message)
       key_digest = ::Digest::SHA1.digest(key)
-      sha1 = OpenSSL::Digest::Digest.new("sha1")
+      sha1 = OpenSSL::Digest.new("sha1")
       OpenSSL::HMAC.hexdigest(sha1, key_digest, message.to_s)
     end
   end
 end
-

data/lib/braintree/disbursement.rb

@@ -0,0 +1,63 @@
+module Braintree
+  class Disbursement
+    include BaseModule
+
+    module Types
+      Credit = "credit"
+      Debit  = "debit"
+    end
+
+    attr_reader :amount
+    attr_reader :disbursement_date
+    attr_reader :disbursement_type
+    attr_reader :exception_message
+    attr_reader :follow_up_action
+    attr_reader :id
+    attr_reader :merchant_account
+    attr_reader :retry
+    attr_reader :success
+    attr_reader :transaction_ids
+
+    alias_method :success?, :success
+
+    def initialize(gateway, attributes)
+      @gateway = gateway
+      set_instance_variables_from_hash(attributes)
+      @amount = Util.to_big_decimal(amount)
+      @disbursement_date = Date.parse(disbursement_date)
+      @merchant_account = MerchantAccount._new(gateway, @merchant_account)
+    end
+
+    def transactions
+      @gateway.transaction.search do |search|
+        search.ids.in transaction_ids
+      end
+    end
+
+    def inspect
+      nice_attributes = self.class._inspect_attributes.map { |attr| "#{attr}: #{send(attr).inspect}" }
+      nice_attributes << "amount: #{self.amount.to_s("F").inspect}"
+      nice_attributes << "disbursement_date: #{self.disbursement_date}"
+      "#<#{self.class} #{nice_attributes.join(', ')}>"
+    end
+
+    def debit?
+      disbursement_type == Types::Debit
+    end
+
+    def credit?
+      disbursement_type == Types::Credit
+    end
+
+    class << self
+      protected :new
+      def _new(*args)
+        self.new(*args)
+      end
+    end
+
+    def self._inspect_attributes
+      [:id, :exception_message, :follow_up_action, :merchant_account, :transaction_ids, :retry, :success]
+    end
+  end
+end

data/lib/braintree/discount.rb

@@ -1,4 +1,8 @@
 module Braintree
   class Discount < Modification
+
+    def self.all
+      Configuration.gateway.discount.all
+    end
   end
 end

data/lib/braintree/discount_gateway.rb

@@ -0,0 +1,17 @@
+module Braintree
+  class DiscountGateway
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+      @config.assert_has_access_token_or_keys
+    end
+
+    def all
+      response = @config.http.get("#{@config.base_merchant_path}/discounts")
+      attributes_collection = response[:discounts]
+      attributes_collection.map do |attributes|
+        Discount._new(attributes)
+      end
+    end
+  end
+end

data/lib/braintree/dispute/evidence.rb

@@ -0,0 +1,24 @@
+module Braintree
+  class Dispute
+    class Evidence
+      include BaseModule
+
+      attr_reader :category,
+        :comment,
+        :created_at,
+        :id,
+        :sent_to_processor_at,
+        :url,
+        :tag,
+        :sequence_number
+
+      def initialize(attributes)
+        unless attributes.nil?
+          @tag = attributes[:category]
+          set_instance_variables_from_hash attributes
+        end
+        @sent_to_processor_at = Date.parse(sent_to_processor_at) unless sent_to_processor_at.nil?
+      end
+    end
+  end
+end

data/lib/braintree/dispute/paypal_message.rb

@@ -0,0 +1,15 @@
+module Braintree
+  class Dispute
+    class PayPalMessage
+      include BaseModule
+
+      attr_reader :message,
+        :sender,
+        :sent_at
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+    end
+  end
+end

data/lib/braintree/dispute/status_history.rb

@@ -0,0 +1,18 @@
+module Braintree
+  class Dispute
+    class StatusHistory
+      include BaseModule
+
+      attr_reader :disbursement_date
+      attr_reader :effective_date
+      attr_reader :status
+      attr_reader :timestamp
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+        @disbursement_date = Date.parse(disbursement_date) unless disbursement_date.nil?
+        @effective_date = Date.parse(effective_date) unless effective_date.nil?
+      end
+    end
+  end
+end

data/lib/braintree/dispute/transaction.rb

@@ -0,0 +1,20 @@
+module Braintree
+  class Dispute
+    class Transaction
+      include BaseModule
+
+      attr_reader :amount
+      attr_reader :created_at
+      attr_reader :id
+      attr_reader :installment_count
+      attr_reader :order_id
+      attr_reader :purchase_order_number
+      attr_reader :payment_instrument_subtype
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+        @amount = Util.to_big_decimal(amount)
+      end
+    end
+  end
+end

data/lib/braintree/dispute/transaction_details.rb

@@ -0,0 +1,15 @@
+module Braintree
+  class Dispute
+    class TransactionDetails
+      include BaseModule
+
+      attr_reader :amount
+      attr_reader :id
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+        @amount = Util.to_big_decimal(amount)
+      end
+    end
+  end
+end