activemerchant 1.42.2 → 1.42.3

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

@@ -19,20 +19,23 @@ module ActiveMerchant #:nodoc:
         commit(request, options)
       end
 
-      def purchase(money, credit_card_or_reference, options = {})
-        request = build_sale_or_authorization_request(:purchase, money, credit_card_or_reference, options)
+      def purchase(money, funding_source, options = {})
+        request = build_sale_or_authorization_request(:purchase, money, funding_source, options)
 
         commit(request, options)
       end
 
-      def credit(money, identification_or_credit_card, options = {})
-        if identification_or_credit_card.is_a?(String)
+      def credit(money, funding_source, options = {})
+        if funding_source.is_a?(String)
           deprecated CREDIT_DEPRECATION_MESSAGE
           # Perform referenced credit
-          refund(money, identification_or_credit_card, options)
-        else
+          refund(money, funding_source, options)
+        elsif card_brand(funding_source) == 'check'
           # Perform non-referenced credit
-          request = build_credit_card_request(:credit, money, identification_or_credit_card, options)
+          request = build_check_request(:credit, money, funding_source, options)
+          commit(request, options)
+        else
+          request = build_credit_card_request(:credit, money, funding_source, options)
           commit(request, options)
         end
       end
@@ -76,11 +79,13 @@ module ActiveMerchant #:nodoc:
       end
 
       private
-      def build_sale_or_authorization_request(action, money, credit_card_or_reference, options)
-        if credit_card_or_reference.is_a?(String)
-          build_reference_sale_or_authorization_request(action, money, credit_card_or_reference, options)
+      def build_sale_or_authorization_request(action, money, funding_source, options)
+        if funding_source.is_a?(String)
+          build_reference_sale_or_authorization_request(action, money, funding_source, options)
+        elsif card_brand(funding_source) == 'check'
+          build_check_request(action, money, funding_source, options)
         else
-          build_credit_card_request(action, money, credit_card_or_reference, options)
+          build_credit_card_request(action, money, funding_source, options)
         end
       end
 
@@ -147,6 +152,31 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def build_check_request(action, money, check, options)
+        xml = Builder::XmlMarkup.new
+        xml.tag! TRANSACTIONS[action] do
+          xml.tag! 'PayData' do
+            xml.tag! 'Invoice' do
+              xml.tag! 'CustIP', options[:ip] unless options[:ip].blank?
+              xml.tag! 'InvNum', options[:order_id].to_s.gsub(/[^\w.]/, '') unless options[:order_id].blank?
+              xml.tag! 'Description', options[:description] unless options[:description].blank?
+              xml.tag! 'BillTo' do
+                xml.tag! 'Name', check.name
+              end
+              xml.tag! 'TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money)
+            end
+            xml.tag! 'Tender' do
+              xml.tag! 'ACH' do
+                xml.tag! 'AcctType', check.account_type == 'checking' ? 'C' : 'S'
+                xml.tag! 'AcctNum', check.account_number
+                xml.tag! 'ABA', check.routing_number
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
       def add_credit_card(xml, credit_card)
         xml.tag! 'Card' do
           xml.tag! 'CardType', credit_card_type(credit_card)

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

@@ -227,7 +227,7 @@ module ActiveMerchant #:nodoc:
       end
 
       # The options hash may contain optional data which will be passed
-      # through the the specialized optional fields at PaymentExpress
+      # through the specialized optional fields at PaymentExpress
       # as follows:
       #
       #     {

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

@@ -67,7 +67,7 @@ module ActiveMerchant #:nodoc:
           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, {})
+          return Response.new(false, response_message(parsed), parsed, {})
         end
 
         response_from(raw_response)
@@ -75,13 +75,13 @@ module ActiveMerchant #:nodoc:
 
       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)
+        succeeded = (parsed['data'] == []) || (parsed['data']['response_code'] == 20000)
+        Response.new(succeeded, response_message(parsed), parsed, options)
       end
 
       def authorization_from(parsed_response)
@@ -175,6 +175,58 @@ module ActiveMerchant #:nodoc:
         authorization.split(';').first
       end
 
