activemerchant 1.43.3 → 1.44.0

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

@@ -63,7 +63,7 @@ module ActiveMerchant #:nodoc:
       # code returned by ePDQ
       def credit(money, creditcard_or_authorization, options = {})
         if creditcard_or_authorization.is_a?(String)
-          deprecated CREDIT_DEPRECATION_MESSAGE
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
           refund(money, creditcard_or_authorization, options)
         else
           credit_new_order(money, creditcard_or_authorization, options)

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

@@ -16,7 +16,10 @@ module ActiveMerchant #:nodoc:
     # BeanStream supports payment profiles (vaults). This allows you to store cc information with BeanStream and process subsequent transactions with a customer id.
     # Secure Payment Profiles must be enabled on your account (must be done over the phone).
     # Your API Access Passcode must be set in Administration => account settings => order settings.
-    # To learn more about storing credit cards with the Beanstream gateway, please read the BEAN_Payment_Profiles.pdf (I had to phone BeanStream to request it.)
+    # To learn more about storing credit cards with the Beanstream gateway, documentation can be found at http://developer.beanstream.com/documentation/classic-apis
+    #
+    # To store a credit card using Beanstream's Legato Javascript Library (http://developer.beanstream.com/documentation/legato) you must pass the singleUseToken in
+    # the store method's option parameter. Example: @gateway.store("gt6-0c78c25b-3637-4ba0-90e2-26105287f198")
     #
     # == Notes
     # * Adding of order products information is not implemented.
@@ -97,6 +100,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def recurring(money, source, options = {})
+        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
+
         post = {}
         add_amount(post, money)
         add_invoice(post, options)
@@ -108,6 +113,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def update_recurring(amount, source, options = {})
+        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
+
         post = {}
         add_recurring_amount(post, amount)
         add_recurring_invoice(post, options)
@@ -119,6 +126,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def cancel_recurring(options = {})
+        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
+
         post = {}
         add_recurring_operation_type(post, :cancel)
         add_recurring_service(post, options)
@@ -131,11 +140,17 @@ module ActiveMerchant #:nodoc:
 
       # To match the other stored-value gateways, like TrustCommerce,
       # store and unstore need to be defined
-      def store(credit_card, options = {})
+      def store(payment_method, options = {})
         post = {}
         add_address(post, options)
-        add_credit_card(post, credit_card)
-        add_secure_profile_variables(post,options)
+
+        if payment_method.respond_to?(:number)
+          add_credit_card(post, payment_method)
+        else
+          post[:singleUseToken] = payment_method
+        end
+        add_secure_profile_variables(post, options)
+
         commit(post, true)
       end
 
@@ -150,10 +165,14 @@ module ActiveMerchant #:nodoc:
       # Update the values (such as CC expiration) stored at
       # the gateway.  The CC number must be supplied in the
       # CreditCard object.
-      def update(vault_id, credit_card, options = {})
+      def update(vault_id, payment_method, options = {})
         post = {}
         add_address(post, options)
-        add_credit_card(post, credit_card)
+        if payment_method.respond_to?(:number)
+          add_credit_card(post, payment_method)
+        else
+          post[:singleUseToken] = payment_method
+        end
         options.merge!({:vault_id => vault_id, :operation => secure_profile_action(:modify)})
         add_secure_profile_variables(post,options)
         commit(post, true)

data/lib/active_merchant/billing/gateways/beanstream/beanstream_core.rb

@@ -87,7 +87,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def capture(money, authorization, options = {})
-        reference, amount, type = split_auth(authorization)
+        reference, _, _ = split_auth(authorization)
 
         post = {}
         add_amount(post, money)
@@ -98,7 +98,7 @@ module ActiveMerchant #:nodoc:
 
       def refund(money, source, options = {})
         post = {}
-        reference, amount, type = split_auth(source)
+        reference, _, type = split_auth(source)
         add_reference(post, reference)
         add_transaction_type(post, refund_action(type))
         add_amount(post, money)
@@ -106,7 +106,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, source, options = {})
-        deprecated Gateway::CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated Gateway::CREDIT_DEPRECATION_MESSAGE
         refund(money, source, options)
       end
 

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

@@ -155,7 +155,7 @@ module ActiveMerchant #:nodoc:
       # * <tt>options</tt> -- A hash of parameters.
       def refund(money, identification, options = {})
         if(identification && !identification.kind_of?(String))
-          deprecated "refund should only be used to refund a referenced transaction"
+          ActiveMerchant.deprecated "refund should only be used to refund a referenced transaction"
           return credit(money, identification, options)
         end
 
@@ -174,7 +174,7 @@ module ActiveMerchant #:nodoc:
 
       def credit(money, payment_object, options = {})
         if(payment_object && payment_object.kind_of?(String))
