activemerchant 1.45.0 → 1.126.0

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

@@ -6,22 +6,25 @@ module ActiveMerchant #:nodoc:
       self.live_na_url = 'https://www.iatspayments.com/NetGate'
       self.live_uk_url = 'https://www.uk.iatspayments.com/NetGate'
 
-      self.supported_countries = %w(AU BR CA CH DE DK ES FI FR GR HK IE IT NL NO PT SE SG TR GB US)
+      self.supported_countries = %w(AU BR CA CH DE DK ES FI FR GR HK IE IT NL NO PT SE SG TR GB US TH ID PH BE)
       self.default_currency = 'USD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = %i[visa master american_express discover]
 
       self.homepage_url = 'http://home.iatspayments.com/'
       self.display_name = 'iATS Payments'
 
       ACTIONS = {
-        purchase: "ProcessCreditCardV1",
-        refund: "ProcessCreditCardRefundWithTransactionIdV1",
-        store: "CreateCreditCardCustomerCodeV1",
-        unstore: "DeleteCustomerCodeV1"
+        purchase: 'ProcessCreditCard',
+        purchase_check: 'ProcessACHEFT',
+        purchase_customer_code: 'ProcessCreditCardWithCustomerCode',
+        refund: 'ProcessCreditCardRefundWithTransactionId',
+        refund_check: 'ProcessACHEFTRefundWithTransactionId',
+        store: 'CreateCreditCardCustomerCode',
+        unstore: 'DeleteCustomerCode'
       }
 
-      def initialize(options={})
-        if(options[:login])
+      def initialize(options = {})
+        if options[:login]
           ActiveMerchant.deprecated("The 'login' option is deprecated in favor of 'agent_code' and will be removed in a future version.")
           options[:agent_code] = options[:login]
         end
@@ -32,25 +35,27 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         post = {}
         add_invoice(post, money, options)
         add_payment(post, payment)
         add_address(post, options)
         add_ip(post, options)
         add_description(post, options)
+        add_customer_details(post, options)
 
-        commit(:purchase, post)
+        commit(determine_purchase_type(payment), post)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
-        post[:transaction_id] = authorization
+        transaction_id, payment_type = split_authorization(authorization)
+        post[:transaction_id] = transaction_id
         add_invoice(post, -money, options)
         add_ip(post, options)
         add_description(post, options)
 
-        commit(:refund, post)
+        commit((payment_type == 'check' ? :refund_check : :refund), post)
       end
 
       def store(credit_card, options = {})
@@ -72,19 +77,45 @@ module ActiveMerchant #:nodoc:
         commit(:unstore, post)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<agentCode>).+(</agentCode>)), '\1[FILTERED]\2').
+          gsub(%r((<password>).+(</password>)), '\1[FILTERED]\2').
+          gsub(%r((<creditCardNum>).+(</creditCardNum>)), '\1[FILTERED]\2').
+          gsub(%r((<cvv2>).+(</cvv2>)), '\1[FILTERED]\2').
+          gsub(%r((<accountNum>).+(</accountNum>)), '\1[FILTERED]\2')
+      end
+
       private
 
+      def determine_purchase_type(payment)
+        if payment.is_a?(String)
+          :purchase_customer_code
+        elsif payment.is_a?(Check)
+          :purchase_check
+        else
+          :purchase
+        end
+      end
+
       def add_ip(post, options)
         post[:customer_ip_address] = options[:ip] if options.has_key?(:ip)
       end
 
       def add_address(post, options)
         billing_address = options[:billing_address] || options[:address]
-        if(billing_address)
+        if billing_address
           post[:address] = billing_address[:address1]
           post[:city] = billing_address[:city]
           post[:state] = billing_address[:state]
           post[:zip_code] = billing_address[:zip]
+          post[:phone] = billing_address[:phone] if billing_address[:phone]
+          post[:email] = billing_address[:email] if billing_address[:email]
+          post[:country] = billing_address[:country] if billing_address[:country]
         end
       end
 
@@ -98,6 +129,16 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_payment(post, payment)
+        if payment.is_a?(String)
+          post[:customer_code] = payment
+        elsif payment.is_a?(Check)
+          add_check(post, payment)
+        else
+          add_credit_card(post, payment)
+        end
+      end
+
+      def add_credit_card(post, payment)
         post[:first_name] = payment.first_name
         post[:last_name] = payment.last_name
         post[:credit_card_num] = payment.number
@@ -106,6 +147,13 @@ module ActiveMerchant #:nodoc:
         post[:mop] = creditcard_brand(payment.brand)
       end
 
