activemerchant 1.29.1 → 1.30.0

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

@@ -44,22 +44,40 @@ module ActiveMerchant #:nodoc:
                            fraud_http_accept_encoding fraud_http_accept_charset
                            fraud_http_referer fraud_http_user_agent apikey),
 
-          :capture   => %w(protocol msgtype merchant amount transaction
-                           fraud_remote_addr fraud_http_accept
-                           fraud_http_accept_language fraud_http_accept_encoding
-                           fraud_http_accept_charset fraud_http_referer
-                           fraud_http_user_agent apikey),
+          :capture   => %w(protocol msgtype merchant amount transaction apikey),
 
-          :cancel    => %w(protocol msgtype merchant transaction fraud_remote_addr
-                           fraud_http_accept fraud_http_accept_language
+          :cancel    => %w(protocol msgtype merchant transaction apikey),
+
+          :refund    => %w(protocol msgtype merchant amount transaction apikey),
+
+          :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
+                           expirationdate cvd cardtypelock description testmode
+                           fraud_remote_addr fraud_http_accept fraud_http_accept_language
                            fraud_http_accept_encoding fraud_http_accept_charset
                            fraud_http_referer fraud_http_user_agent apikey),
 
-          :refund    => %w(protocol msgtype merchant amount transaction
-                           fraud_remote_addr fraud_http_accept fraud_http_accept_language
+          :recurring => %w(protocol msgtype merchant ordernumber amount currency
+                           autocapture transaction apikey),
+
+          :status    => %w(protocol msgtype merchant transaction apikey),
+
+          :chstatus  => %w(protocol msgtype merchant apikey)
+        },
+
+        5 => {
+          :authorize => %w(protocol msgtype merchant ordernumber amount
+                           currency autocapture cardnumber expirationdate cvd
+                           cardtypelock testmode fraud_remote_addr
+                           fraud_http_accept fraud_http_accept_language
                            fraud_http_accept_encoding fraud_http_accept_charset
                            fraud_http_referer fraud_http_user_agent apikey),
 
+          :capture   => %w(protocol msgtype merchant amount transaction apikey),
+
+          :cancel    => %w(protocol msgtype merchant transaction apikey),
+
+          :refund    => %w(protocol msgtype merchant amount transaction apikey),
+
           :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
                            expirationdate cvd cardtypelock description testmode
                            fraud_remote_addr fraud_http_accept fraud_http_accept_language
@@ -67,20 +85,40 @@ module ActiveMerchant #:nodoc:
                            fraud_http_referer fraud_http_user_agent apikey),
 
           :recurring => %w(protocol msgtype merchant ordernumber amount currency
-                           autocapture transaction fraud_remote_addr fraud_http_accept
-                           fraud_http_accept_language fraud_http_accept_encoding
-                           fraud_http_accept_charset fraud_http_referer
-                           fraud_http_user_agent apikey),
+                           autocapture transaction apikey),
+
+          :status    => %w(protocol msgtype merchant transaction apikey),
 
-          :status    => %w(protocol msgtype merchant transaction fraud_remote_addr
+          :chstatus  => %w(protocol msgtype merchant apikey)
+        },
+
+        6 => {
+          :authorize => %w(protocol msgtype merchant ordernumber amount
+                           currency autocapture cardnumber expirationdate cvd
+                           cardtypelock testmode fraud_remote_addr
                            fraud_http_accept fraud_http_accept_language
                            fraud_http_accept_encoding fraud_http_accept_charset
                            fraud_http_referer fraud_http_user_agent apikey),
 
-          :chstatus  => %w(protocol msgtype merchant fraud_remote_addr fraud_http_accept
-                           fraud_http_accept_language fraud_http_accept_encoding
-                           fraud_http_accept_charset fraud_http_referer
-                           fraud_http_user_agent apikey)
+          :capture   => %w(protocol msgtype merchant amount transaction
+                           apikey),
+
+          :cancel    => %w(protocol msgtype merchant transaction apikey),
+
+          :refund    => %w(protocol msgtype merchant amount transaction apikey),
+
+          :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
+                           expirationdate cvd cardtypelock description testmode
+                           fraud_remote_addr fraud_http_accept fraud_http_accept_language
+                           fraud_http_accept_encoding fraud_http_accept_charset
+                           fraud_http_referer fraud_http_user_agent apikey),
+
+          :recurring => %w(protocol msgtype merchant ordernumber amount currency
+                           autocapture transaction apikey),
+
+          :status    => %w(protocol msgtype merchant transaction apikey),
+
+          :chstatus  => %w(protocol msgtype merchant apikey)
         }
       }
 
