braintree 2.10.0 → 4.26.0

data/lib/braintree/graphql/inputs/phone_input.rb

@@ -0,0 +1,32 @@
+# Phone number input for PayPal customer session.
+
+module Braintree
+    class PhoneInput
+        include BaseModule
+
+        attr_reader :attrs
+        attr_reader :country_phone_code
+        attr_reader :phone_number
+        attr_reader :extension_number
+
+        def initialize(attributes)
+            @attrs = attributes.keys
+            set_instance_variables_from_hash(attributes)
+        end
+
+        def inspect
+            inspected_attributes = @attrs.map { |attr| "#{attr}:#{send(attr).inspect}" }
+            "#<#{self.class} #{inspected_attributes.join(" ")}>"
+        end
+
+        def to_graphql_variables
+            variables = {}
+            variables["countryPhoneCode"] = country_phone_code if country_phone_code
+            variables["phoneNumber"] = phone_number if phone_number
+            variables["extensionNumber"] = extension_number if extension_number
+            variables
+        end
+    end
+end
+
+

data/lib/braintree/graphql/inputs/update_customer_session_input.rb

@@ -0,0 +1,37 @@
+# Represents the input to request an update to a PayPal customer session.
+
+module Braintree
+    class UpdateCustomerSessionInput
+        include BaseModule
+
+        attr_reader :attrs
+        attr_reader :merchant_account_id
+        attr_reader :session_id
+        attr_reader :customer
+
+        def initialize(attributes)
+            unless attributes[:session_id]
+                raise ArgumentError, "Expected hash to contain a :session_id"
+            end
+            @attrs = attributes.keys
+            set_instance_variables_from_hash(attributes)
+            @customer = attributes[:customer] ? CustomerSessionInput.new(attributes[:customer]) : nil
+        end
+
+        def inspect
+            inspected_attributes = @attrs.map { |attr| "#{attr}:#{send(attr).inspect}" }
+            "#<#{self.class} #{inspected_attributes.join(" ")}>"
+        end
+
+        def to_graphql_variables
+            variables = {}
+            variables["merchantAccountId"] = merchant_account_id if merchant_account_id
+            variables["sessionId"] = session_id if session_id
+            variables["customer"] = customer.to_graphql_variables if customer
+            variables
+        end
+
+    end
+end
+
+

data/lib/braintree/graphql/types/customer_recommendations_payload.rb

@@ -0,0 +1,32 @@
+# Represents the customer recommendations information associated with a PayPal customer session.
+
+module Braintree
+    class CustomerRecommendationsPayload
+        include BaseModule
+
+        attr_reader :attrs
+        attr_reader :is_in_paypal_network
+        attr_reader :recommendations
+
+        def initialize(attributes)
+            @attrs = [:is_in_paypal_network, :recommendations]
+            @is_in_paypal_network = attributes[:isInPayPalNetwork] if attributes[:isInPayPalNetwork]
+            @recommendations = CustomerRecommendations._new(attributes[:recommendations]) if attributes[:recommendations]
+        end
+
+        def inspect
+            inspected_attributes = @attrs.map { |attr| "#{attr}:#{send(attr).inspect}" }
+            "#<#{self.class} #{inspected_attributes.join(" ")}>"
+        end
+
+        class << self
+            protected :new
+        end
+
+        def self._new(*args)
+            self.new(*args)
+        end
+    end
+end
+
+

data/lib/braintree/graphql/types/payment_options.rb

@@ -0,0 +1,33 @@
+# Represents the payment method and priority associated with a PayPal customer session.
+
+module Braintree
+    class PaymentOptions
+        include BaseModule
+
+        attr_reader :attrs
+        attr_reader :payment_option
+        attr_reader :recommended_priority
+
+        def initialize(attributes)
+            @attrs = [:payment_option, :recommended_priority]
+            @payment_option = attributes[:paymentOption] if attributes[:paymentOption]
+            @recommended_priority = attributes[:recommendedPriority] if attributes[:recommendedPriority]
+
+        end
+
+        def inspect
+            inspected_attributes = @attrs.map { |attr| "#{attr}:#{send(attr).inspect}" }
+            "#<#{self.class} #{inspected_attributes.join(" ")}>"
+        end
+
+        class << self
+            protected :new
+        end
+
+        def self._new(*args)
+            self.new(*args)
+        end
+    end
+end
+
+