+      def add_check(post, payment)
+        post[:first_name] = payment.first_name
+        post[:last_name] = payment.last_name
+        post[:account_num] = "#{payment.routing_number}#{payment.account_number}"
+        post[:account_type] = payment.account_type.upcase
+      end
+
       def add_store_defaults(post)
         post[:recurring] = false
         post[:begin_date] = Time.now.xmlschema
@@ -113,20 +161,24 @@ module ActiveMerchant #:nodoc:
         post[:amount] = 0
       end
 
+      def add_customer_details(post, options)
+        post[:email] = options[:email] if options[:email]
+      end
+
       def expdate(creditcard)
-        year  = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
+        year  = sprintf('%.4i', creditcard.year)
+        month = sprintf('%.2i', creditcard.month)
 
         "#{month}/#{year[-2..-1]}"
       end
 
       def creditcard_brand(brand)
         case brand
-        when "visa" then "VISA"
-        when "master" then "MC"
-        when "discover" then "DSC"
-        when "american_express" then "AMX"
-        when "maestro" then "MAESTR"
+        when 'visa' then 'VISA'
+        when 'master' then 'MC'
+        when 'discover' then 'DSC'
+        when 'american_express' then 'AMX'
+        when 'maestro' then 'MAESTR'
         else
           raise "Unhandled credit card brand #{brand}"
         end
