aktivemerchant 2.0.0

data/lib/active_merchant/billing/gateways/bogus.rb

@@ -0,0 +1,140 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Bogus Gateway
+    class BogusGateway < Gateway
+      AUTHORIZATION = '53433'
+
+      SUCCESS_MESSAGE = "Bogus Gateway: Forced success"
+      FAILURE_MESSAGE = "Bogus Gateway: Forced failure"
+      ERROR_MESSAGE = "Bogus Gateway: Use CreditCard number ending in 1 for success, 2 for exception and anything else for error"
+      UNSTORE_ERROR_MESSAGE = "Bogus Gateway: Use trans_id ending in 1 for success, 2 for exception and anything else for error"
+      CAPTURE_ERROR_MESSAGE = "Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success"
+      VOID_ERROR_MESSAGE = "Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success"
+      REFUND_ERROR_MESSAGE = "Bogus Gateway: Use trans_id number ending in 1 for exception, 2 for error and anything else for success"
+      CHECK_ERROR_MESSAGE = "Bogus Gateway: Use bank account number ending in 1 for success, 2 for exception and anything else for error"
+
+      self.supported_countries = []
+      self.supported_cardtypes = [:bogus]
+      self.homepage_url = 'http://example.com'
+      self.display_name = 'Bogus'
+
+      def authorize(money, paysource, options = {})
+        money = amount(money)
+        case normalize(paysource)
+        when /1$/
+          Response.new(true, SUCCESS_MESSAGE, {:authorized_amount => money}, :test => true, :authorization => AUTHORIZATION )
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:authorized_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, error_message(paysource)
+        end
+      end
+
+      def purchase(money, paysource, options = {})
+        money = amount(money)
+        case normalize(paysource)
+        when /1$/, AUTHORIZATION
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true, :authorization => AUTHORIZATION)
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, error_message(paysource)
+        end
+      end
+
+      def credit(money, paysource, options = {})
+        if paysource.is_a?(String)
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
+          return refund(money, paysource, options)
+        end
+
+        money = amount(money)
+        case normalize(paysource)
+        when /1$/
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true )
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, error_message(paysource)
+        end
+      end
+
+      def refund(money, reference, options = {})
+        money = amount(money)
+        case reference
+        when /1$/
+          raise Error, REFUND_ERROR_MESSAGE
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
+        end
+      end
+
+      def capture(money, reference, options = {})
+        money = amount(money)
+        case reference
+        when /1$/
+          raise Error, CAPTURE_ERROR_MESSAGE
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
+        end
+      end
+
+      def void(reference, options = {})
+        case reference
+        when /1$/
+          raise Error, VOID_ERROR_MESSAGE
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:authorization => reference, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          Response.new(true, SUCCESS_MESSAGE, {:authorization => reference}, :test => true)
+        end
+      end
+
+      def store(paysource, options = {})
+        case normalize(paysource)
+        when /1$/
+          Response.new(true, SUCCESS_MESSAGE, {:billingid => '1'}, :test => true, :authorization => AUTHORIZATION)
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:billingid => nil, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, error_message(paysource)
+        end
+      end
+
+      def unstore(reference, options = {})
+        case reference
+        when /1$/
+          Response.new(true, SUCCESS_MESSAGE, {}, :test => true)
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, {:error => FAILURE_MESSAGE },:test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, UNSTORE_ERROR_MESSAGE
+        end
+      end
+
+      private
+
+      def normalize(paysource)
+        if paysource.respond_to?(:account_number) && (paysource.try(:number).blank? || paysource.number.blank?)
+          paysource.account_number
+        elsif paysource.respond_to?(:number)
+          paysource.number
+        else
+          paysource.to_s
+        end
+      end
+
+      def error_message(paysource)
+        if paysource.respond_to?(:account_number)
+          CHECK_ERROR_MESSAGE
+        elsif paysource.respond_to?(:number)
+          ERROR_MESSAGE
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/borgun.rb