data/lib/braintree/graphql/unions/customer_recommendations.rb

@@ -0,0 +1,34 @@
+# A union of all possible customer recommendations associated with a PayPal customer session.
+
+module Braintree
+    class CustomerRecommendations
+        include BaseModule
+
+        attr_reader :attrs
+        attr_reader :payment_options
+
+        def initialize(attributes)
+            @attrs = [:payment_options]
+            if attributes.nil?
+                @payment_options = []
+            else
+                @payment_options = (attributes[:paymentOptions] || []).map { |payment_options_hash| PaymentOptions._new(payment_options_hash) }
+            end
+        end
+
+        def inspect
+            inspected_attributes = @attrs.map { |attr| "#{attr}:#{send(attr).inspect}" }
+            "#<#{self.class} #{inspected_attributes.join(" ")}>"
+        end
+
+        class << self
+            protected :new
+        end
+
+        def self._new(*args)
+            self.new(*args)
+        end
+    end
+end
+
+

data/lib/braintree/graphql_client.rb

@@ -0,0 +1,50 @@
+module Braintree
+  class GraphQLClient < Http
+
+    def initialize(config)
+      @config = config
+      @graphql_headers = {
+        "Accept" => "application/json",
+        "Braintree-Version" => @config.graphql_api_version,
+        "Content-Type" => "application/json"
+      }
+    end
+
+    def query(definition, variables = {}, operationName = nil)
+      graphql_connection = _setup_connection(@config.graphql_server, @config.graphql_port)
+
+      request = {}
+      request["query"] = definition
+      request["operationName"] = operationName if operationName
+      request["variables"] = variables
+
+      response = _http_do Net::HTTP::Post, @config.graphql_base_url, request.to_json, nil, graphql_connection, @graphql_headers
+      data = _parse_response(response)
+      Util.raise_exception_for_graphql_error(data)
+
+      data
+    end
+
+    def _parse_response(response)
+      body = response.body
+      body = Zlib::GzipReader.new(StringIO.new(body)).read if response.header["Content-Encoding"] == "gzip"
+      JSON.parse(body, :symbolize_names => true)
+    end
+
+    def self.get_validation_errors(response)
+      return nil unless response.key?(:errors) && response[:errors].is_a?(Array)
+      validation_errors = response[:errors].map do |error|
+        {
+          :attribute => "",
+          :code => get_validation_error_code(error),
+          :message => error[:message]
+        }
+      end
+      {errors: validation_errors}
+    end
+
+    def self.get_validation_error_code(error)
+      error[:extensions] && error[:extensions][:legacyCode] rescue nil
+    end
+  end
+end

data/lib/braintree/http.rb

@@ -1,30 +1,38 @@
 module Braintree
-  class Http # :nodoc:
+  class Http
+
+    LINE_FEED = "\r\n"
 
     def initialize(config)
       @config = config
     end
 
-    def delete(path)
+    def delete(path, query_params = {})
       response = _http_do Net::HTTP::Delete, path
-      if response.code.to_i == 200
+      if response.code.to_i == 200 || response.code.to_i == 204
         true
+      elsif response.code.to_i == 422
+        Xml.hash_from_xml(_body(response))
       else
         Util.raise_exception_for_status_code(response.code)
       end
     end
 
-    def get(path)
+    def get(path, query_params = {})
       response = _http_do Net::HTTP::Get, path
-      if response.code.to_i == 200
+      if response.code.to_i == 200 || response.code.to_i == 422
         Xml.hash_from_xml(_body(response))
       else
         Util.raise_exception_for_status_code(response.code)
       end
     end
 
