activemerchant 1.42.6 → 1.90.0

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

@@ -1,34 +1,289 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    class IatsPaymentsGateway < AuthorizeNetGateway
-      self.live_url = self.test_url = 'https://www.iatspayments.com/netgate/AEGateway.aspx'
+    class IatsPaymentsGateway < Gateway
+      class_attribute :live_na_url, :live_uk_url
 
-      self.homepage_url = 'http://www.iatspayments.com/'
-      self.display_name = 'IATSPayments'
+      self.live_na_url = 'https://www.iatspayments.com/NetGate'
+      self.live_uk_url = 'https://www.uk.iatspayments.com/NetGate'
 
-      def authorize(money, paysource, options = {})
-        raise NotImplementedError
+      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.homepage_url = 'http://home.iatspayments.com/'
+      self.display_name = 'iATS Payments'
+
+      ACTIONS = {
+        purchase: 'ProcessCreditCardV1',
+        purchase_check: 'ProcessACHEFTV1',
+        refund: 'ProcessCreditCardRefundWithTransactionIdV1',
+        refund_check: 'ProcessACHEFTRefundWithTransactionIdV1',
+        store: 'CreateCreditCardCustomerCodeV1',
+        unstore: 'DeleteCustomerCodeV1'
+      }
+
+      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
+
+        options[:region] = 'na' unless options[:region]
+
+        requires!(options, :agent_code, :password, :region)
+        super
       end
 
-      def capture(money, authorization, options = {})
-        raise NotImplementedError
+      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)
+
+        commit((payment.is_a?(Check) ? :purchase_check : :purchase), post)
       end
 
-      def void(authorization, options = {})
-        raise NotImplementedError
+      def refund(money, authorization, options={})
+        post = {}
+        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((payment_type == 'check' ? :refund_check : :refund), post)
       end
 
-      def refund(money, identification, options = {})
-        raise NotImplementedError
+      def store(credit_card, options = {})
+        post = {}
+        add_payment(post, credit_card)
+        add_address(post, options)
+        add_ip(post, options)
+        add_description(post, options)
+        add_store_defaults(post)
+
+        commit(:store, post)
       end
 
-      def credit(money, identification, options = {})
-        raise NotImplementedError
+      def unstore(authorization, options = {})
+        post = {}
+        post[:customer_code] = authorization
+        add_ip(post, options)
+
+        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 split(response)
-        response.split(',')
+
+      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)
+          post[:address] = billing_address[:address1]
+          post[:city] = billing_address[:city]
+          post[:state] = billing_address[:state]
+          post[:zip_code] = billing_address[:zip]
+        end
+      end
+
+      def add_invoice(post, money, options)
+        post[:invoice_num] = options[:order_id] if options[:order_id]
+        post[:total] = amount(money)
+      end
+
+      def add_description(post, options)
+        post[:comment] = options[:description] if options[:description]
+      end
+
+      def add_payment(post, payment)
+        if 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
+        post[:credit_card_expiry] = expdate(payment)
+        post[:cvv2] = payment.verification_value if payment.verification_value?
+        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
+        post[:end_date] = Time.now.xmlschema
+        post[:amount] = 0
+      end
+
+      def expdate(creditcard)
+        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'
+        else
+          raise "Unhandled credit card brand #{brand}"
+        end
+      end
+
+      def commit(action, parameters)
+        response = parse(ssl_post(url(action), post_data(action, parameters),
+          { 'Content-Type' => 'application/soap+xml; charset=utf-8'}))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(action, response),
+          test: test?
+        )
+      end
+
+      def endpoints
+        {
+          purchase: 'ProcessLink.asmx',
+          purchase_check: 'ProcessLink.asmx',
+          refund: 'ProcessLink.asmx',
+          refund_check: 'ProcessLink.asmx',
+          store: 'CustomerLink.asmx',
+          unstore: 'CustomerLink.asmx'
+        }
+      end
+
+      def url(action)
+        base_url = @options[:region] == 'uk' ? live_uk_url : live_na_url
+        "#{base_url}/#{endpoints[action]}?op=#{ACTIONS[action]}"
+      end
+
+      def parse(body)
+        response = {}
+        hashify_xml!(body, response)
+        response
+      end
+
+      def dexmlize_param_name(name)
+        names = {
+          'AUTHORIZATIONRESULT' => :authorization_result,
+          'SETTLEMENTBATCHDATE' => :settlement_batch_date,
+          'SETTLEMENTDATE' => :settlement_date,
+          'TRANSACTIONID' => :transaction_id
+        }
+        names[name] || name.to_s.downcase.intern
+      end
+
+      def hashify_xml!(xml, response)
+        xml = REXML::Document.new(xml)
+
+        xml.elements.each('//IATSRESPONSE/*') do |node|
+          recursively_parse_element(node, response)
+        end
+      end
+
+      def recursively_parse_element(node, response)
+        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)
+        end
+      end
+
+      def successful_result_message?(response)
+        response[:authorization_result] ? response[:authorization_result].start_with?('OK') : false
+      end
+
+      def success_from(response)
+        response[:status] == 'Success' && successful_result_message?(response)
+      end
+
+      def message_from(response)
+        if !successful_result_message?(response) && response[:authorization_result]
+          return response[:authorization_result].strip
+        elsif(response[:status] == 'Failure')
+          return response[:errors]
+        else
+          response[:status]
+        end
+      end
+
+      def authorization_from(action, response)
+        if [: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'
+        }
+      end
+
+      def post_data(action, parameters = {})
+        xml = Builder::XmlMarkup.new
+        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!('agentCode', @options[:agent_code])
+              xml.tag!('password', @options[:password])
+              parameters.each do |name, value|
+                xml.tag!(xmlize_param_name(name), value)
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def xmlize_param_name(name)
+        names = { customer_ip_address: 'customerIPAddress' }
+        names[name] || name.to_s.camelcase(:lower)
       end
     end
   end

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

