activemerchant 1.38.0 → 1.79.2

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

@@ -1,24 +1,197 @@
-require File.dirname(__FILE__) + '/authorize_net'
+require 'active_merchant/billing/gateways/authorize_net'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    class SecurePayGateway < AuthorizeNetGateway
+    class SecurePayGateway < Gateway
+      API_VERSION = '3.1'
+
       self.live_url = self.test_url = 'https://www.securepay.com/AuthSpayAdapter/process.aspx'
 
+      class_attribute :duplicate_window
+
+      APPROVED, DECLINED, ERROR, FRAUD_REVIEW = 1, 2, 3, 4
+
+      RESPONSE_CODE, RESPONSE_REASON_CODE, RESPONSE_REASON_TEXT, AUTHORIZATION_CODE = 0, 2, 3, 4
+      AVS_RESULT_CODE, TRANSACTION_ID, CARD_CODE_RESPONSE_CODE, CARDHOLDER_AUTH_CODE = 5, 6, 38, 39
+
+      self.default_currency = 'USD'
+
+      self.supported_countries = %w(US CA GB AU)
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
       self.homepage_url = 'http://www.securepay.com/'
       self.display_name = 'SecurePay'
 
-      # Limit support to purchase() for the time being
-      # JRuby chokes here
-      # undef_method :authorize, :capture, :void, :credit
+      CARD_CODE_ERRORS = %w( N S )
+      AVS_ERRORS = %w( A E N R W Z )
+      AVS_REASON_CODES = %w(27 45)
+      TRANSACTION_ALREADY_ACTIONED = %w(310 311)
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, paysource, options = {})
+        post = {}
+        add_currency_code(post, money, options)
+        add_invoice(post, options)
+        add_payment_source(post, paysource, options)
+        add_address(post, options)
+        add_customer_data(post, options)
+        add_duplicate_window(post)
 
