activemerchant 1.29.1 → 1.31.0

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

@@ -0,0 +1,161 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaymillGateway < Gateway
+      self.supported_countries = %w(AT BE CH CZ DE DK EE ES FI FR GB HU IE
+                                    IS IT LI LU LV NL NO PL PT SE SI TR)
+
+      self.supported_cardtypes = [:visa, :master]
+      self.homepage_url = 'https://paymill.com'
+      self.display_name = 'Paymill'
+      self.money_format = :cents
+      self.default_currency = 'EUR'
+
+      def initialize(options = {})
+        requires!(options, :public_key, :private_key)
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        MultiResponse.run do |r|
+          r.process { save_card(credit_card) }
+          r.process { purchase_with_token(money, r.authorization, options) }
+        end
+      end
+
+      def authorize(money, credit_card, options = {})
+        MultiResponse.run do |r|
+          r.process { save_card(credit_card) }
+          r.process { authorize_with_token(money, r.authorization, options) }
+        end
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        post[:preauthorization] = preauth(authorization)
+        post[:description] = options[:description]
+        commit(:post, 'transactions', post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+
+        post[:amount] = amount(money)
+        post[:description] = options[:description]
+        commit(:post, "refunds/#{transaction_id(authorization)}", post)
+      end
+
+      private
+
+      def add_credit_card(post, credit_card)
+        post['account.number'] = credit_card.number
+        post['account.expiry.month'] = sprintf("%.2i", credit_card.month)
+        post['account.expiry.year'] = sprintf("%.4i", credit_card.year)
+        post['account.verification'] = credit_card.verification_value
+      end
+
+      def headers
+        { 'Authorization' => ('Basic ' + Base64.strict_encode64("#{@options[:private_key]}:X").chomp) }
+      end
+
+      def commit(method, url, parameters=nil)
+        begin
+          raw_response = ssl_request(method, "https://api.paymill.com/v2/#{url}", post_data(parameters), headers)
+        rescue ResponseError => e
+          parsed = JSON.parse(e.response.body)
+          return Response.new(false, parsed['error'], parsed, {})
+        end
+
+        response_from(raw_response)
+      end
+
+      def response_from(raw_response)
+        parsed = JSON.parse(raw_response)
+
+        options = {
+          :authorization => authorization_from(parsed),
+          :test => (parsed['mode'] == 'test'),
+        }
+
+        Response.new(true, 'Transaction approved', parsed, options)
+      end
+
+      def authorization_from(parsed_response)
+        [
+          parsed_response['data']['id'],
+          parsed_response['data']['preauthorization'].try(:[], 'id')
+        ].join(";")
+      end
+
+      def purchase_with_token(money, card_token, options)
+        post = {}
+
+        add_amount(post, money, options)
+        post[:token] = card_token
+        post[:description] = options[:description]
+        commit(:post, 'transactions', post)
+      end
+
+      def authorize_with_token(money, card_token, options)
+        post = {}
+
+        add_amount(post, money, options)
+        post[:token] = card_token
+        commit(:post, 'preauthorizations', post)
+      end
+
+      def save_card(credit_card)
+        post = {}
+
+        add_credit_card(post, credit_card)
+        post['channel.id'] = @options[:public_key]
+        post['jsonPFunction'] = 'jsonPFunction'
+        post['transaction.mode'] = (test? ? 'CONNECTOR_TEST' : 'LIVE')
+
+        begin
+          raw_response = ssl_request(:get, "#{save_card_url}?#{post_data(post)}", nil, {})
+        rescue ResponseError => e
+          return Response.new(false, e.response.body, e.response.body, {})
+        end
+
+        response_for_save_from(raw_response)
+      end
+
+      def response_for_save_from(raw_response)
+        parsed = JSON.parse(raw_response.sub(/jsonPFunction\(/, '').sub(/\)\z/, ''))
+        succeeded = parsed['transaction']['processing']['result'] == 'ACK'
+
+        options = { :test => test? }
+        if succeeded
+          options[:authorization] = parsed['transaction']['identification']['uniqueId']
+        end
+
+        message = parsed['transaction']['processing']['return']['message']
+        Response.new(succeeded, message, parsed, options)
+      end
+
+      def save_card_url
+        (test? ? 'https://test-token.paymill.de' : 'https://token-v2.paymill.de')
+      end
+
+      def post_data(params)
+        no_blanks = params.reject { |key, value| value.blank? }
+        no_blanks.map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def add_amount(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+      end
+
+      def preauth(authorization)
+        authorization.split(";").last
+      end
+
+      def transaction_id(authorization)
+        authorization.split(';').first
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/paypal/paypal_common_api.rb

@@ -397,7 +397,7 @@ module ActiveMerchant #:nodoc:
         transaction_search_optional_fields = %w{ Payer ReceiptID Receiver
                                                  TransactionID InvoiceID CardNumber
                                                  AuctionItemNumber TransactionClass
-                                                 CurrencyCode Status }
+                                                 CurrencyCode Status ProfileID }
         build_request_wrapper('TransactionSearch') do |xml|
           xml.tag! 'StartDate', date_to_iso(options[:start_date])
           xml.tag! 'EndDate', date_to_iso(options[:end_date]) unless options[:end_date].blank?

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

@@ -1,5 +1,6 @@
 require File.dirname(__FILE__) + '/paypal/paypal_common_api'
 require File.dirname(__FILE__) + '/paypal/paypal_express_response'
+require File.dirname(__FILE__) + '/paypal/paypal_recurring_api'
 require File.dirname(__FILE__) + '/paypal_express_common'
 
 module ActiveMerchant #:nodoc:
@@ -7,6 +8,7 @@ module ActiveMerchant #:nodoc:
     class PaypalExpressGateway < Gateway
       include PaypalCommonAPI
       include PaypalExpressCommon
+      include PaypalRecurringApi
 
       NON_STANDARD_LOCALE_CODES = {
         'DK' => 'da_DK',
@@ -28,16 +30,16 @@ module ActiveMerchant #:nodoc:
       self.supported_countries = ['US']
       self.homepage_url = 'https://www.paypal.com/cgi-bin/webscr?cmd=xpt/merchant/ExpressCheckoutIntro-outside'
       self.display_name = 'PayPal Express Checkout'
-      
+
       def setup_authorization(money, options = {})
         requires!(options, :return_url, :cancel_return_url)
-        
+
         commit 'SetExpressCheckout', build_setup_request('Authorization', money, options)
       end
-      
+
       def setup_purchase(money, options = {})
         requires!(options, :return_url, :cancel_return_url)
-        
+
         commit 'SetExpressCheckout', build_setup_request('Sale', money, options)
       end
 
@@ -47,13 +49,13 @@ module ActiveMerchant #:nodoc:
 
       def authorize(money, options = {})
         requires!(options, :token, :payer_id)
-      
+
         commit 'DoExpressCheckoutPayment', build_sale_or_authorization_request('Authorization', money, options)
       end
 
       def purchase(money, options = {})
         requires!(options, :token, :payer_id)
-        
+
         commit 'DoExpressCheckoutPayment', build_sale_or_authorization_request('Sale', money, options)
       end
 
@@ -75,10 +77,10 @@ module ActiveMerchant #:nodoc:
 
         xml.target!
       end
-      
+
       def build_sale_or_authorization_request(action, money, options)
         currency_code = options[:currency] || currency(money)
-        
+
         xml = Builder::XmlMarkup.new :indent => 2
         xml.tag! 'DoExpressCheckoutPaymentReq', 'xmlns' => PAYPAL_NAMESPACE do
           xml.tag! 'DoExpressCheckoutPaymentRequest', 'xmlns:n2' => EBAY_NAMESPACE do
@@ -139,7 +141,7 @@ module ActiveMerchant #:nodoc:
                 xml.tag! 'n2:AllowNote', options[:allow_note] ? '1' : '0'
               end
               xml.tag! 'n2:CallbackURL', options[:callback_url] unless options[:callback_url].blank?
-              
+
               add_payment_details(xml, with_money_default(money), currency_code, options)
               if options[:shipping_options]
                 options[:shipping_options].each do |shipping_option|
@@ -153,16 +155,20 @@ module ActiveMerchant #:nodoc:
 
               xml.tag! 'n2:CallbackTimeout', options[:callback_timeout] unless options[:callback_timeout].blank?
               xml.tag! 'n2:CallbackVersion', options[:callback_version] unless options[:callback_version].blank?
+
+              if options.has_key?(:allow_buyer_optin)
+                xml.tag! 'n2:BuyerEmailOptInEnable', (options[:allow_buyer_optin] ? '1' : '0')
+              end
             end
           end
         end
 
         xml.target!
       end
-      
+
       def build_reference_transaction_request(action, money, options)
         currency_code = options[:currency] || currency(money)
-        
+
         # I am not sure why it's set like this for express gateway
         # but I don't want to break the existing behavior
         xml = Builder::XmlMarkup.new :indent => 2

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

@@ -0,0 +1,157 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PinGateway < Gateway
+      self.test_url = 'https://test-api.pin.net.au/1'
+      self.live_url = 'https://api.pin.net.au/1'
+
+      self.default_currency = 'AUD'
+      self.money_format = :cents
+      self.supported_countries = ['AU']
+      self.supported_cardtypes = [:visa, :master]
+      self.homepage_url = 'http://www.pin.net.au/'
+      self.display_name = 'Pin'
+
+      def initialize(options = {})
+        requires!(options, :api_key)
+        super
+      end
+
+      # Create a charge using a credit card, card token or customer token
+      #
+      # To charge a credit card: purchase([money], [creditcard hash], ...)
+      # To charge a customer: purchase([money], [token], ...)
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_customer_data(post, options)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+
+        commit('charges', post)
+      end
+
+      # Create a customer and associated credit card. The token that is returned
+      # can be used instead of a credit card parameter in the purchase method
+      def store(creditcard, options = {})
+        post = {}
+
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_address(post, creditcard, options)
+        commit('customers', post)
+      end
+
+      # Refund a transaction, note that the money attribute is ignored at the
+      # moment as the API does not support partial refunds. The parameter is
+      # kept for compatibility reasons
+      def refund(money, token, options = {})
+        commit("charges/#{CGI.escape(token)}/refunds", :amount => amount(money))
+      end
+
+      private
+      def add_amount(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:currency] = post[:currency].upcase if post[:currency]
+      end
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email]
+        post[:ip_address] = options[:ip]
+      end
+
+      def add_address(post, creditcard, options)
+        return if creditcard.kind_of?(String)
+        address = (options[:billing_address] || options[:address])
+        return unless address
+
+        post[:card] ||= {}
+        post[:card].merge!(
+          :address_line1 => address[:address1],
+          :address_city => address[:city],
+          :address_postcode => address[:zip],
+          :address_state => address[:state],
+          :address_country => address[:country]
+        )
+      end
+
+      def add_invoice(post, options)
+        post[:description] = options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        if creditcard.respond_to?(:number)
+          post[:card] ||= {}
+
+          post[:card].merge!(
+            :number => creditcard.number,
+            :expiry_month => creditcard.month,
+            :expiry_year => creditcard.year,
+            :cvc => creditcard.verification_value,
+            :name => "#{creditcard.first_name} #{creditcard.last_name}"
+          )
+        elsif creditcard.kind_of?(String)
+          post[:customer_token] = creditcard
+        end
+      end
+
+      def headers
+        {
+          "Content-Type" => "application/json",
+          "Authorization" => "Basic #{Base64.strict_encode64(options[:api_key] + ':').strip}"
+        }
+      end
+
+      def commit(action, params)
+        url = "#{test? ? test_url : live_url}/#{action}"
+
+        begin
+          body = parse(ssl_post(url, post_data(params), headers))
+        rescue ResponseError => e
+          body = parse(e.response.body)
+        end
+
+        if body["response"]
+          success_response(body)
+        elsif body["error"]
+          error_response(body)
+        end
+      end
+
+      def success_response(body)
+        response = body["response"]
+        Response.new(
+          true,
+          response['status_message'],
+          body,
+          :authorization => token(response),
+          :test => test?
+        )
+      end
+
+      def error_response(body)
+        Response.new(
+          false,
+          body['error_description'],
+          body,
+          :authorization => nil,
+          :test => test?
+        )
+      end
+
+      def token(response)
+        response['token']
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def post_data(parameters = {})
+        parameters.to_json
+      end
+    end
+  end
+end

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

@@ -126,6 +126,7 @@ module ActiveMerchant #:nodoc:
         parameters[:trans_request_id] ||= SecureRandom.hex(10)
 
         req = build_request(type, money, parameters)
+
         data = ssl_post(url, req, "Content-Type" => "application/x-qbmsxml")
         response = parse(type, data)
         message = (response[:status_message] || '').strip
@@ -260,8 +261,8 @@ module ActiveMerchant #:nodoc:
 
       def add_address(xml, parameters)
         if address = parameters[:billing_address] || parameters[:address]
-          xml.tag!("CreditCardAddress", address[:address1][0...30])
-          xml.tag!("CreditCardPostalCode", address[:zip][0...9])
+          xml.tag!("CreditCardAddress", (address[:address1] || "")[0...30])
+          xml.tag!("CreditCardPostalCode", (address[:zip] || "")[0...9])
         end
       end
 

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"] }