@@ -134,7 +186,7 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, parameters)
         response = parse(ssl_post(url(action), post_data(action, parameters),
-         { 'Content-Type' => 'application/soap+xml; charset=utf-8'}))
+          { 'Content-Type' => 'application/soap+xml; charset=utf-8' }))
 
         Response.new(
           success_from(response),
@@ -147,10 +199,13 @@ module ActiveMerchant #:nodoc:
 
       def endpoints
         {
-          purchase: "ProcessLink.asmx",
-          refund: "ProcessLink.asmx",
-          store: "CustomerLink.asmx",
-          unstore: "CustomerLink.asmx"
+          purchase: 'ProcessLinkv3.asmx',
+          purchase_check: 'ProcessLinkv3.asmx',
+          purchase_customer_code: 'ProcessLinkv3.asmx',
+          refund: 'ProcessLinkv3.asmx',
+          refund_check: 'ProcessLinkv3.asmx',
+          store: 'CustomerLinkv3.asmx',
+          unstore: 'CustomerLinkv3.asmx'
         }
       end
 
@@ -178,13 +233,13 @@ module ActiveMerchant #:nodoc:
       def hashify_xml!(xml, response)
         xml = REXML::Document.new(xml)
 
-        xml.elements.each("//IATSRESPONSE/*") do |node|
+        xml.elements.each('//IATSRESPONSE/*') do |node|
           recursively_parse_element(node, response)
         end
       end
 
       def recursively_parse_element(node, response)
-        if(node.has_elements?)
+        if node.has_elements?
           node.elements.each { |n| recursively_parse_element(n, response) }
         else
           response[dexmlize_param_name(node.name)] = (node.text ? node.text.strip : nil)
@@ -192,17 +247,17 @@ module ActiveMerchant #:nodoc:
       end
 
       def successful_result_message?(response)
-        response[:authorization_result].start_with?('OK')
+        response[:authorization_result] ? response[:authorization_result].start_with?('OK') : false
       end
 
       def success_from(response)
-        response[:status] == "Success" && successful_result_message?(response)
+        response[:status] == 'Success' && successful_result_message?(response)
       end
 
       def message_from(response)
-        if(!successful_result_message?(response))
+        if !successful_result_message?(response) && response[:authorization_result]
           return response[:authorization_result].strip
-        elsif(response[:status] == 'Failure')
+        elsif response[:status] == 'Failure'
           return response[:errors]
         else
           response[:status]
@@ -210,27 +265,33 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(action, response)
-        if [:store, :unstore].include?(action)
+        if %i[store unstore].include?(action)
           response[:customercode]
+        elsif [:purchase_check].include?(action)
+          response[:transaction_id] ? "#{response[:transaction_id]}|check" : nil
         else
           response[:transaction_id]
         end
       end
 
+      def split_authorization(authorization)
+        authorization.split('|')
+      end
+
       def envelope_namespaces
         {
-          "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
-          "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
-          "xmlns:soap12" => "http://www.w3.org/2003/05/soap-envelope"
+          'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+          'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+          'xmlns:soap12' => 'http://www.w3.org/2003/05/soap-envelope'
         }
       end
 
       def post_data(action, parameters = {})
         xml = Builder::XmlMarkup.new
-        xml.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
+        xml.instruct!(:xml, version: '1.0', encoding: 'utf-8')
         xml.tag! 'soap12:Envelope', envelope_namespaces do
           xml.tag! 'soap12:Body' do
-            xml.tag! ACTIONS[action], { "xmlns" => "https://www.iatspayments.com/NetGate/" } do
+            xml.tag! ACTIONS[action], { 'xmlns' => 'https://www.iatspayments.com/NetGate/' } do
               xml.tag!('agentCode', @options[:agent_code])
               xml.tag!('password', @options[:password])
               parameters.each do |name, value|

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

@@ -0,0 +1,15 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class InContextPaypalExpressGateway < PaypalExpressGateway
+      self.test_redirect_url = 'https://www.sandbox.paypal.com/checkoutnow'
+      self.live_redirect_url = 'https://www.paypal.com/checkoutnow'
+
+      def redirect_url_for(token, options = {})
+        options = { review: true }.update(options)
+        url  = "#{redirect_url}?token=#{token}"
+        url += '&useraction=commit' unless options[:review]
+        url
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module ActiveMerchant #:nodoc:
       self.live_url = self.test_url = 'https://secure.inspiregateway.net/api/transact.php'
 
       self.supported_countries = ['US']
-      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.supported_cardtypes = %i[visa master american_express]
       self.homepage_url = 'http://www.inspiregateway.com'
       self.display_name = 'Inspire Commerce'
 
@@ -17,7 +17,7 @@ module ActiveMerchant #:nodoc:
       # ==== Options
       #
       # * <tt>:login</tt> -- The Inspire Username.
-      # * <tt>:password</tt> -- The Inspire Passowrd.
+      # * <tt>:password</tt> -- The Inspire Password.
       # See the Inspire Integration Guide for details. (default: +false+)
       def initialize(options = {})
         requires!(options, :login, :password)
@@ -33,7 +33,7 @@ module ActiveMerchant #:nodoc:
       def authorize(money, creditcard, options = {})
         post = {}
         add_invoice(post, options)
-        add_payment_source(post, creditcard,options)
+        add_payment_source(post, creditcard, options)
         add_address(post, creditcard, options)
         add_customer_data(post, options)
 
@@ -51,23 +51,29 @@ module ActiveMerchant #:nodoc:
       end
 
       def capture(money, authorization, options = {})
-        post ={}
+        post = {}
         post[:transactionid] = authorization
         commit('capture', money, post)
       end
 
       def void(authorization, options = {})
-        post ={}
+        post = {}
         post[:transactionid] = authorization
         commit('void', nil, post)
       end
 
+      def refund(money, authorization, options = {})
+        post = {}
+        post[:transactionid] = authorization
+        commit('refund', money, post)
+      end
+
       # Update the values (such as CC expiration) stored at
       # InspireGateway.  The CC number must be supplied in the
       # CreditCard object.
       def update(vault_id, creditcard, options = {})
         post = {}
-        post[:customer_vault] = "update_customer"
+        post[:customer_vault] = 'update_customer'
         add_customer_vault_id(post, vault_id)
         add_creditcard(post, creditcard, options)
         add_address(post, creditcard, options)
@@ -78,7 +84,7 @@ module ActiveMerchant #:nodoc:
 
       def delete(vault_id)
         post = {}
-        post[:customer_vault] = "delete_customer"
+        post[:customer_vault] = 'delete_customer'
         add_customer_vault_id(post, vault_id)
         commit(nil, nil, post)
       end
@@ -87,32 +93,29 @@ module ActiveMerchant #:nodoc:
       # store and unstore need to be defined
       def store(creditcard, options = {})
         billing_id = options.delete(:billing_id).to_s || true
-        authorize(100, creditcard, options.merge(:store => billing_id))
+        authorize(100, creditcard, options.merge(store: billing_id))
       end
 
-      alias_method :unstore, :delete
+      alias unstore delete
 
       private
+
       def add_customer_data(post, options)
-        if options.has_key? :email
-          post[:email] = options[:email]
-        end
+        post[:email] = options[:email] if options.has_key? :email
 
-        if options.has_key? :ip
-          post[:ipaddress] = options[:ip]
-        end
+        post[:ipaddress] = options[:ip] if options.has_key? :ip
       end
 
       def add_address(post, creditcard, options)
         if address = options[:billing_address] || options[:address]
           post[:address1]    = address[:address1].to_s
           post[:address2]    = address[:address2].to_s unless address[:address2].blank?
-          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]
+          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
       end
 
@@ -121,7 +124,7 @@ module ActiveMerchant #:nodoc:
         post[:orderdescription] = options[:description]
       end
 
-      def add_payment_source(params, source, options={})
+      def add_payment_source(params, source, options = {})
         case determine_funding_source(source)
         when :vault       then add_customer_vault_id(params, source)
         when :credit_card then add_creditcard(params, source, options)
@@ -129,18 +132,18 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_customer_vault_id(params,vault_id)
+      def add_customer_vault_id(params, vault_id)
         params[:customer_vault_id] = vault_id
       end
 