@@ -89,7 +127,7 @@ module ActiveMerchant #:nodoc:
       # The login is the QuickpayId
       # The password is the md5checkword from the Quickpay manager
       # To use the API-key from the Quickpay manager, specify :api-key
-      # Using the API-key, requires that you use version 4. Specify :version => 4 in options.
+      # Using the API-key, requires that you use version 4+. Specify :version => 4/5/6 in options.
       def initialize(options = {})
         requires!(options, :login, :password)
         @protocol = options.delete(:version) || 3 # default to protocol version 3
@@ -99,26 +137,30 @@ module ActiveMerchant #:nodoc:
       def authorize(money, credit_card_or_reference, options = {})
         post = {}
 
+        action = recurring_or_authorize(credit_card_or_reference)
+
         add_amount(post, money, options)
         add_invoice(post, options)
         add_creditcard_or_reference(post, credit_card_or_reference, options)
         add_autocapture(post, false)
-        add_fraud_parameters(post, options)
+        add_fraud_parameters(post, options) if action.eql?(:authorize)
         add_testmode(post)
 
-        commit(recurring_or_authorize(credit_card_or_reference), post)
+        commit(action, post)
       end
 
       def purchase(money, credit_card_or_reference, options = {})
         post = {}
 
+        action = recurring_or_authorize(credit_card_or_reference)
+
         add_amount(post, money, options)
         add_creditcard_or_reference(post, credit_card_or_reference, options)
         add_invoice(post, options)
-        add_fraud_parameters(post, options)
+        add_fraud_parameters(post, options) if action.eql?(:authorize)
         add_autocapture(post, true)
 
-        commit(recurring_or_authorize(credit_card_or_reference), post)
+        commit(action, post)
       end
 
       def capture(money, authorization, options = {})
@@ -126,8 +168,6 @@ module ActiveMerchant #:nodoc:
 
         add_reference(post, authorization)
         add_amount_without_currency(post, money)
-        add_fraud_parameters(post, options)
-
         commit(:capture, post)
       end
 
@@ -135,7 +175,6 @@ module ActiveMerchant #:nodoc:
         post = {}
 
         add_reference(post, identification)
-        add_fraud_parameters(post, options)
 
         commit(:cancel, post)
       end
@@ -145,7 +184,6 @@ module ActiveMerchant #:nodoc:
 
         add_amount_without_currency(post, money)
         add_reference(post, identification)
-        add_fraud_parameters(post, options)
 
         commit(:refund, post)
       end
@@ -219,7 +257,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_fraud_parameters(post, options)
-        if @protocol == 4
+        if @protocol >= 4
           post[:fraud_remote_addr] = options[:fraud_remote_addr] if options[:fraud_remote_addr]
           post[:fraud_http_accept] = options[:fraud_http_accept] if options[:fraud_http_accept]
           post[:fraud_http_accept_language] = options[:fraud_http_accept_language] if options[:fraud_http_accept_language]

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

@@ -65,6 +65,7 @@ module ActiveMerchant #:nodoc:
         add_credit_card(post, credit_card)
         add_address(post, options)
         add_customer_data(post, options)
+        add_optional_data(post, options)
 
         commit(:purchase, post)
       end
@@ -79,6 +80,7 @@ module ActiveMerchant #:nodoc:
         add_credit_card(post, credit_card)
         add_address(post, options)
         add_customer_data(post, options)
+        add_optional_data(post, options)
 
         commit(:authorization, post)
       end
@@ -156,6 +158,10 @@ module ActiveMerchant #:nodoc:
         add_pair(post, :ClientIPAddress, options[:ip])
       end
 
+      def add_optional_data(post, options)
+        add_pair(post, :GiftAidPayment, options[:gift_aid_payment]) unless options[:gift_aid_payment].blank?
+      end
+
       def add_address(post, options)
         if billing_address = options[:billing_address] || options[:address]
           first_name, last_name = parse_first_and_last_name(billing_address[:name])

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