@@ -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)
 
@@ -62,12 +62,18 @@ module ActiveMerchant #:nodoc:
         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
@@ -93,6 +99,7 @@ module ActiveMerchant #:nodoc:
       alias_method :unstore, :delete
 
       private
+
       def add_customer_data(post, options)
         if options.has_key? :email
           post[:email] = options[:email]
@@ -129,13 +136,13 @@ 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
@@ -157,7 +164,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
 
@@ -167,33 +174,24 @@ module ActiveMerchant #:nodoc:
       def commit(action, money, parameters)
         parameters[:amount]  = amount(money) if money
 
-        response = parse( ssl_post(self.live_url, post_data(action,parameters)) )
+        response = parse(ssl_post(self.live_url, post_data(action, parameters)))
 
-        Response.new(response["response"] == "1", message_from(response), response,
-          :authorization => response["transactionid"],
+        Response.new(response['response'] == '1', message_from(response), response,
+          :authorization => response['transactionid'],
           :test => test?,
-          :cvv_result => response["cvvresponse"],
-          :avs_result => { :code => response["avsresponse"] }
+          :cvv_result => response['cvvresponse'],
+          :avs_result => { :code => response['avsresponse'] }
         )
-
       end
 
-      def expdate(creditcard)
-        year  = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-
-        "#{month}#{year[-2..-1]}"
-      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
 
@@ -203,19 +201,18 @@ module ActiveMerchant #:nodoc:
         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

@@ -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,7 +140,7 @@ module ActiveMerchant #:nodoc:
         data = ssl_post self.live_url, post_data(action, parameters)
         response = parse(data)
 
-        Response.new(response[:success] , response[:message], response,
+        Response.new(response[:success], response[:message], response,
           :authorization => response[:transaction_id],
           :avs_result => { :code => response[:avs_result] },
           :cvv_result => response[:cvv_result]
@@ -154,10 +154,9 @@ module ActiveMerchant #:nodoc:
           post[:merchantpin] = @options[:password]
         end
         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
-

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

@@ -0,0 +1,175 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class IppGateway < Gateway
+      self.live_url = 'https://www.ippayments.com.au/interface/api/dts.asmx'
+      self.test_url = 'https://demo.ippayments.com.au/interface/api/dts.asmx'
+
+      self.supported_countries = ['AU']
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
+
+      self.homepage_url = 'http://www.ippayments.com.au/'
+      self.display_name = 'IPP'
+
+      self.money_format = :cents
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '05' => STANDARD_ERROR_CODE[:card_declined],
+        '06' => STANDARD_ERROR_CODE[:processing_error],
+        '14' => STANDARD_ERROR_CODE[:invalid_number],
+        '54' => STANDARD_ERROR_CODE[:expired_card],
+      }
+
+      def initialize(options={})
+        requires!(options, :username, :password)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        commit('SubmitSinglePayment') do |xml|
+          xml.Transaction do
+            xml.CustRef options[:order_id]
+            add_amount(xml, money)
+            xml.TrnType '1'
+            add_credit_card(xml, payment)
+            add_credentials(xml)
+            xml.TrnSource options[:ip]
+          end
+        end
+      end
+
+      def authorize(money, payment, options={})
+        commit('SubmitSinglePayment') do |xml|
+          xml.Transaction do
+            xml.CustRef options[:order_id]
+            add_amount(xml, money)
+            xml.TrnType '2'
+            add_credit_card(xml, payment)
+            add_credentials(xml)
+            xml.TrnSource options[:ip]
+          end
+        end
+      end
+
+      def capture(money, authorization, options={})
+        commit('SubmitSingleCapture') do |xml|
+          xml.Capture do
+            xml.Receipt authorization
+            add_amount(xml, money)
+            add_credentials(xml)
+          end
+        end
+      end
+
+      def refund(money, authorization, options={})
+        commit('SubmitSingleRefund') do |xml|
+          xml.Refund do
+            xml.Receipt authorization
+            add_amount(xml, money)
+            add_credentials(xml)
+          end
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<CardNumber>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<CVN>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<Password>)[^<]+(<))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_credentials(xml)
+        xml.Security do
+          xml.UserName @options[:username]
+          xml.Password @options[:password]
+        end
+      end
+
+      def add_amount(xml, money)
+        xml.Amount amount(money)
+      end
+
+      def add_credit_card(xml, payment)
+        xml.CreditCard :Registered => 'False' do
+          xml.CardNumber payment.number
+          xml.ExpM format(payment.month, :two_digits)
+          xml.ExpY format(payment.year, :four_digits)
+          xml.CVN payment.verification_value
+          xml.CardHolderName payment.name
+        end
+      end
+
+      def parse(body)
+        element = Nokogiri::XML(body).root.first_element_child.first_element_child
+
+        response = {}
+        doc = Nokogiri::XML(element)
+        doc.root.elements.each do |e|
+          response[e.name.underscore.to_sym] = e.inner_text
+        end
+        response
+      end
+
+      def commit(action, &block)
+        headers = {
+          'Content-Type' => 'text/xml; charset=utf-8',
+          'SOAPAction' => "http://www.ippayments.com.au/interface/api/dts/#{action}",
+        }
+        response = parse(ssl_post(commit_url, new_submit_xml(action, &block), headers))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          error_code: error_code_from(response),
+          test: test?
+        )
+      end
+
+      def new_submit_xml(action)
+        xml = Builder::XmlMarkup.new(indent: 2)
+        xml.instruct!
+        xml.soap :Envelope, 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance', 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema', 'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/' do
+          xml.soap :Body do
+            xml.__send__(action, 'xmlns' => 'http://www.ippayments.com.au/interface/api/dts') do
+              xml.trnXML do
+                inner_xml = Builder::XmlMarkup.new(indent: 2)
+                yield(inner_xml)
+                xml.cdata!(inner_xml.target!)
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def commit_url
+        (test? ? test_url : live_url)
+      end
+
+      def success_from(response)
+        (response[:response_code] == '0')
+      end
+
+      def error_code_from(response)
+        STANDARD_ERROR_CODE_MAPPING[response[:declined_code]]
+      end
+
+      def message_from(response)
+        response[:declined_message]
+      end
+
+      def authorization_from(response)
+        response[:receipt]
+      end
+    end
+  end
+end