-    def post(path, params = nil)
-      response = _http_do Net::HTTP::Post, path, _build_xml(params)
+    def post(path, params = nil, file = nil)
+      body = params
+      if !file
+        body = _build_xml(params)
+      end
+      response = _http_do Net::HTTP::Post, path, body, file
       if response.code.to_i == 200 || response.code.to_i == 201 || response.code.to_i == 422
         Xml.hash_from_xml(_body(response))
       else
@@ -42,31 +50,87 @@ module Braintree
     end
 
     def _build_xml(params)
-      return nil if params.nil?
+      return "" if params.nil?
       Braintree::Xml.hash_to_xml params
     end
 
-    def _http_do(http_verb, path, body = nil)
-      connection = Net::HTTP.new(@config.server, @config.port)
-      connection.read_timeout = 60
+    def _build_query_string(params)
+      if params.empty?
+        ""
+      else
+        "?" + params.map do |x, y|
+          raise(ArgumentError, "Nested hashes aren't supported in query parameters") if y.respond_to?(:to_hash)
+          "#{x}=#{y}"
+        end.join("&")
+      end
+    end
+
+    def _setup_connection(server = @config.server, port = @config.port)
+      if @config.proxy_address
+        Net::HTTP.new(
+          server,
+          port,
+          @config.proxy_address,
+          @config.proxy_port,
+          @config.proxy_user,
+          @config.proxy_pass,
+        )
+      else
+        Net::HTTP.new(server, port)
+      end
+    end
+
+    def _compose_headers(header_overrides = {})
+      headers = {}
+      headers["Accept"] = "application/xml"
+      headers["User-Agent"] = @config.user_agent
+      headers["Accept-Encoding"] = "gzip"
+      headers["X-ApiVersion"] = @config.api_version
+      headers["Content-Type"] = "application/xml"
+
+      headers.merge(header_overrides)
+    end
+
+    def _http_do(http_verb, path, body = nil, file = nil, connection = nil, header_overrides = {})
+      connection ||= _setup_connection
+
+      connection.open_timeout = @config.http_open_timeout
+      connection.read_timeout = @config.http_read_timeout
       if @config.ssl?
         connection.use_ssl = true
+        connection.ssl_version = @config.ssl_version if @config.ssl_version
         connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
         connection.ca_file = @config.ca_file
         connection.verify_callback = proc { |preverify_ok, ssl_context| _verify_ssl_certificate(preverify_ok, ssl_context) }
       end
+
       connection.start do |http|
-        request = http_verb.new("#{@config.base_merchant_path}#{path}")
-        request["Accept"] = "application/xml"
-        request["User-Agent"] = @config.user_agent
-        request["Accept-Encoding"] = "gzip"
-        request["X-ApiVersion"] = @config.api_version
-        request.basic_auth @config.public_key, @config.private_key
+        request = http_verb.new(path)
+        _compose_headers(header_overrides).each { |header, value| request[header] = value }
+        if @config.client_credentials?
+          request.basic_auth @config.client_id, @config.client_secret
+        elsif @config.access_token
+          request["Authorization"] = "Bearer #{@config.access_token}"
+        else
+          request.basic_auth @config.public_key, @config.private_key
+        end
         @config.logger.debug "[Braintree] [#{_current_time}] #{request.method} #{path}"
         if body