@@ -221,7 +221,7 @@ module ActiveMerchant #:nodoc:
         parameters[:amount]  = amount(money) if money
         response = parse( ssl_post(self.live_url, post_data(action,parameters)) )
         Response.new(response["response"] == "1", message_from(response), response,
-          :authorization => response["transactionid"],
+          :authorization => (response["transactionid"] || response["customer_vault_id"]),
           :test => test?,
           :cvv_result => response["cvvresponse"],
           :avs_result => { :code => response["avsresponse"] }

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

@@ -0,0 +1,235 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Public: This gateway allows you to interact with any gateway you've
+    # created in Spreedly Core (https://spreedlycore.com).  It's an adapter
+    # which can be particularly useful if you already have code interacting with
+    # ActiveMerchant and want to easily take advantage of Core's vault.
+    class SpreedlyCoreGateway < Gateway
+      self.live_url = 'https://spreedlycore.com/v1'
+
+      self.supported_countries = %w(AD AE AT AU BD BE BG BN CA CH CY CZ DE DK EE EG ES FI FR GB
+                                    GI GR HK HU ID IE IL IM IN IS IT JO KW LB LI LK LT LU LV MC
+                                    MT MU MV MX MY NL NO NZ OM PH PL PT QA RO SA SE SG SI SK SM
+                                    TR TT UM US VA VN ZA)
+
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'https://spreedlycore.com'
+      self.display_name = 'Spreedly Core'
+      self.money_format = :cents
+      self.default_currency = 'USD'
+
+      # Public: Create a new Spreedly Core Gateway.
+      #
+      # options - A hash of options:
+      #           :login         - Your Spreedly Core API login.
+      #           :password      - Your Spreedly Core API secret.
+      #           :gateway_token - The token of the gateway you've created in
+      #                            Spreedly Core.
+      def initialize(options = {})
+        requires!(options, :login, :password, :gateway_token)
+        super
+      end
+
+      # Public: Run a purchase transaction.
+      #
+      # money          - The monetary amount of the transaction in cents.
+      # payment_method - The CreditCard or the Spreedly Core payment method
+      #                  token.
+      # options        - A standard ActiveMerchant options hash
+      def purchase(money, payment_method, options = {})
+        if payment_method.is_a?(String)
+          purchase_with_token(money, payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { save_card(false, payment_method, options) }
+            r.process { purchase_with_token(money, r.authorization, options) }
+          end
+        end
+      end
+
+      # Public: Run an authorize transaction.
+      #
+      # money          - The monetary amount of the transaction in cents.
+      # payment_method - The CreditCard or the Spreedly Core payment method
+      #                  token.
+      # options        - A standard ActiveMerchant options hash
+      def authorize(money, payment_method, options = {})
+        if payment_method.is_a?(String)
+          authorize_with_token(money, payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { save_card(false, payment_method, options) }
+            r.process { authorize_with_token(money, r.authorization, options) }
+          end
+        end
+      end
+
+      def capture(money, authorization, options={})
+        request = build_xml_request('transaction') do |doc|
+          add_invoice(doc, money, options)
+        end
+
+        commit("transactions/#{authorization}/capture.xml", request)
+      end
+
+      def refund(money, authorization, options={})
+        request = build_xml_request('transaction') do |doc|
+          add_invoice(doc, money, options)
+        end
+
+        commit("transactions/#{authorization}/credit.xml", request)
+      end
+
+      def void(authorization, options={})
+        commit("transactions/#{authorization}/void.xml", '')
+      end
+
+      # Public: Store a credit card in the Spreedly Core vault and retain it.
+      #
+      # credit_card    - The CreditCard to store
+      # options        - A standard ActiveMerchant options hash
+      def store(credit_card, options={})
+        save_card(true, credit_card, options)
+      end
+
+      # Public: Redact the CreditCard in Spreedly Core.  This wipes the
+      # sensitive payment information from the card.
+      #
+      # credit_card    - The CreditCard to store
+      # options        - A standard ActiveMerchant options hash
+      def unstore(authorization, options={})
+        commit("payment_methods/#{authorization}/redact.xml", '', :put)
+      end
+
+      private
+      def save_card(retain, credit_card, options)
+        request = build_xml_request('payment_method') do |doc|
+          add_credit_card(doc, credit_card, options)
+          add_data(doc, options)
+          doc.retained(true) if retain
+        end
+
+        commit("payment_methods.xml", request, :post, :payment_method_token)
+      end
+
+      def purchase_with_token(money, payment_method_token, options)
+        request = auth_purchase_request(money, payment_method_token, options)
+        commit("gateways/#{@options[:gateway_token]}/purchase.xml", request)
+      end
+
+      def authorize_with_token(money, payment_method_token, options)
+        request = auth_purchase_request(money, payment_method_token, options)
+        commit("gateways/#{@options[:gateway_token]}/authorize.xml", request)
+      end
+
+      def auth_purchase_request(money, payment_method_token, options)
+        build_xml_request('transaction') do |doc|
+          add_invoice(doc, money, options)
+          doc.payment_method_token(payment_method_token)
+        end
+      end
+
+      def add_invoice(doc, money, options)
+        doc.amount amount(money)
+        doc.currency_code(options[:currency] || currency(money) || default_currency)
+      end
+
+      def add_credit_card(doc, credit_card, options)
+        doc.credit_card do
+          doc.number(credit_card.number)
+          doc.first_name(credit_card.first_name)
+          doc.last_name(credit_card.last_name)
+          doc.month(credit_card.month)
+          doc.year(credit_card.year)
+          doc.email(options[:email])
+          doc.address1(options[:billing_address].try(:[], :address1))
+          doc.address2(options[:billing_address].try(:[], :address2))
+          doc.city(options[:billing_address].try(:[], :city))
+          doc.state(options[:billing_address].try(:[], :state))
+          doc.zip(options[:billing_address].try(:[], :zip))
+        end
+      end
+
+      def add_data(doc, options)
+        doc.data do
+          data_to_doc(doc, options[:data])
+        end
+      end
+
+      def data_to_doc(doc, value)
+        return doc.text value unless value.kind_of? Hash
+        value.each do |k, v|
+          doc.send(k) do
+            data_to_doc(doc, v)
+          end
+        end
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.root.xpath('*').each do |node|
+          if (node.elements.empty?)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              childnode_to_response(response, node, childnode)
+            end
+          end
+        end
+
+        response
+      end
+
+      def childnode_to_response(response, node, childnode)
+        name = "#{node.name.downcase}_#{childnode.name.downcase}"
+        if name == 'payment_method_data' && !childnode.elements.empty?
+          response[name.to_sym] = Hash.from_xml(childnode.to_s).values.first
+        else
+          response[name.to_sym] = childnode.text
+        end
+      end
+
+      def build_xml_request(root)
+        builder = Nokogiri::XML::Builder.new
+        builder.__send__(root) do |doc|
+          yield(doc)
+        end
+        builder.to_xml
+      end
+
+      def commit(relative_url, request, method = :post, authorization_field = :token)
+        begin
+          raw_response = ssl_request(method, "#{live_url}/#{relative_url}", request, headers)
+        rescue ResponseError => e
+          raw_response = e.response.body
+        end
+
+        response_from(raw_response, authorization_field)
+      end
+
+      def response_from(raw_response, authorization_field)
+        parsed = parse(raw_response)
+        options = {
+          :authorization => parsed[authorization_field],
+          :test => (parsed[:on_test_gateway] == 'true'),
+          :avs_result => { :code => parsed[:response_avs_code] },
+          :cvv_result => parsed[:response_cvv_code]
+        }
+
+        Response.new(parsed[:succeeded] == 'true', parsed[:message] || parsed[:error], parsed, options)
+      end
+
+      def headers
+        {
+          'Authorization' => ('Basic ' + Base64.strict_encode64("#{@options[:login]}:#{@options[:password]}").chomp),
+          'Content-Type' => 'text/xml'
+        }
+      end
+    end
+  end
+end
+

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

@@ -50,6 +50,7 @@ module ActiveMerchant #:nodoc:
         add_customer(post, options)
         add_customer_data(post,options)
         post[:description] = options[:description] || options[:email]
+        post[:application_fee] = options[:application_fee] if options[:application_fee]
         add_flags(post, options)
 
         meta = generate_meta(options)

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

@@ -16,7 +16,7 @@ module ActiveMerchant #:nodoc:
         'xsi:noNamespaceSchemaLocation' => 'wirecard.xsd'
       }
 
-      PERMITTED_TRANSACTIONS = %w[ AUTHORIZATION CAPTURE_AUTHORIZATION PURCHASE ]
+      PERMITTED_TRANSACTIONS = %w[ PREAUTHORIZATION CAPTURE PURCHASE ]
 
       RETURN_CODES = %w[ ACK NOK ]
 
@@ -63,13 +63,13 @@ module ActiveMerchant #:nodoc:
       # Authorization
       def authorize(money, creditcard, options = {})
         options[:credit_card] = creditcard
-        commit(:authorization, money, options)
+        commit(:preauthorization, money, options)
       end
 
       # Capture Authorization
       def capture(money, authorization, options = {})
-        options[:authorization] = authorization
-        commit(:capture_authorization, money, options)
+        options[:preauthorization] = authorization
+        commit(:capture, money, options)
       end
 
       # Purchase
@@ -148,16 +148,17 @@ module ActiveMerchant #:nodoc:
         options[:order_id] ||= generate_unique_id
 
         xml.tag! "FNC_CC_#{options[:action].to_s.upcase}" do
-          xml.tag! 'FunctionID', options[:description]
+          xml.tag! 'FunctionID', options[:description].to_s.slice(0,32)
           xml.tag! 'CC_TRANSACTION' do
             xml.tag! 'TransactionID', options[:order_id]
             case options[:action]
-            when :authorization, :purchase
+            when :preauthorization, :purchase
               add_invoice(xml, money, options)
               add_creditcard(xml, options[:credit_card])
               add_address(xml, options[:billing_address])
-            when :capture_authorization
-              xml.tag! 'GuWID', options[:authorization]
+            when :capture
+              xml.tag! 'GuWID', options[:preauthorization]
+              add_amount(xml, money)
             end
           end
         end
@@ -165,7 +166,7 @@ module ActiveMerchant #:nodoc:
 
       # Includes the payment (amount, currency, country) to the transaction-xml
       def add_invoice(xml, money, options)
-        xml.tag! 'Amount', amount(money)
+        add_amount(xml, money)
         xml.tag! 'Currency', options[:currency] || currency(money)
         xml.tag! 'CountryCode', options[:billing_address][:country]
         xml.tag! 'RECURRING_TRANSACTION' do
@@ -173,6 +174,11 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      # Include the amount in the transaction-xml
+      def add_amount(xml, money)
+        xml.tag! 'Amount', amount(money)
+      end
+
       # Includes the credit-card data to the transaction-xml
       def add_creditcard(xml, creditcard)
         raise "Creditcard must be supplied!" if creditcard.nil?

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

@@ -38,6 +38,10 @@ module ActiveMerchant #:nodoc:
       def capture(money, authorization, options = {})
         MultiResponse.run do |r|
           r.process{inquire_request(authorization, options, "AUTHORISED")} unless options[:authorization_validated]
+          if r.params
+            authorization_currency = r.params['amount_currency_code']
+            options = options.merge(:currency => authorization_currency) if authorization_currency.present?
+          end
           r.process{capture_request(money, authorization, options)}
         end
       end
@@ -148,10 +152,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_amount(xml, money, options)
-        xml.tag! 'amount',
-          :value => amount(money),
-          'currencyCode' => (options[:currency] || currency(money)),
-          'exponent' => 2
+        currency = options[:currency] || currency(money)
+        amount   = localized_amount(money, currency)
+
+        xml.tag! 'amount', :value => amount, 'currencyCode' => currency, 'exponent' => 2
       end
 
       def add_payment_method(xml, amount, payment_method, options)
@@ -261,6 +265,13 @@ module ActiveMerchant #:nodoc:
         credentials = "#{@options[:login]}:#{@options[:password]}"
         "Basic #{[credentials].pack('m').strip}"
       end
+
+      def localized_amount(money, currency)
+        amount = amount(money)
+        return amount unless CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s)
+        
+        amount.to_i / 100 * 100
+      end
     end
   end
 end

data/lib/active_merchant/billing/integrations/payflow_link/helper.rb

@@ -20,7 +20,6 @@ module ActiveMerchant #:nodoc:
           mapping :credential2, 'pwd'
           mapping :credential3, 'partner'
           mapping :order, 'user1'
-          mapping :description, 'description'
 
           mapping :amount, 'amt'
 
@@ -35,6 +34,10 @@ module ActiveMerchant #:nodoc:
 
           mapping :customer, :name => 'name'
 
+          def description(value)
+            add_field('description', "#{value}".delete("#"))
+          end
+
           def customer(params = {})
             add_field(mappings[:customer][:name], [params.delete(:first_name), params.delete(:last_name)].compact.join(' '))
           end