@@ -0,0 +1,210 @@
+require "nokogiri"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BorgunGateway < Gateway
+      self.display_name = "Borgun"
+
+      self.test_url = 'https://gatewaytest.borgun.is/ws/Heimir.pub.ws:Authorization'
+      self.live_url = 'https://gateway01.borgun.is/ws/Heimir.pub.ws:Authorization'
+
+      self.supported_countries = ['IS']
+      self.default_currency = 'ISK'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb]
+
+      self.homepage_url = 'https://www.borgun.is/'
+
+      def initialize(options={})
+        requires!(options, :processor, :merchant_id, :username, :password)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = {}
+        post[:TransType] = '1'
+        add_invoice(post, money, options)
+        add_payment_method(post, payment)
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        post[:TransType] = '5'
+        add_invoice(post, money, options)
+        add_payment_method(post, payment)
+
+        commit('authonly', post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        post[:TransType] = '1'
+        add_invoice(post, money, options)
+        add_reference(post, authorization)
+        commit('capture', post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        post[:TransType] = '3'
+        add_invoice(post, money, options)
+        add_reference(post, authorization)
+        commit('refund', post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        # TransType and TrAmount must match original values from auth or purchase.
+        _, _, _, _, _, transtype, tramount = split_authorization(authorization)
+        post[:TransType] = transtype
+        add_invoice(post, tramount.to_i, options)
+        add_reference(post, authorization)
+        commit('void', post)
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency for HDFC: #{k}")}
+      CURRENCY_CODES["ISK"] = "352"
+      CURRENCY_CODES["EUR"] = "978"
+
+      def add_invoice(post, money, options)
+        post[:TrAmount] = amount(money)
+        post[:TrCurrency] = CURRENCY_CODES[options[:currency] || currency(money)]
+      end
+
+      def add_payment_method(post, payment_method)
+        post[:PAN] = payment_method.number
+        post[:ExpDate] = format(payment_method.year, :two_digits) + format(payment_method.month, :two_digits)
+        post[:CVC2] = payment_method.verification_value
+        post[:DateAndTime] = Time.now.strftime("%y%m%d%H%M%S")
+        post[:RRN] = 'AMRCNT' + six_random_digits
+      end
+
+      def add_reference(post, authorization)
+        dateandtime, batch, transaction, rrn, authcode, _, _ = split_authorization(authorization)
+        post[:DateAndTime] = dateandtime
+        post[:Batch] = batch
+        post[:Transaction] = transaction
+        post[:RRN] = rrn
+        post[:AuthCode] = authcode
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(CGI.unescapeHTML(xml))
+        body = doc.xpath('//getAuthorizationReply')
+        body = doc.xpath('//cancelAuthorizationReply') if body.length == 0
+        body.children.each do |node|
+          if node.text?
+            next
+          elsif (node.elements.size == 0)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              name = "#{node.name.downcase}_#{childnode.name.downcase}"
+              response[name.to_sym] = childnode.text
+            end
+          end
+        end
+
+        response
+      end
+
+      def commit(action, post)
+        post[:Version] = '1000'
+        post[:Processor] = @options[:processor]
+        post[:MerchantID] = @options[:merchant_id]
+        post[:TerminalID] = 1
+
+        url = (test? ? test_url : live_url)
+        request = build_request(action, post)
+        raw = ssl_post(url(action), request, headers)
+        pairs = parse(raw)
+        success = success_from(pairs)
+
+        Response.new(
+          success,
+          message_from(success, pairs),
+          pairs,
+          authorization: authorization_from(pairs),
+          test: test?
+        )
+      end
+
+      def success_from(response)
+        (response[:actioncode] == '000')
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response[:message] || "Error with ActionCode=#{response[:actioncode]}"
+        end
+      end
+
+      def authorization_from(response)
+        [
+          response[:dateandtime],
+          response[:batch],
+          response[:transaction],
+          response[:rrn],
+          response[:authcode],
+          response[:transtype],
+          response[:tramount]
+        ].join("|")
+      end
+
+      def split_authorization(authorization)
+        dateandtime, batch, transaction, rrn, authcode, transtype, tramount = authorization.split("|")
+        [dateandtime, batch, transaction, rrn, authcode, transtype, tramount]
+      end
+
+      def headers
+        {
+          'Authorization' => 'Basic ' + Base64.strict_encode64(@options[:username].to_s + ':' + @options[:password].to_s),
+        }
+      end
+
+      def build_request(action, post)
+        mode = (action == 'void') ? 'cancel' : 'get'
+        xml = Builder::XmlMarkup.new :indent => 18
+        xml.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
+        xml.tag!("#{mode}Authorization") do
+          post.each do |field, value|
+            xml.tag!(field, value)
+          end
+        end
+        inner = CGI.escapeHTML(xml.target!)
+        envelope(mode).sub(/{{ :body }}/,inner)
+      end
+
+      def envelope(mode)
+        <<-EOS
+          <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:aut="http://Borgun/Heimir/pub/ws/Authorization">
+            <soapenv:Header/>
+            <soapenv:Body>
+              <aut:#{mode}AuthorizationInput>
+                <#{mode}AuthReqXml>
+                {{ :body }}
+                </#{mode}AuthReqXml>
+              </aut:#{mode}AuthorizationInput>
+            </soapenv:Body>
+          </soapenv:Envelope>
+        EOS
+      end
+
+      def url(action)
+        (test? ? test_url : live_url)
+      end
+
+      def six_random_digits
+        (0...6).map { (48 + rand(10)).chr }.join
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/braintree.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/braintree/braintree_common'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BraintreeGateway < Gateway
+      include BraintreeCommon
+      
+      self.abstract_class = true
+
+      def self.new(options={})
+        if options.has_key?(:login)
+          BraintreeOrangeGateway.new(options)
+        else
+          BraintreeBlueGateway.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/braintree/braintree_common.rb

@@ -0,0 +1,9 @@
+module BraintreeCommon
+  def self.included(base)
+    base.supported_countries = %w(US CA AU AD AT BE BG CY CZ DK EE FI FR GI DE GR HU IS IM IE IT LV LI LT LU MT MC NL NO PL PT RO SM SK SI ES SE CH TR GB)
+    base.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+    base.homepage_url = 'http://www.braintreepaymentsolutions.com'
+    base.display_name = 'Braintree'
+    base.default_currency = 'USD'
+  end
+end

data/lib/active_merchant/billing/gateways/braintree_blue.rb

@@ -0,0 +1,515 @@
+require File.dirname(__FILE__) + '/braintree/braintree_common'
+
+begin
+  require "braintree"
+rescue LoadError
+  raise "Could not load the braintree gem.  Use `gem install braintree` to install it."
+end
+
+raise "Need braintree gem 2.x.y. Run `gem install braintree --version '~>2.0'` to get the correct version." unless Braintree::Version::Major == 2
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # For more information on the Braintree Gateway please visit their
+    # {Developer Portal}[https://www.braintreepayments.com/developers]
+    #
+    # ==== About this implementation
+    #
+    # This implementation leverages the Braintree-authored ruby gem:
+    # https://github.com/braintree/braintree_ruby
+    #
+    # ==== Debugging Information
+    #
+    # Setting an ActiveMerchant +wiredump_device+ will automatically
+    # configure the Braintree logger (via the Braintree gem's
+    # configuration) when the BraintreeBlueGateway is instantiated.
+    # Additionally, the log level will be set to +DEBUG+. Therefore,
+    # all you have to do is set the +wiredump_device+ and you'll get
+    # your debug output from your HTTP interactions with the remote
+    # gateway. (Don't enable this in production.) The ActiveMerchant
+    # implementation doesn't mess with the Braintree::Configuration
+    # globals at all, so there won't be any side effects outside
+    # Active Merchant.
+    #
+    # If no +wiredump_device+ is set, the logger in
+    # +Braintree::Configuration.logger+ will be cloned and the log
+    # level set to +WARN+.
+    #
+    class BraintreeBlueGateway < Gateway
+      include BraintreeCommon
+
+      self.display_name = 'Braintree (Blue Platform)'
+
+      def initialize(options = {})
+        requires!(options, :merchant_id, :public_key, :private_key)
+        @merchant_account_id = options[:merchant_account_id]
+
+        super
+
+        if wiredump_device
+          logger = ((Logger === wiredump_device) ? wiredump_device : Logger.new(wiredump_device))
+          logger.level = Logger::DEBUG
+        else
+          logger = Braintree::Configuration.logger.clone
+          logger.level = Logger::WARN
+        end
+
+        @configuration = Braintree::Configuration.new(
+          :merchant_id       => options[:merchant_id],
+          :public_key        => options[:public_key],
+          :private_key       => options[:private_key],
+          :environment       => (options[:environment] || (test? ? :sandbox : :production)).to_sym,
+          :custom_user_agent => "ActiveMerchant #{ActiveMerchant::VERSION}",
+          :logger            => logger,
+        )
+
+        @braintree_gateway = Braintree::Gateway.new( @configuration )
+      end
+
+      def authorize(money, credit_card_or_vault_id, options = {})
+        create_transaction(:sale, money, credit_card_or_vault_id, options)
+      end
+
+      def capture(money, authorization, options = {})
+        commit do
+          result = @braintree_gateway.transaction.submit_for_settlement(authorization, amount(money).to_s)
+          response_from_result(result)
+        end
+      end
+
+      def purchase(money, credit_card_or_vault_id, options = {})
+        authorize(money, credit_card_or_vault_id, options.merge(:submit_for_settlement => true))
+      end
+
+      def credit(money, credit_card_or_vault_id, options = {})
+        create_transaction(:credit, money, credit_card_or_vault_id, options)
+      end
+
+      def refund(*args)
+        # legacy signature: #refund(transaction_id, options = {})
+        # new signature: #refund(money, transaction_id, options = {})
+        money, transaction_id, _ = extract_refund_args(args)
+        money = amount(money).to_s if money
+
+        commit do
+          response_from_result(@braintree_gateway.transaction.refund(transaction_id, money))
+        end
+      end
+
+      def void(authorization, options = {})
+        commit do
+          response_from_result(@braintree_gateway.transaction.void(authorization))
+        end
+      end
+
+      def verify(credit_card, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def store(creditcard, options = {})
+        if options[:customer].present?
+          MultiResponse.new.tap do |r|
+            customer_exists_response = nil
+            r.process{customer_exists_response = check_customer_exists(options[:customer])}
+            r.process do
+              if customer_exists_response.params["exists"]
+                add_credit_card_to_customer(creditcard, options)
+              else
+                add_customer_with_credit_card(creditcard, options)
+              end
+            end
+          end
+        else
+          add_customer_with_credit_card(creditcard, options)
+        end
+      end
+
+      def update(vault_id, creditcard, options = {})
+        braintree_credit_card = nil
+        commit do
+          braintree_credit_card = @braintree_gateway.customer.find(vault_id).credit_cards.detect { |cc| cc.default? }
+          return Response.new(false, 'Braintree::NotFoundError') if braintree_credit_card.nil?
+
+          options.merge!(:update_existing_token => braintree_credit_card.token)
+          credit_card_params = merge_credit_card_options({
+            :credit_card => {
+              :cardholder_name => creditcard.name,
+              :number => creditcard.number,
+              :cvv => creditcard.verification_value,
+              :expiration_month => creditcard.month.to_s.rjust(2, "0"),
+              :expiration_year => creditcard.year.to_s
+            }
+          }, options)[:credit_card]
+
+          result = @braintree_gateway.customer.update(vault_id,
+            :first_name => creditcard.first_name,
+            :last_name => creditcard.last_name,
+            :email => scrub_email(options[:email]),
+            :credit_card => credit_card_params
+          )
+          Response.new(result.success?, message_from_result(result),
+            :braintree_customer => (customer_hash(@braintree_gateway.customer.find(vault_id), :include_credit_cards) if result.success?),
+            :customer_vault_id => (result.customer.id if result.success?)
+          )
+        end
+      end
+
+      def unstore(customer_vault_id, options = {})
+        commit do
+          if(!customer_vault_id && options[:credit_card_token])
+            @braintree_gateway.credit_card.delete(options[:credit_card_token])
+          else
+            @braintree_gateway.customer.delete(customer_vault_id)
+          end
+          Response.new(true, "OK")
+        end
+      end
+      alias_method :delete, :unstore
+
+      private
+
+      def check_customer_exists(customer_vault_id)
+        commit do
+          begin
+            @braintree_gateway.customer.find(customer_vault_id)
+            ActiveMerchant::Billing::Response.new(true, "Customer found", {exists: true}, authorization: customer_vault_id)
+          rescue Braintree::NotFoundError
+            ActiveMerchant::Billing::Response.new(true, "Customer not found", {exists: false})
+          end
+        end
+      end
+
+      def add_customer_with_credit_card(creditcard, options)
+        commit do
+          parameters = {
+            :first_name => creditcard.first_name,
+            :last_name => creditcard.last_name,
+            :email => scrub_email(options[:email]),
+            :id => options[:customer],
+            :credit_card => {
+              :cardholder_name => creditcard.name,
+              :number => creditcard.number,
+              :cvv => creditcard.verification_value,
+              :expiration_month => creditcard.month.to_s.rjust(2, "0"),
+              :expiration_year => creditcard.year.to_s,
+              :token => options[:credit_card_token]
+            }
+          }
+          result = @braintree_gateway.customer.create(merge_credit_card_options(parameters, options))
+          Response.new(result.success?, message_from_result(result),
+            {
+              :braintree_customer => (customer_hash(result.customer, :include_credit_cards) if result.success?),
+              :customer_vault_id => (result.customer.id if result.success?),
+              :credit_card_token => (result.customer.credit_cards[0].token if result.success?)
+            },
+            :authorization => (result.customer.id if result.success?)
+          )
+        end
+      end
+
+      def add_credit_card_to_customer(credit_card, options)
+        commit do
+          parameters = {
+            customer_id: options[:customer],
+            token: options[:credit_card_token],
+            cardholder_name: credit_card.name,
+            number: credit_card.number,
+            cvv: credit_card.verification_value,
+            expiration_month: credit_card.month.to_s.rjust(2, "0"),
+            expiration_year: credit_card.year.to_s,
+          }
+          parameters[:billing_address] = map_address(options[:billing_address]) if options[:billing_address]
+
+          result = @braintree_gateway.credit_card.create(parameters)
+          ActiveMerchant::Billing::Response.new(
+            result.success?,
+            message_from_result(result),
+            {
+              customer_vault_id: (result.credit_card.customer_id if result.success?),
+              credit_card_token: (result.credit_card.token if result.success?)
+            },
+            authorization: (result.credit_card.customer_id if result.success?)
+          )
+        end
+      end
+
+      def scrub_email(email)
+        return nil unless email.present?
+        return nil if (
+          email !~ /^.+@[^\.]+(\.[^\.]+)+[a-z]$/i ||
+          email =~ /\.(con|met)$/i
+        )
+        email
+      end
+
+      def scrub_zip(zip)
+        return nil unless zip.present?
+        return nil if(
+          zip.gsub(/[^a-z0-9]/i, '').length > 9 ||
+          zip =~ /[^a-z0-9\- ]/i
+        )
+        zip
+      end
+
+      def merge_credit_card_options(parameters, options)
+        valid_options = {}
+        options.each do |key, value|
+          valid_options[key] = value if [:update_existing_token, :verify_card, :verification_merchant_account_id].include?(key)
+        end
+
+        if valid_options.include?(:verify_card) && @merchant_account_id
+          valid_options[:verification_merchant_account_id] ||= @merchant_account_id
+        end
+
+        parameters[:credit_card] ||= {}
+        parameters[:credit_card].merge!(:options => valid_options)
+        parameters[:credit_card][:billing_address] = map_address(options[:billing_address]) if options[:billing_address]
+        parameters
+      end
+
+      def map_address(address)
+        return {} if address.nil?
+        mapped = {
+          :street_address => address[:address1],
+          :extended_address => address[:address2],
+          :company => address[:company],
+          :locality => address[:city],
+          :region => address[:state],
+          :postal_code => scrub_zip(address[:zip]),
+        }
+        if(address[:country] || address[:country_code_alpha2])
+          mapped[:country_code_alpha2] = (address[:country] || address[:country_code_alpha2])
+        elsif address[:country_name]
+          mapped[:country_name] = address[:country_name]
+        elsif address[:country_code_alpha3]
+          mapped[:country_code_alpha3] = address[:country_code_alpha3]
+        elsif address[:country_code_numeric]
+          mapped[:country_code_numeric] = address[:country_code_numeric]
+        end
+        mapped
+      end
+
+      def commit(&block)
+        yield
+      rescue Braintree::BraintreeError => ex
+        Response.new(false, ex.class.to_s)
+      end
+
+      def message_from_result(result)
+        if result.success?
+          "OK"
+        elsif result.errors.size == 0 && result.credit_card_verification
+          "Processor declined: #{result.credit_card_verification.processor_response_text} (#{result.credit_card_verification.processor_response_code})"
+        else
+          result.errors.map { |e| "#{e.message} (#{e.code})" }.join(" ")
+        end
+      end
+
+      def response_from_result(result)
+        Response.new(result.success?, message_from_result(result),
+          { braintree_transaction: (transaction_hash(result.transaction) if result.success?) },
+          { authorization: (result.transaction.id if result.success?) }
+         )
+      end
+
+      def response_params(result)
+        params = {}
+        if result.success?
+          params[:braintree_transaction] = transaction_hash(result.transaction)
+          params[:customer_vault_id] = result.transaction.customer_details.id
+        end
+        params
+      end
+
+      def response_options(result)
+        options = {}
+        if result.success?
+          options[:authorization] = result.transaction.id
+        end
+        if result.transaction
+          options[:avs_result] = {
+            :code => nil, :message => nil,
+            :street_match => result.transaction.avs_street_address_response_code,
+            :postal_match => result.transaction.avs_postal_code_response_code
+          }
+          options[:cvv_result] = result.transaction.cvv_response_code
+        end
+        options
+      end
+
+      def message_from_transaction_result(result)
+        if result.transaction && result.transaction.status == "gateway_rejected"
+          "Transaction declined - gateway rejected"
+        elsif result.transaction
+          "#{result.transaction.processor_response_code} #{result.transaction.processor_response_text}"
+        else
+          message_from_result(result)
+        end
+      end
+
+      def create_transaction(transaction_type, money, credit_card_or_vault_id, options)
+        transaction_params = create_transaction_parameters(money, credit_card_or_vault_id, options)
+        commit do
+          result = @braintree_gateway.transaction.send(transaction_type, transaction_params)
+          response = Response.new(result.success?, message_from_transaction_result(result), response_params(result), response_options(result))
+          response.cvv_result['message'] = ''
+          response
+        end
+      end
+
+      def extract_refund_args(args)
+        options = args.extract_options!
+
+        # money, transaction_id, options
+        if args.length == 1 # legacy signature
+          return nil, args[0], options
+        elsif args.length == 2
+          return args[0], args[1], options
+        else
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 2)"
+        end
+      end
+
+      def customer_hash(customer, include_credit_cards=false)
+        hash = {
+          "email" => customer.email,
+          "first_name" => customer.first_name,
+          "last_name" => customer.last_name,
+          "id" => customer.id
+        }
+
+        if include_credit_cards
+          hash["credit_cards"] = customer.credit_cards.map do |cc|
+            {
+              "bin" => cc.bin,
+              "expiration_date" => cc.expiration_date,
+              "token" => cc.token,
+              "last_4" => cc.last_4,
+              "card_type" => cc.card_type,
+              "masked_number" => cc.masked_number,
+              "token" => cc.token
+            }
+          end
+        end
+
+        hash
+      end
+
+      def transaction_hash(transaction)
+        if transaction.vault_customer
+          vault_customer = {
+          }
+          vault_customer["credit_cards"] = transaction.vault_customer.credit_cards.map do |cc|
+            {
+              "bin" => cc.bin
+            }
+          end
+        else
+          vault_customer = nil
+        end
+
+        customer_details = {
+          "id" => transaction.customer_details.id,
+          "email" => transaction.customer_details.email
+        }
+
+        billing_details = {
+          "street_address"   => transaction.billing_details.street_address,
+          "extended_address" => transaction.billing_details.extended_address,
+          "company"          => transaction.billing_details.company,
+          "locality"         => transaction.billing_details.locality,
+          "region"           => transaction.billing_details.region,
+          "postal_code"      => transaction.billing_details.postal_code,
+          "country_name"     => transaction.billing_details.country_name,
+        }
+
+        shipping_details = {
+          "street_address"   => transaction.shipping_details.street_address,
+          "extended_address" => transaction.shipping_details.extended_address,
+          "company"          => transaction.shipping_details.company,
+          "locality"         => transaction.shipping_details.locality,
+          "region"           => transaction.shipping_details.region,
+          "postal_code"      => transaction.shipping_details.postal_code,
+          "country_name"     => transaction.shipping_details.country_name,
+        }
+        credit_card_details = {
+          "masked_number"       => transaction.credit_card_details.masked_number,
+          "bin"                 => transaction.credit_card_details.bin,
+          "last_4"              => transaction.credit_card_details.last_4,
+          "card_type"           => transaction.credit_card_details.card_type,
+          "token"               => transaction.credit_card_details.token
+        }
+
+        {
+          "order_id"            => transaction.order_id,
+          "status"              => transaction.status,
+          "credit_card_details" => credit_card_details,
+          "customer_details"    => customer_details,
+          "billing_details"     => billing_details,
+          "shipping_details"    => shipping_details,
+          "vault_customer"      => vault_customer,
+          "merchant_account_id" => transaction.merchant_account_id
+        }
+      end
+
+      def create_transaction_parameters(money, credit_card_or_vault_id, options)
+        parameters = {
+          :amount => amount(money).to_s,
+          :order_id => options[:order_id],
+          :customer => {
+            :id => options[:store] == true ? "" : options[:store],
+            :email => scrub_email(options[:email])
+          },
+          :options => {
+            :store_in_vault => options[:store] ? true : false,
+            :submit_for_settlement => options[:submit_for_settlement]
+          }
+        }
+
+        parameters[:custom_fields] = options[:custom_fields]
+        parameters[:device_data] = options[:device_data] if options[:device_data]
+        if merchant_account_id = (options[:merchant_account_id] || @merchant_account_id)
+          parameters[:merchant_account_id] = merchant_account_id
+        end
+
+        if options[:recurring]
+          parameters[:recurring] = true
+        end
+
+        if credit_card_or_vault_id.is_a?(String) || credit_card_or_vault_id.is_a?(Integer)
+          if options[:payment_method_token]
+            parameters[:payment_method_token] = credit_card_or_vault_id
+          else
+            parameters[:customer_id] = credit_card_or_vault_id
+          end
+        else
+          parameters[:customer].merge!(
+            :first_name => credit_card_or_vault_id.first_name,
+            :last_name => credit_card_or_vault_id.last_name
+          )
+          parameters[:credit_card] = {
+            :number => credit_card_or_vault_id.number,
+            :cvv => credit_card_or_vault_id.verification_value,
+            :expiration_month => credit_card_or_vault_id.month.to_s.rjust(2, "0"),
+            :expiration_year => credit_card_or_vault_id.year.to_s
+          }
+        end
+        parameters[:billing] = map_address(options[:billing_address]) if options[:billing_address] && !options[:payment_method_token]
+        parameters[:shipping] = map_address(options[:shipping_address]) if options[:shipping_address]
+        parameters[:channel] = application_id if application_id.present? && application_id != "ActiveMerchant"
+
+        if options[:descriptor_name] || options[:descriptor_phone]
+          parameters[:descriptor] = {
+            name: options[:descriptor_name],
+            phone: options[:descriptor_phone]
+          }
+        end
+
+        parameters
+      end
+    end
+  end
+end