+      RESPONSE_CODES = {
+        10001 => "General undefined response.",
+        10002 => "Still waiting on something.",
+
+        20000 => "General success response.",
+
+        40000 => "General problem with data.",
+        40001 => "General problem with payment data.",
+        40100 => "Problem with credit card data.",
+        40101 => "Problem with cvv.",
+        40102 => "Card expired or not yet valid.",
+        40103 => "Limit exceeded.",
+        40104 => "Card invalid.",
+        40105 => "Expiry date not valid.",
+        40106 => "Credit card brand required.",
+        40200 => "Problem with bank account data.",
+        40201 => "Bank account data combination mismatch.",
+        40202 => "User authentication failed.",
+        40300 => "Problem with 3d secure data.",
+        40301 => "Currency / amount mismatch",
+        40400 => "Problem with input data.",
+        40401 => "Amount too low or zero.",
+        40402 => "Usage field too long.",
+        40403 => "Currency not allowed.",
+
+        50000 => "General problem with backend.",
+        50001 => "Country blacklisted.",
+        50100 => "Technical error with credit card.",
+        50101 => "Error limit exceeded.",
+        50102 => "Card declined by authorization system.",
+        50103 => "Manipulation or stolen card.",
+        50104 => "Card restricted.",
+        50105 => "Invalid card configuration data.",
+        50200 => "Technical error with bank account.",
+        50201 => "Card blacklisted.",
+        50300 => "Technical error with 3D secure.",
+        50400 => "Decline because of risk issues.",
+        50500 => "General timeout.",
+        50501 => "Timeout on side of the acquirer.",
+        50502 => "Risk management transaction timeout.",
+        50600 => "Duplicate transaction."
+      }
+
+      def response_message(parsed_response)
+        return parsed_response["error"] if parsed_response["error"]
+        return "Transaction approved." if (parsed_response['data'] == [])
+
+        code = parsed_response["data"]["response_code"]
+        RESPONSE_CODES[code] || code.to_s
+      end
+
+
       class ResponseParser
         def initialize(raw_response="", options={})
           @raw_response = raw_response

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

@@ -242,7 +242,7 @@ module ActiveMerchant #:nodoc:
         commit 'DoAuthorization', build_do_authorize(transaction_id, money, options)
       end
 
-      # The ManagePendingTransactionStatus API operation accepts or denys a
+      # The ManagePendingTransactionStatus API operation accepts or denies a
       # pending transaction held by Fraud Management Filters.
       #
       # ==== Parameters:

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

@@ -0,0 +1,171 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayscoutGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.payscout.com/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.default_currency = 'USD'
+      self.homepage_url = 'http://www.payscout.com/'
+      self.display_name = 'Payscout'
+
+      self.ssl_version = 'SSLv3'
+
+      def initialize(options = {})
+        requires!(options, :username, :password)
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_currency(post, money, options)
+        add_address(post, options)
+
+        commit('auth', money, post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_currency(post, money, options)
+        add_address(post, options)
+
+        commit('sale', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post[:transactionid] = authorization
+
+        commit('capture', money, post)
+      end
+
+
+      def refund(money, authorization, options = {})
+        post = {}
+        post[:transactionid] = authorization
+
+        commit('refund', money, post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        post[:transactionid] = authorization
+
+        commit('void', nil, post)
+      end
+
+      private
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:address1] = address[:address1].to_s
+          post[:address2] = address[:address2].to_s
+          post[:city]     = address[:city].to_s
+          post[:state]    = (address[:state].blank?  ? 'n/a' : address[:state])
+          post[:zip]      = address[:zip].to_s
+          post[:country]  = address[:country].to_s
+          post[:phone]    = address[:phone].to_s
+          post[:fax]      = address[:fax].to_s
+          post[:email]    = address[:email].to_s
+        end
+
+        if address = options[:shipping_address]
+          post[:shipping_firstname] = address[:first_name].to_s
+          post[:shipping_lastname]  = address[:last_name].to_s
+          post[:shipping_company]   = address[:company].to_s
+          post[:shipping_address1]  = address[:address1].to_s
+          post[:shipping_address2]  = address[:address2].to_s
+          post[:shipping_city]      = address[:city].to_s
+          post[:shipping_country]   = address[:country].to_s
+          post[:shipping_state]     = (address[:state].blank?  ? 'n/a' : address[:state])
+          post[:shipping_zip]       = address[:zip].to_s
+          post[:shipping_email]     = address[:email].to_s
+        end
+      end
+
+      def add_currency(post, money, options)
+        post[:currency] = options[:currency] || currency(money)
+      end
+
+      def add_invoice(post, options)
+        post[:orderdescription] = options[:description]
+        post[:orderid]          = options[:order_id]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:ccnumber]  = creditcard.number
+        post[:cvv]       = creditcard.verification_value if creditcard.verification_value?
+        post[:ccexp]     = expdate(creditcard)
+        post[:firstname] = creditcard.first_name
+        post[:lastname]  = creditcard.last_name
+      end
+
+      def parse(body)
+        Hash[body.split('&').map{|x|x.split('=')}]
+      end
+
+      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)
+        test_mode = (test? || message =~ /TESTMODE/)
+        Response.new(success?(response), message, response,
+          :test => test_mode,
+          :authorization => response['transactionid'],
+          :fraud_review => fraud_review?(response),
+          :avs_result => { :code => response['avsresponse'] },
+          :cvv_result => response['cvvresponse']
+        )
+      end
+
+      def message_from(response)
+        case response['response']
+        when '1'
+          'The transaction has been approved'
+        when '2'
+          'The transaction has been declined'
+        when '3'
+          response['responsetext']
+        else
+          'There was an error processing the transaction'
+        end
+      end
+
+      def fraud_review?(response)
+        false
+      end
+
+      def success?(response)
+        (response['response'] == '1')
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+
+        post[:username]       = @options[:username]
+        post[:password]       = @options[:password]
+        post[:type]           = action
+
+        request = post.merge(parameters).collect { |key, value| "#{key}=#{URI.escape(value.to_s)}" }.join("&")
+        request
+      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/pin.rb