-          deprecated "credit should only be used to credit a payment method"
+          ActiveMerchant.deprecated "credit should only be used to credit a payment method"
           return refund(money, payment_object, options)
         end
 
@@ -224,6 +224,8 @@ module ActiveMerchant #:nodoc:
       #   :rebill_amount     => '39.95'
       #   A money object of 1995 cents would be passed into the 'money' parameter.
       def recurring(money, payment_object, options = {})
+        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
+
         requires!(options, :rebill_start_date, :rebill_expression)
         options[:rebill] = true
         if money
@@ -241,6 +243,8 @@ module ActiveMerchant #:nodoc:
       #
       # * <tt>rebill_id</tt> -- A string containing the rebill_id of the recurring billing that is already active (REQUIRED)
       def status_recurring(rebill_id)
+        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
+
         post = {}
         requires!(rebill_id)
         post[:REBILL_ID] = rebill_id
@@ -262,6 +266,8 @@ module ActiveMerchant #:nodoc:
       # * <tt>:rebill_next_amount</tt> -- A string containing the next rebilling amount to charge the customer. This ONLY affects the next scheduled charge; all other rebillings will continue at the regular (rebill_amount) amount.
       #   Take a look above at the recurring_payment method for similar examples on how to use.
       def update_recurring(options = {})
+        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
+
         post = {}
         requires!(options, :rebill_id)
         post[:REBILL_ID]          = options[:rebill_id]
@@ -282,6 +288,8 @@ module ActiveMerchant #:nodoc:
       #
       # * <tt>rebill_id</tt> -- A string containing the rebill_id of the recurring billing that you wish to cancel/stop (REQUIRED)
       def cancel_recurring(rebill_id)
+        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
+
         post = {}
         requires!(rebill_id)
         post[:REBILL_ID]         = rebill_id
@@ -357,7 +365,7 @@ module ActiveMerchant #:nodoc:
           else
             message = message.chomp('.')
           end
-        elsif message == "Missing ACCOUNT_ID" 
+        elsif message == "Missing ACCOUNT_ID"
           message = "The merchant login ID or password is invalid"
         elsif message =~ /Approved/
           message = "This transaction has been approved"

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

@@ -42,21 +42,9 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def recurring(money, paysource, options = {})
-        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)
-        else
-          raise Error, error_message(paysource)
-        end
-      end
-
       def credit(money, paysource, options = {})
         if paysource.is_a?(String)
-          deprecated CREDIT_DEPRECATION_MESSAGE
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
           return refund(money, paysource, options)
         end
 

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

@@ -0,0 +1,211 @@
+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.ssl_version = :SSLv3
+
+      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_blue.rb

@@ -73,7 +73,7 @@ module ActiveMerchant #:nodoc:
       def capture(money, authorization, options = {})
         commit do
           result = @braintree_gateway.transaction.submit_for_settlement(authorization, amount(money).to_s)
-          Response.new(result.success?, message_from_result(result))
+          response_from_result(result)
         end
       end
 
@@ -92,21 +92,20 @@ module ActiveMerchant #:nodoc:
         money = amount(money).to_s if money
 
         commit do
-          result = @braintree_gateway.transaction.refund(transaction_id, money)
-          Response.new(result.success?, message_from_result(result),
-            {:braintree_transaction => (transaction_hash(result.transaction) if result.success?)},
-            {:authorization => (result.transaction.id if result.success?)}
-           )
+          response_from_result(@braintree_gateway.transaction.refund(transaction_id, money))
         end
       end
 
       def void(authorization, options = {})
         commit do
-          result = @braintree_gateway.transaction.void(authorization)
-          Response.new(result.success?, message_from_result(result),
-            {:braintree_transaction => (transaction_hash(result.transaction) if result.success?)},
-            {:authorization => (result.transaction.id if result.success?)}
-          )
+          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
 
@@ -137,6 +136,7 @@ module ActiveMerchant #:nodoc:
           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"),
@@ -190,6 +190,7 @@ module ActiveMerchant #:nodoc:
             :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"),
@@ -214,6 +215,7 @@ module ActiveMerchant #:nodoc:
           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"),
@@ -258,6 +260,10 @@ module ActiveMerchant #:nodoc:
           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]
@@ -302,6 +308,13 @@ module ActiveMerchant #:nodoc:
         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?
@@ -467,7 +480,11 @@ module ActiveMerchant #:nodoc:
         end
 
         if credit_card_or_vault_id.is_a?(String) || credit_card_or_vault_id.is_a?(Integer)
-          parameters[:customer_id] = credit_card_or_vault_id
+          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,
@@ -480,8 +497,9 @@ module ActiveMerchant #:nodoc:
             :expiration_year => credit_card_or_vault_id.year.to_s
           }
         end
-        parameters[:billing] = map_address(options[:billing_address]) if options[:billing_address]
+        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"
         parameters
       end
     end