-          request["Content-Type"] = "application/xml"
-          request.body = body
-          @config.logger.debug _format_and_sanitize_body_for_log(body)
+          if file
+            boundary = DateTime.now.strftime("%Q")
+            request["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+
+            form_params = []
+            body.each do |k, v|
+              form_params.push(_add_form_field(k, v))
+            end
+            form_params.push(_add_file_part("file", file))
+            request.body = form_params.collect { |p| "--" + boundary + "#{LINE_FEED}" + p }.join("") + "--" + boundary + "--"
+            @config.logger.debug _format_and_sanitize_body_for_log(_build_xml(body))
+          else
+            request.body = body
+            @config.logger.debug _format_and_sanitize_body_for_log(body)
+          end
         end
         response = http.request(request)
         @config.logger.info "[Braintree] [#{_current_time}] #{request.method} #{path} #{response.code}"
@@ -76,11 +140,39 @@ module Braintree
         end
         response
       end
+    rescue OpenSSL::SSL::SSLError
+      raise Braintree::SSLCertificateError
+    end
+
+    def _add_form_field(key, value)
+      return "Content-Disposition: form-data; name=\"#{key}\"#{LINE_FEED}#{LINE_FEED}#{value}#{LINE_FEED}"
+    end
+
+    def _add_file_part(key, file)
+      mime_type = _mime_type_for_file_name(file.path)
+      return "Content-Disposition: form-data; name=\"#{key}\"; filename=\"#{file.path}\"#{LINE_FEED}" +
+          "Content-Type: #{mime_type}#{LINE_FEED}#{LINE_FEED}#{file.read}#{LINE_FEED}"
+    end
+
+    def _mime_type_for_file_name(filename)
+      file_extension = File.extname(filename).strip.downcase[1..-1]
+      if file_extension == "jpeg" || file_extension == "jpg"
+        return "image/jpeg"
+      elsif file_extension == "png"
+        return "image/png"
+      elsif file_extension == "pdf"
+        return "application/pdf"
+      else
+        return "application/octet-stream"
+      end
     end
 
     def _body(response)
-      if response.header["Content-Encoding"] == "gzip"
+      content_encoding = response.header["Content-Encoding"]
+      if content_encoding == "gzip"
         Zlib::GzipReader.new(StringIO.new(response.body)).read
+      elsif content_encoding.nil?
+        ""
       else
         raise UnexpectedError, "expected a gzipped response"
       end
@@ -92,8 +184,9 @@ module Braintree
 
     def _format_and_sanitize_body_for_log(input_xml)
       formatted_xml = input_xml.gsub(/^/, "[Braintree] ")
-      formatted_xml = formatted_xml.gsub(/<number>(.{6}).+?(.{4})<\/number>/, '<number>\1******\2</number>')
-      formatted_xml = formatted_xml.gsub(/<cvv>.+?<\/cvv>/, '<cvv>***</cvv>')
+      formatted_xml = formatted_xml.gsub(/<number>(.{6}).+?(.{4})<\/number>/m, '<number>\1******\2</number>')
+      formatted_xml = formatted_xml.gsub(/<cvv>.+?<\/cvv>/m, "<cvv>***</cvv>")
+      formatted_xml = formatted_xml.gsub(/<encrypted-card-data>.+?<\/encrypted-card-data>/m, "<encrypted-card-data>***</encrypted-card-data>")
       formatted_xml
     end
 
@@ -101,9 +194,10 @@ module Braintree
       if preverify_ok != true || ssl_context.error != 0
         err_msg = "SSL Verification failed -- Preverify: #{preverify_ok}, Error: #{ssl_context.error_string} (#{ssl_context.error})"
         @config.logger.error err_msg
-        raise SSLCertificateError.new(err_msg)
+        false
+      else
+        true
       end
-      true
     end
   end
 end

data/lib/braintree/local_payment_completed/blik_alias.rb

@@ -0,0 +1,23 @@
+module Braintree
+  class LocalPaymentCompleted
+    class BlikAlias
+      include BaseModule
+
+      attr_reader :key
+      attr_reader :label
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+
+      def inspect
+        attrs = [:key, :label]
+        formatted_attrs = attrs.map do |attr|
+          "#{attr}: #{send(attr).inspect}"
+        end
+
+        "#<#{formatted_attrs.join(", ")}>"
+      end
+    end
+  end
+end

data/lib/braintree/local_payment_completed.rb

@@ -0,0 +1,28 @@
+module Braintree
+  class LocalPaymentCompleted
+    include BaseModule
+
+    attr_reader :bic
+    attr_reader :blik_aliases
+    attr_reader :iban_last_chars
+    attr_reader :payer_id
+    attr_reader :payer_name
+    attr_reader :payment_id
+    attr_reader :payment_method_nonce
+    attr_reader :transaction
+
+    def initialize(attributes)
+      set_instance_variables_from_hash(attributes)
+      @transaction = Transaction._new(Configuration.gateway, transaction) unless transaction.nil?
+      blik_aliases.map { |attrs| BlikAlias.new(attrs) } if blik_aliases
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args)
+      self.new(*args)
+    end
+  end
+end