-      undef_method :authorize
-      undef_method :capture
-      undef_method :void
-      undef_method :credit
+        commit('AUTH_CAPTURE', money, post)
+      end
 
       private
 
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money) unless action == 'VOID'
+
+        url = (test? ? self.test_url : self.live_url)
+        data = ssl_post(url, post_data(action, parameters))
+
+        response          = parse(data)
+        response[:action] = action
+
+        message = message_from(response)
+
+        Response.new(success?(response), message, response,
+          :test => test?,
+          :authorization => response[:transaction_id],
+          :fraud_review => fraud_review?(response),
+          :avs_result => { :code => response[:avs_result_code] },
+          :cvv_result => response[:card_code]
+        )
+      end
+
+      def success?(response)
+        response[:response_code] == APPROVED && TRANSACTION_ALREADY_ACTIONED.exclude?(response[:response_reason_code])
+      end
+
+      def fraud_review?(response)
+        response[:response_code] == FRAUD_REVIEW
+      end
+
+      def parse(body)
+        fields = split(body)
+
+        results = {
+          :response_code => fields[RESPONSE_CODE].to_i,
+          :response_reason_code => fields[RESPONSE_REASON_CODE],
+          :response_reason_text => fields[RESPONSE_REASON_TEXT],
+          :avs_result_code => fields[AVS_RESULT_CODE],
+          :transaction_id => fields[TRANSACTION_ID],
+          :card_code => fields[CARD_CODE_RESPONSE_CODE],
+          :authorization_code => fields[AUTHORIZATION_CODE],
+          :cardholder_authentication_code => fields[CARDHOLDER_AUTH_CODE]
+        }
+        results
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+
+        post[:version]        = API_VERSION
+        post[:login]          = @options[:login]
+        post[:tran_key]       = @options[:password]
+        post[:relay_response] = "FALSE"
+        post[:type]           = action
+        post[:delim_data]     = "TRUE"
+        post[:delim_char]     = ","
+        post[:encap_char]     = "$"
+        post[:solution_ID]    = application_id if application_id
+
+        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+
+      def add_currency_code(post, money, options)
+        post[:currency_code] = options[:currency] || currency(money)
+      end
+
+      def add_invoice(post, options)
+        post[:invoice_num] = options[:order_id]
+        post[:description] = options[:description]
+      end
+
+      def add_creditcard(post, creditcard, options={})
+        post[:card_num]   = creditcard.number
+        post[:card_code]  = creditcard.verification_value if creditcard.verification_value?
+        post[:exp_date]   = expdate(creditcard)
+        post[:first_name] = creditcard.first_name
+        post[:last_name]  = creditcard.last_name
+      end
+
+      def add_payment_source(params, source, options={})
+        add_creditcard(params, source, options)
+      end
+
+      def add_customer_data(post, options)
+        if options.has_key? :email
+          post[:email] = options[:email]
+          post[:email_customer] = false
+        end
+
+        if options.has_key? :customer
+          post[:cust_id] = options[:customer] if Float(options[:customer]) rescue nil
+        end
+
+        if options.has_key? :ip
+          post[:customer_ip] = options[:ip]
+        end
+
+        if options.has_key? :cardholder_authentication_value
+          post[:cardholder_authentication_value] = options[:cardholder_authentication_value]
+        end
+
+        if options.has_key? :authentication_indicator
+          post[:authentication_indicator] = options[:authentication_indicator]
+        end
+      end
+
+      # x_duplicate_window won't be sent by default, because sending it changes the response.
+      # "If this field is present in the request with or without a value, an enhanced duplicate transaction response will be sent."
+      # (as of 2008-12-30) http://www.authorize.net/support/AIM_guide_SCC.pdf
+      def add_duplicate_window(post)
+        post[:duplicate_window] = duplicate_window if duplicate_window
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:address] = address[:address1].to_s
+          post[:company] = address[:company].to_s
+          post[:phone]   = address[:phone].to_s
+          post[:zip]     = address[:zip].to_s
+          post[:city]    = address[:city].to_s
+          post[:country] = address[:country].to_s
+          post[:state]   = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+
+        if address = options[:shipping_address]
+          post[:ship_to_first_name] = address[:first_name].to_s
+          post[:ship_to_last_name] = address[:last_name].to_s
+          post[:ship_to_address] = address[:address1].to_s
+          post[:ship_to_company] = address[:company].to_s
+          post[:ship_to_phone]   = address[:phone].to_s
+          post[:ship_to_zip]     = address[:zip].to_s
+          post[:ship_to_city]    = address[:city].to_s
+          post[:ship_to_country] = address[:country].to_s
+          post[:ship_to_state]   = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+      end
+
+      def message_from(results)
+        if results[:response_code] == DECLINED
+          return CVVResult.messages[ results[:card_code] ] if CARD_CODE_ERRORS.include?(results[:card_code])
+          if AVS_REASON_CODES.include?(results[:response_reason_code]) && AVS_ERRORS.include?(results[:avs_result_code])
+            return AVSResult.messages[ results[:avs_result_code] ]
+          end
+        end
+
+        (results[:response_reason_text] ? results[:response_reason_text].chomp('.') : '')
+      end
+
       def split(response)
         response.split(',')
       end

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

@@ -8,8 +8,8 @@ module ActiveMerchant #:nodoc:
 
       class_attribute :test_periodic_url, :live_periodic_url
 
-      self.test_url = 'https://www.securepay.com.au/test/payment'
-      self.live_url = 'https://www.securepay.com.au/xmlapi/payment'
+      self.test_url = 'https://api.securepay.com.au/test/payment'
+      self.live_url = 'https://api.securepay.com.au/xmlapi/payment'
 
       self.test_periodic_url = 'https://test.securepay.com.au/xmlapi/periodic'
       self.live_periodic_url = 'https://api.securepay.com.au/xmlapi/periodic'
@@ -85,7 +85,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, reference, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, reference)
       end
 
@@ -103,13 +103,27 @@ module ActiveMerchant #:nodoc:
         commit_periodic(build_periodic_item(:remove_triggered, options[:amount], nil, options))
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<merchantID>).+(</merchantID>)), '\1[FILTERED]\2').
+          gsub(%r((<password>).+(</password>)), '\1[FILTERED]\2').
+          gsub(%r((<cardNumber>).+(</cardNumber>)), '\1[FILTERED]\2').
+          gsub(%r((<cvv>).+(</cvv>)), '\1[FILTERED]\2')
+      end
+
       private
 
       def build_purchase_request(money, credit_card, options)
         xml = Builder::XmlMarkup.new
 