-      def add_creditcard(post, creditcard,options)
+      def add_creditcard(post, creditcard, options)
         if options[:store]
-          post[:customer_vault] = "add_customer"
+          post[:customer_vault] = 'add_customer'
           post[:customer_vault_id] = options[:store] unless options[:store] == true
         end
-        post[:ccnumber]  = creditcard.number
+        post[:ccnumber] = creditcard.number
         post[:cvv] = creditcard.verification_value if creditcard.verification_value?
-        post[:ccexp]  = expdate(creditcard)
+        post[:ccexp] = expdate(creditcard)
         post[:firstname] = creditcard.first_name
         post[:lastname]  = creditcard.last_name
       end
@@ -157,7 +160,7 @@ module ActiveMerchant #:nodoc:
       def parse(body)
         results = {}
         body.split(/&/).each do |pair|
-          key,val = pair.split(/=/)
+          key, val = pair.split(%r{=})
           results[key] = val
         end
 
@@ -165,49 +168,46 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, money, parameters)
-        parameters[:amount]  = amount(money) if money
+        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"],
-          :test => test?,
-          :cvv_result => response["cvvresponse"],
-          :avs_result => { :code => response["avsresponse"] }
-        )
+        response = parse(ssl_post(self.live_url, post_data(action, parameters)))
 
+        Response.new(response['response'] == '1', message_from(response), response,
+          authorization: response['transactionid'],
+          test: test?,
+          cvv_result: response['cvvresponse'],
+          avs_result: { code: response['avsresponse'] })
       end
 
       def message_from(response)
-        case response["responsetext"]
-        when "SUCCESS","Approved"
-          "This transaction has been approved"
-        when "DECLINE"
-          "This transaction has been declined"
+        case response['responsetext']
+        when 'SUCCESS', 'Approved'
+          'This transaction has been approved'
+        when 'DECLINE'
+          'This transaction has been declined'
         else
-          response["responsetext"]
+          response['responsetext']
         end
       end
 
       def post_data(action, parameters = {})
         post = {}
-        post[:username]      = @options[:login]
+        post[:username]   = @options[:login]
         post[:password]   = @options[:password]
         post[:type]       = action if action
 
-        request = post.merge(parameters).map {|key,value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
+        request = post.merge(parameters).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
         request
       end
 
       def determine_funding_source(source)
         case
         when source.is_a?(String) then :vault
-        when CreditCard.card_companies.keys.include?(card_brand(source)) then :credit_card
+        when CreditCard.card_companies.include?(card_brand(source)) then :credit_card
         when card_brand(source) == 'check' then :check
-        else raise ArgumentError, "Unsupported funding source provided"
+        else raise ArgumentError, 'Unsupported funding source provided'
         end
       end
     end
   end
 end
-

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

@@ -8,7 +8,7 @@ module ActiveMerchant #:nodoc:
       self.money_format = :dollars
       self.default_currency = 'USD'
       # The card types supported by the payment gateway
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = %i[visa master american_express discover]
 
       # The homepage URL of the gateway
       self.homepage_url = 'http://www.instapayllc.com'
@@ -16,8 +16,8 @@ module ActiveMerchant #:nodoc:
       # The name of the gateway
       self.display_name = 'InstaPay'
 
-      SUCCESS         = "Accepted"
-      SUCCESS_MESSAGE = "The transaction has been approved"
+      SUCCESS         = 'Accepted'
+      SUCCESS_MESSAGE = 'The transaction has been approved'
 
       def initialize(options = {})
         requires!(options, :login)
@@ -66,7 +66,7 @@ module ActiveMerchant #:nodoc:
 
       def add_customer_data(post, options)
         post[:ci_email]       = options[:email]
-        post["ci_IP Address"] = options[:ip]
+        post['ci_IP Address'] = options[:ip]
       end
 
       def add_address(post, options)
@@ -140,24 +140,20 @@ module ActiveMerchant #:nodoc:
         data = ssl_post self.live_url, post_data(action, parameters)
         response = parse(data)
 
-        Response.new(response[:success] , response[:message], response,
-          :authorization => response[:transaction_id],
-          :avs_result => { :code => response[:avs_result] },
-          :cvv_result => response[:cvv_result]
-        )
+        Response.new(response[:success], response[:message], response,
+          authorization: response[:transaction_id],
+          avs_result: { code: response[:avs_result] },
+          cvv_result: response[:cvv_result])
       end
 
       def post_data(action, parameters = {})
         post = {}
         post[:acctid] = @options[:login]
-        if(@options[:password])
-          post[:merchantpin] = @options[:password]
-        end
+        post[:merchantpin] = @options[:password] if @options[:password]
         post[:action] = action
-        request = post.merge(parameters).collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request = post.merge(parameters).collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
         request
       end
     end
   end
 end
-