data/lib/braintree/local_payment_expired.rb

@@ -0,0 +1,21 @@
+module Braintree
+  class LocalPaymentExpired
+    include BaseModule
+
+    attr_reader :payment_id
+    attr_reader :payment_context_id
+
+    def initialize(attributes)
+      set_instance_variables_from_hash(attributes)
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args)
+      self.new(*args)
+    end
+  end
+end
+

data/lib/braintree/local_payment_funded.rb

@@ -0,0 +1,22 @@
+module Braintree
+  class LocalPaymentFunded
+    include BaseModule
+
+    attr_reader :payment_id
+    attr_reader :payment_context_id
+    attr_reader :transaction
+
+    def initialize(attributes)
+      set_instance_variables_from_hash(attributes)
+      @transaction = Transaction._new(Configuration.gateway, transaction)
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args)
+      self.new(*args)
+    end
+  end
+end

data/lib/braintree/local_payment_reversed.rb

@@ -0,0 +1,19 @@
+module Braintree
+  class LocalPaymentReversed
+    include BaseModule
+
+    attr_reader :payment_id
+
+    def initialize(attributes)
+      set_instance_variables_from_hash(attributes)
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args)
+      self.new(*args)
+    end
+  end
+end

data/lib/braintree/merchant.rb

@@ -0,0 +1,34 @@
+module Braintree
+  class Merchant
+    include BaseModule
+
+    attr_reader :company_name
+    attr_reader :country_code_alpha2
+    attr_reader :country_code_alpha3
+    attr_reader :country_code_numeric
+    attr_reader :country_name
+    attr_reader :email
+    attr_reader :id
+    attr_reader :merchant_accounts
+
+    def initialize(gateway, attributes)
+      @merchant_accounts = attributes.delete(:merchant_accounts).map do |merchant_account|
+        MerchantAccount._new(gateway, merchant_account)
+      end
+
+      set_instance_variables_from_hash(attributes)
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args)
+      self.new(*args)
+    end
+
+    def self.provision_raw_apple_pay
+      Configuration.gateway.merchant.provision_raw_apple_pay
+    end
+  end
+end

data/lib/braintree/merchant_account/address_details.rb

@@ -0,0 +1,16 @@
+module Braintree
+  class MerchantAccount
+    class AddressDetails
+      include BaseModule
+
+      attr_reader :locality
+      attr_reader :postal_code
+      attr_reader :region
+      attr_reader :street_address
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+    end
+  end
+end

data/lib/braintree/merchant_account/business_details.rb

@@ -0,0 +1,17 @@
+module Braintree
+  class MerchantAccount
+    class BusinessDetails
+      include BaseModule
+
+      attr_reader :address_details
+      attr_reader :dba_name
+      attr_reader :legal_name
+      attr_reader :tax_id
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+        @address_details = MerchantAccount::AddressDetails.new(@address)
+      end
+    end
+  end
+end

data/lib/braintree/merchant_account/funding_details.rb

@@ -0,0 +1,18 @@
+module Braintree
+  class MerchantAccount
+    class FundingDetails
+      include BaseModule
+
+      attr_reader :account_number_last_4
+      attr_reader :descriptor
+      attr_reader :destination
+      attr_reader :email
+      attr_reader :mobile_phone
+      attr_reader :routing_number
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+    end
+  end
+end

data/lib/braintree/merchant_account/individual_details.rb

@@ -0,0 +1,20 @@
+module Braintree
+  class MerchantAccount
+    class IndividualDetails
+      include BaseModule
+
+      attr_reader :address_details
+      attr_reader :date_of_birth
+      attr_reader :email
+      attr_reader :first_name
+      attr_reader :last_name
+      attr_reader :phone
+      attr_reader :ssn_last_4
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+        @address_details = MerchantAccount::AddressDetails.new(@address)
+      end
+    end
+  end
+end