activemerchant 1.38.0 → 1.78.0

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

@@ -0,0 +1,305 @@
+require "nokogiri"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class HpsGateway < Gateway
+      self.live_url = 'https://posgateway.secureexchange.net/Hps.Exchange.PosGateway/PosGatewayService.asmx?wsdl'
+      self.test_url = 'https://posgateway.cert.secureexchange.net/Hps.Exchange.PosGateway/PosGatewayService.asmx?wsdl'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jbc, :diners_club]
+
+      self.homepage_url = 'http://developer.heartlandpaymentsystems.com/SecureSubmit/'
+      self.display_name = 'Heartland Payment Systems'
+
+      self.money_format = :dollars
+
+      def initialize(options={})
+        requires!(options, :secret_api_key)
+        super
+      end
+
+      def authorize(money, card_or_token, options={})
+        commit('CreditAuth') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_customer_data(xml, card_or_token, options)
+          add_details(xml, options)
+          add_descriptor_name(xml, options)
+          add_payment(xml, card_or_token, options)
+        end
+      end
+
+      def capture(money, transaction_id, options={})
+        commit('CreditAddToBatch') do |xml|
+          add_amount(xml, money)
+          add_reference(xml, transaction_id)
+        end
+      end
+
+      def purchase(money, card_or_token, options={})
+        commit('CreditSale') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_customer_data(xml, card_or_token,options)
+          add_details(xml, options)
+          add_descriptor_name(xml, options)
+          add_payment(xml, card_or_token, options)
+        end
+      end
+
+      def refund(money, transaction_id, options={})
+        commit('CreditReturn') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_reference(xml, transaction_id)
+          add_customer_data(xml, transaction_id,options)
+          add_details(xml, options)
+        end
+      end
+
+      def verify(card_or_token, options={})
+        commit('CreditAccountVerify') do |xml|
+          add_customer_data(xml, card_or_token, options)
+          add_descriptor_name(xml, options)
+          add_payment(xml, card_or_token, options)
+        end
+      end
+
+      def void(transaction_id, options={})
+        commit('CreditVoid') do |xml|
+          add_reference(xml, transaction_id)
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<hps:CardNbr>)[^<]*(<\/hps:CardNbr>))i, '\1[FILTERED]\2').
+          gsub(%r((<hps:CVV2>)[^<]*(<\/hps:CVV2>))i, '\1[FILTERED]\2').
+          gsub(%r((<hps:SecretAPIKey>)[^<]*(<\/hps:SecretAPIKey>))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_reference(xml, transaction_id)
+        xml.hps :GatewayTxnId, transaction_id
+      end
+
+      def add_amount(xml, money)
+        xml.hps :Amt, amount(money) if money
+      end
+
+      def add_customer_data(xml, credit_card, options)
+        xml.hps :CardHolderData do
+          if credit_card.respond_to?(:number)
+            xml.hps :CardHolderFirstName, credit_card.first_name if credit_card.first_name
+            xml.hps :CardHolderLastName, credit_card.last_name if credit_card.last_name
+          end
+
+          xml.hps :CardHolderEmail, options[:email] if options[:email]
+          xml.hps :CardHolderPhone, options[:phone] if options[:phone]
+
+          if(billing_address = (options[:billing_address] || options[:address]))
+            xml.hps :CardHolderAddr, billing_address[:address1] if billing_address[:address1]
+            xml.hps :CardHolderCity, billing_address[:city] if billing_address[:city]
+            xml.hps :CardHolderState, billing_address[:state] if billing_address[:state]
+            xml.hps :CardHolderZip, billing_address[:zip] if billing_address[:zip]
+          end
+        end
+      end
+
+      def add_payment(xml, card_or_token, options)
+        xml.hps :CardData do
+          if card_or_token.respond_to?(:number)
+            if card_or_token.track_data
+              xml.tag!("hps:TrackData", 'method'=>'swipe') do
+                xml.text! card_or_token.track_data
+              end
+              if options[:encryption_type]
+                xml.hps :EncryptionData do
+                  xml.hps :Version, options[:encryption_type]
+                  if options[:encryption_type] == '02'
+                    xml.hps :EncryptedTrackNumber, options[:encrypted_track_number]
+                    xml.hps :KTB, options[:ktb]
+                  end
+                end
+              end
+            else
+              xml.hps :ManualEntry do
+                xml.hps :CardNbr, card_or_token.number
+                xml.hps :ExpMonth, card_or_token.month
+                xml.hps :ExpYear, card_or_token.year
+                xml.hps :CVV2, card_or_token.verification_value if card_or_token.verification_value
+                xml.hps :CardPresent, 'N'
+                xml.hps :ReaderPresent, 'N'
+              end
+            end
+          else
+            xml.hps :TokenData do
+              xml.hps :TokenValue, card_or_token
+            end
+          end
+          xml.hps :TokenRequest, (options[:store] ? 'Y' : 'N')
+        end
+      end
+
+      def add_details(xml, options)
+        xml.hps :AdditionalTxnFields do
+          xml.hps :Description, options[:description] if options[:description]
+          xml.hps :InvoiceNbr, options[:order_id] if options[:order_id]
+          xml.hps :CustomerID, options[:customer_id] if options[:customer_id]
+        end
+      end
+
+      def add_allow_dup(xml)
+        xml.hps :AllowDup, 'Y'
+      end
+
+      def add_descriptor_name(xml, options)
+        xml.hps :TxnDescriptor, options[:descriptor_name] if options[:descriptor_name]
+      end
+
+      def build_request(action)
+        xml = Builder::XmlMarkup.new(encoding: 'UTF-8')
+        xml.instruct!(:xml, encoding: 'UTF-8')
+        xml.SOAP :Envelope, {
+            'xmlns:SOAP' => 'http://schemas.xmlsoap.org/soap/envelope/',
+            'xmlns:hps' => 'http://Hps.Exchange.PosGateway' } do
+          xml.SOAP :Body do
+            xml.hps :PosRequest do
+              xml.hps 'Ver1.0'.to_sym do
+                xml.hps :Header do
+                  xml.hps :SecretAPIKey, @options[:secret_api_key]
+                  xml.hps :DeveloperID, @options[:developer_id] if @options[:developer_id]
+                  xml.hps :VersionNbr, @options[:version_number] if @options[:version_number]
+                  xml.hps :SiteTrace, @options[:site_trace] if @options[:site_trace]
+                end
+                xml.hps :Transaction do
+                  xml.hps action.to_sym do
+                    if %w(CreditVoid CreditAddToBatch).include?(action)
+                      yield(xml)
+                    else
+                      xml.hps :Block1 do
+                        yield(xml)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def parse(raw)
+        response = {}
+
+        doc = Nokogiri::XML(raw)
+        doc.remove_namespaces!
+        if(header = doc.xpath("//Header").first)
+          header.elements.each do |node|
+            if (node.elements.size == 0)
+              response[node.name] = node.text
+            else
+              node.elements.each do |childnode|
+                response[childnode.name] = childnode.text
+              end
+            end
+          end
+        end
+        if(transaction = doc.xpath("//Transaction/*[1]").first)
+          transaction.elements.each do |node|
+            response[node.name] = node.text
+          end
+        end
+        if(fault = doc.xpath("//Fault/Reason/Text").first)
+          response["Fault"] = fault.text
+        end
+
+        response
+      end
+
+      def commit(action, &request)
+        data = build_request(action, &request)
+
+        response = begin
+          parse(ssl_post((test? ? test_url : live_url), data, 'Content-Type' => 'text/xml'))
+        rescue ResponseError => e
+          parse(e.response.body)
+        end
+
+        ActiveMerchant::Billing::Response.new(
+          successful?(response),
+          message_from(response),
+          response,
+          test: test?,
+          authorization: authorization_from(response),
+          avs_result: {
+            code: response['AVSRsltCode'],
+            message: response['AVSRsltText']
+          },
+          cvv_result: response['CVVRsltCode']
+        )
+      end
+
+      def successful?(response)
+        (
+          (response["GatewayRspCode"] == "0") &&
+          ((response["RspCode"] || "00") == "00" || response["RspCode"] == "85")
+        )
+      end
+
+      def message_from(response)
+        if(response["Fault"])
+          response["Fault"]
+        elsif(response["GatewayRspCode"] == "0")
+          if(response["RspCode"] != "00" && response["RspCode"] != "85")
+            issuer_message(response["RspCode"])
+          else
+            response['GatewayRspMsg']
+          end
+        else
+          (GATEWAY_MESSAGES[response["GatewayRspCode"]] || response["GatewayRspMsg"])
+        end
+      end
+
+      def authorization_from(response)
+        response['GatewayTxnId']
+      end
+
+      def test?
+        (@options[:secret_api_key] && @options[:secret_api_key].include?('_cert_'))
+      end
+
+      ISSUER_MESSAGES = {
+        "13" => "Must be greater than or equal 0.",
+        "14" => "The card number is incorrect.",
+        "54" => "The card has expired.",
+        "55" => "The 4-digit pin is invalid.",
+        "75" => "Maximum number of pin retries exceeded.",
+        "80" => "Card expiration date is invalid.",
+        "86" => "Can't verify card pin number."
+      }
+      def issuer_message(code)
+        return "The card was declined." if %w(02 03 04 05 41 43 44 51 56 61 62 63 65 78).include?(code)
+        return "An error occurred while processing the card." if %w(06 07 12 15 19 12 52 53 57 58 76 77 91 96 EC).include?(code)
+        return "The card's security code is incorrect." if %w(EB N7).include?(code)
+        ISSUER_MESSAGES[code]
+      end
+
+      GATEWAY_MESSAGES = {
+        "-2" => "Authentication error. Please double check your service configuration.",
+        "12" => "Invalid CPC data.",
+        "13" => "Invalid card data.",
+        "14" => "The card number is not a valid credit card number.",
+        "30" => "Gateway timed out."
+      }
+    end
+  end
+end

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/ideal/ideal_base.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/ideal_response'
+require 'active_merchant/billing/gateways/ideal/ideal_response'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -52,10 +52,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def token
-        if @token.nil?
-          @token = create_fingerprint(@options[:pem])
-        end
-        @token
+        @token ||= create_fingerprint(@options[:pem])
       end
 
       # <?xml version="1.0" encoding="UTF-8"?>

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

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/ideal/ideal_base'
+require 'active_merchant/billing/gateways/ideal/ideal_base'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:

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)
@@ -62,6 +62,12 @@ 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.
@@ -157,7 +163,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
 
@@ -178,14 +184,6 @@ module ActiveMerchant #:nodoc:
 
       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"