-        xml.tag! 'amount', amount(money)
-        xml.tag! 'currency', options[:currency] || currency(money)
+        currency = options[:currency] || currency(money)
+
+        xml.tag! 'amount', localized_amount(money, currency)
+        xml.tag! 'currency', currency
         xml.tag! 'purchaseOrderNo', options[:order_id].to_s.gsub(/[ ']/, '')
 
         xml.tag! 'CreditCardInfo' do
@@ -140,7 +154,7 @@ module ActiveMerchant #:nodoc:
         xml.instruct!
         xml.tag! 'SecurePayMessage' do
           xml.tag! 'MessageInfo' do
-            xml.tag! 'messageID', ActiveMerchant::Utils.generate_unique_id.slice(0, 30)
+            xml.tag! 'messageID', SecureRandom.hex(15)
             xml.tag! 'messageTimestamp', generate_timestamp
             xml.tag! 'timeoutValue', request_timeout
             xml.tag! 'apiVersion', API_VERSION
@@ -199,7 +213,7 @@ module ActiveMerchant #:nodoc:
         xml.instruct!
         xml.tag! 'SecurePayMessage' do
           xml.tag! 'MessageInfo' do
-            xml.tag! 'messageID', ActiveMerchant::Utils.generate_unique_id.slice(0, 30)
+            xml.tag! 'messageID', SecureRandom.hex(15)
             xml.tag! 'messageTimestamp', generate_timestamp
             xml.tag! 'timeoutValue', request_timeout
             xml.tag! 'apiVersion', PERIODIC_API_VERSION

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

@@ -99,13 +99,6 @@ module ActiveMerchant #:nodoc:
         post[:MerchantKey] = @options[:password]
         post.to_s
       end
-
-      def expdate(creditcard)
-        year = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
     end
   end
 end

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

@@ -0,0 +1,267 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SecurionPayGateway < Gateway
+      self.test_url = 'https://api.securionpay.com/'
+      self.live_url = 'https://api.securionpay.com/'
+
+
+      self.supported_countries = %w(AL AD AT BY BE BG HR CY CZ RE DK EE IS FI FR DE GI GR HU IS IE IT IL LV LI LT LU
+                                    MK MT MD MC NL NO PL PT RO RU MA RS SK SI ES SE CH UA GB KI CI ME)
+
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+
+      self.homepage_url = 'https://securionpay.com/'
+      self.display_name = 'SecurionPay'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        'incorrect_number' => STANDARD_ERROR_CODE[:incorrect_number],
+        'invalid_number' => STANDARD_ERROR_CODE[:invalid_number],
+        'invalid_expiry_month' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        'invalid_expiry_year' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        'invalid_cvc' => STANDARD_ERROR_CODE[:invalid_cvc],
+        'expired_card' => STANDARD_ERROR_CODE[:expired_card],
+        'insufficient_funds' => STANDARD_ERROR_CODE[:card_declined],
+        'incorrect_cvc' => STANDARD_ERROR_CODE[:incorrect_cvc],
+        'incorrect_zip' => STANDARD_ERROR_CODE[:incorrect_zip],
+        'card_declined' => STANDARD_ERROR_CODE[:card_declined],
+        'processing_error' => STANDARD_ERROR_CODE[:processing_error],
+        'lost_or_stolen' => STANDARD_ERROR_CODE[:card_declined],
+        'suspected_fraud' => STANDARD_ERROR_CODE[:card_declined],
+        'expired_token' => STANDARD_ERROR_CODE[:card_declined]
+      }
+
+      def initialize(options={})
+        requires!(options, :secret_key)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = create_post_for_auth_or_purchase(money, payment, options)
+        commit('charges', post, options)
+      end
+
+      def authorize(money, payment, options={})
+        post = create_post_for_auth_or_purchase(money, payment, options)
+        post[:captured] = "false"
+        commit('charges', post, options)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_amount(post, money, options)
+        commit("charges/#{CGI.escape(authorization)}/capture", post, options)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        add_amount(post, money, options)
+        commit("charges/#{CGI.escape(authorization)}/refund", post, options)
+      end
+
+      def void(authorization, options = {})
+        commit("charges/#{CGI.escape(authorization)}/refund", {}, options)
+      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(credit_card, options = {})
+        if options[:customer_id].blank?
+          MultiResponse.run() do |r|
+            #create charge object
+            r.process { authorize(100, credit_card, options) }
+            #create customer and save card
+            r.process { create_customer_add_card(r.authorization, options) }
+            #void the charge
+            r.process(:ignore_result) { void(r.params["metadata"]["chargeId"], options) }
+          end
+        else
+          verify(credit_card, options)
+        end
+      end
+
+      def customer(options = {})
+        if options[:customer_id].blank?
+          return nil
+        else
+          commit("customers/#{CGI.escape(options[:customer_id])}", nil, options, :get)
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((card\[number\]=)\d+), '\1[FILTERED]').
+          gsub(%r((card\[cvc\]=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def create_customer_add_card(authorization, options)
+        post = {}
+        post[:email] = options[:email]
+        post[:description] = options[:description]
+        post[:card] = authorization
+        post[:metadata] = {}
+        post[:metadata][:chargeId] = authorization
+        commit('customers', post, options)
+      end
+
+      def add_customer(post, payment, options)
+        post[:customerId] = options[:customer_id] if options[:customer_id]
+      end
+
+      def add_customer_data(post, options)
+        post[:description] = options[:description]
+        post[:ip] =          options[:ip]
+        post[:user_agent] =  options[:user_agent]
+        post[:referrer] =    options[:referrer]
+      end
+
+      def create_post_for_auth_or_purchase(money, payment, options)
+        post = {}
+        add_amount(post, money, options, true)
+        add_creditcard(post, payment, options)
+        add_customer(post, payment, options)
+        add_customer_data(post, options)
+        if options[:email]
+          post[:metadata] = {}
+          post[:metadata][:email] = options[:email]
+        end
+        post
+      end
+
+      def add_amount(post, money, options, include_currency = false)
+        currency = (options[:currency] || default_currency)
+        post[:amount] = localized_amount(money, currency)
+        post[:currency] = currency.downcase if include_currency
+      end
+
+      def add_creditcard(post, creditcard, options)
+        card = {}
+        if creditcard.respond_to?(:number)
+          card[:number] = creditcard.number
+          card[:expMonth] = creditcard.month
+          card[:expYear] = creditcard.year
+          card[:cvc] = creditcard.verification_value if creditcard.verification_value?
+          card[:cardholderName] = creditcard.name if creditcard.name
+
+          post[:card] = card
+          add_address(post, options)
+        elsif creditcard.kind_of?(String)
+          post[:card] = creditcard
+        else
+          raise ArgumentError.new("Unhandled payment method #{creditcard.class}.")
+        end
+      end
+
+      def add_address(post, options)
+        return unless post[:card] && post[:card].kind_of?(Hash)
+        if address = options[:billing_address]
+          post[:card][:addressLine1] = address[:address1] if address[:address1]
+          post[:card][:addressLine2] = address[:address2] if address[:address2]
+          post[:card][:addressCountry] = address[:country] if address[:country]
+          post[:card][:addressZip] = address[:zip] if address[:zip]
+          post[:card][:addressState] = address[:state] if address[:state]
+          post[:card][:addressCity] = address[:city] if address[:city]
+        end
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(url, parameters = nil, options = {}, method = nil)
+        response = api_request(url, parameters, options, method)
+        success = !response.key?("error")
+
+        Response.new(success,
+          (success ? "Transaction approved" : response["error"]["message"]),
+          response,
+          test: test?,
+          authorization: (success ? response["id"] : response["error"]["charge"]),
+          error_code: (success ? nil : STANDARD_ERROR_CODE_MAPPING[response["error"]["code"]])
+        )
+      end
+
+      def headers(options = {})
+        secret_key = options[:secret_key] || @options[:secret_key]
+
+        headers = {
+          "Authorization" => "Basic " + Base64.encode64(secret_key.to_s + ":").strip,
+          "User-Agent" => "SecurionPay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}"
+        }
+        headers
+      end
+
+      def response_error(raw_response)
+        begin
+          parse(raw_response)
+        rescue JSON::ParserError
+          json_error(raw_response)
+        end
+      end
+
+      def post_data(params)
+        return nil unless params
+
+        params.map do |key, value|
+          next if value.blank?
+          if value.is_a?(Hash)
+            h = {}
+            value.each do |k, v|
+              h["#{key}[#{k}]"] = v unless v.blank?
+            end
+            post_data(h)
+          elsif value.is_a?(Array)
+            value.map { |v| "#{key}[]=#{CGI.escape(v.to_s)}" }.join("&")
+          else
+            "#{key}=#{CGI.escape(value.to_s)}"
+          end
+        end.compact.join("&")
+      end
+
+      def api_request(endpoint, parameters = nil, options = {}, method = nil)
+        raw_response = response = nil
+        begin
+          if method.blank?
+            raw_response = ssl_post(self.live_url + endpoint, post_data(parameters), headers(options))
+          else
+            raw_response = ssl_request(method, self.live_url + endpoint, post_data(parameters), headers(options))
+          end
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = response_error(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+        response
+      end
+
+      def json_error(raw_response)
+        msg = 'Invalid response received from the SecurionPay API.'
+        msg += "  (The raw response returned by the API was #{raw_response.inspect})"
+        {
+          "error" => {
+            "message" => msg
+          }
+        }
+      end
+
+      def test?
+        (@options[:secret_key] && @options[:secret_key].include?('_test_'))
+      end
+    end
+  end
+end

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

@@ -46,7 +46,6 @@ module ActiveMerchant #:nodoc:
         "N" => "Neither street address nor zip/postal match billing information",
         "O" => "Non-US issuer does not participate",
         "P" => "Postal codes match for international transaction but street address not verified due to incompatible formats",
-        "P" => "Address verification not applicable for this transaction",
         "R" => "Payment gateway was unavailable or timed out",
         "S" => "Address verification service not supported by issuer",
         "U" => "Address information is unavailable",
@@ -195,7 +194,6 @@ module ActiveMerchant #:nodoc:
       end
 
       def purchase(money, creditcard, options = {})
-        post = {}
         authorization = authorize(money, creditcard, options)
         if authorization.success?
           capture(money, authorization.authorization)
@@ -240,7 +238,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
 

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

@@ -43,6 +43,7 @@ module ActiveMerchant #:nodoc:
         add_currency(post, money, options)
         add_taxes(post, options)
         add_processor(post, options)
+        add_eci(post, options)
         commit('sale', money, post)
       end
 
@@ -76,6 +77,12 @@ module ActiveMerchant #:nodoc:
         commit('refund', money, post)
       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
 
       # Update the values (such as CC expiration) stored at
       # the gateway.  The CC number must be supplied in the
@@ -207,6 +214,10 @@ module ActiveMerchant #:nodoc:
         post[:transactionid] = auth
       end
 
+      def add_eci(post, options)
+        post[:billing_method] = options[:eci] if options[:eci]
+      end
+
       def parse(body)
         results = {}
         body.split(/&/).each do |pair|
@@ -218,7 +229,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, money, parameters)
-        parameters[:amount]  = amount(money) if money
+        parameters[:amount]  = localized_amount(money, parameters[:currency] || default_currency) 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"] || response["customer_vault_id"]),
@@ -230,8 +241,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def expdate(creditcard)
-        year  = sprintf("%.04i", creditcard.year.to_i)
-        month = sprintf("%.02i", creditcard.month.to_i)
+        year  = sprintf("%.04i", creditcard.year)
+        month = sprintf("%.02i", creditcard.month)
 
         "#{month}#{year[-2..-1]}"
       end