@@ -90,7 +90,7 @@ module ActiveMerchant #:nodoc:
             :expiry_month => creditcard.month,
             :expiry_year => creditcard.year,
             :cvc => creditcard.verification_value,
-            :name => "#{creditcard.first_name} #{creditcard.last_name}"
+            :name => creditcard.name
           )
         elsif creditcard.kind_of?(String)
           if creditcard =~ /^card_/

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

@@ -12,7 +12,7 @@ module ActiveMerchant
     # login - The unique id of the merchant
     # password - The secret is used to digitally sign the request
     # account - This is an optional third part of the authentication process
-    # and is used if the merchant wishes do distuinguish cc traffic from the different sources
+    # and is used if the merchant wishes do distinguish cc traffic from the different sources
     # by using a different account. This must be created in advance
     #
     # the Realex team decided to make the orderid unique per request,

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

@@ -49,7 +49,7 @@ module ActiveMerchant #:nodoc:
       self.default_currency    = 'EUR'
       self.money_format        = :cents
 
-      # Not all card types may be actived by the bank!
+      # Not all card types may be activated by the bank!
       self.supported_cardtypes = [:visa, :master, :american_express, :jcb, :diners_club]
 
       # Homepage URL of the gateway for reference

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

@@ -0,0 +1,194 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SoEasyPayGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.soeasypay.com/gateway.asmx'
+      self.money_format = :cents
+
+      self.supported_countries = [
+        'US', 'CA', 'AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE',
+        'FI', 'FR', 'DE', 'GR', 'HU', 'IE', 'IT', 'LV', 'LT', 'LU',
+        'MT', 'NL', 'PL', 'PT', 'RO', 'SK', 'SI', 'ES', 'SE', 'GB',
+        'IS', 'NO', 'CH'
+      ]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :maestro, :jcb, :solo, :diners_club]
+      self.homepage_url = 'http://www.soeasypay.com/'
+      self.display_name = 'SoEasyPay'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, payment_source, options = {})
+        if payment_source.respond_to?(:number)
+          commit('AuthorizeTransaction', do_authorization(money, payment_source, options), options)
+        else
+          commit('ReauthorizeTransaction', do_reauthorization(money, payment_source, options), options)
+        end
+      end
+
+      def purchase(money, payment_source, options = {})
+        if payment_source.respond_to?(:number)
+          commit('SaleTransaction', do_sale(money, payment_source, options), options)
+        else
+          commit('RebillTransaction', do_rebill(money, payment_source, options), options)
+        end
+      end
+
+      def capture(money, authorization, options = {})
+        commit('CaptureTransaction', do_capture(money, authorization, options), options)
+      end
+
+      def refund(money, authorization, options={})
+        commit('RefundTransaction', do_refund(money, authorization, options), options)
+      end
+
+      def void(authorization, options={})
+        commit('CancelTransaction', do_void(authorization, options), options)
+      end
+
+      private
+
+      def do_authorization(money, card, options)
+        build_soap('AuthorizeTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_cardholder(soap, card, options)
+          fill_card(soap, card)
+        end
+      end
+
+      def do_sale(money, card, options)
+        build_soap('SaleTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_cardholder(soap, card, options)
+          fill_card(soap, card)
+        end
+      end
+
+      def do_reauthorization(money, authorization, options)
+        build_soap('ReauthorizeTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_rebill(money, authorization, options)
+        build_soap('RebillTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_capture(money, authorization, options)
+        build_soap('CaptureTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options, :no_currency)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_refund(money, authorization, options)
+        build_soap('RefundTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options, :no_currency)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_void(authorization, options)
+        build_soap('CancelTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def fill_credentials(soap, options)
+        soap.tag!('websiteID', @options[:login].to_s)
+        soap.tag!('password', @options[:password].to_s)
+      end
+
+      def fill_cardholder(soap, card, options)
+        ch_info = options[:billing_address] || options[:address]
+
+        soap.tag!('customerIP',options[:ip].to_s)
+        name = card.name || ch_info[:name]
+        soap.tag!('cardHolderName', name.to_s)
+        address = ch_info[:address1] || ''
+        address << ch_info[:address2] if ch_info[:address2]
+        soap.tag!('cardHolderAddress', address.to_s)
+        soap.tag!('cardHolderZipcode', ch_info[:zip].to_s)
+        soap.tag!('cardHolderCity', ch_info[:city].to_s)
+        soap.tag!('cardHolderState', ch_info[:state].to_s)
+        soap.tag!('cardHolderCountryCode', ch_info[:country].to_s)
+        soap.tag!('cardHolderPhone', ch_info[:phone].to_s)
+        soap.tag!('cardHolderEmail', options[:email].to_s)
+      end
+
+      def fill_transaction_id(soap, transaction_id)
+        soap.tag!('transactionID', transaction_id.to_s)
+      end
+
+      def fill_card(soap, card)
+        soap.tag!('cardNumber', card.number.to_s)
+        soap.tag!('cardSecurityCode', card.verification_value.to_s)
+        soap.tag!('cardExpireMonth', card.month.to_s.rjust(2, "0"))
+        soap.tag!('cardExpireYear', card.year.to_s)
+      end
+
+      def fill_order_info(soap, money, options, skip_currency=false)
+        soap.tag!('orderID', options[:order_id].to_s)
+        soap.tag!('orderDescription', "Order #{options[:order_id]}")
+        soap.tag!('amount', amount(money).to_s)
+        soap.tag!('currency', (options[:currency] || currency(money)).to_s) unless skip_currency
+      end
+
+      def parse(response, action)
+        result = {}
+        document = REXML::Document.new(response)
+        response_element = document.root.get_elements("//[@xsi:type='tns:#{action}Response']").first
+        response_element.elements.each do |element|
+          result[element.name.underscore] = element.text
+        end
+        result
+      end
+
+      def commit(soap_action, soap, options)
+        headers = {"SOAPAction" => "\"urn:Interface##{soap_action}\"",
+                   "Content-Type" => "text/xml; charset=utf-8"}
+        response_string = ssl_post(test? ? self.test_url : self.live_url, soap, headers)
+        response = parse(response_string, soap_action)
+        return Response.new(response['errorcode'] == '000',
+                            response['errormessage'],
+                            response,
+                            :test => test?,
+                            :authorization => response['transaction_id'])
+      end
+
+      def build_soap(request)
+        retval = Builder::XmlMarkup.new(:indent => 2)
+        retval.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
+        retval.tag!('soap:Envelope', {
+            'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+            'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+            'xmlns:soapenc' => 'http://schemas.xmlsoap.org/soap/encoding/',
+            'xmlns:tns' => 'urn:Interface',
+            'xmlns:types' => 'urn:Interface/encodedTypes',
+            'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/'}) do
+          retval.tag!('soap:Body', {'soap:encodingStyle'=>'http://schemas.xmlsoap.org/soap/encoding/'}) do
+            retval.tag!("tns:#{request}") do
+              retval.tag!("#{request}Request", {'xsi:type'=>"tns:#{request}Request"}) do
+                yield retval
+              end
+            end
+          end
+        end
+        retval.target!
+      end
+
+    end
+  end
+end